necromancer 0.6.0 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 68eb8e7721b9b177485217e74aecb8e9c9bbe2995615bdb21d2601c04afe2bb2
-  data.tar.gz: d80270564204a03b60dacfc21c0e4da9283a0c387bef4fe1566829e9bce9bd54
+  metadata.gz: ab3ba9bfe1c011b3ecf087642ff05a74b51939fa7fb881bbcdb7acec618e9d76
+  data.tar.gz: 4323c173f67da37e1eab170642aff2b8f179b8dc55f777b5424f487271bef105
 SHA512:
-  metadata.gz: 5638c5411b0f5a2f4b2fe59d78ef59c59a4c0de675989c8c3fe40b6694f02b11ecb87f8294e1cc9147e17efcc6c7b906f9cbb23caa75e4b21c32e48607b01a08
-  data.tar.gz: b89a52e45e1aab9d36121a7ef17aba54436bdb3fa58182df77808d57cb146e0688cb05e335b6464b6d66bf396bf579fbe61ea0ecb9abdac59ed9d80cbf992f26
+  metadata.gz: bbf17295bcc8268d93805f7b3e1fb6233358db0bdfb91bd5f7de644a5a7546e735e5f046430b1dbed3a85cffcba0dba3d38b107e12e5f4c366b89b71c8882d1e
+  data.tar.gz: 644eb159ae79c9a7f394b858ea2b367692959562979ad7e2c4befc45006f90ab014c3aa2e222469754f71687fee7ebd549dc6e2fe6ea5bc3439b11bf8bec9332

data/CHANGELOG.md

@@ -1,5 +1,16 @@
 # Change log
 
+## [v0.7.0] - 2020-12-29
+
+### Added
+* Add HashConverters for transforming string into hash of string, integer, float or boolean values
+* Add converters for transforming string to array of booleans, integers, floats and numeric
+
+### Changed
+* Change StringToRange converter to work with decimal numbers and spaces
+* Change :strict to be a keyword argument
+* Change StringToNumeric converter to allow numbers with space characters
+
 ## [v0.6.0] - 2020-03-08
 
 ### Changed
@@ -57,6 +68,7 @@
 
 * Initial implementation and release
 
+[v0.7.0]: https://github.com/piotrmurach/necromancer/compare/v0.6.0...v0.7.0
 [v0.6.0]: https://github.com/piotrmurach/necromancer/compare/v0.5.1...v0.6.0
 [v0.5.1]: https://github.com/piotrmurach/necromancer/compare/v0.5.0...v0.5.1
 [v0.5.0]: https://github.com/piotrmurach/necromancer/compare/v0.4.0...v0.5.0

data/README.md

@@ -1,14 +1,14 @@
 # Necromancer
 
 [![Gem Version](https://badge.fury.io/rb/necromancer.svg)][gem]
-[![Build Status](https://secure.travis-ci.org/piotrmurach/necromancer.svg?branch=master)][travis]
+[![Actions CI](https://github.com/piotrmurach/tty-runner/workflows/CI/badge.svg?branch=master)][gh_actions_ci]
 [![Build status](https://ci.appveyor.com/api/projects/status/qj3xn5gbbfi4puet?svg=true)][appveyor]
 [![Code Climate](https://codeclimate.com/github/piotrmurach/necromancer/badges/gpa.svg)][codeclimate]
 [![Coverage Status](https://coveralls.io/repos/github/piotrmurach/necromancer/badge.svg?branch=master)][coverage]
 [![Inline docs](http://inch-ci.org/github/piotrmurach/necromancer.svg?branch=master)][inchpages]
 
 [gem]: http://badge.fury.io/rb/necromancer
-[travis]: http://travis-ci.org/piotrmurach/necromancer
+[gh_actions_ci]: https://github.com/piotrmurach/tty-runner/actions?query=workflow%3ACI
 [appveyor]: https://ci.appveyor.com/project/piotrmurach/necromancer
 [codeclimate]: https://codeclimate.com/github/piotrmurach/necromancer
 [coverage]: https://coveralls.io/github/piotrmurach/necromancer
@@ -35,7 +35,7 @@ Conversion between Ruby core types frequently comes up in projects but is solved
 Add this line to your application's Gemfile:
 
 ```ruby
-gem 'necromancer'
+gem "necromancer"
 ```
 
 And then execute:
@@ -73,39 +73,48 @@ Or install it yourself as:
 For example, to convert a string to a [range](#36-range) type:
 
 ```ruby
-Necromancer.convert('1-10').to(:range)  # => 1..10
-Necromancer.convert('1-10') >> :range   # => 1..10
-Necromancer.convert('1-10') >> Range    # => 1..10
+Necromancer.convert("1-10").to(:range)  # => 1..10
+Necromancer.convert("1-10") >> :range   # => 1..10
+Necromancer.convert("1-10") >> Range    # => 1..10
 ```
 
 In order to handle [boolean](#32-boolean) conversions:
 
 ```ruby
-Necromancer.convert('t').to(:boolean)   # => true
-Necromancer.convert('t') >> true        # => true
+Necromancer.convert("t").to(:boolean)   # => true
+Necromancer.convert("t") >> true        # => true
 ```
 
 To convert string to [numeric](#35-numeric) value:
 
 ```ruby
-Necromancer.convert('10e1').to(:numeric)  # => 100
+Necromancer.convert("10e1").to(:numeric)  # => 100
 ```
 
-or convert [array](#31-array) of string values into numeric type:
+You can convert string to [array](#31-array) of values like `boolean`, `integer` or `float`:
 
 ```ruby
-Necromancer.convert(['1', '2.3', '3.0']).to(:numeric)  # => [1, 2.3, 3.0]
+Necromancer.convert("t,f,t"]).to(:booleans)      # => [true, false, true]
+Necromancer.convert("1,2.3,3.0"]).to(:integers)  # => [1, 2, 3]
+Necromancer.convert("1,2.3,3.0"]).to(:floats)    # => [1.0, 2.3, 3.0]
 ```
 
-To provide extra information about the conversion value type you can use `from`.
+To convert string to [hash](#34-hash) value:
 
 ```ruby
-Necromancer.convert(['1', '2.3', '3.0']).from(:array).to(:numeric) # => [1, 2.3, 3.0]
+Necromancer.convert("a:1 b:2 c:3").to(:hash) # => {a: "1", b: "2", c: "3"}
+Necromancer.convert("a=1 b=2 c=3").to(:hash) # => {a: "1", b: "2", c: "3"}
+````
+
+To provide extra information about the conversion value type use the `from`:
+
+```ruby
+Necromancer.convert(["1", "2.3", "3.0"]).from(:array).to(:numeric) # => [1, 2.3, 3.0]
 ```
 
 **Necromancer** also allows you to add [custom](#37-custom) conversions.
 
-Conversion isn't always possible, in which case a `Necromancer::NoTypeConversionAvailableError` is thrown indicating that `convert` doesn't know how to perform the requested conversion:
+When conversion isn't possible, a `Necromancer::NoTypeConversionAvailableError` is thrown indicating that `convert` doesn't know how to perform the requested conversion:
 
 ```ruby
 Necromancer.convert(:foo).to(:float)
@@ -121,13 +130,13 @@ Necromancer.convert(:foo).to(:float)
 For the purpose of divination, **Necromancer** uses `convert` method to turn source type into target type. For example, in order to convert a string into a range type do:
 
 ```ruby
-Necromancer.convert('1,10').to(:range)  #  => 1..10
+Necromancer.convert("1,10").to(:range)  #  => 1..10
 ```
 
 Alternatively, you can use block:
 
 ```ruby
-Necromancer.convert { '1,10' }.to(:range) # => 1..10
+Necromancer.convert { "1,10" }.to(:range) # => 1..10
 ```
 
 Conversion isn't always possible, in which case a `Necromancer::NoTypeConversionAvailableError` is thrown indicating that `convert` doesn't know how to perform the requested conversion:
@@ -142,54 +151,54 @@ Necromancer.convert(:foo).to(:float)
 To specify conversion source type use `from` method:
 
 ```ruby
-Necromancer.convert('1.0').from(:string).to(:numeric)
+Necromancer.convert("1.0").from(:string).to(:numeric)
 ```
 
 In majority of cases you do not need to specify `from` as the type will be inferred from the `convert` method argument and then appropriate conversion will be applied to result in `target` type such as `:numeric`. However, if you do not control the input to `convert` and want to ensure consistent behaviour please use `from`.
 
 The source parameters are:
 
-* :array
-* :boolean
-* :date
-* :datetime
-* :float
-* :integer
-* :numeric
-* :range
-* :string
-* :time
+* `:array`
+* `:boolean`
+* `:date`
+* `:datetime`
+* `:float`
+* `:integer`
+* `:numeric`
+* `:range`
+* `:string`
+* `:time`
 
 ### 2.3 to
 
 To convert objects between types, **Necromancer** provides several target types. The `to` or functional style `>>` method allows you to pass target as an argument to perform actual conversion. The target can be one of `:symbol`, `object` or `ClassName`:
 
 ```ruby
-Necromancer.convert('yes').to(:boolean)   # => true
-Necromancer.convert('yes') >> :boolean    # => true
-Necromancer.convert('yes') >> true        # => true
-Necromancer.convert('yes') >> TrueClass   # => true
+Necromancer.convert("yes").to(:boolean)   # => true
+Necromancer.convert("yes") >> :boolean    # => true
+Necromancer.convert("yes") >> true        # => true
+Necromancer.convert("yes") >> TrueClass   # => true
 ```
 
-By default, when target conversion fails the orignal value is returned. However, you can pass `strict` as an additional argument to ensure failure when conversion cannot be performed:
+By default, when target conversion fails the original value is returned. However, you can pass `strict` as an additional argument to ensure failure when conversion cannot be performed:
 
 ```ruby
-Necromancer.convert('1a').to(:integer, strict: true)
+Necromancer.convert("1a").to(:integer, strict: true)
 # => raises Necromancer::ConversionTypeError
 ```
 
 The target parameters are:
 
-* :array
-* :boolean
-* :date
-* :datetime
-* :float
-* :integer
-* :numeric
-* :range
-* :string
-* :time
+* `:array`
+* `:boolean`, `:booleans`, `:bools`, `:boolean_hash`, `:bool_hash`
+* `:date`
+* `:datetime`,
+* `:float`, `:floats`, `:float_hash`
+* `:integer`, `:integers`, `:ints`, `:integer_hash`, `:int_hash`
+* `:numeric`, `:numerics`, `:nums`, `:numeric_hash`, `:num_hash`
+* `:range`
+* `:string`
+* `:time`
 
 ### 2.4 can?
 
@@ -211,7 +220,7 @@ Necromancer.new do |config|
 end
 ```
 
-or calling `configure` method:
+Or calling `configure` method:
 
 ```ruby
 converter = Necromancer.new
@@ -222,12 +231,12 @@ end
 
 Available configuration options are:
 
-* strict - ensures correct types for conversion, by default `false`
-* copy - ensures only copy is modified, by default `true`
+* `strict` - ensures correct types for conversion, by default `false`
+* `copy` - ensures only copy is modified, by default `true`
 
 ## 3. Converters
 
-**Necromancer** flexibility means you can register your own converters or use the already defined converters for such types as `Array`, `Boolean`, `Hash`, `Numeric`, `Range`.
+**Necromancer** flexibility means you can register your own converters or use the already defined converters for such types as `Array`, `Boolean`, `Date`, `DateTime`, `Hash`, `Numeric`, `Range` and `Time`.
 
 ### 3.1 Array
 
@@ -241,47 +250,61 @@ Necromancer.convert({x: 1}).to(:array)  # => [[:x, 1]]
 In addition, **Necromancer** excels at converting `,` or `-` delimited string into an array object:
 
 ```ruby
-Necromancer.convert('a, b, c').to(:array)  # => ['a', 'b', 'c']
+Necromancer.convert("a, b, c").to(:array)  # => ["a", "b", "c"]
 ```
 
 If the string is a list of `-` or `,` separated numbers, they will be converted to their respective numeric types:
 
 ```ruby
-Necromancer.convert('1 - 2 - 3').to(:array)  # => [1, 2, 3]
+Necromancer.convert("1 - 2 - 3").to(:array)  # => [1, 2, 3]
+```
+
+It handles conversion of string into an array of boolean values as well:
+
+```ruby
+Necromancer.convert("yes,no,t").to(:booleans)    # => [true, false, true]
+Necromancer.convert("1 - f - FALSE").to(:bools)  # => [true, false, false]
 ```
 
 You can also convert array containing string objects to array containing numeric values:
 
 ```ruby
-Necromancer.convert(['1', '2.3', '3.0']).to(:numeric)
+Necromancer.convert(["1", "2.3", "3.0"]).to(:numerics) # => [1, 2.3, 3.0]
+Necromancer.convert(["1", "2.3", "3.0"]).to(:nums)     # => [1, 2.3, 3.0]
+```
+
+Or you can be more specific by using `:integers` and `:floats` as the resulting type:
+
+```ruby
+Necromancer.convert(["1", "2.3", "3.0"]).to(:integers) # => [1, 2, 3]
 ```
 
 When in `strict` mode the conversion will raise a `Necromancer::ConversionTypeError` error like so:
 
 ```ruby
-Necromancer.convert(['1', '2.3', false]).to(:numeric, strict: true)
-# => Necromancer::ConversionTypeError: false cannot be converted from `array` to `numeric`
+Necromancer.convert(["1", "2.3", false]).to(:numerics, strict: true)
+# => Necromancer::ConversionTypeError: false cannot be converted from `array` to `numerics`
 ```
 
 However, in `non-strict` mode the value will be simply returned unchanged:
 
 ```ruby
-Necromancer.convert(['1', '2.3', false]).to(:numeric, strict: false)
+Necromancer.convert(["1", "2.3", false]).to(:numerics, strict: false)
 # => [1, 2.3, false]
 ```
 
 ### 3.2 Boolean
 
-The **Necromancer** allows you to convert a string object to boolean object. The `1`, `'1'`, `'t'`, `'T'`, `'true'`, `'TRUE'`, `'y'`, `'Y'`, `'yes'`, `'Yes'`, `'on'`, `'ON'` values are converted to `TrueClass`.
+The **Necromancer** allows you to convert a string object to boolean object. The `1`, `"1"`, `"t"`, `"T"`, `"true"`, `"TRUE"`, `"y"`, `"Y"`, `"yes"`, `"Yes"`, `"on"`, `"ON"` values are converted to `TrueClass`.
 
 ```ruby
-Necromancer.convert('yes').to(:boolean)  # => true
+Necromancer.convert("yes").to(:boolean)  # => true
 ```
 
-Similarly, the `0`, `'0'`, `'f'`, `'F'`, `'false'`, `'FALSE'`, `'n'`, `'N'`, `'no'`, `'No'`, `'off'`, `'OFF'` values are converted to `FalseClass`.
+Similarly, the `0`, `"0"`, `"f"`, `"F"`, `"false"`, `"FALSE"`, `"n"`, `"N"`, `"no"`, `"No"`, `"off"`, `"OFF"` values are converted to `FalseClass`.
 
 ```ruby
-Necromancer.convert('no').to(:boolean) # => false
+Necromancer.convert("no").to(:boolean) # => false
 ```
 
 You can also convert an integer object to boolean:
@@ -296,8 +319,8 @@ Necromancer.convert(0).to(:boolean)  # => false
 **Necromancer** knows how to convert string to `date` object:
 
 ```ruby
-Necromancer.convert('1-1-2015').to(:date)    # => "2015-01-01"
-Necromancer.convert('01/01/2015').to(:date)  # => "2015-01-01"
+Necromancer.convert("1-1-2015").to(:date)    # => "2015-01-01"
+Necromancer.convert("01/01/2015").to(:date)  # => "2015-01-01"
 ```
 
 You can also convert string to `datetime`:
@@ -317,9 +340,39 @@ Necromancer.convert("12:35").to(:time)            # => 2015-01-04 12:35:00 +0100
 
 ### 3.4 Hash
 
+With **Necromancer** you can convert a string with pairs delimited by `=` or `:` characters into a hash:
+
+```ruby
+Necromancer.convert("a:1 b:2 c:3").to(:hash)
+Necromancer.convert("a=1 b=2 c=3").to(:hash)
+# => {a: "1", b: "2", c: "3"}
+```
+
+The pairs can be separated by `&` symbols and mix `=` and `:` pair delimiters:
+
+```ruby
+Necromancer.convert("a:1 & b=2 & c:3").to(:hash)
+# => {a: "1", b: "2", c: "3"}
+```
+
+You can also convert string to hash with integer values using `:int_hash` type:
+
+```ruby
+Necromancer.convert("a:1 b:2 c:3").to(:int_hash)     # => {a: 1, b: 2, c: 3}
+Necromancer.convert("a:1 b:2 c:3").to(:integer_hash) # => {a: 1, b: 2, c: 3}
+```
+
+Similarly you can convert string to hash with `float` or `numeric` values using `:float_hash` and `numeric_hash` types:
+
+```ruby
+Necromancer.convert("a:1 b:2 c:3").to(:float_hash)    # => {a: 1.0, b: 2.0, c: 3.0}
+Necromancer.convert("a:1 b:2.0 c:3").to(:num_hash)    # => {a: 1, b:2.0, c: 3}
+```
+
+String can also be converted to hash with boolean values using `:boolean_hash` or `:bool_hash`:
+
 ```ruby
-Necromancer.convert({ x: '27.5', y: '4', z: '11'}).to(:numeric)
-# => { x: 27.5, y: 4, z: 11}
+Necromancer.convert("a:yes b:no c:t").to(:bool_hash)  # => {a: true, b: false, c: true}
 ```
 
 ### 3.5 Numeric
@@ -329,25 +382,25 @@ Necromancer.convert({ x: '27.5', y: '4', z: '11'}).to(:numeric)
 To convert a string to a float do:
 
 ```ruby
-Necromancer.convert('1.2a').to(:float)  #  => 1.2
+Necromancer.convert("1.2a").to(:float)  #  => 1.2
 ```
 
 Conversion to numeric in strict mode raises `Necromancer::ConversionTypeError`:
 
 ```ruby
-Necromancer.convert('1.2a').to(:float, strict: true) # => raises error
+Necromancer.convert("1.2a").to(:float, strict: true) # => raises error
 ```
 
 To convert a string to an integer do:
 
 ```ruby
-Necromancer.convert('1a').to(:integer)  #  => 1
+Necromancer.convert("1a").to(:integer)  #  => 1
 ```
 
 However, if you want to convert string to an appropriate matching numeric type do:
 
 ```ruby
-Necromancer.convert('1e1').to(:numeric)   # => 10
+Necromancer.convert("1e1").to(:numeric)   # => 10
 ```
 
 ### 3.6 Range
@@ -355,15 +408,22 @@ Necromancer.convert('1e1').to(:numeric)   # => 10
 **Necromancer** is no stranger to figuring out ranges from strings. You can pass `,`, `-`, `..`, `...` characters to denote ranges:
 
 ```ruby
-Necromancer.convert('1,10').to(:range)  # => 1..10
+Necromancer.convert("1,10").to(:range)  # => 1..10
 ```
 
-or to create a range of letters:
+Or to create a range of letters:
 
 ```ruby
-Necromancer.convert('a-z').to(:range)   # => 'a'..'z'
+Necromancer.convert("a-z").to(:range)   # => "a".."z"
 ```
 
+It will handle space characters:
+
+```ruby
+Necromancer.convert("1 . . 10") >> :range   # => 1..10
+Necromancer.convert("a . . . z") >> :range  # =>  "a"..."z"
+````
+
 ### 3.7 Custom
 
 In case where provided conversions do not match your needs you can create your own and `register` with **Necromancer** by using an `Object` or a `Proc`.
@@ -398,7 +458,7 @@ converter.register(upcase_converter)   # => true if successfully registered
 Finally, by invoking `convert` method and specifying `:upcase` as the target for the conversion we achieve the result:
 
 ```ruby
-converter.convert('magic').to(:upcase)   # => 'MAGIC'
+converter.convert("magic").to(:upcase)   # => "MAGIC"
 ```
 
 #### 3.7.2 Using a Proc
@@ -418,7 +478,7 @@ end
 Then by invoking the `convert` method and passing the `:upcase` conversion type you can transform the string like so:
 
 ```ruby
-converter.convert('magic').to(:upcase)   # => 'MAGIC'
+converter.convert("magic").to(:upcase)   # => "MAGIC"
 ```
 
 ## Contributing

data/lib/necromancer/context.rb

@@ -19,7 +19,7 @@ module Necromancer
     #
     # @api private
     def initialize(&block)
-      block.call(configuration) if block_given?
+      block.(configuration) if block_given?
       @conversions = Conversions.new(configuration)
       @conversions.load
     end

data/lib/necromancer/conversions.rb

@@ -5,6 +5,7 @@ require_relative "converter"
 require_relative "converters/array"
 require_relative "converters/boolean"
 require_relative "converters/date_time"
+require_relative "converters/hash"
 require_relative "converters/numeric"
 require_relative "converters/range"
 
@@ -34,6 +35,7 @@ module Necromancer
       ArrayConverters.load(self)
       BooleanConverters.load(self)
       DateTimeConverters.load(self)
+      HashConverters.load(self)
       NumericConverters.load(self)
       RangeConverters.load(self)
     end
@@ -76,6 +78,7 @@ module Necromancer
       key = generate_key(converter)
       converter = add_config(converter, @configuration)
       return false if converter_map.key?(key)
+
       converter_map[key] = converter
       true
     end

data/lib/necromancer/converter.rb

@@ -34,9 +34,9 @@ module Necromancer
     # @api private
     def self.create(&block)
       Class.new(self) do
-        define_method(:initialize) { |*a| block.call(self, *a) }
+        define_method(:initialize) { |*a| block.(self, *a) }
 
-        define_method(:call) { |value| convert.call(value) }
+        define_method(:call) { |value| convert.(value) }
       end.new
     end
 
@@ -48,7 +48,7 @@ module Necromancer
     # @api private
     def raise_conversion_type(value)
       raise ConversionTypeError, "'#{value}' could not be converted " \
-                                "from `#{source}` into `#{target}` "
+                                 "from `#{source}` into `#{target}`"
     end
 
     attr_accessor :source
@@ -57,7 +57,7 @@ module Necromancer
 
     attr_accessor :convert
 
-    protected
+   # protected
 
     attr_reader :config
   end # Converter

data/lib/necromancer/converters/array.rb

@@ -3,10 +3,14 @@
 require "set"
 
 require_relative "../converter"
+require_relative "boolean"
+require_relative "numeric"
 
 module Necromancer
   # Container for Array converter classes
   module ArrayConverters
+    ARRAY_MATCHER = /^(.+?(\s*(?<sep>(,|-))\s*))+/x.freeze
+
     # An object that converts a String to an Array
     class StringToArrayConverter < Converter
       # Convert string value to array
@@ -15,24 +19,103 @@ module Necromancer
       #   converter.call("a, b, c")  # => ["a", "b", "c"]
       #
       # @example
-      #   converter.call("1 - 2 - 3")  # => [1, 2, 3]
+      #   converter.call("1 - 2 - 3")  # => ["1", "2", "3"]
       #
       # @api public
-      def call(value, options = {})
-        strict = options.fetch(:strict, config.strict)
-        case value.to_s
-        when /^\s*?((\d+)(\s*(,|-)\s*)?)+\s*?$/
-          value.to_s.split($4).map(&:to_i)
-        when /^((\w)(\s*(,|-)\s*)?)+$/
-          value.to_s.split($4)
+      def call(value, strict: config.strict)
+        return [] if value.to_s.empty?
+
+        if match = value.to_s.match(ARRAY_MATCHER)
+          value.to_s.split(match[:sep])
         else
           strict ? raise_conversion_type(value) : Array(value)
         end
       end
     end
 
+    class StringToBooleanArrayConverter < Converter
+      # @example
+      #   converter.call("t,f,yes,no") # => [true, false, true, false]
+      #
+      # @param [Array] value
+      #   the array value to boolean
+      #
+      # @api public
+      def call(value, strict: config.strict)
+        array_converter = StringToArrayConverter.new(:string, :array)
+        array = array_converter.(value, strict: strict)
+        bool_converter = ArrayToBooleanArrayConverter.new(:array, :boolean)
+        bool_converter.(array, strict: strict)
+      end
+    end
+
+    class StringToIntegerArrayConverter < Converter
+      # @example
+      #   converter.call("1,2,3") # => [1, 2, 3]
+      #
+      # @api public
+      def call(string, strict: config.strict)
+        array_converter = StringToArrayConverter.new(:string, :array)
+        array = array_converter.(string, strict: strict)
+        int_converter = ArrayToIntegerArrayConverter.new(:array, :integers)
+        int_converter.(array, strict: strict)
+      end
+    end
+
+    class StringToFloatArrayConverter < Converter
+      # @example
+      #   converter.call("1,2,3") # => [1.0, 2.0, 3.0]
+      #
+      # @api public
+      def call(string, strict: config.strict)
+        array_converter = StringToArrayConverter.new(:string, :array)
+        array = array_converter.(string, strict: strict)
+        float_converter = ArrayToFloatArrayConverter.new(:array, :floats)
+        float_converter.(array, strict: strict)
+      end
+    end
+
+    class StringToNumericArrayConverter < Converter
+      # Convert string value to array with numeric values
+      #
+      # @example
+      #   converter.call("1,2.0,3") # => [1, 2.0, 3]
+      #
+      # @api public
+      def call(string, strict: config.strict)
+        array_converter = StringToArrayConverter.new(:string, :array)
+        array = array_converter.(string, strict: strict)
+        num_converter = ArrayToNumericArrayConverter.new(:array, :numeric)
+        num_converter.(array, strict: strict)
+      end
+    end
+
+    class ArrayToIntegerArrayConverter < Converter
+      # @example
+      #   converter.call(["1", "2", "3"]) # => [1, 2, 3]
+      #
+      # @api public
+      def call(array, strict: config.strict)
+        int_converter = NumericConverters::StringToIntegerConverter.new(:string,
+                                                                        :integer)
+        array.map { |val| int_converter.(val, strict: strict) }
+      end
+    end
+
+    class ArrayToFloatArrayConverter < Converter
+      # @example
+      #   converter.call(["1", "2", "3"]) # => [1.0, 2.0, 3.0]
+      #
+      # @api public
+      def call(array, strict: config.strict)
+        float_converter = NumericConverters::StringToFloatConverter.new(:string,
+                                                                        :float)
+        array.map { |val| float_converter.(val, strict: strict) }
+      end
+    end
+
     # An object that converts an array to an array with numeric values
-    class ArrayToNumericConverter < Converter
+    class ArrayToNumericArrayConverter < Converter
       # Convert an array to an array of numeric values
       #
       # @example
@@ -42,16 +125,15 @@ module Necromancer
       #   the value to convert
       #
       # @api public
-      def call(value, options = {})
-        numeric_converter = NumericConverters::StringToNumericConverter.new(:string, :numeric)
-        value.reduce([]) do |acc, el|
-          acc << numeric_converter.call(el, **options)
-        end
+      def call(value, strict: config.strict)
+        num_converter = NumericConverters::StringToNumericConverter.new(:string,
+                                                                        :numeric)
+        value.map { |val| num_converter.(val, strict: strict) }
       end
     end
 
     # An object that converts an array to an array with boolean values
-    class ArrayToBooleanConverter < Converter
+    class ArrayToBooleanArrayConverter < Converter
       # @example
       #   converter.call(["t", "f", "yes", "no"]) # => [true, false, true, false]
       #
@@ -59,11 +141,10 @@ module Necromancer
       #   the array value to boolean
       #
       # @api public
-      def call(value, options = {})
-        boolean_converter = BooleanConverters::StringToBooleanConverter.new(:string, :boolean)
-        value.reduce([]) do |acc, el|
-          acc << boolean_converter.call(el, options)
-        end
+      def call(value, strict: config.strict)
+        bool_converter = BooleanConverters::StringToBooleanConverter.new(:string,
+                                                                         :boolean)
+        value.map { |val| bool_converter.(val, strict: strict) }
       end
     end
 
@@ -75,13 +156,10 @@ module Necromancer
       #   converter.call({x: 1})   # => [[:x, 1]]
       #
       # @api public
-      def call(value, options = {})
-        strict = options.fetch(:strict, config.strict)
-        begin
-          Array(value)
-        rescue
-          strict ? raise_conversion_type(value) : value
-        end
+      def call(value, strict: config.strict)
+        Array(value)
+      rescue StandardError
+        strict ? raise_conversion_type(value) : value
       end
     end
 
@@ -96,23 +174,39 @@ module Necromancer
       #   the array to convert
       #
       # @api public
-      def call(value, options = {})
-        strict = options.fetch(:strict, config.strict)
-        begin
-          value.to_set
-        rescue
-          strict ? raise_conversion_type(value) : value
-        end
+      def call(value, strict: config.strict)
+        value.to_set
+      rescue StandardError
+        strict ? raise_conversion_type(value) : value
       end
     end
 
     def self.load(conversions)
-      conversions.register NullConverter.new(:array, :array)
-      conversions.register StringToArrayConverter.new(:string, :array)
-      conversions.register ArrayToNumericConverter.new(:array, :numeric)
-      conversions.register ArrayToBooleanConverter.new(:array, :boolean)
-      conversions.register ObjectToArrayConverter.new(:object, :array)
-      conversions.register ObjectToArrayConverter.new(:hash, :array)
+      [
+        NullConverter.new(:array, :array),
+
+        StringToArrayConverter.new(:string, :array),
+        StringToBooleanArrayConverter.new(:string, :bools),
+        StringToBooleanArrayConverter.new(:string, :booleans),
+        StringToIntegerArrayConverter.new(:string, :integers),
+        StringToIntegerArrayConverter.new(:string, :ints),
+        StringToFloatArrayConverter.new(:string, :floats),
+        StringToNumericArrayConverter.new(:string, :numerics),
+        StringToNumericArrayConverter.new(:string, :nums),
+
+        ArrayToNumericArrayConverter.new(:array, :numerics),
+        ArrayToNumericArrayConverter.new(:array, :nums),
+        ArrayToIntegerArrayConverter.new(:array, :integers),
+        ArrayToIntegerArrayConverter.new(:array, :ints),
+        ArrayToFloatArrayConverter.new(:array, :floats),
+        ArrayToBooleanArrayConverter.new(:array, :booleans),
+        ArrayToBooleanArrayConverter.new(:array, :bools),
+
+        ObjectToArrayConverter.new(:object, :array),
+        ObjectToArrayConverter.new(:hash, :array)
+      ].each do |converter|
+        conversions.register converter
+      end
     end
   end # ArrayConverters
 end # Necromancer

data/lib/necromancer/converters/boolean.rb

@@ -29,8 +29,7 @@ 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
@@ -50,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 ? raise_conversion_type(value) : value
-        end
+      def call(value, strict: config.strict)
+        !value.zero?
+      rescue StandardError
+        strict ? raise_conversion_type(value) : value
       end
     end
 
@@ -71,8 +67,7 @@ module Necromancer
       #   converter.call(false)  # => 0
       #
       # @api public
-      def call(value, options = {})
-        strict = options.fetch(:strict, config.strict)
+      def call(value, strict: config.strict)
         if %w[TrueClass FalseClass].include?(value.class.name)
           value ? 1 : 0
         else
@@ -82,10 +77,14 @@ module Necromancer
     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

@@ -20,10 +20,9 @@ module Necromancer
       #   converter.call("12/11/2015")  # => "2015-11-12"
       #
       # @api public
-      def call(value, options = {})
-        strict = options.fetch(:strict, config.strict)
+      def call(value, strict: config.strict)
         Date.parse(value)
-      rescue
+      rescue StandardError
         strict ? raise_conversion_type(value) : value
       end
     end
@@ -37,10 +36,9 @@ module Necromancer
       #  converer.call("1-1-2015 15:12:44")  # => "2015-01-01T15:12:44+00:00"
       #
       # @api public
-      def call(value, options = {})
-        strict = options.fetch(:strict, config.strict)
+      def call(value, strict: config.strict)
         DateTime.parse(value)
-      rescue
+      rescue StandardError
         strict ? raise_conversion_type(value) : value
       end
     end
@@ -57,21 +55,24 @@ module Necromancer
       #   converter.call("12:35")            # => 2015-01-04 12:35:00 +0100
       #
       # @api public
-      def call(value, options = {})
-        strict = options.fetch(:strict, config.strict)
+      def call(value, strict: config.strict)
         Time.parse(value)
-      rescue
+      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)
-      conversions.register StringToTimeConverter.new(:string, :time)
-      conversions.register NullConverter.new(:time, :time)
+      [
+        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

@@ -6,9 +6,9 @@ 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
@@ -18,10 +18,9 @@ module Necromancer
       #   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
+      rescue StandardError
         strict ? raise_conversion_type(value) : value.to_i
       end
     end
@@ -47,10 +46,9 @@ module Necromancer
       #   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
+      rescue StandardError
         strict ? raise_conversion_type(value) : value.to_f
       end
     end
@@ -66,13 +64,12 @@ module Necromancer
       #   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 ? raise_conversion_type(value) : value
         end
@@ -80,12 +77,16 @@ module Necromancer
     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

@@ -6,11 +6,17 @@ 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
@@ -25,24 +31,41 @@ module Necromancer
       #   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 ? 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

data/lib/necromancer/null_converter.rb

@@ -5,7 +5,7 @@ require_relative "converter"
 module Necromancer
   # A pass through converter
   class NullConverter < Converter
-    def call(value, **options)
+    def call(value, strict: config.strict)
       value
     end
   end # NullConverter

data/lib/necromancer/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Necromancer
-  VERSION = "0.6.0"
+  VERSION = "0.7.0"
 end # Necromancer

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: necromancer
 version: !ruby/object:Gem::Version
-  version: 0.6.0
+  version: 0.7.0
 platform: ruby
 authors:
 - Piotr Murach
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-03-08 00:00:00.000000000 Z
+date: 2020-12-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -28,14 +28,14 @@ dependencies:
   name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: '3.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: '3.0'
 description: Conversion from one object type to another with a bit of black magic.
@@ -60,6 +60,7 @@ files:
 - lib/necromancer/converters/array.rb
 - lib/necromancer/converters/boolean.rb
 - lib/necromancer/converters/date_time.rb
+- lib/necromancer/converters/hash.rb
 - lib/necromancer/converters/numeric.rb
 - lib/necromancer/converters/range.rb
 - lib/necromancer/null_converter.rb
@@ -88,7 +89,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.2
+rubygems_version: 3.2.3
 signing_key: 
 specification_version: 4
 summary: Conversion from one object type to another with a bit of black magic.