coercible 0.0.1

data/lib/coercible/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/coercible/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/coercible/coercer/time_coercions.rb

@@ -0,0 +1,87 @@
+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
+
+      # Coerce given value to DateTime
+      #
+      # @example
+      #   coercer[Time].to_datetime(time)  # => DateTime object
+      #
+      # @param [Date,Time] value
+      #
+      # @return [DateTime]
+      #
+      # @api public
+      def to_datetime(value)
+        coerce_with_method(value, :to_datetime)
+      end
+
+      # Coerce given value to Date
+      #
+      # @example
+      #   coercer[Time].to_date(time)  # => Date object
+      #
+      # @param [Time,DateTime] value
+      #
+      # @return [Date]
+      #
+      # @api public
+      def to_date(value)
+        coerce_with_method(value, :to_date)
+      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)
+        coerced = super
+        if coerced.equal?(value)
+          coercers[::String].public_send(method, to_string(value))
+        else
+          coerced
+        end
+      end
+
+    end # module TimeCoercions
+
+  end # class Coercer
+end # module Coercible

data/lib/coercible/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/coercible/configuration.rb

@@ -0,0 +1,33 @@
+module Coercible
+
+  # Configuration object for global and per coercer type settings
+  #
+  class Configuration
+
+    # Build a configuration instance
+    #
+    # @param [Array] list of accessor keys
+    #
+    # @return [Configuration]
+    #
+    # @api private
+    def self.build(keys, &block)
+      config = new
+      keys.each do |key|
+        config.instance_eval <<-RUBY
+          def #{key}
+            @#{key}
+          end
+
+          def #{key}=(value)
+            @#{key} = value
+          end
+        RUBY
+      end
+      yield(config) if block_given?
+      config
+    end
+
+  end # class Configuration
+
+end # module Coercible

data/lib/coercible/version.rb

@@ -0,0 +1,3 @@
+module Coercible
+  VERSION = "0.0.1"
+end

data/lib/support/options.rb

@@ -0,0 +1,113 @@
+module Coercible
+
+  # A module that adds class and instance level options
+  module Options
+    Undefined = Class.new.freeze
+
+    # Returns default options hash for a given attribute class
+    #
+    # @example
+    #   Virtus::Attribute::String.options
+    #   # => {:primitive => String}
+    #
+    # @return [Hash]
+    #   a hash of default option values
+    #
+    # @api public
+    def options
+      accepted_options.each_with_object({}) do |option_name, options|
+        option_value         = send(option_name)
+        options[option_name] = option_value unless option_value.nil?
+      end
+    end
+
+    # Returns an array of valid options
+    #
+    # @example
+    #   Virtus::Attribute::String.accepted_options
+    #   # => [:primitive, :accessor, :reader, :writer]
+    #
+    # @return [Array]
+    #   the array of valid option names
+    #
+    # @api public
+    def accepted_options
+      @accepted_options ||= []
+    end
+
+    # Defines which options are valid for a given attribute class
+    #
+    # @example
+    #   class MyAttribute < Virtus::Attribute::Object
+    #     accept_options :foo, :bar
+    #   end
+    #
+    # @return [self]
+    #
+    # @api public
+    def accept_options(*new_options)
+      add_accepted_options(new_options)
+      new_options.each { |option| define_option_method(option) }
+      descendants.each { |descendant| descendant.add_accepted_options(new_options) }
+      self
+    end
+
+  protected
+
+    # Adds a reader/writer method for the give option name
+    #
+    # @return [undefined]
+    #
+    # @api private
+    def define_option_method(option)
+      class_eval <<-RUBY, __FILE__, __LINE__ + 1
+        def self.#{option}(value = Undefined)           # def self.primitive(value = Undefined)
+          return @#{option} if value.equal?(Undefined)  #   return @primitive if value.equal?(Undefined)
+          @#{option} = value                            #   @primitive = value
+          self                                          #   self
+        end                                             # end
+      RUBY
+    end
+
+    # Sets default options
+    #
+    # @param [#each] new_options
+    #   options to be set
+    #
+    # @return [self]
+    #
+    # @api private
+    def set_options(new_options)
+      new_options.each { |pair| send(*pair) }
+      self
+    end
+
+    # Adds new options that an attribute class can accept
+    #
+    # @param [#to_ary] new_options
+    #   new options to be added
+    #
+    # @return [self]
+    #
+    # @api private
+    def add_accepted_options(new_options)
+      accepted_options.concat(new_options)
+      self
+    end
+
+  private
+
+    # Adds descendant to descendants array and inherits default options
+    #
+    # @param [Class] descendant
+    #
+    # @return [undefined]
+    #
+    # @api private
+    def inherited(descendant)
+      super
+      descendant.add_accepted_options(accepted_options).set_options(options)
+    end
+
+  end # module Options
+end # module Virtus

data/lib/support/type_lookup.rb

@@ -0,0 +1,113 @@
+module Coercible
+
+  # A module that adds type lookup to a class
+  module TypeLookup
+
+    TYPE_FORMAT = /\A[A-Z]\w*\z/.freeze
+
+    # Set cache ivar on the model
+    #
+    # @param [Class] model
+    #
+    # @return [undefined]
+    #
+    # @api private
+    def self.extended(model)
+      model.instance_variable_set('@type_lookup_cache', {})
+    end
+
+    # Returns a descendant based on a name or class
+    #
+    # @example
+    #   MyClass.determine_type('String')  # => MyClass::String
+    #
+    # @param [Class, #to_s] class_or_name
+    #   name of a class or a class itself
+    #
+    # @return [Class]
+    #   a descendant
+    #
+    # @return [nil]
+    #   nil if the type cannot be determined by the class_or_name
+    #
+    # @api public
+    def determine_type(class_or_name)
+      @type_lookup_cache[class_or_name] ||= determine_type_and_cache(class_or_name)
+    end
+
+    # Return the default primitive supported
+    #
+    # @return [Class]
+    #
+    # @api private
+    def primitive
+      raise NotImplementedError, "#{self}.primitive must be implemented"
+    end
+
+    private
+
+    # Determine type and cache the class
+    #
+    # @return [Class]
+    #
+    # @api private
+    def determine_type_and_cache(class_or_name)
+      case class_or_name
+      when singleton_class
+        determine_type_from_descendant(class_or_name)
+      when Class
+        determine_type_from_primitive(class_or_name)
+      else
+        determine_type_from_string(class_or_name.to_s)
+      end
+    end
+
+    # Return the class given a descendant
+    #
+    # @param [Class] descendant
+    #
+    # @return [Class]
+    #
+    # @api private
+    def determine_type_from_descendant(descendant)
+      descendant if descendant < self
+    end
+
+    # Return the class given a primitive
+    #
+    # @param [Class] primitive
+    #
+    # @return [Class]
+    #
+    # @return [nil]
+    #   nil if the type cannot be determined by the primitive
+    #
+    # @api private
+    def determine_type_from_primitive(primitive)
+      type = nil
+      descendants.reverse_each do |descendant|
+        descendant_primitive = descendant.primitive
+        next unless primitive <= descendant_primitive
+        type = descendant if type.nil? or type.primitive > descendant_primitive
+      end
+      type
+    end
+
+    # Return the class given a string
+    #
+    # @param [String] string
+    #
+    # @return [Class]
+    #
+    # @return [nil]
+    #   nil if the type cannot be determined by the string
+    #
+    # @api private
+    def determine_type_from_string(string)
+      if string =~ TYPE_FORMAT and const_defined?(string, *EXTRA_CONST_ARGS)
+        const_get(string, *EXTRA_CONST_ARGS)
+      end
+    end
+
+  end # module TypeLookup
+end # module Virtus