xommelier 0.1.21 → 0.1.22

data/lib/xommelier/version.rb

@@ -1,3 +1,3 @@
 module Xommelier
-  VERSION = '0.1.21'
+  VERSION = '0.1.22'
 end

data/lib/xommelier/xml.rb

@@ -2,6 +2,7 @@ require 'xommelier'
 require 'nokogiri'
 require 'xommelier/xml/namespace'
 require 'active_support/concern'
+require 'xommelier/xml/schema'
 
 module Xommelier
   module Xml
@@ -10,6 +11,8 @@ module Xommelier
     DEFAULT_NS = 'http://www.w3.org/XML/1998/namespace'
 
     module ClassMethods
+      include Schema
+
       # Defines namespace used in formats
       def xmlns(uri = nil, options = {}, &block)
         if uri
@@ -18,29 +21,6 @@ module Xommelier
         end
         instance_variable_get(:@_xmlns) || Xml.xmlns
       end
-
-      def schema(schema = nil)
-        if schema
-          # If schema or schema path provided, set schema
-          schema = Nokogiri::XML::Schema(open(schema).read) unless schema.is_a?(Nokogiri::XML::Node)
-          instance_variable_set(:@_schema, schema)
-        elsif !instance_variable_defined?(:@_schema)
-          # Unless schema exists, try to autoload schema
-          available_schema = available_schemas.find { |path| path =~ /#{xmlns.as}\.xsd/ }
-          self.schema(available_schema) if available_schema
-        else
-          instance_variable_set(:@schema, nil)
-        end
-        instance_variable_get(:@_schema)
-      end
-
-      protected
-
-      def available_schemas
-        @_available_schemas ||= $:.map do |path|
-          Dir[File.join(path, 'xommelier/schemas', '*.xsd')]
-        end.flatten.uniq
-      end
     end
 
     included do
@@ -49,6 +29,7 @@ module Xommelier
 
     # Define XML default namespace
     extend ClassMethods
+
     xmlns DEFAULT_NS, as: :xml
 
     # Inject common XML attributes to every XML element

data/lib/xommelier/xml/element.rb

@@ -1,4 +1,5 @@
 require 'xommelier/xml'
+require 'xommelier/xml/element/namespace'
 require 'xommelier/xml/element/structure'
 require 'xommelier/xml/element/serialization'
 require 'active_support/core_ext/string/inflections'
@@ -8,6 +9,7 @@ require 'active_support/core_ext/class/attribute'
 module Xommelier
   module Xml
     class Element
+      include Xommelier::Xml::Element::Namespace
       include Xommelier::Xml::Element::Structure
       include Xommelier::Xml::Element::Serialization
 
@@ -16,10 +18,10 @@ module Xommelier
       def initialize(contents = {}, options = {})
         self.options = options
 
-        @elements = {}
+        @elements   = {}
         @attributes = {}
-        @text = nil
-        @errors = []
+        @text       = nil
+        @errors     = []
 
         set_default_values
 
@@ -42,39 +44,22 @@ module Xommelier
         @options.delete(:type)
       end
 
-      def valid?
-        validate
-        @errors.empty? || @errors
-      end
-
       def inspect
         %(#<#{self.class.name}:0x#{object_id.to_s(16)} #{inspect_contents}>)
       end
 
       private
 
-      def validate
-        @errors = []
-        to_xml unless xml_document
-        if schema
-          schema.validate(xml_document).each do |error|
-            @errors << error
-          end
-        else
-          raise NoSchemaError.new(self)
-        end
-      end
-
       def inspect_contents
         [inspect_attributes, inspect_elements, inspect_text].compact.join(' ')
       end
 
       def inspect_attributes
-        "@attributes={#{@attributes.map { |name, value| "#{name}: #{value.inspect}"}.join(', ')}}" if @attributes.any?
+        "@attributes={#{@attributes.map { |name, value| "#{name}: #{value.inspect}" }.join(', ')}}" if @attributes.any?
       end
 
       def inspect_elements
-        "#{@elements.map { |name, value| "@#{name}=#{value.inspect}"}.join(' ')}" if @elements.any?
+        "#{@elements.map { |name, value| "@#{name}=#{value.inspect}" }.join(' ')}" if @elements.any?
       end
 
       def inspect_text

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

@@ -0,0 +1,83 @@
+require 'xommelier/xml/element'
+require 'active_support/concern'
+
+module Xommelier
+  module Xml
+    class Element
+      module Namespace
+        extend ActiveSupport::Concern
+
+        module ClassMethods
+          # @return [Xommelier::Xml::Namespace] associated namespace
+          def xmlns(value = nil)
+            self.xmlns = value if value
+            @xmlns ||= find_namespace
+          end
+
+          # @param [Module, Xommelier::Xml::Namespace] value namespace object or module
+          def xmlns=(value)
+            @xmlns = case value
+                     when Module
+                       value.xmlns
+                     else
+                       value
+                     end
+          end
+
+          # @return [Nokogiri::XML::Schema] schema associated with element's namespace or module
+          def schema
+            containing_module.schema
+          end
+
+          # @return [String] path to schema file
+          def schema_location
+            containing_module.schema_location
+          end
+
+          protected
+
+          # @return [Module, Class]
+          def containing_module
+            @containing_module ||= ("::#{name.gsub(/::[^:]+$/, '')}").constantize
+          end
+
+          # @return [Xommelier::Xml::Namespace]
+          def find_namespace
+            (self == containing_module ? Xommelier::Xml : containing_module).xmlns
+          end
+        end
+
+        # @return [true, false]
+        def valid?
+          validate
+          schema_validation_errors.empty?
+        end
+
+        # @return [Array<Nokogiri::XML::SyntaxError>]
+        attr_reader :schema_validation_errors
+        alias errors schema_validation_errors # compatibility
+
+        protected
+
+        # Validates document
+        def validate
+          @schema_validation_errors = []
+          if self.class.schema
+            #document = ensure_xml_document
+            document = Nokogiri::XML(to_xml)
+            self.class.schema.validate(document).each do |error|
+              @schema_validation_errors << error
+            end
+            if @schema_validation_errors.any?
+              puts self.class, self.class.schema_location, document
+              require 'pp'
+              pp @schema_validation_errors
+            end
+          else
+            raise NoSchemaError.new(self)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -1,6 +1,8 @@
 require 'xommelier/xml/element'
 require 'active_support/concern'
 require 'active_support/core_ext/object/blank'
+require 'active_support/core_ext/hash/slice'
+require 'active_support/core_ext/hash/except'
 require 'nokogiri'
 
 module Xommelier
@@ -12,6 +14,7 @@ module Xommelier
         SERIALIZATION_OPTIONS = {
           encoding: 'utf-8'
         }
+        SAVE_OPTIONS = [:save_with, :indent_text, :indent]
 
         module ClassMethods
           def from_xml(xml, options = {})
@@ -45,7 +48,6 @@ module Xommelier
             xml = Nokogiri::XML(xml)
           end
           @_xml_node = options.delete(:node) { xml.at_xpath(element_xpath(xml.document, element_name)) }
-          validate if options[:validate]
 
           if text? && @_xml_node.inner_html.present?
             self.text = @_xml_node.inner_html
@@ -63,6 +65,9 @@ module Xommelier
 
         def to_xml(options = {})
           options = SERIALIZATION_OPTIONS.merge(options)
+          save_options = options.slice(:encoding, *SAVE_OPTIONS)
+          options = options.except(*SAVE_OPTIONS)
+
           element_name = options.delete(:element_name) { self.element_name }
           element_name = element_name.to_s
           element_name << '_' if %w(text class id).include?(element_name)
@@ -109,7 +114,7 @@ module Xommelier
             end
             xml.text(@text) if respond_to?(:text)
           end.instance_variable_get(:@node)
-          builder.to_xml
+          builder.to_xml(save_options)
         end
         alias_method :to_xommelier, :to_xml
 
@@ -133,6 +138,11 @@ module Xommelier
           end
         end
 
+        # @return [Nokogiri::XML::Node]
+        def to_nokogiri
+          ensure_xml_document.root
+        end
+
         def <=>(other)
           if text? && other.is_a?(String)
             text.to_s <=> other
@@ -191,6 +201,11 @@ module Xommelier
           @_xml_node.try(:document)
         end
 
+        def ensure_xml_document
+          to_xml unless xml_document
+          xml_document
+        end
+
         def xmlns_xpath(xml_document = self.xml_document)
           self.class.xmlns_xpath(xml_document)
         end

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

@@ -23,46 +23,16 @@ module Xommelier
 
           extend SingletonClassMethods
 
-          delegate :xmlns, :schema, to: 'self.class'
+          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 schema
-            containing_module.schema
-          end
-
           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
+          protected
 
           def find_element_name
             name.demodulize.underscore.dasherize
@@ -70,6 +40,7 @@ module Xommelier
         end
 
         module ClassMethods
+          # @param [Xommelier::Xml::Element] child
           def inherited(child)
             child.elements   = elements.dup
             child.attributes = attributes.dup
@@ -79,12 +50,33 @@ module Xommelier
           # @example
           #   element :author, type: Xommelier::Atom::Person
           def element(name, options = {})
-            options[:ns]   ||= if options[:type].try(:<, Xml::Element)
-                                 options[:type].xmlns
-                               else
-                                 xmlns
-                               end
-            element = Element.new(name, options)
+            # Set name, type and element name by reference if provided
+            name, options = nil, name if name.is_a?(Hash)
+
+            # Set type and element name from reference
+            if options.key?(:ref)
+              raise "#{options[:ref]} is not subclass of Xommelier::Element" unless referenceable?(options[:ref])
+
+              options[:type] = options.delete(:ref)
+
+              # Set element name from provided complex type
+              options[:as]   ||= options[:type].element_name
+
+              # Set attribute name from element name
+              name           ||= options[:as].underscore.to_sym
+            end
+
+            # Try to define element name from
+            options[:as] ||= name.to_s.camelize(:lower)
+
+            # Set namespace from element type or wrapper xmlns
+            options[:ns] ||= if referenceable?(options[:type])
+                               options[:type].xmlns
+                             else
+                               xmlns
+                             end
+
+            element        = Element.new(name, options)
             elements[name] = element
             define_element_accessors(element)
           end
@@ -167,6 +159,10 @@ module Xommelier
             define_method(name, &block)
             alias_method "#{name}=", name
           end
+
+          def referenceable?(type)
+            type.is_a?(Class) && type < Xommelier::Xml::Element
+          end
         end
 
         protected
@@ -199,7 +195,7 @@ module Xommelier
 
         def write_element(name, value, index = nil)
           element = element_options(name)
-          type = element.type
+          type    = element.type
           unless value.is_a?(type)
             value = if element.complex_type? && !value.is_a?(Nokogiri::XML::Node)
                       type.new(value)

data/lib/xommelier/xml/schema.rb

@@ -0,0 +1,68 @@
+require 'xommelier'
+
+module Xommelier
+  module Xml
+    module Schema
+      def schema_location(new_location = nil)
+        self.schema_location = new_location if new_location
+
+        @_schema_location
+      end
+
+      def schema_location=(location)
+        return unless location
+        @_schema_location = location
+        # For loading schema containing imports we need to temporarily chdir,
+        #   so relative file names will be properly discovered
+        Dir.chdir(File.dirname(location)) do
+          @_schema = Nokogiri::XML::Schema(File.read(File.basename(location)))
+        end
+      end
+
+      # @param [String, Nokogiri::XML::Node] schema
+      # @return [Nokogiri::XML::Schema, nil]
+      def schema(schema = nil)
+        self.schema = schema if schema
+
+        unless instance_variable_defined?(:@_schema)
+          # Unless schema exists, try to autoload schema
+          if _default_schema_location
+            self.schema_location = _default_schema_location
+          else
+            @_schema = nil
+          end
+        end
+        @_schema
+      end
+
+      def schema=(schema)
+        if schema
+          # If schema or schema path provided, set schema
+          if schema.is_a?(Nokogiri::XML::Schema)
+            @_schema = schema
+          elsif schema.is_a?(Nokogiri::XML::Node)
+            @_schema = Nokogiri::XML::Schema(schema)
+          else
+            self.schema_location = schema
+          end
+        end
+        @_schema
+      end
+
+      protected
+
+      def _available_schemas
+        @_available_schemas ||= $:.map do |path|
+          Dir[File.join(path, 'xommelier/schemas', '*.xsd')]
+        end.flatten.uniq
+      end
+
+      def _default_schema_location
+        @_default_schema_location ||= begin
+          file_name = /#{xmlns.as || name.demodulize.underscore}\.xsd\Z/
+          _available_schemas.find { |path| path =~ file_name }
+        end
+      end
+    end
+  end
+end