exempla-atomic 0.0.8 → 0.0.11

data/VERSION.yml

@@ -1,4 +1,4 @@
 --- 
-:patch: 8
+:patch: 11
 :major: 0
 :minor: 0

data/lib/atomic.rb

@@ -1,8 +1,9 @@
+require File.dirname(__FILE__) + '/atomic/parser'
+require File.dirname(__FILE__) + '/atomic/person'
 require File.dirname(__FILE__) + '/atomic/service'
 require File.dirname(__FILE__) + '/atomic/feed'
 require File.dirname(__FILE__) + '/atomic/entry'
 require File.dirname(__FILE__) + '/atomic/extensions'
 
-Atomic::NAMESPACES = { "xmlns:atom" => "http://www.w3.org/2005/Atom",
-                       "xmlns:app" => "http://www.w3.org/2007/app",
-                       "xmlns:cirrus" => "http://www.glam.ac.uk/2009/cirrus" }
+Atomic::NS_ATOM = "http://www.w3.org/2005/Atom"
+Atomic::NS_APP = "http://www.w3.org/2007/app"

data/lib/atomic/entry.rb

@@ -5,50 +5,9 @@ module Atomic
 
   class Entry
 
-    attr_accessor :id, :title, :categories, :created_at, :updated_at, :content
+    include Parser
 
-    class << self
-
-      def parse(data)
-        entry = new
-        doc = data.kind_of?(Nokogiri::XML::Element) ? data : Nokogiri.XML(data, nil, nil, Nokogiri::XML::PARSE_RECOVER + Nokogiri::XML::PARSE_NOBLANKS)
-
-        entry_node = doc.xpath('//atom:entry', NAMESPACES).first
-
-        entry.id = entry_node.xpath('atom:id', NAMESPACES).first.text
-        entry.title = entry_node.xpath('atom:title', NAMESPACES).first.text
-        entry.created_at = entry_node.xpath('atom:published', NAMESPACES).first.text
-        entry.updated_at = entry_node.xpath('atom:updated', NAMESPACES).first.text
-
-        content_node = entry_node.xpath('atom:content', NAMESPACES).first
-
-        entry.content = {:type => content_node['type']}
-        if (content_node['type'] == 'application/xml')
-          content_hash = {}
-          case content_node.children.first.name
-          when 'announcement'
-            announcement_node = content_node.xpath('cirrus:announcement', NAMESPACES).first
-            unless announcement_node.nil?
-              content_hash[:message] = announcement_node.xpath('cirrus:message', NAMESPACES).first.text
-              content_hash[:starts_at] = announcement_node.xpath('cirrus:starts-at', NAMESPACES).first.text
-              content_hash[:ends_at] = announcement_node.xpath('cirrus:ends-at', NAMESPACES).first.text
-            end
-          else
-            throw("Unknown Content Type: #{content_node.children.first.name}")
-          end
-          entry.content[:data] = {content_node.children.first.name.to_sym => content_hash}
-        else
-          entry.content[:data] = content_node.inner_html
-        end
-        entry.categories = []
-        entry_node.xpath('atom:category', NAMESPACES).each do |category_node|
-          entry.categories << {:term => category_node['term'], :scheme => category_node['scheme']}
-        end
-
-        entry
-      end
-
-    end
+    attr_accessor :id, :title, :categories, :created_at, :updated_at, :content, :links, :author, :contributors
 
     def initialize(params = {})
       params.symbolize_keys!
@@ -58,7 +17,71 @@ module Atomic
       @categories = params[:categories] || []
       @created_at = params[:created_at].nil? ? Time.now : Time.parse(params[:created_at])
       @updated_at = params[:updated_at].nil? ? @created_at : Time.parse(params[:updated_at])
-      @content = params[:content]
+      @content = params[:content] || {}
+      @links = params[:links] || []
+      @author = params[:author]
+      @contributors = params[:contributors] || []
+    end
+
+    def handle_open_element(node, reader)
+      progressed = false
+      case [node.depth, node.uri, node.name]
+      when [0, NS_ATOM, 'entry']
+      when [1, NS_ATOM, 'title']
+      when [1, NS_ATOM, 'id']
+      when [1, NS_ATOM, 'published']
+      when [1, NS_ATOM, 'updated']
+      when [1, NS_ATOM, 'category']
+      when [1, NS_ATOM, 'author']
+        author = Person.new
+        author.deserialize(reader)
+        self.author = author
+        progressed = true
+      when [1, NS_ATOM, 'contributor']
+        contributor = Person.new
+        contributor.deserialize(reader)
+        self.contributors << contributor
+        progressed = true
+      when [1, NS_ATOM, 'content']
+        if node.attributes['type'] == 'application/xml'
+          @processing_xml_content = true
+        end
+      when [1, NS_ATOM, 'link']
+      else
+        if @processing_xml_content
+          extension_class = Extensions::MAP[[node.uri, node.name]]
+          unless extension_class.nil?
+            extension_class.new(self).deserialize(reader)
+            progressed = true
+          end
+        else
+          puts("Entry ==> Unexpected Open Element - [#{node.depth}] #{node.name} #{node.uri} #{node.attributes.inspect}")
+        end
+      end
+      return progressed
+    end
+
+    def handle_close_element(node)
+      case [node.depth, node.uri, node.name]
+      when [0, NS_ATOM, 'entry']
+      when [1, NS_ATOM, 'title']
+        @title = node.text
+      when [1, NS_ATOM, 'id']
+        @id = node.text
+      when [1, NS_ATOM, 'published']
+        @created_at = Time.parse(node.text)
+      when [1, NS_ATOM, 'updated']
+        @updated_at = Time.parse(node.text)
+      when [1, NS_ATOM, 'category']
+        @categories << {:scheme => node.attributes['scheme'], :term => node.attributes['term']}
+      when [1, NS_ATOM, 'author']
+      when [1, NS_ATOM, 'content']
+        @processing_xml_content = false
+      when [1, NS_ATOM, 'link']
+        @links << {:href => node.attributes['href'], :rel => node.attributes['rel'], :type => node.attributes['type']}
+      else
+        puts("Entry ==> Unexpected Close Element - [#{node.depth}] #{node.name} #{node.uri} #{node.attributes.inspect} #{node.text}") unless @processing_xml_content
+      end
     end
 
     def to_hash
@@ -68,23 +91,12 @@ module Atomic
         :categories => @categories,
         :created_at => @created_at,
         :updated_at => @updated_at,
-        :content => @content
+        :content => @content,
+        :links => @links,
+        :author => @author
       }
     end
 
-#    def method_missing(method_symbol, *arguments)
-#      method_name = method_symbol.to_s
-#      case method_name[-1..-1]
-#      when "="
-#        @attributes[method_name[0..-2]] = arguments.first
-#      when "?"
-#        @attributes[method_name[0..-2]] == true
-#      else
-#        # Returns nil on failure so forms will work
-#        @attributes.has_key?(method_name) ? @attributes[method_name] : nil
-#      end
-#    end
-
   end
 
 end

data/lib/atomic/extensions.rb

@@ -0,0 +1,7 @@
+module Atomic
+  module Extensions
+    MAP = {}
+  end
+end
+
+Dir[File.dirname(__FILE__) + '/extensions/*.rb'].each { |f| require f }

data/lib/atomic/extensions/cirrus.rb

@@ -0,0 +1,10 @@
+require File.dirname(__FILE__) + '/cirrus/base'
+require File.dirname(__FILE__) + '/cirrus/announcement'
+require File.dirname(__FILE__) + '/cirrus/news'
+require File.dirname(__FILE__) + '/cirrus/event'
+
+module Atomic
+  module Extensions
+    MAP.merge!(Cirrus::Announcement.mapping => Cirrus::Announcement)
+  end
+end

data/lib/atomic/extensions/cirrus/announcement.rb

@@ -0,0 +1,42 @@
+module Atomic
+  module Extensions
+    module Cirrus
+      class Announcement < Atomic::Extensions::Cirrus::Base
+
+        class << self
+          def mapping
+            [namespace, 'announcement']
+          end
+        end
+
+        def handle_open_element(node, reader)
+          progressed = false
+          case [node.depth, node.uri, node.name]
+          when [0, Announcement.namespace, 'announcement']
+          when [1, Announcement.namespace, 'message']
+          when [1, Announcement.namespace, 'starts-at']
+          when [1, Announcement.namespace, 'ends-at']
+          else
+            puts "Announcement ==>> Unexpected OPEN #{node.depth} #{node.uri} #{node.name} #{node.attributes.inspect}"
+          end
+          return progressed
+        end
+
+        def handle_close_element(node)
+          case [node.depth, node.uri, node.name]
+          when [0, Announcement.namespace, 'announcement']
+          when [1, Announcement.namespace, 'message']
+            @parent.content[:message] = node.text
+          when [1, Announcement.namespace, 'starts-at']
+            @parent.content[:starts_at] = node.text
+          when [1, Announcement.namespace, 'ends-at']
+            @parent.content[:ends_at] = node.text
+          else
+            puts "Announcement ==>> Unexpected CLOSE #{node.depth} #{node.uri} #{node.name} #{node.attributes.inspect}"
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/atomic/extensions/cirrus/base.rb

@@ -0,0 +1,20 @@
+# To change this template, choose Tools | Templates
+# and open the template in the editor.
+
+module Atomic
+  module Extensions
+    module Cirrus
+      class Base
+        include Parser
+        class << self
+          def namespace
+            'http://www.glam.ac.uk/2009/cirrus'
+          end
+        end
+        def initialize(parent)
+           @parent = parent
+        end
+      end
+    end
+  end
+end

data/lib/atomic/extensions/cirrus/event.rb

@@ -0,0 +1,11 @@
+module Atomic
+  module Extensions
+    module Cirrus
+      class Event < Atomic::Extensions::Cirrus::Base
+        def initialize
+          
+        end
+      end
+    end
+  end
+end

data/lib/atomic/extensions/cirrus/news.rb

@@ -0,0 +1,11 @@
+module Atomic
+  module Extensions
+    module Cirrus
+      class News < Atomic::Extensions::Cirrus::Base
+        def initialize
+          
+        end
+      end
+    end
+  end
+end

data/lib/atomic/feed.rb

@@ -6,28 +6,76 @@ module Atomic
 
   class Feed
 
-    class << self
-
-      def parse(data)
-        feed = new
-        doc = data.kind_of?(Nokogiri::XML::Element) ? data : Nokogiri.XML(data)
-        feed_node = doc.xpath('//atom:feed', NAMESPACES).first
-        feed.title = feed_node.xpath('atom:title', NAMESPACES).first.text
-        feed.id = feed_node.xpath('atom:id', NAMESPACES).first.text
-        feed_node.xpath('atom:entry', NAMESPACES).each do |entry_node|
-          feed.entries << Entry.parse(entry_node)
-        end
-        feed
-      end
+    include Parser
 
-    end
+#    class << self
+#
+#      def parse(data)
+#        feed = new
+#        doc = data.kind_of?(Nokogiri::XML::Element) ? data : Nokogiri.XML(data)
+#        feed_node = doc.xpath('//atom:feed', NAMESPACES).first
+#        feed.title = feed_node.xpath('atom:title', NAMESPACES).first.text
+#        feed.id = feed_node.xpath('atom:id', NAMESPACES).first.text
+#        feed_node.xpath('atom:entry', NAMESPACES).each do |entry_node|
+#          feed.entries << Entry.parse(entry_node)
+#        end
+#        feed
+#      end
+#
+#    end
 
-    attr_accessor :title, :id, :entries
+    attr_accessor :id, :title, :subtitle, :updated_at, :links, :rights, :generator, :entries
 
     def initialize(params = {})
       @title = params[:title]
       @id = params[:id]
       @entries = params[:entries] || []
+      @links = params[:links] || []
+    end
+
+    def handle_open_element(node, reader)
+      progressed = false
+      case [node.depth, node.uri, node.name]
+      when [0, 'http://www.w3.org/2005/Atom', 'feed']
+      when [1, NS_ATOM, 'title']
+      when [1, NS_ATOM, 'subtitle']
+      when [1, NS_ATOM, 'updated']
+      when [1, NS_ATOM, 'id']
+      when [1, NS_ATOM, 'link']
+      when [1, NS_ATOM, 'rights']
+      when [1, NS_ATOM, 'generator']
+      when [1, NS_ATOM, 'entry']
+        entry = Entry.new
+        entry.deserialize(reader)
+        @entries << entry
+        progressed = true
+      else
+          puts("Feed ==> Unexpected Open Element - [#{node.depth}] #{node.name} {#{node.uri}} #{node.attributes.inspect}")
+      end
+      return progressed
+    end
+
+    def handle_close_element(node)
+      case [node.depth, node.uri, node.name]
+      when [0, 'http://www.w3.org/2005/Atom', 'feed']
+      when [1, NS_ATOM, 'title']
+        @title = node.text
+      when [1, NS_ATOM, 'subtitle']
+        @subtitle = node.text
+      when [1, NS_ATOM, 'updated']
+        @updated_at = Time.parse(node.text)
+      when [1, NS_ATOM, 'id']
+        @id = node.text
+      when [1, NS_ATOM, 'link']
+        @links << {:href => node.attributes['href'], :rel => node.attributes['rel'], :type => node.attributes['type']}
+      when [1, NS_ATOM, 'rights']
+        @rights = node.text
+      when [1, NS_ATOM, 'generator']
+        @generator = node.text
+      when [1, NS_ATOM, 'entry']
+      else
+          puts("Feed ==> Unexpected Close Element - [#{node.depth}] #{node.name} {#{node.uri}} #{node.attributes.inspect} #{node.text}")
+      end
     end
 
     def to_hash

data/lib/atomic/parser.rb

@@ -0,0 +1,72 @@
+require 'rubygems'
+require 'nokogiri'
+
+module Atomic
+
+  module Parser
+
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+
+    module ClassMethods
+      def parse(xml)
+        reader = Nokogiri::XML::Reader.from_memory(xml, nil, nil, Nokogiri::XML::PARSE_NOBLANKS)
+        object = new
+        object.deserialize(reader.read)
+        object
+      end
+    end
+
+    Node = Struct.new("Node", :depth, :name, :uri, :attributes, :text)
+
+    def deserialize(reader)
+      stack = []
+      start_depth = reader.depth
+      loop do
+#        puts "#{self.class} STACK: #{stack.inspect}"
+        node = Node.new(reader.depth - start_depth, reader.local_name, reader.namespace_uri, reader.attributes)
+        if (stack.empty? || node.depth > stack.last.depth)
+          # child
+          if(reader.value?)
+            stack.last.text = reader.value unless stack.empty?
+            reader.read
+          else
+#            puts "#{self.class} OPEN ELEMENT: #{node.inspect}"
+            redo if handle_open_element(node,reader)
+            stack.push(node)
+          end
+        elsif(node.depth < stack.last.depth)
+          # parent
+#          puts "#{self.class} CLOSE ELEMENT: #{stack.last}"
+          handle_close_element(stack.last)
+          stack.pop
+        else
+          # sibling
+#          puts "#{self.class} SIB CLOSE ELEMENT: #{stack.last}"
+          handle_close_element(stack.last)
+          stack.pop
+          unless stack.empty?
+#            puts "#{self.class} SIB OPEN ELEMENT: #{node.inspect}"
+            redo if handle_open_element(node,reader)
+            stack.push(node)
+          end
+        end
+        break if stack.empty?
+        reader.read
+      end
+    end
+
+    def handle_open_element(node, reader)
+      progressed = false
+      puts("Open Element - #{node.inspect}")
+      return progressed
+    end
+
+    def handle_close_element(node)
+      puts("Close Element - #{node.inspect}")
+    end
+
+  end
+end

data/lib/atomic/person.rb

@@ -0,0 +1,48 @@
+require 'activesupport'
+
+module Atomic
+  class Person
+  
+    include Parser
+
+    attr_accessor :name, :uri, :email
+
+    def initialize(params = {})
+      params.symbolize_keys!
+      params.assert_valid_keys(:name, :uri, :email)
+      @name = params[:name]
+      @uri = params[:uri]
+      @email = params[:email]
+    end
+
+    def handle_open_element(node, reader)
+      progressed = false
+      case [node.depth, node.uri, node.name]
+      when [0, NS_ATOM, 'author']
+      when [0, NS_ATOM, 'contributor']
+      when [1, NS_ATOM, 'name']
+      when [1, NS_ATOM, 'uri']
+      when [1, NS_ATOM, 'email']
+      else
+          puts("Person ==> Unexpected Open Element - [#{node.depth}] #{node.name} #{node.uri} #{node.attributes.inspect}")
+      end
+      return progressed
+    end
+
+    def handle_close_element(node)
+      case [node.depth, node.uri, node.name]
+      when [0, NS_ATOM, 'author']
+      when [0, NS_ATOM, 'contributor']
+      when [1, NS_ATOM, 'name']
+        @name = node.text
+      when [1, NS_ATOM, 'uri']
+        @uri = node.text
+      when [1, NS_ATOM, 'email']
+        @email = node.text
+      else
+          puts("Person ==> Unexpected Close Element - [#{node.depth}] #{node.name} #{node.uri} #{node.attributes.inspect} #{node.text}")
+      end
+    end
+
+  end
+end

data/lib/atomic/service.rb

@@ -4,80 +4,138 @@ require 'time'
 
 module Atomic
 
-  class Workspace
-    class << self
-      def parse(data)
-        workspace = new
-        doc = data.kind_of?(Nokogiri::XML::Element) ? data : Nokogiri.XML(data)
-        workspace_node = doc.xpath('//app:workspace', NAMESPACES).first
-        workspace.title = workspace_node.xpath('atom:title', NAMESPACES).first.text
-        workspace_node.xpath('app:collection', NAMESPACES).each do |collection_node|
-          workspace.collections << Collection.parse(collection_node)
-        end
-        workspace
-      end
-    end
-    attr_accessor :title, :collections
+  class Collection
+
+    include Parser
+    attr_accessor :href, :title, :content_types, :categories
+
     def initialize(params = {})
+      @href = params[:href]
       @title = params[:title]
-      @collections = params[:collections] || []
+      @content_types = params[:content_types] || []
+      @categories = params[:categories] || []
+    end
+
+    def handle_open_element(node, reader)
+      progressed = false
+      case [node.depth, node.uri, node.name]
+      when [0, NS_APP, 'collection']
+      when [1, NS_ATOM, 'title']
+      when [1, NS_APP, 'accept']
+      when [1, NS_APP, 'categories']
+        @processing_categories = true
+      when [2, NS_APP, 'category']
+      else
+          puts("Collection ==> Unexpected Open Element - [#{node.depth}] #{node.name} {#{node.uri}} #{node.attributes.inspect}")
+      end
+      return progressed
+    end
+
+    def handle_close_element(node)
+      case [node.depth, node.uri, node.name]
+      when [0, NS_APP, 'collection']
+        self.href = node.attributes['href']
+      when [1, NS_ATOM, 'title']
+        self.title = node.text
+      when [1, NS_APP, 'accept']
+        self.content_types << node.text
+      when [1, NS_APP, 'categories']
+        @processing_categories = false
+      when [2, NS_APP, 'category']
+        self.categories << {:scheme => node.attributes['scheme'], :term => node.attributes['term']} if @processing_categories
+      else
+          puts("Collection ==> Unexpected Close Element - [#{node.depth}] #{node.name} {#{node.uri}} #{node.attributes.inspect} #{node.text}")
+      end
     end
+
     def to_hash
       {
-        :title => @title,
-        :collections => @collections.collect{ |collection| collection.to_hash }
+        :href => @href,
+        :title => @title
       }
     end
+
   end
 
-  class Collection
-    class << self
-      def parse(data)
-        collection = new
-        collection_node = data.kind_of?(Nokogiri::XML::Element) ? data : Nokogiri.XML(data).xpath('//app:collection', NAMESPACES).first
-#        puts "*********"
-#        puts collection_node
-#        puts "*********"
-        collection.href = collection_node['href']
-        collection.title = collection_node.xpath('atom:title', NAMESPACES).first.text
-        collection
-      end
-    end
-    attr_accessor :href, :title
+  class Workspace
+
+    include Parser
+    attr_accessor :title, :collections
+
     def initialize(params = {})
-      @href = params[:href]
       @title = params[:title]
+      @collections = params[:collections] || []
+    end
+
+    def handle_open_element(node, reader)
+      progressed = false
+      case [node.depth, node.uri, node.name]
+      when [0, NS_APP, 'workspace']
+      when [1, NS_ATOM, 'title']
+      when [1, NS_APP, 'collection']
+        collection = Collection.new
+        collection.deserialize(reader)
+        self.collections << collection
+        progressed = true
+      else
+          puts("Workspace ==> Unexpected Open Element - [#{node.depth}] #{node.name} {#{node.uri}} #{node.attributes.inspect}")
+      end
+      return progressed
     end
+
+    def handle_close_element(node)
+      case [node.depth, node.uri, node.name]
+      when [0, NS_APP, 'workspace']
+      when [1, NS_ATOM, 'title']
+        self.title = node.text
+      when [1, NS_APP, 'collection']
+      else
+          puts("Workspace ==> Unexpected Close Element - [#{node.depth}] #{node.name} {#{node.uri}} #{node.attributes.inspect} #{node.text}")
+      end
+    end
+
     def to_hash
       {
-        :href => @href,
-        :title => @title
+        :title => @title,
+        :collections => @collections.collect{ |collection| collection.to_hash }
       }
     end
+
   end
 
   class Service
-    
-    class << self
-
-      def parse(data)
-        service = new
-        doc = data.kind_of?(Nokogiri::XML::Element) ? data : Nokogiri.XML(data)
-        service_node = doc.xpath('//app:service', NAMESPACES).first
-        service_node.xpath('app:workspace', NAMESPACES).each do |workspace_node|
-          service.workspaces << Workspace.parse(workspace_node)
-        end
-        service
-      end
-
-    end
 
+    include Parser
     attr_accessor :workspaces
 
     def initialize(params = {})
       @workspaces = params[:workspaces] || []
     end
 
+    def handle_open_element(node, reader)
+      progressed = false
+      case [node.depth, node.uri, node.name]
+      when [0, NS_APP, 'service']
+      when [1, NS_APP, 'workspace']
+        workspace = Workspace.new
+        workspace.deserialize(reader)
+        self.workspaces << workspace
+        progressed = true
+      else
+          puts("Service ==> Unexpected Open Element - [#{node.depth}] #{node.name} {#{node.uri}} #{node.attributes.inspect}")
+      end
+      return progressed
+    end
+
+    def handle_close_element(node)
+      case [node.depth, node.uri, node.name]
+      when [0, NS_APP, 'service']
+      when [1, NS_APP, 'workspace']
+      else
+          puts("Service ==> Unexpected Close Element - [#{node.depth}] #{node.name} {#{node.uri}} #{node.attributes.inspect} #{node.text}")
+      end
+    end
+
     def to_hash
       { :workspaces => @workspaces.collect { |workspace| workspace.to_hash } }
     end

data/spec/atomic/entry_spec.rb

@@ -39,14 +39,17 @@ describe Atomic::Entry do
         @entry.title.should == 'Test Announcement'
         @entry.id.should == 'tag:example.org,2003:3.2397'
         @entry.categories.size.should == 2
-        @entry.content.should_not be_nil
-        puts "Content: #{@entry.content.inspect}"
+      end
+
+      it "should handle author element" do
+        @entry.author.should_not be_nil
       end
 
       it "should handle the announcements extension" do
-        @entry.content[:data].should_not be_nil
-        puts "Data: #{@entry.content[:data].inspect}"
-        @entry.content[:data][:announcement].should_not be_nil
+        @entry.content.should_not be_nil
+        @entry.content[:message].should == 'Test Announcement Message'
+        @entry.content[:starts_at].should == '2009-02-10T08:00:00Z'
+        @entry.content[:ends_at].should == '2009-02-10T17:00:00Z'
       end
 
     end

data/spec/atomic/parser_spec.rb

@@ -0,0 +1,16 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe Atomic::Parser do
+  before(:each) do
+    @entry_xml = File.read(File.join(File.dirname(__FILE__), '..', 'fixtures', 'valid_atom_entry.xml'))
+    @klass = Class.new do
+      include Atomic::Parser
+    end
+  end
+
+  it "should work nicely" do
+    @klass.parse(@entry_xml)
+  end
+
+end
+

data/spec/fixtures/valid_atom_entry.xml

@@ -5,17 +5,17 @@
     <updated>2009-02-10T08:00:00Z</updated>
     <published>2009-02-10T08:00:00Z</published>
     <author>
-      <name>Peter Portal</name>
-      <uri>http://www.glam.ac.uk/</uri>
-      <email>peterportal@glam.ac.uk</email>
+        <name>Peter Portal</name>
+        <uri>http://www.glam.ac.uk/</uri>
+        <email>peterportal@glam.ac.uk</email>
     </author>
     <category term="trefforest" scheme="http://cirrusstage.glam.ac.uk/schemes/locations"/>
     <category term="gbs" scheme="http://cirrusstage.glam.ac.uk/schemes/faculties"/>
     <content type="application/xml">
-         <cirrus:announcement>
-             <cirrus:message>Test Announcement Message</cirrus:message>
-             <cirrus:starts-at type="datetime">2009-02-10T08:00:00Z</cirrus:starts-at>
-             <cirrus:ends-at type="datetime">2009-02-10T17:00:00Z</cirrus:ends-at>
-         </cirrus:announcement>
+        <cirrus:announcement>
+            <cirrus:message>Test Announcement Message</cirrus:message>
+            <cirrus:starts-at type="datetime">2009-02-10T08:00:00Z</cirrus:starts-at>
+            <cirrus:ends-at type="datetime">2009-02-10T17:00:00Z</cirrus:ends-at>
+        </cirrus:announcement>
     </content>
-  </entry>
+</entry>

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: exempla-atomic
 version: !ruby/object:Gem::Version 
-  version: 0.0.8
+  version: 0.0.11
 platform: ruby
 authors: 
 - Darrin Wortlehock
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-02-20 00:00:00 -08:00
+date: 2009-02-24 00:00:00 -08:00
 default_executable: 
 dependencies: []
 
@@ -34,6 +34,8 @@ files:
 - lib/atomic/extensions/cirrus/news.rb
 - lib/atomic/extensions/cirrus/event.rb
 - lib/atomic/entry.rb
+- lib/atomic/parser.rb
+- lib/atomic/person.rb
 - lib/atomic/extensions.rb
 - lib/atomic/feed.rb
 - spec/spec.opts
@@ -45,6 +47,7 @@ files:
 - spec/atomic
 - spec/atomic/entry_spec.rb
 - spec/atomic/feed_spec.rb
+- spec/atomic/parser_spec.rb
 - spec/atomic/service_spec.rb
 has_rdoc: true
 homepage: http://github.com/exempla/atomic