shale 0.3.0 → 0.5.0

data/lib/shale/adapter/rexml/node.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+require_relative '../../utils'
+
+module Shale
+  module Adapter
+    module REXML
+      # Wrapper around REXML::Element API
+      #
+      # @api private
+      class Node
+        # Initialize object with REXML element
+        #
+        # @param [::REXML::Element] node REXML element
+        #
+        # @api private
+        def initialize(node)
+          @node = node
+        end
+
+        # Return namespaces defined on document
+        #
+        # @return [Hash<String, String>]
+        #
+        # @example
+        #   node.namespaces # => { 'foo' => 'http://foo.com', 'bar' => 'http://bar.com' }
+        #
+        # @api private
+        def namespaces
+          @node.namespaces
+        end
+
+        # 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]
+        #
+        # @example without namespace
+        #   node.name # => Bar
+        #
+        # @example with namespace
+        #   node.name # => http://foo:Bar
+        #
+        # @api private
+        def name
+          [Utils.presence(@node.namespace), @node.name].compact.join(':')
+        end
+
+        # Return all attributes associated with the node
+        #
+        # @return [Hash]
+        #
+        # @api private
+        def 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 parent
+        #
+        # @return [Shale::Adapter::REXML::Node, nil]
+        #
+        # @api private
+        def parent
+          if @node.parent && @node.parent.name != ''
+            self.class.new(@node.parent)
+          end
+        end
+
+        # Return node's element children
+        #
+        # @return [Array<Shale::Adapter::REXML::Node>]
+        #
+        # @api private
+        def children
+          @node
+            .children
+            .filter { |e| e.node_type == :element }
+            .map { |e| self.class.new(e) }
+        end
+
+        # Return first text child of a node
+        #
+        # @return [String]
+        #
+        # @api private
+        def text
+          @node.text
+        end
+      end
+    end
+  end
+end

data/lib/shale/adapter/rexml.rb

@@ -1,7 +1,10 @@
 # frozen_string_literal: true
 
 require 'rexml/document'
-require_relative '../utils'
+
+require_relative '../error'
+require_relative 'rexml/document'
+require_relative 'rexml/node'
 
 module Shale
   module Adapter
@@ -13,12 +16,16 @@ module Shale
       #
       # @param [String] xml XML document
       #
-      # @return [::REXML::Document]
+      # @raise [ParseError] when XML document has errors
+      #
+      # @return [Shale::Adapter::REXML::Node]
       #
       # @api private
       def self.load(xml)
         doc = ::REXML::Document.new(xml, ignore_whitespace_nodes: :all)
         Node.new(doc.root)
+      rescue ::REXML::ParseException => e
+        raise ParseError, "Document is invalid: #{e.message}"
       end
 
       # Serialize REXML document into XML
@@ -53,154 +60,6 @@ module Shale
       def self.create_document
         Document.new
       end
-
-      # Wrapper around REXML API
-      #
-      # @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
-        def doc
-          if @doc.root
-            @namespaces.each do |prefix, namespace|
-              @doc.root.add_namespace(prefix, namespace)
-            end
-          end
-
-          @doc
-        end
-
-        # Create REXML element
-        #
-        # @param [String] name Name of the XML element
-        #
-        # @return [::REXML::Element]
-        #
-        # @api private
-        def create_element(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
-        #
-        # @param [::REXML::Element] element REXML element
-        # @param [String] name Name of the XML attribute
-        # @param [String] value Value of the XML attribute
-        #
-        # @api private
-        def add_attribute(element, name, value)
-          element.add_attribute(name, value)
-        end
-
-        # Add child element to REXML element
-        #
-        # @param [::REXML::Element] element REXML parent element
-        # @param [::REXML::Element] child REXML child element
-        #
-        # @api private
-        def add_element(element, child)
-          element.add_element(child)
-        end
-
-        # Add text node to REXML element
-        #
-        # @param [::REXML::Element] element REXML element
-        # @param [String] text Text to add
-        #
-        # @api private
-        def add_text(element, text)
-          element.add_text(text)
-        end
-      end
-
-      # Wrapper around REXML::Element API
-      #
-      # @api private
-      class Node
-        # Initialize object with REXML element
-        #
-        # @param [::REXML::Element] node REXML element
-        #
-        # @api private
-        def initialize(node)
-          @node = node
-        end
-
-        # 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]
-        #
-        # @example without namespace
-        #   node.name # => Bar
-        #
-        # @example with namespace
-        #   node.name # => http://foo:Bar
-        #
-        # @api private
-        def name
-          [Utils.presence(@node.namespace), @node.name].compact.join(':')
-        end
-
-        # Return all attributes associated with the node
-        #
-        # @return [Hash]
-        #
-        # @api private
-        def 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
-        #
-        # @return [Array<Shale::Adapter::REXML::Node>]
-        #
-        # @api private
-        def children
-          @node
-            .children
-            .filter { |e| e.node_type == :element }
-            .map { |e| self.class.new(e) }
-        end
-
-        # Return first text child of a node
-        #
-        # @return [String]
-        #
-        # @api private
-        def text
-          @node.text
-        end
-      end
     end
   end
 end

data/lib/shale/attribute.rb

@@ -20,6 +20,11 @@ module Shale
     # @api private
     attr_reader :default
 
+    # Return setter name
+    #
+    # @api private
+    attr_reader :setter
+
     # Initialize Attribute object
     #
     # @param [Symbol] name Name of the attribute
@@ -30,6 +35,7 @@ module Shale
     # @api private
     def initialize(name, type, collection, default)
       @name = name
+      @setter = "#{name}="
       @type = type
       @collection = collection
       @default = collection ? -> { [] } : default

data/lib/shale/error.rb

@@ -1,6 +1,27 @@
 # frozen_string_literal: true
 
 module Shale
+  # Error message displayed when adapter is not set
+  # @api private
+  ADAPTER_NOT_SET_MESSAGE = <<~MSG
+    XML Adapter is not set.
+    To use Shale with XML documents you have to install parser and set adapter.
+
+    To use REXML:
+    require 'shale/adapter/rexml'
+    Shale.xml_adapter = Shale::Adapter::REXML
+
+    To use Nokogiri:
+    # Make sure Nokogiri is installed eg. execute: gem install nokogiri
+    require 'shale/adapter/nokogiri'
+    Shale.xml_adapter = Shale::Adapter::Nokogiri
+
+    To use OX:
+    # Make sure Ox is installed eg. execute: gem install ox
+    require 'shale/adapter/ox'
+    Shale.xml_adapter = Shale::Adapter::Ox
+  MSG
+
   # Error for assigning value to not existing attribute
   #
   # @api private
@@ -42,4 +63,22 @@ module Shale
   # @api private
   class NotAShaleMapperError < StandardError
   end
+
+  # Schema compilation error
+  #
+  # @api private
+  class SchemaError < StandardError
+  end
+
+  # Parsing error
+  #
+  # @api private
+  class ParseError < StandardError
+  end
+
+  # Adapter error
+  #
+  # @api private
+  class AdapterError < StandardError
+  end
 end

data/lib/shale/mapper.rb

@@ -5,7 +5,7 @@ require_relative 'error'
 require_relative 'utils'
 require_relative 'mapping/dict'
 require_relative 'mapping/xml'
-require_relative 'type/composite'
+require_relative 'type/complex'
 
 module Shale
   # Base class used for mapping
@@ -42,7 +42,7 @@ module Shale
   #   person.to_json
   #
   # @api public
-  class Mapper < Type::Composite
+  class Mapper < Type::Complex
     @attributes = {}
     @hash_mapping = Mapping::Dict.new
     @json_mapping = Mapping::Dict.new
@@ -272,9 +272,11 @@ module Shale
     def initialize(**props)
       super()
 
-      props.each_key do |name|
-        unless self.class.attributes.keys.include?(name)
-          raise UnknownAttributeError.new(self.class.to_s, name.to_s)
+      unless props.empty?
+        unknown_attributes = props.keys - self.class.attributes.keys
+
+        unless unknown_attributes.empty?
+          raise UnknownAttributeError.new(self.class.to_s, unknown_attributes[0].to_s)
         end
       end
 
@@ -285,7 +287,7 @@ module Shale
           value = attribute.default.call
         end
 
-        public_send("#{name}=", value)
+        send(attribute.setter, value)
       end
     end
   end

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

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Shale
+  module Schema
+    module Compiler
+      # 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/compiler/complex.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+require_relative '../../utils'
+
+module Shale
+  module Schema
+    module Compiler
+      # Class representing Shale's complex type
+      #
+      # @api private
+      class Complex
+        # Return id
+        #
+        # @return [String]
+        #
+        # @api private
+        attr_reader :id
+
+        # Return properties
+        #
+        # @return [Array<Shale::Schema::Compiler::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::Compiler::Property>]
+        #
+        # @api private
+        def references
+          @properties
+            .filter { |e| e.type.is_a?(self.class) && e.type != self }
+            .uniq { |e| e.type.id }
+            .sort { |a, b| a.type.file_name <=> b.type.file_name }
+        end
+
+        # Add property to Object
+        #
+        # @param [Shale::Schema::Compiler::Property] property
+        #
+        # @api private
+        def add_property(property)
+          unless @properties.find { |e| e.mapping_name == property.mapping_name }
+            @properties << property
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Shale
+  module Schema
+    module Compiler
+      # 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/compiler/float.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Shale
+  module Schema
+    module Compiler
+      # 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/compiler/integer.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Shale
+  module Schema
+    module Compiler
+      # 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/compiler/property.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+require_relative '../../utils'
+
+module Shale
+  module Schema
+    module Compiler
+      # Class representing Shale's property
+      #
+      # @api private
+      class Property
+        # Return mapping's name
+        #
+        # @return [String]
+        #
+        # @api private
+        attr_reader :mapping_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::Compiler::Type] type
+        # @param [true, false] collection
+        # @param [Object] default
+        #
+        # @api private
+        def initialize(name, type, collection, default)
+          @mapping_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/compiler/string.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Shale
+  module Schema
+    module Compiler
+      # 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/compiler/time.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Shale
+  module Schema
+    module Compiler
+      # 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/compiler/value.rb

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