active_attr 0.7.0 → 0.8.0

data/spec/unit/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
@@ -35,13 +35,13 @@ module ActiveAttr
 
     describe ".attribute" do
       it "defines an attribute pre-typecasting reader that calls #attribute_before_type_cast" do
-        subject.should_receive(:attribute_before_type_cast).with("first_name")
-        subject.first_name_before_type_cast
+        model.should_receive(:attribute_before_type_cast).with("first_name")
+        model.first_name_before_type_cast
       end
 
       it "defines an attribute reader that can be called via super" do
-        subject.should_receive(:attribute_before_type_cast).with("last_name")
-        subject.last_name_before_type_cast
+        model.should_receive(:attribute_before_type_cast).with("last_name")
+        model.last_name_before_type_cast
       end
     end
 
@@ -61,19 +61,19 @@ module ActiveAttr
 
     describe "#attribute_before_type_cast" do
       it "returns nil when the attribute has not been assigned yet" do
-        subject.attribute_before_type_cast(:amount).should be_nil
+        model.attribute_before_type_cast(:amount).should be_nil
       end
 
       it "returns the assigned attribute value, without typecasting, when given an attribute name as a Symbol" do
         value = :value
-        subject.amount = value
-        subject.attribute_before_type_cast(:amount).should equal value
+        model.amount = value
+        model.attribute_before_type_cast(:amount).should equal value
       end
 
       it "returns the assigned attribute value, without typecasting, when given an attribute name as a String" do
         value = :value
-        subject.amount = value
-        subject.attribute_before_type_cast('amount').should equal value
+        model.amount = value
+        model.attribute_before_type_cast('amount').should equal value
       end
     end
   end

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

@@ -4,34 +4,36 @@ require "active_attr/typecasting/big_decimal_typecaster"
 module ActiveAttr
   module Typecasting
     describe BigDecimalTypecaster do
+      subject(:typecaster) { described_class.new }
+
       describe "#call" do
         it "returns the original BigDecimal for a BigDecimal" do
           value = BigDecimal.new("2.0")
-          subject.call(value).should equal value
+          typecaster.call(value).should equal value
         end
 
         it "casts nil to a zero BigDecimal" do
-          subject.call(nil).should eql BigDecimal.new("0.0")
+          typecaster.call(nil).should eql BigDecimal.new("0.0")
         end
 
         it "casts a numeric String to a BigDecimal" do
-          subject.call("2").should eql BigDecimal.new("2.0")
+          typecaster.call("2").should eql BigDecimal.new("2.0")
         end
 
         it "casts a alpha String to a zero BigDecimal" do
-          subject.call("bob").should eql BigDecimal.new("0.0")
+          typecaster.call("bob").should eql BigDecimal.new("0.0")
         end
 
         it "casts a Rational to a BigDecimal" do
-          subject.call(Rational(1, 2)).should eql BigDecimal.new("0.5")
+          typecaster.call(Rational(1, 2)).should eql BigDecimal.new("0.5")
         end
 
         it "casts a Float to a BigDecimal" do
-          subject.call(1.2).should eql BigDecimal.new("1.2")
+          typecaster.call(1.2).should eql BigDecimal.new("1.2")
         end
 
         it "cases an Integer to a BigDecimal" do
-          subject.call(2).should eql BigDecimal.new("2.0")
+          typecaster.call(2).should eql BigDecimal.new("2.0")
         end
       end
     end

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

@@ -5,30 +5,32 @@ require "bigdecimal"
 module ActiveAttr
   module Typecasting
     describe BooleanTypecaster do
+      subject(:typecaster) { described_class.new }
+
       describe "#call" do
         it "returns true for true" do
-          subject.call(true).should equal true
+          typecaster.call(true).should equal true
         end
 
         it "returns false for false" do
-          subject.call(false).should equal false
+          typecaster.call(false).should equal false
         end
 
         it "casts nil to false" do
-          subject.call(nil).should equal false
+          typecaster.call(nil).should equal false
         end
 
         it "casts an Object to true" do
-          subject.call(Object.new).should equal true
+          typecaster.call(Object.new).should equal true
         end
 
         context "when the value is a String" do
           it "casts an empty String to false" do
-            subject.call("").should equal false
+            typecaster.call("").should equal false
           end
 
           it "casts a non-empty String to true" do
-            subject.call("abc").should equal true
+            typecaster.call("abc").should equal true
           end
 
           {
@@ -61,84 +63,84 @@ module ActiveAttr
             "OFF" => false,
           }.each_pair do |value, result|
             it "casts #{value.inspect} to #{result.inspect}" do
-              subject.call(value).should equal result
+              typecaster.call(value).should equal result
             end
           end
         end
 
         context "when the value is Numeric" do
           it "casts 0 to false" do
-            subject.call(0).should equal false
+            typecaster.call(0).should equal false
           end
 
           it "casts 1 to true" do
-            subject.call(1).should equal true
+            typecaster.call(1).should equal true
           end
 
           it "casts 0.0 to false" do
-            subject.call(0.0).should equal false
+            typecaster.call(0.0).should equal false
           end
 
           it "casts 0.1 to true" do
-            subject.call(0.1).should equal true
+            typecaster.call(0.1).should equal true
           end
 
           it "casts a zero BigDecimal to false" do
-            subject.call(BigDecimal.new("0.0")).should equal false
+            typecaster.call(BigDecimal.new("0.0")).should equal false
           end
 
           it "casts a non-zero BigDecimal to true" do
-            subject.call(BigDecimal.new("0.1")).should equal true
+            typecaster.call(BigDecimal.new("0.1")).should equal true
           end
 
           it "casts -1 to true" do
-            subject.call(-1).should equal true
+            typecaster.call(-1).should equal true
           end
 
           it "casts -0.0 to false" do
-            subject.call(-0.0).should equal false
+            typecaster.call(-0.0).should equal false
           end
 
           it "casts -0.1 to true" do
-            subject.call(-0.1).should equal true
+            typecaster.call(-0.1).should equal true
           end
 
           it "casts a negative zero BigDecimal to false" do
-            subject.call(BigDecimal.new("-0.0")).should equal false
+            typecaster.call(BigDecimal.new("-0.0")).should equal false
           end
 
           it "casts a negative BigDecimal to true" do
-            subject.call(BigDecimal.new("-0.1")).should equal true
+            typecaster.call(BigDecimal.new("-0.1")).should equal true
           end
         end
 
         context "when the value is the String version of a Numeric" do
           it "casts '0' to false" do
-            subject.call("0").should equal false
+            typecaster.call("0").should equal false
           end
 
           it "casts '1' to true" do
-            subject.call("1").should equal true
+            typecaster.call("1").should equal true
           end
 
           it "casts '0.0' to false" do
-            subject.call("0.0").should equal false
+            typecaster.call("0.0").should equal false
           end
 
           it "casts '0.1' to true" do
-            subject.call("0.1").should equal true
+            typecaster.call("0.1").should equal true
           end
 
           it "casts '-1' to true" do
-            subject.call("-1").should equal true
+            typecaster.call("-1").should equal true
           end
 
           it "casts '-0.0' to false" do
-            subject.call("-0.0").should equal false
+            typecaster.call("-0.0").should equal false
           end
 
           it "casts '-0.1' to true" do
-            subject.call("-0.1").should equal true
+            typecaster.call("-0.1").should equal true
           end
         end
       end

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

@@ -4,61 +4,63 @@ require "active_attr/typecasting/date_time_typecaster"
 module ActiveAttr
   module Typecasting
     describe DateTimeTypecaster do
+      subject(:typecaster) { described_class.new }
+
       describe "#call" do
         it "returns the original DateTime for a DateTime" do
           value = DateTime.now
-          subject.call(value).should equal value
+          typecaster.call(value).should equal value
         end
 
         it "returns nil for nil" do
-          subject.call(nil).should equal nil
+          typecaster.call(nil).should equal nil
         end
 
         it "casts a Date to a DateTime at the beginning of the day with no offset" do
-          result = subject.call(Date.new(2012, 1, 1))
+          result = typecaster.call(Date.new(2012, 1, 1))
           result.should eql DateTime.new(2012, 1, 1)
           result.should be_instance_of DateTime
         end
 
         it "casts a UTC Time to a DateTime with no offset" do
-          result = subject.call(Time.utc(2012, 1, 1, 12, 0, 0))
+          result = typecaster.call(Time.utc(2012, 1, 1, 12, 0, 0))
           result.should eql DateTime.new(2012, 1, 1, 12, 0, 0, 0)
           result.should be_instance_of DateTime
         end
 
         it "casts a local Time to a DateTime with a matching offset" do
           value = Time.local(2012, 1, 1, 12, 0, 0)
-          result = subject.call(value)
+          result = typecaster.call(value)
           result.should eql DateTime.new(2012, 1, 1, 12, 0, 0, Rational(value.utc_offset, 86400))
           result.should be_instance_of DateTime
         end
 
         it "casts an ISO8601 date String to a Date" do
-          result = subject.call("2012-01-01")
+          result = typecaster.call("2012-01-01")
           result.should eql DateTime.new(2012, 1, 1)
           result.should be_instance_of DateTime
         end
 
         it "casts an RFC2616 date and GMT time String to a DateTime" do
-          result = subject.call("Sat, 03 Feb 2001 00:00:00 GMT")
+          result = typecaster.call("Sat, 03 Feb 2001 00:00:00 GMT")
           result.should eql DateTime.new(2001, 2, 3)
           result.should be_instance_of DateTime
         end
 
         it "casts an RFC3339 date and offset time String to a DateTime" do
-          result = subject.call("2001-02-03T04:05:06+07:00")
+          result = typecaster.call("2001-02-03T04:05:06+07:00")
           result.should eql DateTime.new(2001, 2, 3, 4, 5, 6, "+07:00")
           result.should be_instance_of DateTime
         end
 
         it "casts a UTC ActiveSupport::TimeWithZone to a DateTime" do
-          result = subject.call(Time.utc(2012, 1, 1, 1, 1, 1).in_time_zone("UTC"))
+          result = typecaster.call(Time.utc(2012, 1, 1, 1, 1, 1).in_time_zone("UTC"))
           result.should eql DateTime.new(2012, 1, 1, 1, 1, 1, 0)
           result.should be_instance_of DateTime
         end
 
         it "casts an Alaska ActiveSupport::TimeWithZone to a Date representing the date portion" do
-          result = subject.call(Time.utc(2012, 1, 1, 0, 0, 0).in_time_zone("Alaska"))
+          result = typecaster.call(Time.utc(2012, 1, 1, 0, 0, 0).in_time_zone("Alaska"))
           result.should eql DateTime.new(2011, 12, 31, 15, 0, 0, "-09:00")
           result.should be_instance_of DateTime
         end

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

@@ -4,54 +4,56 @@ require "active_attr/typecasting/date_typecaster"
 module ActiveAttr
   module Typecasting
     describe DateTypecaster do
+      subject(:typecaster) { described_class.new }
+
       describe "#call" do
         it "returns the original date for a Date" do
           value = Date.today
-          subject.call(value).should equal value
+          typecaster.call(value).should equal value
         end
 
         it "returns nil for nil" do
-          subject.call(nil).should equal nil
+          typecaster.call(nil).should equal nil
         end
 
         it "returns nil for an invalid String" do
-          subject.call("x").should equal nil
+          typecaster.call("x").should equal nil
         end
 
         it "casts a UTC Time to a Date representing the date portion" do
-          subject.call(Time.utc(2012, 1, 1, 0, 0, 0)).should eql Date.new(2012, 1, 1)
+          typecaster.call(Time.utc(2012, 1, 1, 0, 0, 0)).should eql Date.new(2012, 1, 1)
         end
 
         it "casts a local Time to a Date representing the date portion" do
-          subject.call(Time.local(2012, 1, 1, 0, 0, 0)).should eql Date.new(2012, 1, 1)
+          typecaster.call(Time.local(2012, 1, 1, 0, 0, 0)).should eql Date.new(2012, 1, 1)
         end
 
         it "casts a UTC DateTime to a Date representing the date portion" do
-          subject.call(DateTime.new(2012, 1, 1, 0, 0, 0)).should eql Date.new(2012, 1, 1)
+          typecaster.call(DateTime.new(2012, 1, 1, 0, 0, 0)).should eql Date.new(2012, 1, 1)
         end
 
         it "casts an offset DateTime to a Date representing the date portion" do
-          subject.call(DateTime.new(2012, 1, 1, 0, 0, 0, "-12:00")).should eql Date.new(2012, 1, 1)
+          typecaster.call(DateTime.new(2012, 1, 1, 0, 0, 0, "-12:00")).should eql Date.new(2012, 1, 1)
         end
 
         it "casts an ISO8601 date String to a Date" do
-          subject.call("2012-01-01").should eql Date.new(2012, 1, 1)
+          typecaster.call("2012-01-01").should eql Date.new(2012, 1, 1)
         end
 
         it "casts an RFC2616 date and GMT time String to a Date representing the date portion" do
-          subject.call("Sat, 03 Feb 2001 00:00:00 GMT").should eql Date.new(2001, 2, 3)
+          typecaster.call("Sat, 03 Feb 2001 00:00:00 GMT").should eql Date.new(2001, 2, 3)
         end
 
         it "casts an RFC3339 date and offset time String to a Date representing the date portion" do
-          subject.call("2001-02-03T04:05:06+07:00").should eql Date.new(2001, 2, 3)
+          typecaster.call("2001-02-03T04:05:06+07:00").should eql Date.new(2001, 2, 3)
         end
 
         it "casts a UTC ActiveSupport::TimeWithZone to a Date representing the date portion" do
-          subject.call(Time.utc(2012, 1, 1, 0, 0, 0).in_time_zone("UTC")).should eql Date.new(2012, 1, 1)
+          typecaster.call(Time.utc(2012, 1, 1, 0, 0, 0).in_time_zone("UTC")).should eql Date.new(2012, 1, 1)
         end
 
         it "casts an Alaska ActiveSupport::TimeWithZone to a Date representing the date portion" do
-          subject.call(Time.utc(2012, 1, 1, 0, 0, 0).in_time_zone("Alaska")).should eql Date.new(2011, 12, 31)
+          typecaster.call(Time.utc(2012, 1, 1, 0, 0, 0).in_time_zone("Alaska")).should eql Date.new(2011, 12, 31)
         end
       end
     end

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

@@ -4,22 +4,24 @@ require "active_attr/typecasting/float_typecaster"
 module ActiveAttr
   module Typecasting
     describe FloatTypecaster do
+      subject(:typecaster) { described_class.new }
+
       describe "#call" do
         it "returns the original float for a Float" do
           value = 2.0
-          subject.call(value).should equal value
+          typecaster.call(value).should equal value
         end
 
         it "casts nil to 0.0" do
-          subject.call(nil).should eql 0.0
+          typecaster.call(nil).should eql 0.0
         end
 
         it "returns the float version of a String" do
-          subject.call("2").should eql 2.0
+          typecaster.call("2").should eql 2.0
         end
 
         it "returns nil for an object that does not respond to #to_f" do
-          subject.call(Object.new).should be_nil
+          typecaster.call(Object.new).should be_nil
         end
       end
     end

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

@@ -4,30 +4,32 @@ require "active_attr/typecasting/integer_typecaster"
 module ActiveAttr
   module Typecasting
     describe IntegerTypecaster do
+      subject(:typecaster) { described_class.new }
+
       describe "#call" do
         it "returns the original integer for a FixNum" do
           value = 2
-          subject.call(value).should equal value
+          typecaster.call(value).should equal value
         end
 
         it "casts nil to 0" do
-          subject.call(nil).should eql 0
+          typecaster.call(nil).should eql 0
         end
 
         it "returns the integer version of a String" do
-          subject.call("2").should eql 2
+          typecaster.call("2").should eql 2
         end
 
         it "returns nil for an object that does not respond to #to_i" do
-          subject.call(Object.new).should be_nil
+          typecaster.call(Object.new).should be_nil
         end
 
         it "returns nil for Float::INFINITY" do
-          subject.call(1.0 / 0.0).should be_nil
+          typecaster.call(1.0 / 0.0).should be_nil
         end
 
         it "returns nil for Float::NAN" do
-          subject.call(0.0 / 0.0).should be_nil
+          typecaster.call(0.0 / 0.0).should be_nil
         end
       end
     end