exempla-atomic 0.0.11 → 0.0.12

data/VERSION.yml

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

data/lib/atomic/atom.rb

@@ -0,0 +1,312 @@
+begin
+  require 'builder'
+rescue LoadError
+  require 'rubygems'
+  require 'builder'
+end
+
+begin
+  require 'activesupport'
+rescue LoadError
+  require 'rubygems'
+  require 'activesupport'
+end
+
+require 'time'
+
+module Atomic
+  module Atom
+    class Person
+
+      include Parser
+
+      attr_accessor :type, :name, :uri, :email
+
+      def initialize(params = {})
+        params.symbolize_keys!
+        params.assert_valid_keys(:type, :name, :uri, :email)
+        self.type = params[:type]
+        self.name = params[:name]
+        self.uri = params[:uri]
+        self.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']
+          self.type = 'author'
+        when [0, NS_ATOM, 'contributor']
+          self.type = 'contributor'
+        when [1, NS_ATOM, 'name']
+          self.name = node.text
+        when [1, NS_ATOM, 'uri']
+          self.uri = node.text
+        when [1, NS_ATOM, 'email']
+          self.email = node.text
+        else
+          puts("Person ==> Unexpected Close Element - [#{node.depth}] #{node.name} #{node.uri} #{node.attributes.inspect} #{node.text}")
+        end
+      end
+
+      def to_hash
+        {
+          :type => self.type,
+          :name => self.name,
+          :uri => self.uri,
+          :email => self.email
+        }
+      end
+
+      def to_xml(as_document=true, target=nil)
+        nsdec = as_document ? {:"xmlns:atom" => NS_ATOM} : {}
+        xml = Builder::XmlMarkup.new(:target => target)
+        xml.instruct! if as_document
+        xml.atom(type.to_sym, nsdec) do
+          xml.atom(:name, self.name)
+          xml.atom(:uri, self.uri)
+          xml.atom(:email, self.email)
+        end
+        xml.target!
+      end
+
+    end
+
+
+    class Entry
+
+      include Parser
+
+      attr_accessor :id, :title, :categories, :created_at, :updated_at, :content, :links, :author, :contributors
+
+      def initialize(params = {})
+        params.symbolize_keys!
+        params.assert_valid_keys(:id, :title, :categories, :created_at, :updated_at, :content, :links, :author, :contributors)
+        self.title = params[:title]
+        self.id = params[:id]
+        self.categories = params[:categories] || []
+        self.created_at = params[:created_at].nil? ? Time.now : Time.parse(params[:created_at])
+        self.updated_at = params[:updated_at].nil? ? self.created_at : Time.parse(params[:updated_at])
+        self.content = params[:content] || {}
+        self.links = params[:links] || []
+        self.author = params[:author]
+        self.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']
+          self.author = Person.new.deserialize(reader)
+          progressed = true
+        when [1, NS_ATOM, 'contributor']
+          self.contributors << Person.new.deserialize(reader)
+          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']
+          self.title = node.text
+        when [1, NS_ATOM, 'id']
+          self.id = node.text
+        when [1, NS_ATOM, 'published']
+          self.created_at = Time.parse(node.text)
+        when [1, NS_ATOM, 'updated']
+          self.updated_at = Time.parse(node.text)
+        when [1, NS_ATOM, 'category']
+          self.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']
+          self.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
+        {
+          :id => self.id,
+          :title => self.title,
+          :categories => self.categories,
+          :created_at => self.created_at,
+          :updated_at => self.updated_at,
+          :content => self.content,
+          :links => self.links,
+          :author => self.author,
+          :contributors => self.contributors.collect { |contributor| contributor.to_hash }
+        }
+      end
+
+      def to_xml(as_document=true, target=nil)
+        nsdec = as_document ? {:"xmlns:atom" => NS_ATOM} : {}
+        xml = Builder::XmlMarkup.new(:target => target)
+        xml.instruct! if as_document
+        xml.atom(:entry, nsdec) do
+          xml.atom(:id, self.id)
+          xml.atom(:title, self.title)
+          xml.atom(:categories) do
+            self.categories.each do |category|
+              xml.atom(:category, category)
+            end
+          end
+          xml.atom(:published, self.created_at.iso8601)
+          xml.atom(:updated, self.updated_at.iso8601)
+          xml.atom(:content, self.content) if self.content
+          self.links.each do |link|
+            xml.atom(:link, link)
+          end
+          self.author.to_xml(false, xml) if self.author
+          self.contributors.each do |contributor|
+            contributor.to_xml(false, xml)
+          end
+        end
+        xml.target!
+      end
+
+    end
+
+    class Feed
+
+      include Parser
+
+      attr_accessor :id, :title, :subtitle, :updated_at, :links, :rights, :generator, :entries
+
+      def initialize(params = {})
+        params.symbolize_keys!
+        params.assert_valid_keys(:id, :title, :subtitle, :updated_at, :links, :rights, :generator, :entries)
+        self.id = params[:id]
+        self.title = params[:title]
+        self.subtitle = params[:subtitle]
+        self.updated_at = params[:updated_at]
+        self.links = params[:links] || []
+        self.rights = params[:rights]
+        self.generator = params[:generator]
+        self.entries = params[:entries] || []
+      end
+
+      def updated_at
+        updated_times = self.entries.collect{ |entry| entry.updated_at }
+        updated_times << @updated_at if @updated_at
+        updated_times.max || Time.now
+      end
+
+      def handle_open_element(node, reader)
+        progressed = false
+        case [node.depth, node.uri, node.name]
+        when [0, NS_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']
+          self.entries << Entry.new.deserialize(reader)
+          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, NS_ATOM, 'feed']
+        when [1, NS_ATOM, 'title']
+          self.title = node.text
+        when [1, NS_ATOM, 'subtitle']
+          self.subtitle = node.text
+        when [1, NS_ATOM, 'updated']
+          self.updated_at = Time.parse(node.text)
+        when [1, NS_ATOM, 'id']
+          self.id = node.text
+        when [1, NS_ATOM, 'link']
+          self.links << {:href => node.attributes['href'], :rel => node.attributes['rel'], :type => node.attributes['type']}
+        when [1, NS_ATOM, 'rights']
+          self.rights = node.text
+        when [1, NS_ATOM, 'generator']
+          self.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
+        {
+          :id => self.id,
+          :title => self.title,
+          :subtitle => self.subtitle,
+          :updated_at => self.updated_at,
+          :links => self.links,
+          :rights => self.rights,
+          :generator => self.generator,
+          :entries => self.entries.collect { |entry| entry.to_hash }
+        }
+      end
+
+      def to_xml(as_document=true, target=nil)
+        nsdec = as_document ? {:"xmlns:atom" => NS_ATOM} : {}
+        xml = Builder::XmlMarkup.new(:target => target)
+        xml.instruct! if as_document
+        xml.atom(:feed, nsdec) do
+          xml.atom(:id, self.id)
+          xml.atom(:title, self.title)
+          xml.atom(:updated, self.updated_at.iso8601)
+          xml.atom(:subtitle, self.subtitle) if self.subtitle
+          self.links.each do |link|
+            xml.atom(:link, link)
+          end
+          xml.atom(:rights, self.rights) if self.rights
+          xml.atom(:generator, self.generator) if self.generator
+          self.entries.each do |entry|
+            entry.to_xml(false, xml)
+          end
+        end
+        xml.target!
+      end
+
+    end
+  end
+end

data/lib/atomic/atompub.rb

@@ -0,0 +1,206 @@
+begin
+  require 'builder'
+rescue LoadError
+  require 'rubygems'
+  require 'builder'
+end
+
+begin
+  require 'activesupport'
+rescue LoadError
+  require 'rubygems'
+  require 'activesupport'
+end
+
+module Atomic
+  module Atompub
+    class Collection
+
+      include Parser
+
+      attr_accessor :href, :title, :accepts, :categories
+
+      def initialize(params = {})
+        params.symbolize_keys!
+        params.assert_valid_keys(:href, :title, :accepts, :categories)
+        self.href = params[:href]
+        self.title = params[:title]
+        self.accepts = params[:accepts] || []
+        self.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.accepts << 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
+        {
+          :href => self.href,
+          :title => self.title,
+          :accepts => self.accepts,
+          :categories => self.categories
+        }
+      end
+
+      def to_xml(as_document=true, target=nil)
+        nsdec = as_document ? {:"xmlns:atom" => NS_ATOM, :"xmlns:app" => NS_APP} : {}
+        xml = Builder::XmlMarkup.new(:target => target)
+        xml.instruct! if as_document
+        xml.app(:collection, nsdec.merge({:href => self.href})) do
+          xml.atom(:title, self.title)
+          self.accepts.each do |accept|
+            xml.app(:accept, accept)
+          end
+          xml.app(:categories) do
+            self.categories.each do |category|
+              xml.app(:category, category)
+            end
+          end unless categories.empty?
+        end
+        xml.target!
+      end
+
+    end
+
+    class Workspace
+
+      include Parser
+      attr_accessor :title, :collections
+
+      def initialize(params = {})
+        params.symbolize_keys!
+        params.assert_valid_keys(:title, :collections)
+        self.title = params[:title]
+        self.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']
+          self.collections << Collection.new.deserialize(reader)
+          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
+        {
+          :title => self.title,
+          :collections => self.collections.collect{ |collection| collection.to_hash }
+        }
+      end
+
+      def to_xml(as_document=true, target=nil)
+        nsdec = as_document ? {:"xmlns:atom" => NS_ATOM, :"xmlns:app" => NS_APP} : {}
+        xml = Builder::XmlMarkup.new(:target => target)
+        xml.instruct! if as_document
+        xml.app(:workspace, nsdec) do
+          xml.atom(:title, self.title)
+          self.collections.each do |collection|
+            collection.to_xml(false, xml)
+          end
+        end
+        xml.target!
+      end
+
+
+    end
+
+    class Service
+
+      include Parser
+      attr_accessor :workspaces
+
+      def initialize(params = {})
+        params.symbolize_keys!
+        params.assert_valid_keys(:workspaces)
+        self.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']
+          self.workspaces << Workspace.new.deserialize(reader)
+          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 => self.workspaces.collect { |workspace| workspace.to_hash }
+        }
+      end
+
+      def to_xml(as_document=true, target=nil)
+        nsdec = as_document ? {:"xmlns:atom" => NS_ATOM, :"xmlns:app" => NS_APP} : {}
+        xml = Builder::XmlMarkup.new(:target => target)
+        xml.instruct! if as_document
+        xml.app(:service, nsdec) do
+          self.workspaces.each do |workspace|
+            workspace.to_xml(false, xml)
+          end
+        end
+        xml.target!
+      end
+
+    end
+  end
+end

data/lib/atomic/parser.rb

@@ -25,7 +25,6 @@ module Atomic
       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
@@ -33,22 +32,18 @@ module Atomic
             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
@@ -56,6 +51,7 @@ module Atomic
         break if stack.empty?
         reader.read
       end
+      return self
     end
 
     def handle_open_element(node, reader)

data/lib/atomic.rb

@@ -1,8 +1,6 @@
 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/atom'
+require File.dirname(__FILE__) + '/atomic/atompub'
 require File.dirname(__FILE__) + '/atomic/extensions'
 
 Atomic::NS_ATOM = "http://www.w3.org/2005/Atom"

data/spec/atomic/atomic_spec_helper.rb

@@ -0,0 +1,54 @@
+module AtomicSpecHelper
+
+  def valid_entry_attributes
+      {
+        :id => "entry_id",
+        :title => "Atom Entry Title",
+        :categories => [
+          {:term => 'treforest', :scheme => 'http://cirrusstage.glam.ac.uk/schemes/locations'},
+          {:term => 'hesas', :scheme => 'http://cirrusstage.glam.ac.uk/schemes/categories'}
+        ],
+        :content => {
+          :message=>"Test Announcement Message",
+          :starts_at=>"2009-02-10T08:00:00Z",
+          :ends_at=>"2009-02-10T17:00:00Z"
+        }
+      }
+    end
+
+    def valid_feed_attributes
+      {
+        :id => 'feed_id',
+        :title => 'Feed Title',
+        :entries => [
+          Atomic::Atom::Entry.new(valid_entry_attributes)
+        ]
+      }
+    end
+    
+    def valid_collection_attributes
+      {
+        :href => 'http://example.org/collection',
+        :title => 'Collection Title',
+        :accepts => ['application/atom+xml;type=entry'],
+        :categories => [
+          {:scheme => 'http://example.org/scheme', :term => 'category1'},
+          {:scheme => 'http://example.org/scheme', :term => 'category2'}
+        ]
+      }
+    end
+
+    def valid_workspace_attributes
+      {
+        :title => 'Workspace Title',
+        :collections => [Atomic::Atompub::Collection.new(valid_collection_attributes)]
+      }
+    end
+
+    def valid_service_attributes
+      {
+        :workspaces => [Atomic::Atompub::Workspace.new(valid_workspace_attributes)]
+      }
+    end
+
+end

data/spec/atomic/entry_spec.rb

@@ -1,23 +1,10 @@
 require File.dirname(__FILE__) + '/../spec_helper'
+require File.dirname(__FILE__) + '/atomic_spec_helper'
 #require 'time'
 
-describe Atomic::Entry do
-
-  def valid_attributes
-    {
-      :id => "123abc",
-      :title => "Atom Entry Title",
-      :categories => [
-        {:term => 'treforest', :scheme => 'http://cirrusstage.glam.ac.uk/schemes/locations'},
-        {:term => 'hesas', :scheme => 'http://cirrusstage.glam.ac.uk/schemes/categories'}
-      ],
-      :content => {
-        :message=>"Test Announcement Message",
-        :starts_at=>"2009-02-10T08:00:00Z",
-        :ends_at=>"2009-02-10T17:00:00Z"
-      }
-    }
-  end
+describe Atomic::Atom::Entry do
+
+  include AtomicSpecHelper
 
   before :each do
     @xml = File.read(File.join(File.dirname(__FILE__), '..', 'fixtures', 'valid_atom_entry.xml'))
@@ -28,11 +15,11 @@ describe Atomic::Entry do
     describe "#parse" do
 
       before :each do
-        @entry = Atomic::Entry.parse(@xml)
+        @entry = Atomic::Atom::Entry.parse(@xml)
       end
       
       it "should return a new Atomic::Entry" do
-        @entry.should be_an(Atomic::Entry)
+        @entry.should be_an(Atomic::Atom::Entry)
       end
 
       it "should decode a valid Atom Entry xml document" do
@@ -57,14 +44,14 @@ describe Atomic::Entry do
     describe "#new" do
       
       it "should return a new Atomic::Entry" do
-        entry = Atomic::Entry.new(valid_attributes)
-        entry.should be_an(Atomic::Entry)
+        entry = Atomic::Atom::Entry.new(valid_entry_attributes)
+        entry.should be_an(Atomic::Atom::Entry)
       end
 
       it "should set created_at and updated_at to current time if not supplied" do
         now = Time.now
         Time.stub!(:now).and_return(now)
-        entry = Atomic::Entry.new(valid_attributes)
+        entry = Atomic::Atom::Entry.new(valid_entry_attributes)
         entry.created_at.should be_a(Time)
         entry.created_at.should == now
         entry.updated_at.should be_a(Time)
@@ -74,7 +61,7 @@ describe Atomic::Entry do
       it "should set created_at to supplied time" do
         now = Time.now
         Time.stub!(:now).and_return(now)
-        entry = Atomic::Entry.new(valid_attributes.merge(:created_at => '2009-02-10T08:00:00Z'))
+        entry = Atomic::Atom::Entry.new(valid_entry_attributes.merge(:created_at => '2009-02-10T08:00:00Z'))
         entry.created_at.should == Time.parse('2009-02-10T08:00:00Z')
         entry.created_at.should be_a(Time)
       end
@@ -82,7 +69,7 @@ describe Atomic::Entry do
       it "should set updated_at to supplied time" do
         now = Time.now
         Time.stub!(:now).and_return(now)
-        entry = Atomic::Entry.new(valid_attributes.merge(:updated_at => '2009-02-10T08:00:00Z'))
+        entry = Atomic::Atom::Entry.new(valid_entry_attributes.merge(:updated_at => '2009-02-10T08:00:00Z'))
         entry.updated_at.should == Time.parse('2009-02-10T08:00:00Z')
         entry.updated_at.should be_a(Time)
       end
@@ -96,7 +83,7 @@ describe Atomic::Entry do
     before :each do
       @now = Time.now
       Time.stub!(:now).and_return(@now)
-      @entry = Atomic::Entry.new(valid_attributes)
+      @entry = Atomic::Atom::Entry.new(valid_entry_attributes)
     end
 
     it "should return a hash" do
@@ -105,22 +92,22 @@ describe Atomic::Entry do
 
     it "should include the id" do
       @entry.to_hash.should have_key(:id)
-      @entry.to_hash[:id].should == valid_attributes[:id]
+      @entry.to_hash[:id].should == valid_entry_attributes[:id]
     end
 
     it "should include the title" do
       @entry.to_hash.should have_key(:title)
-      @entry.to_hash[:title].should == valid_attributes[:title]
+      @entry.to_hash[:title].should == valid_entry_attributes[:title]
     end
 
     it "should include the categories" do
       @entry.to_hash.should have_key(:categories)
-      @entry.to_hash[:categories].should == valid_attributes[:categories]
+      @entry.to_hash[:categories].should == valid_entry_attributes[:categories]
     end
 
     it "should include the content" do
       @entry.to_hash.should have_key(:content)
-      @entry.to_hash[:content].should == valid_attributes[:content]
+      @entry.to_hash[:content].should == valid_entry_attributes[:content]
     end
 
     it "should include the created_at time" do
@@ -134,6 +121,21 @@ describe Atomic::Entry do
     end
 
   end
+
+  describe "#to_xml" do
+
+    before :each do
+      @now = Time.now
+      Time.stub!(:now).and_return(@now)
+      @entry = Atomic::Atom::Entry.new(valid_entry_attributes)
+    end
+
+    it "should work" do
+      puts @entry.to_xml(true)
+    end
+
+  end
+
   
 end
 

data/spec/atomic/feed_spec.rb

@@ -1,12 +1,37 @@
 require File.dirname(__FILE__) + '/../spec_helper'
+require File.dirname(__FILE__) + '/atomic_spec_helper'
+
+describe Atomic::Atom::Feed do
+
+  include AtomicSpecHelper
+
+  describe "#new" do
 
-describe Atomic::Feed do
-  before(:each) do
   end
 
-  it "should work" do
-    xml = File.read(File.join(File.dirname(__FILE__), '..', 'fixtures', 'valid_atom_feed.xml'))
-    @feed = Atomic::Feed.parse(xml)
+  describe "#parse" do
+    before(:each) do
+      @xml = File.read(File.join(File.dirname(__FILE__), '..', 'fixtures', 'valid_atom_feed.xml'))
+      @feed = Atomic::Atom::Feed.parse(@xml)
+    end
+    it "should work" do
+
+    end
   end
+
+  describe "#to_hash" do
+
+  end
+
+  describe "#to_xml" do
+    before(:each) do
+      @feed = Atomic::Atom::Feed.new(valid_feed_attributes)
+    end
+
+    it "should work" do
+      puts @feed.to_xml(true)
+    end
+  end
+
 end
 

data/spec/atomic/service_spec.rb

@@ -1,14 +1,35 @@
 require File.dirname(__FILE__) + '/../spec_helper'
+require File.dirname(__FILE__) + '/atomic_spec_helper'
 
-describe Atomic::Service do
+describe Atomic::Atompub::Service do
+
+  include AtomicSpecHelper
+
+  describe "#new" do
 
-  before(:each) do
   end
 
-  it "should work" do
-    xml = File.read(File.join(File.dirname(__FILE__), '..', 'fixtures', 'valid_atom_service.xml'))
-    @service = Atomic::Service.parse(xml)
+  describe "#parse" do
+    it "should work" do
+      xml = File.read(File.join(File.dirname(__FILE__), '..', 'fixtures', 'valid_atom_service.xml'))
+      @service = Atomic::Atompub::Service.parse(xml)
+    end
+  end
+
+  describe "#to_hash" do
+
   end
+
+  describe "#to_xml" do
+    before(:each) do
+      @service = Atomic::Atompub::Service.new(valid_service_attributes)
+    end
+
+    it "should work" do
+      puts @service.to_xml(true)
+    end
+  end
+
   
 end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: exempla-atomic
 version: !ruby/object:Gem::Version 
-  version: 0.0.11
+  version: 0.0.12
 platform: ruby
 authors: 
 - Darrin Wortlehock
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-02-24 00:00:00 -08:00
+date: 2009-02-25 00:00:00 -08:00
 default_executable: 
 dependencies: []
 
@@ -25,7 +25,7 @@ files:
 - VERSION.yml
 - lib/atomic.rb
 - lib/atomic
-- lib/atomic/service.rb
+- lib/atomic/atompub.rb
 - lib/atomic/extensions
 - lib/atomic/extensions/cirrus.rb
 - lib/atomic/extensions/cirrus
@@ -33,20 +33,20 @@ files:
 - lib/atomic/extensions/cirrus/base.rb
 - 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
+- lib/atomic/atom.rb
 - spec/spec.opts
 - spec/fixtures
 - spec/fixtures/valid_atom_entry.xml
 - spec/fixtures/valid_atom_service.xml
 - spec/fixtures/valid_atom_feed.xml
+- spec/fixtures/cirrus_feed.xml
 - spec/spec_helper.rb
 - spec/atomic
 - spec/atomic/entry_spec.rb
 - spec/atomic/feed_spec.rb
+- spec/atomic/atomic_spec_helper.rb
 - spec/atomic/parser_spec.rb
 - spec/atomic/service_spec.rb
 has_rdoc: true

data/lib/atomic/entry.rb

@@ -1,102 +0,0 @@
-require 'time'
-require 'activesupport'
-
-module Atomic
-
-  class Entry
-
-    include Parser
-
-    attr_accessor :id, :title, :categories, :created_at, :updated_at, :content, :links, :author, :contributors
-
-    def initialize(params = {})
-      params.symbolize_keys!
-      params.assert_valid_keys(:title, :id, :categories, :created_at, :updated_at, :content)
-      @title = params[:title]
-      @id = params[:id]
-      @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] || {}
-      @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
-      {
-        :id => @id,
-        :title => @title,
-        :categories => @categories,
-        :created_at => @created_at,
-        :updated_at => @updated_at,
-        :content => @content,
-        :links => @links,
-        :author => @author
-      }
-    end
-
-  end
-
-end

data/lib/atomic/feed.rb

@@ -1,91 +0,0 @@
-require 'rubygems'
-require 'nokogiri'
-require 'time'
-
-module Atomic
-
-  class Feed
-
-    include Parser
-
-#    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 :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
-      {
-        :title => @title,
-        :id => @id,
-        :entries => @entries.collect { |entry| entry.to_hash }
-      }
-    end
-
-  end
-
-end

data/lib/atomic/person.rb

@@ -1,48 +0,0 @@
-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

@@ -1,145 +0,0 @@
-require 'rubygems'
-require 'nokogiri'
-require 'time'
-
-module Atomic
-
-  class Collection
-
-    include Parser
-    attr_accessor :href, :title, :content_types, :categories
-
-    def initialize(params = {})
-      @href = params[:href]
-      @title = params[:title]
-      @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
-      {
-        :href => @href,
-        :title => @title
-      }
-    end
-
-  end
-
-  class Workspace
-
-    include Parser
-    attr_accessor :title, :collections
-
-    def initialize(params = {})
-      @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
-      {
-        :title => @title,
-        :collections => @collections.collect{ |collection| collection.to_hash }
-      }
-    end
-
-  end
-
-  class Service
-
-    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
-
-  end
-
-end