Add support for changelistarchive document format, and introduce support in the base classes for ordered url/sitemap elements

Author: richard-jones

src/main/java/org/openarchives/resourcesync/ChangeListArchive.java

@@ -0,0 +1,49 @@
+package org.openarchives.resourcesync;
+
+import java.util.Date;
+
+public class ChangeListArchive extends SitemapIndex
+{
+    public ChangeListArchive()
+    {
+        this(null, null);
+    }
+
+    public ChangeListArchive(Date lastMod)
+    {
+        this(lastMod, null);
+    }
+
+    public ChangeListArchive(Date lastMod, String capabilityList)
+    {
+        this.capability = ResourceSync.CAPABILITY_CHANGELIST;
+
+        if (lastMod != null)
+        {
+            this.setLastModified(lastMod);
+        }
+        else
+        {
+            this.setLastModified(new Date());
+        }
+
+        if (capabilityList != null)
+        {
+            this.addLn(ResourceSync.REL_RESOURCESYNC, capabilityList);
+        }
+    }
+
+    public void addChangeList(Sitemap sitemap)
+    {
+        this.addSitemap(sitemap);
+    }
+
+    public Sitemap addChangeList(String loc, Date lastMod)
+    {
+        Sitemap sitemap = new Sitemap();
+        sitemap.setLoc(loc);
+        sitemap.setLastModified(lastMod);
+        this.addChangeList(sitemap);
+        return sitemap;
+    }
+}

src/main/java/org/openarchives/resourcesync/ResourceSyncDocument.java

@@ -9,6 +9,7 @@
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
+import java.util.TreeMap;
 
 public abstract class ResourceSyncDocument
 {
@@ -18,7 +19,8 @@ public abstract class ResourceSyncDocument
 
     // these options can be accessed using getters and setters
     protected Date lastModified;
-    protected List<ResourceSyncEntry> entries = new ArrayList<ResourceSyncEntry>();
+    protected List<ResourceSyncEntry> unorderedEntries = new ArrayList<ResourceSyncEntry>();
+    protected TreeMap<Date, List<ResourceSyncEntry>> orderedEntries = new TreeMap<Date, List<ResourceSyncEntry>>();
     protected List<ResourceSyncLn> lns = new ArrayList<ResourceSyncLn>();
 
     public ResourceSyncLn addLn(String rel, String href)
@@ -38,12 +40,21 @@ public void addLn(ResourceSyncLn ln)
 
     public void addEntry(ResourceSyncEntry entry)
     {
-        this.entries.add(entry);
+        Date key = entry.getLastModified() == null ? new Date(0) : entry.getLastModified();
+        if (!this.orderedEntries.containsKey(key))
+        {
+            this.orderedEntries.put(key, new ArrayList<ResourceSyncEntry>());
+        }
+        this.orderedEntries.get(key).add(entry);
+
+        // FIXME: are there any serious concerns about storing the entry in two locations?
+        // it's all by-reference, right?
+        this.unorderedEntries.add(entry);
     }
 
     public List<ResourceSyncEntry> getEntries()
     {
-        return entries;
+        return this.unorderedEntries;
     }
 
     public List<ResourceSyncLn> getLns()
@@ -75,7 +86,10 @@ public Element getElement()
         // set the capability of the document in the rs:md
         Element md = new Element("md", ResourceSync.NS_RS);
         md.setAttribute("capability", this.capability, ResourceSync.NS_RS);
-        md.setAttribute("modified", ResourceSync.DATE_FORMAT.format(this.lastModified), ResourceSync.NS_ATOM);
+        if (this.lastModified != null)
+        {
+            md.setAttribute("modified", ResourceSync.DATE_FORMAT.format(this.lastModified), ResourceSync.NS_ATOM);
+        }
         root.addContent(md);
 
         // serialise the rs:ln elements
@@ -87,10 +101,14 @@ public Element getElement()
             root.addContent(lnEl);
         }
 
-        for (ResourceSyncEntry entry : this.entries)
+        for (Date date : this.orderedEntries.keySet())
         {
-            Element entryElement = entry.getElement();
-            root.addContent(entryElement);
+            List<ResourceSyncEntry> entries = this.orderedEntries.get(date);
+            for (ResourceSyncEntry entry : entries)
+            {
+                Element entryElement = entry.getElement();
+                root.addContent(entryElement);
+            }
         }
 
         return root;

src/main/java/org/openarchives/resourcesync/Sitemap.java

@@ -0,0 +1,9 @@
+package org.openarchives.resourcesync;
+
+public class Sitemap extends ResourceSyncEntry
+{
+    public Sitemap()
+    {
+        this.root = "sitemap";
+    }
+}

src/main/java/org/openarchives/resourcesync/SitemapIndex.java

@@ -0,0 +1,21 @@
+package org.openarchives.resourcesync;
+
+import java.util.List;
+
+public class SitemapIndex extends ResourceSyncDocument
+{
+    public SitemapIndex()
+    {
+        this.root = "sitemapindex";
+    }
+
+    public void addSitemap(Sitemap sitemap)
+    {
+        this.addEntry(sitemap);
+    }
+
+    public List<ResourceSyncEntry> getSitemaps()
+    {
+        return this.getEntries();
+    }
+}

src/test/java/org/openarchives/resourcesync/test/TestBaseClasses.java

@@ -365,6 +365,65 @@ public void resourceSyncDocument()
         System.out.println(serial);
     }
 
+    @Test
+    public void ordering()
+    {
+        ResourceSyncDocument doc = new TestResourceSyncDocument();
+
+        ResourceSyncEntry entry1 = new TestResourceSyncEntry();
+        entry1.setLoc("http://entry1");
+        entry1.setLastModified(new Date(1000));
+
+        ResourceSyncEntry entry2 = new TestResourceSyncEntry();
+        entry2.setLoc("http://entry2");
+        entry2.setLastModified(new Date(10000));
+
+        ResourceSyncEntry entry3 = new TestResourceSyncEntry();
+        entry3.setLoc("http://entry3");
+        entry3.setLastModified(new Date(5000));
+
+        ResourceSyncEntry entry4 = new TestResourceSyncEntry();
+        entry4.setLoc("http://entry4");
+
+        doc.addEntry(entry1);
+        doc.addEntry(entry2);
+        doc.addEntry(entry3);
+        doc.addEntry(entry4);
+
+        Element element = doc.getElement();
+        List<Element> entries = element.getChildren("url", ResourceSync.NS_SITEMAP);
+        assert entries.size() == 4;
+        int i = 0;
+        for (Element entry : entries)
+        {
+            // these should all be in order, so this test will check that what we get
+            // comes in the following order (oldest first):
+            // 0s - http://entry4
+            // 1000s - http://entry1
+            // 5000s - http//entry3
+            // 10000s - http://entry4
+            if (i == 0)
+            {
+                assert entry.getChild("loc", ResourceSync.NS_SITEMAP).getText().equals("http://entry4");
+            }
+            if (i == 1)
+            {
+                assert entry.getChild("loc", ResourceSync.NS_SITEMAP).getText().equals("http://entry1");
+            }
+            if (i == 2)
+            {
+                assert entry.getChild("loc", ResourceSync.NS_SITEMAP).getText().equals("http://entry3");
+            }
+            if (i == 3)
+            {
+                assert entry.getChild("loc", ResourceSync.NS_SITEMAP).getText().equals("http://entry2");
+            }
+
+            // increment our counter
+            i++;
+        }
+    }
+
     class TestResourceSyncEntry extends ResourceSyncEntry
     {
         public TestResourceSyncEntry()

src/test/java/org/openarchives/resourcesync/test/TestChangeListArchive.java

@@ -0,0 +1,91 @@
+package org.openarchives.resourcesync.test;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+import org.openarchives.resourcesync.ChangeListArchive;
+import org.openarchives.resourcesync.ResourceSync;
+import org.openarchives.resourcesync.ResourceSyncEntry;
+import org.openarchives.resourcesync.ResourceSyncLn;
+import org.openarchives.resourcesync.Sitemap;
+
+import java.util.Date;
+import java.util.List;
+
+@RunWith(JUnit4.class)
+public class TestChangeListArchive
+{
+    @Test
+    public void blankConstructor()
+    {
+        Date now = new Date();
+        ChangeListArchive cla = new ChangeListArchive();
+
+        assert cla.getCapability().equals(ResourceSync.CAPABILITY_CHANGELIST);
+        assert cla.getLastModified().getTime() >= now.getTime();
+
+        List<ResourceSyncLn> lns = cla.getLns();
+        assert lns.size() == 0;
+    }
+
+    @Test
+    public void construction()
+    {
+        Date now = new Date();
+        ChangeListArchive cla = new ChangeListArchive(now, "http://capabilitylist");
+
+        assert cla.getCapability().equals(ResourceSync.CAPABILITY_CHANGELIST);
+        assert cla.getLastModified().equals(now);
+
+        List<ResourceSyncLn> lns = cla.getLns();
+        assert lns.size() == 1;
+    }
+
+    @Test
+    public void methods()
+    {
+        ChangeListArchive cla = new ChangeListArchive();
+
+        Sitemap sm = new Sitemap();
+        sm.setLoc("http://changelist1");
+        sm.setLastModified(new Date(1000));
+        cla.addChangeList(sm);
+
+        Sitemap sm2 = cla.addChangeList("http://changelist2", new Date(10000));
+        sm2.setType("application/xml");
+
+        List<ResourceSyncEntry> entries = cla.getEntries();
+        boolean change1 = false;
+        boolean change2 = false;
+        for (ResourceSyncEntry entry : entries)
+        {
+            if (entry.getLoc().equals("http://changelist1"))
+            {
+                assert entry.getLastModified().equals(new Date(1000));
+                change1 = true;
+            }
+            if (entry.getLoc().equals("http://changelist2"))
+            {
+                assert entry.getLastModified().equals(new Date(10000));
+                assert entry.getType().equals("application/xml");
+                change2 = true;
+            }
+        }
+        assert change1;
+        assert change2;
+    }
+    @Test
+    public void manualCheck()
+    {
+        Date now = new Date();
+        ChangeListArchive cla = new ChangeListArchive(now, "http://capabilitylist");
+
+        cla.addChangeList("http://changelist1", new Date(10000));
+        cla.addChangeList("http://changelist2", new Date(1000));
+        cla.addChangeList("http://changelist3", new Date(50000));
+        cla.addChangeList("http://changelist4", new Date(5000));
+
+        System.out.println(cla.serialise());
+    }
+
+}