virtus 0.0.10 → 0.1.0

data/lib/virtus/attribute/array.rb

@@ -12,10 +12,26 @@ module Virtus
     #
     #   post = Post.new(:tags => %w(red green blue))
     #
-    class Array < Object
+    class Array < Collection
       primitive       ::Array
       coercion_method :to_array
 
+      # Coerce a member of a source collection and append it to the target collection
+      #
+      # @param [Array, Set] collection
+      #   target collection to which the coerced member should be appended
+      #
+      # @param [Object] entry
+      #   the member that should be coerced and appended
+      #
+      # @return [Array, Set]
+      #   collection with the coerced member appended to it
+      #
+      # @api private
+      def coerce_and_append_member(collection, entry)
+        collection << @member_type_instance.coerce(entry)
+      end
+
     end # class Array
   end # class Attribute
 end # module Virtus

data/lib/virtus/attribute/boolean.rb

@@ -21,19 +21,20 @@ module Virtus
       # Returns if the given value is either true or false
       #
       # @example
-      #   Virtus::Attribute::Boolean.primitive?(true)    # => true
-      #   Virtus::Attribute::Boolean.primitive?(false)   # => true
-      #   Virtus::Attribute::Boolean.primitive?(1)       # => false
-      #   Virtus::Attribute::Boolean.primitive?('true')  # => false
+      #   boolean = Virtus::Attribute::Boolean.new(:bool)
+      #   boolean.value_coerced?(true)    # => true
+      #   boolean.value_coerced?(false)   # => true
+      #   boolean.value_coerced?(1)       # => false
+      #   boolean.value_coerced?('true')  # => false
       #
       # @return [Boolean]
       #
       # @api public
-      def self.primitive?(value)
+      def value_coerced?(value)
         value.equal?(true) || value.equal?(false)
       end
 
-      # Creates standard and boolean attribute reader methods
+      # Creates an attribute reader method as a query
       #
       # @param [Module] mod
       #
@@ -42,13 +43,7 @@ module Virtus
       # @api private
       def define_reader_method(mod)
         super
-
-        reader_method_name = "#{name}?"
-        attribute          = self
-
-        mod.send(:define_method,    reader_method_name) { attribute.get(self) }
-        mod.send(reader_visibility, reader_method_name)
-
+        mod.define_reader_method(self, "#{name}?", reader_visibility)
         self
       end
 

data/lib/virtus/attribute/collection.rb

@@ -0,0 +1,96 @@
+module Virtus
+  class Attribute
+
+    # Abstract superclass for collection Attributes.
+    #
+    # Handles coercing members to the designated member type.
+    #
+    # @abstract
+    class Collection < Object
+
+      # The type to which members of this collection will be coerced
+      #
+      # @example
+      #
+      #   class Post
+      #     include Virtus
+      #
+      #     attribute :tags, Array[String]
+      #   end
+      #
+      #   Post.attributes[:tags].member_type # => Virtus::Attribute::String
+      #
+      # @return [Virtus::Attribute]
+      #
+      # @api public
+      attr_reader :member_type
+
+      # Handles collection with member_type syntax
+      #
+      # @param [Class]
+      #
+      # @param [Hash]
+      #
+      # @return [Hash]
+      #
+      # @api private
+      def self.merge_options(type, options)
+        if !type.respond_to?(:size)
+          options
+        elsif type.size > 1
+          raise NotImplementedError, "build SumType from list of types (#{type.inspect})"
+        else
+          options.merge(:member_type => type.first)
+        end
+      end
+
+      # Init an instance of Virtus::Attribute::Collection
+      #
+      # @api private
+      def initialize(*)
+        super
+        @member_type = @options.fetch(:member_type, Virtus::Attribute::Object)
+        @member_type_instance = Attribute.build(@name, @member_type)
+      end
+
+      # Coerce a collection with members
+      #
+      # @param [Object]
+      #
+      # @return [Object]
+      #
+      # @api private
+      def coerce(value)
+        coerced = super
+        return coerced unless coerced.respond_to?(:inject)
+        coerced.inject(new_collection) do |collection, entry|
+          coerce_and_append_member(collection, entry)
+        end
+      end
+
+      # Return an instance of the collection
+      #
+      # @return [Enumerable]
+      #
+      # @api private
+      def new_collection
+        self.class.primitive.new
+      end
+
+      # Coerce entry and add it to the collection
+      #
+      # @abstract
+      #
+      # @raise NotImplementedError
+      #
+      # @return [undefined]
+      #
+      # @api private
+      def coerce_and_append_member(collection, entry)
+        raise NotImplementedError,
+          "#{self.class}#coerce_and_append_member has not been implemented"
+      end
+
+    end # class Array
+  end # class Attribute
+end # module Virtus

data/lib/virtus/attribute/default_value.rb

@@ -3,8 +3,8 @@ module Virtus
 
     # Class representing the default value option
     class DefaultValue
-      DUP_CLASSES = [ ::NilClass, ::TrueClass, ::FalseClass,
-                      ::Numeric,  ::Symbol ].freeze
+      SINGLETON_CLASSES = [ ::NilClass, ::TrueClass, ::FalseClass,
+                            ::Numeric,  ::Symbol ].freeze
 
       # Returns the attribute associated with this default value instance
       #
@@ -42,8 +42,8 @@ module Virtus
       def evaluate(instance)
         if callable?
           call(instance)
-        elsif duplicable?
-          value.dup
+        elsif cloneable?
+          value.clone
         else
           value
         end
@@ -71,13 +71,17 @@ module Virtus
         value.respond_to?(:call)
       end
 
-      # Returns whether or not the value is duplicable
+      # Returns whether or not the value is cloneable
       #
       # # return [TrueClass, FalseClass]
       #
       # @api private
-      def duplicable?
-        DUP_CLASSES.none? { |klass| value.kind_of?(klass) }
+      def cloneable?
+        case value
+        when *SINGLETON_CLASSES then false
+        else
+          true
+        end
       end
 
     end # class DefaultValue

data/lib/virtus/attribute/embedded_value.rb

@@ -0,0 +1,70 @@
+require 'ostruct'
+
+module Virtus
+  class Attribute
+
+    # EmbeddedValue
+    #
+    # @example
+    #
+    #   class Address
+    #     include Virtus
+    #
+    #     attribute :street,  String
+    #     attribute :zipcode, String
+    #     attribute :city,    String
+    #   end
+    #
+    #   class User
+    #     include Virtus
+    #
+    #     attribute :address, Address
+    #   end
+    #
+    #   user = User.new(:address => {
+    #     :street => 'Street 1/2', :zipcode => '12345', :city => 'NYC' })
+    #
+    class EmbeddedValue < Object
+
+      # @see Attribute.merge_options
+      #
+      # @return [Hash]
+      #   an updated options hash for configuring an EmbeddedValue instance
+      #
+      # @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)
+      end
+
+      # Coerce attributes into a virtus object
+      #
+      # @param [Hash,Virtus]
+      #
+      # @return [Virtus]
+      #
+      # @api private
+      def coerce(attributes_or_object)
+        value = if attributes_or_object.kind_of?(::Hash)
+                  @model.new(attributes_or_object)
+                else
+                  attributes_or_object
+                end
+
+        super(value)
+      end
+
+    end # class EmbeddedValue
+  end # class Attribute
+end # module Virtus

data/lib/virtus/attribute/set.rb

@@ -0,0 +1,25 @@
+module Virtus
+  class Attribute
+
+    # Set
+    #
+    # @example
+    #   class Post
+    #     include Virtus
+    #
+    #     attribute :tags, Set
+    #   end
+    #
+    #   post = Post.new(:tags => %w(red green blue))
+    #
+    class Set < Collection
+      primitive       ::Set
+      coercion_method :to_set
+
+      def coerce_and_append_member(collection, entry)
+        collection << @member_type_instance.coerce(entry)
+      end
+
+    end # class Set
+  end # class Attribute
+end # module Virtus

data/lib/virtus/attribute_set.rb

@@ -24,9 +24,10 @@ module Virtus
     #
     # @api private
     def initialize(parent = nil, attributes = [])
-      @parent     = parent
-      @attributes = attributes.dup
-      @index      = {}
+      @parent       = parent
+      @attributes   = attributes.dup
+      @index        = {}
+      @string_index = {}
       reset
     end
 
@@ -91,7 +92,7 @@ module Virtus
     #
     # @api public
     def [](name)
-      @index[name]
+      @index.fetch(name) { @string_index[name] }
     end
 
     # Set an attribute by name
@@ -106,9 +107,8 @@ module Virtus
     #
     # @api public
     def []=(name, attribute)
-      delete(name)
       @attributes << attribute
-      @index[name] = attribute
+      update_index(name, attribute)
     end
 
     # Reset the index when the parent is updated
@@ -118,33 +118,35 @@ module Virtus
     # @api private
     def reset
       parent = self.parent
-      merge_index(parent) if parent
-      merge_index(@attributes)
+      merge_attributes(parent) if parent
+      merge_attributes(@attributes)
       self
     end
 
   private
 
-    # Delete the Attribute by name
+    # Merge the attributes into the index
     #
-    # @param [Symbol] name
+    # @param [Array<Attribute>] attributes
     #
     # @return [undefined]
     #
     # @api private
-    def delete(name)
-      @attributes.delete(@index.delete(name))
+    def merge_attributes(attributes)
+      attributes.each { |attribute| update_index(attribute.name, attribute) }
     end
 
-    # Add the attributes to the index
+    # Update the symbol and string indexes with the attribute
     #
-    # @param [Array<Attribute>] attributes
+    # @param [Symbol] name
+    #
+    # @param [Attribute] attribute
     #
     # @return [undefined]
     #
     # @api private
-    def merge_index(attributes)
-      attributes.each { |attribute| @index[attribute.name] = attribute }
+    def update_index(name, attribute)
+      @index[name] = @string_index[name.to_s.freeze] = attribute
     end
 
   end # class AttributeSet

data/lib/virtus/attributes_accessor.rb

@@ -0,0 +1,66 @@
+module Virtus
+
+  # Host attribute accessor methods
+  class AttributesAccessor < Module
+
+    # The inspect value of this Module
+    #
+    # This provides meaningful output when inspecting the ancestors
+    # of a class/module that includes this module
+    #
+    # @example
+    #
+    #   class ClassWithAttributes
+    #     include Virtus
+    #   end
+    #
+    #   mod = ClassWithAttributes.send(:virtus_setup_attributes_accessor_module)
+    #   mod.inspect
+    #
+    # @return [String]
+    #
+    # @api public
+    attr_reader :inspect
+
+    # Initialize a module for hosting Attribute access methods
+    #
+    # @param [Symbol, String] name
+    #
+    # @api private
+    def initialize(name)
+      super()
+      @inspect = "#{name}::AttributesAccessor"
+    end
+
+    # Defines an attribute reader method
+    #
+    # @param [Attribute] attribute
+    # @param [Symbol] method_name
+    # @param [Symbol] visibility
+    #
+    # @return [self]
+    #
+    # @api private
+    def define_reader_method(attribute, method_name, visibility)
+      define_method(method_name) { attribute.get(self) }
+      send(visibility, method_name)
+      self
+    end
+
+    # Defines an attribute writer method
+    #
+    # @param [Attribute] attribute
+    # @param [Symbol] method_name
+    # @param [Symbol] visibility
+    #
+    # @return [self]
+    #
+    # @api private
+    def define_writer_method(attribute, method_name, visibility)
+      define_method(method_name) { |value| attribute.set(self, value) }
+      send(visibility, method_name)
+      self
+    end
+
+  end
+end