shale 0.9.0 → 1.1.0

data/lib/shale/mapper.rb

@@ -151,7 +151,7 @@ module Shale
       # @raise [DefaultNotCallableError] when attribute's default is not callable
       #
       # @example
-      #   calss Person < Shale::Mapper
+      #   class Person < Shale::Mapper
       #     attribute :first_name, Shale::Type::String
       #     attribute :last_name, Shale::Type::String
       #     attribute :age, Shale::Type::Integer, default: -> { 1 }
@@ -200,7 +200,7 @@ module Shale
       # @param [Proc] block
       #
       # @example
-      #   calss Person < Shale::Mapper
+      #   class Person < Shale::Mapper
       #     attribute :first_name, Shale::Type::String
       #     attribute :last_name, Shale::Type::String
       #     attribute :age, Shale::Type::Integer
@@ -224,7 +224,7 @@ module Shale
       # @param [Proc] block
       #
       # @example
-      #   calss Person < Shale::Mapper
+      #   class Person < Shale::Mapper
       #     attribute :first_name, Shale::Type::String
       #     attribute :last_name, Shale::Type::String
       #     attribute :age, Shale::Type::Integer
@@ -248,7 +248,7 @@ module Shale
       # @param [Proc] block
       #
       # @example
-      #   calss Person < Shale::Mapper
+      #   class Person < Shale::Mapper
       #     attribute :first_name, Shale::Type::String
       #     attribute :last_name, Shale::Type::String
       #     attribute :age, Shale::Type::Integer
@@ -272,7 +272,7 @@ module Shale
       # @param [Proc] block
       #
       # @example
-      #   calss Person < Shale::Mapper
+      #   class Person < Shale::Mapper
       #     attribute :first_name, Shale::Type::String
       #     attribute :last_name, Shale::Type::String
       #     attribute :age, Shale::Type::Integer
@@ -296,7 +296,7 @@ module Shale
       # @param [Proc] block
       #
       # @example
-      #   calss Person < Shale::Mapper
+      #   class Person < Shale::Mapper
       #     attribute :first_name, Shale::Type::String
       #     attribute :last_name, Shale::Type::String
       #     attribute :age, Shale::Type::Integer
@@ -320,7 +320,7 @@ module Shale
       # @param [Proc] block
       #
       # @example
-      #   calss Person < Shale::Mapper
+      #   class Person < Shale::Mapper
       #     attribute :first_name, Shale::Type::String
       #     attribute :last_name, Shale::Type::String
       #     attribute :age, Shale::Type::Integer

data/lib/shale/mapping/delegates.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+module Shale
+  module Mapping
+    # Class for handling attribute delegation
+    #
+    # @api private
+    class Delegates
+      # Class representing individual delegation
+      #
+      # @api private
+      class Delegate
+        # Return receiver_attribute
+        #
+        # @return [Shale::Attribute]
+        #
+        # @api private
+        attr_reader :receiver_attribute
+
+        # Return attribute setter on a delegate
+        #
+        # @return [String]
+        #
+        # @api private
+        attr_reader :setter
+
+        # Return value to set on a delegate
+        #
+        # @return [any]
+        #
+        # @api private
+        attr_reader :value
+
+        # Initialize instance
+        #
+        # @param [Shale::Attribute] receiver_attribute
+        # @param [String] setter
+        # @param [any] value
+        #
+        # @api private
+        def initialize(receiver_attribute, setter, value)
+          @receiver_attribute = receiver_attribute
+          @setter = setter
+          @value = value
+        end
+      end
+
+      # Initialize instance
+      #
+      # @api private
+      def initialize
+        @delegates = []
+      end
+
+      # Add single value to delegate
+      #
+      # @param [Shale::Attribute] receiver_attribute
+      # @param [String] setter
+      # @param [any] value
+      #
+      # @api private
+      def add(receiver_attribute, setter, value)
+        @delegates << Delegate.new(receiver_attribute, setter, value)
+      end
+
+      # Add collection to delegate
+      #
+      # @param [Shale::Attribute] receiver_attribute
+      # @param [String] setter
+      # @param [any] value
+      #
+      # @api private
+      def add_collection(receiver_attribute, setter, value)
+        delegate = @delegates.find do |e|
+          e.receiver_attribute == receiver_attribute && e.setter == setter
+        end
+
+        if delegate
+          delegate.value << value
+        else
+          @delegates << Delegate.new(receiver_attribute, setter, [value])
+        end
+      end
+
+      # Iterate over delegates and yield a block
+      #
+      # @param [Proc] block
+      #
+      # @api private
+      def each(&block)
+        @delegates.each(&block)
+      end
+    end
+  end
+end

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

@@ -21,6 +21,13 @@ module Shale
         # @api private
         attr_reader :attribute
 
+        # Return receiver name
+        #
+        # @return [Symbol]
+        #
+        # @api private
+        attr_reader :receiver
+
         # Return method symbol
         #
         # @return [Symbol]
@@ -42,20 +49,31 @@ module Shale
         # @api private
         attr_reader :group
 
+        # Return schema hash
+        #
+        # @return [Hash]
+        #
+        # @api private
+        attr_reader :schema
+
         # Initialize instance
         #
         # @param [String] name
         # @param [Symbol, nil] attribute
+        # @param [Symbol, nil] receiver
         # @param [Hash, nil] methods
         # @param [String, nil] group
         # @param [true, false] render_nil
+        # @param [Hash, nil] schema
         #
         # @api private
-        def initialize(name:, attribute:, methods:, group:, render_nil:)
+        def initialize(name:, attribute:, receiver:, methods:, group:, render_nil:, schema: nil)
           @name = name
           @attribute = attribute
+          @receiver = receiver
           @group = group
           @render_nil = render_nil
+          @schema = schema
 
           if methods
             @method_from = methods[:from]

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,33 @@ 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
+      # @param [Hash, nil] schema
       #
       # @raise [IncorrectMappingArgumentsError] when arguments are incorrect
       #
+      # @api public
+      def map(key, to: nil, receiver: nil, using: nil, render_nil: nil, schema: nil)
+        super(key, to: to, receiver: receiver, using: using, render_nil: render_nil, schema: schema)
+      end
+
+      # Set render_nil default
+      #
+      # @param [true, false] val
+      #
       # @api private
-      def map(key, to: nil, using: nil, render_nil: nil)
-        super(key, to: to, using: using, render_nil: render_nil)
+      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
@@ -16,6 +16,13 @@ module Shale
       # @api private
       attr_reader :keys
 
+      # Return hash for hash with properties for root Object
+      #
+      # @return [Hash]
+      #
+      # @api private
+      attr_reader :root
+
       # Initialize instance
       #
       # @param [true, false] render_nil_default
@@ -23,6 +30,7 @@ module Shale
       # @api private
       def initialize(render_nil_default: false)
         @keys = {}
+        @root = {}
         @finalized = false
         @render_nil_default = render_nil_default
       end
@@ -31,24 +39,44 @@ 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
+      # @param [Hash, nil] schema
       #
       # @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, schema: 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
+          render_nil: render_nil.nil? ? @render_nil_default : render_nil,
+          schema: schema
         )
       end
 
+      # Allow schema properties to be set on the object
+      #
+      # @param [Integer] min_properties
+      # @param [Integer] max_properties
+      # @param [Hash] dependent_required
+      #
+      # @api public
+      def properties(min_properties: nil, max_properties: nil, dependent_required: nil)
+        @root = {
+          min_properties: min_properties,
+          max_properties: max_properties,
+          dependent_required: dependent_required,
+        }
+      end
+
       # Set the "finalized" instance variable to true
       #
       # @api private

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