virtus 0.0.5 → 0.0.6

data/lib/virtus/coercion/symbol.rb

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

data/lib/virtus/coercion/time.rb

@@ -0,0 +1,26 @@
+module Virtus
+  class Coercion
+
+    # Coerce Time values
+    class Time < Object
+      extend TimeCoercions
+
+      primitive ::Time
+
+      # Passthrough the value
+      #
+      # @example
+      #   Virtus::Coercion::DateTime.to_time(time)  # => Time object
+      #
+      # @param [DateTime] value
+      #
+      # @return [Date]
+      #
+      # @api public
+      def self.to_time(value)
+        value
+      end
+
+    end # class Time
+  end # class Coercion
+end # module Virtus

data/lib/virtus/coercion/time_coercions.rb

@@ -0,0 +1,85 @@
+module Virtus
+  class Coercion
+
+    # Common time coercion methods
+    module TimeCoercions
+
+      # Coerce given value to String
+      #
+      # @example
+      #   Virtus::Coercion::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
+      #   Virtus::Coercion::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
+      #   Virtus::Coercion::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
+      #   Virtus::Coercion::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)
+        if value.respond_to?(method)
+          value.send(method)
+        else
+          String.send(method, to_string(value))
+        end
+      end
+
+    end # module TimeCoercions
+  end # class Coercion
+end # module Virtus

data/lib/virtus/coercion/true_class.rb

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

data/lib/virtus/instance_methods.rb

@@ -117,6 +117,13 @@ module Virtus
       end
     end
 
+    # @see Virtus::InstanceMethods#attributes
+    #
+    # @api public
+    def to_hash
+      attributes
+    end
+
   private
 
     # Returns a value of the attribute with the given name

data/lib/virtus/support/descendants_tracker.rb

@@ -32,7 +32,7 @@ module Virtus
     #
     # @param [Class] descendant
     #
-    # @return [self]
+    # @return [undefined]
     #
     # @api private
     def inherited(descendant)

data/lib/virtus/support/options.rb

@@ -0,0 +1,114 @@
+module Virtus
+
+  # A module that adds class and instance level options
+  module Options
+
+    # 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
+      options = {}
+      accepted_options.each do |option_name|
+        option_value         = send(option_name)
+        options[option_name] = option_value unless option_value.nil?
+      end
+      options
+    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 [Array]
+    #   All accepted options
+    #
+    # @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
+        end                                             # end
+      RUBY
+    end
+
+    # Sets default options
+    #
+    # @param [#to_hash] new_options
+    #   options to be set
+    #
+    # @return [self]
+    #
+    # @api private
+    def set_options(new_options)
+      new_options.to_hash.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.to_ary)
+      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/virtus/support/type_lookup.rb

@@ -0,0 +1,95 @@
+module Virtus
+
+  # A module that adds type lookup to a class
+  module TypeLookup
+
+    TYPE_FORMAT = /\A(?:[A-Z]\w*)\z/.freeze
+
+    # 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)
+      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 default primitive supported
+    #
+    # @return [Class]
+    #
+    # @api private
+    def primitive
+      raise NotImplementedError, "#{self}.primitive must be implemented"
+    end
+
+  private
+
+    # 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)
+      descendants.detect { |descendant| primitive <= descendant.primitive }
+    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 && const_defined?(string, false)
+        const_get(string, false)
+      end
+    end
+
+    if RUBY_VERSION < '1.9'
+      def determine_type_from_string(string)
+        if string =~ TYPE_FORMAT && const_defined?(string)
+          const_get(string)
+        end
+      end
+    end
+
+  end # module TypeLookup
+end # module Virtus

data/spec/integration/virtus/attributes/attribute/{typecast_spec.rb → set_spec.rb}

@@ -1,10 +1,10 @@
 require 'spec_helper'
 
-describe Virtus::Attribute, '#typecast' do
+describe Virtus::Attribute, '#set' do
   let(:attribute_class) do
     Class.new(Virtus::Attribute::Integer) do
-      def typecast(value)
-        super + 1
+      def set(instance, value)
+        super(instance, coerce(value) + 1) unless value.nil?
       end
     end
   end
@@ -23,14 +23,14 @@ describe Virtus::Attribute, '#typecast' do
 
   context 'when overridden' do
     let(:input_value)  { 1 }
-    let(:output_value) { 2   }
+    let(:output_value) { 2 }
 
     before do
       object.count = input_value
     end
 
-    it "peforms custom typecasting" do
-      object.count.should eql(output_value)
-    end
+    subject { object }
+
+    its(:count) { should eql(output_value) }
   end
 end

data/spec/unit/shared/attribute.rb

@@ -1,8 +1,8 @@
-shared_examples_for "Attribute" do
-  it_behaves_like 'Attribute.options'
+shared_examples_for 'Attribute' do
   it_behaves_like 'Attribute.accept_options'
   it_behaves_like 'Attribute.accepted_options'
+  it_behaves_like 'Attribute.primitive?'
+  it_behaves_like 'Attribute#inspect'
   it_behaves_like 'Attribute#set'
   it_behaves_like 'Attribute#get'
-  it_behaves_like 'Attribute#complex?'
 end