shale 0.7.1 → 0.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 468fc4f3fa1ccd796958748eea653aaa9aec0dbf223c2e5486ddba00350d79fc
-  data.tar.gz: 4b78746e97bc6fd080b8a6566be2534c3a1c05017acacabd3935f7e2ea81b097
+  metadata.gz: 76c0022b3d2d42be143362c84c6697628781acdce7694fb9bc0f305d3f854964
+  data.tar.gz: 0b0b1b060eab81ebfae80afa3c31c809280b66ebd77e413c5908c4bbd09a081a
 SHA512:
-  metadata.gz: 776a30c22e95f8c85e150b64ec7df09e89aeb4e86fb2f6f0fcec67a438b13b73926c3d5419b8194f457a2f09fc8eb64bf491e8b1ea5c5d6957e1e1b5cfab9549
-  data.tar.gz: 0d236bde4f3b5aaf9b3ea5a5b8380b3861b24f5d0b310430329c68d010c368890dedbd7f6fad8649b71cd443362c8c6272ebb9c7a234998fa546ecb99e728f44
+  metadata.gz: 43bc9188d1f07c5c367a8ed94e2a3da6b878a7b7b86773d7898697abbd3937d4de6ae0471f9362c72e8a6be2cc5e5100a5206b2f2cc7155ff2ff8784953ef702
+  data.tar.gz: 0e610703cc73809a78007785962d9a322e515b88ab143a55adfeaa1a0da5961f14d8768a3dec4ad797070bbab165c238123702cbc671f522f86e2934968ff78b

data/CHANGELOG.md

@@ -1,9 +1,19 @@
-## [0.7.1] - [2022-08-12]
+## [0.8.0] - 2022-08-30
+
+### Added
+- Allow to group mappings using `group` block
+- Bring back Ruby 2.6 support
+
+### Changed
+- Use anonymous module for attributes definition.
+  It allows to override accessors and `super` works as expected.
+
+## [0.7.1] - 2022-08-12
 
 ### Fixed
 - Fix broken handling of Date and Time types
 
-## [0.7.0] - [2022-08-09]
+## [0.7.0] - 2022-08-09
 
 ### Added
 - `only: []` and `except: []` options that allow to controll what attributes are rendered/parsed

data/README.md

@@ -17,7 +17,7 @@ Documentation with interactive examples is available at [Shale website](https://
 
 ## Installation
 
-Shale supports Ruby (MRI) 2.7+
+Shale supports Ruby (MRI) 2.6+
 
 Add this line to your application's Gemfile:
 
@@ -729,6 +729,55 @@ end
 Person.new(password: 'secret').to_json(context: current_user)
 ```
 
+If you want to work on multiple elements at a time you can group them using `group` block:
+
+```ruby
+class Person < Shale::Mapper
+  attribute :name, Shale::Type::String
+
+  json do
+    group from: :name_from_json, to: :name_to_json do
+      map 'first_name'
+      map 'last_name'
+    end
+  end
+
+  xml do
+    group from: :name_from_xml, to: :name_to_xml do
+      map_content
+      map_element 'first_name'
+      map_attribute 'last_name'
+    end
+  end
+
+  def name_from_json(model, value)
+    model.name = "#{value['first_name']} #{value['last_name']}"
+  end
+
+  def name_to_json(model, doc)
+    doc['first_name'] = model.name.split(' ')[0]
+    doc['last_name'] = model.name.split(' ')[1]
+  end
+
+  def name_from_xml(model, value)
+    # value => { content: ..., attributes: {}, elements: {} }
+  end
+
+  def name_to_xml(model, element, doc)
+    # ...
+  end
+end
+
+Person.from_json(<<~DATA)
+{
+  "first_name": "John",
+  "last_name": "Doe"
+}
+DATA
+
+# => #<Person:0x00007f9bc3086d60 @name="John Doe">
+```
+
 ### Additional options
 
 You can control which attributes to render and parse by

data/lib/shale/mapper.rb

@@ -98,6 +98,10 @@ module Shale
       def inherited(subclass)
         super
 
+        attributes_module = Module.new
+        subclass.instance_variable_set('@attributes_module', attributes_module)
+        subclass.include(attributes_module)
+
         subclass.instance_variable_set('@model', subclass)
         subclass.instance_variable_set('@attributes', @attributes.dup)
 
@@ -171,7 +175,7 @@ module Shale
         @toml_mapping.map(name.to_s, to: name) unless @toml_mapping.finalized?
         @xml_mapping.map_element(name.to_s, to: name) unless @xml_mapping.finalized?
 
-        class_eval(<<-RUBY, __FILE__, __LINE__ + 1)
+        @attributes_module.class_eval(<<-RUBY, __FILE__, __LINE__ + 1)
           attr_reader :#{name}
 
           def #{name}=(val)

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

@@ -35,17 +35,26 @@ module Shale
         # @api private
         attr_reader :method_to
 
+        # Return group name
+        #
+        # @return [String]
+        #
+        # @api private
+        attr_reader :group
+
         # Initialize instance
         #
         # @param [String] name
         # @param [Symbol, nil] attribute
         # @param [Hash, nil] methods
+        # @param [String, nil] group
         # @param [true, false] render_nil
         #
         # @api private
-        def initialize(name:, attribute:, methods:, render_nil:)
+        def initialize(name:, attribute:, methods:, group:, render_nil:)
           @name = name
           @attribute = attribute
+          @group = group
           @render_nil = render_nil
 
           if methods

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

@@ -28,13 +28,21 @@ module Shale
         # @param [String] name
         # @param [Symbol, String] attribute
         # @param [Hash, nil] methods
+        # @param [String, nil] group
         # @param [Shale::Mapping::XmlNamespace] namespace
         # @param [true, false] cdata
         # @param [true, false] render_nil
         #
         # @api private
-        def initialize(name:, attribute:, methods:, namespace:, cdata:, render_nil:)
-          super(name: name, attribute: attribute, methods: methods, render_nil: render_nil)
+        def initialize(name:, attribute:, methods:, group:, namespace:, cdata:, render_nil:)
+          super(
+            name: name,
+            attribute: attribute,
+            methods: methods,
+            group: group,
+            render_nil: render_nil
+          )
+
           @namespace = namespace
           @cdata = cdata
         end
@@ -47,6 +55,15 @@ module Shale
         def prefixed_name
           [namespace.prefix, name].compact.join(':')
         end
+
+        # Return name with XML namespace
+        #
+        # @return [String]
+        #
+        # @api private
+        def namespaced_name
+          [namespace.name, name].compact.join(':')
+        end
       end
     end
   end

data/lib/shale/mapping/dict.rb

@@ -1,30 +1,14 @@
 # frozen_string_literal: true
 
-require_relative 'descriptor/dict'
-require_relative 'validator'
+require_relative 'dict_base'
+require_relative 'dict_group'
 
 module Shale
   module Mapping
     # Mapping for dictionary serialization formats (Hash/JSON/YAML)
     #
     # @api private
-    class Dict
-      # Return keys mapping hash
-      #
-      # @return [Hash]
-      #
-      # @api private
-      attr_reader :keys
-
-      # Initialize instance
-      #
-      # @api private
-      def initialize
-        super
-        @keys = {}
-        @finalized = false
-      end
-
+    class Dict < DictBase
       # Map key to attribute
       #
       # @param [String] key Document's key
@@ -36,36 +20,20 @@ module Shale
       #
       # @api private
       def map(key, to: nil, using: nil, render_nil: false)
-        Validator.validate_arguments(key, to, using)
-        @keys[key] = Descriptor::Dict.new(
-          name: key,
-          attribute: to,
-          methods: using,
-          render_nil: render_nil
-        )
+        super(key, to: to, using: using, render_nil: render_nil)
       end
 
-      # Set the "finalized" instance variable to true
+      # Map group of keys to mapping methods
       #
-      # @api private
-      def finalize!
-        @finalized = true
-      end
-
-      # Query the "finalized" instance variable
-      #
-      # @return [truem false]
+      # @param [Symbol] from
+      # @param [Symbol] to
+      # @param [Proc] block
       #
       # @api private
-      def finalized?
-        @finalized
-      end
-
-      # @api private
-      def initialize_dup(other)
-        @keys = other.instance_variable_get('@keys').dup
-        @finalized = false
-        super
+      def group(from:, to:, &block)
+        group = DictGroup.new(from, to)
+        group.instance_eval(&block)
+        @keys.merge!(group.keys)
       end
     end
   end

data/lib/shale/mapping/dict_base.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+require_relative 'descriptor/dict'
+require_relative 'validator'
+
+module Shale
+  module Mapping
+    # Base class for Mapping dictionary serialization formats (Hash/JSON/YAML)
+    #
+    # @api private
+    class DictBase
+      # Return keys mapping hash
+      #
+      # @return [Hash]
+      #
+      # @api private
+      attr_reader :keys
+
+      # Initialize instance
+      #
+      # @api private
+      def initialize
+        @keys = {}
+        @finalized = false
+      end
+
+      # Map key to attribute
+      #
+      # @param [String] key
+      # @param [Symbol, nil] to
+      # @param [Hash, nil] using
+      # @param [String, nil] group
+      # @param [true, false] render_nil
+      #
+      # @raise [IncorrectMappingArgumentsError] when arguments are incorrect
+      #
+      # @api private
+      def map(key, to: nil, using: nil, group: nil, render_nil: false)
+        Validator.validate_arguments(key, to, using)
+        @keys[key] = Descriptor::Dict.new(
+          name: key,
+          attribute: to,
+          methods: using,
+          group: group,
+          render_nil: render_nil
+        )
+      end
+
+      # Set the "finalized" instance variable to true
+      #
+      # @api private
+      def finalize!
+        @finalized = true
+      end
+
+      # Query the "finalized" instance variable
+      #
+      # @return [truem false]
+      #
+      # @api private
+      def finalized?
+        @finalized
+      end
+
+      # @api private
+      def initialize_dup(other)
+        @keys = other.instance_variable_get('@keys').dup
+        @finalized = false
+        super
+      end
+    end
+  end
+end

data/lib/shale/mapping/dict_group.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require_relative 'dict_base'
+
+module Shale
+  module Mapping
+    # Group for dictionary serialization formats (Hash/JSON/YAML)
+    #
+    # @api private
+    class DictGroup < DictBase
+      # Return name of the group
+      #
+      # @return [String]
+      #
+      # @api private
+      attr_reader :name
+
+      # Initialize instance
+      #
+      # @param [Symbol] from
+      # @param [Symbol] to
+      #
+      # @api private
+      def initialize(from, to)
+        super()
+        @from = from
+        @to = to
+        @name = "group_#{hash}"
+      end
+
+      # Map key to attribute
+      #
+      # @param [String] key
+      #
+      # @api private
+      def map(key)
+        super(key, using: { from: @from, to: @to }, group: @name)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module Shale
+  module Mapping
+    module Group
+      # Dict group descriptor
+      #
+      # @api private
+      class Dict
+        # Return method_from
+        #
+        # @return [Symbol]
+        #
+        # @api private
+        attr_reader :method_from
+
+        # Return method_to
+        #
+        # @return [Symbol]
+        #
+        # @api private
+        attr_reader :method_to
+
+        # Return dict hash
+        #
+        # @return [Hash]
+        #
+        # @api private
+        attr_reader :dict
+
+        # Initialize instance
+        #
+        # @param [Symbol] method_from
+        # @param [Symbol] method_to
+        #
+        # @api private
+        def initialize(method_from, method_to)
+          @method_from = method_from
+          @method_to = method_to
+          @dict = {}
+        end
+
+        # Add key-value pair to a group
+        #
+        # @param [String] key
+        # @param [any] value
+        #
+        # @api private
+        def add(key, value)
+          @dict[key] = value
+        end
+      end
+    end
+  end
+end

data/lib/shale/mapping/group/dict_grouping.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require_relative 'dict'
+
+module Shale
+  module Mapping
+    module Group
+      # Class representing mapping group for JSON/YAML/TOML
+      #
+      # @api private
+      class DictGrouping
+        # Initialize instance
+        #
+        # @api private
+        def initialize
+          @groups = {}
+        end
+
+        # Add a value to a group
+        #
+        # @param [Shale::Mapping::Descriptor::Dict] mapping
+        # @param [any] value
+        #
+        # @api private
+        def add(mapping, value)
+          group = @groups[mapping.group] ||= Dict.new(mapping.method_from, mapping.method_to)
+          group.add(mapping.name, value)
+        end
+
+        # Iterate over groups
+        #
+        # @param [Proc] block
+        #
+        # @api private
+        def each(&block)
+          @groups.values.each(&block)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require_relative 'dict'
+
+module Shale
+  module Mapping
+    module Group
+      # Xml group descriptor
+      #
+      # @api private
+      class Xml < Dict
+        # Initialize instance
+        #
+        # @param [Symbol] method_from
+        # @param [Symbol] method_to
+        #
+        # @api private
+        def initialize(method_from, method_to)
+          super(method_from, method_to)
+          @dict = { content: nil, attributes: {}, elements: {} }
+        end
+
+        # Add key-value pair to a group
+        #
+        # @param [Symbol] kind
+        # @param [String] key
+        # @param [any] value
+        #
+        # @api private
+        def add(kind, key, value)
+          case kind
+          when :content
+            @dict[:content] = value
+          when :attribute
+            @dict[:attributes][key] = value
+          when :element
+            @dict[:elements][key] = value
+          end
+        end
+      end
+    end
+  end
+end

data/lib/shale/mapping/group/xml_grouping.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require_relative 'dict_grouping'
+require_relative 'xml'
+
+module Shale
+  module Mapping
+    module Group
+      # Class representing mapping group for XML
+      #
+      # @api private
+      class XmlGrouping < DictGrouping
+        # Add a value to a group
+        #
+        # @param [Shale::Mapping::Descriptor::Dict] mapping
+        # @param [Symbol] kind
+        # @param [any] value
+        #
+        # @api private
+        def add(mapping, kind, value)
+          group = @groups[mapping.group] ||= Xml.new(mapping.method_from, mapping.method_to)
+          group.add(kind, mapping.namespaced_name, value)
+        end
+      end
+    end
+  end
+end

data/lib/shale/mapping/xml.rb

@@ -1,80 +1,23 @@
 # frozen_string_literal: true
 
-require_relative 'descriptor/xml'
-require_relative 'descriptor/xml_namespace'
-require_relative 'validator'
+require_relative 'xml_base'
+require_relative 'xml_group'
 
 module Shale
   module Mapping
-    class Xml
-      # Return elements mapping hash
-      #
-      # @return [Hash]
-      #
-      # @api private
-      attr_reader :elements
-
-      # Return attributes mapping hash
-      #
-      # @return [Hash]
-      #
-      # @api private
-      attr_reader :attributes
-
-      # Return content mapping
-      #
-      # @return [Symbol]
-      #
-      # @api private
-      attr_reader :content
-
-      # Return default namespace
-      #
-      # @return [Shale::Mapping::Descriptor::XmlNamespace]
-      #
-      # @api private
-      attr_reader :default_namespace
-
-      # Return unprefixed root
-      #
-      # @return [String]
-      #
-      # @api private
-      def unprefixed_root
-        @root
-      end
-
-      # Return prefixed root
-      #
-      # @return [String]
-      #
-      # @api private
-      def prefixed_root
-        [default_namespace.prefix, @root].compact.join(':')
-      end
-
-      # Initialize instance
-      #
-      # @api private
-      def initialize
-        super
-        @elements = {}
-        @attributes = {}
-        @content = nil
-        @root = ''
-        @default_namespace = Descriptor::XmlNamespace.new
-        @finalized = false
-      end
-
+    # Mapping for XML serialization format
+    #
+    # @api private
+    class Xml < XmlBase
       # Map element to attribute
       #
-      # @param [String] element Document's element
-      # @param [Symbol, nil] to Object's attribute
+      # @param [String] element
+      # @param [Symbol, nil] to
       # @param [Hash, nil] using
       # @param [String, nil] namespace
       # @param [String, nil] prefix
-      #
-      # @raise [IncorrectMappingArgumentsError] when arguments are incorrect
+      # @param [true, false] cdata
+      # @param [true, false] render_nil
       #
       # @api private
       def map_element(
@@ -86,24 +29,12 @@ module Shale
         cdata: false,
         render_nil: false
       )
-        Validator.validate_arguments(element, to, using)
-        Validator.validate_namespace(element, namespace, prefix)
-
-        if namespace == :undefined && prefix == :undefined
-          nsp = default_namespace.name
-          pfx = default_namespace.prefix
-        else
-          nsp = namespace
-          pfx = prefix
-        end
-
-        namespaced_element = [nsp, element].compact.join(':')
-
-        @elements[namespaced_element] = Descriptor::Xml.new(
-          name: element,
-          attribute: to,
-          methods: using,
-          namespace: Descriptor::XmlNamespace.new(nsp, pfx),
+        super(
+          element,
+          to: to,
+          using: using,
+          namespace: namespace,
+          prefix: prefix,
           cdata: cdata,
           render_nil: render_nil
         )
@@ -111,13 +42,12 @@ module Shale
 
       # Map document's attribute to object's attribute
       #
-      # @param [String] attribute Document's attribute
-      # @param [Symbol, nil] to Object's attribute
+      # @param [String] attribute
+      # @param [Symbol, nil] to
       # @param [Hash, nil] using
       # @param [String, nil] namespace
       # @param [String, nil] prefix
-      #
-      # @raise [IncorrectMappingArgumentsError] when arguments are incorrect
+      # @param [true, false] render_nil
       #
       # @api private
       def map_attribute(
@@ -128,85 +58,43 @@ module Shale
         prefix: nil,
         render_nil: false
       )
-        Validator.validate_arguments(attribute, to, using)
-        Validator.validate_namespace(attribute, namespace, prefix)
-
-        namespaced_attribute = [namespace, attribute].compact.join(':')
-
-        @attributes[namespaced_attribute] = Descriptor::Xml.new(
-          name: attribute,
-          attribute: to,
-          methods: using,
-          namespace: Descriptor::XmlNamespace.new(namespace, prefix),
-          cdata: false,
+        super(
+          attribute,
+          to: to,
+          using: using,
+          namespace: namespace,
+          prefix: prefix,
           render_nil: render_nil
         )
       end
 
       # Map document's content to object's attribute
       #
-      # @param [Symbol] to Object's attribute
+      # @param [Symbol] to
+      # @param [Hash, nil] using
+      # @param [true, false] cdata
       #
       # @api private
       def map_content(to: nil, using: nil, cdata: false)
-        Validator.validate_arguments('content', to, using)
-
-        @content = Descriptor::Xml.new(
-          name: nil,
-          attribute: to,
-          methods: using,
-          namespace: nil,
-          cdata: cdata,
-          render_nil: false
-        )
-      end
-
-      # Set the name for root element
-      #
-      # @param [String] value root's name
-      #
-      # @api private
-      def root(value)
-        @root = value
-      end
-
-      # Set default namespace for root element
-      #
-      # @param [String] name
-      # @param [String] prefix
-      #
-      # @api private
-      def namespace(name, prefix)
-        @default_namespace.name = name
-        @default_namespace.prefix = prefix
+        super(to: to, using: using, cdata: cdata)
       end
 
-      # Set the "finalized" instance variable to true
+      # Map group of nodes to mapping methods
       #
-      # @api private
-      def finalize!
-        @finalized = true
-      end
-
-      # Query the "finalized" instance variable
-      #
-      # @return [truem false]
+      # @param [Symbol] from
+      # @param [Symbol] to
+      # @param [Proc] block
       #
       # @api private
-      def finalized?
-        @finalized
-      end
+      def group(from:, to:, &block)
+        group = XmlGroup.new(from, to)
 
-      # @api private
-      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
+        group.namespace(default_namespace.name, default_namespace.prefix)
+        group.instance_eval(&block)
 
-        super
+        @elements.merge!(group.elements)
+        @attributes.merge!(group.attributes)
+        @content = group.content if group.content
       end
     end
   end

data/lib/shale/mapping/xml_base.rb

@@ -0,0 +1,227 @@
+# frozen_string_literal: true
+
+require_relative 'descriptor/xml'
+require_relative 'descriptor/xml_namespace'
+require_relative 'validator'
+
+module Shale
+  module Mapping
+    # Base class for Mapping XML serialization format
+    #
+    # @api private
+    class XmlBase
+      # Return elements mapping hash
+      #
+      # @return [Hash]
+      #
+      # @api private
+      attr_reader :elements
+
+      # Return attributes mapping hash
+      #
+      # @return [Hash]
+      #
+      # @api private
+      attr_reader :attributes
+
+      # Return content mapping
+      #
+      # @return [Symbol]
+      #
+      # @api private
+      attr_reader :content
+
+      # Return default namespace
+      #
+      # @return [Shale::Mapping::Descriptor::XmlNamespace]
+      #
+      # @api private
+      attr_reader :default_namespace
+
+      # Return unprefixed root
+      #
+      # @return [String]
+      #
+      # @api private
+      def unprefixed_root
+        @root
+      end
+
+      # Return prefixed root
+      #
+      # @return [String]
+      #
+      # @api private
+      def prefixed_root
+        [default_namespace.prefix, @root].compact.join(':')
+      end
+
+      # Initialize instance
+      #
+      # @api private
+      def initialize
+        super
+        @elements = {}
+        @attributes = {}
+        @content = nil
+        @root = ''
+        @default_namespace = Descriptor::XmlNamespace.new
+        @finalized = false
+      end
+
+      # Map element to attribute
+      #
+      # @param [String] element
+      # @param [Symbol, nil] to
+      # @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
+      #
+      # @raise [IncorrectMappingArgumentsError] when arguments are incorrect
+      #
+      # @api private
+      def map_element(
+        element,
+        to: nil,
+        using: nil,
+        group: nil,
+        namespace: :undefined,
+        prefix: :undefined,
+        cdata: false,
+        render_nil: false
+      )
+        Validator.validate_arguments(element, to, using)
+        Validator.validate_namespace(element, namespace, prefix)
+
+        if namespace == :undefined && prefix == :undefined
+          nsp = default_namespace.name
+          pfx = default_namespace.prefix
+        else
+          nsp = namespace
+          pfx = prefix
+        end
+
+        namespaced_element = [nsp, element].compact.join(':')
+
+        @elements[namespaced_element] = Descriptor::Xml.new(
+          name: element,
+          attribute: to,
+          methods: using,
+          group: group,
+          namespace: Descriptor::XmlNamespace.new(nsp, pfx),
+          cdata: cdata,
+          render_nil: render_nil
+        )
+      end
+
+      # Map document's attribute to object's attribute
+      #
+      # @param [String] attribute
+      # @param [Symbol, nil] to
+      # @param [Hash, nil] using
+      # @param [String, nil] namespace
+      # @param [String, nil] prefix
+      # @param [true, false] render_nil
+      #
+      # @raise [IncorrectMappingArgumentsError] when arguments are incorrect
+      #
+      # @api private
+      def map_attribute(
+        attribute,
+        to: nil,
+        using: nil,
+        group: nil,
+        namespace: nil,
+        prefix: nil,
+        render_nil: false
+      )
+        Validator.validate_arguments(attribute, to, using)
+        Validator.validate_namespace(attribute, namespace, prefix)
+
+        namespaced_attribute = [namespace, attribute].compact.join(':')
+
+        @attributes[namespaced_attribute] = Descriptor::Xml.new(
+          name: attribute,
+          attribute: to,
+          methods: using,
+          namespace: Descriptor::XmlNamespace.new(namespace, prefix),
+          cdata: false,
+          group: group,
+          render_nil: render_nil
+        )
+      end
+
+      # Map document's content to object's attribute
+      #
+      # @param [Symbol] to
+      # @param [Hash, nil] using
+      # @param [true, false] cdata
+      #
+      # @api private
+      def map_content(to: nil, using: nil, group: nil, cdata: false)
+        Validator.validate_arguments('content', to, using)
+
+        @content = Descriptor::Xml.new(
+          name: nil,
+          attribute: to,
+          methods: using,
+          namespace: Descriptor::XmlNamespace.new(nil, nil),
+          cdata: cdata,
+          group: group,
+          render_nil: false
+        )
+      end
+
+      # Set the name for root element
+      #
+      # @param [String] value root's name
+      #
+      # @api private
+      def root(value)
+        @root = value
+      end
+
+      # Set default namespace for root element
+      #
+      # @param [String] name
+      # @param [String] prefix
+      #
+      # @api private
+      def namespace(name, prefix)
+        @default_namespace.name = name
+        @default_namespace.prefix = prefix
+      end
+
+      # Set the "finalized" instance variable to true
+      #
+      # @api private
+      def finalize!
+        @finalized = true
+      end
+
+      # Query the "finalized" instance variable
+      #
+      # @return [truem false]
+      #
+      # @api private
+      def finalized?
+        @finalized
+      end
+
+      # @api private
+      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
+
+        super
+      end
+    end
+  end
+end

data/lib/shale/mapping/xml_group.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+require_relative 'xml_base'
+
+module Shale
+  module Mapping
+    # Group for XML serialization format
+    #
+    # @api private
+    class XmlGroup < XmlBase
+      # Return name of the group
+      #
+      # @return [String]
+      #
+      # @api private
+      attr_reader :name
+
+      # Initialize instance
+      #
+      # @api private
+      def initialize(from, to)
+        super()
+        @from = from
+        @to = to
+        @name = "group_#{hash}"
+      end
+
+      # Map element to attribute
+      #
+      # @param [String] element
+      # @param [String, nil] namespace
+      # @param [String, nil] prefix
+      #
+      # @api private
+      def map_element(element, namespace: :undefined, prefix: :undefined)
+        super(
+          element,
+          using: { from: @from, to: @to },
+          group: @name,
+          namespace: namespace,
+          prefix: prefix
+        )
+      end
+
+      # Map document's attribute to object's attribute
+      #
+      # @param [String] attribute
+      # @param [String, nil] namespace
+      # @param [String, nil] prefix
+      #
+      # @api private
+      def map_attribute(attribute, namespace: nil, prefix: nil)
+        super(
+          attribute,
+          using: { from: @from, to: @to },
+          group: @name,
+          namespace: namespace,
+          prefix: prefix
+        )
+      end
+
+      # Map document's content to object's attribute
+      #
+      # @api private
+      def map_content
+        super(using: { from: @from, to: @to }, group: @name)
+      end
+    end
+  end
+end

data/lib/shale/type/complex.rb

@@ -1,6 +1,8 @@
 # frozen_string_literal: true
 
 require_relative '../error'
+require_relative '../mapping/group/dict_grouping'
+require_relative '../mapping/group/xml_grouping'
 require_relative 'value'
 
 module Shale
@@ -32,6 +34,7 @@ module Shale
                 .each { |attr| instance.send(attr.setter, attr.default.call) }
 
               mapping_keys = #{format}_mapping.keys
+              grouping = Shale::Mapping::Group::DictGrouping.new
 
               only = to_partial_render_attributes(only)
               except = to_partial_render_attributes(except)
@@ -40,7 +43,9 @@ module Shale
                 mapping = mapping_keys[key]
                 next unless mapping
 
-                if mapping.method_from
+                if mapping.group
+                  grouping.add(mapping, value)
+                elsif mapping.method_from
                   mapper = new
 
                   if mapper.method(mapping.method_from).arity == 3
@@ -89,6 +94,16 @@ module Shale
                 end
               end
 
+              grouping.each do |group|
+                mapper = new
+
+                if mapper.method(group.method_from).arity == 3
+                  mapper.send(group.method_from, instance, group.dict, context)
+                else
+                  mapper.send(group.method_from, instance, group.dict)
+                end
+              end
+
               instance
             end
 
@@ -111,12 +126,15 @@ module Shale
               end
 
               hash = {}
+              grouping = Shale::Mapping::Group::DictGrouping.new
 
               only = to_partial_render_attributes(only)
               except = to_partial_render_attributes(except)
 
               #{format}_mapping.keys.each_value do |mapping|
-                if mapping.method_to
+                if mapping.group
+                  grouping.add(mapping, nil)
+                elsif mapping.method_to
                   mapper = new
 
                   if mapper.method(mapping.method_to).arity == 3
@@ -166,6 +184,16 @@ module Shale
                 end
               end
 
+              grouping.each do |group|
+                mapper = new
+
+                if mapper.method(group.method_to).arity == 3
+                  mapper.send(group.method_to, instance, hash, context)
+                else
+                  mapper.send(group.method_to, instance, hash)
+                end
+              end
+
               hash
             end
           RUBY
@@ -302,6 +330,8 @@ module Shale
             .select { |attr| attr.default }
             .each { |attr| instance.send(attr.setter, attr.default.call) }
 
+          grouping = Shale::Mapping::Group::XmlGrouping.new
+
           only = to_partial_render_attributes(only)
           except = to_partial_render_attributes(except)
 
@@ -309,7 +339,9 @@ module Shale
             mapping = xml_mapping.attributes[key.to_s]
             next unless mapping
 
-            if mapping.method_from
+            if mapping.group
+              grouping.add(mapping, :attribute, value)
+            elsif mapping.method_from
               mapper = new
 
               if mapper.method(mapping.method_from).arity == 3
@@ -335,7 +367,9 @@ module Shale
           content_mapping = xml_mapping.content
 
           if content_mapping
-            if content_mapping.method_from
+            if content_mapping.group
+              grouping.add(content_mapping, :content, element)
+            elsif content_mapping.method_from
               mapper = new
 
               if mapper.method(content_mapping.method_from).arity == 3
@@ -366,7 +400,9 @@ module Shale
             mapping = xml_mapping.elements[node.name]
             next unless mapping
 
-            if mapping.method_from
+            if mapping.group
+              grouping.add(mapping, :element, node)
+            elsif mapping.method_from
               mapper = new
 
               if mapper.method(mapping.method_from).arity == 3
@@ -403,6 +439,16 @@ module Shale
             end
           end
 
+          grouping.each do |group|
+            mapper = new
+
+            if mapper.method(group.method_from).arity == 3
+              mapper.send(group.method_from, instance, group.dict, context)
+            else
+              mapper.send(group.method_from, instance, group.dict)
+            end
+          end
+
           instance
         end
 
@@ -479,11 +525,15 @@ module Shale
             xml_mapping.default_namespace.name
           )
 
+          grouping = Shale::Mapping::Group::XmlGrouping.new
+
           only = to_partial_render_attributes(only)
           except = to_partial_render_attributes(except)
 
           xml_mapping.attributes.each_value do |mapping|
-            if mapping.method_to
+            if mapping.group
+              grouping.add(mapping, :attribute, nil)
+            elsif mapping.method_to
               mapper = new
 
               if mapper.method(mapping.method_to).arity == 4
@@ -510,7 +560,9 @@ module Shale
           content_mapping = xml_mapping.content
 
           if content_mapping
-            if content_mapping.method_to
+            if content_mapping.group
+              grouping.add(content_mapping, :content, nil)
+            elsif content_mapping.method_to
               mapper = new
 
               if mapper.method(content_mapping.method_to).arity == 4
@@ -543,7 +595,9 @@ module Shale
           end
 
           xml_mapping.elements.each_value do |mapping|
-            if mapping.method_to
+            if mapping.group
+              grouping.add(mapping, :element, nil)
+            elsif mapping.method_to
               mapper = new
 
               if mapper.method(mapping.method_to).arity == 4
@@ -605,6 +659,16 @@ module Shale
             end
           end
 
+          grouping.each do |group|
+            mapper = new
+
+            if mapper.method(group.method_to).arity == 4
+              mapper.send(group.method_to, instance, element, doc, context)
+            else
+              mapper.send(group.method_to, instance, element, doc)
+            end
+          end
+
           element
         end
 

data/lib/shale/version.rb

@@ -2,5 +2,5 @@
 
 module Shale
   # @api private
-  VERSION = '0.7.1'
+  VERSION = '0.8.0'
 end

data/shale.gemspec

@@ -26,5 +26,5 @@ Gem::Specification.new do |spec|
   spec.bindir = 'exe'
   spec.executables = 'shaleb'
 
-  spec.required_ruby_version = '>= 2.7.0'
+  spec.required_ruby_version = '>= 2.6.0'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: shale
 version: !ruby/object:Gem::Version
-  version: 0.7.1
+  version: 0.8.0
 platform: ruby
 authors:
 - Kamil Giszczak
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2022-08-12 00:00:00.000000000 Z
+date: 2022-08-30 00:00:00.000000000 Z
 dependencies: []
 description: Ruby object mapper and serializer for XML, JSON, TOML and YAML.
 email:
@@ -41,8 +41,16 @@ files:
 - lib/shale/mapping/descriptor/xml.rb
 - lib/shale/mapping/descriptor/xml_namespace.rb
 - lib/shale/mapping/dict.rb
+- lib/shale/mapping/dict_base.rb
+- lib/shale/mapping/dict_group.rb
+- lib/shale/mapping/group/dict.rb
+- lib/shale/mapping/group/dict_grouping.rb
+- lib/shale/mapping/group/xml.rb
+- lib/shale/mapping/group/xml_grouping.rb
 - lib/shale/mapping/validator.rb
 - lib/shale/mapping/xml.rb
+- lib/shale/mapping/xml_base.rb
+- lib/shale/mapping/xml_group.rb
 - lib/shale/schema.rb
 - lib/shale/schema/compiler/boolean.rb
 - lib/shale/schema/compiler/complex.rb
@@ -108,7 +116,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.7.0
+      version: 2.6.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="