coercible 0.0.1

data/lib/coercible/coercer/integer.rb

@@ -0,0 +1,130 @@
+module Coercible
+  class Coercer
+
+    # Coerce Fixnum values
+    class Integer < Numeric
+      extend Configurable
+
+      primitive ::Integer
+
+      config_keys [ :datetime_format, :datetime_proc, :boolean_map ]
+
+      # Return default config for Integer coercer type
+      #
+      # @return [Configuration]
+      #
+      # @see Configurable#config
+      #
+      # @api private
+      def self.config
+        # FIXME: Remove after Rubinius 2.0 is released
+        is_rbx = defined?(RUBY_ENGINE) && RUBY_ENGINE == 'rbx'
+
+        super do |config|
+          config.datetime_format = is_rbx ? '%Q' : '%s'
+
+          config.datetime_proc   = is_rbx ?
+            Proc.new { |value| "#{value * 10**3}" } : Proc.new { |value| "#{value}" }
+
+          config.boolean_map = { 0 => false, 1 => true }
+        end
+      end
+
+      # Return datetime format from config
+      #
+      # @return [::String]
+      #
+      # @api private
+      attr_reader :datetime_format
+
+      # Return datetime proc from config
+      #
+      # @return [Proc]
+      #
+      # @api private
+      attr_reader :datetime_proc
+
+      # Return boolean map from config
+      #
+      # @return [::Hash]
+      #
+      # @api private
+      attr_reader :boolean_map
+
+      # Initialize a new Integer coercer instance and set its configuration
+      #
+      # @return [undefined]
+      #
+      # @api private
+      def initialize(coercer = Coercer.new, config = self.class.config)
+        super(coercer)
+        @boolean_map     = config.boolean_map
+        @datetime_format = config.datetime_format
+        @datetime_proc   = config.datetime_proc
+      end
+
+      # Coerce given value to String
+      #
+      # @example
+      #   coercer[Integer].to_string(1)  # => "1"
+      #
+      # @param [Fixnum] value
+      #
+      # @return [String]
+      #
+      # @api public
+      def to_string(value)
+        value.to_s
+      end
+
+      # Passthrough the value
+      #
+      # @example
+      #   coercer[Integer].to_integer(1)  # => 1
+      #
+      # @param [Fixnum] value
+      #
+      # @return [Float]
+      #
+      # @api public
+      def to_integer(value)
+        value
+      end
+
+      # Coerce given value to a Boolean
+      #
+      # @example with a 1
+      #   coercer[Integer].to_boolean(1)  # => true
+      #
+      # @example with a 0
+      #   coercer[Integer].to_boolean(0)  # => false
+      #
+      # @param [Fixnum] value
+      #
+      # @return [BigDecimal]
+      #
+      # @api public
+      def to_boolean(value)
+        boolean_map.fetch(value) {
+          raise_unsupported_coercion(value, __method__)
+        }
+      end
+
+      # Coerce given value to a DateTime
+      #
+      # @example
+      #   coercer[Integer].to_datetime(0)  # => Thu, 01 Jan 1970 00:00:00 +0000
+      #
+      # @param [Integer] value
+      #
+      # @return [DateTime]
+      #
+      # @api public
+      def to_datetime(value)
+        ::DateTime.strptime(datetime_proc.call(value), datetime_format)
+      end
+
+    end # class Fixnum
+
+  end # class Coercer
+end # module Coercible

data/lib/coercible/coercer/numeric.rb

@@ -0,0 +1,67 @@
+module Coercible
+  class Coercer
+
+    # Base class for all numeric Coercion classes
+    class Numeric < Object
+      primitive ::Numeric
+
+      # Coerce given value to String
+      #
+      # @example
+      #   coercer[Numeric].to_string(Rational(2, 2))  # => "1.0"
+      #
+      # @param [Numeric] value
+      #
+      # @return [String]
+      #
+      # @api public
+      def to_string(value)
+        value.to_s
+      end
+
+      # Creates an Integer instance from a numeric object
+      #
+      # @example
+      #   coercer[Numeric].to_integer(Rational(2, 2))  # => 1
+      #
+      # @param [Numeric] value
+      #
+      # @return [Integer]
+      #
+      # @api public
+      def to_integer(value)
+        value.to_i
+      end
+
+      # Creates a Float instance from a numeric object
+      #
+      # @example
+      #   coercer[Numeric].to_float(Rational(2, 2))  # => 1.0
+      #
+      # @param [Numeric] value
+      #
+      # @return [Float]
+      #
+      # @api public
+      def to_float(value)
+        value.to_f
+      end
+
+      # Coerce a BigDecimal instance from a numeric object
+      #
+      # @example
+      #   coercer[Numeric].to_decimal(Rational(2, 2))  # => BigDecimal('1.0')
+      #
+      # @param [Numeric] value
+      #
+      # @return [BigDecimal]
+      #
+      # @api public
+      def to_decimal(value)
+        to_string(value).to_d
+      end
+
+    end # class Numeric
+
+  end # class Coercer
+end # module Coercible

data/lib/coercible/coercer/object.rb

@@ -0,0 +1,160 @@
+module Coercible
+  class Coercer
+
+    # Coerce Object values
+    class Object
+      extend DescendantsTracker, TypeLookup, Options
+
+      accept_options :primitive
+
+      primitive ::Object
+
+      COERCION_METHOD_REGEXP = /\Ato_/.freeze
+
+      # Return coercers object
+      #
+      # @return [Coercer]
+      #
+      # @api private
+      attr_reader :coercers
+
+      # Initialize a new coercer instance
+      #
+      # @param [Coercer] coercers
+      #
+      # @return [undefined]
+      #
+      # @api private
+      def initialize(coercers = Coercer.new)
+        @coercers = coercers
+      end
+
+      # Create an Array from any Object
+      #
+      # @example with an object that does not respond to #to_a or #to_ary
+      #   coercer[Object].to_array(value)         # => [ value ]
+      #
+      # @example with an object that responds to #to_a
+      #   coercer[Object].to_array(Set[ value ])  # => [ value ]
+      #
+      # @example with n object that responds to #to_ary
+      #   coercer[Object].to_array([ value ])     # => [ value ]
+      #
+      # @param [#to_a,#to_ary,Object] value
+      # @param [#to_a,#to_ary,Object] value
+      #
+      # @return [Array]
+      #
+      # @api public
+      def to_array(value)
+        Array(value)
+      end
+
+      # Create a Hash from the Object if possible
+      #
+      # @example with a coercible object
+      #   coercer[Object].to_hash(key => value)  # => { key => value }
+      #
+      # @example with an object that is not coercible
+      #   coercer[Object].to_hash(value)  # => value
+      #
+      # @param [#to_hash, Object] value
+      #
+      # @return [Hash]
+      #   returns a Hash when the object can be coerced
+      # @return [Object]
+      #   returns the value when the object cannot be coerced
+      #
+      # @api public
+      def to_hash(value)
+        coerce_with_method(value, :to_hash)
+      end
+
+      # Create a String from the Object if possible
+      #
+      # @example with a coercible object
+      #   coercer[Object].to_string("string")  # => "string"
+      #
+      # @example with an object that is not coercible
+      #   coercer[Object].to_string(value)  # => value
+      #
+      # @param [#to_str, Object] value
+      #
+      # @return [String]
+      #   returns a String when the object can be coerced
+      # @return [Object]
+      #   returns the value when the object cannot be coerced
+      #
+      # @api public
+      def to_string(value)
+        coerce_with_method(value, :to_str)
+      end
+
+      # Create an Integer from the Object if possible
+      #
+      # @example with a coercible object
+      #   coercer[Object].to_integer(1)  # => 1
+      #
+      # @example with an object that is not coercible
+      #   coercer[Object].to_integer(value)  # => value
+      #
+      # @param [#to_int, Object] value
+      #
+      # @return [Integer]
+      #   returns an Integer when the object can be coerced
+      # @return [Object]
+      #   returns the value when the object cannot be coerced
+      #
+      # @api public
+      def to_integer(value)
+        coerce_with_method(value, :to_int)
+      end
+
+      private
+
+      # Raise an unsupported coercion error
+      #
+      # @raises [UnsupportedCoercion]
+      #
+      # @return [undefined]
+      #
+      # @api private
+      def raise_unsupported_coercion(value, method)
+        raise(
+          UnsupportedCoercion,
+          "#{self.class}##{method} doesn't know how to coerce #{value.inspect}"
+        )
+      end
+
+      # Passthrough given value
+      #
+      # @param [Object] value
+      #
+      # @return [Object]
+      #
+      # @api private
+      def method_missing(method, *args)
+        if method.to_s =~ COERCION_METHOD_REGEXP and args.size == 1
+          args.first
+        else
+          super
+        end
+      end
+
+      # Try to use native coercion method on the given value
+      #
+      # @param [Object] value
+      #
+      # @param [Symbol] method
+      #
+      # @return [Object]
+      #
+      # @api private
+      def coerce_with_method(value, method)
+        value.respond_to?(method) ? value.public_send(method) : value
+      end
+
+    end # class Object
+
+  end # class Coercer
+end # module Coercible

data/lib/coercible/coercer/string.rb

@@ -0,0 +1,251 @@
+module Coercible
+  class Coercer
+
+    # Coerce String values
+    class String < Object
+      extend Configurable
+
+      primitive ::String
+
+      config_keys [ :boolean_map ]
+
+      TRUE_VALUES  = %w[ 1 on  t true  y yes ].freeze
+      FALSE_VALUES = %w[ 0 off f false n no  ].freeze
+      BOOLEAN_MAP  = ::Hash[ TRUE_VALUES.product([ true ]) + FALSE_VALUES.product([ false ]) ].freeze
+
+      INTEGER_REGEXP    = /[-+]?(?:[0-9]\d*)/.freeze
+      EXPONENT_REGEXP   = /(?:[eE][-+]?\d+)/.freeze
+      FRACTIONAL_REGEXP = /(?:\.\d+)/.freeze
+
+      NUMERIC_REGEXP    = /\A(
+        #{INTEGER_REGEXP}#{FRACTIONAL_REGEXP}?#{EXPONENT_REGEXP}? |
+        #{FRACTIONAL_REGEXP}#{EXPONENT_REGEXP}?
+      )\z/x.freeze
+
+      # Return default configuration for string coercer type
+      #
+      # @return [Configuration]
+      #
+      # @api private
+      def self.config
+        super { |config| config.boolean_map = BOOLEAN_MAP }
+      end
+
+      # Return boolean map from the config
+      #
+      # @return [::Hash]
+      #
+      # @api private
+      attr_reader :boolean_map
+
+      # Initialize a new string coercer instance
+      #
+      # @param [Coercer]
+      #
+      # @param [Configuration]
+      #
+      # @return [undefined]
+      #
+      # @api private
+      def initialize(coercer = Coercer.new, config = self.class.config)
+        super(coercer)
+        @boolean_map = config.boolean_map
+      end
+
+      # Coerce give value to a constant
+      #
+      # @example
+      #   coercer[String].to_constant('String') # => String
+      #
+      # @param [String] value
+      #
+      # @return [Object]
+      #
+      # @api public
+      def to_constant(value)
+        names = value.split('::')
+        names.shift if names.first.empty?
+        names.inject(::Object) { |*args| constant_lookup(*args) }
+      end
+
+      # Coerce give value to a symbol
+      #
+      # @example
+      #   coercer[String].to_symbol('string') # => :string
+      #
+      # @param [String] value
+      #
+      # @return [Symbol]
+      #
+      # @api public
+      def to_symbol(value)
+        value.to_sym
+      end
+
+      # Coerce given value to Time
+      #
+      # @example
+      #   coercer[String].to_time(string)  # => Time object
+      #
+      # @param [String] value
+      #
+      # @return [Time]
+      #
+      # @api public
+      def to_time(value)
+        parse_value(::Time, value, __method__)
+      end
+
+      # Coerce given value to Date
+      #
+      # @example
+      #   coercer[String].to_date(string)  # => Date object
+      #
+      # @param [String] value
+      #
+      # @return [Date]
+      #
+      # @api public
+      def to_date(value)
+        parse_value(::Date, value, __method__)
+      end
+
+      # Coerce given value to DateTime
+      #
+      # @example
+      #   coercer[String].to_datetime(string)  # => DateTime object
+      #
+      # @param [String] value
+      #
+      # @return [DateTime]
+      #
+      # @api public
+      def to_datetime(value)
+        parse_value(::DateTime, value, __method__)
+      end
+
+      # Coerce value to TrueClass or FalseClass
+      #
+      # @example with "T"
+      #   coercer[String].to_boolean('T')  # => true
+      #
+      # @example with "F"
+      #   coercer[String].to_boolean('F')  # => false
+      #
+      # @param [#to_s]
+      #
+      # @return [Boolean]
+      #
+      # @api public
+      def to_boolean(value)
+        boolean_map.fetch(value.downcase) {
+          raise_unsupported_coercion(value, __method__)
+        }
+      end
+
+      # Coerce value to integer
+      #
+      # @example
+      #   coercer[String].to_integer('1')  # => 1
+      #
+      # @param [Object] value
+      #
+      # @return [Integer]
+      #
+      # @api public
+      def to_integer(value)
+        if value =~ /\A#{INTEGER_REGEXP}\z/
+          value.to_i
+        else
+          # coerce to a Float first to evaluate scientific notation (if any)
+          # that may change the integer part, then convert to an integer
+          coerced = to_float(value)
+          ::Float === coerced ? coerced.to_i : coerced
+        end
+      end
+
+      # Coerce value to float
+      #
+      # @example
+      #   coercer[String].to_float('1.2')  # => 1.2
+      #
+      # @param [Object] value
+      #
+      # @return [Float]
+      #
+      # @api public
+      def to_float(value)
+        to_numeric(value, :to_f)
+      end
+
+      # Coerce value to decimal
+      #
+      # @example
+      #   coercer[String].to_decimal('1.2')  # => #<BigDecimal:b72157d4,'0.12E1',8(8)>
+      #
+      # @param [Object] value
+      #
+      # @return [BigDecimal]
+      #
+      # @api public
+      def to_decimal(value)
+        to_numeric(value, :to_d)
+      end
+
+      private
+
+      # Lookup a constant within a module
+      #
+      # @param [Module] mod
+      #
+      # @param [String] name
+      #
+      # @return [Object]
+      #
+      # @api private
+      def constant_lookup(mod, name)
+        if mod.const_defined?(name, *EXTRA_CONST_ARGS)
+          mod.const_get(name, *EXTRA_CONST_ARGS)
+        else
+          mod.const_missing(name)
+        end
+      end
+
+      # Match numeric string
+      #
+      # @param [String] value
+      #   value to typecast
+      # @param [Symbol] method
+      #   method to typecast with
+      #
+      # @return [Numeric]
+      #   number if matched, value if no match
+      #
+      # @api private
+      def to_numeric(value, method)
+        if value =~ NUMERIC_REGEXP
+          $1.public_send(method)
+        else
+          value
+        end
+      end
+
+      # Parse the value or return it as-is if it is invalid
+      #
+      # @param [#parse] parser
+      #
+      # @param [String] value
+      #
+      # @return [Time]
+      #
+      # @api private
+      def parse_value(parser, value, method)
+        parser.parse(value)
+      rescue ArgumentError
+        raise_unsupported_coercion(value, method)
+      end
+
+    end # class String
+
+  end # class Coercer
+end # module Coercible