active_attr 0.7.0 → 0.8.0

data/spec/functional/active_attr/model_spec.rb

@@ -1,5 +1,6 @@
 require "spec_helper"
 require "active_attr/model"
+require "active_model/mass_assignment_security"
 require "active_support/core_ext/hash/conversions"
 require "active_support/json/decoding"
 
@@ -8,6 +9,7 @@ module ActiveAttr
     let :model_class do
       Class.new do
         include Model
+        include ActiveModel::MassAssignmentSecurity
 
         attribute :first_name
         attribute :last_name
@@ -21,19 +23,22 @@ module ActiveAttr
       end
     end
 
-    subject { model_class.new }
-    it_should_behave_like "ActiveModel"
+    subject(:model) { model_class.new }
+
+    it_should_behave_like "ActiveModel" do
+      subject { model_class.new }
+    end
 
     it "reads and writes attributes" do
-      subject.first_name = "Chris"
-      subject.first_name.should eq "Chris"
-      subject.attributes["first_name"].should == "Chris"
+      model.first_name = "Chris"
+      model.first_name.should eq "Chris"
+      model.attributes["first_name"].should == "Chris"
     end
 
     it "can query attributes" do
-      subject.first_name?.should be_false
-      subject.first_name = "Chris"
-      subject.first_name?.should be_true
+      model.first_name?.should be_false
+      model.first_name = "Chris"
+      model.first_name?.should be_true
     end
 
     it "initializes with a block that can use attributes" do
@@ -51,14 +56,14 @@ module ActiveAttr
     it "has a logger" do
       logger = double("logger")
       model_class.logger?.should be_false
-      subject.logger?.should be_false
+      model.logger?.should be_false
 
       model_class.logger = logger
 
       model_class.logger?.should be_true
       model_class.logger.should eq logger
-      subject.logger?.should be_true
-      subject.logger.should == logger
+      model.logger?.should be_true
+      model.logger.should == logger
     end
 
     it "supports mass assignment with security" do
@@ -68,17 +73,19 @@ module ActiveAttr
     end
 
     it "does not use strict mass assignment" do
-      expect { subject.assign_attributes :middle_initial => "J" }.not_to raise_error
+      expect { model.assign_attributes :middle_initial => "J" }.not_to raise_error
     end
 
     it "serializes to/from JSON" do
-      subject.first_name = "Chris"
-      model_class.new.from_json(subject.to_json).first_name.should == "Chris"
+      model.first_name = "Chris"
+      model_class.new.from_json(model.to_json).first_name.should == "Chris"
     end
 
     it "serializes to/from XML" do
-      subject.first_name = "Chris"
-      model_class.new.from_xml(subject.to_xml).first_name.should == "Chris"
+      model.first_name = "Chris"
+      model.last_name = "Griego"
+      model.age = 21
+      model_class.new.from_xml(model.to_xml).first_name.should == "Chris"
     end
 
     it "supports attribute name translation" do
@@ -86,14 +93,15 @@ module ActiveAttr
     end
 
     it "typecasts attributes" do
-      subject.age = "29"
-      subject.age.should eql 29
+      model.age = "29"
+      model.age.should eql 29
     end
 
     context "attribute defaults" do
       let :model_class do
         Class.new do
           include Model
+          include ActiveModel::MassAssignmentSecurity
 
           attribute :start_date
           attribute :end_date, :default => lambda { start_date }
@@ -102,7 +110,7 @@ module ActiveAttr
       end
 
       it "are applied" do
-        subject.age_limit.should == 21
+        model.age_limit.should == 21
       end
 
       it "are overridden by mass assigned attributes" do

data/spec/functional/active_attr/serialization_spec.rb

@@ -16,16 +16,16 @@ module ActiveAttr
       end
     end
 
-    subject { model_class.new }
+    subject(:model) { model_class.new }
 
     it "serializes to/from JSON" do
-      subject.first_name = "Chris"
-      model_class.new.from_json(subject.to_json).first_name.should == "Chris"
+      model.first_name = "Chris"
+      model_class.new.from_json(model.to_json).first_name.should == "Chris"
     end
 
     it "serializes to/from XML" do
-      subject.first_name = "Chris"
-      model_class.new.from_xml(subject.to_xml).first_name.should == "Chris"
+      model.first_name = "Chris"
+      model_class.new.from_xml(model.to_xml).first_name.should == "Chris"
     end
   end
 end

data/spec/functional/active_attr/typecasted_attributes_spec.rb

@@ -3,7 +3,7 @@ require "active_attr/typecasted_attributes"
 
 module ActiveAttr
   describe TypecastedAttributes do
-    subject { model_class.new }
+    subject(:model) { model_class.new }
 
     let :model_class do
       Class.new do
@@ -30,118 +30,118 @@ module ActiveAttr
 
     context "when assigning nil" do
       it "a typeless attribute returns nil" do
-        subject.typeless = nil
-        subject.typeless.should be_nil
+        model.typeless = nil
+        model.typeless.should be_nil
       end
 
       it "an attribute with no known typecaster raises" do
-        subject.unknown = nil
-        expect { subject.unknown }.to raise_error Typecasting::UnknownTypecasterError, "Unable to cast to type Unknown"
+        model.unknown = nil
+        expect { model.unknown }.to raise_error Typecasting::UnknownTypecasterError, "Unable to cast to type Unknown"
       end
 
       it "an attribute with an inline typecaster returns nil" do
-        subject.age = nil
-        subject.age.should be_nil
+        model.age = nil
+        model.age.should be_nil
       end
 
       it "an Object attribute returns nil" do
-        subject.object = nil
-        subject.object.should be_nil
+        model.object = nil
+        model.object.should be_nil
       end
 
       it "a BigDecimal attribute returns nil" do
-        subject.big_decimal = nil
-        subject.big_decimal.should be_nil
+        model.big_decimal = nil
+        model.big_decimal.should be_nil
       end
 
       it "a Boolean attribute returns nil" do
-        subject.boolean = nil
-        subject.boolean.should be_nil
+        model.boolean = nil
+        model.boolean.should be_nil
       end
 
       it "a Date attribute returns nil" do
-        subject.date = nil
-        subject.date.should be_nil
+        model.date = nil
+        model.date.should be_nil
       end
 
       it "a DateTime attribute returns nil" do
-        subject.date_time = nil
-        subject.date_time.should be_nil
+        model.date_time = nil
+        model.date_time.should be_nil
       end
 
       it "a Float attribute returns nil" do
-        subject.float = nil
-        subject.float.should be_nil
+        model.float = nil
+        model.float.should be_nil
       end
 
       it "an Integer attribute returns nil" do
-        subject.integer = nil
-        subject.integer.should be_nil
+        model.integer = nil
+        model.integer.should be_nil
       end
 
       it "a String attribute returns nil" do
-        subject.string = nil
-        subject.string.should be_nil
+        model.string = nil
+        model.string.should be_nil
       end
     end
 
     context "when assigning a valid String" do
       it "a typeless attribute returns the original String" do
         value = "test"
-        subject.typeless = value
-        subject.typeless.should equal value
+        model.typeless = value
+        model.typeless.should equal value
       end
 
       it "an Object attribute returns the original String" do
         value = "test"
-        subject.object = value
-        subject.object.should equal value
+        model.object = value
+        model.object.should equal value
       end
 
       it "a BigDecimal attribute returns a BigDecimal" do
-        subject.big_decimal = "1.1"
-        subject.big_decimal.should eql BigDecimal.new("1.1")
+        model.big_decimal = "1.1"
+        model.big_decimal.should eql BigDecimal.new("1.1")
       end
 
       it "a Boolean attribute returns a Boolean" do
-        subject.boolean = "false"
-        subject.boolean.should eql false
+        model.boolean = "false"
+        model.boolean.should eql false
       end
 
       it "a Date attribute returns a Date" do
-        subject.date = "2012-01-01"
-        subject.date.should eql Date.new(2012, 1, 1)
+        model.date = "2012-01-01"
+        model.date.should eql Date.new(2012, 1, 1)
       end
 
       it "a Date attribute before typecasting returns the original String" do
         value = "2012-01-01"
-        subject.date = value
-        subject.date_before_type_cast.should equal value
+        model.date = value
+        model.date_before_type_cast.should equal value
       end
 
       it "a DateTime attribute returns a DateTime" do
-        subject.date_time = "2012-01-01"
-        subject.date_time.should eql DateTime.new(2012, 1, 1)
+        model.date_time = "2012-01-01"
+        model.date_time.should eql DateTime.new(2012, 1, 1)
       end
 
       it "a Float attribute returns a Float" do
-        subject.float = "1.1"
-        subject.float.should eql 1.1
+        model.float = "1.1"
+        model.float.should eql 1.1
       end
 
       it "an Integer attribute returns an Integer" do
-        subject.integer = "1"
-        subject.integer.should eql 1
+        model.integer = "1"
+        model.integer.should eql 1
       end
 
       it "a String attribute returns the String" do
-        subject.string = "1.0"
-        subject.string.should eql "1.0"
+        model.string = "1.0"
+        model.string.should eql "1.0"
       end
 
       it "an attribute using an inline typecaster returns the result of the inline typecaster" do
-        subject.age = 2
-        subject.age.should == Age.new(2)
+        model.age = 2
+        model.age.should == Age.new(2)
       end
     end
   end

data/spec/support/mass_assignment_shared_examples.rb

@@ -12,7 +12,7 @@ shared_examples "mass assignment class", :mass_assignment => true do
     end
   end
 
-  let(:person) { subject.new }
+  let(:person) { model_class.new }
   let(:first_name) { "Chris" }
   let(:last_name) { "Griego" }
 
@@ -52,19 +52,19 @@ shared_examples "#assign_attribures", :assign_attributes => true do
   end
 
   it "raises ArgumentError when called with three arguments" do
-    expect { subject.new.assign_attributes({}, {}, nil) }.to raise_error ArgumentError
+    expect { model_class.new.assign_attributes({}, {}, nil) }.to raise_error ArgumentError
   end
 
   it "does not raise when called with two arguments" do
-    expect { subject.new.assign_attributes({}, {}) }.not_to raise_error
+    expect { model_class.new.assign_attributes({}, {}) }.not_to raise_error
   end
 
   it "does not raise when called with a single argument" do
-    expect { subject.new.assign_attributes({}) }.not_to raise_error
+    expect { model_class.new.assign_attributes({}) }.not_to raise_error
   end
 
   it "raises ArgumentError when called with no arguments" do
-    expect { subject.new.assign_attributes }.to raise_error ArgumentError
+    expect { model_class.new.assign_attributes }.to raise_error ArgumentError
   end
 end
 
@@ -81,30 +81,30 @@ end
 
 shared_examples "#initialize", :initialize => true do
   def mass_assign_attributes(attributes)
-    subject.new(attributes)
+    model_class.new(attributes)
   end
 
   def mass_assign_attributes_with_options(attributes, options)
-    subject.new(attributes, options)
+    model_class.new(attributes, options)
   end
 
   it "invokes the superclass initializer" do
-    subject.new.should be_initialized
+    model_class.new.should be_initialized
   end
 
   it "raises ArgumentError when called with three arguments" do
-    expect { subject.new({}, {}, nil) }.to raise_error ArgumentError
+    expect { model_class.new({}, {}, nil) }.to raise_error ArgumentError
   end
 
   it "does not raise when called with two arguments" do
-    expect { subject.new({}, {}) }.not_to raise_error
+    expect { model_class.new({}, {}) }.not_to raise_error
   end
 
   it "does not raise when called with a single argument" do
-    expect { subject.new({}) }.not_to raise_error
+    expect { model_class.new({}) }.not_to raise_error
   end
 
   it "does not raise when called with no arguments" do
-    expect { subject.new }.not_to raise_error
+    expect { model_class.new }.not_to raise_error
   end
 end

data/spec/unit/active_attr/attribute_defaults_spec.rb

@@ -3,7 +3,7 @@ require "active_attr/attribute_defaults"
 
 module ActiveAttr
   describe AttributeDefaults do
-    subject { model_class.new }
+    subject(:model) { model_class.new }
 
     let :model_class do
       Class.new do
@@ -16,21 +16,21 @@ module ActiveAttr
     end
 
     describe "#attribute_defaults" do
-      subject { model_class.new.attribute_defaults }
+      subject(:attribute_defaults) { model_class.new.attribute_defaults }
 
       it { should be_a_kind_of Hash }
 
       it "includes declared literal string attribute defaults" do
-        subject["first_name"].should == "John"
+        attribute_defaults["first_name"].should == "John"
       end
 
       it "includes declared nil attribute defaults" do
-        subject.should include "age"
-        subject["age"].should be_nil
+        attribute_defaults.should include "age"
+        attribute_defaults["age"].should be_nil
       end
 
       it "includes declared dynamic attribute defaults" do
-        subject["created_at"].should be_a_kind_of Time
+        attribute_defaults["created_at"].should be_a_kind_of Time
       end
     end
 

data/spec/unit/active_attr/attribute_definition_spec.rb

@@ -3,15 +3,15 @@ require "active_attr/attribute_definition"
 
 module ActiveAttr
   describe AttributeDefinition do
-    subject { described_class.new(:amount, :default => "default") }
+    subject(:attribute_definition) { described_class.new(:amount, :default => "default") }
 
     describe "#<=>" do
       it "is nil if the right side is not an #{described_class}" do
-        (subject <=> nil).should be_nil
+        (attribute_definition <=> nil).should be_nil
       end
 
       it "prefers neither when both sides use the same attribute name and options" do
-        (subject <=> subject).should == 0
+        (attribute_definition <=> attribute_definition).should == 0
       end
 
       it "prefers the left side when the left side name sorts alphabetically before the right side name" do
@@ -39,7 +39,7 @@ module ActiveAttr
 
     describe "#[]" do
       it "reads an attribute option" do
-        subject[:default].should == "default"
+        attribute_definition[:default].should == "default"
       end
     end
 
@@ -91,13 +91,13 @@ module ActiveAttr
 
     describe "#to_s" do
       it "renders the name as a String" do
-        subject.to_s.should == "amount"
+        attribute_definition.to_s.should == "amount"
       end
     end
 
     describe "#to_sym" do
       it "renders the name as a Symbol" do
-        subject.to_sym.should == :amount
+        attribute_definition.to_sym.should == :amount
       end
     end
   end