xommelier 0.1.16 → 0.1.18

data/lib/xommelier/version.rb

@@ -1,3 +1,3 @@
 module Xommelier
-  VERSION = '0.1.16'
+  VERSION = '0.1.18'
 end

data/lib/xommelier/xml.rb

@@ -20,7 +20,7 @@ module Xommelier
           options[:module] ||= self
           instance_variable_set(:@_xmlns, Xommelier::Xml::Namespace.new(uri, options, &block))
         end
-        instance_variable_get(:@_xmlns)
+        instance_variable_get(:@_xmlns) || Xml.xmlns
       end
 
       def schema(schema = nil)

data/lib/xommelier/xml/element.rb

@@ -7,13 +7,6 @@ require 'active_support/core_ext/class/attribute'
 
 module Xommelier
   module Xml
-    DEFAULT_OPTIONS = {
-      type: String
-    }
-    DEFAULT_ELEMENT_OPTIONS = DEFAULT_OPTIONS.merge(
-      count: :one
-    )
-
     class Element
       include Xommelier::Xml::Element::Structure
       include Xommelier::Xml::Element::Serialization
@@ -28,13 +21,7 @@ module Xommelier
         @text = nil
         @errors = []
 
-        self.class.attributes.each do |name, options|
-          send("#{name}=", options[:default]) if options.key?(:default)
-        end
-
-        self.class.elements.each do |name, options|
-          send("#{name}=", options[:default]) if options.key?(:default)
-        end
+        set_default_values
 
         case contents
         when Hash
@@ -68,10 +55,12 @@ module Xommelier
       def validate
         @errors = []
         to_xml unless xml_document
-        if xmlns.schema
-          xmlns.schema.validate(xml_document).each do |error|
+        if schema
+          schema.validate(xml_document).each do |error|
             @errors << error
           end
+        else
+          raise NoSchemaError.new(self)
         end
       end
 

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

@@ -26,13 +26,13 @@ module Xommelier
             [ns, element].compact.join(':')
           end
 
-          def element_xpath(xmldoc = nil, name = nil)
-            ns_element(xmlns_xpath(xmldoc), name || element_name)
+          def element_xpath(xml_doc = nil, name = nil)
+            ns_element(xmlns_xpath(xml_doc), name || element_name)
           end
 
-          def xmlns_xpath(xml_document = nil)
-            if xml_document
-              prefix = xml_document.namespaces.key(xmlns.try(:uri))
+          def xmlns_xpath(xml_doc = nil)
+            if xml_doc
+              prefix = xml_doc.namespaces.key(xmlns.try(:uri))
               (prefix =~ /:/) ? prefix[6..-1] : prefix
             else
               xmlns.as
@@ -41,8 +41,7 @@ module Xommelier
         end
 
         def from_xml(xml, options = {})
-          case xml
-          when IO, String
+          if IO === xml || String === xml
             xml = Nokogiri::XML(xml)
           end
           @_xml_node = options.delete(:node) { xml.at_xpath(element_xpath(xml.document, element_name)) }
@@ -52,12 +51,12 @@ module Xommelier
             self.text = @_xml_node.inner_html
           end
 
-          self.class.attributes.each do |name, options|
-            deserialize_attribute(name, options)
+          self.class.attributes.values.each do |attribute|
+            deserialize_attribute(attribute)
           end
 
-          self.class.elements.each do |name, options|
-            deserialize_element(name, options)
+          self.class.elements.values.each do |element|
+            deserialize_element(element)
           end
         end
         alias_method :from_xommelier, :from_xml
@@ -72,7 +71,7 @@ module Xommelier
             builder = options.delete(:builder)
             attribute_values = {}
             namespaces = builder.doc.namespaces
-            prefix = options[:prefix] || builder.doc.namespaces.key(xmlns.uri)[6..-1].presence
+            prefix = options[:prefix] || namespaces.key(xmlns.uri).try(:[], 6..-1).presence
           else # Root element
             builder = Nokogiri::XML::Builder.new(options)
             attribute_values = children_namespaces.inject({xmlns: xmlns.uri}) do |hash, ns|
@@ -86,25 +85,26 @@ module Xommelier
           end
           current_xmlns = builder.doc.namespaces[prefix ? "xmlns:#{prefix}" : 'xmlns']
           attributes.each do |name, value|
-            attribute_options = attribute_options(name)
-            attribute_name = attribute_options[:attribute_name]
-            ns = attribute_options[:ns]
+            attribute = attribute_options(name)
+            attribute_name = attribute.attribute_name
+            ns = attribute.ns
             if ns.uri != current_xmlns
               if ns.as == :xml
-                attribute_name = "xml:#{attribute_options[:attribute_name]}"
-              elsif attr_prefix = namespaces.key(ns.uri).try(:[], 6..-1).presence
-                attribute_name = "#{attr_prefix}:#{attribute_options[:attribute_name]}"
+                attribute_name = "xml:#{attribute_name}"
+              elsif (attr_prefix = namespaces.key(ns.uri).try(:[], 6..-1).presence)
+                attribute_name = "#{attr_prefix}:#{attribute_name}"
               end
             end
             serialize_attribute(attribute_name, value, attribute_values)
           end
           @_xml_node = (prefix ? builder[prefix] : builder).
               send(element_name, attribute_values) do |xml|
-            self.class.elements.each do |name, element_options|
+            self.class.elements.each do |name, element|
               value = elements.fetch(name, options[:default])
               if value
-                serialize_element(name, value, xml,
-                                  element_options.merge(overriden_xmlns: xmlns))
+                element.override(xmlns: xmlns) do
+                  serialize_element(name, value, xml, element)
+                end
               end
             end
             xml.text(@text) if respond_to?(:text)
@@ -117,7 +117,7 @@ module Xommelier
           attributes.dup.tap do |hash|
             @elements.each do |name, value|
               options = element_options(name)
-              type = options[:type]
+              type = options.type
               value = Array.wrap(value)
               if type < Xml::Element
                 value = value.map(&:to_hash)
@@ -168,16 +168,16 @@ module Xommelier
 
         delegate :ns_element, to: 'self.class'
 
-        def element_xpath(xmldoc = self.xml_document, name = nil)
-          self.class.element_xpath(xmldoc, name)
+        def element_xpath(xml_doc = self.xml_document, name = nil)
+          self.class.element_xpath(xml_doc, name)
         end
 
         def children_namespaces(namespaces = Set[xmlns])
           elements.inject(namespaces) do |result, (name, children)|
-            element_options = self.class.elements[name]
-            result << element_options[:ns]
-            result += attributes.keys.map { |name| attribute_options(name)[:ns] }
-            if element_options[:type] < Xml::Element
+            element = self.class.elements[name]
+            result << element.ns
+            result += attributes.keys.map { |attr_name| attribute_options(attr_name).ns }
+            if element.type < Xml::Element
               Array(children).each do |child|
                 result += child.children_namespaces
               end
@@ -198,60 +198,67 @@ module Xommelier
           attributes[name] = value.to_xommelier
         end
 
-        def deserialize_attribute(name, options = nil)
-          options ||= self.element_options(name)
-          ns = options[:ns]
+        # @param [Xommelier::Xml::Element::Structure::Attribute] attribute
+        def deserialize_attribute(attribute)
+          ns = attribute.ns
           if ns.default? || ns == xmlns
-            send(name, @_xml_node[options[:attribute_name]])
+            send(attribute.writer, @_xml_node[attribute.attribute_name])
           else
-            send(name, @_xml_node.attribute_with_ns(options[:attribute_name].to_s, ns.uri.to_s).try(:value))
+            send(attribute.writer, @_xml_node.attribute_with_ns(attribute.attribute_name, ns.uri.to_s).try(:value))
           end
         end
 
-        def deserialize_element(name, options = nil)
-          options ||= self.element_options(name)
-          type = options[:type]
-          nodes = @_xml_node.xpath("./#{ns_element(options[:ns].as, options[:element_name])}", options[:ns].to_hash)
+        # @param [Xommelier::Xml::Element::Structure::Element] element
+        def deserialize_element(element)
+          nodes = @_xml_node.xpath("./#{ns_element(element.ns.as, element.element_name)}", element.ns.to_hash)
           if nodes.any?
-            case options[:count]
-            when :any, :many
-              children = nodes.map { |node| typecast_element(type, node, options) }
-              send options[:plural], children
+            if element.multiple?
+              children = nodes.map { |node| typecast_element(node, element) }
+              send(element.plural_writer, children)
             else
-              send(name, typecast_element(type, nodes[0], options))
+              send(element.writer, typecast_element(nodes[0], element))
             end
           end
         end
 
-        def typecast_element(type, node, options)
-          if type < Xml::Element
-            type.from_xommelier(xml_document, options.merge(node: node))
+        # @param [Nokogiri::XML::Node] node
+        # @param [Xommelier::Xml::Element::Structure::Element] options
+        def typecast_element(node, options)
+          if options.type < Xml::Element
+            options.type.from_xommelier(xml_document, node: node)
           else
-            type.from_xommelier(node.text)
+            options.type.from_xommelier(node.text)
           end
         end
 
-        def serialize_element(name, value, xml, options = {})
-          case options[:count]
-          when :any, :many
-            single_element = options.merge(count: :one)
-            value.each { |item| serialize_element(name, item, xml, single_element) }
+        # @param [Object] name
+        # @param [Object] value
+        # @param [Object] xml
+        # @param [Xommelier::Xml::Element::Structure::Element] element
+        def serialize_element(name, value, xml, element)
+          if element.multiple?
+            element.override(multiple: false) do
+              value.each do |item|
+                serialize_element(name, item, xml, element)
+              end
+            end
           else
-            xmlns = options[:overriden_xmlns] || self.xmlns
-            prefix = if options[:prefix]
-                       options[:prefix]
-                     elsif options[:ns].try(:!=, xmlns)
-                       xml.doc.namespaces.key(options[:ns].uri)[6..-1].presence
-                     else
-                       nil
+            xmlns  = element.overridden_xmlns || self.xmlns
+            prefix = if xmlns != element.ns
+                       xml.doc.namespaces.key(element.ns.uri)[6..-1].presence
                      end
             case value
             when Xommelier::Xml::Element
-              value.to_xommelier(builder: xml, element_name: options[:element_name], prefix: prefix, ns: options[:ns])
+              value.to_xommelier(
+                builder:      xml,
+                element_name: element.element_name,
+                prefix:       prefix,
+                ns:           element.ns
+              )
             else
-              element_name = options[:element_name].to_s
-              element_name << '_' if %w(text class id).include?(element_name)
-              (prefix ? xml[prefix] : xml).send(element_name) { xml.text(value.to_xommelier) }
+              (prefix ? xml[prefix] : xml).send(element.serializable_element_name) do
+                xml.text(value.to_xommelier)
+              end
             end
           end
         end

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

@@ -1,4 +1,5 @@
 require 'xommelier/xml/element'
+require 'xommelier/xml/element/structure/property'
 require 'active_support/concern'
 require 'active_support/core_ext/module/delegation'
 require 'active_support/core_ext/object/with_options'
@@ -14,16 +15,15 @@ module Xommelier
 
         included do
           class_attribute :elements, :attributes
-          attr_writer :element_name
 
-          self.elements = {}
+          self.elements   = {}
           self.attributes = {}
 
-          class << self
-            include SingletonClassMethods
-          end
+          attr_writer :element_name
+
+          extend SingletonClassMethods
 
-          delegate :xmlns, to: 'self.class'
+          delegate :xmlns, :schema, to: 'self.class'
         end
 
         module SingletonClassMethods
@@ -42,8 +42,13 @@ module Xommelier
             end
             @xmlns ||= find_namespace
           end
+
           alias_method :xmlns=, :xmlns
 
+          def schema
+            containing_module.schema
+          end
+
           def element_name(element_name = nil)
             @element_name = element_name if element_name
             @element_name ||= find_element_name
@@ -66,29 +71,27 @@ module Xommelier
 
         module ClassMethods
           def inherited(child)
-            child.elements    = elements.dup
-            child.attributes  = attributes.dup
+            child.elements   = elements.dup
+            child.attributes = attributes.dup
           end
 
           # Defines containing element
           # @example
           #   element :author, type: Xommelier::Atom::Person
           def element(name, options = {})
-            options[:element_name] = options.delete(:as) { name }
-            options[:ns] ||= if options[:type].try(:<, Xml::Element)
-                               options[:type].xmlns
-                             else
-                               xmlns
-                             end
-            elements[name] = DEFAULT_ELEMENT_OPTIONS.merge(options)
+            options[:ns]   ||= if options[:type].try(:<, Xml::Element)
+                                 options[:type].xmlns
+                               else
+                                 xmlns
+                               end
+            elements[name] = Element.new(name, options)
             define_element_accessors(name)
           end
 
           # Defines containing attribute
           def attribute(name, options = {})
-            options[:attribute_name] = options.delete(:as) { name }
-            options[:ns] ||= xmlns
-            attributes[name] = DEFAULT_OPTIONS.merge(options)
+            options[:ns]     ||= xmlns
+            attributes[name] = Attribute.new(name, options)
             define_attribute_accessors(name)
           end
 
@@ -98,7 +101,7 @@ module Xommelier
           end
 
           def any(&block)
-            with_options(count: :any)  { |any| any.instance_eval(&block) }
+            with_options(count: :any) { |any| any.instance_eval(&block) }
           end
 
           def many(&block)
@@ -109,73 +112,71 @@ module Xommelier
             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?
-                  args.flatten.each_with_index do |object, index|
-                    write_element(name, object, index)
-                  end
-                end
+            element = elements[name]
+            if element.multiple?
+              # Define plural accessors
+              plural = element.plural
+
+              rw_accessor(plural) do |*args|
+                args.flatten.each_with_index do |object, index|
+                  write_element(name, object, index)
+                end if args.any?
+
                 @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
+
+              # Define singular accessors for first element
+              unless element.numbers_equal?
+                rw_accessor(name) do |*args|
+                  send(plural, [args[0]]) if args[0]
+                  send(plural)[0]
                 end
-                alias_method "#{name}=", name
+              end
+            else
+              # Define singular accessors
+              name = name.to_sym
+              rw_accessor(name) do |*args|
+                write_element(name, args[0]) if args[0]
+                read_element(name)
               end
             end
           end
 
           def define_attribute_accessors(name)
-            define_method(name) do |*args|
-              if args[0]
-                write_attribute(name.to_s, args[0])
-              end
+            rw_accessor(name) do |*args|
+              write_attribute(name.to_s, args[0]) if args[0]
               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
+            rw_accessor(:text) do |*args|
+              write_text(args[0]) if args[0]
               read_text
             end
-            alias_method :text=, :text
             alias_attribute :content, :text
           end
+
+          protected
+
+          # Defines read-write accessor for +name+ and provides alias for write-only version
+          def rw_accessor(name, &block)
+            define_method(name, &block)
+            alias_method "#{name}=", name
+          end
         end
 
         protected
 
+        def set_default_values
+          self.class.attributes.merge(self.class.elements).each do |name, property|
+            send("#{name}=", property.default) if property.default?
+          end
+        end
+
         def options=(options = {})
           if @options.key?(:element_name)
             element_name(@options.delete(:element_name))
@@ -184,12 +185,11 @@ module Xommelier
         end
 
         def element_name(value = nil)
-          if value
-            @element_name = value
-          end
+          @element_name = value if value
           @element_name ||= self.class.element_name
         end
 
+        # @return [Xommelier::Xml::Element::Structure::Element]
         def element_options(name)
           self.class.elements[name.to_sym]
         end
@@ -199,7 +199,7 @@ module Xommelier
         end
 
         def write_element(name, value, index = nil)
-          type = element_options(name)[:type]
+          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)
@@ -208,7 +208,7 @@ module Xommelier
                     end
           end
           if index
-            @elements[name.to_sym] ||= []
+            @elements[name.to_sym]        ||= []
             @elements[name.to_sym][index] = value
           else
             @elements[name.to_sym] = value
@@ -219,6 +219,7 @@ module Xommelier
           @elements.delete(name.to_sym)
         end
 
+        # @return [Xommelier::Xml::Element::Structure::Attribute]
         def attribute_options(name)
           self.class.attributes[name.to_sym]
         end
@@ -228,7 +229,7 @@ module Xommelier
         end
 
         def write_attribute(name, value)
-          type = attribute_options(name)[:type]
+          type = attribute_options(name).type
           value = type.from_xommelier(value) unless value.is_a?(type)
           @attributes[name.to_sym] = value
         end