more_core_extensions 1.2.0 → 2.0.0

data/spec/core_ext/array/tableize_spec.rb

@@ -1,5 +1,3 @@
-require_relative "../../spec_helper"
-
 describe Array do
   context '#tableize' do
     context "on an Array of Arrays" do
@@ -11,7 +9,7 @@ describe Array do
  Val1   | Val2
  Value3 | Value4
 EOF
-        test.tableize.should == expected
+        expect(test.tableize).to eq(expected)
       end
 
       it 'with numeric column values right justified' do
@@ -22,7 +20,7 @@ EOF
  Val1   |  200
  Value3 |   30
 EOF
-        test.tableize.should == expected
+        expect(test.tableize).to eq(expected)
       end
 
       it 'with really long column value' do
@@ -33,7 +31,7 @@ EOF
  Val1                      | Val2
  Really Really Long Value3 | Value4
 EOF
-        test.tableize.should == expected
+        expect(test.tableize).to eq(expected)
       end
 
       it 'with really long column value and :max_width option' do
@@ -44,7 +42,7 @@ EOF
  Val1       | Val2
  Really Rea | Value4
 EOF
-        test.tableize(:max_width => 10).should == expected
+        expect(test.tableize(:max_width => 10)).to eq(expected)
       end
 
       it 'with :header => false option' do
@@ -54,7 +52,7 @@ EOF
  Val1   | Val2
  Value3 | Value4
 EOF
-        test.tableize(:header => false).should == expected
+        expect(test.tableize(:header => false)).to eq(expected)
       end
     end
 
@@ -72,8 +70,8 @@ EOF
  Value4 | Value5 | Value6
 EOF
 
-        @str_case.tableize.should == expected
-        @sym_case.tableize.should == expected
+        expect(@str_case.tableize).to eq(expected)
+        expect(@sym_case.tableize).to eq(expected)
       end
 
       context "with :columns option" do
@@ -87,8 +85,8 @@ EOF
         end
 
         it "normal case" do
-          @str_case.tableize(:columns => ["Col3", "Col1", "Col2"]).should == @expected
-          @sym_case.tableize(:columns => [:Col3,  :Col1,  :Col2 ]).should == @expected
+          expect(@str_case.tableize(:columns => ["Col3", "Col1", "Col2"])).to eq(@expected)
+          expect(@sym_case.tableize(:columns => [:Col3,  :Col1,  :Col2 ])).to eq(@expected)
         end
 
         it "with only some values" do
@@ -99,18 +97,18 @@ EOF
  Value6 | Value4
 EOF
 
-          @str_case.tableize(:columns => ["Col3", "Col1"]).should == expected
-          @sym_case.tableize(:columns => [:Col3,  :Col1 ]).should == expected
+          expect(@str_case.tableize(:columns => ["Col3", "Col1"])).to eq(expected)
+          expect(@sym_case.tableize(:columns => [:Col3,  :Col1 ])).to eq(expected)
         end
 
         it "and :leading_columns option" do
-          @str_case.tableize(:columns => ["Col3", "Col1", "Col2"], :leading_columns => ["Col1"]).should == @expected
-          @sym_case.tableize(:columns => [:Col3,  :Col1,  :Col2 ], :leading_columns => [:Col1 ]).should == @expected
+          expect(@str_case.tableize(:columns => ["Col3", "Col1", "Col2"], :leading_columns => ["Col1"])).to eq(@expected)
+          expect(@sym_case.tableize(:columns => [:Col3,  :Col1,  :Col2 ], :leading_columns => [:Col1 ])).to eq(@expected)
         end
 
         it "and :trailing_columns option" do
-          @str_case.tableize(:columns => ["Col3", "Col1", "Col2"], :trailing_columns => ["Col1"]).should == @expected
-          @sym_case.tableize(:columns => [:Col3,  :Col1,  :Col2 ], :trailing_columns => [:Col1 ]).should == @expected
+          expect(@str_case.tableize(:columns => ["Col3", "Col1", "Col2"], :trailing_columns => ["Col1"])).to eq(@expected)
+          expect(@sym_case.tableize(:columns => [:Col3,  :Col1,  :Col2 ], :trailing_columns => [:Col1 ])).to eq(@expected)
         end
       end
 
@@ -122,8 +120,8 @@ EOF
  Value6 | Value5 | Value4
 EOF
 
-        @str_case.tableize(:leading_columns => ["Col3", "Col2"]).should == expected
-        @sym_case.tableize(:leading_columns => [:Col3,  :Col2 ]).should == expected
+        expect(@str_case.tableize(:leading_columns => ["Col3", "Col2"])).to eq(expected)
+        expect(@sym_case.tableize(:leading_columns => [:Col3,  :Col2 ])).to eq(expected)
       end
 
       it "with :trailing_columns option" do
@@ -134,8 +132,8 @@ EOF
  Value4 | Value6 | Value5
 EOF
 
-        @str_case.tableize(:trailing_columns => ["Col3", "Col2"]).should == expected
-        @sym_case.tableize(:trailing_columns => [:Col3,  :Col2 ]).should == expected
+        expect(@str_case.tableize(:trailing_columns => ["Col3", "Col2"])).to eq(expected)
+        expect(@sym_case.tableize(:trailing_columns => [:Col3,  :Col2 ])).to eq(expected)
       end
 
       it "with both :leading_columns and :trailing_columns options" do
@@ -146,13 +144,13 @@ EOF
  Value6 | Value4 | Value5
 EOF
 
-        @str_case.tableize(:leading_columns => ["Col3"], :trailing_columns => ["Col2"]).should == expected
-        @sym_case.tableize(:leading_columns => [:Col3 ], :trailing_columns => [:Col2 ]).should == expected
+        expect(@str_case.tableize(:leading_columns => ["Col3"], :trailing_columns => ["Col2"])).to eq(expected)
+        expect(@sym_case.tableize(:leading_columns => [:Col3 ], :trailing_columns => [:Col2 ])).to eq(expected)
       end
     end
 
     it 'with an invalid receiver' do
-      lambda { [1, 2, 3].tableize }.should raise_error(RuntimeError)
+      expect { [1, 2, 3].tableize }.to raise_error(RuntimeError)
     end
   end
-end
+end

data/spec/core_ext/hash/deletes_spec.rb

@@ -1,17 +1,15 @@
-require_relative "../../spec_helper"
-
 describe Hash do
   it "#delete_nils" do
-    {}.delete_nils.should == {}
-    {:a => 1}.delete_nils.should == {:a => 1}
-    {:c => nil}.delete_nils.should == {}
-    {:a => 1, :b => [], :c => nil}.delete_nils.should == {:a => 1, :b => []}
+    expect({}.delete_nils).to eq({})
+    expect({:a => 1}.delete_nils).to eq({:a => 1})
+    expect({:c => nil}.delete_nils).to eq({})
+    expect({:a => 1, :b => [], :c => nil}.delete_nils).to eq({:a => 1, :b => []})
   end
 
   it "#delete_blanks" do
-    {}.delete_blanks.should == {}
-    {:a => 1}.delete_blanks.should == {:a => 1}
-    {:c => nil}.delete_blanks.should == {}
-    {:a => 1, :b => [], :c => nil}.delete_blanks.should == {:a => 1}
+    expect({}.delete_blanks).to eq({})
+    expect({:a => 1}.delete_blanks).to eq({:a => 1})
+    expect({:c => nil}.delete_blanks).to eq({})
+    expect({:a => 1, :b => [], :c => nil}.delete_blanks).to eq({:a => 1})
   end
 end

data/spec/core_ext/hash/nested_spec.rb

@@ -1,5 +1,3 @@
-require_relative "../../spec_helper"
-
 shared_examples_for "core_ext/hash/nested will not modify arguments" do |meth|
   it "will not modify arguments" do
     args = (meth == :store_path ? [1] : [])
@@ -7,49 +5,49 @@ shared_examples_for "core_ext/hash/nested will not modify arguments" do |meth|
     key  = ["d", "d1", "d2", "d3"]
     key2 = key.dup
     hash.send(meth, key2, *args)
-    key2.should == key
+    expect(key2).to eq(key)
 
     key  = ["e", "e1", "e2"]
     key2 = key.dup
     hash.send(meth, key2, *args)
-    key2.should == key
+    expect(key2).to eq(key)
   end
 end
 
 shared_examples_for "core_ext/hash/nested" do
   context '#fetch_path' do
     it "with various values" do
-      hash.fetch_path("a").should == 1
-      hash.fetch_path("b").should == {}
-      hash.fetch_path("b", "b1").should be_nil
-      hash.fetch_path("b", "b1", "b2").should be_nil
-      hash.fetch_path("c").should == {"c1" => 2}
-      hash.fetch_path("c", "c1").should == 2
-      hash.fetch_path("c", "c1", "c2").should be_nil
-      hash.fetch_path("d", "d1", "d2", "d3").should == 3
-      hash.fetch_path("d", "d1", "d2", "dx").should be_nil
-      hash.fetch_path("d", "d1", "d2", "d3", "d4").should be_nil
-      hash.fetch_path("e").should == {}
-      hash.fetch_path("e", "e1").should == 4
-      hash.fetch_path("e", "e1", "e2").should be_nil
-      hash.fetch_path("f").should == {}
-      hash.fetch_path("f", "f1").should == {}
-      hash.fetch_path("f", "f1", "f2").should be_nil
+      expect(hash.fetch_path("a")).to eq(1)
+      expect(hash.fetch_path("b")).to eq({})
+      expect(hash.fetch_path("b", "b1")).to be_nil
+      expect(hash.fetch_path("b", "b1", "b2")).to be_nil
+      expect(hash.fetch_path("c")).to eq({"c1" => 2})
+      expect(hash.fetch_path("c", "c1")).to eq(2)
+      expect(hash.fetch_path("c", "c1", "c2")).to be_nil
+      expect(hash.fetch_path("d", "d1", "d2", "d3")).to eq(3)
+      expect(hash.fetch_path("d", "d1", "d2", "dx")).to be_nil
+      expect(hash.fetch_path("d", "d1", "d2", "d3", "d4")).to be_nil
+      expect(hash.fetch_path("e")).to eq({})
+      expect(hash.fetch_path("e", "e1")).to eq(4)
+      expect(hash.fetch_path("e", "e1", "e2")).to be_nil
+      expect(hash.fetch_path("f")).to eq({})
+      expect(hash.fetch_path("f", "f1")).to eq({})
+      expect(hash.fetch_path("f", "f1", "f2")).to be_nil
     end
 
     it "with a nil value" do
-      hash.fetch_path(nil).should == {nil => 7}
-      hash.fetch_path("d", nil, "d1").should be_nil
-      hash.fetch_path("e", nil).should == 4
-      hash.fetch_path("e", nil, "e1").should be_nil
+      expect(hash.fetch_path(nil)).to eq({nil => 7})
+      expect(hash.fetch_path("d", nil, "d1")).to be_nil
+      expect(hash.fetch_path("e", nil)).to eq(4)
+      expect(hash.fetch_path("e", nil, "e1")).to be_nil
     end
 
     it "with array key" do
-      hash.fetch_path([["h", "i"]]).should == 8
+      expect(hash.fetch_path([["h", "i"]])).to eq(8)
     end
 
     it "with invalid values" do
-      lambda { hash.fetch_path }.should raise_error(ArgumentError)
+      expect { hash.fetch_path }.to raise_error(ArgumentError)
     end
 
     include_examples "core_ext/hash/nested will not modify arguments", :fetch_path
@@ -59,54 +57,54 @@ shared_examples_for "core_ext/hash/nested" do
     it "on an empty hash" do
       h = described_class.new
       h.store_path("a", 1)
-      h.should == {"a" => 1}
+      expect(h).to eq({"a" => 1})
 
       h = described_class.new
       h.store_path("b", "b1", 2)
-      h.should == {"b" => {"b1" => 2}}
+      expect(h).to eq({"b" => {"b1" => 2}})
     end
 
     it "on an existing hash" do
       hash.store_path("b", "b1", 2)
-      hash["b"].should == {"b1" => 2}
+      expect(hash["b"]).to eq({"b1" => 2})
       hash.store_path("c", "c1", 3)
-      hash["c"].should == {"c1" => 3}
+      expect(hash["c"]).to eq({"c1" => 3})
     end
 
     it "on an existing item that is not a hash" do
       hash.store_path("a", 2)
-      hash["a"].should == 2
+      expect(hash["a"]).to eq(2)
       hash.store_path("a", "a1", 3)
-      hash["a"].should == {"a1" => 3}
+      expect(hash["a"]).to eq({"a1" => 3})
     end
 
     it "with an array key" do
       h = described_class.new
       h.store_path([["d", "d1"], ["d2", "d3"]], 3)
-      h.should == {["d", "d1"] => {["d2", "d3"] => 3}}
+      expect(h).to eq({["d", "d1"] => {["d2", "d3"] => 3}})
     end
 
     it "with a nil value" do
       h = described_class.new
       h.store_path("a", "b", nil)
-      h.should == {"a" => {"b" => nil}}
+      expect(h).to eq({"a" => {"b" => nil}})
     end
 
     it "with an Array value" do
       h = described_class.new
       h.store_path("a", "b", ["c", "d"])
-      h.should == {"a" => {"b" => ["c", "d"]}}
+      expect(h).to eq({"a" => {"b" => ["c", "d"]}})
     end
 
     it "with a Hash value" do
       h = described_class.new
       h.store_path("a", "b", {"c" => "d"})
-      h.should == {"a" => {"b" => {"c" => "d"}}}
+      expect(h).to eq({"a" => {"b" => {"c" => "d"}}})
     end
 
     it "with invalid values" do
-      lambda { described_class.new.store_path }.should raise_error(ArgumentError)
-      lambda { described_class.new.store_path(1) }.should raise_error(ArgumentError)
+      expect { described_class.new.store_path }.to raise_error(ArgumentError)
+      expect { described_class.new.store_path(1) }.to raise_error(ArgumentError)
     end
 
     include_examples "core_ext/hash/nested will not modify arguments", :store_path
@@ -114,33 +112,33 @@ shared_examples_for "core_ext/hash/nested" do
 
   context '#has_key_path?' do
     it "with various values" do
-      hash.has_key_path?("a").should be_true
-      hash.has_key_path?("b").should be_true
-      hash.has_key_path?("b", "b1").should be_false
-      hash.has_key_path?("b", "b1", "b2").should be_false
-      hash.has_key_path?("c").should be_true
-      hash.has_key_path?("c", "c1").should be_true
-      hash.has_key_path?("c", "c1", "c2").should be_false
-      hash.has_key_path?("d", "d1", "d2", "d3").should be_true
-      hash.has_key_path?("d", "d1", "d2", "dx").should be_false
-      hash.has_key_path?("d", "d1", "d2", "d3", "d4").should be_false
-      hash.has_key_path?("e").should be_true
-      hash.has_key_path?("e", "e1").should be_false
-      hash.has_key_path?("e", "e1", "e2").should be_false
-      hash.has_key_path?("f").should be_true
-      hash.has_key_path?("f", "f1").should be_false
-      hash.has_key_path?("f", "f1", "f2").should be_false
+      expect(hash.has_key_path?("a")).to be_truthy
+      expect(hash.has_key_path?("b")).to be_truthy
+      expect(hash.has_key_path?("b", "b1")).to be_falsey
+      expect(hash.has_key_path?("b", "b1", "b2")).to be_falsey
+      expect(hash.has_key_path?("c")).to be_truthy
+      expect(hash.has_key_path?("c", "c1")).to be_truthy
+      expect(hash.has_key_path?("c", "c1", "c2")).to be_falsey
+      expect(hash.has_key_path?("d", "d1", "d2", "d3")).to be_truthy
+      expect(hash.has_key_path?("d", "d1", "d2", "dx")).to be_falsey
+      expect(hash.has_key_path?("d", "d1", "d2", "d3", "d4")).to be_falsey
+      expect(hash.has_key_path?("e")).to be_truthy
+      expect(hash.has_key_path?("e", "e1")).to be_falsey
+      expect(hash.has_key_path?("e", "e1", "e2")).to be_falsey
+      expect(hash.has_key_path?("f")).to be_truthy
+      expect(hash.has_key_path?("f", "f1")).to be_falsey
+      expect(hash.has_key_path?("f", "f1", "f2")).to be_falsey
     end
 
     it "with a nil value" do
-      hash.has_key_path?(nil).should be_true
-      hash.has_key_path?("d", nil, "d1").should be_false
-      hash.has_key_path?("e", nil).should be_false
-      hash.has_key_path?("e", nil, "e1").should be_false
+      expect(hash.has_key_path?(nil)).to be_truthy
+      expect(hash.has_key_path?("d", nil, "d1")).to be_falsey
+      expect(hash.has_key_path?("e", nil)).to be_falsey
+      expect(hash.has_key_path?("e", nil, "e1")).to be_falsey
     end
 
     it "with invalid values" do
-      lambda { hash.has_key_path? }.should raise_error(ArgumentError)
+      expect { hash.has_key_path? }.to raise_error(ArgumentError)
     end
 
     include_examples "core_ext/hash/nested will not modify arguments", :has_key_path?
@@ -149,28 +147,28 @@ shared_examples_for "core_ext/hash/nested" do
   context "#delete_path" do
     it "on a nested hash" do
       hash.delete_path("d", "d1", "d2", "d3")
-      hash["d"].should == {"d1"=>{"d2"=>{}}}
+      expect(hash["d"]).to eq({"d1"=>{"d2"=>{}}})
     end
 
     it "with an invalid path" do
       hash.delete_path("d", "d1", :d)
-      hash["d"].should == {"d1"=>{"d2"=>{"d3"=>3}}}
+      expect(hash["d"]).to eq({"d1"=>{"d2"=>{"d3"=>3}}})
     end
 
     include_examples "core_ext/hash/nested will not modify arguments", :delete_path
   end
 
   it "#delete_blank_paths" do
-    hash.delete_blank_paths.should == {"a"=>1, "c"=>{"c1"=>2}, "d"=>{"d1"=>{"d2"=>{"d3"=>3}}}, nil=>{nil=>7}, ["h", "i"]=>8}
+    expect(hash.delete_blank_paths).to eq({"a"=>1, "c"=>{"c1"=>2}, "d"=>{"d1"=>{"d2"=>{"d3"=>3}}}, nil=>{nil=>7}, ["h", "i"]=>8})
   end
 
   context "#find_path" do
     it "with a real value" do
-      hash.find_path(3).should == ["d", "d1", "d2", "d3"]
+      expect(hash.find_path(3)).to eq(["d", "d1", "d2", "d3"])
     end
 
     it "with non-existent value" do
-      hash.find_path(42).should == []
+      expect(hash.find_path(42)).to eq([])
     end
   end
 end
@@ -192,6 +190,7 @@ describe Hash do
   include_examples "core_ext/hash/nested"
 end
 
+require 'active_support'
 require 'active_support/core_ext/hash'
 describe HashWithIndifferentAccess do
   let(:hash) do

data/spec/core_ext/object/namespace_spec.rb

@@ -1,5 +1,3 @@
-require "spec_helper"
-
 describe Class do
   before do
     module Aaa
@@ -14,33 +12,19 @@ describe Class do
 
   context "in_namespace?" do
     it "Class in Module" do
-      Aaa::Bbb::Ccc::Ddd.in_namespace?(Aaa::Bbb).should be_true
+      expect(Aaa::Bbb::Ccc::Ddd.in_namespace?(Aaa::Bbb)).to be_truthy
     end
 
     it "Module in Module" do
-      Aaa::Bbb::Ccc::Eee.in_namespace?("Aaa::Bbb").should be_true
+      expect(Aaa::Bbb::Ccc::Eee.in_namespace?("Aaa::Bbb")).to be_truthy
     end
 
     it "Instance of Class" do
-      Aaa::Bbb::Ccc::Ddd.new.in_namespace?(Aaa::Bbb).should be_true
+      expect(Aaa::Bbb::Ccc::Ddd.new.in_namespace?(Aaa::Bbb)).to be_truthy
     end
 
     it "Not in namespace" do
-      Aaa::Bbb::Ccc::Eee.in_namespace?(Aaa::Bbb::Ccc::Ddd).should be_false
-    end
-  end
-
-  context "namespace" do
-    it "Class in Module" do
-      expect(Aaa::Bbb::Ccc::Ddd.namespace).to eq(["Aaa", "Bbb", "Ccc", "Ddd"])
-    end
-
-    it "Module in Module" do
-      expect(Aaa::Bbb::Ccc::Eee.namespace).to eq(["Aaa", "Bbb", "Ccc", "Eee"])
-    end
-
-    it "Instance of a Class" do
-      expect(Aaa::Bbb::Ccc::Ddd.new.namespace).to eq(["Aaa", "Bbb", "Ccc", "Ddd"])
+      expect(Aaa::Bbb::Ccc::Eee.in_namespace?(Aaa::Bbb::Ccc::Ddd)).to be_falsey
     end
   end
 end

data/spec/core_ext/string/formats_spec.rb

@@ -1,76 +1,74 @@
-require_relative "../../spec_helper"
-
 describe String do
   it '#email?' do
-    "john@example.com".should be_email
-    "john.doe@example.com".should be_email
+    expect("john@example.com").to be_email
+    expect("john.doe@example.com").to be_email
 
-    "john.doe@examplecom".should_not be_email
-    "john.doe@example-com".should_not be_email
-    "".should_not be_email
-    "foo".should_not be_email
+    expect("john.doe@examplecom").not_to be_email
+    expect("john.doe@example-com").not_to be_email
+    expect("").not_to be_email
+    expect("foo").not_to be_email
   end
 
   it '#domain_name?' do
-    "example.com".should be_domain_name
+    expect("example.com").to be_domain_name
 
-    "example..com".should_not be_domain_name
-    "john.doe@example.com".should_not be_domain_name
-    "".should_not be_domain_name
-    "foo".should_not be_domain_name
+    expect("example..com").not_to be_domain_name
+    expect("john.doe@example.com").not_to be_domain_name
+    expect("").not_to be_domain_name
+    expect("foo").not_to be_domain_name
   end
 
   it '#ipv4?' do
-    "192.168.252.15".should be_ipv4
+    expect("192.168.252.15").to be_ipv4
 
-    "392.168.252.15".should_not be_ipv4
-    "".should_not be_ipv4
-    "foo".should_not be_ipv4
-    "::1".should_not be_ipv4                            # 127.0.0.1 in IPv6
-    "1762:0:0:0:0:B03:1:AF18".should_not be_ipv4        # Standard Notation
-    "1762:0:0:0:0:B03:127.32.67.15".should_not be_ipv4  # Mixed Notation
-    "1762::B03:1:AF18".should_not be_ipv4               # Compressed Notation
+    expect("392.168.252.15").not_to be_ipv4
+    expect("").not_to be_ipv4
+    expect("foo").not_to be_ipv4
+    expect("::1").not_to be_ipv4                            # 127.0.0.1 in IPv6
+    expect("1762:0:0:0:0:B03:1:AF18").not_to be_ipv4        # Standard Notation
+    expect("1762:0:0:0:0:B03:127.32.67.15").not_to be_ipv4  # Mixed Notation
+    expect("1762::B03:1:AF18").not_to be_ipv4               # Compressed Notation
   end
 
   it '#ipv6?' do
-    "::1".should be_ipv6                            # 127.0.0.1 in IPv6
-    "1762:0:0:0:0:B03:1:AF18".should be_ipv6        # Standard Notation
-    "1762:0:0:0:0:B03:127.32.67.15".should be_ipv6  # Mixed Notation
-    "1762::B03:1:AF18".should be_ipv6               # Compressed Notation
+    expect("::1").to be_ipv6                            # 127.0.0.1 in IPv6
+    expect("1762:0:0:0:0:B03:1:AF18").to be_ipv6        # Standard Notation
+    expect("1762:0:0:0:0:B03:127.32.67.15").to be_ipv6  # Mixed Notation
+    expect("1762::B03:1:AF18").to be_ipv6               # Compressed Notation
 
-    "192.168.252.15".should_not be_ipv6
-    "392.168.252.15".should_not be_ipv6
-    "".should_not be_ipv6
-    "foo".should_not be_ipv6
+    expect("192.168.252.15").not_to be_ipv6
+    expect("392.168.252.15").not_to be_ipv6
+    expect("").not_to be_ipv6
+    expect("foo").not_to be_ipv6
   end
 
   it "#ipaddress?" do
-    "192.168.252.15".should be_ipaddress
-    "::1".should be_ipaddress                            # 127.0.0.1 in IPv6
-    "1762:0:0:0:0:B03:1:AF18".should be_ipaddress        # Standard Notation
-    "1762:0:0:0:0:B03:127.32.67.15".should be_ipaddress  # Mixed Notation
-    "1762::B03:1:AF18".should be_ipaddress               # Compressed Notation
+    expect("192.168.252.15").to be_ipaddress
+    expect("::1").to be_ipaddress                            # 127.0.0.1 in IPv6
+    expect("1762:0:0:0:0:B03:1:AF18").to be_ipaddress        # Standard Notation
+    expect("1762:0:0:0:0:B03:127.32.67.15").to be_ipaddress  # Mixed Notation
+    expect("1762::B03:1:AF18").to be_ipaddress               # Compressed Notation
 
-    "392.168.252.15".should_not be_ipaddress
-    "".should_not be_ipaddress
-    "foo".should_not be_ipaddress
+    expect("392.168.252.15").not_to be_ipaddress
+    expect("").not_to be_ipaddress
+    expect("foo").not_to be_ipaddress
   end
 
   it "#integer?" do
-    "100".should be_integer
-    "-100".should be_integer
+    expect("100").to be_integer
+    expect("-100").to be_integer
 
-    "".should_not be_integer
-    "100.2".should_not be_integer
-    "A".should_not be_integer
-    "100A".should_not be_integer
+    expect("").not_to be_integer
+    expect("100.2").not_to be_integer
+    expect("A").not_to be_integer
+    expect("100A").not_to be_integer
   end
 
   it '#guid?' do
-    '01234567-89ab-cdef-abcd-ef0123456789'.should be_guid
+    expect('01234567-89ab-cdef-abcd-ef0123456789').to be_guid
 
-    '012ZZZ67-89ab-cdef-abcd-ef0123456789'.should_not be_guid
-    "".should_not be_guid
-    "foo".should_not be_guid
+    expect('012ZZZ67-89ab-cdef-abcd-ef0123456789').not_to be_guid
+    expect("").not_to be_guid
+    expect("foo").not_to be_guid
   end
-end
+end