active_attr 0.4.1 → 0.5.0.alpha1

data/.travis.yml

@@ -5,4 +5,11 @@ rvm:
 bundler_args: --without development
 gemfile:
   - Gemfile
+  - gemfiles/rails_3_1.gemfile
   - gemfiles/rails_head.gemfile
+matrix:
+  exclude:
+    - rvm: ree
+      gemfile: gemfiles/rails_head.gemfile
+    - rvm: 1.9.2
+      gemfile: gemfiles/rails_head.gemfile

data/CHANGELOG.md

@@ -1,3 +1,17 @@
+# ActiveAttr 0.5.0 (unreleased) #
+
+* Added AttributeDefaults
+* Added AttributeDefinition#[]
+* Added Attributes.attribute_names
+* Added Matchers::HaveAttributeMatcher#with_default_value_of
+* Added TypecastedAttributes
+* Added Typecasting
+* Changed Attributes.attributes return value from an Array to a Hash
+* Changed redefining an attribute to actually redefine the attribute
+* Removed StrictMassAssignment, instead use MassAssignmentSecurity with
+  ActiveModel v3.2 which allows assigning mass_assignment_sanitizer to
+  :strict on the class
+
 # ActiveAttr 0.4.1 (November 27, 2011) #
 
 * Implemented ActiveModel serialization in Model

data/README.md

@@ -2,13 +2,18 @@
 
 [![Build History][2]][1]
 
-ActiveAttr makes it easy to create plain old ruby models without reinventing
-the wheel.
+ActiveAttr is a set of modules that makes it easy to create plain old ruby
+models with functionality found in ORMs, like ActiveRecord, without
+reinventing the wheel. Think of ActiveAttr as the stuff ActiveModel left out.
 
-[API Documentation](http://rubydoc.info/gems/active_attr)
+ActiveAttr is distributed as a rubygem [on rubygems.org][3].
+
+* [API Documentation](http://rubydoc.info/gems/active_attr)
+* [Contributors](https://github.com/cgriego/active_attr/contributors)
 
 [1]: http://travis-ci.org/cgriego/active_attr
 [2]: https://secure.travis-ci.org/cgriego/active_attr.png?branch=master
+[3]: http://rubygems.org/gems/active_attr
 
 ## Modules ##
 
@@ -39,6 +44,52 @@ the attributes of your model.
     person.last_name = "Griego"
     person.attributes #=> {"first_name"=>"Chris", "last_name"=>"Griego"}
 
+#### AttributeDefaults ####
+
+Including the AttributeDefaults module into your class builds on Attributes by
+allowing defaults to be declared with attributes.
+
+    class Person
+      include ActiveAttr::AttributeDefaults
+
+      attribute :first_name, :default => "John"
+      attribute :last_name, :default => "Doe"
+    end
+
+    person = Person.new
+    person.first_name #=> "John"
+    person.last_name #=> "Doe"
+
+#### QueryAttributes ####
+
+Including the QueryAttributes module into your class builds on Attributes by
+providing instance methods for querying your attributes.
+
+    class Person
+      include ActiveAttr::QueryAttributes
+
+      attribute :first_name
+      attribute :last_name
+    end
+
+    person = Person.new
+    person.first_name = "Chris"
+    person.first_name? #=> true
+    person.last_name? #=> false
+
+#### TypecastedAttributes ####
+
+TODO documentation
+
+    class Person
+      include ActiveAttr::TypecastedAttributes
+      attribute :age, :type => Integer
+    end
+
+    person = Person.new
+    person.age = "29"
+    person.age #=> 29
+
 ### BasicModel ###
 
 Including the BasicModel module into your class gives you the bare minimum
@@ -96,9 +147,7 @@ logger will be configured by default.
 
 Including the MassAssignment module into your class gives you methods for bulk
 initializing and updating the attributes of your model. Any unknown attributes
-are silently ignored unless you substitute the StrictMassAssignment module
-which will raise an exception if an attempt is made to assign an unknown
-attribute.
+are silently ignored.
 
     class Person
       include ActiveAttr::MassAssignment
@@ -110,7 +159,7 @@ attribute.
     person.first_name #=> "Chris"
     person.last_name #=> "Griego"
 
-### MassAssignmentSecurity ###
+#### MassAssignmentSecurity ####
 
 Including the MassAssignmentSecurity module into your class extends the
 MassAssignment methods to honor any declared mass assignment permission
@@ -126,23 +175,6 @@ blacklists or whitelists including support for mass assignment roles.
     person.first_name #=> "Chris"
     person.last_name #=> nil
 
-### QueryAttributes ###
-
-Including the QueryAttributes module into your class builds on Attributes by
-providing instance methods for querying your attributes
-
-    class Person
-      include ActiveAttr::QueryAttributes
-
-      attribute :first_name
-      attribute :last_name
-    end
-
-    person = Person.new
-    person.first_name = "Chris"
-    person.first_name? #=> true
-    person.last_name? #=> false
-
 ## Integrations ##
 
 ### Ruby on Rails ###
@@ -161,5 +193,5 @@ your models. The matchers also work with compatible frameworks like Shoulda.
     require "active_attr/rspec"
 
     describe Person do
-      it { should have_attribute(:first_name) }
+      it { should have_attribute(:first_name).with_default_value_of("John") }
     end

data/Rakefile

@@ -15,10 +15,12 @@ namespace :spec do
   desc "Run RSpec unit specs"
   RSpec::Core::RakeTask.new(:units) do |spec|
     spec.pattern = "spec/unit/**/*_spec.rb"
+    spec.ruby_opts = "-w"
   end
 
   desc "Run RSpec functional specs"
   RSpec::Core::RakeTask.new(:functionals) do |spec|
     spec.pattern = "spec/functional/**/*_spec.rb"
+    spec.ruby_opts = "-w"
   end
 end

data/active_attr.gemspec

@@ -18,11 +18,12 @@ Gem::Specification.new do |s|
   s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
   s.require_paths = ["lib"]
 
-  s.add_runtime_dependency "activemodel",   "~> 3.1"
-  s.add_runtime_dependency "activesupport", "~> 3.1"
+  s.add_runtime_dependency "activemodel",   ">= 3.1", "< 4.1"
+  s.add_runtime_dependency "activesupport", ">= 3.1", "< 4.1"
 
   s.add_development_dependency "bundler",      "~> 1.0"
   s.add_development_dependency "factory_girl", "~> 2.2"
   s.add_development_dependency "rake",         "~> 0.9.0"
   s.add_development_dependency "rspec",        "~> 2.6"
+  s.add_development_dependency "tzinfo",       "~> 0.3.29"
 end

data/gemfiles/rails_3_1.gemfile

@@ -0,0 +1,6 @@
+source "http://rubygems.org"
+
+gemspec :development_group => :test, :path => ".."
+
+gem "activemodel",   "~> 3.1.0"
+gem "activesupport", "~> 3.1.0"

data/lib/active_attr.rb

@@ -9,6 +9,7 @@ require "active_support/dependencies/autoload"
 module ActiveAttr
   extend ActiveSupport::Autoload
 
+  autoload :AttributeDefaults
   autoload :AttributeDefinition
   autoload :Attributes
   autoload :BasicModel
@@ -19,8 +20,8 @@ module ActiveAttr
   autoload :MassAssignmentSecurity
   autoload :Model
   autoload :QueryAttributes
-  autoload :StrictMassAssignment
+  autoload :TypecastedAttributes
+  autoload :Typecasting
   autoload :UnknownAttributeError
-  autoload :UnknownAttributesError
   autoload :VERSION
 end

data/lib/active_attr/attribute_defaults.rb

@@ -0,0 +1,120 @@
+require "active_attr/attributes"
+require "active_attr/chainable_initialization"
+require "active_support/concern"
+require "active_support/core_ext/object/duplicable"
+
+module ActiveAttr
+  # AttributeDefaults allows defaults to be declared for your attributes
+  #
+  # Defaults are declared by passing the :default option to the attribute
+  # class method. If you need the default to be dynamic, pass a lambda, Proc,
+  # or any object that responds to #call as the value to the :default option
+  # and the result will calculated on initialization. These dynamic defaults
+  # can depend on the values of other attributes when those attributes are
+  # assigned using MassAssignment or BlockInitialization.
+  #
+  # @example Usage
+  #   class Person
+  #     include ActiveAttr::AttributeDefaults
+  #
+  #     attribute :first_name, :default => "John"
+  #     attribute :last_name, :default => "Doe"
+  #   end
+  #
+  #   person = Person.new
+  #   person.first_name #=> "John"
+  #   person.last_name #=> "Doe"
+  #
+  # @example Dynamic Default
+  #   class Event
+  #     include ActiveAttr::MassAssignment
+  #     include ActiveAttr::AttributeDefaults
+  #
+  #     attribute :start_date
+  #     attribute :end_date, :default => lambda { start_date }
+  #   end
+  #
+  #   event = Event.new(:start_date => Date.parse("2012-01-01"))
+  #   event.end_date.to_s #=> "2012-01-01"
+  #
+  # @since 0.5.0
+  module AttributeDefaults
+    extend ActiveSupport::Concern
+    include ActiveAttr::ChainableInitialization
+    include Attributes
+
+    # Applies the attribute defaults
+    #
+    # Applies all the default values to any attributes not yet set, avoiding
+    # any attribute setter logic, such as dirty tracking.
+    #
+    # @example Usage
+    #   class Person
+    #     include ActiveAttr::AttributeDefaults
+    #
+    #     attribute :first_name, :default => "John"
+    #
+    #     def reset!
+    #       @attributes = {}
+    #       apply_defaults
+    #     end
+    #   end
+    #
+    #   person = Person.new(:first_name => "Chris")
+    #   person.reset!
+    #   person.first_name #=> "John"
+    #
+    # @param [Hash{String => Object}, #each] defaults The defaults to apply
+    #
+    # @since 0.5.0
+    def apply_defaults(defaults=attribute_defaults)
+      @attributes ||= {}
+      defaults.each do |name, value|
+        # instance variable is used here to avoid any dirty tracking in attribute setter methods
+        @attributes[name] = value unless @attributes.has_key? name
+      end
+    end
+
+    # Calculates the attribute defaults from the attribute definitions
+    #
+    # @example Usage
+    #   class Person
+    #     include ActiveAttr::AttributeDefaults
+    #
+    #     attribute :first_name, :default => "John"
+    #   end
+    #
+    #   Person.new.attribute_defaults #=> {"first_name"=>"John"}
+    #
+    # @return [Hash{String => Object}] the attribute defaults
+    #
+    # @since 0.5.0
+    def attribute_defaults
+      Hash[ self.class.attribute_names.map { |name| [name, _attribute_default(name)] } ]
+    end
+
+    # Applies attribute default values
+    #
+    # @since 0.5.0
+    def initialize(*)
+      super
+      apply_defaults
+    end
+
+    private
+
+    # Calculates an attribute default
+    #
+    # @private
+    # @since 0.5.0
+    def _attribute_default(attribute_name)
+      default = self.class.attributes[attribute_name][:default]
+
+      case
+      when default.respond_to?(:call) then instance_exec(&default)
+      when default.duplicable? then default.dup
+      else default
+      end
+    end
+  end
+end

data/lib/active_attr/attribute_definition.rb

@@ -1,3 +1,6 @@
+require 'active_support/core_ext/hash/reverse_merge'
+require 'active_support/core_ext/string/inflections'
+
 module ActiveAttr
   # Represents an attribute for reflection
   #
@@ -17,16 +20,30 @@ module ActiveAttr
     # @example
     #   attribute_definition <=> other
     #
-    # @param [ActiveAttr::AttributeDefinition, Object] other The other attribute definition to compare with.
+    # @param [ActiveAttr::AttributeDefinition, Object] other The other
+    #   attribute definition to compare with.
     #
     # @return [-1, 0, 1, nil]
     #
     # @since 0.2.1
     def <=>(other)
       return nil unless other.instance_of? self.class
+      return nil if name == other.name && options != other.options
       self.name.to_s <=> other.name.to_s
     end
 
+    # Read an attribute option
+    #
+    # @example
+    #   attribute_definition[:type]
+    #
+    # @param [Symbol] key The option key
+    #
+    # @since 0.5.0
+    def [](key)
+      @options[key]
+    end
+
     # Creates a new AttributeDefinition
     #
     # @example Create an attribute defintion
@@ -40,6 +57,7 @@ module ActiveAttr
     def initialize(name, options={})
       raise TypeError, "can't convert #{name.class} into Symbol" unless name.respond_to? :to_sym
       @name = name.to_sym
+      @options = options
     end
 
     # The attribute name
@@ -50,7 +68,6 @@ module ActiveAttr
     def to_s
       name.to_s
     end
-    alias_method :inspect, :to_s
 
     # The attribute name
     #
@@ -60,5 +77,11 @@ module ActiveAttr
     def to_sym
       name
     end
+
+    protected
+
+    # The attribute options
+    # @since 0.5.0
+    attr_reader :options
   end
 end

data/lib/active_attr/attributes.rb

@@ -1,9 +1,9 @@
 require "active_attr/attribute_definition"
-require "active_attr/chainable_initialization"
 require "active_attr/dangerous_attribute_error"
 require "active_attr/unknown_attribute_error"
 require "active_model"
 require "active_support/concern"
+require "active_support/hash_with_indifferent_access"
 
 module ActiveAttr
   # Attributes provides a set of class methods for defining an attributes
@@ -21,7 +21,6 @@ module ActiveAttr
   # @since 0.2.0
   module Attributes
     extend ActiveSupport::Concern
-    include ActiveAttr::ChainableInitialization
     include ActiveModel::AttributeMethods
 
     # Methods deprecated on the Object class which can be safely overridden
@@ -38,9 +37,10 @@ module ActiveAttr
     # @example Compare for equality.
     #   model == other
     #
-    # @param [ActiveAttr::Attributes, Object] other The other model to compare with.
+    # @param [ActiveAttr::Attributes, Object] other The other model to compare
     #
-    # @return [true, false] True if attributes are equal and other is instance of the same Class, false if not.
+    # @return [true, false] True if attributes are equal and other is instance
+    #   of the same Class, false if not.
     #
     # @since 0.2.0
     def ==(other)
@@ -53,18 +53,11 @@ module ActiveAttr
     # @example Get attributes
     #   person.attributes # => {"name"=>"Ben Poweski"}
     #
-    # @return [Hash] The Hash of all attributes
+    # @return [Hash{String => Object}] The Hash of all attributes
     #
     # @since 0.2.0
     def attributes
-      attribute_names = self.class.attributes.map { |definition| definition.name.to_s }
-      Hash[attribute_names.map { |key| [key, send(key)] }]
-    end
-
-    # @since 0.2.1
-    def initialize(*)
-      @attributes ||= {}
-      super
+      Hash[self.class.attribute_names.map { |key| [key, send(key)] }]
     end
 
     # Returns the class name plus its attributes
@@ -72,11 +65,12 @@ module ActiveAttr
     # @example Inspect the model.
     #   person.inspect
     #
-    # @return [String] A nice pretty string to look at.
+    # @return [String] Human-readable presentation of the attribute
+    #   definitions
     #
     # @since 0.2.0
     def inspect
-      attribute_descriptions = self.attributes.sort.map { |key, value| "#{key}: #{value.inspect}" }.join(", ")
+      attribute_descriptions = attributes.sort.map { |key, value| "#{key}: #{value.inspect}" }.join(", ")
       separator = " " unless attribute_descriptions.empty?
       "#<#{self.class.name}#{separator}#{attribute_descriptions}>"
     end
@@ -131,7 +125,7 @@ module ActiveAttr
     # Overrides ActiveModel::AttributeMethods
     # @private
     def attribute_method?(attr_name)
-      self.class.attributes.map { |definition| definition.name.to_s }.include? attr_name.to_s
+      self.class.attribute_names.include? attr_name.to_s
     end
 
     private
@@ -140,61 +134,77 @@ module ActiveAttr
     #
     # @since 0.2.1
     def attribute(name)
-      @attributes[name.to_s]
+      @attributes ||= {}
+      @attributes[name]
     end
 
     # Write an attribute to the attributes hash
     #
     # @since 0.2.1
     def attribute=(name, value)
-      @attributes[name.to_s] = value
+      @attributes ||= {}
+      @attributes[name] = value
     end
 
     module ClassMethods
-      # Defines all the attributes that are to be returned from the attributes instance method.
+      # Defines an attribute
+      #
       # For each attribute that is defined, a getter and setter will be
-      # added as an instance method to the model. An AttributeDefinition instance will be
-      # added to result of the attributes class method.
+      # added as an instance method to the model. An AttributeDefinition
+      # instance will be added to result of the attributes class method.
       #
       # @example Define an attribute.
       #   attribute :name
       #
       # @param (see AttributeDefinition#initialize)
       #
-      # @raise [DangerousAttributeError] if the attribute name conflicts with existing methods
+      # @raise [DangerousAttributeError] if the attribute name conflicts with
+      #   existing methods
       #
       # @since 0.2.0
       def attribute(name, options={})
         AttributeDefinition.new(name, options).tap do |attribute_definition|
-          unless attributes.include? attribute_definition
-            define_attribute_method attribute_definition.name
-            attributes << attribute_definition
-          end
+          attribute_name = attribute_definition.name.to_s
+          define_attribute_method attribute_definition.name unless attribute_names.include? attribute_name
+          attributes[attribute_name] = attribute_definition
         end
       end
 
-      # Returns an Array of AttributeDefinition instances
+      # Returns an Array of attribute names as Strings
+      #
+      # @example Get attribute names
+      #   Person.attribute_names
+      #
+      # @return [Array<String>] The attribute names
+      #
+      # @since 0.5.0
+      def attribute_names
+        attributes.keys
+      end
+
+      # Returns a Hash of AttributeDefinition instances
       #
       # @example Get attribute definitions
       #   Person.attributes
       #
-      # @return [Array<ActiveAttr::AttributeDefinition>] The Array of AttributeDefinition instances
+      # @return [ActiveSupport::HashWithIndifferentAccess{String => ActiveAttr::AttributeDefinition}]
+      #   The Hash of AttributeDefinition instances
       #
       # @since 0.2.0
       def attributes
-        @attributes ||= []
+        @attributes ||= ActiveSupport::HashWithIndifferentAccess.new
       end
 
-      # Returns the class name plus its attribute definitions
+      # Returns the class name plus its attribute names
       #
       # @example Inspect the model's definition.
       #   Person.inspect
       #
-      # @return [String] A nice pretty string to look at.
+      # @return [String] Human-readable presentation of the attributes
       #
       # @since 0.2.0
       def inspect
-        inspected_attributes = attributes.sort.map { |attr| attr.inspect }
+        inspected_attributes = attribute_names.sort
         attributes_list = "(#{inspected_attributes.join(", ")})" unless inspected_attributes.empty?
         "#{self.name}#{attributes_list}"
       end
@@ -203,7 +213,8 @@ module ActiveAttr
 
       # Assign a set of attribute definitions, used when subclassing models
       #
-      # @param [Array<ActiveAttr::AttributeDefinition>] The Array of AttributeDefinition instances
+      # @param [Array<ActiveAttr::AttributeDefinition>] The Array of
+      #   AttributeDefinition instances
       #
       # @since 0.2.2
       def attributes=(attributes)