shale 0.1.0

data/lib/shale/adapter/ox.rb

@@ -0,0 +1,162 @@
+# frozen_string_literal: true
+
+require 'ox'
+
+module Shale
+  module Adapter
+    # Ox adapter
+    #
+    # @api public
+    module Ox
+      # Parse XML into Ox document
+      #
+      # @param [String] xml XML document
+      #
+      # @return [::Ox::Document, ::Ox::Element]
+      #
+      # @api private
+      def self.load(xml)
+        Node.new(::Ox.parse(xml))
+      end
+
+      # Serialize Ox document into XML
+      #
+      # @param [::Ox::Document, ::Ox::Element] doc Ox document
+      #
+      # @return [String]
+      #
+      # @api private
+      def self.dump(doc)
+        ::Ox.dump(doc)
+      end
+
+      # Create Shale::Adapter::Ox::Document instance
+      #
+      # @api private
+      def self.create_document
+        Document.new
+      end
+
+      # Wrapper around Ox API
+      #
+      # @api private
+      class Document
+        # Return Ox document
+        #
+        # @return [::Ox::Document]
+        #
+        # @api private
+        attr_reader :doc
+
+        # Initialize object
+        #
+        # @api private
+        def initialize
+          @doc = ::Ox::Document.new
+        end
+
+        # Create Ox element
+        #
+        # @param [String] name Name of the XML element
+        #
+        # @return [::Ox::Element]
+        #
+        # @api private
+        def create_element(name)
+          ::Ox::Element.new(name)
+        end
+
+        # Add attribute to Ox element
+        #
+        # @param [::Ox::Element] element Ox 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[name] = value
+        end
+
+        # Add child element to Ox element
+        #
+        # @param [::Ox::Element] element Ox parent element
+        # @param [::Ox::Element] child Ox child element
+        #
+        # @api private
+        def add_element(element, child)
+          element << child
+        end
+
+        # Add text node to Ox element
+        #
+        # @param [::Ox::Element] element Ox element
+        # @param [String] text Text to add
+        #
+        # @api private
+        def add_text(element, text)
+          element << text
+        end
+      end
+
+      # Wrapper around Ox::Element API
+      #
+      # @api private
+      class Node
+        # Initialize object with Ox element
+        #
+        # @param [::Ox::Element] node Ox element
+        #
+        # @api private
+        def initialize(node)
+          @node = node
+        end
+
+        # Return fully qualified 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 # => foo:Bar
+        #
+        # @api private
+        def name
+          @node.name
+        end
+
+        # Return all attributes associated with the node
+        #
+        # @return [Hash]
+        #
+        # @api private
+        def attributes
+          @node.attributes
+        end
+
+        # Return node's element children
+        #
+        # @return [Array<Shale::Adapter::Ox::Node>]
+        #
+        # @api private
+        def children
+          @node
+            .nodes
+            .filter { |e| e.is_a?(::Ox::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

@@ -0,0 +1,163 @@
+# frozen_string_literal: true
+
+require 'rexml/document'
+
+module Shale
+  module Adapter
+    # REXML adapter
+    #
+    # @api public
+    module REXML
+      # Parse XML into REXML document
+      #
+      # @param [String] xml XML document
+      #
+      # @return [::REXML::Document]
+      #
+      # @api private
+      def self.load(xml)
+        doc = ::REXML::Document.new(xml, ignore_whitespace_nodes: :all)
+        Node.new(doc.root)
+      end
+
+      # Serialize REXML document into XML
+      #
+      # @param [::REXML::Document] doc REXML document
+      #
+      # @return [String]
+      #
+      # @api private
+      def self.dump(doc)
+        doc.to_s
+      end
+
+      # Create Shale::Adapter::REXML::Document instance
+      #
+      # @api private
+      def self.create_document
+        Document.new
+      end
+
+      # Wrapper around REXML API
+      #
+      # @api private
+      class Document
+        # Return REXML document
+        #
+        # @return [::REXML::Document]
+        #
+        # @api private
+        attr_reader :doc
+
+        # Initialize object
+        #
+        # @api private
+        def initialize
+          @doc = ::REXML::Document.new
+        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)
+        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 fully qualified 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 # => foo:Bar
+        #
+        # @api private
+        def name
+          @node.expanded_name
+        end
+
+        # Return all attributes associated with the node
+        #
+        # @return [Hash]
+        #
+        # @api private
+        def attributes
+          @node.attributes
+        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

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Shale
+  # Class representing object's attribute
+  #
+  # @api private
+  class Attribute
+    # Return name
+    #
+    # @api private
+    attr_reader :name
+
+    # Return type
+    #
+    # @api private
+    attr_reader :type
+
+    # Return default
+    #
+    # @api private
+    attr_reader :default
+
+    # Initialize Attribute object
+    #
+    # @param [Symbol] name Name of the attribute
+    # @param [Shale::Type::Base] type Type of the attribute
+    # @param [Boolean] collection Is this attribute a collection
+    # @param [Proc] default Default value
+    #
+    # @api private
+    def initialize(name, type, collection, default)
+      @name = name
+      @type = type
+      @collection = collection
+      @default = collection ? -> { [] } : default
+    end
+
+    # Return wheter attribute is collection or not
+    #
+    # @return [Boolean]
+    #
+    # @api private
+    def collection?
+      @collection == true
+    end
+  end
+end

data/lib/shale/error.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Shale
+  # Error for assigning value to not existing attribute
+  #
+  # @api private
+  class UnknownAttributeError < NoMethodError
+    # Initialize error object
+    #
+    # @param [String] record
+    # @param [String] attribute
+    #
+    # @api private
+    def initialize(record, attribute)
+      super("unknown attribute '#{attribute}' for #{record}.")
+    end
+  end
+
+  # Error for trying to assign not callable object as an attribute's default
+  #
+  # @api private
+  class DefaultNotCallableError < StandardError
+    # Initialize error object
+    #
+    # @param [String] record
+    # @param [String] attribute
+    #
+    # @api private
+    def initialize(record, attribute)
+      super("'#{attribute}' default is not callable for #{record}.")
+    end
+  end
+end

data/lib/shale/mapper.rb

@@ -0,0 +1,292 @@
+# frozen_string_literal: true
+
+require_relative 'attribute'
+require_relative 'error'
+require_relative 'utils'
+require_relative 'mapping/key_value'
+require_relative 'mapping/xml'
+require_relative 'type/complex'
+
+module Shale
+  # Base class used for mapping
+  #
+  # @example
+  #   class Address < Shale::Mapper
+  #     attribute :city, Shale::Type::String
+  #     attribute :street, Shale::Type::String
+  #     attribute :state, Shale::Type::Integer
+  #     attribute :zip, Shale::Type::String
+  #   end
+  #
+  #   class Person < Shale::Mapper
+  #     attribute :first_name, Shale::Type::String
+  #     attribute :last_name, Shale::Type::String
+  #     attribute :age, Shale::Type::Integer
+  #     attribute :address, Address
+  #   end
+  #
+  #   person = Person.from_json(%{
+  #     {
+  #       "first_name": "John",
+  #       "last_name": "Doe",
+  #       "age": 55,
+  #       "address": {
+  #         "city": "London",
+  #         "street": "Oxford Street",
+  #         "state": "London",
+  #         "zip": "E1 6AN"
+  #       }
+  #     }
+  #   })
+  #
+  #   person.to_json
+  #
+  # @api public
+  class Mapper < Type::Complex
+    @attributes = {}
+    @hash_mapping = Mapping::KeyValue.new
+    @json_mapping = Mapping::KeyValue.new
+    @yaml_mapping = Mapping::KeyValue.new
+    @xml_mapping = Mapping::Xml.new
+
+    class << self
+      # Return attributes Hash
+      #
+      # @return [Hash<Symbol, Shale::Attribute>]
+      #
+      # @api public
+      attr_reader :attributes
+
+      # Return Hash mapping object
+      #
+      # @return [Shale::Mapping::KeyValue]
+      #
+      # @api public
+      attr_reader :hash_mapping
+
+      # Return JSON mapping object
+      #
+      # @return [Shale::Mapping::KeyValue]
+      #
+      # @api public
+      attr_reader :json_mapping
+
+      # Return YAML mapping object
+      #
+      # @return [Shale::Mapping::KeyValue]
+      #
+      # @api public
+      attr_reader :yaml_mapping
+
+      # Return XML mapping object
+      #
+      # @return [Shale::Mapping::XML]
+      #
+      # @api public
+      attr_reader :xml_mapping
+
+      # @api private
+      def inherited(subclass)
+        super
+        subclass.instance_variable_set('@attributes', @attributes.dup)
+
+        subclass.instance_variable_set('@__hash_mapping_init', @hash_mapping.dup)
+        subclass.instance_variable_set('@__json_mapping_init', @json_mapping.dup)
+        subclass.instance_variable_set('@__yaml_mapping_init', @yaml_mapping.dup)
+        subclass.instance_variable_set('@__xml_mapping_init', @xml_mapping.dup)
+
+        subclass.instance_variable_set('@hash_mapping', @hash_mapping.dup)
+        subclass.instance_variable_set('@json_mapping', @json_mapping.dup)
+        subclass.instance_variable_set('@yaml_mapping', @yaml_mapping.dup)
+
+        xml_mapping = @xml_mapping.dup
+        xml_mapping.root(Utils.underscore(subclass.name || ''))
+
+        subclass.instance_variable_set('@xml_mapping', xml_mapping.dup)
+      end
+
+      # Define attribute on class
+      #
+      # @param [Symbol] name Name of the attribute
+      # @param [Shale::Type::Base] type Type of the attribute
+      # @param [Boolean] collection Is the attribute a collection
+      # @param [Proc] default Default value for the attribute
+      #
+      # @raise [DefaultNotCallableError] when attribute's default is not callable
+      #
+      # @example
+      #   calss Person < Shale::Mapper
+      #     attribute :first_name, Shale::Type::String
+      #     attribute :last_name, Shale::Type::String
+      #     attribute :age, Shale::Type::Integer, default: -> { 1 }
+      #     attribute :hobbies, Shale::Type::String, collection: true
+      #   end
+      #
+      #   person = Person.new
+      #
+      #   person.first_name # => nil
+      #   person.first_name = 'John'
+      #   person.first_name # => 'John'
+      #
+      #   person.age # => 1
+      #
+      #   person.hobbies << 'Dancing'
+      #   person.hobbies # => ['Dancing']
+      #
+      # @api public
+      def attribute(name, type, collection: false, default: nil)
+        name = name.to_sym
+
+        unless default.nil? || default.respond_to?(:call)
+          raise DefaultNotCallableError.new(to_s, name)
+        end
+
+        @attributes[name] = Attribute.new(name, type, collection, default)
+
+        @hash_mapping.map(name.to_s, to: name)
+        @json_mapping.map(name.to_s, to: name)
+        @yaml_mapping.map(name.to_s, to: name)
+        @xml_mapping.map_element(name.to_s, to: name)
+
+        class_eval(<<-RUBY, __FILE__, __LINE__ + 1)
+          attr_reader name
+
+          def #{name}=(val)
+            @#{name} = #{collection} ? val : #{type}.cast(val)
+          end
+        RUBY
+      end
+
+      # Define Hash mapping
+      #
+      # @param [Proc] block
+      #
+      # @example
+      #   calss Person < Shale::Mapper
+      #     attribute :first_name, Shale::Type::String
+      #     attribute :last_name, Shale::Type::String
+      #     attribute :age, Shale::Type::Integer
+      #
+      #     yaml do
+      #       map 'firatName', to: :first_name
+      #       map 'lastName', to: :last_name
+      #       map 'age', to: :age
+      #     end
+      #   end
+      #
+      # @api public
+      def hash(&block)
+        @hash_mapping = @__hash_mapping_init.dup
+        @hash_mapping.instance_eval(&block)
+      end
+
+      # Define JSON mapping
+      #
+      # @param [Proc] block
+      #
+      # @example
+      #   calss Person < Shale::Mapper
+      #     attribute :first_name, Shale::Type::String
+      #     attribute :last_name, Shale::Type::String
+      #     attribute :age, Shale::Type::Integer
+      #
+      #     yaml do
+      #       map 'firatName', to: :first_name
+      #       map 'lastName', to: :last_name
+      #       map 'age', to: :age
+      #     end
+      #   end
+      #
+      # @api public
+      def json(&block)
+        @json_mapping = @__json_mapping_init.dup
+        @json_mapping.instance_eval(&block)
+      end
+
+      # Define YAML mapping
+      #
+      # @param [Proc] block
+      #
+      # @example
+      #   calss Person < Shale::Mapper
+      #     attribute :first_name, Shale::Type::String
+      #     attribute :last_name, Shale::Type::String
+      #     attribute :age, Shale::Type::Integer
+      #
+      #     yaml do
+      #       map 'firat_name', to: :first_name
+      #       map 'last_name', to: :last_name
+      #       map 'age', to: :age
+      #     end
+      #   end
+      #
+      # @api public
+      def yaml(&block)
+        @yaml_mapping = @__yaml_mapping_init.dup
+        @yaml_mapping.instance_eval(&block)
+      end
+
+      # Define XML mapping
+      #
+      # @param [Proc] block
+      #
+      # @example
+      #   calss Person < Shale::Mapper
+      #     attribute :first_name, Shale::Type::String
+      #     attribute :last_name, Shale::Type::String
+      #     attribute :age, Shale::Type::Integer
+      #
+      #     xml do
+      #       root 'Person'
+      #       map_content to: :first_name
+      #       map_element 'LastName', to: :last_name
+      #       map_attribute 'age', to: :age
+      #     end
+      #   end
+      #
+      # @api public
+      def xml(&block)
+        @xml_mapping = @__xml_mapping_init.dup
+        @xml_mapping.instance_eval(&block)
+      end
+    end
+
+    # Initialize instance with properties
+    #
+    # @param [Hash] props Properties
+    #
+    # @raise [UnknownAttributeError] when attribute is not defined on the class
+    #
+    # @example
+    #   Person.new(
+    #     first_name: 'John',
+    #     last_name: 'Doe',
+    #     address: Address.new(city: 'London')
+    #   )
+    #   # => #<Person:0x00007f82768a2370
+    #           @first_name="John",
+    #           @last_name="Doe"
+    #           @address=#<Address:0x00007fe9cf0f57d8 @city="London">>
+    #
+    # @api public
+    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)
+        end
+      end
+
+      self.class.attributes.each do |name, attribute|
+        if props.key?(name)
+          value = props[name]
+        elsif attribute.default
+          value = attribute.default.call
+        end
+
+        public_send("#{name}=", value)
+      end
+    end
+  end
+end