shale 0.9.0 → 1.1.0

data/lib/shale/schema/compiler/xml_complex.rb

@@ -33,14 +33,15 @@ module Shale
         # Initialize object
         #
         # @param [String] id
-        # @param [String] name
+        # @param [String] root_name
         # @param [String] prefix
         # @param [String] namespace
+        # @param [String, nil] package
         #
         # @api private
-        def initialize(id, name, prefix, namespace)
-          super(id, name)
-          @root = name
+        def initialize(id, root_name, prefix, namespace, package)
+          super(id, root_name, package)
+          @root = root_name
           @prefix = prefix
           @namespace = namespace
         end

data/lib/shale/schema/json_compiler.rb

@@ -4,6 +4,7 @@ require 'erb'
 require 'uri'
 
 require_relative '../../shale'
+require_relative '../utils'
 require_relative 'compiler/boolean'
 require_relative 'compiler/complex'
 require_relative 'compiler/date'
@@ -31,29 +32,37 @@ 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.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 -%>
 
-          json do
+          <%= indent %>json do
             <%- type.properties.each do |property| -%>
-            map '<%= property.mapping_name %>', to: :<%= property.attribute_name %>
+            <%= indent %>map '<%= property.mapping_name %>', to: :<%= property.attribute_name %>
             <%- 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 JSON Schema and return them as a Ruby Array of objects
       #
       # @param [Array<String>] schemas
       # @param [String, nil] root_name
+      # @param [Hash<String, String>, nil] namespace_mapping
       #
       # @raise [SchemaError] when JSON Schema has errors
       #
@@ -63,12 +72,13 @@ module Shale
       #   Shale::Schema::JSONCompiler.new.as_models([schema1, schema2])
       #
       # @api public
-      def as_models(schemas, root_name: nil)
+      def as_models(schemas, root_name: nil, namespace_mapping: nil)
         schemas = schemas.map do |schema|
           Shale.json_adapter.load(schema)
         end
 
         @root_name = root_name
+        @namespace_mapping = namespace_mapping || {}
         @schema_repository = {}
         @types = []
 
@@ -89,7 +99,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
 
@@ -100,6 +110,7 @@ module Shale
       #
       # @param [Array<String>] schemas
       # @param [String, nil] root_name
+      # @param [Hash<String, String>, nil] namespace_mapping
       #
       # @raise [SchemaError] when JSON Schema has errors
       #
@@ -109,8 +120,8 @@ module Shale
       #   Shale::Schema::JSONCompiler.new.to_models([schema1, schema2])
       #
       # @api public
-      def to_models(schemas, root_name: nil)
-        types = as_models(schemas, root_name: root_name)
+      def to_models(schemas, root_name: nil, namespace_mapping: nil)
+        types = as_models(schemas, root_name: root_name, namespace_mapping: namespace_mapping)
 
         types.to_h do |type|
           [type.file_name, MODEL_TEMPLATE.result(binding)]
@@ -207,7 +218,8 @@ module Shale
         end
 
         if type == 'object'
-          Compiler::Complex.new(id, name)
+          base_id = Utils.presence(id.split('#')[0])
+          Compiler::Complex.new(id, name, @namespace_mapping[base_id])
         elsif type == 'string' && format == 'date'
           Compiler::Date.new
         elsif type == 'string' && format == 'date-time'
@@ -297,7 +309,9 @@ module Shale
         if schema.is_a?(Hash) && schema.key?('$ref')
           entry = resolve_ref(id, schema['$ref'])
           schema = entry[:schema]
-          fragment = entry[:id].split('/') - ['#']
+          entry_id, entry_fragment = entry[:id].split('#')
+          id = build_id(id, entry_id)
+          fragment = (entry_fragment || '').split('/') - ['']
         end
 
         pointer = entry[:id] || build_pointer(id, fragment)

data/lib/shale/schema/json_generator/base.rb

@@ -12,15 +12,21 @@ module Shale
         # @api private
         attr_reader :name
 
-        # Return nullable
+        # Return schema hash
+        #
+        # @api private
+        attr_reader :schema
+
+        # Set nullable
         #
         # @api private
         attr_writer :nullable
 
-        def initialize(name, default: nil)
+        def initialize(name, default: nil, schema: nil)
           @name = name.gsub('::', '_')
           @default = default
-          @nullable = true
+          @schema = schema || {}
+          @nullable = !schema&.[](:required)
         end
 
         # Return JSON Schema fragment as Ruby Hash

data/lib/shale/schema/json_generator/collection.rb

@@ -7,13 +7,20 @@ module Shale
       #
       # @api private
       class Collection
+        # Return schema hash
+        #
+        # @api private
+        attr_reader :schema
+
         # Initialize Collection object
         #
         # @param [Shale::Schema::JSONGenerator::Base] type
+        # @param [Hash] schema
         #
         # @api private
-        def initialize(type)
+        def initialize(type, schema: nil)
           @type = type
+          @schema = schema
         end
 
         # Delegate name to wrapped type object
@@ -31,7 +38,15 @@ module Shale
         #
         # @api private
         def as_json
-          { 'type' => 'array', 'items' => @type.as_type }
+          schema = @schema || {}
+
+          { 'type' => 'array',
+            'items' => @type.as_type,
+            'minItems' => schema[:min_items],
+            'maxItems' => schema[:max_items],
+            'uniqueItems' => schema[:unique],
+            'minContains' => schema[:min_contains],
+            'maxContains' => schema[:max_contains] }.compact
         end
       end
     end

data/lib/shale/schema/json_generator/float.rb

@@ -15,7 +15,12 @@ module Shale
         #
         # @api private
         def as_type
-          { 'type' => 'number' }
+          { 'type' => 'number',
+            'exclusiveMinimum' => schema[:exclusive_minimum],
+            'exclusiveMaximum' => schema[:exclusive_maximum],
+            'minimum' => schema[:minimum],
+            'maximum' => schema[:maximum],
+            'multipleOf' => schema[:multiple_of] }.compact
         end
       end
     end

data/lib/shale/schema/json_generator/integer.rb

@@ -15,7 +15,12 @@ module Shale
         #
         # @api private
         def as_type
-          { 'type' => 'integer' }
+          { 'type' => 'integer',
+            'exclusiveMinimum' => schema[:exclusive_minimum],
+            'exclusiveMaximum' => schema[:exclusive_maximum],
+            'minimum' => schema[:minimum],
+            'maximum' => schema[:maximum],
+            'multipleOf' => schema[:multiple_of] }.compact
         end
       end
     end

data/lib/shale/schema/json_generator/object.rb

@@ -16,10 +16,12 @@ module Shale
         #   Array<Shale::Schema::JSONGenerator::Base,
         #   Shale::Schema::JSONGenerator::Collection>
         # ] properties
+        # @param [Hash] root
         #
         # @api private
-        def initialize(name, properties)
+        def initialize(name, properties, root)
           super(name)
+          @root = root
           @properties = properties
         end
 
@@ -29,10 +31,16 @@ module Shale
         #
         # @api private
         def as_type
+          required_props = @properties.filter_map { |prop| prop.name if prop&.schema&.[](:required) }
+
           {
             'type' => 'object',
             'properties' => @properties.to_h { |el| [el.name, el.as_json] },
-          }
+            'required' => required_props.empty? ? nil : required_props,
+            'minProperties' => @root[:min_properties],
+            'maxProperties' => @root[:max_properties],
+            'dependentRequired' => @root[:dependent_required],
+          }.compact
         end
       end
     end

data/lib/shale/schema/json_generator/string.rb

@@ -15,7 +15,11 @@ module Shale
         #
         # @api private
         def as_type
-          { 'type' => 'string' }
+          { 'type' => 'string',
+            'format' => schema[:format],
+            'minLength' => schema[:min_length],
+            'maxLength' => schema[:max_length],
+            'pattern' => schema[:pattern] }.compact
         end
       end
     end

data/lib/shale/schema/json_generator.rb

@@ -87,7 +87,7 @@ module Shale
             next unless attribute
 
             if mapper_type?(attribute.type)
-              json_type = Ref.new(mapping.name, attribute.type.name)
+              json_type = Ref.new(mapping.name, attribute.type.model.name)
             else
               json_klass = self.class.get_json_type(attribute.type)
 
@@ -96,14 +96,18 @@ module Shale
                 default = attribute.type.as_json(value)
               end
 
-              json_type = json_klass.new(mapping.name, default: default)
+              json_type = json_klass.new(
+                mapping.name,
+                default: default,
+                schema: mapping.schema
+              )
             end
 
-            json_type = Collection.new(json_type) if attribute.collection?
+            json_type = Collection.new(json_type, schema: mapping.schema) if attribute.collection?
             properties << json_type
           end
 
-          objects << Object.new(type.name, properties)
+          objects << Object.new(type.model.name, properties, type.json_mapping.root)
         end
 
         Schema.new(objects, id: id, title: title, description: description).as_json

data/lib/shale/schema/xml_compiler.rb

@@ -34,51 +34,51 @@ module Shale
 
       # XML Schema "schema" element name
       # @api private
-      XS_SCHEMA = "#{XS_NAMESPACE_URI}:schema"
+      XS_SCHEMA = "#{XS_NAMESPACE_URI}:schema".freeze
 
       # XML Schema "element" element name
       # @api private
-      XS_ELEMENT = "#{XS_NAMESPACE_URI}:element"
+      XS_ELEMENT = "#{XS_NAMESPACE_URI}:element".freeze
 
       # XML Schema "attribute" element name
       # @api private
-      XS_ATTRIBUTE = "#{XS_NAMESPACE_URI}:attribute"
+      XS_ATTRIBUTE = "#{XS_NAMESPACE_URI}:attribute".freeze
 
       # XML Schema "attribute" element name
       # @api private
-      XS_SIMPLE_TYPE = "#{XS_NAMESPACE_URI}:simpleType"
+      XS_SIMPLE_TYPE = "#{XS_NAMESPACE_URI}:simpleType".freeze
 
       # XML Schema "simpleContent" element name
       # @api private
-      XS_SIMPLE_CONTENT = "#{XS_NAMESPACE_URI}:simpleContent"
+      XS_SIMPLE_CONTENT = "#{XS_NAMESPACE_URI}:simpleContent".freeze
 
       # XML Schema "restriction" element name
       # @api private
-      XS_RESTRICTION = "#{XS_NAMESPACE_URI}:restriction"
+      XS_RESTRICTION = "#{XS_NAMESPACE_URI}:restriction".freeze
 
       # XML Schema "group" element name
       # @api private
-      XS_GROUP = "#{XS_NAMESPACE_URI}:group"
+      XS_GROUP = "#{XS_NAMESPACE_URI}:group".freeze
 
       # XML Schema "attributeGroup" element name
       # @api private
-      XS_ATTRIBUTE_GROUP = "#{XS_NAMESPACE_URI}:attributeGroup"
+      XS_ATTRIBUTE_GROUP = "#{XS_NAMESPACE_URI}:attributeGroup".freeze
 
       # XML Schema "complexType" element name
       # @api private
-      XS_COMPLEX_TYPE = "#{XS_NAMESPACE_URI}:complexType"
+      XS_COMPLEX_TYPE = "#{XS_NAMESPACE_URI}:complexType".freeze
 
       # XML Schema "complexContent" element name
       # @api private
-      XS_COMPLEX_CONTENT = "#{XS_NAMESPACE_URI}:complexContent"
+      XS_COMPLEX_CONTENT = "#{XS_NAMESPACE_URI}:complexContent".freeze
 
       # XML Schema "extension" element name
       # @api private
-      XS_EXTENSION = "#{XS_NAMESPACE_URI}:extension"
+      XS_EXTENSION = "#{XS_NAMESPACE_URI}:extension".freeze
 
       # XML Schema "anyType" type
       # @api private
-      XS_TYPE_ANY = "#{XS_NAMESPACE_URI}:anyType"
+      XS_TYPE_ANY = "#{XS_NAMESPACE_URI}:anyType".freeze
 
       # XML Schema "date" types
       # @api private
@@ -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