shale 0.9.0 → 1.0.0

data/lib/shale/mapping/descriptor/xml.rb

@@ -26,7 +26,8 @@ module Shale
         # Initialize instance
         #
         # @param [String] name
-        # @param [Symbol, String] attribute
+        # @param [Symbol, nil] attribute
+        # @param [Symbol, nil] receiver
         # @param [Hash, nil] methods
         # @param [String, nil] group
         # @param [Shale::Mapping::XmlNamespace] namespace
@@ -34,10 +35,20 @@ module Shale
         # @param [true, false] render_nil
         #
         # @api private
-        def initialize(name:, attribute:, methods:, group:, namespace:, cdata:, render_nil:)
+        def initialize(
+          name:,
+          attribute:,
+          receiver:,
+          methods:,
+          group:,
+          namespace:,
+          cdata:,
+          render_nil:
+        )
           super(
             name: name,
             attribute: attribute,
+            receiver: receiver,
             methods: methods,
             group: group,
             render_nil: render_nil

data/lib/shale/mapping/dict.rb

@@ -5,22 +5,32 @@ require_relative 'dict_group'
 
 module Shale
   module Mapping
-    # Mapping for dictionary serialization formats (Hash/JSON/YAML)
+    # Mapping for dictionary serialization formats (Hash/JSON/YAML/TOML/CSV)
     #
     # @api private
     class Dict < DictBase
       # Map key to attribute
       #
       # @param [String] key Document's key
-      # @param [Symbol, nil] to Object's attribute
+      # @param [Symbol, nil] to
+      # @param [Symbol, nil] receiver
       # @param [Hash, nil] using
       # @param [true, false, nil] render_nil
       #
       # @raise [IncorrectMappingArgumentsError] when arguments are incorrect
       #
       # @api private
-      def map(key, to: nil, using: nil, render_nil: nil)
-        super(key, to: to, using: using, render_nil: render_nil)
+      def map(key, to: nil, receiver: nil, using: nil, render_nil: nil)
+        super(key, to: to, receiver: receiver, using: using, render_nil: render_nil)
+      end
+
+      # Set render_nil default
+      #
+      # @param [true, false] val
+      #
+      # @api private
+      def render_nil(val)
+        @render_nil_default = val
       end
 
       # Map group of keys to mapping methods

data/lib/shale/mapping/dict_base.rb

@@ -5,7 +5,7 @@ require_relative 'validator'
 
 module Shale
   module Mapping
-    # Base class for Mapping dictionary serialization formats (Hash/JSON/YAML)
+    # Base class for Mapping dictionary serialization formats (Hash/JSON/YAML/TOML/CSV)
     #
     # @api private
     class DictBase
@@ -31,6 +31,7 @@ module Shale
       #
       # @param [String] key
       # @param [Symbol, nil] to
+      # @param [Symbol, nil] receiver
       # @param [Hash, nil] using
       # @param [String, nil] group
       # @param [true, false, nil] render_nil
@@ -38,11 +39,13 @@ module Shale
       # @raise [IncorrectMappingArgumentsError] when arguments are incorrect
       #
       # @api private
-      def map(key, to: nil, using: nil, group: nil, render_nil: nil)
-        Validator.validate_arguments(key, to, using)
+      def map(key, to: nil, receiver: nil, using: nil, group: nil, render_nil: nil)
+        Validator.validate_arguments(key, to, receiver, using)
+
         @keys[key] = Descriptor::Dict.new(
           name: key,
           attribute: to,
+          receiver: receiver,
           methods: using,
           group: group,
           render_nil: render_nil.nil? ? @render_nil_default : render_nil

data/lib/shale/mapping/dict_group.rb

@@ -4,7 +4,7 @@ require_relative 'dict_base'
 
 module Shale
   module Mapping
-    # Group for dictionary serialization formats (Hash/JSON/YAML)
+    # Group for dictionary serialization formats (Hash/JSON/YAML/TOML/CSV)
     #
     # @api private
     class DictGroup < DictBase

data/lib/shale/mapping/validator.rb

@@ -8,18 +8,25 @@ module Shale
       # Validate correctness of argument passed to map functions
       #
       # @param [String] key
-      # @param [Symbol] to
-      # @param [Hash] using
+      # @param [Symbol, nil] to
+      # @param [Symbol, nil] receiver
+      # @param [Hash, nil] using
       #
       # @raise [IncorrectMappingArgumentsError] when arguments are incorrect
       #
       # @api private
-      def self.validate_arguments(key, to, using)
+      def self.validate_arguments(key, to, receiver, using)
         if to.nil? && using.nil?
           msg = ":to or :using argument is required for mapping '#{key}'"
           raise IncorrectMappingArgumentsError, msg
         end
 
+        if to.nil? && !receiver.nil?
+          msg = ":receiver argument for mapping '#{key}' " \
+                'can only be used together with :to argument'
+          raise IncorrectMappingArgumentsError, msg
+        end
+
         if !using.nil? && (using[:from].nil? || using[:to].nil?)
           msg = ":using argument for mapping '#{key}' requires :to and :from keys"
           raise IncorrectMappingArgumentsError, msg

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