motion_coercible 0.2.0

data/lib/project/coercer/string.rb

@@ -0,0 +1,228 @@
+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 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
+          to_float(value).to_i
+        end
+      rescue UnsupportedCoercion
+        raise_unsupported_coercion(value, __method__)
+      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)
+      rescue UnsupportedCoercion
+        raise_unsupported_coercion(value, __method__)
+      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)
+      rescue UnsupportedCoercion
+        raise_unsupported_coercion(value, __method__)
+      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
+          raise_unsupported_coercion(value, method)
+        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

data/lib/project/coercer/symbol.rb

@@ -0,0 +1,25 @@
+module Coercible
+  class Coercer
+
+    # Coerce Symbol values
+    class Symbol < Object
+      primitive ::Symbol
+
+      # Coerce given value to String
+      #
+      # @example
+      #   coercer[Symbol].to_string(:name)  # => "name"
+      #
+      # @param [Symbol] value
+      #
+      # @return [String]
+      #
+      # @api public
+      def to_string(value)
+        value.to_s
+      end
+
+    end # class Symbol
+
+  end # class Coercer
+end # module Coercible

data/lib/project/coercer/time.rb

@@ -0,0 +1,41 @@
+module Coercible
+  class Coercer
+
+    # Coerce Time values
+    class Time < Object
+      include TimeCoercions
+
+      primitive ::Time
+
+      # Passthrough the value
+      #
+      # @example
+      #   coercer[DateTime].to_time(time)  # => Time object
+      #
+      # @param [DateTime] value
+      #
+      # @return [Date]
+      #
+      # @api public
+      def to_time(value)
+        value
+      end
+
+      # Creates a Fixnum instance from a Time object
+      #
+      # @example
+      #   Coercible::Coercion::Time.to_integer(time)  # => Fixnum object
+      #
+      # @param [Time] value
+      #
+      # @return [Fixnum]
+      #
+      # @api public
+      def to_integer(value)
+        value.to_i
+      end
+
+    end # class Time
+
+  end # class Coercer
+end # module Coercible

data/lib/project/coercer/time_coercions.rb

@@ -0,0 +1,58 @@
+module Coercible
+  class Coercer
+
+    # Common time coercion methods
+    module TimeCoercions
+
+      # Coerce given value to String
+      #
+      # @example
+      #   coercer[Time].to_string(time)  # => "Wed Jul 20 10:30:41 -0700 2011"
+      #
+      # @param [Date,Time,DateTime] value
+      #
+      # @return [String]
+      #
+      # @api public
+      def to_string(value)
+        value.to_s
+      end
+
+      # Coerce given value to Time
+      #
+      # @example
+      #   coercer[DateTime].to_time(datetime)  # => Time object
+      #
+      # @param [Date,DateTime] value
+      #
+      # @return [Time]
+      #
+      # @api public
+      def to_time(value)
+        coerce_with_method(value, :to_time)
+      end
+
+      private
+
+      # Try to use native coercion method on the given value
+      #
+      # Falls back to String-based parsing
+      #
+      # @param [Date,DateTime,Time] value
+      # @param [Symbol] method
+      #
+      # @return [Date,DateTime,Time]
+      #
+      # @api private
+      def coerce_with_method(value, method)
+        if value.respond_to?(method)
+          value.public_send(method)
+        else
+          coercers[::String].public_send(method, to_string(value))
+        end
+      end
+
+    end # module TimeCoercions
+
+  end # class Coercer
+end # module Coercible

data/lib/project/coercer/true_class.rb

@@ -0,0 +1,25 @@
+module Coercible
+  class Coercer
+
+    # Coerce true values
+    class TrueClass < Object
+      primitive ::TrueClass
+
+      # Coerce given value to String
+      #
+      # @example
+      #   coercer[TrueClass].to_string(true)  # => "true"
+      #
+      # @param [TrueClass] value
+      #
+      # @return [String]
+      #
+      # @api public
+      def to_string(value)
+        value.to_s
+      end
+
+    end # class TrueClass
+
+  end # class Coercer
+end # module Coercible

data/lib/project/coercer.rb

@@ -0,0 +1,136 @@
+module Coercible
+
+  # Coercer object
+  #
+  #
+  # @example
+  #
+  #   coercer = Coercible::Coercer.new
+  #
+  #   coercer[String].to_boolean('yes') # => true
+  #   coercer[Integer].to_string(1)     # => '1'
+  #
+  # @api public
+  class Coercer
+
+    # Return coercer instances
+    #
+    # @return [Array<Coercer::Object>]
+    #
+    # @api private
+    attr_reader :coercers
+
+    # Returns global configuration for coercers
+    #
+    # @return [Configuration]
+    #
+    # @api private
+    attr_reader :config
+
+    # Build a new coercer
+    #
+    # @example
+    #
+    #   Coercible::Coercer.new { |config| # set configuration }
+    #
+    # @yieldparam [Configuration]
+    #
+    # @return [Coercer]
+    #
+    # @api public
+    def self.new(&block)
+      configuration = Configuration.build(config_keys)
+
+      configurable_coercers.each do |coercer|
+        configuration.send("#{coercer.config_name}=", coercer.config)
+      end
+
+      yield(configuration) if block_given?
+
+      super(configuration)
+    end
+
+    # Return configuration keys for Coercer instance
+    #
+    # @return [Array<Symbol>]
+    #
+    # @api private
+    def self.config_keys
+      configurable_coercers.map(&:config_name)
+    end
+    private_class_method :config_keys
+
+    # Return coercer classes that are configurable
+    #
+    # @return [Array<Class>]
+    #
+    # @api private
+    def self.configurable_coercers(&block)
+      Coercer::Object.descendants.select { |descendant|
+        descendant.respond_to?(:config)
+      }
+    end
+    private_class_method :configurable_coercers
+
+    # Initialize a new coercer instance
+    #
+    # @param [Hash] coercers
+    #
+    # @param [Configuration] config
+    #
+    # @return [undefined]
+    #
+    # @api private
+    def initialize(config, coercers = {})
+      @coercers = coercers
+      @config   = config
+    end
+
+    # Access a specific coercer object for the given type
+    #
+    # @example
+    #
+    #   coercer[String] # => string coercer
+    #   coercer[Integer] # => integer coercer
+    #
+    # @param [Class] type
+    #
+    # @return [Coercer::Object]
+    #
+    # @api public
+    def [](klass)
+      coercers[klass] || initialize_coercer(klass)
+    end
+
+    private
+
+    # Initialize a new coercer instance for the given type
+    #
+    # If a coercer class supports configuration it will receive it from the
+    # global configuration object
+    #
+    # @return [Coercer::Object]
+    #
+    # @api private
+    def initialize_coercer(klass)
+      coercers[klass] =
+        begin
+          coercer = Coercer::Object.determine_type(klass) || Coercer::Object
+          args    = [ self ]
+          args   << config_for(coercer) if coercer.respond_to?(:config_name)
+          coercer.new(*args)
+        end
+    end
+
+    # Find configuration for the given coercer type
+    #
+    # @return [Configuration]
+    #
+    # @api private
+    def config_for(coercer)
+      config.send(coercer.config_name)
+    end
+
+  end # class Coercer
+
+end # module Coercible