shale 0.7.1 → 0.9.0

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
@@ -11,11 +13,11 @@ module Shale
     # @api private
     class Complex < Value
       class << self
-        %i[hash json yaml toml].each do |format|
+        %i[hash json yaml toml csv].each do |format|
           class_eval(<<-RUBY, __FILE__, __LINE__ + 1)
             # Convert Hash to Object using Hash/JSON/YAML/TOML mapping
             #
-            # @param [Hash] hash Hash to convert
+            # @param [Hash, Array] hash Hash to convert
             # @param [Array<Symbol>] only
             # @param [Array<Symbol>] except
             # @param [any] context
@@ -24,6 +26,18 @@ module Shale
             #
             # @api public
             def of_#{format}(hash, only: nil, except: nil, context: nil)
+              #{
+                if format != :toml
+                  <<~CODE
+                    if hash.is_a?(Array)
+                      return hash.map do |item|
+                        of_#{format}(item, only: only, except: except, context: context)
+                      end
+                    end
+                  CODE
+                end
+              }
+
               instance = model.new
 
               attributes
@@ -32,6 +46,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 +55,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,12 +106,22 @@ 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
 
             # Convert Object to Hash using Hash/JSON/YAML/TOML mapping
             #
-            # @param [any] instance Object to convert
+            # @param [any, Array<any>] instance Object to convert
             # @param [Array<Symbol>] only
             # @param [Array<Symbol>] except
             # @param [any] context
@@ -105,18 +132,33 @@ module Shale
             #
             # @api public
             def as_#{format}(instance, only: nil, except: nil, context: nil)
+              #{
+                if format != :toml
+                  <<~CODE
+                    if instance.is_a?(Array)
+                      return instance.map do |item|
+                        as_#{format}(item, only: only, except: except, context: context)
+                      end
+                    end
+                  CODE
+                end
+              }
+
               unless instance.is_a?(model)
                 msg = "argument is a '\#{instance.class}' but should be a '\#{model}'"
                 raise IncorrectModelError, msg
               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 +208,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
@@ -284,6 +336,65 @@ module Shale
           )
         end
 
+        # Convert CSV to Object
+        #
+        # @param [String] csv CSV to convert
+        # @param [Array<Symbol>] only
+        # @param [Array<Symbol>] except
+        # @param [any] context
+        # @param [true, false] headers
+        # @param [Hash] csv_options
+        #
+        # @return [model instance]
+        #
+        # @api public
+        def from_csv(csv, only: nil, except: nil, context: nil, headers: false, **csv_options)
+          data = Shale.csv_adapter.load(csv, **csv_options.merge(headers: csv_mapping.keys.keys))
+
+          data.shift if headers
+
+          of_csv(
+            data,
+            only: only,
+            except: except,
+            context: context
+          )
+        end
+
+        # Convert Object to CSV
+        #
+        # @param [model instance] instance Object to convert
+        # @param [Array<Symbol>] only
+        # @param [Array<Symbol>] except
+        # @param [any] context
+        # @param [true, false] headers
+        # @param [Hash] csv_options
+        #
+        # @return [String]
+        #
+        # @api public
+        def to_csv(instance, only: nil, except: nil, context: nil, headers: false, **csv_options)
+          data = as_csv([*instance], only: only, except: except, context: context)
+
+          cols = csv_mapping.keys.values
+
+          if only
+            cols = cols.select { |e| only.include?(e.attribute) }
+          end
+
+          if except
+            cols = cols.reject { |e| except.include?(e.attribute) }
+          end
+
+          cols = cols.map(&:name)
+
+          if headers
+            data.prepend(cols.to_h { |e| [e, e] })
+          end
+
+          Shale.csv_adapter.dump(data, **csv_options.merge(headers: cols))
+        end
+
         # Convert XML document to Object
         #
         # @param [Shale::Adapter::<XML adapter>::Node] element
@@ -302,6 +413,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 +422,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 +450,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 +483,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 +522,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
 
@@ -449,7 +578,8 @@ module Shale
           _cdata = nil,
           only: nil,
           except: nil,
-          context: nil
+          context: nil,
+          version: nil
         )
           unless instance.is_a?(model)
             msg = "argument is a '#{instance.class}' but should be a '#{model}'"
@@ -457,7 +587,7 @@ module Shale
           end
 
           unless doc
-            doc = Shale.xml_adapter.create_document
+            doc = Shale.xml_adapter.create_document(version)
 
             element = as_xml(
               instance,
@@ -479,11 +609,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 +644,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 +679,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 +743,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
 
@@ -616,6 +764,7 @@ module Shale
         # @param [any] context
         # @param [true, false] pretty
         # @param [true, false] declaration
+        # @param [true, false, String] encoding
         #
         # @raise [AdapterError]
         #
@@ -628,13 +777,15 @@ module Shale
           except: nil,
           context: nil,
           pretty: false,
-          declaration: false
+          declaration: false,
+          encoding: false
         )
           validate_xml_adapter
           Shale.xml_adapter.dump(
-            as_xml(instance, only: only, except: except, context: context),
+            as_xml(instance, only: only, except: except, context: context, version: declaration),
             pretty: pretty,
-            declaration: declaration
+            declaration: declaration,
+            encoding: encoding
           )
         end
 
@@ -737,6 +888,26 @@ module Shale
         self.class.to_toml(self, only: only, except: except, context: context)
       end
 
+      # Convert Object to CSV
+      #
+      # @param [Array<Symbol>] only
+      # @param [Array<Symbol>] except
+      # @param [any] context
+      #
+      # @return [String]
+      #
+      # @api public
+      def to_csv(only: nil, except: nil, context: nil, headers: false, **csv_options)
+        self.class.to_csv(
+          self,
+          only: only,
+          except: except,
+          context: context,
+          headers: headers,
+          **csv_options
+        )
+      end
+
       # Convert Object to XML
       #
       # @param [Array<Symbol>] only
@@ -744,18 +915,27 @@ module Shale
       # @param [any] context
       # @param [true, false] pretty
       # @param [true, false] declaration
+      # @param [true, false, String] encoding
       #
       # @return [String]
       #
       # @api public
-      def to_xml(only: nil, except: nil, context: nil, pretty: false, declaration: false)
+      def to_xml(
+        only: nil,
+        except: nil,
+        context: nil,
+        pretty: false,
+        declaration: false,
+        encoding: false
+      )
         self.class.to_xml(
           self,
           only: only,
           except: except,
           context: context,
           pretty: pretty,
-          declaration: declaration
+          declaration: declaration,
+          encoding: encoding
         )
       end
     end