shale 0.9.0 → 1.0.0

data/lib/shale/schema/xml_compiler.rb

@@ -139,55 +139,63 @@ module Shale
         <%- unless type.references.empty? -%>
 
         <%- type.references.each do |property| -%>
-        require_relative '<%= property.type.file_name %>'
+        require_relative '<%= type.relative_path(property.type.file_name) %>'
         <%- end -%>
         <%- end -%>
 
-        class <%= type.name %> < Shale::Mapper
+        <%- type.modules.each_with_index do |name, i| -%>
+        <%= '  ' * i %>module <%= name %>
+        <%- end -%>
+        <%- indent = '  ' * type.modules.length -%>
+        <%= indent %>class <%= type.root_name %> < Shale::Mapper
           <%- type.properties.select(&:content?).each do |property| -%>
-          attribute :<%= property.attribute_name %>, <%= property.type.name -%>
+          <%= indent %>attribute :<%= property.attribute_name %>, <%= property.type.name -%>
           <%- if property.collection? %>, collection: true<% end -%>
           <%- unless property.default.nil? %>, default: -> { <%= property.default %> }<% end %>
           <%- end -%>
           <%- type.properties.select(&:attribute?).each do |property| -%>
-          attribute :<%= property.attribute_name %>, <%= property.type.name -%>
+          <%= indent %>attribute :<%= property.attribute_name %>, <%= property.type.name -%>
           <%- if property.collection? %>, collection: true<% end -%>
           <%- unless property.default.nil? %>, default: -> { <%= property.default %> }<% end %>
           <%- end -%>
           <%- type.properties.select(&:element?).each do |property| -%>
-          attribute :<%= property.attribute_name %>, <%= property.type.name -%>
+          <%= indent %>attribute :<%= property.attribute_name %>, <%= property.type.name -%>
           <%- if property.collection? %>, collection: true<% end -%>
           <%- unless property.default.nil? %>, default: -> { <%= property.default %> }<% end %>
           <%- end -%>
 
-          xml do
-            root '<%= type.root %>'
+          <%= indent %>xml do
+            <%= indent %>root '<%= type.root %>'
             <%- if type.namespace -%>
-            namespace '<%= type.namespace %>', '<%= type.prefix %>'
+            <%= indent %>namespace '<%= type.namespace %>', '<%= type.prefix %>'
             <%- end -%>
             <%- unless type.properties.empty? -%>
 
             <%- type.properties.select(&:content?).each do |property| -%>
-            map_content to: :<%= property.attribute_name %>
+            <%= indent %>map_content to: :<%= property.attribute_name %>
             <%- end -%>
             <%- type.properties.select(&:attribute?).each do |property| -%>
-            map_attribute '<%= property.mapping_name %>', to: :<%= property.attribute_name -%>
+            <%= indent %>map_attribute '<%= property.mapping_name %>', to: :<%= property.attribute_name -%>
             <%- if property.namespace %>, prefix: '<%= property.prefix %>'<%- end -%>
             <%- if property.namespace %>, namespace: '<%= property.namespace %>'<% end %>
             <%- end -%>
             <%- type.properties.select(&:element?).each do |property| -%>
-            map_element '<%= property.mapping_name %>', to: :<%= property.attribute_name -%>
+            <%= indent %>map_element '<%= property.mapping_name %>', to: :<%= property.attribute_name -%>
             <%- if type.namespace != property.namespace %>, prefix: <%= property.prefix ? "'\#{property.prefix}'" : 'nil' %><%- end -%>
             <%- if type.namespace != property.namespace %>, namespace: <%= property.namespace ? "'\#{property.namespace}'" : 'nil' %><% end %>
             <%- end -%>
             <%- end -%>
-          end
-        end
+          <%= indent %>end
+        <%= indent %>end
+        <%- type.modules.length.times do |i| -%>
+        <%= '  ' * (type.modules.length - i - 1) %>end
+        <%- end -%>
       TEMPLATE
 
       # Generate Shale models from XML Schema and return them as a Ruby Array of objects
       #
       # @param [Array<String>] schemas
+      # @param [Hash<String, String>, nil] namespace_mapping
       #
       # @raise [AdapterError] when XML adapter is not set or Ox adapter is used
       # @raise [SchemaError] when XML Schema has errors
@@ -198,7 +206,7 @@ module Shale
       #   Shale::Schema::XMLCompiler.new.as_models([schema1, schema2])
       #
       # @api public
-      def as_models(schemas)
+      def as_models(schemas, namespace_mapping: nil)
         unless Shale.xml_adapter
           raise AdapterError, XML_ADAPTER_NOT_SET_MESSAGE
         end
@@ -212,6 +220,7 @@ module Shale
           Shale.xml_adapter.load(schema)
         end
 
+        @namespace_mapping = namespace_mapping || {}
         @elements_repository = {}
         @attributes_repository = {}
         @simple_types_repository = {}
@@ -244,7 +253,7 @@ module Shale
           duplicates[type.name] += 1
 
           if total_duplicates[type.name] > 1
-            type.name = format("#{type.name}%d", duplicates[type.name])
+            type.root_name = format("#{type.root_name}%d", duplicates[type.name])
           end
         end
 
@@ -256,6 +265,7 @@ module Shale
       # Generate Shale models from XML Schema
       #
       # @param [Array<String>] schemas
+      # @param [Hash<String, String>, nil] namespace_mapping
       #
       # @raise [SchemaError] when XML Schema has errors
       #
@@ -265,8 +275,8 @@ module Shale
       #   Shale::Schema::XMLCompiler.new.to_models([schema1, schema2])
       #
       # @api public
-      def to_models(schemas)
-        types = as_models(schemas)
+      def to_models(schemas, namespace_mapping: nil)
+        types = as_models(schemas, namespace_mapping: namespace_mapping)
 
         types.to_h do |type|
           [type.file_name, MODEL_TEMPLATE.result(binding)]
@@ -415,6 +425,10 @@ module Shale
           type = type.sub(/^#{prefix}/, name)
         end
 
+        if namespaces.key?('xmlns') && !type.include?(':')
+          type = "#{namespaces['xmlns']}:#{type}"
+        end
+
         type
       end
 
@@ -535,7 +549,13 @@ module Shale
             name = node.attributes['name'] || node.parent.attributes['name']
             prefix, namespace = resolve_complex_type_namespace(node)
 
-            @complex_types[id] = Compiler::XMLComplex.new(id, name, prefix, namespace)
+            @complex_types[id] = Compiler::XMLComplex.new(
+              id,
+              name,
+              prefix,
+              namespace,
+              @namespace_mapping[namespace]
+            )
           end
         end
       end
@@ -571,6 +591,14 @@ module Shale
         infer_type_from_xs_type(type, namespaces)
       end
 
+      # Infer type from XSD type
+      #
+      # @param [String] type
+      # @param [Hash<String, String>] namespaces
+      #
+      # @return [Shale::Schema::Compiler::<any>]
+      #
+      # @api private
       def infer_type_from_xs_type(type, namespaces)
         type = replace_ns_prefixes(type, namespaces)
 

data/lib/shale/schema/xml_generator.rb

@@ -84,7 +84,7 @@ module Shale
 
         root_element = TypedElement.new(
           name: klass.xml_mapping.unprefixed_root,
-          type: [default_namespace.prefix, schematize(klass.name)].compact.join(':'),
+          type: [default_namespace.prefix, schematize(klass.model.name)].compact.join(':'),
           required: true
         )
 
@@ -195,7 +195,7 @@ module Shale
           end
 
           complex = ComplexType.new(
-            schematize(type.name),
+            schematize(type.model.name),
             children,
             mixed: !type.xml_mapping.content.nil?
           )
@@ -287,7 +287,7 @@ module Shale
       # @api private
       def get_xml_type_for_attribute(type, namespace)
         if mapper_type?(type)
-          [namespace.prefix, schematize(type.name)].compact.join(':')
+          [namespace.prefix, schematize(type.model.name)].compact.join(':')
         else
           "xs:#{self.class.get_xml_type(type)}"
         end

data/lib/shale/schema.rb

@@ -38,6 +38,7 @@ module Shale
     #
     # @param [Array<String>] schemas
     # @param [String, nil] root_name
+    # @param [Hash<String, String>, nil] namespace_mapping
     #
     # @return [Array<String>]
     #
@@ -46,8 +47,12 @@ module Shale
     #   # => [model1, model2, model3]
     #
     # @api public
-    def self.from_json(schemas, root_name: nil)
-      JSONCompiler.new.to_models(schemas, root_name: root_name)
+    def self.from_json(schemas, root_name: nil, namespace_mapping: nil)
+      JSONCompiler.new.to_models(
+        schemas,
+        root_name: root_name,
+        namespace_mapping: namespace_mapping
+      )
     end
 
     # Generate XML Schema from Shale model
@@ -71,6 +76,7 @@ module Shale
     # Generate Shale model from XML Schema
     #
     # @param [Array<String>] schemas
+    # @param [Hash<String, String>, nil] namespace_mapping
     #
     # @return [Array<String>]
     #
@@ -79,8 +85,8 @@ module Shale
     #   # => [model1, model2, model3]
     #
     # @api public
-    def self.from_xml(schemas)
-      XMLCompiler.new.to_models(schemas)
+    def self.from_xml(schemas, namespace_mapping: nil)
+      XMLCompiler.new.to_models(schemas, namespace_mapping: namespace_mapping)
     end
   end
 end

data/lib/shale/type/complex.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative '../error'
+require_relative '../mapping/delegates'
 require_relative '../mapping/group/dict_grouping'
 require_relative '../mapping/group/xml_grouping'
 require_relative 'value'
@@ -47,6 +48,7 @@ module Shale
 
               mapping_keys = #{format}_mapping.keys
               grouping = Shale::Mapping::Group::DictGrouping.new
+              delegates = Shale::Mapping::Delegates.new
 
               only = to_partial_render_attributes(only)
               except = to_partial_render_attributes(except)
@@ -66,7 +68,8 @@ module Shale
                     mapper.send(mapping.method_from, instance, value)
                   end
                 else
-                  attribute = attributes[mapping.attribute]
+                  receiver_attributes = get_receiver_attributes(mapping)
+                  attribute = receiver_attributes[mapping.attribute]
                   next unless attribute
 
                   if only
@@ -79,20 +82,22 @@ module Shale
                     next if except.key?(attribute.name) && attribute_except.nil?
                   end
 
+                  casted_value = nil
+
                   if value.nil?
-                    instance.send(attribute.setter, nil)
+                    casted_value = nil
                   elsif attribute.collection?
-                    [*value].each do |val|
-                      if val
+                    casted_value = (value.is_a?(Array) ? value : [value]).map do |val|
+                      unless val.nil?
                         val = attribute.type.of_#{format}(
                           val,
                           only: attribute_only,
                           except: attribute_except,
                           context: context
                         )
-                      end
 
-                      instance.send(attribute.name) << attribute.type.cast(val)
+                        attribute.type.cast(val)
+                      end
                     end
                   else
                     val = attribute.type.of_#{format}(
@@ -101,11 +106,23 @@ module Shale
                       except: attribute_except,
                       context: context
                     )
-                    instance.send(attribute.setter, attribute.type.cast(val))
+
+                    casted_value = attribute.type.cast(val)
+                  end
+
+                  if mapping.receiver
+                    delegates.add(attributes[mapping.receiver], attribute.setter, casted_value)
+                  else
+                    instance.send(attribute.setter, casted_value)
                   end
                 end
               end
 
+              delegates.each do |delegate|
+                receiver = get_receiver(instance, delegate.receiver_attribute)
+                receiver.send(delegate.setter, delegate.value)
+              end
+
               grouping.each do |group|
                 mapper = new
 
@@ -167,7 +184,14 @@ module Shale
                     mapper.send(mapping.method_to, instance, hash)
                   end
                 else
-                  attribute = attributes[mapping.attribute]
+                  if mapping.receiver
+                    receiver = instance.send(mapping.receiver)
+                  else
+                    receiver = instance
+                  end
+
+                  receiver_attributes = get_receiver_attributes(mapping)
+                  attribute = receiver_attributes[mapping.attribute]
                   next unless attribute
 
                   if only
@@ -180,7 +204,7 @@ module Shale
                     next if except.key?(attribute.name) && attribute_except.nil?
                   end
 
-                  value = instance.send(attribute.name)
+                  value = receiver.send(attribute.name) if receiver
 
                   if value.nil?
                     hash[mapping.name] = nil if mapping.render_nil?
@@ -414,6 +438,7 @@ module Shale
             .each { |attr| instance.send(attr.setter, attr.default.call) }
 
           grouping = Shale::Mapping::Group::XmlGrouping.new
+          delegates = Shale::Mapping::Delegates.new
 
           only = to_partial_render_attributes(only)
           except = to_partial_render_attributes(except)
@@ -433,16 +458,29 @@ module Shale
                 mapper.send(mapping.method_from, instance, value)
               end
             else
-              attribute = attributes[mapping.attribute]
+              receiver_attributes = get_receiver_attributes(mapping)
+              attribute = receiver_attributes[mapping.attribute]
               next unless attribute
 
               next if only && !only.key?(attribute.name)
               next if except&.key?(attribute.name)
 
+              casted_value = attribute.type.cast(value)
+
               if attribute.collection?
-                instance.send(attribute.name) << attribute.type.cast(value)
+                if mapping.receiver
+                  delegates.add_collection(
+                    attributes[mapping.receiver],
+                    attribute.setter,
+                    casted_value
+                  )
+                else
+                  instance.send(attribute.name) << casted_value
+                end
+              elsif mapping.receiver
+                delegates.add(attributes[mapping.receiver], attribute.setter, casted_value)
               else
-                instance.send(attribute.setter, attribute.type.cast(value))
+                instance.send(attribute.setter, casted_value)
               end
             end
           end
@@ -461,7 +499,8 @@ module Shale
                 mapper.send(content_mapping.method_from, instance, element)
               end
             else
-              attribute = attributes[content_mapping.attribute]
+              receiver_attributes = get_receiver_attributes(content_mapping)
+              attribute = receiver_attributes[content_mapping.attribute]
 
               if attribute
                 skip = false
@@ -471,8 +510,13 @@ module Shale
                 skip = true if except&.key?(attribute.name)
 
                 unless skip
-                  value = attribute.type.of_xml(element)
-                  instance.send(attribute.setter, attribute.type.cast(value))
+                  value = attribute.type.cast(attribute.type.of_xml(element))
+
+                  if content_mapping.receiver
+                    delegates.add(attributes[content_mapping.receiver], attribute.setter, value)
+                  else
+                    instance.send(attribute.setter, value)
+                  end
                 end
                 # rubocop:enable Metrics/BlockNesting
               end
@@ -494,7 +538,8 @@ module Shale
                 mapper.send(mapping.method_from, instance, node)
               end
             else
-              attribute = attributes[mapping.attribute]
+              receiver_attributes = get_receiver_attributes(mapping)
+              attribute = receiver_attributes[mapping.attribute]
               next unless attribute
 
               if only
@@ -514,14 +559,31 @@ module Shale
                 context: context
               )
 
+              casted_value = attribute.type.cast(value)
+
               if attribute.collection?
-                instance.send(attribute.name) << attribute.type.cast(value)
+                if mapping.receiver
+                  delegates.add_collection(
+                    attributes[mapping.receiver],
+                    attribute.setter,
+                    casted_value
+                  )
+                else
+                  instance.send(attribute.name) << casted_value
+                end
+              elsif mapping.receiver
+                delegates.add(attributes[mapping.receiver], attribute.setter, casted_value)
               else
-                instance.send(attribute.setter, attribute.type.cast(value))
+                instance.send(attribute.setter, casted_value)
               end
             end
           end
 
+          delegates.each do |delegate|
+            receiver = get_receiver(instance, delegate.receiver_attribute)
+            receiver.send(delegate.setter, delegate.value)
+          end
+
           grouping.each do |group|
             mapper = new
 
@@ -626,13 +688,20 @@ module Shale
                 mapper.send(mapping.method_to, instance, element, doc)
               end
             else
-              attribute = attributes[mapping.attribute]
+              if mapping.receiver
+                receiver = instance.send(mapping.receiver)
+              else
+                receiver = instance
+              end
+
+              receiver_attributes = get_receiver_attributes(mapping)
+              attribute = receiver_attributes[mapping.attribute]
               next unless attribute
 
               next if only && !only.key?(attribute.name)
               next if except&.key?(attribute.name)
 
-              value = instance.send(attribute.name)
+              value = receiver.send(attribute.name) if receiver
 
               if mapping.render_nil? || !value.nil?
                 doc.add_namespace(mapping.namespace.prefix, mapping.namespace.name)
@@ -655,7 +724,14 @@ module Shale
                 mapper.send(content_mapping.method_to, instance, element, doc)
               end
             else
-              attribute = attributes[content_mapping.attribute]
+              if content_mapping.receiver
+                receiver = instance.send(content_mapping.receiver)
+              else
+                receiver = instance
+              end
+
+              receiver_attributes = get_receiver_attributes(content_mapping)
+              attribute = receiver_attributes[content_mapping.attribute]
 
               if attribute
                 skip = false
@@ -665,7 +741,7 @@ module Shale
                 skip = true if except&.key?(attribute.name)
 
                 unless skip
-                  value = instance.send(attribute.name)
+                  value = receiver.send(attribute.name) if receiver
 
                   if content_mapping.cdata
                     doc.create_cdata(value.to_s, element)
@@ -690,7 +766,14 @@ module Shale
                 mapper.send(mapping.method_to, instance, element, doc)
               end
             else
-              attribute = attributes[mapping.attribute]
+              if mapping.receiver
+                receiver = instance.send(mapping.receiver)
+              else
+                receiver = instance
+              end
+
+              receiver_attributes = get_receiver_attributes(mapping)
+              attribute = receiver_attributes[mapping.attribute]
               next unless attribute
 
               if only
@@ -703,7 +786,7 @@ module Shale
                 next if except.key?(attribute.name) && attribute_except.nil?
               end
 
-              value = instance.send(attribute.name)
+              value = receiver.send(attribute.name) if receiver
 
               if mapping.render_nil? || !value.nil?
                 doc.add_namespace(mapping.namespace.prefix, mapping.namespace.name)
@@ -827,6 +910,64 @@ module Shale
             end
           end.to_h
         end
+
+        # Get receiver attributes for given mapping
+        #
+        # @param [Shale::Mapping::Descriptor::Dict] mapping
+        #
+        # @raise [AttributeNotDefinedError]
+        # @raise [NotAShaleMapperError]
+        #
+        # @return [Hash<Symbol, Shale::Attribute>]
+        #
+        # @api private
+        def get_receiver_attributes(mapping)
+          return attributes unless mapping.receiver
+
+          receiver_attribute = attributes[mapping.receiver]
+
+          unless receiver_attribute
+            msg = "attribute '#{mapping.receiver}' is not defined on #{self} mapper"
+            raise AttributeNotDefinedError, msg
+          end
+
+          unless receiver_attribute.type < Mapper
+            msg = "attribute '#{mapping.receiver}' is not a descendant of Shale::Mapper type"
+            raise NotAShaleMapperError, msg
+          end
+
+          if receiver_attribute.collection?
+            msg = "attribute '#{mapping.receiver}' can't be a collection"
+            raise NotAShaleMapperError, msg
+          end
+
+          receiver_attribute.type.attributes
+        end
+
+        # Get receiver for given mapping
+        #
+        # @param [any] instance
+        # @param [Shale::Attribute] receiver_attribute
+        #
+        # @return [Array]
+        #
+        # @api private
+        def get_receiver(instance, receiver_attribute)
+          receiver = instance.send(receiver_attribute.name)
+
+          unless receiver
+            receiver = receiver_attribute.type.model.new
+
+            receiver_attribute.type.attributes
+              .values
+              .select { |attr| attr.default }
+              .each { |attr| receiver.send(attr.setter, attr.default.call) }
+
+            instance.send(receiver_attribute.setter, receiver)
+          end
+
+          receiver
+        end
       end
 
       # Convert Object to Hash

data/lib/shale/utils.rb

@@ -5,6 +5,21 @@ module Shale
   #
   # @api private
   module Utils
+    # Upcase first letter of a string
+    #
+    # @param [String] val
+    #
+    # @example
+    #   Shale::Utils.upcase_first('fooBar')
+    #   # => 'FooBar'
+    #
+    # @api private
+    def self.upcase_first(str)
+      return '' unless str
+      return '' if str.empty?
+      str[0].upcase + str[1..-1]
+    end
+
     # Convert string to Ruby's class naming convention
     #
     # @param [String] val
@@ -15,13 +30,14 @@ module Shale
     #
     # @api private
     def self.classify(str)
-      str = str.to_s.sub(/.*\./, '')
+      # names may include a period, which will need to be stripped out
+      str = str.to_s.gsub(/\./, '')
 
-      str = str.sub(/^[a-z\d]*/) { |match| match.capitalize || match }
+      str = str.sub(/^[a-z\d]*/) { |match| upcase_first(match) || match }
 
-      str.gsub(%r{(?:_|-|(/))([a-z\d]*)}i) do
+      str.gsub('::', '/').gsub(%r{(?:_|-|(/))([a-z\d]*)}i) do
         word = Regexp.last_match(2)
-        substituted = word.capitalize || word
+        substituted = upcase_first(word) || word
         Regexp.last_match(1) ? "::#{substituted}" : substituted
       end
     end
@@ -36,6 +52,8 @@ module Shale
     #
     # @api private
     def self.snake_case(str)
+      # XML elements allow periods and hyphens
+      str = str.to_s.gsub('.', '_')
       return str.to_s unless /[A-Z-]|::/.match?(str)
       word = str.to_s.gsub('::', '/')
       word = word.gsub(/([A-Z]+)(?=[A-Z][a-z])|([a-z\d])(?=[A-Z])/) do

data/lib/shale/version.rb

@@ -2,5 +2,5 @@
 
 module Shale
   # @api private
-  VERSION = '0.9.0'
+  VERSION = '1.0.0'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: shale
 version: !ruby/object:Gem::Version
-  version: 0.9.0
+  version: 1.0.0
 platform: ruby
 authors:
 - Kamil Giszczak
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2022-10-31 00:00:00.000000000 Z
+date: 2023-07-15 00:00:00.000000000 Z
 dependencies: []
 description: Ruby object mapper and serializer for XML, JSON, TOML, CSV and YAML.
 email:
@@ -38,6 +38,7 @@ files:
 - lib/shale/attribute.rb
 - lib/shale/error.rb
 - lib/shale/mapper.rb
+- lib/shale/mapping/delegates.rb
 - lib/shale/mapping/descriptor/dict.rb
 - lib/shale/mapping/descriptor/xml.rb
 - lib/shale/mapping/descriptor/xml_namespace.rb
@@ -124,7 +125,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.7
+rubygems_version: 3.4.10
 signing_key:
 specification_version: 4
 summary: Ruby object mapper and serializer for XML, JSON, TOML, CSV and YAML.