xml_schema_mapper 0.0.1 → 0.0.5

data/.gitignore

@@ -15,3 +15,4 @@ spec/reports
 test/tmp
 test/version_tmp
 tmp
+.idea

data/lib/thor/templates/converter_class.erb

@@ -1,13 +1,20 @@
-<%- if options[:module_name].present? -%>
-class <%= options[:module_name] %>::<%= name.camelize %>Converter
+# encoding: utf-8
+# @note <%= type.annotation.to_s.gsub("\n", "\n# ") %>
+
+<%-  elements.each do |element| -%>
+  <%- (element.annotation || element.type.annotation).each_line do |line| -%>
+# <%= line %>
+  <%- end -%>
+# @attr <%= element.name %> [<%= element.type.name %>]
+<%- end -%>
+
+<%- if options[:converter_module_name].present? -%>
+class <%= options[:converter_module_name] %>::<%= converter_name %> < Converter
 <% else -%>
-class <%= name.camelize %>Converter
+class <%= converter_name %> < Converter
 <% end -%>
-  include ModelConverter
 
-  converter do
-  <%-  attributes.each do |attr| -%>
-    convert_attr :<%= attr.underscore %>
-  <%- end %>
-  end
-end
+<%-  elements.each do |element| -%>
+  map mapper: :<%= element.name.underscore %>, model: :<%= element.name.underscore %>
+<%- end -%>
+end

data/lib/thor/templates/converter_spec.erb

@@ -1,11 +1,12 @@
 require 'spec_helper'
 
-<%- if options[:module_name].present? -%>
-describe <%= options[:module_name] %>::<%= name.camelize %> do
+<%-  elements.each do |element| -%>
+# @attr <%= element.name %> [<%= element.type.name %>]
+<%- end %>
+
+<%- if options[:converter_module_name].present? -%>
+describe <%= options[:converter_module_name] %>::<%= converter_name %> do
 <% else -%>
-describe <%= name.camelize %> do
+describe <%= converter_name %> do
 <% end -%>
-  it { should be_a XmlSchemaMapper }
-  it { _schema.should be_a LibXML::XML::Schema }
-  it { _type.name.should eql '<%= name %>' }
-end
+end

data/lib/thor/templates/mapper_class.erb

@@ -1,16 +1,35 @@
 # encoding: utf-8
+<%- unless type.annotation.to_s.blank? -%>
 # @note <%= type.annotation.to_s.gsub("\n", "\n# ") %>
-
-<%-  elements.each do |element| -%>
-# @attr <%= element.name %> [<%= element.type.name %>] <%= element.annotation || element.type.annotation %>
 <%- end -%>
 
-<%- if options[:module_name].present? -%>
-class <%= options[:module_name] %>::<%= name.camelize %>Mapper
-<% else -%>
-class <%= name.camelize %>Mapper
-<% end -%>
+class <%= mapper_name %>
   include XmlSchemaMapper
   schema '<%= schema_path %>'
   type '<%= name %>'
-end
+
+<%- elements.each do |element| -%>
+  <%- element_annotation(element).split("\n").delete_if(&:blank?).each do |comment| -%>
+  # <%= comment %>
+  <%- end -%>
+  # minOccurs: <%= element.min_occurs %>, maxOccurs: <%= element.max_occurs %>
+  attr_accessor :<%= element.name.underscore %>
+<%- end -%>
+
+<%- subclasses.each do |subclass, type| -%>
+  class <%= subclass.split('::').map(&:camelize).join('::') %>
+    include XmlSchemaMapper
+    schema '<%= schema_path %>'
+    annonymus_type '<%= [name.camelize, subclass].join('::') %>'
+
+  <%- type.elements.values.each do |element| -%>
+    <%- element_annotation(element).split("\n").delete_if(&:blank?).each do |comment| -%>
+    # <%= comment %>
+    <%- end -%>
+    # minOccurs: <%= element.min_occurs %>, maxOccurs: <%= element.max_occurs %>
+    attr_accessor :<%= element.name.underscore %>
+  <%- end -%>
+  end
+
+<%- end unless subclasses.empty? -%>
+end

data/lib/thor/templates/mapper_spec.erb

@@ -1,16 +1,22 @@
-# encoding: utf-8
-# <%= type.annotation.to_s.gsub("\n", "\n# ") %>
+require 'spec_helper'
+require "xml_schema_mapper/test_builder"
 
 <%-  elements.each do |element| -%>
-  # @attr <%= element.name %> [<%= element.type.name %>] <%= element.type.annotation %>
+  # @attr <%= element.name %> [<%= element.type.name %>]
 <%- end %>
 
-require 'spec_helper'
-
 <%- if options[:module_name].present? -%>
-describe <%= options[:module_name] %>::<%= name.camelize %> do
+describe <%= options[:module_name] %>::<%= name.camelize %>Mapper do
 <% else -%>
-describe <%= name.camelize %> do
+describe <%= name.underscore.camelize %>Mapper do
 <% end -%>
-  it { should be_a ModelConverter }
-end
+
+  include XmlSchemaMapper::TestBuilder::Helper
+
+  subject { build_described_mapper }
+
+  it "should be self-compatible xml <-> object" do
+    described_class.parse(subject.to_xml).to_xml.should eql subject.to_xml
+  end
+
+end

data/lib/thor/xsd_mappers.rb

@@ -4,19 +4,15 @@ require "thor/group"
 module XsdMappers
   class CLI < Thor
 
-    desc 'mappers path/to/xsd path/to/generate/classes', 'generate classes for xsd types'
+    desc 'generate path/to/xsd', 'generate mappers for xsd types'
     method_option :module_name, default: ''
-    def mappers(schema_path, destination = './')
-      schema(schema_path).types.each do |name, type|
-        Mappers.new([name, schema_path, destination]).invoke_all
-      end
-    end
+    method_option :converter_module_name, default: ''
+    method_option :'skip-converters', type: :boolean
 
-    desc 'converters path/to/xsd path/to/generate/classes', 'generate converters for xsd types'
-    method_option :module_name, default: ''
-    def converters(schema_path, destination = './')
-      schema(schema_path).types.each do |name, type|
-        Converters.new([name, schema_path, destination], options.merge(attributes: type.elements.keys)).invoke_all
+    def generate(schema_path)
+      schema(schema_path).types.each do |name, _|
+        Mappers.new([name, schema_path], options).invoke_all
+        Converters.new([name, schema_path], options).invoke_all unless options[:'skip-converters']
       end
     end
 
@@ -34,7 +30,6 @@ module XsdMappers
     # Define arguments and options
     argument :name
     argument :schema_path
-    argument :destination, default: './'
     class_option :module_name, default: ''
     class_option :override, default: false
     class_option :base_type, default: nil
@@ -44,20 +39,27 @@ module XsdMappers
       File.dirname(__FILE__)
     end
 
+    def module_path
+      options[:module_name] ? options[:module_name].underscore : ""
+    end
+
     def create_lib_file
-      template('templates/mapper_class.erb', "app/#{destination}/#{name.underscore}_mapper.rb")
+      filename = "#{name.underscore}_mapper.rb"
+      template('templates/mapper_class.erb', File.join('app/mappers/', module_path, filename))
     end
 
     def create_test_file
-      test = options[:test_framework] == "test" ? :test : :spec
+      test     = options[:test_framework] == "test" ? :test : :spec
+      filename = "#{name.underscore}_mapper_#{test}.rb"
       with_padding do
-        template 'templates/mapper_spec.erb', "spec/#{destination}/#{name.underscore}_mapper_#{test}.rb"
+        template 'templates/mapper_spec.erb', File.join("#{test}/mappers/", module_path, filename)
       end
     end
 
     protected
-    def attributes
-      options[:attributes]
+
+    def subclasses
+      type.annonymus_subtypes_recursively.inject({ }, &:merge)
     end
 
     def schema
@@ -71,21 +73,64 @@ module XsdMappers
     def type
       @type ||= schema.types[name]
     end
+
+    def element_annotation(element)
+      type    = element.type.name || "#{element.name}"
+      comment = element.annotation || element.type.annotation
+
+      if is_a_simple?(element.type)
+        "#{comment}\n" <<
+            "@return [#{type.camelize}]"
+      else
+        "#{comment}\n" <<
+            "@return [#{module_name}#{type.camelize}Mapper]"
+      end
+    end
+
+    def is_a_simple?(type)
+      [LibXML::XML::Schema::Types::XML_SCHEMA_TYPE_SIMPLE,
+       LibXML::XML::Schema::Types::XML_SCHEMA_TYPE_BASIC].include?(type.kind)
+    end
+
+    def module_name
+      if options[:module_name].presence
+        "#{options[:module_name]}::"
+      else
+        ""
+      end
+    end
+
+    def mapper_name
+      class_name = "#{name.underscore.camelize}Mapper"
+      "#{module_name}#{class_name}"
+    end
   end
 
   class Converters < Mappers
     class_option :attributes, type: :array
+    class_option :converter_module_name, default: ""
     class_option :force, default: false
+    class_option :skip, default: true
+
+    def module_path
+      options[:converter_module_name] ? options[:converter_module_name].underscore : ""
+    end
 
     def create_lib_file
-      template('templates/converter_class.erb', "app/#{destination}/#{name.underscore}_converter.rb")
+      filename = "#{name.underscore}_converter.rb"
+      template('templates/converter_class.erb', File.join('app/converters/', module_path, filename))
     end
 
     def create_test_file
-      test = options[:test_framework] == "test" ? :test : :spec
+      test     = options[:test_framework] == "test" ? :test : :spec
+      filename = "#{name.underscore}_converter_#{test}.rb"
       with_padding do
-        template 'templates/converter_spec.erb', "spec/#{destination}/#{name.underscore}_converter_#{test}.rb"
+        template 'templates/converter_spec.erb', File.join("#{test}/converters/", module_path, filename)
       end
     end
+
+    def converter_name
+      "#{name.underscore.camelize}Converter"
+    end
   end
-end
+end

data/lib/xml_schema_mapper.rb

@@ -4,46 +4,52 @@ require "nokogiri"
 require "active_support/concern"
 require "active_support/core_ext/class"
 require "active_support/core_ext/module/delegation"
+require "active_support/core_ext/object/blank"
+require "active_support/core_ext/string/inflections"
 require "virtus"
 
 require "xml_schema_mapper/element"
 require "xml_schema_mapper/parser"
 require "xml_schema_mapper/builder"
+require "xml_schema_mapper/namespace_resolver"
 
 module XmlSchemaMapper
   extend ActiveSupport::Concern
-  mattr_accessor :default_class
-  self.default_class = String
+  mattr_accessor :namespace_resolver_class
 
   included do
     class_attribute :_schema
     class_attribute :_type
-    class_attribute :elements
-    self.elements = []
+    class_attribute :namespace_resolver_class
     include Virtus
   end
 
   module ClassMethods
-    def schema(location)
-      self._schema = LibXML::XML::Schema.cached(location)
+    def schema(location=nil)
+      if location
+        self._schema = LibXML::XML::Schema.cached(location)
+      else
+        self._schema
+      end
     end
 
-    def type(name)
+    def type(name=nil)
       raise(%Q{call "schema 'path/to/your/File.xsd'" before calling "type"}) unless _schema
-      self._type = _schema.types[name]
-      define_elements!
+      if name
+        self._type = _schema.types[name]
+        attr_accessor :attrs
+      else
+        self._type
+      end
     end
 
-    def define_elements!
-      _type.elements.values.each do |element|
-        e = XmlSchemaMapper::Element.new(element)
-        elements << e
-        begin
-          attr_accessor e.method_name
-        rescue
-          raise [e.method_name, e.klass, e.type.name].inspect
-        end
-      end
+    def annonymus_type(name)
+      raise(%Q{call "schema 'path/to/your/File.xsd'" before calling "type"}) unless _schema
+      path       = name.split('::')
+      type       = _schema.types[path.shift]
+      self._type = path.map do |n|
+        type = type.elements[n].type if type
+      end.last
     end
 
     def parse(string_or_node)
@@ -58,20 +64,90 @@ module XmlSchemaMapper
         raise(ArgumentError, "param must be a String or Nokogiri::XML::Node, but \"#{string_or_node.inspect}\" given")
       end
     end
+
+    def elements
+      @elements ||= type.elements.values.map do |element|
+        XmlSchemaMapper::Element.new(element)
+      end
+    end
+
+    def attrs
+      @attrs ||= type.attributes
+    end
+  end
+
+  delegate :first, :last, :each, :length, :size, :all?, :any?, :one?, :empty?, to: :element_values
+
+  def [](key)
+    send(key)
+  end
+
+  def []=(key, val)
+    send(:"#{key}=", val)
+  end
+
+  def accept(visitor, *args)
+    visitor.visit(self, *args)
+  end
+
+  def simple?
+    _type.simple?
+  end
+
+  def values
+    _type.facets.map &:value
+  end
+
+  def type
+    self.class.type
+  end
+
+  def schema
+    self.class.schema
   end
 
   def element_names
-    elements.map(&:name)
+    elements.keys
   end
 
-  def to_xml(options = {})
-    xml_document.root.to_xml({:encoding => 'UTF-8'}.merge(options))
+  def element_values
+    elements.values
+  end
+
+  def elements
+    type.elements.values.inject({ }) do |hash, element|
+      hash.merge element.name.underscore.to_sym => send(element.name.underscore.to_sym)
+    end
+  end
+
+  def to_xml(options = { })
+    xml_document.root.to_xml({ :encoding => 'UTF-8' }.merge(options))
   end
 
   def xml_document
     document = XmlSchemaMapper::Builder.create_document(_type)
-    builder  = XmlSchemaMapper::Builder.new(self, document.root)
+
+    ns                      = namespace_resolver.find_by_href (global_element || _type).namespace
+    document.root.namespace = document.root.add_namespace_definition(ns.prefix, ns.href)
+
+    builder                    = XmlSchemaMapper::Builder.new(self, document.root, namespace_resolver)
     builder.build
     builder.document
   end
+
+  def namespace_resolver
+    case
+    when self.class.namespace_resolver_class
+      self.class.namespace_resolver_class.new(schema.namespaces)
+    when XmlSchemaMapper.namespace_resolver_class
+      XmlSchemaMapper.namespace_resolver_class.new(schema.namespaces)
+    else
+      schema.namespaces
+    end
+  end
+
+  def global_element
+    schema.elements.values.find { |e| e.type.name == _type.name }
+  end
+
 end

data/lib/xml_schema_mapper/builder.rb

@@ -4,29 +4,39 @@ end
 module XmlSchemaMapper
   class Builder
 
-    attr_reader :document, :parent
-
-    delegate :elements, :to => :@klass
+    attr_reader :document, :parent, :namespace_resolver
+
+    def initialize(source, parent, namespace_resolver)
+      @parent             = parent.is_a?(Nokogiri::XML::Document) ? parent.root : parent
+      @document           = parent.document
+      @source             = source
+      @klass              = source.class
+      @namespace_resolver = namespace_resolver
+      @schema             = @klass._schema
+    end
 
-    def initialize(source, parent)
-      @parent   = parent.is_a?(Nokogiri::XML::Document) ? parent.root : parent
-      @document = parent.document
-      @source   = source
-      @klass    = source.class
-      @schema   = @klass._schema
+    def elements
+      @klass.type.elements.values.map { |e| XmlSchemaMapper::Element.new e }
     end
 
     def build
       elements.each do |element|
         add_element_namespace_to_root!(element)
         node = create_node(element)
-        parent << node unless node.content.blank?
+
+        parent << node if can_add?(element, node)
+
+        if node.is_a?(Nokogiri::XML::NodeSet)
+          node.each { |n| n.namespace = nil if element.namespace.nil? }
+        else
+          node.namespace = nil if element.namespace.nil?
+        end
       end
       self
     end
 
-    def clean!
-
+    def can_add?(element, node)
+      node.is_a?(Nokogiri::XML::NodeSet) || node.content.present?
     end
 
     private
@@ -41,50 +51,82 @@ module XmlSchemaMapper
 
     def setup_namespace(element)
       yield.tap do |node|
-        return if node.nil?
-        node.namespace = find_namespace_definition(element.namespace)
+        case node
+        when Nokogiri::XML::NodeSet
+          node.each { |n| n.namespace = find_namespace_definition(element.namespace) }
+        when NilClass
+        else
+          node.namespace = find_namespace_definition(element.namespace)
+        end
       end
     end
 
     def simple_node(element)
-      document.create_element(element.name, element.content_from(source))
+      value = source.send(element.reader)
+      if value.is_a? Array
+        list = value.map do |i|
+          document.create_element(element.name, i)
+        end
+        Nokogiri::XML::NodeSet.new(document, list)
+      else
+        document.create_element(element.name, element.content_from(source))
+      end
     end
 
     def complex_node(element)
       object            = source.send(element.reader)
       complex_root_node = document.create_element(element.name)
 
+      complex_children(complex_root_node, object)
+    rescue NoToXmlError
+      raise("object of #{source.class}##{element.reader} should respond to :to_xml")
+    end
+
+    def complex_children(complex_root_node, object)
       if object.is_a?(XmlSchemaMapper)
         complex_node_from_mapper(complex_root_node, object)
       else
         complex_node_from_xml(complex_root_node, object)
       end
-    rescue NoToXmlError
-      raise("object of #{source.class}##{element.reader} should respond to :to_xml")
     end
 
-    def complex_node_from_xml(root, object)
-      return root if object.nil?
-      if object.respond_to?(:to_xml)
-        root << object.to_xml
+    def complex_node_from_xml(complex_root_node, object)
+      return complex_root_node if object.nil?
+      if object.is_a?(Array)
+        list = object.map do |o|
+          complex_node_item = complex_root_node.dup
+          complex_children(complex_node_item, o)
+        end
+        Nokogiri::XML::NodeSet.new(complex_root_node.document, list)
+      elsif object.respond_to?(:to_xml)
+        complex_root_node << object.to_xml
       else
         raise NoToXmlError
       end
     end
 
-    def complex_node_from_mapper(root, object)
-      XmlSchemaMapper::Builder.build(object, root).parent
+    def complex_node_from_mapper(complex_root_node, object)
+      XmlSchemaMapper::Builder.build(object, complex_root_node, namespace_resolver).parent
     end
 
     def add_element_namespace_to_root!(element)
       if element.namespace
-        ns = schema.namespaces.find_by_href(element.namespace)
+
+        ns = find_namespace(element)
         raise "prefix for namespace #{element.namespace.inspect} not found" unless ns
 
         document.root.add_namespace(ns.prefix, ns.href)
       end
     end
 
+    def find_namespace(element)
+      if namespace_resolver
+        namespace_resolver.find_by_href(element.namespace)
+      else
+        schema.namespaces.find_by_href(element.namespace)
+      end
+    end
+
     def find_namespace_definition(href)
       document.root.namespace_definitions.find { |ns| ns.href == href }
     end
@@ -97,9 +139,9 @@ module XmlSchemaMapper
       end
     end
 
-    def self.build(mapper, parent)
-      XmlSchemaMapper::Builder.new(mapper, parent).build
+    def self.build(mapper, parent, namespace_resolver)
+      XmlSchemaMapper::Builder.new(mapper, parent, namespace_resolver).build
     end
 
   end
-end
+end