virtus 0.0.10 → 0.1.0

data/lib/virtus/class_methods.rb

@@ -12,8 +12,10 @@ module Virtus
     # @api private
     def self.extended(descendant)
       super
-      descendant.extend(DescendantsTracker)
-      descendant.const_set(:AttributeMethods, Module.new)
+      descendant.module_eval do
+        extend DescendantsTracker
+        virtus_setup_attributes_accessor_module
+      end
     end
 
     private_class_method :extended
@@ -41,10 +43,12 @@ module Virtus
     #
     # @return [self]
     #
+    # @see Attribute.build
+    #
     # @api public
-    def attribute(name, type, options = {})
-      attribute = Attribute.determine_type(type).new(name, options)
-      virtus_define_attribute_methods(attribute)
+    def attribute(*args)
+      attribute = Attribute.build(*args)
+      attribute.define_accessor_methods(virtus_attributes_accessor_module)
       virtus_add_attribute(attribute)
       self
     end
@@ -67,44 +71,62 @@ module Virtus
     #
     # @api public
     def attributes
-      @attributes ||= begin
-        superclass = self.superclass
-        parent     = superclass.attributes if superclass.respond_to?(:attributes)
-        AttributeSet.new(parent)
-      end
+      return @attributes if defined?(@attributes)
+      superclass  = self.superclass
+      method      = __method__
+      parent      = superclass.send(method) if superclass.respond_to?(method)
+      @attributes = AttributeSet.new(parent)
     end
 
-  private
+  protected
 
-    # Hooks into const missing process to determine types of attributes
-    #
-    # It is used when an attribute is defined and a global class like String
-    # or Integer is provided as the type which needs to be mapped to
-    # Virtus::Attribute::String and Virtus::Attribute::Integer
-    #
-    # @param [String] name
+    # Set up the anonymous module which will host Attribute accessor methods
     #
-    # @return [Class]
+    # @return [self]
     #
     # @api private
-    def const_missing(name)
-      Attribute.determine_type(name) || super
+    def virtus_setup_attributes_accessor_module
+      @virtus_attributes_accessor_module = AttributesAccessor.new(inspect)
+      include virtus_attributes_accessor_module
+      self
     end
 
-    # Define the attribute reader and writer methods in the class
+  private
+
+    # Setup descendants' own Attribute-accessor-method-hosting modules
     #
-    # @param [Attribute]
+    # Descendants inherit Attribute accessor methods via Ruby's inheritance
+    # mechanism: Attribute accessor methods are defined in a module included
+    # in a superclass. Attributes defined on descendants add methods to the
+    # descendant's Attributes accessor module, leaving the superclass's method
+    # table unaffected.
+    #
+    # @param [Class] descendant
     #
     # @return [undefined]
     #
     # @api private
-    def virtus_define_attribute_methods(attribute)
-      module_with_methods = self::AttributeMethods
+    def inherited(descendant)
+      super
+      descendant.virtus_setup_attributes_accessor_module
+    end
 
-      attribute.define_reader_method(module_with_methods)
-      attribute.define_writer_method(module_with_methods)
+    # Holds the anonymous module which hosts this class's Attribute accessors
+    #
+    # @return [Module]
+    #
+    # @api private
+    attr_reader :virtus_attributes_accessor_module
 
-      include module_with_methods
+    # Hooks into const missing process to determine types of attributes
+    #
+    # @param [String] name
+    #
+    # @return [Class]
+    #
+    # @api private
+    def const_missing(name)
+      Attribute.determine_type(name) || super
     end
 
     # Add the attribute to the class' and descendants' attributes

data/lib/virtus/coercion/array.rb

@@ -0,0 +1,23 @@
+module Virtus
+  class Coercion
+
+    # 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 self.to_set(value)
+        value.to_set
+      end
+
+    end # class Array
+  end # class Coercion
+end # module Virtus

data/lib/virtus/coercion/string.rb

@@ -5,11 +5,14 @@ module Virtus
     class String < Object
       primitive ::String
 
-      TRUE_VALUES  = %w[ 1 t true  ].freeze
-      FALSE_VALUES = %w[ 0 f false ].freeze
+      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
 
-      NUMERIC_REGEXP = /\A(-?(?:0|[1-9]\d*)(?:\.\d+)?|(?:\.\d+))\z/.freeze
+      INTEGER_REGEXP    = /[-+]?(?:0|[1-9]\d*)/.freeze
+      EXPONENT_REGEXP   = /(?:[eE][-+]?\d+)/.freeze
+      FRACTIONAL_REGEXP = /(?:\.\d+#{EXPONENT_REGEXP}?)/.freeze
+      NUMERIC_REGEXP    = /\A(#{INTEGER_REGEXP}#{FRACTIONAL_REGEXP}?|#{FRACTIONAL_REGEXP})\z/.freeze
 
       # Coerce give value to a constant
       #
@@ -96,7 +99,10 @@ module Virtus
       #
       # @api public
       def self.to_integer(value)
-        to_numeric(value, :to_i)
+        # coerce to a Float first to evaluate scientific notation (if any)
+        # that may change the integer part, then convert to an integer
+        coerced = to_float(value)
+        ::Float === coerced ? coerced.to_i : coerced
       end
 
       # Coerce value to float

data/lib/virtus/instance_methods.rb

@@ -11,8 +11,8 @@ module Virtus
     # @return [undefined]
     #
     # @api private
-    def initialize(attributes = {})
-      self.attributes = attributes
+    def initialize(attribute_values = {})
+      self.attributes = attribute_values
     end
 
     # Returns a value of the attribute with the given name
@@ -35,7 +35,7 @@ module Virtus
     #
     # @api public
     def [](name)
-      attribute_get(name)
+      __send__(name)
     end
 
     # Sets a value of the attribute with the given name
@@ -62,7 +62,7 @@ module Virtus
     #
     # @api public
     def []=(name, value)
-      attribute_set(name, value)
+      __send__("#{name}=", value)
     end
 
     # Returns a hash of all publicly accessible attributes
@@ -82,17 +82,17 @@ module Virtus
     #
     # @api public
     def attributes
-      attributes = {}
-
-      self.class.attributes.each do |attribute|
+      self.class.attributes.each_with_object({}) do |attribute, attributes|
         name = attribute.name
-        attributes[name] = attribute_get(name) if respond_to?(name)
+        attributes[name] = self[name] if attribute.public_reader?
       end
-
-      attributes
     end
 
-    # Mass-assign of attribute values
+    # Mass-assign attribute values
+    #
+    # Keys in the +attribute_values+ param can be symbols or strings.
+    # Only non-private referenced Attribute writer methods will be called.
+    # Non-attribute setter methods on the receiver will not be called.
     #
     # @example
     #   class User
@@ -103,18 +103,20 @@ module Virtus
     #   end
     #
     #   user = User.new
-    #   user.attributes = { :name => 'John', :age => 28 }
+    #   user.attributes = { :name => 'John', 'age' => 28 }
     #
-    # @param [#to_hash] attributes
-    #   a hash of attribute values to be set on an object
+    # @param [#to_hash] attribute_values
+    #   a hash of attribute names and values to set on the receiver
     #
     # @return [Hash]
     #
     # @api public
-    def attributes=(attributes)
-      attributes.to_hash.each do |name, value|
-        attribute_set(name, value) if respond_to?("#{name}=")
-      end
+    def attributes=(attribute_values)
+      attributes = self.class.attributes
+      set_attributes(attribute_values.select { |name,|
+        attribute = attributes[name]
+        attribute && attribute.public_writer?
+      })
     end
 
     # Returns a hash of all publicly accessible attributes
@@ -139,26 +141,31 @@ module Virtus
 
   private
 
-    # Returns a value of the attribute with the given name
+    # Mass-assign attribute values
     #
-    # @see Virtus::InstanceMethods#[]
+    # Keys in the +attribute_values+ param can be symbols or strings.
+    # All referenced Attribute writer methods *will* be called.
+    # Non-attribute setter methods on the receiver *will* be called.
     #
-    # @return [Object]
+    # @example
+    #   class User
+    #     include Virtus
     #
-    # @api private
-    def attribute_get(name)
-      __send__(name)
-    end
-
-    # Sets a value of the attribute with the given name
+    #     attribute :name, String
+    #     attribute :age,  Integer
+    #   end
     #
-    # @see Virtus::InstanceMethods#[]=
+    #   user = User.new
+    #   user.attributes = { :name => 'John', 'age' => 28 }
     #
-    # @return [Object]
+    # @param [#to_hash] attribute_values
+    #   a hash of attribute names and values to set on the receiver
+    #
+    # @return [Hash]
     #
     # @api private
-    def attribute_set(name, value)
-      __send__("#{name}=", value)
+    def set_attributes(attribute_values)
+      attribute_values.each { |name, value| self[name] = value }
     end
 
   end # module InstanceMethods

data/lib/virtus/support/options.rb

@@ -14,12 +14,10 @@ module Virtus
     #
     # @api public
     def options
-      options = {}
-      accepted_options.each do |option_name|
+      accepted_options.each_with_object({}) do |option_name, options|
         option_value         = send(option_name)
         options[option_name] = option_value unless option_value.nil?
       end
-      options
     end
 
     # Returns an array of valid options
@@ -43,8 +41,7 @@ module Virtus
     #     accept_options :foo, :bar
     #   end
     #
-    # @return [Array]
-    #   All accepted options
+    # @return [self]
     #
     # @api public
     def accept_options(*new_options)
@@ -66,20 +63,21 @@ module Virtus
         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 [#to_hash] new_options
+    # @param [#each] new_options
     #   options to be set
     #
     # @return [self]
     #
     # @api private
     def set_options(new_options)
-      new_options.to_hash.each { |pair| send(*pair) }
+      new_options.each { |pair| send(*pair) }
       self
     end
 
@@ -92,7 +90,7 @@ module Virtus
     #
     # @api private
     def add_accepted_options(new_options)
-      accepted_options.concat(new_options.to_ary)
+      accepted_options.concat(new_options)
       self
     end
 

data/lib/virtus/support/type_lookup.rb

@@ -3,7 +3,8 @@ module Virtus
   # A module that adds type lookup to a class
   module TypeLookup
 
-    TYPE_FORMAT = /\A(?:[A-Z]\w*)\z/.freeze
+    TYPE_FORMAT      = /\A[A-Z]\w*\z/.freeze
+    EXTRA_CONST_ARGS = RUBY_VERSION < '1.9' || RUBY_ENGINE == 'rbx' ? [] : [ false ]
 
     # Returns a descendant based on a name or class
     #
@@ -84,16 +85,8 @@ module Virtus
     #
     # @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' || RUBY_ENGINE == 'rbx'
-      def determine_type_from_string(string)
-        if string =~ TYPE_FORMAT && const_defined?(string)
-          const_get(string)
-        end
+      if string =~ TYPE_FORMAT && const_defined?(string, *EXTRA_CONST_ARGS)
+        const_get(string, *EXTRA_CONST_ARGS)
       end
     end
 

data/lib/virtus/version.rb

@@ -1,3 +1,3 @@
 module Virtus
-  VERSION = '0.0.10'
+  VERSION = '0.1.0'
 end

data/spec/integration/collection_member_coercion_spec.rb

@@ -0,0 +1,75 @@
+require 'spec_helper'
+
+# TODO: refactor to make it inline with the new style of integration specs
+
+class Address
+  include Virtus
+
+  attribute :address,     String
+  attribute :locality,    String
+  attribute :region,      String
+  attribute :postal_code, String
+end
+
+class PhoneNumber
+  include Virtus
+
+  attribute :number, String
+end
+
+class User
+  include Virtus
+
+  attribute :phone_numbers, Array[PhoneNumber]
+  attribute :addresses,     Set[Address]
+end
+
+describe User do
+  it { should respond_to(:phone_numbers)  }
+  it { should respond_to(:phone_numbers=) }
+  it { should respond_to(:addresses)  }
+  it { should respond_to(:addresses=) }
+
+  let(:instance) do
+    described_class.new(:phone_numbers => phone_numbers_attributes,
+                        :addresses     => addresses_attributes)
+  end
+
+  let(:phone_numbers_attributes) { [
+    { :number => '212-555-1212' },
+    { :number => '919-444-3265' },
+  ] }
+
+  let(:addresses_attributes) { [
+    { :address => '1234 Any St.', :locality => 'Anytown', :region => "DC", :postal_code => "21234" },
+  ] }
+
+  describe '#phone_numbers' do
+    describe 'first entry' do
+      subject { instance.phone_numbers.first }
+
+      it { should be_instance_of(PhoneNumber) }
+
+      its(:number)  { should eql('212-555-1212') }
+    end
+
+    describe 'last entry' do
+      subject { instance.phone_numbers.last }
+
+      it { should be_instance_of(PhoneNumber) }
+
+      its(:number)  { should eql('919-444-3265') }
+    end
+  end
+
+  describe '#addresses' do
+    subject { instance.addresses.first }
+
+    it { should be_instance_of(Address) }
+
+    its(:address)     { should eql('1234 Any St.') }
+    its(:locality)    { should eql('Anytown')      }
+    its(:region)      { should eql('DC')           }
+    its(:postal_code) { should eql('21234')        }
+  end
+end