shale 0.8.0 → 1.0.0

data/lib/shale/mapping/xml.rb

@@ -13,25 +13,28 @@ module Shale
       #
       # @param [String] element
       # @param [Symbol, nil] to
+      # @param [Symbol, nil] receiver
       # @param [Hash, nil] using
       # @param [String, nil] namespace
       # @param [String, nil] prefix
       # @param [true, false] cdata
-      # @param [true, false] render_nil
+      # @param [true, false, nil] render_nil
       #
       # @api private
       def map_element(
         element,
         to: nil,
+        receiver: nil,
         using: nil,
         namespace: :undefined,
         prefix: :undefined,
         cdata: false,
-        render_nil: false
+        render_nil: nil
       )
         super(
           element,
           to: to,
+          receiver: receiver,
           using: using,
           namespace: namespace,
           prefix: prefix,
@@ -44,23 +47,26 @@ module Shale
       #
       # @param [String] attribute
       # @param [Symbol, nil] to
+      # @param [Symbol, nil] receiver
       # @param [Hash, nil] using
       # @param [String, nil] namespace
       # @param [String, nil] prefix
-      # @param [true, false] render_nil
+      # @param [true, false, nil] render_nil
       #
       # @api private
       def map_attribute(
         attribute,
         to: nil,
+        receiver: nil,
         using: nil,
         namespace: nil,
         prefix: nil,
-        render_nil: false
+        render_nil: nil
       )
         super(
           attribute,
           to: to,
+          receiver: receiver,
           using: using,
           namespace: namespace,
           prefix: prefix,
@@ -71,12 +77,22 @@ module Shale
       # Map document's content to object's attribute
       #
       # @param [Symbol] to
+      # @param [Symbol, nil] receiver
       # @param [Hash, nil] using
       # @param [true, false] cdata
       #
       # @api private
-      def map_content(to: nil, using: nil, cdata: false)
-        super(to: to, using: using, cdata: cdata)
+      def map_content(to: nil, receiver: nil, using: nil, cdata: false)
+        super(to: to, receiver: receiver, using: using, cdata: cdata)
+      end
+
+      # Set render_nil default
+      #
+      # @param [true, false] val
+      #
+      # @api private
+      def render_nil(val)
+        @render_nil_default = val
       end
 
       # Map group of nodes to mapping methods

data/lib/shale/mapping/xml_base.rb

@@ -67,18 +67,20 @@ module Shale
         @root = ''
         @default_namespace = Descriptor::XmlNamespace.new
         @finalized = false
+        @render_nil_default = false
       end
 
       # Map element to attribute
       #
       # @param [String] element
       # @param [Symbol, nil] to
+      # @param [Symbol, nil] receiver
       # @param [Hash, nil] using
       # @param [String, nil] group
       # @param [String, nil] namespace
       # @param [String, nil] prefix
       # @param [true, false] cdata
-      # @param [true, false] render_nil
+      # @param [true, false, nil] render_nil
       #
       # @raise [IncorrectMappingArgumentsError] when arguments are incorrect
       #
@@ -86,14 +88,15 @@ module Shale
       def map_element(
         element,
         to: nil,
+        receiver: nil,
         using: nil,
         group: nil,
         namespace: :undefined,
         prefix: :undefined,
         cdata: false,
-        render_nil: false
+        render_nil: nil
       )
-        Validator.validate_arguments(element, to, using)
+        Validator.validate_arguments(element, to, receiver, using)
         Validator.validate_namespace(element, namespace, prefix)
 
         if namespace == :undefined && prefix == :undefined
@@ -109,11 +112,12 @@ module Shale
         @elements[namespaced_element] = Descriptor::Xml.new(
           name: element,
           attribute: to,
+          receiver: receiver,
           methods: using,
           group: group,
           namespace: Descriptor::XmlNamespace.new(nsp, pfx),
           cdata: cdata,
-          render_nil: render_nil
+          render_nil: render_nil.nil? ? @render_nil_default : render_nil
         )
       end
 
@@ -121,10 +125,12 @@ module Shale
       #
       # @param [String] attribute
       # @param [Symbol, nil] to
+      # @param [Symbol, nil] receiver
       # @param [Hash, nil] using
+      # @param [String, nil] group
       # @param [String, nil] namespace
       # @param [String, nil] prefix
-      # @param [true, false] render_nil
+      # @param [true, false, nil] render_nil
       #
       # @raise [IncorrectMappingArgumentsError] when arguments are incorrect
       #
@@ -132,13 +138,14 @@ module Shale
       def map_attribute(
         attribute,
         to: nil,
+        receiver: nil,
         using: nil,
         group: nil,
         namespace: nil,
         prefix: nil,
-        render_nil: false
+        render_nil: nil
       )
-        Validator.validate_arguments(attribute, to, using)
+        Validator.validate_arguments(attribute, to, receiver, using)
         Validator.validate_namespace(attribute, namespace, prefix)
 
         namespaced_attribute = [namespace, attribute].compact.join(':')
@@ -146,27 +153,31 @@ module Shale
         @attributes[namespaced_attribute] = Descriptor::Xml.new(
           name: attribute,
           attribute: to,
+          receiver: receiver,
           methods: using,
           namespace: Descriptor::XmlNamespace.new(namespace, prefix),
           cdata: false,
           group: group,
-          render_nil: render_nil
+          render_nil: render_nil.nil? ? @render_nil_default : render_nil
         )
       end
 
       # Map document's content to object's attribute
       #
       # @param [Symbol] to
+      # @param [Symbol, nil] receiver
       # @param [Hash, nil] using
+      # @param [String, nil] group
       # @param [true, false] cdata
       #
       # @api private
-      def map_content(to: nil, using: nil, group: nil, cdata: false)
-        Validator.validate_arguments('content', to, using)
+      def map_content(to: nil, receiver: nil, using: nil, group: nil, cdata: false)
+        Validator.validate_arguments('content', to, receiver, using)
 
         @content = Descriptor::Xml.new(
           name: nil,
           attribute: to,
+          receiver: receiver,
           methods: using,
           namespace: Descriptor::XmlNamespace.new(nil, nil),
           cdata: cdata,
@@ -215,8 +226,6 @@ module Shale
       def initialize_dup(other)
         @elements = other.instance_variable_get('@elements').dup
         @attributes = other.instance_variable_get('@attributes').dup
-        @content = other.instance_variable_get('@content').dup
-        @root = other.instance_variable_get('@root').dup
         @default_namespace = other.instance_variable_get('@default_namespace').dup
         @finalized = false
 

data/lib/shale/schema/compiler/complex.rb

@@ -23,32 +23,52 @@ module Shale
         # @api private
         attr_reader :properties
 
-        # Name setter
+        # Root name setter
         #
         # @param [String] val
         #
         # @api private
-        attr_writer :name
+        attr_writer :root_name
 
         # Initialize object
         #
         # @param [String] id
-        # @param [String] name
+        # @param [String] root_name
+        # @param [String, nil] package
         #
         # @api private
-        def initialize(id, name)
+        def initialize(id, root_name, package)
           @id = id
-          @name = name
+          @root_name = root_name
+          @package = package ? Utils.classify(package) : nil
           @properties = []
         end
 
-        # Return name
+        # Return base name
+        #
+        # @return [String]
+        #
+        # @api private
+        def root_name
+          Utils.classify(@root_name)
+        end
+
+        # Return namespaced name
         #
         # @return [String]
         #
         # @api private
         def name
-          Utils.classify(@name)
+          Utils.classify([@package, @root_name].compact.join('::'))
+        end
+
+        # Return module names
+        #
+        # @return [Array<String>]
+        #
+        # @api private
+        def modules
+          (@package || '').split('::')
         end
 
         # Return file name
@@ -57,7 +77,31 @@ module Shale
         #
         # @api private
         def file_name
-          Utils.snake_case(@name)
+          Utils.snake_case(name)
+        end
+
+        # Return relative path to target
+        #
+        # @param [String] target
+        #
+        # @return [String]
+        #
+        # @api private
+        def relative_path(target)
+          base_paths = file_name.split('/')
+          target_paths = target.split('/')
+
+          common_paths_length = 0
+
+          base_paths.length.times do |i|
+            break if base_paths[i] != target_paths[i]
+            common_paths_length += 1
+          end
+
+          unique_base_paths = base_paths[common_paths_length..-1]
+          unique_target_paths = target_paths[common_paths_length..-1]
+
+          ((0...unique_base_paths.length - 1).map { '..' } + unique_target_paths).join('/')
         end
 
         # Return references

data/lib/shale/schema/compiler/xml_complex.rb

@@ -33,14 +33,15 @@ module Shale
         # Initialize object
         #
         # @param [String] id
-        # @param [String] name
+        # @param [String] root_name
         # @param [String] prefix
         # @param [String] namespace
+        # @param [String, nil] package
         #
         # @api private
-        def initialize(id, name, prefix, namespace)
-          super(id, name)
-          @root = name
+        def initialize(id, root_name, prefix, namespace, package)
+          super(id, root_name, package)
+          @root = root_name
           @prefix = prefix
           @namespace = namespace
         end

data/lib/shale/schema/json_compiler.rb

@@ -4,6 +4,7 @@ require 'erb'
 require 'uri'
 
 require_relative '../../shale'
+require_relative '../utils'
 require_relative 'compiler/boolean'
 require_relative 'compiler/complex'
 require_relative 'compiler/date'
@@ -31,29 +32,37 @@ module Shale
         <%- unless type.references.empty? -%>
 
         <%- type.references.each do |property| -%>
-        require_relative '<%= property.type.file_name %>'
+        require_relative '<%= type.relative_path(property.type.file_name) %>'
         <%- end -%>
         <%- end -%>
 
-        class <%= type.name %> < Shale::Mapper
+        <%- type.modules.each_with_index do |name, i| -%>
+        <%= '  ' * i %>module <%= name %>
+        <%- end -%>
+        <%- indent = '  ' * type.modules.length -%>
+        <%= indent %>class <%= type.root_name %> < Shale::Mapper
           <%- type.properties.each do |property| -%>
-          attribute :<%= property.attribute_name %>, <%= property.type.name -%>
+          <%= indent %>attribute :<%= property.attribute_name %>, <%= property.type.name -%>
           <%- if property.collection? %>, collection: true<% end -%>
           <%- unless property.default.nil? %>, default: -> { <%= property.default %> }<% end %>
           <%- end -%>
 
-          json do
+          <%= indent %>json do
             <%- type.properties.each do |property| -%>
-            map '<%= property.mapping_name %>', to: :<%= property.attribute_name %>
+            <%= indent %>map '<%= property.mapping_name %>', to: :<%= property.attribute_name %>
             <%- end -%>
-          end
-        end
+          <%= indent %>end
+        <%= indent %>end
+        <%- type.modules.length.times do |i| -%>
+        <%= '  ' * (type.modules.length - i - 1) %>end
+        <%- end -%>
       TEMPLATE
 
       # Generate Shale models from JSON Schema and return them as a Ruby Array of objects
       #
       # @param [Array<String>] schemas
       # @param [String, nil] root_name
+      # @param [Hash<String, String>, nil] namespace_mapping
       #
       # @raise [SchemaError] when JSON Schema has errors
       #
@@ -63,12 +72,13 @@ module Shale
       #   Shale::Schema::JSONCompiler.new.as_models([schema1, schema2])
       #
       # @api public
-      def as_models(schemas, root_name: nil)
+      def as_models(schemas, root_name: nil, namespace_mapping: nil)
         schemas = schemas.map do |schema|
           Shale.json_adapter.load(schema)
         end
 
         @root_name = root_name
+        @namespace_mapping = namespace_mapping || {}
         @schema_repository = {}
         @types = []
 
@@ -89,7 +99,7 @@ module Shale
           duplicates[type.name] += 1
 
           if total_duplicates[type.name] > 1
-            type.name = format("#{type.name}%d", duplicates[type.name])
+            type.root_name = format("#{type.root_name}%d", duplicates[type.name])
           end
         end
 
@@ -100,6 +110,7 @@ module Shale
       #
       # @param [Array<String>] schemas
       # @param [String, nil] root_name
+      # @param [Hash<String, String>, nil] namespace_mapping
       #
       # @raise [SchemaError] when JSON Schema has errors
       #
@@ -109,8 +120,8 @@ module Shale
       #   Shale::Schema::JSONCompiler.new.to_models([schema1, schema2])
       #
       # @api public
-      def to_models(schemas, root_name: nil)
-        types = as_models(schemas, root_name: root_name)
+      def to_models(schemas, root_name: nil, namespace_mapping: nil)
+        types = as_models(schemas, root_name: root_name, namespace_mapping: namespace_mapping)
 
         types.to_h do |type|
           [type.file_name, MODEL_TEMPLATE.result(binding)]
@@ -207,7 +218,8 @@ module Shale
         end
 
         if type == 'object'
-          Compiler::Complex.new(id, name)
+          base_id = Utils.presence(id.split('#')[0])
+          Compiler::Complex.new(id, name, @namespace_mapping[base_id])
         elsif type == 'string' && format == 'date'
           Compiler::Date.new
         elsif type == 'string' && format == 'date-time'
@@ -297,7 +309,9 @@ module Shale
         if schema.is_a?(Hash) && schema.key?('$ref')
           entry = resolve_ref(id, schema['$ref'])
           schema = entry[:schema]
-          fragment = entry[:id].split('/') - ['#']
+          entry_id, entry_fragment = entry[:id].split('#')
+          id = build_id(id, entry_id)
+          fragment = (entry_fragment || '').split('/') - ['']
         end
 
         pointer = entry[:id] || build_pointer(id, fragment)

data/lib/shale/schema/json_generator.rb

@@ -87,7 +87,7 @@ module Shale
             next unless attribute
 
             if mapper_type?(attribute.type)
-              json_type = Ref.new(mapping.name, attribute.type.name)
+              json_type = Ref.new(mapping.name, attribute.type.model.name)
             else
               json_klass = self.class.get_json_type(attribute.type)
 
@@ -103,7 +103,7 @@ module Shale
             properties << json_type
           end
 
-          objects << Object.new(type.name, properties)
+          objects << Object.new(type.model.name, properties)
         end
 
         Schema.new(objects, id: id, title: title, description: description).as_json

data/lib/shale/schema/xml_compiler.rb

@@ -139,55 +139,63 @@ module Shale
         <%- unless type.references.empty? -%>
 
         <%- type.references.each do |property| -%>
-        require_relative '<%= property.type.file_name %>'
+        require_relative '<%= type.relative_path(property.type.file_name) %>'
         <%- end -%>
         <%- end -%>
 
-        class <%= type.name %> < Shale::Mapper
+        <%- type.modules.each_with_index do |name, i| -%>
+        <%= '  ' * i %>module <%= name %>
+        <%- end -%>
+        <%- indent = '  ' * type.modules.length -%>
+        <%= indent %>class <%= type.root_name %> < Shale::Mapper
           <%- type.properties.select(&:content?).each do |property| -%>
-          attribute :<%= property.attribute_name %>, <%= property.type.name -%>
+          <%= indent %>attribute :<%= property.attribute_name %>, <%= property.type.name -%>
           <%- if property.collection? %>, collection: true<% end -%>
           <%- unless property.default.nil? %>, default: -> { <%= property.default %> }<% end %>
           <%- end -%>
           <%- type.properties.select(&:attribute?).each do |property| -%>
-          attribute :<%= property.attribute_name %>, <%= property.type.name -%>
+          <%= indent %>attribute :<%= property.attribute_name %>, <%= property.type.name -%>
           <%- if property.collection? %>, collection: true<% end -%>
           <%- unless property.default.nil? %>, default: -> { <%= property.default %> }<% end %>
           <%- end -%>
           <%- type.properties.select(&:element?).each do |property| -%>
-          attribute :<%= property.attribute_name %>, <%= property.type.name -%>
+          <%= indent %>attribute :<%= property.attribute_name %>, <%= property.type.name -%>
           <%- if property.collection? %>, collection: true<% end -%>
           <%- unless property.default.nil? %>, default: -> { <%= property.default %> }<% end %>
           <%- end -%>
 
-          xml do
-            root '<%= type.root %>'
+          <%= indent %>xml do
+            <%= indent %>root '<%= type.root %>'
             <%- if type.namespace -%>
-            namespace '<%= type.namespace %>', '<%= type.prefix %>'
+            <%= indent %>namespace '<%= type.namespace %>', '<%= type.prefix %>'
             <%- end -%>
             <%- unless type.properties.empty? -%>
 
             <%- type.properties.select(&:content?).each do |property| -%>
-            map_content to: :<%= property.attribute_name %>
+            <%= indent %>map_content to: :<%= property.attribute_name %>
             <%- end -%>
             <%- type.properties.select(&:attribute?).each do |property| -%>
-            map_attribute '<%= property.mapping_name %>', to: :<%= property.attribute_name -%>
+            <%= indent %>map_attribute '<%= property.mapping_name %>', to: :<%= property.attribute_name -%>
             <%- if property.namespace %>, prefix: '<%= property.prefix %>'<%- end -%>
             <%- if property.namespace %>, namespace: '<%= property.namespace %>'<% end %>
             <%- end -%>
             <%- type.properties.select(&:element?).each do |property| -%>
-            map_element '<%= property.mapping_name %>', to: :<%= property.attribute_name -%>
+            <%= indent %>map_element '<%= property.mapping_name %>', to: :<%= property.attribute_name -%>
             <%- if type.namespace != property.namespace %>, prefix: <%= property.prefix ? "'\#{property.prefix}'" : 'nil' %><%- end -%>
             <%- if type.namespace != property.namespace %>, namespace: <%= property.namespace ? "'\#{property.namespace}'" : 'nil' %><% end %>
             <%- end -%>
             <%- end -%>
-          end
-        end
+          <%= indent %>end
+        <%= indent %>end
+        <%- type.modules.length.times do |i| -%>
+        <%= '  ' * (type.modules.length - i - 1) %>end
+        <%- end -%>
       TEMPLATE
 
       # Generate Shale models from XML Schema and return them as a Ruby Array of objects
       #
       # @param [Array<String>] schemas
+      # @param [Hash<String, String>, nil] namespace_mapping
       #
       # @raise [AdapterError] when XML adapter is not set or Ox adapter is used
       # @raise [SchemaError] when XML Schema has errors
@@ -198,7 +206,7 @@ module Shale
       #   Shale::Schema::XMLCompiler.new.as_models([schema1, schema2])
       #
       # @api public
-      def as_models(schemas)
+      def as_models(schemas, namespace_mapping: nil)
         unless Shale.xml_adapter
           raise AdapterError, XML_ADAPTER_NOT_SET_MESSAGE
         end
@@ -212,6 +220,7 @@ module Shale
           Shale.xml_adapter.load(schema)
         end
 
+        @namespace_mapping = namespace_mapping || {}
         @elements_repository = {}
         @attributes_repository = {}
         @simple_types_repository = {}
@@ -244,7 +253,7 @@ module Shale
           duplicates[type.name] += 1
 
           if total_duplicates[type.name] > 1
-            type.name = format("#{type.name}%d", duplicates[type.name])
+            type.root_name = format("#{type.root_name}%d", duplicates[type.name])
           end
         end
 
@@ -256,6 +265,7 @@ module Shale
       # Generate Shale models from XML Schema
       #
       # @param [Array<String>] schemas
+      # @param [Hash<String, String>, nil] namespace_mapping
       #
       # @raise [SchemaError] when XML Schema has errors
       #
@@ -265,8 +275,8 @@ module Shale
       #   Shale::Schema::XMLCompiler.new.to_models([schema1, schema2])
       #
       # @api public
-      def to_models(schemas)
-        types = as_models(schemas)
+      def to_models(schemas, namespace_mapping: nil)
+        types = as_models(schemas, namespace_mapping: namespace_mapping)
 
         types.to_h do |type|
           [type.file_name, MODEL_TEMPLATE.result(binding)]
@@ -415,6 +425,10 @@ module Shale
           type = type.sub(/^#{prefix}/, name)
         end
 
+        if namespaces.key?('xmlns') && !type.include?(':')
+          type = "#{namespaces['xmlns']}:#{type}"
+        end
+
         type
       end
 
@@ -535,7 +549,13 @@ module Shale
             name = node.attributes['name'] || node.parent.attributes['name']
             prefix, namespace = resolve_complex_type_namespace(node)
 
-            @complex_types[id] = Compiler::XMLComplex.new(id, name, prefix, namespace)
+            @complex_types[id] = Compiler::XMLComplex.new(
+              id,
+              name,
+              prefix,
+              namespace,
+              @namespace_mapping[namespace]
+            )
           end
         end
       end
@@ -571,6 +591,14 @@ module Shale
         infer_type_from_xs_type(type, namespaces)
       end
 
+      # Infer type from XSD type
+      #
+      # @param [String] type
+      # @param [Hash<String, String>] namespaces
+      #
+      # @return [Shale::Schema::Compiler::<any>]
+      #
+      # @api private
       def infer_type_from_xs_type(type, namespaces)
         type = replace_ns_prefixes(type, namespaces)
 

data/lib/shale/schema/xml_generator.rb

@@ -84,7 +84,7 @@ module Shale
 
         root_element = TypedElement.new(
           name: klass.xml_mapping.unprefixed_root,
-          type: [default_namespace.prefix, schematize(klass.name)].compact.join(':'),
+          type: [default_namespace.prefix, schematize(klass.model.name)].compact.join(':'),
           required: true
         )
 
@@ -195,7 +195,7 @@ module Shale
           end
 
           complex = ComplexType.new(
-            schematize(type.name),
+            schematize(type.model.name),
             children,
             mixed: !type.xml_mapping.content.nil?
           )
@@ -287,7 +287,7 @@ module Shale
       # @api private
       def get_xml_type_for_attribute(type, namespace)
         if mapper_type?(type)
-          [namespace.prefix, schematize(type.name)].compact.join(':')
+          [namespace.prefix, schematize(type.model.name)].compact.join(':')
         else
           "xs:#{self.class.get_xml_type(type)}"
         end

data/lib/shale/schema.rb

@@ -38,6 +38,7 @@ module Shale
     #
     # @param [Array<String>] schemas
     # @param [String, nil] root_name
+    # @param [Hash<String, String>, nil] namespace_mapping
     #
     # @return [Array<String>]
     #
@@ -46,8 +47,12 @@ module Shale
     #   # => [model1, model2, model3]
     #
     # @api public
-    def self.from_json(schemas, root_name: nil)
-      JSONCompiler.new.to_models(schemas, root_name: root_name)
+    def self.from_json(schemas, root_name: nil, namespace_mapping: nil)
+      JSONCompiler.new.to_models(
+        schemas,
+        root_name: root_name,
+        namespace_mapping: namespace_mapping
+      )
     end
 
     # Generate XML Schema from Shale model
@@ -71,6 +76,7 @@ module Shale
     # Generate Shale model from XML Schema
     #
     # @param [Array<String>] schemas
+    # @param [Hash<String, String>, nil] namespace_mapping
     #
     # @return [Array<String>]
     #
@@ -79,8 +85,8 @@ module Shale
     #   # => [model1, model2, model3]
     #
     # @api public
-    def self.from_xml(schemas)
-      XMLCompiler.new.to_models(schemas)
+    def self.from_xml(schemas, namespace_mapping: nil)
+      XMLCompiler.new.to_models(schemas, namespace_mapping: namespace_mapping)
     end
   end
 end