shale 0.2.2 → 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_generator.rb

@@ -0,0 +1,165 @@
+# frozen_string_literal: true
+
+require_relative '../../shale'
+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 generating JSON schema
+    #
+    # @api public
+    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::JSONGenerator::Base] json_type
+      #
+      # @example
+      #   Shale::Schema::JSONGenerator.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::JSONGenerator::Base]
+      #
+      # @example
+      #   Shale::Schema::JSONGenerator.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::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
+      #
+      # @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::JSONGenerator.new.as_schema(Person)
+      #
+      # @api public
+      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(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, title: title, 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::JSONGenerator.new.to_schema(Person)
+      #
+      # @api public
+      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)
+      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 [Array<Shale::Mapper>] types
+      # @param [Shale::Mapper] type
+      #
+      # @api private
+      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)
+            collect_composite_types(types, attribute.type)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Shale
+  module Schema
+    class XMLGenerator
+      # 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_generator/complex_type.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+require_relative 'attribute'
+require_relative 'element'
+
+module Shale
+  module Schema
+    class XMLGenerator
+      # 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::XMLGenerator::Element,
+        #   Shale::Schema::XMLGenerator::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_generator/element.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module Shale
+  module Schema
+    class XMLGenerator
+      # 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_generator/import.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Shale
+  module Schema
+    class XMLGenerator
+      # 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_generator/ref_attribute.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require_relative 'attribute'
+
+module Shale
+  module Schema
+    class XMLGenerator
+      # 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

data/lib/shale/schema/xml_generator/ref_element.rb

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

data/lib/shale/schema/xml_generator/schema.rb

@@ -0,0 +1,121 @@
+# frozen_string_literal: true
+
+require_relative '../../../shale'
+require_relative 'complex_type'
+
+module Shale
+  module Schema
+    class XMLGenerator
+      class Schema
+        # XML Schema namespace
+        # @api private
+        NAMESPACE_NAME = 'http://www.w3.org/2001/XMLSchema'
+
+        # Return name
+        #
+        # @return [String]
+        #
+        # @api private
+        attr_reader :name
+
+        # Initialize Schema object
+        #
+        # @param [String] name
+        # @param [String, nil] target_namespace
+        #
+        # @api private
+        def initialize(name, target_namespace)
+          @name = name
+          @target_namespace = target_namespace
+          @namespaces = []
+          @children = []
+        end
+
+        # Add namespace to XML Schema
+        #
+        # @param [String] prefix
+        # @param [String] name
+        #
+        # @api private
+        def add_namespace(prefix, name)
+          @namespaces << { prefix: prefix, name: name }
+        end
+
+        # Add child element to XML Schema
+        #
+        # @param [Shale::Schema::XMLGenerator::Import,
+        #         Shale::Schema::XMLGenerator::Element,
+        #         Shale::Schema::XMLGenerator::Attribute,
+        #         Shale::Schema::XMLGenerator::ComplesType] child
+        #
+        # @api private
+        def add_child(child)
+          @children << child
+        end
+
+        # Append element to the XML document
+        #
+        # @param [Shale::Adapter::<XML adapter>::Document] doc
+        #
+        # @return [Shale::Adapter::REXML::Document,
+        #          Shale::Adapter::Nokogiri::Document,
+        #          Shale::Adapter::Ox::Document]
+        #
+        # @api private
+        def as_xml
+          doc = Shale.xml_adapter.create_document
+          doc.add_namespace('xs', NAMESPACE_NAME)
+
+          @namespaces.uniq.each do |namespace|
+            doc.add_namespace(namespace[:prefix], namespace[:name])
+          end
+
+          schema = doc.create_element('xs:schema')
+          doc.add_element(doc.doc, schema)
+
+          doc.add_attribute(schema, 'elementFormDefault', 'qualified')
+          doc.add_attribute(schema, 'attributeFormDefault', 'qualified')
+
+          unless @target_namespace.nil?
+            doc.add_attribute(schema, 'targetNamespace', @target_namespace)
+          end
+
+          imports = @children
+            .select { |e| e.is_a?(Import) }
+            .uniq(&:namespace)
+            .sort { |a, b| (a.namespace || '') <=> (b.namespace || '') }
+
+          elements = @children
+            .select { |e| e.is_a?(Element) }
+            .sort { |a, b| a.name <=> b.name }
+
+          attributes = @children
+            .select { |e| e.is_a?(Attribute) }
+            .sort { |a, b| a.name <=> b.name }
+
+          complex_types = @children
+            .select { |e| e.is_a?(ComplexType) }
+            .sort { |a, b| a.name <=> b.name }
+
+          imports.each do |import|
+            doc.add_element(schema, import.as_xml(doc))
+          end
+
+          elements.each do |element|
+            doc.add_element(schema, element.as_xml(doc))
+          end
+
+          attributes.each do |attribute|
+            doc.add_element(schema, attribute.as_xml(doc))
+          end
+
+          complex_types.each do |complex_type|
+            doc.add_element(schema, complex_type.as_xml(doc))
+          end
+
+          doc.doc
+        end
+      end
+    end
+  end
+end

data/lib/shale/schema/xml_generator/typed_attribute.rb

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

data/lib/shale/schema/xml_generator/typed_element.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require_relative 'element'
+
+module Shale
+  module Schema
+    class XMLGenerator
+      # Class representing XML Schema <element mame="" type=""> element
+      # with a name and a type
+      #
+      # @api private
+      class TypedElement < Element
+        # Return name
+        #
+        # @return [String]
+        #
+        # @api private
+        attr_reader :name
+
+        # Initialize TypedElement object
+        #
+        # @param [String] name
+        # @param [String] type
+        # @param [String, nil] default
+        # @param [true, false] collection
+        # @param [true, false] required
+        #
+        # @api private
+        def initialize(name:, type:, default: nil, collection: false, required: false)
+          super(default, collection, required)
+          @name = name
+          @type = type
+        end
+
+        # Return attributes as Ruby Hash
+        #
+        # @return [Hash]
+        #
+        # @api private
+        def attributes
+          { 'name' => @name, 'type' => @type }
+        end
+      end
+    end
+  end
+end