objectify-xml 0.2.0

data/lib/objectify_xml/element_parser.rb

@@ -0,0 +1,18 @@
+module Objectify
+  class ElementParser < Xml
+    def primary_xml_element(xml)
+      xml.attributes.keys.each do |name|
+        method = "#{ name }="
+        if respond_to? method
+          send(method, xml_text_to_value(xml[name]))
+        end
+      end
+      if respond_to? :inner_html=
+        self.inner_html = xml.inner_html
+      end
+      if respond_to? :inner_text=
+        self.inner_text = xml.inner_text
+      end
+    end
+  end
+end

data/spec/atom_spec.rb

@@ -0,0 +1,63 @@
+require File.join(File.dirname(__FILE__), 'spec_helper')
+
+# This is not a validation of my definition of Atom, just a sort of integration test.
+describe Objectify::Atom do
+  before :all do
+    @feed = Objectify::Atom::Feed.new(sample_feed('wikipedia.atom'))
+  end
+
+  describe 'the feed' do
+    it 'should have 2 links' do
+      @feed.links.length.should == 2
+    end
+
+    it 'should have 50 entries' do
+      @feed.entries.length.should == 50
+    end
+
+    it 'should be generated by Mediawiki' do
+      @feed.generator.inner_text.should == 'MediaWiki 1.15alpha'
+    end
+  end
+  
+  describe 'the first link' do
+    it 'should have all attributes' do
+      link = @feed.links.first
+      link.rel.should == 'self'
+      link.type.should == 'application/atom+xml'
+      # the href has been unescaped.
+      link.href.should == "http://en.wikipedia.org/w/index.php?title=Special:RecentChanges&feed=atom"
+    end
+  end
+
+  describe 'the first entry' do
+    before do
+      @entry = @feed.entries.first
+    end
+
+    it 'should be updated at...' do
+      @entry.updated.should == DateTime.parse('2009-02-23T19:08:18')
+    end
+
+    it 'should be titled ...' do
+      @entry.title.should == 'Audio commentary'
+    end
+
+    it 'should have a summary' do
+      @entry.summary.length.should == 5692
+    end
+
+    it 'should inspect nicely' do
+      @entry.inspect.should == '<Objectify::Atom::Entry title, author:Objectify::Atom::Author, id, summary, links:1, updated>'
+    end
+
+    it 'should have the author name' do
+      @entry.author.name.should == 'Richiekim'
+    end
+
+    it 'should be nil if the element was not included' do
+      @entry.category.should be_nil
+      @entry.published.should be_nil
+    end
+  end
+end

data/spec/document_parser_spec.rb

@@ -0,0 +1,156 @@
+require File.join(File.dirname(__FILE__), 'spec_helper')
+
+describe Objectify::DocumentParser do
+  class D < Objectify::DocumentParser
+    def initialize; end
+    public *private_instance_methods.map { |s| s.to_sym }
+  end
+
+  before do
+    @author = Nokogiri::XML('<author><name>Joe</name></author>').child
+  end
+
+  describe 'primary_xml_element' do
+    it 'should call parse_xml' do
+      d = D.new
+      d.expects(:parse_xml).with(@author.child)
+      d.primary_xml_element(@author)
+    end
+  end
+
+  describe 'xml helpers' do
+    before do
+      @title = Nokogiri::XML('<title>Joe</title>').child
+      @isbn = Nokogiri::XML('<entry xmlns:book="http://example.com"><book:isbn>123</book:isbn></entry>').child.child
+      @generator = Nokogiri::XML('<generator type="friendly">Mr. Happy</title>').child
+    end
+
+    describe 'qualified_name' do
+      it 'should return name with just name' do
+        D.new.qualified_name(@author).should == 'author'
+      end
+
+      it 'should return namespace:name with name and namespace' do
+        D.new.qualified_name(@isbn).should == 'book:isbn'
+      end
+    end
+
+    describe 'delegate methods' do
+      it 'attribute_type' do
+        D.expects(:attribute_type).with('title').returns(:result)
+        D.new.attribute_type(@title).should == :result
+      end
+      it 'flatten?' do
+        D.expects(:flatten?).with('title').returns(:result)
+        D.new.flatten?(@title).should == :result
+      end
+      it 'collection?' do
+        D.expects(:collection?).with('title').returns(:result)
+        D.new.collection?(@title).should == :result
+      end
+      it 'attribute' do
+        D.expects(:find_attribute).with('book:isbn', 'book', 'isbn').returns(:result)
+        D.new.attribute(@isbn).should == :result
+      end
+    end
+
+    describe 'namespace?' do
+      it 'should delegate if the element has a namespace' do
+        d = D.new
+        d.class.expects(:namespace?).with('book').returns(:result)
+        d.namespace?(@isbn).should == :result
+      end
+
+      it 'should just return true if no namespace' do
+        d = D.new
+        d.class.expects(:namespace?).never
+        d.namespace?(@title).should be_true
+      end
+    end
+
+    describe 'parse_xml' do
+      it 'should call read_xml_element on each xml sibling node' do
+        xml2 = mock('xml2', :next => nil)
+        xml = mock('xml1', :next => xml2)
+        d = D.new
+        d.expects(:read_xml_element).with(xml)
+        d.expects(:read_xml_element).with(xml2)
+        d.parse_xml(xml)
+      end
+    end
+
+    describe 'read_xml_element' do
+      class FlattenAuthor < D
+        flatten :author
+        attribute :name
+      end
+
+      it 'should skip text elements' do
+        d = D.new
+        d.expects(:set_attribute).never
+        @title.child.should be_an_instance_of(Nokogiri::XML::Text)
+        d.read_xml_element(@title.child)
+      end
+
+      it 'should skip elements in the wrong namespace' do
+        d = D.new
+        d.expects(:set_attribute).never
+        d.read_xml_element(@isbn)
+      end
+
+      it 'should call parse_xml on the first child node of a flattened element' do
+        e = FlattenAuthor.new
+        e.flatten?(@author).should be_true
+        e.expects(:parse_xml).with(@author.child)
+        e.read_xml_element(@author)
+      end
+
+      describe 'with an attribute type' do
+        class HasAuthor < D
+          has_one 'author', Objectify::Atom::Author, 'author'
+        end
+        it 'should set the attribute' do
+          e = HasAuthor.new
+          e.attribute_type(@author).should == Objectify::Atom::Author
+          e.expects(:author=).with(instance_of(Objectify::Atom::Author))
+          e.read_xml_element(@author)
+        end
+      end
+
+      describe 'without an attribute type' do
+        it 'should set the attribute' do
+          e = FlattenAuthor.new
+          e.expects(:xml_text_to_value).with('Joe').returns(43)
+          e.expects(:name=).with(43)
+          e.read_xml_element(@author)
+        end
+      end
+   end
+
+    describe 'set_attribute' do
+      it 'should do nothing if the attribute is not found' do
+        d = D.new
+        d.expects(:attribute).with(:xml).returns(nil)
+        d.set_attribute(:xml) do
+          fail "Shouldn't get here"
+        end
+      end
+      it 'should yield and append the result to a collection' do
+        d = D.new
+        d.expects(:attribute).with(:xml).returns('attr_name')
+        d.expects(:collection?).with(:xml).returns(true)
+        array = []
+        d.expects(:attr_name).returns(array)
+        d.set_attribute(:xml) { :value }
+        array.should == [:value]
+      end
+      it 'should yield and set the result if not a collection' do
+        d = D.new
+        d.expects(:attribute).with(:xml).returns('attr_name')
+        d.expects(:collection?).with(:xml).returns(false)
+        d.expects(:attr_name=).with(:value)
+        d.set_attribute(:xml) { :value }
+      end
+    end
+  end
+end

data/spec/dsl_spec.rb

@@ -0,0 +1,164 @@
+require File.join(File.dirname(__FILE__), 'spec_helper')
+
+describe Objectify::Xml::Dsl do
+  A = Objectify::Atom
+
+  class D < Objectify::DocumentParser
+    def initialize; end
+  end
+
+  class MyAuthor < A::Author
+    attributes :weight
+    attribute 'attr', 'ns:realname'
+    attribute 'attrs', nil, true
+    attribute 'ns_something'
+    flatten :nest
+    namespace 'ns', 'http://example.com'
+    namespaces :blog
+    default_namespace 'http://place.com'
+    has_one :link, 'Objectify::Atom::Link', 'link'
+  end
+
+  it 'should init the metadata' do
+    D.metadata.each do |k, v|
+      v.should_not be_nil
+    end
+  end
+  describe 'inheritance' do
+    it 'should include the parent metadata' do
+      MyAuthor.metadata[:attributes].should include('name')
+    end
+    it 'should include the new metadata' do
+      MyAuthor.metadata[:attributes].should include('weight')
+    end
+    it "should not affect the parent's metadata" do
+      A::Author.metadata[:attributes].should include('name')
+      A::Author.metadata[:attributes].should_not include('weight')
+    end
+  end
+
+  describe 'has_one' do
+    it 'should set the metadata correctly' do
+      A::Feed.metadata[:attributes].should_not include('generator')
+      A::Feed.metadata[:qualified_attributes].should include('generator')
+      A::Feed.metadata[:collections].should_not include('generator')
+      A::Feed.metadata[:types]['generator'].should == A::Generator
+    end
+  end
+
+  describe 'has_many' do
+    it 'should set the metadata correctly' do
+      A::Feed.metadata[:attributes].should_not include('links')
+      A::Feed.metadata[:qualified_attributes].should include('link')
+      A::Feed.metadata[:collections].should include('link')
+      A::Feed.metadata[:types]['link'].to_s.should match(/Link/)
+    end
+  end
+
+  describe 'attributes' do
+    it 'should call attribute for each item' do
+      D.expects(:attribute).with(:one)
+      D.expects(:attribute).with(:two)
+      D.attributes :one, :two
+    end
+  end
+
+  describe 'attribute' do
+    it 'should set up an attribute with namespace' do
+      #attribute 'attr', 'ns:realname'
+      MyAuthor.metadata[:attributes].should_not include('attr')
+      MyAuthor.metadata[:qualified_attributes]['ns:realname'].should == 'attr'
+      MyAuthor.metadata[:collections].should_not include('ns:realname')
+      MyAuthor.metadata[:collections].should_not include('attr')
+      MyAuthor.metadata[:types]['ns:realname'].should be_nil
+      MyAuthor.metadata[:types]['attr'].should be_nil
+      d = MyAuthor.new('')
+      d.attr.should be_nil
+      d.attr = true
+      d.attr.should be_true
+    end
+    it 'should set up a collection attribute' do
+      #attribute 'attr2', nil, true
+      MyAuthor.metadata[:attributes].should include('attrs')
+      MyAuthor.metadata[:qualified_attributes].keys.should_not include('attrs')
+      MyAuthor.metadata[:qualified_attributes].values.should_not include('attrs')
+      MyAuthor.metadata[:collections].should include('attrs')
+      MyAuthor.metadata[:types]['attr'].should be_nil
+      d = MyAuthor.new('')
+      d.attrs.should == []
+      d.attrs = [:something]
+      d.attrs.should == [:something]
+    end
+  end
+
+  describe 'find_attribute' do
+    it 'should find the attribute with namespace' do
+      MyAuthor.find_attribute('ns:realname', 'ns', 'realname').should == 'attr'
+    end
+    it 'should find the attribute' do
+      MyAuthor.find_attribute('attrs', nil, 'attrs').should == 'attrs'
+    end
+    it 'should pluralize and find the attribute' do
+      A::Entry.find_attribute('link', nil, 'link').should == 'links'
+    end
+    it 'should not find attr with a wrong namespace' do
+      MyAuthor.find_attribute('attr', nil, 'attr').should be_nil
+    end
+    it 'should find the attribute with implicit namespaced name' do
+      MyAuthor.find_attribute('ns:something', 'ns', 'something').should == 'ns_something'
+    end
+  end
+
+  describe 'flatten' do
+    it 'should set the metadata' do
+      MyAuthor.metadata[:flatten].should include('nest')
+    end
+  end
+
+  describe 'flatten?' do
+    it 'should work' do
+      MyAuthor.flatten?('nest').should be_true
+      MyAuthor.flatten?('attr').should be_false
+    end
+  end
+
+  describe 'namespace, namespaces and default_namespace' do
+    it 'should define the namespaces' do
+      MyAuthor.metadata[:namespaces].keys.should include('ns')
+      MyAuthor.metadata[:namespaces].keys.should include('blog')
+      MyAuthor.metadata[:namespaces].keys.should include('')
+    end
+  end
+
+  describe 'find_namespace' do
+    it 'should find a namespace' do
+      MyAuthor.find_namespace('blog').should be_nil
+      MyAuthor.find_namespace.should == 'http://place.com'
+      MyAuthor.find_namespace('').should == 'http://place.com'
+      MyAuthor.find_namespace('ns').should == 'http://example.com'
+    end
+  end
+
+  describe 'attribute_type' do
+    it 'should parse a symbol type definition in module scope' do
+      A::Feed.attribute_type('link').should == A::Link
+    end
+    it 'should parse a string type definition' do
+      MyAuthor.attribute_type('link').should == A::Link
+    end
+  end
+
+  describe 'set_type' do
+    it 'should work' do
+      MyAuthor.metadata[:types]['link'].to_s.should == 'Objectify::Atom::Link' 
+    end
+  end
+
+  describe 'collection?' do
+    it 'should work' do
+      MyAuthor.collection?('ns:realname').should be_false
+      MyAuthor.collection?('attr').should be_false
+      MyAuthor.collection?('attrs').should be_true
+    end
+  end
+end

data/spec/element_parser_spec.rb

@@ -0,0 +1,38 @@
+require File.join(File.dirname(__FILE__), 'spec_helper')
+
+describe Objectify::ElementParser do
+  class TestElement < Objectify::ElementParser
+    attr_accessor :attr
+
+    def initialize(*args)
+      yield self if block_given?
+      super
+    end
+  end
+
+  class TestBodyElement < Objectify::ElementParser
+    attr_accessor :attr, :inner_html, :inner_text
+  end
+
+  describe 'primary_xml_element' do
+    before do
+      @xml = Nokogiri::XML('<element attr="value" attr2="value2"><div>body</div></element>').child
+    end
+    it 'should call xml_text_to_value for defined attributes only' do
+      TestElement.new(@xml) do |te|
+        te.expects(:xml_text_to_value).with('value')
+        te.expects(:xml_text_to_value).with('value2').never
+      end
+    end
+    it 'should set inner_html and inner_text if the methods are defined' do
+      e = TestBodyElement.new(@xml)
+      e.inner_html.should == '<div>body</div>'
+      e.inner_text.should == 'body'
+    end
+    it 'should not set inner_html and inner_text if the methods are not defined' do
+      @xml.expects(:inner_html).never
+      @xml.expects(:inner_text).never
+      e = TestElement.new(@xml)
+    end
+  end
+end

data/spec/objectify_xml_spec.rb

@@ -0,0 +1,81 @@
+require File.join(File.dirname(__FILE__), 'spec_helper')
+
+describe Objectify::Xml do
+  class Xml < Objectify::Xml
+    def initialize(*args)
+      yield self if block_given?
+      super
+    end
+    public :xml_text_to_value
+  end
+
+  describe 'initialize' do
+    describe 'with nil' do
+      it 'should handle nil string' do
+        Xml.new(nil) do |x|
+          x.expects(:primary_xml_element).never
+        end
+      end
+      it 'should assign the parent' do
+        x = Xml.new(nil, :parent)
+        x.parent.should == :parent
+      end
+      it 'should initialize the attributes' do
+        x = Xml.new(nil)
+        x.attributes.should == {}
+      end
+    end
+
+    describe 'with multiple nodes before the first element' do
+      it 'should call parse_xml with the first element' do
+        xml_string = <<-exml
+<?xml version="1.0"?>
+<?xml-stylesheet type="text/css" href="http://en.wikipedia.org/skins-1.5/common/feed.css?206xx"?>
+<feed xmlns="http://www.w3.org/2005/Atom" xml:lang="en"></feed>
+        exml
+        xml = Nokogiri::XML(xml_string).child.next
+        x = Xml.new(xml_string) do |x|
+          def x.primary_xml_element(xml)
+            xml.name.should == 'feed'
+            @parent = :called
+          end
+        end
+        x.parent.should == :called
+      end
+    end
+
+    describe 'with ""' do
+      it 'should not call primary_xml_element' do
+        Xml.new('') do |x|
+          x.expects(:primary_xml_element).never
+        end
+      end
+    end
+    describe 'with valid xml' do
+      it 'should call primary_xml_element with a Nokogiri XML object' do
+        Xml.new('<foo><bar>no</bar></foo>') do |x|
+          x.expects(:primary_xml_element)
+        end
+      end
+    end
+  end
+
+  describe 'inspect' do
+    it 'should work' do
+      f = Objectify::Atom::Feed.new(sample_feed('wikipedia.atom'))
+      f.inspect.should == '<Objectify::Atom::Feed title, id, subtitle, links:2, generator:Objectify::Atom::Generator, entries:50, updated>'
+    end
+  end
+
+  describe 'xml_text_to_value' do
+    it('should cast true') { Xml.new('').xml_text_to_value('true').should == true }
+    it('should cast false') { Xml.new('').xml_text_to_value('false').should == false }
+    it('should cast integer') { Xml.new('').xml_text_to_value('12').should == 12 }
+    it('should cast float') { Xml.new('').xml_text_to_value('3.5').should == 3.5 }
+    it('should cast date1') { Xml.new('').xml_text_to_value('2009-02-01T11:32:11.03Z').should be_an_instance_of(DateTime) }
+    it('should cast date2') { Xml.new('').xml_text_to_value('2009-02-01T11:32:11+400Z').should be_an_instance_of(DateTime) }
+    it('should cast date3') { Xml.new('').xml_text_to_value('2009-02-01T11:32:11').should be_an_instance_of(DateTime) }
+    it('should cast date4') { Xml.new('').xml_text_to_value('2009-02-01').should be_an_instance_of(DateTime) }
+    it('should not cast anything else') { Xml.new('').xml_text_to_value('anything').should == 'anything' }
+  end
+end