virtus 0.5.5 → 1.0.0.beta3

data/lib/virtus/class_inclusions.rb

@@ -13,29 +13,36 @@ module Virtus
     def self.included(descendant)
       super
       descendant.extend(ClassMethods)
+      descendant.class_eval { include Methods }
       descendant.class_eval { include InstanceMethods }
+      descendant.class_eval { include InstanceMethods::Constructor }
+      descendant.class_eval { include InstanceMethods::MassAssignment }
     end
     private_class_method :included
 
-  private
+    module Methods
 
-    # Return class' attribute set
-    #
-    # @return [Virtus::AttributeSet]
-    #
-    # @api private
-    def attribute_set
-      self.class.attribute_set
-    end
+      # Return a list of allowed writer method names
+      #
+      # @return [Set]
+      #
+      # @api private
+      def allowed_writer_methods
+        self.class.allowed_writer_methods
+      end
 
-    # Return a list of allowed writer method names
-    #
-    # @return [Set]
-    #
-    # @api private
-    def allowed_writer_methods
-      self.class.allowed_writer_methods
-    end
+      private
+
+      # Return class' attribute set
+      #
+      # @return [Virtus::AttributeSet]
+      #
+      # @api private
+      def attribute_set
+        self.class.attribute_set
+      end
+
+    end # Methods
 
   end # module ClassInclusions
 end # module Virtus

data/lib/virtus/class_methods.rb

@@ -2,7 +2,8 @@ module Virtus
 
   # Class methods that are added when you include Virtus
   module ClassMethods
-    include Extensions
+    include Extensions::Methods
+    include ConstMissingExtensions
 
     # Hook called when module is extended
     #
@@ -13,12 +14,12 @@ module Virtus
     # @api private
     def self.extended(descendant)
       super
+      AttributeSet.create(descendant)
       descendant.module_eval do
         extend DescendantsTracker
         include attribute_set
       end
     end
-
     private_class_method :extended
 
     # Returns all the attributes defined on a Class
@@ -39,11 +40,7 @@ module Virtus
     #
     # @api public
     def attribute_set
-      return @attribute_set if defined?(@attribute_set)
-      superclass  = self.superclass
-      method      = __method__
-      parent      = superclass.public_send(method) if superclass.respond_to?(method)
-      @attribute_set = AttributeSet.new(parent)
+      @attribute_set
     end
 
     # @see Virtus::ClassMethods.attribute_set
@@ -56,18 +53,7 @@ module Virtus
       attribute_set
     end
 
-    # 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) or super
-    end
-
-  private
+    private
 
     # Setup descendants' own Attribute-accessor-method-hosting modules
     #
@@ -84,21 +70,10 @@ module Virtus
     # @api private
     def inherited(descendant)
       super
+      AttributeSet.create(descendant)
       descendant.module_eval { include attribute_set }
     end
 
-    # Add the attribute to the class' and descendants' attributes
-    #
-    # @param [Attribute]
-    #
-    # @return [undefined]
-    #
-    # @api private
-    def virtus_add_attribute(attribute)
-      super
-      descendants.each { |descendant| descendant.attribute_set.reset }
-    end
-
     # The list of allowed public methods
     #
     # @return [Array<String>]
@@ -108,5 +83,12 @@ module Virtus
       public_instance_methods.map(&:to_s)
     end
 
+    # @api private
+    def assert_valid_name(name)
+      if instance_methods.include?(:attributes) && name.to_sym == :attributes
+        raise ArgumentError, "#{name.inspect} is not allowed as an attribute name"
+      end
+    end
+
   end # module ClassMethods
 end # module Virtus

data/lib/virtus/configuration.rb

@@ -0,0 +1,77 @@
+module Virtus
+
+  # A Configuration instance
+  class Configuration
+
+    # Access the coerce setting for this instance
+    attr_accessor :coerce
+
+    # Access the strict setting for this instance
+    attr_accessor :strict
+
+    # Access the constructor setting for this instance
+    attr_accessor :constructor
+
+    # Access the mass-assignment setting for this instance
+    attr_accessor :mass_assignment
+
+    # Build new configuration instance using the passed block
+    #
+    # @example
+    #   Configuration.build do |config|
+    #     config.coerce = false
+    #   end
+    #
+    # @return [Configuration]
+    #
+    # @api public
+    def self.build(&block)
+      new.call(&block)
+    end
+
+    # Initialized a configuration instance
+    #
+    # @return [undefined]
+    #
+    # @api private
+    def initialize
+      @coerce          = true
+      @strict          = false
+      @constructor     = true
+      @mass_assignment = true
+      @coercer         = Coercible::Coercer.new
+    end
+
+    # Provide access to the attributes and methods via the passed block
+    #
+    # @example
+    #   configuration.call do |config|
+    #     config.coerce = false
+    #   end
+    #
+    # @return [self]
+    #
+    # @api private
+    def call(&block)
+      block.call(self) if block_given?
+      self
+    end
+
+    # Access the coercer for this instance and optional configure a
+    # new coercer with the passed block
+    #
+    # @example
+    #   configuration.coercer do |config|
+    #     config.string.boolean_map = { true => '1', false => '0' }
+    #   end
+    #
+    # @return [Coercer]
+    #
+    # @api private
+    def coercer(&block)
+      @coercer = Coercible::Coercer.new(&block) if block_given?
+      @coercer
+    end
+
+  end # class Configuration
+end # module Virtus

data/lib/virtus/const_missing_extensions.rb

@@ -0,0 +1,16 @@
+module Virtus
+  module ConstMissingExtensions
+
+    # Hooks into const missing process to determine types of attributes
+    #
+    # @param [String] name
+    #
+    # @return [Class]
+    #
+    # @api private
+    def const_missing(name)
+      Attribute::Builder.determine_type(name) or Axiom::Types.const_get(name) or super
+    end
+
+  end
+end

data/lib/virtus/extensions.rb

@@ -4,6 +4,7 @@ module Virtus
   module Extensions
     WRITER_METHOD_REGEXP   = /=\z/.freeze
     INVALID_WRITER_METHODS = %w[ == != === []= attributes= ].to_set.freeze
+    RESERVED_NAMES         = [:attributes].to_set.freeze
 
     # A hook called when an object is extended with Virtus
     #
@@ -15,78 +16,102 @@ module Virtus
     def self.extended(object)
       super
       object.instance_eval do
+        extend Methods
         extend InstanceMethods
+        extend InstanceMethods::Constructor
+        extend InstanceMethods::MassAssignment
         extend attribute_set
       end
     end
     private_class_method :extended
 
-    # Defines an attribute on an object's class
-    #
-    # @example
-    #    class Book
-    #      include Virtus
-    #
-    #      attribute :title,        String
-    #      attribute :author,       String
-    #      attribute :published_at, DateTime
-    #      attribute :page_count,   Integer
-    #      attribute :index                   # defaults to Object
-    #    end
-    #
-    # @param [Symbol] name
-    #   the name of an attribute
-    #
-    # @param [Class] type
-    #   the type class of an attribute
-    #
-    # @param [#to_hash] options
-    #   the extra options hash
-    #
-    # @return [self]
-    #
-    # @see Attribute.build
-    #
-    # @api public
-    def attribute(*args)
-      attribute = Attribute.build(*args)
-      virtus_add_attribute(attribute)
-      self
-    end
+    module Methods
 
-    # 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  = allowed_methods.grep(WRITER_METHOD_REGEXP).to_set
-          allowed_writer_methods -= INVALID_WRITER_METHODS
-          allowed_writer_methods.freeze
+      # @api private
+      def self.extended(descendant)
+        AttributeSet.create(descendant)
+        descendant.instance_eval do
+          extend attribute_set
+        end
       end
-    end
+      private_class_method :extended
 
-  private
+      # Defines an attribute on an object's class
+      #
+      # @example
+      #    class Book
+      #      include Virtus
+      #
+      #      attribute :title,        String
+      #      attribute :author,       String
+      #      attribute :published_at, DateTime
+      #      attribute :page_count,   Integer
+      #      attribute :index                   # defaults to Object
+      #    end
+      #
+      # @param [Symbol] name
+      #   the name of an attribute
+      #
+      # @param [Class] type
+      #   the type class of an attribute
+      #
+      # @param [#to_hash] options
+      #   the extra options hash
+      #
+      # @return [self]
+      #
+      # @see Attribute.build
+      #
+      # @api public
+      def attribute(name, type, options = {})
+        assert_valid_name(name)
+        attribute_set << Attribute.build(type, merge_options(name, options))
+        self
+      end
 
-    # Return an attribute set for that instance
-    #
-    # @return [AttributeSet]
-    #
-    # @api private
-    def attribute_set
-      @attribute_set ||= AttributeSet.new
-    end
+      # @api public
+      def values(&block)
+        private :attributes=
+        yield
+        include(::Equalizer.new(*attribute_set.map(&:name)))
+        self
+      end
 
-    # Add an attribute to the attribute set
-    #
-    # @return [AttributeSet]
-    #
-    # @api private
-    def virtus_add_attribute(attribute)
-      attribute_set << attribute
-    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  = allowed_methods.grep(WRITER_METHOD_REGEXP).to_set
+            allowed_writer_methods -= INVALID_WRITER_METHODS
+            allowed_writer_methods.freeze
+          end
+      end
+
+      private
+
+      # Return an attribute set for that instance
+      #
+      # @return [AttributeSet]
+      #
+      # @api private
+      def attribute_set
+        @attribute_set
+      end
+
+      # Merge default options
+      #
+      # @return [Hash]
+      #
+      # @api private
+      def merge_options(name, options)
+        { :name => name }.merge(options)
+      end
+
+    end # Methods
 
   end # module Extensions
 end # module Virtus

data/lib/virtus/instance_methods.rb

@@ -3,17 +3,74 @@ module Virtus
   # Instance methods that are added when you include Virtus
   module InstanceMethods
 
-    # Set attributes during initialization of an object
-    #
-    # @param [#to_hash] attributes
-    #   the attributes hash to be set
-    #
-    # @return [undefined]
-    #
-    # @api private
-    def initialize(attributes = nil)
-      self.attributes = attributes if attributes
-    end
+    module Constructor
+
+      # Set attributes during initialization of an object
+      #
+      # @param [#to_hash] attributes
+      #   the attributes hash to be set
+      #
+      # @return [undefined]
+      #
+      # @api private
+      def initialize(attributes = nil)
+        attribute_set.set(self, attributes) if attributes
+        set_default_attributes
+      end
+
+    end # Constructor
+
+    module MassAssignment
+
+      # Returns a hash of all publicly accessible attributes
+      #
+      # @example
+      #   class User
+      #     include Virtus
+      #
+      #     attribute :name, String
+      #     attribute :age,  Integer
+      #   end
+      #
+      #   user = User.new(:name => 'John', :age => 28)
+      #   user.attributes  # => { :name => 'John', :age => 28 }
+      #
+      # @return [Hash]
+      #
+      # @api public
+      def attributes
+        attribute_set.get(self)
+      end
+      alias_method :to_hash, :attributes
+
+      # Mass-assign attribute values
+      #
+      # Keys in the +attributes+ 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] attributes
+      #   a hash of attribute names and values to set on the receiver
+      #
+      # @return [Hash]
+      #
+      # @api public
+      def attributes=(attributes)
+        attribute_set.set(self, attributes)
+      end
+
+    end # MassAssignment
 
     # Returns a value of the attribute with the given name
     #
@@ -35,7 +92,7 @@ module Virtus
     #
     # @api public
     def [](name)
-      get_attribute(name)
+      public_send(name)
     end
 
     # Sets a value of the attribute with the given name
@@ -62,59 +119,17 @@ module Virtus
     #
     # @api public
     def []=(name, value)
-      set_attribute(name, value)
+      public_send("#{name}=", value)
     end
 
-    # Returns a hash of all publicly accessible attributes
-    #
-    # @example
-    #   class User
-    #     include Virtus
-    #
-    #     attribute :name, String
-    #     attribute :age,  Integer
-    #   end
-    #
-    #   user = User.new(:name => 'John', :age => 28)
-    #   user.attributes  # => { :name => 'John', :age => 28 }
+    # Freeze object
     #
-    # @return [Hash]
+    # @return [self]
     #
     # @api public
-    def attributes
-      get_attributes(&:public_reader?)
-    end
-
-    # Mass-assign attribute values
-    #
-    # Keys in the +attributes+ 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] attributes
-    #   a hash of attribute names and values to set on the receiver
     #
-    # @return [Hash]
-    #
-    # @api public
-    def attributes=(attributes)
-      set_attributes(attributes)
-    end
-
-    # Returns a hash of all publicly accessible attributes
-    #
-    # @example
     #   class User
     #     include Virtus
     #
@@ -123,16 +138,17 @@ module Virtus
     #   end
     #
     #   user = User.new(:name => 'John', :age => 28)
-    #   user.attributes  # => { :name => 'John', :age => 28 }
-    #
-    # @return [Hash]
+    #   user.frozen? # => false
+    #   user.freeze
+    #   user.frozen? # => true
     #
     # @api public
-    def to_hash
-      attributes
+    def freeze
+      set_default_attributes!
+      super
     end
 
-    # Freeze object
+    # Reset an attribute to its default
     #
     # @return [self]
     #
@@ -143,87 +159,43 @@ module Virtus
     #   class User
     #     include Virtus
     #
-    #     attribute :name, String
-    #     attribute :age,  Integer
+    #     attribute :age,  Integer, default: 21
     #   end
     #
     #   user = User.new(:name => 'John', :age => 28)
-    #   user.frozen? # => false
-    #   user.freeze
-    #   user.frozen? # => true
+    #   user.age = 30
+    #   user.age # => 30
+    #   user.reset_attribute(:age)
+    #   user.age # => 21
     #
     # @api public
-    def freeze
-      set_defaults
-      super
+    def reset_attribute(attribute_name)
+      attribute = attribute_set[attribute_name]
+      attribute_set.set_default(self, attribute) if attribute
+      self
     end
 
-  private
-
-    # Get values of all attributes defined for this class, ignoring privacy
-    #
-    # @return [Hash]
-    #
-    # @api private
-    def get_attributes
-      attribute_set.each_with_object({}) do |attribute, attributes|
-        name = attribute.name
-        attributes[name] = get_attribute(name) if yield(attribute)
-      end
-    end
-
-    # Ensure all defaults are set
-    #
-    # @return [AttributeSet]
-    #
-    # @api private
-    def set_defaults
-      attribute_set.each do |attribute|
-        get_attribute(attribute.name)
-      end
-    end
-
-    # Mass-assign attribute values
-    #
-    # @see Virtus::InstanceMethods#attributes=
+    # Set default attributes
     #
-    # @return [Hash]
+    # @return [self]
     #
     # @api private
-    def set_attributes(attributes)
-      hash = ::Hash.try_convert(attributes)
-
-      if hash.nil?
-        raise NoMethodError,
-          "Expected #{attributes.inspect} to respond to #to_hash"
-      end
-
-      hash.each do |name, value|
-        set_attribute(name, value) if allowed_writer_methods.include?("#{name}=")
-      end
+    def set_default_attributes
+      attribute_set.set_defaults(self)
+      self
     end
 
-    # Returns a value of the attribute with the given name
+    # Set default attributes even lazy ones
     #
-    # @see Virtus::InstanceMethods#[]
-    #
-    # @return [Object]
+    # @return [self]
     #
-    # @api private
-    def get_attribute(name)
-      __send__(name)
+    # @api public
+    def set_default_attributes!
+      attribute_set.set_defaults(self, proc { |_| false })
+      self
     end
 
-    # Sets a value of the attribute with the given name
-    #
-    # @see Virtus::InstanceMethods#[]=
-    #
-    # @return [Object]
-    #
-    # @api private
-    def set_attribute(name, value)
-      __send__("#{name}=", value)
-    end
+    private
 
     # The list of allowed public methods
     #
@@ -234,5 +206,12 @@ module Virtus
       public_methods.map(&:to_s)
     end
 
+    # @api private
+    def assert_valid_name(name)
+      if respond_to?(:attributes) && name.to_sym == :attributes || name.to_sym == :attribute_set
+        raise ArgumentError, "#{name.inspect} is not allowed as an attribute name"
+      end
+    end
+
   end # module InstanceMethods
 end # module Virtus