xml_schema_mapper 0.0.1 → 0.0.5

data/lib/xml_schema_mapper/element.rb

@@ -6,29 +6,34 @@ module XmlSchemaMapper
   class Element
     attr_reader :xsd
 
-    delegate :name, :namespace, :type, to: :xsd
+    delegate :name, :namespace, :type, :base, :array?, :required?, to: :xsd
 
-    def initialize(xsd_element, klass=nil)
-      @xsd   = xsd_element
-      @klass = klass
-    end
-
-    def klass
-      @klass ||= begin
-        name = (klass_name || base_klass_name)
-        name ? (name+"Mapper").constantize : XmlSchemaMapper.default_class
-      rescue NameError
-        name.constantize
-      rescue NameError => e
-        raise e, "NotImplimented type #{name.inspect}"
-      end
+    def initialize(xsd_element)
+      @xsd = xsd_element
     end
 
     def simple?
       [
           LibXML::XML::Schema::Types::XML_SCHEMA_TYPE_SIMPLE,
           LibXML::XML::Schema::Types::XML_SCHEMA_TYPE_BASIC
-      ].include? @xsd.type.kind
+      ].include? type.kind
+    end
+
+    def complex?
+      !simple?
+    end
+
+    def elements
+      xsd.elements.values.map { |e| XmlSchemaMapper::Element.new(e) }
+    end
+
+    def accept(visitor, data, *args)
+      case data
+      when Array
+        visitor.visit_array(self, data, *args)
+      else
+        visitor.visit(self, data, *args)
+      end
     end
 
     def content_from(object)
@@ -37,42 +42,42 @@ module XmlSchemaMapper
     end
 
     def method_name
-      name.underscore
+      name.underscore.to_sym
     end
 
     def writer
-      "#{method_name}="
+      :"#{method_name}="
     end
 
     def reader
-      "#{method_name}"
+      method_name
     end
 
-    def xpath(xml)
-      if namespace
-        xml.at_xpath("./foo:#{name}", { 'foo' => @xsd.namespace })
-      else
-        xml.at_xpath("./#{name}")
-      end
+    def converter_class
+      (klass_name + "Converter").safe_constantize
     end
 
-    def elements
-      @xsd.elements.keys.map(&:to_sym)
+    def mapper_class
+      mapper_class_name.constantize
     end
 
-    private
+    def mapper_class_name
+      klass_name + "Mapper"
+    end
 
     def klass_name
-      @xsd.type.name.camelize
-    rescue NameError
-      nil
+      if type.name.nil?
+        name.underscore.camelize
+      else
+        type.name.underscore.camelize
+      end
     end
 
     def base_klass_name
-      @xsd.base.name.camelize
-    rescue NameError
+      base.name.camelize
+    rescue NoMethodError
       nil
     end
 
   end
-end
+end

data/lib/xml_schema_mapper/namespace_resolver.rb

@@ -0,0 +1,33 @@
+module XmlSchemaMapper
+  class NamespaceResolver
+    class Namespace
+      attr_reader :prefix, :href
+
+      def initialize(prefix, href)
+        @prefix, @href = prefix, href
+      end
+    end
+
+    def initialize(fallback)
+      @fallback = fallback
+    end
+
+    # @return [DuckyTyped with #prefix and #href]
+    def find_by_href(href)
+      by_href(href) || @fallback.find_by_href(href)
+    end
+
+    # @return [DuckyTyped with #prefix and #href]
+    def find_by_prefix(prefix)
+      by_prefix(prefix) || @fallback.find_by_prefix(prefix)
+    end
+
+    # @return [DuckyTyped with #prefix and #href]
+    def by_href(href)
+    end
+
+    # @return [DuckyTyped with #prefix and #href]
+    def by_prefix(prefix)
+    end
+  end
+end

data/lib/xml_schema_mapper/parser.rb

@@ -1,30 +1,90 @@
 module XmlSchemaMapper
   class Parser
     def initialize(klass)
-      @klass = klass
+      @klass  = klass
+      @module = resolve_module
     end
 
     def parse(xml)
       instance = @klass.new
-      xml = document(xml)
+      xml      = document(xml)
       @klass.elements.each do |e|
-        if e.simple?
-          instance.send(e.writer, content_for(e, xml))
+        if e.array?
+          write_array_element(e, instance, xml)
         else
-          instance.send(e.writer, e.klass.parse(e.xpath(xml)))
+          write_element(e, instance, xml)
         end
       end
       instance
     end
 
-    def content_for(element, xml)
-      node = element.xpath(xml)
+    def write_element(element, instance, xml)
+      node = get_node_by_xpath(element, xml)
+      if element.simple?
+        instance.send(element.writer, content_for(node)) if instance.respond_to?(element.writer)
+      else
+        instance.send(element.writer, resolve_element_parser(element).parse(node)) if instance.respond_to?(element.writer)
+      end
+    end
+
+    def write_array_element(element, instance, xml)
+      instance.send(element.writer, [])
+      if element.simple?
+        get_nodes_by_xpath(element, xml).each do |node|
+          instance.send(element.reader) << content_for(node) if instance.respond_to?(element.writer)
+        end
+      else
+        get_nodes_by_xpath(element, xml).each do |node|
+          instance.send(element.reader) << resolve_element_parser(element).parse(node) if instance.respond_to?(element.writer)
+        end
+      end
+    end
+
+    def content_for(node)
       node.content if node
     end
 
+    def get_node_by_xpath(element, xml)
+      if element.namespace
+        xml.at_xpath("./foo:#{element.name}", { 'foo' => element.namespace })
+      else
+        xml.at_xpath("./#{element.name}")
+      end
+    end
+
+    def get_nodes_by_xpath(element, xml)
+      if element.namespace
+        xml.xpath("./foo:#{element.name}", { 'foo' => element.namespace })
+      else
+        xml.xpath("./#{element.name}")
+      end
+    end
+
     def document(xml)
       return xml if xml.is_a?(Nokogiri::XML::Node)
       Nokogiri::XML(xml).root
     end
+
+    private
+
+    def resolve_element_parser(element)
+      parsers_for_resolve(element).find(&:safe_constantize).safe_constantize or raise_class_not_found(e)
+    end
+
+    def parsers_for_resolve(element)
+      %W(#{element.mapper_class_name} #{element.klass_name} #{@klass.name}::#{element.klass_name})
+    end
+
+    def raise_class_not_found(element)
+      raise NameError, "No one of the classes #{parsers_for_resolve(element)} cannot be found"
+    end
+
+    def resolve_module
+      if @klass.name.index('::')
+        @klass.name[0..@klass.name.index('::')-1].safe_constantize
+      else
+        Object
+      end
+    end
   end
-end
+end

data/lib/xml_schema_mapper/test_builder.rb

@@ -0,0 +1,84 @@
+module XmlSchemaMapper
+  class TestBuilder
+    module Helper
+      def build_mapper(klass)
+        XmlSchemaMapper::TestBuilder.new(klass).build
+      end
+
+      def build_described_mapper
+        build_mapper described_class
+      end
+    end
+
+    def initialize(klass)
+      @klass  = klass
+      @module = resolve_module
+    end
+
+    def build
+      instance = @klass.new
+      @klass.elements.each do |e|
+        if e.array?
+          fill_array_element(e, instance)
+        else
+          fill_element(e, instance)
+        end
+      end
+      instance
+    end
+
+    def fill_element(element, instance)
+      if element.simple?
+        instance.send(element.writer, content_for(element)) if instance.respond_to?(element.writer)
+      else
+        instance.send(element.writer, resolve_element_builder(element).build) if instance.respond_to?(element.writer)
+      end
+    end
+
+    def fill_array_element(element, instance)
+      instance.send(element.writer, [])
+      if element.simple?
+        3.times do
+          instance.send(element.reader) << content_for(element) if instance.respond_to?(element.writer)
+        end
+      else
+        3.times do
+          instance.send(element.reader) << resolve_element_builder(element).build if instance.respond_to?(element.writer)
+        end
+      end
+    end
+
+    def content_for(element)
+      case element.type.kind
+      when LibXML::XML::Schema::Types::XML_SCHEMA_TYPE_SIMPLE
+        element.type.base.name
+      when LibXML::XML::Schema::Types::XML_SCHEMA_TYPE_BASIC
+        element.type.name
+      else
+        "content"
+      end
+    end
+
+    private
+
+    def resolve_element_builder(element)
+      TestBuilder.new(parsers_for_resolve(element).find(&:safe_constantize).safe_constantize) or raise_class_not_found(e)
+    end
+
+    def parsers_for_resolve(element)
+      %W(#{element.mapper_class_name} #{element.klass_name} #{@klass.name}::#{element.klass_name})
+    end
+
+    def raise_class_not_found(element)
+      raise NameError, "No one of the classes #{parsers_for_resolve(element)} cannot be found"
+    end
+
+    def resolve_module
+      if @klass.name.index('::')
+        @klass.name[0..@klass.name.index('::')-1].safe_constantize
+      else
+        Object
+      end
+    end
+  end
+end

data/lib/xml_schema_mapper/version.rb

@@ -1,3 +1,3 @@
 module XmlSchemaMapper
-  VERSION = "0.0.1"
+  VERSION = "0.0.5"
 end

data/spec/build_xml_spec.rb

@@ -7,15 +7,15 @@ describe "Build XML" do
 
     context "valid data" do
       let(:object) do
-        o     = Options.new
+        o     = OptionsMapper.new
         o.one = 'one'
         o.two = 'two'
 
-        f        = Filter.new
+        f        = FilterMapper.new
         f.age    = 50
         f.gender = 'male'
 
-        g                 = GetFirstName.new
+        g                 = GetFirstNameMapper.new
         g.user_identifier = '001'
         g.is_out          = 'a'
         g.zone            = 'b'

data/spec/builder_spec.rb

@@ -1,10 +1,10 @@
 require "spec_helper"
 
 describe XmlSchemaMapper::Builder do
-  let(:options) { o = Options.new; o.one = 'one'; o.two = 'two'; o }
+  let(:options) { o = OptionsMapper.new; o.one = 'one'; o.two = 'two'; o }
   let(:object) do
-    f = Filter.new; f.age = 50; f.gender = 'male'
-    g = GetFirstName.new; g.user_identifier = '001'; g.is_out = 'a'; g.zone = 'b'; g.filter = f; g.options = options
+    f = FilterMapper.new; f.age = 50; f.gender = 'male'
+    g = GetFirstNameMapper.new; g.user_identifier = '001'; g.is_out = 'a'; g.zone = 'b'; g.filter = f; g.options = options
     g
   end
 
@@ -43,7 +43,7 @@ describe XmlSchemaMapper::Builder do
 
     it "should add namespace to root node" do
       namespace = stub(prefix: 'w', href: 'namespace')
-      element.stub(namespace: 'namespace')
+      element.stub(reader: 'is_out', namespace: 'namespace')
       subject.stub_chain('schema.namespaces.find_by_href').and_return(namespace)
 
       subject.build
@@ -98,8 +98,6 @@ describe XmlSchemaMapper::Builder do
       subject.build
 
       element_node.namespace.should be_nil
-      one_node.namespace.should be_nil
-      two_node.namespace.should be_nil
     end
 
     it "should accept not a XmlSchemaMapper for node" do
@@ -114,12 +112,29 @@ describe XmlSchemaMapper::Builder do
       subject.build
     end
 
+    it "if array build element for each" do
+      object.stub(array_mappers: [object.filter,object.filter])
+      complex_element.stub(namespace: 'http://example.com/common/', reader: 'array_mappers')
+      subject.stub(elements: [complex_element])
+
+      subject.parent.should_receive(:<<).with(instance_of(Nokogiri::XML::NodeSet))
+      subject.build
+    end
+
+    it "if array build element for each" do
+      mapper = ArrayNamespace::ArrayOfStringsMapper.new
+      mapper.item = [1,2,3,4]
+      subj = XmlSchemaMapper::Builder.new(mapper, document.root)
+      subj.build
+      document.root.search('.//t:item', 't' => 'http://example.com/UserService/type/').count.should eql 4
+    end
+
     it "should raise error when don't respond to :to_xml'" do
-      object.stub(not_a_mapper: [])
+      object.stub(not_a_mapper: 1)
       complex_element.stub(namespace: nil, reader: 'not_a_mapper')
       subject.stub(elements: [complex_element])
 
-      expect { subject.build }.to raise_error("object of GetFirstName#not_a_mapper should respond to :to_xml")
+      expect { subject.build }.to raise_error("object of GetFirstNameMapper#not_a_mapper should respond to :to_xml")
     end
 
   end

data/spec/fixtures/UserService.xsd

@@ -1,9 +1,9 @@
 <?xml version="1.0" encoding="utf-8"?>
 <xs:schema xmlns:tns="http://example.com/UserService/type/" xmlns:xs="http://www.w3.org/2001/XMLSchema"
            xmlns:com="http://example.com/common/"
-           targetNamespace="http://example.com/UserService/type/" version="1.0">
+           targetNamespace="http://example.com/UserService/type/" version="1.0" elementFormDefault="qualified">
 
- <xs:import namespace="http://example.com/common/" schemaLocation="common.xsd"/>
+  <xs:import namespace="http://example.com/common/" schemaLocation="common.xsd"/>
 
   <xs:complexType name="Filter">
     <xs:sequence>
@@ -24,6 +24,7 @@
       <xs:element name="options" type="com:Options"/>
     </xs:sequence>
     <xs:attribute name="id" type="xs:string"/>
+    <xs:attribute name="default" type="xs:string" use="required"/>
   </xs:complexType>
 
   <xs:complexType name="GetLastName">
@@ -43,6 +44,24 @@
     </xs:complexContent>
   </xs:complexType>
 
+  <xs:complexType name="ArrayOfGetFirstName">
+    <xs:annotation>
+      <xs:documentation>Array</xs:documentation>
+    </xs:annotation>
+    <xs:sequence>
+      <xs:element name="query" type="tns:GetFirstName" maxOccurs="unbounded"/>
+    </xs:sequence>
+  </xs:complexType>
+
+  <xs:complexType name="ArrayOfStrings">
+    <xs:annotation>
+      <xs:documentation>Array</xs:documentation>
+    </xs:annotation>
+    <xs:sequence>
+      <xs:element name="item" type="xs:string" maxOccurs="unbounded"/>
+    </xs:sequence>
+  </xs:complexType>
+
   <xs:element name="gender">
     <xs:simpleType>
       <xs:restriction base="xs:string">
@@ -63,5 +82,7 @@
 
   <xs:element name="filter" type="tns:Filter"/>
   <xs:element name="getFirstName" type="tns:GetFirstName"/>
+  <xs:element name="getFirstNames" type="tns:ArrayOfGetFirstName"/>
   <xs:element name="getLastName" type="tns:GetLastName"/>
+  <xs:element name="getTypes" type="tns:ArrayOfStrings"/>
 </xs:schema>