active_attr 0.7.0 → 0.8.0

data/spec/unit/active_attr/attributes_spec.rb

@@ -3,7 +3,7 @@ require "active_attr/attributes"
 
 module ActiveAttr
   describe Attributes do
-    subject { model_class.new }
+    subject(:model) { model_class.new }
     let(:last_name) { "Poweski" }
 
     let :model_class do
@@ -69,23 +69,23 @@ module ActiveAttr
         end
 
         it "defines an attribute reader that calls #attribute" do
-          subject.should_receive(:attribute).with("first_name")
-          subject.first_name
+          model.should_receive(:attribute).with("first_name")
+          model.first_name
         end
 
         it "defines an attribute reader that can be called via super" do
-          subject.should_receive(:attribute).with("amount")
-          subject.amount
+          model.should_receive(:attribute).with("amount")
+          model.amount
         end
 
         it "defines an attribute writer that calls #attribute=" do
-          subject.should_receive(:attribute=).with("first_name", "Ben")
-          subject.first_name = "Ben"
+          model.should_receive(:attribute=).with("first_name", "Ben")
+          model.first_name = "Ben"
         end
 
         it "defines an attribute writer that can be called via super" do
-          subject.should_receive(:attribute=).with("amount", 1)
-          subject.amount = 1
+          model.should_receive(:attribute=).with("amount", 1)
+          model.amount = 1
         end
 
         it "defining an attribute twice does not give the class two attribute definitions" do
@@ -121,17 +121,17 @@ module ActiveAttr
 
       it "defines an attribute reader that calls #attribute" do
         attributeless.attribute! :first_name
-        instance = attributeless.new
+        model = attributeless.new
         result = mock
-        instance.should_receive(:attribute).with("first_name").and_return(result)
-        instance.first_name.should equal result
+        model.should_receive(:attribute).with("first_name").and_return(result)
+        model.first_name.should equal result
       end
 
       it "defines an attribute writer that calls #attribute=" do
         attributeless.attribute! :first_name
-        instance = attributeless.new
-        instance.should_receive(:attribute=).with("first_name", "Ben")
-        instance.first_name = "Ben"
+        model = attributeless.new
+        model.should_receive(:attribute=).with("first_name", "Ben")
+        model.first_name = "Ben"
       end
     end
 
@@ -186,32 +186,32 @@ module ActiveAttr
 
       context "when an attribute is defined" do
         it "returns the key value pairs" do
-          subject.first_name = "Ben"
-          subject.attributes.should include("first_name" => "Ben")
+          model.first_name = "Ben"
+          model.attributes.should include("first_name" => "Ben")
         end
 
         it "returns a new Hash " do
-          subject.attributes.merge!("first_name" => "Bob")
-          subject.attributes.should_not include("first_name" => "Bob")
+          model.attributes.merge!("first_name" => "Bob")
+          model.attributes.should_not include("first_name" => "Bob")
         end
 
         it "returns all attributes" do
-          subject.attributes.keys.should =~ %w(amount first_name last_name)
+          model.attributes.keys.should =~ %w(amount first_name last_name)
         end
       end
 
       context "when a getter is overridden" do
         it "uses the overridden implementation" do
-          subject.attributes.should include("last_name" => last_name)
+          model.attributes.should include("last_name" => last_name)
         end
       end
     end
 
     describe "#inspect" do
-      before { subject.first_name = "Ben" }
+      before { model.first_name = "Ben" }
 
       it "includes the class name and all attribute values in alphabetical order by attribute name" do
-        subject.inspect.should == %{#<Foo amount: nil, first_name: "Ben", last_name: "#{last_name}">}
+        model.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
@@ -220,7 +220,7 @@ module ActiveAttr
 
       context "when a getter is overridden" do
         it "uses the overridden implementation" do
-          subject.inspect.should include %{last_name: "#{last_name}"}
+          model.inspect.should include %{last_name: "#{last_name}"}
         end
       end
     end
@@ -229,33 +229,33 @@ module ActiveAttr
       describe "##{method}" do
         context "when an attribute is not set" do
           it "returns nil" do
-            subject.send(method, :first_name).should be_nil
+            model.send(method, :first_name).should be_nil
           end
         end
 
         context "when an attribute is set" do
           let(:first_name) { "Bob" }
 
-          before { subject.write_attribute(:first_name, first_name) }
+          before { model.write_attribute(:first_name, first_name) }
 
           it "returns the attribute using a Symbol" do
-            subject.send(method, :first_name).should == first_name
+            model.send(method, :first_name).should == first_name
           end
 
           it "returns the attribute using a String" do
-            subject.send(method, 'first_name').should == first_name
+            model.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
+            model.send(method, :last_name).should == last_name
           end
         end
 
         it "raises when getting an undefined attribute" do
           expect do
-            subject.send(method, :initials)
+            model.send(method, :initials)
           end.to raise_error UnknownAttributeError, "unknown attribute: initials"
         end
       end
@@ -264,33 +264,33 @@ module ActiveAttr
     [:[]=, :write_attribute].each do |method|
       describe "##{method}" do
         it "raises ArgumentError with one argument" do
-          expect { subject.send(method, :first_name) }.to raise_error(ArgumentError)
+          expect { model.send(method, :first_name) }.to raise_error(ArgumentError)
         end
 
         it "raises ArgumentError with no arguments" do
-          expect { subject.send(method) }.to raise_error(ArgumentError)
+          expect { model.send(method) }.to raise_error(ArgumentError)
         end
 
         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")
+          expect { model.send(method, :first_name, "Ben") }.to change { model.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")
+          expect { model.send(method, 'first_name', "Ben") }.to change { model.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)
+          model.first_name = "Ben"
+          expect { model.send(method, :first_name, nil) }.to change { model.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"
+          model.send(method, :last_name, "poweski").should == "POWESKI"
         end
 
         it "raises when setting an undefined attribute" do
           expect do
-            subject.send(method, :initials, "BP")
+            model.send(method, :initials, "BP")
           end.to raise_error UnknownAttributeError, "unknown attribute: initials"
         end
       end

data/spec/unit/active_attr/logger_spec.rb

@@ -3,7 +3,7 @@ require "active_attr/logger"
 
 module ActiveAttr
   describe Logger do
-    subject { model_class.new }
+    subject(:model) { model_class.new }
     let(:logger) { double "logger" }
     let(:child_class) { Class.new(parent_class) }
     let(:parent_class) { model_class }
@@ -32,11 +32,11 @@ module ActiveAttr
       end
 
       it "#logger is nil" do
-        subject.logger.should be_nil
+        model.logger.should be_nil
       end
 
       it "#logger? is false" do
-        subject.logger?.should == false
+        model.logger?.should == false
       end
     end
 
@@ -61,11 +61,11 @@ module ActiveAttr
       end
 
       it "#logger is the logger" do
-        subject.logger.should == logger
+        model.logger.should == logger
       end
 
       it "#logger? is true" do
-        subject.logger?.should == true
+        model.logger?.should == true
       end
     end
 
@@ -89,17 +89,17 @@ module ActiveAttr
       end
 
       it "#logger is the logger" do
-        subject.logger.should == logger
+        model.logger.should == logger
       end
 
       it "#logger? is true" do
-        subject.logger?.should == true
+        model.logger?.should == true
       end
     end
 
     context "when the logger is set on a parent class" do
       before { parent_class.logger = logger }
-      subject { child_class.new }
+      subject(:model) { child_class.new }
 
       it "#{described_class}.logger is nil" do
         described_class.logger.should be_nil
@@ -118,17 +118,17 @@ module ActiveAttr
       end
 
       it "#logger is the logger" do
-        subject.logger.should == logger
+        model.logger.should == logger
       end
 
       it "#logger? is true" do
-        subject.logger?.should == true
+        model.logger?.should == true
       end
     end
 
     context "when the logger is set on a child class" do
       before { child_class.logger = logger }
-      subject { parent_class.new }
+      subject(:model) { parent_class.new }
 
       it "#{described_class}.logger is nil" do
         described_class.logger.should be_nil
@@ -147,16 +147,16 @@ module ActiveAttr
       end
 
       it "#logger is nil" do
-        subject.logger.should be_nil
+        model.logger.should be_nil
       end
 
       it "#logger? is false" do
-        subject.logger?.should == false
+        model.logger?.should == false
       end
     end
 
     context "when the logger is set on the instance" do
-      before { subject.logger = logger }
+      before { model.logger = logger }
 
       it "#{described_class}.logger is nil" do
         described_class.logger.should be_nil
@@ -175,11 +175,11 @@ module ActiveAttr
       end
 
       it "#logger is the logger" do
-        subject.logger.should == logger
+        model.logger.should == logger
       end
 
       it "#logger? is true" do
-        subject.logger?.should == true
+        model.logger?.should == true
       end
     end
   end

data/spec/unit/active_attr/mass_assignment_spec.rb

@@ -3,7 +3,7 @@ require "active_attr/mass_assignment"
 
 module ActiveAttr
   describe MassAssignment, :mass_assignment do
-    subject do
+    before do
       model_class.class_eval do
         include MassAssignment
       end

data/spec/unit/active_attr/matchers_spec.rb

@@ -3,20 +3,19 @@ require "active_attr/matchers"
 
 module ActiveAttr
   describe Matchers do
-    let(:dsl) { Object.new.extend described_class }
-    subject { dsl }
+    subject(:dsl) { Object.new.extend described_class }
 
     it { should respond_to(:have_attribute).with(1).argument }
 
     describe "#have_attribute" do
-      subject { dsl.have_attribute(:first_name) }
+      subject(:matcher) { dsl.have_attribute(:first_name) }
 
       it "builds a HaveAttributeMatcher" do
         should be_a_kind_of Matchers::HaveAttributeMatcher
       end
 
       it "uses the given attribute name to construct the matcher" do
-        subject.send(:attribute_name).should == :first_name
+        matcher.send(:attribute_name).should == :first_name
       end
     end
   end

data/spec/unit/active_attr/query_attributes_spec.rb

@@ -4,7 +4,7 @@ require "bigdecimal"
 
 module ActiveAttr
   describe QueryAttributes do
-    subject { model_class.new }
+    subject(:model) { model_class.new }
 
     let :model_class do
       Class.new do
@@ -29,196 +29,196 @@ module ActiveAttr
 
     describe ".attribute" do
       it "defines an attribute predicate method that calls #attribute?" do
-        subject.should_receive(:attribute?).with("value")
-        subject.value?
+        model.should_receive(:attribute?).with("value")
+        model.value?
       end
 
       it "defines an attribute reader that can be called via super" do
-        subject.should_receive(:attribute?).with("overridden")
-        subject.overridden?
+        model.should_receive(:attribute?).with("overridden")
+        model.overridden?
       end
     end
 
     describe "#query_attribute" do
       it "raises ArgumentError when called with two arguments" do
-        expect { subject.query_attribute(:a, :b) }.to raise_error ArgumentError
+        expect { model.query_attribute(:a, :b) }.to raise_error ArgumentError
       end
 
       it "does not raise when called with a single argument" do
-        expect { subject.query_attribute(:a) }.not_to raise_error ArgumentError
+        expect { model.query_attribute(:a) }.not_to raise_error ArgumentError
       end
 
       it "raises ArgumentError when called with no arguments" do
-        expect { subject.query_attribute }.to raise_error ArgumentError
+        expect { model.query_attribute }.to raise_error ArgumentError
       end
 
       it "calls the predicate method if defined" do
-        subject.query_attribute(:true).should eq true
-        subject.query_attribute(:false).should == false
+        model.query_attribute(:true).should eq true
+        model.query_attribute(:false).should == false
       end
 
       it "raises when getting an undefined attribute" do
-        expect { subject.query_attribute(:initials) }.to raise_error UnknownAttributeError, "unknown attribute: initials"
+        expect { model.query_attribute(:initials) }.to raise_error UnknownAttributeError, "unknown attribute: initials"
       end
 
       it "is false when the attribute is false" do
-        subject.value = false
-        subject.value?.should == false
+        model.value = false
+        model.value?.should == false
       end
 
       it "is true when the attribute is true" do
-        subject.value = true
-        subject.value?.should == true
+        model.value = true
+        model.value?.should == true
       end
 
       it "is false when the attribute is nil" do
-        subject.value = nil
-        subject.value?.should == false
+        model.value = nil
+        model.value?.should == false
       end
 
       it "is true when the attribute is an Object" do
-        subject.value = Object.new
-        subject.value?.should == true
+        model.value = Object.new
+        model.value?.should == true
       end
 
       it "is false when the attribute is an empty string" do
-        subject.value = ""
-        subject.value?.should == false
+        model.value = ""
+        model.value?.should == false
       end
 
       it "is true when the attribute is a non-empty string" do
-        subject.value = "Chris"
-        subject.value?.should == true
+        model.value = "Chris"
+        model.value?.should == true
       end
 
       it "is false when the attribute is 0" do
-        subject.value = 0
-        subject.value?.should == false
+        model.value = 0
+        model.value?.should == false
       end
 
       it "is true when the attribute is 1" do
-        subject.value = 1
-        subject.value?.should == true
+        model.value = 1
+        model.value?.should == true
       end
 
       it "is false when the attribute is 0.0" do
-        subject.value = 0.0
-        subject.value?.should == false
+        model.value = 0.0
+        model.value?.should == false
       end
 
       it "is true when the attribute is 0.1" do
-        subject.value = 0.1
-        subject.value?.should == true
+        model.value = 0.1
+        model.value?.should == true
       end
 
       it "is false when the attribute is a zero BigDecimal" do
-        subject.value = BigDecimal.new("0.0")
-        subject.value?.should == false
+        model.value = BigDecimal.new("0.0")
+        model.value?.should == false
       end
 
       it "is true when the attribute is a non-zero BigDecimal" do
-        subject.value = BigDecimal.new("0.1")
-        subject.value?.should == true
+        model.value = BigDecimal.new("0.1")
+        model.value?.should == true
       end
 
       it "is true when the attribute is -1" do
-        subject.value = -1
-        subject.value?.should == true
+        model.value = -1
+        model.value?.should == true
       end
 
       it "is false when the attribute is -0.0" do
-        subject.value = -0.0
-        subject.value?.should == false
+        model.value = -0.0
+        model.value?.should == false
       end
 
       it "is true when the attribute is -0.1" do
-        subject.value = -0.1
-        subject.value?.should == true
+        model.value = -0.1
+        model.value?.should == true
       end
 
       it "is false when the attribute is a negative zero BigDecimal" do
-        subject.value = BigDecimal.new("-0.0")
-        subject.value?.should == false
+        model.value = BigDecimal.new("-0.0")
+        model.value?.should == false
       end
 
       it "is true when the attribute is a negative BigDecimal" do
-        subject.value = BigDecimal.new("-0.1")
-        subject.value?.should == true
+        model.value = BigDecimal.new("-0.1")
+        model.value?.should == true
       end
 
       it "is false when the attribute is '0'" do
-        subject.value = "0"
-        subject.value?.should == false
+        model.value = "0"
+        model.value?.should == false
       end
 
       it "is true when the attribute is '1'" do
-        subject.value = "1"
-        subject.value?.should == true
+        model.value = "1"
+        model.value?.should == true
       end
 
       it "is false when the attribute is '0.0'" do
-        subject.value = "0.0"
-        subject.value?.should == false
+        model.value = "0.0"
+        model.value?.should == false
       end
 
       it "is true when the attribute is '0.1'" do
-        subject.value = "0.1"
-        subject.value?.should == true
+        model.value = "0.1"
+        model.value?.should == true
       end
 
       it "is true when the attribute is '-1'" do
-        subject.value = "-1"
-        subject.value?.should == true
+        model.value = "-1"
+        model.value?.should == true
       end
 
       it "is false when the attribute is '-0.0'" do
-        subject.value = "-0.0"
-        subject.value?.should == false
+        model.value = "-0.0"
+        model.value?.should == false
       end
 
       it "is true when the attribute is '-0.1'" do
-        subject.value = "-0.1"
-        subject.value?.should == true
+        model.value = "-0.1"
+        model.value?.should == true
       end
 
       it "is true when the attribute is 'true'" do
-        subject.value = "true"
-        subject.value?.should == true
+        model.value = "true"
+        model.value?.should == true
       end
 
       it "is false when the attribute is 'false'" do
-        subject.value = "false"
-        subject.value?.should == false
+        model.value = "false"
+        model.value?.should == false
       end
 
       it "is true when the attribute is 't'" do
-        subject.value = "t"
-        subject.value?.should == true
+        model.value = "t"
+        model.value?.should == true
       end
 
       it "is false when the attribute is 'f'" do
-        subject.value = "f"
-        subject.value?.should == false
+        model.value = "f"
+        model.value?.should == false
       end
 
       it "is true when the attribute is 'T'" do
-        subject.value = "T"
-        subject.value?.should == true
+        model.value = "T"
+        model.value?.should == true
       end
 
       it "is false when the attribute is 'F'" do
-        subject.value = "F"
-        subject.value?.should == false
+        model.value = "F"
+        model.value?.should == false
       end
 
       it "is true when the attribute is 'TRUE'" do
-        subject.value = "TRUE"
-        subject.value?.should == true
+        model.value = "TRUE"
+        model.value?.should == true
       end
 
       it "is false when the attribute is 'FALSE" do
-        subject.value = "FALSE"
-        subject.value?.should == false
+        model.value = "FALSE"
+        model.value?.should == false
       end
     end
   end