xml_schema_mapper 0.0.1

data/README.md

@@ -0,0 +1,29 @@
+# XmlSchemaMapper
+
+TODO: Write a gem description
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'xml_schema_mapper'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install xml_schema_mapper
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Added some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,2 @@
+#!/usr/bin/env rake
+require "bundler/gem_tasks"

data/bin/xml_schema_mapper

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+$:.unshift File.expand_path('../../lib', __FILE__)
+
+require "xml_schema_mapper"
+require "thor/xsd_mappers"
+
+XsdMappers::CLI.start

data/lib/thor/templates/converter_class.erb

@@ -0,0 +1,13 @@
+<%- if options[:module_name].present? -%>
+class <%= options[:module_name] %>::<%= name.camelize %>Converter
+<% else -%>
+class <%= name.camelize %>Converter
+<% end -%>
+  include ModelConverter
+
+  converter do
+  <%-  attributes.each do |attr| -%>
+    convert_attr :<%= attr.underscore %>
+  <%- end %>
+  end
+end

data/lib/thor/templates/converter_spec.erb

@@ -0,0 +1,11 @@
+require 'spec_helper'
+
+<%- if options[:module_name].present? -%>
+describe <%= options[:module_name] %>::<%= name.camelize %> do
+<% else -%>
+describe <%= name.camelize %> do
+<% end -%>
+  it { should be_a XmlSchemaMapper }
+  it { _schema.should be_a LibXML::XML::Schema }
+  it { _type.name.should eql '<%= name %>' }
+end

data/lib/thor/templates/mapper_class.erb

@@ -0,0 +1,16 @@
+# encoding: utf-8
+# @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 -%>
+  include XmlSchemaMapper
+  schema '<%= schema_path %>'
+  type '<%= name %>'
+end

data/lib/thor/templates/mapper_spec.erb

@@ -0,0 +1,16 @@
+# encoding: utf-8
+# <%= type.annotation.to_s.gsub("\n", "\n# ") %>
+
+<%-  elements.each do |element| -%>
+  # @attr <%= element.name %> [<%= element.type.name %>] <%= element.type.annotation %>
+<%- end %>
+
+require 'spec_helper'
+
+<%- if options[:module_name].present? -%>
+describe <%= options[:module_name] %>::<%= name.camelize %> do
+<% else -%>
+describe <%= name.camelize %> do
+<% end -%>
+  it { should be_a ModelConverter }
+end

data/lib/thor/xsd_mappers.rb

@@ -0,0 +1,91 @@
+require "thor"
+require "thor/group"
+
+module XsdMappers
+  class CLI < Thor
+
+    desc 'mappers path/to/xsd path/to/generate/classes', 'generate classes 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
+
+    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
+      end
+    end
+
+    protected
+
+    def schema(path)
+      @schema ||= LibXML::XML::Schema.cached(path)
+    end
+
+  end
+
+  class Mappers < Thor::Group
+    include Thor::Actions
+
+    # 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
+    class_option :force, default: true
+
+    def self.source_root
+      File.dirname(__FILE__)
+    end
+
+    def create_lib_file
+      template('templates/mapper_class.erb', "app/#{destination}/#{name.underscore}_mapper.rb")
+    end
+
+    def create_test_file
+      test = options[:test_framework] == "test" ? :test : :spec
+      with_padding do
+        template 'templates/mapper_spec.erb', "spec/#{destination}/#{name.underscore}_mapper_#{test}.rb"
+      end
+    end
+
+    protected
+    def attributes
+      options[:attributes]
+    end
+
+    def schema
+      @schema ||= LibXML::XML::Schema.cached(schema_path)
+    end
+
+    def elements
+      @elements ||= type.elements.values
+    end
+
+    def type
+      @type ||= schema.types[name]
+    end
+  end
+
+  class Converters < Mappers
+    class_option :attributes, type: :array
+    class_option :force, default: false
+
+    def create_lib_file
+      template('templates/converter_class.erb', "app/#{destination}/#{name.underscore}_converter.rb")
+    end
+
+    def create_test_file
+      test = options[:test_framework] == "test" ? :test : :spec
+      with_padding do
+        template 'templates/converter_spec.erb', "spec/#{destination}/#{name.underscore}_converter_#{test}.rb"
+      end
+    end
+  end
+end

data/lib/xml_schema_mapper/builder.rb

@@ -0,0 +1,105 @@
+class NoToXmlError < NoMethodError
+end
+
+module XmlSchemaMapper
+  class Builder
+
+    attr_reader :document, :parent
+
+    delegate :elements, :to => :@klass
+
+    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
+    end
+
+    def build
+      elements.each do |element|
+        add_element_namespace_to_root!(element)
+        node = create_node(element)
+        parent << node unless node.content.blank?
+      end
+      self
+    end
+
+    def clean!
+
+    end
+
+    private
+
+    attr_reader :source, :schema
+
+    def create_node(element)
+      setup_namespace(element) do
+        element.simple? ? simple_node(element) : complex_node(element)
+      end
+    end
+
+    def setup_namespace(element)
+      yield.tap do |node|
+        return if node.nil?
+        node.namespace = find_namespace_definition(element.namespace)
+      end
+    end
+
+    def simple_node(element)
+      document.create_element(element.name, element.content_from(source))
+    end
+
+    def complex_node(element)
+      object            = source.send(element.reader)
+      complex_root_node = document.create_element(element.name)
+
+      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
+      else
+        raise NoToXmlError
+      end
+    end
+
+    def complex_node_from_mapper(root, object)
+      XmlSchemaMapper::Builder.build(object, root).parent
+    end
+
+    def add_element_namespace_to_root!(element)
+      if element.namespace
+        ns = schema.namespaces.find_by_href(element.namespace)
+        raise "prefix for namespace #{element.namespace.inspect} not found" unless ns
+
+        document.root.add_namespace(ns.prefix, ns.href)
+      end
+    end
+
+    def find_namespace_definition(href)
+      document.root.namespace_definitions.find { |ns| ns.href == href }
+    end
+
+    # CLASS_METHODS
+
+    def self.create_document(xtype)
+      Nokogiri::XML::Document.new.tap do |doc|
+        doc.root = doc.create_element(xtype.name.camelize(:lower))
+      end
+    end
+
+    def self.build(mapper, parent)
+      XmlSchemaMapper::Builder.new(mapper, parent).build
+    end
+
+  end
+end

data/lib/xml_schema_mapper/element.rb

@@ -0,0 +1,78 @@
+Int     = Integer
+Double  = Float
+Decimal = Integer
+
+module XmlSchemaMapper
+  class Element
+    attr_reader :xsd
+
+    delegate :name, :namespace, :type, 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
+    end
+
+    def simple?
+      [
+          LibXML::XML::Schema::Types::XML_SCHEMA_TYPE_SIMPLE,
+          LibXML::XML::Schema::Types::XML_SCHEMA_TYPE_BASIC
+      ].include? @xsd.type.kind
+    end
+
+    def content_from(object)
+      data = object.send(reader)
+      data.respond_to?(:to_xml) ? data.to_xml : data
+    end
+
+    def method_name
+      name.underscore
+    end
+
+    def writer
+      "#{method_name}="
+    end
+
+    def reader
+      "#{method_name}"
+    end
+
+    def xpath(xml)
+      if namespace
+        xml.at_xpath("./foo:#{name}", { 'foo' => @xsd.namespace })
+      else
+        xml.at_xpath("./#{name}")
+      end
+    end
+
+    def elements
+      @xsd.elements.keys.map(&:to_sym)
+    end
+
+    private
+
+    def klass_name
+      @xsd.type.name.camelize
+    rescue NameError
+      nil
+    end
+
+    def base_klass_name
+      @xsd.base.name.camelize
+    rescue NameError
+      nil
+    end
+
+  end
+end

data/lib/xml_schema_mapper/parser.rb

@@ -0,0 +1,30 @@
+module XmlSchemaMapper
+  class Parser
+    def initialize(klass)
+      @klass = klass
+    end
+
+    def parse(xml)
+      instance = @klass.new
+      xml = document(xml)
+      @klass.elements.each do |e|
+        if e.simple?
+          instance.send(e.writer, content_for(e, xml))
+        else
+          instance.send(e.writer, e.klass.parse(e.xpath(xml)))
+        end
+      end
+      instance
+    end
+
+    def content_for(element, xml)
+      node = element.xpath(xml)
+      node.content if node
+    end
+
+    def document(xml)
+      return xml if xml.is_a?(Nokogiri::XML::Node)
+      Nokogiri::XML(xml).root
+    end
+  end
+end

data/lib/xml_schema_mapper/version.rb

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

data/lib/xml_schema_mapper.rb

@@ -0,0 +1,77 @@
+require "xml_schema_mapper/version"
+require "xml"
+require "nokogiri"
+require "active_support/concern"
+require "active_support/core_ext/class"
+require "active_support/core_ext/module/delegation"
+require "virtus"
+
+require "xml_schema_mapper/element"
+require "xml_schema_mapper/parser"
+require "xml_schema_mapper/builder"
+
+module XmlSchemaMapper
+  extend ActiveSupport::Concern
+  mattr_accessor :default_class
+  self.default_class = String
+
+  included do
+    class_attribute :_schema
+    class_attribute :_type
+    class_attribute :elements
+    self.elements = []
+    include Virtus
+  end
+
+  module ClassMethods
+    def schema(location)
+      self._schema = LibXML::XML::Schema.cached(location)
+    end
+
+    def type(name)
+      raise(%Q{call "schema 'path/to/your/File.xsd'" before calling "type"}) unless _schema
+      self._type = _schema.types[name]
+      define_elements!
+    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
+    end
+
+    def parse(string_or_node)
+      return if string_or_node.nil?
+      case string_or_node
+      when String
+        string = File.exist?(string_or_node) ? File.read(string_or_node) : string_or_node
+        XmlSchemaMapper::Parser.new(self).parse(string)
+      when Nokogiri::XML::Node
+        XmlSchemaMapper::Parser.new(self).parse(string_or_node)
+      else
+        raise(ArgumentError, "param must be a String or Nokogiri::XML::Node, but \"#{string_or_node.inspect}\" given")
+      end
+    end
+  end
+
+  def element_names
+    elements.map(&:name)
+  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)
+    builder.build
+    builder.document
+  end
+end

data/spec/build_xml_spec.rb

@@ -0,0 +1,34 @@
+require "spec_helper"
+
+describe "Build XML" do
+
+  context "by GetFirstName" do
+    let(:xml) { File.read('spec/fixtures/get_first_name.xml') }
+
+    context "valid data" do
+      let(:object) do
+        o     = Options.new
+        o.one = 'one'
+        o.two = 'two'
+
+        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         = o
+
+        g
+      end
+
+      it "should build xml" do
+        object.to_xml.should eql xml
+      end
+    end
+  end
+
+end

data/spec/builder_spec.rb

@@ -0,0 +1,126 @@
+require "spec_helper"
+
+describe XmlSchemaMapper::Builder do
+  let(:options) { o = Options.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
+    g
+  end
+
+  let(:document) { XmlSchemaMapper::Builder.create_document(object._type) }
+  subject { XmlSchemaMapper::Builder.new(object, document.root) }
+
+  context 'after initialize' do
+    its(:source) { should be object }
+  end
+
+  context 'on build' do
+    let(:element) { stub(namespace: 'http://example.com/common/', name: 'element', simple?: true, content_from: 1) }
+    let(:complex_element) { stub(namespace: 'http://example.com/common/', name: 'element', simple?: false) }
+    let(:stub_node) { document.create_element('element') }
+
+    before do
+      subject.stub(elements: [element], value: 1)
+    end
+
+    it "should create node for each element" do
+      subject.should_receive(:create_node).with(element).and_return(stub_node)
+      subject.build
+    end
+
+    it "should create simple_node if element#simple?" do
+      element.should_receive(:simple?).and_return(true)
+      subject.should_receive(:simple_node).and_return(stub_node)
+      subject.build
+    end
+
+    it "should create complex_node unless element#simple?" do
+      element.should_receive(:simple?).and_return(false)
+      subject.should_receive(:complex_node).and_return(stub_node)
+      subject.build
+    end
+
+    it "should add namespace to root node" do
+      namespace = stub(prefix: 'w', href: 'namespace')
+      element.stub(namespace: 'namespace')
+      subject.stub_chain('schema.namespaces.find_by_href').and_return(namespace)
+
+      subject.build
+
+      subject.document.root.namespaces.should include "xmlns:w" => "namespace"
+    end
+
+    it "should raise error when element namespace not found" do
+      element.stub(namespace: 'namespace')
+      subject.stub_chain('schema.namespaces.find_by_href').and_return(nil)
+
+      expect { subject.build }.to raise_error("prefix for namespace \"namespace\" not found")
+    end
+
+    it "should set namespace for node" do
+      subject.stub(simple_node: stub_node)
+      subject.build
+      stub_node.namespace.prefix.should eql 'cm'
+      stub_node.namespace.href.should eql 'http://example.com/common/'
+    end
+
+    it "should create complex element with namespace" do
+      complex_element.stub(reader: 'filter')
+      element_node = document.create_element('element')
+      age_node = document.create_element('age', '50')
+      gender_node = document.create_element('gender', 'male')
+      subject.stub(elements: [complex_element])
+
+      subject.document.should_receive(:create_element).with('element').and_return(element_node)
+      subject.document.should_receive(:create_element).with('age', 50).and_return(age_node)
+      subject.document.should_receive(:create_element).with('gender', 'male').and_return(gender_node)
+
+      subject.build
+
+      element_node.namespace.prefix.should eql 'cm'
+      gender_node.namespace.prefix.should eql 'tns'
+      age_node.namespace.prefix.should eql 'tns'
+    end
+
+    it "should create complex element without namespace" do
+      complex_element.stub(namespace: nil, reader: 'options')
+      subject.stub(elements: [complex_element])
+
+      element_node = document.create_element('element')
+      one_node = document.create_element('one', 'one')
+      two_node = document.create_element('two', 'two')
+
+      subject.document.should_receive(:create_element).with('element').and_return(element_node)
+      subject.document.should_receive(:create_element).with('one', 'one').and_return(one_node)
+      subject.document.should_receive(:create_element).with('two', 'two').and_return(two_node)
+
+      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
+      object.stub(not_a_mapper: document.create_element('not_a_mapper'))
+      complex_element.stub(namespace: 'http://example.com/common/', reader: 'not_a_mapper')
+      subject.stub(elements: [complex_element])
+      element_node = document.create_element('element') << object.not_a_mapper.to_xml
+
+      element_node.should_receive(:<<).with(object.not_a_mapper.to_xml).and_return(element_node)
+      subject.document.should_receive(:create_element).with('element').and_return(element_node)
+
+      subject.build
+    end
+
+    it "should raise error when don't respond to :to_xml'" do
+      object.stub(not_a_mapper: [])
+      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")
+    end
+
+  end
+end

data/spec/element_spec.rb

@@ -0,0 +1,10 @@
+require "spec_helper"
+
+describe XmlSchemaMapper::Element do
+
+  subject { XmlSchemaMapper::Element.new(@type) }
+
+  context "resolve klass name" do
+    it "should eql"
+  end
+end

data/spec/fixtures/LocalUserService.xsd

@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="utf-8"?>
+<xs:schema xmlns:tns="http://example.com/UserService/type/" xmlns:xs="http://www.w3.org/2001/XMLSchema"
+           targetNamespace="http://example.com/UserService/type/loc" version="1.0">
+
+  <xs:import namespace="http://example.com/UserService/type/" schemaLocation="UserService.xsd"/>
+
+
+  <xs:element name="getFirstNameObj">
+    <xs:complexType>
+      <xs:sequence>
+        <xs:element ref="tns:getFirstName"/>
+        <xs:element ref="tns:getLastName"/>
+      </xs:sequence>
+    </xs:complexType>
+  </xs:element>
+
+</xs:schema>