necromancer 0.3.0 → 0.7.0

data/lib/necromancer.rb

@@ -1,21 +1,7 @@
-# coding: utf-8
+# frozen_string_literal: true
 
-require 'forwardable'
-require 'date'
-require 'set'
-
-require 'necromancer/conversions'
-require 'necromancer/configuration'
-require 'necromancer/context'
-require 'necromancer/converter'
-require 'necromancer/null_converter'
-require 'necromancer/converters/array'
-require 'necromancer/converters/boolean'
-require 'necromancer/converters/date_time'
-require 'necromancer/converters/numeric'
-require 'necromancer/converters/range'
-require 'necromancer/conversion_target'
-require 'necromancer/version'
+require_relative "necromancer/context"
+require_relative "necromancer/version"
 
 module Necromancer
   # Raised when cannot conver to a given type
@@ -35,6 +21,19 @@ module Necromancer
   def new(&block)
     Context.new(&block)
   end
-
   module_function :new
+
+  # Convenience to directly call conversion
+  #
+  # @example
+  #   Necromancer.convert("1").to(:integer)
+  #   # => 1
+  #
+  # @return [ConversionTarget]
+  #
+  # @api public
+  def convert(*args, &block)
+    Context.new.convert(*args, &block)
+  end
+  module_function :convert
 end # Necromancer

data/lib/necromancer/configuration.rb

@@ -1,4 +1,4 @@
-# coding: utf-8
+# frozen_string_literal: true
 
 module Necromancer
   # A global configuration for converters.

data/lib/necromancer/context.rb

@@ -1,4 +1,10 @@
-# coding: utf-8
+# frozen_string_literal: true
+
+require "forwardable"
+
+require_relative "configuration"
+require_relative "conversions"
+require_relative "conversion_target"
 
 module Necromancer
   # A class used by Necromancer to provide user interace
@@ -13,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
@@ -47,7 +53,7 @@ module Necromancer
     end
 
     # Converts the object
-    # @param [Object] value
+    # @param [Object] object
     #   any object to be converted
     #
     # @api public
@@ -71,6 +77,13 @@ module Necromancer
       false
     end
 
+    # Inspect this context
+    #
+    # @api public
+    def inspect
+      %(#<#{self.class}@#{object_id} @config=#{configuration}>)
+    end
+
     protected
 
     attr_reader :conversions

data/lib/necromancer/conversion_target.rb

@@ -1,4 +1,4 @@
-# coding: utf-8
+# frozen_string_literal: true
 
 module Necromancer
   # A class responsible for wrapping conversion target
@@ -19,13 +19,13 @@ module Necromancer
     def self.for(context, value, block)
       if UndefinedValue.equal?(value)
         unless block
-          fail ArgumentError,
-               'You need to pass either argument or a block to `convert`.'
+          raise ArgumentError,
+                "You need to pass either argument or a block to `convert`."
         end
         new(context, block.call)
       elsif block
-        fail ArgumentError,
-             'You cannot pass both an argument and a block to `convert`.'
+        raise ArgumentError,
+              "You cannot pass both an argument and a block to `convert`."
       else
         new(context, value)
       end
@@ -34,7 +34,7 @@ module Necromancer
     # Allows to specify conversion source type
     #
     # @example
-    #   converter.convert('1').from(:string).to(:numeric)  # => 1
+    #   converter.convert("1").from(:string).to(:numeric)  # => 1
     #
     # @return [ConversionType]
     #
@@ -47,29 +47,46 @@ module Necromancer
     # Runs a given conversion
     #
     # @example
-    #   converter.convert('1').to(:numeric)  # => 1
+    #   converter.convert("1").to(:numeric)  # => 1
+    #
+    # @example
+    #   converter.convert("1") >> Integer # => 1
     #
     # @return [Object]
     #   the converted target type
     #
     # @api public
     def to(target, options = {})
-      conversion = conversions[source || detect(object), detect(target)]
-      conversion.call(object, options)
+      conversion = conversions[source || detect(object, false), detect(target)]
+      conversion.call(object, **options)
+    end
+    alias >> to
+
+    # Inspect this conversion
+    #
+    # @api public
+    def inspect
+      %(#<#{self.class}@#{object_id} @object=#{object}, @source=#{detect(object)}>)
     end
 
     protected
 
-    # Detect object type
+    # Detect object type and coerce into known key type
+    #
+    # @param [Object] object
     #
     # @api private
-    def detect(object)
+    def detect(object, symbol_as_object = true)
       case object
       when TrueClass, FalseClass then :boolean
-      when Fixnum, Bignum then :integer
-      when Symbol then object
+      when Integer then :integer
+      when Class   then object.name.downcase
       else
-        object.class.name.downcase
+        if object.is_a?(Symbol) && symbol_as_object
+          object
+        else
+          object.class.name.downcase
+        end
       end
     end
 

data/lib/necromancer/conversions.rb

@@ -1,4 +1,13 @@
-# coding: utf-8
+# frozen_string_literal: true
+
+require_relative "configuration"
+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"
 
 module Necromancer
   # Represents the context used to configure various converters
@@ -6,7 +15,7 @@ module Necromancer
   #
   # @api public
   class Conversions
-    DELIMITER = '->'.freeze
+    DELIMITER = "->"
 
     # Creates a new conversions map
     #
@@ -14,9 +23,9 @@ module Necromancer
     #   conversion = Necromancer::Conversions.new
     #
     # @api public
-    def initialize(configuration = Configuration.new)
+    def initialize(configuration = Configuration.new, map = {})
       @configuration = configuration
-      @converter_map = {}
+      @converter_map = map.dup
     end
 
     # Load converters
@@ -26,6 +35,7 @@ module Necromancer
       ArrayConverters.load(self)
       BooleanConverters.load(self)
       DateTimeConverters.load(self)
+      HashConverters.load(self)
       NumericConverters.load(self)
       RangeConverters.load(self)
     end
@@ -45,22 +55,22 @@ module Necromancer
     def [](source, target)
       key = "#{source}#{DELIMITER}#{target}"
       converter_map[key] ||
-      converter_map["object->#{target}"] ||
-      fail_no_type_conversion_available(key)
+        converter_map["object#{DELIMITER}#{target}"] ||
+        raise_no_type_conversion_available(key)
     end
+    alias fetch []
 
-    # Fail with conversion error
+    # Register a converter
     #
-    # @api private
-    def fail_no_type_conversion_available(key)
-      fail NoTypeConversionAvailableError, "Conversion '#{key}' unavailable."
-    end
-
     # @example with simple object
-    #
+    #   conversions.register NullConverter.new(:array, :array)
     #
     # @example with block
-    #
+    #   conversions.register do |c|
+    #     c.source = :array
+    #     c.target = :array
+    #     c.convert = -> { |val, options| val }
+    #   end
     #
     # @api public
     def register(converter = nil, &block)
@@ -68,21 +78,34 @@ module Necromancer
       key = generate_key(converter)
       converter = add_config(converter, @configuration)
       return false if converter_map.key?(key)
+
       converter_map[key] = converter
       true
     end
 
+    # Export all the conversions as hash
+    #
+    # @return [Hash[String, String]]
+    #
+    # @api public
     def to_hash
       converter_map.dup
     end
 
     protected
 
+    # Fail with conversion error
+    #
+    # @api private
+    def raise_no_type_conversion_available(key)
+      raise NoTypeConversionAvailableError, "Conversion '#{key}' unavailable."
+    end
+
     # @api private
     def generate_key(converter)
       parts = []
-      parts << (converter.source ? converter.source.to_s : 'none')
-      parts << (converter.target ? converter.target.to_s : 'none')
+      parts << (converter.source ? converter.source.to_s : "none")
+      parts << (converter.target ? converter.target.to_s : "none")
       parts.join(DELIMITER)
     end
 

data/lib/necromancer/converter.rb

@@ -1,4 +1,6 @@
-# coding: utf-8
+# frozen_string_literal: true
+
+require_relative "configuration"
 
 module Necromancer
   # Abstract converter used internally as a base for other converters
@@ -24,7 +26,7 @@ module Necromancer
     #
     # @api private
     def call(*)
-      fail NotImplementedError
+      raise NotImplementedError
     end
 
     # Creates anonymous converter
@@ -32,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
 
@@ -44,9 +46,9 @@ module Necromancer
     #   the value that cannot be converted
     #
     # @api private
-    def fail_conversion_type(value)
-      fail ConversionTypeError, "'#{value}' could not be converted " \
-                                "from `#{source}` into `#{target}` "
+    def raise_conversion_type(value)
+      raise ConversionTypeError, "'#{value}' could not be converted " \
+                                 "from `#{source}` into `#{target}`"
     end
 
     attr_accessor :source
@@ -55,7 +57,7 @@ module Necromancer
 
     attr_accessor :convert
 
-    protected
+   # protected
 
     attr_reader :config
   end # Converter

data/lib/necromancer/converters/array.rb

@@ -1,65 +1,150 @@
-# coding: utf-8
+# frozen_string_literal: true
+
+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
       #
       # @example
-      #   converter.call('a, b, c')  # => ['a', 'b', 'c']
+      #   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 ? fail_conversion_type(value) : Array(value)
+          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
-      #   converter.call(['1', '2.3', '3.0])  # => [1, 2.3, 3.0]
+      #   converter.call(["1", "2.3", "3.0])  # => [1, 2.3, 3.0]
       #
       # @param [Array] value
       #   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]
+      #   converter.call(["t", "f", "yes", "no"]) # => [true, false, true, false]
       #
       # @param [Array] value
       #   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
 
@@ -71,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 ? fail_conversion_type(value) : value
-        end
+      def call(value, strict: config.strict)
+        Array(value)
+      rescue StandardError
+        strict ? raise_conversion_type(value) : value
       end
     end
 
@@ -92,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 ? fail_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