necromancer 0.1.0 → 0.2.0

data/lib/necromancer/converters/boolean.rb

@@ -1,10 +1,14 @@
 # coding: utf-8
 
 module Necromancer
+  # Container for Boolean converter classes
   module BooleanConverters
+    TRUE_MATCHER = /^(yes|y|on|t(rue)?|1)$/i.freeze
+
+    FALSE_MATCHER = /^(no|n|off|f(alse)?|0)$/i.freeze
+
     # An object that converts a String to a Boolean
     class StringToBooleanConverter < Converter
-
       # Convert value to boolean type including range of strings
       #
       # @param [Object] value
@@ -19,32 +23,58 @@ module Necromancer
       #   converter.call("False") # => false
       #
       #  other values coerced to false are:
-      #    0, f, F, FALSE, false, False, n, N, NO,  no,  No, on, ON
+      #    0, f, F, FALSE, false, False, n, N, NO,  no,  No, off, OFF
       #
       # @api public
       def call(value, options = {})
+        strict = options.fetch(:strict, false)
         case value.to_s
-        when /^(yes|y|on|t(rue)?|1)$/i
-          return true
-        when /^(no|n|off|f(alse)?|0)$/i
-          return false
-        else
-          fail ArgumentError, "Expected boolean type, got #{value}"
+        when TRUE_MATCHER then true
+        when FALSE_MATCHER then false
+        else strict ? fail_conversion_type(value) : value
         end
       end
     end
 
     # An object that converts an Integer to a Boolean
     class IntegerToBooleanConverter < Converter
+      # Convert integer to boolean
+      #
+      # @example
+      #   converter.call(1)  # => true
+      #
+      # @example
+      #   converter.call(0)  # => false
+      #
+      # @api public
       def call(value, options = {})
-        !value.zero?
+        strict = options.fetch(:strict, false)
+        begin
+          !value.zero?
+        rescue
+          strict ?  fail_conversion_type(value) : value
+        end
       end
     end
 
     # An object that converts a Boolean to an Integer
     class BooleanToIntegerConverter < Converter
+      # Convert boolean to integer
+      #
+      # @example
+      #   converter.call(true)   # => 1
+      #
+      # @example
+      #   converter.call(false)  # => 0
+      #
+      # @api public
       def call(value, options = {})
-        value ? 1 : 0
+        strict = options.fetch(:strict, false)
+        if ['TrueClass', 'FalseClass'].include?(value.class.name)
+          value ? 1 : 0
+        else
+          strict ? fail_conversion_type(value) : value
+        end
       end
     end
 

data/lib/necromancer/converters/date_time.rb

@@ -0,0 +1,33 @@
+# coding: utf-8
+
+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, false)
+        Date.parse(value)
+      rescue
+        strict ? fail_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, false)
+        DateTime.parse(value)
+      rescue
+        strict ? fail_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)
+    end
+  end # DateTimeConverters
+end # Necromancer

data/lib/necromancer/converters/numeric.rb

@@ -0,0 +1,88 @@
+# coding: utf-8
+
+module Necromancer
+  # Container for Numeric converter classes
+  module NumericConverters
+    INTEGER_MATCHER = /^[-+]?(\d+)$/.freeze
+
+    FLOAT_MATCHER = /^[-+]?(\d*)(\.\d+)?([eE]?[-+]?\d+)?$/.freeze
+
+    # An object that converts a String to an Integer
+    class StringToIntegerConverter < Converter
+      # Convert string value to integer
+      #
+      # @example
+      #   converter.call('1abc')  # => 1
+      #
+      # @api public
+      def call(value, options = {})
+        strict = options.fetch(:strict, false)
+        Integer(value)
+      rescue
+        strict ? fail_conversion_type(value) : value.to_i
+      end
+    end
+
+    # An object that converts an Integer to a String
+    class IntegerToStringConverter < Converter
+      # Convert integer value to string
+      #
+      # @example
+      #   converter.call(1)  # => '1'
+      #
+      # @api public
+      def call(value, _)
+        value.to_s
+      end
+    end
+
+    # An object that converts a String to a Float
+    class StringToFloatConverter < Converter
+      # Convert string to float value
+      #
+      # @example
+      #   converter.call('1.2') # => 1.2
+      #
+      # @api public
+      def call(value, options = {})
+        strict = options.fetch(:strict, false)
+        Float(value)
+      rescue
+        strict ? fail_conversion_type(value) : value.to_f
+      end
+    end
+
+    # An object that converts a String to a Numeric
+    class StringToNumericConverter < Converter
+      # Convert string to numeric value
+      #
+      # @example
+      #   converter.call('1.0')  # => 1.0
+      #
+      # @example
+      #   converter.call('1')   # => 1
+      #
+      # @api public
+      def call(value, options = {})
+        strict = options.fetch(:strict, false)
+        case value
+        when INTEGER_MATCHER
+          StringToIntegerConverter.new(:string, :integer).call(value, options)
+        when FLOAT_MATCHER
+          StringToFloatConverter.new(:string, :float).call(value, options)
+        else
+          strict ? fail_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)
+    end
+  end # Conversion
+end # Necromancer

data/lib/necromancer/converters/range.rb

@@ -3,6 +3,12 @@
 module Necromancer
   # Container for Range converter classes
   module RangeConverters
+    SINGLE_DIGIT_MATCHER = /^(\-?\d+)$/.freeze
+
+    DIGIT_MATCHER = /^(-?\d+?)(\.{2}\.?|-|,)(-?\d+)$/.freeze
+
+    LETTER_MATCHER = /^(\w)(\.{2}\.?|-|,)(\w)$/.freeze
+
     # An object that converts a String to a Range
     class StringToRangeConverter < Converter
       # Convert value to Range type with possible ranges
@@ -17,22 +23,23 @@ module Necromancer
       #
       # @api public
       def call(value, options = {})
-        case value.to_s
-        when /\A(\-?\d+)\Z/
+        strict = options.fetch(:strict, false)
+        case value
+        when SINGLE_DIGIT_MATCHER
           ::Range.new($1.to_i, $1.to_i)
-        when /\A(-?\d+?)(\.{2}\.?|-|,)(-?\d+)\Z/
+        when DIGIT_MATCHER
           ::Range.new($1.to_i, $3.to_i, $2 == '...')
-        when /\A(\w)(\.{2}\.?|-|,)(\w)\Z/
+        when LETTER_MATCHER
           ::Range.new($1.to_s, $3.to_s, $2 == '...')
         else
-          fail ConversionTypeError, "#{value} could not be converted " \
-                                    "from #{source} into Range type"
+          strict ? fail_conversion_type(value) : value
         end
       end
     end
 
     def self.load(conversions)
       conversions.register StringToRangeConverter.new(:string, :range)
+      conversions.register NullConverter.new(:range, :range)
     end
   end # RangeConverters
 end # Necromancer

data/lib/necromancer/version.rb

@@ -1,5 +1,5 @@
 # coding: utf-8
 
 module Necromancer
-  VERSION = "0.1.0"
+  VERSION = "0.2.0"
 end # Necromancer

data/spec/spec_helper.rb

@@ -42,4 +42,12 @@ RSpec.configure do |config|
   config.order = :random
 
   Kernel.srand config.seed
+
+  config.before :each do
+    [:UpcaseConverter].each do |class_name|
+      if Object.const_defined?(class_name)
+        Object.send(:remove_const, class_name)
+      end
+    end
+  end
 end

data/spec/unit/convert_spec.rb

@@ -6,7 +6,7 @@ RSpec.describe Necromancer, '.convert' do
 
   subject(:converter) { described_class.new }
 
-  context 'when integer' do
+  context 'when numeric' do
     it "converts string to integer" do
       expect(converter.convert('1').to(:integer)).to eq(1)
     end
@@ -28,6 +28,18 @@ RSpec.describe Necromancer, '.convert' do
         converter.convert('1a').to(:integer, strict: true)
       }.to raise_error(Necromancer::ConversionTypeError)
     end
+
+    it "doesn't raise error when in non-strict mode" do
+      expect(converter.convert('1').to(:integer, strict: false)).to eql(1)
+    end
+
+    it "converts string to float" do
+      expect(converter.convert('1.0').to(:float)).to eql(1.0)
+    end
+
+    it "converts string to numeric" do
+      expect(converter.convert('1.0').to(:numeric)).to eql(1.0)
+    end
   end
 
   context 'when boolean' do
@@ -62,5 +74,23 @@ RSpec.describe Necromancer, '.convert' do
     it "converts array to numeric " do
       expect(converter.convert(['1','2.3','3.0']).to(:numeric)).to eq([1,2.3,3.0])
     end
+
+    it "fails to convert in strict mode" do
+      expect {
+        converter.convert(['1', '2.3', false]).to(:numeric, strict: true)
+      }.to raise_error(Necromancer::ConversionTypeError)
+    end
+  end
+
+  context 'when datetime' do
+    it "converts string to date" do
+      expect(converter.convert('2014-12-07').to(:date)).
+        to eq(Date.parse('2014-12-07'))
+    end
+
+    it "converts string to datetime" do
+      expect(converter.convert('2014-12-07 17:35:44').to(:datetime)).
+        to eq(DateTime.parse('2014-12-07 17:35:44'))
+    end
   end
 end

data/spec/unit/converters/array/string_to_array_spec.rb

@@ -3,7 +3,17 @@
 require 'spec_helper'
 
 RSpec.describe Necromancer::ArrayConverters::StringToArrayConverter, '.call' do
-  subject(:converter) { described_class.new }
+  subject(:converter) { described_class.new(:string, :array) }
+
+  it "converts empty string to array" do
+    expect(converter.call('', strict: false)).to eq([''])
+  end
+
+  it "fails to convert empty string to array in strict mode" do
+    expect {
+      converter.call('', strict: true)
+    }.to raise_error(Necromancer::ConversionTypeError)
+  end
 
   it "converts `1,2,3` to array" do
     expect(converter.call('1,2,3')).to eq([1,2,3])
@@ -12,4 +22,12 @@ RSpec.describe Necromancer::ArrayConverters::StringToArrayConverter, '.call' do
   it "converts `a,b,c` to array" do
     expect(converter.call('a,b,c')).to eq(['a','b','c'])
   end
+
+  it "converts '1-2-3' to array" do
+    expect(converter.call('1-2-3')).to eq([1,2,3])
+  end
+
+  it "converts ' 1 - 2 - 3 ' to array" do
+    expect(converter.call('  1 - 2 - 3 ')).to eq([1,2,3])
+  end
 end

data/spec/unit/converters/boolean/boolean_to_integer_spec.rb

@@ -13,4 +13,14 @@ RSpec.describe Necromancer::BooleanConverters::BooleanToIntegerConverter, '.call
   it "converts false to 0 value" do
     expect(converter.call(false)).to eq(0)
   end
+
+  it "fails to convert in strict mode" do
+    expect {
+      converter.call('unknown', strict: true)
+    }.to raise_error(Necromancer::ConversionTypeError)
+  end
+
+  it "returns value in non-strict mode" do
+    expect(converter.call('unknown', strict: false)).to eq('unknown')
+  end
 end

data/spec/unit/converters/boolean/integer_to_boolean_spec.rb

@@ -13,4 +13,10 @@ RSpec.describe Necromancer::BooleanConverters::IntegerToBooleanConverter, '.call
   it "converts 0 to false value" do
     expect(converter.call(0)).to eq(false)
   end
+
+  it "fails to convert in strict mode" do
+    expect  {
+      converter.call('1', strict: true)
+    }.to raise_error(Necromancer::ConversionTypeError)
+  end
 end

data/spec/unit/converters/boolean/string_to_boolean_spec.rb

@@ -4,93 +4,33 @@ require 'spec_helper'
 
 RSpec.describe Necromancer::BooleanConverters::StringToBooleanConverter, '.call' do
 
-  subject(:converter) { described_class.new }
+  subject(:converter) { described_class.new(:string, :boolean) }
 
-  it "raises error for empty string" do
-    expect { converter.call('') }.to raise_error(ArgumentError)
+  it "raises error for empty string strict mode" do
+    expect {
+      converter.call('', strict: true)
+    }.to raise_error(Necromancer::ConversionTypeError)
   end
 
-  it "passes through boolean value" do
-    expect(converter.call(true)).to eq(true)
-  end
-
-  it "converts 'true' to true value" do
-    expect(converter.call('true')).to eq(true)
-  end
-
-  it "converts 'TRUE' to true value" do
-    expect(converter.call('TRUE')).to eq(true)
-  end
-
-  it "converts TRUE to true value" do
-    expect(converter.call(TRUE)).to eq(true)
-  end
-
-  it "converts 't' to true value" do
-    expect(converter.call('t')).to eq(true)
-  end
-
-  it "converts 'T' to true value" do
-    expect(converter.call('T')).to eq(true)
-  end
-
-  it "converts 1 to true value" do
-    expect(converter.call(1)).to eq(true)
-  end
-
-  it "converts '1' to true value" do
-    expect(converter.call('1')).to eq(true)
-  end
-
-  it "converts 'y' to true value" do
-    expect(converter.call('y')).to eq(true)
-  end
-
-  it "converts 'yes' to true value" do
-    expect(converter.call('yes')).to eq(true)
-  end
-
-  it "converts 'on' to true value" do
-    expect(converter.call('on')).to eq(true)
-  end
-
-  it "converts 'false' to false value" do
-    expect(converter.call('false')).to eq(false)
-  end
-
-  it "converts FALSE to false value" do
-    expect(converter.call(FALSE)).to eq(false)
-  end
-
-  it "converts 'FALSE' to false value" do
-    expect(converter.call('FALSE')).to eq(false)
-  end
-
-  it "converts 'f' to false value" do
-    expect(converter.call('f')).to eq(false)
-  end
-
-  it "converts 'F' to false value" do
-    expect(converter.call('F')).to eq(false)
-  end
-
-  it "converts '0' to false value" do
-    expect(converter.call('0')).to eq(false)
-  end
-
-  it "converts 'n' to false value" do
-    expect(converter.call('n')).to eq(false)
+  it "fails to convert unkonwn value FOO" do
+    expect {
+      converter.call('FOO', strict: true)
+    }.to raise_error(Necromancer::ConversionTypeError)
   end
 
-  it "converts 'no' to false value" do
-    expect(converter.call('no')).to eq(false)
+  it "passes through boolean value" do
+    expect(converter.call(true)).to eq(true)
   end
 
-  it "converts 'off' to false value" do
-    expect(converter.call('off')).to eq(false)
+  %w[true TRUE t T 1 y Y YES yes on ON].each do |value|
+    it "converts '#{value}' to true value" do
+      expect(converter.call(value)).to eq(true)
+    end
   end
 
-  it "fails to convert unkonwn value FOO" do
-    expect { converter.call('FOO') }.to raise_error(ArgumentError)
+  %w[false FALSE f F 0 n N NO No no off OFF].each do |value|
+    it "converts '#{value}' to false value" do
+      expect(converter.call(value)).to eq(false)
+    end
   end
 end