shale 0.3.1 → 0.4.0

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

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require_relative 'base'
+
+module Shale
+  module Schema
+    class JSONGenerator
+      # Class representing JSON Schema any type
+      #
+      # @api private
+      class Value < Base
+        # Return JSON Schema fragment as Ruby Hash
+        #
+        # @return [Hash]
+        #
+        # @api private
+        def as_type
+          { 'type' => %w[boolean integer number object string] }
+        end
+      end
+    end
+  end
+end

data/lib/shale/schema/{json.rb → json_generator.rb}

@@ -1,32 +1,33 @@
 # frozen_string_literal: true
 
 require_relative '../../shale'
-require_relative 'json/schema'
-require_relative 'json/boolean'
-require_relative 'json/collection'
-require_relative 'json/date'
-require_relative 'json/float'
-require_relative 'json/integer'
-require_relative 'json/object'
-require_relative 'json/ref'
-require_relative 'json/string'
-require_relative 'json/time'
+require_relative 'json_generator/schema'
+require_relative 'json_generator/boolean'
+require_relative 'json_generator/collection'
+require_relative 'json_generator/date'
+require_relative 'json_generator/float'
+require_relative 'json_generator/integer'
+require_relative 'json_generator/object'
+require_relative 'json_generator/ref'
+require_relative 'json_generator/string'
+require_relative 'json_generator/time'
+require_relative 'json_generator/value'
 
 module Shale
   module Schema
-    # Class for handling JSON schema
+    # Class for generating JSON schema
     #
     # @api public
-    class JSON
-      @json_types = Hash.new(Shale::Schema::JSON::String)
+    class JSONGenerator
+      @json_types = Hash.new(Shale::Schema::JSONGenerator::String)
 
       # Register Shale to JSON type mapping
       #
       # @param [Shale::Type::Value] shale_type
-      # @param [Shale::Schema::JSON::Base] json_type
+      # @param [Shale::Schema::JSONGenerator::Base] json_type
       #
       # @example
-      #   Shale::Schema::JSON.register_json_type(Shale::Type::String, MyCustomJsonType)
+      #   Shale::Schema::JSONGenerator.register_json_type(Shale::Type::String, MyCustomJsonType)
       #
       # @api public
       def self.register_json_type(shale_type, json_type)
@@ -37,10 +38,10 @@ module Shale
       #
       # @param [Shale::Type::Value] shale_type
       #
-      # @return [Shale::Schema::JSON::Base]
+      # @return [Shale::Schema::JSONGenerator::Base]
       #
       # @example
-      #   Shale::Schema::JSON.get_json_type(Shale::Type::String)
+      #   Shale::Schema::JSONGenerator.get_json_type(Shale::Type::String)
       #   # => Shale::Schema::JSON::String
       #
       # @api private
@@ -48,11 +49,12 @@ module Shale
         @json_types[shale_type]
       end
 
-      register_json_type(Shale::Type::Boolean, Shale::Schema::JSON::Boolean)
-      register_json_type(Shale::Type::Date, Shale::Schema::JSON::Date)
-      register_json_type(Shale::Type::Float, Shale::Schema::JSON::Float)
-      register_json_type(Shale::Type::Integer, Shale::Schema::JSON::Integer)
-      register_json_type(Shale::Type::Time, Shale::Schema::JSON::Time)
+      register_json_type(Shale::Type::Boolean, Shale::Schema::JSONGenerator::Boolean)
+      register_json_type(Shale::Type::Date, Shale::Schema::JSONGenerator::Date)
+      register_json_type(Shale::Type::Float, Shale::Schema::JSONGenerator::Float)
+      register_json_type(Shale::Type::Integer, Shale::Schema::JSONGenerator::Integer)
+      register_json_type(Shale::Type::Time, Shale::Schema::JSONGenerator::Time)
+      register_json_type(Shale::Type::Value, Shale::Schema::JSONGenerator::Value)
 
       # Generate JSON Schema from Shale model and return it as a Ruby Hash
       #
@@ -65,15 +67,16 @@ module Shale
       # @return [Hash]
       #
       # @example
-      #   Shale::Schema::JSON.new.as_schema(Person)
+      #   Shale::Schema::JSONGenerator.new.as_schema(Person)
       #
       # @api public
-      def as_schema(klass, id: nil, description: nil)
+      def as_schema(klass, id: nil, title: nil, description: nil)
         unless mapper_type?(klass)
           raise NotAShaleMapperError, "JSON Shema can't be generated for '#{klass}' type"
         end
 
-        types = collect_composite_types(klass)
+        types = []
+        collect_composite_types(types, klass)
         objects = []
 
         types.each do |type|
@@ -103,7 +106,7 @@ module Shale
           objects << Object.new(type.name, properties)
         end
 
-        Schema.new(objects, id: id, description: description).as_json
+        Schema.new(objects, id: id, title: title, description: description).as_json
       end
 
       # Generate JSON Schema from Shale model
@@ -116,11 +119,11 @@ module Shale
       # @return [String]
       #
       # @example
-      #   Shale::Schema::JSON.new.to_schema(Person)
+      #   Shale::Schema::JSONGenerator.new.to_schema(Person)
       #
       # @api public
-      def to_schema(klass, id: nil, description: nil, pretty: false)
-        schema = as_schema(klass, id: id, description: description)
+      def to_schema(klass, id: nil, title: nil, description: nil, pretty: false)
+        schema = as_schema(klass, id: id, title: title, description: description)
         options = pretty ? :pretty : nil
 
         Shale.json_adapter.dump(schema, options)
@@ -141,24 +144,21 @@ module Shale
 
       # Collect recursively Shale::Mapper types
       #
+      # @param [Array<Shale::Mapper>] types
       # @param [Shale::Mapper] type
       #
-      # @return [Array<Shale::Mapper>]
-      #
       # @api private
-      def collect_composite_types(type)
-        types = [type]
+      def collect_composite_types(types, type)
+        types << type
 
         type.json_mapping.keys.values.each do |mapping|
           attribute = type.attributes[mapping.attribute]
           next unless attribute
 
           if mapper_type?(attribute.type) && !types.include?(attribute.type)
-            types += collect_composite_types(attribute.type)
+            collect_composite_types(types, attribute.type)
           end
         end
-
-        types.uniq
       end
     end
   end

data/lib/shale/schema/{xml → xml_generator}/attribute.rb

@@ -2,7 +2,7 @@
 
 module Shale
   module Schema
-    class XML
+    class XMLGenerator
       # Class representing XML Schema <attribute> element.
       # Serves as a base class for TypedAttribute and RefAttribute
       #

data/lib/shale/schema/{xml → xml_generator}/complex_type.rb

@@ -5,7 +5,7 @@ require_relative 'element'
 
 module Shale
   module Schema
-    class XML
+    class XMLGenerator
       # Class representing XML Schema <complexType> element
       #
       # @api private
@@ -20,7 +20,10 @@ module Shale
         # Initialize ComplexType object
         #
         # @param [String] name
-        # @param [Array<Shale::Schema::XML::Element, Shale::Schema::XML::Attribute>] children
+        # @param [Array<
+        #   Shale::Schema::XMLGenerator::Element,
+        #   Shale::Schema::XMLGenerator::Attribute
+        # >] children
         # @param [true, false] mixed
         #
         # @api private

data/lib/shale/schema/{xml → xml_generator}/element.rb

@@ -2,7 +2,7 @@
 
 module Shale
   module Schema
-    class XML
+    class XMLGenerator
       # Class representing XML Schema <element> element.
       # Serves as a base class for TypedElement and RefElement
       #

data/lib/shale/schema/{xml → xml_generator}/import.rb

@@ -2,7 +2,7 @@
 
 module Shale
   module Schema
-    class XML
+    class XMLGenerator
       # Class representing XML Schema <import> element
       #
       # @api private

data/lib/shale/schema/{xml → xml_generator}/ref_attribute.rb

@@ -4,7 +4,7 @@ require_relative 'attribute'
 
 module Shale
   module Schema
-    class XML
+    class XMLGenerator
       # Class representing XML Schema <attribute ref=""> element
       # with a reference
       #

data/lib/shale/schema/{xml → xml_generator}/ref_element.rb

@@ -4,7 +4,7 @@ require_relative 'element'
 
 module Shale
   module Schema
-    class XML
+    class XMLGenerator
       # Class representing XML Schema <element ref=""> element
       # with a reference
       #

data/lib/shale/schema/{xml → xml_generator}/schema.rb

@@ -5,7 +5,7 @@ require_relative 'complex_type'
 
 module Shale
   module Schema
-    class XML
+    class XMLGenerator
       class Schema
         # XML Schema namespace
         # @api private
@@ -43,10 +43,10 @@ module Shale
 
         # Add child element to XML Schema
         #
-        # @param [Shale::Schema::XML::Import,
-        #         Shale::Schema::XML::Element,
-        #         Shale::Schema::XML::Attribute,
-        #         Shale::Schema::XML::ComplesType] child
+        # @param [Shale::Schema::XMLGenerator::Import,
+        #         Shale::Schema::XMLGenerator::Element,
+        #         Shale::Schema::XMLGenerator::Attribute,
+        #         Shale::Schema::XMLGenerator::ComplesType] child
         #
         # @api private
         def add_child(child)

data/lib/shale/schema/{xml → xml_generator}/typed_attribute.rb

@@ -4,7 +4,7 @@ require_relative 'attribute'
 
 module Shale
   module Schema
-    class XML
+    class XMLGenerator
       # Class representing XML Schema <attribute name="" type=""> element
       # with a name and a type
       #

data/lib/shale/schema/{xml → xml_generator}/typed_element.rb

@@ -4,7 +4,7 @@ require_relative 'element'
 
 module Shale
   module Schema
-    class XML
+    class XMLGenerator
       # Class representing XML Schema <element mame="" type=""> element
       # with a name and a type
       #

data/lib/shale/schema/{xml.rb → xml_generator.rb}

@@ -1,20 +1,20 @@
 # frozen_string_literal: true
 
 require_relative '../../shale'
-require_relative 'xml/complex_type'
-require_relative 'xml/import'
-require_relative 'xml/ref_attribute'
-require_relative 'xml/ref_element'
-require_relative 'xml/schema'
-require_relative 'xml/typed_attribute'
-require_relative 'xml/typed_element'
+require_relative 'xml_generator/complex_type'
+require_relative 'xml_generator/import'
+require_relative 'xml_generator/ref_attribute'
+require_relative 'xml_generator/ref_element'
+require_relative 'xml_generator/schema'
+require_relative 'xml_generator/typed_attribute'
+require_relative 'xml_generator/typed_element'
 
 module Shale
   module Schema
-    # Class for handling XML schema
+    # Class for generating XML schema
     #
     # @api public
-    class XML
+    class XMLGenerator
       # XML Schema default name
       # @api private
       DEFAULT_SCHEMA_NAME = 'schema'
@@ -27,7 +27,7 @@ module Shale
       # @param [String] xml_type
       #
       # @example
-      #   Shale::Schema::XML.register_xml_type(Shale::Type::String, 'myType')
+      #   Shale::Schema::XMLGenerator.register_xml_type(Shale::Type::String, 'myType')
       #
       # @api public
       def self.register_xml_type(shale_type, xml_type)
@@ -41,7 +41,7 @@ module Shale
       # @return [String]
       #
       # @example
-      #   Shale::Schema::XML.get_xml_type(Shale::Type::String)
+      #   Shale::Schema::XMLGenerator.get_xml_type(Shale::Type::String)
       #   # => 'string'
       #
       # @api private
@@ -54,19 +54,20 @@ module Shale
       register_xml_type(Shale::Type::Float, 'decimal')
       register_xml_type(Shale::Type::Integer, 'integer')
       register_xml_type(Shale::Type::Time, 'dateTime')
+      register_xml_type(Shale::Type::Value, 'anyType')
 
       # Generate XML Schema from Shale model and return
-      # it as a Shale::Schema::XML::Schema array
+      # it as a Shale::Schema::XMLGenerator::Schema array
       #
       # @param [Shale::Mapper] klass
       # @param [String, nil] base_name
       #
       # @raise [NotAShaleMapperError] when attribute is not a Shale model
       #
-      # @return [Array<Shale::Schema::XML::Schema>]
+      # @return [Array<Shale::Schema::XMLGenerator::Schema>]
       #
       # @example
-      #   Shale::Schema::XML.new.as_schemas(Person)
+      #   Shale::Schema::XMLGenerator.new.as_schemas(Person)
       #
       # @api public
       def as_schemas(klass, base_name = nil)
@@ -93,7 +94,8 @@ module Shale
         )
         schemas[default_namespace.name].add_child(root_element)
 
-        composites = collect_composite_types(klass, klass.xml_mapping.default_namespace.name)
+        composites = []
+        collect_composite_types(composites, klass, klass.xml_mapping.default_namespace.name)
 
         composites.each do |composite|
           type = composite[:type]
@@ -214,7 +216,7 @@ module Shale
       # @return [Hash<String, String>]
       #
       # @example
-      #   Shale::Schema::XML.new.to_schemas(Person)
+      #   Shale::Schema::XMLGenerator.new.to_schemas(Person)
       #
       # @api public
       def to_schemas(klass, base_name = nil, pretty: false, declaration: false)
@@ -245,14 +247,13 @@ module Shale
 
       # Collect recursively Shale::Mapper types
       #
+      # @param [Array<Shale::Mapper>] types
       # @param [Shale::Mapper] type
       # @param [String, nil] namespace
       #
-      # @return [Array<Hash<Symbol, String>>]
-      #
       # @api private
-      def collect_composite_types(type, namespace)
-        types = [{ type: type, namespace: namespace }]
+      def collect_composite_types(types, type, namespace)
+        types << { type: type, namespace: namespace }
 
         type.xml_mapping.elements.values.each do |mapping|
           attribute = type.attributes[mapping.attribute]
@@ -262,11 +263,9 @@ module Shale
           is_included = types.include?({ type: attribute.type, namespace: namespace })
 
           if is_mapper && !is_included
-            types += collect_composite_types(attribute.type, mapping.namespace.name)
+            collect_composite_types(types, attribute.type, mapping.namespace.name)
           end
         end
-
-        types.uniq
       end
 
       # Convert Ruby class name to XML Schema name

data/lib/shale/schema.rb

@@ -1,7 +1,8 @@
 # frozen_string_literal: true
 
-require_relative 'schema/json'
-require_relative 'schema/xml'
+require_relative 'schema/json_generator'
+require_relative 'schema/json_compiler'
+require_relative 'schema/xml_generator'
 
 module Shale
   # Module for handling JSON and XML schema
@@ -22,8 +23,30 @@ module Shale
     #   # => JSON schema
     #
     # @api public
-    def self.to_json(klass, id: nil, description: nil, pretty: false)
-      JSON.new.to_schema(klass, id: id, description: description, pretty: pretty)
+    def self.to_json(klass, id: nil, title: nil, description: nil, pretty: false)
+      JSONGenerator.new.to_schema(
+        klass,
+        id: id,
+        title: title,
+        description: description,
+        pretty: pretty
+      )
+    end
+
+    # Generate Shale model from JSON Schema
+    #
+    # @param [Array<String>] schemas
+    # @param [String, nil] root_name
+    #
+    # @return [Array<String>]
+    #
+    # @example
+    #   Shale::Schema.from_json([json_schema1, json_schema2], root_name: 'foobar')
+    #   # => [model1, model2, model3]
+    #
+    # @api public
+    def self.from_json(schemas, root_name: nil)
+      JSONCompiler.new.to_models(schemas, root_name: root_name)
     end
 
     # Generate XML Schema from Shale model
@@ -41,7 +64,7 @@ module Shale
     #
     # @api public
     def self.to_xml(klass, base_name = nil, pretty: false, declaration: false)
-      XML.new.to_schemas(klass, base_name, pretty: pretty, declaration: declaration)
+      XMLGenerator.new.to_schemas(klass, base_name, pretty: pretty, declaration: declaration)
     end
   end
 end

data/lib/shale/type/composite.rb

@@ -35,18 +35,15 @@ module Shale
                   next unless attribute
 
                   if value.nil?
-                    instance.public_send("\#{attribute.name}=", nil)
-                    next
-                  end
-
-                  if attribute.collection?
+                    instance.send(attribute.setter, nil)
+                  elsif attribute.collection?
                     [*value].each do |val|
                       val = val ? attribute.type.of_#{format}(val) : val
-                      instance.public_send(attribute.name) << attribute.type.cast(val)
+                      instance.send(attribute.name) << attribute.type.cast(val)
                     end
                   else
                     val = attribute.type.of_#{format}(value)
-                    instance.public_send("\#{attribute.name}=", val)
+                    instance.send(attribute.setter, val)
                   end
                 end
               end
@@ -71,14 +68,11 @@ module Shale
                   attribute = instance.class.attributes[mapping.attribute]
                   next unless attribute
 
-                  value = instance.public_send(attribute.name)
+                  value = instance.send(attribute.name)
 
                   if value.nil?
                     hash[mapping.name] = nil
-                    next
-                  end
-
-                  if attribute.collection?
+                  elsif attribute.collection?
                     hash[mapping.name] = [*value].map do |v|
                       v ? attribute.type.as_#{format}(v) : v
                     end
@@ -163,9 +157,9 @@ module Shale
               next unless attribute
 
               if attribute.collection?
-                instance.public_send(attribute.name) << attribute.type.cast(value)
+                instance.send(attribute.name) << attribute.type.cast(value)
               else
-                instance.public_send("#{attribute.name}=", value)
+                instance.send(attribute.setter, value)
               end
             end
           end
@@ -174,7 +168,7 @@ module Shale
             attribute = attributes[xml_mapping.content]
 
             if attribute
-              instance.public_send("#{attribute.name}=", attribute.type.of_xml(element))
+              instance.send(attribute.setter, attribute.type.of_xml(element))
             end
           end
 
@@ -190,9 +184,9 @@ module Shale
 
               if attribute.collection?
                 value = attribute.type.of_xml(node)
-                instance.public_send(attribute.name) << attribute.type.cast(value)
+                instance.send(attribute.name) << attribute.type.cast(value)
               else
-                instance.public_send("#{attribute.name}=", attribute.type.of_xml(node))
+                instance.send(attribute.setter, attribute.type.of_xml(node))
               end
             end
           end
@@ -237,7 +231,7 @@ module Shale
               attribute = instance.class.attributes[mapping.attribute]
               next unless attribute
 
-              value = instance.public_send(attribute.name)
+              value = instance.send(attribute.name)
               next if value.nil?
 
               doc.add_namespace(mapping.namespace.prefix, mapping.namespace.name)
@@ -249,7 +243,7 @@ module Shale
             attribute = instance.class.attributes[xml_mapping.content]
 
             if attribute
-              value = instance.public_send(attribute.name)
+              value = instance.send(attribute.name)
               doc.add_text(element, value.to_s) if value
             end
           end
@@ -261,7 +255,7 @@ module Shale
               attribute = instance.class.attributes[mapping.attribute]
               next unless attribute
 
-              value = instance.public_send(attribute.name)
+              value = instance.send(attribute.name)
               next if value.nil?
 
               doc.add_namespace(mapping.namespace.prefix, mapping.namespace.name)

data/lib/shale/version.rb

@@ -2,5 +2,5 @@
 
 module Shale
   # @api private
-  VERSION = '0.3.1'
+  VERSION = '0.4.0'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: shale
 version: !ruby/object:Gem::Version
-  version: 0.3.1
+  version: 0.4.0
 platform: ruby
 authors:
 - Kamil Giszczak
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2022-05-10 00:00:00.000000000 Z
+date: 2022-05-30 00:00:00.000000000 Z
 dependencies: []
 description: Ruby object mapper and serializer for XML, JSON and YAML.
 email:
@@ -37,28 +37,40 @@ files:
 - lib/shale/mapping/validator.rb
 - lib/shale/mapping/xml.rb
 - lib/shale/schema.rb
-- lib/shale/schema/json.rb
-- lib/shale/schema/json/base.rb
-- lib/shale/schema/json/boolean.rb
-- lib/shale/schema/json/collection.rb
-- lib/shale/schema/json/date.rb
-- lib/shale/schema/json/float.rb
-- lib/shale/schema/json/integer.rb
-- lib/shale/schema/json/object.rb
-- lib/shale/schema/json/ref.rb
-- lib/shale/schema/json/schema.rb
-- lib/shale/schema/json/string.rb
-- lib/shale/schema/json/time.rb
-- lib/shale/schema/xml.rb
-- lib/shale/schema/xml/attribute.rb
-- lib/shale/schema/xml/complex_type.rb
-- lib/shale/schema/xml/element.rb
-- lib/shale/schema/xml/import.rb
-- lib/shale/schema/xml/ref_attribute.rb
-- lib/shale/schema/xml/ref_element.rb
-- lib/shale/schema/xml/schema.rb
-- lib/shale/schema/xml/typed_attribute.rb
-- lib/shale/schema/xml/typed_element.rb
+- lib/shale/schema/json_compiler.rb
+- lib/shale/schema/json_compiler/boolean.rb
+- lib/shale/schema/json_compiler/date.rb
+- lib/shale/schema/json_compiler/float.rb
+- lib/shale/schema/json_compiler/integer.rb
+- lib/shale/schema/json_compiler/object.rb
+- lib/shale/schema/json_compiler/property.rb
+- lib/shale/schema/json_compiler/string.rb
+- lib/shale/schema/json_compiler/time.rb
+- lib/shale/schema/json_compiler/utils.rb
+- lib/shale/schema/json_compiler/value.rb
+- lib/shale/schema/json_generator.rb
+- lib/shale/schema/json_generator/base.rb
+- lib/shale/schema/json_generator/boolean.rb
+- lib/shale/schema/json_generator/collection.rb
+- lib/shale/schema/json_generator/date.rb
+- lib/shale/schema/json_generator/float.rb
+- lib/shale/schema/json_generator/integer.rb
+- lib/shale/schema/json_generator/object.rb
+- lib/shale/schema/json_generator/ref.rb
+- lib/shale/schema/json_generator/schema.rb
+- lib/shale/schema/json_generator/string.rb
+- lib/shale/schema/json_generator/time.rb
+- lib/shale/schema/json_generator/value.rb
+- lib/shale/schema/xml_generator.rb
+- lib/shale/schema/xml_generator/attribute.rb
+- lib/shale/schema/xml_generator/complex_type.rb
+- lib/shale/schema/xml_generator/element.rb
+- lib/shale/schema/xml_generator/import.rb
+- lib/shale/schema/xml_generator/ref_attribute.rb
+- lib/shale/schema/xml_generator/ref_element.rb
+- lib/shale/schema/xml_generator/schema.rb
+- lib/shale/schema/xml_generator/typed_attribute.rb
+- lib/shale/schema/xml_generator/typed_element.rb
 - lib/shale/type/boolean.rb
 - lib/shale/type/composite.rb
 - lib/shale/type/date.rb