virtus 0.2.0 → 0.3.0

data/lib/virtus/attribute/default_value/from_callable.rb

@@ -0,0 +1,33 @@
+module Virtus
+  class Attribute
+    class DefaultValue
+
+      # Represents default value evaluated via a callable object
+      #
+      # @api private
+      class FromCallable < DefaultValue
+
+        # Return if the class can handle the value
+        #
+        # @return [Boolean]
+        #
+        # @api private
+        def self.handle?(attribute, value)
+          value.respond_to?(:call)
+        end
+
+        # Evaluates the value via value#call
+        #
+        # @param [Object]
+        #
+        # @return [Object] evaluated value
+        #
+        # @api private
+        def evaluate(instance)
+          @value.call(instance, @attribute)
+        end
+
+      end # class FromCallable
+    end # class DefaultValue
+  end # class Attribute
+end # module Virtus

data/lib/virtus/attribute/default_value/from_clonable.rb

@@ -0,0 +1,40 @@
+module Virtus
+  class Attribute
+    class DefaultValue
+
+      # Represents default value evaluated via a clonable object
+      #
+      # @api private
+      class FromClonable < DefaultValue
+        SINGLETON_CLASSES = [
+          ::NilClass, ::TrueClass, ::FalseClass, ::Numeric,  ::Symbol ].freeze
+
+        # Return if the class can handle the value
+        #
+        # @return [Boolean]
+        #
+        # @api private
+        def self.handle?(attribute, value)
+          case value
+          when *SINGLETON_CLASSES
+            false
+          else
+            true
+          end
+        end
+
+        # Evaluates the value via value#clone
+        #
+        # @param [Object]
+        #
+        # @return [Object] evaluated value
+        #
+        # @api private
+        def evaluate(instance)
+          @value.clone
+        end
+
+      end # class FromClonable
+    end # class DefaultValue
+  end # class Attribute
+end # module Virtus

data/lib/virtus/attribute/default_value/from_symbol.rb

@@ -0,0 +1,35 @@
+module Virtus
+  class Attribute
+    class DefaultValue
+
+      # Represents default value evaluated via a symbol
+      #
+      # @api private
+      class FromSymbol < DefaultValue
+
+        # Return if the class can handle the value
+        #
+        # @return [Boolean]
+        #
+        # @api private
+        def self.handle?(attribute, value)
+          value.is_a?(::Symbol)
+        end
+
+        # Evaluates the value via instance#__send__(value)
+        #
+        # Symbol value is returned if the instance doesn't respond to value
+        #
+        # @param [Object]
+        #
+        # @return [Object] evaluated value
+        #
+        # @api private
+        def evaluate(instance)
+          instance.respond_to?(@value) ? instance.__send__(@value) : @value
+        end
+
+      end # class FromSymbol
+    end # class DefaultValue
+  end # class Attribute
+end # module Virtus

data/lib/virtus/attribute/embedded_value.rb

@@ -25,6 +25,7 @@ module Virtus
     #     :street => 'Street 1/2', :zipcode => '12345', :city => 'NYC' })
     #
     class EmbeddedValue < Object
+      primitive ::OpenStruct
 
       # @see Attribute.merge_options
       #
@@ -33,19 +34,7 @@ module Virtus
       #
       # @api private
       def self.merge_options(type, options)
-        options.merge(:model => type)
-      end
-
-      # Sets @model ivar
-      #
-      # @see Virtus::Attribute#initialize
-      #
-      # @return [undefined]
-      #
-      # @api private
-      def initialize(name, options = {})
-        super
-        @model = options.fetch(:model, OpenStruct)
+        options.merge(:primitive => type)
       end
 
       # Coerce attributes into a virtus object
@@ -57,7 +46,7 @@ module Virtus
       # @api private
       def coerce(attributes_or_object)
         value = if attributes_or_object.kind_of?(::Hash)
-                  @model.new(attributes_or_object)
+                  @primitive.new(attributes_or_object)
                 else
                   attributes_or_object
                 end

data/lib/virtus/class_methods.rb

@@ -2,6 +2,8 @@ module Virtus
 
   # Class methods that are added when you include Virtus
   module ClassMethods
+    WRITER_METHOD_REGEXP   = /=\z/.freeze
+    INVALID_WRITER_METHODS = %w[ == != === []= attributes= ].to_set.freeze
 
     # Hook called when module is extended
     #
@@ -78,6 +80,21 @@ module Virtus
       @attributes = AttributeSet.new(parent)
     end
 
+    # The list of writer methods that can be mass-assigned to in #attributes=
+    #
+    # @return [Set]
+    #
+    # @api private
+    def allowed_writer_methods
+      @allowed_writer_methods ||=
+        begin
+          allowed_writer_methods  = public_instance_methods.map(&:to_s)
+          allowed_writer_methods  = allowed_writer_methods.grep(WRITER_METHOD_REGEXP).to_set
+          allowed_writer_methods -= INVALID_WRITER_METHODS
+          allowed_writer_methods.freeze
+        end
+    end
+
   protected
 
     # Set up the anonymous module which will host Attribute accessor methods

data/lib/virtus/coercion/hash.rb

@@ -7,17 +7,6 @@ module Virtus
 
       TIME_SEGMENTS = [ :year, :month, :day, :hour, :min, :sec ].freeze
 
-      # Creates an Array instance from a Hash
-      #
-      # @param [Hash] value
-      #
-      # @return [Array]
-      #
-      # @api private
-      def self.to_array(value)
-        value.to_a
-      end
-
       # Creates a Time instance from a Hash
       #
       # Valid keys are: :year, :month, :day, :hour, :min, :sec

data/lib/virtus/coercion/object.rb

@@ -7,6 +7,87 @@ module Virtus
 
       COERCION_METHOD_REGEXP = /\Ato_/.freeze
 
+      # Create an Array from any Object
+      #
+      # @example with an object that does not respond to #to_a or #to_ary
+      #   Virtus::Coercion::Object.to_array(value)         # => [ value ]
+      #
+      # @example with an object that responds to #to_a
+      #   Virtus::Coercion::Object.to_array(Set[ value ])  # => [ value ]
+      #
+      # @example with n object that responds to #to_ary
+      #   Virtus::Coercion::Object.to_array([ value ])     # => [ value ]
+      #
+      # @param [#to_a,#to_ary,Object] value
+      # @param [#to_a,#to_ary,Object] value
+      #
+      # @return [Array]
+      #
+      # @api public
+      def self.to_array(value)
+        Array(value)
+      end
+
+      # Create a Hash from the Object if possible
+      #
+      # @example with a coercible object
+      #   Virtus::Coercion::Object.to_hash(key => value)  # => { key => value }
+      #
+      # @example with an object that is not coercible
+      #   Virtus::Coercion::Object.to_hash(value)  # => value
+      #
+      # @param [#to_hash, Object] value
+      #
+      # @return [Hash]
+      #   returns a Hash when the object can be coerced
+      # @return [Object]
+      #   returns the value when the object cannot be coerced
+      #
+      # @api public
+      def self.to_hash(value)
+        coerce_with_method(value, :to_hash)
+      end
+
+      # Create a String from the Object if possible
+      #
+      # @example with a coercible object
+      #   Virtus::Coercion::Object.to_string("string")  # => "string"
+      #
+      # @example with an object that is not coercible
+      #   Virtus::Coercion::Object.to_string(value)  # => value
+      #
+      # @param [#to_str, Object] value
+      #
+      # @return [String]
+      #   returns a String when the object can be coerced
+      # @return [Object]
+      #   returns the value when the object cannot be coerced
+      #
+      # @api public
+      def self.to_string(value)
+        coerce_with_method(value, :to_str)
+      end
+
+      # Create an Integer from the Object if possible
+      #
+      # @example with a coercible object
+      #   Virtus::Coercion::Object.to_integer(1)  # => 1
+      #
+      # @example with an object that is not coercible
+      #   Virtus::Coercion::Object.to_integer(value)  # => value
+      #
+      # @param [#to_int, Object] value
+      #
+      # @return [Integer]
+      #   returns an Integer when the object can be coerced
+      # @return [Object]
+      #   returns the value when the object cannot be coerced
+      #
+      # @api public
+      def self.to_integer(value)
+        coerce_with_method(value, :to_int)
+      end
+
       # Passthrough given value
       #
       # @param [Object] value
@@ -22,6 +103,23 @@ module Virtus
         end
       end
 
+      private_class_method :method_missing
+
+      # Try to use native coercion method on the given value
+      #
+      # @param [Object] value
+      #
+      # @param [Symbol] method
+      #
+      # @return [Object]
+      #
+      # @api private
+      def self.coerce_with_method(value, method)
+        value.respond_to?(method) ? value.send(method) : value
+      end
+
+      private_class_method :coerce_with_method
+
     end # class Object
   end # class Coercion
 end # module Virtus

data/lib/virtus/coercion/string.rb

@@ -25,8 +25,15 @@ module Virtus
       #
       # @api public
       def self.to_constant(value)
-        # TODO: add support for namespaced classes like 'Virtus::Attribute::String'
-        ::Object.const_get(value)
+        names = value.split('::')
+        names.shift if names.first.empty?
+        names.inject(::Object) do |mod, name|
+          if mod.const_defined?(name, *EXTRA_CONST_ARGS)
+            mod.const_get(name, *EXTRA_CONST_ARGS)
+          else
+            mod.const_missing(name)
+          end
+        end
       end
 
       # Coerce give value to a symbol

data/lib/virtus/coercion/time_coercions.rb

@@ -73,11 +73,8 @@ module Virtus
       #
       # @api private
       def coerce_with_method(value, method)
-        if value.respond_to?(method)
-          value.send(method)
-        else
-          String.send(method, to_string(value))
-        end
+        coerced = super
+        coerced.equal?(value) ? String.send(method, to_string(value)) : coerced
       end
 
     end # module TimeCoercions

data/lib/virtus/instance_methods.rb

@@ -82,17 +82,14 @@ module Virtus
     #
     # @api public
     def attributes
-      self.class.attributes.each_with_object({}) do |attribute, attributes|
-        name = attribute.name
-        attributes[name] = self[name] if attribute.public_reader?
-      end
+      get_attributes(&:public_reader?)
     end
 
     # 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.
+    # All referenced Attribute writer methods *will* be called.
+    # Non-attribute setter methods on the receiver *will* be called.
     #
     # @example
     #   class User
@@ -112,11 +109,7 @@ module Virtus
     #
     # @api public
     def attributes=(attribute_values)
-      attributes = self.class.attributes
-      set_attributes(attribute_values.select { |name,|
-        attribute = attributes[name]
-        attribute && attribute.public_writer?
-      })
+      set_attributes(attribute_values)
     end
 
     # Returns a hash of all publicly accessible attributes
@@ -141,42 +134,28 @@ module Virtus
 
   private
 
-    # Mass-assign attribute values
-    #
-    # 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.
-    #
-    # @example
-    #   class User
-    #     include Virtus
-    #
-    #     attribute :name, String
-    #     attribute :age,  Integer
-    #   end
-    #
-    #   user = User.new
-    #   user.attributes = { :name => 'John', 'age' => 28 }
-    #
-    # @param [#to_hash] attribute_values
-    #   a hash of attribute names and values to set on the receiver
+    # Get values of all attributes defined for this class, ignoring privacy
     #
     # @return [Hash]
     #
     # @api private
-    def set_attributes(attribute_values)
-      attribute_values.each { |pair| set_attribute(*pair) }
+    def get_attributes
+      self.class.attributes.each_with_object({}) do |attribute, attributes|
+        name = attribute.name
+        attributes[name] = get_attribute(name) if yield(attribute)
+      end
     end
 
-    # Get values of all attributes defined for this class, ignoring privacy
+    # Mass-assign attribute values
+    #
+    # @see Virtus::InstanceMethods#attributes=
     #
     # @return [Hash]
     #
     # @api private
-    def get_attributes
-      self.class.attributes.each_with_object({}) do |attribute, attributes|
-        attribute_name = attribute.name
-        attributes[attribute_name] = get_attribute(attribute_name)
+    def set_attributes(attribute_values)
+      attribute_values.each do |name, value|
+        set_attribute(name, value) if self.class.allowed_writer_methods.include?("#{name}=")
       end
     end
 

data/lib/virtus/support/type_lookup.rb

@@ -3,8 +3,7 @@ module Virtus
   # A module that adds type lookup to a class
   module TypeLookup
 
-    TYPE_FORMAT      = /\A[A-Z]\w*\z/.freeze
-    EXTRA_CONST_ARGS = RUBY_VERSION < '1.9' || RUBY_ENGINE == 'rbx' ? [] : [ false ]
+    TYPE_FORMAT = /\A[A-Z]\w*\z/.freeze
 
     # Returns a descendant based on a name or class
     #

data/lib/virtus/value_object.rb

@@ -4,6 +4,7 @@ require 'virtus'
 require 'virtus/value_object/equalizer'
 
 module Virtus
+
   # Include this Module for Value Object semantics
   #
   # The idea is that instances should be immutable and compared based on state
@@ -22,6 +23,7 @@ module Virtus
   #   hash = { location => :foo }
   #   hash[same_location]             #=> :foo
   module ValueObject
+
     # Callback to configure including Class as a Value Object
     #
     # Including Class will include Virtus and have additional
@@ -41,17 +43,25 @@ module Virtus
       end
     end
 
+    private_class_method :included
+
     module InstanceMethods
+      # the #get_attributes method accept a Proc object that will filter
+      # out an attribute when the block returns false. the ValueObject
+      # needs all the attributes, so we allow every attribute.
+      FILTER_NONE = proc { true }
+
       def initialize(attributes = {})
         set_attributes(attributes)
       end
 
       def with(attribute_updates)
-        self.class.new(get_attributes.merge(attribute_updates))
+        self.class.new(get_attributes(&FILTER_NONE).merge(attribute_updates))
       end
     end
 
     module ClassMethods
+
       # Define an attribute on the receiver
       #
       # The Attribute will have private writer methods (eg., immutable instances)
@@ -73,7 +83,6 @@ module Virtus
       def attribute(name, type, options = {})
         equalizer << name
         options[:writer] = :private
-
         super
       end
 
@@ -91,14 +100,28 @@ module Virtus
       #
       # @api public
       def equalizer
-        return @equalizer if instance_variable_defined?('@equalizer')
+        @equalizer ||=
+          begin
+            equalizer = Equalizer.new(name || inspect)
+            include equalizer
+            equalizer
+          end
+      end
 
-        @equalizer = begin
-          equalizer = Equalizer.new(name || inspect)
-          include equalizer
-          equalizer
-        end
+      # The list of writer methods that can be mass-assigned to in #attributes=
+      #
+      # @return [Set]
+      #
+      # @api private
+      def allowed_writer_methods
+        @allowed_writer_methods ||=
+          begin
+            allowed_writer_methods = super
+            allowed_writer_methods += attributes.map{|attr| "#{attr.name}="}
+            allowed_writer_methods.to_set.freeze
+          end
       end
+
     end # module ClassMethods
   end # module ValueObject
 end # module Virtus