shale 0.5.0 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: aaa3043e612d332fab30ff87ecab722e3812e7769eba982db27c38f74c205ce1
-  data.tar.gz: bb5cdb963bce5756c48edb37d28bddc40a816901e87b4714ea512f07f8ec4c28
+  metadata.gz: 243b99a073ac189f66ae0fbfedd94a5715399de731d0e0fd1d970dad749d27a0
+  data.tar.gz: d2f57de2427574d710d6a6fe9ba35868fd162214ce8aa2092ddfb3fe1f5e7c3d
 SHA512:
-  metadata.gz: ed1f1ffc88cabb5f9403ff957c02efc4565aee73b9a8a1fd2297ff13bfbb6bdf0e94664b865f8d2d812ddd66fe97d154e34982eea3318ba01c6d16b4a6922c70
-  data.tar.gz: d41392de36bcace9efee12a869f49beffba235ae09e09f33c6973159b96320e3f657a6edd4d634e53da430f8127e74fa1025fa2f5c75dad2e7568abe6a0794ce
+  metadata.gz: 9de1be5eccbb647f05b6573d783491f858fb56614f09c7c625e7fa922c7b89b5d38863a57defbe506d42f0b542b326e4ca61ecf308b94f7b35b4056751e0299e
+  data.tar.gz: a1e29fc097c130c55e45837af198e3cd4f7d3ad6a94b17d032eb31b8065f7ea013682836256d12127480965ed3733079e5badd7a8b0060e3bc60f00734fcc215

data/CHANGELOG.md

@@ -1,3 +1,14 @@
+## [0.6.0] - 2022-07-05
+
+### Added
+- Support for TOML
+- Support for CDATA nodes in XML documents
+- Support for using custom models
+
+### Fixed
+- Allow to map XML content using methods
+- Prevent adding default mapping after mapping block was declared
+
 ## [0.5.0] - 2022-06-28
 
 ### Added

data/README.md

@@ -1,18 +1,18 @@
 # Shale
 
-Shale is a Ruby object mapper and serializer for JSON, YAML and XML.
-It allows you to parse JSON, YAML and XML data and convert it into Ruby data structures,
-as well as serialize data structures into JSON, YAML or XML.
+Shale is a Ruby object mapper and serializer for JSON, YAML, TOML and XML.
+It allows you to parse JSON, YAML, TOML and XML data and convert it into Ruby data structures,
+as well as serialize data structures into JSON, YAML, TOML or XML.
 
 Documentation with interactive examples is available at [Shale website](https://www.shalerb.org)
 
 ## Features
 
-* Convert JSON, YAML and XML to Ruby data model
-* Convert Ruby data model to JSON, YAML and XML
+* Convert JSON, YAML, TOML and XML to Ruby data model
+* Convert Ruby data model to JSON, YAML, TOML and XML
 * Generate JSON and XML Schema from Ruby models
 * Compile JSON and XML Schema into Ruby models
-* Out of the box support for JSON, YAML, Nokogiri, REXML and Ox parsers
+* Out of the box support for JSON, YAML, toml-rb, Nokogiri, REXML and Ox parsers
 * Support for custom adapters
 
 ## Installation
@@ -45,17 +45,21 @@ $ gem install shale
 * [Converting object to JSON](#converting-object-to-json)
 * [Converting YAML to object](#converting-yaml-to-object)
 * [Converting object to YAML](#converting-object-to-yaml)
+* [Converting TOML to object](#converting-toml-to-object)
+* [Converting object to TOML](#converting-object-to-toml)
 * [Converting Hash to object](#converting-hash-to-object)
 * [Converting object to Hash](#converting-object-to-hash)
 * [Converting XML to object](#converting-xml-to-object)
 * [Converting object to XML](#converting-object-to-xml)
 * [Mapping JSON keys to object attributes](#mapping-json-keys-to-object-attributes)
 * [Mapping YAML keys to object attributes](#mapping-yaml-keys-to-object-attributes)
+* [Mapping TOML keys to object attributes](#mapping-toml-keys-to-object-attributes)
 * [Mapping Hash keys to object attributes](#mapping-hash-keys-to-object-attributes)
 * [Mapping XML elements and attributes to object attributes](#mapping-xml-elements-and-attributes-to-object-attributes)
 * [Using XML namespaces](#using-xml-namespaces)
 * [Using methods to extract and generate data](#using-methods-to-extract-and-generate-data)
 * [Pretty printing and XML declaration](#pretty-printing-and-xml-declaration)
+* [Using custom models](#using-custom-models)
 * [Supported types](#supported-types)
 * [Writing your own type](#writing-your-own-type)
 * [Adapters](#adapters)
@@ -195,6 +199,62 @@ person.to_yaml
 #   zip: E1 6AN
 ```
 
+### Converting TOML to object
+
+To use TOML with Shale you have to set adapter you want to use.
+Shale comes with adapter for [toml-rb](https://github.com/emancu/toml-rb).
+For details see [Adapters](#adapters) section.
+
+To set it, first make sure toml-rb gem is installed:
+
+```
+$ gem install shale
+```
+
+then setup adapter:
+
+```ruby
+require 'shale/adapter/toml_rb'
+Shale.toml_adapter = Shale::Adapter::TomlRB
+```
+
+Now you can use TOML with Shale:
+
+```ruby
+person = Person.from_toml(<<~DATA)
+first_name = "John"
+last_name = "Doe"
+age = 50
+married = false
+hobbies = ["Singing", "Dancing"]
+[address]
+city = "London"
+street = "Oxford Street"
+zip = "E1 6AN"
+DATA
+```
+
+### Converting object to TOML
+
+```ruby
+person.to_toml
+
+# =>
+#
+# ---
+# first_name: John
+# last_name: Doe
+# age: 50
+# married: false
+# hobbies:
+# - Singing
+# - Dancing
+# address:
+#   city: London
+#   street: Oxford Street
+#   zip: E1 6AN
+```
+
 ### Converting Hash to object
 
 ```ruby
@@ -240,6 +300,8 @@ require 'shale/adapter/rexml'
 Shale.xml_adapter = Shale::Adapter::REXML
 ```
 
+Now you can use XML with Shale:
+
 ```ruby
 person = Person.from_xml(<<~DATA)
 <person>
@@ -284,6 +346,8 @@ person.to_xml
 
 By default keys are named the same as attributes. To use custom keys use:
 
+:warning: **Declaring custom mapping removes default mapping for given format!**
+
 ```ruby
 class Person < Shale::Mapper
   attribute :first_name, Shale::Type::String
@@ -310,6 +374,20 @@ class Person < Shale::Mapper
 end
 ```
 
+### Mapping TOML keys to object attributes
+
+```ruby
+class Person < Shale::Mapper
+  attribute :first_name, Shale::Type::String
+  attribute :last_name, Shale::Type::String
+
+  toml do
+    map 'firstName', to: :first_name
+    map 'lastName', to: :last_name
+  end
+end
+```
+
 ### Mapping Hash keys to object attributes
 
 ```ruby
@@ -380,6 +458,37 @@ DATA
 - `map_attribute` - map element's attribute to attribute
 - `map_content` - map first text node to attribute
 
+You can use `cdata: true` option on `map_element` and `map_content` to handle CDATA nodes:
+
+```ruby
+class Address < Shale::Mapper
+  attribute :content, Shale::Type::String
+
+  xml do
+    map_content to: :content, cdata: true
+  end
+end
+
+class Person < Shale::Mapper
+  attribute :first_name, Shale::Type::String
+  attribute :address, Address
+
+  xml do
+    root 'Person'
+
+    map_element 'FirstName', to: :first_name, cdata: true
+    map_element 'Address', to: :address
+  end
+end
+
+person = Person.from_xml(<<~DATA)
+<Person>
+  <FirstName><![CDATA[John]]></FirstName>
+  <Address><![CDATA[Oxford Street]]></Address>
+</person>
+DATA
+```
+
 ### Using XML namespaces
 
 To map namespaced elements and attributes use `namespace` and `prefix` properties on
@@ -469,42 +578,42 @@ class Person < Shale::Mapper
     map_element 'Address', using: { from: :address_from_xml, to: :address_to_xml }
   end
 
-  def hobbies_from_json(value)
-    self.hobbies = value.split(',').map(&:strip)
+  def hobbies_from_json(model, value)
+    model.hobbies = value.split(',').map(&:strip)
   end
 
-  def hobbies_to_json
-    hobbies.join(', ')
+  def hobbies_to_json(model)
+    model.hobbies.join(', ')
   end
 
-  def address_from_json(value)
-    self.street = value['street']
-    self.city = value['city']
+  def address_from_json(model, value)
+    model.street = value['street']
+    model.city = value['city']
   end
 
-  def address_to_json
-    { 'street' => street, 'city' => city }
+  def address_to_json(model)
+    { 'street' => model.street, 'city' => model.city }
   end
 
-  def hobbies_from_xml(value)
-    self.hobbies = value.split(',').map(&:strip)
+  def hobbies_from_xml(model, value)
+    model.hobbies = value.split(',').map(&:strip)
   end
 
-  def hobbies_to_xml(element, doc)
-    doc.add_attribute(element, 'hobbies', hobbies.join(', '))
+  def hobbies_to_xml(model, element, doc)
+    doc.add_attribute(element, 'hobbies', model.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
+  def address_from_xml(model, node)
+    model.street = node.children.find { |e| e.name == 'Street' }.text
+    model.city = node.children.find { |e| e.name == 'City' }.text
   end
 
-  def address_to_xml(parent, doc)
+  def address_to_xml(model, parent, doc)
     street_element = doc.create_element('Street')
-    doc.add_text(street_element, street.to_s)
+    doc.add_text(street_element, model.street.to_s)
 
     city_element = doc.create_element('City')
-    doc.add_text(city_element, city.to_s)
+    doc.add_text(city_element, model.city.to_s)
 
     address_element = doc.create_element('Address')
     doc.add_element(address_element, street_element)
@@ -529,7 +638,7 @@ person = Person.from_xml(<<~DATA)
     <Street>Oxford Street</Street>
     <City>London</City>
   </Address>
-</person>
+</Person>
 DATA
 
 # =>
@@ -570,6 +679,67 @@ person.to_xml(:pretty, :declaration)
 # </Person>
 ```
 
+### Using custom models
+
+By default Shale combines mapper and model into one class. If you want to use your own classes
+as models you can do it by using `model` directive on the mapper:
+
+```ruby
+class Address
+  attr_accessor :street, :city
+end
+
+class Person
+  attr_accessor :first_name, :last_name, :address
+end
+
+class AddressMapper < Shale::Mapper
+  model Address
+
+  attribute :street, Shale::Type::String
+  attribute :city, Shale::Type::String
+end
+
+class PersonMapper < Shale::Mapper
+  model Person
+
+  attribute :first_name, Shale::Type::String
+  attribute :last_name, Shale::Type::String
+  attribute :address, AddressMapper
+end
+
+person = PersonMapper.from_json(<<~DATA)
+{
+  "first_name": "John",
+  "last_name": "Doe",
+  "address": {
+    "street": "Oxford Street",
+    "city": "London"
+  }
+}
+DATA
+
+# =>
+#
+# #<Person:0x0000000113d7a488
+#  @first_name="John",
+#  @last_name="Doe",
+#  @address=#<Address:0x0000000113d7a140 @street="Oxford Street", @city="London">>
+
+PersonMapper.to_json(person, :pretty)
+
+# =>
+#
+# {
+#   "first_name": "John",
+#   "last_name": "Doe",
+#   "address": {
+#     "street": "Oxford Street",
+#     "city": "London"
+#   }
+# }
+```
+
 ### Supported types
 
 Shale supports these types out of the box:
@@ -598,9 +768,9 @@ end
 ### Adapters
 
 Shale uses adapters for parsing and generating documents.
-By default Ruby's standard JSON and YAML parsers are used for handling JSON and YAML documents.
+By default Ruby's standard JSON, YAML parsers are used for handling JSON and YAML documents.
 
-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, YAML and TOML, adapter must implement
 `.load` and `.dump` class methods.
 
 ```ruby
@@ -611,6 +781,16 @@ Shale.json_adapter = MultiJson
 Shale.yaml_adapter = MyYamlAdapter
 ```
 
+To handle TOML documents you have to set TOML adapter.
+Shale provides adapter for `toml-rb` TOML parser:
+
+```ruby
+require 'shale'
+
+require 'shale/adapter/toml_rb'
+Shale.toml_adapter = Shale::Adapter::TomlRB
+```
+
 To handle XML documents you have to explicitly set XML adapter.
 Shale provides adapters for most popular Ruby XML parsers:
 

data/lib/shale/adapter/nokogiri/document.rb

@@ -41,6 +41,16 @@ module Shale
           ::Nokogiri::XML::Element.new(name, @doc)
         end
 
+        # Create CDATA node and add it to parent
+        #
+        # @param [String] text
+        # @param [::Nokogiri::XML::Element] parent
+        #
+        # @api private
+        def create_cdata(text, parent)
+          parent.add_child(::Nokogiri::XML::CDATA.new(@doc, text))
+        end
+
         # Add XML namespace to document
         #
         # @param [String] prefix

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

@@ -89,7 +89,7 @@ module Shale
           first = @node
             .children
             .to_a
-            .filter(&:text?)
+            .filter { |e| e.text? || e.cdata? }
             .first
 
           first&.text

data/lib/shale/adapter/ox/document.rb

@@ -32,6 +32,16 @@ module Shale
           ::Ox::Element.new(name)
         end
 
+        # Create CDATA node and add it to parent
+        #
+        # @param [String] text
+        # @param [::Ox::Element] parent
+        #
+        # @api private
+        def create_cdata(text, parent)
+          parent << ::Ox::CData.new(text)
+        end
+
         # Add XML namespace to document
         #
         # Ox doesn't support XML namespaces so this method does nothing.

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

@@ -80,7 +80,16 @@ module Shale
         #
         # @api private
         def text
-          @node.text
+          texts = @node.nodes.map do |e|
+            case e
+            when ::Ox::CData
+              e.value
+            when ::String
+              e
+            end
+          end
+
+          texts.compact.first
         end
       end
     end

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

@@ -42,6 +42,16 @@ module Shale
           ::REXML::Element.new(name, nil, attribute_quote: :quote)
         end
 
+        # Create CDATA node and add it to parent
+        #
+        # @param [String] text
+        # @param [::REXML::Element] parent
+        #
+        # @api private
+        def create_cdata(text, parent)
+          ::REXML::CData.new(text, true, parent)
+        end
+
         # Add XML namespace to document
         #
         # @param [String] prefix

data/lib/shale/adapter/toml_rb.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require 'toml-rb'
+
+module Shale
+  module Adapter
+    # TOML adapter
+    #
+    # @api public
+    class TomlRB
+      # Parse TOML into Hash
+      #
+      # @param [String] toml TOML document
+      #
+      # @return [Hash]
+      #
+      # @api private
+      def self.load(toml)
+        ::TomlRB.parse(toml)
+      end
+
+      # Serialize Hash into TOML
+      #
+      # @param [Hash] obj Hash object
+      #
+      # @return [String]
+      #
+      # @api private
+      def self.dump(obj)
+        ::TomlRB.dump(obj)
+      end
+    end
+  end
+end

data/lib/shale/error.rb

@@ -1,9 +1,20 @@
 # frozen_string_literal: true
 
 module Shale
-  # Error message displayed when adapter is not set
+  # Error message displayed when TOML adapter is not set
   # @api private
-  ADAPTER_NOT_SET_MESSAGE = <<~MSG
+  TOML_ADAPTER_NOT_SET_MESSAGE = <<~MSG
+    TOML Adapter is not set.
+    To use Shale with TOML documents you have to install parser and set adapter.
+
+    # Make sure toml-rb is installed eg. execute: gem install toml-rb
+    require 'shale/adapter/toml_rb'
+    Shale.toml_adapter = Shale::Adapter::TomlRB
+  MSG
+
+  # Error message displayed when XML adapter is not set
+  # @api private
+  XML_ADAPTER_NOT_SET_MESSAGE = <<~MSG
     XML Adapter is not set.
     To use Shale with XML documents you have to install parser and set adapter.
 
@@ -52,6 +63,12 @@ module Shale
     end
   end
 
+  # Error for passing incorrect model type
+  #
+  # @api private
+  class IncorrectModelError < StandardError
+  end
+
   # Error for passing incorrect arguments to map functions
   #
   # @api private

data/lib/shale/mapper.rb

@@ -43,10 +43,12 @@ module Shale
   #
   # @api public
   class Mapper < Type::Complex
+    @model = nil
     @attributes = {}
     @hash_mapping = Mapping::Dict.new
     @json_mapping = Mapping::Dict.new
     @yaml_mapping = Mapping::Dict.new
+    @toml_mapping = Mapping::Dict.new
     @xml_mapping = Mapping::Xml.new
 
     class << self
@@ -78,6 +80,13 @@ module Shale
       # @api public
       attr_reader :yaml_mapping
 
+      # Return TOML mapping object
+      #
+      # @return [Shale::Mapping::Dict]
+      #
+      # @api public
+      attr_reader :toml_mapping
+
       # Return XML mapping object
       #
       # @return [Shale::Mapping::XML]
@@ -88,16 +97,20 @@ module Shale
       # @api private
       def inherited(subclass)
         super
+
+        subclass.instance_variable_set('@model', subclass)
         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('@__toml_mapping_init', @toml_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)
+        subclass.instance_variable_set('@toml_mapping', @toml_mapping.dup)
 
         xml_mapping = @xml_mapping.dup
         xml_mapping.root(Utils.underscore(subclass.name || ''))
@@ -105,6 +118,15 @@ module Shale
         subclass.instance_variable_set('@xml_mapping', xml_mapping.dup)
       end
 
+      def model(klass = nil)
+        if klass
+          @model = klass
+          xml_mapping.root(Utils.underscore(@model.name))
+        else
+          @model
+        end
+      end
+
       # Define attribute on class
       #
       # @param [Symbol] name Name of the attribute
@@ -143,10 +165,11 @@ module Shale
 
         @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)
+        @hash_mapping.map(name.to_s, to: name) unless @hash_mapping.finalized?
+        @json_mapping.map(name.to_s, to: name) unless @json_mapping.finalized?
+        @yaml_mapping.map(name.to_s, to: name) unless @yaml_mapping.finalized?
+        @toml_mapping.map(name.to_s, to: name) unless @toml_mapping.finalized?
+        @xml_mapping.map_element(name.to_s, to: name) unless @xml_mapping.finalized?
 
         class_eval(<<-RUBY, __FILE__, __LINE__ + 1)
           attr_reader :#{name}
@@ -168,7 +191,7 @@ module Shale
       #     attribute :age, Shale::Type::Integer
       #
       #     hsh do
-      #       map 'firatName', to: :first_name
+      #       map 'firstName', to: :first_name
       #       map 'lastName', to: :last_name
       #       map 'age', to: :age
       #     end
@@ -177,6 +200,7 @@ module Shale
       # @api public
       def hsh(&block)
         @hash_mapping = @__hash_mapping_init.dup
+        @hash_mapping.finalize!
         @hash_mapping.instance_eval(&block)
       end
 
@@ -191,7 +215,7 @@ module Shale
       #     attribute :age, Shale::Type::Integer
       #
       #     json do
-      #       map 'firatName', to: :first_name
+      #       map 'firstName', to: :first_name
       #       map 'lastName', to: :last_name
       #       map 'age', to: :age
       #     end
@@ -200,6 +224,7 @@ module Shale
       # @api public
       def json(&block)
         @json_mapping = @__json_mapping_init.dup
+        @json_mapping.finalize!
         @json_mapping.instance_eval(&block)
       end
 
@@ -214,7 +239,7 @@ module Shale
       #     attribute :age, Shale::Type::Integer
       #
       #     yaml do
-      #       map 'firat_name', to: :first_name
+      #       map 'first_name', to: :first_name
       #       map 'last_name', to: :last_name
       #       map 'age', to: :age
       #     end
@@ -223,9 +248,34 @@ module Shale
       # @api public
       def yaml(&block)
         @yaml_mapping = @__yaml_mapping_init.dup
+        @yaml_mapping.finalize!
         @yaml_mapping.instance_eval(&block)
       end
 
+      # Define TOML 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
+      #
+      #     toml do
+      #       map 'first_name', to: :first_name
+      #       map 'last_name', to: :last_name
+      #       map 'age', to: :age
+      #     end
+      #   end
+      #
+      # @api public
+      def toml(&block)
+        @toml_mapping = @__toml_mapping_init.dup
+        @toml_mapping.finalize!
+        @toml_mapping.instance_eval(&block)
+      end
+
       # Define XML mapping
       #
       # @param [Proc] block
@@ -247,6 +297,8 @@ module Shale
       # @api public
       def xml(&block)
         @xml_mapping = @__xml_mapping_init.dup
+        @xml_mapping.finalize!
+        @xml_mapping.root('')
         @xml_mapping.instance_eval(&block)
       end
     end

data/lib/shale/mapping/descriptor/xml.rb

@@ -16,17 +16,26 @@ module Shale
         # @api private
         attr_reader :namespace
 
+        # Return cdata
+        #
+        # @return [true, false]
+        #
+        # @api private
+        attr_reader :cdata
+
         # Initialize instance
         #
         # @param [String] name
         # @param [Symbol, String] attribute
         # @param [Hash, nil] methods
         # @param [Shale::Mapping::XmlNamespace] namespace
+        # @param [true, false] cdata
         #
         # @api private
-        def initialize(name:, attribute:, methods:, namespace:)
+        def initialize(name:, attribute:, methods:, namespace:, cdata:)
           super(name: name, attribute: attribute, methods: methods)
           @namespace = namespace
+          @cdata = cdata
         end
 
         # Return name with XML prefix

data/lib/shale/mapping/dict.rb

@@ -22,6 +22,7 @@ module Shale
       def initialize
         super
         @keys = {}
+        @finalized = false
       end
 
       # Map key to attribute
@@ -38,9 +39,26 @@ module Shale
         @keys[key] = Descriptor::Dict.new(name: key, attribute: to, methods: using)
       end
 
+      # Set the "finalized" instance variable to true
+      #
+      # @api private
+      def finalize!
+        @finalized = true
+      end
+
+      # Query the "finalized" instance variable
+      #
+      # @return [truem false]
+      #
+      # @api private
+      def finalized?
+        @finalized
+      end
+
       # @api private
       def initialize_dup(other)
         @keys = other.instance_variable_get('@keys').dup
+        @finalized = false
         super
       end
     end

data/lib/shale/mapping/xml.rb

@@ -63,6 +63,7 @@ module Shale
         @content = nil
         @root = ''
         @default_namespace = Descriptor::XmlNamespace.new
+        @finalized = false
       end
 
       # Map element to attribute
@@ -76,7 +77,14 @@ module Shale
       # @raise [IncorrectMappingArgumentsError] when arguments are incorrect
       #
       # @api private
-      def map_element(element, to: nil, using: nil, namespace: :undefined, prefix: :undefined)
+      def map_element(
+        element,
+        to: nil,
+        using: nil,
+        namespace: :undefined,
+        prefix: :undefined,
+        cdata: false
+      )
         Validator.validate_arguments(element, to, using)
         Validator.validate_namespace(element, namespace, prefix)
 
@@ -94,7 +102,8 @@ module Shale
           name: element,
           attribute: to,
           methods: using,
-          namespace: Descriptor::XmlNamespace.new(nsp, pfx)
+          namespace: Descriptor::XmlNamespace.new(nsp, pfx),
+          cdata: cdata
         )
       end
 
@@ -119,7 +128,8 @@ module Shale
           name: attribute,
           attribute: to,
           methods: using,
-          namespace: Descriptor::XmlNamespace.new(namespace, prefix)
+          namespace: Descriptor::XmlNamespace.new(namespace, prefix),
+          cdata: false
         )
       end
 
@@ -128,8 +138,16 @@ module Shale
       # @param [Symbol] to Object's attribute
       #
       # @api private
-      def map_content(to:)
-        @content = to
+      def map_content(to: nil, using: nil, cdata: false)
+        Validator.validate_arguments('content', to, using)
+
+        @content = Descriptor::Xml.new(
+          name: nil,
+          attribute: to,
+          methods: using,
+          namespace: nil,
+          cdata: cdata
+        )
       end
 
       # Set the name for root element
@@ -152,6 +170,22 @@ module Shale
         @default_namespace.prefix = prefix
       end
 
+      # Set the "finalized" instance variable to true
+      #
+      # @api private
+      def finalize!
+        @finalized = true
+      end
+
+      # Query the "finalized" instance variable
+      #
+      # @return [truem false]
+      #
+      # @api private
+      def finalized?
+        @finalized
+      end
+
       # @api private
       def initialize_dup(other)
         @elements = other.instance_variable_get('@elements').dup
@@ -159,6 +193,7 @@ module Shale
         @content = other.instance_variable_get('@content').dup
         @root = other.instance_variable_get('@root').dup
         @default_namespace = other.instance_variable_get('@default_namespace').dup
+        @finalized = false
 
         super
       end

data/lib/shale/schema/xml_compiler.rb

@@ -200,7 +200,7 @@ module Shale
       # @api public
       def as_models(schemas)
         unless Shale.xml_adapter
-          raise AdapterError, ADAPTER_NOT_SET_MESSAGE
+          raise AdapterError, XML_ADAPTER_NOT_SET_MESSAGE
         end
 
         if Shale.xml_adapter.name == 'Shale::Adapter::Ox'

data/lib/shale/type/complex.rb

@@ -11,9 +11,9 @@ module Shale
     # @api private
     class Complex < Value
       class << self
-        %i[hash json yaml].each do |format|
+        %i[hash json yaml toml].each do |format|
           class_eval(<<-RUBY, __FILE__, __LINE__ + 1)
-            # Convert Hash to Object using Hash/JSON/YAML mapping
+            # Convert Hash to Object using Hash/JSON/YAML/TOML mapping
             #
             # @param [Hash] hash Hash to convert
             #
@@ -21,7 +21,12 @@ module Shale
             #
             # @api public
             def of_#{format}(hash)
-              instance = new
+              instance = model.new
+
+              attributes
+                .values
+                .select { |attr| attr.default }
+                .each { |attr| instance.send(attr.setter, attr.default.call) }
 
               mapping_keys = #{format}_mapping.keys
 
@@ -30,7 +35,7 @@ module Shale
                 next unless mapping
 
                 if mapping.method_from
-                  instance.send(mapping.method_from, value)
+                  new.send(mapping.method_from, instance, value)
                 else
                   attribute = attributes[mapping.attribute]
                   next unless attribute
@@ -44,7 +49,7 @@ module Shale
                     end
                   else
                     val = attribute.type.of_#{format}(value)
-                    instance.send(attribute.setter, val)
+                    instance.send(attribute.setter, attribute.type.cast(val))
                   end
                 end
               end
@@ -52,21 +57,28 @@ module Shale
               instance
             end
 
-            # Convert Object to Hash using Hash/JSON/YAML mapping
+            # Convert Object to Hash using Hash/JSON/YAML/TOML mapping
+            #
+            # @param [any] instance Object to convert
             #
-            # @param [Shale::Mapper] instance Object to convert
+            # @raise [IncorrectModelError]
             #
             # @return [Hash]
             #
             # @api public
             def as_#{format}(instance)
+              unless instance.is_a?(model)
+                msg = "argument is a '\#{instance.class}' but should be a '\#{model}'"
+                raise IncorrectModelError, msg
+              end
+
               hash = {}
 
-              instance.class.#{format}_mapping.keys.each_value do |mapping|
+              #{format}_mapping.keys.each_value do |mapping|
                 if mapping.method_to
-                  hash[mapping.name] = instance.send(mapping.method_to)
+                  hash[mapping.name] = new.send(mapping.method_to, instance)
                 else
-                  attribute = instance.class.attributes[mapping.attribute]
+                  attribute = attributes[mapping.attribute]
                   next unless attribute
 
                   value = instance.send(attribute.name)
@@ -137,6 +149,30 @@ module Shale
           Shale.yaml_adapter.dump(as_yaml(instance))
         end
 
+        # Convert TOML to Object
+        #
+        # @param [String] toml TOML to convert
+        #
+        # @return [Shale::Mapper]
+        #
+        # @api public
+        def from_toml(toml)
+          validate_toml_adapter
+          of_toml(Shale.toml_adapter.load(toml))
+        end
+
+        # Convert Object to TOML
+        #
+        # @param [Shale::Mapper] instance Object to convert
+        #
+        # @return [String]
+        #
+        # @api public
+        def to_toml(instance)
+          validate_toml_adapter
+          Shale.toml_adapter.dump(as_toml(instance))
+        end
+
         # Convert XML document to Object
         #
         # @param [Shale::Adapter::<XML adapter>::Node] xml XML to convert
@@ -145,14 +181,19 @@ module Shale
         #
         # @api public
         def of_xml(element)
-          instance = new
+          instance = model.new
+
+          attributes
+            .values
+            .select { |attr| attr.default }
+            .each { |attr| instance.send(attr.setter, attr.default.call) }
 
           element.attributes.each do |key, value|
             mapping = xml_mapping.attributes[key.to_s]
             next unless mapping
 
             if mapping.method_from
-              instance.send(mapping.method_from, value)
+              new.send(mapping.method_from, instance, value)
             else
               attribute = attributes[mapping.attribute]
               next unless attribute
@@ -160,16 +201,23 @@ module Shale
               if attribute.collection?
                 instance.send(attribute.name) << attribute.type.cast(value)
               else
-                instance.send(attribute.setter, value)
+                instance.send(attribute.setter, attribute.type.cast(value))
               end
             end
           end
 
-          if xml_mapping.content
-            attribute = attributes[xml_mapping.content]
+          content_mapping = xml_mapping.content
+
+          if content_mapping
+            if content_mapping.method_from
+              new.send(content_mapping.method_from, instance, element)
+            else
+              attribute = attributes[content_mapping.attribute]
 
-            if attribute
-              instance.send(attribute.setter, attribute.type.of_xml(element))
+              if attribute
+                value = attribute.type.of_xml(element)
+                instance.send(attribute.setter, attribute.type.cast(value))
+              end
             end
           end
 
@@ -178,16 +226,17 @@ module Shale
             next unless mapping
 
             if mapping.method_from
-              instance.send(mapping.method_from, node)
+              new.send(mapping.method_from, instance, node)
             else
               attribute = attributes[mapping.attribute]
               next unless attribute
 
+              value = attribute.type.of_xml(node)
+
               if attribute.collection?
-                value = attribute.type.of_xml(node)
                 instance.send(attribute.name) << attribute.type.cast(value)
               else
-                instance.send(attribute.setter, attribute.type.of_xml(node))
+                instance.send(attribute.setter, attribute.type.cast(value))
               end
             end
           end
@@ -211,14 +260,21 @@ module Shale
 
         # Convert Object to XML document
         #
-        # @param [Shale::Mapper] instance Object to convert
+        # @param [any] instance Object to convert
         # @param [String, nil] node_name XML node name
         # @param [Shale::Adapter::<xml adapter>::Document, nil] doc Object to convert
         #
+        # @raise [IncorrectModelError]
+        #
         # @return [::REXML::Document, ::Nokogiri::Document, ::Ox::Document]
         #
         # @api public
-        def as_xml(instance, node_name = nil, doc = nil)
+        def as_xml(instance, node_name = nil, doc = nil, _cdata = nil)
+          unless instance.is_a?(model)
+            msg = "argument is a '#{instance.class}' but should be a '#{model}'"
+            raise IncorrectModelError, msg
+          end
+
           unless doc
             doc = Shale.xml_adapter.create_document
             doc.add_element(doc.doc, as_xml(instance, xml_mapping.prefixed_root, doc))
@@ -226,13 +282,17 @@ module Shale
           end
 
           element = doc.create_element(node_name)
-          doc.add_namespace(xml_mapping.default_namespace.prefix, xml_mapping.default_namespace.name)
+
+          doc.add_namespace(
+            xml_mapping.default_namespace.prefix,
+            xml_mapping.default_namespace.name
+          )
 
           xml_mapping.attributes.each_value do |mapping|
             if mapping.method_to
-              instance.send(mapping.method_to, element, doc)
+              new.send(mapping.method_to, instance, element, doc)
             else
-              attribute = instance.class.attributes[mapping.attribute]
+              attribute = attributes[mapping.attribute]
               next unless attribute
 
               value = instance.send(attribute.name)
@@ -243,20 +303,33 @@ module Shale
             end
           end
 
-          if xml_mapping.content
-            attribute = instance.class.attributes[xml_mapping.content]
+          content_mapping = xml_mapping.content
 
-            if attribute
-              value = instance.send(attribute.name)
-              doc.add_text(element, value.to_s) if value
+          if content_mapping
+            if content_mapping.method_to
+              new.send(content_mapping.method_to, instance, element, doc)
+            else
+              attribute = attributes[content_mapping.attribute]
+
+              if attribute
+                value = instance.send(attribute.name)
+
+                # rubocop:disable Metrics/BlockNesting
+                if content_mapping.cdata
+                  doc.create_cdata(value.to_s, element)
+                else
+                  doc.add_text(element, value.to_s)
+                end
+                # rubocop:enable Metrics/BlockNesting
+              end
             end
           end
 
           xml_mapping.elements.each_value do |mapping|
             if mapping.method_to
-              instance.send(mapping.method_to, element, doc)
+              new.send(mapping.method_to, instance, element, doc)
             else
-              attribute = instance.class.attributes[mapping.attribute]
+              attribute = attributes[mapping.attribute]
               next unless attribute
 
               value = instance.send(attribute.name)
@@ -267,10 +340,12 @@ module Shale
               if attribute.collection?
                 [*value].each do |v|
                   next if v.nil?
-                  doc.add_element(element, attribute.type.as_xml(v, mapping.prefixed_name, doc))
+                  child = attribute.type.as_xml(v, mapping.prefixed_name, doc, mapping.cdata)
+                  doc.add_element(element, child)
                 end
               else
-                doc.add_element(element, attribute.type.as_xml(value, mapping.prefixed_name, doc))
+                child = attribute.type.as_xml(value, mapping.prefixed_name, doc, mapping.cdata)
+                doc.add_element(element, child)
               end
             end
           end
@@ -295,13 +370,22 @@ module Shale
 
         private
 
+        # Validate TOML adapter
+        #
+        # @raise [AdapterError]
+        #
+        # @api private
+        def validate_toml_adapter
+          raise AdapterError, TOML_ADAPTER_NOT_SET_MESSAGE unless Shale.toml_adapter
+        end
+
         # Validate XML adapter
         #
         # @raise [AdapterError]
         #
         # @api private
         def validate_xml_adapter
-          raise AdapterError, ADAPTER_NOT_SET_MESSAGE unless Shale.xml_adapter
+          raise AdapterError, XML_ADAPTER_NOT_SET_MESSAGE unless Shale.xml_adapter
         end
       end
 
@@ -334,6 +418,15 @@ module Shale
         self.class.to_yaml(self)
       end
 
+      # Convert Object to TOML
+      #
+      # @return [String]
+      #
+      # @api public
+      def to_toml
+        self.class.to_toml(self)
+      end
+
       # Convert Object to XML
       #
       # @param [Array<Symbol>] options

data/lib/shale/type/value.rb

@@ -89,6 +89,28 @@ module Shale
           value
         end
 
+        # Extract value from TOML document
+        #
+        # @param [any] value
+        #
+        # @return [any]
+        #
+        # @api private
+        def of_toml(value)
+          value
+        end
+
+        # Convert value to form accepted by TOML document
+        #
+        # @param [any] value
+        #
+        # @return [any]
+        #
+        # @api private
+        def as_toml(value)
+          value
+        end
+
         # Extract value from XML document
         #
         # @param [Shale::Adapter::<XML adapter>::Node] value
@@ -116,11 +138,18 @@ module Shale
         # @param [#to_s] value Value to convert to XML
         # @param [String] name Name of the element
         # @param [Shale::Adapter::<XML adapter>::Document] doc Document
+        # @param [true, false] cdata
         #
         # @api private
-        def as_xml(value, name, doc)
+        def as_xml(value, name, doc, cdata = false)
           element = doc.create_element(name)
-          doc.add_text(element, as_xml_value(value))
+
+          if cdata
+            doc.create_cdata(as_xml_value(value), element)
+          else
+            doc.add_text(element, as_xml_value(value))
+          end
+
           element
         end
       end

data/lib/shale/version.rb

@@ -2,5 +2,5 @@
 
 module Shale
   # @api private
-  VERSION = '0.5.0'
+  VERSION = '0.6.0'
 end

data/lib/shale.rb

@@ -72,6 +72,20 @@ module Shale
     # @api public
     attr_writer :yaml_adapter
 
+    # TOML adapter accessor.
+    #
+    # @param [@see Shale::Adapter::TomlRB] adapter
+    #
+    # @example setting adapter
+    #   Shale.toml_adapter = Shale::Adapter::TomlRB
+    #
+    # @example getting adapter
+    #   Shale.toml_adapter
+    #   # => Shale::Adapter::TomlRB
+    #
+    # @api public
+    attr_accessor :toml_adapter
+
     # XML adapter accessor. Available adapters are Shale::Adapter::REXML,
     # Shale::Adapter::Nokogiri and Shale::Adapter::Ox
     #

data/shale.gemspec

@@ -8,8 +8,8 @@ Gem::Specification.new do |spec|
   spec.authors = ['Kamil Giszczak']
   spec.email = ['beerkg@gmail.com']
 
-  spec.summary = 'Ruby object mapper and serializer for XML, JSON and YAML.'
-  spec.description = 'Ruby object mapper and serializer for XML, JSON and YAML.'
+  spec.summary = 'Ruby object mapper and serializer for XML, JSON, TOML and YAML.'
+  spec.description = 'Ruby object mapper and serializer for XML, JSON, TOML and YAML.'
   spec.homepage = 'https://shalerb.org'
   spec.license = 'MIT'
 

metadata

@@ -1,16 +1,16 @@
 --- !ruby/object:Gem::Specification
 name: shale
 version: !ruby/object:Gem::Version
-  version: 0.5.0
+  version: 0.6.0
 platform: ruby
 authors:
 - Kamil Giszczak
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2022-06-28 00:00:00.000000000 Z
+date: 2022-07-05 00:00:00.000000000 Z
 dependencies: []
-description: Ruby object mapper and serializer for XML, JSON and YAML.
+description: Ruby object mapper and serializer for XML, JSON, TOML and YAML.
 email:
 - beerkg@gmail.com
 executables:
@@ -33,6 +33,7 @@ files:
 - lib/shale/adapter/rexml.rb
 - lib/shale/adapter/rexml/document.rb
 - lib/shale/adapter/rexml/node.rb
+- lib/shale/adapter/toml_rb.rb
 - lib/shale/attribute.rb
 - lib/shale/error.rb
 - lib/shale/mapper.rb
@@ -117,5 +118,5 @@ requirements: []
 rubygems_version: 3.3.7
 signing_key:
 specification_version: 4
-summary: Ruby object mapper and serializer for XML, JSON and YAML.
+summary: Ruby object mapper and serializer for XML, JSON, TOML and YAML.
 test_files: []