shale 0.2.2 → 0.4.0

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_compiler/boolean.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Shale
+  module Schema
+    class JSONCompiler
+      # Class that maps Schema type to Shale Boolean type
+      #
+      # @api private
+      class Boolean
+        # Return name of the Shale type
+        #
+        # @return [String]
+        #
+        # @api private
+        def name
+          'Shale::Type::Boolean'
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Shale
+  module Schema
+    class JSONCompiler
+      # Class that maps Schema type to Shale Date type
+      #
+      # @api private
+      class Date
+        # Return name of the Shale type
+        #
+        # @return [String]
+        #
+        # @api private
+        def name
+          'Shale::Type::Date'
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Shale
+  module Schema
+    class JSONCompiler
+      # Class that maps Schema type to Shale Float type
+      #
+      # @api private
+      class Float
+        # Return name of the Shale type
+        #
+        # @return [String]
+        #
+        # @api private
+        def name
+          'Shale::Type::Float'
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Shale
+  module Schema
+    class JSONCompiler
+      # Class that maps Schema type to Shale Integer type
+      #
+      # @api private
+      class Integer
+        # Return name of the Shale type
+        #
+        # @return [String]
+        #
+        # @api private
+        def name
+          'Shale::Type::Integer'
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+require_relative 'utils'
+
+module Shale
+  module Schema
+    class JSONCompiler
+      # Class representing Shale's comosite type
+      #
+      # @api private
+      class Object
+        # Return id
+        #
+        # @return [String]
+        #
+        # @api private
+        attr_reader :id
+
+        # Return properties
+        #
+        # @return [Array<Shale::Schema::JSONCompiler::Property>]
+        #
+        # @api private
+        attr_reader :properties
+
+        # Name setter
+        #
+        # @param [String] val
+        #
+        # @api private
+        attr_writer :name
+
+        # Initialize object
+        #
+        # @param [String] id
+        # @param [String] name
+        #
+        # @api private
+        def initialize(id, name)
+          @id = id
+          @name = name
+          @properties = []
+        end
+
+        # Return name
+        #
+        # @return [String]
+        #
+        # @api private
+        def name
+          Utils.classify(@name)
+        end
+
+        # Return file name
+        #
+        # @return [String]
+        #
+        # @api private
+        def file_name
+          Utils.snake_case(@name)
+        end
+
+        # Return references
+        #
+        # @return [Array<Shale::Schema::JSONCompiler::Property>]
+        #
+        # @api private
+        def references
+          @properties
+            .filter { |e| e.type.is_a?(self.class) && e.type != self }
+            .uniq { |e| e.type.id }
+        end
+
+        # Add property to Object
+        #
+        # @param [Shale::Schema::JSONCompiler::Property] property
+        #
+        # @api private
+        def add_property(property)
+          @properties << property
+        end
+      end
+    end
+  end
+end

data/lib/shale/schema/json_compiler/property.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+require_relative 'utils'
+
+module Shale
+  module Schema
+    class JSONCompiler
+      # Class representing Shale's property
+      #
+      # @api private
+      class Property
+        # Return property's name
+        #
+        # @return [String]
+        #
+        # @api private
+        attr_reader :property_name
+
+        # Return attribute's name
+        #
+        # @return [String]
+        #
+        # @api private
+        attr_reader :attribute_name
+
+        # Return types's name
+        #
+        # @return [String]
+        #
+        # @api private
+        attr_reader :type
+
+        # Initialize Property object
+        #
+        # @param [String] name
+        # @param [Shale::Schema::JsonCompiler::Type] type
+        # @param [true, false] collection
+        # @param [Object] default
+        #
+        # @api private
+        def initialize(name, type, collection, default)
+          @property_name = name
+          @attribute_name = Utils.snake_case(name)
+          @type = type
+          @collection = collection
+          @default = default
+        end
+
+        # Return whether property is a collection
+        #
+        # @return [true, false]
+        #
+        # @api private
+        def collection?
+          @collection
+        end
+
+        # Return default value
+        #
+        # @return [nil, Object]
+        #
+        # @api private
+        def default
+          return if collection?
+          @default.is_a?(::String) ? @default.dump : @default
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Shale
+  module Schema
+    class JSONCompiler
+      # Class that maps Schema type to Shale String type
+      #
+      # @api private
+      class String
+        # Return name of the Shale type
+        #
+        # @return [String]
+        #
+        # @api private
+        def name
+          'Shale::Type::String'
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Shale
+  module Schema
+    class JSONCompiler
+      # Class that maps Schema type to Shale Time type
+      #
+      # @api private
+      class Time
+        # Return name of the Shale type
+        #
+        # @return [String]
+        #
+        # @api private
+        def name
+          'Shale::Type::Time'
+        end
+      end
+    end
+  end
+end

data/lib/shale/schema/json_compiler/utils.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module Shale
+  module Schema
+    class JSONCompiler
+      # Module with utility functions
+      #
+      # @api private
+      module Utils
+        # Convert string to Ruby's class naming convention
+        #
+        # @param [String] val
+        #
+        # @example
+        #   Shale::Schema::JSONCompiler.classify('foobar')
+        #   # => 'Foobar'
+        #
+        # @api private
+        def self.classify(str)
+          str = str.to_s.sub(/.*\./, '')
+
+          str = str.sub(/^[a-z\d]*/) { |match| match.capitalize || match }
+
+          str.gsub(%r{(?:_|(/))([a-z\d]*)}i) do
+            word = Regexp.last_match(2)
+            substituted = word.capitalize || word
+            Regexp.last_match(1) ? "::#{substituted}" : substituted
+          end
+        end
+
+        # Convert string to snake case
+        #
+        # @param [String] val
+        #
+        # @example
+        #   Shale::Schema::JSONCompiler.snake_case('FooBar')
+        #   # => 'foo_bar'
+        #
+        # @api private
+        def self.snake_case(str)
+          return str.to_s unless /[A-Z-]|::/.match?(str)
+          word = str.to_s.gsub('::', '/')
+          word = word.gsub(/([A-Z]+)(?=[A-Z][a-z])|([a-z\d])(?=[A-Z])/) do
+            "#{Regexp.last_match(1) || Regexp.last_match(2)}_"
+          end
+          word = word.tr('-', '_')
+          word.downcase
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Shale
+  module Schema
+    class JSONCompiler
+      class Value
+        def name
+          'Shale::Type::Value'
+        end
+      end
+    end
+  end
+end