shale 0.1.0

data/lib/shale/mapping/key_value.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Shale
+  module Mapping
+    # Mapping for key/value serialization formats (Hash/JSON/YAML)
+    #
+    # @api private
+    class KeyValue
+      # Return keys mapping hash
+      #
+      # @return [Hash]
+      #
+      # @api private
+      attr_reader :keys
+
+      # Initialize instance
+      #
+      # @api private
+      def initialize
+        @keys = {}
+      end
+
+      # Map key to attribute
+      #
+      # @param [String] key Document's key
+      # @param [Symbol] to Object's attribute
+      #
+      # @api private
+      def map(key, to:)
+        @keys[key] = to
+      end
+
+      # @api private
+      def initialize_dup(other)
+        @keys = other.instance_variable_get('@keys').dup
+        super
+      end
+    end
+  end
+end

data/lib/shale/mapping/xml.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+module Shale
+  module Mapping
+    class Xml
+      # Return elements mapping hash
+      #
+      # @return [Hash]
+      #
+      # @api private
+      attr_reader :elements
+
+      # Return attributes mapping hash
+      #
+      # @return [Hash]
+      #
+      # @api private
+      attr_reader :attributes
+
+      # Return content mapping
+      #
+      # @return [Symbol]
+      #
+      # @api private
+      attr_reader :content
+
+      # Initialize instance
+      #
+      # @api private
+      def initialize
+        @elements = {}
+        @attributes = {}
+        @content = nil
+        @root = ''
+      end
+
+      # Map element to attribute
+      #
+      # @param [String] element Document's element
+      # @param [Symbol] to Object's attribute
+      #
+      # @api private
+      def map_element(element, to:)
+        @elements[element] = to
+      end
+
+      # Map document's attribute to object's attribute
+      #
+      # @param [String] attribute Document's attribute
+      # @param [Symbol] to Object's attribute
+      #
+      # @api private
+      def map_attribute(attribute, to:)
+        @attributes[attribute] = to
+      end
+
+      # Map document's content to object's attribute
+      #
+      # @param [Symbol] to Object's attribute
+      #
+      # @api private
+      def map_content(to:)
+        @content = to
+      end
+
+      # Name document's element
+      #
+      # @param [String, nil] value Document's element name
+      #
+      # @return [Stirng, nil]
+      #
+      # @api private
+      def root(value = nil)
+        value.nil? ? @root : @root = value
+      end
+
+      # @api private
+      def initialize_dup(other)
+        @elements = other.instance_variable_get('@elements').dup
+        @attributes = other.instance_variable_get('@attributes').dup
+        @content = other.instance_variable_get('@content').dup
+        @root = other.instance_variable_get('@root').dup
+        super
+      end
+    end
+  end
+end

data/lib/shale/type/base.rb

@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+
+module Shale
+  module Type
+    # Base class for all types
+    #
+    # @example
+    #   class MyType < Shale::Type::Base
+    #     ... overwrite methods as needed
+    #   end
+    #
+    # @api public
+    class Base
+      class << self
+        # Cast raw value to a type. Base form just returns whatever it receives
+        #
+        # @param [any] value Value to cast
+        #
+        # @return [any]
+        #
+        # @api private
+        def cast(value)
+          value
+        end
+
+        # Extract value from Hash document
+        #
+        # @param [any] value
+        #
+        # @return [any]
+        #
+        # @api private
+        def out_of_hash(value)
+          value
+        end
+
+        # Convert value to form accepted by Hash document
+        #
+        # @param [any] value
+        #
+        # @return [any]
+        #
+        # @api private
+        def as_hash(value)
+          value
+        end
+
+        # Extract value from JSON document
+        #
+        # @param [any] value
+        #
+        # @return [any]
+        #
+        # @api private
+        def out_of_json(value)
+          value
+        end
+
+        # Convert value to form accepted by JSON document
+        #
+        # @param [any] value
+        #
+        # @return [any]
+        #
+        # @api private
+        def as_json(value)
+          value
+        end
+
+        # Extract value from YAML document
+        #
+        # @param [any] value
+        #
+        # @return [any]
+        #
+        # @api private
+        def out_of_yaml(value)
+          value
+        end
+
+        # Convert value to form accepted by YAML document
+        #
+        # @param [any] value
+        #
+        # @return [any]
+        #
+        # @api private
+        def as_yaml(value)
+          value
+        end
+
+        # Extract value from XML document
+        #
+        # @param [Shale::Adapter::<XML adapter>::Node] value
+        #
+        # @return [String]
+        #
+        # @api private
+        def out_of_xml(node)
+          node.text
+        end
+
+        # Convert value to form accepted by XML document
+        #
+        # @param [#to_s] value Value to convert to XML
+        # @param [String] name Name of the element
+        # @param [Shale::Adapter::<XML adapter>::Document] doc Document
+        #
+        # @api private
+        def as_xml(value, name, doc)
+          element = doc.create_element(name)
+          doc.add_text(element, value.to_s)
+          element
+        end
+      end
+    end
+  end
+end

data/lib/shale/type/boolean.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require_relative 'base'
+
+module Shale
+  module Type
+    # Cast value to Boolean
+    #
+    # @api public
+    class Boolean < Base
+      FALSE_VALUES = [
+        false,
+        0,
+        '0',
+        'f',
+        'F',
+        'false',
+        'FALSE',
+        'off',
+        'OFF',
+      ].freeze
+
+      # @param [any] value Value to cast
+      #
+      # @return [Boolean, nil]
+      #
+      # @api private
+      def self.cast(value)
+        !FALSE_VALUES.include?(value) unless value.nil?
+      end
+    end
+  end
+end

data/lib/shale/type/complex.rb

@@ -0,0 +1,427 @@
+# frozen_string_literal: true
+
+require_relative 'base'
+
+module Shale
+  module Type
+    # Build complex object. Don't use it directly.
+    # It serves as a base type class for @see Shale::Mapper
+    #
+    # @api private
+    class Complex < Base
+      class << self
+        # Convert Hash to Object
+        #
+        # @param [Hash] hash Hash to convert
+        #
+        # @return [Shale::Mapper]
+        #
+        # @api public
+        def out_of_hash(hash)
+          instance = new
+
+          hash.each do |key, value|
+            mapping = hash_mapping.keys[key]
+            next unless mapping
+
+            attribute = attributes[mapping]
+            next unless attribute
+
+            if value.nil?
+              instance.public_send("#{attribute.name}=", nil)
+              next
+            end
+
+            if attribute.collection?
+              [*value].each do |val|
+                val = val ? attribute.type.out_of_hash(val) : val
+                instance.public_send(attribute.name) << attribute.type.cast(val)
+              end
+            else
+              instance.public_send("#{attribute.name}=", attribute.type.out_of_hash(value))
+            end
+          end
+
+          instance
+        end
+
+        alias from_hash out_of_hash
+
+        # Convert Object to Hash
+        #
+        # @param [Shale::Type::Base] instance Object to convert
+        #
+        # @return [Hash]
+        #
+        # @api public
+        def as_hash(instance)
+          hash = {}
+
+          instance.class.hash_mapping.keys.each do |key, attr|
+            attribute = instance.class.attributes[attr]
+            next unless attribute
+
+            value = instance.public_send(attribute.name)
+
+            if value.nil?
+              hash[key] = nil
+              next
+            end
+
+            if attribute.collection?
+              hash[key] = [*value].map { |v| v ? attribute.type.as_hash(v) : v }
+            else
+              hash[key] = attribute.type.as_hash(value)
+            end
+          end
+
+          hash
+        end
+
+        alias to_hash as_hash
+
+        # Convert JSON document to Object
+        #
+        # @param [Hash] hash JSON document to convert
+        #
+        # @return [Shale::Mapper]
+        #
+        # @api public
+        def out_of_json(hash)
+          instance = new
+
+          hash.each do |key, value|
+            mapping = json_mapping.keys[key]
+            next unless mapping
+
+            attribute = attributes[mapping]
+            next unless attribute
+
+            if value.nil?
+              instance.public_send("#{attribute.name}=", nil)
+              next
+            end
+
+            if attribute.collection?
+              [*value].each do |val|
+                val = val ? attribute.type.out_of_json(val) : val
+                instance.public_send(attribute.name) << attribute.type.cast(val)
+              end
+            else
+              instance.public_send("#{attribute.name}=", attribute.type.out_of_json(value))
+            end
+          end
+
+          instance
+        end
+
+        # Convert JSON to Object
+        #
+        # @param [String] json JSON to convert
+        #
+        # @return [Shale::Mapper]
+        #
+        # @api public
+        def from_json(json)
+          out_of_json(Shale.json_adapter.load(json))
+        end
+
+        # Convert Object to JSON document
+        #
+        # @param [Shale::Type::Base] instance Object to convert
+        #
+        # @return [Hash]
+        #
+        # @api public
+        def as_json(instance)
+          hash = {}
+
+          instance.class.json_mapping.keys.each do |key, attr|
+            attribute = instance.class.attributes[attr]
+            next unless attribute
+
+            value = instance.public_send(attribute.name)
+
+            if value.nil?
+              hash[key] = nil
+              next
+            end
+
+            if attribute.collection?
+              hash[key] = [*value].map { |v| v ? attribute.type.as_json(v) : v }
+            else
+              hash[key] = attribute.type.as_json(value)
+            end
+          end
+
+          hash
+        end
+
+        # Convert Object to JSON
+        #
+        # @param [Shale::Type::Base] instance Object to convert
+        #
+        # @return [String]
+        #
+        # @api public
+        def to_json(instance)
+          Shale.json_adapter.dump(as_json(instance))
+        end
+
+        # Convert YAML document to Object
+        #
+        # @param [Hash] hash YAML document to convert
+        #
+        # @return [Shale::Mapper]
+        #
+        # @api public
+        def out_of_yaml(hash)
+          instance = new
+
+          hash.each do |key, value|
+            mapping = yaml_mapping.keys[key]
+            next unless mapping
+
+            attribute = attributes[mapping]
+            next unless attribute
+
+            if value.nil?
+              instance.public_send("#{attribute.name}=", nil)
+              next
+            end
+
+            if attribute.collection?
+              [*value].each do |val|
+                val = val ? attribute.type.out_of_yaml(val) : val
+                instance.public_send(attribute.name) << attribute.type.cast(val)
+              end
+            else
+              instance.public_send("#{attribute.name}=", attribute.type.out_of_yaml(value))
+            end
+          end
+
+          instance
+        end
+
+        # Convert YAML to Object
+        #
+        # @param [String] yaml YAML to convert
+        #
+        # @return [Shale::Mapper]
+        #
+        # @api public
+        def from_yaml(yaml)
+          out_of_yaml(Shale.yaml_adapter.load(yaml))
+        end
+
+        # Convert Object to YAML document
+        #
+        # @param [Shale::Type::Base] instance Object to convert
+        #
+        # @return [Hash]
+        #
+        # @api public
+        def as_yaml(instance)
+          hash = {}
+
+          instance.class.yaml_mapping.keys.each do |key, attr|
+            attribute = instance.class.attributes[attr]
+            next unless attribute
+
+            value = instance.public_send(attribute.name)
+
+            if value.nil?
+              hash[key] = nil
+              next
+            end
+
+            if attribute.collection?
+              hash[key] = [*value].map { |v| v ? attribute.type.as_yaml(v) : v }
+            else
+              hash[key] = attribute.type.as_yaml(value)
+            end
+          end
+
+          hash
+        end
+
+        # Convert Object to YAML
+        #
+        # @param [Shale::Type::Base] instance Object to convert
+        #
+        # @return [String]
+        #
+        # @api public
+        def to_yaml(instance)
+          Shale.yaml_adapter.dump(as_yaml(instance))
+        end
+
+        # Convert XML document to Object
+        #
+        # @param [Shale::Adapter::<XML adapter>::Node] xml XML to convert
+        #
+        # @return [Shale::Mapper]
+        #
+        # @api public
+        def out_of_xml(element)
+          instance = new
+
+          element.attributes.each do |key, value|
+            mapping = xml_mapping.attributes[key.to_s]
+            next unless mapping
+
+            attribute = attributes[mapping]
+            next unless attribute
+
+            if attribute.collection?
+              instance.public_send(attribute.name) << attribute.type.cast(value)
+            else
+              instance.public_send("#{attribute.name}=", value)
+            end
+          end
+
+          if xml_mapping.content
+            attribute = attributes[xml_mapping.content]
+
+            if attribute
+              instance.public_send("#{attribute.name}=", attribute.type.out_of_xml(element))
+            end
+          end
+
+          element.children.each do |node|
+            mapping = xml_mapping.elements[node.name]
+            next unless mapping
+
+            attribute = attributes[mapping]
+            next unless attribute
+
+            if attribute.collection?
+              value = attribute.type.out_of_xml(node)
+              instance.public_send(attribute.name) << attribute.type.cast(value)
+            else
+              instance.public_send("#{attribute.name}=", attribute.type.out_of_xml(node))
+            end
+          end
+
+          instance
+        end
+
+        # Convert XML to Object
+        #
+        # @param [String] xml XML to convert
+        #
+        # @return [Shale::Mapper]
+        #
+        # @api public
+        def from_xml(xml)
+          out_of_xml(Shale.xml_adapter.load(xml))
+        end
+
+        # Convert Object to XML document
+        #
+        # @param [Shale::Type::Base] instance Object to convert
+        # @param [String, nil] node_name XML node name
+        # @param [Shale::Adapter::<xml adapter>::Document, nil] doc Object to convert
+        #
+        # @return [::REXML::Document, ::Nokogiri::Document, ::Ox::Document]
+        #
+        # @api public
+        def as_xml(instance, node_name = nil, doc = nil)
+          unless doc
+            doc = Shale.xml_adapter.create_document
+            doc.add_element(doc.doc, as_xml(instance, instance.class.xml_mapping.root, doc))
+            return doc.doc
+          end
+
+          element = doc.create_element(node_name)
+
+          xml_mapping.attributes.each do |xml_attr, obj_attr|
+            attribute = instance.class.attributes[obj_attr]
+            next unless attribute
+
+            value = instance.public_send(attribute.name)
+
+            if value && !value.empty?
+              doc.add_attribute(element, xml_attr, value)
+            end
+          end
+
+          if xml_mapping.content
+            attribute = instance.class.attributes[xml_mapping.content]
+
+            if attribute
+              value = instance.public_send(attribute.name)
+              doc.add_text(element, value.to_s) if value
+            end
+          end
+
+          xml_mapping.elements.each do |xml_name, obj_attr|
+            attribute = instance.class.attributes[obj_attr]
+            next unless attribute
+
+            value = instance.public_send(attribute.name)
+            next if value.nil?
+
+            if attribute.collection?
+              [*value].each do |v|
+                next if v.nil?
+                doc.add_element(element, attribute.type.as_xml(v, xml_name, doc))
+              end
+            else
+              doc.add_element(element, attribute.type.as_xml(value, xml_name, doc))
+            end
+          end
+
+          element
+        end
+
+        # Convert Object to XML
+        #
+        # @param [Shale::Type::Base] instance Object to convert
+        #
+        # @return [String]
+        #
+        # @api public
+        def to_xml(instance)
+          Shale.xml_adapter.dump(as_xml(instance))
+        end
+      end
+
+      # Convert Object to Hash
+      #
+      # @return [Hash]
+      #
+      # @api public
+      def to_hash
+        self.class.to_hash(self)
+      end
+
+      # Convert Object to JSON
+      #
+      # @return [String]
+      #
+      # @api public
+      def to_json
+        self.class.to_json(self)
+      end
+
+      # Convert Object to YAML
+      #
+      # @return [String]
+      #
+      # @api public
+      def to_yaml
+        self.class.to_yaml(self)
+      end
+
+      # Convert Object to XML
+      #
+      # @return [String]
+      #
+      # @api public
+      def to_xml
+        self.class.to_xml(self)
+      end
+    end
+  end
+end