necromancer 0.3.0 → 0.7.0

data/lib/necromancer/converters/boolean.rb

@@ -1,4 +1,7 @@
-# coding: utf-8
+# frozen_string_literal: true
+
+require_relative "../converter"
+require_relative "../null_converter"
 
 module Necromancer
   # Container for Boolean converter classes
@@ -26,12 +29,11 @@ module Necromancer
       #    0, f, F, FALSE, false, False, n, N, NO,  no,  No, off, OFF
       #
       # @api public
-      def call(value, options = {})
-        strict = options.fetch(:strict, config.strict)
+      def call(value, strict: config.strict)
         case value.to_s
         when TRUE_MATCHER then true
         when FALSE_MATCHER then false
-        else strict ? fail_conversion_type(value) : value
+        else strict ? raise_conversion_type(value) : value
         end
       end
     end
@@ -47,13 +49,10 @@ module Necromancer
       #   converter.call(0)  # => false
       #
       # @api public
-      def call(value, options = {})
-        strict = options.fetch(:strict, config.strict)
-        begin
-          !value.zero?
-        rescue
-          strict ? fail_conversion_type(value) : value
-        end
+      def call(value, strict: config.strict)
+        !value.zero?
+      rescue StandardError
+        strict ? raise_conversion_type(value) : value
       end
     end
 
@@ -68,21 +67,24 @@ module Necromancer
       #   converter.call(false)  # => 0
       #
       # @api public
-      def call(value, options = {})
-        strict = options.fetch(:strict, config.strict)
-        if ['TrueClass', 'FalseClass'].include?(value.class.name)
+      def call(value, strict: config.strict)
+        if %w[TrueClass FalseClass].include?(value.class.name)
           value ? 1 : 0
         else
-          strict ? fail_conversion_type(value) : value
+          strict ? raise_conversion_type(value) : value
         end
       end
     end
 
     def self.load(conversions)
-      conversions.register StringToBooleanConverter.new(:string, :boolean)
-      conversions.register IntegerToBooleanConverter.new(:integer, :boolean)
-      conversions.register BooleanToIntegerConverter.new(:boolean, :integer)
-      conversions.register NullConverter.new(:boolean, :boolean)
+      [
+        StringToBooleanConverter.new(:string, :boolean),
+        IntegerToBooleanConverter.new(:integer, :boolean),
+        BooleanToIntegerConverter.new(:boolean, :integer),
+        NullConverter.new(:boolean, :boolean)
+      ].each do |converter|
+        conversions.register converter
+      end
     end
   end # BooleanConverters
 end # Necromancer

data/lib/necromancer/converters/date_time.rb

@@ -1,33 +1,78 @@
-# coding: utf-8
+# frozen_string_literal: true
+
+require "date"
+require "time"
+
+require_relative "../converter"
+require_relative "../null_converter"
 
 module Necromancer
   # Container for Date converter classes
   module DateTimeConverters
     # An object that converts a String to a Date
     class StringToDateConverter < Converter
-      def call(value, options = {})
-        strict = options.fetch(:strict, config.strict)
+      # Convert a string value to a Date
+      #
+      # @example
+      #   converter.call("1-1-2015")    # => "2015-01-01"
+      #   converter.call("01/01/2015")  # => "2015-01-01"
+      #   converter.call("2015-11-12")  # => "2015-11-12"
+      #   converter.call("12/11/2015")  # => "2015-11-12"
+      #
+      # @api public
+      def call(value, strict: config.strict)
         Date.parse(value)
-      rescue
-        strict ? fail_conversion_type(value) : value
+      rescue StandardError
+        strict ? raise_conversion_type(value) : value
       end
     end
 
     # An object that converts a String to a DateTime
     class StringToDateTimeConverter < Converter
-      def call(value, options = {})
-        strict = options.fetch(:strict, config.strict)
+      # Convert a string value to a DateTime
+      #
+      # @example
+      #  converer.call("1-1-2015")           # => "2015-01-01T00:00:00+00:00"
+      #  converer.call("1-1-2015 15:12:44")  # => "2015-01-01T15:12:44+00:00"
+      #
+      # @api public
+      def call(value, strict: config.strict)
         DateTime.parse(value)
-      rescue
-        strict ? fail_conversion_type(value) : value
+      rescue StandardError
+        strict ? raise_conversion_type(value) : value
+      end
+    end
+
+    class StringToTimeConverter < Converter
+      # Convert a String value to a Time value
+      #
+      # @param [String] value
+      #   the value to convert
+      #
+      # @example
+      #   converter.call("01-01-2015")       # => 2015-01-01 00:00:00 +0100
+      #   converter.call("01-01-2015 08:35") # => 2015-01-01 08:35:00 +0100
+      #   converter.call("12:35")            # => 2015-01-04 12:35:00 +0100
+      #
+      # @api public
+      def call(value, strict: config.strict)
+        Time.parse(value)
+      rescue StandardError
+        strict ? raise_conversion_type(value) : value
       end
     end
 
     def self.load(conversions)
-      conversions.register StringToDateConverter.new(:string, :date)
-      conversions.register NullConverter.new(:date, :date)
-      conversions.register StringToDateTimeConverter.new(:string, :datetime)
-      conversions.register NullConverter.new(:datetime, :datetime)
+      [
+        StringToDateConverter.new(:string, :date),
+        NullConverter.new(:date, :date),
+        StringToDateTimeConverter.new(:string, :datetime),
+        NullConverter.new(:datetime, :datetime),
+        StringToTimeConverter.new(:string, :time),
+        NullConverter.new(:time, :time)
+      ].each do |converter|
+        conversions.register converter
+      end
     end
   end # DateTimeConverters
 end # Necromancer

data/lib/necromancer/converters/hash.rb

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+
+require_relative "../converter"
+require_relative "boolean"
+require_relative "numeric"
+
+module Necromancer
+  module HashConverters
+    # An object that converts a String to a Hash
+    class StringToHashConverter < Converter
+      DEFAULT_CONVERSION = ->(val, *_rest) { val }
+
+      # Convert string value to hash
+      #
+      # @example
+      #   converter.call("a:1 b:2 c:3")
+      #   # => {a: "1", b: "2", c: "3"}
+      #
+      # @example
+      #   converter.call("a=1 & b=3 & c=3")
+      #   # => {a: "1", b: "2", c: "3"}
+      #
+      # @api public
+      def call(value, strict: config.strict, value_converter: DEFAULT_CONVERSION)
+        values = value.split(/\s*[& ]\s*/)
+        values.each_with_object({}) do |pair, pairs|
+          key, value = pair.split(/[=:]/, 2)
+          value_converted = value_converter.(value, strict: strict)
+          if current = pairs[key.to_sym]
+            pairs[key.to_sym] = Array(current) << value_converted
+          else
+            pairs[key.to_sym] = value_converted
+          end
+          pairs
+        end
+      end
+    end
+
+    class StringToIntegerHashConverter < Converter
+      # Convert string value to hash with integer values
+      #
+      # @example
+      #   converter.call("a:1 b:2 c:3")
+      #   # => {a: 1, b: 2, c: 3}
+      #
+      # @api public
+      def call(value, strict: config.strict)
+        int_converter = NumericConverters::StringToIntegerConverter.new(:string,
+                                                                        :integer)
+        hash_converter = StringToHashConverter.new(:string, :hash)
+        hash_converter.(value, strict: strict, value_converter: int_converter)
+      end
+    end
+
+    class StringToFloatHashConverter < Converter
+      # Convert string value to hash with float values
+      #
+      # @example
+      #   converter.call("a:1 b:2 c:3")
+      #   # => {a: 1.0, b: 2.0, c: 3.0}
+      #
+      # @api public
+      def call(value, strict: config.strict)
+        float_converter = NumericConverters::StringToFloatConverter.new(:string,
+                                                                        :float)
+        hash_converter = StringToHashConverter.new(:string, :hash)
+        hash_converter.(value, strict: strict, value_converter: float_converter)
+      end
+    end
+
+    class StringToNumericHashConverter < Converter
+      # Convert string value to hash with numeric values
+      #
+      # @example
+      #   converter.call("a:1 b:2.0 c:3")
+      #   # => {a: 1, b: 2.0, c: 3}
+      #
+      # @api public
+      def call(value, strict: config.strict)
+        num_converter = NumericConverters::StringToNumericConverter.new(:string,
+                                                                        :numeric)
+        hash_converter = StringToHashConverter.new(:string, :hash)
+        hash_converter.(value, strict: strict, value_converter: num_converter)
+      end
+    end
+
+    class StringToBooleanHashConverter < Converter
+      # Convert string value to hash with boolean values
+      #
+      # @example
+      #   converter.call("a:yes b:no c:t")
+      #   # => {a: true, b: false, c: true}
+      #
+      # @api public
+      def call(value, strict: config.strict)
+        bool_converter = BooleanConverters::StringToBooleanConverter.new(:string,
+                                                                         :boolean)
+        hash_converter = StringToHashConverter.new(:string, :hash)
+        hash_converter.(value, strict: strict, value_converter: bool_converter)
+      end
+    end
+
+    def self.load(conversions)
+      [
+        NullConverter.new(:hash, :hash),
+        StringToHashConverter.new(:string, :hash),
+        StringToIntegerHashConverter.new(:string, :int_hash),
+        StringToIntegerHashConverter.new(:string, :integer_hash),
+        StringToFloatHashConverter.new(:string, :float_hash),
+        StringToNumericHashConverter.new(:string, :num_hash),
+        StringToNumericHashConverter.new(:string, :numeric_hash),
+        StringToBooleanHashConverter.new(:string, :boolean_hash),
+        StringToBooleanHashConverter.new(:string, :bool_hash)
+      ].each do |converter|
+        conversions.register(converter)
+      end
+    end
+  end # HashConverters
+end # Necromancer

data/lib/necromancer/converters/numeric.rb

@@ -1,25 +1,27 @@
-# coding: utf-8
+# frozen_string_literal: true
+
+require_relative "../converter"
+require_relative "../null_converter"
 
 module Necromancer
   # Container for Numeric converter classes
   module NumericConverters
-    INTEGER_MATCHER = /^[-+]?(\d+)$/.freeze
+    INTEGER_MATCHER = /^\s*[-+]?\s*(\d[\d\s]*)?$/.freeze
 
-    FLOAT_MATCHER = /^[-+]?(\d*)(\.\d+)?([eE]?[-+]?\d+)?$/.freeze
+    FLOAT_MATCHER = /^\s*[-+]?([\d\s]*)(\.[\d\s]+)?([eE]?[-+]?[\d\s]+)?$/.freeze
 
     # An object that converts a String to an Integer
     class StringToIntegerConverter < Converter
       # Convert string value to integer
       #
       # @example
-      #   converter.call('1abc')  # => 1
+      #   converter.call("1abc")  # => 1
       #
       # @api public
-      def call(value, options = {})
-        strict = options.fetch(:strict, config.strict)
+      def call(value, strict: config.strict)
         Integer(value)
-      rescue
-        strict ? fail_conversion_type(value) : value.to_i
+      rescue StandardError
+        strict ? raise_conversion_type(value) : value.to_i
       end
     end
 
@@ -28,10 +30,10 @@ module Necromancer
       # Convert integer value to string
       #
       # @example
-      #   converter.call(1)  # => '1'
+      #   converter.call(1)  # => "1"
       #
       # @api public
-      def call(value, _)
+      def call(value, **_)
         value.to_s
       end
     end
@@ -41,14 +43,13 @@ module Necromancer
       # Convert string to float value
       #
       # @example
-      #   converter.call('1.2') # => 1.2
+      #   converter.call("1.2") # => 1.2
       #
       # @api public
-      def call(value, options = {})
-        strict = options.fetch(:strict, config.strict)
+      def call(value, strict: config.strict)
         Float(value)
-      rescue
-        strict ? fail_conversion_type(value) : value.to_f
+      rescue StandardError
+        strict ? raise_conversion_type(value) : value.to_f
       end
     end
 
@@ -57,32 +58,35 @@ module Necromancer
       # Convert string to numeric value
       #
       # @example
-      #   converter.call('1.0')  # => 1.0
+      #   converter.call("1.0")  # => 1.0
       #
       # @example
-      #   converter.call('1')   # => 1
+      #   converter.call("1")   # => 1
       #
       # @api public
-      def call(value, options = {})
-        strict = options.fetch(:strict, config.strict)
+      def call(value, strict: config.strict)
         case value
         when INTEGER_MATCHER
-          StringToIntegerConverter.new(:string, :integer).call(value, options)
+          StringToIntegerConverter.new(:string, :integer).(value, strict: strict)
         when FLOAT_MATCHER
-          StringToFloatConverter.new(:string, :float).call(value, options)
+          StringToFloatConverter.new(:string, :float).(value, strict: strict)
         else
-          strict ? fail_conversion_type(value) : value
+          strict ? raise_conversion_type(value) : value
         end
       end
     end
 
     def self.load(conversions)
-      conversions.register StringToIntegerConverter.new(:string, :integer)
-      conversions.register IntegerToStringConverter.new(:integer, :string)
-      conversions.register NullConverter.new(:integer, :integer)
-      conversions.register StringToFloatConverter.new(:string, :float)
-      conversions.register NullConverter.new(:float, :float)
-      conversions.register StringToNumericConverter.new(:string, :numeric)
+      [
+        StringToIntegerConverter.new(:string, :integer),
+        IntegerToStringConverter.new(:integer, :string),
+        NullConverter.new(:integer, :integer),
+        StringToFloatConverter.new(:string, :float),
+        NullConverter.new(:float, :float),
+        StringToNumericConverter.new(:string, :numeric)
+      ].each do |converter|
+        conversions.register converter
+      end
     end
   end # Conversion
 end # Necromancer

data/lib/necromancer/converters/range.rb

@@ -1,13 +1,22 @@
-# coding: utf-8
+# frozen_string_literal: true
+
+require_relative "../converter"
+require_relative "../null_converter"
 
 module Necromancer
   # Container for Range converter classes
   module RangeConverters
-    SINGLE_DIGIT_MATCHER = /^(\-?\d+)$/.freeze
+    SINGLE_DIGIT_MATCHER = /^(?<digit>-?\d+(\.\d+)?)$/.freeze
 
-    DIGIT_MATCHER = /^(-?\d+?)(\.{2}\.?|-|,)(-?\d+)$/.freeze
+    DIGIT_MATCHER = /^(?<open>-?\d+(\.\d+)?)
+                      \s*(?<sep>(\.\s*){2,3}|-|,)\s*
+                      (?<close>-?\d+(\.\d+)?)$
+                    /x.freeze
 
-    LETTER_MATCHER = /^(\w)(\.{2}\.?|-|,)(\w)$/.freeze
+    LETTER_MATCHER = /^(?<open>\w)
+                      \s*(?<sep>(\.\s*){2,3}|-|,)\s*
+                      (?<close>\w)$
+                      /x.freeze
 
     # An object that converts a String to a Range
     class StringToRangeConverter < Converter
@@ -16,30 +25,47 @@ module Necromancer
       # @param [Object] value
       #
       # @example
-      #   converter.call('0,9')  # => (0..9)
+      #   converter.call("0,9")  # => (0..9)
       #
       # @example
-      #   converter.call('0-9')  # => (0..9)
+      #   converter.call("0-9")  # => (0..9)
       #
       # @api public
-      def call(value, options = {})
-        strict = options.fetch(:strict, config.strict)
-        case value
-        when SINGLE_DIGIT_MATCHER
-          ::Range.new($1.to_i, $1.to_i)
-        when DIGIT_MATCHER
-          ::Range.new($1.to_i, $3.to_i, $2 == '...')
-        when LETTER_MATCHER
-          ::Range.new($1.to_s, $3.to_s, $2 == '...')
+      def call(value, strict: config.strict)
+        if match = value.match(SINGLE_DIGIT_MATCHER)
+          digit = cast_to_num(match[:digit])
+          ::Range.new(digit, digit)
+        elsif match = value.match(DIGIT_MATCHER)
+          open = cast_to_num(match[:open])
+          close = cast_to_num(match[:close])
+          ::Range.new(open, close, match[:sep].gsub(/\s*/, "") == "...")
+        elsif match = value.match(LETTER_MATCHER)
+          ::Range.new(match[:open], match[:close],
+                      match[:sep].gsub(/\s*/, "") == "...")
         else
-          strict ? fail_conversion_type(value) : value
+          strict ? raise_conversion_type(value) : value
         end
       end
+
+      # Convert range end to numeric value
+      #
+      # @api private
+      def cast_to_num(str)
+        Integer(str)
+      rescue ArgumentError
+        Float(str)
+      rescue ArgumentError
+        nil
+      end
     end
 
     def self.load(conversions)
-      conversions.register StringToRangeConverter.new(:string, :range)
-      conversions.register NullConverter.new(:range, :range)
+      [
+        StringToRangeConverter.new(:string, :range),
+        NullConverter.new(:range, :range)
+      ].each do |converter|
+        conversions.register converter
+      end
     end
   end # RangeConverters
 end # Necromancer