ruby-xsd 0.0.2

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in ruby-xsd.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2012 Fábio Luiz Nery de Miranda
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,29 @@
+# Ruby::Xsd
+
+TODO: Write a gem description
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'ruby-xsd'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install ruby-xsd
+
+## 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 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,8 @@
+require "bundler/gem_tasks"
+require 'rake/testtask'
+
+Rake::TestTask.new do |t|
+  t.libs.push "lib"
+  t.pattern = 'test/**/*.rb'
+  t.verbose = true
+end

data/lib/ruby-xsd.rb

@@ -0,0 +1,20 @@
+require "ruby-xsd/version"
+require "ruby-xsd/class_maker"
+require "nokogiri"
+
+class RubyXsd
+  class << self
+    include ClassMaker
+
+    def models_from xsd_definitions
+      doc = Nokogiri::XML xsd_definitions
+
+      schema = doc.children.first
+      raise "Invalid XMLSchema root" if schema.name != "schema"
+      raise "Missing XMLSchema namespace" if schema.namespace.nil?
+      raise "Wrong XMLSchema namespace" unless is_xml_schema_node schema
+
+      schema.children.each { |node| make_definition node }
+    end
+  end
+end

data/lib/ruby-xsd/class_maker.rb

@@ -0,0 +1,149 @@
+require "active_model"
+require "active_support"
+
+module ClassMaker
+  include ActiveSupport::Inflector
+
+  XMLSchemaNS = "http://www.w3.org/2001/XMLSchema"
+
+  def make_definition node, target=Object
+    return if is_text node
+
+    attrs = node.attributes.to_hash
+    name = attrs["name"].value
+    if is_element node
+      type = attrs["type"].value if attrs.has_key? "type"
+      if type.nil?
+        complex_node = select_children(node, "complexType").first
+        define_class name, complex_node, target
+      else
+        attr_accessor name
+      end
+    elsif is_simple node
+      if not name.nil?
+        restrictions = select_children(node, "restriction").first
+        define_validator name, restrictions, target
+      end
+    elsif is_complex_root node
+      define_class name, node, target
+    end
+  end
+
+  private
+  def namespace_of node
+    node.namespace.href
+  end
+
+  def is_text node
+    node.name == "text"
+  end
+
+  def is_xml_schema_node node
+    namespace_of(node) == XMLSchemaNS
+  end
+
+  def is_element node
+    is_xml_schema_node node and node.name == "element"
+  end
+
+  def is_simple node
+    is_xml_schema_node node and node.name == "simpleType"
+  end
+
+  def is_complex_root node
+    is_xml_schema_node node and node.name == "complexType"
+  end
+
+  def define_class name, node, target
+    name = classify name
+
+    elems = []
+    unless node.nil?
+      sequence = select_children node, "sequence"
+      elems = select_children sequence.first, "element" unless sequence.empty?
+    end
+
+    cls = Class.new do
+      class << self
+        include ClassMaker
+      end
+      elems.each { |e| make_definition e, self }
+    end
+
+    target.const_set name, cls
+  end
+
+  def define_validator name, restrictions, target
+    name = classify "#{name}_validator"
+
+    type = constantize classify restrictions
+      .attributes["base"].value.split(":").last
+
+    ws_action = select_children(restrictions, "whiteSpace").first
+    ws_action = ws_action.attributes["value"].value unless ws_action.nil?
+
+    enum_values = select_children(restrictions, "enumeration").collect { |enum|
+      enum.attributes["value"].value
+    }
+
+    pattern = select_children(restrictions, "pattern").first
+    pattern = pattern.attributes["value"].value unless pattern.nil?
+
+    cls = Class.new ActiveModel::EachValidator do
+      const_set "TYPE", type
+      const_set("WS_ACTION", ws_action) unless ws_action.nil?
+      const_set "ENUM_VALUES", enum_values
+      unless pattern.nil?
+        const_set "PATTERN", pattern
+        const_set "REGEXP", Regexp.new("^#{pattern}$")
+      end
+
+      def validate_each record, attribute, value
+        validate_type record, attribute, value
+        handle_whitespaces record, attribute, value
+        validate_enumeration record, attribute, value unless self.class::ENUM_VALUES.empty?
+        validate_regexp record, attribute, value if self.class.const_defined? "REGEXP"
+      end
+
+      private
+      def validate_type record, attribute, value
+        unless value.kind_of? self.class::TYPE
+          add_error record, attribute, "#{value}: not a #{self.class::TYPE}"
+        end
+      end
+
+      def handle_whitespaces record, attribute, value
+        if self.class.const_defined? "WS_ACTION"
+          case self.class::WS_ACTION
+          when "replace" then value.gsub! /[\n\t\r ]/, " "
+          when "collapse" then
+            value.gsub! /[\n\t\r]/, " "
+            value = value.split.join " "
+          end
+          record.send "#{attribute}=", value
+        end
+      end
+
+      def validate_enumeration record, attribute, value
+        unless self.class::ENUM_VALUES.include? value.to_s
+          add_error record, attribute, "#{value}: not in #{self.class::ENUM_VALUES}"
+        end
+      end
+
+      def validate_regexp record, attribute, value
+        unless value =~ self.class::REGEXP
+          add_error record, attribute, "#{value}: not matching #{self.class::PATTERN}"
+        end
+      end
+
+      def add_error record, attribute, message=""
+        record.errors[attribute] << (options[:message] || message)
+      end
+    end
+    target.const_set name, cls
+  end
+
+  def select_children node, name
+    node.children.select { |n| n.name == name }
+  end
+end

data/lib/ruby-xsd/version.rb

@@ -0,0 +1,5 @@
+module Ruby
+  module Xsd
+    VERSION = "0.0.2"
+  end
+end

data/ruby-xsd.gemspec

@@ -0,0 +1,24 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'ruby-xsd/version'
+
+Gem::Specification.new do |gem|
+  gem.name          = "ruby-xsd"
+  gem.version       = Ruby::Xsd::VERSION
+  gem.authors       = ["Fábio Luiz Nery de Miranda"]
+  gem.email         = ["fabio@miranti.net.br"]
+  gem.description   = %q{Generates in-memory ruby classes from XSD files}
+  gem.summary       = %q{}
+  gem.homepage      = "https://github.com/fabiolnm/ruby-xsd"
+
+  gem.files         = `git ls-files`.split($/)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ["lib"]
+
+  gem.add_development_dependency "debugger"
+  gem.add_development_dependency "nokogiri"
+  gem.add_development_dependency "activesupport"
+  gem.add_development_dependency "activemodel"
+end

data/test/minitest_helper.rb

@@ -0,0 +1,5 @@
+require 'minitest/spec'
+require 'minitest/autorun'
+require 'debugger'
+
+require 'ruby-xsd'

data/test/ruby-xsd/test.rb

@@ -0,0 +1,342 @@
+describe RubyXsd do
+  describe "XMLSchema root validation" do
+    it "rejects non-schema root" do
+      ex = assert_raises RuntimeError do
+        RubyXsd.models_from "<non-xs></non-xs>"
+      end
+      assert_equal "Invalid XMLSchema root", ex.message
+    end
+
+    it "rejects schema root without XMLSchema namespace" do
+      ex = assert_raises RuntimeError do
+        RubyXsd.models_from "<schema></schema>"
+      end
+      assert_equal "Missing XMLSchema namespace", ex.message
+    end
+
+    it "rejects schema with wrong XMLSchema namespace" do
+      ex = assert_raises RuntimeError do
+        RubyXsd.models_from "<xs:schema xmlns:xs='wrong'></xs:schema>"
+      end
+      assert_equal "Wrong XMLSchema namespace", ex.message
+    end
+  end
+
+  let(:schema) {
+    "<xs:schema xmlns:xs='#{ClassMaker::XMLSchemaNS}'>%s</xs:schema>"
+  }
+
+  describe "simple elements" do
+    let(:template) {
+      schema % "<xs:element name='%s' type='%s' />"
+    }
+
+    it "defines object attributes" do
+      RubyXsd.models_from template % [ "xsd_attr", "xs:string" ]
+      RubyXsd.new.must_respond_to :xsd_attr
+      RubyXsd.new.must_respond_to :xsd_attr=
+    end
+  end
+
+  describe "complex elements" do
+    let(:template) {
+      schema % "<xs:element name='%s'>%s</xs:element>"
+    }
+
+    let(:class_template) {
+      template % [ "xsd_complex", "" ]
+    }
+
+    let(:class_with_attrs_template) {
+      template % [ "xsd_complex_with_attr", %{
+        <xs:complexType>
+          <xs:sequence>
+            <xs:element name="foo" type="xs:string" />
+            <xs:element name="bar" type="xs:string" />
+          </xs:sequence>
+        </xs:complexType>
+      }]
+    }
+
+    it "defines a new Class" do
+      RubyXsd.models_from class_template
+      defined?(XsdComplex).must_be :==, "constant"
+      XsdComplex.class.must_be :==, Class
+    end
+
+    it "defines class attributes" do
+      RubyXsd.models_from class_with_attrs_template
+
+      defined?(XsdComplexWithAttr).must_be :==, "constant"
+      XsdComplexWithAttr.class.must_be :==, Class
+
+      obj = XsdComplexWithAttr.new
+      [ :foo, :foo=, :bar, :bar= ].each { |m|
+        obj.must_respond_to m
+      }
+    end
+  end
+
+  describe "complex roots" do
+    let(:template) {
+      schema % "<xs:complexType name='%s'>%s</xs:complexType>"
+    }
+
+    let(:complex_root) {
+      template % [ "complex_root", "" ]
+    }
+
+    let(:root_with_attrs_template) {
+      template % [ "xsd_root_with_attr", %{
+        <xs:sequence>
+          <xs:element name="foo" type="xs:string" />
+          <xs:element name="bar" type="xs:string" />
+        </xs:sequence>
+      }]
+    }
+
+    it "defines new class" do
+      RubyXsd.models_from complex_root
+      defined?(ComplexRoot).must_be :==, "constant"
+      ComplexRoot.class.must_be :==, Class
+    end
+
+    it "defines class attributes" do
+      RubyXsd.models_from root_with_attrs_template
+
+      defined?(XsdRootWithAttr).must_be :==, "constant"
+      XsdRootWithAttr.class.must_be :==, Class
+
+      obj = XsdRootWithAttr.new
+      [ :foo, :foo=, :bar, :bar= ].each { |m|
+        obj.must_respond_to m
+      }
+    end
+  end
+
+  describe "nested classes" do
+    let(:template) {
+      schema % %{
+        <xs:complexType name='%s'>
+          <xs:sequence>%s</xs:sequence>
+        </xs:complexType>
+      }
+    }
+
+    let(:elements_template) {
+      template % [ "elem_parent", %{
+        <xs:element name="nested1"></xs:element>
+        <xs:element name="nested2"></xs:element>
+      }]
+    }
+
+    let(:elements_template_with_attr) {
+      template % [ "elem_parent_with_attr", %{
+        <xs:element name="nested1">
+          <xs:complexType>
+            <xs:sequence>
+              <xs:element name="foo" type="xs:string" />
+            </xs:sequence>
+          </xs:complexType>
+        </xs:element>
+        <xs:element name="nested2">
+          <xs:complexType>
+            <xs:sequence>
+              <xs:element name="bar" type="xs:string" />
+            </xs:sequence>
+          </xs:complexType>
+        </xs:element>
+      }]
+    }
+
+    it "nests with complex elements" do
+      RubyXsd.models_from elements_template
+
+      defined?(ElemParent).must_be :==, "constant"
+      ElemParent.class.must_be :==, Class
+
+      defined?(Nested1).must_be_nil
+      defined?(ElemParent::Nested1).must_be :==, "constant"
+      ElemParent::Nested1.class.must_be :==, Class
+
+      defined?(Nested2).must_be_nil
+      defined?(ElemParent::Nested2).must_be :==, "constant"
+      ElemParent::Nested2.class.must_be :==, Class
+    end
+
+    it "nests with complex elements" do
+      RubyXsd.models_from elements_template_with_attr
+
+      ElemParentWithAttr::Nested1.new.must_respond_to :foo
+      ElemParentWithAttr::Nested1.new.wont_respond_to :bar
+
+      ElemParentWithAttr::Nested2.new.wont_respond_to :foo
+      ElemParentWithAttr::Nested2.new.must_respond_to :bar
+    end
+  end
+
+  describe "restrictions" do
+    describe "compact form" do
+      let(:template) {
+        schema % %{
+          <xs:simpleType name="foo">
+            <xs:restriction base="xs:%s">%s</xs:restriction>
+          </xs:simpleType>
+        }
+      }
+
+      let(:make_bar) {
+        class Bar
+          include ActiveModel::Validations
+          attr_accessor :baz
+          validates :baz, foo: true
+        end
+      }
+
+      after do
+        [ :FooValidator, :Bar ].each { |const|
+          Object.send(:remove_const, const) if Object.const_defined? const
+        }
+      end
+
+      it "creates validator" do
+        RubyXsd.models_from template % [ "string", "" ]
+
+        defined?(FooValidator).must_be :==, "constant"
+        FooValidator.superclass.must_be :==, ActiveModel::EachValidator
+      end
+
+      it "validates string type" do
+        RubyXsd.models_from template % [ "string", "" ]
+        make_bar
+
+        bar = Bar.new
+        bar.baz = 1
+        bar.valid?.wont_equal true
+
+        bar.baz = "1"
+        bar.valid?.must_equal true
+      end
+
+      it "validates integer type" do
+        RubyXsd.models_from template % [ "integer", "" ]
+        make_bar
+
+        bar = Bar.new
+        bar.baz = 1
+        bar.valid?.must_equal true
+
+        bar.baz = "1"
+        bar.valid?.wont_equal true
+      end
+
+      describe "Whitespace handling" do
+        let(:whitespace_schema) {
+          template % [ "string", %{<xs:whiteSpace value="%s" />} ]
+        }
+
+        let(:whitespace_string) {
+          "  abc  de\tfg\n\rhi jk   "
+        }
+
+        let(:replaced_string) {
+          "  abc  de fg  hi jk   "
+        }
+
+        let(:collapsed_string) {
+          "abc de fg hi jk"
+        }
+
+        def apply action
+          xsd = whitespace_schema % action
+          RubyXsd.models_from xsd
+          make_bar
+
+          bar = Bar.new
+          bar.baz = whitespace_string
+          bar.valid?
+          bar
+        end
+
+        it "preserves" do
+          apply("preserve").baz.must_equal whitespace_string
+        end
+
+        it "replaces" do
+          apply("replace").baz.must_equal replaced_string
+        end
+
+        it "collapses" do
+          apply("collapse").baz.must_equal collapsed_string
+        end
+      end
+
+      describe "Enumeration handling" do
+        def enum_xsd values
+          enum_str = ""
+          values.each do |v|
+            enum_str << %{<xs:enumeration value="#{v}" />}
+          end
+          template % [ "string", enum_str ]
+        end
+
+        let(:range) { (5..10).to_a + (20..25).to_a }
+        let(:out_of_range) { (1..30).to_a - range }
+        let(:bar) { Bar.new }
+
+        before do
+          RubyXsd.models_from enum_xsd range
+          make_bar
+        end
+
+        it "accepts value in range" do
+          range.each { |val|
+            bar.baz = val.to_s
+            bar.valid?.must_equal true, message: bar.errors.messages
+          }
+        end
+
+        it "rejects value out of range" do
+          out_of_range.each { |val|
+            bar.baz = val.to_s
+            bar.valid?.wont_equal true, message: bar.errors.messages
+
+            range_str = range.collect{|v| v.to_s}.to_s
+            bar.errors.messages[:baz].first
+            .must_equal "#{val}: not in #{range_str}"
+          }
+        end
+      end
+
+      describe "Regexp handling" do
+        let(:pattern) { '\w{3}[X-Z]{3}_\d{6}' }
+
+        let(:pattern_schema) {
+          template % [ "string", %{<xs:pattern value="#{pattern}" />} ]
+        }
+
+        let(:bar) {
+          inst = Bar.new
+          inst.baz = "AbcXYZ_123456"
+          inst
+        }
+
+        before do
+          RubyXsd.models_from pattern_schema
+          make_bar
+        end
+
+        it "accepts value matching pattern" do
+          bar.valid?.must_equal true, message: bar.errors.messages
+        end
+
+        it "rejects value not matching pattern" do
+          bar.baz = "not matches"
+          bar.valid?.wont_equal true, message: bar.errors.messages
+          bar.errors.messages[:baz].first
+            .must_equal "#{bar.baz}: not matching #{pattern}"
+        end
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,123 @@
+--- !ruby/object:Gem::Specification
+name: ruby-xsd
+version: !ruby/object:Gem::Version
+  version: 0.0.2
+  prerelease: 
+platform: ruby
+authors:
+- Fábio Luiz Nery de Miranda
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-10-19 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: debugger
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: nokogiri
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: activemodel
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Generates in-memory ruby classes from XSD files
+email:
+- fabio@miranti.net.br
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/ruby-xsd.rb
+- lib/ruby-xsd/class_maker.rb
+- lib/ruby-xsd/version.rb
+- ruby-xsd.gemspec
+- test/minitest_helper.rb
+- test/ruby-xsd/test.rb
+homepage: https://github.com/fabiolnm/ruby-xsd
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: ''
+test_files:
+- test/minitest_helper.rb
+- test/ruby-xsd/test.rb
+has_rdoc: