active_attr 0.2.2 → 0.3.0

data/lib/active_attr/mass_assignment_security.rb

@@ -0,0 +1,42 @@
+require "active_attr/mass_assignment"
+require "active_support/concern"
+require "active_model"
+
+module ActiveAttr
+  # MassAssignmentSecurity allows you to bulk set and update a blacklist or
+  # whitelist of attributes
+  #
+  # Including MassAssignmentSecurity extends all {ActiveAttr::MassAssignment}
+  # methods to honor any declared attribute permissions.
+  #
+  # @example Usage
+  #   class Person
+  #     include ActiveAttr::MassAssignmentSecurity
+  #   end
+  #
+  # @since 0.3.0
+  module MassAssignmentSecurity
+    extend ActiveSupport::Concern
+    include MassAssignment
+    include ActiveModel::MassAssignmentSecurity
+
+    # Mass update a model's attributes, honoring attribute permissions
+    #
+    # @param (see MassAssignment#assign_attributes)
+    # @param [Hash, #[]] options Options that affect mass assignment
+    #
+    # @option options [Symbol] :as (:default) Mass assignment role
+    # @option options [true, false] :without_protection (false) Bypass mass
+    #   assignment security if true
+    #
+    # @since 0.3.0
+    def assign_attributes(new_attributes, options={})
+      if new_attributes && !options[:without_protection]
+        mass_assignment_role = options[:as] || :default
+        new_attributes = sanitize_for_mass_assignment new_attributes, mass_assignment_role
+      end
+
+      super
+    end
+  end
+end

data/lib/active_attr/query_attributes.rb

@@ -0,0 +1,62 @@
+require "active_attr/attributes"
+require "active_attr/unknown_attribute_error"
+require "active_support/concern"
+require "active_support/core_ext/object/blank"
+
+module ActiveAttr
+  # QueryAttributes provides instance methods for querying attributes.
+  #
+  # @example Usage
+  #   class Person
+  #     include ActiveAttr::QueryAttributes
+  #     attribute :name
+  #   end
+  #
+  #   person = Person.new
+  #   person.name? #=> false
+  #   person.name = "Chris Griego"
+  #   person.name? #=> true
+  #
+  # @since 0.3.0
+  module QueryAttributes
+    extend ActiveSupport::Concern
+    include Attributes
+
+    included do
+      attribute_method_suffix "?"
+    end
+
+    # Test the presence of an attribute
+    #
+    # Similar to an ActiveRecord model, when the attribute is a zero value or
+    # is a string that represents false, the method returns false.
+    #
+    # @example Query an attribute
+    #   person.query_attribute(:name)
+    #
+    # @param [String, Symbol, #to_s] name The name of the attribute to query
+    #
+    # @return [true, false] The presence of the attribute
+    #
+    # @raise [UnknownAttributeError] if the attribute is unknown
+    #
+    # @since 0.3.0
+    def query_attribute(name)
+      if respond_to? "#{name}?"
+        send "#{name}?"
+      else
+        raise UnknownAttributeError, "unknown attribute: #{name}"
+      end
+    end
+
+    private
+
+    def attribute?(name)
+      case value = read_attribute(name)
+      when "false", "FALSE", "f", "F" then false
+      when Numeric, /^\-?[0-9]/ then !value.to_f.zero?
+      else value.present?
+      end
+    end
+  end
+end

data/lib/active_attr/railtie.rb

@@ -0,0 +1,10 @@
+require "active_attr/logger"
+
+module ActiveAttr
+  # @private
+  class Railtie < Rails::Railtie
+    initializer "active_attr.logger" do
+      Logger.logger ||= ::Rails.logger
+    end
+  end
+end

data/lib/active_attr/unknown_attribute_error.rb

@@ -0,0 +1,19 @@
+require "active_attr/error"
+
+module ActiveAttr
+  # This exception is raised if attempting to assign unknown attributes when
+  # using {Attributes}
+  #
+  # @example Rescuing an UnknownAttributeError error
+  #   begin
+  #     person.write_attribute(:middle_initial, "J")
+  #   rescue ActiveAttr::UnknownAttributeError
+  #     logger.error "attempted to write an unknown attribute"
+  #     raise
+  #   end
+  #
+  # @since 0.3.0
+  class UnknownAttributeError < NoMethodError
+    include Error
+  end
+end

data/lib/active_attr/version.rb

@@ -1,5 +1,5 @@
 module ActiveAttr
   # Complete version string
   # @since 0.1.0
-  VERSION = "0.2.2"
+  VERSION = "0.3.0"
 end

data/spec/functional/active_attr/attributes_spec.rb

@@ -1,6 +1,7 @@
 require "spec_helper"
 require "active_attr/attributes"
 require "active_model"
+require "factory_girl"
 
 module ActiveAttr
   describe Attributes do
@@ -107,5 +108,108 @@ module ActiveAttr
         include_examples "serialization method"
       end
     end
+
+    context "building with FactoryGirl" do
+      subject { FactoryGirl.build(:person) }
+
+      before do
+        Object.const_set("Person", model_class)
+
+        Factory.define :person, :class => :person do |model|
+          model.first_name "Chris"
+          model.last_name "Griego"
+        end
+      end
+
+      after do
+        FactoryGirl.factories.clear
+        Object.send :remove_const, "Person"
+      end
+
+      let :model_class do
+        Class.new do
+          include Attributes
+          attribute :first_name
+          attribute :last_name
+        end
+      end
+
+      it "builds an instance of the model class" do
+        should be_a_kind_of Person
+      end
+
+      it "sets the attributes" do
+        subject.first_name.should == "Chris"
+        subject.last_name.should == "Griego"
+      end
+    end
+
+    context "defining dangerous attributes" do
+      shared_examples "defining a dangerous attribute" do
+        it "defining an attribute that conflicts with #{described_class} raises DangerousAttributeError" do
+          expect { model_class.attribute(:write_attribute) }.to raise_error DangerousAttributeError, %{an attribute method named "write_attribute" would conflict with an existing method}
+        end
+
+        it "defining an attribute that conflicts with ActiveModel::AttributeMethods raises DangerousAttributeError" do
+          expect { model_class.attribute(:attribute_method_matchers) }.to raise_error DangerousAttributeError, %{an attribute method named "attribute_method_matchers" would conflict with an existing method}
+        end
+
+        it "defining an :id attribute does not raise" do
+          expect { model_class.attribute(:id) }.not_to raise_error
+        end
+
+        it "defining a :type attribute does not raise" do
+          expect { model_class.attribute(:type) }.not_to raise_error
+        end
+
+        it "defining an attribute that conflicts with Kernel raises DangerousAttributeError" do
+          expect { model_class.attribute(:puts) }.to raise_error DangerousAttributeError
+        end
+
+        it "defining an attribute that conflicts with Object raises DangerousAttributeError" do
+          expect { model_class.attribute(:class) }.to raise_error DangerousAttributeError
+        end
+
+        it "defining an attribute that conflicts with BasicObject raises DangerousAttributeError" do
+          expect { model_class.attribute(:instance_eval) }.to raise_error DangerousAttributeError
+        end
+
+        it "defining an attribute that conflicts with a properly implemented method_missing callback raises DangerousAttributeError" do
+          expect { model_class.attribute(:my_proper_missing_method) }.to raise_error DangerousAttributeError
+        end
+
+        it "defining an attribute that conflicts with a less properly implemented method_missing callback raises DangerousAttributeError" do
+          expect { model_class.attribute(:my_less_proper_missing_method) }.to raise_error DangerousAttributeError
+        end
+      end
+
+      let :dangerous_model_class do
+        Class.new do
+          include Attributes
+
+          def method_missing(method_name, *)
+            super if %w(my_proper_missing_method my_less_proper_missing_method).include? method_name.to_s
+          end
+
+          def respond_to_missing?(method_name, *)
+            method_name.to_s == "my_proper_missing_method" || super
+          end
+
+          def respond_to?(method_name, include_private=false)
+            super || method_name.to_s == "my_less_proper_missing_method" || (RUBY_VERSION < "1.9" && respond_to_missing?(method_name, include_private))
+          end
+        end
+      end
+
+      context "on a model class" do
+        let(:model_class) { dangerous_model_class }
+        include_examples "defining a dangerous attribute"
+      end
+
+      context "on a child class" do
+        let(:model_class) { Class.new(dangerous_model_class) }
+        include_examples "defining a dangerous attribute"
+      end
+    end
   end
 end

data/spec/functional/active_attr/query_attributes_spec.rb

@@ -0,0 +1,32 @@
+require "spec_helper"
+require "active_attr/query_attributes"
+
+module ActiveAttr
+  describe QueryAttributes do
+    context "defining dangerous attributes" do
+      shared_examples "defining a dangerous queryable attribute" do
+        it "defining an attribute that conflicts with ActiveModel::AttributeMethods raises DangerousAttributeError" do
+          expect { model_class.attribute(:attribute_method) }.to raise_error DangerousAttributeError, %{an attribute method named "attribute_method?" would conflict with an existing method}
+        end
+
+        it "defining an attribute that conflicts with Kernel raises DangerousAttributeError" do
+          expect { model_class.attribute(:block_given) }.to raise_error DangerousAttributeError
+        end
+
+        it "defining an attribute that conflicts with Object raises DangerousAttributeError" do
+          expect { model_class.attribute(:nil) }.to raise_error DangerousAttributeError
+        end
+      end
+
+      context "on a model class" do
+        let(:model_class) { Class.new { include QueryAttributes } }
+        include_examples "defining a dangerous queryable attribute"
+      end
+
+      context "on a child class" do
+        let(:model_class) { Class.new(Class.new { include QueryAttributes }) }
+        include_examples "defining a dangerous queryable attribute"
+      end
+    end
+  end
+end

data/spec/support/mass_assignment_shared_examples.rb

@@ -46,6 +46,11 @@ shared_examples "#assign_attribures", :assign_attributes => true do
     person
   end
 
+  def mass_assign_attributes_with_options(attributes, options)
+    person.assign_attributes attributes, options
+    person
+  end
+
   it "raises ArgumentError when called with three arguments" do
     expect { subject.new.assign_attributes({}, {}, nil) }.to raise_error ArgumentError
   end
@@ -79,6 +84,10 @@ shared_examples "#initialize", :initialize => true do
     subject.new(attributes)
   end
 
+  def mass_assign_attributes_with_options(attributes, options)
+    subject.new(attributes, options)
+  end
+
   it "invokes the superclass initializer" do
     subject.new.should be_initialized
   end

data/spec/unit/active_attr/attributes_spec.rb

@@ -4,12 +4,14 @@ require "active_attr/attributes"
 module ActiveAttr
   describe Attributes do
     subject { model_class.new }
+    let(:last_name) { "Poweski" }
 
     let :model_class do
       Class.new do
         include InitializationVerifier
         include Attributes
-        attribute :name
+        attribute :first_name
+        attribute :last_name
         attribute :amount
 
         def self.name
@@ -24,9 +26,17 @@ module ActiveAttr
           super
         end
 
-        def initialize(name=nil)
+        def last_name=(value)
+          super(value.to_s.upcase)
+        end
+
+        def last_name
+          super || "Poweski"
+        end
+
+        def initialize(first_name=nil)
           super
-          write_attribute(:name, name)
+          write_attribute(:first_name, first_name)
         end
       end
     end
@@ -43,7 +53,7 @@ module ActiveAttr
 
     describe ".attribute" do
       it "creates an attribute with no options" do
-        model_class.attributes.should include(AttributeDefinition.new(:name))
+        model_class.attributes.should include(AttributeDefinition.new(:first_name))
       end
 
       it "returns the attribute definition" do
@@ -51,8 +61,8 @@ module ActiveAttr
       end
 
       it "defines an attribute reader that calls #attribute" do
-        subject.should_receive(:attribute).with("name")
-        subject.name
+        subject.should_receive(:attribute).with("first_name")
+        subject.first_name
       end
 
       it "defines an attribute reader that can be called via super" do
@@ -61,8 +71,8 @@ module ActiveAttr
       end
 
       it "defines an attribute writer that calls #attribute=" do
-        subject.should_receive(:attribute=).with("name", "Ben")
-        subject.name = "Ben"
+        subject.should_receive(:attribute=).with("first_name", "Ben")
+        subject.first_name = "Ben"
       end
 
       it "defines an attribute writer that can be called via super" do
@@ -70,7 +80,7 @@ module ActiveAttr
         subject.amount = 1
       end
 
-      it "defining an attribute twice does not make appear in the" do
+      it "defining an attribute twice does not give the class two attribute definitions" do
         Class.new do
           include Attributes
           attribute :name
@@ -93,7 +103,7 @@ module ActiveAttr
       end
 
       it "renders the attribute names in alphabetical order" do
-        model_class.inspect.should match "(amount, name)"
+        model_class.inspect.should match "(amount, first_name, last_name)"
       end
 
       it "doesn't format the inspection string for attributes if the model does not have any" do
@@ -109,7 +119,7 @@ module ActiveAttr
       end
 
       it "returns false when compared to another type" do
-        should_not == Struct.new(:attributes).new("name" => "Ben")
+        should_not == Struct.new(:attributes).new("first_name" => "Ben")
       end
     end
 
@@ -122,32 +132,23 @@ module ActiveAttr
 
       context "when an attribute is defined" do
         it "returns the key value pairs" do
-          subject.name = "Ben"
-          subject.attributes.should include("name" => "Ben")
+          subject.first_name = "Ben"
+          subject.attributes.should include("first_name" => "Ben")
         end
 
         it "returns a new Hash " do
-          subject.attributes.merge!("name" => "Bob")
-          subject.attributes.should_not include("name" => "Bob")
+          subject.attributes.merge!("first_name" => "Bob")
+          subject.attributes.should_not include("first_name" => "Bob")
         end
 
         it "returns all attributes" do
-          subject.attributes.keys.should =~ %w(amount name)
+          subject.attributes.keys.should =~ %w(amount first_name last_name)
         end
       end
 
       context "when a getter is overridden" do
-        before do
-          subject.extend Module.new {
-            def name
-              "Benjamin"
-            end
-          }
-        end
-
         it "uses the overridden implementation" do
-          subject.name = "Ben"
-          subject.attributes.should include("name" => "Benjamin")
+          subject.attributes.should include("last_name" => last_name)
         end
       end
     end
@@ -159,14 +160,20 @@ module ActiveAttr
     end
 
     describe "#inspect" do
-      before { subject.name = "Ben" }
+      before { subject.first_name = "Ben" }
 
       it "includes the class name and all attribute values in alphabetical order by attribute name" do
-        subject.inspect.should == %q{#<Foo amount: nil, name: "Ben">}
+        subject.inspect.should == %{#<Foo amount: nil, first_name: "Ben", last_name: "#{last_name}">}
       end
 
       it "doesn't format the inspection string for attributes if the model does not have any" do
-        attributeless.new.inspect.should == %q{#<Foo>}
+        attributeless.new.inspect.should == %{#<Foo>}
+      end
+
+      context "when a getter is overridden" do
+        it "uses the overridden implementation" do
+          subject.inspect.should include %{last_name: "#{last_name}"}
+        end
       end
     end
 
@@ -174,42 +181,69 @@ module ActiveAttr
       describe "##{method}" do
         context "when an attribute is not set" do
           it "returns nil" do
-            subject.send(method, :name).should == nil
+            subject.send(method, :first_name).should be_nil
           end
         end
 
         context "when an attribute is set" do
-          let(:name) { "Bob" }
+          let(:first_name) { "Bob" }
 
-          before { subject.write_attribute(:name, name) }
+          before { subject.write_attribute(:first_name, first_name) }
 
           it "returns the attribute using a Symbol" do
-            subject.send(method, :name).should == name
+            subject.send(method, :first_name).should == first_name
           end
 
           it "returns the attribute using a String" do
-            subject.send(method, 'name').should == name
+            subject.send(method, 'first_name').should == first_name
           end
         end
+
+        context "when the getter is overridden" do
+          it "uses the overridden implementation" do
+            subject.send(method, :last_name).should == last_name
+          end
+        end
+
+        it "raises when getting an undefined attribute" do
+          expect do
+            subject.send(method, :initials)
+          end.to raise_error UnknownAttributeError, "unknown attribute: initials"
+        end
       end
     end
 
     [:[]=, :write_attribute].each do |method|
       describe "##{method}" do
         it "raises ArgumentError with one argument" do
-          expect { subject.send(method, :name) }.to raise_error(ArgumentError)
+          expect { subject.send(method, :first_name) }.to raise_error(ArgumentError)
         end
 
         it "raises ArgumentError with no arguments" do
           expect { subject.send(method) }.to raise_error(ArgumentError)
         end
 
-        it "assigns sets an attribute using a Symbol and value" do
-          expect { subject.send(method, :name, "Ben") }.to change { subject.attributes["name"] }.from(nil).to("Ben")
+        it "sets an attribute using a Symbol and value" do
+          expect { subject.send(method, :first_name, "Ben") }.to change { subject.attributes["first_name"] }.from(nil).to("Ben")
+        end
+
+        it "sets an attribute using a String and value" do
+          expect { subject.send(method, 'first_name', "Ben") }.to change { subject.attributes["first_name"] }.from(nil).to("Ben")
+        end
+
+        it "is able to set an attribute to nil" do
+          subject.first_name = "Ben"
+          expect { subject.send(method, :first_name, nil) }.to change { subject.attributes["first_name"] }.from("Ben").to(nil)
+        end
+
+        it "uses the overridden implementation when the setter is overridden" do
+          subject.send(method, :last_name, "poweski").should == "POWESKI"
         end
 
-        it "assigns sets an attribute using a String and value" do
-          expect { subject.send(method, 'name', "Ben") }.to change { subject.attributes["name"] }.from(nil).to("Ben")
+        it "raises when setting an undefined attribute" do
+          expect do
+            subject.send(method, :initials, "BP")
+          end.to raise_error UnknownAttributeError, "unknown attribute: initials"
         end
       end
     end