virtus 0.0.2 → 0.0.3

data/lib/virtus/support/chainable.rb

@@ -3,12 +3,10 @@ module Virtus
     module Chainable
       MODULES = {}
 
-      def chainable(key, &block)
-        begin
-          mod = (MODULES[key] ||= Module.new)
-          include mod
-          mod
-        end.module_eval(&block)
+      def chainable(key)
+        mod = MODULES[key] ||= Module.new
+        include mod
+        mod.module_eval { yield }
       end
     end
   end

data/lib/virtus/typecast/boolean.rb

@@ -0,0 +1,27 @@
+module Virtus
+  module Typecast
+    # Typecast defined values into true or false.
+    # See TRUE_VALUES and FALSE_VALUES constants for a reference.
+    class Boolean
+      TRUE_VALUES  = [ 1, '1', 't', 'T', 'true',  'TRUE'  ].freeze
+      FALSE_VALUES = [ 0, '0', 'f', 'F', 'false', 'FALSE' ].freeze
+
+      BOOLEAN_MAP  = Hash[TRUE_VALUES.product([ true ]) + FALSE_VALUES.product([ false ]) ].freeze
+
+      # Typecast value to TrueClass or FalseClass
+      #
+      # @example
+      #   Virtus::Typecast::Boolean.call('T') # => true
+      #   Virtus::Typecast::Boolean.call('F') # => false
+      #
+      # @param [Integer, String]
+      #
+      # @return [TrueClass, FalseClass]
+      #
+      # @api public
+      def self.call(value)
+        BOOLEAN_MAP.fetch(value, value)
+      end
+    end # Boolean
+  end # Typecast
+end # Virtus

data/lib/virtus/typecast/numeric.rb

@@ -0,0 +1,82 @@
+module Virtus
+  module Typecast
+    # Typecast numeric values. Supports Integer, Float and BigDecimal
+    class Numeric
+      # Typecast value to integer
+      #
+      # @example
+      #   Virtus::Typecast::Numeric.to_i('1') # => 1
+      #   Virtus::Typecast::Numeric.to_i(1.2) # => 1
+      #
+      # @param [Object]
+      #
+      # @return [Integer]
+      #
+      # @api public
+      def self.to_i(value)
+        call(value, :to_i)
+      end
+
+      # Typecast value to float
+      #
+      # @example
+      #   Virtus::Typecast::Numeric.to_f('1.2') # => 1.2
+      #   Virtus::Typecast::Numeric.to_f(1)     # => 1.0
+      #
+      # @param [Object]
+      #
+      # @return [Float]
+      #
+      # @api public
+      def self.to_f(value)
+        call(value, :to_f)
+      end
+
+      # Typecast value to decimal
+      #
+      # @example
+      #   Virtus::Typecast::Numeric.to_d('1.2') # => #<BigDecimal:b72157d4,'0.12E1',8(8)>
+      #   Virtus::Typecast::Numeric.to_d(1)     # => #<BigDecimal:b7212e08,'0.1E1',4(8)>
+      #
+      # @param [Object]
+      #
+      # @return [BigDecimal]
+      #
+      # @api public
+      def self.to_d(value)
+        if value.kind_of?(::Integer)
+          value.to_s.to_d
+        else
+          call(value, :to_d)
+        end
+      end
+
+      private
+
+      # Match numeric string
+      #
+      # @param [#to_str, Numeric] value
+      #   value to typecast
+      # @param [Symbol] method
+      #   method to typecast with
+      #
+      # @return [Numeric]
+      #   number if matched, value if no match
+      #
+      # @api private
+      def self.call(value, method)
+        if value.respond_to?(:to_str)
+          if value.to_str =~ /\A(-?(?:0|[1-9]\d*)(?:\.\d+)?|(?:\.\d+))\z/
+            $1.send(method)
+          else
+            value
+          end
+        elsif value.respond_to?(method)
+          value.send(method)
+        else
+          value
+        end
+      end
+    end # Numeric
+  end # Typecast
+end # Virtus

data/lib/virtus/typecast/time.rb

@@ -0,0 +1,162 @@
+module Virtus
+  module Typecast
+    # Typecast various values into Date, DateTime or Time
+    class Time
+      SEGMENTS = [ :year, :month, :day, :hour, :min, :sec ].freeze
+
+      METHOD_TO_CLASS = {
+        :to_time     => ::Time,
+        :to_date     => ::Date,
+        :to_datetime => ::DateTime
+      }.freeze
+
+      # Typecasts an arbitrary value to a Time
+      #
+      # Handles both Hashes and Time instances
+      #
+      # @example
+      #   Virtus::Typecast::Time.to_time('2011/06/09 12:01')
+      #   # => Thu Jun 09 12:01:00 +0200 2011
+      #
+      # @param [Hash, #to_mash, #to_s] value
+      #   value to be typecast
+      #
+      # @return [Time]
+      #   Time constructed from value
+      #
+      # @api public
+      def self.to_time(value)
+        call(value, :to_time)
+      end
+
+      # Typecasts an arbitrary value to a Date
+      #
+      # Handles both Hashes and Date instances
+      #
+      # @example
+      #   Virtus::Typecast::Time.to_date('2011/06/09')
+      #   # => #<Date: 4911443/2,0,2299161>
+      #
+      # @param [Hash, #to_mash, #to_s] value
+      #   value to be typecast
+      #
+      # @return [Date]
+      #   Date constructed from value
+      #
+      # @api public
+      def self.to_date(value)
+        call(value, :to_date)
+      end
+
+      # Typecasts an arbitrary value to a DateTime
+      #
+      # Handles both Hashes and DateTime instances
+      #
+      # @example
+      #   Virtus::Typecast::Time.to_datetime('2011/06/09 12:01')
+      #   # => #<DateTime: 3536239681/1440,0,2299161>
+      #
+      # @param [Hash, #to_mash, #to_s] value
+      #   value to be typecast
+      #
+      # @return [DateTime]
+      #   DateTime constructed from value
+      #
+      # @api public
+      def self.to_datetime(value)
+        call(value, :to_datetime)
+      end
+
+      private
+
+      # @api private
+      def self.call(value, method)
+        return value.send(method) if value.respond_to?(method)
+
+        begin
+          if value.is_a?(::Hash)
+            from_hash(value, method)
+          else
+            from_string(value.to_s, method)
+          end
+        rescue ArgumentError
+          return value
+        end
+      end
+
+      # @api private
+      def self.from_string(value, method)
+        METHOD_TO_CLASS[method].parse(value.to_s)
+      end
+
+      # @api private
+      def self.from_hash(value, method)
+        send("hash_#{method}", value)
+      end
+
+      # Creates a Time instance from a Hash
+      #
+      # Valid keys are: :year, :month, :day, :hour, :min, :sec
+      #
+      # @param [Hash, #to_mash] value
+      #   value to be typecast
+      #
+      # @return [Time]
+      #   Time constructed from hash
+      #
+      # @api private
+      def self.hash_to_time(value)
+        ::Time.local(*extract(value))
+      end
+
+      # Creates a Date instance from a Hash
+      #
+      # Valid keys are: :year, :month, :day, :hour
+      #
+      # @param [Hash, #to_mash] value
+      #   value to be typecast
+      #
+      # @return [Date]
+      #   Date constructed from hash
+      #
+      # @api private
+      def self.hash_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, #to_mash] value
+      #   value to be typecast
+      #
+      # @return [DateTime]
+      #   DateTime constructed from hash
+      #
+      # @api private
+      def self.hash_to_datetime(value)
+        ::DateTime.new(*extract(value))
+      end
+
+      # Extracts the given args from the hash
+      #
+      # If a value does not exist, it uses the value of Time.now
+      #
+      # @param [Hash, #to_mash] value
+      #   value to extract time args from
+      #
+      # @return [Array]
+      #   Extracted values
+      #
+      # @api private
+      def self.extract(value)
+        now = ::Time.now
+
+        SEGMENTS.map do |segment|
+          Numeric.to_i(value.fetch(segment, now.send(segment)))
+        end
+      end
+    end # Time
+  end # Typecast
+end # Virtus

data/spec/integration/virtus/attributes/attribute/typecast_spec.rb

@@ -1,9 +1,9 @@
 require 'spec_helper'
 
-describe Virtus::Attributes::Attribute, '#typecast' do
+describe Virtus::Attribute, '#typecast' do
   let(:attribute_class) do
-    Class.new(Virtus::Attributes::Integer) do
-      def typecast(value, object)
+    Class.new(Virtus::Attribute::Integer) do
+      def typecast(value)
         super + 1
       end
     end
@@ -30,7 +30,7 @@ describe Virtus::Attributes::Attribute, '#typecast' do
     end
 
     it "peforms custom typecasting" do
-      object.count.should == output_value
+      object.count.should eql(output_value)
     end
   end
 end

data/spec/integration/virtus/class_methods/attribute_spec.rb

@@ -25,7 +25,7 @@ describe Virtus::ClassMethods, '.attribute' do
     end
 
     it "should create an attribute of a correct type" do
-      described_class.attributes[:name].should be_instance_of(Virtus::Attributes::String)
+      described_class.attributes[:name].should be_instance_of(Virtus::Attribute::String)
     end
 
     it "creates attribute writer" do

data/spec/integration/virtus/class_methods/attributes_spec.rb

@@ -16,9 +16,10 @@ describe Virtus::ClassMethods, '.attributes' do
     subject { described_class.attributes }
 
     it "returns an attributes hash" do
-      subject.should == {
+      subject.should eql(
         :name => described_class.attributes[:name],
-        :age  => described_class.attributes[:age] }
+        :age  => described_class.attributes[:age]
+      )
     end
   end
 end

data/spec/integration/virtus/class_methods/const_missing_spec.rb

@@ -14,7 +14,7 @@ describe Virtus::ClassMethods, '.const_missing' do
     end
 
     it "should create attribute of the correct type" do
-      User.attributes[:name].should be_instance_of(Virtus::Attributes::String)
+      User.attributes[:name].should be_instance_of(Virtus::Attribute::String)
     end
   end
 
@@ -27,7 +27,7 @@ describe Virtus::ClassMethods, '.const_missing' do
     end
 
     it "should create attribute of the correct type" do
-      User.attributes[:admin].should be_instance_of(Virtus::Attributes::Boolean)
+      User.attributes[:admin].should be_instance_of(Virtus::Attribute::Boolean)
     end
   end
 

data/spec/rcov.opts

@@ -0,0 +1,6 @@
+--exclude-only "spec/,^/"
+--sort coverage
+--callsites
+--xrefs
+--profile
+--text-summary

data/spec/spec_helper.rb

@@ -2,15 +2,6 @@ require 'pathname'
 require 'rubygems'
 require 'rspec'
 
-if ENV['SPEC_COV'] && RUBY_VERSION >= '1.9.2'
-  require 'simplecov'
-
-  SimpleCov.start do
-    add_filter "/spec/"
-    add_group "lib", "lib"
-  end
-end
-
 require 'virtus'
 
 ENV['TZ'] = 'UTC'

data/spec/unit/shared/attribute.rb

@@ -27,7 +27,7 @@ shared_examples_for "Attribute" do
     end
 
     it "accepts base options" do
-      described_class.accepted_options.should include(*Virtus::Attributes::Attribute::OPTIONS)
+      described_class.accepted_options.should include(*Virtus::Attribute::OPTIONS)
     end
   end
 
@@ -65,20 +65,20 @@ shared_examples_for "Attribute" do
       end
 
       context "when new attribute is created" do
-        subject { sub_attribute.new(attribute_name, model) }
+        subject { sub_attribute.new(attribute_name) }
 
         it "sets the default value" do
-          subject.options[option].should == value
+          subject.options[option].should eql(value)
         end
       end
 
       context "when new attribute is created and overrides option's default value" do
         let(:new_value) { 11 }
 
-        subject { sub_attribute.new(attribute_name, model, option => new_value) }
+        subject { sub_attribute.new(attribute_name, option => new_value) }
 
         it "sets the new value" do
-          subject.options[option].should == new_value
+          subject.options[option].should eql(new_value)
         end
       end
     end
@@ -105,7 +105,7 @@ shared_examples_for "Attribute" do
       before { attribute.set(object, attribute_value) }
 
       it "sets the value in an ivar" do
-        object.instance_variable_get(attribute.instance_variable_name).should == attribute_value
+        object.instance_variable_get(attribute.instance_variable_name).should eql(attribute_value)
       end
     end
 
@@ -127,7 +127,7 @@ shared_examples_for "Attribute" do
 
       subject { attribute.get(object) }
 
-      it { should == attribute_value }
+      it { should eql(attribute_value) }
     end
 
     context "when nil is set" do
@@ -139,7 +139,7 @@ shared_examples_for "Attribute" do
     end
   end
 
-  describe "#complex" do
+  describe "#complex?" do
     let(:attribute) { model.attribute(attribute_name, described_class, :complex => complex) }
 
     subject { attribute.complex? }

data/spec/unit/virtus/{attributes → attribute}/array_spec.rb

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe Virtus::Attributes::Array do
+describe Virtus::Attribute::Array do
   it_should_behave_like 'Attribute' do
     let(:attribute_name)        { :colors }
     let(:attribute_value)       { [ 'red', 'green', 'blue' ] }