shale 0.2.2 → 0.3.0

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

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require_relative 'element'
+
+module Shale
+  module Schema
+    class XML
+      # 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/schema.rb

@@ -0,0 +1,121 @@
+# frozen_string_literal: true
+
+require_relative '../../../shale'
+require_relative 'complex_type'
+
+module Shale
+  module Schema
+    class XML
+      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::XML::Import,
+        #         Shale::Schema::XML::Element,
+        #         Shale::Schema::XML::Attribute,
+        #         Shale::Schema::XML::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/typed_attribute.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require_relative 'attribute'
+
+module Shale
+  module Schema
+    class XML
+      # 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/typed_element.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require_relative 'element'
+
+module Shale
+  module Schema
+    class XML
+      # 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

data/lib/shale/schema/xml.rb

@@ -0,0 +1,316 @@
+# 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'
+
+module Shale
+  module Schema
+    # Class for handling XML schema
+    #
+    # @api public
+    class XML
+      # XML Schema default name
+      # @api private
+      DEFAULT_SCHEMA_NAME = 'schema'
+
+      @xml_types = Hash.new('string')
+
+      # Register Shale to XML type mapping
+      #
+      # @param [Shale::Type::Value] shale_type
+      # @param [String] xml_type
+      #
+      # @example
+      #   Shale::Schema::XML.register_xml_type(Shale::Type::String, 'myType')
+      #
+      # @api public
+      def self.register_xml_type(shale_type, xml_type)
+        @xml_types[shale_type] = xml_type
+      end
+
+      # Return XML type for given Shale type
+      #
+      # @param [Shale::Type::Value] shale_type
+      #
+      # @return [String]
+      #
+      # @example
+      #   Shale::Schema::XML.get_xml_type(Shale::Type::String)
+      #   # => 'string'
+      #
+      # @api private
+      def self.get_xml_type(shale_type)
+        @xml_types[shale_type]
+      end
+
+      register_xml_type(Shale::Type::Boolean, 'boolean')
+      register_xml_type(Shale::Type::Date, 'date')
+      register_xml_type(Shale::Type::Float, 'decimal')
+      register_xml_type(Shale::Type::Integer, 'integer')
+      register_xml_type(Shale::Type::Time, 'dateTime')
+
+      # Generate XML Schema from Shale model and return
+      # it as a Shale::Schema::XML::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>]
+      #
+      # @example
+      #   Shale::Schema::XML.new.as_schemas(Person)
+      #
+      # @api public
+      def as_schemas(klass, base_name = nil)
+        unless mapper_type?(klass)
+          raise NotAShaleMapperError, "XML Shema can't be generated for '#{klass}' type"
+        end
+
+        schemas = Hash.new do |hash, key|
+          name = "#{base_name || DEFAULT_SCHEMA_NAME}#{hash.keys.length}.xsd"
+          hash[key] = Schema.new(name, key)
+        end
+
+        default_namespace = klass.xml_mapping.default_namespace
+
+        root_element = TypedElement.new(
+          name: klass.xml_mapping.unprefixed_root,
+          type: [default_namespace.prefix, schematize(klass.name)].compact.join(':'),
+          required: true
+        )
+
+        schemas[default_namespace.name].add_namespace(
+          default_namespace.prefix,
+          default_namespace.name
+        )
+        schemas[default_namespace.name].add_child(root_element)
+
+        composites = collect_composite_types(klass, klass.xml_mapping.default_namespace.name)
+
+        composites.each do |composite|
+          type = composite[:type]
+          namespace = composite[:namespace]
+          children = []
+
+          type.xml_mapping.elements.values.each do |mapping|
+            attribute = type.attributes[mapping.attribute]
+            next unless attribute
+
+            xml_type = get_xml_type_for_attribute(attribute.type, mapping.namespace)
+            default = get_default_for_attribute(attribute)
+
+            if namespace == mapping.namespace.name
+              children << TypedElement.new(
+                name: mapping.name,
+                type: xml_type,
+                collection: attribute.collection?,
+                default: default
+              )
+            else
+              target_namespace = mapping.namespace
+              target_schema = schemas[target_namespace.name]
+
+              children << RefElement.new(
+                ref: mapping.prefixed_name,
+                collection: attribute.collection?,
+                default: default
+              )
+
+              target_element = TypedElement.new(
+                name: mapping.name,
+                type: xml_type,
+                required: true
+              )
+
+              import_element = Import.new(
+                target_namespace.name,
+                target_schema.name
+              )
+
+              target_schema.add_namespace(
+                target_namespace.prefix,
+                target_namespace.name
+              )
+              target_schema.add_child(target_element)
+
+              schemas[namespace].add_namespace(
+                target_namespace.prefix,
+                target_namespace.name
+              )
+              schemas[namespace].add_child(import_element)
+            end
+          end
+
+          type.xml_mapping.attributes.values.each do |mapping|
+            attribute = type.attributes[mapping.attribute]
+            next unless attribute
+
+            xml_type = get_xml_type_for_attribute(attribute.type, mapping.namespace)
+            default = get_default_for_attribute(attribute)
+
+            if namespace == mapping.namespace.name
+              children << TypedAttribute.new(
+                name: mapping.name,
+                type: xml_type,
+                default: default
+              )
+            else
+              target_namespace = mapping.namespace
+              target_schema = schemas[target_namespace.name]
+
+              children << RefAttribute.new(
+                ref: mapping.prefixed_name,
+                default: default
+              )
+
+              target_element = TypedAttribute.new(name: mapping.name, type: xml_type)
+
+              import_element = Import.new(
+                target_namespace.name,
+                target_schema.name
+              )
+
+              target_schema.add_namespace(
+                target_namespace.prefix,
+                target_namespace.name
+              )
+              target_schema.add_child(target_element)
+
+              schemas[namespace].add_namespace(
+                target_namespace.prefix,
+                target_namespace.name
+              )
+              schemas[namespace].add_child(import_element)
+            end
+          end
+
+          complex = ComplexType.new(
+            schematize(type.name),
+            children,
+            mixed: !type.xml_mapping.content.nil?
+          )
+
+          schemas[namespace].add_child(complex)
+        end
+
+        schemas.values
+      end
+
+      # Generate XML Schema from Shale model
+      #
+      # @param [Shale::Mapper] klass
+      # @param [String, nil] base_name
+      # @param [true, false] pretty
+      # @param [true, false] declaration
+      #
+      # @return [Hash<String, String>]
+      #
+      # @example
+      #   Shale::Schema::XML.new.to_schemas(Person)
+      #
+      # @api public
+      def to_schemas(klass, base_name = nil, pretty: false, declaration: false)
+        schemas = as_schemas(klass, base_name)
+
+        options = [
+          pretty ? :pretty : nil,
+          declaration ? :declaration : nil,
+        ]
+
+        schemas.to_h do |schema|
+          [schema.name, Shale.xml_adapter.dump(schema.as_xml, *options)]
+        end
+      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
+      # @param [String, nil] namespace
+      #
+      # @return [Array<Hash<Symbol, String>>]
+      #
+      # @api private
+      def collect_composite_types(type, namespace)
+        types = [{ type: type, namespace: namespace }]
+
+        type.xml_mapping.elements.values.each do |mapping|
+          attribute = type.attributes[mapping.attribute]
+          next unless attribute
+
+          is_mapper = mapper_type?(attribute.type)
+          is_included = types.include?({ type: attribute.type, namespace: namespace })
+
+          if is_mapper && !is_included
+            types += collect_composite_types(attribute.type, mapping.namespace.name)
+          end
+        end
+
+        types.uniq
+      end
+
+      # Convert Ruby class name to XML Schema name
+      #
+      # @param [String] word
+      #
+      # @return [String]
+      #
+      # @api private
+      def schematize(word)
+        word.gsub('::', '_')
+      end
+
+      # Return XML Schema type for given Shale::Type::Value
+      #
+      # @param [Shale::Type::Value] type
+      # @param [String] namespace
+      #
+      # @return [String]
+      #
+      # @api private
+      def get_xml_type_for_attribute(type, namespace)
+        if mapper_type?(type)
+          [namespace.prefix, schematize(type.name)].compact.join(':')
+        else
+          "xs:#{self.class.get_xml_type(type)}"
+        end
+      end
+
+      # Return default value for given Shale::Attribute
+      #
+      # @param [Shale::Attribute] attribute
+      #
+      # @return [String, nil]
+      #
+      # @api private
+      def get_default_for_attribute(attribute)
+        return unless attribute.default
+        return if attribute.collection?
+        return if mapper_type?(attribute.type)
+
+        value = attribute.type.cast(attribute.default.call)
+        attribute.type.as_xml_value(value)
+      end
+    end
+  end
+end

data/lib/shale/schema.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require_relative 'schema/json'
+require_relative 'schema/xml'
+
+module Shale
+  # Module for handling JSON and XML schema
+  #
+  # @api private
+  module Schema
+    # 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.to_json(Person, id: 'My ID', description: 'My description', pretty: true)
+    #   # => 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)
+    end
+
+    # Generate XML Schema from Shale model
+    #
+    # @param [Shale::Mapper] klass
+    # @param [String, nil] base_name
+    # @param [true, false] pretty
+    # @param [true, false] declaration
+    #
+    # @return [Hash<String, String>]
+    #
+    # @example
+    #   Shale::Schema.to_xml(Person, pretty: true, declaration: true)
+    #   # => { 'schema0.xsd' => <JSON schema>, 'schema1.xsd' => <JSON schema> }
+    #
+    # @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)
+    end
+  end
+end

data/lib/shale/type/boolean.rb

@@ -1,13 +1,13 @@
 # frozen_string_literal: true
 
-require_relative 'base'
+require_relative 'value'
 
 module Shale
   module Type
     # Cast value to Boolean
     #
     # @api public
-    class Boolean < Base
+    class Boolean < Value
       FALSE_VALUES = [
         false,
         0,