shale 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4c96481848145b9736af4cc830c84c04970042fdc61f7d348aa64099065319ef
-  data.tar.gz: 25739ce30a7f4e66040b5dbff394da06a5c578065af0cd0b03bd0a56c7d78cbf
+  metadata.gz: ab65ef1fa452cb7d3810b6a996597190541fcbc5e4d5832901f8608bb8ddbf29
+  data.tar.gz: 241f5a1b333205a53cb598e51c8cd639a82f6f7661437f44d20fc3a0674935df
 SHA512:
-  metadata.gz: f205c1407868c6469922b7553f9aef3cdb0dc70502981d56eeef5b08703c793213f63c2a898568f372bc4e9519bcbfa771eefd6cfd663746e5b4180d1738c351
-  data.tar.gz: 95d7e2c6f88d7d5099c1ff62345509e83faee23a3bdd16e77d8eea05fb061e0eeb76fabbba5dc50d7c15ea675d2d1430570a2ac4134416c3d03d905d4ef59528
+  metadata.gz: a6107d0c547481b76ad03573a880001043b030825eccccdb11e5627dfc817467bedce0c77f0c2ca52f267a2791855c5b37aa6a518347be908458bbeff42e1f50
+  data.tar.gz: c7e883f3a41049a72904ca94702eadcb2c568b1d8c7717ad2000340b21c53b5f9c90bd1a981e57866bb704e9ddcfb36d713b74061ed59eb3d065df9fbc5fbcba

data/CHANGELOG.md

@@ -1,3 +1,12 @@
+## [0.2.0] - 2022-01-20
+
+### Added
+- Support for using methods to extract/generate data from/to document
+
+### Changed
+- deduplicate code
+- Rename `Shale::Type::Complex` -> `Shale::Type::Composite`
+
 ## [0.1.0] - 2021-11-30
 
 First public release

data/README.md

@@ -48,7 +48,7 @@ end
 ```
 
 - `default: -> { 'value' }` - add a default value to attribute (it must be a proc that returns value)
-- `collection: true` - indicated that a attribute is a collection
+- `collection: true` - indicates that a attribute is a collection
 
 ### Creating objects
 
@@ -327,6 +327,100 @@ DATA
 - `map_attribute` - map element's attribute to attribute
 - `map_content` - map first text node to attribute
 
+### Using methods to extract and generate data
+
+If you need full controll over extracting and generating data from/to document,
+you can use methods to do so:
+
+```ruby
+class Person < Shale::Mapper
+  attribute :hobbies, Shale::Type::String, collection: true
+  attribute :street, Shale::Type::String
+  attribute :city, Shale::Type::String
+
+  json do
+    map 'hobbies', using: { from: :hobbies_from_json, to: :hobbies_to_json }
+    map 'address', using: { from: :address_from_json, to: :address_to_json }
+  end
+
+  xml do
+    root 'Person'
+
+    map_attribute 'hobbies', using: { from: :hobbies_from_xml, to: :hobbies_to_xml }
+    map_element 'Address', using: { from: :address_from_xml, to: :address_to_xml }
+  end
+
+  def hobbies_from_json(value)
+    self.hobbies = value.split(',').map(&:strip)
+  end
+
+  def hobbies_to_json
+    hobbies.join(', ')
+  end
+
+  def address_from_json(value)
+    self.street = value['street']
+    self.city = value['city']
+  end
+
+  def address_to_json
+    { 'street' => street, 'city' => city }
+  end
+
+  def hobbies_from_xml(value)
+    self.hobbies = value.split(',').map(&:strip)
+  end
+
+  def hobbies_to_xml(element, doc)
+    doc.add_attribute(element, 'hobbies', hobbies.join(', '))
+  end
+
+  def address_from_xml(node)
+    self.street = node.children.find { |e| e.name == 'Street' }.text
+    self.city = node.children.find { |e| e.name == 'City' }.text
+  end
+
+  def address_to_xml(parent, doc)
+    street_element = doc.create_element('Street')
+    doc.add_text(street_element, street.to_s)
+
+    city_element = doc.create_element('City')
+    doc.add_text(city_element, city.to_s)
+
+    address_element = doc.create_element('Address')
+    doc.add_element(address_element, street_element)
+    doc.add_element(address_element, city_element)
+    doc.add_element(parent, address_element)
+  end
+end
+
+person = Person.from_json(<<~DATA)
+{
+  "hobbies": "Singing, Dancing, Running",
+  "address": {
+    "street": "Oxford Street",
+    "city": "London"
+  }
+}
+DATA
+
+person = Person.from_xml(<<~DATA)
+<Person hobbies="Singing, Dancing, Running">
+  <Address>
+    <Street>Oxford Street</Street>
+    <City>London</City>
+  </Address>
+</person>
+DATA
+
+# =>
+#
+# #<Person:0x00007f9bc3086d60
+#  @hobbies=["Singing", "Dancing", "Running"],
+#  @street="Oxford Street",
+#  @city="London">
+```
+
 ### Supported types
 
 Shale supports these types out of the box:
@@ -355,10 +449,10 @@ end
 ### Adapters
 
 Shale uses adapters for parsing and generating documents.
-By default Ruby's standard JSON parser is used for handing JSON documents, YAML for YAML and
+By default Ruby's standard JSON parser is used for handling JSON documents, YAML for YAML and
 REXML for XML.
 
-You can change it by providing your own adapter. For JSON and YAML adapter must implement
+You can change it by providing your own adapter. For JSON and YAML, adapter must implement
 `.load` and `.dump` class methods.
 
 ```ruby
@@ -369,15 +463,22 @@ Shale.json_adapter = MultiJson
 Shale.yaml_adapter = MyYamlAdapter
 ```
 
-For XML, other than REXML, Shale provides adapters for most popular Ruby XML parsers:
+For XML, Shale provides adapters for most popular Ruby XML parsers:
 
 ```ruby
 require 'shale'
 
+# REXML is used by default:
+
+require 'shale/adapter/rexml'
+Shale.xml_adapter = Shale::Adapter::REXML
+
+# if you want to use Nokogiri:
+
 require 'shale/adapter/nokogiri'
 Shale.xml_adapter = Shale::Adapter::Nokogiri
 
-# or if you want to use Ox
+# or if you want to use Ox:
 
 require 'shale/adapter/ox'
 Shale.xml_adapter = Shale::Adapter::Ox

data/lib/shale/error.rb

@@ -30,4 +30,10 @@ module Shale
       super("'#{attribute}' default is not callable for #{record}.")
     end
   end
+
+  # Error for passing incorrect arguments to map functions
+  #
+  # @api private
+  class IncorrectMappingArgumentsError < StandardError
+  end
 end

data/lib/shale/mapper.rb

@@ -5,7 +5,7 @@ require_relative 'error'
 require_relative 'utils'
 require_relative 'mapping/key_value'
 require_relative 'mapping/xml'
-require_relative 'type/complex'
+require_relative 'type/composite'
 
 module Shale
   # Base class used for mapping
@@ -42,7 +42,7 @@ module Shale
   #   person.to_json
   #
   # @api public
-  class Mapper < Type::Complex
+  class Mapper < Type::Composite
     @attributes = {}
     @hash_mapping = Mapping::KeyValue.new
     @json_mapping = Mapping::KeyValue.new

data/lib/shale/mapping/base.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require_relative '../error'
+
+module Shale
+  module Mapping
+    class Base
+      private
+
+      # 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 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
+    end
+  end
+end

data/lib/shale/mapping/key_value.rb

@@ -1,11 +1,13 @@
 # frozen_string_literal: true
 
+require_relative 'base'
+
 module Shale
   module Mapping
     # Mapping for key/value serialization formats (Hash/JSON/YAML)
     #
     # @api private
-    class KeyValue
+    class KeyValue < Base
       # Return keys mapping hash
       #
       # @return [Hash]
@@ -17,6 +19,7 @@ module Shale
       #
       # @api private
       def initialize
+        super
         @keys = {}
       end
 
@@ -25,9 +28,12 @@ module Shale
       # @param [String] key Document's key
       # @param [Symbol] to Object's attribute
       #
+      # @raise [IncorrectMappingArgumentsError] when arguments are incorrect
+      #
       # @api private
-      def map(key, to:)
-        @keys[key] = to
+      def map(key, to: nil, using: nil)
+        validate_arguments(key, to, using)
+        @keys[key] = to || using
       end
 
       # @api private

data/lib/shale/mapping/xml.rb

@@ -1,8 +1,10 @@
 # frozen_string_literal: true
 
+require_relative 'base'
+
 module Shale
   module Mapping
-    class Xml
+    class Xml < Base
       # Return elements mapping hash
       #
       # @return [Hash]
@@ -28,6 +30,7 @@ module Shale
       #
       # @api private
       def initialize
+        super
         @elements = {}
         @attributes = {}
         @content = nil
@@ -39,9 +42,12 @@ module Shale
       # @param [String] element Document's element
       # @param [Symbol] to Object's attribute
       #
+      # @raise [IncorrectMappingArgumentsError] when arguments are incorrect
+      #
       # @api private
-      def map_element(element, to:)
-        @elements[element] = to
+      def map_element(element, to: nil, using: nil)
+        validate_arguments(element, to, using)
+        @elements[element] = to || using
       end
 
       # Map document's attribute to object's attribute
@@ -49,9 +55,12 @@ module Shale
       # @param [String] attribute Document's attribute
       # @param [Symbol] to Object's attribute
       #
+      # @raise [IncorrectMappingArgumentsError] when arguments are incorrect
+      #
       # @api private
-      def map_attribute(attribute, to:)
-        @attributes[attribute] = to
+      def map_attribute(attribute, to: nil, using: nil)
+        validate_arguments(attribute, to, using)
+        @attributes[attribute] = to || using
       end
 
       # Map document's content to object's attribute

data/lib/shale/type/composite.rb

@@ -0,0 +1,326 @@
+# frozen_string_literal: true
+
+require_relative 'base'
+
+module Shale
+  module Type
+    # Build composite object. Don't use it directly.
+    # It serves as a base type class for @see Shale::Mapper
+    #
+    # @api private
+    class Composite < Base
+      class << self
+        %i[hash json yaml].each do |format|
+          class_eval(<<-RUBY, __FILE__, __LINE__ + 1)
+            # Convert Hash to Object using Hash/JSON/YAML mapping
+            #
+            # @param [Hash] hash Hash to convert
+            #
+            # @return [Shale::Mapper]
+            #
+            # @api public
+            def out_of_#{format}(hash)
+              instance = new
+
+              mapping_keys = #{format}_mapping.keys
+
+              hash.each do |key, value|
+                mapping = mapping_keys[key]
+                next unless mapping
+
+                if mapping.is_a?(Hash)
+                  instance.send(mapping[:from], value)
+                else
+                  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_#{format}(val) : val
+                      instance.public_send(attribute.name) << attribute.type.cast(val)
+                    end
+                  else
+                    val = attribute.type.out_of_#{format}(value)
+                    instance.public_send("\#{attribute.name}=", val)
+                  end
+                end
+              end
+
+              instance
+            end
+
+            # Convert Object to Hash using Hash/JSON/YAML mapping
+            #
+            # @param [Shale::Type::Base] instance Object to convert
+            #
+            # @return [Hash]
+            #
+            # @api public
+            def as_#{format}(instance)
+              hash = {}
+
+              instance.class.#{format}_mapping.keys.each do |key, attr|
+                if attr.is_a?(Hash)
+                  hash[key] = instance.send(attr[:to])
+                else
+                  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_#{format}(v) : v }
+                  else
+                    hash[key] = attribute.type.as_#{format}(value)
+                  end
+                end
+              end
+
+              hash
+            end
+          RUBY
+        end
+
+        alias from_hash out_of_hash
+
+        alias to_hash as_hash
+
+        # 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
+        #
+        # @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 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
+        #
+        # @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
+
+            if mapping.is_a?(Hash)
+              instance.send(mapping[:from], value)
+            else
+              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
+          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
+
+            if mapping.is_a?(Hash)
+              instance.send(mapping[:from], node)
+            else
+              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
+          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|
+            if obj_attr.is_a?(Hash)
+              instance.send(obj_attr[:to], element, doc)
+            else
+              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
+          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|
+            if obj_attr.is_a?(Hash)
+              instance.send(obj_attr[:to], element, doc)
+            else
+              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
+          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

data/lib/shale/version.rb

@@ -2,5 +2,5 @@
 
 module Shale
   # @api private
-  VERSION = '0.1.0'
+  VERSION = '0.2.0'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: shale
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Kamil Giszczak
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-11-30 00:00:00.000000000 Z
+date: 2022-01-20 00:00:00.000000000 Z
 dependencies: []
 description: Ruby object mapper and serializer for XML, JSON and YAML.
 email:
@@ -28,11 +28,12 @@ files:
 - lib/shale/attribute.rb
 - lib/shale/error.rb
 - lib/shale/mapper.rb
+- lib/shale/mapping/base.rb
 - lib/shale/mapping/key_value.rb
 - lib/shale/mapping/xml.rb
 - lib/shale/type/base.rb
 - lib/shale/type/boolean.rb
-- lib/shale/type/complex.rb
+- lib/shale/type/composite.rb
 - lib/shale/type/date.rb
 - lib/shale/type/float.rb
 - lib/shale/type/integer.rb

data/lib/shale/type/complex.rb

@@ -1,427 +0,0 @@
-# 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