shale 0.2.1 → 0.3.1

data/lib/shale/adapter/rexml.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require 'rexml/document'
+require_relative '../utils'
 
 module Shale
   module Adapter
@@ -23,12 +24,27 @@ module Shale
       # Serialize REXML document into XML
       #
       # @param [::REXML::Document] doc REXML document
+      # @param [Array<Symbol>] options
       #
       # @return [String]
       #
       # @api private
-      def self.dump(doc)
-        doc.to_s
+      def self.dump(doc, *options)
+        if options.include?(:declaration)
+          doc.add(::REXML::XMLDecl.new)
+        end
+
+        io = StringIO.new
+
+        if options.include?(:pretty)
+          formatter = ::REXML::Formatters::Pretty.new
+          formatter.compact = true
+        else
+          formatter = ::REXML::Formatters::Default.new
+        end
+
+        formatter.write(doc, io)
+        io.string
       end
 
       # Create Shale::Adapter::REXML::Document instance
@@ -42,18 +58,28 @@ module Shale
       #
       # @api private
       class Document
+        # Initialize object
+        #
+        # @api private
+        def initialize
+          context = { attribute_quote: :quote, prologue_quote: :quote }
+          @doc = ::REXML::Document.new(nil, context)
+          @namespaces = {}
+        end
+
         # Return REXML document
         #
         # @return [::REXML::Document]
         #
         # @api private
-        attr_reader :doc
+        def doc
+          if @doc.root
+            @namespaces.each do |prefix, namespace|
+              @doc.root.add_namespace(prefix, namespace)
+            end
+          end
 
-        # Initialize object
-        #
-        # @api private
-        def initialize
-          @doc = ::REXML::Document.new
+          @doc
         end
 
         # Create REXML element
@@ -64,7 +90,17 @@ module Shale
         #
         # @api private
         def create_element(name)
-          ::REXML::Element.new(name)
+          ::REXML::Element.new(name, nil, attribute_quote: :quote)
+        end
+
+        # Add XML namespace to document
+        #
+        # @param [String] prefix
+        # @param [String] namespace
+        #
+        # @api private
+        def add_namespace(prefix, namespace)
+          @namespaces[prefix] = namespace if prefix && namespace
         end
 
         # Add attribute to REXML element
@@ -112,7 +148,7 @@ module Shale
           @node = node
         end
 
-        # Return fully qualified name of the node in the format of
+        # Return name of the node in the format of
         # namespace:name when the node is namespaced or just name when it's not
         #
         # @return [String]
@@ -121,11 +157,11 @@ module Shale
         #   node.name # => Bar
         #
         # @example with namespace
-        #   node.name # => foo:Bar
+        #   node.name # => http://foo:Bar
         #
         # @api private
         def name
-          @node.expanded_name
+          [Utils.presence(@node.namespace), @node.name].compact.join(':')
         end
 
         # Return all attributes associated with the node
@@ -134,7 +170,14 @@ module Shale
         #
         # @api private
         def attributes
-          @node.attributes
+          attributes = @node.attributes.values.map do |attribute|
+            attribute.is_a?(Hash) ? attribute.values : attribute
+          end.flatten
+
+          attributes.each_with_object({}) do |attribute, hash|
+            name = [Utils.presence(attribute.namespace), attribute.name].compact.join(':')
+            hash[name] = attribute.value
+          end
         end
 
         # Return node's element children

data/lib/shale/attribute.rb

@@ -23,7 +23,7 @@ module Shale
     # Initialize Attribute object
     #
     # @param [Symbol] name Name of the attribute
-    # @param [Shale::Type::Base] type Type of the attribute
+    # @param [Shale::Type::Value] type Type of the attribute
     # @param [Boolean] collection Is this attribute a collection
     # @param [Proc] default Default value
     #

data/lib/shale/error.rb

@@ -36,4 +36,10 @@ module Shale
   # @api private
   class IncorrectMappingArgumentsError < StandardError
   end
+
+  # Error for passing incorrect arguments to schema generation function
+  #
+  # @api private
+  class NotAShaleMapperError < StandardError
+  end
 end

data/lib/shale/mapper.rb

@@ -3,7 +3,7 @@
 require_relative 'attribute'
 require_relative 'error'
 require_relative 'utils'
-require_relative 'mapping/key_value'
+require_relative 'mapping/dict'
 require_relative 'mapping/xml'
 require_relative 'type/composite'
 
@@ -44,9 +44,9 @@ module Shale
   # @api public
   class Mapper < Type::Composite
     @attributes = {}
-    @hash_mapping = Mapping::KeyValue.new
-    @json_mapping = Mapping::KeyValue.new
-    @yaml_mapping = Mapping::KeyValue.new
+    @hash_mapping = Mapping::Dict.new
+    @json_mapping = Mapping::Dict.new
+    @yaml_mapping = Mapping::Dict.new
     @xml_mapping = Mapping::Xml.new
 
     class << self
@@ -59,21 +59,21 @@ module Shale
 
       # Return Hash mapping object
       #
-      # @return [Shale::Mapping::KeyValue]
+      # @return [Shale::Mapping::Dict]
       #
       # @api public
       attr_reader :hash_mapping
 
       # Return JSON mapping object
       #
-      # @return [Shale::Mapping::KeyValue]
+      # @return [Shale::Mapping::Dict]
       #
       # @api public
       attr_reader :json_mapping
 
       # Return YAML mapping object
       #
-      # @return [Shale::Mapping::KeyValue]
+      # @return [Shale::Mapping::Dict]
       #
       # @api public
       attr_reader :yaml_mapping
@@ -108,7 +108,7 @@ module Shale
       # Define attribute on class
       #
       # @param [Symbol] name Name of the attribute
-      # @param [Shale::Type::Base] type Type of the attribute
+      # @param [Shale::Type::Value] type Type of the attribute
       # @param [Boolean] collection Is the attribute a collection
       # @param [Proc] default Default value for the attribute
       #
@@ -167,7 +167,7 @@ module Shale
       #     attribute :last_name, Shale::Type::String
       #     attribute :age, Shale::Type::Integer
       #
-      #     yaml do
+      #     hsh do
       #       map 'firatName', to: :first_name
       #       map 'lastName', to: :last_name
       #       map 'age', to: :age
@@ -175,7 +175,7 @@ module Shale
       #   end
       #
       # @api public
-      def hash(&block)
+      def hsh(&block)
         @hash_mapping = @__hash_mapping_init.dup
         @hash_mapping.instance_eval(&block)
       end
@@ -190,7 +190,7 @@ module Shale
       #     attribute :last_name, Shale::Type::String
       #     attribute :age, Shale::Type::Integer
       #
-      #     yaml do
+      #     json do
       #       map 'firatName', to: :first_name
       #       map 'lastName', to: :last_name
       #       map 'age', to: :age

data/lib/shale/mapping/descriptor/dict.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module Shale
+  module Mapping
+    module Descriptor
+      # Class representing attribute mapping
+      #
+      # @api private
+      class Dict
+        # Return mapping name
+        #
+        # @return [String]
+        #
+        # @api private
+        attr_reader :name
+
+        # Return attribute name
+        #
+        # @return [Symbol]
+        #
+        # @api private
+        attr_reader :attribute
+
+        # Return method symbol
+        #
+        # @return [Symbol]
+        #
+        # @api private
+        attr_reader :method_from
+
+        # Return method symbol
+        #
+        # @return [Symbol]
+        #
+        # @api private
+        attr_reader :method_to
+
+        # Initialize instance
+        #
+        # @param [String] name
+        # @param [Symbol, nil] attribute
+        # @param [Hash, nil] methods
+        #
+        # @api private
+        def initialize(name:, attribute:, methods:)
+          @name = name
+          @attribute = attribute
+
+          if methods
+            @method_from = methods[:from]
+            @method_to = methods[:to]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/shale/mapping/descriptor/xml.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require_relative 'dict'
+
+module Shale
+  module Mapping
+    module Descriptor
+      # Class representing XML attribute mapping
+      #
+      # @api private
+      class Xml < Dict
+        # Return namespace
+        #
+        # @return [String]
+        #
+        # @api private
+        attr_reader :namespace
+
+        # Initialize instance
+        #
+        # @param [String] name
+        # @param [Symbol, String] attribute
+        # @param [Hash, nil] methods
+        # @param [Shale::Mapping::XmlNamespace] namespace
+        #
+        # @api private
+        def initialize(name:, attribute:, methods:, namespace:)
+          super(name: name, attribute: attribute, methods: methods)
+          @namespace = namespace
+        end
+
+        # Return name with XML prefix
+        #
+        # @return [String]
+        #
+        # @api private
+        def prefixed_name
+          [namespace.prefix, name].compact.join(':')
+        end
+      end
+    end
+  end
+end

data/lib/shale/mapping/descriptor/xml_namespace.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Shale
+  module Mapping
+    module Descriptor
+      # Class representing XML namespace
+      #
+      # @api private
+      class XmlNamespace
+        # Return name
+        #
+        # @return [String]
+        #
+        # @api private
+        attr_accessor :name
+
+        # Return prefix
+        #
+        # @return [String]
+        #
+        # @api private
+        attr_accessor :prefix
+
+        # Initialize instance
+        #
+        # @param [String, nil] name
+        # @param [String, nil] prefix
+        #
+        # @api private
+        def initialize(name = nil, prefix = nil)
+          @name = name
+          @prefix = prefix
+        end
+      end
+    end
+  end
+end

data/lib/shale/mapping/{key_value.rb → dict.rb}

@@ -1,13 +1,14 @@
 # frozen_string_literal: true
 
-require_relative 'base'
+require_relative 'descriptor/dict'
+require_relative 'validator'
 
 module Shale
   module Mapping
-    # Mapping for key/value serialization formats (Hash/JSON/YAML)
+    # Mapping for dictionary serialization formats (Hash/JSON/YAML)
     #
     # @api private
-    class KeyValue < Base
+    class Dict
       # Return keys mapping hash
       #
       # @return [Hash]
@@ -26,14 +27,15 @@ module Shale
       # Map key to attribute
       #
       # @param [String] key Document's key
-      # @param [Symbol] to Object's attribute
+      # @param [Symbol, nil] to Object's attribute
+      # @param [Hash, nil] using
       #
       # @raise [IncorrectMappingArgumentsError] when arguments are incorrect
       #
       # @api private
       def map(key, to: nil, using: nil)
-        validate_arguments(key, to, using)
-        @keys[key] = to || using
+        Validator.validate_arguments(key, to, using)
+        @keys[key] = Descriptor::Dict.new(name: key, attribute: to, methods: using)
       end
 
       # @api private

data/lib/shale/mapping/validator.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require_relative '../error'
+
+module Shale
+  module Mapping
+    module Validator
+      # Validate correctness of argument passed to map functions
+      #
+      # @param [String] key
+      # @param [Symbol] to
+      # @param [Hash] using
+      #
+      # @raise [IncorrectMappingArgumentsError] when arguments are incorrect
+      #
+      # @api private
+      def self.validate_arguments(key, to, using)
+        if to.nil? && using.nil?
+          msg = ":to or :using argument is required for mapping '#{key}'"
+          raise IncorrectMappingArgumentsError, msg
+        end
+
+        if !using.nil? && (using[:from].nil? || using[:to].nil?)
+          msg = ":using argument for mapping '#{key}' requires :to and :from keys"
+          raise IncorrectMappingArgumentsError, msg
+        end
+      end
+
+      # Validate correctness of namespace arguments
+      #
+      # @param [String] key
+      # @param [String, Symbol, nil] namespace
+      # @param [String, Symbol, nil] prefix
+      #
+      # @raise [IncorrectMappingArgumentsError] when arguments are incorrect
+      #
+      # @api private
+      def self.validate_namespace(key, namespace, prefix)
+        return if namespace == :undefined && prefix == :undefined
+
+        nsp = namespace == :undefined ? nil : namespace
+        pfx = prefix == :undefined ? nil : prefix
+
+        if (nsp && !pfx) || (!nsp && pfx)
+          msg = "both :namespace and :prefix arguments are required for mapping '#{key}'"
+          raise IncorrectMappingArgumentsError, msg
+        end
+      end
+    end
+  end
+end

data/lib/shale/mapping/xml.rb

@@ -1,10 +1,12 @@
 # frozen_string_literal: true
 
-require_relative 'base'
+require_relative 'descriptor/xml'
+require_relative 'descriptor/xml_namespace'
+require_relative 'validator'
 
 module Shale
   module Mapping
-    class Xml < Base
+    class Xml
       # Return elements mapping hash
       #
       # @return [Hash]
@@ -26,6 +28,31 @@ module Shale
       # @api private
       attr_reader :content
 
+      # Return default namespace
+      #
+      # @return [Shale::Mapping::Descriptor::XmlNamespace]
+      #
+      # @api private
+      attr_reader :default_namespace
+
+      # Return unprefixed root
+      #
+      # @return [String]
+      #
+      # @api private
+      def unprefixed_root
+        @root
+      end
+
+      # Return prefixed root
+      #
+      # @return [String]
+      #
+      # @api private
+      def prefixed_root
+        [default_namespace.prefix, @root].compact.join(':')
+      end
+
       # Initialize instance
       #
       # @api private
@@ -35,32 +62,65 @@ module Shale
         @attributes = {}
         @content = nil
         @root = ''
+        @default_namespace = Descriptor::XmlNamespace.new
       end
 
       # Map element to attribute
       #
       # @param [String] element Document's element
-      # @param [Symbol] to Object's attribute
+      # @param [Symbol, nil] to Object's attribute
+      # @param [Hash, nil] using
+      # @param [String, nil] namespace
+      # @param [String, nil] prefix
       #
       # @raise [IncorrectMappingArgumentsError] when arguments are incorrect
       #
       # @api private
-      def map_element(element, to: nil, using: nil)
-        validate_arguments(element, to, using)
-        @elements[element] = to || using
+      def map_element(element, to: nil, using: nil, namespace: :undefined, prefix: :undefined)
+        Validator.validate_arguments(element, to, using)
+        Validator.validate_namespace(element, namespace, prefix)
+
+        if namespace == :undefined && prefix == :undefined
+          nsp = default_namespace.name
+          pfx = default_namespace.prefix
+        else
+          nsp = namespace
+          pfx = prefix
+        end
+
+        namespaced_element = [nsp, element].compact.join(':')
+
+        @elements[namespaced_element] = Descriptor::Xml.new(
+          name: element,
+          attribute: to,
+          methods: using,
+          namespace: Descriptor::XmlNamespace.new(nsp, pfx)
+        )
       end
 
       # Map document's attribute to object's attribute
       #
       # @param [String] attribute Document's attribute
-      # @param [Symbol] to Object's attribute
+      # @param [Symbol, nil] to Object's attribute
+      # @param [Hash, nil] using
+      # @param [String, nil] namespace
+      # @param [String, nil] prefix
       #
       # @raise [IncorrectMappingArgumentsError] when arguments are incorrect
       #
       # @api private
-      def map_attribute(attribute, to: nil, using: nil)
-        validate_arguments(attribute, to, using)
-        @attributes[attribute] = to || using
+      def map_attribute(attribute, to: nil, using: nil, namespace: nil, prefix: nil)
+        Validator.validate_arguments(attribute, to, using)
+        Validator.validate_namespace(attribute, namespace, prefix)
+
+        namespaced_attribute = [namespace, attribute].compact.join(':')
+
+        @attributes[namespaced_attribute] = Descriptor::Xml.new(
+          name: attribute,
+          attribute: to,
+          methods: using,
+          namespace: Descriptor::XmlNamespace.new(namespace, prefix)
+        )
       end
 
       # Map document's content to object's attribute
@@ -72,15 +132,24 @@ module Shale
         @content = to
       end
 
-      # Name document's element
+      # Set the name for root element
+      #
+      # @param [String] value root's name
       #
-      # @param [String, nil] value Document's element name
+      # @api private
+      def root(value)
+        @root = value
+      end
+
+      # Set default namespace for root element
       #
-      # @return [Stirng, nil]
+      # @param [String] name
+      # @param [String] prefix
       #
       # @api private
-      def root(value = nil)
-        value.nil? ? @root : @root = value
+      def namespace(name, prefix)
+        @default_namespace.name = name
+        @default_namespace.prefix = prefix
       end
 
       # @api private
@@ -89,6 +158,8 @@ module Shale
         @attributes = other.instance_variable_get('@attributes').dup
         @content = other.instance_variable_get('@content').dup
         @root = other.instance_variable_get('@root').dup
+        @default_namespace = other.instance_variable_get('@default_namespace').dup
+
         super
       end
     end

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

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Shale
+  module Schema
+    class JSON
+      # Base class for JSON Schema types
+      #
+      # @api private
+      class Base
+        # Return name
+        #
+        # @api private
+        attr_reader :name
+
+        # Return nullable
+        #
+        # @api private
+        attr_writer :nullable
+
+        def initialize(name, default: nil)
+          @name = name.gsub('::', '_')
+          @default = default
+          @nullable = true
+        end
+
+        # Return JSON Schema fragment as Ruby Hash
+        #
+        # @return [Hash]
+        #
+        # @api private
+        def as_json
+          type = as_type
+          type['type'] = [type['type'], 'null'] if type['type'] && @nullable
+          type['default'] = @default unless @default.nil?
+
+          type
+        end
+      end
+    end
+  end
+end

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

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