active_attr 0.13.1 → 0.15.3

data/lib/active_attr/typecasting/integer_typecaster.rb

@@ -1,3 +1,5 @@
+require "active_support/core_ext/object/blank"
+
 module ActiveAttr
   module Typecasting
     # Typecasts an Object to an Integer
@@ -21,7 +23,7 @@ module ActiveAttr
       #
       # @since 0.5.0
       def call(value)
-        value.to_i if value.respond_to? :to_i
+        value.to_i if value.present? && value.respond_to?(:to_i)
       rescue FloatDomainError
       end
     end

data/lib/active_attr/version.rb

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

data/spec/functional/active_attr/attributes_spec.rb

@@ -1,7 +1,7 @@
 require "spec_helper"
 require "active_attr/attributes"
 require "active_model"
-require "factory_girl"
+require "factory_bot"
 
 module ActiveAttr
   describe Attributes do
@@ -149,22 +149,22 @@ module ActiveAttr
       end
     end
 
-    context "building with FactoryGirl" do
-      subject(:model) { FactoryGirl.build(:person) }
+    context "building with FactoryBot" do
+      subject(:model) { FactoryBot.build(:person) }
 
       before do
         Object.const_set("Person", model_class)
 
-        FactoryGirl.define do
+        FactoryBot.define do
           factory :person, :class => :person do
-            first_name "Chris"
-            last_name "Griego"
+            first_name { "Chris" }
+            last_name { "Griego" }
           end
         end
       end
 
       after do
-        FactoryGirl.factories.clear
+        FactoryBot.factories.clear
         Object.send :remove_const, "Person"
       end
 
@@ -201,28 +201,6 @@ module ActiveAttr
         end
       end
 
-      shared_examples "a whitelisted attribute" do
-        it ".dangerous_attribute? is falsey" do
-          model_class.dangerous_attribute?(attribute_name).should be_falsey
-        end
-
-        it ".attribute does not raise" do
-          expect { model_class.attribute(attribute_name) }.not_to raise_error
-        end
-
-        it ".attribute! does not raise" do
-          expect { model_class.attribute!(attribute_name) }.not_to raise_error
-        end
-
-        it "can be set and get" do
-          model_class.attribute attribute_name
-          model = model_class.new
-          value = double
-          model.send "#{attribute_name}=", value
-          model.send(attribute_name).should equal value
-        end
-      end
-
       shared_examples "defining dangerous attributes" do
         context "an attribute that conflicts with #{described_class}" do
           let(:attribute_name) { :write_attribute }
@@ -258,16 +236,6 @@ module ActiveAttr
           let(:attribute_name) { :my_less_proper_missing_method }
           include_examples "a dangerous attribute"
         end
-
-        context "an :id attribute" do
-          let(:attribute_name) { :id }
-          include_examples "a whitelisted attribute"
-        end
-
-        context "a :type attribute" do
-          let(:attribute_name) { :type }
-          include_examples "a whitelisted attribute"
-        end
       end
 
       let :dangerous_model_class do
@@ -284,7 +252,7 @@ module ActiveAttr
             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))
+              super || method_name.to_s == "my_less_proper_missing_method"
             end
           end
         end

data/spec/functional/active_attr/mass_assignment_spec.rb

@@ -40,7 +40,7 @@ module ActiveAttr
         end
       end
 
-      context "white listing attributes" do
+      context "allowing attributes" do
         before do
           model_class.class_eval do
             attr_accessible :first_name, :last_name, :name
@@ -53,7 +53,7 @@ module ActiveAttr
         describe "#initialize", :initialize, :secure_mass_assignment_method, :secure_mass_assignment_method_with_options
       end
 
-      context "black listing attributes" do
+      context "denying attributes" do
         before do
           model_class.class_eval do
             attr_protected :age

data/spec/functional/active_attr/matchers/have_attribute_matcher_spec.rb

@@ -14,6 +14,14 @@ module ActiveAttr
           include AttributeDefaults
           include TypecastedAttributes
 
+          def john
+            "John"
+          end
+
+          def doe
+            "Doe"
+          end
+
           def self.name
             "Person"
           end
@@ -167,6 +175,25 @@ module ActiveAttr
           end
         end
 
+        context "a class with the attribute and a different default (lazy evaluation)" do
+          before { model_class.attribute :first_name, :default => lambda { doe } }
+
+          describe "#matches?" do
+            it { matcher.matches?(model_class).should == false }
+          end
+
+          describe "#failure_message" do
+            before { matcher.matches?(model_class) }
+
+            it do
+              matcher.failure_message.should match Regexp.new <<-MESSAGE.strip_heredoc.chomp, Regexp::MULTILINE
+                expected: attribute :first_name, :default => "John"
+                     got: attribute :first_name, :default => #<Proc.+?>
+              MESSAGE
+            end
+          end
+        end
+
         context "a class with the attribute and the right default" do
           before { model_class.attribute :first_name, :default => "John" }
 
@@ -187,6 +214,27 @@ module ActiveAttr
             end
           end
         end
+
+        context "a class with the attribute and the right default (lazy evaluation)" do
+          before { model_class.attribute :first_name, :default => lambda { john } }
+
+          describe "#matches?" do
+            it { matcher.matches?(model_class).should == true }
+          end
+
+          [:negative_failure_message, :failure_message_when_negated].each do |method|
+            describe "##{method}" do
+              before { matcher.matches?(model_class) }
+
+              it do
+                matcher.send(method).should match Regexp.new <<-MESSAGE.strip_heredoc.chomp, Regexp::MULTILINE
+                  expected not: attribute :first_name, :default => "John"
+                           got: attribute :first_name, :default => #<Proc.+?>
+                MESSAGE
+              end
+            end
+          end
+        end
       end
 
       context "a matcher with a default value of false" do

data/spec/functional/active_attr/model_spec.rb

@@ -120,5 +120,52 @@ module ActiveAttr
         end.end_date.should == Date.today
       end
     end
+
+    context "when define validation callbacks" do
+      let :model_class do
+        Class.new do
+          include Model
+
+          attribute :name
+          attribute :status
+
+          validates :name, :presence => true, :length => {:maximum => 6}
+
+          before_validation :remove_whitespaces
+          after_validation :set_status
+
+          def self.name
+            "Person"
+          end
+
+          private
+
+          def remove_whitespaces
+            name.strip!
+          end
+
+          def set_status
+            self.status = errors.empty?
+          end
+        end
+      end
+
+      it "can call before_validation" do
+        person = model_class.new(:name => "  bob  ")
+
+        expect(person.valid?).to be(true)
+        expect(person.name).to eq("bob")
+      end
+
+      it "can call after_validation" do
+        person = model_class.new(:name => "")
+        expect(person.valid?).to be(false)
+        expect(person.status).to be(false)
+
+        person = model_class.new(:name => "alice")
+        expect(person.valid?).to be(true)
+        expect(person.status).to be(true)
+      end
+    end
   end
 end

data/spec/unit/active_attr/attribute_defaults_spec.rb

@@ -4,14 +4,18 @@ require "active_attr/attribute_defaults"
 module ActiveAttr
   describe AttributeDefaults do
     subject(:model) { model_class.new }
+    let(:non_duplicable) { double("non-duplicable", :duplicable? => false) }
 
     let :model_class do
+      non_duplicable_default = non_duplicable
+
       Class.new do
         include InitializationVerifier
         include AttributeDefaults
         attribute :first_name, :default => "John"
         attribute :age, :default => nil
         attribute :created_at, :default => lambda { Time.now }
+        attribute :non_duplicable, :default => non_duplicable_default
       end
     end
 
@@ -32,6 +36,10 @@ module ActiveAttr
       it "includes declared dynamic attribute defaults" do
         attribute_defaults["created_at"].should be_a_kind_of Time
       end
+
+      it "includes non-duplicable attribute defaults" do
+        attribute_defaults["non_duplicable"].should == non_duplicable
+      end
     end
 
     describe "#initialize" do

data/spec/unit/active_attr/attributes_spec.rb

@@ -9,6 +9,7 @@ module ActiveAttr
     let :model_class do
       Class.new do
         include Attributes
+
         attribute :first_name
         attribute :last_name
         attribute :amount
@@ -133,6 +134,11 @@ module ActiveAttr
         model.should_receive(:attribute=).with("first_name", "Ben")
         model.first_name = "Ben"
       end
+
+      it "returns the new attribute definition" do
+        result = attributeless.attribute! :first_name
+        result.should == AttributeDefinition.new(:first_name)
+      end
     end
 
     describe ".attributes" do
@@ -151,6 +157,38 @@ module ActiveAttr
       end
     end
 
+    describe "#{described_class}.filter_attributes" do
+      after { described_class.send(:remove_instance_variable, "@filter_attributes") }
+
+      it "defaults to an empty array" do
+        described_class.filter_attributes.should == []
+      end
+
+      it "can be mutated" do
+        described_class.filter_attributes << :password
+        described_class.filter_attributes.should == [:password]
+      end
+
+      it "can be assigned" do
+        described_class.filter_attributes += [:password]
+        described_class.filter_attributes.should == [:password]
+      end
+
+      it "initiailizes new classes using the module config" do
+        described_class.filter_attributes += [:password]
+        model_class.filter_attributes.should == [:password]
+      end
+
+      it "subclasses should inherit from the parent class" do
+        model_class.filter_attributes = [:password]
+        Class.new(model_class).filter_attributes.should == [:password]
+      end
+
+      it "cannot be overridden on instances" do
+        model_class.new.should_not respond_to(:filter_attributes=)
+      end
+    end
+
     describe ".inspect" do
       it "renders the class name" do
         model_class.inspect.should match(/^Foo\(.*\)$/)
@@ -214,6 +252,59 @@ module ActiveAttr
         model.inspect.should == %{#<Foo amount: nil, first_name: "Ben", last_name: "#{last_name}">}
       end
 
+      context "filtering attributes with a Symbol" do
+        before { model_class.filter_attributes = [:amount] }
+
+        it "does not filter an attribute with a nil value" do
+          model.inspect.should == %{#<Foo amount: nil, first_name: "Ben", last_name: "#{last_name}">}
+        end
+
+        it "filters filtered attributes that have a value" do
+          model.amount = 100
+          model.inspect.should == %{#<Foo amount: [FILTERED], first_name: "Ben", last_name: "#{last_name}">}
+        end
+      end
+
+      context "filtering attributes with a String" do
+        before { model_class.filter_attributes = ["amount"] }
+
+        it "does not filter an attribute with a nil value" do
+          model.inspect.should == %{#<Foo amount: nil, first_name: "Ben", last_name: "#{last_name}">}
+        end
+
+        it "filters filtered attributes that have a value" do
+          model.amount = 100
+          model.inspect.should == %{#<Foo amount: [FILTERED], first_name: "Ben", last_name: "#{last_name}">}
+        end
+      end
+
+      context "filtering attributes with a partial attribute name" do
+        before { model_class.filter_attributes = [:name] }
+
+        it "filters filtered attributes that have a value and whose attribute contains the filtered attribute name" do
+          model.inspect.should == %{#<Foo amount: nil, first_name: [FILTERED], last_name: [FILTERED]>}
+        end
+      end
+
+      context "filtering attributes with a Regexp" do
+        before { model_class.filter_attributes = [/name/i] }
+
+        it "filters filtered attributes that have a value and whose attribute matches the Regexp" do
+          model.inspect.should == %{#<Foo amount: nil, first_name: [FILTERED], last_name: [FILTERED]>}
+        end
+      end
+
+      context "filtering attributes with a Proc with 2 arguments" do
+        before do
+          model.amount = 100
+          model_class.filter_attributes = [->(key, value) { value.reverse! if key =~ /name/ }]
+        end
+
+        it "filters filtered attributes that have a value by mutating the attributes" do
+          model.inspect.should == %{#<Foo amount: 100, first_name: "neB", last_name: "iksewoP">}
+        end
+      end
+
       it "doesn't format the inspection string for attributes if the model does not have any" do
         attributeless.new.inspect.should == %{#<Foo>}
       end

data/spec/unit/active_attr/typecasting/big_decimal_typecaster_spec.rb

@@ -12,18 +12,26 @@ module ActiveAttr
           typecaster.call(value).should equal value
         end
 
-        it "casts nil to a zero BigDecimal" do
-          typecaster.call(nil).should eql BigDecimal("0.0")
+        it "casts nil to nil" do
+          typecaster.call(nil).should eql nil
         end
 
         it "casts a numeric String to a BigDecimal" do
           typecaster.call("2").should eql BigDecimal("2.0")
         end
 
-        it "casts a alpha String to a zero BigDecimal" do
+        it "casts an empty String to nil" do
+          typecaster.call("").should eql nil
+        end
+
+        it "casts an alpha String to a zero BigDecimal" do
           typecaster.call("bob").should eql BigDecimal("0.0")
         end
 
+        it "casts an alpha string coercable object to a zero BigDecimal" do
+          typecaster.call(double(to_s: "bob")).should eql BigDecimal("0.0")
+        end
+
         it "casts a Rational to a BigDecimal" do
           typecaster.call(Rational(1, 2)).should eql BigDecimal("0.5")
         end

data/spec/unit/active_attr/typecasting/boolean_typecaster_spec.rb

@@ -16,8 +16,8 @@ module ActiveAttr
           typecaster.call(false).should equal false
         end
 
-        it "casts nil to false" do
-          typecaster.call(nil).should equal false
+        it "casts nil to nil" do
+          typecaster.call(nil).should equal nil
         end
 
         it "casts an Object to true" do
@@ -26,7 +26,7 @@ module ActiveAttr
 
         context "when the value is a String" do
           it "casts an empty String to false" do
-            typecaster.call("").should equal false
+            typecaster.call("").should equal nil
           end
 
           it "casts a non-empty String to true" do