xommelier 0.0.1 → 0.0.2

data/lib/xommelier/xml/element/structure.rb

@@ -0,0 +1,236 @@
+require 'xommelier/xml/element'
+require 'active_support/core_ext/module/delegation'
+require 'active_support/core_ext/object/with_options'
+require 'active_support/core_ext/string/inflections'
+require 'active_support/inflections'
+
+module Xommelier
+  module Xml
+    class Element
+      module Structure
+        extend ActiveSupport::Concern
+
+        included do
+          class_attribute :elements, :attributes
+          attr_writer :element_name
+
+          self.elements = {}
+          self.attributes = {}
+
+          class << self
+            include SingletonClassMethods
+          end
+
+          delegate :xmlns, to: 'self.class'
+        end
+
+        module SingletonClassMethods
+          def containing_module
+            @containing_module ||= ("::#{name.gsub(/::[^:]+$/, '')}").constantize
+          end
+
+          def xmlns(value = nil)
+            if value
+              @xmlns = case value
+                       when Module
+                         value.xmlns
+                       else
+                         value
+                       end
+            end
+            @xmlns ||= find_namespace
+          end
+          alias_method :xmlns=, :xmlns
+
+          def element_name(element_name = nil)
+            @element_name = element_name if element_name
+            @element_name ||= find_element_name
+          end
+
+          private
+
+          def find_namespace
+            if self == containing_module
+              Xommelier::Xml::DEFAULT_NS
+            else
+              containing_module.xmlns
+            end
+          end
+
+          def find_element_name
+            name.demodulize.underscore.dasherize
+          end
+        end
+
+        module ClassMethods
+          def inherited(child)
+            child.elements    = elements.dup
+            child.attributes  = attributes.dup
+          end
+
+          # Defines containing element
+          # @example
+          #   element :author, class_name: 'Xommelier::Atom::Person'
+          def element(name, options = {})
+            options[:element_name] = name
+            elements[name] = DEFAULT_ELEMENT_OPTIONS.merge(options)
+            define_element_accessors(name)
+          end
+
+          # Defines containing attribute
+          def attribute(name, options = {})
+            attributes[name] = DEFAULT_OPTIONS.merge(options)
+            define_attribute_accessors(name)
+          end
+
+          # Defines containing text
+          def text(options = {})
+            define_text_accessors
+          end
+
+          def any(&block)
+            with_options(count: :any)  { |any| any.instance_eval(&block) }
+          end
+
+          def many(&block)
+            with_options(count: :many) { |many| many.instance_eval(&block) }
+          end
+
+          def may(&block)
+            with_options(count: :may) { |may| may.instance_eval(&block) }
+          end
+
+          def root; end
+
+          private
+
+          def define_element_accessors(name)
+            element_options = elements[name]
+            case element_options[:count]
+            when :one, :may
+              name = name.to_sym
+              define_method(name) do |*args|
+                if args[0]
+                  write_element(name, args[0])
+                end
+                read_element(name)
+              end
+              alias_method "#{name}=", name
+            when :many, :any
+              plural = name.to_s.pluralize.to_sym
+              element_options[:plural] = plural
+
+              define_method(plural) do |*args|
+                if args.any?
+                  @elements[name] = args.flatten
+                end
+                @elements[name] ||= []
+              end
+              alias_method "#{plural}=", plural
+
+              unless plural == name
+                define_method(name) do |*args|
+                  if args[0]
+                    send(plural, [args[0]])
+                  else
+                    send(plural)[0]
+                  end
+                end
+                alias_method "#{name}=", name
+              end
+            end
+          end
+
+          protected
+
+          def define_attribute_accessors(name)
+            define_method(name) do |*args|
+              if args[0]
+                write_attribute(name.to_s, args[0])
+              end
+              read_attribute(name)
+            end
+            alias_method "#{name}=", name
+          end
+
+          def define_text_accessors
+            define_method(:text) do |*args|
+              if args[0]
+                write_text(args[0])
+              end
+              read_text
+            end
+            alias_method :text=, :text
+          end
+        end
+
+        protected
+
+        def element_name(value = nil)
+          if value
+            @element_name = value
+          end
+          @element_name ||= self.class.element_name
+        end
+
+        def element_options(name)
+          self.class.elements[name.to_sym]
+        end
+
+        def read_element(name)
+          @elements[name.to_sym]
+        end
+
+        def write_element(name, value)
+          type = element_options(name)[:type]
+          unless value.is_a?(type)
+            value = if (type < Xommelier::Xml::Element) && !value.is_a?(Nokogiri::XML::Node)
+                      type.new(value)
+                    else
+                      type.from_xommelier(value)
+                    end
+          end
+          @elements[name.to_sym] = value
+        end
+
+        def remove_element(name)
+          @elements.delete(name.to_sym)
+        end
+
+        def attribute_options(name)
+          self.class.attributes[name.to_sym]
+        end
+
+        def read_attribute(name)
+          @attributes[name.to_sym]
+        end
+
+        def write_attribute(name, value)
+          type = attribute_options(name)[:type]
+          value = type.from_xommelier(value) unless value.is_a?(type)
+          @attributes[name.to_sym] = value
+        end
+
+        def remove_attribute(name)
+          @attributes.delete(name.to_sym)
+        end
+
+        def text?
+          respond_to?(:text)
+        end
+
+        def read_text
+          @text
+        end
+
+        def write_text(text)
+          @text = text
+        end
+
+        def remove_text
+          @text = nil
+        end
+      end
+    end
+  end
+end

data/lib/xommelier/xml/element.rb

@@ -1,6 +1,6 @@
 require 'xommelier/xml'
-require 'xommelier/xml/element/dsl'
-require 'nokogiri'
+require 'xommelier/xml/element/structure'
+require 'xommelier/xml/element/serialization'
 require 'active_support/core_ext/string/inflections'
 require 'active_support/core_ext/array/extract_options'
 require 'active_support/core_ext/class/attribute'
@@ -15,48 +15,13 @@ module Xommelier
     )
 
     class Element
-      extend Xommelier::Xml::Element::DSL
+      include Xommelier::Xml::Element::Structure
+      include Xommelier::Xml::Element::Serialization
 
-      class_attribute :elements, :attributes
-      self.elements = {}
-      self.attributes = {}
-
-      class << self
-        def xmlns(value = nil)
-          if value
-            @xmlns = case ns
-                     when Module
-                       ns.xmlns
-                     else
-                       ns
-                     end
-          end
-          @xmlns ||= find_namespace
-        end
-        alias xmlns= xmlns
-
-        def element_name(element_name = nil)
-          @element_name = element_name if element_name
-          @element_name ||= find_element_name
-        end
-
-        private
-
-        def containing_module
-          @containing_module ||= ("::#{name.gsub(/::[^:]+$/, '')}").constantize
-        end
-
-        def find_namespace
-          containing_module.xmlns
-        end
-
-        def find_element_name
-          name.demodulize.tableize.dasherize
-        end
-      end
+      attr_reader :options
 
       def initialize(contents = {}, options = {})
-        @options = DEFAULT_OPTIONS.merge(options)
+        self.options = options
 
         @elements = {}
         @attributes = {}
@@ -72,70 +37,35 @@ module Xommelier
         end
       end
 
-      def to_xml(options = {})
-        element_name = options.delete(:element_name) { self.element_name }
-        if options[:builder] # Non-root element
-          builder = options.delete(:builder)
-          attribute_values = {}
-        else # Root element
-          builder = Nokogiri::XML::Builder.new(options)
-          attribute_values = {xmlns: xmlns.to_s}
-        end
-        attributes.each do |name, value|
-          serialize_attribute(name, value, attribute_values)
-        end
-        builder.send(element_name, attribute_values) do |xml|
-          if respond_to?(:text)
-            xml.text @text
-          else
-            elements.each do |name, value|
-              serialize_element(name, value, xml)
-            end
-          end
+      def options=(options = {})
+        @options = options
+        @options.delete(:type)
+
+        if @options.key?(:element_name)
+          element_name(@options.delete(:element_name))
         end
-        builder.to_xml
       end
 
-      protected
-
-      def element_options(name)
-        self.class.elements[name]
+      def inspect
+        %(#<#{self.class.name}:0x#{object_id.to_s(16)} #{inspect_contents}>)
       end
 
-      def attribute_options(name)
-        self.class.attributes[name]
-      end
+      private
 
-      def element_name
-        self.class.element_name
+      def inspect_contents
+        [inspect_attributes, inspect_elements, inspect_text].compact.join(' ')
       end
 
-      def xmlns
-        self.class.xmlns
+      def inspect_attributes
+        "@attributes={#{@attributes.map { |name, value| "#{name}: #{value.inspect}"}.join(', ')}}" if @attributes.any?
       end
 
-      def serialize_attribute(name, value, attributes)
-        attribute_options = self.attribute_options(name)
-        attribute_class = attribute_options[:type]
-        value = attribute_class.new(value) unless value.is_a?(attribute_class)
-        attributes[name] = value.to_xommelier
+      def inspect_elements
+        "#{@elements.map { |name, value| "@#{name}=#{value.inspect}"}.join(' ')}" if @elements.any?
       end
 
-      def serialize_element(name, value, xml, element_options = nil)
-        element_options ||= self.element_options(name)
-        if element_options[:count] == :many
-          single_element = element_options.merge(count: :one)
-          value.each { |item| serialize_element(name, item, xml, single_element) }
-        else
-          element_class = element_options[:type]
-          value = element_class.new(value) unless value.is_a?(element_class)
-          case value
-          when Xommelier::Xml::Element
-            value.to_xml(builder: xml, element_name: name)
-          else
-            xml.send(name) { xml.text value.to_xommelier }
-          end
-        end
+      def inspect_text
+        text.inspect if text?
       end
     end
   end

data/lib/xommelier/xml/namespace.rb

@@ -17,7 +17,6 @@ module Xommelier
         @uri        = uri
         @options    = {}
         @elements   = Xommelier::Collection.new(Xommelier::Xml::Element)
-        @attributes = Xommelier::Collection.new(Xommelier::Xml::Attribute)
         @as         = options.delete(:as)
 
         Xommelier::Xml::Namespace.registry[as] = self

data/lib/xommelier/xml.rb

@@ -6,7 +6,7 @@ module Xommelier
   module Xml
     extend ActiveSupport::Concern
 
-    Infinity = 1.0 / 0
+    DEFAULT_NS = 'http://www.w3.org/XML/1998/namespace'
 
     included do
       instance_variable_set :@_xmlns, nil
@@ -14,6 +14,5 @@ module Xommelier
 
     autoload :Namespace,  'xommelier/xml/namespace'
     autoload :Element,    'xommelier/xml/element'
-    autoload :Attribute,  'xommelier/xml/attribute'
   end
 end

data/spec/fixtures/feed.atom

@@ -0,0 +1,39 @@
+<?xml version="1.0" encoding="utf-8"?>
+<feed xmlns="http://www.w3.org/2005/Atom">
+  <id>urn:uuid:60a76c80-d399-11d9-b93C-0003939e0af6</id>
+  <title type="text">Example Feed</title>
+  <updated>2003-12-13T18:30:02Z</updated>
+  <subtitle type="html">A &lt;em&gt;lot&lt;/em&gt; of effort went into making this effortless</subtitle>
+  <link rel="alternate" type="text/html" href="http://example.ru/" />
+  <link rel="self" type="application/atom+xml" href="http://example.ru/feed.atom" />
+  <rights>© Mark Pilgrim, 2003</rights>
+  <generator uri="http://example.com/" version="1.0">Example Toolkit</generator>
+  <author>
+    <name>John Doe</name>
+  </author>
+  <entry>
+    <id>urn:uuid:1225c695-cfb8-4ebb-aaaa-80da344efa6a</id>
+    <title type="text">Atom-Powered Robots Run Amok</title>
+    <updated>2003-12-13T18:30:02Z</updated>
+    <published>2003-12-13T08:29:29-04:00</published>
+    <link rel="alternate" type="text/html" href="http://example.ru/2003/12/13/atom03"/>
+    <link rel="enclosure" type="audio/mpeg" href="http://example.org/audio/ph34r_my_podcast.mp3" length="1337"/>
+    <author>
+      <name>Mark Pilgrim</name>
+      <uri>http://example.org/</uri>
+      <email>f8dy@example.com</email>
+    </author>
+    <contributor>
+      <name>Sam Ruby</name>
+    </contributor>
+    <contributor>
+      <name>Joe Gregorio</name>
+    </contributor>
+    <summary>Some text.</summary>
+    <content type="xhtml" xml:lang="en" xml:base="http://diveintomark.org/">
+      <div xmlns="http://www.w3.org/1999/xhtml">
+        <p><i>[Update: The Atom draft is finished.]</i></p>
+      </div>
+    </content>
+  </entry>
+</feed>

data/spec/fixtures/simple_feed.atom

@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="utf-8"?>
+<feed xmlns="http://www.w3.org/2005/Atom">
+  <id>urn:uuid:60a76c80-d399-11d9-b93C-0003939e0af6</id>
+  <title>Example Feed</title>
+  <link href="http://example.org/"/>
+  <updated>2003-12-13T18:30:02Z</updated>
+  <author>
+    <name>John Doe</name>
+  </author>
+  <entry>
+    <title>Atom-Powered Robots Run Amok</title>
+    <link href="http://example.org/2003/12/13/atom03"/>
+    <id>urn:uuid:1225c695-cfb8-4ebb-aaaa-80da344efa6a</id>
+    <updated>2003-12-13T18:30:02Z</updated>
+    <summary>Some text.</summary>
+  </entry>
+</feed>

data/spec/lib/xommelier/atom/entry_spec.rb

@@ -0,0 +1,18 @@
+require 'spec_helper'
+
+describe Xommelier::Atom::Entry do
+  describe 'instance' do
+    subject { Xommelier::Atom::Entry.new }
+
+    [:id, :title, :updated].each do |must_field|
+      it { should respond_to(must_field) }
+    end
+    [:content, :published, :rights, :source, :summary].each do |may_field|
+      it { should respond_to(may_field) }
+    end
+    %w(author category contributor link).each do |any_field|
+      it { should respond_to(any_field) }
+      it('have plural methods for embedded collections') { should respond_to(any_field.pluralize) }
+    end
+  end
+end

data/spec/lib/xommelier/xml/element/serialization_spec.rb

@@ -0,0 +1,36 @@
+require 'spec_helper'
+
+describe Xommelier::Xml::Element::Serialization do
+  describe 'class' do
+    subject { Xommelier::Atom::Feed }
+
+    it { should respond_to(:parse) }
+  end
+
+  describe 'parsing simple_feed' do
+    let(:feed) { @feed = Xommelier::Atom::Feed.parse(open(File.join(SPEC_ROOT, 'spec', 'fixtures', 'simple_feed.atom'))) }
+
+    it { feed.id.should == 'urn:uuid:60a76c80-d399-11d9-b93C-0003939e0af6' }
+    it { feed.title.should == 'Example Feed' }
+    it { feed.link.href.should == URI.parse('http://example.org/') }
+    it { feed.updated.should == Time.utc(2003, 12, 13, 18, 30, 02) }
+    it { feed.should have(1).authors }
+    it { feed.author.name.should == 'John Doe' }
+    it { feed.should have(1).entries }
+    it { feed.entry.title.should == 'Atom-Powered Robots Run Amok' }
+    it { feed.entry.link.href.should == URI.parse('http://example.org/2003/12/13/atom03') }
+    it { feed.entry.id.should == 'urn:uuid:1225c695-cfb8-4ebb-aaaa-80da344efa6a' }
+    it { feed.entry.updated.should == Time.utc(2003, 12, 13, 18, 30, 02) }
+    it { feed.entry.summary.should == 'Some text.' }
+  end
+
+  describe 'parsing feed' do
+    let(:feed) { Xommelier::Atom::Feed.parse(open(File.join(SPEC_ROOT, 'spec', 'fixtures', 'feed.atom'))) }
+
+    it { feed.should have(2).links }
+    it { feed.subtitle.should == 'A <em>lot</em> of effort went into making this effortless' }
+    it { feed.entry.should have(2).links }
+    it { feed.entry.should have(1).authors }
+    it { feed.entry.should have(2).contributors }
+  end
+end

data/spec/lib/xommelier/xml/element/structure_spec.rb

@@ -0,0 +1,27 @@
+require 'spec_helper'
+
+describe Xommelier::Xml::Element::Structure do
+  subject { NamespacedModule::RootWithSimpleSubelement }
+
+  it { should respond_to(:elements) }
+  it { should respond_to(:element) }
+  it 'defines subelement' do
+    NamespacedModule::RootWithSimpleSubelement.elements.should have_key(:some)
+  end
+
+  it { should respond_to(:attributes) }
+  it { should respond_to(:attribute) }
+  it 'defines attribute' do
+    NamespacedModule::RootWithAttribute.attributes.should have_key(:another)
+  end
+
+  it { should respond_to(:text) }
+  it 'defines as containing text' do
+    NamespacedModule::RootWithText.new.should respond_to(:text)
+  end
+
+  it { should respond_to(:xmlns) }
+  it { NamespacedModule::RootWithText.xmlns.uri.should == 'http://example.org/'}
+  it { NamespacedModule::RootWithAttribute.xmlns.uri.should == 'http://example.org/'}
+  it { Xommelier::Atom::Feed.xmlns.uri.should == 'http://www.w3.org/2005/Atom'}
+end

data/spec/lib/xommelier/xml/element_spec.rb

@@ -2,67 +2,46 @@ require 'spec_helper'
 
 describe Xommelier::Xml::Element do
   describe 'class' do
-    subject { NamespacedModule::EmptyRoot }
+    subject { Xommelier::Atom::Link }
 
     it { should respond_to(:xmlns) }
-    it { subject.xmlns.to_s.should == 'http://example.org/' }
+    it { subject.xmlns.to_s.should == ATOM_XMLNS }
 
     it { should respond_to(:element_name) }
-    it { subject.element_name.should == 'empty-root' }
-
-    it { should respond_to(:elements) }
-    it { should respond_to(:attributes) }
-  end
-
-  describe 'DSL' do
-    subject { NamespacedModule::RootWithSimpleSubelement }
-
-    it { should respond_to(:element) }
-    it 'defines subelement' do
-      NamespacedModule::RootWithSimpleSubelement.elements.should have_key(:some)
-    end
-
-    it { should respond_to(:attribute) }
-    it 'defines attribute' do
-      NamespacedModule::RootWithAttribute.attributes.should have_key(:another)
-    end
-
-    it { should respond_to(:text) }
-    it 'defines as containing text' do
-      NamespacedModule::RootWithText.new.should respond_to(:text)
-    end
+    it { subject.element_name.should == 'link' }
   end
 
   describe 'instance' do
-    subject { NamespacedModule::EmptyRoot.new }
+    subject { Xommelier::Atom::Link.new }
 
     it { should respond_to(:to_xml) }
-    it { subject.to_xml.should == %(<?xml version="1.0"?>\n<empty-root xmlns="http://example.org/"/>\n) }
+    it { subject.to_xml.should == %(<?xml version="1.0" encoding="utf-8"?>\n<link xmlns="#{ATOM_XMLNS}"/>\n) }
 
     describe 'with text' do
       subject { NamespacedModule::RootWithText.new('Text') }
 
       it { should respond_to(:text) }
       it { subject.text.should == 'Text' }
-      it { subject.to_xml.should == %(<?xml version="1.0"?>\n<root-with-text xmlns="http://example.org/">Text</root-with-text>\n) }
+      it { subject.to_xml.should == %(<?xml version="1.0" encoding="utf-8"?>\n<root-with-text xmlns="http://example.org/">Text</root-with-text>\n) }
     end
 
     describe 'with simple subelements' do
-      subject { NamespacedModule::RootWithSimpleSubelement.new(some: 'Text') }
+      subject { Xommelier::Atom::Person.new(name: 'Ivan') }
 
-      it { should respond_to(:some) }
-      it { subject.some.should == 'Text' }
-      it { subject.to_xml.should == %(<?xml version="1.0"?>\n<root-with-simple-subelement xmlns="http://example.org/">\n  <some>Text</some>\n</root-with-simple-subelement>\n) }
+      it { should respond_to(:name) }
+      it { subject.name.should == 'Ivan' }
+      it { subject.to_xml.should == %(<?xml version="1.0" encoding="utf-8"?>\n<person xmlns="#{ATOM_XMLNS}">\n  <name>Ivan</name>\n</person>\n) }
     end
 
     describe 'with many simple subelements' do
       subject do
-        NamespacedModule::RootWithManySimpleSubelements.new(foo: ['bar', 'baz'])
+        NamespacedModule::RootWithManySimpleSubelements.new(foos: ['bar', 'baz'])
       end
 
       it { should respond_to(:foo) }
-      it { subject.foo.should == ['bar', 'baz'] }
-      it { subject.to_xml.should == %(<?xml version="1.0"?>\n<root-with-many-simple-subelements xmlns="http://example.org/">\n  <foo>bar</foo>\n  <foo>baz</foo>\n</root-with-many-simple-subelements>\n) }
+      it { subject.foos.should == ['bar', 'baz'] }
+      it { subject.foo.should == 'bar' }
+      it { subject.to_xml.should == %(<?xml version="1.0" encoding="utf-8"?>\n<root-with-many-simple-subelements xmlns="http://example.org/">\n  <foo>bar</foo>\n  <foo>baz</foo>\n</root-with-many-simple-subelements>\n) }
     end
 
     describe 'with attribute' do
@@ -70,7 +49,7 @@ describe Xommelier::Xml::Element do
 
       it { should respond_to(:another) }
       it { subject.another.should == 'Difference' }
-      it { subject.to_xml.should == %(<?xml version="1.0"?>\n<root-with-attribute xmlns="http://example.org/" another="Difference"/>\n) }
+      it { subject.to_xml.should == %(<?xml version="1.0" encoding="utf-8"?>\n<root-with-attribute xmlns="http://example.org/" another="Difference"/>\n) }
     end
 
     describe 'with subelements' do
@@ -84,8 +63,12 @@ describe Xommelier::Xml::Element do
       end
 
       it { should respond_to(:one) }
-      it { subject.another.should == {some: 'Text'} }
-      it { subject.to_xml.should == %(<?xml version="1.0"?>\n<root-with-subelement xmlns="http://example.org/" one="2011-08-15" two="2">\n  <some>Text</some>\n  <another>\n    <some>Text</some>\n  </another>\n</root-with-subelement>\n) }
+      it { should respond_to(:two) }
+      it { should respond_to(:some) }
+      it { should respond_to(:another) }
+      it { subject.another.class.should == NamespacedModule::RootWithSimpleSubelement }
+      it { subject.another.some.should == 'Text' }
+      it { subject.to_xml.should == %(<?xml version="1.0" encoding="utf-8"?>\n<root-with-subelement xmlns="http://example.org/" one="2011-08-15" two="2">\n  <some>Text</some>\n  <another>\n    <some>Text</some>\n  </another>\n</root-with-subelement>\n) }
     end
   end
 end

data/spec/lib/xommelier/xml_spec.rb

@@ -3,9 +3,7 @@ require 'spec_helper'
 describe Xommelier::Xml do
 end
 
-describe NamespacedModule do
-  subject { NamespacedModule }
-
+describe Xommelier::Atom do
   it { should respond_to(:xmlns) }
-  it { subject.xmlns.to_s.should == 'http://example.org/' }
+  it { subject.xmlns.to_s.should == ATOM_XMLNS }
 end

data/spec/lib/xommelier_spec.rb

@@ -1,5 +1,5 @@
 require 'spec_helper'
 
 describe Xommelier do
-  it { Xommelier::VERSION.should == '0.0.1' }
+  it { Xommelier::VERSION.should == '0.0.2' }
 end