active_attr 0.5.1 → 0.6.0

data/.rvmrc

@@ -4,7 +4,7 @@
 # development environment upon cd'ing into the directory
 
 # First we specify our desired <ruby>[@<gemset>], the @gemset name is optional.
-environment_id="ruby-1.9.2-p290@active_attr"
+environment_id="ruby-1.9.3@active_attr"
 
 #
 # Uncomment the following lines if you want to verify rvm version per project

data/CHANGELOG.md

@@ -1,3 +1,15 @@
+# ActiveAttr 0.6.0 (June 27, 2012) #
+
+* Added AttributeDefinition#inspect
+* Added Attributes.attribute!
+* Added Attributes.dangerous_attribute?
+* Added Typecasting#typecaster_for
+* Added Typecasting::UnknownTypecasterError
+* Changed Typecasting#typecast_attribute to take a typecaster, not a type
+* Removed Typecasting#typecast_value
+* TypecastedAttributes now supports a :typecaster option on attribute
+  definitions which can be any object that responds to #call
+
 # ActiveAttr 0.5.1 (March 16, 2012) #
 
 * ActiveAttr now supports Rails 3.0.2+ (Egor Baranov)

data/Gemfile

@@ -1,8 +1,10 @@
-source "http://rubygems.org"
+source "https://rubygems.org"
 
 gemspec :development_group => :test
+gem "factory_girl", "< 3.0", :group => :test if RUBY_VERSION < "1.9.2"
 
 group :development do
+  gem "debugger",  :platforms => :mri_19
   gem "growl"
   gem "guard"
   gem "guard-bundler"
@@ -10,8 +12,7 @@ group :development do
   gem "rb-fsevent"
   gem "rdiscount"
   gem "rdoc"
-  gem "ruby-debug",    :platforms => :mri_18
-  gem "ruby-debug19",  :platforms => :mri_19 if RUBY_VERSION < "1.9.3"
+  gem "ruby-debug", :platforms => :mri_18
   gem "spec_coverage", :platforms => :mri_19
   gem "travis-lint"
   gem "yard"

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (C) 2011-2012 by Chris Griego, Ben Poweski
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Rakefile

@@ -1,3 +1,5 @@
+#!/usr/bin/env rake
+
 require "bundler/setup"
 require "bundler/gem_tasks"
 require "rspec/core/rake_task"

data/active_attr.gemspec

@@ -1,29 +1,26 @@
 # -*- encoding: utf-8 -*-
-$:.push File.expand_path("../lib", __FILE__)
-require "active_attr/version"
+require File.expand_path("../lib/active_attr/version", __FILE__)
 
-Gem::Specification.new do |s|
-  s.name        = "active_attr"
-  s.version     = ActiveAttr::VERSION
-  s.authors     = ["Chris Griego", "Ben Poweski"]
-  s.email       = ["cgriego@gmail.com", "bpoweski@gmail.com"]
-  s.homepage    = "https://github.com/cgriego/active_attr"
-  s.summary     = %q{What ActiveModel left out}
-  s.description = %q{Create plain old ruby models without reinventing the wheel.}
+Gem::Specification.new do |gem|
+  gem.authors       = ["Chris Griego", "Ben Poweski"]
+  gem.email         = ["cgriego@gmail.com", "bpoweski@gmail.com"]
+  gem.description   = %q{Create plain old ruby models without reinventing the wheel.}
+  gem.summary       = %q{What ActiveModel left out}
+  gem.homepage      = "https://github.com/cgriego/active_attr"
 
-  s.rubyforge_project = "active_attr"
+  gem.files         = `git ls-files`.split($\)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.name          = "active_attr"
+  gem.require_paths = ["lib"]
+  gem.version       = ActiveAttr::VERSION
 
-  s.files         = `git ls-files`.split("\n")
-  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
-  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
-  s.require_paths = ["lib"]
+  gem.add_runtime_dependency "activemodel",   ">= 3.0.2", "< 4.1"
+  gem.add_runtime_dependency "activesupport", ">= 3.0.2", "< 4.1"
 
-  s.add_runtime_dependency "activemodel",   ">= 3.0.2", "< 4.1"
-  s.add_runtime_dependency "activesupport", ">= 3.0.2", "< 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"
+  gem.add_development_dependency "bundler",      "~> 1.0"
+  gem.add_development_dependency "factory_girl", ">= 2.2", "< 4.0"
+  gem.add_development_dependency "rake",         "~> 0.9.0"
+  gem.add_development_dependency "rspec",        "~> 2.6"
+  gem.add_development_dependency "tzinfo",       "~> 0.3.29"
 end

data/gemfiles/rails_3_0.gemfile

@@ -1,6 +1,7 @@
 source "http://rubygems.org"
 
 gemspec :development_group => :test, :path => ".."
+gem "factory_girl", "< 3.0", :group => :test if RUBY_VERSION < "1.9.2"
 
 gem "activemodel",   "~> 3.0.2"
 gem "activesupport", "~> 3.0.2"

data/gemfiles/rails_3_1.gemfile

@@ -1,6 +1,7 @@
 source "http://rubygems.org"
 
 gemspec :development_group => :test, :path => ".."
+gem "factory_girl", "< 3.0", :group => :test if RUBY_VERSION < "1.9.2"
 
 gem "activemodel",   "~> 3.1.0"
 gem "activesupport", "~> 3.1.0"

data/lib/active_attr.rb

@@ -13,6 +13,7 @@ module ActiveAttr
   autoload :AttributeDefinition
   autoload :Attributes
   autoload :BasicModel
+  autoload :BlockInitialization
   autoload :ChainableInitialization
   autoload :Error
   autoload :Logger

data/lib/active_attr/attribute_definition.rb

@@ -47,6 +47,7 @@ module ActiveAttr
     #   AttributeDefinition.new(:amount)
     #
     # @param [Symbol, String, #to_sym] name attribute name
+    # @param [Hash{Symbol => Object}] options attribute options
     #
     # @return [ActiveAttr::AttributeDefinition]
     #
@@ -57,6 +58,21 @@ module ActiveAttr
       @options = options
     end
 
+    # Returns the code that would generate the attribute definition
+    #
+    # @example Inspect the attribute definition
+    #   attribute.inspect
+    #
+    # @return [String] Human-readable presentation of the attribute
+    #   definition
+    #
+    # @since 0.6.0
+    def inspect
+      options_description = options.map { |key, value| "#{key.inspect} => #{value.inspect}" }.sort.join(", ")
+      inspected_options = ", #{options_description}" unless options_description.empty?
+      "attribute :#{name}#{inspected_options}"
+    end
+
     # The attribute name
     #
     # @return [String] the attribute name

data/lib/active_attr/attributes.rb

@@ -120,14 +120,6 @@ module ActiveAttr
     end
     alias_method :[]=, :write_attribute
 
-    protected
-
-    # Overrides ActiveModel::AttributeMethods
-    # @private
-    def attribute_method?(attr_name)
-      self.class.attribute_names.include? attr_name.to_s
-    end
-
     private
 
     # Read an attribute from the attributes hash
@@ -150,8 +142,9 @@ module ActiveAttr
       # 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
@@ -161,8 +154,34 @@ module ActiveAttr
       # @raise [DangerousAttributeError] if the attribute name conflicts with
       #   existing methods
       #
+      # @return [AttributeDefinition] Attribute's definition
+      #
       # @since 0.2.0
       def attribute(name, options={})
+        if dangerous_attribute_method_name = dangerous_attribute?(name)
+          raise DangerousAttributeError, %{an attribute method named "#{dangerous_attribute_method_name}" would conflict with an existing method}
+        else
+          attribute! name, options
+        end
+      end
+
+      # Defines an attribute without checking for conflicts
+      #
+      # Allows you to define an attribute whose methods will conflict
+      # with an existing method. For example, Ruby's Timeout library
+      # adds a timeout method to Object. Attempting to define a timeout
+      # attribute using .attribute will raise a
+      # {DangerousAttributeError}, but .attribute! will not.
+      #
+      # @example Define a dangerous attribute.
+      #   attribute! :timeout
+      #
+      # @param (see AttributeDefinition#initialize)
+      #
+      # @return [AttributeDefinition] Attribute's definition
+      #
+      # @since 0.6.0
+      def attribute!(name, options={})
         AttributeDefinition.new(name, options).tap do |attribute_definition|
           attribute_name = attribute_definition.name.to_s
           # Force active model to generate attribute methods
@@ -197,6 +216,30 @@ module ActiveAttr
         @attributes ||= ActiveSupport::HashWithIndifferentAccess.new
       end
 
+      # Determine if a given attribute name is dangerous
+      #
+      # Some attribute names can cause conflicts with existing methods
+      # on an object. For example, an attribute named "timeout" would
+      # conflict with the timeout method that Ruby's Timeout library
+      # mixes into Object.
+      #
+      # @example Testing a harmless attribute
+      #   Person.dangerous_attribute? :name #=> false
+      #
+      # @example Testing a dangerous attribute
+      #   Person.dangerous_attribute? :nil #=> "nil?"
+      #
+      # @param name Attribute name
+      #
+      # @return [false, String] False or the conflicting method name
+      #
+      # @since 0.6.0
+      def dangerous_attribute?(name)
+        attribute_methods(name).detect do |method_name|
+          !DEPRECATED_OBJECT_METHODS.include?(method_name.to_s) && allocate.respond_to?(method_name, true)
+        end unless attribute_names.include? name.to_s
+      end
+
       # Returns the class name plus its attribute names
       #
       # @example Inspect the model's definition.
@@ -208,7 +251,7 @@ module ActiveAttr
       def inspect
         inspected_attributes = attribute_names.sort
         attributes_list = "(#{inspected_attributes.join(", ")})" unless inspected_attributes.empty?
-        "#{self.name}#{attributes_list}"
+        "#{name}#{attributes_list}"
       end
 
       protected
@@ -223,17 +266,20 @@ module ActiveAttr
         @attributes = attributes
       end
 
-      # Overrides ActiveModel::AttributeMethods
-      # @private
+      # Overrides ActiveModel::AttributeMethods to backport 3.2 fix
       def instance_method_already_implemented?(method_name)
-        deprecated_object_method = DEPRECATED_OBJECT_METHODS.include?(method_name.to_s)
-        already_implemented = !deprecated_object_method && self.allocate.respond_to?(method_name, true)
-        raise DangerousAttributeError, %{an attribute method named "#{method_name}" would conflict with an existing method} if already_implemented
-        false
+        generated_attribute_methods.method_defined?(method_name)
       end
 
       private
 
+      # Expand an attribute name into its generated methods names
+      #
+      # @since 0.6.0
+      def attribute_methods(name)
+        attribute_method_matchers.map { |matcher| matcher.method_name name }
+      end
+
       # Ruby inherited hook to assign superclass attributes to subclasses
       #
       # @since 0.2.2

data/lib/active_attr/matchers/have_attribute_matcher.rb

@@ -22,36 +22,17 @@ module ActiveAttr
     #
     # @since 0.2.0
     class HaveAttributeMatcher
-      attr_reader :attribute_name, :default_value
-      private :attribute_name, :default_value
-
-      # @return [String] Description
-      # @private
-      def description
-        "has #{attribute_description}"
-      end
-
-      # @return [String] Failure message
-      # @private
-      def failure_message
-        if !includes_attributes?
-          "expected #{@model_class.name} to include ActiveAttr::Attributes"
-        elsif !includes_defaults?
-          "expected #{@model_class.name} to include ActiveAttr::AttributeDefaults"
-        elsif !includes_typecasting?
-          "expected #{@model_class.name} to include ActiveAttr::TypecastedAttributes"
-        else
-          "expected #{@model_class.name} to have #{attribute_description}"
-        end
-      end
+      attr_reader :attribute_name
+      private :attribute_name
 
       # @param [Symbol, String, #to_sym] attribute_name
       # @private
       def initialize(attribute_name)
         raise TypeError, "can't convert #{attribute_name.class} into Symbol" unless attribute_name.respond_to? :to_sym
         @attribute_name = attribute_name.to_sym
-        @default_value_set = false
-        @type = nil
+        @description = "attribute named #{attribute_name}"
+        @expected_ancestors = ["ActiveAttr::Attributes"]
+        @attribute_expectations = [lambda { attribute_definition }]
       end
 
       # Specify that the attribute should have the given type
@@ -67,27 +48,12 @@ module ActiveAttr
       #
       # @since 0.5.0
       def of_type(type)
-        @type = type
+        @description << " of type #{type}"
+        @expected_ancestors << "ActiveAttr::TypecastedAttributes"
+        @attribute_expectations << lambda { @model_class._attribute_type(attribute_name) == type }
         self
       end
 
-      # @private
-      def matches?(model_or_model_class)
-        @model_class = class_from(model_or_model_class)
-
-        return false if !includes_attributes? || !includes_defaults? || !includes_typecasting?
-
-        @attribute_definition = @model_class.attributes[attribute_name]
-
-        !!(@attribute_definition && default_matches? && type_matches?)
-      end
-
-      # @return [String] Negative failure message
-      # @private
-      def negative_failure_message
-        "expected #{@model_class.name} to not have #{attribute_description}"
-      end
-
       # Specify that the attribute should have the given default value
       #
       # @example Person's first name should default to John
@@ -103,46 +69,52 @@ module ActiveAttr
       #
       # @since 0.5.0
       def with_default_value_of(default_value)
-        @default_value_set = true
-        @default_value = default_value
+        @description << " with a default value of #{default_value.inspect}"
+        @expected_ancestors << "ActiveAttr::AttributeDefaults"
+        @attribute_expectations << lambda { attribute_definition[:default] == default_value }
         self
       end
 
-      private
-
-      def attribute_description
-        "attribute named #{attribute_name}".tap do |result|
-          result << " of type #{@type}" if @type
-          result << " with a default value of #{default_value.inspect}" if @default_value_set
-        end
+      # @return [String] Description
+      # @private
+      def description
+        "has #{@description}"
       end
 
-      def includes_attributes?
-        model_ancestor_names.include?("ActiveAttr::Attributes")
+      # @private
+      def matches?(model_or_model_class)
+        @model_class = Class === model_or_model_class ? model_or_model_class : model_or_model_class.class
+        missing_ancestors.none? && @attribute_expectations.all? { | expectation| expectation.call }
       end
 
-      def includes_defaults?
-        !@default_value_set || model_ancestor_names.include?("ActiveAttr::AttributeDefaults")
+      # @return [String] Failure message
+      # @private
+      def failure_message
+        if missing_ancestors.any?
+          "expected #{@model_class.name} to include #{missing_ancestors.first}"
+        else
+          "expected #{@model_class.name} to have #{@description}"
+        end
       end
 
-      def includes_typecasting?
-        !@type || model_ancestor_names.include?("ActiveAttr::TypecastedAttributes")
+      # @return [String] Negative failure message
+      # @private
+      def negative_failure_message
+        "expected #{@model_class.name} to not have #{@description}"
       end
 
-      def model_ancestor_names
-        @model_class.ancestors.map(&:name)
-      end
+      private
 
-      def class_from(object)
-        Class === object ? object : object.class
+      def attribute_definition
+        @model_class.attributes[attribute_name]
       end
 
-      def default_matches?
-        !@default_value_set || @attribute_definition[:default] == default_value
-      end
+      def missing_ancestors
+        model_ancestor_names = @model_class.ancestors.map(&:name)
 
-      def type_matches?
-        !@type || @model_class._attribute_type(attribute_name) == @type
+        @expected_ancestors.reject do |ancestor_name|
+          model_ancestor_names.include? ancestor_name
+        end
       end
     end
   end