shale 0.2.1 → 0.3.1

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

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Shale
+  module Schema
+    class JSON
+      # Class representing array type in JSON Schema
+      #
+      # @api private
+      class Collection
+        # Initialize Collection object
+        #
+        # @param [Shale::Schema::JSON::Base] type
+        #
+        # @api private
+        def initialize(type)
+          @type = type
+        end
+
+        # Delegate name to wrapped type object
+        #
+        # @return [String]
+        #
+        # @api private
+        def name
+          @type.name
+        end
+
+        # Return JSON Schema fragment as Ruby Hash
+        #
+        # @return [Hash]
+        #
+        # @api private
+        def as_json
+          { 'type' => 'array', 'items' => @type.as_type }
+        end
+      end
+    end
+  end
+end

data/lib/shale/schema/json/date.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require_relative 'base'
+
+module Shale
+  module Schema
+    class JSON
+      # Class representing JSON Schema date type
+      #
+      # @api private
+      class Date < Base
+        # Return JSON Schema fragment as Ruby Hash
+        #
+        # @return [Hash]
+        #
+        # @api private
+        def as_type
+          { 'type' => 'string', 'format' => 'date' }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require_relative 'base'
+
+module Shale
+  module Schema
+    class JSON
+      # Class representing JSON Schema float type
+      #
+      # @api private
+      class Float < Base
+        # Return JSON Schema fragment as Ruby Hash
+        #
+        # @return [Hash]
+        #
+        # @api private
+        def as_type
+          { 'type' => 'number' }
+        end
+      end
+    end
+  end
+end

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

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

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

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require_relative 'base'
+
+module Shale
+  module Schema
+    class JSON
+      # Class representing JSON Schema object type
+      #
+      # @api private
+      class Object < Base
+        # Initialize object
+        #
+        # @param [String] name
+        # @param [Array<Shale::Schema::JSON::Base, Shale::Schema::JSON::Collection>] properties
+        #
+        # @api private
+        def initialize(name, properties)
+          super(name)
+          @properties = properties
+        end
+
+        # Return JSON Schema fragment as Ruby Hash
+        #
+        # @return [Hash]
+        #
+        # @api private
+        def as_type
+          {
+            'type' => 'object',
+            'properties' => @properties.to_h { |el| [el.name, el.as_json] },
+          }
+        end
+      end
+    end
+  end
+end

data/lib/shale/schema/json/ref.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require_relative 'base'
+
+module Shale
+  module Schema
+    class JSON
+      # Class representing JSON Schema reference
+      #
+      # @api private
+      class Ref < Base
+        def initialize(name, type)
+          super(name)
+          @type = type.gsub('::', '_')
+        end
+
+        # Return JSON Schema fragment as Ruby Hash
+        #
+        # @return [Hash]
+        #
+        # @api private
+        def as_type
+          { '$ref' => "#/$defs/#{@type}" }
+        end
+      end
+    end
+  end
+end

data/lib/shale/schema/json/schema.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module Shale
+  module Schema
+    class JSON
+      # Class representing JSON schema
+      #
+      # @api private
+      class Schema
+        # JSON Schema dialect (aka version)
+        # @api private
+        DIALECT = 'https://json-schema.org/draft/2020-12/schema'
+
+        # Initialize Schema object
+        #
+        # @param [Array<Shale::Schema::JSON::Base>] types
+        # @param [String, nil] id
+        # @param [String, nil] description
+        #
+        # @api private
+        def initialize(types, id: nil, description: nil)
+          @types = types
+          @id = id
+          @description = description
+        end
+
+        # Return JSON schema as Ruby Hash
+        #
+        # @return [Hash]
+        #
+        # @example
+        #   Shale::Schema::JSON::Schema.new(types).as_json
+        #
+        # @api private
+        def as_json
+          schema = {
+            '$schema' => DIALECT,
+            '$id' => @id,
+            'description' => @description,
+          }
+
+          unless @types.empty?
+            root = @types.first
+            root.nullable = false
+
+            schema['$ref'] = "#/$defs/#{root.name}"
+            schema['$defs'] = @types
+              .sort { |a, b| a.name <=> b.name }
+              .to_h { |e| [e.name, e.as_json] }
+          end
+
+          schema.compact
+        end
+      end
+    end
+  end
+end

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

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

data/lib/shale/schema/json/time.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require_relative 'base'
+
+module Shale
+  module Schema
+    class JSON
+      # Class representing JSON Schema time type
+      #
+      # @api private
+      class Time < Base
+        # Return JSON Schema fragment as Ruby Hash
+        #
+        # @return [Hash]
+        #
+        # @api private
+        def as_type
+          { 'type' => 'string', 'format' => 'date-time' }
+        end
+      end
+    end
+  end
+end

data/lib/shale/schema/json.rb

@@ -0,0 +1,165 @@
+# 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'
+
+module Shale
+  module Schema
+    # Class for handling JSON schema
+    #
+    # @api public
+    class JSON
+      @json_types = Hash.new(Shale::Schema::JSON::String)
+
+      # Register Shale to JSON type mapping
+      #
+      # @param [Shale::Type::Value] shale_type
+      # @param [Shale::Schema::JSON::Base] json_type
+      #
+      # @example
+      #   Shale::Schema::JSON.register_json_type(Shale::Type::String, MyCustomJsonType)
+      #
+      # @api public
+      def self.register_json_type(shale_type, json_type)
+        @json_types[shale_type] = json_type
+      end
+
+      # Return JSON type for given Shale type
+      #
+      # @param [Shale::Type::Value] shale_type
+      #
+      # @return [Shale::Schema::JSON::Base]
+      #
+      # @example
+      #   Shale::Schema::JSON.get_json_type(Shale::Type::String)
+      #   # => Shale::Schema::JSON::String
+      #
+      # @api private
+      def self.get_json_type(shale_type)
+        @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)
+
+      # Generate JSON Schema from Shale model and return it as a Ruby Hash
+      #
+      # @param [Shale::Mapper] klass
+      # @param [String, nil] id
+      # @param [String, nil] description
+      #
+      # @raise [NotAShaleMapperError] when attribute is not a Shale model
+      #
+      # @return [Hash]
+      #
+      # @example
+      #   Shale::Schema::JSON.new.as_schema(Person)
+      #
+      # @api public
+      def as_schema(klass, id: nil, description: nil)
+        unless mapper_type?(klass)
+          raise NotAShaleMapperError, "JSON Shema can't be generated for '#{klass}' type"
+        end
+
+        types = collect_composite_types(klass)
+        objects = []
+
+        types.each do |type|
+          properties = []
+
+          type.json_mapping.keys.values.each do |mapping|
+            attribute = type.attributes[mapping.attribute]
+            next unless attribute
+
+            if mapper_type?(attribute.type)
+              json_type = Ref.new(mapping.name, attribute.type.name)
+            else
+              json_klass = self.class.get_json_type(attribute.type)
+
+              if attribute.default && !attribute.collection?
+                value = attribute.type.cast(attribute.default.call)
+                default = attribute.type.as_json(value)
+              end
+
+              json_type = json_klass.new(mapping.name, default: default)
+            end
+
+            json_type = Collection.new(json_type) if attribute.collection?
+            properties << json_type
+          end
+
+          objects << Object.new(type.name, properties)
+        end
+
+        Schema.new(objects, id: id, description: description).as_json
+      end
+
+      # Generate JSON Schema from Shale model
+      #
+      # @param [Shale::Mapper] klass
+      # @param [String, nil] id
+      # @param [String, nil] description
+      # @param [true, false] pretty
+      #
+      # @return [String]
+      #
+      # @example
+      #   Shale::Schema::JSON.new.to_schema(Person)
+      #
+      # @api public
+      def to_schema(klass, id: nil, description: nil, pretty: false)
+        schema = as_schema(klass, id: id, description: description)
+        options = pretty ? :pretty : nil
+
+        Shale.json_adapter.dump(schema, options)
+      end
+
+      private
+
+      # Check it type inherits from Shale::Mapper
+      #
+      # @param [Class] type
+      #
+      # @return [true, false]
+      #
+      # @api private
+      def mapper_type?(type)
+        type < Shale::Mapper
+      end
+
+      # Collect recursively Shale::Mapper types
+      #
+      # @param [Shale::Mapper] type
+      #
+      # @return [Array<Shale::Mapper>]
+      #
+      # @api private
+      def collect_composite_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)
+          end
+        end
+
+        types.uniq
+      end
+    end
+  end
+end

data/lib/shale/schema/xml/attribute.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Shale
+  module Schema
+    class XML
+      # Class representing XML Schema <attribute> element.
+      # Serves as a base class for TypedAttribute and RefAttribute
+      #
+      # @api private
+      class Attribute
+        # Initialize Attribute object
+        #
+        # @param [String, nil] default
+        #
+        # @api private
+        def initialize(default)
+          @default = default
+        end
+
+        # Append element to the XML document
+        #
+        # @param [Shale::Adapter::<XML adapter>::Document] doc
+        #
+        # @return [Shale::Adapter::<XML adapter>::Node]
+        #
+        # @api private
+        def as_xml(doc)
+          attribute = doc.create_element('xs:attribute')
+
+          attributes.each do |name, value|
+            doc.add_attribute(attribute, name, value)
+          end
+
+          doc.add_attribute(attribute, 'default', @default) unless @default.nil?
+
+          attribute
+        end
+      end
+    end
+  end
+end

data/lib/shale/schema/xml/complex_type.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+require_relative 'attribute'
+require_relative 'element'
+
+module Shale
+  module Schema
+    class XML
+      # Class representing XML Schema <complexType> element
+      #
+      # @api private
+      class ComplexType
+        # Return name
+        #
+        # @return [String]
+        #
+        # @api private
+        attr_reader :name
+
+        # Initialize ComplexType object
+        #
+        # @param [String] name
+        # @param [Array<Shale::Schema::XML::Element, Shale::Schema::XML::Attribute>] children
+        # @param [true, false] mixed
+        #
+        # @api private
+        def initialize(name, children = [], mixed: false)
+          @name = name
+          @children = children
+          @mixed = mixed
+        end
+
+        # Append element to the XML document
+        #
+        # @param [Shale::Adapter::<XML adapter>::Document] doc
+        #
+        # @return [Shale::Adapter::<XML adapter>::Node]
+        #
+        # @api private
+        def as_xml(doc)
+          complex_type = doc.create_element('xs:complexType')
+
+          doc.add_attribute(complex_type, 'name', @name)
+          doc.add_attribute(complex_type, 'mixed', 'true') if @mixed
+
+          elements = @children.select { |e| e.is_a?(Element) }
+          attributes = @children.select { |e| e.is_a?(Attribute) }
+
+          unless elements.empty?
+            sequence = doc.create_element('xs:sequence')
+            doc.add_element(complex_type, sequence)
+
+            elements.each do |element|
+              doc.add_element(sequence, element.as_xml(doc))
+            end
+          end
+
+          attributes.each do |attribute|
+            doc.add_element(complex_type, attribute.as_xml(doc))
+          end
+
+          complex_type
+        end
+      end
+    end
+  end
+end

data/lib/shale/schema/xml/element.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module Shale
+  module Schema
+    class XML
+      # Class representing XML Schema <element> element.
+      # Serves as a base class for TypedElement and RefElement
+      #
+      # @api private
+      class Element
+        # Initialize Element object
+        #
+        # @param [String, nil] default
+        # @param [true, false] collection
+        # @param [true, false] required
+        #
+        # @api private
+        def initialize(default, collection, required)
+          @default = default
+          @collection = collection
+          @required = required
+        end
+
+        # Append element to the XML document
+        #
+        # @param [Shale::Adapter::<XML adapter>::Document] doc
+        #
+        # @return [Shale::Adapter::<XML adapter>::Node]
+        #
+        # @api private
+        def as_xml(doc)
+          element = doc.create_element('xs:element')
+
+          attributes.each do |name, value|
+            doc.add_attribute(element, name, value)
+          end
+
+          unless @required
+            doc.add_attribute(element, 'minOccurs', 0)
+          end
+
+          if @collection
+            doc.add_attribute(element, 'maxOccurs', 'unbounded')
+          end
+
+          unless @default.nil?
+            doc.add_attribute(element, 'default', @default)
+          end
+
+          element
+        end
+      end
+    end
+  end
+end

data/lib/shale/schema/xml/import.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Shale
+  module Schema
+    class XML
+      # Class representing XML Schema <import> element
+      #
+      # @api private
+      class Import
+        # Return namespace
+        #
+        # @return [String]
+        #
+        # @api private
+        attr_reader :namespace
+
+        # Initialize Import object
+        #
+        # @param [String, nil] namespace
+        # @param [String, nil] location
+        #
+        # @api private
+        def initialize(namespace, location)
+          @namespace = namespace
+          @location = location
+        end
+
+        # Append element to the XML document
+        #
+        # @param [Shale::Adapter::<XML adapter>::Document] doc
+        #
+        # @return [Shale::Adapter::<XML adapter>::Node]
+        #
+        # @api private
+        def as_xml(doc)
+          import = doc.create_element('xs:import')
+
+          doc.add_attribute(import, 'namespace', @namespace)
+          doc.add_attribute(import, 'schemaLocation', @location)
+
+          import
+        end
+      end
+    end
+  end
+end

data/lib/shale/schema/xml/ref_attribute.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require_relative 'attribute'
+
+module Shale
+  module Schema
+    class XML
+      # Class representing XML Schema <attribute ref=""> element
+      # with a reference
+      #
+      # @api private
+      class RefAttribute < Attribute
+        # Initialize RefAttribute object
+        #
+        # @param [String] ref
+        # @param [String, nil] default
+        #
+        # @api private
+        def initialize(ref:, default: nil)
+          super(default)
+          @ref = ref
+        end
+
+        private
+
+        # Return attributes as Ruby Hash
+        #
+        # @return [Hash]
+        #
+        # @api private
+        def attributes
+          { 'ref' => @ref }
+        end
+      end
+    end
+  end
+end