necromancer 0.1.0

data/lib/necromancer/converter.rb

@@ -0,0 +1,37 @@
+# coding: utf-8
+
+module Necromancer
+  # Abstract converter used internally as a base for other converters
+  #
+  # @api private
+  class Converter
+    def initialize(source = nil, target = nil)
+      @source = source if source
+      @target = target if target
+    end
+
+    # Run converter
+    #
+    # @api private
+    def call(*)
+      fail NotImplementedError
+    end
+
+    # Creates anonymous converter
+    #
+    # @api private
+    def self.create(&block)
+      Class.new(self) do
+        define_method(:initialize) { |*a| block.call(self, *a) }
+
+        define_method(:call) { |value| convert.call(value) }
+      end.new
+    end
+
+    attr_accessor :source
+
+    attr_accessor :target
+
+    attr_accessor :convert
+  end # Converter
+end # Necromancer

data/lib/necromancer/converters/array.rb

@@ -0,0 +1,50 @@
+# coding: utf-8
+
+module Necromancer
+  module ArrayConverters
+    class StringToArrayConverter < Converter
+
+      # @example
+      #   converter.call('1,2,3')  # => ['1', '2', '3']
+      #
+      # @api public
+      def call(value, options = {})
+        case value.to_s
+        when /^((\d+)(\s*(,)\s*)?)+$/
+          value.to_s.split($4).map(&:to_i)
+        when /^((\w)(\s*,\s*)?)+$/
+          value.to_s.split(',')
+        else
+          fail ConversionTypeError, "#{value} could not be converted " \
+                                    "from #{source} into `#{target}`"
+        end
+      end
+    end
+
+    class ArrayToNumericConverter < Converter
+      def call(value, options = {})
+        strict = options.fetch(:strict, false)
+        value.reduce([]) do |acc, el|
+          acc << case el.to_s
+          when /^\d+\.\d+$/
+            el.to_f
+          when /^\d+$/
+            el.to_i
+          else
+            if strict
+              raise ConversionTypeError, "#{value} could not be converted " \
+                                        " from `#{source}` into `#{target}`"
+            else
+              el
+            end
+          end
+        end
+      end
+    end
+
+    def self.load(conversions)
+      conversions.register StringToArrayConverter.new(:string, :array)
+      conversions.register ArrayToNumericConverter.new(:array, :numeric)
+    end
+  end # ArrayConverters
+end # Necromancer

data/lib/necromancer/converters/boolean.rb

@@ -0,0 +1,58 @@
+# coding: utf-8
+
+module Necromancer
+  module BooleanConverters
+    # An object that converts a String to a Boolean
+    class StringToBooleanConverter < Converter
+
+      # Convert value to boolean type including range of strings
+      #
+      # @param [Object] value
+      #
+      # @example
+      #   converter.call("True") # => true
+      #
+      #   other values converted to true are:
+      #     1, t, T, TRUE,  true,  True,  y, Y, YES, yes, Yes, on, ON
+      #
+      # @example
+      #   converter.call("False") # => false
+      #
+      #  other values coerced to false are:
+      #    0, f, F, FALSE, false, False, n, N, NO,  no,  No, on, ON
+      #
+      # @api public
+      def call(value, options = {})
+        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}"
+        end
+      end
+    end
+
+    # An object that converts an Integer to a Boolean
+    class IntegerToBooleanConverter < Converter
+      def call(value, options = {})
+        !value.zero?
+      end
+    end
+
+    # An object that converts a Boolean to an Integer
+    class BooleanToIntegerConverter < Converter
+      def call(value, options = {})
+        value ? 1 : 0
+      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)
+    end
+  end # BooleanConverters
+end # Necromancer

data/lib/necromancer/converters/float.rb

@@ -0,0 +1,28 @@
+# coding: utf-8
+
+module Necromancer
+  module FloatConverters
+    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.to_s)
+      rescue
+        if strict
+          raise ConversionTypeError, "#{value} could not be converted from " \
+                                     "`#{source}` into `#{target}`"
+        else
+          value.to_f
+        end
+      end
+    end
+
+    def self.load(conversions)
+    end
+  end # Conversion
+end # Necromancer

data/lib/necromancer/converters/integer.rb

@@ -0,0 +1,48 @@
+# coding: utf-8
+
+module Necromancer
+  # Container for Integer converter classes
+  module IntegerConverters
+    # 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.to_s)
+      rescue
+        if strict
+          raise ConversionTypeError, "#{value} could not be converted from " \
+                                     "`#{source}` into `#{target}`"
+        else
+          value.to_i
+        end
+      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
+
+    def self.load(conversions)
+      conversions.register StringToIntegerConverter.new(:string, :integer)
+      conversions.register IntegerToStringConverter.new(:integer, :string)
+      conversions.register IntegerToStringConverter.new(:fixnum, :string)
+      conversions.register NullConverter.new(:integer, :integer)
+      conversions.register NullConverter.new(:fixnum, :integer)
+    end
+  end # IntegerConverters
+end # Necromancer

data/lib/necromancer/converters/range.rb

@@ -0,0 +1,38 @@
+# coding: utf-8
+
+module Necromancer
+  # Container for Range converter classes
+  module RangeConverters
+    # An object that converts a String to a Range
+    class StringToRangeConverter < Converter
+      # Convert value to Range type with possible ranges
+      #
+      # @param [Object] value
+      #
+      # @example
+      #   converter.call('0,9')  # => (0..9)
+      #
+      # @example
+      #   converter.call('0-9')  # => (0..9)
+      #
+      # @api public
+      def call(value, options = {})
+        case value.to_s
+        when /\A(\-?\d+)\Z/
+          ::Range.new($1.to_i, $1.to_i)
+        when /\A(-?\d+?)(\.{2}\.?|-|,)(-?\d+)\Z/
+          ::Range.new($1.to_i, $3.to_i, $2 == '...')
+        when /\A(\w)(\.{2}\.?|-|,)(\w)\Z/
+          ::Range.new($1.to_s, $3.to_s, $2 == '...')
+        else
+          fail ConversionTypeError, "#{value} could not be converted " \
+                                    "from #{source} into Range type"
+        end
+      end
+    end
+
+    def self.load(conversions)
+      conversions.register StringToRangeConverter.new(:string, :range)
+    end
+  end # RangeConverters
+end # Necromancer

data/lib/necromancer/null_converter.rb

@@ -0,0 +1,10 @@
+# coding: utf-8
+
+module Necromancer
+  # A pass through converter
+  class NullConverter < Converter
+    def call(value, options = {})
+      value
+    end
+  end # NullConverter
+end # Necromancer

data/lib/necromancer/version.rb

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

data/necromancer.gemspec

@@ -0,0 +1,21 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'necromancer/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'necromancer'
+  spec.version       = Necromancer::VERSION
+  spec.authors       = ['Piotr Murach']
+  spec.email         = ['']
+  spec.summary       = %q{Conversion from one object type to another with a bit of black magic.}
+  spec.description   = %q{Conversion from one object type to another with a bit of black magic.}
+  spec.homepage      = 'https://github.com/peter-murach/necromancer'
+  spec.license       = 'MIT'
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.test_files    = spec.files.grep(%r{^(spec)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.6"
+end

data/spec/spec_helper.rb

@@ -0,0 +1,45 @@
+# encoding: utf-8
+
+if RUBY_VERSION > '1.9' and (ENV['COVERAGE'] || ENV['TRAVIS'])
+  require 'simplecov'
+  require 'coveralls'
+
+  SimpleCov.formatter = SimpleCov::Formatter::MultiFormatter[
+    SimpleCov::Formatter::HTMLFormatter,
+    Coveralls::SimpleCov::Formatter
+  ]
+
+  SimpleCov.start do
+    command_name 'spec'
+    add_filter 'spec'
+  end
+end
+
+require 'necromancer'
+
+RSpec.configure do |config|
+  config.expect_with :rspec do |expectations|
+    expectations.include_chain_clauses_in_custom_matcher_descriptions = true
+  end
+
+  config.mock_with :rspec do |mocks|
+    mocks.verify_partial_doubles = true
+  end
+
+  # Limits the available syntax to the non-monkey patched syntax that is recommended.
+  config.disable_monkey_patching!
+
+  # This setting enables warnings. It's recommended, but in some cases may
+  # be too noisy due to issues in dependencies.
+  config.warnings = true
+
+  if config.files_to_run.one?
+    config.default_formatter = 'doc'
+  end
+
+  config.profile_examples = 2
+
+  config.order = :random
+
+  Kernel.srand config.seed
+end

data/spec/unit/can_spec.rb

@@ -0,0 +1,11 @@
+# coding: utf-8
+
+require 'spec_helper'
+
+RSpec.describe Necromancer, 'can?' do
+  it "checks if conversion is possible" do
+    converter = described_class.new
+    expect(converter.can?(:string, :integer)).to eq(true)
+    expect(converter.can?(:unknown, :integer)).to eq(false)
+  end
+end

data/spec/unit/conversions/register_spec.rb

@@ -0,0 +1,50 @@
+# coding: utf-8
+
+require 'spec_helper'
+
+RSpec.describe Necromancer::Conversions, '.register' do
+
+  it "allows to register converter" do
+    context = described_class.new
+    converter = double(:converter, {source: :string, target: :numeric})
+    expect(context.register(converter)).to eq(true)
+    expect(context[:string, :numeric]).to eq(converter)
+  end
+
+  it "allows to register converter with no source" do
+    context = described_class.new
+    converter = double(:converter, {source: nil, target: :numeric})
+    expect(context.register(converter)).to eq(true)
+    expect(context[:none, :numeric]).to eq(converter)
+  end
+
+  it "allows to register converter with no target" do
+    context = described_class.new
+    converter = double(:converter, {source: :string, target: nil})
+    expect(context.register(converter)).to eq(true)
+    expect(context[:string, :none]).to eq(converter)
+  end
+
+  it "allows to register anonymous converter" do
+    conversions = described_class.new
+
+    conversions.register do |c|
+      c.source= :string
+      c.target= :upcase
+      c.convert = proc { |value| value.to_s.upcase }
+    end
+    expect(conversions[:string, :upcase].call('magic')).to eq('MAGIC')
+  end
+
+  it "allows to register custom converter" do
+    conversions = described_class.new
+    UpcaseConverter = Struct.new(:source, :target) do
+      def call(value)
+        value.to_s.upcase
+      end
+    end
+    upcase_converter = UpcaseConverter.new(:string, :upcase)
+    expect(conversions.register(upcase_converter)).to be(true)
+    expect(conversions[:string, :upcase].call('magic')).to eq('MAGIC')
+  end
+end

data/spec/unit/convert_spec.rb

@@ -0,0 +1,66 @@
+# coding: utf-8
+
+require 'spec_helper'
+
+RSpec.describe Necromancer, '.convert' do
+
+  subject(:converter) { described_class.new }
+
+  context 'when integer' do
+    it "converts string to integer" do
+      expect(converter.convert('1').to(:integer)).to eq(1)
+    end
+
+    it "allows for block for conversion method" do
+      expect(converter.convert { '1' }.to(:integer)).to eq(1)
+    end
+
+    it "convers integer to string" do
+      expect(converter.convert(1).to(:string)).to eq('1')
+    end
+
+    it "allows for null type conversion" do
+      expect(converter.convert(1).to(:integer)).to eq(1)
+    end
+
+    it "raises error when in strict mode" do
+      expect {
+        converter.convert('1a').to(:integer, strict: true)
+      }.to raise_error(Necromancer::ConversionTypeError)
+    end
+  end
+
+  context 'when boolean' do
+    it "converts boolean to boolean" do
+      expect(converter.convert(true).to(:boolean)).to eq(true)
+    end
+
+    it "converts string to boolean" do
+      expect(converter.convert('yes').to(:boolean)).to eq(true)
+    end
+
+    it "converts integer to boolean" do
+      expect(converter.convert(0).to(:boolean)).to eq(false)
+    end
+
+    it "converts boolean to integer" do
+      expect(converter.convert(true).to(:integer)).to eq(1)
+    end
+  end
+
+  context 'when range' do
+    it "converts string to range" do
+      expect(converter.convert('1-10').to(:range)).to eq(1..10)
+    end
+  end
+
+  context 'when array' do
+    it "converts string to array" do
+      expect(converter.convert("1,2,3").to(:array)).to eq([1,2,3])
+    end
+
+    it "converts array to numeric " do
+      expect(converter.convert(['1','2.3','3.0']).to(:numeric)).to eq([1,2.3,3.0])
+    end
+  end
+end