Ticket #1366: format-atom.patch

a/lib/OpenLayers.js

@@ -217 +217 @@
-            "OpenLayers/Format/GML/Base.js",
-            "OpenLayers/Format/GML/v2.js",
-            "OpenLayers/Format/GML/v3.js",
+            "OpenLayers/Format/Atom.js",
-            "OpenLayers/Format/KML.js",
-            "OpenLayers/Format/GeoRSS.js",
-            "OpenLayers/Format/WFS.js",

/dev/null

@@ +1 @@
+// Copyright to be assigned to OpenLayers project
+
+/**
+ * @requires OpenLayers/Format/XML.js
+ * @requires OpenLayers/Format/GML/v3.js
+ * @requires OpenLayers/Feature/Vector.js
+ */
+
+/**
+ * Class: OpenLayers.Format.Atom
+ * Read/write Atom feeds. Create a new instance with the
+ *     <OpenLayers.Format.AtomFeed> constructor.
+ *
+ * Inherits from:
+ *  - <OpenLayers.Format.XML>
+ */
+OpenLayers.Format.Atom = OpenLayers.Class(OpenLayers.Format.XML, {
+    
+    /**
+     * APIProperty: atomns
+     * {String} Atom namespace to use.
+     */
+    atomns: "http://www.w3.org/2005/Atom",
+    
+    /**
+     * APIProperty: georssns
+     * {String} GeoRSS namespace to use.  Defaults to
+     *     "http://www.georss.org/georss"
+     */
+    georssns: "http://www.georss.org/georss",
+        
+    /**
+     * Property: gmlParse
+     * {Object} GML Format object for parsing features
+     * Non-API and only created if necessary
+     */
+    gmlParser: null,
+    
+    /**
+     * APIProperty: xy
+     * {Boolean} Order of the GML coordinate: true:(x,y) or false:(y,x)
+     * For GeoRSS the default is (y,x), therefore: false
+     */
+    xy: false,
+    
+    /**
+     * Constructor: OpenLayers.Format.AtomEntry
+     * Create a new parser for Atom.
+     *
+     * Parameters:
+     * options - {Object} An optional object whose properties will be set on
+     *     this instance.
+     */
+    initialize: function(options) {
+        OpenLayers.Format.XML.prototype.initialize.apply(this, [options]);
+    },
+    
+    /**
+     * APIMethod: read
+     * Return a list of features from an Atom feed or entry document.
+     
+     * Parameters:
+     * doc - {Element} or {String}
+     *
+     * Returns:
+     * An Array of <OpenLayers.Feature.Vector>s
+     */
+    read: function(doc) {
+        if (typeof doc == "string") {
+            doc = OpenLayers.Format.XML.prototype.read.apply(this, [doc]);
+        }
+        return this.parseFeatures(doc);
+    },
+    
+    /**
+     * APIMethod: write
+     * Serialize or more feature nodes to Atom documents.
+     *
+     * Parameters:
+     * features - a single {<OpenLayers.Feature.Vector>} or an
+     * Array({<OpenLayers.Feature.Vector>}).
+     *
+     * Returns:
+     * {String} an Atom entry document if passed one feature node, or a feed
+     * document if passed an array of feature nodes.
+     */
+    write: function(features) {
+        var doc;
+        if (features instanceof Array) {
+            doc = this.createElementNS(this.atomns, "feed");
+            for (var i=0; i<features.length; i++) {
+                doc.appendChild(this.buildEntryNode(features[i]));
+            }
+        }
+        else {
+            doc = this.buildEntryNode(features);
+        }
+        return OpenLayers.Format.XML.prototype.write.apply(this, [doc]);
+    },
+    
+    /**
+     * Method: buildContentNode
+     *
+     * Parameters:
+     * content - {Object}
+     *
+     * Returns:
+     * {DOMElement} an Atom content node.
+     *
+     * TODO: types other than text.
+     */
+    
+    buildContentNode: function(content) {
+        var node = this.createElementNS(this.atomns, "content");
+        if (content.type) {
+            node.setAttribute("type", content.type);
+        }
+        node.appendChild(
+            this.createTextNode(content.value)
+            );
+        return node;
+    },
+    
+    /**
+     * Method: buildEntryNode
+     * Build an Atom entry node from a feature object.
+     *
+     * Parameters:
+     * feature - {<OpenLayers.Feature.Vector>}
+     *
+     * Returns:
+     * {DOMElement} an Atom entry node.
+     *
+     * These entries are geared for publication using AtomPub.
+     *
+     * TODO: support extension elements
+     */
+    buildEntryNode: function(feature) {
+        var attrib = feature.attributes;
+        var atomAttrib = attrib.atom ? attrib.atom : {};
+        var entryNode = this.createElementNS(this.atomns, "entry");
+        
+        // atom:author
+        if (atomAttrib.authors) {
+            var authors = atomAttrib.authors instanceof Array ?
+                atomAttrib.authors : new Array(atomAttrib.authors);
+            var authorNode;
+            for (var i=0; i<authors.length; i++) {
+                entryNode.appendChild(
+                    this.buildPersonConstructNode(
+                        "author",
+                        authors[i]
+                        )
+                    );
+            }
+        }
+        
+        // atom:category
+        if (atomAttrib.categories) {
+            var categories = atomAttrib.categories instanceof Array ?
+                atomAttrib.categories : new Array(atomAttrib.categories);
+            var category;
+            var categoryNode;
+            for (var i=0; i<categories.length; i++) {
+                categoryNode = this.createElementNS(this.atomns, "category");
+                category = categories[i];
+                categoryNode.setAttribute("term", category.term);
+                if (category.scheme) {
+                    categoryNode.setAttribute("scheme", category.scheme);
+                }
+                if (category.label) {
+                    categoryNode.setAttribute("label", category.label);
+                }
+                entryNode.appendChild(categoryNode);
+            }
+        }
+        
+        // atom:content
+        if (atomAttrib.content) {
+            entryNode.appendChild(this.buildContentNode(atomAttrib.content));
+        }
+        
+        // atom:contributor
+        if (atomAttrib.contributors) {
+            var contributors = atomAttrib.contributors instanceof Array ?
+                atomAttrib.contributors : new Array(atomAttrib.contributors);
+            var contributorNode;
+            for (var i=0; i<contributors.length; i++) {
+                entryNode.appendChild(
+                    this.buildPersonConstructNode(
+                        "contributor",
+                        contributors[i]
+                        )
+                    );
+            }
+        }
+        
+        // atom:id
+        if (feature.fid) {
+            entryNode.appendChild(
+                this.buildTextConstructNode("id", feature.fid)
+                );
+        }
+        
+        // atom:link
+        if (atomAttrib.links) {
+            var links = atomAttrib.links instanceof Array ?
+                atomAttrib.links : new Array(atomAttrib.links);
+            var link;
+            var linkNode;
+            var oAtts = ["rel", "type", "hreflang", "title", "length"];
+            for (var i=0; i<links.length; i++) {
+                link = links[i];
+                linkNode = this.createElementNS(this.atomns, "link");
+                linkNode.setAttribute("href", link.href);
+                for (var j=0; j<oAtts.length; j++) {
+                    if (link[oAtts[j]]) {
+                        linkNode.setAttribute(oAtts[j], link[oAtts[j]]);
+                    }
+                }
+                entryNode.appendChild(linkNode);
+            }
+        }
+        
+        // atom:published
+        if (atomAttrib.published) {
+            entryNode.appendChild(
+                this.buildTextConstructNode("published", atomAttrib.published)
+                );
+        }
+        
+        // atom:rights
+        if (atomAttrib.rights) {
+            entryNode.appendChild(
+                this.buildTextConstructNode("rights", atomAttrib.rights)
+                );
+        }
+        
+        // atom:source not implemented
+        
+        // atom:summary
+        if (atomAttrib.summary || attrib.description) {
+            entryNode.appendChild(
+                this.buildTextConstructNode(
+                    "summary",
+                    atomAttrib.summary || attrib.description
+                    )
+                );
+        }
+        
+        // atom:title
+        entryNode.appendChild(
+            this.buildTextConstructNode(
+                "title", 
+                atomAttrib.title || attrib.title
+                )
+            );
+        
+        // atom:updated
+        if (atomAttrib.updated) {
+            entryNode.appendChild(
+                this.buildTextConstructNode("updated", atomAttrib.updated)
+                );
+        }
+        
+        // georss:where
+        if (feature.geometry) {
+            var whereNode = this.createElementNS(
+                this.georssns, "georss:where"
+                );
+            var geometryNode = this.buildGeometryNode(feature.geometry);
+            whereNode.appendChild(geometryNode);
+            entryNode.appendChild(whereNode);
+        }
+        
+        return entryNode;
+    },
+    
+    /**
+     * Method: buildGeometryNode
+     * builds a GeoRSS node with a given geometry
+     *
+     * Parameters:
+     * geometry - {<OpenLayers.Geometry>}
+     *
+     * Returns:
+     * {DOMElement} A gml node.
+     */
+    buildGeometryNode: function(geometry) {
+        var gmlParser = new OpenLayers.Format.GML.v3({'xy': this.xy});
+        var geomType = gmlParser.geometryTypes[geometry.CLASS_NAME];
+        return gmlParser.writers["gml"][geomType].apply(
+                                                    gmlParser, [geometry]
+                                                    );
+    },
+    
+    /**
+     * Method: buildPersonConstructNode
+     *
+     * Parameters:
+     * name - {String}
+     * value - {Object}
+     *
+     * Returns:
+     * {DOMElement} an Atom person construct node.
+     *
+     * Example:
+     * >>> buildPersonConstructNode("author", {name: "John Smith"})
+     * {<author><name>John Smith</name></author>}
+     *
+     * TODO: how to specify extension elements? Add to the oNames array?
+     */
+    
+    buildPersonConstructNode: function(name, value) {
+        var oNode;
+        var oNames = ["uri", "email"];
+        var personNode = this.createElementNS(this.atomns, name);
+        var nameNode = this.createElementNS(this.atomns, "name");
+        nameNode.appendChild(
+            this.createTextNode(value.name)
+            );
+        personNode.appendChild(nameNode);
+        for (var i=0; i<oNames.length; i++) {
+            if (value[oNames[i]]) {
+                oNode = this.createElementNS(this.atomns, oNames[i]);
+                oNode.appendChild(
+                    this.createTextNode(value[oNames[i]])
+                    );
+                personNode.appendChild(oNode);
+            }
+        }
+        return personNode;
+    },
+    
+    /**
+     * Method: buildTextConstructNode
+     *
+     * Parameters:
+     * name - {String}
+     * value - {String}
+     *
+     * Returns:
+     * {DOMElement} an Atom text construct node with tag=name containing the
+     * value as text.
+     *
+     * Example:
+     * >>> buildTextConstructNode("published", "2003-12-13T08:29:29-04:00")
+     * {<published>2003-12-13T08:29:29-04:00</published>}
+     */
+    
+    buildTextConstructNode: function(name, value) {
+        var node = this.createElementNS(this.atomns, name);
+        node.appendChild(
+            this.createTextNode(value)
+            );
+        return node;
+    },
+    
+    /**
+     * Method: getChildValue
+     *
+     * Parameters:
+     * node - {DOMElement}
+     * nsuri - {String} Child node namespace uri ("*" for any).
+     * name - {String} Child node name.
+     * def - {String} Optional string default to return if no child found.
+     *
+     * Returns:
+     * {String} The value of the first child with the given tag name.  Returns
+     *     default value or empty string if none found.
+     */
+    getChildValue: function(node, nsuri, name, def) {
+        var value;
+        try {
+            value = this.getElementsByTagNameNS(node, nsuri, name)[0].firstChild.nodeValue;
+        } catch(e) {
+            value = (def == undefined) ? "" : def;
+        }
+        return value;
+    },
+    
+    /**
+     * Method: parseFeature
+     * Parse feature from an Atom entry node..
+     *
+     * Parameters:
+     * node - {DOMElement} An Atom entry or feed node.
+     *
+     * Returns:
+     * An <OpenLayers.Feature.Vector>.
+     */
+    
+    parseFeature: function(node) {
+        var atomAttrib = {};
+        var value = null;
+        var nodes = null;
+        var attval = null;
+        
+        // atomAuthor*
+        this.parsePersonConstructs(node, "author", atomAttrib);
+        
+        // atomCategory*
+        nodes = this.getElementsByTagNameNS(node, this.atomns, 'category');
+        if (nodes.length > 0) {
+            atomAttrib.categories = new Array();
+        }
+        for (var i=0; i<nodes.length; i++) {
+            value = {};
+            value.term = nodes[i].getAttribute("term");
+            attval = nodes[i].getAttribute("scheme");
+            if (attval) { value.scheme = attval; }
+            attval = nodes[i].getAttribute("label");
+            if (attval) { value.label = attval; }
+            atomAttrib.categories.push(value);
+        }
+        
+        // atomContent?
+        nodes = this.getElementsByTagNameNS(node, this.atomns, 'content');
+        if (nodes.length > 0) {
+            value = {};
+            attval = nodes[0].getAttribute("type")
+            if (attval) { value.type = attval; }
+            value.value = this.getChildValue(
+                            node,
+                            this.atomns,
+                            "content",
+                            null
+                            );
+            atomAttrib.content = value;
+        }
+        
+        // atomContributor*
+        this.parsePersonConstructs(node, "contributor", atomAttrib);
+        
+        // atomId
+        atomAttrib.id = this.getChildValue(node, this.atomns, "id", null);
+        
+        // atomLink*
+        nodes = this.getElementsByTagNameNS(node, this.atomns, 'link');
+        if (nodes.length > 0) {
+            atomAttrib.links = new Array(nodes.length);
+        }
+        var oAtts = ["rel", "type", "hreflang", "title", "length"];
+        for (var i=0; i<nodes.length; i++) {
+            value = {};
+            value.href = nodes[i].getAttribute("href");
+            for (var j=0; j<oAtts.length; j++) {
+                attval = nodes[i].getAttribute(oAtts[j]);
+                if (attval) { value[oAtts[j]] = attval; }
+            }
+            atomAttrib.links[i] = value;
+        }
+        
+        // atomPublished?
+        value = this.getChildValue(node, this.atomns, "published", null);
+        if (value) { atomAttrib.published = value; }
+        
+        // atomRights?
+        value = this.getChildValue(node, this.atomns, "rights", null);
+        if (value) { atomAttrib.rights = value; }
+        
+        // atomSource? -- not implemented
+        
+        // atomSummary?
+        value = this.getChildValue(node, this.atomns, "summary", null);
+        if (value) { atomAttrib.summary = value; }
+        
+        // atomTitle
+        atomAttrib.title = this.getChildValue(
+                                node, this.atomns, "title", null
+                                );
+        
+        // atomUpdated
+        atomAttrib.updated = this.getChildValue(
+                                node, this.atomns, "updated", null
+                                );
+        
+        var featureAttrib = {
+            title: atomAttrib.title,
+            description: atomAttrib.summary
+            }
+        featureAttrib.atom = atomAttrib;
+        var geometry = this.parseLocations(node)[0];
+        var feature = new OpenLayers.Feature.Vector(geometry, featureAttrib);
+        feature.fid = atomAttrib.id;
+        return feature;
+    },
+    
+    /**
+     * Method: parseFeatures
+     * Return features from an Atom entry or feed.
+     *
+     * Parameters:
+     * node - {DOMElement} An Atom entry or feed node.
+     *
+     * Returns:
+     * An Array of <OpenLayers.Feature.Vector>s.
+     */
+    
+    parseFeatures: function(node) {
+        var features = [];
+        var entries = null;
+        entries = this.getElementsByTagNameNS(node, this.atomns, 'entry');
+        if (entries.length == 0) {
+            entries = new Array(node);
+        }
+        for (var i=0; i<entries.length; i++) {
+            features.push(this.parseFeature(entries[i]));
+        }
+        return features;
+    },
+    
+    /**
+     * Method: parseLocations
+     * Parse the locations from an Atom entry or feed.
+     *
+     * Parameters:
+     * node - {DOMElement} An Atom entry or feed node.
+     *
+     * Returns:
+     * An Array of <OpenLayers.Geometry>s.
+     */
+    parseLocations: function(node) {
+        var locations = {components: []};
+        var where = this.getElementsByTagNameNS(
+                        node,
+                        this.georssns,
+                        "where"
+                        );
+        var point = this.getElementsByTagNameNS(
+                        node,
+                        this.georssns,
+                        "point"
+                        );
+        var line = this.getElementsByTagNameNS(
+                        node,
+                        this.georssns,
+                        "line"
+                        );
+        var polygon = this.getElementsByTagNameNS(
+                        node,
+                        this.georssns,
+                        "polygon"
+                        );
+        
+        if (where.length > 0) {
+            var gmlParser = new OpenLayers.Format.GML.v3({'xy': this.xy});
+            for (var i=0; i<where.length; i++) {
+                gmlParser.readChildNodes(where[i], locations);
+            }
+        }
+        
+        if (point.length > 0) {
+            for (var i=0; i<point.length; i++) {
+                var xy = OpenLayers.String.trim(
+                            point[i].firstChild.nodeValue
+                            ).split(/\s+/);
+                if (xy.length !=2) {
+                    xy = OpenLayers.String.trim(
+                                point[i].firstChild.nodeValue
+                                ).split(/\s*,\s*/);
+                }
+                locations.components.push(
+                    new OpenLayers.Geometry.Point(
+                            parseFloat(xy[1]),
+                            parseFloat(xy[0])
+                            )
+                    );
+            }
+        }
+        
+        if (line.length > 0) {
+            var coords;
+            var p;
+            var points;
+            for (var i=0; i<line.length; i++) {
+                coords = OpenLayers.String.trim(
+                                line[i].firstChild.nodeValue
+                                ).split(/\s+/);
+                points = new Array();
+                for (var j=0; j<coords.length; j+=2) {
+                    p = new OpenLayers.Geometry.Point(
+                            parseFloat(coords[j+1]),
+                            parseFloat(coords[j])
+                            );
+                    points.push(p);
+                }
+                locations.components.push(
+                    new OpenLayers.Geometry.LineString(points)
+                    );
+            }
+        }
+        
+        if (polygon.length > 0) {
+            var coords;
+            var p;
+            var points;
+            for (var i=0; i<polygon.length; i++) {
+                coords = OpenLayers.String.trim(
+                            polygon[i].firstChild.nodeValue
+                            ).split(/\s+/);
+                points = new Array();
+                for (var j=0; j<coords.length; j+=2) {
+                    p = new OpenLayers.Geometry.Point(
+                                parseFloat(coords[i+1]),
+                                parseFloat(coords[i])
+                                );
+                    points.push(p);
+                }
+                locations.components.push(
+                    new OpenLayers.Geometry.Polygon(
+                            [new OpenLayers.Geometry.LinearRing(components)]
+                            )
+                    );
+            }
+        }
+        
+        if (this.internalProjection && this.externalProjection) {
+            for (var i=0; i<locations.components.length; i++) {
+                if (locations.components[i]) {
+                    locations.components[i].transform(
+                            this.externalProjection,
+                            this.internalProjection
+                            );
+                }
+            }
+        }
+        
+        return locations.components;
+    },
+    
+    /**
+     * Method: parsePersonConstruct
+     * Parse Atom person constructs from an Atom entry node.
+     *
+     * Parameters:
+     * node - {DOMElement} An Atom entry or feed node.
+     * name - {String} Construcy name ("author" or "contributor")
+     * data = {Object} Object in which to put parsed persons.
+     *
+     * Returns:
+     * An {Object}.
+     */
+    
+    parsePersonConstructs: function(node, name, data) {
+        var persons = new Array();
+        nodes = this.getElementsByTagNameNS(node, this.atomns, name);
+        var oAtts = ["uri", "email"];
+        for (var i=0; i<nodes.length; i++) {
+            value = {};
+            value.name = this.getChildValue(
+                            nodes[i],
+                            this.atomns,
+                            "name",
+                            null
+                            );
+            for (var j=0; j<oAtts.length; j++) {
+                attval = this.getChildValue(
+                            nodes[i],
+                            this.atomns,
+                            oAtts[j],
+                            null);
+                if (attval) { value[oAtts[j]] = attval; }
+            }
+            persons.push(value);
+        }
+        if (persons.length > 0) {
+            data[name + "s"] = persons;
+        }
+    },
+
+    CLASS_NAME: "OpenLayers.Format.Atom"
+});

/dev/null

@@ +1 @@
+<html> 
+<head> 
+    <script src="../../lib/OpenLayers.js"></script> 
+    <script type="text/javascript">
+
+    function test_Format_Atom_constructor(t) { 
+        t.plan(4); 
+        var options = {'foo': 'bar'}; 
+        var format = new OpenLayers.Format.Atom(options); 
+        t.ok(format instanceof OpenLayers.Format.Atom, 
+             "new OpenLayers.Format.GeoRSS returns object" ); 
+        t.eq(format.foo, "bar", "constructor sets options correctly"); 
+        t.eq(typeof format.read, "function", "format has a read function"); 
+        t.eq(typeof format.write, "function", "format has a write function"); 
+    }
+
+    /* Reading tests */
+
+    function test_Format_Atom_reproject_null(t) { 
+        t.plan(1);
+        var parser = new OpenLayers.Format.Atom({'internalProjection':new OpenLayers.Projection("EPSG:4326"), 'externalProjection': new OpenLayers.Projection("EPSG:4326")});
+        var data = parser.read(
+          // begin document
+          '<feed xmlns="http://www.w3.org/2005/Atom">'  +
+          '<entry></entry>'                             +
+          '</feed>'
+          // end document
+          );
+        t.eq(
+          data.length, 1, 
+          "Parsing items with null geometry and reprojection doesn't fail"
+          );
+    }
+
+    // read entry 1: basic entry, no categories or persons
+    function test_Format_Atom_readentry1(t) { 
+        t.plan(10);
+        var parser = new OpenLayers.Format.Atom();
+        var data = parser.read(
+          // begin document
+          '<entry xmlns="http://www.w3.org/2005/Atom">'                 +
+          '  <id>urn:uuid:82ede847-b31a-4e3d-b773-7471bad154ed</id>'    +
+          '  <link href="http://example.com/blog/1" rel="alternate"/>'  +
+          '  <summary>An Atom testing entry</summary>'                  +
+          '  <title>Atom test</title>'                                  +
+          '  <updated>2009-06-02T10:00:00Z</updated>'                   +
+          '</entry>'
+          // end document
+          );
+        t.ok(data instanceof Array, "Read features");
+        var fx = data[0];
+        t.ok(fx instanceof OpenLayers.Feature.Vector, "Read feature");
+        t.eq(fx.geometry, null, "Geometry is null");
+        t.eq(
+            fx.fid, 
+            "urn:uuid:82ede847-b31a-4e3d-b773-7471bad154ed", 
+            "Read fid"
+            );
+        var attrib = fx.attributes;
+        t.eq(attrib.title, "Atom test", "Correct title attribute");
+        t.eq(
+            attrib.description, 
+            "An Atom testing entry", 
+            "Correct description attribute"
+            );
+        var atomAttrib = attrib.atom;
+        t.eq(
+            atomAttrib.links, 
+            [{href: "http://example.com/blog/1", rel: "alternate"}], 
+            "Correct links in atom namespace"
+            );
+        t.eq(
+            atomAttrib.summary, 
+            "An Atom testing entry", 
+            "Correct summary in atom namespace"
+            );
+        t.eq(
+            atomAttrib.title, 
+            "Atom test", 
+            "Correct title in atom namespace"
+            );
+        t.eq(
+            atomAttrib.updated, 
+            "2009-06-02T10:00:00Z", 
+            "Correct timestamp in atom namespace"
+            );
+    }
+
+    // read entry 2: with georss:where
+    function test_Format_Atom_readentry2(t) { 
+        t.plan(5);
+        var parser = new OpenLayers.Format.Atom();
+        var data = parser.read(
+          // begin document
+          '<entry xmlns="http://www.w3.org/2005/Atom">'                   +
+          '  <id>urn:uuid:82ede847-b31a-4e3d-b773-7471bad154ed</id>'      +
+          '  <georss:where xmlns:georss="http://www.georss.org/georss">'  +
+          '    <gml:Point xmlns:gml="http://www.opengis.net/gml">'        +
+          '      <gml:pos>45.68 -111.04</gml:pos>'                        +
+          '    </gml:Point>'                                              +
+          '  </georss:where>'                                             +
+          '</entry>'
+          // end document
+          );
+        t.ok(data instanceof Array, "Read features");
+        var fx = data[0];
+        t.ok(fx instanceof OpenLayers.Feature.Vector, "Read feature");
+        t.ok(fx.geometry instanceof OpenLayers.Geometry.Point, "Read geometry");
+        t.eq(fx.geometry.x, -111.04, "Read x");
+        t.eq(fx.geometry.y, 45.68, "Read y");
+    }
+
+    // read entry 3: with georss:point
+    function test_Format_Atom_readentry3(t) { 
+        t.plan(5);
+        var parser = new OpenLayers.Format.Atom();
+        var data = parser.read(
+          // begin document
+          '<entry xmlns="http://www.w3.org/2005/Atom">'                   +
+          '  <id>urn:uuid:82ede847-b31a-4e3d-b773-7471bad154ed</id>'      +
+          '  <georss:point xmlns:georss="http://www.georss.org/georss">45.68 -111.04</georss:point>'                                                   +
+          '</entry>'
+          // end document
+          );
+        t.ok(data instanceof Array, "Read features");
+        var fx = data[0];
+        t.ok(fx instanceof OpenLayers.Feature.Vector, "Read feature");
+        t.ok(fx.geometry instanceof OpenLayers.Geometry.Point, "Read geometry");
+        t.eq(fx.geometry.x, -111.04, "Read x");
+        t.eq(fx.geometry.y, 45.68, "Read y");
+    }
+
+    // read feed 1
+    function test_Format_Atom_readfeed1(t) { 
+        t.plan(2);
+        var parser = new OpenLayers.Format.Atom();
+        var data = parser.read(
+          // begin document
+          '<feed xmlns="http://www.w3.org/2005/Atom">'                  +
+          '  <entry>'                                                   +
+          '    <id>urn:uuid:82ede847-b31a-4e3d-b773-7471bad154ed</id>'  +
+          '  </entry>'                                                  +
+          '</feed>'
+          // end document
+          );
+        t.ok(data instanceof Array, "Read features");
+        var fx = data[0];
+        t.ok(fx instanceof OpenLayers.Feature.Vector, "Read feature");
+    }
+    
+    /* Writing tests */
+  
+    // write entry 1: null geometry, no attributes
+    function test_Format_Atom_writeentry1(t) { 
+        t.plan(1);
+        var writer = new OpenLayers.Format.Atom();
+        var feature = new OpenLayers.Feature.Vector(null, {});
+        feature.fid = '1';
+        var data = writer.write(feature);
+        t.xml_eq(
+          data,
+          // begin document
+          '<entry xmlns="http://www.w3.org/2005/Atom">' +
+          '<id>1</id>'                                  +
+          '<title>undefined</title>'                    +
+          '</entry>',
+          // end document 
+          'Writes an entry doc with id, no attributes'
+          );
+    }
+
+    // write entry 2: null geometry, well-known attributes
+    function test_Format_Atom_writeentry2(t) { 
+        t.plan(1);
+        var writer = new OpenLayers.Format.Atom();
+        var feature = new OpenLayers.Feature.Vector(null, {title: "Test", description: "A testing feature"});
+        feature.fid = '1';
+        var data = writer.write(feature);
+        t.xml_eq(
+          data,
+          // begin document
+          '<entry xmlns="http://www.w3.org/2005/Atom">' +
+          '<id>1</id>'                                  +
+          '<summary>A testing feature</summary>'        +
+          '<title>Test</title>'                         +
+          '</entry>',
+          // end document
+          'Writes an entry doc with id, well-known attributes'
+          );
+    }
+
+    // write entry 3: null geometry, Atom constructs to override 
+    // well-known attributes
+    function test_Format_Atom_writeentry3(t) { 
+        t.plan(1);
+        var writer = new OpenLayers.Format.Atom();
+        var feature = new OpenLayers.Feature.Vector(null, {title: "Test", description: "A testing feature", atom: {title: "Atom test", summary: "An Atom testing feature", updated: "2009-06-02T10:00:00Z"}});
+        feature.fid = '1';
+        var data = writer.write(feature);
+        t.xml_eq(
+          data,
+          // begin document
+          '<entry xmlns="http://www.w3.org/2005/Atom">' +
+          '<id>1</id>'                                  +
+          '<summary>An Atom testing feature</summary>'  +
+          '<title>Atom test</title>'                    +
+          '<updated>2009-06-02T10:00:00Z</updated>'     +
+          '</entry>',
+          // end document
+          'Writes an entry doc with Atom constructs overriding well-known atts'
+          );
+    }
+
+    // write entry 4: Atom categories
+    function test_Format_Atom_writeentry4(t) { 
+        t.plan(1);
+        var writer = new OpenLayers.Format.Atom();
+        var feature = new OpenLayers.Feature.Vector(null, {title: "Test", description: "A testing feature", atom: {title: "Atom test", summary: "An Atom testing feature", updated: "2009-06-02T10:00:00Z", categories: [{term: "blog", scheme: "http://example.com/terms", label: "A blog post"}]}});
+        feature.fid = '1';
+        var data = writer.write(feature);
+        t.xml_eq(
+          data,
+          // begin document
+          '<entry xmlns="http://www.w3.org/2005/Atom">' +
+          '<category term="blog" scheme="http://example.com/terms" label="A blog post"/>'                                           +
+          '<id>1</id>'                                  +
+          '<summary>An Atom testing feature</summary>'  +
+          '<title>Atom test</title>'                    +
+          '<updated>2009-06-02T10:00:00Z</updated>'     +
+          '</entry>',
+          // end document
+          'Writes an entry doc with Atom constructs and categories'
+          );
+    }
+
+    // write entry 5: Atom authors, contributors
+    function test_Format_Atom_writeentry5(t) { 
+        t.plan(1);
+        var writer = new OpenLayers.Format.Atom();
+        var feature = new OpenLayers.Feature.Vector(null, {title: "Test", description: "A testing feature", atom: {title: "Atom test", summary: "An Atom testing feature", updated: "2009-06-02T10:00:00Z", authors: [{name: "John Doe", uri: "http://example.com/people/jdoe", email: "jdoe@example.com"}], contributors: [{name: "Pikov Andropov", uri: "http://example.com/people/pandropov", email: "pandropov@example.com"}]}});
+        feature.fid = '1';
+        var data = writer.write(feature);
+        t.xml_eq(
+          data,
+          // begin document
+          '<entry xmlns="http://www.w3.org/2005/Atom">' +
+          '<author>'                                    +
+          '  <name>John Doe</name>'                     +
+          '  <uri>http://example.com/people/jdoe</uri>' +
+          '  <email>jdoe@example.com</email>'           +
+          '</author>'                                   +
+          '<contributor>'                               +
+          '  <name>Pikov Andropov</name>'               +
+          '  <uri>http://example.com/people/pandropov</uri>' +
+          '  <email>pandropov@example.com</email>'      +
+          '</contributor>'                              +
+          '<id>1</id>'                                  +
+          '<summary>An Atom testing feature</summary>'  +
+          '<title>Atom test</title>'                    +
+          '<updated>2009-06-02T10:00:00Z</updated>'     +
+          '</entry>',
+          // end document
+          'Writes an entry doc with Atom constructs and persons'
+          );
+    }
+
+    // write entry 6: Atom links
+    function test_Format_Atom_writeentry6(t) { 
+        t.plan(1);
+        
+        // Feature attributes in Atom namespace
+        var atomAttrib = {
+              title: "Atom test", 
+              summary: "An Atom testing feature", 
+              updated: "2009-06-02T10:00:00Z", 
+              links: [
+                { href: "http://example.com/blog/1", rel: "alternate" }
+                ]
+              };
+        var fx = new OpenLayers.Feature.Vector(null, {atom: atomAttrib});
+        fx.fid = 'urn:uuid:82ede847-b31a-4e3d-b773-7471bad154ed';
+        
+        var writer = new OpenLayers.Format.Atom();
+        var data = writer.write(fx);
+        
+        t.xml_eq(
+          data,
+          // begin document
+          '<entry xmlns="http://www.w3.org/2005/Atom">'               +
+          '<id>urn:uuid:82ede847-b31a-4e3d-b773-7471bad154ed</id>'    +
+          '<link href="http://example.com/blog/1" rel="alternate"/>'  +
+          '<summary>An Atom testing feature</summary>'                +
+          '<title>Atom test</title>'                                  +
+          '<updated>2009-06-02T10:00:00Z</updated>'                   +
+          '</entry>',
+          // end document
+          'Writes an entry doc with Atom constructs and links'
+          );
+    }
+
+    // write out point -- just enough to see that we're getting the
+    // georss:where element with a Point. We'll trust GML.v3 to get the
+    // details right.
+    function test_Format_Atom_writepoint(t) { 
+        t.plan(1);
+
+        var point = new OpenLayers.Geometry.Point(-111.04, 45.68);  
+        var fx = new OpenLayers.Feature.Vector(point, {});
+        fx.fid = 'urn:uuid:82ede847-b31a-4e3d-b773-7471bad154ed';
+        
+        var writer = new OpenLayers.Format.Atom();
+        var data = writer.write(fx);
+        
+        t.xml_eq(
+          data,
+          // begin document
+          '<entry xmlns="http://www.w3.org/2005/Atom">'                 +
+          '<id>urn:uuid:82ede847-b31a-4e3d-b773-7471bad154ed</id>'      +
+          '<title>undefined</title>'                                    +
+          '<georss:where xmlns:georss="http://www.georss.org/georss">'  +
+          '  <gml:Point xmlns:gml="http://www.opengis.net/gml">'        +
+          '    <gml:pos>45.68 -111.04</gml:pos>'                        +
+          '  </gml:Point>'                                              +
+          '</georss:where>'                                             +
+          '</entry>',
+          // end document
+          'Writes an entry doc with a point location'
+          );
+    }
+    
+    </script> 
+</head> 
+<body> 
+</body> 
+</html> 

a/tests/list-tests.html

@@ -45 +45 @@
-    <li>Filter/Logical.html</li>
-    <li>Filter/Spatial.html</li>
-    <li>Format.html</li>
+    <li>Format/Atom.html</li>
-    <li>Format/ArcXML.html</li>
-    <li>Format/ArcXML/Features.html</li>
-    <li>Format/GeoJSON.html</li>