shale 0.3.1 → 0.6.0

data/lib/shale/type/{composite.rb → complex.rb}

@@ -1,18 +1,19 @@
 # frozen_string_literal: true
 
+require_relative '../error'
 require_relative 'value'
 
 module Shale
   module Type
-    # Build composite object. Don't use it directly.
+    # Build complex object. Don't use it directly.
     # It serves as a base type class for @see Shale::Mapper
     #
     # @api private
-    class Composite < Value
+    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
             #
@@ -20,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
 
@@ -29,24 +35,21 @@ 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
 
                   if value.nil?
-                    instance.public_send("\#{attribute.name}=", nil)
-                    next
-                  end
-
-                  if attribute.collection?
+                    instance.send(attribute.setter, nil)
+                  elsif attribute.collection?
                     [*value].each do |val|
                       val = val ? attribute.type.of_#{format}(val) : val
-                      instance.public_send(attribute.name) << attribute.type.cast(val)
+                      instance.send(attribute.name) << attribute.type.cast(val)
                     end
                   else
                     val = attribute.type.of_#{format}(value)
-                    instance.public_send("\#{attribute.name}=", val)
+                    instance.send(attribute.setter, attribute.type.cast(val))
                   end
                 end
               end
@@ -54,31 +57,35 @@ 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.public_send(attribute.name)
+                  value = instance.send(attribute.name)
 
                   if value.nil?
                     hash[mapping.name] = nil
-                    next
-                  end
-
-                  if attribute.collection?
+                  elsif attribute.collection?
                     hash[mapping.name] = [*value].map do |v|
                       v ? attribute.type.as_#{format}(v) : v
                     end
@@ -142,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
@@ -150,31 +181,43 @@ 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
 
               if attribute.collection?
-                instance.public_send(attribute.name) << attribute.type.cast(value)
+                instance.send(attribute.name) << attribute.type.cast(value)
               else
-                instance.public_send("#{attribute.name}=", 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.public_send("#{attribute.name}=", attribute.type.of_xml(element))
+              if attribute
+                value = attribute.type.of_xml(element)
+                instance.send(attribute.setter, attribute.type.cast(value))
+              end
             end
           end
 
@@ -183,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.public_send(attribute.name) << attribute.type.cast(value)
+                instance.send(attribute.name) << attribute.type.cast(value)
               else
-                instance.public_send("#{attribute.name}=", attribute.type.of_xml(node))
+                instance.send(attribute.setter, attribute.type.cast(value))
               end
             end
           end
@@ -204,23 +248,33 @@ module Shale
         #
         # @param [String] xml XML to convert
         #
+        # @raise [AdapterError]
+        #
         # @return [Shale::Mapper]
         #
         # @api public
         def from_xml(xml)
+          validate_xml_adapter
           of_xml(Shale.xml_adapter.load(xml))
         end
 
         # 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))
@@ -228,16 +282,20 @@ 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.public_send(attribute.name)
+              value = instance.send(attribute.name)
               next if value.nil?
 
               doc.add_namespace(mapping.namespace.prefix, mapping.namespace.name)
@@ -245,23 +303,36 @@ module Shale
             end
           end
 
-          if xml_mapping.content
-            attribute = instance.class.attributes[xml_mapping.content]
+          content_mapping = xml_mapping.content
+
+          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.public_send(attribute.name)
-              doc.add_text(element, value.to_s) if value
+              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.public_send(attribute.name)
+              value = instance.send(attribute.name)
               next if value.nil?
 
               doc.add_namespace(mapping.namespace.prefix, mapping.namespace.name)
@@ -269,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
@@ -285,12 +358,35 @@ module Shale
         # @param [Shale::Mapper] instance Object to convert
         # @param [Array<Symbol>] options
         #
+        # @raise [AdapterError]
+        #
         # @return [String]
         #
         # @api public
         def to_xml(instance, *options)
+          validate_xml_adapter
           Shale.xml_adapter.dump(as_xml(instance), *options)
         end
+
+        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, XML_ADAPTER_NOT_SET_MESSAGE unless Shale.xml_adapter
+        end
       end
 
       # Convert Object to Hash
@@ -322,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/utils.rb

@@ -5,6 +5,46 @@ module Shale
   #
   # @api private
   module Utils
+    # Convert string to Ruby's class naming convention
+    #
+    # @param [String] val
+    #
+    # @example
+    #   Shale::Utils.classify('foobar')
+    #   # => 'Foobar'
+    #
+    # @api private
+    def self.classify(str)
+      str = str.to_s.sub(/.*\./, '')
+
+      str = str.sub(/^[a-z\d]*/) { |match| match.capitalize || match }
+
+      str.gsub(%r{(?:_|-|(/))([a-z\d]*)}i) do
+        word = Regexp.last_match(2)
+        substituted = word.capitalize || word
+        Regexp.last_match(1) ? "::#{substituted}" : substituted
+      end
+    end
+
+    # Convert string to snake case
+    #
+    # @param [String] val
+    #
+    # @example
+    #   Shale::Utils.snake_case('FooBar')
+    #   # => 'foo_bar'
+    #
+    # @api private
+    def self.snake_case(str)
+      return str.to_s unless /[A-Z-]|::/.match?(str)
+      word = str.to_s.gsub('::', '/')
+      word = word.gsub(/([A-Z]+)(?=[A-Z][a-z])|([a-z\d])(?=[A-Z])/) do
+        "#{Regexp.last_match(1) || Regexp.last_match(2)}_"
+      end
+      word = word.tr('-', '_')
+      word.downcase
+    end
+
     # Convert word to under score
     #
     # @param [String] word
@@ -14,13 +54,8 @@ module Shale
     #   Shale::Utils.underscore('Namespace::FooBar') # => foo_bar
     #
     # @api private
-    def self.underscore(word)
-      word
-        .split('::')
-        .last
-        .gsub(/([A-Z\d]+)([A-Z][a-z])/, '\1_\2')
-        .gsub(/([a-z\d])([A-Z])/, '\1_\2')
-        .downcase
+    def self.underscore(str)
+      snake_case(str).split('/').last
     end
 
     # Return value or nil if value is empty

data/lib/shale/version.rb

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

data/lib/shale.rb

@@ -4,7 +4,6 @@ require 'yaml'
 
 require_relative 'shale/mapper'
 require_relative 'shale/adapter/json'
-require_relative 'shale/adapter/rexml'
 require_relative 'shale/type/boolean'
 require_relative 'shale/type/date'
 require_relative 'shale/type/float'
@@ -73,15 +72,34 @@ module Shale
     # @api public
     attr_writer :yaml_adapter
 
-    # Set XML 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
     #
     # @param [@see Shale::Adapter::REXML] adapter
     #
-    # @example
+    # @example setting adapter
     #   Shale.xml_adapter = Shale::Adapter::REXML
     #
+    # @example getting adapter
+    #   Shale.xml_adapter
+    #   # => Shale::Adapter::REXML
+    #
     # @api public
-    attr_writer :xml_adapter
+    attr_accessor :xml_adapter
 
     # Return JSON adapter. By default Shale::Adapter::JSON is used
     #
@@ -108,20 +126,5 @@ module Shale
     def yaml_adapter
       @yaml_adapter || YAML
     end
-
-    # Return XML adapter. By default Shale::Adapter::REXML is used.
-    # Available adapters are Shale::Adapter::REXML,
-    # Shale::Adapter::Nokogiri and Shale::Adapter::Ox
-    #
-    # @return [@see Shale::Adapter::REXML]
-    #
-    # @example
-    #   Shale.xml_adapter
-    #   # => Shale::Adapter::REXML
-    #
-    # @api public
-    def xml_adapter
-      @xml_adapter || Adapter::REXML
-    end
   end
 end

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'
 
@@ -26,5 +26,5 @@ Gem::Specification.new do |spec|
   spec.bindir = 'exe'
   spec.executables = 'shaleb'
 
-  spec.required_ruby_version = '>= 2.6.0'
+  spec.required_ruby_version = '>= 2.7.0'
 end