coercible 0.0.1

data/lib/coercible/coercer.rb

@@ -0,0 +1,155 @@
+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(coercers = {}, config = nil)
+      @coercers = coercers
+      @config   = config
+      initialize_default_coercer
+    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)
+      fetch(klass) || coercers[::Object]
+    end
+
+    private
+
+    # Fetch an existing coercer or create a new instance
+    #
+    # @return [Coercer::Object]
+    #
+    # @api private
+    def fetch(klass)
+      coercers[klass] || initialize_coercer(klass)
+    end
+
+    # Initialize a new coercer instance for the give 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
+
+    # Initialize default coercer object
+    #
+    # @return [Coercer::Object]
+    #
+    # @api private
+    def initialize_default_coercer
+      coercers[::Object] = Coercer::Object.new(self)
+    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

data/lib/coercible/coercer/array.rb

@@ -0,0 +1,24 @@
+module Coercible
+  class Coercer
+
+    # Coerce Array values
+    class Array < Object
+      primitive ::Array
+
+      TIME_SEGMENTS = [ :year, :month, :day, :hour, :min, :sec ].freeze
+
+      # Creates a Set instance from an Array
+      #
+      # @param [Array] value
+      #
+      # @return [Array]
+      #
+      # @api private
+      def to_set(value)
+        value.to_set
+      end
+
+    end # class Array
+
+  end # class Coercer
+end # module Coercible

data/lib/coercible/coercer/configurable.rb

@@ -0,0 +1,54 @@
+module Coercible
+  class Coercer
+
+    module Configurable
+
+      # Add configuration-specific option keys to the descendant
+      #
+      # @return [self]
+      #
+      # @api private
+      def self.extended(coercer)
+        coercer.accept_options :config_keys
+        super
+      end
+
+      # Build configuration object for the coercer class
+      #
+      # @example
+      #
+      #   coercer_class = Class.new(Coercer::Object) do
+      #     extend Configurable
+      #
+      #     config_keys [ :foo, :bar ]
+      #   end
+      #
+      #   coercer_class.config do |config|
+      #     config.foo = '1'
+      #     config.bar = '2'
+      #   end
+      #
+      # @yieldparam [Configuration]
+      #
+      # @return [Configuration]
+      #
+      # @api public
+      def config(&block)
+        configuration = Configuration.build(config_keys)
+        yield configuration
+        configuration
+      end
+
+      # Return configuration name in the global config
+      #
+      # @return [Symbol]
+      #
+      # @api private
+      def config_name
+        self.name.downcase.split('::').last.to_sym
+      end
+
+    end # module Configurable
+
+  end # class Coercer
+end # module Coercible

data/lib/coercible/coercer/date.rb

@@ -0,0 +1,27 @@
+module Coercible
+  class Coercer
+
+    # Coerce Date values
+    class Date < Object
+      include TimeCoercions
+
+      primitive ::Date
+
+      # Passthrough the value
+      #
+      # @example
+      #   coercer[DateTime].to_date(date)  # => Date object
+      #
+      # @param [DateTime] value
+      #
+      # @return [Date]
+      #
+      # @api public
+      def to_date(value)
+        value
+      end
+
+    end # class Date
+
+  end # class Coercer
+end # module Coercible

data/lib/coercible/coercer/date_time.rb

@@ -0,0 +1,27 @@
+module Coercible
+  class Coercer
+
+    # Coerce DateTime values
+    class DateTime < Object
+      primitive ::DateTime
+
+      include TimeCoercions
+
+      # Passthrough the value
+      #
+      # @example
+      #   coercer[DateTime].to_datetime(datetime)  # => DateTime object
+      #
+      # @param [DateTime] value
+      #
+      # @return [Date]
+      #
+      # @api public
+      def to_datetime(value)
+        value
+      end
+
+    end # class DateTime
+
+  end # class Coercer
+end # module Coercible

data/lib/coercible/coercer/decimal.rb

@@ -0,0 +1,41 @@
+module Coercible
+  class Coercer
+
+    # Coerce BigDecimal values
+    class Decimal < Numeric
+      primitive ::BigDecimal
+
+      FLOAT_FORMAT = 'F'.freeze
+
+      # Coerce given value to String
+      #
+      # @example
+      #   coercer[BigDecimal].to_string(BigDecimal('1.0')) # => "1.0"
+      #
+      # @param [BigDecimal] value
+      #
+      # @return [String]
+      #
+      # @api public
+      def to_string(value)
+        value.to_s(FLOAT_FORMAT)
+      end
+
+      # Passthrough the value
+      #
+      # @example
+      #   Coercible::Coercion::BigDecimal.to_decimal(BigDecimal('1.0')) # => BigDecimal('1.0')
+      #
+      # @param [BigDecimal] value
+      #
+      # @return [Fixnum]
+      #
+      # @api public
+      def to_decimal(value)
+        value
+      end
+
+    end # class BigDecimal
+
+  end # class Coercer
+end # module Coercible

data/lib/coercible/coercer/false_class.rb

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

data/lib/coercible/coercer/float.rb

@@ -0,0 +1,40 @@
+module Coercible
+  class Coercer
+
+    # Coerce Float values
+    class Float < Numeric
+      primitive ::Float
+
+      # Passthrough the value
+      #
+      # @example
+      #   coercer[Float].to_float(1.0)  # => 1.0
+      #
+      # @param [Float] value
+      #
+      # @return [Integer]
+      #
+      # @api public
+      def to_float(value)
+        value
+      end
+
+      # Coerce given value to a DateTime
+      #
+      # @example
+      #   datetime = Coercible::Coercion::Float.to_datetime(1000000000.999)  # => Sun, 09 Sep 2001 01:46:40 +0000
+      #   datetime.to_f  # => 1000000000.999
+      #
+      # @param [Float] value
+      #
+      # @return [DateTime]
+      #
+      # @api public
+      def to_datetime(value)
+        ::DateTime.strptime((value * 10**3).to_s, "%Q")
+      end
+
+    end # class Float
+
+  end # class Coercer
+end # module Coercible

data/lib/coercible/coercer/hash.rb

@@ -0,0 +1,72 @@
+module Coercible
+  class Coercer
+
+    # Coerce Hash values
+    class Hash < Object
+      primitive ::Hash
+
+      TIME_SEGMENTS = [ :year, :month, :day, :hour, :min, :sec ].freeze
+
+      # Creates a Time instance from a Hash
+      #
+      # Valid keys are: :year, :month, :day, :hour, :min, :sec
+      #
+      # @param [Hash] value
+      #
+      # @return [Time]
+      #
+      # @api private
+      def to_time(value)
+        ::Time.local(*extract(value))
+      end
+
+      # Creates a Date instance from a Hash
+      #
+      # Valid keys are: :year, :month, :day, :hour
+      #
+      # @param [Hash] value
+      #
+      # @return [Date]
+      #
+      # @api private
+      def to_date(value)
+        ::Date.new(*extract(value).first(3))
+      end
+
+      # Creates a DateTime instance from a Hash
+      #
+      # Valid keys are: :year, :month, :day, :hour, :min, :sec
+      #
+      # @param [Hash] value
+      #
+      # @return [DateTime]
+      #
+      # @api private
+      def to_datetime(value)
+        ::DateTime.new(*extract(value))
+      end
+
+      private
+
+      # Extracts the given args from a Hash
+      #
+      # If a value does not exist, it uses the value of Time.now
+      #
+      # @param [Hash] value
+      #
+      # @return [Array]
+      #
+      # @api private
+      def extract(value)
+        now = ::Time.now
+
+        TIME_SEGMENTS.map do |segment|
+          val = value.fetch(segment, now.public_send(segment))
+          coercers[val.class].to_integer(val)
+        end
+      end
+
+    end # class Hash
+
+  end # class Coercer
+end # module Coercible