ratom 0.3.0 → 0.3.1

data/History.txt

@@ -1,3 +1,8 @@
+== 0.3.1 2008-04-02
+
+* Bunch of fixes to the Atom::Pub classes to make them work like the Atom classes
+  with respect to initializers and to_xml.
+
 == 0.3.0 2008-04-02
 
 * Raise Atom::Serialization error when you try and serialize non-utf8 content.

data/lib/atom.rb

@@ -147,6 +147,13 @@ module Atom # :nodoc:
         super(xml.read_string)
         parse(xml, :once => true)
       end
+      
+      def to_xml(nodeonly = true, name = 'content', namespace = nil)
+        node = XML::Node.new(name)
+        node['xmlns'] = namespace
+        node << self.to_s
+        node
+      end
     end
     
     # Html content within an Atom document.
@@ -167,7 +174,7 @@ module Atom # :nodoc:
         end        
       end
       
-      def to_xml(nodeonly = true, name = 'content') # :nodoc:
+      def to_xml(nodeonly = true, name = 'content', namespace = nil) # :nodoc:
         require 'iconv'
         # Convert from utf-8 to utf-8 as a way of making sure the content is UTF-8.
         #
@@ -180,6 +187,7 @@ module Atom # :nodoc:
           node = XML::Node.new(name)
           node << Iconv.iconv('utf-8', 'utf-8', self.to_s)
           node['type'] = 'html'
+          node['xmlns'] = namespace
           node['xml:lang'] = self.xml_lang        
           node
         rescue Iconv::IllegalSequence => e
@@ -210,10 +218,11 @@ module Atom # :nodoc:
         while xml.read == 1 && xml.depth > starting_depth; end
       end
       
-      def to_xml(nodeonly = true, name = 'content')
+      def to_xml(nodeonly = true, name = 'content', namespace = nil)
         node = XML::Node.new(name)
         node['type'] = 'xhtml'
         node['xml:lang'] = self.xml_lang
+        node['xmlns'] = namespace
         
         div = XML::Node.new('div')        
         div['xmlns'] = XHTML
@@ -287,6 +296,7 @@ module Atom # :nodoc:
 
     loadable! 
     
+    namespace Atom::NAMESPACE
     element :id, :rights
     element :generator, :class => Generator
     element :title, :subtitle, :class => Content
@@ -403,6 +413,7 @@ module Atom # :nodoc:
     def_delegators :@links, :alternate, :self, :alternates, :enclosures, :edit_link, :via
     
     loadable!
+    namespace Atom::NAMESPACE
     element :title, :id, :summary
     element :updated, :published, :class => Time, :content_only => true
     element :content, :class => Content

data/lib/atom/pub.rb

@@ -24,6 +24,7 @@ module Atom
     
     class Service
       include Atom::Xml::Parseable
+      namespace Atom::Pub::NAMESPACE
       elements :workspaces
       loadable! do |reader, message, severity, base, line|
         if severity == XML::Reader::SEVERITY_ERROR
@@ -31,51 +32,77 @@ module Atom
         end
       end
       
-      def initialize(xml)
+      def initialize(xml = nil)
         @workspaces = []
-        begin
-          if next_node_is?(xml, 'service', Atom::Pub::NAMESPACE)
-            xml.read
-            parse(xml)
-          else
-            raise ArgumentError, "XML document was missing atom:feed"        
+
+        if xml
+          begin
+            if next_node_is?(xml, 'service', Atom::Pub::NAMESPACE)
+              xml.read
+              parse(xml)
+            else
+              raise ArgumentError, "XML document was missing atom:service"        
+            end
+          ensure
+            xml.close
           end
-        ensure
-          xml.close
         end
+        
+        yield(self) if block_given?        
+      end
+    end
+    
+    class Category
+      include Atom::Xml::Parseable
+      def initialize(o)
+        o.read
+        parse(o, :once => true)
       end
     end
     
-    class Categories
+    class Categories < DelegateClass(Array)
       include Atom::Xml::Parseable
+      elements :categories, :class => Category
       
       def initialize(o)
+        super([])
         o.read
         parse(o)
       end
-      
+
+      def categories; self; end
     end
     
     class Workspace
       include Atom::Xml::Parseable
-      element :title, :class => Content
+      element :title, :class => Content, :namespace => Atom::NAMESPACE
       elements :collections
       
-      def initialize(o)
+      def initialize(o = nil)
         @collections = []
-        o.read
-        parse(o)
+        
+        case o
+        when XML::Reader
+          o.read
+          parse(o)
+        when Hash
+          o.each do |k, v|
+            self.send("#{k}=".to_sym, v)
+          end
+        end
+        
+        yield(self) if block_given?
       end
     end
     
     class Collection
       include Atom::Xml::Parseable
       attribute :href
+      element :title, :class => Content, :namespace => Atom::NAMESPACE
       element :categories, :class => Categories
-      element :title, :class => Content
       elements :accepts, :content_only => true
       
-      def initialize(o)
+      def initialize(o = nil)
         @accepts = []
         case o
         when XML::Reader
@@ -89,6 +116,8 @@ module Atom
             self.send("#{k}=", v)
           end  
         end
+        
+        yield(self) if block_given?
       end
       
       def feed

data/lib/atom/version.rb

@@ -2,7 +2,7 @@ module Atom #:nodoc:
   module VERSION #:nodoc:
     MAJOR = 0
     MINOR = 3
-    TINY  = 0
+    TINY  = 1
 
     STRING = [MAJOR, MINOR, TINY].join('.')
   end

data/lib/atom/xml/parser.rb

@@ -68,6 +68,7 @@ module Atom
           def o.attributes; @attributes ||= []; end
           def element_specs; self.class.element_specs; end
           def attributes; self.class.attributes; end
+          def o.namespace(ns = @namespace); @namespace = ns; end
         end
         o.send(:extend, DeclarationMethods)
       end
@@ -84,27 +85,32 @@ module Atom
         end
       end
       
-      def to_xml(nodeonly = false, root_name = self.class.name.demodulize.downcase)
-        
+      def to_xml(nodeonly = false, root_name = self.class.name.demodulize.downcase, namespace = nil)        
         node = XML::Node.new(root_name)
-        node['xmlns'] = Atom::NAMESPACE unless nodeonly
+        node['xmlns'] = self.class.namespace unless nodeonly || !self.class.respond_to?(:namespace)
         
-        self.class.element_specs.values.each do |spec|
-          if spec.single?
-            if attribute = self.send(spec.attribute)
-              if attribute.is_a?(Time)
-                node << XML::Node.new(spec.name, attribute.xmlschema)
-              elsif attribute.respond_to?(:to_xml)
-                node << attribute.to_xml(true)
-              else
-                n =  XML::Node.new(spec.name)
-                n << attribute
-                node << n
-              end
+        self.class.element_specs.values.select {|s| s.single? }.each do |spec|
+          if attribute = self.send(spec.attribute)
+            if attribute.respond_to?(:to_xml)
+              node << attribute.to_xml(true, spec.name, spec.options[:namespace])
+            else
+              n =  XML::Node.new(spec.name)
+              n['xmlns'] = spec.options[:namespace]              
+              n << (attribute.is_a?(Time)? attribute.xmlschema : attribute.to_s)
+              node << n
             end
-          else
-            self.send(spec.attribute).each do |attribute|
+          end
+        end  
+        
+        self.class.element_specs.values.select {|s| !s.single? }.each do |spec|
+          self.send(spec.attribute).each do |attribute|
+            if attribute.respond_to?(:to_xml)
               node << attribute.to_xml(true, spec.name.singularize)
+            else
+              n = XML::Node.new(spec.name.singularize)
+              n['xmlns'] = spec.options[:namespace]
+              n << attribute.to_s
+              node << n
             end
           end
         end

data/spec/atom/pub_spec.rb

@@ -12,215 +12,263 @@ require 'atom/version'
 require 'uri'
 require 'net/http'
 
+shared_examples_for 'parser of spec/app/service.xml' do
+  it "should have 2 workspaces" do
+    @service.should have(2).workspaces
+  end
+    
+  it "should have a title" do
+    @workspace.title.should == "Main Site"
+  end
+
+  it "should have 2 collections" do
+    @workspace.should have(2).collections
+  end
+
+  it "should have the right href" do
+    @collection1.href.should == 'http://example.org/blog/main'
+  end
+
+  it "should have categories" do
+    @collection1.categories.should_not be_nil
+  end
+
+  it "should have a title" do
+    @collection1.title.should == 'My Blog Entries'
+  end
+  
+  it "should have a title" do
+    @collection2.title.should == 'Pictures'
+  end
+
+  it "should have the right href" do
+    @collection2.href.should == 'http://example.org/blog/pic'
+  end
+
+  it "should not have categories" do
+    @collection2.categories.should be_nil
+  end
+
+  it "should have 3 accepts" do
+    @collection2.should have(3).accepts
+  end
+
+  it "should accept 'image/png'" do
+    @collection2.accepts.should include('image/png')
+  end
+
+  it "should accept 'image/jpeg'" do
+    @collection2.accepts.should include('image/jpeg')
+  end
+
+  it "should accept 'image/gif'" do
+    @collection2.accepts.should include('image/gif')
+  end
+  
+  it "should have a title on workspace 2" do
+    @workspace2.title.should == 'Sidebar Blog'
+  end
+
+  it "should have 1 collection on workspace 2" do
+    @workspace2.should have(1).collections
+  end
+
+  it "should have a title on collection 3" do
+    @collection3.title.should == 'Remaindered Links'
+  end
+
+  it "should have 1 accept on collection 3" do
+    @collection3.should have(1).accepts
+  end
+
+  it "should accept 'application/atom+xml;type=entry'" do
+    @collection3.accepts.should include('application/atom+xml;type=entry')
+  end
+
+  it "should have categories" do
+    @collection3.categories.should_not be_nil
+  end
+end
+
 describe Atom::Pub do  
   describe Atom::Pub::Service do
-    before(:all) do
-      @service = Atom::Pub::Service.load_service(File.open('spec/app/service.xml'))
+    it "should load from a URL" do
+      uri = URI.parse('http://example.com/service.xml')
+      response = Net::HTTPSuccess.new(nil, nil, nil)
+      response.stub!(:body).and_return(File.read('spec/app/service.xml'))
+      Net::HTTP.should_receive(:get_response).with(uri).and_return(response)
+      Atom::Pub::Service.load_service(uri).should be_an_instance_of(Atom::Pub::Service)
     end
+    
+    it "should raise ArgumentError with a non-http URL" do
+      lambda { Atom::Pub::Service.load_service(URI.parse('file:/tmp')) }.should raise_error(ArgumentError)
+    end
+    
+    it "should be able to be created without xml" do
+      lambda { Atom::Pub::Service.new }.should_not raise_error
+    end
+    
+    it "should yield in the initializer" do
+      yielded = false
+      Atom::Pub::Service.new do
+        yielded = true
+      end
       
-    it "should have 2 workspaces" do
-      @service.should have(2).workspaces
+      yielded.should be_true
     end
-  
-    describe 'workspace 1' do
-      before(:each) do
+
+    it "should parse it's output" do
+      orig = File.read('spec/app/service.xml')
+      svc = Atom::Pub::Service.load_service(orig)
+      xml = svc.to_xml
+      lambda do
+        Atom::Pub::Service.load_service(xml)
+      end.should_not raise_error
+    end
+        
+    describe "load_service" do
+      before(:all) do
+        @service = Atom::Pub::Service.load_service(File.open('spec/app/service.xml'))
         @workspace = @service.workspaces.first
+        @workspace2 = @service.workspaces[1]
+        @collection1 = @workspace.collections.first
+        @collection2 = @workspace.collections[1]
+        @collection3 = @workspace2.collections.first
       end
+      
+      it_should_behave_like 'parser of spec/app/service.xml'
+    end
     
-      it "should have a title" do
-        @workspace.title.should == "Main Site"
+    describe "#to_xml" do
+      before(:each) do
+        @svc = Atom::Pub::Service.load_service(File.read('spec/app/service.xml'))
+        @xml = @svc.to_xml
+        @service = Atom::Pub::Service.load_service(@xml)
+        @workspace = @service.workspaces.first
+        @workspace2 = @service.workspaces[1]
+        @collection1 = @workspace.collections.first
+        @collection2 = @workspace.collections[1]
+        @collection3 = @workspace2.collections.first
       end
     
-      it "should have 2 collections" do
-        @workspace.should have(2).collections
+      it "should put title in Atom namespace" do
+        # TODO fix this to use a prefix?
+        @xml.should match(%r{title xmlns="#{Atom::NAMESPACE}"})
       end
-    
-      describe 'first collection' do
-        before(:each) do
-          @collection = @workspace.collections.first
-        end
-      
-        it "should have the right href" do
-          @collection.href.should == 'http://example.org/blog/main'
-        end
-      
-        it "should have categories" do
-          @collection.categories.should_not be_nil
-        end
       
-        it "should have a title" do
-          @collection.title.should == 'My Blog Entries'
-        end
+      it_should_behave_like 'parser of spec/app/service.xml'
+    end
+  end
+  
+  describe Atom::Pub::Collection do    
+    describe '.new' do    
+      it "should set the href from the hash" do
+        collection = Atom::Pub::Collection.new(:href => 'http://example.org/blog')
+        collection.href.should == 'http://example.org/blog'
       end
-    
-      describe 'second collection' do
-        before(:each) do
-          @collection = @workspace.collections[1]
-        end
-      
-        it "should have a title" do
-          @collection.title.should == 'Pictures'
-        end
       
-        it "should have the right href" do
-          @collection.href.should == 'http://example.org/blog/pic'
-        end
-      
-        it "should not have categories" do
-          @collection.categories.should be_nil
-        end
-      
-        it "should have 3 accepts" do
-          @collection.should have(3).accepts
-        end
-      
-        it "should accept 'image/png'" do
-          @collection.accepts.should include('image/png')
-        end
-      
-        it "should accept 'image/jpeg'" do
-          @collection.accepts.should include('image/jpeg')
-        end
-      
-        it "should accept 'image/gif'" do
-          @collection.accepts.should include('image/gif')
+      it "should set the href from a block" do
+        collection = Atom::Pub::Collection.new do |c|
+          c.href = "http://example.org/blog"
         end
+        collection.href.should == 'http://example.org/blog'
       end
     end
-  
-    describe 'workspace 2' do
+     
+    describe '#publish' do 
       before(:each) do
-        @workspace = @service.workspaces[1]
-      end
-    
-      it "should have a title" do
-        @workspace.title.should == 'Sidebar Blog'
+        @collection = Atom::Pub::Collection.new(:href => 'http://example.org/blog')
+        @request_headers = {'Accept' => 'application/atom+xml', 
+                   'Content-Type' => 'application/atom+xml;type=entry',
+                   'User-Agent' => "rAtom #{Atom::VERSION::STRING}"
+                   }
       end
-    
-      it "should have 1 collection" do
-        @workspace.should have(1).collections
+      
+      it "should return the feed" do
+        response = Net::HTTPSuccess.new(nil, nil, nil)
+        response.stub!(:body).and_return(File.read('spec/fixtures/simple_single_entry.atom'))
+        Net::HTTP.should_receive(:get_response).with(URI.parse(@collection.href)).and_return(response)
+        @collection.feed.should be_an_instance_of(Atom::Feed)
       end
     
-      describe 'collection' do
-        before(:each) do
-          @collection = @workspace.collections.first
-        end
-      
-        it "should have a title" do
-          @collection.title.should == 'Remaindered Links'
-        end
-      
-        it "should have 1 accept" do
-          @collection.should have(1).accepts
-        end
+      it "should send a POST request when an entry is published" do      
+        entry = Atom::Entry.load_entry(File.open('spec/fixtures/entry.atom'))      
+                 
+        response = mock_response(Net::HTTPCreated, entry.to_xml.to_s)
       
-        it "should accept 'application/atom+xml;type=entry'" do
-          @collection.accepts.should include('application/atom+xml;type=entry')
-        end
+        http = mock('http')
+        http.should_receive(:post).with('/blog', entry.to_xml.to_s, @request_headers).and_return(response)
+        Net::HTTP.should_receive(:start).with('example.org', 80).and_yield(http)
       
-        it "should have categories" do
-          @collection.categories.should_not be_nil
-        end
+        created = @collection.publish(entry)
+        created.should == entry
       end
-    end
-  end
-  
-  describe Atom::Pub::Service do
-    it "should load from a URL" do
-      uri = URI.parse('http://example.com/service.xml')
-      response = Net::HTTPSuccess.new(nil, nil, nil)
-      response.stub!(:body).and_return(File.read('spec/app/service.xml'))
-      Net::HTTP.should_receive(:get_response).with(uri).and_return(response)
-      Atom::Pub::Service.load_service(uri).should be_an_instance_of(Atom::Pub::Service)
-    end
     
-    it "should raise ArgumentError with a non-http URL" do
-      lambda { Atom::Pub::Service.load_service(URI.parse('file:/tmp')) }.should raise_error(ArgumentError)
-    end
-  end
-  
-  describe Atom::Pub::Collection do
-    before(:each) do
-      @collection = Atom::Pub::Collection.new(:href => 'http://example.org/blog')
-      @request_headers = {'Accept' => 'application/atom+xml', 
-                 'Content-Type' => 'application/atom+xml;type=entry',
-                 'User-Agent' => "rAtom #{Atom::VERSION::STRING}"
-                 }
-    end
-    
-    it "should set the href from the hash" do
-      @collection.href.should == 'http://example.org/blog'
-    end
+      it "should behave well when no content is returned" do      
+        entry = Atom::Entry.load_entry(File.open('spec/fixtures/entry.atom'))      
+                 
+        response = mock_response(Net::HTTPCreated, " ")
       
-    it "should return the feed" do
-      response = Net::HTTPSuccess.new(nil, nil, nil)
-      response.stub!(:body).and_return(File.read('spec/fixtures/simple_single_entry.atom'))
-      Net::HTTP.should_receive(:get_response).with(URI.parse(@collection.href)).and_return(response)
-      @collection.feed.should be_an_instance_of(Atom::Feed)
-    end
+        http = mock('http')
+        http.should_receive(:post).with('/blog', entry.to_xml.to_s, @request_headers).and_return(response)
+        Net::HTTP.should_receive(:start).with('example.org', 80).and_yield(http)
+      
+        created = @collection.publish(entry)
+        created.should == entry
+      end
     
-    it "should send a POST request when an entry is published" do      
-      entry = Atom::Entry.load_entry(File.open('spec/fixtures/entry.atom'))      
-                 
-      response = mock_response(Net::HTTPCreated, entry.to_xml.to_s)
+      it "should raise error when response is not HTTPCreated" do
+        entry = Atom::Entry.load_entry(File.open('spec/fixtures/entry.atom'))
+        response = mock_response(Net::HTTPPreconditionFailed, "")
       
-      http = mock('http')
-      http.should_receive(:post).with('/blog', entry.to_xml.to_s, @request_headers).and_return(response)
-      Net::HTTP.should_receive(:start).with('example.org', 80).and_yield(http)
+        http = mock('http')
+        http.should_receive(:post).with('/blog', entry.to_xml.to_s, @request_headers).and_return(response)
+        Net::HTTP.should_receive(:start).with('example.org', 80).and_yield(http)
       
-      created = @collection.publish(entry)
-      created.should == entry
-    end
+        lambda { @collection.publish(entry) }.should raise_error(Atom::Pub::ProtocolError)
+      end
     
-    it "should behave well when no content is returned" do      
-      entry = Atom::Entry.load_entry(File.open('spec/fixtures/entry.atom'))      
+      it "should copy Location into edit link of entry" do
+        entry = Atom::Entry.load_entry(File.open('spec/fixtures/entry.atom'))      
                  
-      response = mock_response(Net::HTTPCreated, " ")
+        response = mock_response(Net::HTTPCreated, entry.to_xml.to_s, 'Location' => 'http://example.org/edit/entry1.atom')
       
-      http = mock('http')
-      http.should_receive(:post).with('/blog', entry.to_xml.to_s, @request_headers).and_return(response)
-      Net::HTTP.should_receive(:start).with('example.org', 80).and_yield(http)
+        http = mock('http')
+        http.should_receive(:post).with('/blog', entry.to_xml.to_s, @request_headers).and_return(response)
+        Net::HTTP.should_receive(:start).with('example.org', 80).and_yield(http)
       
-      created = @collection.publish(entry)
-      created.should == entry
-    end
+        created = @collection.publish(entry)
+        created.edit_link.should_not be_nil
+        created.edit_link.href.should == 'http://example.org/edit/entry1.atom'
+      end
     
-    it "should raise error when response is not HTTPCreated" do
-      entry = Atom::Entry.load_entry(File.open('spec/fixtures/entry.atom'))
-      response = mock_response(Net::HTTPPreconditionFailed, "")
+      it "should update the entry when response is different" do
+        entry = Atom::Entry.load_entry(File.open('spec/fixtures/entry.atom'))
+        response = mock_response(Net::HTTPCreated, File.read('spec/fixtures/created_entry.atom'),
+                                 'Location' => 'http://example.org/edit/atom')
       
-      http = mock('http')
-      http.should_receive(:post).with('/blog', entry.to_xml.to_s, @request_headers).and_return(response)
-      Net::HTTP.should_receive(:start).with('example.org', 80).and_yield(http)
+        http = mock('http')
+        http.should_receive(:post).with('/blog', entry.to_xml.to_s, @request_headers).and_return(response)
+        Net::HTTP.should_receive(:start).with('example.org', 80).and_yield(http)
       
-      lambda { @collection.publish(entry) }.should raise_error(Atom::Pub::ProtocolError)
+        created = @collection.publish(entry)
+        created.should == Atom::Entry.load_entry(File.open('spec/fixtures/created_entry.atom'))
+      end
     end
-    
-    it "should copy Location into edit link of entry" do
-      entry = Atom::Entry.load_entry(File.open('spec/fixtures/entry.atom'))      
-                 
-      response = mock_response(Net::HTTPCreated, entry.to_xml.to_s, 'Location' => 'http://example.org/edit/entry1.atom')
-      
-      http = mock('http')
-      http.should_receive(:post).with('/blog', entry.to_xml.to_s, @request_headers).and_return(response)
-      Net::HTTP.should_receive(:start).with('example.org', 80).and_yield(http)
+  end
+  
+  describe Atom::Pub::Workspace do
+    it "should do the block initialization thing" do
+      workspace = Atom::Pub::Workspace.new do |w|
+        w.title = "Title"
+      end
       
-      created = @collection.publish(entry)
-      created.edit_link.should_not be_nil
-      created.edit_link.href.should == 'http://example.org/edit/entry1.atom'
+      workspace.title.should == "Title"
     end
     
-    it "should update the entry when response is different" do
-      entry = Atom::Entry.load_entry(File.open('spec/fixtures/entry.atom'))
-      response = mock_response(Net::HTTPCreated, File.read('spec/fixtures/created_entry.atom'),
-                               'Location' => 'http://example.org/edit/atom')
-      
-      http = mock('http')
-      http.should_receive(:post).with('/blog', entry.to_xml.to_s, @request_headers).and_return(response)
-      Net::HTTP.should_receive(:start).with('example.org', 80).and_yield(http)
-      
-      created = @collection.publish(entry)
-      created.should == Atom::Entry.load_entry(File.open('spec/fixtures/created_entry.atom'))
+    it "should do the hash initialization thing" do
+      workspace = Atom::Pub::Workspace.new(:title => 'Title')      
+      workspace.title.should == "Title"
     end
   end
   

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: ratom
 version: !ruby/object:Gem::Version 
-  version: 0.3.0
+  version: 0.3.1
 platform: ruby
 authors: 
 - Peerworks