cowtech-extensions 2.7.1 → 2.7.2

data/spec/cowtech-extensions/hash_spec.rb

@@ -18,13 +18,13 @@ describe Cowtech::Extensions::Hash do
   end
 
   describe "allows access to keys using method syntax" do
-    it "should allow method reference for symbol key" do reference.b.should == 2 end
+    it "should allow method reference for symbol key" do expect(reference.b).to eq(2) end
     it "should use super for missing key" do expect {reference.c}.to raise_error(NoMethodError) end
   end
 
   describe "#respond_to" do
-    it "should return true for string key" do reference.respond_to?(:a).should be_true end
-    it "should return true for symbol key" do reference.respond_to?(:b).should be_true end
-    it "should return false for missing key" do reference.respond_to?(:c).should be_false end
+    it "should return true for string key" do expect(reference.respond_to?(:a)).to be_true end
+    it "should return true for symbol key" do expect(reference.respond_to?(:b)).to be_true end
+    it "should return false for missing key" do expect(reference.respond_to?(:c)).to be_false end
   end
 end

data/spec/cowtech-extensions/math_spec.rb

@@ -17,25 +17,25 @@ describe Cowtech::Extensions::Math do
 
   describe "::min" do
     it "should return the minimum argument" do
-      ::Math.min(first).should == first
-      ::Math.min(first, second).should == first
-      ::Math.min([first, [second, third]]).should == third
+      expect(::Math.min(first)).to eq(first)
+      expect(::Math.min(first, second)).to eq(first)
+      expect(::Math.min([first, [second, third]])).to eq(third)
     end
 
     it "should return nil for an empty array" do
-      ::Math.min().should be_nil
+      expect(::Math.min()).to be_nil
     end
   end
 
   describe "::max" do
     it "should return the maximum argument" do
-      ::Math.max(first).should == first
-      ::Math.max(first, second).should == second
-      ::Math.max([first, [second, third]]).should == second
+      expect(::Math.max(first)).to eq(first)
+      expect(::Math.max(first, second)).to eq(second)
+      expect(::Math.max([first, [second, third]])).to eq(second)
     end
 
     it "should return nil for an empty array" do
-      ::Math.max().should be_nil
+      expect(::Math.max()).to be_nil
     end
   end
 end

data/spec/cowtech-extensions/object_spec.rb

@@ -13,207 +13,219 @@ describe Cowtech::Extensions::Object do
 
   describe "#normalize_number" do
     it "should correctly sanitize numbers" do
-      123.normalize_number.should == "123"
-      "123.45".normalize_number.should == "123.45"
-      "1,23.45".normalize_number.should == "123.45"
-      "-1.23.45".normalize_number.should == "-123.45"
-      "+123.45".normalize_number.should == "+123.45"
-      "+1.231,45".normalize_number.should == "+1231.45"
+      expect(123.normalize_number).to eq("123")
+      expect("123.45".normalize_number).to eq("123.45")
+      expect("1,23.45".normalize_number).to eq("123.45")
+      expect("-1.23.45".normalize_number).to eq("-123.45")
+      expect("+123.45".normalize_number).to eq("+123.45")
+      expect("+1.231,45".normalize_number).to eq("+1231.45")
     end
   end
 
   describe "#is_number?" do
     it "should return true for a valid number" do
-      "123.45".is_number?.should be_true
-      "1,23.45".is_number?.should be_true
-      "-1.23.45".is_number?.should be_true
-      "+123.45".is_number?.should be_true
-      "+1.231,45".is_number?.should be_true
+      expect("123.45".is_number?).to be_true
+      expect("1,23.45".is_number?).to be_true
+      expect("-1.23.45".is_number?).to be_true
+      expect("+123.45".is_number?).to be_true
+      expect("+1.231,45".is_number?).to be_true
     end
 
     it "should return true for a invalid number" do
-      "s213".is_number?.should be_false
-      nil.is_number?.should be_false
+      expect("s213".is_number?).to be_false
+      expect(nil.is_number?).to be_false
     end
   end
 
   describe "#is_integer?" do
     it "should return true for a valid number" do
-      "123".is_integer?.should be_true
-      "-123".is_integer?.should be_true
-      "+123".is_integer?.should be_true
+      expect("123".is_integer?).to be_true
+      expect("-123".is_integer?).to be_true
+      expect("+123".is_integer?).to be_true
     end
 
     it "should return true for a invalid number" do
-      "s123".is_integer?.should be_false
-      "123.12".is_integer?.should be_false
+      expect("s123".is_integer?).to be_false
+      expect("123.12".is_integer?).to be_false
     end
   end
 
   describe "#is_float?" do
     it "should return true for a valid number" do
-      "123.45".is_float?.should be_true
-      "1,23.45".is_float?.should be_true
-      "-1.23.45".is_float?.should be_true
-      "+123.45".is_float?.should be_true
-      "+1.231,45".is_float?.should be_true
+      expect("123.45".is_float?).to be_true
+      expect("1,23.45".is_float?).to be_true
+      expect("-1.23.45".is_float?).to be_true
+      expect("+123.45".is_float?).to be_true
+      expect("+1.231,45".is_float?).to be_true
     end
 
     it "should return true for a invalid number" do
-      "s213".is_float?.should be_false
-      nil.is_float?.should be_false
+      expect("s213".is_float?).to be_false
+      expect(nil.is_float?).to be_false
     end
   end
 
   describe "#is_boolean?" do
     it "should return true for a valid boolean" do
-      true.is_boolean?.should be_true
-      false.is_boolean?.should be_true
-      nil.is_boolean?.should be_true
-      "y".is_boolean?.should be_true
-      "n".is_boolean?.should be_true
-      "yes".is_boolean?.should be_true
-      "no".is_boolean?.should be_true
-      "1".is_boolean?.should be_true
-      "0".is_boolean?.should be_true
-      "true".is_boolean?.should be_true
-      "false".is_boolean?.should be_true
-      "t".is_boolean?.should be_true
-      "f".is_boolean?.should be_true
-      1.is_boolean?.should be_true
-      0.is_boolean?.should be_true
-    end
-
-    it "should return true for a invalid boolean" do  "11".is_boolean?.should be_false end
+      expect(true.is_boolean?).to be_true
+      expect(false.is_boolean?).to be_true
+      expect(nil.is_boolean?).to be_true
+      expect("y".is_boolean?).to be_true
+      expect("n".is_boolean?).to be_true
+      expect("yes".is_boolean?).to be_true
+      expect("no".is_boolean?).to be_true
+      expect("1".is_boolean?).to be_true
+      expect("0".is_boolean?).to be_true
+      expect("true".is_boolean?).to be_true
+      expect("false".is_boolean?).to be_true
+      expect("t".is_boolean?).to be_true
+      expect("f".is_boolean?).to be_true
+      expect(1.is_boolean?).to be_true
+      expect(0.is_boolean?).to be_true
+    end
+
+    it "should return true for a invalid boolean" do
+      expect("11".is_boolean?).to be_false
+    end
   end
 
   describe "#ensure_string" do
     it "should correctly handle strings" do
-      " abc ".ensure_string.should == " abc "
+      expect(" abc ".ensure_string).to eq(" abc ")
       1.ensure_string == "1"
-      1.0.ensure_string.should == "1.0"
-      :abc.ensure_string.should == "abc"
-      nil.ensure_string.should == ""
+      expect(1.0.ensure_string).to eq("1.0")
+      expect(:abc.ensure_string).to eq("abc")
+      expect(nil.ensure_string).to eq("")
     end
   end
 
   describe "#to_float" do
     it "should correctly convert number" do
-      123.45.to_float.should == 123.45
-      123.to_float.should == 123.00
-      "123.45".to_float.should == 123.45
-      "1,23.45".to_float.should == 123.45
-      "-1.23.45".to_float.should == -123.45
-      "+123.45".to_float.should == 123.45
-      "+1.231,45".to_float.should == 1231.45
+      expect(123.45.to_float).to eq(123.45)
+      expect(123.to_float).to eq(123.00)
+      expect("123.45".to_float).to eq(123.45)
+      expect("1,23.45".to_float).to eq(123.45)
+      expect("-1.23.45".to_float).to eq(-123.45)
+      expect("+123.45".to_float).to eq(123.45)
+      expect("+1.231,45".to_float).to eq(1231.45)
     end
 
-    it "should return 0.0 for a invalid number without a default" do "s213".to_float.should == 0.0 end
+    it "should return 0.0 for a invalid number without a default" do
+      expect("s213".to_float).to eq(0.0)
+    end
 
-    it "should return the default for a invalid number" do "s213".to_float(1.0).should == 1.0 end
+    it "should return the default for a invalid number" do
+      expect("s213".to_float(1.0)).to eq(1.0)
+    end
   end
 
   describe "#to_integer" do
     it "should correctly convert number" do
-      123.45.to_integer.should == 123
-      123.to_integer.should == 123
-      "+123".to_integer.should == 123
-      "-123".to_integer.should == -123
+      expect(123.45.to_integer).to eq(123)
+      expect(123.to_integer).to eq(123)
+      expect("+123".to_integer).to eq(123)
+      expect("-123".to_integer).to eq(-123)
     end
 
-    it "should return 0 for a invalid number without a default" do "s213".to_integer.should == 0 end
+    it "should return 0 for a invalid number without a default" do
+      expect("s213".to_integer).to eq(0)
+    end
 
-    it "should return the default for a invalid number" do "s213".to_integer(1).should == 1 end
+    it "should return the default for a invalid number" do
+      expect("s213".to_integer(1)).to eq(1)
+    end
   end
 
   describe "#to_boolean" do
     it "should return true for a valid true boolean" do
-      true.to_boolean.should be_true
-      "y".to_boolean.should be_true
-      "yes".to_boolean.should be_true
-      "1".to_boolean.should be_true
-      1.to_boolean.should be_true
-      1.0.to_boolean.should be_true
+      expect(true.to_boolean).to be_true
+      expect("y".to_boolean).to be_true
+      expect("yes".to_boolean).to be_true
+      expect("1".to_boolean).to be_true
+      expect(1.to_boolean).to be_true
+      expect(1.0.to_boolean).to be_true
     end
 
     it "should return false for all other values" do
-      false.to_boolean.should be_false
-      nil.to_boolean.should be_false
-      "n".to_boolean.should be_false
-      "no".to_boolean.should be_false
-      "2".to_boolean.should be_false
-      2.0.to_boolean.should be_false
-      "false".to_boolean.should be_false
-      "abc".to_boolean.should be_false
-      0.to_boolean.should be_false
+      expect(false.to_boolean).to be_false
+      expect(nil.to_boolean).to be_false
+      expect("n".to_boolean).to be_false
+      expect("no".to_boolean).to be_false
+      expect("2".to_boolean).to be_false
+      expect(2.0.to_boolean).to be_false
+      expect("false".to_boolean).to be_false
+      expect("abc".to_boolean).to be_false
+      expect(0.to_boolean).to be_false
     end
   end
 
   describe "#round_to_precision" do
     it "should round number" do
-      123.456789.round_to_precision(2).should == "123.46"
-      123.456789.round_to_precision(0).should == "123"
-      "123.456789".round_to_precision(2).should == "123.46"
+      expect(123.456789.round_to_precision(2)).to eq("123.46")
+      expect(123.456789.round_to_precision(0)).to eq("123")
+      expect("123.456789".round_to_precision(2)).to eq("123.46")
     end
 
     it "should return nil for non numeric values" do
-      123.456789.round_to_precision(-1).should == nil
-      "abc".round_to_precision(-1).should == nil
+      expect(123.456789.round_to_precision(-1)).to eq(nil)
+      expect("abc".round_to_precision(-1)).to eq(nil)
     end
   end
 
   describe "#format_number" do
     it "should format number" do
-      123123.456789.format_number.should == "123,123.46"
-      123123.456789.format_number(2).should == "123,123.46"
-      123123.456789.format_number(3, "@").should == "123,123@457"
-      123123.456789.format_number(3, "@", "$").should == "123,123@457 $"
-      "123123.456789".format_number(3, "@", "$", "!").should == "123!123@457 $"
+      expect(123123.456789.format_number).to eq("123,123.46")
+      expect(123123.456789.format_number(2)).to eq("123,123.46")
+      expect(123123.456789.format_number(3, "@")).to eq("123,123@457")
+      expect(123123.456789.format_number(3, "@", "$")).to eq("123,123@457 $")
+      expect("123123.456789".format_number(3, "@", "$", "!")).to eq("123!123@457 $")
 
       Cowtech::Extensions.settings.setup_format_number(5, ",", "£", ".")
-      123123.456789.format_number.should == "123.123,45679 £"
+      expect(123123.456789.format_number).to eq("123.123,45679 £")
     end
 
     it "should return nil for non numeric values" do
-      123.456789.format_number(-1).should == nil
-      "abc".format_number(-1).should == nil
+      expect(123.456789.format_number(-1)).to eq(nil)
+      expect("abc".format_number(-1)).to eq(nil)
     end
   end
 
   describe "#format_boolean" do
     it "should return the correct string for all values" do
-      "yes".format_boolean.should == "Yes"
-      "abc".format_boolean.should == "No"
+      expect("yes".format_boolean).to eq("Yes")
+      expect("abc".format_boolean).to eq("No")
     end
 
     it "should support localization" do
       Cowtech::Extensions.settings.setup_boolean_names("YYY", "NNN")
-      "yes".format_boolean.should == "YYY"
-      "abc".format_boolean.should == "NNN"
+      expect("yes".format_boolean).to eq("YYY")
+      expect("abc".format_boolean).to eq("NNN")
     end
 
     it "should support overrides" do
       Cowtech::Extensions.settings.setup_boolean_names
-      "yes".format_boolean("TTT").should == "TTT"
-      "yes".format_boolean(nil, "FFF").should == "Yes"
-      "abc".format_boolean("TTT").should == "No"
-      "abc".format_boolean(nil, "FFF").should == "FFF"
+      expect("yes".format_boolean("TTT")).to eq("TTT")
+      expect("yes".format_boolean(nil, "FFF")).to eq("Yes")
+      expect("abc".format_boolean("TTT")).to eq("No")
+      expect("abc".format_boolean(nil, "FFF")).to eq("FFF")
     end
   end
 
   describe "#debug_dump" do
     it "should return the correct representation for an object" do
       reference = {:a => "b"}
-      reference.debug_dump(:json, false).should == reference.to_json
-      reference.debug_dump(:pretty_json, false).should == ::JSON.pretty_generate(reference)
-      reference.debug_dump(:yaml, false).should == reference.to_yaml
+      expect(reference.debug_dump(:json, false)).to eq(reference.to_json)
+      expect(reference.debug_dump(:pretty_json, false)).to eq(::JSON.pretty_generate(reference))
+      expect(reference.debug_dump(:yaml, false)).to eq(reference.to_yaml)
     end
 
     it "should inspect the object if the format is not recognized" do
       reference = {:a => "b"}
-      reference.debug_dump(:unknown, false).should == reference.inspect
+      expect(reference.debug_dump(:unknown, false)).to eq(reference.inspect)
     end
 
-    it "should raise an exception if requested" do expect { {:a => "b"}.debug_dump }.to raise_error(::Cowtech::Extensions::Exceptions::Dump) end
+    it "should raise an exception if requested" do
+      expect { {:a => "b"}.debug_dump }.to raise_error(::Cowtech::Extensions::Exceptions::Dump)
+    end
   end
 end

data/spec/cowtech-extensions/pathname_spec.rb

@@ -14,6 +14,8 @@ describe Cowtech::Extensions::Pathname do
   end
 
   describe "#components" do
-    it "should return the components of the path" do ([""] + reference.components).should == reference.to_s.split("/") end
+    it "should return the components of the path" do
+      expect([""] + reference.components).to eq(reference.to_s.split("/"))
+    end
   end
 end

data/spec/cowtech-extensions/settings_spec.rb

@@ -18,52 +18,52 @@ describe Cowtech::Extensions::Settings do
   describe "#initialize" do
     it "should create good defaults" do
       settings = ::Cowtech::Extensions::Settings.new
-      settings.format_number.should be_a(Hash)
-      settings.boolean_names.should be_a(Hash)
-      settings.date_names.should be_a(Hash)
-      settings.date_formats.should be_a(Hash)
+      expect(settings.format_number).to be_a(Hash)
+      expect(settings.boolean_names).to be_a(Hash)
+      expect(settings.date_names).to be_a(Hash)
+      expect(settings.date_formats).to be_a(Hash)
     end
 
     it "should create good defaults for the singleton" do
-      reference.format_number.should be_a(Hash)
-      reference.boolean_names.should be_a(Hash)
-      reference.date_names.should be_a(Hash)
-      reference.date_formats.should be_a(Hash)
+      expect(reference.format_number).to be_a(Hash)
+      expect(reference.boolean_names).to be_a(Hash)
+      expect(reference.date_names).to be_a(Hash)
+      expect(reference.date_formats).to be_a(Hash)
     end
   end
 
   describe "#setup_format_number" do
     it "should save format numbering options for usage" do
       reference.setup_format_number(2)
-      number_reference.format_number.should == "123,456.65"
+      expect(number_reference.format_number).to eq("123,456.65")
 
       reference.setup_format_number(3, "A")
-      number_reference.format_number.should == "123,456A654"
+      expect(number_reference.format_number).to eq("123,456A654")
 
       reference.setup_format_number(4, "A", "B")
-      number_reference.format_number.should == "123,456A6543 B"
+      expect(number_reference.format_number).to eq("123,456A6543 B")
 
       reference.setup_format_number(5, "A", "B", "C")
-      number_reference.format_number.should == "123C456A65432 B"
+      expect(number_reference.format_number).to eq("123C456A65432 B")
 
       reference.setup_format_number
-      number_reference.format_number.should == "123,456.65"
+      expect(number_reference.format_number).to eq("123,456.65")
     end
   end
 
   describe "#setup_boolean_names" do
     it "should save names for boolean values" do
       reference.setup_boolean_names("TRUE1")
-      [true.format_boolean, false.format_boolean].should == ["TRUE1", "No"]
+      expect([true.format_boolean, false.format_boolean]).to eq(["TRUE1", "No"])
 
       reference.setup_boolean_names(nil, "FALSE1")
-      [true.format_boolean, false.format_boolean].should == ["Yes", "FALSE1"]
+      expect([true.format_boolean, false.format_boolean]).to eq(["Yes", "FALSE1"])
 
       reference.setup_boolean_names("TRUE2", "FALSE2")
-      [true.format_boolean, false.format_boolean].should == ["TRUE2", "FALSE2"]
+      expect([true.format_boolean, false.format_boolean]).to eq(["TRUE2", "FALSE2"])
 
       reference.setup_boolean_names
-      [true.format_boolean, false.format_boolean].should == ["Yes", "No"]
+      expect([true.format_boolean, false.format_boolean]).to eq(["Yes", "No"])
     end
   end
 
@@ -72,20 +72,20 @@ describe Cowtech::Extensions::Settings do
       reference.setup_date_formats(nil, true)
 
       reference.setup_date_formats({:c1 => "%Y"})
-      date_reference.lstrftime(:ct_date) == date_reference.strftime("%Y-%m-%d")
-      date_reference.lstrftime(:c1) == date_reference.year.to_s
+      expect(date_reference.lstrftime(:ct_date)).to eq(date_reference.strftime("%Y-%m-%d"))
+      expect(date_reference.lstrftime(:c1)).to eq(date_reference.year.to_s)
 
       reference.setup_date_formats({:c1 => "%Y"}, true)
-      date_reference.lstrftime(:ct_date).should == "ct_date"
-      date_reference.lstrftime(:c1).should == date_reference.year.to_s
+      expect(date_reference.lstrftime(:ct_date)).to eq("ct_date")
+      expect(date_reference.lstrftime(:c1)).to eq(date_reference.year.to_s)
 
       reference.setup_date_formats()
-      date_reference.lstrftime(:ct_date).should == date_reference.strftime("%Y-%m-%d")
-      date_reference.lstrftime(:c1).should == date_reference.year.to_s
+      expect(date_reference.lstrftime(:ct_date)).to eq(date_reference.strftime("%Y-%m-%d"))
+      expect(date_reference.lstrftime(:c1)).to eq(date_reference.year.to_s)
 
       reference.setup_date_formats(nil, true)
-      date_reference.lstrftime(:ct_date) == date_reference.strftime("%Y-%m-d")
-      date_reference.lstrftime(:c1).should == "c1"
+      expect(date_reference.lstrftime(:ct_date)).to eq(date_reference.strftime("%Y-%m-%d"))
+      expect(date_reference.lstrftime(:c1)).to eq("c1")
     end
   end
 
@@ -100,19 +100,19 @@ describe Cowtech::Extensions::Settings do
       short_days = 7.times.collect {|i| (i + 1).to_s}
 
       reference.setup_date_names(long_months)
-      date_reference.lstrftime(:sdn).should == "66 Jun Tuesday Tue"
+      expect(date_reference.lstrftime(:sdn)).to eq("66 Jun Tuesday Tue")
 
       reference.setup_date_names(long_months, short_months)
-      date_reference.lstrftime(:sdn).should == "66 6 Tuesday Tue"
+      expect(date_reference.lstrftime(:sdn)).to eq("66 6 Tuesday Tue")
 
       reference.setup_date_names(long_months, short_months, long_days)
-      date_reference.lstrftime(:sdn).should == "66 6 33 Tue"
+      expect(date_reference.lstrftime(:sdn)).to eq("66 6 33 Tue")
 
       reference.setup_date_names(long_months, short_months, long_days, short_days)
-      date_reference.lstrftime(:sdn).should == "66 6 33 3"
+      expect(date_reference.lstrftime(:sdn)).to eq("66 6 33 3")
 
       reference.setup_date_names
-      date_reference.lstrftime(:sdn).should == "June Jun Tuesday Tue"
+      expect(date_reference.lstrftime(:sdn)).to eq("June Jun Tuesday Tue")
     end
   end
 end