shale 0.7.1 → 0.9.0

data/lib/shale/mapping/dict.rb

@@ -1,71 +1,39 @@
 # 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
       # @param [Symbol, nil] to Object's attribute
       # @param [Hash, nil] using
-      # @param [true, false] render_nil
+      # @param [true, false, nil] render_nil
       #
       # @raise [IncorrectMappingArgumentsError] when arguments are incorrect
       #
       # @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
-        )
+      def map(key, to: nil, using: nil, render_nil: 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,76 @@
+# 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
+      #
+      # @param [true, false] render_nil_default
+      #
+      # @api private
+      def initialize(render_nil_default: false)
+        @keys = {}
+        @finalized = false
+        @render_nil_default = render_nil_default
+      end
+
+      # Map key to attribute
+      #
+      # @param [String] key
+      # @param [Symbol, nil] to
+      # @param [Hash, nil] using
+      # @param [String, nil] group
+      # @param [true, false, nil] render_nil
+      #
+      # @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)
+        @keys[key] = Descriptor::Dict.new(
+          name: key,
+          attribute: to,
+          methods: using,
+          group: group,
+          render_nil: render_nil.nil? ? @render_nil_default : 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