diff --git a/spec/oga/blacklist_spec.rb b/spec/oga/blacklist_spec.rb
index 759b519..b257b02 100644
--- a/spec/oga/blacklist_spec.rb
+++ b/spec/oga/blacklist_spec.rb
@@ -14,15 +14,15 @@ describe Oga::Blacklist do
     it 'returns true for a name not in the list' do
       list = described_class.new(%w{foo})
 
-      list.allow?('bar').should == true
-      list.allow?('BAR').should == true
+      expect(list.allow?('bar')).to eq(true)
+      expect(list.allow?('BAR')).to eq(true)
     end
 
     it 'returns false for a name in the list' do
       list = described_class.new(%w{foo})
 
-      list.allow?('foo').should == false
-      list.allow?('FOO').should == false
+      expect(list.allow?('foo')).to eq(false)
+      expect(list.allow?('FOO')).to eq(false)
     end
   end
 
@@ -32,8 +32,8 @@ describe Oga::Blacklist do
       list2 = described_class.new(%w{bar})
       list3 = list1 + list2
 
-      list3.should be_an_instance_of(described_class)
-      list3.names.to_a.should == %w{foo FOO bar BAR}
+      expect(list3).to be_an_instance_of(described_class)
+      expect(list3.names.to_a).to eq(%w{foo FOO bar BAR})
     end
   end
 end
diff --git a/spec/oga/css/compiler/axes_spec.rb b/spec/oga/css/compiler/axes_spec.rb
index d73667a..2b2e55c 100644
--- a/spec/oga/css/compiler/axes_spec.rb
+++ b/spec/oga/css/compiler/axes_spec.rb
@@ -10,15 +10,15 @@ describe 'CSS selector evaluation' do
       end
 
       it 'returns a node set containing direct child nodes' do
-        evaluate_css(@document, 'root > a').should == node_set(@a1)
+        expect(evaluate_css(@document, 'root > a')).to eq(node_set(@a1))
       end
 
       it 'returns a node set containing direct child nodes relative to a node' do
-        evaluate_css(@a1, '> a').should == @a1.children
+        expect(evaluate_css(@a1, '> a')).to eq(@a1.children)
       end
 
       it 'returns an empty node set for non matching child nodes' do
-        evaluate_css(@document, '> a').should == node_set
+        expect(evaluate_css(@document, '> a')).to eq(node_set)
       end
     end
 
@@ -31,15 +31,15 @@ describe 'CSS selector evaluation' do
       end
 
       it 'returns a node set containing following siblings' do
-        evaluate_css(@document, 'root a + b').should == node_set(@b1)
+        expect(evaluate_css(@document, 'root a + b')).to eq(node_set(@b1))
       end
 
       it 'returns a node set containing following siblings relatie to a node' do
-        evaluate_css(@b1, '+ b').should == node_set(@b2)
+        expect(evaluate_css(@b1, '+ b')).to eq(node_set(@b2))
       end
 
       it 'returns an empty node set for non matching following siblings' do
-        evaluate_css(@document, 'root a + c').should == node_set
+        expect(evaluate_css(@document, 'root a + c')).to eq(node_set)
       end
     end
 
@@ -52,15 +52,15 @@ describe 'CSS selector evaluation' do
       end
 
       it 'returns a node set containing following siblings' do
-        evaluate_css(@document, 'root a ~ b').should == node_set(@b1, @b2)
+        expect(evaluate_css(@document, 'root a ~ b')).to eq(node_set(@b1, @b2))
       end
 
       it 'returns a node set containing following siblings relative to a node' do
-        evaluate_css(@b1, '~ b').should == node_set(@b2)
+        expect(evaluate_css(@b1, '~ b')).to eq(node_set(@b2))
       end
 
       it 'returns an empty node set for non matching following siblings' do
-        evaluate_css(@document, 'root a ~ c').should == node_set
+        expect(evaluate_css(@document, 'root a ~ c')).to eq(node_set)
       end
     end
   end
diff --git a/spec/oga/css/compiler/classes_spec.rb b/spec/oga/css/compiler/classes_spec.rb
index c532212..75229f6 100644
--- a/spec/oga/css/compiler/classes_spec.rb
+++ b/spec/oga/css/compiler/classes_spec.rb
@@ -5,25 +5,25 @@ describe 'CSS selector evaluation' do
     it 'returns a node set containing a node with a single class' do
       document = parse('<x class="foo" />')
 
-      evaluate_css(document, '.foo').should == document.children
+      expect(evaluate_css(document, '.foo')).to eq(document.children)
     end
 
     it 'returns a node set containing a node having one of two classes' do
       document = parse('<x class="foo bar" />')
 
-      evaluate_css(document, '.foo').should == document.children
+      expect(evaluate_css(document, '.foo')).to eq(document.children)
     end
 
     it 'returns a node set containing a node having both classes' do
       document = parse('<x class="foo bar" />')
 
-      evaluate_css(document, '.foo.bar').should == document.children
+      expect(evaluate_css(document, '.foo.bar')).to eq(document.children)
     end
 
     it 'returns an empty node set for non matching classes' do
       document = parse('<x class="bar" />')
 
-      evaluate_css(document, '.foo').should == node_set
+      expect(evaluate_css(document, '.foo')).to eq(node_set)
     end
   end
 end
diff --git a/spec/oga/css/compiler/ids_spec.rb b/spec/oga/css/compiler/ids_spec.rb
index 10fd55f..5f4df98 100644
--- a/spec/oga/css/compiler/ids_spec.rb
+++ b/spec/oga/css/compiler/ids_spec.rb
@@ -7,11 +7,11 @@ describe 'CSS selector evaluation' do
     end
 
     it 'returns a node set containing a node with a single ID' do
-      evaluate_css(@document, '#foo').should == @document.children
+      expect(evaluate_css(@document, '#foo')).to eq(@document.children)
     end
 
     it 'returns an empty node set for non matching IDs' do
-      evaluate_css(@document, '#bar').should == node_set
+      expect(evaluate_css(@document, '#bar')).to eq(node_set)
     end
   end
 end
diff --git a/spec/oga/css/compiler/operators_spec.rb b/spec/oga/css/compiler/operators_spec.rb
index 6efdb4b..f239fb9 100644
--- a/spec/oga/css/compiler/operators_spec.rb
+++ b/spec/oga/css/compiler/operators_spec.rb
@@ -8,11 +8,11 @@ describe 'CSS selector evaluation' do
       end
 
       it 'returns a node set containing nodes with matching attributes' do
-        evaluate_css(@document, 'x[a = "b"]').should == @document.children
+        expect(evaluate_css(@document, 'x[a = "b"]')).to eq(@document.children)
       end
 
       it 'returns an empty node set for non matching attribute values' do
-        evaluate_css(@document, 'x[a = "c"]').should == node_set
+        expect(evaluate_css(@document, 'x[a = "c"]')).to eq(node_set)
       end
     end
 
@@ -20,19 +20,19 @@ describe 'CSS selector evaluation' do
       it 'returns a node set containing nodes with matching attributes' do
         document = parse('<x a="1 2 3" />')
 
-        evaluate_css(document, 'x[a ~= "2"]').should == document.children
+        expect(evaluate_css(document, 'x[a ~= "2"]')).to eq(document.children)
       end
 
       it 'returns a node set containing nodes with single attribute values' do
         document = parse('<x a="1" />')
 
-        evaluate_css(document, 'x[a ~= "1"]').should == document.children
+        expect(evaluate_css(document, 'x[a ~= "1"]')).to eq(document.children)
       end
 
       it 'returns an empty node set for non matching attributes' do
         document = parse('<x a="1 2 3" />')
 
-        evaluate_css(document, 'x[a ~= "4"]').should == node_set
+        expect(evaluate_css(document, 'x[a ~= "4"]')).to eq(node_set)
       end
     end
 
@@ -42,11 +42,11 @@ describe 'CSS selector evaluation' do
       end
 
       it 'returns a node set containing nodes with matching attributes' do
-        evaluate_css(@document, 'x[a ^= "fo"]').should == @document.children
+        expect(evaluate_css(@document, 'x[a ^= "fo"]')).to eq(@document.children)
       end
 
       it 'returns an empty node set for non matching attributes' do
-        evaluate_css(@document, 'x[a ^= "bar"]').should == node_set
+        expect(evaluate_css(@document, 'x[a ^= "bar"]')).to eq(node_set)
       end
     end
 
@@ -56,11 +56,11 @@ describe 'CSS selector evaluation' do
       end
 
       it 'returns a node set containing nodes with matching attributes' do
-        evaluate_css(@document, 'x[a $= "oo"]').should == @document.children
+        expect(evaluate_css(@document, 'x[a $= "oo"]')).to eq(@document.children)
       end
 
       it 'returns an empty node set for non matching attributes' do
-        evaluate_css(@document, 'x[a $= "x"]').should == node_set
+        expect(evaluate_css(@document, 'x[a $= "x"]')).to eq(node_set)
       end
     end
 
@@ -70,11 +70,11 @@ describe 'CSS selector evaluation' do
       end
 
       it 'returns a node set containing nodes with matching attributes' do
-        evaluate_css(@document, 'x[a *= "o"]').should == @document.children
+        expect(evaluate_css(@document, 'x[a *= "o"]')).to eq(@document.children)
       end
 
       it 'returns an empty node set for non matching attributes' do
-        evaluate_css(@document, 'x[a *= "x"]').should == node_set
+        expect(evaluate_css(@document, 'x[a *= "x"]')).to eq(node_set)
       end
     end
 
@@ -82,19 +82,19 @@ describe 'CSS selector evaluation' do
       it 'returns a node set containing nodes with matching attributes' do
         document = parse('<x a="foo-bar" />')
 
-        evaluate_css(document, 'x[a |= "foo"]').should == document.children
+        expect(evaluate_css(document, 'x[a |= "foo"]')).to eq(document.children)
       end
 
       it 'returns a node set containing nodes with single attribute values' do
         document = parse('<x a="foo" />')
 
-        evaluate_css(document, 'x[a |= "foo"]').should == document.children
+        expect(evaluate_css(document, 'x[a |= "foo"]')).to eq(document.children)
       end
 
       it 'returns an empty node set for non matching attributes' do
         document = parse('<x a="bar" />')
 
-        evaluate_css(document, 'x[a |= "foo"]').should == node_set
+        expect(evaluate_css(document, 'x[a |= "foo"]')).to eq(node_set)
       end
     end
   end
diff --git a/spec/oga/css/compiler/paths_spec.rb b/spec/oga/css/compiler/paths_spec.rb
index 6b34337..63fc91a 100644
--- a/spec/oga/css/compiler/paths_spec.rb
+++ b/spec/oga/css/compiler/paths_spec.rb
@@ -12,23 +12,23 @@ describe 'CSS selector evaluation' do
     end
 
     it 'returns a node set containing the root node' do
-      evaluate_css(@document, 'a').should == node_set(@a1)
+      expect(evaluate_css(@document, 'a')).to eq(node_set(@a1))
     end
 
     it 'returns a node set containing nested nodes' do
-      evaluate_css(@document, 'a b').should == node_set(@b1, @b2)
+      expect(evaluate_css(@document, 'a b')).to eq(node_set(@b1, @b2))
     end
 
     it 'returns a node set containing the union of multiple paths' do
-      evaluate_css(@document, 'b, ns1|c').should == node_set(@b1, @b2, @c1)
+      expect(evaluate_css(@document, 'b, ns1|c')).to eq(node_set(@b1, @b2, @c1))
     end
 
     it 'returns a node set containing namespaced nodes' do
-      evaluate_css(@document, 'a ns1|c').should == node_set(@c1)
+      expect(evaluate_css(@document, 'a ns1|c')).to eq(node_set(@c1))
     end
 
     it 'returns a node set containing wildcard nodes' do
-      evaluate_css(@document, 'a *').should == node_set(@b1, @b2, @c1)
+      expect(evaluate_css(@document, 'a *')).to eq(node_set(@b1, @b2, @c1))
     end
 
     it 'returns a node set containing nodes with namespace wildcards' do
@@ -36,11 +36,11 @@ describe 'CSS selector evaluation' do
     end
 
     it 'returns a node set containing nodes with a namespace name and name wildcard' do
-      evaluate_css(@document, 'a ns1|*').should == node_set(@c1)
+      expect(evaluate_css(@document, 'a ns1|*')).to eq(node_set(@c1))
     end
 
     it 'returns a node set containing nodes using full wildcards' do
-      evaluate_css(@document, 'a *|*').should == node_set(@b1, @b2, @c1)
+      expect(evaluate_css(@document, 'a *|*')).to eq(node_set(@b1, @b2, @c1))
     end
   end
 end
diff --git a/spec/oga/css/compiler/predicates_spec.rb b/spec/oga/css/compiler/predicates_spec.rb
index 8159439..af77ce9 100644
--- a/spec/oga/css/compiler/predicates_spec.rb
+++ b/spec/oga/css/compiler/predicates_spec.rb
@@ -9,11 +9,11 @@ describe 'CSS selector evaluation' do
     end
 
     it 'returns a node set containing nodes with an attribute' do
-      evaluate_css(@document, 'root a[class]').should == node_set(@a1)
+      expect(evaluate_css(@document, 'root a[class]')).to eq(node_set(@a1))
     end
 
     it 'returns a node set containing nodes with a matching attribute value' do
-      evaluate_css(@document, 'root a[class="foo"]').should == node_set(@a1)
+      expect(evaluate_css(@document, 'root a[class="foo"]')).to eq(node_set(@a1))
     end
   end
 end
diff --git a/spec/oga/css/compiler/pseudo_classes/empty_spec.rb b/spec/oga/css/compiler/pseudo_classes/empty_spec.rb
index 6d519cc..3c914a8 100644
--- a/spec/oga/css/compiler/pseudo_classes/empty_spec.rb
+++ b/spec/oga/css/compiler/pseudo_classes/empty_spec.rb
@@ -10,15 +10,15 @@ describe 'CSS selector evaluation' do
     end
 
     it 'returns a node set containing empty nodes' do
-      evaluate_css(@document, 'root :empty').should == node_set(@a1)
+      expect(evaluate_css(@document, 'root :empty')).to eq(node_set(@a1))
     end
 
     it 'returns a node set containing empty nodes with a node test' do
-      evaluate_css(@document, 'root a:empty').should == node_set(@a1)
+      expect(evaluate_css(@document, 'root a:empty')).to eq(node_set(@a1))
     end
 
     it 'returns an empty node set containing non empty nodes' do
-      evaluate_css(@document, 'root b:empty').should == node_set
+      expect(evaluate_css(@document, 'root b:empty')).to eq(node_set)
     end
   end
 end
diff --git a/spec/oga/css/compiler/pseudo_classes/first_child_spec.rb b/spec/oga/css/compiler/pseudo_classes/first_child_spec.rb
index 37d3cce..c049bb4 100644
--- a/spec/oga/css/compiler/pseudo_classes/first_child_spec.rb
+++ b/spec/oga/css/compiler/pseudo_classes/first_child_spec.rb
@@ -10,15 +10,15 @@ describe 'CSS selector evaluation' do
     end
 
     it 'returns a node set containing the first child node' do
-      evaluate_css(@document, 'root :first-child').should == node_set(@a1)
+      expect(evaluate_css(@document, 'root :first-child')).to eq(node_set(@a1))
     end
 
     it 'returns a node set containing the first child node with a node test' do
-      evaluate_css(@document, 'root a:first-child').should == node_set(@a1)
+      expect(evaluate_css(@document, 'root a:first-child')).to eq(node_set(@a1))
     end
 
     it 'returns an empty node set for non first-child nodes' do
-      evaluate_css(@document, 'root b:first-child').should == node_set
+      expect(evaluate_css(@document, 'root b:first-child')).to eq(node_set)
     end
   end
 end
diff --git a/spec/oga/css/compiler/pseudo_classes/first_of_type_spec.rb b/spec/oga/css/compiler/pseudo_classes/first_of_type_spec.rb
index 99d0498..3fc86fe 100644
--- a/spec/oga/css/compiler/pseudo_classes/first_of_type_spec.rb
+++ b/spec/oga/css/compiler/pseudo_classes/first_of_type_spec.rb
@@ -18,8 +18,8 @@ describe 'CSS selector evaluation' do
     end
 
     it 'returns a node set containing all first <a> nodes' do
-      evaluate_css(@document, 'root a:first-of-type')
-        .should == node_set(@a1, @a3)
+      expect(evaluate_css(@document, 'root a:first-of-type'))
+        .to eq(node_set(@a1, @a3))
     end
   end
 end
diff --git a/spec/oga/css/compiler/pseudo_classes/last_child_spec.rb b/spec/oga/css/compiler/pseudo_classes/last_child_spec.rb
index 09edf7a..463070a 100644
--- a/spec/oga/css/compiler/pseudo_classes/last_child_spec.rb
+++ b/spec/oga/css/compiler/pseudo_classes/last_child_spec.rb
@@ -10,15 +10,15 @@ describe 'CSS selector evaluation' do
     end
 
     it 'returns a node set containing the last child node' do
-      evaluate_css(@document, 'root :last-child').should == node_set(@b1)
+      expect(evaluate_css(@document, 'root :last-child')).to eq(node_set(@b1))
     end
 
     it 'returns a node set containing the last child node with a node test' do
-      evaluate_css(@document, 'root b:last-child').should == node_set(@b1)
+      expect(evaluate_css(@document, 'root b:last-child')).to eq(node_set(@b1))
     end
 
     it 'returns an empty node set for non last-child nodes' do
-      evaluate_css(@document, 'root a:last-child').should == node_set
+      expect(evaluate_css(@document, 'root a:last-child')).to eq(node_set)
     end
   end
 end
diff --git a/spec/oga/css/compiler/pseudo_classes/last_of_type_spec.rb b/spec/oga/css/compiler/pseudo_classes/last_of_type_spec.rb
index 9fa1852..05223dd 100644
--- a/spec/oga/css/compiler/pseudo_classes/last_of_type_spec.rb
+++ b/spec/oga/css/compiler/pseudo_classes/last_of_type_spec.rb
@@ -18,8 +18,8 @@ describe 'CSS selector evaluation' do
     end
 
     it 'returns a node set containing all last <a> nodes' do
-      evaluate_css(@document, 'root a:last-of-type')
-        .should == node_set(@a2, @a4)
+      expect(evaluate_css(@document, 'root a:last-of-type'))
+        .to eq(node_set(@a2, @a4))
     end
   end
 end
diff --git a/spec/oga/css/compiler/pseudo_classes/nth_child_spec.rb b/spec/oga/css/compiler/pseudo_classes/nth_child_spec.rb
index 47a6b46..99c5e31 100644
--- a/spec/oga/css/compiler/pseudo_classes/nth_child_spec.rb
+++ b/spec/oga/css/compiler/pseudo_classes/nth_child_spec.rb
@@ -13,36 +13,36 @@ describe 'CSS selector evaluation' do
     end
 
     it 'returns a node set containing the first child node' do
-      evaluate_css(@document, 'root :nth-child(1)').should == node_set(@a1)
+      expect(evaluate_css(@document, 'root :nth-child(1)')).to eq(node_set(@a1))
     end
 
     it 'returns a node set containing even nodes' do
-      evaluate_css(@document, 'root :nth-child(even)')
-        .should == node_set(@a2, @a4)
+      expect(evaluate_css(@document, 'root :nth-child(even)'))
+        .to eq(node_set(@a2, @a4))
     end
 
     it 'returns a node set containing odd nodes' do
-      evaluate_css(@document, 'root :nth-child(odd)')
-        .should == node_set(@a1, @a3)
+      expect(evaluate_css(@document, 'root :nth-child(odd)'))
+        .to eq(node_set(@a1, @a3))
     end
 
     it 'returns a node set containing every 2 nodes starting at node 2' do
-      evaluate_css(@document, 'root :nth-child(2n+2)')
-        .should == node_set(@a2, @a4)
+      expect(evaluate_css(@document, 'root :nth-child(2n+2)'))
+        .to eq(node_set(@a2, @a4))
     end
 
     it 'returns a node set containing all nodes' do
-      evaluate_css(@document, 'root :nth-child(n)').should == @root.children
+      expect(evaluate_css(@document, 'root :nth-child(n)')).to eq(@root.children)
     end
 
     it 'returns a node set containing the first two nodes' do
-      evaluate_css(@document, 'root :nth-child(-n+2)')
-        .should == node_set(@a1, @a2)
+      expect(evaluate_css(@document, 'root :nth-child(-n+2)'))
+        .to eq(node_set(@a1, @a2))
     end
 
     it 'returns a node set containing all nodes starting at node 2' do
-      evaluate_css(@document, 'root :nth-child(n+2)')
-        .should == node_set(@a2, @a3, @a4)
+      expect(evaluate_css(@document, 'root :nth-child(n+2)'))
+        .to eq(node_set(@a2, @a3, @a4))
     end
   end
 end
diff --git a/spec/oga/css/compiler/pseudo_classes/nth_last_child_spec.rb b/spec/oga/css/compiler/pseudo_classes/nth_last_child_spec.rb
index 6a91088..de3ed8b 100644
--- a/spec/oga/css/compiler/pseudo_classes/nth_last_child_spec.rb
+++ b/spec/oga/css/compiler/pseudo_classes/nth_last_child_spec.rb
@@ -13,37 +13,37 @@ describe 'CSS selector evaluation' do
     end
 
     it 'returns a node set containing the last child node' do
-      evaluate_css(@document, 'root :nth-last-child(1)').should == node_set(@a4)
+      expect(evaluate_css(@document, 'root :nth-last-child(1)')).to eq(node_set(@a4))
     end
 
     it 'returns a node set containing even nodes' do
-      evaluate_css(@document, 'root :nth-last-child(even)')
-        .should == node_set(@a1, @a3)
+      expect(evaluate_css(@document, 'root :nth-last-child(even)'))
+        .to eq(node_set(@a1, @a3))
     end
 
     it 'returns a node set containing odd nodes' do
-      evaluate_css(@document, 'root :nth-last-child(odd)')
-        .should == node_set(@a2, @a4)
+      expect(evaluate_css(@document, 'root :nth-last-child(odd)'))
+        .to eq(node_set(@a2, @a4))
     end
 
     it 'returns a node set containing every 2 nodes starting at node 3' do
-      evaluate_css(@document, 'root :nth-last-child(2n+2)')
-        .should == node_set(@a1, @a3)
+      expect(evaluate_css(@document, 'root :nth-last-child(2n+2)'))
+        .to eq(node_set(@a1, @a3))
     end
 
     it 'returns a node set containing all nodes' do
-      evaluate_css(@document, 'root :nth-last-child(n)')
-        .should == @root.children
+      expect(evaluate_css(@document, 'root :nth-last-child(n)'))
+        .to eq(@root.children)
     end
 
     it 'returns a node set containing the first two nodes' do
-      evaluate_css(@document, 'root :nth-last-child(-n+2)')
-        .should == node_set(@a3, @a4)
+      expect(evaluate_css(@document, 'root :nth-last-child(-n+2)'))
+        .to eq(node_set(@a3, @a4))
     end
 
     it 'returns a node set containing all nodes starting at node 2' do
-      evaluate_css(@document, 'root :nth-last-child(n+2)')
-        .should == node_set(@a1, @a2, @a3)
+      expect(evaluate_css(@document, 'root :nth-last-child(n+2)'))
+        .to eq(node_set(@a1, @a2, @a3))
     end
   end
 end
diff --git a/spec/oga/css/compiler/pseudo_classes/nth_last_of_type_spec.rb b/spec/oga/css/compiler/pseudo_classes/nth_last_of_type_spec.rb
index c9e8217..026b067 100644
--- a/spec/oga/css/compiler/pseudo_classes/nth_last_of_type_spec.rb
+++ b/spec/oga/css/compiler/pseudo_classes/nth_last_of_type_spec.rb
@@ -22,38 +22,38 @@ describe 'CSS selector evaluation' do
     end
 
     it 'returns a node set containing the first child node' do
-      evaluate_css(@document, 'root a:nth-last-of-type(1)')
-        .should == node_set(@a3, @a4)
+      expect(evaluate_css(@document, 'root a:nth-last-of-type(1)'))
+        .to eq(node_set(@a3, @a4))
     end
 
     it 'returns a node set containing even nodes' do
-      evaluate_css(@document, 'root a:nth-last-of-type(even)')
-        .should == node_set(@a2)
+      expect(evaluate_css(@document, 'root a:nth-last-of-type(even)'))
+        .to eq(node_set(@a2))
     end
 
     it 'returns a node set containing odd nodes' do
-      evaluate_css(@document, 'root a:nth-last-of-type(odd)')
-        .should == node_set(@a1, @a3, @a4)
+      expect(evaluate_css(@document, 'root a:nth-last-of-type(odd)'))
+        .to eq(node_set(@a1, @a3, @a4))
     end
 
     it 'returns a node set containing every 2 nodes starting at node 2' do
-      evaluate_css(@document, 'root a:nth-last-of-type(2n+2)')
-        .should == node_set(@a2)
+      expect(evaluate_css(@document, 'root a:nth-last-of-type(2n+2)'))
+        .to eq(node_set(@a2))
     end
 
     it 'returns a node set containing all nodes' do
-      evaluate_css(@document, 'root a:nth-last-of-type(n)')
-        .should == node_set(@a1, @a2, @a3, @a4)
+      expect(evaluate_css(@document, 'root a:nth-last-of-type(n)'))
+        .to eq(node_set(@a1, @a2, @a3, @a4))
     end
 
     it 'returns a node set containing the first two nodes' do
-      evaluate_css(@document, 'root a:nth-last-of-type(-n+2)')
-        .should == node_set(@a2, @a3, @a4)
+      expect(evaluate_css(@document, 'root a:nth-last-of-type(-n+2)'))
+        .to eq(node_set(@a2, @a3, @a4))
     end
 
     it 'returns a node set containing all nodes starting at node 2' do
-      evaluate_css(@document, 'root a:nth-last-of-type(n+2)')
-        .should == node_set(@a1, @a2)
+      expect(evaluate_css(@document, 'root a:nth-last-of-type(n+2)'))
+        .to eq(node_set(@a1, @a2))
     end
   end
 end
diff --git a/spec/oga/css/compiler/pseudo_classes/nth_of_type_spec.rb b/spec/oga/css/compiler/pseudo_classes/nth_of_type_spec.rb
index b1a8994..600b0cf 100644
--- a/spec/oga/css/compiler/pseudo_classes/nth_of_type_spec.rb
+++ b/spec/oga/css/compiler/pseudo_classes/nth_of_type_spec.rb
@@ -22,38 +22,38 @@ describe 'CSS selector evaluation' do
     end
 
     it 'returns a node set containing the first child node' do
-      evaluate_css(@document, 'root a:nth-of-type(1)')
-        .should == node_set(@a1, @a4)
+      expect(evaluate_css(@document, 'root a:nth-of-type(1)'))
+        .to eq(node_set(@a1, @a4))
     end
 
     it 'returns a node set containing even nodes' do
-      evaluate_css(@document, 'root a:nth-of-type(even)')
-        .should == node_set(@a2)
+      expect(evaluate_css(@document, 'root a:nth-of-type(even)'))
+        .to eq(node_set(@a2))
     end
 
     it 'returns a node set containing odd nodes' do
-      evaluate_css(@document, 'root a:nth-of-type(odd)')
-        .should == node_set(@a1, @a3, @a4)
+      expect(evaluate_css(@document, 'root a:nth-of-type(odd)'))
+        .to eq(node_set(@a1, @a3, @a4))
     end
 
     it 'returns a node set containing every 2 nodes starting at node 2' do
-      evaluate_css(@document, 'root a:nth-of-type(2n+2)')
-        .should == node_set(@a2)
+      expect(evaluate_css(@document, 'root a:nth-of-type(2n+2)'))
+        .to eq(node_set(@a2))
     end
 
     it 'returns a node set containing all nodes' do
-      evaluate_css(@document, 'root a:nth-of-type(n)')
-        .should == node_set(@a1, @a2, @a3, @a4)
+      expect(evaluate_css(@document, 'root a:nth-of-type(n)'))
+        .to eq(node_set(@a1, @a2, @a3, @a4))
     end
 
     it 'returns a node set containing the first two nodes' do
-      evaluate_css(@document, 'root a:nth-of-type(-n+2)')
-        .should == node_set(@a1, @a2, @a4)
+      expect(evaluate_css(@document, 'root a:nth-of-type(-n+2)'))
+        .to eq(node_set(@a1, @a2, @a4))
     end
 
     it 'returns a node set containing all nodes starting at node 2' do
-      evaluate_css(@document, 'root a:nth-of-type(n+2)')
-        .should == node_set(@a2, @a3)
+      expect(evaluate_css(@document, 'root a:nth-of-type(n+2)'))
+        .to eq(node_set(@a2, @a3))
     end
   end
 end
diff --git a/spec/oga/css/compiler/pseudo_classes/nth_spec.rb b/spec/oga/css/compiler/pseudo_classes/nth_spec.rb
index 407a3ea..84e6f99 100644
--- a/spec/oga/css/compiler/pseudo_classes/nth_spec.rb
+++ b/spec/oga/css/compiler/pseudo_classes/nth_spec.rb
@@ -11,11 +11,11 @@ describe 'CSS selector evaluation' do
     end
 
     it 'returns a node set containing the first <a> node' do
-      evaluate_css(@document, 'root a:nth(1)').should == node_set(@a1)
+      expect(evaluate_css(@document, 'root a:nth(1)')).to eq(node_set(@a1))
     end
 
     it 'returns a node set containing the second <a> node' do
-      evaluate_css(@document, 'root a:nth(2)').should == node_set(@a2)
+      expect(evaluate_css(@document, 'root a:nth(2)')).to eq(node_set(@a2))
     end
   end
 end
diff --git a/spec/oga/css/compiler/pseudo_classes/only_child_spec.rb b/spec/oga/css/compiler/pseudo_classes/only_child_spec.rb
index 0695df4..122f032 100644
--- a/spec/oga/css/compiler/pseudo_classes/only_child_spec.rb
+++ b/spec/oga/css/compiler/pseudo_classes/only_child_spec.rb
@@ -11,7 +11,7 @@ describe 'CSS selector evaluation' do
     end
 
     it 'returns a node set containing <c> nodes' do
-      evaluate_css(@document, 'root :only-child').should == node_set(@c1, @c2)
+      expect(evaluate_css(@document, 'root :only-child')).to eq(node_set(@c1, @c2))
     end
   end
 end
diff --git a/spec/oga/css/compiler/pseudo_classes/only_of_type_spec.rb b/spec/oga/css/compiler/pseudo_classes/only_of_type_spec.rb
index 4e83e6c..9e38519 100644
--- a/spec/oga/css/compiler/pseudo_classes/only_of_type_spec.rb
+++ b/spec/oga/css/compiler/pseudo_classes/only_of_type_spec.rb
@@ -11,7 +11,7 @@ describe 'CSS selector evaluation' do
     end
 
     it 'returns a node set containing <c> nodes' do
-      evaluate_css(@document, 'root a :only-of-type').should == node_set(@c1)
+      expect(evaluate_css(@document, 'root a :only-of-type')).to eq(node_set(@c1))
     end
   end
 end
diff --git a/spec/oga/css/compiler/pseudo_classes/root_spec.rb b/spec/oga/css/compiler/pseudo_classes/root_spec.rb
index 9686301..2ebbd59 100644
--- a/spec/oga/css/compiler/pseudo_classes/root_spec.rb
+++ b/spec/oga/css/compiler/pseudo_classes/root_spec.rb
@@ -7,7 +7,7 @@ describe 'CSS selector evaluation' do
     end
 
     it 'returns a node set containing the root node' do
-      evaluate_css(@document, ':root').should == @document.children
+      expect(evaluate_css(@document, ':root')).to eq(@document.children)
     end
   end
 end
diff --git a/spec/oga/css/lexer/axes_spec.rb b/spec/oga/css/lexer/axes_spec.rb
index 0471b62..7537354 100644
--- a/spec/oga/css/lexer/axes_spec.rb
+++ b/spec/oga/css/lexer/axes_spec.rb
@@ -3,63 +3,63 @@ require 'spec_helper'
 describe Oga::CSS::Lexer do
   describe 'axes' do
     it 'lexes the > axis' do
-      lex_css('>').should == [[:T_GREATER, nil]]
+      expect(lex_css('>')).to eq([[:T_GREATER, nil]])
     end
 
     it 'lexes the expression "> y"' do
-      lex_css('> y').should == [[:T_GREATER, nil], [:T_IDENT, 'y']]
+      expect(lex_css('> y')).to eq([[:T_GREATER, nil], [:T_IDENT, 'y']])
     end
 
     it 'lexes the expression "x > y"' do
-      lex_css('x > y').should == [
+      expect(lex_css('x > y')).to eq([
         [:T_IDENT, 'x'],
         [:T_GREATER, nil],
         [:T_IDENT, 'y']
-      ]
+      ])
     end
 
     it 'lexes the expression "x>y"' do
-      lex_css('x>y').should == lex_css('x > y')
+      expect(lex_css('x>y')).to eq(lex_css('x > y'))
     end
 
     it 'lexes the + axis' do
-      lex_css('+').should == [[:T_PLUS, nil]]
+      expect(lex_css('+')).to eq([[:T_PLUS, nil]])
     end
 
     it 'lexes the expression "+ y"' do
-      lex_css('+ y').should == [[:T_PLUS, nil], [:T_IDENT, 'y']]
+      expect(lex_css('+ y')).to eq([[:T_PLUS, nil], [:T_IDENT, 'y']])
     end
 
     it 'lexes the expression "x + y"' do
-      lex_css('x + y').should == [
+      expect(lex_css('x + y')).to eq([
         [:T_IDENT, 'x'],
         [:T_PLUS, nil],
         [:T_IDENT, 'y']
-      ]
+      ])
     end
 
     it 'lexes the expression "x+y"' do
-      lex_css('x+y').should == lex_css('x + y')
+      expect(lex_css('x+y')).to eq(lex_css('x + y'))
     end
 
     it 'lexes the ~ axis' do
-      lex_css('~').should == [[:T_TILDE, nil]]
+      expect(lex_css('~')).to eq([[:T_TILDE, nil]])
     end
 
     it 'lexes the expression "~ y"' do
-      lex_css('~ y').should == [[:T_TILDE, nil], [:T_IDENT, 'y']]
+      expect(lex_css('~ y')).to eq([[:T_TILDE, nil], [:T_IDENT, 'y']])
     end
 
     it 'lexes the expression "x ~ y"' do
-      lex_css('x ~ y').should == [
+      expect(lex_css('x ~ y')).to eq([
         [:T_IDENT, 'x'],
         [:T_TILDE, nil],
         [:T_IDENT, 'y']
-      ]
+      ])
     end
 
     it 'lexes the expression "x~y"' do
-      lex_css('x~y').should == lex_css('x ~ y')
+      expect(lex_css('x~y')).to eq(lex_css('x ~ y'))
     end
   end
 end
diff --git a/spec/oga/css/lexer/namespaces_spec.rb b/spec/oga/css/lexer/namespaces_spec.rb
index 2c881bf..58d8c6f 100644
--- a/spec/oga/css/lexer/namespaces_spec.rb
+++ b/spec/oga/css/lexer/namespaces_spec.rb
@@ -3,19 +3,19 @@ require 'spec_helper'
 describe Oga::CSS::Lexer do
   describe 'namespaces' do
     it 'lexes a path containing a namespace name' do
-      lex_css('foo|bar').should == [
+      expect(lex_css('foo|bar')).to eq([
         [:T_IDENT, 'foo'],
         [:T_PIPE, nil],
         [:T_IDENT, 'bar']
-      ]
+      ])
     end
 
     it 'lexes a path containing a namespace wildcard' do
-      lex_css('*|foo').should == [
+      expect(lex_css('*|foo')).to eq([
         [:T_IDENT, '*'],
         [:T_PIPE, nil],
         [:T_IDENT, 'foo']
-      ]
+      ])
     end
   end
 end
diff --git a/spec/oga/css/lexer/operators_spec.rb b/spec/oga/css/lexer/operators_spec.rb
index 6e37e21..767e01d 100644
--- a/spec/oga/css/lexer/operators_spec.rb
+++ b/spec/oga/css/lexer/operators_spec.rb
@@ -3,87 +3,87 @@ require 'spec_helper'
 describe Oga::CSS::Lexer do
   describe 'operators' do
     it 'lexes the = operator' do
-      lex_css('[foo="bar"]').should == [
+      expect(lex_css('[foo="bar"]')).to eq([
         [:T_LBRACK, nil],
         [:T_IDENT, 'foo'],
         [:T_EQ, nil],
         [:T_STRING, 'bar'],
         [:T_RBRACK, nil]
-      ]
+      ])
     end
 
     it 'lexes the ~= operator' do
-      lex_css('[foo~="bar"]').should == [
+      expect(lex_css('[foo~="bar"]')).to eq([
         [:T_LBRACK, nil],
         [:T_IDENT, 'foo'],
         [:T_SPACE_IN, nil],
         [:T_STRING, 'bar'],
         [:T_RBRACK, nil]
-      ]
+      ])
     end
 
     it 'lexes the ^= operator' do
-      lex_css('[foo^="bar"]').should == [
+      expect(lex_css('[foo^="bar"]')).to eq([
         [:T_LBRACK, nil],
         [:T_IDENT, 'foo'],
         [:T_STARTS_WITH, nil],
         [:T_STRING, 'bar'],
         [:T_RBRACK, nil]
-      ]
+      ])
     end
 
     it 'lexes the $= operator' do
-      lex_css('[foo$="bar"]').should == [
+      expect(lex_css('[foo$="bar"]')).to eq([
         [:T_LBRACK, nil],
         [:T_IDENT, 'foo'],
         [:T_ENDS_WITH, nil],
         [:T_STRING, 'bar'],
         [:T_RBRACK, nil],
-      ]
+      ])
     end
 
     it 'lexes the *= operator' do
-      lex_css('[foo*="bar"]').should == [
+      expect(lex_css('[foo*="bar"]')).to eq([
         [:T_LBRACK, nil],
         [:T_IDENT, 'foo'],
         [:T_IN, nil],
         [:T_STRING, 'bar'],
         [:T_RBRACK, nil]
-      ]
+      ])
     end
 
     it 'lexes the |= operator' do
-      lex_css('[foo|="bar"]').should == [
+      expect(lex_css('[foo|="bar"]')).to eq([
         [:T_LBRACK, nil],
         [:T_IDENT, 'foo'],
         [:T_HYPHEN_IN, nil],
         [:T_STRING, 'bar'],
         [:T_RBRACK, nil]
-      ]
+      ])
     end
 
     it 'lexes the = operator surrounded by whitespace' do
-      lex_css('[foo = "bar"]').should == lex_css('[foo="bar"]')
+      expect(lex_css('[foo = "bar"]')).to eq(lex_css('[foo="bar"]'))
     end
 
     it 'lexes the ~= operator surrounded by whitespace' do
-      lex_css('[foo ~= "bar"]').should == lex_css('[foo~="bar"]')
+      expect(lex_css('[foo ~= "bar"]')).to eq(lex_css('[foo~="bar"]'))
     end
 
     it 'lexes the ^= operator surrounded by whitespace' do
-      lex_css('[foo ^= "bar"]').should == lex_css('[foo^="bar"]')
+      expect(lex_css('[foo ^= "bar"]')).to eq(lex_css('[foo^="bar"]'))
     end
 
     it 'lexes the $= operator surrounded by whitespace' do
-      lex_css('[foo $= "bar"]').should == lex_css('[foo$="bar"]')
+      expect(lex_css('[foo $= "bar"]')).to eq(lex_css('[foo$="bar"]'))
     end
 
     it 'lexes the *= operator surrounded by whitespace' do
-      lex_css('[foo *= "bar"]').should == lex_css('[foo*="bar"]')
+      expect(lex_css('[foo *= "bar"]')).to eq(lex_css('[foo*="bar"]'))
     end
 
     it 'lexes the |= operator surrounded by whitespace' do
-      lex_css('[foo |= "bar"]').should == lex_css('[foo|="bar"]')
+      expect(lex_css('[foo |= "bar"]')).to eq(lex_css('[foo|="bar"]'))
     end
   end
 end
diff --git a/spec/oga/css/lexer/paths_spec.rb b/spec/oga/css/lexer/paths_spec.rb
index 3038bc2..225595c 100644
--- a/spec/oga/css/lexer/paths_spec.rb
+++ b/spec/oga/css/lexer/paths_spec.rb
@@ -5,73 +5,73 @@ require 'spec_helper'
 describe Oga::CSS::Lexer do
   describe 'paths' do
     it 'lexes a simple path' do
-      lex_css('h3').should == [[:T_IDENT, 'h3']]
+      expect(lex_css('h3')).to eq([[:T_IDENT, 'h3']])
     end
 
     it 'lexes a path with Unicode characters' do
-      lex_css('áâã').should == [[:T_IDENT, 'áâã']]
+      expect(lex_css('áâã')).to eq([[:T_IDENT, 'áâã']])
     end
 
     it 'lexes a path with Unicode and ASCII characters' do
-      lex_css('áâãfoo').should == [[:T_IDENT, 'áâãfoo']]
+      expect(lex_css('áâãfoo')).to eq([[:T_IDENT, 'áâãfoo']])
     end
 
     it 'lexes a simple path starting with an underscore' do
-      lex_css('_h3').should == [[:T_IDENT, '_h3']]
+      expect(lex_css('_h3')).to eq([[:T_IDENT, '_h3']])
     end
 
     it 'lexes a path with an escaped identifier' do
-      lex_css('foo\.bar\.baz').should == [[:T_IDENT, 'foo.bar.baz']]
+      expect(lex_css('foo\.bar\.baz')).to eq([[:T_IDENT, 'foo.bar.baz']])
     end
 
     it 'lexes a path with an escaped identifier followed by another identifier' do
-      lex_css('foo\.bar baz').should == [
+      expect(lex_css('foo\.bar baz')).to eq([
         [:T_IDENT, 'foo.bar'],
         [:T_SPACE, nil],
         [:T_IDENT, 'baz']
-      ]
+      ])
     end
 
     it 'lexes a path with two members' do
-      lex_css('div h3').should == [
+      expect(lex_css('div h3')).to eq([
         [:T_IDENT, 'div'],
         [:T_SPACE, nil],
         [:T_IDENT, 'h3']
-      ]
+      ])
     end
 
     it 'lexes a path with two members separated by multiple spaces' do
-      lex_css('div    h3').should == [
+      expect(lex_css('div    h3')).to eq([
         [:T_IDENT, 'div'],
         [:T_SPACE, nil],
         [:T_IDENT, 'h3']
-      ]
+      ])
     end
 
     it 'lexes two paths' do
-      lex_css('foo, bar').should == [
+      expect(lex_css('foo, bar')).to eq([
         [:T_IDENT, 'foo'],
         [:T_COMMA, nil],
         [:T_IDENT, 'bar']
-      ]
+      ])
     end
 
     it 'lexes a path selecting an ID' do
-      lex_css('#foo').should == [
+      expect(lex_css('#foo')).to eq([
         [:T_HASH, nil],
         [:T_IDENT, 'foo']
-      ]
+      ])
     end
 
     it 'lexes a path selecting a class' do
-      lex_css('.foo').should == [
+      expect(lex_css('.foo')).to eq([
         [:T_DOT, nil],
         [:T_IDENT, 'foo']
-      ]
+      ])
     end
 
     it 'lexes a wildcard path' do
-      lex_css('*').should == [[:T_IDENT, '*']]
+      expect(lex_css('*')).to eq([[:T_IDENT, '*']])
     end
   end
 end
diff --git a/spec/oga/css/lexer/predicates_spec.rb b/spec/oga/css/lexer/predicates_spec.rb
index 92d917c..f311689 100644
--- a/spec/oga/css/lexer/predicates_spec.rb
+++ b/spec/oga/css/lexer/predicates_spec.rb
@@ -3,12 +3,12 @@ require 'spec_helper'
 describe Oga::CSS::Lexer do
   describe 'predicates' do
     it 'lexes a path containing a simple predicate' do
-      lex_css('foo[bar]').should == [
+      expect(lex_css('foo[bar]')).to eq([
         [:T_IDENT, 'foo'],
         [:T_LBRACK, nil],
         [:T_IDENT, 'bar'],
         [:T_RBRACK, nil]
-      ]
+      ])
     end
   end
 end
diff --git a/spec/oga/css/lexer/pseudo_classes_spec.rb b/spec/oga/css/lexer/pseudo_classes_spec.rb
index c307fe0..b5ea2f9 100644
--- a/spec/oga/css/lexer/pseudo_classes_spec.rb
+++ b/spec/oga/css/lexer/pseudo_classes_spec.rb
@@ -3,86 +3,86 @@ require 'spec_helper'
 describe Oga::CSS::Lexer do
   describe 'pseudo classes' do
     it 'lexes the :root pseudo class' do
-      lex_css(':root').should == [
+      expect(lex_css(':root')).to eq([
         [:T_COLON, nil],
         [:T_IDENT, 'root']
-      ]
+      ])
     end
 
     it 'lexes the :nth-child pseudo class' do
-      lex_css(':nth-child(1)').should == [
+      expect(lex_css(':nth-child(1)')).to eq([
         [:T_COLON, nil],
         [:T_IDENT, 'nth-child'],
         [:T_LPAREN, nil],
         [:T_INT, 1],
         [:T_RPAREN, nil]
-      ]
+      ])
     end
 
     it 'lexes the :nth-child pseudo class with extra whitespace' do
-      lex_css(':nth-child(  1)').should == [
+      expect(lex_css(':nth-child(  1)')).to eq([
         [:T_COLON, nil],
         [:T_IDENT, 'nth-child'],
         [:T_LPAREN, nil],
         [:T_INT, 1],
         [:T_RPAREN, nil]
-      ]
+      ])
     end
 
     it 'lexes the :nth-child(odd) pseudo class' do
-      lex_css(':nth-child(odd)').should == [
+      expect(lex_css(':nth-child(odd)')).to eq([
         [:T_COLON, nil],
         [:T_IDENT, 'nth-child'],
         [:T_LPAREN, nil],
         [:T_ODD, nil],
         [:T_RPAREN, nil]
-      ]
+      ])
     end
 
     it 'lexes the :nth-child(even) pseudo class' do
-      lex_css(':nth-child(even)').should == [
+      expect(lex_css(':nth-child(even)')).to eq([
         [:T_COLON, nil],
         [:T_IDENT, 'nth-child'],
         [:T_LPAREN, nil],
         [:T_EVEN, nil],
         [:T_RPAREN, nil]
-      ]
+      ])
     end
 
     it 'lexes the :nth-child(n) pseudo class' do
-      lex_css(':nth-child(n)').should == [
+      expect(lex_css(':nth-child(n)')).to eq([
         [:T_COLON, nil],
         [:T_IDENT, 'nth-child'],
         [:T_LPAREN, nil],
         [:T_NTH, nil],
         [:T_RPAREN, nil]
-      ]
+      ])
     end
 
     it 'lexes the :nth-child(-n) pseudo class' do
-      lex_css(':nth-child(-n)').should == [
+      expect(lex_css(':nth-child(-n)')).to eq([
         [:T_COLON, nil],
         [:T_IDENT, 'nth-child'],
         [:T_LPAREN, nil],
         [:T_MINUS, nil],
         [:T_NTH, nil],
         [:T_RPAREN, nil]
-      ]
+      ])
     end
 
     it 'lexes the :nth-child(2n) pseudo class' do
-      lex_css(':nth-child(2n)').should == [
+      expect(lex_css(':nth-child(2n)')).to eq([
         [:T_COLON, nil],
         [:T_IDENT, 'nth-child'],
         [:T_LPAREN, nil],
         [:T_INT, 2],
         [:T_NTH, nil],
         [:T_RPAREN, nil]
-      ]
+      ])
     end
 
     it 'lexes the :nth-child(2n+1) pseudo class' do
-      lex_css(':nth-child(2n+1)').should == [
+      expect(lex_css(':nth-child(2n+1)')).to eq([
         [:T_COLON, nil],
         [:T_IDENT, 'nth-child'],
         [:T_LPAREN, nil],
@@ -90,11 +90,11 @@ describe Oga::CSS::Lexer do
         [:T_NTH, nil],
         [:T_INT, 1],
         [:T_RPAREN, nil]
-      ]
+      ])
     end
 
     it 'lexes the :nth-child(2n-1) pseudo class' do
-      lex_css(':nth-child(2n-1)').should == [
+      expect(lex_css(':nth-child(2n-1)')).to eq([
         [:T_COLON, nil],
         [:T_IDENT, 'nth-child'],
         [:T_LPAREN, nil],
@@ -102,11 +102,11 @@ describe Oga::CSS::Lexer do
         [:T_NTH, nil],
         [:T_INT, -1],
         [:T_RPAREN, nil]
-      ]
+      ])
     end
 
     it 'lexes the :nth-child(-2n-1) pseudo class' do
-      lex_css(':nth-child(-2n-1)').should == [
+      expect(lex_css(':nth-child(-2n-1)')).to eq([
         [:T_COLON, nil],
         [:T_IDENT, 'nth-child'],
         [:T_LPAREN, nil],
@@ -114,28 +114,28 @@ describe Oga::CSS::Lexer do
         [:T_NTH, nil],
         [:T_INT, -1],
         [:T_RPAREN, nil]
-      ]
+      ])
     end
 
     it 'lexes the :lang(fr) pseudo class' do
-      lex_css(':lang(fr)').should == [
+      expect(lex_css(':lang(fr)')).to eq([
         [:T_COLON, nil],
         [:T_IDENT, 'lang'],
         [:T_LPAREN, nil],
         [:T_IDENT, 'fr'],
         [:T_RPAREN, nil]
-      ]
+      ])
     end
 
     it 'lexes the :not(#foo) pseudo class' do
-      lex_css(':not(#foo)').should == [
+      expect(lex_css(':not(#foo)')).to eq([
         [:T_COLON, nil],
         [:T_IDENT, 'not'],
         [:T_LPAREN, nil],
         [:T_HASH, nil],
         [:T_IDENT, 'foo'],
         [:T_RPAREN, nil]
-      ]
+      ])
     end
   end
 end
diff --git a/spec/oga/css/lexer/strings_spec.rb b/spec/oga/css/lexer/strings_spec.rb
index 1c782f5..e91e018 100644
--- a/spec/oga/css/lexer/strings_spec.rb
+++ b/spec/oga/css/lexer/strings_spec.rb
@@ -3,19 +3,19 @@ require 'spec_helper'
 describe Oga::CSS::Lexer do
   describe 'strings' do
     it 'lexes a single quoted string' do
-      lex_css("['foo']").should == [
+      expect(lex_css("['foo']")).to eq([
         [:T_LBRACK, nil],
         [:T_STRING, 'foo'],
         [:T_RBRACK, nil]
-      ]
+      ])
     end
 
     it 'lexes a double quoted string' do
-      lex_css('["foo"]').should == [
+      expect(lex_css('["foo"]')).to eq([
         [:T_LBRACK, nil],
         [:T_STRING, 'foo'],
         [:T_RBRACK, nil]
-      ]
+      ])
     end
   end
 end
diff --git a/spec/oga/css/parser/axes_spec.rb b/spec/oga/css/parser/axes_spec.rb
index d09cbfd..5b7a0fb 100644
--- a/spec/oga/css/parser/axes_spec.rb
+++ b/spec/oga/css/parser/axes_spec.rb
@@ -3,72 +3,72 @@ require 'spec_helper'
 describe Oga::CSS::Parser do
   describe 'axes' do
     it 'parses the > axis' do
-      parse_css('x > y').should == parse_xpath('descendant::x/y')
+      expect(parse_css('x > y')).to eq(parse_xpath('descendant::x/y'))
     end
 
     it 'parses the > axis without whitespace' do
-      parse_css('x>y').should == parse_css('x > y')
+      expect(parse_css('x>y')).to eq(parse_css('x > y'))
     end
 
     it 'parses the > axis called on another > axis' do
-      parse_css('a > b > c').should == parse_xpath('descendant::a/b/c')
+      expect(parse_css('a > b > c')).to eq(parse_xpath('descendant::a/b/c'))
     end
 
     it 'parses an > axis followed by an element with an ID' do
-      parse_css('x > foo#bar').should == parse_xpath(
+      expect(parse_css('x > foo#bar')).to eq(parse_xpath(
         'descendant::x/foo[@id="bar"]'
-      )
+      ))
     end
 
     it 'parses an > axis followed by an element with a class' do
-      parse_css('x > foo.bar').should == parse_xpath(
+      expect(parse_css('x > foo.bar')).to eq(parse_xpath(
         'descendant::x/foo[contains(concat(" ", @class, " "), " bar ")]'
-      )
+      ))
     end
 
     it 'parses the + axis' do
-      parse_css('x + y').should == parse_xpath(
+      expect(parse_css('x + y')).to eq(parse_xpath(
         'descendant::x/following-sibling::*[1]/self::y'
-      )
+      ))
     end
 
     it 'parses the + axis without whitespace' do
-      parse_css('x+y').should == parse_css('x + y')
+      expect(parse_css('x+y')).to eq(parse_css('x + y'))
     end
 
     it 'parses the + axis with an identifier only at the right-hand side' do
-      parse_css('+ y').should == parse_xpath(
+      expect(parse_css('+ y')).to eq(parse_xpath(
         'following-sibling::*[1]/self::y'
-      )
+      ))
     end
 
     it 'parses the + axis called on another + axis' do
-      parse_css('a + b + c').should == parse_xpath(
+      expect(parse_css('a + b + c')).to eq(parse_xpath(
         'descendant::a/following-sibling::*[1]/self::b/' \
           'following-sibling::*[1]/self::c'
-      )
+      ))
     end
 
     it 'parses the ~ axis' do
-      parse_css('x ~ y').should == parse_xpath(
+      expect(parse_css('x ~ y')).to eq(parse_xpath(
         'descendant::x/following-sibling::y'
-      )
+      ))
     end
 
     it 'parses the ~ axis without whitespace' do
-      parse_css('x~y').should == parse_css('x ~ y')
+      expect(parse_css('x~y')).to eq(parse_css('x ~ y'))
     end
 
     it 'parses the ~ axis followed by another node test' do
-      parse_css('x ~ y z').should == parse_xpath(
+      expect(parse_css('x ~ y z')).to eq(parse_xpath(
         'descendant::x/following-sibling::y/descendant::z'
-      )
+      ))
     end
 
     it 'parses the ~ axis called on another ~ axis' do
-      parse_css('a ~ b ~ c').should == parse_xpath(
+      expect(parse_css('a ~ b ~ c')).to eq(parse_xpath(
         'descendant::a/following-sibling::b/following-sibling::c'
-      )
+      ))
     end
   end
 end
diff --git a/spec/oga/css/parser/cache_spec.rb b/spec/oga/css/parser/cache_spec.rb
index 4ddbad2..c84e884 100644
--- a/spec/oga/css/parser/cache_spec.rb
+++ b/spec/oga/css/parser/cache_spec.rb
@@ -7,21 +7,21 @@ describe Oga::CSS::Parser do
     end
 
     it 'parses an expression' do
-      described_class.parse_with_cache('foo')
-        .should == s(:axis, 'descendant', s(:test, nil, 'foo'))
+      expect(described_class.parse_with_cache('foo'))
+        .to eq(s(:axis, 'descendant', s(:test, nil, 'foo')))
     end
 
     it 'caches an expression after parsing it' do
-      described_class.any_instance
-        .should_receive(:parse)
+      expect_any_instance_of(described_class)
+        .to receive(:parse)
         .once
         .and_call_original
 
-      described_class.parse_with_cache('foo')
-        .should == s(:axis, 'descendant', s(:test, nil, 'foo'))
+      expect(described_class.parse_with_cache('foo'))
+        .to eq(s(:axis, 'descendant', s(:test, nil, 'foo')))
 
-      described_class.parse_with_cache('foo')
-        .should == s(:axis, 'descendant', s(:test, nil, 'foo'))
+      expect(described_class.parse_with_cache('foo'))
+        .to eq(s(:axis, 'descendant', s(:test, nil, 'foo')))
     end
   end
 end
diff --git a/spec/oga/css/parser/classes_spec.rb b/spec/oga/css/parser/classes_spec.rb
index 1bd41ff..42063d8 100644
--- a/spec/oga/css/parser/classes_spec.rb
+++ b/spec/oga/css/parser/classes_spec.rb
@@ -3,29 +3,29 @@ require 'spec_helper'
 describe Oga::CSS::Parser do
   describe 'classes' do
     it 'parses a class selector' do
-      parse_css('.foo').should == parse_xpath(
+      expect(parse_css('.foo')).to eq(parse_xpath(
         'descendant::*[contains(concat(" ", @class, " "), " foo ")]'
-      )
+      ))
     end
 
     it 'parses a selector for an element with a class' do
-      parse_css('foo.bar').should == parse_xpath(
+      expect(parse_css('foo.bar')).to eq(parse_xpath(
         'descendant::foo[contains(concat(" ", @class, " "), " bar ")]'
-      )
+      ))
     end
 
     it 'parses a selector using multiple classes' do
-      parse_css('.foo.bar').should == parse_xpath(
+      expect(parse_css('.foo.bar')).to eq(parse_xpath(
         'descendant::*[contains(concat(" ", @class, " "), " foo ") ' \
           'and contains(concat(" ", @class, " "), " bar ")]'
-      )
+      ))
     end
 
     it 'parses a selector using a class and an ID' do
-      parse_css('#foo.bar').should == parse_xpath(
+      expect(parse_css('#foo.bar')).to eq(parse_xpath(
         'descendant::*[@id="foo" and ' \
           'contains(concat(" ", @class, " "), " bar ")]'
-      )
+      ))
     end
   end
 end
diff --git a/spec/oga/css/parser/ids_spec.rb b/spec/oga/css/parser/ids_spec.rb
index 63f53f7..c6eeaef 100644
--- a/spec/oga/css/parser/ids_spec.rb
+++ b/spec/oga/css/parser/ids_spec.rb
@@ -3,24 +3,24 @@ require 'spec_helper'
 describe Oga::CSS::Parser do
   describe 'IDs' do
     it 'parses an ID selector' do
-      parse_css('#foo').should == parse_xpath('descendant::*[@id="foo"]')
+      expect(parse_css('#foo')).to eq(parse_xpath('descendant::*[@id="foo"]'))
     end
 
     it 'parses a selector for an element with an ID' do
-      parse_css('foo#bar').should == parse_xpath('descendant::foo[@id="bar"]')
+      expect(parse_css('foo#bar')).to eq(parse_xpath('descendant::foo[@id="bar"]'))
     end
 
     it 'parses a selector using multiple IDs' do
-      parse_css('#foo#bar').should == parse_xpath(
+      expect(parse_css('#foo#bar')).to eq(parse_xpath(
         'descendant::*[@id="foo" and @id="bar"]'
-      )
+      ))
     end
 
     it 'parses a selector using an ID and a class' do
-      parse_css('.foo#bar').should == parse_xpath(
+      expect(parse_css('.foo#bar')).to eq(parse_xpath(
         'descendant::*[contains(concat(" ", @class, " "), " foo ") ' \
           'and @id="bar"]'
-      )
+      ))
     end
   end
 end
diff --git a/spec/oga/css/parser/operators_spec.rb b/spec/oga/css/parser/operators_spec.rb
index 4dfb4fc..e2f8e84 100644
--- a/spec/oga/css/parser/operators_spec.rb
+++ b/spec/oga/css/parser/operators_spec.rb
@@ -3,39 +3,39 @@ require 'spec_helper'
 describe Oga::CSS::Parser do
   describe 'operators' do
     it 'parses the = operator' do
-      parse_css('x[a="b"]').should == parse_xpath('descendant::x[@a="b"]')
+      expect(parse_css('x[a="b"]')).to eq(parse_xpath('descendant::x[@a="b"]'))
     end
 
     it 'parses the ~= operator' do
-      parse_css('x[a~="b"]').should == parse_xpath(
+      expect(parse_css('x[a~="b"]')).to eq(parse_xpath(
         'descendant::x[contains(concat(" ", @a, " "), ' \
           'concat(" ", "b", " "))]'
-      )
+      ))
     end
 
     it 'parses the ^= operator' do
-      parse_css('x[a^="b"]').should == parse_xpath(
+      expect(parse_css('x[a^="b"]')).to eq(parse_xpath(
         'descendant::x[starts-with(@a, "b")]'
-      )
+      ))
     end
 
     it 'parses the $= operator' do
-      parse_css('x[a$="b"]').should == parse_xpath(
+      expect(parse_css('x[a$="b"]')).to eq(parse_xpath(
         'descendant::x[substring(@a, string-length(@a) - ' \
           'string-length("b") + 1, string-length("b")) = "b"]'
-      )
+      ))
     end
 
     it 'parses the *= operator' do
-      parse_css('x[a*="b"]').should == parse_xpath(
+      expect(parse_css('x[a*="b"]')).to eq(parse_xpath(
         'descendant::x[contains(@a, "b")]'
-      )
+      ))
     end
 
     it 'parses the |= operator' do
-      parse_css('x[a|="b"]').should == parse_xpath(
+      expect(parse_css('x[a|="b"]')).to eq(parse_xpath(
         'descendant::x[@a = "b" or starts-with(@a, concat("b", "-"))]'
-      )
+      ))
     end
   end
 end
diff --git a/spec/oga/css/parser/paths_spec.rb b/spec/oga/css/parser/paths_spec.rb
index 5307050..7273a9a 100644
--- a/spec/oga/css/parser/paths_spec.rb
+++ b/spec/oga/css/parser/paths_spec.rb
@@ -3,26 +3,29 @@ require 'spec_helper'
 describe Oga::CSS::Parser do
   describe 'paths' do
     it 'parses a single path' do
-      parse_css('foo').should == parse_xpath('descendant::foo')
+      expect(parse_css('foo')).to eq(parse_xpath('descendant::foo'))
     end
 
     it 'parses a path using a namespace' do
-      parse_css('ns|foo').should == parse_xpath('descendant::ns:foo')
+      expect(parse_css('ns|foo')).to eq(parse_xpath('descendant::ns:foo'))
     end
 
     it 'parses a path using two selectors' do
-      parse_css('foo bar').should ==
+      expect(parse_css('foo bar')).to eq(
         parse_xpath('descendant::foo/descendant::bar')
+      )
     end
 
     it 'parses two paths separated by a comma' do
-      parse_css('foo, bar').should ==
+      expect(parse_css('foo, bar')).to eq(
         parse_xpath('descendant::foo | descendant::bar')
+      )
     end
 
     it 'parses three paths separated by a comma' do
-      parse_css('foo, bar, baz').should ==
+      expect(parse_css('foo, bar, baz')).to eq(
         parse_xpath('descendant::foo | descendant::bar | descendant::baz')
+      )
     end
   end
 end
diff --git a/spec/oga/css/parser/predicates_spec.rb b/spec/oga/css/parser/predicates_spec.rb
index 1f558db..0a4be39 100644
--- a/spec/oga/css/parser/predicates_spec.rb
+++ b/spec/oga/css/parser/predicates_spec.rb
@@ -3,19 +3,19 @@ require 'spec_helper'
 describe Oga::CSS::Parser do
   describe 'predicates' do
     it 'parses a predicate' do
-      parse_css('foo[bar]').should == parse_xpath('descendant::foo[@bar]')
+      expect(parse_css('foo[bar]')).to eq(parse_xpath('descendant::foo[@bar]'))
     end
 
     it 'parses a node test followed by a node test with a predicate' do
-      parse_css('foo bar[baz]').should == parse_xpath(
+      expect(parse_css('foo bar[baz]')).to eq(parse_xpath(
         'descendant::foo/descendant::bar[@baz]'
-      )
+      ))
     end
 
     it 'parses a predicate testing an attribute value' do
-      parse_css('foo[bar="baz"]').should == parse_xpath(
+      expect(parse_css('foo[bar="baz"]')).to eq(parse_xpath(
         'descendant::foo[@bar="baz"]'
-      )
+      ))
     end
   end
 end
diff --git a/spec/oga/css/parser/pseudo_classes/empty_spec.rb b/spec/oga/css/parser/pseudo_classes/empty_spec.rb
index c5e5f62..d5a2d98 100644
--- a/spec/oga/css/parser/pseudo_classes/empty_spec.rb
+++ b/spec/oga/css/parser/pseudo_classes/empty_spec.rb
@@ -3,7 +3,7 @@ require 'spec_helper'
 describe Oga::CSS::Parser do
   describe ':empty pseudo class' do
     it 'parses the :empty pseudo class' do
-      parse_css(':empty').should == parse_xpath('descendant::*[not(node())]')
+      expect(parse_css(':empty')).to eq(parse_xpath('descendant::*[not(node())]'))
     end
   end
 end
diff --git a/spec/oga/css/parser/pseudo_classes/first_child_spec.rb b/spec/oga/css/parser/pseudo_classes/first_child_spec.rb
index c878907..b801f02 100644
--- a/spec/oga/css/parser/pseudo_classes/first_child_spec.rb
+++ b/spec/oga/css/parser/pseudo_classes/first_child_spec.rb
@@ -3,9 +3,9 @@ require 'spec_helper'
 describe Oga::CSS::Parser do
   describe ':first-child pseudo class' do
     it 'parses the :first-child pseudo class' do
-      parse_css(':first-child').should == parse_xpath(
+      expect(parse_css(':first-child')).to eq(parse_xpath(
         'descendant::*[count(preceding-sibling::*) = 0]'
-      )
+      ))
     end
   end
 end
diff --git a/spec/oga/css/parser/pseudo_classes/first_of_type_spec.rb b/spec/oga/css/parser/pseudo_classes/first_of_type_spec.rb
index fb0225b..f91f8da 100644
--- a/spec/oga/css/parser/pseudo_classes/first_of_type_spec.rb
+++ b/spec/oga/css/parser/pseudo_classes/first_of_type_spec.rb
@@ -3,15 +3,15 @@ require 'spec_helper'
 describe Oga::CSS::Parser do
   describe ':first-of-type pseudo class' do
     it 'parses the :first-of-type pseudo class' do
-      parse_css(':first-of-type').should == parse_xpath(
+      expect(parse_css(':first-of-type')).to eq(parse_xpath(
         'descendant::*[count(preceding-sibling::*) = 0]'
-      )
+      ))
     end
 
     it 'parses the a:first-of-type pseudo class' do
-      parse_css('a:first-of-type').should == parse_xpath(
+      expect(parse_css('a:first-of-type')).to eq(parse_xpath(
         'descendant::a[count(preceding-sibling::a) = 0]'
-      )
+      ))
     end
   end
 end
diff --git a/spec/oga/css/parser/pseudo_classes/last_child_spec.rb b/spec/oga/css/parser/pseudo_classes/last_child_spec.rb
index 8201c31..3c0cdb0 100644
--- a/spec/oga/css/parser/pseudo_classes/last_child_spec.rb
+++ b/spec/oga/css/parser/pseudo_classes/last_child_spec.rb
@@ -3,9 +3,9 @@ require 'spec_helper'
 describe Oga::CSS::Parser do
   describe ':last-child pseudo class' do
     it 'parses the :last-child pseudo class' do
-      parse_css(':last-child').should == parse_xpath(
+      expect(parse_css(':last-child')).to eq(parse_xpath(
         'descendant::*[count(following-sibling::*) = 0]'
-      )
+      ))
     end
   end
 end
diff --git a/spec/oga/css/parser/pseudo_classes/last_of_type_spec.rb b/spec/oga/css/parser/pseudo_classes/last_of_type_spec.rb
index f38ed62..585f6b9 100644
--- a/spec/oga/css/parser/pseudo_classes/last_of_type_spec.rb
+++ b/spec/oga/css/parser/pseudo_classes/last_of_type_spec.rb
@@ -3,15 +3,15 @@ require 'spec_helper'
 describe Oga::CSS::Parser do
   describe ':last-of-type pseudo class' do
     it 'parses the :last-of-type pseudo class' do
-      parse_css(':last-of-type').should == parse_xpath(
+      expect(parse_css(':last-of-type')).to eq(parse_xpath(
         'descendant::*[count(following-sibling::*) = 0]'
-      )
+      ))
     end
 
     it 'parses the a:last-of-type pseudo class' do
-      parse_css('a:last-of-type').should == parse_xpath(
+      expect(parse_css('a:last-of-type')).to eq(parse_xpath(
         'descendant::a[count(following-sibling::a) = 0]'
-      )
+      ))
     end
   end
 end
diff --git a/spec/oga/css/parser/pseudo_classes/not_spec.rb b/spec/oga/css/parser/pseudo_classes/not_spec.rb
index 79871fb..e3b9945 100644
--- a/spec/oga/css/parser/pseudo_classes/not_spec.rb
+++ b/spec/oga/css/parser/pseudo_classes/not_spec.rb
@@ -3,16 +3,17 @@ require 'spec_helper'
 describe Oga::CSS::Parser do
   describe ':not pseudo class' do
     it 'parses the :not(x) pseudo class' do
-      parse_css(':not(x)').should == parse_xpath('descendant::*[not(self::x)]')
+      expect(parse_css(':not(x)')).to eq(parse_xpath('descendant::*[not(self::x)]'))
     end
 
     it 'parses the x:not(y) pseudo class' do
-      parse_css('x:not(y)').should == parse_xpath('descendant::x[not(self::y)]')
+      expect(parse_css('x:not(y)')).to eq(parse_xpath('descendant::x[not(self::y)]'))
     end
 
     it 'parses the x:not(#foo) pseudo class' do
-      parse_css('x:not(#foo)').should ==
+      expect(parse_css('x:not(#foo)')).to eq(
         parse_xpath('descendant::x[not(@id="foo")]')
+      )
     end
   end
 end
diff --git a/spec/oga/css/parser/pseudo_classes/nth_child_spec.rb b/spec/oga/css/parser/pseudo_classes/nth_child_spec.rb
index ce20be4..839e4ca 100644
--- a/spec/oga/css/parser/pseudo_classes/nth_child_spec.rb
+++ b/spec/oga/css/parser/pseudo_classes/nth_child_spec.rb
@@ -3,92 +3,92 @@ require 'spec_helper'
 describe Oga::CSS::Parser do
   describe ':nth-child pseudo class' do
     it 'parses the x:nth-child(1) pseudo class' do
-      parse_css('x:nth-child(1)').should == parse_xpath(
+      expect(parse_css('x:nth-child(1)')).to eq(parse_xpath(
         'descendant::x[count(preceding-sibling::*) = 0]'
-      )
+      ))
     end
 
     it 'parses the :nth-child(1) pseudo class' do
-      parse_css(':nth-child(1)').should == parse_xpath(
+      expect(parse_css(':nth-child(1)')).to eq(parse_xpath(
         'descendant::*[count(preceding-sibling::*) = 0]'
-      )
+      ))
     end
 
     it 'parses the :nth-child(2) pseudo class' do
-      parse_css(':nth-child(2)').should == parse_xpath(
+      expect(parse_css(':nth-child(2)')).to eq(parse_xpath(
         'descendant::*[count(preceding-sibling::*) = 1]'
-      )
+      ))
     end
 
     it 'parses the x:nth-child(even) pseudo class' do
-      parse_css('x:nth-child(even)').should == parse_xpath(
+      expect(parse_css('x:nth-child(even)')).to eq(parse_xpath(
         'descendant::x[((count(preceding-sibling::*) + 1) mod 2) = 0]'
-      )
+      ))
     end
 
     it 'parses the x:nth-child(odd) pseudo class' do
-      parse_css('x:nth-child(odd)').should == parse_xpath(
+      expect(parse_css('x:nth-child(odd)')).to eq(parse_xpath(
         'descendant::x[(count(preceding-sibling::*) + 1) >= 1 ' \
           'and (((count(preceding-sibling::*) + 1) - 1) mod 2) = 0]'
-      )
+      ))
     end
 
     it 'parses the x:nth-child(n) pseudo class' do
-      parse_css('x:nth-child(n)').should == parse_xpath(
+      expect(parse_css('x:nth-child(n)')).to eq(parse_xpath(
         'descendant::x[((count(preceding-sibling::*) + 1) mod 1) = 0]'
-      )
+      ))
     end
 
     it 'parses the x:nth-child(-n) pseudo class' do
-      parse_css('x:nth-child(-n)').should == parse_xpath(
+      expect(parse_css('x:nth-child(-n)')).to eq(parse_xpath(
         'descendant::x[((count(preceding-sibling::*) + 1) mod 1) = 0]'
-      )
+      ))
     end
 
     it 'parses the x:nth-child(-n+6) pseudo class' do
-      parse_css('x:nth-child(-n+6)').should == parse_xpath(
+      expect(parse_css('x:nth-child(-n+6)')).to eq(parse_xpath(
         'descendant::x[((count(preceding-sibling::*) + 1) <= 6) ' \
           'and (((count(preceding-sibling::*) + 1) - 6) mod 1) = 0]'
-      )
+      ))
     end
 
     it 'parses the x:nth-child(n+5) pseudo class' do
-      parse_css('x:nth-child(n+5)').should == parse_xpath(
+      expect(parse_css('x:nth-child(n+5)')).to eq(parse_xpath(
         'descendant::x[(count(preceding-sibling::*) + 1) >= 5 ' \
           'and (((count(preceding-sibling::*) + 1) - 5) mod 1) = 0]'
-      )
+      ))
     end
 
     it 'parses the x:nth-child(2n) pseudo class' do
-      parse_css('x:nth-child(2n)').should == parse_css('x:nth-child(even)')
+      expect(parse_css('x:nth-child(2n)')).to eq(parse_css('x:nth-child(even)'))
     end
 
     it 'parses the x:nth-child(2n+1) pseudo class' do
-      parse_css('x:nth-child(2n+1)').should == parse_xpath(
+      expect(parse_css('x:nth-child(2n+1)')).to eq(parse_xpath(
         'descendant::x[(count(preceding-sibling::*) + 1) >= 1 ' \
           'and (((count(preceding-sibling::*) + 1) - 1) mod 2) = 0]'
-      )
+      ))
     end
 
     it 'parses the x:nth-child(3n+1) pseudo class' do
-      parse_css('x:nth-child(3n+1)').should == parse_xpath(
+      expect(parse_css('x:nth-child(3n+1)')).to eq(parse_xpath(
         'descendant::x[(count(preceding-sibling::*) + 1) >= 1 ' \
           'and (((count(preceding-sibling::*) + 1) - 1) mod 3) = 0]'
-      )
+      ))
     end
 
     it 'parses the x:nth-child(2n-6) pseudo class' do
-      parse_css('x:nth-child(2n-6)').should == parse_xpath(
+      expect(parse_css('x:nth-child(2n-6)')).to eq(parse_xpath(
         'descendant::x[(count(preceding-sibling::*) + 1) >= 2 ' \
           'and (((count(preceding-sibling::*) + 1) - 2) mod 2) = 0]'
-      )
+      ))
     end
 
     it 'parses the x:nth-child(-2n+6) pseudo class' do
-      parse_css('x:nth-child(-2n+6)').should == parse_xpath(
+      expect(parse_css('x:nth-child(-2n+6)')).to eq(parse_xpath(
         'descendant::x[((count(preceding-sibling::*) + 1) <= 6) ' \
           'and (((count(preceding-sibling::*) + 1) - 6) mod 2) = 0]'
-      )
+      ))
     end
   end
 end
diff --git a/spec/oga/css/parser/pseudo_classes/nth_last_child_spec.rb b/spec/oga/css/parser/pseudo_classes/nth_last_child_spec.rb
index e9aeaa6..6af7127 100644
--- a/spec/oga/css/parser/pseudo_classes/nth_last_child_spec.rb
+++ b/spec/oga/css/parser/pseudo_classes/nth_last_child_spec.rb
@@ -3,87 +3,87 @@ require 'spec_helper'
 describe Oga::CSS::Parser do
   describe ':nth-last-child pseudo class' do
     it 'parses the x:nth-last-child(1) pseudo class' do
-      parse_css('x:nth-last-child(1)').should == parse_xpath(
+      expect(parse_css('x:nth-last-child(1)')).to eq(parse_xpath(
         'descendant::x[count(following-sibling::*) = 0]'
-      )
+      ))
     end
 
     it 'parses the :nth-last-child(1) pseudo class' do
-      parse_css(':nth-last-child(1)').should == parse_xpath(
+      expect(parse_css(':nth-last-child(1)')).to eq(parse_xpath(
         'descendant::*[count(following-sibling::*) = 0]'
-      )
+      ))
     end
 
     it 'parses the :nth-last-child(2) pseudo class' do
-      parse_css(':nth-last-child(2)').should == parse_xpath(
+      expect(parse_css(':nth-last-child(2)')).to eq(parse_xpath(
         'descendant::*[count(following-sibling::*) = 1]'
-      )
+      ))
     end
 
     it 'parses the x:nth-last-child(even) pseudo class' do
-      parse_css('x:nth-last-child(even)').should == parse_xpath(
+      expect(parse_css('x:nth-last-child(even)')).to eq(parse_xpath(
         'descendant::x[((count(following-sibling::*) + 1) mod 2) = 0]'
-      )
+      ))
     end
 
     it 'parses the x:nth-last-child(odd) pseudo class' do
-      parse_css('x:nth-last-child(odd)').should == parse_xpath(
+      expect(parse_css('x:nth-last-child(odd)')).to eq(parse_xpath(
         'descendant::x[(count(following-sibling::*) + 1) >= 1 ' \
           'and (((count(following-sibling::*) + 1) - 1) mod 2) = 0]'
-      )
+      ))
     end
 
     it 'parses the x:nth-last-child(n) pseudo class' do
-      parse_css('x:nth-last-child(n)').should == parse_xpath(
+      expect(parse_css('x:nth-last-child(n)')).to eq(parse_xpath(
         'descendant::x[((count(following-sibling::*) + 1) mod 1) = 0]'
-      )
+      ))
     end
 
     it 'parses the x:nth-last-child(-n) pseudo class' do
-      parse_css('x:nth-last-child(-n)').should == parse_xpath(
+      expect(parse_css('x:nth-last-child(-n)')).to eq(parse_xpath(
         'descendant::x[((count(following-sibling::*) + 1) mod 1) = 0]'
-      )
+      ))
     end
 
     it 'parses the x:nth-last-child(-n+6) pseudo class' do
-      parse_css('x:nth-last-child(-n+6)').should == parse_xpath(
+      expect(parse_css('x:nth-last-child(-n+6)')).to eq(parse_xpath(
         'descendant::x[((count(following-sibling::*) + 1) <= 6) ' \
           'and (((count(following-sibling::*) + 1) - 6) mod 1) = 0]'
-      )
+      ))
     end
 
     it 'parses the x:nth-last-child(2n) pseudo class' do
-      parse_css('x:nth-last-child(2n)').should == parse_css(
+      expect(parse_css('x:nth-last-child(2n)')).to eq(parse_css(
         'x:nth-last-child(even)'
-      )
+      ))
     end
 
     it 'parses the x:nth-last-child(2n+1) pseudo class' do
-      parse_css('x:nth-last-child(2n+1)').should == parse_xpath(
+      expect(parse_css('x:nth-last-child(2n+1)')).to eq(parse_xpath(
         'descendant::x[(count(following-sibling::*) + 1) >= 1 ' \
           'and (((count(following-sibling::*) + 1) - 1) mod 2) = 0]'
-      )
+      ))
     end
 
     it 'parses the x:nth-last-child(2n-6) pseudo class' do
-      parse_css('x:nth-last-child(2n-6)').should == parse_xpath(
+      expect(parse_css('x:nth-last-child(2n-6)')).to eq(parse_xpath(
         'descendant::x[(count(following-sibling::*) + 1) >= 2 ' \
           'and (((count(following-sibling::*) + 1) - 2) mod 2) = 0]'
-      )
+      ))
     end
 
     it 'parses the x:nth-last-child(-2n-6) pseudo class' do
-      parse_css('x:nth-last-child(-2n-6)').should == parse_xpath(
+      expect(parse_css('x:nth-last-child(-2n-6)')).to eq(parse_xpath(
         'descendant::x[((count(following-sibling::*) + 1) <= -2) ' \
           'and (((count(following-sibling::*) + 1) - -2) mod 2) = 0]'
-      )
+      ))
     end
 
     it 'parses the x:nth-last-child(-2n+6) pseudo class' do
-      parse_css('x:nth-last-child(-2n+6)').should == parse_xpath(
+      expect(parse_css('x:nth-last-child(-2n+6)')).to eq(parse_xpath(
         'descendant::x[((count(following-sibling::*) + 1) <= 6) ' \
           'and (((count(following-sibling::*) + 1) - 6) mod 2) = 0]'
-      )
+      ))
     end
   end
 end
diff --git a/spec/oga/css/parser/pseudo_classes/nth_last_of_type_spec.rb b/spec/oga/css/parser/pseudo_classes/nth_last_of_type_spec.rb
index 22f3d3d..34c7a16 100644
--- a/spec/oga/css/parser/pseudo_classes/nth_last_of_type_spec.rb
+++ b/spec/oga/css/parser/pseudo_classes/nth_last_of_type_spec.rb
@@ -3,93 +3,93 @@ require 'spec_helper'
 describe Oga::CSS::Parser do
   describe ':nth-last-of-type pseudo class' do
     it 'parses the x:nth-last-of-type(1) pseudo class' do
-      parse_css('x:nth-last-of-type(1)').should == parse_xpath(
+      expect(parse_css('x:nth-last-of-type(1)')).to eq(parse_xpath(
         'descendant::x[count(following-sibling::x) = 0]'
-      )
+      ))
     end
 
     it 'parses the :nth-last-of-type(1) pseudo class' do
-      parse_css(':nth-last-of-type(1)').should == parse_xpath(
+      expect(parse_css(':nth-last-of-type(1)')).to eq(parse_xpath(
         'descendant::*[count(following-sibling::*) = 0]'
-      )
+      ))
     end
 
     it 'parses the :nth-last-of-type(2) pseudo class' do
-      parse_css(':nth-last-of-type(2)').should == parse_xpath(
+      expect(parse_css(':nth-last-of-type(2)')).to eq(parse_xpath(
         'descendant::*[count(following-sibling::*) = 1]'
-      )
+      ))
     end
 
     it 'parses the x:nth-last-of-type(even) pseudo class' do
-      parse_css('x:nth-last-of-type(even)').should == parse_xpath(
+      expect(parse_css('x:nth-last-of-type(even)')).to eq(parse_xpath(
         'descendant::x[((count(following-sibling::x) + 1) mod 2) = 0]'
-      )
+      ))
     end
 
     it 'parses the x:nth-last-of-type(odd) pseudo class' do
-      parse_css('x:nth-last-of-type(odd)').should == parse_xpath(
+      expect(parse_css('x:nth-last-of-type(odd)')).to eq(parse_xpath(
         'descendant::x[(count(following-sibling::x) + 1) >= 1 ' \
           'and (((count(following-sibling::x) + 1) - 1) mod 2) = 0]'
-      )
+      ))
     end
 
     it 'parses the x:nth-last-of-type(n) pseudo class' do
-      parse_css('x:nth-last-of-type(n)').should == parse_xpath(
+      expect(parse_css('x:nth-last-of-type(n)')).to eq(parse_xpath(
         'descendant::x[((count(following-sibling::x) + 1) mod 1) = 0]'
-      )
+      ))
     end
 
     it 'parses the x:nth-last-of-type(-n) pseudo class' do
-      parse_css('x:nth-last-of-type(-n)').should == parse_xpath(
+      expect(parse_css('x:nth-last-of-type(-n)')).to eq(parse_xpath(
         'descendant::x[((count(following-sibling::x) + 1) mod 1) = 0]'
-      )
+      ))
     end
 
     it 'parses the x:nth-last-of-type(-n+6) pseudo class' do
-      parse_css('x:nth-last-of-type(-n+6)').should == parse_xpath(
+      expect(parse_css('x:nth-last-of-type(-n+6)')).to eq(parse_xpath(
         'descendant::x[((count(following-sibling::x) + 1) <= 6) ' \
           'and (((count(following-sibling::x) + 1) - 6) mod 1) = 0]'
-      )
+      ))
     end
 
     it 'parses the x:nth-last-of-type(n+5) pseudo class' do
-      parse_css('x:nth-last-of-type(n+5)').should == parse_xpath(
+      expect(parse_css('x:nth-last-of-type(n+5)')).to eq(parse_xpath(
         'descendant::x[(count(following-sibling::x) + 1) >= 5 ' \
           'and (((count(following-sibling::x) + 1) - 5) mod 1) = 0]'
-      )
+      ))
     end
 
     it 'parses the x:nth-last-of-type(2n) pseudo class' do
-      parse_css('x:nth-last-of-type(2n)')
-        .should == parse_css('x:nth-last-of-type(even)')
+      expect(parse_css('x:nth-last-of-type(2n)'))
+        .to eq(parse_css('x:nth-last-of-type(even)'))
     end
 
     it 'parses the x:nth-last-of-type(2n+1) pseudo class' do
-      parse_css('x:nth-last-of-type(2n+1)').should == parse_xpath(
+      expect(parse_css('x:nth-last-of-type(2n+1)')).to eq(parse_xpath(
         'descendant::x[(count(following-sibling::x) + 1) >= 1 ' \
           'and (((count(following-sibling::x) + 1) - 1) mod 2) = 0]'
-      )
+      ))
     end
 
     it 'parses the x:nth-last-of-type(3n+1) pseudo class' do
-      parse_css('x:nth-last-of-type(3n+1)').should == parse_xpath(
+      expect(parse_css('x:nth-last-of-type(3n+1)')).to eq(parse_xpath(
         'descendant::x[(count(following-sibling::x) + 1) >= 1 ' \
           'and (((count(following-sibling::x) + 1) - 1) mod 3) = 0]'
-      )
+      ))
     end
 
     it 'parses the x:nth-last-of-type(2n-6) pseudo class' do
-      parse_css('x:nth-last-of-type(2n-6)').should == parse_xpath(
+      expect(parse_css('x:nth-last-of-type(2n-6)')).to eq(parse_xpath(
         'descendant::x[(count(following-sibling::x) + 1) >= 2 ' \
           'and (((count(following-sibling::x) + 1) - 2) mod 2) = 0]'
-      )
+      ))
     end
 
     it 'parses the x:nth-last-of-type(-2n+6) pseudo class' do
-      parse_css('x:nth-last-of-type(-2n+6)').should == parse_xpath(
+      expect(parse_css('x:nth-last-of-type(-2n+6)')).to eq(parse_xpath(
         'descendant::x[((count(following-sibling::x) + 1) <= 6) ' \
           'and (((count(following-sibling::x) + 1) - 6) mod 2) = 0]'
-      )
+      ))
     end
   end
 end
diff --git a/spec/oga/css/parser/pseudo_classes/nth_of_type_spec.rb b/spec/oga/css/parser/pseudo_classes/nth_of_type_spec.rb
index 7443be8..9fb20d1 100644
--- a/spec/oga/css/parser/pseudo_classes/nth_of_type_spec.rb
+++ b/spec/oga/css/parser/pseudo_classes/nth_of_type_spec.rb
@@ -3,92 +3,92 @@ require 'spec_helper'
 describe Oga::CSS::Parser do
   describe ':nth-of-type pseudo class' do
     it 'parses the x:nth-of-type(1) pseudo class' do
-      parse_css('x:nth-of-type(1)').should == parse_xpath(
+      expect(parse_css('x:nth-of-type(1)')).to eq(parse_xpath(
         'descendant::x[count(preceding-sibling::x) = 0]'
-      )
+      ))
     end
 
     it 'parses the :nth-of-type(1) pseudo class' do
-      parse_css(':nth-of-type(1)').should == parse_xpath(
+      expect(parse_css(':nth-of-type(1)')).to eq(parse_xpath(
         'descendant::*[count(preceding-sibling::*) = 0]'
-      )
+      ))
     end
 
     it 'parses the :nth-of-type(2) pseudo class' do
-      parse_css(':nth-of-type(2)').should == parse_xpath(
+      expect(parse_css(':nth-of-type(2)')).to eq(parse_xpath(
         'descendant::*[count(preceding-sibling::*) = 1]'
-      )
+      ))
     end
 
     it 'parses the x:nth-of-type(even) pseudo class' do
-      parse_css('x:nth-of-type(even)').should == parse_xpath(
+      expect(parse_css('x:nth-of-type(even)')).to eq(parse_xpath(
         'descendant::x[((count(preceding-sibling::x) + 1) mod 2) = 0]'
-      )
+      ))
     end
 
     it 'parses the x:nth-of-type(odd) pseudo class' do
-      parse_css('x:nth-of-type(odd)').should == parse_xpath(
+      expect(parse_css('x:nth-of-type(odd)')).to eq(parse_xpath(
         'descendant::x[(count(preceding-sibling::x) + 1) >= 1 ' \
           'and (((count(preceding-sibling::x) + 1) - 1) mod 2) = 0]'
-      )
+      ))
     end
 
     it 'parses the x:nth-of-type(n) pseudo class' do
-      parse_css('x:nth-of-type(n)').should == parse_xpath(
+      expect(parse_css('x:nth-of-type(n)')).to eq(parse_xpath(
         'descendant::x[((count(preceding-sibling::x) + 1) mod 1) = 0]'
-      )
+      ))
     end
 
     it 'parses the x:nth-of-type(-n) pseudo class' do
-      parse_css('x:nth-of-type(-n)').should == parse_xpath(
+      expect(parse_css('x:nth-of-type(-n)')).to eq(parse_xpath(
         'descendant::x[((count(preceding-sibling::x) + 1) mod 1) = 0]'
-      )
+      ))
     end
 
     it 'parses the x:nth-of-type(-n+6) pseudo class' do
-      parse_css('x:nth-of-type(-n+6)').should == parse_xpath(
+      expect(parse_css('x:nth-of-type(-n+6)')).to eq(parse_xpath(
         'descendant::x[((count(preceding-sibling::x) + 1) <= 6) ' \
           'and (((count(preceding-sibling::x) + 1) - 6) mod 1) = 0]'
-      )
+      ))
     end
 
     it 'parses the x:nth-of-type(n+5) pseudo class' do
-      parse_css('x:nth-of-type(n+5)').should == parse_xpath(
+      expect(parse_css('x:nth-of-type(n+5)')).to eq(parse_xpath(
         'descendant::x[(count(preceding-sibling::x) + 1) >= 5 ' \
           'and (((count(preceding-sibling::x) + 1) - 5) mod 1) = 0]'
-      )
+      ))
     end
 
     it 'parses the x:nth-of-type(2n) pseudo class' do
-      parse_css('x:nth-of-type(2n)').should == parse_css('x:nth-of-type(even)')
+      expect(parse_css('x:nth-of-type(2n)')).to eq(parse_css('x:nth-of-type(even)'))
     end
 
     it 'parses the x:nth-of-type(2n+1) pseudo class' do
-      parse_css('x:nth-of-type(2n+1)').should == parse_xpath(
+      expect(parse_css('x:nth-of-type(2n+1)')).to eq(parse_xpath(
         'descendant::x[(count(preceding-sibling::x) + 1) >= 1 ' \
           'and (((count(preceding-sibling::x) + 1) - 1) mod 2) = 0]'
-      )
+      ))
     end
 
     it 'parses the x:nth-of-type(3n+1) pseudo class' do
-      parse_css('x:nth-of-type(3n+1)').should == parse_xpath(
+      expect(parse_css('x:nth-of-type(3n+1)')).to eq(parse_xpath(
         'descendant::x[(count(preceding-sibling::x) + 1) >= 1 ' \
           'and (((count(preceding-sibling::x) + 1) - 1) mod 3) = 0]'
-      )
+      ))
     end
 
     it 'parses the x:nth-of-type(2n-6) pseudo class' do
-      parse_css('x:nth-of-type(2n-6)').should == parse_xpath(
+      expect(parse_css('x:nth-of-type(2n-6)')).to eq(parse_xpath(
         'descendant::x[(count(preceding-sibling::x) + 1) >= 2 ' \
           'and (((count(preceding-sibling::x) + 1) - 2) mod 2) = 0]'
-      )
+      ))
     end
 
     it 'parses the x:nth-of-type(-2n+6) pseudo class' do
-      parse_css('x:nth-of-type(-2n+6)').should == parse_xpath(
+      expect(parse_css('x:nth-of-type(-2n+6)')).to eq(parse_xpath(
         'descendant::x[((count(preceding-sibling::x) + 1) <= 6) ' \
           'and (((count(preceding-sibling::x) + 1) - 6) mod 2) = 0]'
-      )
+      ))
     end
   end
 end
diff --git a/spec/oga/css/parser/pseudo_classes/nth_spec.rb b/spec/oga/css/parser/pseudo_classes/nth_spec.rb
index 2e42020..2635e1a 100644
--- a/spec/oga/css/parser/pseudo_classes/nth_spec.rb
+++ b/spec/oga/css/parser/pseudo_classes/nth_spec.rb
@@ -3,13 +3,13 @@ require 'spec_helper'
 describe Oga::CSS::Parser do
   describe ':nth pseudo class' do
     it 'parses the :nth(1) pseudo class' do
-      parse_css(':nth(1)')
-        .should == parse_xpath('descendant::*[position() = 1]')
+      expect(parse_css(':nth(1)'))
+        .to eq(parse_xpath('descendant::*[position() = 1]'))
     end
 
     it 'parses the :nth(2) pseudo class' do
-      parse_css(':nth(2)')
-        .should == parse_xpath('descendant::*[position() = 2]')
+      expect(parse_css(':nth(2)'))
+        .to eq(parse_xpath('descendant::*[position() = 2]'))
     end
   end
 end
diff --git a/spec/oga/css/parser/pseudo_classes/only_child_spec.rb b/spec/oga/css/parser/pseudo_classes/only_child_spec.rb
index 086629f..12333c8 100644
--- a/spec/oga/css/parser/pseudo_classes/only_child_spec.rb
+++ b/spec/oga/css/parser/pseudo_classes/only_child_spec.rb
@@ -3,10 +3,10 @@ require 'spec_helper'
 describe Oga::CSS::Parser do
   describe ':only-child pseudo class' do
     it 'parses the :only-child pseudo class' do
-      parse_css(':only-child').should == parse_xpath(
+      expect(parse_css(':only-child')).to eq(parse_xpath(
         'descendant::*[count(preceding-sibling::*) = 0 ' \
           'and count(following-sibling::*) = 0]'
-      )
+      ))
     end
   end
 end
diff --git a/spec/oga/css/parser/pseudo_classes/only_of_type_spec.rb b/spec/oga/css/parser/pseudo_classes/only_of_type_spec.rb
index b2384ff..c075cf2 100644
--- a/spec/oga/css/parser/pseudo_classes/only_of_type_spec.rb
+++ b/spec/oga/css/parser/pseudo_classes/only_of_type_spec.rb
@@ -3,17 +3,17 @@ require 'spec_helper'
 describe Oga::CSS::Parser do
   describe ':only-of-type pseudo class' do
     it 'parses the :only-of-type pseudo class' do
-      parse_css(':only-of-type').should == parse_xpath(
+      expect(parse_css(':only-of-type')).to eq(parse_xpath(
         'descendant::*[count(preceding-sibling::*) = 0 and ' \
           'count(following-sibling::*) = 0]'
-      )
+      ))
     end
 
     it 'parses the a:only-of-type pseudo class' do
-      parse_css('a:only-of-type').should == parse_xpath(
+      expect(parse_css('a:only-of-type')).to eq(parse_xpath(
         'descendant::a[count(preceding-sibling::a) = 0 and ' \
           'count(following-sibling::a) = 0]'
-      )
+      ))
     end
   end
 end
diff --git a/spec/oga/css/parser/pseudo_classes/root_spec.rb b/spec/oga/css/parser/pseudo_classes/root_spec.rb
index fb56800..9be97a5 100644
--- a/spec/oga/css/parser/pseudo_classes/root_spec.rb
+++ b/spec/oga/css/parser/pseudo_classes/root_spec.rb
@@ -3,11 +3,11 @@ require 'spec_helper'
 describe Oga::CSS::Parser do
   describe ':root pseudo class' do
     it 'parses the x:root pseudo class' do
-      parse_css('x:root').should == parse_xpath('descendant::x[not(parent::*)]')
+      expect(parse_css('x:root')).to eq(parse_xpath('descendant::x[not(parent::*)]'))
     end
 
     it 'parses the :root pseudo class' do
-      parse_css(':root').should == parse_xpath('descendant::*[not(parent::*)]')
+      expect(parse_css(':root')).to eq(parse_xpath('descendant::*[not(parent::*)]'))
     end
   end
 end
diff --git a/spec/oga/css/parser/wildcards_spec.rb b/spec/oga/css/parser/wildcards_spec.rb
index 2f0238b..e562e81 100644
--- a/spec/oga/css/parser/wildcards_spec.rb
+++ b/spec/oga/css/parser/wildcards_spec.rb
@@ -3,15 +3,15 @@ require 'spec_helper'
 describe Oga::CSS::Parser do
   describe 'wildcards' do
     it 'parses a wildcard name test' do
-      parse_css('*').should == parse_xpath('descendant::*')
+      expect(parse_css('*')).to eq(parse_xpath('descendant::*'))
     end
 
     it 'parses a wildcard namespace test' do
-      parse_css('*|foo').should == parse_xpath('descendant::*:foo')
+      expect(parse_css('*|foo')).to eq(parse_xpath('descendant::*:foo'))
     end
 
     it 'parses a wildcard namespace and name test' do
-      parse_css('*|*').should == parse_xpath('descendant::*:*')
+      expect(parse_css('*|*')).to eq(parse_xpath('descendant::*:*'))
     end
   end
 end
diff --git a/spec/oga/entity_decoder_spec.rb b/spec/oga/entity_decoder_spec.rb
index 1ba1be2..94c41fd 100644
--- a/spec/oga/entity_decoder_spec.rb
+++ b/spec/oga/entity_decoder_spec.rb
@@ -3,29 +3,29 @@ require 'spec_helper'
 describe Oga::EntityDecoder do
   describe 'try_decode' do
     it 'returns nil if the input is also nil' do
-      described_class.try_decode(nil).should be_nil
+      expect(described_class.try_decode(nil)).to be_nil
     end
 
     it 'decodes XML entities' do
-      described_class.try_decode('&lt;')
-        .should == Oga::XML::Entities::DECODE_MAPPING['&lt;']
+      expect(described_class.try_decode('&lt;'))
+        .to eq(Oga::XML::Entities::DECODE_MAPPING['&lt;'])
     end
 
     it 'decodes HTML entities' do
-      described_class.try_decode('&copy;', true)
-        .should == Oga::HTML::Entities::DECODE_MAPPING['&copy;']
+      expect(described_class.try_decode('&copy;', true))
+        .to eq(Oga::HTML::Entities::DECODE_MAPPING['&copy;'])
     end
   end
 
   describe 'decode' do
     it 'decodes XML entities' do
-      described_class.decode('&lt;')
-        .should == Oga::XML::Entities::DECODE_MAPPING['&lt;']
+      expect(described_class.decode('&lt;'))
+        .to eq(Oga::XML::Entities::DECODE_MAPPING['&lt;'])
     end
 
     it 'decodes HTML entities' do
-      described_class.decode('&copy;', true)
-        .should == Oga::HTML::Entities::DECODE_MAPPING['&copy;']
+      expect(described_class.decode('&copy;', true))
+        .to eq(Oga::HTML::Entities::DECODE_MAPPING['&copy;'])
     end
   end
 end
diff --git a/spec/oga/html/entities_spec.rb b/spec/oga/html/entities_spec.rb
index b036c0f..af4d68d 100644
--- a/spec/oga/html/entities_spec.rb
+++ b/spec/oga/html/entities_spec.rb
@@ -5,15 +5,15 @@ require 'spec_helper'
 describe Oga::HTML::Entities do
   describe 'decode' do
     it 'decodes &amp; into &' do
-      described_class.decode('&amp;').should == '&'
+      expect(described_class.decode('&amp;')).to eq('&')
     end
 
     it 'decodes &lambda; into λ' do
-      described_class.decode('&lambda;').should == 'λ'
+      expect(described_class.decode('&lambda;')).to eq('λ')
     end
 
     it 'decodes &frac12; into ½' do
-      described_class.decode('&frac12;').should == '½'
+      expect(described_class.decode('&frac12;')).to eq('½')
     end
   end
 end
diff --git a/spec/oga/html/lexer/attributes_spec.rb b/spec/oga/html/lexer/attributes_spec.rb
index 7773dd6..dc44279 100644
--- a/spec/oga/html/lexer/attributes_spec.rb
+++ b/spec/oga/html/lexer/attributes_spec.rb
@@ -3,18 +3,18 @@ require 'spec_helper'
 describe Oga::XML::Lexer do
   describe 'HTML attributes' do
     it 'lexes an attribute with an unquoted value' do
-      lex_html('<a href=foo></a>').should == [
+      expect(lex_html('<a href=foo></a>')).to eq([
         [:T_ELEM_NAME, 'a', 1],
         [:T_ATTR, 'href', 1],
         [:T_STRING_SQUOTE, nil, 1],
         [:T_STRING_BODY, 'foo', 1],
         [:T_STRING_SQUOTE, nil, 1],
         [:T_ELEM_END, nil, 1]
-      ]
+      ])
     end
 
     it 'lexes an attribute with an unquoted value containing a space' do
-      lex_html('<a href=foo bar></a>').should == [
+      expect(lex_html('<a href=foo bar></a>')).to eq([
         [:T_ELEM_NAME, 'a', 1],
         [:T_ATTR, 'href', 1],
         [:T_STRING_SQUOTE, nil, 1],
@@ -22,55 +22,55 @@ describe Oga::XML::Lexer do
         [:T_STRING_SQUOTE, nil, 1],
         [:T_ATTR, 'bar', 1],
         [:T_ELEM_END, nil, 1]
-      ]
+      ])
     end
 
     it 'lexes an attribute with an unquoted value containing an underscore' do
-      lex_html('<a href=foo_bar></a>').should == [
+      expect(lex_html('<a href=foo_bar></a>')).to eq([
         [:T_ELEM_NAME, 'a', 1],
         [:T_ATTR, 'href', 1],
         [:T_STRING_SQUOTE, nil, 1],
         [:T_STRING_BODY, 'foo_bar', 1],
         [:T_STRING_SQUOTE, nil, 1],
         [:T_ELEM_END, nil, 1]
-      ]
+      ])
     end
 
     it 'lexes an attribute with an unquoted value containing a dash' do
-      lex_html('<a href=foo-bar></a>').should == [
+      expect(lex_html('<a href=foo-bar></a>')).to eq([
         [:T_ELEM_NAME, 'a', 1],
         [:T_ATTR, 'href', 1],
         [:T_STRING_SQUOTE, nil, 1],
         [:T_STRING_BODY, 'foo-bar', 1],
         [:T_STRING_SQUOTE, nil, 1],
         [:T_ELEM_END, nil, 1]
-      ]
+      ])
     end
 
     it 'lexes an attribute with an unquoted value containing a slash' do
-      lex_html('<a href=foo/></a>').should == [
+      expect(lex_html('<a href=foo/></a>')).to eq([
         [:T_ELEM_NAME, 'a', 1],
         [:T_ATTR, 'href', 1],
         [:T_STRING_SQUOTE, nil, 1],
         [:T_STRING_BODY, 'foo/', 1],
         [:T_STRING_SQUOTE, nil, 1],
         [:T_ELEM_END, nil, 1]
-      ]
+      ])
     end
 
     it 'lexes an attribute with an unquoted chunk of Javascript' do
-      lex_html('<a href=ijustlovehtml("because","reasons")').should == [
+      expect(lex_html('<a href=ijustlovehtml("because","reasons")')).to eq([
         [:T_ELEM_NAME, 'a', 1],
         [:T_ATTR, 'href', 1],
         [:T_STRING_SQUOTE, nil, 1],
         [:T_STRING_BODY, 'ijustlovehtml("because","reasons")', 1],
         [:T_STRING_SQUOTE, nil, 1],
         [:T_ELEM_END, nil, 1]
-      ]
+      ])
     end
 
     it 'lexes an attribute with an unquoted chunk of Javascript followed by another attribute' do
-      lex_html('<a href=ijustlovehtml("because","reasons") foo="bar"').should == [
+      expect(lex_html('<a href=ijustlovehtml("because","reasons") foo="bar"')).to eq([
         [:T_ELEM_NAME, 'a', 1],
         [:T_ATTR, 'href', 1],
         [:T_STRING_SQUOTE, nil, 1],
@@ -81,73 +81,73 @@ describe Oga::XML::Lexer do
         [:T_STRING_BODY, 'bar', 1],
         [:T_STRING_DQUOTE, nil, 1],
         [:T_ELEM_END, nil, 1]
-      ]
+      ])
     end
 
     it 'lexes an attribute with a value without a starting double quote' do
-      lex_html('<a href=foo"></a>').should == [
+      expect(lex_html('<a href=foo"></a>')).to eq([
         [:T_ELEM_NAME, 'a', 1],
         [:T_ATTR, 'href', 1],
         [:T_STRING_SQUOTE, nil, 1],
         [:T_STRING_BODY, 'foo"', 1],
         [:T_STRING_SQUOTE, nil, 1],
         [:T_ELEM_END, nil, 1]
-      ]
+      ])
     end
 
     it 'lexes an attribute with a value without a starting single quote' do
-      lex_html("<a href=foo'></a>").should == [
+      expect(lex_html("<a href=foo'></a>")).to eq([
         [:T_ELEM_NAME, 'a', 1],
         [:T_ATTR, 'href', 1],
         [:T_STRING_SQUOTE, nil, 1],
         [:T_STRING_BODY, "foo'", 1],
         [:T_STRING_SQUOTE, nil, 1],
         [:T_ELEM_END, nil, 1]
-      ]
+      ])
     end
 
     it 'lexes an element with spaces around the attribute equal sign' do
-      lex_html('<p foo = "bar"></p>').should == [
+      expect(lex_html('<p foo = "bar"></p>')).to eq([
         [:T_ELEM_NAME, 'p', 1],
         [:T_ATTR, 'foo', 1],
         [:T_STRING_DQUOTE, nil, 1],
         [:T_STRING_BODY, 'bar', 1],
         [:T_STRING_DQUOTE, nil, 1],
         [:T_ELEM_END, nil, 1]
-      ]
+      ])
     end
 
     it 'lexes an element with a newline following the equals sign' do
-      lex_html(%Q{<p foo =\n"bar"></p>}).should == [
+      expect(lex_html(%Q{<p foo =\n"bar"></p>})).to eq([
         [:T_ELEM_NAME, 'p', 1],
         [:T_ATTR, 'foo', 1],
         [:T_STRING_DQUOTE, nil, 2],
         [:T_STRING_BODY, 'bar', 2],
         [:T_STRING_DQUOTE, nil, 2],
         [:T_ELEM_END, nil, 2]
-      ]
+      ])
     end
 
     it 'lexes an element with a newline following the equals sign using an IO as input' do
-      lex_stringio(%Q{<p foo =\n"bar"></p>}, :html => true).should == [
+      expect(lex_stringio(%Q{<p foo =\n"bar"></p>}, :html => true)).to eq([
         [:T_ELEM_NAME, 'p', 1],
         [:T_ATTR, 'foo', 1],
         [:T_STRING_DQUOTE, nil, 2],
         [:T_STRING_BODY, 'bar', 2],
         [:T_STRING_DQUOTE, nil, 2],
         [:T_ELEM_END, nil, 2]
-      ]
+      ])
     end
 
     it 'lexes an element containing a namespaced attribute' do
-      lex_html('<foo bar:baz="10" />').should == [
+      expect(lex_html('<foo bar:baz="10" />')).to eq([
         [:T_ELEM_NAME, 'foo', 1],
         [:T_ATTR, 'bar:baz', 1],
         [:T_STRING_DQUOTE, nil, 1],
         [:T_STRING_BODY, '10', 1],
         [:T_STRING_DQUOTE, nil, 1],
         [:T_ELEM_END, nil, 1]
-      ]
+      ])
     end
   end
 end
diff --git a/spec/oga/html/lexer/closing_mismatch_spec.rb b/spec/oga/html/lexer/closing_mismatch_spec.rb
index 5cabc4e..bef74ea 100644
--- a/spec/oga/html/lexer/closing_mismatch_spec.rb
+++ b/spec/oga/html/lexer/closing_mismatch_spec.rb
@@ -3,22 +3,22 @@ require 'spec_helper'
 describe Oga::XML::Lexer do
   describe 'closing HTML elements with mismatched closing tags' do
     it 'lexes a <p> element closed using a </div> element' do
-      lex_html('<p>foo</div>').should == [
+      expect(lex_html('<p>foo</div>')).to eq([
         [:T_ELEM_NAME, 'p', 1],
         [:T_TEXT, 'foo', 1],
         [:T_ELEM_END, nil, 1]
-      ]
+      ])
     end
 
     it 'lexes a <param> element' do
-      lex_html('<object><param></param><param></param></object>').should == [
+      expect(lex_html('<object><param></param><param></param></object>')).to eq([
         [:T_ELEM_NAME, 'object', 1],
         [:T_ELEM_NAME, 'param', 1],
         [:T_ELEM_END, nil, 1],
         [:T_ELEM_NAME, 'param', 1],
         [:T_ELEM_END, nil, 1],
         [:T_ELEM_END, nil, 1]
-      ]
+      ])
     end
   end
 end
diff --git a/spec/oga/html/lexer/closing_rules/body_spec.rb b/spec/oga/html/lexer/closing_rules/body_spec.rb
index c732205..e565438 100644
--- a/spec/oga/html/lexer/closing_rules/body_spec.rb
+++ b/spec/oga/html/lexer/closing_rules/body_spec.rb
@@ -3,35 +3,35 @@ require 'spec_helper'
 describe Oga::XML::Lexer do
   describe 'using HTML <body> elements' do
     it 'lexes an unclosed <body> followed by a <head> as separate elements' do
-      lex_html('<body>foo<head>bar').should == [
+      expect(lex_html('<body>foo<head>bar')).to eq([
         [:T_ELEM_NAME, 'body', 1],
         [:T_TEXT, 'foo', 1],
         [:T_ELEM_END, nil, 1],
         [:T_ELEM_NAME, 'head', 1],
         [:T_TEXT, 'bar', 1],
         [:T_ELEM_END, nil, 1]
-      ]
+      ])
     end
 
     it 'lexes an unclosed <body> followed by a <body> as separate elements' do
-      lex_html('<body>foo<body>bar').should == [
+      expect(lex_html('<body>foo<body>bar')).to eq([
         [:T_ELEM_NAME, 'body', 1],
         [:T_TEXT, 'foo', 1],
         [:T_ELEM_END, nil, 1],
         [:T_ELEM_NAME, 'body', 1],
         [:T_TEXT, 'bar', 1],
         [:T_ELEM_END, nil, 1]
-      ]
+      ])
     end
 
     it 'lexes a <p> following an unclosed <body> as a child element' do
-      lex_html('<body><p>foo</body>').should == [
+      expect(lex_html('<body><p>foo</body>')).to eq([
         [:T_ELEM_NAME, 'body', 1],
         [:T_ELEM_NAME, 'p', 1],
         [:T_TEXT, 'foo', 1],
         [:T_ELEM_END, nil, 1],
         [:T_ELEM_END, nil, 1]
-      ]
+      ])
     end
   end
 end
diff --git a/spec/oga/html/lexer/closing_rules/caption_spec.rb b/spec/oga/html/lexer/closing_rules/caption_spec.rb
index 037cabf..9428d2d 100644
--- a/spec/oga/html/lexer/closing_rules/caption_spec.rb
+++ b/spec/oga/html/lexer/closing_rules/caption_spec.rb
@@ -3,79 +3,79 @@ require 'spec_helper'
 describe Oga::XML::Lexer do
   describe 'using HTML <caption> elements' do
     it 'lexes an unclosed <caption> followed by a <thead> as separate elements' do
-      lex_html('<caption>foo<thead>bar').should == [
+      expect(lex_html('<caption>foo<thead>bar')).to eq([
         [:T_ELEM_NAME, 'caption', 1],
         [:T_TEXT, 'foo', 1],
         [:T_ELEM_END, nil, 1],
         [:T_ELEM_NAME, 'thead', 1],
         [:T_TEXT, 'bar', 1],
         [:T_ELEM_END, nil, 1]
-      ]
+      ])
     end
 
     it 'lexes an unclosed <caption> followed by a <tbody> as separate elements' do
-      lex_html('<caption>foo<tbody>bar').should == [
+      expect(lex_html('<caption>foo<tbody>bar')).to eq([
         [:T_ELEM_NAME, 'caption', 1],
         [:T_TEXT, 'foo', 1],
         [:T_ELEM_END, nil, 1],
         [:T_ELEM_NAME, 'tbody', 1],
         [:T_TEXT, 'bar', 1],
         [:T_ELEM_END, nil, 1]
-      ]
+      ])
     end
 
     it 'lexes an unclosed <caption> followed by a <tfoot> as separate elements' do
-      lex_html('<caption>foo<tfoot>bar').should == [
+      expect(lex_html('<caption>foo<tfoot>bar')).to eq([
         [:T_ELEM_NAME, 'caption', 1],
         [:T_TEXT, 'foo', 1],
         [:T_ELEM_END, nil, 1],
         [:T_ELEM_NAME, 'tfoot', 1],
         [:T_TEXT, 'bar', 1],
         [:T_ELEM_END, nil, 1]
-      ]
+      ])
     end
 
     it 'lexes an unclosed <caption> followed by a <tr> as separate elements' do
-      lex_html('<caption>foo<tr>bar').should == [
+      expect(lex_html('<caption>foo<tr>bar')).to eq([
         [:T_ELEM_NAME, 'caption', 1],
         [:T_TEXT, 'foo', 1],
         [:T_ELEM_END, nil, 1],
         [:T_ELEM_NAME, 'tr', 1],
         [:T_TEXT, 'bar', 1],
         [:T_ELEM_END, nil, 1]
-      ]
+      ])
     end
 
     it 'lexes an unclosed <caption> followed by a <caption> as separate elements' do
-      lex_html('<caption>foo<caption>bar').should == [
+      expect(lex_html('<caption>foo<caption>bar')).to eq([
         [:T_ELEM_NAME, 'caption', 1],
         [:T_TEXT, 'foo', 1],
         [:T_ELEM_END, nil, 1],
         [:T_ELEM_NAME, 'caption', 1],
         [:T_TEXT, 'bar', 1],
         [:T_ELEM_END, nil, 1]
-      ]
+      ])
     end
 
     it 'lexes an unclosed <caption> followed by a <colgroup> as separate elements' do
-      lex_html('<caption>foo<colgroup>bar').should == [
+      expect(lex_html('<caption>foo<colgroup>bar')).to eq([
         [:T_ELEM_NAME, 'caption', 1],
         [:T_TEXT, 'foo', 1],
         [:T_ELEM_END, nil, 1],
         [:T_ELEM_NAME, 'colgroup', 1],
         [:T_TEXT, 'bar', 1],
         [:T_ELEM_END, nil, 1]
-      ]
+      ])
     end
 
     it 'lexes an unclosed <caption> followed by a <col> as separate elements' do
-      lex_html('<caption>foo<col>').should == [
+      expect(lex_html('<caption>foo<col>')).to eq([
         [:T_ELEM_NAME, 'caption', 1],
         [:T_TEXT, 'foo', 1],
         [:T_ELEM_END, nil, 1],
         [:T_ELEM_NAME, 'col', 1],
         [:T_ELEM_END, nil, 1]
-      ]
+      ])
     end
   end
 end
diff --git a/spec/oga/html/lexer/closing_rules/colgroup_spec.rb b/spec/oga/html/lexer/closing_rules/colgroup_spec.rb
index cc0bf41..0626fad 100644
--- a/spec/oga/html/lexer/closing_rules/colgroup_spec.rb
+++ b/spec/oga/html/lexer/closing_rules/colgroup_spec.rb
@@ -3,32 +3,32 @@ require 'spec_helper'
 describe Oga::XML::Lexer do
   describe 'using HTML <colgroup> elements' do
     it 'lexes two unclosed <colgroup> elements as separate elements' do
-      lex_html('<colgroup>foo<colgroup>bar').should == [
+      expect(lex_html('<colgroup>foo<colgroup>bar')).to eq([
         [:T_ELEM_NAME, 'colgroup', 1],
         [:T_TEXT, 'foo', 1],
         [:T_ELEM_END, nil, 1],
         [:T_ELEM_NAME, 'colgroup', 1],
         [:T_TEXT, 'bar', 1],
         [:T_ELEM_END, nil, 1]
-      ]
+      ])
     end
 
     it 'lexes a <col> element following a <colgroup> as a child element' do
-      lex_html('<colgroup><col>').should == [
+      expect(lex_html('<colgroup><col>')).to eq([
         [:T_ELEM_NAME, 'colgroup', 1],
         [:T_ELEM_NAME, 'col', 1],
         [:T_ELEM_END, nil, 1],
         [:T_ELEM_END, nil, 1]
-      ]
+      ])
     end
 
     it 'lexes a <template> element following a <colgroup> as a child element' do
-      lex_html('<colgroup><template>').should == [
+      expect(lex_html('<colgroup><template>')).to eq([
         [:T_ELEM_NAME, 'colgroup', 1],
         [:T_ELEM_NAME, 'template', 1],
         [:T_ELEM_END, nil, 1],
         [:T_ELEM_END, nil, 1]
-      ]
+      ])
     end
   end
 end
diff --git a/spec/oga/html/lexer/closing_rules/dd_spec.rb b/spec/oga/html/lexer/closing_rules/dd_spec.rb
index dc3f7ae..6447cb2 100644
--- a/spec/oga/html/lexer/closing_rules/dd_spec.rb
+++ b/spec/oga/html/lexer/closing_rules/dd_spec.rb
@@ -3,25 +3,25 @@ require 'spec_helper'
 describe Oga::XML::Lexer do
   describe 'using HTML <dt> elements' do
     it 'lexes two unclosed <dd> elements following each other as separate elements' do
-      lex_html('<dd>foo<dd>bar').should == [
+      expect(lex_html('<dd>foo<dd>bar')).to eq([
         [:T_ELEM_NAME, 'dd', 1],
         [:T_TEXT, 'foo', 1],
         [:T_ELEM_END, nil, 1],
         [:T_ELEM_NAME, 'dd', 1],
         [:T_TEXT, 'bar', 1],
         [:T_ELEM_END, nil, 1]
-      ]
+      ])
     end
 
     it 'lexes an unclosed <dd> followed by a <dt> as separate elements' do
-      lex_html('<dd>foo<dt>bar').should == [
+      expect(lex_html('<dd>foo<dt>bar')).to eq([
         [:T_ELEM_NAME, 'dd', 1],
         [:T_TEXT, 'foo', 1],
         [:T_ELEM_END, nil, 1],
         [:T_ELEM_NAME, 'dt', 1],
         [:T_TEXT, 'bar', 1],
         [:T_ELEM_END, nil, 1]
-      ]
+      ])
     end
   end
 end
diff --git a/spec/oga/html/lexer/closing_rules/dt_spec.rb b/spec/oga/html/lexer/closing_rules/dt_spec.rb
index 9f5e199..0533a84 100644
--- a/spec/oga/html/lexer/closing_rules/dt_spec.rb
+++ b/spec/oga/html/lexer/closing_rules/dt_spec.rb
@@ -3,25 +3,25 @@ require 'spec_helper'
 describe Oga::XML::Lexer do
   describe 'using HTML <dt> elements' do
     it 'lexes two unclosed <dt> elements following each other as separate elements' do
-      lex_html('<dt>foo<dt>bar').should == [
+      expect(lex_html('<dt>foo<dt>bar')).to eq([
         [:T_ELEM_NAME, 'dt', 1],
         [:T_TEXT, 'foo', 1],
         [:T_ELEM_END, nil, 1],
         [:T_ELEM_NAME, 'dt', 1],
         [:T_TEXT, 'bar', 1],
         [:T_ELEM_END, nil, 1]
-      ]
+      ])
     end
 
     it 'lexes an unclosed <dt> followed by a <dd> as separate elements' do
-      lex_html('<dt>foo<dd>bar').should == [
+      expect(lex_html('<dt>foo<dd>bar')).to eq([
         [:T_ELEM_NAME, 'dt', 1],
         [:T_TEXT, 'foo', 1],
         [:T_ELEM_END, nil, 1],
         [:T_ELEM_NAME, 'dd', 1],
         [:T_TEXT, 'bar', 1],
         [:T_ELEM_END, nil, 1]
-      ]
+      ])
     end
   end
 end
diff --git a/spec/oga/html/lexer/closing_rules/head_spec.rb b/spec/oga/html/lexer/closing_rules/head_spec.rb
index d5248af..7f4a4d5 100644
--- a/spec/oga/html/lexer/closing_rules/head_spec.rb
+++ b/spec/oga/html/lexer/closing_rules/head_spec.rb
@@ -3,35 +3,35 @@ require 'spec_helper'
 describe Oga::XML::Lexer do
   describe 'using HTML <head> elements' do
     it 'lexes an unclosed <head> followed by a <head> as separate elements' do
-      lex_html('<head>foo<head>bar').should == [
+      expect(lex_html('<head>foo<head>bar')).to eq([
         [:T_ELEM_NAME, 'head', 1],
         [:T_TEXT, 'foo', 1],
         [:T_ELEM_END, nil, 1],
         [:T_ELEM_NAME, 'head', 1],
         [:T_TEXT, 'bar', 1],
         [:T_ELEM_END, nil, 1]
-      ]
+      ])
     end
 
     it 'lexes an unclosed <head> followed by a <body> as separate elements' do
-      lex_html('<head>foo<body>bar').should == [
+      expect(lex_html('<head>foo<body>bar')).to eq([
         [:T_ELEM_NAME, 'head', 1],
         [:T_TEXT, 'foo', 1],
         [:T_ELEM_END, nil, 1],
         [:T_ELEM_NAME, 'body', 1],
         [:T_TEXT, 'bar', 1],
         [:T_ELEM_END, nil, 1]
-      ]
+      ])
     end
 
     it 'lexes a <title> following an unclosed <head> as a child element' do
-      lex_html('<head><title>foo</title>').should == [
+      expect(lex_html('<head><title>foo</title>')).to eq([
         [:T_ELEM_NAME, 'head', 1],
         [:T_ELEM_NAME, 'title', 1],
         [:T_TEXT, 'foo', 1],
         [:T_ELEM_END, nil, 1],
         [:T_ELEM_END, nil, 1]
-      ]
+      ])
     end
   end
 end
diff --git a/spec/oga/html/lexer/closing_rules/li_spec.rb b/spec/oga/html/lexer/closing_rules/li_spec.rb
index ebb18f7..d1f59fa 100644
--- a/spec/oga/html/lexer/closing_rules/li_spec.rb
+++ b/spec/oga/html/lexer/closing_rules/li_spec.rb
@@ -3,14 +3,14 @@ require 'spec_helper'
 describe Oga::XML::Lexer do
   describe 'using HTML <li> elements' do
     it 'lexes two unclosed <li> elements following each other as separate elements' do
-      lex_html('<li>foo<li>bar').should == [
+      expect(lex_html('<li>foo<li>bar')).to eq([
         [:T_ELEM_NAME, 'li', 1],
         [:T_TEXT, 'foo', 1],
         [:T_ELEM_END, nil, 1],
         [:T_ELEM_NAME, 'li', 1],
         [:T_TEXT, 'bar', 1],
         [:T_ELEM_END, nil, 1]
-      ]
+      ])
     end
   end
 end
diff --git a/spec/oga/html/lexer/closing_rules/optgroup_spec.rb b/spec/oga/html/lexer/closing_rules/optgroup_spec.rb
index 913807a..9c888a2 100644
--- a/spec/oga/html/lexer/closing_rules/optgroup_spec.rb
+++ b/spec/oga/html/lexer/closing_rules/optgroup_spec.rb
@@ -4,7 +4,7 @@ describe Oga::XML::Lexer do
   describe 'HTML optgroup elements' do
     describe 'with unclosed <optgroup> tags' do
       it 'lexes an <option> tag followed by a <optgroup> tag' do
-        lex_html('<optgroup><option>foo<optgroup><option>bar').should == [
+        expect(lex_html('<optgroup><option>foo<optgroup><option>bar')).to eq([
           [:T_ELEM_NAME, 'optgroup', 1],
           [:T_ELEM_NAME, 'option', 1],
           [:T_TEXT, 'foo', 1],
@@ -15,7 +15,7 @@ describe Oga::XML::Lexer do
           [:T_TEXT, 'bar', 1],
           [:T_ELEM_END, nil, 1],
           [:T_ELEM_END, nil, 1]
-        ]
+        ])
       end
     end
   end
diff --git a/spec/oga/html/lexer/closing_rules/option_spec.rb b/spec/oga/html/lexer/closing_rules/option_spec.rb
index 424dc36..a9fb353 100644
--- a/spec/oga/html/lexer/closing_rules/option_spec.rb
+++ b/spec/oga/html/lexer/closing_rules/option_spec.rb
@@ -3,25 +3,25 @@ require 'spec_helper'
 describe Oga::XML::Lexer do
   describe 'using HTML <option> elements' do
     it 'lexes two unclosed <option> elements following each other as separate elements' do
-      lex_html('<option>foo<option>bar').should == [
+      expect(lex_html('<option>foo<option>bar')).to eq([
         [:T_ELEM_NAME, 'option', 1],
         [:T_TEXT, 'foo', 1],
         [:T_ELEM_END, nil, 1],
         [:T_ELEM_NAME, 'option', 1],
         [:T_TEXT, 'bar', 1],
         [:T_ELEM_END, nil, 1]
-      ]
+      ])
     end
 
     it 'lexes an unclosed <option> followed by a <optgroup> as separate elements' do
-      lex_html('<option>foo<optgroup>bar').should == [
+      expect(lex_html('<option>foo<optgroup>bar')).to eq([
         [:T_ELEM_NAME, 'option', 1],
         [:T_TEXT, 'foo', 1],
         [:T_ELEM_END, nil, 1],
         [:T_ELEM_NAME, 'optgroup', 1],
         [:T_TEXT, 'bar', 1],
         [:T_ELEM_END, nil, 1]
-      ]
+      ])
     end
   end
 end
diff --git a/spec/oga/html/lexer/closing_rules/p_spec.rb b/spec/oga/html/lexer/closing_rules/p_spec.rb
index 604b7c7..818fd13 100644
--- a/spec/oga/html/lexer/closing_rules/p_spec.rb
+++ b/spec/oga/html/lexer/closing_rules/p_spec.rb
@@ -3,25 +3,25 @@ require 'spec_helper'
 describe Oga::XML::Lexer do
   describe 'using HTML <p> elements' do
     it 'lexes two unclosed <p> elements following each other as separate elements' do
-      lex_html('<p>foo<p>bar').should == [
+      expect(lex_html('<p>foo<p>bar')).to eq([
         [:T_ELEM_NAME, 'p', 1],
         [:T_TEXT, 'foo', 1],
         [:T_ELEM_END, nil, 1],
         [:T_ELEM_NAME, 'p', 1],
         [:T_TEXT, 'bar', 1],
         [:T_ELEM_END, nil, 1]
-      ]
+      ])
     end
 
     it 'lexes an unclosed <p> followed by a <address> as separate elements' do
-      lex_html('<p>foo<address>bar').should == [
+      expect(lex_html('<p>foo<address>bar')).to eq([
         [:T_ELEM_NAME, 'p', 1],
         [:T_TEXT, 'foo', 1],
         [:T_ELEM_END, nil, 1],
         [:T_ELEM_NAME, 'address', 1],
         [:T_TEXT, 'bar', 1],
         [:T_ELEM_END, nil, 1]
-      ]
+      ])
     end
   end
 end
diff --git a/spec/oga/html/lexer/closing_rules/rb_spec.rb b/spec/oga/html/lexer/closing_rules/rb_spec.rb
index f8e61ce..1f279bb 100644
--- a/spec/oga/html/lexer/closing_rules/rb_spec.rb
+++ b/spec/oga/html/lexer/closing_rules/rb_spec.rb
@@ -3,25 +3,25 @@ require 'spec_helper'
 describe Oga::XML::Lexer do
   describe 'using HTML <rb> elements' do
     it 'lexes two unclosed <rb> elements following each other as separate elements' do
-      lex_html('<rb>foo<rb>bar').should == [
+      expect(lex_html('<rb>foo<rb>bar')).to eq([
         [:T_ELEM_NAME, 'rb', 1],
         [:T_TEXT, 'foo', 1],
         [:T_ELEM_END, nil, 1],
         [:T_ELEM_NAME, 'rb', 1],
         [:T_TEXT, 'bar', 1],
         [:T_ELEM_END, nil, 1]
-      ]
+      ])
     end
 
     it 'lexes an unclosed <rb> followed by a <rt> as separate elements' do
-      lex_html('<rb>foo<rt>bar').should == [
+      expect(lex_html('<rb>foo<rt>bar')).to eq([
         [:T_ELEM_NAME, 'rb', 1],
         [:T_TEXT, 'foo', 1],
         [:T_ELEM_END, nil, 1],
         [:T_ELEM_NAME, 'rt', 1],
         [:T_TEXT, 'bar', 1],
         [:T_ELEM_END, nil, 1]
-      ]
+      ])
     end
   end
 end
diff --git a/spec/oga/html/lexer/closing_rules/rp_spec.rb b/spec/oga/html/lexer/closing_rules/rp_spec.rb
index 765fd20..2cdfeee 100644
--- a/spec/oga/html/lexer/closing_rules/rp_spec.rb
+++ b/spec/oga/html/lexer/closing_rules/rp_spec.rb
@@ -3,25 +3,25 @@ require 'spec_helper'
 describe Oga::XML::Lexer do
   describe 'using HTML <rp> elements' do
     it 'lexes two unclosed <rp> elements following each other as separate elements' do
-      lex_html('<rp>foo<rp>bar').should == [
+      expect(lex_html('<rp>foo<rp>bar')).to eq([
         [:T_ELEM_NAME, 'rp', 1],
         [:T_TEXT, 'foo', 1],
         [:T_ELEM_END, nil, 1],
         [:T_ELEM_NAME, 'rp', 1],
         [:T_TEXT, 'bar', 1],
         [:T_ELEM_END, nil, 1]
-      ]
+      ])
     end
 
     it 'lexes an unclosed <rp> followed by a <rb> as separate elements' do
-      lex_html('<rp>foo<rb>bar').should == [
+      expect(lex_html('<rp>foo<rb>bar')).to eq([
         [:T_ELEM_NAME, 'rp', 1],
         [:T_TEXT, 'foo', 1],
         [:T_ELEM_END, nil, 1],
         [:T_ELEM_NAME, 'rb', 1],
         [:T_TEXT, 'bar', 1],
         [:T_ELEM_END, nil, 1]
-      ]
+      ])
     end
   end
 end
diff --git a/spec/oga/html/lexer/closing_rules/rt_spec.rb b/spec/oga/html/lexer/closing_rules/rt_spec.rb
index ec3a60b..f592297 100644
--- a/spec/oga/html/lexer/closing_rules/rt_spec.rb
+++ b/spec/oga/html/lexer/closing_rules/rt_spec.rb
@@ -3,25 +3,25 @@ require 'spec_helper'
 describe Oga::XML::Lexer do
   describe 'using HTML <rt> elements' do
     it 'lexes two unclosed <rt> elements following each other as separate elements' do
-      lex_html('<rt>foo<rt>bar').should == [
+      expect(lex_html('<rt>foo<rt>bar')).to eq([
         [:T_ELEM_NAME, 'rt', 1],
         [:T_TEXT, 'foo', 1],
         [:T_ELEM_END, nil, 1],
         [:T_ELEM_NAME, 'rt', 1],
         [:T_TEXT, 'bar', 1],
         [:T_ELEM_END, nil, 1]
-      ]
+      ])
     end
 
     it 'lexes an unclosed <rt> followed by a <rtc> as separate elements' do
-      lex_html('<rt>foo<rtc>bar').should == [
+      expect(lex_html('<rt>foo<rtc>bar')).to eq([
         [:T_ELEM_NAME, 'rt', 1],
         [:T_TEXT, 'foo', 1],
         [:T_ELEM_END, nil, 1],
         [:T_ELEM_NAME, 'rtc', 1],
         [:T_TEXT, 'bar', 1],
         [:T_ELEM_END, nil, 1]
-      ]
+      ])
     end
   end
 end
diff --git a/spec/oga/html/lexer/closing_rules/rtc_spec.rb b/spec/oga/html/lexer/closing_rules/rtc_spec.rb
index 2ed7cce..2c222ae 100644
--- a/spec/oga/html/lexer/closing_rules/rtc_spec.rb
+++ b/spec/oga/html/lexer/closing_rules/rtc_spec.rb
@@ -3,25 +3,25 @@ require 'spec_helper'
 describe Oga::XML::Lexer do
   describe 'using HTML <rt> elements' do
     it 'lexes two unclosed <rtc> elements following each other as separate elements' do
-      lex_html('<rtc>foo<rtc>bar').should == [
+      expect(lex_html('<rtc>foo<rtc>bar')).to eq([
         [:T_ELEM_NAME, 'rtc', 1],
         [:T_TEXT, 'foo', 1],
         [:T_ELEM_END, nil, 1],
         [:T_ELEM_NAME, 'rtc', 1],
         [:T_TEXT, 'bar', 1],
         [:T_ELEM_END, nil, 1]
-      ]
+      ])
     end
 
     it 'lexes an unclosed <rtc> followed by a <rb> as separate elements' do
-      lex_html('<rtc>foo<rb>bar').should == [
+      expect(lex_html('<rtc>foo<rb>bar')).to eq([
         [:T_ELEM_NAME, 'rtc', 1],
         [:T_TEXT, 'foo', 1],
         [:T_ELEM_END, nil, 1],
         [:T_ELEM_NAME, 'rb', 1],
         [:T_TEXT, 'bar', 1],
         [:T_ELEM_END, nil, 1]
-      ]
+      ])
     end
   end
 end
diff --git a/spec/oga/html/lexer/closing_rules/table_spec.rb b/spec/oga/html/lexer/closing_rules/table_spec.rb
index 160f80c..60222f3 100644
--- a/spec/oga/html/lexer/closing_rules/table_spec.rb
+++ b/spec/oga/html/lexer/closing_rules/table_spec.rb
@@ -3,44 +3,44 @@ require 'spec_helper'
 describe Oga::XML::Lexer do
   describe 'using HTML <table> elements' do
     it 'lexes two unclosed <table> elements following each other as separate elements' do
-      lex_html('<table>foo<table>bar').should == [
+      expect(lex_html('<table>foo<table>bar')).to eq([
         [:T_ELEM_NAME, 'table', 1],
         [:T_TEXT, 'foo', 1],
         [:T_ELEM_END, nil, 1],
         [:T_ELEM_NAME, 'table', 1],
         [:T_TEXT, 'bar', 1],
         [:T_ELEM_END, nil, 1]
-      ]
+      ])
     end
 
     it 'lexes a <table> element containing a <thead> element' do
-      lex_html('<table><thead>foo</thead></table>').should == [
+      expect(lex_html('<table><thead>foo</thead></table>')).to eq([
         [:T_ELEM_NAME, 'table', 1],
         [:T_ELEM_NAME, 'thead', 1],
         [:T_TEXT, 'foo', 1],
         [:T_ELEM_END, nil, 1],
         [:T_ELEM_END, nil, 1]
-      ]
+      ])
     end
 
     it 'lexes a <table> element containing a <script> element' do
-      lex_html('<table><script>foo</script></table>').should == [
+      expect(lex_html('<table><script>foo</script></table>')).to eq([
         [:T_ELEM_NAME, 'table', 1],
         [:T_ELEM_NAME, 'script', 1],
         [:T_TEXT, 'foo', 1],
         [:T_ELEM_END, nil, 1],
         [:T_ELEM_END, nil, 1]
-      ]
+      ])
     end
 
     it 'lexes a <table> element containing a <template> element' do
-      lex_html('<table><template>foo</template></table>').should == [
+      expect(lex_html('<table><template>foo</template></table>')).to eq([
         [:T_ELEM_NAME, 'table', 1],
         [:T_ELEM_NAME, 'template', 1],
         [:T_TEXT, 'foo', 1],
         [:T_ELEM_END, nil, 1],
         [:T_ELEM_END, nil, 1]
-      ]
+      ])
     end
   end
 end
diff --git a/spec/oga/html/lexer/closing_rules/tbody_spec.rb b/spec/oga/html/lexer/closing_rules/tbody_spec.rb
index 4864dae..9967ea5 100644
--- a/spec/oga/html/lexer/closing_rules/tbody_spec.rb
+++ b/spec/oga/html/lexer/closing_rules/tbody_spec.rb
@@ -3,55 +3,55 @@ require 'spec_helper'
 describe Oga::XML::Lexer do
   describe 'using HTML <tbody> elements' do
     it 'lexes two unclosed <tbody> elements following each other as separate elements' do
-      lex_html('<tbody>foo<tbody>bar').should == [
+      expect(lex_html('<tbody>foo<tbody>bar')).to eq([
         [:T_ELEM_NAME, 'tbody', 1],
         [:T_TEXT, 'foo', 1],
         [:T_ELEM_END, nil, 1],
         [:T_ELEM_NAME, 'tbody', 1],
         [:T_TEXT, 'bar', 1],
         [:T_ELEM_END, nil, 1]
-      ]
+      ])
     end
 
     it 'lexes an unclosed <tbody> followed by a <tfoot> as separate elements' do
-      lex_html('<tbody>foo<tfoot>bar').should == [
+      expect(lex_html('<tbody>foo<tfoot>bar')).to eq([
         [:T_ELEM_NAME, 'tbody', 1],
         [:T_TEXT, 'foo', 1],
         [:T_ELEM_END, nil, 1],
         [:T_ELEM_NAME, 'tfoot', 1],
         [:T_TEXT, 'bar', 1],
         [:T_ELEM_END, nil, 1]
-      ]
+      ])
     end
 
     it 'lexes a <tr> following an unclosed <tbody> as a child element' do
-      lex_html('<tbody><tr>foo').should == [
+      expect(lex_html('<tbody><tr>foo')).to eq([
         [:T_ELEM_NAME, 'tbody', 1],
         [:T_ELEM_NAME, 'tr', 1],
         [:T_TEXT, 'foo', 1],
         [:T_ELEM_END, nil, 1],
         [:T_ELEM_END, nil, 1]
-      ]
+      ])
     end
 
     it 'lexes a <tbody> element containing a <script> element' do
-      lex_html('<tbody><script>foo</script></tbody>').should == [
+      expect(lex_html('<tbody><script>foo</script></tbody>')).to eq([
         [:T_ELEM_NAME, 'tbody', 1],
         [:T_ELEM_NAME, 'script', 1],
         [:T_TEXT, 'foo', 1],
         [:T_ELEM_END, nil, 1],
         [:T_ELEM_END, nil, 1]
-      ]
+      ])
     end
 
     it 'lexes a <tbody> element containing a <template> element' do
-      lex_html('<tbody><template>foo</template></tbody>').should == [
+      expect(lex_html('<tbody><template>foo</template></tbody>')).to eq([
         [:T_ELEM_NAME, 'tbody', 1],
         [:T_ELEM_NAME, 'template', 1],
         [:T_TEXT, 'foo', 1],
         [:T_ELEM_END, nil, 1],
         [:T_ELEM_END, nil, 1]
-      ]
+      ])
     end
   end
 end
diff --git a/spec/oga/html/lexer/closing_rules/td_spec.rb b/spec/oga/html/lexer/closing_rules/td_spec.rb
index 0e4de3c..4a4da74 100644
--- a/spec/oga/html/lexer/closing_rules/td_spec.rb
+++ b/spec/oga/html/lexer/closing_rules/td_spec.rb
@@ -3,35 +3,35 @@ require 'spec_helper'
 describe Oga::XML::Lexer do
   describe 'using HTML <td> elements' do
     it 'lexes two unclosed <td> elements following each other as separate elements' do
-      lex_html('<td>foo<td>bar').should == [
+      expect(lex_html('<td>foo<td>bar')).to eq([
         [:T_ELEM_NAME, 'td', 1],
         [:T_TEXT, 'foo', 1],
         [:T_ELEM_END, nil, 1],
         [:T_ELEM_NAME, 'td', 1],
         [:T_TEXT, 'bar', 1],
         [:T_ELEM_END, nil, 1]
-      ]
+      ])
     end
 
     it 'lexes an unclosed <td> followed by a <thead> as separate elements' do
-      lex_html('<td>foo<thead>bar').should == [
+      expect(lex_html('<td>foo<thead>bar')).to eq([
         [:T_ELEM_NAME, 'td', 1],
         [:T_TEXT, 'foo', 1],
         [:T_ELEM_END, nil, 1],
         [:T_ELEM_NAME, 'thead', 1],
         [:T_TEXT, 'bar', 1],
         [:T_ELEM_END, nil, 1]
-      ]
+      ])
     end
 
     it 'lexes a <p> followed an unclosed <td> as a child element' do
-      lex_html('<td><p>foo').should == [
+      expect(lex_html('<td><p>foo')).to eq([
         [:T_ELEM_NAME, 'td', 1],
         [:T_ELEM_NAME, 'p', 1],
         [:T_TEXT, 'foo', 1],
         [:T_ELEM_END, nil, 1],
         [:T_ELEM_END, nil, 1]
-      ]
+      ])
     end
   end
 end
diff --git a/spec/oga/html/lexer/closing_rules/tfoot_spec.rb b/spec/oga/html/lexer/closing_rules/tfoot_spec.rb
index 2bf2c90..6b296e1 100644
--- a/spec/oga/html/lexer/closing_rules/tfoot_spec.rb
+++ b/spec/oga/html/lexer/closing_rules/tfoot_spec.rb
@@ -3,55 +3,55 @@ require 'spec_helper'
 describe Oga::XML::Lexer do
   describe 'using HTML <tfoot> elements' do
     it 'lexes two unclosed <tfoot> elements following each other as separate elements' do
-      lex_html('<tfoot>foo<tfoot>bar').should == [
+      expect(lex_html('<tfoot>foo<tfoot>bar')).to eq([
         [:T_ELEM_NAME, 'tfoot', 1],
         [:T_TEXT, 'foo', 1],
         [:T_ELEM_END, nil, 1],
         [:T_ELEM_NAME, 'tfoot', 1],
         [:T_TEXT, 'bar', 1],
         [:T_ELEM_END, nil, 1]
-      ]
+      ])
     end
 
     it 'lexes an unclosed <tfoot> followed by a <tbody> as separate elements' do
-      lex_html('<tfoot>foo<tbody>bar').should == [
+      expect(lex_html('<tfoot>foo<tbody>bar')).to eq([
         [:T_ELEM_NAME, 'tfoot', 1],
         [:T_TEXT, 'foo', 1],
         [:T_ELEM_END, nil, 1],
         [:T_ELEM_NAME, 'tbody', 1],
         [:T_TEXT, 'bar', 1],
         [:T_ELEM_END, nil, 1]
-      ]
+      ])
     end
 
     it 'lexes a <tr> following an unclosed <tfoot> as a child element' do
-      lex_html('<tfoot><tr>foo').should == [
+      expect(lex_html('<tfoot><tr>foo')).to eq([
         [:T_ELEM_NAME, 'tfoot', 1],
         [:T_ELEM_NAME, 'tr', 1],
         [:T_TEXT, 'foo', 1],
         [:T_ELEM_END, nil, 1],
         [:T_ELEM_END, nil, 1]
-      ]
+      ])
     end
 
     it 'lexes a <tfoot> element containing a <script> element' do
-      lex_html('<tfoot><script>foo</script></tfoot>').should == [
+      expect(lex_html('<tfoot><script>foo</script></tfoot>')).to eq([
         [:T_ELEM_NAME, 'tfoot', 1],
         [:T_ELEM_NAME, 'script', 1],
         [:T_TEXT, 'foo', 1],
         [:T_ELEM_END, nil, 1],
         [:T_ELEM_END, nil, 1]
-      ]
+      ])
     end
 
     it 'lexes a <tfoot> element containing a <template> element' do
-      lex_html('<tfoot><template>foo</template></tfoot>').should == [
+      expect(lex_html('<tfoot><template>foo</template></tfoot>')).to eq([
         [:T_ELEM_NAME, 'tfoot', 1],
         [:T_ELEM_NAME, 'template', 1],
         [:T_TEXT, 'foo', 1],
         [:T_ELEM_END, nil, 1],
         [:T_ELEM_END, nil, 1]
-      ]
+      ])
     end
   end
 end
diff --git a/spec/oga/html/lexer/closing_rules/th_spec.rb b/spec/oga/html/lexer/closing_rules/th_spec.rb
index e4096a1..28992d5 100644
--- a/spec/oga/html/lexer/closing_rules/th_spec.rb
+++ b/spec/oga/html/lexer/closing_rules/th_spec.rb
@@ -3,35 +3,35 @@ require 'spec_helper'
 describe Oga::XML::Lexer do
   describe 'using HTML <th> elements' do
     it 'lexes two unclosed <th> elements following each other as separate elements' do
-      lex_html('<th>foo<th>bar').should == [
+      expect(lex_html('<th>foo<th>bar')).to eq([
         [:T_ELEM_NAME, 'th', 1],
         [:T_TEXT, 'foo', 1],
         [:T_ELEM_END, nil, 1],
         [:T_ELEM_NAME, 'th', 1],
         [:T_TEXT, 'bar', 1],
         [:T_ELEM_END, nil, 1]
-      ]
+      ])
     end
 
     it 'lexes an unclosed <th> followed by a <thead> as separate elements' do
-      lex_html('<th>foo<thead>bar').should == [
+      expect(lex_html('<th>foo<thead>bar')).to eq([
         [:T_ELEM_NAME, 'th', 1],
         [:T_TEXT, 'foo', 1],
         [:T_ELEM_END, nil, 1],
         [:T_ELEM_NAME, 'thead', 1],
         [:T_TEXT, 'bar', 1],
         [:T_ELEM_END, nil, 1]
-      ]
+      ])
     end
 
     it 'lexes a <p> followed an unclosed <th> as a child element' do
-      lex_html('<th><p>foo').should == [
+      expect(lex_html('<th><p>foo')).to eq([
         [:T_ELEM_NAME, 'th', 1],
         [:T_ELEM_NAME, 'p', 1],
         [:T_TEXT, 'foo', 1],
         [:T_ELEM_END, nil, 1],
         [:T_ELEM_END, nil, 1]
-      ]
+      ])
     end
   end
 end
diff --git a/spec/oga/html/lexer/closing_rules/thead_spec.rb b/spec/oga/html/lexer/closing_rules/thead_spec.rb
index f9b1d71..760f522 100644
--- a/spec/oga/html/lexer/closing_rules/thead_spec.rb
+++ b/spec/oga/html/lexer/closing_rules/thead_spec.rb
@@ -3,55 +3,55 @@ require 'spec_helper'
 describe Oga::XML::Lexer do
   describe 'using HTML <thead> elements' do
     it 'lexes two unclosed <thead> elements following each other as separate elements' do
-      lex_html('<thead>foo<thead>bar').should == [
+      expect(lex_html('<thead>foo<thead>bar')).to eq([
         [:T_ELEM_NAME, 'thead', 1],
         [:T_TEXT, 'foo', 1],
         [:T_ELEM_END, nil, 1],
         [:T_ELEM_NAME, 'thead', 1],
         [:T_TEXT, 'bar', 1],
         [:T_ELEM_END, nil, 1]
-      ]
+      ])
     end
 
     it 'lexes an unclosed <thead> followed by a <tbody> as separate elements' do
-      lex_html('<thead>foo<tbody>bar').should == [
+      expect(lex_html('<thead>foo<tbody>bar')).to eq([
         [:T_ELEM_NAME, 'thead', 1],
         [:T_TEXT, 'foo', 1],
         [:T_ELEM_END, nil, 1],
         [:T_ELEM_NAME, 'tbody', 1],
         [:T_TEXT, 'bar', 1],
         [:T_ELEM_END, nil, 1]
-      ]
+      ])
     end
 
     it 'lexes a <tr> following an unclosed <thead> as a child element' do
-      lex_html('<thead><tr>foo').should == [
+      expect(lex_html('<thead><tr>foo')).to eq([
         [:T_ELEM_NAME, 'thead', 1],
         [:T_ELEM_NAME, 'tr', 1],
         [:T_TEXT, 'foo', 1],
         [:T_ELEM_END, nil, 1],
         [:T_ELEM_END, nil, 1]
-      ]
+      ])
     end
 
     it 'lexes a <thead> element containing a <script> element' do
-      lex_html('<thead><script>foo</script></thead>').should == [
+      expect(lex_html('<thead><script>foo</script></thead>')).to eq([
         [:T_ELEM_NAME, 'thead', 1],
         [:T_ELEM_NAME, 'script', 1],
         [:T_TEXT, 'foo', 1],
         [:T_ELEM_END, nil, 1],
         [:T_ELEM_END, nil, 1]
-      ]
+      ])
     end
 
     it 'lexes a <thead> element containing a <template> element' do
-      lex_html('<thead><template>foo</template></thead>').should == [
+      expect(lex_html('<thead><template>foo</template></thead>')).to eq([
         [:T_ELEM_NAME, 'thead', 1],
         [:T_ELEM_NAME, 'template', 1],
         [:T_TEXT, 'foo', 1],
         [:T_ELEM_END, nil, 1],
         [:T_ELEM_END, nil, 1]
-      ]
+      ])
     end
   end
 end
diff --git a/spec/oga/html/lexer/closing_rules/tr_spec.rb b/spec/oga/html/lexer/closing_rules/tr_spec.rb
index 4952b17..3a9acf8 100644
--- a/spec/oga/html/lexer/closing_rules/tr_spec.rb
+++ b/spec/oga/html/lexer/closing_rules/tr_spec.rb
@@ -3,54 +3,54 @@ require 'spec_helper'
 describe Oga::XML::Lexer do
   describe 'using HTML <tr> elements' do
     it 'lexes two unclosed <tr> elements following each other as separate elements' do
-      lex_html('<tr>foo<tr>bar').should == [
+      expect(lex_html('<tr>foo<tr>bar')).to eq([
         [:T_ELEM_NAME, 'tr', 1],
         [:T_TEXT, 'foo', 1],
         [:T_ELEM_END, nil, 1],
         [:T_ELEM_NAME, 'tr', 1],
         [:T_TEXT, 'bar', 1],
         [:T_ELEM_END, nil, 1]
-      ]
+      ])
     end
 
     it 'lexes a <td> followed an unclosed <tr> as a child element' do
-      lex_html('<tr><td>foo').should == [
+      expect(lex_html('<tr><td>foo')).to eq([
         [:T_ELEM_NAME, 'tr', 1],
         [:T_ELEM_NAME, 'td', 1],
         [:T_TEXT, 'foo', 1],
         [:T_ELEM_END, nil, 1],
         [:T_ELEM_END, nil, 1]
-      ]
+      ])
     end
 
     it 'lexes a <th> followed an unclosed <tr> as a child element' do
-      lex_html('<tr><th>foo').should == [
+      expect(lex_html('<tr><th>foo')).to eq([
         [:T_ELEM_NAME, 'tr', 1],
         [:T_ELEM_NAME, 'th', 1],
         [:T_TEXT, 'foo', 1],
         [:T_ELEM_END, nil, 1],
         [:T_ELEM_END, nil, 1]
-      ]
+      ])
     end
 
     it 'lexes a <tr> element containing a <script> element' do
-      lex_html('<tr><script>foo</script></tr>').should == [
+      expect(lex_html('<tr><script>foo</script></tr>')).to eq([
         [:T_ELEM_NAME, 'tr', 1],
         [:T_ELEM_NAME, 'script', 1],
         [:T_TEXT, 'foo', 1],
         [:T_ELEM_END, nil, 1],
         [:T_ELEM_END, nil, 1]
-      ]
+      ])
     end
 
     it 'lexes a <tr> element containing a <template> element' do
-      lex_html('<tr><template>foo</template></tr>').should == [
+      expect(lex_html('<tr><template>foo</template></tr>')).to eq([
         [:T_ELEM_NAME, 'tr', 1],
         [:T_ELEM_NAME, 'template', 1],
         [:T_TEXT, 'foo', 1],
         [:T_ELEM_END, nil, 1],
         [:T_ELEM_END, nil, 1]
-      ]
+      ])
     end
   end
 end
diff --git a/spec/oga/html/lexer/closing_rules/ul_spec.rb b/spec/oga/html/lexer/closing_rules/ul_spec.rb
index 39ae1a8..6328a71 100644
--- a/spec/oga/html/lexer/closing_rules/ul_spec.rb
+++ b/spec/oga/html/lexer/closing_rules/ul_spec.rb
@@ -3,7 +3,7 @@ require 'spec_helper'
 describe Oga::XML::Lexer do
   describe 'using HTML <ul> elements' do
     it 'lexes an <ul> element containing unclosed <li> elements with text' do
-      lex_html('<ul><li>foo<li>bar</ul>').should == [
+      expect(lex_html('<ul><li>foo<li>bar</ul>')).to eq([
         [:T_ELEM_NAME, 'ul', 1],
         [:T_ELEM_NAME, 'li', 1],
         [:T_TEXT, 'foo', 1],
@@ -12,11 +12,11 @@ describe Oga::XML::Lexer do
         [:T_TEXT, 'bar', 1],
         [:T_ELEM_END, nil, 1],
         [:T_ELEM_END, nil, 1]
-      ]
+      ])
     end
 
     it 'lexes an <ul> element followed by text containing unclosed <li> elements with text' do
-      lex_html('<ul><li>foo<li>bar</ul>outside ul').should == [
+      expect(lex_html('<ul><li>foo<li>bar</ul>outside ul')).to eq([
         [:T_ELEM_NAME, 'ul', 1],
         [:T_ELEM_NAME, 'li', 1],
         [:T_TEXT, 'foo', 1],
@@ -26,11 +26,11 @@ describe Oga::XML::Lexer do
         [:T_ELEM_END, nil, 1],
         [:T_ELEM_END, nil, 1],
         [:T_TEXT, 'outside ul', 1]
-      ]
+      ])
     end
 
     it 'lexes nested <ul> elements containing unclosed <li> elements' do
-      lex_html('<ul><li><ul><li>foo</ul><li>bar</ul>').should == [
+      expect(lex_html('<ul><li><ul><li>foo</ul><li>bar</ul>')).to eq([
         [:T_ELEM_NAME, 'ul', 1],
         [:T_ELEM_NAME, 'li', 1],
         [:T_ELEM_NAME, 'ul', 1],
@@ -43,7 +43,7 @@ describe Oga::XML::Lexer do
         [:T_TEXT, 'bar', 1],
         [:T_ELEM_END, nil, 1],
         [:T_ELEM_END, nil, 1]
-      ]
+      ])
     end
   end
 end
diff --git a/spec/oga/html/lexer/elements_spec.rb b/spec/oga/html/lexer/elements_spec.rb
index 3988e8c..5a12141 100644
--- a/spec/oga/html/lexer/elements_spec.rb
+++ b/spec/oga/html/lexer/elements_spec.rb
@@ -3,10 +3,10 @@ require 'spec_helper'
 describe Oga::XML::Lexer do
   describe 'HTML elements' do
     it 'lexes an element containing an element namespace' do
-      lex_html('<foo:bar />').should == [
+      expect(lex_html('<foo:bar />')).to eq([
         [:T_ELEM_NAME, 'bar', 1],
         [:T_ELEM_END, nil, 1]
-      ]
+      ])
     end
   end
 end
diff --git a/spec/oga/html/lexer/inline_javascript_spec.rb b/spec/oga/html/lexer/inline_javascript_spec.rb
index ceb0537..e48ec59 100644
--- a/spec/oga/html/lexer/inline_javascript_spec.rb
+++ b/spec/oga/html/lexer/inline_javascript_spec.rb
@@ -7,54 +7,54 @@ describe Oga::XML::Lexer do
     end
 
     it 'lexes inline Javascript' do
-      lex("<script>#{@javascript}</script>").should == [
+      expect(lex("<script>#{@javascript}</script>")).to eq([
         [:T_ELEM_NAME, 'script', 1],
         [:T_TEXT, @javascript, 1],
         [:T_ELEM_END, nil, 1]
-      ]
+      ])
     end
 
     it 'lexes inline Javascript containing an XML comment' do
-      lex("<script>#{@javascript}<!--foo--></script>").should == [
+      expect(lex("<script>#{@javascript}<!--foo--></script>")).to eq([
         [:T_ELEM_NAME, 'script', 1],
         [:T_TEXT, @javascript, 1],
         [:T_COMMENT_START, nil, 1],
         [:T_COMMENT_BODY, 'foo', 1],
         [:T_COMMENT_END, nil, 1],
         [:T_ELEM_END, nil, 1]
-      ]
+      ])
     end
 
     it 'lexes inline Javascript containing a CDATA tag' do
-      lex("<script>#{@javascript}<![CDATA[foo]]></script>").should == [
+      expect(lex("<script>#{@javascript}<![CDATA[foo]]></script>")).to eq([
         [:T_ELEM_NAME, 'script', 1],
         [:T_TEXT, @javascript, 1],
         [:T_CDATA_START, nil, 1],
         [:T_CDATA_BODY, 'foo', 1],
         [:T_CDATA_END, nil, 1],
         [:T_ELEM_END, nil, 1]
-      ]
+      ])
     end
 
     it 'lexes inline Javascript containing a processing instruction' do
-      lex("<script>#{@javascript}<?foo?></script>").should == [
+      expect(lex("<script>#{@javascript}<?foo?></script>")).to eq([
         [:T_ELEM_NAME, 'script', 1],
         [:T_TEXT, @javascript, 1],
         [:T_PROC_INS_START, nil, 1],
         [:T_PROC_INS_NAME, 'foo', 1],
         [:T_PROC_INS_END, nil, 1],
         [:T_ELEM_END, nil, 1]
-      ]
+      ])
     end
 
     it 'lexes inline Javascript containing another element' do
-      lex("<script>#{@javascript}<p></p></script>").should == [
+      expect(lex("<script>#{@javascript}<p></p></script>")).to eq([
         [:T_ELEM_NAME, 'script', 1],
         [:T_TEXT, @javascript, 1],
         [:T_ELEM_NAME, 'p', 1],
         [:T_ELEM_END, nil, 1],
         [:T_ELEM_END, nil, 1]
-      ]
+      ])
     end
   end
 end
diff --git a/spec/oga/html/lexer/script_spec.rb b/spec/oga/html/lexer/script_spec.rb
index 8c9a31a..7bf9a29 100644
--- a/spec/oga/html/lexer/script_spec.rb
+++ b/spec/oga/html/lexer/script_spec.rb
@@ -3,24 +3,24 @@ require 'spec_helper'
 describe Oga::XML::Lexer do
   describe 'HTML script elements' do
     it 'treats the content of a script tag as plain text' do
-      lex_html('<script>foo <bar</script>').should == [
+      expect(lex_html('<script>foo <bar</script>')).to eq([
         [:T_ELEM_NAME, 'script', 1],
         [:T_TEXT, 'foo ', 1],
         [:T_TEXT, '<', 1],
         [:T_TEXT, 'bar', 1],
         [:T_ELEM_END, nil, 1]
-      ]
+      ])
     end
 
     it 'treats style tags inside script tags as text' do
-      lex_html('<script><style></style></script>').should == [
+      expect(lex_html('<script><style></style></script>')).to eq([
         [:T_ELEM_NAME, 'script', 1],
         [:T_TEXT, '<', 1],
         [:T_TEXT, 'style>', 1],
         [:T_TEXT, '<', 1],
         [:T_TEXT, '/style>', 1],
         [:T_ELEM_END, nil, 1]
-      ]
+      ])
     end
   end
 end
diff --git a/spec/oga/html/lexer/style_spec.rb b/spec/oga/html/lexer/style_spec.rb
index 6d47b8f..09a6f53 100644
--- a/spec/oga/html/lexer/style_spec.rb
+++ b/spec/oga/html/lexer/style_spec.rb
@@ -3,48 +3,48 @@ require 'spec_helper'
 describe Oga::XML::Lexer do
   describe 'HTML style elements' do
     it 'lexes an empty <style> tag' do
-      lex_html('<style></style>').should == [
+      expect(lex_html('<style></style>')).to eq([
         [:T_ELEM_NAME, 'style', 1],
         [:T_ELEM_END, nil, 1]
-      ]
+      ])
     end
 
     it 'treats the content of a style tag as plain text' do
-      lex_html('<style>foo <bar</style>').should == [
+      expect(lex_html('<style>foo <bar</style>')).to eq([
         [:T_ELEM_NAME, 'style', 1],
         [:T_TEXT, 'foo ', 1],
         [:T_TEXT, '<', 1],
         [:T_TEXT, 'bar', 1],
         [:T_ELEM_END, nil, 1]
-      ]
+      ])
     end
 
     it 'treats script tags inside style tags as text' do
-      lex_html('<style><script></script></style>').should == [
+      expect(lex_html('<style><script></script></style>')).to eq([
         [:T_ELEM_NAME, 'style', 1],
         [:T_TEXT, '<', 1],
         [:T_TEXT, 'script>', 1],
         [:T_TEXT, '<', 1],
         [:T_TEXT, '/script>', 1],
         [:T_ELEM_END, nil, 1]
-      ]
+      ])
     end
 
     it 'lexes a multi-line <style> tag using a String as the input' do
-      lex_html("<style>foo\nbar</style>").should == [
+      expect(lex_html("<style>foo\nbar</style>")).to eq([
         [:T_ELEM_NAME, 'style', 1],
         [:T_TEXT, "foo\nbar", 1],
         [:T_ELEM_END, nil, 2]
-      ]
+      ])
     end
 
     it 'lexes a multi-line <style> tag using an IO as the input' do
-      lex_stringio("<style>foo\nbar</style>", :html => true).should == [
+      expect(lex_stringio("<style>foo\nbar</style>", :html => true)).to eq([
         [:T_ELEM_NAME, 'style', 1],
         [:T_TEXT, "foo\n", 1],
         [:T_TEXT, 'bar', 2],
         [:T_ELEM_END, nil, 2]
-      ]
+      ])
     end
   end
 end
diff --git a/spec/oga/html/lexer/void_elements_spec.rb b/spec/oga/html/lexer/void_elements_spec.rb
index 0ad6dda..4d6438e 100644
--- a/spec/oga/html/lexer/void_elements_spec.rb
+++ b/spec/oga/html/lexer/void_elements_spec.rb
@@ -3,85 +3,85 @@ require 'spec_helper'
 describe Oga::XML::Lexer do
   describe 'HTML void elements' do
     it 'lexes a void element that omits the closing /' do
-      lex_html('<link>').should == [
+      expect(lex_html('<link>')).to eq([
         [:T_ELEM_NAME, 'link', 1],
         [:T_ELEM_END, nil, 1]
-      ]
+      ])
     end
 
     it 'lexes a upper case void element' do
-      lex_html('<BR>').should == [
+      expect(lex_html('<BR>')).to eq([
         [:T_ELEM_NAME, "BR", 1],
         [:T_ELEM_END, nil, 1]
-      ]
+      ])
     end
 
     it 'lexes text after a void element' do
-      lex_html('<link>foo').should == [
+      expect(lex_html('<link>foo')).to eq([
         [:T_ELEM_NAME, 'link', 1],
         [:T_ELEM_END, nil, 1],
         [:T_TEXT, 'foo', 1]
-      ]
+      ])
     end
 
     it 'lexes a void element inside another element' do
-      lex_html('<head><link></head>').should == [
+      expect(lex_html('<head><link></head>')).to eq([
         [:T_ELEM_NAME, 'head', 1],
         [:T_ELEM_NAME, 'link', 1],
         [:T_ELEM_END, nil, 1],
         [:T_ELEM_END, nil, 1]
-      ]
+      ])
     end
 
     it 'lexes a void element inside another element with whitespace' do
-      lex_html("<head><link>\n</head>").should == [
+      expect(lex_html("<head><link>\n</head>")).to eq([
         [:T_ELEM_NAME, 'head', 1],
         [:T_ELEM_NAME, 'link', 1],
         [:T_ELEM_END, nil, 1],
         [:T_TEXT, "\n", 1],
         [:T_ELEM_END, nil, 2]
-      ]
+      ])
     end
 
     it 'lexes a void element with an unquoted attribute value' do
-      lex_html('<br class=foo />').should == [
+      expect(lex_html('<br class=foo />')).to eq([
         [:T_ELEM_NAME, 'br', 1],
         [:T_ATTR, 'class', 1],
         [:T_STRING_SQUOTE, nil, 1],
         [:T_STRING_BODY, 'foo', 1],
         [:T_STRING_SQUOTE, nil, 1],
         [:T_ELEM_END, nil, 1]
-      ]
+      ])
     end
 
     describe 'without a space before the closing tag' do
       it 'lexes a void element' do
-        lex_html('<br/>').should == [
+        expect(lex_html('<br/>')).to eq([
           [:T_ELEM_NAME, 'br', 1],
           [:T_ELEM_END, nil, 1]
-        ]
+        ])
       end
 
       it 'lexes a void element with an attribute' do
-        lex_html('<br class="foo"/>').should == [
+        expect(lex_html('<br class="foo"/>')).to eq([
           [:T_ELEM_NAME, 'br', 1],
           [:T_ATTR, 'class', 1],
           [:T_STRING_DQUOTE, nil, 1],
           [:T_STRING_BODY, 'foo', 1],
           [:T_STRING_DQUOTE, nil, 1],
           [:T_ELEM_END, nil, 1]
-        ]
+        ])
       end
 
       it 'lexes a void element with an unquoted attribute value' do
-        lex_html('<br class=foo/>').should == [
+        expect(lex_html('<br class=foo/>')).to eq([
           [:T_ELEM_NAME, 'br', 1],
           [:T_ATTR, 'class', 1],
           [:T_STRING_SQUOTE, nil, 1],
           [:T_STRING_BODY, 'foo/', 1],
           [:T_STRING_SQUOTE, nil, 1],
           [:T_ELEM_END, nil, 1]
-        ]
+        ])
       end
     end
   end
diff --git a/spec/oga/html/parser/element_spec.rb b/spec/oga/html/parser/element_spec.rb
index ba077f4..ae1aa9d 100644
--- a/spec/oga/html/parser/element_spec.rb
+++ b/spec/oga/html/parser/element_spec.rb
@@ -7,11 +7,11 @@ describe Oga::HTML::Parser do
     end
 
     it 'returns an Element instance' do
-      @node.is_a?(Oga::XML::Element).should == true
+      expect(@node.is_a?(Oga::XML::Element)).to eq(true)
     end
 
     it 'sets the name of the element' do
-      @node.name.should == 'meta'
+      expect(@node.name).to eq('meta')
     end
   end
 end
diff --git a/spec/oga/html/sax_parser_spec.rb b/spec/oga/html/sax_parser_spec.rb
index 2552e97..42f10e5 100644
--- a/spec/oga/html/sax_parser_spec.rb
+++ b/spec/oga/html/sax_parser_spec.rb
@@ -17,6 +17,6 @@ describe Oga::HTML::SaxParser do
 
     parser.parse
 
-    handler.name.should == 'link'
+    expect(handler.name).to eq('link')
   end
 end
diff --git a/spec/oga/lru_spec.rb b/spec/oga/lru_spec.rb
index 19a3069..05609f8 100644
--- a/spec/oga/lru_spec.rb
+++ b/spec/oga/lru_spec.rb
@@ -7,7 +7,7 @@ describe Oga::LRU do
 
       cache.maximum = 20
 
-      cache.maximum.should == 20
+      expect(cache.maximum).to eq(20)
     end
 
     it 'resizes the cache when needed' do
@@ -18,20 +18,20 @@ describe Oga::LRU do
 
       cache.maximum = 1
 
-      cache.size.should == 1
-      cache.keys.should == [:b]
+      expect(cache.size).to eq(1)
+      expect(cache.keys).to eq([:b])
     end
   end
 
   describe '#maximum' do
     it 'returns the maximum amount of keys' do
-      described_class.new(5).maximum.should == 5
+      expect(described_class.new(5).maximum).to eq(5)
     end
   end
 
   describe '#[]' do
     it 'returns nil for a non existing key' do
-      described_class.new[:a].should be_nil
+      expect(described_class.new[:a]).to be_nil
     end
 
     it 'returns the value of an existing key' do
@@ -39,7 +39,7 @@ describe Oga::LRU do
 
       cache[:a] = 10
 
-      cache[:a].should == 10
+      expect(cache[:a]).to eq(10)
     end
   end
 
@@ -49,7 +49,7 @@ describe Oga::LRU do
 
       cache[:a] = 10
 
-      cache[:a].should == 10
+      expect(cache[:a]).to eq(10)
     end
 
     it 'resizes the cache if the new amount of keys exceeds the limit' do
@@ -58,7 +58,7 @@ describe Oga::LRU do
       cache[:a] = 10
       cache[:b] = 20
 
-      cache.keys.should == [:b]
+      expect(cache.keys).to eq([:b])
     end
 
     it 'adds duplicate keys at the end of the list of keys' do
@@ -68,7 +68,7 @@ describe Oga::LRU do
       cache[:b] = 20
       cache[:a] = 30
 
-      cache.keys.should == [:b, :a]
+      expect(cache.keys).to eq([:b, :a])
     end
 
     describe 'using multiple threads' do
@@ -81,7 +81,7 @@ describe Oga::LRU do
         end
 
         numbers.each do |number|
-          cache[number].should == number
+          expect(cache[number]).to eq(number)
         end
       end
 
@@ -93,7 +93,7 @@ describe Oga::LRU do
           cache[number] = number
         end
 
-        cache.size.should == 5
+        expect(cache.size).to eq(5)
       end
     end
   end
@@ -102,7 +102,7 @@ describe Oga::LRU do
     it 'sets a non existing key' do
       cache = described_class.new
 
-      cache.get_or_set(:a) { 10 }.should == 10
+      expect(cache.get_or_set(:a) { 10 }).to eq(10)
     end
 
     it 'returns the value of an existing key' do
@@ -110,14 +110,14 @@ describe Oga::LRU do
 
       cache[:a] = 10
 
-      cache.get_or_set(:a) { 20 }.should == 10
+      expect(cache.get_or_set(:a) { 20 }).to eq(10)
     end
 
     describe 'using multiple threads' do
       it 'only sets a key once' do
         cache = described_class.new
 
-        cache.should_receive(:[]=).once.and_call_original
+        expect(cache).to receive(:[]=).once.and_call_original
 
         each_in_parallel([1, 1, 1]) do |number|
           cache.get_or_set(number) { number }
@@ -133,7 +133,7 @@ describe Oga::LRU do
       cache[:a] = 10
       cache[:b] = 20
 
-      cache.keys.should == [:a, :b]
+      expect(cache.keys).to eq([:a, :b])
     end
 
     it 'returns the keys without any duplicates' do
@@ -142,7 +142,7 @@ describe Oga::LRU do
       cache[:a] = 10
       cache[:a] = 20
 
-      cache.keys.should == [:a]
+      expect(cache.keys).to eq([:a])
     end
   end
 
@@ -152,13 +152,13 @@ describe Oga::LRU do
 
       cache[:a] = 10
 
-      cache.key?(:a).should == true
+      expect(cache.key?(:a)).to eq(true)
     end
 
     it 'returns false for a non existing key' do
       cache = described_class.new
 
-      cache.key?(:a).should == false
+      expect(cache.key?(:a)).to eq(false)
     end
   end
 
@@ -170,13 +170,13 @@ describe Oga::LRU do
 
       cache.clear
 
-      cache.size.should == 0
+      expect(cache.size).to eq(0)
     end
   end
 
   describe '#size' do
     it 'returns 0 for an empty cache' do
-      described_class.new.size.should == 0
+      expect(described_class.new.size).to eq(0)
     end
 
     it 'returns the number of keys for a non empty cache' do
@@ -184,7 +184,7 @@ describe Oga::LRU do
 
       cache[:a] = 10
 
-      cache.size.should == 1
+      expect(cache.size).to eq(1)
     end
   end
 end
diff --git a/spec/oga/oga_spec.rb b/spec/oga/oga_spec.rb
index 067904e..fb4edf0 100644
--- a/spec/oga/oga_spec.rb
+++ b/spec/oga/oga_spec.rb
@@ -5,13 +5,13 @@ describe Oga do
     it 'parses an XML document' do
       document = described_class.parse_xml('<root>foo</root>')
 
-      document.is_a?(Oga::XML::Document).should == true
+      expect(document.is_a?(Oga::XML::Document)).to eq(true)
     end
 
     it 'raises an error when parsing an invalid document in strict mode' do
       block = proc { described_class.parse_xml('<root>foo', :strict => true) }
 
-      block.should raise_error(LL::ParserError)
+      expect(block).to raise_error(LL::ParserError)
     end
   end
 
@@ -19,7 +19,7 @@ describe Oga do
     it 'parses an HTML document' do
       document = described_class.parse_xml('<html><body></body></html>')
 
-      document.is_a?(Oga::XML::Document).should == true
+      expect(document.is_a?(Oga::XML::Document)).to eq(true)
     end
   end
 
@@ -39,19 +39,19 @@ describe Oga do
     it 'parses an XML document using the SAX parser' do
       described_class.sax_parse_xml(@handler, '<foo />')
 
-      @handler.name.should == 'foo'
+      expect(@handler.name).to eq('foo')
     end
 
     it 'raises an error when parsing an invalid XML document in strict mode' do
       block = proc { Oga.sax_parse_xml(@handler, '<foo>', :strict => true) }
 
-      block.should raise_error(LL::ParserError)
+      expect(block).to raise_error(LL::ParserError)
     end
 
     it 'parses an HTML document using the SAX parser' do
       described_class.sax_parse_html(@handler, '<link>')
 
-      @handler.name.should == 'link'
+      expect(@handler.name).to eq('link')
     end
   end
 end
diff --git a/spec/oga/ruby/generator_spec.rb b/spec/oga/ruby/generator_spec.rb
index 9addba4..d768d6f 100644
--- a/spec/oga/ruby/generator_spec.rb
+++ b/spec/oga/ruby/generator_spec.rb
@@ -11,7 +11,7 @@ describe Oga::Ruby::Generator do
       node2  = Oga::Ruby::Node.new(:lit, %w{20})
       joined = node1.followed_by(node2)
 
-      @generator.on_followed_by(joined).should == "10\n\n20"
+      expect(@generator.on_followed_by(joined)).to eq("10\n\n20")
     end
   end
 
@@ -21,7 +21,7 @@ describe Oga::Ruby::Generator do
       val    = Oga::Ruby::Node.new(:lit, %w{10})
       assign = var.assign(val)
 
-      @generator.on_assign(assign).should == 'number = 10'
+      expect(@generator.on_assign(assign)).to eq('number = 10')
     end
 
     describe 'using a followed_by node' do
@@ -30,7 +30,7 @@ describe Oga::Ruby::Generator do
       val    = Oga::Ruby::Node.new(:lit, %w{10})
       assign = var.assign(val.followed_by(val))
 
-      @generator.on_assign(assign).should == <<-EOF
+      expect(@generator.on_assign(assign)).to eq <<-EOF
 number = begin
   10
 
@@ -49,7 +49,7 @@ EOF
 
       assign = Oga::Ruby::Node.new(:massign, [[var1, var2], val])
 
-      @generator.on_massign(assign).should == 'foo, bar = 10'
+      expect(@generator.on_massign(assign)).to eq('foo, bar = 10')
     end
   end
 
@@ -58,7 +58,7 @@ EOF
       number = Oga::Ruby::Node.new(:lit, %w{10})
       node   = Oga::Ruby::Node.new(:begin, [number])
 
-      @generator.on_begin(node).should == <<-EOF
+      expect(@generator.on_begin(node)).to eq <<-EOF
 begin
   10
 end
@@ -72,7 +72,7 @@ end
       val = Oga::Ruby::Node.new(:lit, %w{10})
       eq  = var.eq(val)
 
-      @generator.on_eq(eq).should == 'number == 10'
+      expect(@generator.on_eq(eq)).to eq('number == 10')
     end
   end
 
@@ -82,7 +82,7 @@ end
       right     = Oga::Ruby::Node.new(:lit, %w{bar})
       condition = left.and(right)
 
-      @generator.on_and(condition).should == 'foo && bar'
+      expect(@generator.on_and(condition)).to eq('foo && bar')
     end
   end
 
@@ -92,7 +92,7 @@ end
       right     = Oga::Ruby::Node.new(:lit, %w{bar})
       condition = left.or(right)
 
-      @generator.on_or(condition).should == '(foo || bar)'
+      expect(@generator.on_or(condition)).to eq('(foo || bar)')
     end
   end
 
@@ -102,7 +102,7 @@ end
         Oga::Ruby::Node.new(:lit, %w{bar})
       end
 
-      @generator.on_if(statement).should == <<-EOF
+      expect(@generator.on_if(statement)).to eq <<-EOF
 if foo
   bar
 end
@@ -117,7 +117,7 @@ end
 
         statement = foo.if_true { bar }.else { baz }
 
-        @generator.on_if(statement).should == <<-EOF
+        expect(@generator.on_if(statement)).to eq <<-EOF
 if foo
   bar
 else
@@ -134,7 +134,7 @@ end
         Oga::Ruby::Node.new(:lit, %w{bar})
       end
 
-      @generator.on_while(statement).should == <<-EOF
+      expect(@generator.on_while(statement)).to eq <<-EOF
 while foo
   bar
 end
@@ -147,7 +147,7 @@ end
       it 'returns a String' do
         node = Oga::Ruby::Node.new(:lit, %w{number}).foobar
 
-        @generator.on_send(node).should == 'number.foobar'
+        expect(@generator.on_send(node)).to eq('number.foobar')
       end
     end
 
@@ -156,7 +156,7 @@ end
         arg  = Oga::Ruby::Node.new(:lit, %w{10})
         node = Oga::Ruby::Node.new(:lit, %w{number}).foobar(arg)
 
-        @generator.on_send(node).should == 'number.foobar(10)'
+        expect(@generator.on_send(node)).to eq('number.foobar(10)')
       end
     end
 
@@ -165,7 +165,7 @@ end
         arg  = Oga::Ruby::Node.new(:lit, %w{10})
         node = Oga::Ruby::Node.new(:lit, %w{number})[arg]
 
-        @generator.on_send(node).should == 'number[10]'
+        expect(@generator.on_send(node)).to eq('number[10]')
       end
     end
   end
@@ -177,7 +177,7 @@ end
           Oga::Ruby::Node.new(:lit, %w{10})
         end
 
-        @generator.on_block(node).should == <<-EOF
+        expect(@generator.on_block(node)).to eq <<-EOF
 number do ||
   10
 end
@@ -192,7 +192,7 @@ end
           Oga::Ruby::Node.new(:lit, %w{10})
         end
 
-        @generator.on_block(node).should == <<-EOF
+        expect(@generator.on_block(node)).to eq <<-EOF
 number do |foo|
   10
 end
@@ -207,7 +207,7 @@ end
       stop  = Oga::Ruby::Node.new(:lit, %w{20})
       node  = Oga::Ruby::Node.new(:range, [start, stop])
 
-      @generator.on_range(node).should == '(10..20)'
+      expect(@generator.on_range(node)).to eq('(10..20)')
     end
   end
 
@@ -215,7 +215,7 @@ end
     it 'returns a String' do
       node = Oga::Ruby::Node.new(:string, %w{foo})
 
-      @generator.on_string(node).should == '"foo"'
+      expect(@generator.on_string(node)).to eq('"foo"')
     end
   end
 
@@ -223,7 +223,7 @@ end
     it 'returns a String' do
       node = Oga::Ruby::Node.new(:symbol, [:foo])
 
-      @generator.on_symbol(node).should == ':foo'
+      expect(@generator.on_symbol(node)).to eq(':foo')
     end
   end
 
@@ -231,7 +231,7 @@ end
     it 'returns a String' do
       node = Oga::Ruby::Node.new(:lit, %w{foo})
 
-      @generator.on_lit(node).should == 'foo'
+      expect(@generator.on_lit(node)).to eq('foo')
     end
   end
 end
diff --git a/spec/oga/ruby/node_spec.rb b/spec/oga/ruby/node_spec.rb
index a840419..68485dd 100644
--- a/spec/oga/ruby/node_spec.rb
+++ b/spec/oga/ruby/node_spec.rb
@@ -5,7 +5,7 @@ describe Oga::Ruby::Node do
     it 'returns the type of the node as a Symbol' do
       node = described_class.new('foo')
 
-      node.type.should == :foo
+      expect(node.type).to eq(:foo)
     end
   end
 
@@ -13,7 +13,7 @@ describe Oga::Ruby::Node do
     it 'returns the children of the Node as an Array' do
       node = described_class.new(:foo, %w{10})
 
-      node.to_a.should == %w{10}
+      expect(node.to_a).to eq(%w{10})
     end
   end
 
@@ -22,8 +22,8 @@ describe Oga::Ruby::Node do
       number = described_class.new(:lit, %w{10})
       node   = number.to_array
 
-      node.type.should == :send
-      node.to_a.should == [number, :to_a]
+      expect(node.type).to eq(:send)
+      expect(node.to_a).to eq([number, :to_a])
     end
   end
 
@@ -33,8 +33,8 @@ describe Oga::Ruby::Node do
       right = described_class.new(:lit, %w{10})
       node  = left.assign(right)
 
-      node.type.should == :assign
-      node.to_a.should == [left, right]
+      expect(node.type).to eq(:assign)
+      expect(node.to_a).to eq([left, right])
     end
   end
 
@@ -44,8 +44,8 @@ describe Oga::Ruby::Node do
       right = described_class.new(:lit, %w{10})
       node  = left.eq(right)
 
-      node.type.should == :eq
-      node.to_a.should == [left, right]
+      expect(node.type).to eq(:eq)
+      expect(node.to_a).to eq([left, right])
     end
   end
 
@@ -55,8 +55,8 @@ describe Oga::Ruby::Node do
       right = described_class.new(:lit, %w{10})
       node  = left.and(right)
 
-      node.type.should == :and
-      node.to_a.should == [left, right]
+      expect(node.type).to eq(:and)
+      expect(node.to_a).to eq([left, right])
     end
   end
 
@@ -66,8 +66,8 @@ describe Oga::Ruby::Node do
       right = described_class.new(:lit, %w{10})
       node  = left.or(right)
 
-      node.type.should == :or
-      node.to_a.should == [left, right]
+      expect(node.type).to eq(:or)
+      expect(node.to_a).to eq([left, right])
     end
   end
 
@@ -76,8 +76,8 @@ describe Oga::Ruby::Node do
       node     = described_class.new(:lit, %w{foo})
       inverted = node.not
 
-      inverted.type.should == :send
-      inverted.to_a.should == [node, '!']
+      expect(inverted.type).to eq(:send)
+      expect(inverted.to_a).to eq([node, '!'])
     end
   end
 
@@ -86,13 +86,13 @@ describe Oga::Ruby::Node do
       left = described_class.new(:lit, %w{number})
       node = left.is_a?(String)
 
-      node.type.should == :send
+      expect(node.type).to eq(:send)
 
-      node.to_a[0].should == left
-      node.to_a[1].should == 'is_a?'
+      expect(node.to_a[0]).to eq(left)
+      expect(node.to_a[1]).to eq('is_a?')
 
-      node.to_a[2].type.should == :lit
-      node.to_a[2].to_a.should == %w{String}
+      expect(node.to_a[2].type).to eq(:lit)
+      expect(node.to_a[2].to_a).to eq(%w{String})
     end
   end
 
@@ -103,8 +103,8 @@ describe Oga::Ruby::Node do
       body  = described_class.new(:lit, %w{20})
       block = left.add_block(arg) { body }
 
-      block.type.should == :block
-      block.to_a.should == [left, [arg], body]
+      expect(block.type).to eq(:block)
+      expect(block.to_a).to eq([left, [arg], body])
     end
   end
 
@@ -113,8 +113,8 @@ describe Oga::Ruby::Node do
       number  = described_class.new(:lit, %w{10})
       wrapped = number.wrap
 
-      wrapped.type.should == :begin
-      wrapped.to_a.should == [number]
+      expect(wrapped.type).to eq(:begin)
+      expect(wrapped.to_a).to eq([number])
     end
   end
 
@@ -124,8 +124,8 @@ describe Oga::Ruby::Node do
       body      = described_class.new(:lit, %w{10})
       statement = condition.if_true { body }
 
-      statement.type.should == :if
-      statement.to_a.should == [condition, body]
+      expect(statement.type).to eq(:if)
+      expect(statement.to_a).to eq([condition, body])
     end
   end
 
@@ -135,12 +135,12 @@ describe Oga::Ruby::Node do
       body      = described_class.new(:lit, %w{10})
       statement = condition.if_false { body }
 
-      statement.type.should == :if
+      expect(statement.type).to eq(:if)
 
-      statement.to_a[0].type.should == :send
+      expect(statement.to_a[0].type).to eq(:send)
 
-      statement.to_a[0].to_a.should == [condition, '!']
-      statement.to_a[1].should      == body
+      expect(statement.to_a[0].to_a).to eq([condition, '!'])
+      expect(statement.to_a[1]).to      eq(body)
     end
   end
 
@@ -150,8 +150,8 @@ describe Oga::Ruby::Node do
       body      = described_class.new(:lit, %w{10})
       statement = condition.while_true { body }
 
-      statement.type.should == :while
-      statement.to_a.should == [condition, body]
+      expect(statement.type).to eq(:while)
+      expect(statement.to_a).to eq([condition, body])
     end
   end
 
@@ -162,8 +162,8 @@ describe Oga::Ruby::Node do
       or_else   = described_class.new(:lit, %w{20})
       statement = condition.if_true { body }.else { or_else }
 
-      statement.type.should == :if
-      statement.to_a.should == [condition, body, or_else]
+      expect(statement.type).to eq(:if)
+      expect(statement.to_a).to eq([condition, body, or_else])
     end
   end
 
@@ -174,8 +174,8 @@ describe Oga::Ruby::Node do
         node2  = described_class.new(:lit, %w{B})
         joined = node1.followed_by(node2)
 
-        joined.type.should == :followed_by
-        joined.to_a.should == [node1, node2]
+        expect(joined.type).to eq(:followed_by)
+        expect(joined.to_a).to eq([node1, node2])
       end
     end
 
@@ -185,8 +185,8 @@ describe Oga::Ruby::Node do
         node2  = described_class.new(:lit, %w{B})
         joined = node1.followed_by { node2 }
 
-        joined.type.should == :followed_by
-        joined.to_a.should == [node1, node2]
+        expect(joined.type).to eq(:followed_by)
+        expect(joined.to_a).to eq([node1, node2])
       end
     end
   end
@@ -197,8 +197,8 @@ describe Oga::Ruby::Node do
       arg      = described_class.new(:lit, %w{10})
       call     = receiver.foo(arg)
 
-      call.type.should == :send
-      call.to_a.should == [receiver, 'foo', arg]
+      expect(call.type).to eq(:send)
+      expect(call.to_a).to eq([receiver, 'foo', arg])
     end
   end
 
@@ -206,7 +206,7 @@ describe Oga::Ruby::Node do
     it 'returns a String' do
       node = described_class.new(:lit, %w{10})
 
-      node.inspect.should == '(lit "10")'
+      expect(node.inspect).to eq('(lit "10")')
     end
   end
 end
diff --git a/spec/oga/whitelist_spec.rb b/spec/oga/whitelist_spec.rb
index 85d5e45..91bc5f1 100644
--- a/spec/oga/whitelist_spec.rb
+++ b/spec/oga/whitelist_spec.rb
@@ -14,15 +14,15 @@ describe Oga::Whitelist do
     it 'returns false for a name not in the list' do
       list = described_class.new(%w{foo})
 
-      list.allow?('bar').should == false
-      list.allow?('BAR').should == false
+      expect(list.allow?('bar')).to eq(false)
+      expect(list.allow?('BAR')).to eq(false)
     end
 
     it 'returns true for a name in the list' do
       list = described_class.new(%w{foo})
 
-      list.allow?('foo').should == true
-      list.allow?('FOO').should == true
+      expect(list.allow?('foo')).to eq(true)
+      expect(list.allow?('FOO')).to eq(true)
     end
   end
 
@@ -32,8 +32,8 @@ describe Oga::Whitelist do
       list2 = described_class.new(%w{bar})
       list3 = list1 + list2
 
-      list3.should be_an_instance_of(described_class)
-      list3.names.to_a.should == %w{foo FOO bar BAR}
+      expect(list3).to be_an_instance_of(described_class)
+      expect(list3.names.to_a).to eq(%w{foo FOO bar BAR})
     end
   end
 
@@ -42,8 +42,8 @@ describe Oga::Whitelist do
       whitelist = described_class.new(%w{foo})
       blacklist = whitelist.to_blacklist
 
-      blacklist.should be_an_instance_of(Oga::Blacklist)
-      blacklist.names.should == whitelist.names
+      expect(blacklist).to be_an_instance_of(Oga::Blacklist)
+      expect(blacklist.names).to eq(whitelist.names)
     end
   end
 end
diff --git a/spec/oga/xml/attribute_spec.rb b/spec/oga/xml/attribute_spec.rb
index 809b1bc..094cf82 100644
--- a/spec/oga/xml/attribute_spec.rb
+++ b/spec/oga/xml/attribute_spec.rb
@@ -3,11 +3,11 @@ require 'spec_helper'
 describe Oga::XML::Attribute do
   describe '#initialize' do
     it 'sets the name' do
-      described_class.new(:name => 'a').name.should == 'a'
+      expect(described_class.new(:name => 'a').name).to eq('a')
     end
 
     it 'sets the value' do
-      described_class.new(:value => 'a').value.should == 'a'
+      expect(described_class.new(:value => 'a').value).to eq('a')
     end
   end
 
@@ -16,7 +16,7 @@ describe Oga::XML::Attribute do
       element = Oga::XML::Element.new(:name => 'foo')
       attr    = described_class.new(:element => element)
 
-      attr.parent.should == element
+      expect(attr.parent).to eq(element)
     end
   end
 
@@ -38,11 +38,11 @@ describe Oga::XML::Attribute do
     end
 
     it 'returns a Namespace instance' do
-      @attribute.namespace.should == @namespace
+      expect(@attribute.namespace).to eq(@namespace)
     end
 
     it 'returns the default XML namespace when the "xml" prefix is used' do
-      @default.namespace.should == Oga::XML::Attribute::DEFAULT_NAMESPACE
+      expect(@default.namespace).to eq(Oga::XML::Attribute::DEFAULT_NAMESPACE)
     end
   end
 
@@ -52,23 +52,23 @@ describe Oga::XML::Attribute do
 
       attr.value = 'foo'
 
-      attr.value.should == 'foo'
+      expect(attr.value).to eq('foo')
     end
 
     it 'flushes the decoded cache when setting a new value' do
       attr = described_class.new(:value => '&lt;')
 
-      attr.value.should == Oga::XML::Entities::DECODE_MAPPING['&lt;']
+      expect(attr.value).to eq(Oga::XML::Entities::DECODE_MAPPING['&lt;'])
 
       attr.value = '&gt;'
 
-      attr.value.should == Oga::XML::Entities::DECODE_MAPPING['&gt;']
+      expect(attr.value).to eq(Oga::XML::Entities::DECODE_MAPPING['&gt;'])
     end
   end
 
   describe '#value' do
     it 'returns the value of an attribute' do
-      described_class.new(:value => 'foo').value.should == 'foo'
+      expect(described_class.new(:value => 'foo').value).to eq('foo')
     end
 
     describe 'using an XML document' do
@@ -84,7 +84,7 @@ describe Oga::XML::Attribute do
           :element => @el
         )
 
-        attr.value.should == '<'
+        expect(attr.value).to eq('<')
       end
     end
 
@@ -101,18 +101,18 @@ describe Oga::XML::Attribute do
           :element => @el
         )
 
-        attr.value.should == Oga::HTML::Entities::DECODE_MAPPING['&copy;']
+        expect(attr.value).to eq(Oga::HTML::Entities::DECODE_MAPPING['&copy;'])
       end
     end
   end
 
   describe '#text' do
     it 'returns an empty String when there is no value' do
-      described_class.new.text.should == ''
+      expect(described_class.new.text).to eq('')
     end
 
     it 'returns the value if it is present' do
-      described_class.new(:value => 'a').text.should == 'a'
+      expect(described_class.new(:value => 'a').text).to eq('a')
     end
   end
 
@@ -120,7 +120,7 @@ describe Oga::XML::Attribute do
     it 'converts an attribute to XML' do
       attr = described_class.new(:name => 'foo', :value => 'bar')
 
-      attr.to_xml.should == 'foo="bar"'
+      expect(attr.to_xml).to eq('foo="bar"')
     end
 
     it 'includes the namespace when converting an attribute to XML' do
@@ -135,7 +135,7 @@ describe Oga::XML::Attribute do
         :element        => element
       )
 
-      attr.to_xml.should == 'foo:class="10"'
+      expect(attr.to_xml).to eq('foo:class="10"')
     end
 
     it 'includes the "xmlns" namespace when present but not registered' do
@@ -145,13 +145,13 @@ describe Oga::XML::Attribute do
         :element        => Oga::XML::Element.new
       )
 
-      attr.to_xml.should == 'xmlns:class=""'
+      expect(attr.to_xml).to eq('xmlns:class=""')
     end
 
     it 'decodes XML entities' do
       attr = described_class.new(:name => 'href', :value => %q{&<>'"})
 
-      attr.to_xml.should == 'href="&amp;&lt;&gt;&apos;&quot;"'
+      expect(attr.to_xml).to eq('href="&amp;&lt;&gt;&apos;&quot;"')
     end
   end
 
@@ -168,7 +168,7 @@ describe Oga::XML::Attribute do
         :element        => element
       )
 
-      obj.inspect.should == <<-EOF.strip
+      expect(obj.inspect).to eq <<-EOF.strip
 Attribute(name: "a" namespace: Namespace(name: "b" uri: nil) value: "c")
 EOF
     end
@@ -179,7 +179,7 @@ EOF
       it 'returns a String' do
         attr = described_class.new(:namespace_name => 'foo', :name => 'bar')
 
-        attr.expanded_name.should == 'foo:bar'
+        expect(attr.expanded_name).to eq('foo:bar')
       end
     end
 
@@ -187,7 +187,7 @@ EOF
       it 'returns a String' do
         attr = described_class.new(:name => 'bar')
 
-        attr.expanded_name.should == 'bar'
+        expect(attr.expanded_name).to eq('bar')
       end
     end
   end
diff --git a/spec/oga/xml/cdata_spec.rb b/spec/oga/xml/cdata_spec.rb
index 06ad695..a585b10 100644
--- a/spec/oga/xml/cdata_spec.rb
+++ b/spec/oga/xml/cdata_spec.rb
@@ -3,14 +3,14 @@ require 'spec_helper'
 describe Oga::XML::Cdata do
   describe 'setting attributes' do
     it 'sets the text via the constructor' do
-      described_class.new(:text => 'foo').text.should == 'foo'
+      expect(described_class.new(:text => 'foo').text).to eq('foo')
     end
 
     it 'sets the text via a setter' do
       instance = described_class.new
       instance.text = 'foo'
 
-      instance.text.should == 'foo'
+      expect(instance.text).to eq('foo')
     end
   end
 
@@ -20,7 +20,7 @@ describe Oga::XML::Cdata do
     end
 
     it 'generates the corresponding XML' do
-      @instance.to_xml.should == '<![CDATA[foo]]>'
+      expect(@instance.to_xml).to eq('<![CDATA[foo]]>')
     end
   end
 
@@ -30,7 +30,7 @@ describe Oga::XML::Cdata do
     end
 
     it 'returns the inspect value' do
-      @instance.inspect.should == 'Cdata("foo")'
+      expect(@instance.inspect).to eq('Cdata("foo")')
     end
   end
 end
diff --git a/spec/oga/xml/character_node_spec.rb b/spec/oga/xml/character_node_spec.rb
index 69ad9a5..aff38e5 100644
--- a/spec/oga/xml/character_node_spec.rb
+++ b/spec/oga/xml/character_node_spec.rb
@@ -3,20 +3,20 @@ require 'spec_helper'
 describe Oga::XML::CharacterNode do
   describe '#initialize' do
     it 'sets the text in the constructor' do
-      described_class.new(:text => 'a').text.should == 'a'
+      expect(described_class.new(:text => 'a').text).to eq('a')
     end
 
     it 'sets the text via an attribute' do
       node      = described_class.new
       node.text = 'a'
 
-      node.text.should == 'a'
+      expect(node.text).to eq('a')
     end
   end
 
   describe '#inspect' do
     it 'returns the inspect value' do
-      described_class.new(:text => 'a').inspect.should == 'CharacterNode("a")'
+      expect(described_class.new(:text => 'a').inspect).to eq('CharacterNode("a")')
     end
   end
 end
diff --git a/spec/oga/xml/comment_spec.rb b/spec/oga/xml/comment_spec.rb
index e523c38..10cd438 100644
--- a/spec/oga/xml/comment_spec.rb
+++ b/spec/oga/xml/comment_spec.rb
@@ -3,14 +3,14 @@ require 'spec_helper'
 describe Oga::XML::Comment do
   describe 'setting attributes' do
     it 'sets the text via the constructor' do
-      described_class.new(:text => 'foo').text.should == 'foo'
+      expect(described_class.new(:text => 'foo').text).to eq('foo')
     end
 
     it 'sets the text via a setter' do
       instance = described_class.new
       instance.text = 'foo'
 
-      instance.text.should == 'foo'
+      expect(instance.text).to eq('foo')
     end
   end
 
@@ -20,7 +20,7 @@ describe Oga::XML::Comment do
     end
 
     it 'generates the corresponding XML' do
-      @instance.to_xml.should == '<!--foo-->'
+      expect(@instance.to_xml).to eq('<!--foo-->')
     end
   end
 
@@ -30,7 +30,7 @@ describe Oga::XML::Comment do
     end
 
     it 'returns the inspect value' do
-      @instance.inspect.should == 'Comment("foo")'
+      expect(@instance.inspect).to eq('Comment("foo")')
     end
   end
 end
diff --git a/spec/oga/xml/doctype_spec.rb b/spec/oga/xml/doctype_spec.rb
index 639f39a..c5278c7 100644
--- a/spec/oga/xml/doctype_spec.rb
+++ b/spec/oga/xml/doctype_spec.rb
@@ -3,26 +3,26 @@ require 'spec_helper'
 describe Oga::XML::Doctype do
   describe 'setting attributes' do
     it 'sets the name via the constructor' do
-      described_class.new(:name => 'html').name.should == 'html'
+      expect(described_class.new(:name => 'html').name).to eq('html')
     end
 
     it 'sets the name via a setter' do
       instance = described_class.new
       instance.name = 'html'
 
-      instance.name.should == 'html'
+      expect(instance.name).to eq('html')
     end
   end
 
   describe '#to_xml' do
     it 'generates a bare minimum representation' do
-      described_class.new(:name => 'html').to_xml.should == '<!DOCTYPE html>'
+      expect(described_class.new(:name => 'html').to_xml).to eq('<!DOCTYPE html>')
     end
 
     it 'includes the type if present' do
       instance = described_class.new(:name => 'html', :type => 'PUBLIC')
 
-      instance.to_xml.should == '<!DOCTYPE html PUBLIC>'
+      expect(instance.to_xml).to eq('<!DOCTYPE html PUBLIC>')
     end
 
     it 'includes the public ID if present' do
@@ -32,7 +32,7 @@ describe Oga::XML::Doctype do
         :public_id => 'foo'
       )
 
-      instance.to_xml.should == '<!DOCTYPE html PUBLIC "foo">'
+      expect(instance.to_xml).to eq('<!DOCTYPE html PUBLIC "foo">')
     end
 
     it 'includes the system ID if present' do
@@ -43,7 +43,7 @@ describe Oga::XML::Doctype do
         :system_id => 'bar'
       )
 
-      instance.to_xml.should == '<!DOCTYPE html PUBLIC "foo" "bar">'
+      expect(instance.to_xml).to eq('<!DOCTYPE html PUBLIC "foo" "bar">')
     end
 
     it 'includes the inline rules if present' do
@@ -52,7 +52,7 @@ describe Oga::XML::Doctype do
         :inline_rules => '<!ELEMENT foo>'
       )
 
-      instance.to_xml.should == '<!DOCTYPE html [<!ELEMENT foo>]>'
+      expect(instance.to_xml).to eq('<!DOCTYPE html [<!ELEMENT foo>]>')
     end
   end
 
@@ -66,7 +66,7 @@ describe Oga::XML::Doctype do
     end
 
     it 'pretty-prints the node' do
-      @instance.inspect.should == <<-EOF.strip
+      expect(@instance.inspect).to eq <<-EOF.strip
 Doctype(name: "html" type: "PUBLIC" inline_rules: "<!ELEMENT foo>")
       EOF
     end
diff --git a/spec/oga/xml/document_spec.rb b/spec/oga/xml/document_spec.rb
index 6c2ed33..409d238 100644
--- a/spec/oga/xml/document_spec.rb
+++ b/spec/oga/xml/document_spec.rb
@@ -6,11 +6,11 @@ describe Oga::XML::Document do
       child    = Oga::XML::Comment.new(:text => 'foo')
       document = described_class.new(:children => [child])
 
-      document.children[0].should == child
+      expect(document.children[0]).to eq(child)
     end
 
     it 'sets the document type' do
-      described_class.new(:type => :html).type.should == :html
+      expect(described_class.new(:type => :html).type).to eq(:html)
     end
   end
 
@@ -21,7 +21,7 @@ describe Oga::XML::Document do
 
       document.children = [child]
 
-      document.children[0].should == child
+      expect(document.children[0]).to eq(child)
     end
 
     it 'sets the child nodes using a NodeSet' do
@@ -30,7 +30,7 @@ describe Oga::XML::Document do
 
       document.children = Oga::XML::NodeSet.new([child])
 
-      document.children[0].should == child
+      expect(document.children[0]).to eq(child)
     end
   end
 
@@ -38,7 +38,7 @@ describe Oga::XML::Document do
     it 'returns self' do
       doc = described_class.new
 
-      doc.root_node.should == doc
+      expect(doc.root_node).to eq(doc)
     end
   end
 
@@ -49,7 +49,7 @@ describe Oga::XML::Document do
     end
 
     it 'generates the corresponding XML' do
-      @document.to_xml.should == '<!--foo-->'
+      expect(@document.to_xml).to eq('<!--foo-->')
     end
   end
 
@@ -65,8 +65,8 @@ describe Oga::XML::Document do
     end
 
     it 'includes the XML of the declaration tag' do
-      @document.to_xml
-        .should == %Q{<?xml version="5.0" encoding="UTF-8" ?>\n<!--foo-->}
+      expect(@document.to_xml)
+        .to eq(%Q{<?xml version="5.0" encoding="UTF-8" ?>\n<!--foo-->})
     end
   end
 
@@ -82,7 +82,7 @@ describe Oga::XML::Document do
     end
 
     it 'includes the doctype' do
-      @document.to_xml.should == %Q{<!DOCTYPE html PUBLIC>\n<!--foo-->}
+      expect(@document.to_xml).to eq(%Q{<!DOCTYPE html PUBLIC>\n<!--foo-->})
     end
   end
 
@@ -100,18 +100,18 @@ describe Oga::XML::Document do
     end
 
     it 'includes the doctype and XML declaration' do
-      @document.to_xml.should == '<?xml version="5.0" encoding="UTF-8" ?>' \
-        "\n<!DOCTYPE html PUBLIC>\n<!--foo-->"
+      expect(@document.to_xml).to eq('<?xml version="5.0" encoding="UTF-8" ?>' \
+        "\n<!DOCTYPE html PUBLIC>\n<!--foo-->")
     end
   end
 
   describe '#html?' do
     it 'returns false for an XML document' do
-      described_class.new(:type => :xml).html?.should == false
+      expect(described_class.new(:type => :xml).html?).to eq(false)
     end
 
     it 'returns true for an HTML document' do
-      described_class.new(:type => :html).html?.should == true
+      expect(described_class.new(:type => :html).html?).to eq(true)
     end
   end
 
@@ -125,7 +125,7 @@ describe Oga::XML::Document do
     end
 
     it 'returns the inspect value' do
-      @instance.inspect.should == <<-EOF.strip
+      expect(@instance.inspect).to eq <<-EOF.strip
 Document(
   doctype: Doctype(name: "html")
   xml_declaration: XmlDeclaration(version: "1.0" encoding: "UTF-8")
@@ -135,7 +135,7 @@ Document(
     end
 
     it 'returns the inspect value of an empty document' do
-      described_class.new.inspect.should == <<-EOF.strip
+      expect(described_class.new.inspect).to eq <<-EOF.strip
 Document(
   children: NodeSet()
 )
@@ -145,7 +145,7 @@ Document(
 
   describe '#literal_html_name?' do
     it 'returns false' do
-      described_class.new.literal_html_name?.should == false
+      expect(described_class.new.literal_html_name?).to eq(false)
     end
   end
 end
diff --git a/spec/oga/xml/element_spec.rb b/spec/oga/xml/element_spec.rb
index 16455fe..82c8e3c 100644
--- a/spec/oga/xml/element_spec.rb
+++ b/spec/oga/xml/element_spec.rb
@@ -3,11 +3,11 @@ require 'spec_helper'
 describe Oga::XML::Element do
   describe '#initialize' do
     it 'sets the name via the constructor' do
-      described_class.new(:name => 'p').name.should == 'p'
+      expect(described_class.new(:name => 'p').name).to eq('p')
     end
 
     it 'sets the default attributes' do
-      described_class.new.attributes.should == []
+      expect(described_class.new.attributes).to eq([])
     end
 
     describe 'with a namespace' do
@@ -21,11 +21,11 @@ describe Oga::XML::Element do
       end
 
       it 'registers the "foo" namespace' do
-        @element.namespaces['foo'].is_a?(Oga::XML::Namespace).should == true
+        expect(@element.namespaces['foo'].is_a?(Oga::XML::Namespace)).to eq(true)
       end
 
       it 'keeps the attributes after registering the namespaces' do
-        @element.attributes.empty?.should == false
+        expect(@element.attributes.empty?).to eq(false)
       end
     end
 
@@ -37,7 +37,7 @@ describe Oga::XML::Element do
       end
 
       it 'registers the default namespace' do
-        @element.namespaces['xmlns'].is_a?(Oga::XML::Namespace).should == true
+        expect(@element.namespaces['xmlns'].is_a?(Oga::XML::Namespace)).to eq(true)
       end
     end
   end
@@ -48,7 +48,7 @@ describe Oga::XML::Element do
 
       element.namespace_name = 'foo'
 
-      element.namespace_name.should == 'foo'
+      expect(element.namespace_name).to eq('foo')
     end
   end
 
@@ -75,35 +75,35 @@ describe Oga::XML::Element do
     end
 
     it 'returns an attribute with only a name' do
-      @instance.attribute('key').value.should == 'value'
+      expect(@instance.attribute('key').value).to eq('value')
     end
 
     it 'returns an attribute with only a name when using a Symbol' do
-      @instance.attribute(:key).value.should == 'value'
+      expect(@instance.attribute(:key).value).to eq('value')
     end
 
     it 'returns an attribute with a name and namespace' do
-      @instance.attribute('x:key').value.should == 'foo'
+      expect(@instance.attribute('x:key').value).to eq('foo')
     end
 
     it 'returns an attribute with a name and namespace when using a Symbol' do
-      @instance.attribute(:'x:key').value.should == 'foo'
+      expect(@instance.attribute(:'x:key').value).to eq('foo')
     end
 
     it 'returns nil when the name matches but the namespace does not' do
-      @instance.attribute('y:key').nil?.should == true
+      expect(@instance.attribute('y:key').nil?).to eq(true)
     end
 
     it 'returns nil when the namespace matches but the name does not' do
-      @instance.attribute('x:foobar').nil?.should == true
+      expect(@instance.attribute('x:foobar').nil?).to eq(true)
     end
 
     it 'returns nil for a non existing attribute' do
-      @instance.attribute('foobar').nil?.should == true
+      expect(@instance.attribute('foobar').nil?).to eq(true)
     end
 
     it 'returns nil if an attribute has a namespace that is not given' do
-      @instance.attribute('bar').nil?.should == true
+      expect(@instance.attribute('bar').nil?).to eq(true)
     end
 
     describe 'using an HTML document' do
@@ -119,12 +119,12 @@ describe Oga::XML::Element do
       end
 
       it 'returns an attribute with a name containing a namespace separator' do
-        el.attribute('foo:bar').should == attr
+        expect(el.attribute('foo:bar')).to eq(attr)
       end
 
       describe 'using a Symbol argument' do
         it 'returns the attribute' do
-          el.attribute(:'foo:bar').should == attr
+          expect(el.attribute(:'foo:bar')).to eq(attr)
         end
       end
     end
@@ -138,14 +138,15 @@ describe Oga::XML::Element do
     end
 
     it 'returns the value of an attribute' do
-      @element.get('foo').should == 'bar'
+      expect(@element.get('foo')).to eq('bar')
     end
   end
 
   describe '#[]' do
     it 'is an alias to get' do
-      described_class.instance_method(:[]).should ==
+      expect(described_class.instance_method(:[])).to eq(
         described_class.instance_method(:get)
+      )
     end
   end
 
@@ -158,13 +159,13 @@ describe Oga::XML::Element do
     it 'adds an Attribute to the element' do
       @element.add_attribute(@attribute)
 
-      @element.attribute('foo').should == @attribute
+      expect(@element.attribute('foo')).to eq(@attribute)
     end
 
     it 'sets the element of the attribute when adding it' do
       @element.add_attribute(@attribute)
 
-      @attribute.element.should == @element
+      expect(@attribute.element).to eq(@element)
     end
   end
 
@@ -178,21 +179,21 @@ describe Oga::XML::Element do
     it 'adds a new attribute' do
       @element.set('class', 'foo')
 
-      @element.get('class').should == 'foo'
+      expect(@element.get('class')).to eq('foo')
     end
 
     it 'supports the use of Symbols for attribute names' do
       @element.set(:foo, 'foo')
-      @element.get('foo').should == 'foo'
+      expect(@element.get('foo')).to eq('foo')
 
       @element.set('bar', 'bar')
-      @element.get(:bar).should == 'bar'
+      expect(@element.get(:bar)).to eq('bar')
     end
 
     it 'adds a new attribute with a namespace' do
       @element.set('x:bar', 'foo')
 
-      @element.get('x:bar').should == 'foo'
+      expect(@element.get('x:bar')).to eq('foo')
     end
 
     it 'sets the namespace of an attribute' do
@@ -200,7 +201,7 @@ describe Oga::XML::Element do
 
       attr = @element.attribute('x:bar')
 
-      attr.namespace.is_a?(Oga::XML::Namespace).should == true
+      expect(attr.namespace.is_a?(Oga::XML::Namespace)).to eq(true)
     end
 
     it 'overwrites the value of an existing attribute' do
@@ -210,14 +211,15 @@ describe Oga::XML::Element do
 
       @element.set('foo', 'baz')
 
-      @element.get('foo').should == 'baz'
+      expect(@element.get('foo')).to eq('baz')
     end
   end
 
   describe '#[]=' do
     it 'is an alias to set' do
-      described_class.instance_method(:[]=).should ==
+      expect(described_class.instance_method(:[]=)).to eq(
         described_class.instance_method(:set)
+      )
     end
   end
 
@@ -234,13 +236,13 @@ describe Oga::XML::Element do
     it 'removes an attribute by its name' do
       @element.unset('foo')
 
-      @element.get('foo').should be_nil
+      expect(@element.get('foo')).to be_nil
     end
 
     it 'removes an attribute using a namespace' do
       @element.unset('x:foo')
 
-      @element.get('x:foo').should be_nil
+      expect(@element.get('x:foo')).to be_nil
     end
   end
 
@@ -252,7 +254,7 @@ describe Oga::XML::Element do
         :namespaces     => {'x' => namespace}
       )
 
-      element.namespace.should == namespace
+      expect(element.namespace).to eq(namespace)
     end
 
     it 'returns the default namespace if available' do
@@ -261,7 +263,7 @@ describe Oga::XML::Element do
         :namespaces => {'xmlns' => namespace}
       )
 
-      element.namespace.should == namespace
+      expect(element.namespace).to eq(namespace)
     end
 
     it 'flushes the cache when changing the namespace name' do
@@ -272,7 +274,7 @@ describe Oga::XML::Element do
 
       element.namespace_name = 'foo'
 
-      element.namespace.should be_nil
+      expect(element.namespace).to be_nil
     end
 
     describe 'in an HTML document' do
@@ -281,7 +283,7 @@ describe Oga::XML::Element do
         el  = described_class.new(:namespaces => {'xmlns' => ns})
         doc = Oga::XML::Document.new(:type => :html, :children => [el])
 
-        el.namespace.should be_nil
+        expect(el.namespace).to be_nil
       end
     end
   end
@@ -294,7 +296,7 @@ describe Oga::XML::Element do
         :namespaces     => {'x' => namespace}
       )
 
-      element.namespaces.should == {'x' => namespace}
+      expect(element.namespaces).to eq({'x' => namespace})
     end
 
     describe 'in an HTML document' do
@@ -303,14 +305,14 @@ describe Oga::XML::Element do
         el  = described_class.new(:namespaces => {'xmlns' => ns})
         doc = Oga::XML::Document.new(:type => :html, :children => [el])
 
-        el.namespaces.should == {}
+        expect(el.namespaces).to eq({})
       end
     end
   end
 
   describe '#default_namespace?' do
     it 'returns true when an element has no explicit namespace' do
-      described_class.new(:name => 'a').default_namespace?.should == true
+      expect(described_class.new(:name => 'a').default_namespace?).to eq(true)
     end
 
     it 'returns true when an element has an explicit default namespace' do
@@ -319,7 +321,7 @@ describe Oga::XML::Element do
 
       element.register_namespace(namespace.name, namespace.uri)
 
-      element.default_namespace?.should == true
+      expect(element.default_namespace?).to eq(true)
     end
 
     it 'returns false when an element resides in a custom namespace' do
@@ -327,7 +329,7 @@ describe Oga::XML::Element do
 
       element.register_namespace('xmlns', 'foo')
 
-      element.default_namespace?.should == false
+      expect(element.default_namespace?).to eq(false)
     end
   end
 
@@ -341,11 +343,11 @@ describe Oga::XML::Element do
     end
 
     it 'returns the text of the parent node and its child nodes' do
-      @n2.text.should == 'FooBar'
+      expect(@n2.text).to eq('FooBar')
     end
 
     it 'returns the text of the child node' do
-      @n1.text.should == 'Foo'
+      expect(@n1.text).to eq('Foo')
     end
   end
 
@@ -359,11 +361,11 @@ describe Oga::XML::Element do
     end
 
     it 'returns the inner text of the parent node' do
-      @n2.inner_text.should == 'Bar'
+      expect(@n2.inner_text).to eq('Bar')
     end
 
     it 'returns the inner text of the child node' do
-      @n1.inner_text.should == 'Foo'
+      expect(@n1.inner_text).to eq('Foo')
     end
   end
 
@@ -374,7 +376,7 @@ describe Oga::XML::Element do
 
     it 'sets the inner text of an element' do
       @element.inner_text = 'foo'
-      @element.inner_text.should == 'foo'
+      expect(@element.inner_text).to eq('foo')
     end
 
     it 'removes all existing nodes before inserting a new text node' do
@@ -383,13 +385,13 @@ describe Oga::XML::Element do
 
       @element.inner_text = 'bar'
 
-      @element.children.length.should == 1
+      expect(@element.children.length).to eq(1)
     end
 
     it 'sets the parent node of the newly inserted text node' do
       @element.inner_text = 'foo'
 
-      @element.children[0].parent.should == @element
+      expect(@element.children[0].parent).to eq(@element)
     end
   end
 
@@ -402,13 +404,13 @@ describe Oga::XML::Element do
     end
 
     it 'returns a node set containing the text nodes' do
-      @element.text_nodes.should == node_set(@t1, @t2)
+      expect(@element.text_nodes).to eq(node_set(@t1, @t2))
     end
   end
 
   describe '#to_xml' do
     it 'generates the corresponding XML' do
-      described_class.new(:name => 'p').to_xml.should == '<p />'
+      expect(described_class.new(:name => 'p').to_xml).to eq('<p />')
     end
 
     it 'includes the namespace if present' do
@@ -419,7 +421,7 @@ describe Oga::XML::Element do
         :children       => [Oga::XML::Text.new(:text => 'Foo')]
       )
 
-      instance.to_xml.should == '<foo:p>Foo</foo:p>'
+      expect(instance.to_xml).to eq('<foo:p>Foo</foo:p>')
     end
 
     it 'includes a single attribute if present' do
@@ -430,7 +432,7 @@ describe Oga::XML::Element do
         ]
       )
 
-      instance.to_xml.should == '<p key="value" />'
+      expect(instance.to_xml).to eq('<p key="value" />')
     end
 
     it 'includes multiple attributes if present' do
@@ -442,7 +444,7 @@ describe Oga::XML::Element do
         ]
       )
 
-      instance.to_xml.should == '<p key1="value1" key2="value2" />'
+      expect(instance.to_xml).to eq('<p key1="value1" key2="value2" />')
     end
 
     it 'includes the child nodes if present' do
@@ -451,7 +453,7 @@ describe Oga::XML::Element do
         :children => [Oga::XML::Comment.new(:text => 'foo')]
       )
 
-      instance.to_xml.should == '<p><!--foo--></p>'
+      expect(instance.to_xml).to eq('<p><!--foo--></p>')
     end
 
     it 'generates the corresponding XML when using a default namespace' do
@@ -461,28 +463,28 @@ describe Oga::XML::Element do
         :namespaces => {'xmlns' => namespace}
       )
 
-      instance.to_xml.should == '<foo />'
+      expect(instance.to_xml).to eq('<foo />')
     end
 
     it 'generates the XML for the HTML <script> element' do
       element  = described_class.new(:name => 'script')
       document = Oga::XML::Document.new(:type => :html, :children => [element])
 
-      element.to_xml.should == '<script></script>'
+      expect(element.to_xml).to eq('<script></script>')
     end
 
     it 'generates the XML for the HTML <link> element' do
       element  = described_class.new(:name => 'link')
       document = Oga::XML::Document.new(:type => :html, :children => [element])
 
-      element.to_xml.should == '<link>'
+      expect(element.to_xml).to eq('<link>')
     end
 
     it 'generates the XML for an empty explicitly closed HTML element' do
       element = described_class.new(:name => 'html')
       document = Oga::XML::Document.new(:type => :html, :children => [element])
 
-      element.to_xml.should == '<html></html>'
+      expect(element.to_xml).to eq('<html></html>')
     end
   end
 
@@ -490,7 +492,7 @@ describe Oga::XML::Element do
     it 'inspects a node with a name' do
       node = described_class.new(:name => 'a')
 
-      node.inspect.should == 'Element(name: "a")'
+      expect(node.inspect).to eq('Element(name: "a")')
     end
 
     it 'inspects a node with attributes and children' do
@@ -500,8 +502,8 @@ describe Oga::XML::Element do
         :attributes => [Oga::XML::Attribute.new(:name => 'x', :value => 'y')]
       )
 
-      node.inspect.should == 'Element(name: "p" attributes: ' \
-        '[Attribute(name: "x" value: "y")] children: NodeSet(Comment("foo")))'
+      expect(node.inspect).to eq('Element(name: "p" attributes: ' \
+        '[Attribute(name: "x" value: "y")] children: NodeSet(Comment("foo")))')
     end
 
     it 'inspects a node with a namespace' do
@@ -511,8 +513,8 @@ describe Oga::XML::Element do
         :namespaces     => {'x' => Oga::XML::Namespace.new(:name => 'x')}
       )
 
-      node.inspect.should == 'Element(name: "p" ' \
-        'namespace: Namespace(name: "x" uri: nil))'
+      expect(node.inspect).to eq('Element(name: "p" ' \
+        'namespace: Namespace(name: "x" uri: nil))')
     end
   end
 
@@ -524,38 +526,38 @@ describe Oga::XML::Element do
     end
 
     it 'returns a Namespace instance' do
-      @element.namespaces['foo'].is_a?(Oga::XML::Namespace).should == true
+      expect(@element.namespaces['foo'].is_a?(Oga::XML::Namespace)).to eq(true)
     end
 
     it 'sets the name of the namespace' do
-      @element.namespaces['foo'].name.should == 'foo'
+      expect(@element.namespaces['foo'].name).to eq('foo')
     end
 
     it 'sets the URI of the namespace' do
-      @element.namespaces['foo'].uri.should == 'http://example.com'
+      expect(@element.namespaces['foo'].uri).to eq('http://example.com')
     end
 
     it 'raises ArgumentError if the namespace already exists' do
       block = lambda { @element.register_namespace('foo', 'bar') }
 
-      block.should raise_error(ArgumentError)
+      expect(block).to raise_error(ArgumentError)
     end
 
     it 'flushes the cache when registering a namespace' do
-      @element.available_namespaces.should == {
+      expect(@element.available_namespaces).to eq({
         'foo' => @element.namespaces['foo']
-      }
+      })
 
       @element.register_namespace('bar', 'http://exmaple.com')
 
-      @element.available_namespaces.should == {
+      expect(@element.available_namespaces).to eq({
         'foo' => @element.namespaces['foo'],
         'bar' => @element.namespaces['bar']
-      }
+      })
     end
 
     it 'does not flush the cache when "flush" is set to false' do
-      @element.should_not receive(:flush_namespaces_cache)
+      expect(@element).not_to receive(:flush_namespaces_cache)
 
       @element.register_namespace('bar', 'http://example.com', false)
     end
@@ -578,23 +580,23 @@ describe Oga::XML::Element do
     end
 
     it 'inherits the "foo" namespace from the parent' do
-      @child_ns['foo'].uri.should == 'bar'
+      expect(@child_ns['foo'].uri).to eq('bar')
     end
 
     it 'overwrites the "baz" namespace in the child' do
-      @child_ns['baz'].uri.should == 'xxx'
+      expect(@child_ns['baz'].uri).to eq('xxx')
     end
 
     it 'returns the "foo" namespace for the parent' do
-      @parent_ns['foo'].uri.should == 'bar'
+      expect(@parent_ns['foo'].uri).to eq('bar')
     end
 
     it 'returns the "baz" namespace for the parent' do
-      @parent_ns['baz'].uri.should == 'yyy'
+      expect(@parent_ns['baz'].uri).to eq('yyy')
     end
 
     it 'does not modify the list of direct namespaces' do
-      @child.namespaces.key?('foo').should == false
+      expect(@child.namespaces.key?('foo')).to eq(false)
     end
 
     describe 'in an HTML document' do
@@ -603,28 +605,28 @@ describe Oga::XML::Element do
         el  = described_class.new(:namespaces => {'xmlns' => ns})
         doc = Oga::XML::Document.new(:type => :html, :children => [el])
 
-        el.available_namespaces.should == {}
+        expect(el.available_namespaces).to eq({})
       end
     end
   end
 
   describe '#self_closing?' do
     it 'returns true for an empty XML element' do
-      described_class.new(:name => 'foo').should be_self_closing
+      expect(described_class.new(:name => 'foo')).to be_self_closing
     end
 
     it 'returns false for a non empty XML element' do
       text = Oga::XML::Text.new(:text => 'bar')
       node = described_class.new(:name => 'foo', :children => [text])
 
-      node.should_not be_self_closing
+      expect(node).not_to be_self_closing
     end
 
     it 'returns true for an HTML void element' do
       element  = described_class.new(:name => 'link')
       document = Oga::XML::Document.new(:type => :html, :children => [element])
 
-      element.should be_self_closing
+      expect(element).to be_self_closing
     end
 
     it 'returns false for a non empty HTML element' do
@@ -632,7 +634,7 @@ describe Oga::XML::Element do
       element  = described_class.new(:name => 'script', :children => [text])
       document = Oga::XML::Document.new(:type => :html, :children => [element])
 
-      element.should_not be_self_closing
+      expect(element).not_to be_self_closing
     end
   end
 
@@ -640,22 +642,22 @@ describe Oga::XML::Element do
     it 'flushes the namespaces cache of the current element' do
       element = described_class.new(:name => 'a')
 
-      element.available_namespaces.should == {}
+      expect(element.available_namespaces).to eq({})
 
       element.register_namespace('foo', 'bar', false)
 
       element.flush_namespaces_cache
 
-      element.available_namespaces.should == {
+      expect(element.available_namespaces).to eq({
         'foo' => element.namespaces['foo']
-      }
+      })
     end
 
     it 'flushes the namespace cache of all child elements' do
       child  = described_class.new(:name => 'b')
       parent = described_class.new(:name => 'a', :children => [child])
 
-      child.should_receive(:flush_namespaces_cache)
+      expect(child).to receive(:flush_namespaces_cache)
 
       parent.flush_namespaces_cache
     end
@@ -666,7 +668,7 @@ describe Oga::XML::Element do
       it 'returns a String' do
         element = described_class.new(:namespace_name => 'foo', :name => 'bar')
 
-        element.expanded_name.should == 'foo:bar'
+        expect(element.expanded_name).to eq('foo:bar')
       end
     end
 
@@ -674,18 +676,18 @@ describe Oga::XML::Element do
       it 'returns a String' do
         element = described_class.new(:name => 'bar')
 
-        element.expanded_name.should == 'bar'
+        expect(element.expanded_name).to eq('bar')
       end
     end
   end
 
   describe '#literal_html_name?' do
     it 'returns true for an element name matching one of the literal HTML elements' do
-      described_class.new(:name => 'script').literal_html_name?.should == true
+      expect(described_class.new(:name => 'script').literal_html_name?).to eq(true)
     end
 
     it 'returns false for an element name not matching one of the literal HTML elements' do
-      described_class.new(:name => 'foo').literal_html_name?.should == false
+      expect(described_class.new(:name => 'foo').literal_html_name?).to eq(false)
     end
   end
 end
diff --git a/spec/oga/xml/entities_spec.rb b/spec/oga/xml/entities_spec.rb
index f015243..87b0fc1 100644
--- a/spec/oga/xml/entities_spec.rb
+++ b/spec/oga/xml/entities_spec.rb
@@ -3,147 +3,147 @@ require 'spec_helper'
 describe Oga::XML::Entities do
   describe 'decode' do
     it 'decodes &lt; into <' do
-      described_class.decode('&lt;').should == '<'
+      expect(described_class.decode('&lt;')).to eq('<')
     end
 
     it 'decodes &gt; into >' do
-      described_class.decode('&gt;').should == '>'
+      expect(described_class.decode('&gt;')).to eq('>')
     end
 
     it "decodes &apos; into '" do
-      described_class.decode('&apos;').should == "'"
+      expect(described_class.decode('&apos;')).to eq("'")
     end
 
     it 'decodes &quot; into "' do
-      described_class.decode('&quot;').should == '"'
+      expect(described_class.decode('&quot;')).to eq('"')
     end
 
     it 'decodes &amp; into &' do
-      described_class.decode('&amp;').should == '&'
+      expect(described_class.decode('&amp;')).to eq('&')
     end
 
     it 'decodes &#60; into <' do
-      described_class.decode('&#60;').should == '<'
+      expect(described_class.decode('&#60;')).to eq('<')
     end
 
     it 'decodes &#62; into >' do
-      described_class.decode('&#62;').should == '>'
+      expect(described_class.decode('&#62;')).to eq('>')
     end
 
     it "decodes &#39; into '" do
-      described_class.decode('&#39;').should == "'"
+      expect(described_class.decode('&#39;')).to eq("'")
     end
 
     it 'decodes &#34; into "' do
-      described_class.decode('&#34;').should == '"'
+      expect(described_class.decode('&#34;')).to eq('"')
     end
 
     it 'decodes &#38; into &' do
-      described_class.decode('&#38;').should == '&'
+      expect(described_class.decode('&#38;')).to eq('&')
     end
 
     it 'decodes &#38;#60; into &#60;' do
-      described_class.decode('&#38;#60;').should == '&#60;'
+      expect(described_class.decode('&#38;#60;')).to eq('&#60;')
     end
 
     it 'decodes &#38;#38; into &#38;' do
-      described_class.decode('&#38;#38;').should == '&#38;'
+      expect(described_class.decode('&#38;#38;')).to eq('&#38;')
     end
 
     it 'decodes &amp;gt; into &gt;' do
-      described_class.decode('&amp;gt;').should == '&gt;'
+      expect(described_class.decode('&amp;gt;')).to eq('&gt;')
     end
 
     it 'decodes &amp;&amp;gt; into &>' do
-      described_class.decode('&amp;&amp;gt;').should == '&&gt;'
+      expect(described_class.decode('&amp;&amp;gt;')).to eq('&&gt;')
     end
 
     it 'decodes &amp;lt; into <' do
-      described_class.decode('&amp;lt;').should == '&lt;'
+      expect(described_class.decode('&amp;lt;')).to eq('&lt;')
     end
 
     it 'decodes &amp;&amp;lt; into &<' do
-      described_class.decode('&amp;&amp;lt;').should == '&&lt;'
+      expect(described_class.decode('&amp;&amp;lt;')).to eq('&&lt;')
     end
 
     it 'decodes &#x3C; into <' do
-      described_class.decode('&#x3C;').should == '<'
+      expect(described_class.decode('&#x3C;')).to eq('<')
     end
 
     it 'decodes numeric entities starting with a 0' do
-      described_class.decode('&#038;').should == '&'
+      expect(described_class.decode('&#038;')).to eq('&')
     end
 
     it 'preserves entity-like tokens' do
-      described_class.decode('&#TAB;').should == '&#TAB;'
+      expect(described_class.decode('&#TAB;')).to eq('&#TAB;')
     end
 
     it 'preserves entity-like hex tokens' do
-      described_class.decode('&#x;').should == '&#x;'
+      expect(described_class.decode('&#x;')).to eq('&#x;')
     end
 
     it 'preserves entity-like letters in non-hex mode' do
-      described_class.decode('&#123A;').should == '&#123A;'
+      expect(described_class.decode('&#123A;')).to eq('&#123A;')
     end
 
     it "preserves numeric entities when they can't be decoded" do
-      described_class.decode('&#2013265920;').should == '&#2013265920;'
+      expect(described_class.decode('&#2013265920;')).to eq('&#2013265920;')
     end
 
     it "preserves hex entities when they can't be decoded" do
-      described_class.decode('&#xffffff;').should == '&#xffffff;'
+      expect(described_class.decode('&#xffffff;')).to eq('&#xffffff;')
     end
   end
 
   describe 'encode' do
     it 'encodes & as &amp;' do
-      described_class.encode('&').should == '&amp;'
+      expect(described_class.encode('&')).to eq('&amp;')
     end
 
     it 'does not encode double quotes' do
-      described_class.encode('"').should == '"'
+      expect(described_class.encode('"')).to eq('"')
     end
 
     it 'does not encode single quotes' do
-      described_class.encode("'").should == "'"
+      expect(described_class.encode("'")).to eq("'")
     end
 
     it 'encodes < as &lt;' do
-      described_class.encode('<').should == '&lt;'
+      expect(described_class.encode('<')).to eq('&lt;')
     end
 
     it 'encodes > as &gt;' do
-      described_class.encode('>').should == '&gt;'
+      expect(described_class.encode('>')).to eq('&gt;')
     end
 
     it 'encodes &gt; as &amp;gt;' do
-      described_class.encode('&gt;').should == '&amp;gt;'
+      expect(described_class.encode('&gt;')).to eq('&amp;gt;')
     end
 
     it 'encodes &lt; as &amp;lt;' do
-      described_class.encode('&lt;').should == '&amp;lt;'
+      expect(described_class.encode('&lt;')).to eq('&amp;lt;')
     end
   end
 
   describe 'encode_attribute' do
     it 'encodes & as &amp;' do
-      described_class.encode_attribute('&').should == '&amp;'
+      expect(described_class.encode_attribute('&')).to eq('&amp;')
     end
 
     it 'encodes > as &gt;' do
-      described_class.encode_attribute('>').should == '&gt;'
+      expect(described_class.encode_attribute('>')).to eq('&gt;')
     end
 
     it 'encodes < as &gt;' do
-      described_class.encode_attribute('<').should == '&lt;'
+      expect(described_class.encode_attribute('<')).to eq('&lt;')
     end
 
     it 'encodes a single quote as &apos;' do
-      described_class.encode_attribute("'").should == '&apos;'
+      expect(described_class.encode_attribute("'")).to eq('&apos;')
     end
 
     it 'encodes a double quote as &quot;' do
-      described_class.encode_attribute('"').should == '&quot;'
+      expect(described_class.encode_attribute('"')).to eq('&quot;')
     end
   end
 end
diff --git a/spec/oga/xml/generator_spec.rb b/spec/oga/xml/generator_spec.rb
index a74d68a..9202058 100644
--- a/spec/oga/xml/generator_spec.rb
+++ b/spec/oga/xml/generator_spec.rb
@@ -4,7 +4,7 @@ describe Oga::XML::Generator do
   describe '#to_xml' do
     describe 'using an unsupported root type' do
       it 'raises TypeError' do
-        -> { described_class.new(:foo).to_xml }.should raise_error(TypeError)
+        expect { described_class.new(:foo).to_xml }.to raise_error(TypeError)
       end
     end
 
@@ -15,7 +15,7 @@ describe Oga::XML::Generator do
 
         output = described_class.new(element).to_xml
 
-        output.should == '<foo attr="value" />'
+        expect(output).to eq('<foo attr="value" />')
       end
     end
 
@@ -25,7 +25,7 @@ describe Oga::XML::Generator do
         doc = Oga::XML::Document.new(children: [element])
         output = described_class.new(doc).to_xml
 
-        output.should == '<foo />'
+        expect(output).to eq('<foo />')
       end
     end
 
@@ -35,7 +35,7 @@ describe Oga::XML::Generator do
         doc = Oga::XML::Document.new(children: [element], type: :html)
         output = described_class.new(doc).to_xml
 
-        output.should == '<foo></foo>'
+        expect(output).to eq('<foo></foo>')
       end
     end
 
@@ -46,7 +46,7 @@ describe Oga::XML::Generator do
         doc = Oga::XML::Document.new(children: [el1], type: :html)
         output = described_class.new(doc).to_xml
 
-        output.should == '<foo><bar></bar></foo>'
+        expect(output).to eq('<foo><bar></bar></foo>')
       end
     end
 
@@ -65,7 +65,7 @@ describe Oga::XML::Generator do
 
         output = described_class.new(root).to_xml
 
-        output.should == '<root><a /><b><c /></b></root>'
+        expect(output).to eq('<root><a /><b><c /></b></root>')
       end
     end
 
@@ -75,7 +75,7 @@ describe Oga::XML::Generator do
         element  = Oga::XML::Element.new(name: 'foo')
         document = Oga::XML::Document.new(children: [text, element])
 
-        described_class.new(text).to_xml.should == "\n"
+        expect(described_class.new(text).to_xml).to eq("\n")
       end
     end
 
@@ -85,7 +85,7 @@ describe Oga::XML::Generator do
         element  = Oga::XML::Element.new(name: 'foo')
         document = Oga::XML::Document.new(children: [text, element])
 
-        described_class.new(element).to_xml.should == '<foo />'
+        expect(described_class.new(element).to_xml).to eq('<foo />')
       end
     end
 
@@ -95,8 +95,8 @@ describe Oga::XML::Generator do
         element2 = Oga::XML::Element.new(name: 'b')
         document = Oga::XML::Document.new(children: [element1, element2])
 
-        described_class.new(element1).to_xml.should == '<a />'
-        described_class.new(element2).to_xml.should == '<b />'
+        expect(described_class.new(element1).to_xml).to eq('<a />')
+        expect(described_class.new(element2).to_xml).to eq('<b />')
       end
     end
 
@@ -123,7 +123,7 @@ describe Oga::XML::Generator do
         doc = Oga.parse_html(input)
         output = described_class.new(doc)
 
-        output.to_xml.should == input
+        expect(output.to_xml).to eq(input)
       end
     end
 
@@ -133,7 +133,7 @@ describe Oga::XML::Generator do
           img = Oga::XML::Element.new(name: 'img')
           doc = Oga::XML::Document.new(children: [img], type: :xml)
 
-          doc.to_xml.should == '<img />'
+          expect(doc.to_xml).to eq('<img />')
         end
       end
 
@@ -143,7 +143,7 @@ describe Oga::XML::Generator do
           img = Oga::XML::Element.new(name: 'img', children: [text])
           doc = Oga::XML::Document.new(children: [img], type: :xml)
 
-          doc.to_xml.should == '<img>kittens</img>'
+          expect(doc.to_xml).to eq('<img>kittens</img>')
         end
       end
     end
@@ -154,7 +154,7 @@ describe Oga::XML::Generator do
           img = Oga::XML::Element.new(name: 'img')
           doc = Oga::XML::Document.new(children: [img], type: :html)
 
-          doc.to_xml.should == '<img>'
+          expect(doc.to_xml).to eq('<img>')
         end
       end
 
@@ -164,7 +164,7 @@ describe Oga::XML::Generator do
           img = Oga::XML::Element.new(name: 'img', children: [text])
           doc = Oga::XML::Document.new(children: [img], type: :html)
 
-          doc.to_xml.should == '<img>kittens</img>'
+          expect(doc.to_xml).to eq('<img>kittens</img>')
         end
       end
     end
diff --git a/spec/oga/xml/lexer/cdata_spec.rb b/spec/oga/xml/lexer/cdata_spec.rb
index d1a2aa7..ea6c65a 100644
--- a/spec/oga/xml/lexer/cdata_spec.rb
+++ b/spec/oga/xml/lexer/cdata_spec.rb
@@ -3,40 +3,40 @@ require 'spec_helper'
 describe Oga::XML::Lexer do
   describe 'CDATA tags' do
     it 'lexes a CDATA tag' do
-      lex('<![CDATA[foo]]>').should == [
+      expect(lex('<![CDATA[foo]]>')).to eq([
         [:T_CDATA_START, nil, 1],
         [:T_CDATA_BODY, 'foo', 1],
         [:T_CDATA_END, nil, 1]
-      ]
+      ])
     end
 
     it 'lexes tags inside CDATA tags as regular text' do
-      lex('<![CDATA[<p>Foo</p>]]>').should == [
+      expect(lex('<![CDATA[<p>Foo</p>]]>')).to eq([
         [:T_CDATA_START, nil, 1],
         [:T_CDATA_BODY, '<p>Foo</p>', 1],
         [:T_CDATA_END, nil, 1]
-      ]
+      ])
     end
 
     it 'lexes a single bracket inside a CDATA tag' do
-      lex('<![CDATA[]]]>').should == [
+      expect(lex('<![CDATA[]]]>')).to eq([
         [:T_CDATA_START, nil, 1],
         [:T_CDATA_BODY, ']', 1],
         [:T_CDATA_END, nil, 1]
-      ]
+      ])
     end
 
     it 'lexes double brackets inside a CDATA tag' do
-      lex('<![CDATA[]]]]>').should == [
+      expect(lex('<![CDATA[]]]]>')).to eq([
         [:T_CDATA_START, nil, 1],
         [:T_CDATA_BODY, ']', 1],
         [:T_CDATA_BODY, ']', 1],
         [:T_CDATA_END, nil, 1]
-      ]
+      ])
     end
 
     it 'lexes two CDATA tags following each other' do
-      lex('<a><![CDATA[foo]]><b><![CDATA[bar]]></b></a>').should == [
+      expect(lex('<a><![CDATA[foo]]><b><![CDATA[bar]]></b></a>')).to eq([
         [:T_ELEM_NAME, 'a', 1],
         [:T_CDATA_START, nil, 1],
         [:T_CDATA_BODY, 'foo', 1],
@@ -47,58 +47,58 @@ describe Oga::XML::Lexer do
         [:T_CDATA_END, nil, 1],
         [:T_ELEM_END, nil, 1],
         [:T_ELEM_END, nil, 1]
-      ]
+      ])
     end
 
     it 'lexes a CDATA tag containing a newline after the open tag' do
-      lex("<![CDATA[\nfoo]]>").should == [
+      expect(lex("<![CDATA[\nfoo]]>")).to eq([
         [:T_CDATA_START, nil, 1],
         [:T_CDATA_BODY, "\nfoo", 1],
         [:T_CDATA_END, nil, 2]
-      ]
+      ])
     end
 
     it 'lexes a CDATA tag containing a newline before the closing tag' do
-      lex("<![CDATA[foo\n]]>").should == [
+      expect(lex("<![CDATA[foo\n]]>")).to eq([
         [:T_CDATA_START, nil, 1],
         [:T_CDATA_BODY, "foo\n", 1],
         [:T_CDATA_END, nil, 2]
-      ]
+      ])
     end
 
     it 'lexes a CDATA tag with the body surrounded by newlines' do
-      lex("<![CDATA[\nfoo\n]]>").should == [
+      expect(lex("<![CDATA[\nfoo\n]]>")).to eq([
         [:T_CDATA_START, nil, 1],
         [:T_CDATA_BODY, "\nfoo\n", 1],
         [:T_CDATA_END, nil, 3]
-      ]
+      ])
     end
 
     describe 'using an IO as input' do
       it 'lexes a CDATA tag containing a newline after the open tag' do
-        lex_stringio("<![CDATA[\nfoo]]>").should == [
+        expect(lex_stringio("<![CDATA[\nfoo]]>")).to eq([
           [:T_CDATA_START, nil, 1],
           [:T_CDATA_BODY, "\n", 1],
           [:T_CDATA_BODY, "foo", 2],
           [:T_CDATA_END, nil, 2]
-        ]
+        ])
       end
 
       it 'lexes a CDATA tag containing a newline before the closing tag' do
-        lex_stringio("<![CDATA[foo\n]]>").should == [
+        expect(lex_stringio("<![CDATA[foo\n]]>")).to eq([
           [:T_CDATA_START, nil, 1],
           [:T_CDATA_BODY, "foo\n", 1],
           [:T_CDATA_END, nil, 2]
-        ]
+        ])
       end
 
       it 'lexes a CDATA tag with the body surrounded by newlines' do
-        lex_stringio("<![CDATA[\nfoo\n]]>").should == [
+        expect(lex_stringio("<![CDATA[\nfoo\n]]>")).to eq([
           [:T_CDATA_START, nil, 1],
           [:T_CDATA_BODY, "\n", 1],
           [:T_CDATA_BODY, "foo\n", 2],
           [:T_CDATA_END, nil, 3]
-        ]
+        ])
       end
     end
   end
diff --git a/spec/oga/xml/lexer/comments_spec.rb b/spec/oga/xml/lexer/comments_spec.rb
index 442e2f0..a1f5b71 100644
--- a/spec/oga/xml/lexer/comments_spec.rb
+++ b/spec/oga/xml/lexer/comments_spec.rb
@@ -3,71 +3,71 @@ require 'spec_helper'
 describe Oga::XML::Lexer do
   describe 'comments' do
     it 'lexes a comment' do
-      lex('<!-- foo -->').should == [
+      expect(lex('<!-- foo -->')).to eq([
         [:T_COMMENT_START, nil, 1],
         [:T_COMMENT_BODY, ' foo ', 1],
         [:T_COMMENT_END, nil, 1]
-      ]
+      ])
     end
 
     it 'lexes a comment containing -' do
-      lex('<!-- - -->').should == [
+      expect(lex('<!-- - -->')).to eq([
         [:T_COMMENT_START, nil, 1],
         [:T_COMMENT_BODY, ' ', 1],
         [:T_COMMENT_BODY, '-', 1],
         [:T_COMMENT_BODY, ' ', 1],
         [:T_COMMENT_END, nil, 1],
-      ]
+      ])
     end
 
     it 'lexes a comment containing --' do
-      lex('<!-- -- -->').should == [
+      expect(lex('<!-- -- -->')).to eq([
         [:T_COMMENT_START, nil, 1],
         [:T_COMMENT_BODY, ' ', 1],
         [:T_COMMENT_BODY, '-', 1],
         [:T_COMMENT_BODY, '-', 1],
         [:T_COMMENT_BODY, ' ', 1],
         [:T_COMMENT_END,  nil, 1]
-      ]
+      ])
     end
 
     it 'lexes a comment containing ->' do
-      lex('<!-- -> -->').should == [
+      expect(lex('<!-- -> -->')).to eq([
         [:T_COMMENT_START, nil, 1],
         [:T_COMMENT_BODY, ' ', 1],
         [:T_COMMENT_BODY, '-', 1],
         [:T_COMMENT_BODY, '> ', 1],
         [:T_COMMENT_END, nil, 1]
-      ]
+      ])
     end
 
     it 'lexes a comment followed by text' do
-      lex('<!---->foo').should == [
+      expect(lex('<!---->foo')).to eq([
         [:T_COMMENT_START, nil, 1],
         [:T_COMMENT_END, nil, 1],
         [:T_TEXT, 'foo', 1]
-      ]
+      ])
     end
 
     it 'lexes text followed by a comment' do
-      lex('foo<!---->').should == [
+      expect(lex('foo<!---->')).to eq([
         [:T_TEXT, 'foo', 1],
         [:T_COMMENT_START, nil, 1],
         [:T_COMMENT_END, nil, 1]
-      ]
+      ])
     end
 
     it 'lexes an element followed by a comment' do
-      lex('<p></p><!---->').should == [
+      expect(lex('<p></p><!---->')).to eq([
         [:T_ELEM_NAME, 'p', 1],
         [:T_ELEM_END, nil, 1],
         [:T_COMMENT_START, nil, 1],
         [:T_COMMENT_END, nil, 1]
-      ]
+      ])
     end
 
     it 'lexes two comments following each other' do
-      lex('<a><!--foo--><b><!--bar--></b></a>').should == [
+      expect(lex('<a><!--foo--><b><!--bar--></b></a>')).to eq([
         [:T_ELEM_NAME, 'a', 1],
         [:T_COMMENT_START, nil, 1],
         [:T_COMMENT_BODY, 'foo', 1],
@@ -78,34 +78,34 @@ describe Oga::XML::Lexer do
         [:T_COMMENT_END, nil, 1],
         [:T_ELEM_END, nil, 1],
         [:T_ELEM_END, nil, 1]
-      ]
+      ])
     end
 
     describe 'using an IO as input' do
       it 'lexes a comment containing a newline after the open tag' do
-        lex_stringio("<!--\nfoo-->").should == [
+        expect(lex_stringio("<!--\nfoo-->")).to eq([
           [:T_COMMENT_START, nil, 1],
           [:T_COMMENT_BODY, "\n", 1],
           [:T_COMMENT_BODY, "foo", 2],
           [:T_COMMENT_END, nil, 2]
-        ]
+        ])
       end
 
       it 'lexes a comment containing a newline before the closing tag' do
-        lex_stringio("<!--foo\n-->").should == [
+        expect(lex_stringio("<!--foo\n-->")).to eq([
           [:T_COMMENT_START, nil, 1],
           [:T_COMMENT_BODY, "foo\n", 1],
           [:T_COMMENT_END, nil, 2]
-        ]
+        ])
       end
 
       it 'lexes a comment with the body surrounded by newlines' do
-        lex_stringio("<!--\nfoo\n-->").should == [
+        expect(lex_stringio("<!--\nfoo\n-->")).to eq([
           [:T_COMMENT_START, nil, 1],
           [:T_COMMENT_BODY, "\n", 1],
           [:T_COMMENT_BODY, "foo\n", 2],
           [:T_COMMENT_END, nil, 3]
-        ]
+        ])
       end
     end
   end
diff --git a/spec/oga/xml/lexer/doctype_spec.rb b/spec/oga/xml/lexer/doctype_spec.rb
index 66d2d20..7fbe8d1 100644
--- a/spec/oga/xml/lexer/doctype_spec.rb
+++ b/spec/oga/xml/lexer/doctype_spec.rb
@@ -3,32 +3,32 @@ require 'spec_helper'
 describe Oga::XML::Lexer do
   describe 'doctypes' do
     it 'lexes the HTML5 doctype' do
-      lex('<!DOCTYPE html>').should == [
+      expect(lex('<!DOCTYPE html>')).to eq([
         [:T_DOCTYPE_START, nil, 1],
         [:T_DOCTYPE_NAME, 'html', 1],
         [:T_DOCTYPE_END, nil, 1]
-      ]
+      ])
     end
 
     it 'lexes a doctype containing a newline before the doctype name' do
-      lex("<!DOCTYPE\nhtml>").should == [
+      expect(lex("<!DOCTYPE\nhtml>")).to eq([
         [:T_DOCTYPE_START, nil, 1],
         [:T_DOCTYPE_NAME, 'html', 2],
         [:T_DOCTYPE_END, nil, 2]
-      ]
+      ])
     end
 
     it 'lexes a doctype with a public ID preceded by a newline' do
-      lex("<!DOCTYPE html\nPUBLIC>").should == [
+      expect(lex("<!DOCTYPE html\nPUBLIC>")).to eq([
         [:T_DOCTYPE_START, nil, 1],
         [:T_DOCTYPE_NAME, 'html', 1],
         [:T_DOCTYPE_TYPE, 'PUBLIC', 2],
         [:T_DOCTYPE_END, nil, 2]
-      ]
+      ])
     end
 
     it 'lexes a doctype with a public and system ID' do
-      lex('<!DOCTYPE HTML PUBLIC "foobar" "baz">').should == [
+      expect(lex('<!DOCTYPE HTML PUBLIC "foobar" "baz">')).to eq([
         [:T_DOCTYPE_START, nil, 1],
         [:T_DOCTYPE_NAME, 'HTML', 1],
         [:T_DOCTYPE_TYPE, 'PUBLIC', 1],
@@ -39,11 +39,11 @@ describe Oga::XML::Lexer do
         [:T_STRING_BODY, 'baz', 1],
         [:T_STRING_DQUOTE, nil, 1],
         [:T_DOCTYPE_END, nil, 1]
-      ]
+      ])
     end
 
     it 'lexes a doctype with a public and system ID using single quotes' do
-      lex("<!DOCTYPE HTML PUBLIC 'foobar' 'baz'>").should == [
+      expect(lex("<!DOCTYPE HTML PUBLIC 'foobar' 'baz'>")).to eq([
         [:T_DOCTYPE_START, nil, 1],
         [:T_DOCTYPE_NAME, 'HTML', 1],
         [:T_DOCTYPE_TYPE, 'PUBLIC', 1],
@@ -54,62 +54,62 @@ describe Oga::XML::Lexer do
         [:T_STRING_BODY, 'baz', 1],
         [:T_STRING_SQUOTE, nil, 1],
         [:T_DOCTYPE_END, nil, 1]
-      ]
+      ])
     end
 
     it 'lexes an inline doctype' do
-      lex('<!DOCTYPE html [<!ELEMENT foo>]>').should == [
+      expect(lex('<!DOCTYPE html [<!ELEMENT foo>]>')).to eq([
         [:T_DOCTYPE_START, nil, 1],
         [:T_DOCTYPE_NAME, 'html', 1],
         [:T_DOCTYPE_INLINE, '<!ELEMENT foo>', 1],
         [:T_DOCTYPE_END, nil, 1]
-      ]
+      ])
     end
 
     it 'lexes an empty inline doctype' do
-      lex('<!DOCTYPE html []>').should == [
+      expect(lex('<!DOCTYPE html []>')).to eq([
         [:T_DOCTYPE_START, nil, 1],
         [:T_DOCTYPE_NAME, 'html', 1],
         [:T_DOCTYPE_END, nil, 1]
-      ]
+      ])
     end
 
     it 'lexes an inline doctype containing a newline' do
-      lex("<!DOCTYPE html [foo\n]>").should == [
+      expect(lex("<!DOCTYPE html [foo\n]>")).to eq([
         [:T_DOCTYPE_START, nil, 1],
         [:T_DOCTYPE_NAME, 'html', 1],
         [:T_DOCTYPE_INLINE, "foo\n", 1],
         [:T_DOCTYPE_END, nil, 2]
-      ]
+      ])
     end
 
     it 'lexes an inline doctype containing a trailing newline using an IO' do
       input = StringIO.new("<!DOCTYPE html [foo\n]>")
 
-      lex(input).should == [
+      expect(lex(input)).to eq([
         [:T_DOCTYPE_START, nil, 1],
         [:T_DOCTYPE_NAME, 'html', 1],
         [:T_DOCTYPE_INLINE, "foo\n", 1],
         [:T_DOCTYPE_END, nil, 2]
-      ]
+      ])
     end
 
     it 'lexes an inline doctype containing a leading newline using an IO' do
       input = StringIO.new("<!DOCTYPE html [\nfoo]>")
 
-      lex(input).should == [
+      expect(lex(input)).to eq([
         [:T_DOCTYPE_START, nil, 1],
         [:T_DOCTYPE_NAME, 'html', 1],
         [:T_DOCTYPE_INLINE, "\n", 1],
         [:T_DOCTYPE_INLINE, "foo", 2],
         [:T_DOCTYPE_END, nil, 2]
-      ]
+      ])
     end
 
     # Technically not valid, put in place to make sure that the Ragel rules are
     # not too greedy.
     it 'lexes an inline doftype followed by a system ID' do
-      lex('<!DOCTYPE html [<!ELEMENT foo>] "foo">').should == [
+      expect(lex('<!DOCTYPE html [<!ELEMENT foo>] "foo">')).to eq([
         [:T_DOCTYPE_START, nil, 1],
         [:T_DOCTYPE_NAME, 'html', 1],
         [:T_DOCTYPE_INLINE, '<!ELEMENT foo>', 1],
@@ -117,7 +117,7 @@ describe Oga::XML::Lexer do
         [:T_STRING_BODY, 'foo', 1],
         [:T_STRING_DQUOTE, nil, 1],
         [:T_DOCTYPE_END, nil, 1]
-      ]
+      ])
     end
   end
 end
diff --git a/spec/oga/xml/lexer/documents_spec.rb b/spec/oga/xml/lexer/documents_spec.rb
index a078ccd..528c635 100644
--- a/spec/oga/xml/lexer/documents_spec.rb
+++ b/spec/oga/xml/lexer/documents_spec.rb
@@ -13,7 +13,7 @@ describe Oga::XML::Lexer do
 </html>
       EOF
 
-      lex(html).should == [
+      expect(lex(html)).to eq([
         [:T_DOCTYPE_START, nil, 1],
         [:T_DOCTYPE_NAME, 'html', 1],
         [:T_DOCTYPE_END, nil, 1],
@@ -45,7 +45,7 @@ describe Oga::XML::Lexer do
         # </html>
         [:T_ELEM_END, nil, 7],
         [:T_TEXT, "\n", 7]
-      ]
+      ])
     end
   end
 end
diff --git a/spec/oga/xml/lexer/elements_spec.rb b/spec/oga/xml/lexer/elements_spec.rb
index c2255f0..7caefce 100644
--- a/spec/oga/xml/lexer/elements_spec.rb
+++ b/spec/oga/xml/lexer/elements_spec.rb
@@ -5,151 +5,151 @@ require 'spec_helper'
 describe Oga::XML::Lexer do
   describe 'elements' do
     it 'lexes an opening element' do
-      lex('<p>').should == [
+      expect(lex('<p>')).to eq([
         [:T_ELEM_NAME, 'p', 1],
         [:T_ELEM_END, nil, 1]
-      ]
+      ])
     end
 
     it 'lexes an opening element with a stray double quote' do
-      lex('<p">').should == [
+      expect(lex('<p">')).to eq([
         [:T_ELEM_NAME, 'p', 1],
         [:T_ELEM_END, nil, 1]
-      ]
+      ])
     end
 
     it 'lexes an opening element with a stray double quoted string' do
-      lex('<p"">').should == [
+      expect(lex('<p"">')).to eq([
         [:T_ELEM_NAME, 'p', 1],
         [:T_ELEM_END, nil, 1]
-      ]
+      ])
     end
 
     it 'lexes an opening an closing element' do
-      lex('<p></p>').should == [
+      expect(lex('<p></p>')).to eq([
         [:T_ELEM_NAME, 'p', 1],
         [:T_ELEM_END, nil, 1]
-      ]
+      ])
     end
 
     it 'lexes an opening an closing element with a stray double quote' do
-      lex('<p"></p>').should == [
+      expect(lex('<p"></p>')).to eq([
         [:T_ELEM_NAME, 'p', 1],
         [:T_ELEM_END, nil, 1]
-      ]
+      ])
     end
 
     it 'lexes an opening an closing element with a stray double quoted string' do
-      lex('<p""></p>').should == [
+      expect(lex('<p""></p>')).to eq([
         [:T_ELEM_NAME, 'p', 1],
         [:T_ELEM_END, nil, 1]
-      ]
+      ])
     end
 
     it 'lexes a paragraph element with text inside it' do
-      lex('<p>Hello</p>').should == [
+      expect(lex('<p>Hello</p>')).to eq([
         [:T_ELEM_NAME, 'p', 1],
         [:T_TEXT, 'Hello', 1],
         [:T_ELEM_END, nil, 1]
-      ]
+      ])
     end
 
     it 'lexes text followed by a paragraph element' do
-      lex('Foo<p>').should == [
+      expect(lex('Foo<p>')).to eq([
         [:T_TEXT, 'Foo', 1],
         [:T_ELEM_NAME, 'p', 1],
         [:T_ELEM_END, nil, 1]
-      ]
+      ])
     end
 
     it 'lexes an element with a newline in the open tag' do
-      lex("<p\n></p>").should == [
+      expect(lex("<p\n></p>")).to eq([
         [:T_ELEM_NAME, 'p', 1],
         [:T_ELEM_END, nil, 2]
-      ]
+      ])
     end
 
     it 'lexes an element with a carriage return in the open tag' do
-      lex("<p\r></p>").should == [
+      expect(lex("<p\r></p>")).to eq([
         [:T_ELEM_NAME, 'p', 1],
         [:T_ELEM_END, nil, 2]
-      ]
+      ])
     end
 
     it 'lexes an element with a space in the closing tag' do
-      lex("<foo></foo >bar").should == [
+      expect(lex("<foo></foo >bar")).to eq([
         [:T_ELEM_NAME, 'foo', 1],
         [:T_ELEM_END, nil, 1],
         [:T_TEXT, 'bar', 1]
-      ]
+      ])
     end
 
     it 'lexes an element with a newline in the closing tag' do
-      lex("<foo></foo\n>bar").should == [
+      expect(lex("<foo></foo\n>bar")).to eq([
         [:T_ELEM_NAME, 'foo', 1],
         [:T_ELEM_END, nil, 1],
         [:T_TEXT, 'bar', 2]
-      ]
+      ])
     end
 
     it 'lexes an element with a newline in the closing tag using an IO as input' do
-      lex(StringIO.new("<foo></foo\n>bar")).should == [
+      expect(lex(StringIO.new("<foo></foo\n>bar"))).to eq([
         [:T_ELEM_NAME, 'foo', 1],
         [:T_ELEM_END, nil, 1],
         [:T_TEXT, 'bar', 2]
-      ]
+      ])
     end
   end
 
   describe 'elements with attributes' do
     it 'lexes an element with an attribute without a value' do
-      lex('<p foo></p>').should == [
+      expect(lex('<p foo></p>')).to eq([
         [:T_ELEM_NAME, 'p', 1],
         [:T_ATTR, 'foo', 1],
         [:T_ELEM_END, nil, 1]
-      ]
+      ])
     end
 
     it 'lexes an element with an empty attribute followed by a stray double quote' do
-      lex('<p foo"></p>').should == [
+      expect(lex('<p foo"></p>')).to eq([
         [:T_ELEM_NAME, 'p', 1],
         [:T_ATTR, 'foo', 1],
         [:T_ELEM_END, nil, 1]
-      ]
+      ])
     end
 
     it 'lexes an element with an attribute with an empty value' do
-      lex('<p foo=""></p>').should == [
+      expect(lex('<p foo=""></p>')).to eq([
         [:T_ELEM_NAME, 'p', 1],
         [:T_ATTR, 'foo', 1],
         [:T_STRING_DQUOTE, nil, 1],
         [:T_STRING_DQUOTE, nil, 1],
         [:T_ELEM_END, nil, 1]
-      ]
+      ])
     end
 
     it 'lexes an attribute value followed by a stray double quote' do
-      lex('<p foo="""></p>').should == [
+      expect(lex('<p foo="""></p>')).to eq([
         [:T_ELEM_NAME, 'p', 1],
         [:T_ATTR, 'foo', 1],
         [:T_STRING_DQUOTE, nil, 1],
         [:T_STRING_DQUOTE, nil, 1],
         [:T_ELEM_END, nil, 1]
-      ]
+      ])
     end
 
     it 'lexes an attribute value followed by a stray single quote' do
-      lex('<p foo=""\'></p>').should == [
+      expect(lex('<p foo=""\'></p>')).to eq([
         [:T_ELEM_NAME, 'p', 1],
         [:T_ATTR, 'foo', 1],
         [:T_STRING_DQUOTE, nil, 1],
         [:T_STRING_DQUOTE, nil, 1],
         [:T_ELEM_END, nil, 1]
-      ]
+      ])
     end
 
     it 'lexes a paragraph element with attributes' do
-      lex('<p class="foo">Hello</p>').should == [
+      expect(lex('<p class="foo">Hello</p>')).to eq([
         [:T_ELEM_NAME, 'p', 1],
         [:T_ATTR, 'class', 1],
         [:T_STRING_DQUOTE, nil, 1],
@@ -157,11 +157,11 @@ describe Oga::XML::Lexer do
         [:T_STRING_DQUOTE, nil, 1],
         [:T_TEXT, 'Hello', 1],
         [:T_ELEM_END, nil, 1]
-      ]
+      ])
     end
 
     it 'lexes a paragraph element with a newline in an attribute' do
-      lex("<p class=\"\nfoo\">Hello</p>").should == [
+      expect(lex("<p class=\"\nfoo\">Hello</p>")).to eq([
         [:T_ELEM_NAME, 'p', 1],
         [:T_ATTR, 'class', 1],
         [:T_STRING_DQUOTE, nil, 1],
@@ -169,22 +169,22 @@ describe Oga::XML::Lexer do
         [:T_STRING_DQUOTE, nil, 2],
         [:T_TEXT, 'Hello', 2],
         [:T_ELEM_END, nil, 2]
-      ]
+      ])
     end
 
     it 'lexes a paragraph element with single quoted attributes' do
-      lex("<p class='foo'></p>").should == [
+      expect(lex("<p class='foo'></p>")).to eq([
         [:T_ELEM_NAME, 'p', 1],
         [:T_ATTR, 'class', 1],
         [:T_STRING_SQUOTE, nil, 1],
         [:T_STRING_BODY, 'foo', 1],
         [:T_STRING_SQUOTE, nil, 1],
         [:T_ELEM_END, nil, 1]
-      ]
+      ])
     end
 
     it 'lexes a paragraph element with a namespaced attribute' do
-      lex('<p foo:bar="baz"></p>').should == [
+      expect(lex('<p foo:bar="baz"></p>')).to eq([
         [:T_ELEM_NAME, 'p', 1],
         [:T_ATTR_NS, 'foo', 1],
         [:T_ATTR, 'bar', 1],
@@ -192,55 +192,55 @@ describe Oga::XML::Lexer do
         [:T_STRING_BODY, 'baz', 1],
         [:T_STRING_DQUOTE, nil, 1],
         [:T_ELEM_END, nil, 1]
-      ]
+      ])
     end
 
     it 'lexes an element with spaces around the attribute equal sign' do
-      lex('<p foo = "bar"></p>').should == [
+      expect(lex('<p foo = "bar"></p>')).to eq([
         [:T_ELEM_NAME, 'p', 1],
         [:T_ATTR, 'foo', 1],
         [:T_STRING_DQUOTE, nil, 1],
         [:T_STRING_BODY, 'bar', 1],
         [:T_STRING_DQUOTE, nil, 1],
         [:T_ELEM_END, nil, 1]
-      ]
+      ])
     end
 
     it 'lexes an element with a newline following the equals sign' do
-      lex(%Q{<p foo =\n"bar"></p>}).should == [
+      expect(lex(%Q{<p foo =\n"bar"></p>})).to eq([
         [:T_ELEM_NAME, 'p', 1],
         [:T_ATTR, 'foo', 1],
         [:T_STRING_DQUOTE, nil, 2],
         [:T_STRING_BODY, 'bar', 2],
         [:T_STRING_DQUOTE, nil, 2],
         [:T_ELEM_END, nil, 2]
-      ]
+      ])
     end
 
     it 'lexes an element with a newline following the equals sign using an IO as input' do
-      lex_stringio(%Q{<p foo =\n"bar"></p>}).should == [
+      expect(lex_stringio(%Q{<p foo =\n"bar"></p>})).to eq([
         [:T_ELEM_NAME, 'p', 1],
         [:T_ATTR, 'foo', 1],
         [:T_STRING_DQUOTE, nil, 2],
         [:T_STRING_BODY, 'bar', 2],
         [:T_STRING_DQUOTE, nil, 2],
         [:T_ELEM_END, nil, 2]
-      ]
+      ])
     end
   end
 
   describe 'nested elements' do
     it 'lexes a nested element' do
-      lex('<p><a></a></p>').should == [
+      expect(lex('<p><a></a></p>')).to eq([
         [:T_ELEM_NAME, 'p', 1],
         [:T_ELEM_NAME, 'a', 1],
         [:T_ELEM_END, nil, 1],
         [:T_ELEM_END, nil, 1]
-      ]
+      ])
     end
 
     it 'lexes nested elements and text nodes' do
-      lex('<p>Foo<a>bar</a>baz</p>').should == [
+      expect(lex('<p>Foo<a>bar</a>baz</p>')).to eq([
         [:T_ELEM_NAME, 'p', 1],
         [:T_TEXT, 'Foo', 1],
         [:T_ELEM_NAME, 'a', 1],
@@ -248,100 +248,100 @@ describe Oga::XML::Lexer do
         [:T_ELEM_END, nil, 1],
         [:T_TEXT, 'baz', 1],
         [:T_ELEM_END, nil, 1]
-      ]
+      ])
     end
   end
 
   describe 'void elements' do
     it 'lexes a void element' do
-      lex('<br />').should == [
+      expect(lex('<br />')).to eq([
         [:T_ELEM_NAME, 'br', 1],
         [:T_ELEM_END, nil, 1]
-      ]
+      ])
     end
 
     it 'lexes a void element with an attribute' do
-      lex('<br class="foo" />').should == [
+      expect(lex('<br class="foo" />')).to eq([
         [:T_ELEM_NAME, 'br', 1],
         [:T_ATTR, 'class', 1],
         [:T_STRING_DQUOTE, nil, 1],
         [:T_STRING_BODY, 'foo', 1],
         [:T_STRING_DQUOTE, nil, 1],
         [:T_ELEM_END, nil, 1]
-      ]
+      ])
     end
 
     describe 'without a space before the closing tag' do
       it 'lexes a void element' do
-        lex('<br/>').should == [
+        expect(lex('<br/>')).to eq([
           [:T_ELEM_NAME, 'br', 1],
           [:T_ELEM_END, nil, 1]
-        ]
+        ])
       end
 
       it 'lexes a void element with an attribute' do
-        lex('<br class="foo"/>').should == [
+        expect(lex('<br class="foo"/>')).to eq([
           [:T_ELEM_NAME, 'br', 1],
           [:T_ATTR, 'class', 1],
           [:T_STRING_DQUOTE, nil, 1],
           [:T_STRING_BODY, 'foo', 1],
           [:T_STRING_DQUOTE, nil, 1],
           [:T_ELEM_END, nil, 1]
-        ]
+        ])
       end
     end
   end
 
   describe 'elements with namespaces' do
     it 'lexes an element with namespaces' do
-      lex('<foo:p></p>').should == [
+      expect(lex('<foo:p></p>')).to eq([
         [:T_ELEM_NS, 'foo', 1],
         [:T_ELEM_NAME, 'p', 1],
         [:T_ELEM_END, nil, 1]
-      ]
+      ])
     end
 
     it 'lexes an element with a start and end namespace' do
-      lex('<foo:p></foo:p>').should == [
+      expect(lex('<foo:p></foo:p>')).to eq([
         [:T_ELEM_NS, 'foo', 1],
         [:T_ELEM_NAME, 'p', 1],
         [:T_ELEM_END, nil, 1]
-      ]
+      ])
     end
   end
 
   it 'lexes an element with inline dots' do
-    lex('<SOAP..TestMapping..MappablePerson>').should == [
+    expect(lex('<SOAP..TestMapping..MappablePerson>')).to eq([
       [:T_ELEM_NAME, "SOAP..TestMapping..MappablePerson", 1],
       [:T_ELEM_END, nil, 1]
-    ]
+    ])
   end
 
   it 'lexes an element with a name containing Unicode characters' do
-    lex('<foobár />').should == [
+    expect(lex('<foobár />')).to eq([
       [:T_ELEM_NAME, 'foobár', 1],
       [:T_ELEM_END, nil, 1]
-    ]
+    ])
   end
 
   it 'lexes an element with a name containing an underscore' do
-    lex('<foo_bar />').should == [
+    expect(lex('<foo_bar />')).to eq([
       [:T_ELEM_NAME, 'foo_bar', 1],
       [:T_ELEM_END, nil, 1]
-    ]
+    ])
   end
 
   it 'lexes an element with a name containing a dash' do
-    lex('<foo-bar />').should == [
+    expect(lex('<foo-bar />')).to eq([
       [:T_ELEM_NAME, 'foo-bar', 1],
       [:T_ELEM_END, nil, 1]
-    ]
+    ])
   end
 
   it 'lexes an element with a name containing numbers' do
-    lex('<foo123 />').should == [
+    expect(lex('<foo123 />')).to eq([
       [:T_ELEM_NAME, 'foo123', 1],
       [:T_ELEM_END, nil, 1]
-    ]
+    ])
   end
 end
diff --git a/spec/oga/xml/lexer/enumerator_spec.rb b/spec/oga/xml/lexer/enumerator_spec.rb
index d9d6fee..33be7a6 100644
--- a/spec/oga/xml/lexer/enumerator_spec.rb
+++ b/spec/oga/xml/lexer/enumerator_spec.rb
@@ -10,18 +10,18 @@ describe Oga::XML::Lexer do
     end
 
     it 'lexes a paragraph element' do
-      lex(@enum).should == [
+      expect(lex(@enum)).to eq([
         [:T_ELEM_NAME, 'p', 1],
         [:T_TEXT, 'foo', 1],
         [:T_ELEM_END, nil, 1]
-      ]
+      ])
     end
 
     it 'rewinds input when resetting the lexer' do
       lexer = described_class.new(@enum)
 
-      lexer.lex.empty?.should == false
-      lexer.lex.empty?.should == false
+      expect(lexer.lex.empty?).to eq(false)
+      expect(lexer.lex.empty?).to eq(false)
     end
   end
 end
diff --git a/spec/oga/xml/lexer/general_spec.rb b/spec/oga/xml/lexer/general_spec.rb
index e214abf..90038c9 100644
--- a/spec/oga/xml/lexer/general_spec.rb
+++ b/spec/oga/xml/lexer/general_spec.rb
@@ -3,39 +3,39 @@ require 'spec_helper'
 describe Oga::XML::Lexer do
   describe 'regular text' do
     it 'lexes regular text' do
-      lex('hello').should == [[:T_TEXT, 'hello', 1]]
+      expect(lex('hello')).to eq([[:T_TEXT, 'hello', 1]])
     end
 
     it 'lexes regular whitespace' do
-      lex(' ').should == [[:T_TEXT, ' ', 1]]
+      expect(lex(' ')).to eq([[:T_TEXT, ' ', 1]])
     end
 
     it 'lexes a Unix newline' do
-      lex("\n").should == [[:T_TEXT, "\n", 1]]
+      expect(lex("\n")).to eq([[:T_TEXT, "\n", 1]])
     end
 
     it 'lexes a Windows newline' do
-      lex("\r\n").should == [[:T_TEXT, "\r\n", 1]]
+      expect(lex("\r\n")).to eq([[:T_TEXT, "\r\n", 1]])
     end
 
     it 'lexes a carriage return' do
-      lex("\r").should == [[:T_TEXT, "\r", 1]]
+      expect(lex("\r")).to eq([[:T_TEXT, "\r", 1]])
     end
 
     it 'lexes text followed by a newline' do
-      lex("foo\n").should == [[:T_TEXT, "foo\n", 1]]
+      expect(lex("foo\n")).to eq([[:T_TEXT, "foo\n", 1]])
     end
 
     it 'lexes a > as regular text' do
-      lex('>').should == [[:T_TEXT, '>', 1]]
+      expect(lex('>')).to eq([[:T_TEXT, '>', 1]])
     end
 
     it 'lexes <! as regular text' do
-      lex('<!').should == [[:T_TEXT, '<!', 1]]
+      expect(lex('<!')).to eq([[:T_TEXT, '<!', 1]])
     end
 
     it 'lexes <? as regular text' do
-      lex('<?').should == [[:T_TEXT, '<?', 1]]
+      expect(lex('<?')).to eq([[:T_TEXT, '<?', 1]])
     end
   end
 end
diff --git a/spec/oga/xml/lexer/invalid_elements_spec.rb b/spec/oga/xml/lexer/invalid_elements_spec.rb
index d6f99ba..90d15e4 100644
--- a/spec/oga/xml/lexer/invalid_elements_spec.rb
+++ b/spec/oga/xml/lexer/invalid_elements_spec.rb
@@ -3,21 +3,21 @@ require 'spec_helper'
 describe Oga::XML::Lexer do
   describe 'invalid elements' do
     it 'adds missing closing tags' do
-      lex('<a>').should == [
+      expect(lex('<a>')).to eq([
         [:T_ELEM_NAME, 'a', 1],
         [:T_ELEM_END, nil, 1]
-      ]
+      ])
     end
 
     it 'ignores closing tags without opening tags' do
-      lex('</a>').should == []
+      expect(lex('</a>')).to eq([])
     end
 
     it 'ignores excessive closing tags' do
-      lex('<a></a></b>').should == [
+      expect(lex('<a></a></b>')).to eq([
         [:T_ELEM_NAME, 'a', 1],
         [:T_ELEM_END, nil, 1]
-      ]
+      ])
     end
   end
 end
diff --git a/spec/oga/xml/lexer/io_spec.rb b/spec/oga/xml/lexer/io_spec.rb
index a32b7d6..f34d2ac 100644
--- a/spec/oga/xml/lexer/io_spec.rb
+++ b/spec/oga/xml/lexer/io_spec.rb
@@ -5,7 +5,7 @@ describe Oga::XML::Lexer do
     it 'lexes a paragraph element with attributes' do
       io = StringIO.new("<p class='foo'>\nHello</p>")
 
-      lex(io).should == [
+      expect(lex(io)).to eq([
         [:T_ELEM_NAME, 'p', 1],
         [:T_ATTR, 'class', 1],
         [:T_STRING_SQUOTE, nil, 1],
@@ -14,14 +14,14 @@ describe Oga::XML::Lexer do
         [:T_TEXT, "\n", 1],
         [:T_TEXT, 'Hello', 2],
         [:T_ELEM_END, nil, 2]
-      ]
+      ])
     end
 
     it 'lexes an attribute value starting with a newline' do
       io    = StringIO.new("<foo bar='\n10'></foo>")
       lexer = described_class.new(io)
 
-      lexer.lex.should == [
+      expect(lexer.lex).to eq([
         [:T_ELEM_NAME, 'foo', 1],
         [:T_ATTR, 'bar', 1],
         [:T_STRING_SQUOTE, nil, 1],
@@ -29,14 +29,14 @@ describe Oga::XML::Lexer do
         [:T_STRING_BODY, "10", 2],
         [:T_STRING_SQUOTE, nil, 2],
         [:T_ELEM_END, nil, 2]
-      ]
+      ])
     end
 
     it 'lexes an attribute value split in two by a newline' do
       io    = StringIO.new("<foo bar='foo\nbar'></foo>")
       lexer = described_class.new(io)
 
-      lexer.lex.should == [
+      expect(lexer.lex).to eq([
         [:T_ELEM_NAME, 'foo', 1],
         [:T_ATTR, 'bar', 1],
         [:T_STRING_SQUOTE, nil, 1],
@@ -44,7 +44,7 @@ describe Oga::XML::Lexer do
         [:T_STRING_BODY, 'bar', 2],
         [:T_STRING_SQUOTE, nil, 2],
         [:T_ELEM_END, nil, 2]
-      ]
+      ])
     end
   end
 end
diff --git a/spec/oga/xml/lexer/multibyte_spec.rb b/spec/oga/xml/lexer/multibyte_spec.rb
index 7b24fe4..5eea14a 100644
--- a/spec/oga/xml/lexer/multibyte_spec.rb
+++ b/spec/oga/xml/lexer/multibyte_spec.rb
@@ -5,7 +5,7 @@ require 'spec_helper'
 describe Oga::XML::Lexer do
   describe 'multibyte text nodes' do
     it 'lexes a multibyte text node' do
-      lex('쿠키').should == [[:T_TEXT, '쿠키', 1]]
+      expect(lex('쿠키')).to eq([[:T_TEXT, '쿠키', 1]])
     end
   end
 end
diff --git a/spec/oga/xml/lexer/processing_instruction_spec.rb b/spec/oga/xml/lexer/processing_instruction_spec.rb
index 46219da..245a0a4 100644
--- a/spec/oga/xml/lexer/processing_instruction_spec.rb
+++ b/spec/oga/xml/lexer/processing_instruction_spec.rb
@@ -3,35 +3,35 @@ require 'spec_helper'
 describe Oga::XML::Lexer do
   describe 'processing instructions' do
     it 'lexes an instruction' do
-      lex('<?foo?>').should == [
+      expect(lex('<?foo?>')).to eq([
         [:T_PROC_INS_START, nil, 1],
         [:T_PROC_INS_NAME, 'foo', 1],
         [:T_PROC_INS_END, nil, 1]
-      ]
+      ])
     end
 
     it 'lexes an instruction containing text' do
-      lex('<?foo bar ?>').should == [
+      expect(lex('<?foo bar ?>')).to eq([
         [:T_PROC_INS_START, nil, 1],
         [:T_PROC_INS_NAME, 'foo', 1],
         [:T_PROC_INS_BODY, ' bar ', 1],
         [:T_PROC_INS_END, nil, 1]
-      ]
+      ])
     end
 
     it 'lexes an instruction containing a ?' do
-      lex('<?foo ? ?>').should == [
+      expect(lex('<?foo ? ?>')).to eq([
         [:T_PROC_INS_START, nil, 1],
         [:T_PROC_INS_NAME, 'foo', 1],
         [:T_PROC_INS_BODY, ' ', 1],
         [:T_PROC_INS_BODY, '?', 1],
         [:T_PROC_INS_BODY, ' ', 1],
         [:T_PROC_INS_END, nil, 1]
-      ]
+      ])
     end
 
     it 'lexes two instructions following each other' do
-      lex('<?foo bar ?><?foo baz ?>').should == [
+      expect(lex('<?foo bar ?><?foo baz ?>')).to eq([
         [:T_PROC_INS_START, nil, 1],
         [:T_PROC_INS_NAME, 'foo', 1],
         [:T_PROC_INS_BODY, ' bar ', 1],
@@ -40,72 +40,72 @@ describe Oga::XML::Lexer do
         [:T_PROC_INS_NAME, 'foo', 1],
         [:T_PROC_INS_BODY, ' baz ', 1],
         [:T_PROC_INS_END, nil, 1]
-      ]
+      ])
     end
 
     it 'lexes an instruction with a newline after the name' do
-      lex("<?foo\nbar?>").should == [
+      expect(lex("<?foo\nbar?>")).to eq([
         [:T_PROC_INS_START, nil, 1],
         [:T_PROC_INS_NAME, 'foo', 1],
         [:T_PROC_INS_BODY, "\nbar", 1],
         [:T_PROC_INS_END, nil, 2]
-      ]
+      ])
     end
 
     it 'lexes an instruction with a newline before the closing tag' do
-      lex("<?foo bar\n?>").should == [
+      expect(lex("<?foo bar\n?>")).to eq([
         [:T_PROC_INS_START, nil, 1],
         [:T_PROC_INS_NAME, 'foo', 1],
         [:T_PROC_INS_BODY, " bar\n", 1],
         [:T_PROC_INS_END, nil, 2]
-      ]
+      ])
     end
 
     it 'lexes an instruction with the body surrounded by newlines' do
-      lex("<?foo\nbar\n?>").should == [
+      expect(lex("<?foo\nbar\n?>")).to eq([
         [:T_PROC_INS_START, nil, 1],
         [:T_PROC_INS_NAME, 'foo', 1],
         [:T_PROC_INS_BODY, "\nbar\n", 1],
         [:T_PROC_INS_END, nil, 3]
-      ]
+      ])
     end
 
     it 'lexes an instruction with a namespace prefix' do
-      lex('<?foo:bar?>').should == [
+      expect(lex('<?foo:bar?>')).to eq([
         [:T_PROC_INS_START, nil, 1],
         [:T_PROC_INS_NAME, 'foo:bar', 1],
         [:T_PROC_INS_END, nil, 1]
-      ]
+      ])
     end
 
     describe 'using an IO as input' do
       it 'lexes an instruction with a newline after the name' do
-        lex_stringio("<?foo\nbar?>").should == [
+        expect(lex_stringio("<?foo\nbar?>")).to eq([
           [:T_PROC_INS_START, nil, 1],
           [:T_PROC_INS_NAME, 'foo', 1],
           [:T_PROC_INS_BODY, "\n", 1],
           [:T_PROC_INS_BODY, "bar", 2],
           [:T_PROC_INS_END, nil, 2]
-        ]
+        ])
       end
 
       it 'lexes an instruction with a newline before the closing tag' do
-        lex_stringio("<?foo bar\n?>").should == [
+        expect(lex_stringio("<?foo bar\n?>")).to eq([
           [:T_PROC_INS_START, nil, 1],
           [:T_PROC_INS_NAME, 'foo', 1],
           [:T_PROC_INS_BODY, " bar\n", 1],
           [:T_PROC_INS_END, nil, 2]
-        ]
+        ])
       end
 
       it 'lexes an instruction with the body surrounded by newlines' do
-        lex_stringio("<?foo\nbar\n?>").should == [
+        expect(lex_stringio("<?foo\nbar\n?>")).to eq([
           [:T_PROC_INS_START, nil, 1],
           [:T_PROC_INS_NAME, 'foo', 1],
           [:T_PROC_INS_BODY, "\n", 1],
           [:T_PROC_INS_BODY, "bar\n", 2],
           [:T_PROC_INS_END, nil, 3]
-        ]
+        ])
       end
     end
   end
diff --git a/spec/oga/xml/lexer/strict_spec.rb b/spec/oga/xml/lexer/strict_spec.rb
index 7b840fc..85f759b 100644
--- a/spec/oga/xml/lexer/strict_spec.rb
+++ b/spec/oga/xml/lexer/strict_spec.rb
@@ -3,10 +3,10 @@ require 'spec_helper'
 describe Oga::XML::Lexer do
   describe 'lexing XML using strict mode' do
     it 'does not automatically insert missing closing tags' do
-      lex('<foo>bar', :strict => true).should == [
+      expect(lex('<foo>bar', :strict => true)).to eq([
         [:T_ELEM_NAME, 'foo', 1],
         [:T_TEXT, 'bar', 1]
-      ]
+      ])
     end
   end
 end
diff --git a/spec/oga/xml/lexer/xml_declaration_spec.rb b/spec/oga/xml/lexer/xml_declaration_spec.rb
index ce6843a..57acda4 100644
--- a/spec/oga/xml/lexer/xml_declaration_spec.rb
+++ b/spec/oga/xml/lexer/xml_declaration_spec.rb
@@ -3,51 +3,51 @@ require 'spec_helper'
 describe Oga::XML::Lexer do
   describe 'XML declaration tags' do
     it 'lexes a start tag' do
-      lex('<?xml').should == [[:T_XML_DECL_START, nil, 1]]
+      expect(lex('<?xml')).to eq([[:T_XML_DECL_START, nil, 1]])
     end
 
     it 'lexes a start and end tag' do
-      lex('<?xml?>').should == [
+      expect(lex('<?xml?>')).to eq([
         [:T_XML_DECL_START, nil, 1],
         [:T_XML_DECL_END, nil, 1]
-      ]
+      ])
     end
 
     it 'lexes a tag with text inside it' do
-      lex('<?xml version="1.0" ?>').should == [
+      expect(lex('<?xml version="1.0" ?>')).to eq([
         [:T_XML_DECL_START, nil, 1],
         [:T_ATTR, 'version', 1],
         [:T_STRING_DQUOTE, nil, 1],
         [:T_STRING_BODY, '1.0', 1],
         [:T_STRING_DQUOTE, nil, 1],
         [:T_XML_DECL_END, nil, 1]
-      ]
+      ])
     end
 
     it 'lexes a declaration with a newline after the open tag' do
-      lex("<?xml\n?>").should == [
+      expect(lex("<?xml\n?>")).to eq([
         [:T_XML_DECL_START, nil, 1],
         [:T_XML_DECL_END, nil, 2]
-      ]
+      ])
     end
 
     it 'lexes a declaration with a newline followed by an attribute' do
-      lex("<?xml\na='b'?>").should == [
+      expect(lex("<?xml\na='b'?>")).to eq([
         [:T_XML_DECL_START, nil, 1],
         [:T_ATTR, 'a', 2],
         [:T_STRING_SQUOTE, nil, 2],
         [:T_STRING_BODY, 'b', 2],
         [:T_STRING_SQUOTE, nil, 2],
         [:T_XML_DECL_END, nil, 2]
-      ]
+      ])
     end
 
     describe 'using an IO as input' do
       it 'lexes a declaration with a newline after the open tag' do
-        lex_stringio("<?xml\n?>").should == [
+        expect(lex_stringio("<?xml\n?>")).to eq([
           [:T_XML_DECL_START, nil, 1],
           [:T_XML_DECL_END, nil, 2]
-        ]
+        ])
       end
     end
   end
diff --git a/spec/oga/xml/namespace_spec.rb b/spec/oga/xml/namespace_spec.rb
index f2e7269..9f0db3d 100644
--- a/spec/oga/xml/namespace_spec.rb
+++ b/spec/oga/xml/namespace_spec.rb
@@ -3,13 +3,13 @@ require 'spec_helper'
 describe Oga::XML::Namespace do
   describe '#initialize' do
     it 'sets the name' do
-      described_class.new(:name => 'a').name.should == 'a'
+      expect(described_class.new(:name => 'a').name).to eq('a')
     end
   end
 
   describe '#to_s' do
     it 'converts the Namespace to a String' do
-      described_class.new(:name => 'x').to_s.should == 'x'
+      expect(described_class.new(:name => 'x').to_s).to eq('x')
     end
   end
 
@@ -17,15 +17,17 @@ describe Oga::XML::Namespace do
     it 'returns the inspect value' do
       ns = described_class.new(:name => 'x', :uri => 'y')
 
-      ns.inspect.should == 'Namespace(name: "x" uri: "y")'
+      expect(ns.inspect).to eq('Namespace(name: "x" uri: "y")')
     end
   end
 
   describe '#==' do
     describe 'when comparing with an object that is not a Namespace' do
-      ns = described_class.new(:name => 'a')
+      it 'returns false' do
+        ns = described_class.new(:name => 'a')
 
-      ns.should_not == 10
+        expect(ns).not_to eq(10)
+      end
     end
 
     describe 'when comparing two Namespace instances' do
@@ -33,28 +35,28 @@ describe Oga::XML::Namespace do
         ns1 = described_class.new(:name => 'a')
         ns2 = described_class.new(:name => 'a')
 
-        ns1.should == ns2
+        expect(ns1).to eq(ns2)
       end
 
       it 'returns true if both namespace names and URIs are equal' do
         ns1 = described_class.new(:name => 'a', :uri => 'foo')
         ns2 = described_class.new(:name => 'a', :uri => 'foo')
 
-        ns1.should == ns2
+        expect(ns1).to eq(ns2)
       end
 
       it 'returns false if two namespace names are not equal' do
         ns1 = described_class.new(:name => 'a')
         ns2 = described_class.new(:name => 'b')
 
-        ns1.should_not == ns2
+        expect(ns1).not_to eq(ns2)
       end
 
       it 'retrns false if two namespace URIs are not equal' do
         ns1 = described_class.new(:name => 'a', :uri => 'foo')
         ns2 = described_class.new(:name => 'a', :uri => 'bar')
 
-        ns1.should_not == ns2
+        expect(ns1).not_to eq(ns2)
       end
     end
   end
diff --git a/spec/oga/xml/node_set_spec.rb b/spec/oga/xml/node_set_spec.rb
index 653c710..af70fc8 100644
--- a/spec/oga/xml/node_set_spec.rb
+++ b/spec/oga/xml/node_set_spec.rb
@@ -3,27 +3,27 @@ require 'spec_helper'
 describe Oga::XML::NodeSet do
   describe '#initialize' do
     it 'creates an empty node set' do
-      described_class.new.length.should == 0
+      expect(described_class.new.length).to eq(0)
     end
 
     it 'creates a node set with a single node' do
       node = Oga::XML::Element.new(:name => 'p')
 
-      described_class.new([node]).length.should == 1
+      expect(described_class.new([node]).length).to eq(1)
     end
 
     it 'sets the owner of a set' do
       node = Oga::XML::Element.new
       set  = described_class.new([], node)
 
-      set.owner.should == node
+      expect(set.owner).to eq(node)
     end
 
     it 'takes ownership of the nodes when the set has an owner' do
       node = Oga::XML::Element.new
       set  = described_class.new([node], node)
 
-      node.node_set.should == set
+      expect(node.node_set).to eq(set)
     end
 
     it 'sets the previous and next nodes for all nodes owned by the set' do
@@ -31,11 +31,11 @@ describe Oga::XML::NodeSet do
       node2 = Oga::XML::Element.new
       set   = described_class.new([node1, node2], node1)
 
-      node1.next.should     == node2
-      node1.previous.should == nil
+      expect(node1.next).to     eq(node2)
+      expect(node1.previous).to eq(nil)
 
-      node2.next.should     == nil
-      node2.previous.should == node1
+      expect(node2.next).to     eq(nil)
+      expect(node2.previous).to eq(node1)
     end
 
     it 'does not set the previous and next nodes for nodes that are not owned' do
@@ -43,11 +43,11 @@ describe Oga::XML::NodeSet do
       node2 = Oga::XML::Element.new
       set   = described_class.new([node1, node2])
 
-      node1.previous.should == nil
-      node1.next.should     == nil
+      expect(node1.previous).to eq(nil)
+      expect(node1.next).to     eq(nil)
 
-      node2.previous.should == nil
-      node2.next.should     == nil
+      expect(node2.previous).to eq(nil)
+      expect(node2.next).to     eq(nil)
     end
   end
 
@@ -61,7 +61,7 @@ describe Oga::XML::NodeSet do
 
       set.each { |node| yielded << node }
 
-      yielded.should == [n1, n2]
+      expect(yielded).to eq([n1, n2])
     end
   end
 
@@ -73,21 +73,21 @@ describe Oga::XML::NodeSet do
     end
 
     it 'returns the first node' do
-      @set.first.should == @n1
+      expect(@set.first).to eq(@n1)
     end
 
     it 'returns the last node' do
-      @set.last.should == @n2
+      expect(@set.last).to eq(@n2)
     end
 
     it 'returns the amount of nodes' do
-      @set.count.should  == 2
-      @set.length.should == 2
-      @set.size.should   == 2
+      expect(@set.count).to  eq(2)
+      expect(@set.length).to eq(2)
+      expect(@set.size).to   eq(2)
     end
 
     it 'returns a boolean that indicates if a set is empty or not' do
-      @set.empty?.should == false
+      expect(@set.empty?).to eq(false)
     end
   end
 
@@ -99,11 +99,11 @@ describe Oga::XML::NodeSet do
     end
 
     it 'returns the index of the first node' do
-      @set.index(@n1).should == 0
+      expect(@set.index(@n1)).to eq(0)
     end
 
     it 'returns the index of the last node' do
-      @set.index(@n2).should == 1
+      expect(@set.index(@n2)).to eq(1)
     end
   end
 
@@ -115,7 +115,7 @@ describe Oga::XML::NodeSet do
     it 'pushes a node into the set' do
       @set.push(Oga::XML::Element.new(:name => 'a'))
 
-      @set.length.should == 1
+      expect(@set.length).to eq(1)
     end
 
     it 'does not push a node that is already part of the set' do
@@ -124,7 +124,7 @@ describe Oga::XML::NodeSet do
       @set.push(element)
       @set.push(element)
 
-      @set.length.should == 1
+      expect(@set.length).to eq(1)
     end
 
     it 'takes ownership of a node if the set has an owner' do
@@ -133,7 +133,7 @@ describe Oga::XML::NodeSet do
 
       @set.push(child)
 
-      child.node_set.should == @set
+      expect(child.node_set).to eq(@set)
     end
 
     it 'updates the previous and next nodes of any owned nodes' do
@@ -145,11 +145,11 @@ describe Oga::XML::NodeSet do
       @set.push(node1)
       @set.push(node2)
 
-      node1.next.should     == node2
-      node1.previous.should == nil
+      expect(node1.next).to     eq(node2)
+      expect(node1.previous).to eq(nil)
 
-      node2.next.should     == nil
-      node2.previous.should == node1
+      expect(node2.next).to     eq(nil)
+      expect(node2.previous).to eq(node1)
     end
   end
 
@@ -164,13 +164,13 @@ describe Oga::XML::NodeSet do
 
       @set.unshift(n2)
 
-      @set.first.should == n2
+      expect(@set.first).to eq(n2)
     end
 
     it 'does not push a node if it is already part of the set' do
       @set.unshift(@n1)
 
-      @set.length.should == 1
+      expect(@set.length).to eq(1)
     end
 
     it 'takes ownership of a node if the set has an owner' do
@@ -179,7 +179,7 @@ describe Oga::XML::NodeSet do
 
       @set.unshift(child)
 
-      child.node_set.should == @set
+      expect(child.node_set).to eq(@set)
     end
 
     it 'updates the next node of the added node' do
@@ -188,7 +188,7 @@ describe Oga::XML::NodeSet do
 
       @set.unshift(node)
 
-      node.next.should == @n1
+      expect(node.next).to eq(@n1)
     end
 
     it 'updates the previous node of the existing node' do
@@ -197,7 +197,7 @@ describe Oga::XML::NodeSet do
 
       @set.unshift(node)
 
-      @n1.previous.should == node
+      expect(@n1.previous).to eq(node)
     end
   end
 
@@ -210,24 +210,24 @@ describe Oga::XML::NodeSet do
 
     it 'removes the node from the set' do
       @set.shift
-      @set.empty?.should == true
+      expect(@set.empty?).to eq(true)
     end
 
     it 'returns the node when shifting it' do
-      @set.shift.should == @n1
+      expect(@set.shift).to eq(@n1)
     end
 
     it 'removes ownership if the node belongs to a node set' do
       @set.shift
 
-      @n1.node_set.nil?.should == true
+      expect(@n1.node_set.nil?).to eq(true)
     end
 
     it 'updates the previous and next nodes of the removed node' do
       @set.shift
 
-      @n1.previous.should == nil
-      @n1.next.should     == nil
+      expect(@n1.previous).to eq(nil)
+      expect(@n1.next).to     eq(nil)
     end
 
     it 'updates the previous node of the remaining node' do
@@ -236,7 +236,7 @@ describe Oga::XML::NodeSet do
       @set.push(node)
       @set.shift
 
-      node.previous.should == nil
+      expect(node.previous).to eq(nil)
     end
   end
 
@@ -249,23 +249,23 @@ describe Oga::XML::NodeSet do
 
     it 'removes the node from the set' do
       @set.pop
-      @set.empty?.should == true
+      expect(@set.empty?).to eq(true)
     end
 
     it 'returns the node when popping it' do
-      @set.pop.should == @n1
+      expect(@set.pop).to eq(@n1)
     end
 
     it 'removes ownership if the node belongs to a node set' do
       @set.pop
 
-      @n1.node_set.nil?.should == true
+      expect(@n1.node_set.nil?).to eq(true)
     end
 
     it 'updates the previous node of the removed node' do
       @set.pop
 
-      @n1.previous.should == nil
+      expect(@n1.previous).to eq(nil)
     end
 
     it 'updates the next node of the last remaining node' do
@@ -274,7 +274,7 @@ describe Oga::XML::NodeSet do
       @set.push(node)
       @set.pop
 
-      @n1.next.should == nil
+      expect(@n1.next).to eq(nil)
     end
   end
 
@@ -289,7 +289,7 @@ describe Oga::XML::NodeSet do
 
       @set.insert(0, node)
 
-      @set[0].should == node
+      expect(@set[0]).to eq(node)
     end
 
     it 'does not insert a node that is already in the set' do
@@ -298,7 +298,7 @@ describe Oga::XML::NodeSet do
       @set.insert(0, node)
       @set.insert(0, node)
 
-      @set.length.should == 1
+      expect(@set.length).to eq(1)
     end
 
     it 'inserts a node before another node' do
@@ -308,8 +308,8 @@ describe Oga::XML::NodeSet do
       @set.insert(0, node1)
       @set.insert(0, node2)
 
-      @set[0].should == node2
-      @set[1].should == node1
+      expect(@set[0]).to eq(node2)
+      expect(@set[1]).to eq(node1)
     end
 
     it 'takes ownership of a node when inserting into an owned set' do
@@ -317,7 +317,7 @@ describe Oga::XML::NodeSet do
 
       @owned_set.insert(0, node)
 
-      node.node_set.should == @owned_set
+      expect(node.node_set).to eq(@owned_set)
     end
 
     it 'updates the previous and next nodes of the inserted node' do
@@ -330,8 +330,8 @@ describe Oga::XML::NodeSet do
 
       @owned_set.insert(1, node3)
 
-      node3.previous.should == node1
-      node3.next.should     == node2
+      expect(node3.previous).to eq(node1)
+      expect(node3.next).to     eq(node2)
     end
 
     it 'updates the next node of the node preceding the inserted node' do
@@ -341,7 +341,7 @@ describe Oga::XML::NodeSet do
       @owned_set.push(node1)
       @owned_set.insert(1, node2)
 
-      node1.next.should == node2
+      expect(node1.next).to eq(node2)
     end
 
     it 'updates the previous node of the node following the inserted node' do
@@ -351,7 +351,7 @@ describe Oga::XML::NodeSet do
       @owned_set.push(node1)
       @owned_set.insert(0, node2)
 
-      node1.previous.should == node2
+      expect(node1.previous).to eq(node2)
     end
   end
 
@@ -362,7 +362,7 @@ describe Oga::XML::NodeSet do
     end
 
     it 'returns a node from a given index' do
-      @set[0].should == @n1
+      expect(@set[0]).to eq(@n1)
     end
   end
 
@@ -373,7 +373,7 @@ describe Oga::XML::NodeSet do
     end
 
     it 'converts a set to an Array' do
-      @set.to_a.should == [@n1]
+      expect(@set.to_a).to eq([@n1])
     end
   end
 
@@ -386,11 +386,11 @@ describe Oga::XML::NodeSet do
     end
 
     it 'merges two sets together' do
-      (@set1 + @set2).to_a.should == [@n1, @n2]
+      expect((@set1 + @set2).to_a).to eq([@n1, @n2])
     end
 
     it 'ignores duplicate nodes' do
-      (@set1 + described_class.new([@n1])).length.should == 1
+      expect((@set1 + described_class.new([@n1])).length).to eq(1)
     end
   end
 
@@ -403,11 +403,11 @@ describe Oga::XML::NodeSet do
     end
 
     it 'returns true if two node sets are equal' do
-      @set1.should == @set2
+      expect(@set1).to eq(@set2)
     end
 
     it 'returns false if two node sets are not equal' do
-      @set1.should_not == @set3
+      expect(@set1).not_to eq(@set3)
     end
   end
 
@@ -423,7 +423,7 @@ describe Oga::XML::NodeSet do
     it 'concatenates two node sets' do
       @set1.concat(@set2)
 
-      @set1.length.should == 2
+      expect(@set1.length).to eq(2)
     end
   end
 
@@ -440,36 +440,36 @@ describe Oga::XML::NodeSet do
     it 'does not remove the nodes from the current set' do
       @query_set.remove
 
-      @query_set.empty?.should == false
+      expect(@query_set.empty?).to eq(false)
     end
 
     it 'removes the nodes from the owning set' do
       @query_set.remove
 
-      @doc_set.empty?.should == true
+      expect(@doc_set.empty?).to eq(true)
     end
 
     it 'unlinks the nodes from the sets they belong to' do
       @query_set.remove
 
-      @n1.node_set.nil?.should == true
-      @n2.node_set.nil?.should == true
+      expect(@n1.node_set.nil?).to eq(true)
+      expect(@n2.node_set.nil?).to eq(true)
     end
 
     it 'removes all nodes from the owned set' do
       @doc_set.remove
 
-      @doc_set.empty?.should == true
+      expect(@doc_set.empty?).to eq(true)
     end
 
     it 'updates the previous and next nodes for all removed nodes' do
       @doc_set.remove
 
-      @n1.previous.should == nil
-      @n1.next.should     == nil
+      expect(@n1.previous).to eq(nil)
+      expect(@n1.next).to     eq(nil)
 
-      @n2.previous.should == nil
-      @n2.next.should     == nil
+      expect(@n2.previous).to eq(nil)
+      expect(@n2.next).to     eq(nil)
     end
   end
 
@@ -481,19 +481,19 @@ describe Oga::XML::NodeSet do
     end
 
     it 'returns the node when deleting it' do
-      @set.delete(@n1).should == @n1
+      expect(@set.delete(@n1)).to eq(@n1)
     end
 
     it 'removes the node from the set' do
       @set.delete(@n1)
 
-      @set.empty?.should == true
+      expect(@set.empty?).to eq(true)
     end
 
     it 'removes ownership of the removed node' do
       @set.delete(@n1)
 
-      @n1.node_set.nil?.should == true
+      expect(@n1.node_set.nil?).to eq(true)
     end
 
     it 'updates the previous and next nodes of the removed node' do
@@ -502,8 +502,8 @@ describe Oga::XML::NodeSet do
       @set.push(node)
       @set.delete(@n1)
 
-      @n1.previous.should == nil
-      @n1.next.should     == nil
+      expect(@n1.previous).to eq(nil)
+      expect(@n1.next).to     eq(nil)
     end
   end
 
@@ -516,7 +516,7 @@ describe Oga::XML::NodeSet do
     end
 
     it 'returns the values of an attribute' do
-      @set.attribute('a').should == [@attr]
+      expect(@set.attribute('a')).to eq([@attr])
     end
   end
 
@@ -536,7 +536,7 @@ describe Oga::XML::NodeSet do
     end
 
     it 'returns the text of all nodes' do
-      @set.text.should == "foobaz\nbar"
+      expect(@set.text).to eq("foobaz\nbar")
     end
   end
 end
diff --git a/spec/oga/xml/node_spec.rb b/spec/oga/xml/node_spec.rb
index 0f10308..5d2d3f5 100644
--- a/spec/oga/xml/node_spec.rb
+++ b/spec/oga/xml/node_spec.rb
@@ -6,20 +6,20 @@ describe Oga::XML::Node do
       set  = Oga::XML::NodeSet.new
       node = described_class.new(:node_set => set)
 
-      node.node_set.should == set
+      expect(node.node_set).to eq(set)
     end
   end
 
   describe '#children' do
     it 'returns an empty set by default' do
-      described_class.new.children.empty?.should == true
+      expect(described_class.new.children.empty?).to eq(true)
     end
 
     it 'returns a set that was created manually' do
       set  = Oga::XML::NodeSet.new([described_class.new])
       node = described_class.new(:children => set)
 
-      node.children.should == set
+      expect(node.children).to eq(set)
     end
   end
 
@@ -30,7 +30,7 @@ describe Oga::XML::Node do
 
       node.children = [child]
 
-      node.children[0].should == child
+      expect(node.children[0]).to eq(child)
     end
 
     it 'sets the child nodes using a NodeSet' do
@@ -39,7 +39,7 @@ describe Oga::XML::Node do
 
       node.children = Oga::XML::NodeSet.new([child])
 
-      node.children[0].should == child
+      expect(node.children[0]).to eq(child)
     end
   end
 
@@ -49,11 +49,11 @@ describe Oga::XML::Node do
       set   = Oga::XML::NodeSet.new([], owner)
       node  = described_class.new(:node_set => set)
 
-      node.parent.should == owner
+      expect(node.parent).to eq(owner)
     end
 
     it 'returns nil if there is no parent node' do
-      described_class.new.parent.nil?.should == true
+      expect(described_class.new.parent.nil?).to eq(true)
     end
   end
 
@@ -66,11 +66,11 @@ describe Oga::XML::Node do
     end
 
     it 'returns the previous node' do
-      @n2.previous.should == @n1
+      expect(@n2.previous).to eq(@n1)
     end
 
     it 'returns nil if there is no previous node' do
-      @n1.previous.nil?.should == true
+      expect(@n1.previous.nil?).to eq(true)
     end
   end
 
@@ -83,11 +83,11 @@ describe Oga::XML::Node do
     end
 
     it 'returns the next node' do
-      @n1.next.should == @n2
+      expect(@n1.next).to eq(@n2)
     end
 
     it 'returns nil if there is no next node' do
-      @n2.next.nil?.should == true
+      expect(@n2.next.nil?).to eq(true)
     end
   end
 
@@ -101,15 +101,15 @@ describe Oga::XML::Node do
     end
 
     it 'returns the previous element of a generic node' do
-      @n3.previous_element.should == @n1
+      expect(@n3.previous_element).to eq(@n1)
     end
 
     it 'returns the previous element of a text node' do
-      @n2.previous_element.should == @n1
+      expect(@n2.previous_element).to eq(@n1)
     end
 
     it 'returns nil if there is no previous element' do
-      @n1.previous_element.nil?.should == true
+      expect(@n1.previous_element.nil?).to eq(true)
     end
   end
 
@@ -123,15 +123,15 @@ describe Oga::XML::Node do
     end
 
     it 'returns the next element of a generic node' do
-      @n1.next_element.should == @n3
+      expect(@n1.next_element).to eq(@n3)
     end
 
     it 'returns the next element of a text node' do
-      @n2.next_element.should == @n3
+      expect(@n2.next_element).to eq(@n3)
     end
 
     it 'returns nil if there is no next element' do
-      @n3.next_element.nil?.should == true
+      expect(@n3.next_element.nil?).to eq(true)
     end
   end
 
@@ -145,17 +145,17 @@ describe Oga::XML::Node do
     end
 
     it 'returns the root document of a Node' do
-      @n2.root_node.should == @doc
+      expect(@n2.root_node).to eq(@doc)
     end
 
     it 'returns the root Node of another Node' do
-      @n4.root_node.should == @n3
+      expect(@n4.root_node).to eq(@n3)
     end
 
     it 'flushes the cache when changing the NodeSet of a Node' do
       @n1.children << @n4
 
-      @n4.root_node.should == @doc
+      expect(@n4.root_node).to eq(@doc)
     end
   end
 
@@ -169,13 +169,13 @@ describe Oga::XML::Node do
     it 'returns a node from the node set' do
       @n1.remove
 
-      @set.empty?.should == true
+      expect(@set.empty?).to eq(true)
     end
 
     it 'removes the reference to the set' do
       @n1.remove
 
-      @n1.node_set.nil?.should == true
+      expect(@n1.node_set.nil?).to eq(true)
     end
   end
 
@@ -190,14 +190,14 @@ describe Oga::XML::Node do
 
       @node.replace(other)
 
-      @container.children[0].should == other
+      expect(@container.children[0]).to eq(other)
     end
 
     it 'replaces a node with Oga::XML::Text when called with String' do
       @node.replace('a string')
 
-      @container.children[0].should be_an_instance_of(Oga::XML::Text)
-      @container.children[0].text.should == 'a string'
+      expect(@container.children[0]).to be_an_instance_of(Oga::XML::Text)
+      expect(@container.children[0].text).to eq('a string')
     end
   end
 
@@ -212,8 +212,8 @@ describe Oga::XML::Node do
 
       @node.before(other)
 
-      @container.children[0].should == other
-      @container.children[1].should == @node
+      expect(@container.children[0]).to eq(other)
+      expect(@container.children[1]).to eq(@node)
     end
   end
 
@@ -228,8 +228,8 @@ describe Oga::XML::Node do
 
       @node.after(other)
 
-      @container.children[0].should == @node
-      @container.children[1].should == other
+      expect(@container.children[0]).to eq(@node)
+      expect(@container.children[1]).to eq(other)
     end
   end
 
@@ -238,14 +238,14 @@ describe Oga::XML::Node do
       node     = described_class.new
       document = Oga::XML::Document.new(:children => [node], :type => :html)
 
-      node.html?.should == true
+      expect(node.html?).to eq(true)
     end
 
     it 'returns false if the node resides within an XML document' do
       node     = described_class.new
       document = Oga::XML::Document.new(:children => [node], :type => :xml)
 
-      node.html?.should == false
+      expect(node.html?).to eq(false)
     end
 
     it 'flushes the cache when changing the NodeSet of a Node' do
@@ -253,11 +253,11 @@ describe Oga::XML::Node do
       html_doc = Oga::XML::Document.new(:type => :html)
       xml_doc  = Oga::XML::Document.new(:type => :xml, :children => [node])
 
-      node.html?.should == false
+      expect(node.html?).to eq(false)
 
       html_doc.children << node
 
-      node.html?.should == true
+      expect(node.html?).to eq(true)
     end
   end
 
@@ -266,14 +266,14 @@ describe Oga::XML::Node do
       node     = described_class.new
       document = Oga::XML::Document.new(:children => [node], :type => :xml)
 
-      node.xml?.should == true
+      expect(node.xml?).to eq(true)
     end
 
     it 'returns false if the node resides within an HTML document' do
       node     = described_class.new
       document = Oga::XML::Document.new(:children => [node], :type => :html)
 
-      node.xml?.should == false
+      expect(node.xml?).to eq(false)
     end
   end
 
diff --git a/spec/oga/xml/parser/cdata_spec.rb b/spec/oga/xml/parser/cdata_spec.rb
index 09c2898..7eedb4c 100644
--- a/spec/oga/xml/parser/cdata_spec.rb
+++ b/spec/oga/xml/parser/cdata_spec.rb
@@ -7,7 +7,7 @@ describe Oga::XML::Parser do
     end
 
     it 'returns a Cdata instance' do
-      @node.is_a?(Oga::XML::Cdata).should == true
+      expect(@node.is_a?(Oga::XML::Cdata)).to eq(true)
     end
   end
 
@@ -17,11 +17,11 @@ describe Oga::XML::Parser do
     end
 
     it 'returns a Cdata instance' do
-      @node.is_a?(Oga::XML::Cdata).should == true
+      expect(@node.is_a?(Oga::XML::Cdata)).to eq(true)
     end
 
     it 'sets the text of the tag' do
-      @node.text.should == 'foo'
+      expect(@node.text).to eq('foo')
     end
   end
 
@@ -31,7 +31,7 @@ describe Oga::XML::Parser do
     end
 
     it 'sets the HTML as raw text' do
-      @node.text.should == '<p>foo</p>'
+      expect(@node.text).to eq('<p>foo</p>')
     end
   end
 end
diff --git a/spec/oga/xml/parser/comments_spec.rb b/spec/oga/xml/parser/comments_spec.rb
index c408edb..37e151d 100644
--- a/spec/oga/xml/parser/comments_spec.rb
+++ b/spec/oga/xml/parser/comments_spec.rb
@@ -7,7 +7,7 @@ describe Oga::XML::Parser do
     end
 
     it 'returns a Comment instance' do
-      @node.is_a?(Oga::XML::Comment).should == true
+      expect(@node.is_a?(Oga::XML::Comment)).to eq(true)
     end
   end
 
@@ -17,11 +17,11 @@ describe Oga::XML::Parser do
     end
 
     it 'returns a Comment instance' do
-      @node.is_a?(Oga::XML::Comment).should == true
+      expect(@node.is_a?(Oga::XML::Comment)).to eq(true)
     end
 
     it 'sets the text of the comment' do
-      @node.text.should == 'foo'
+      expect(@node.text).to eq('foo')
     end
   end
 end
diff --git a/spec/oga/xml/parser/doctype_spec.rb b/spec/oga/xml/parser/doctype_spec.rb
index 1461f4b..0acc653 100644
--- a/spec/oga/xml/parser/doctype_spec.rb
+++ b/spec/oga/xml/parser/doctype_spec.rb
@@ -7,11 +7,11 @@ describe Oga::XML::Parser do
     end
 
     it 'returns a Doctype instance' do
-      @document.doctype.is_a?(Oga::XML::Doctype).should == true
+      expect(@document.doctype.is_a?(Oga::XML::Doctype)).to eq(true)
     end
 
     it 'sets the name of the doctype' do
-      @document.doctype.name.should == 'html'
+      expect(@document.doctype.name).to eq('html')
     end
   end
 
@@ -21,15 +21,15 @@ describe Oga::XML::Parser do
     end
 
     it 'returns a Doctype instance' do
-      @document.doctype.is_a?(Oga::XML::Doctype).should == true
+      expect(@document.doctype.is_a?(Oga::XML::Doctype)).to eq(true)
     end
 
     it 'sets the name of the doctype' do
-      @document.doctype.name.should == 'html'
+      expect(@document.doctype.name).to eq('html')
     end
 
     it 'sets the type of the doctype' do
-      @document.doctype.type.should == 'PUBLIC'
+      expect(@document.doctype.type).to eq('PUBLIC')
     end
   end
 
@@ -39,19 +39,19 @@ describe Oga::XML::Parser do
     end
 
     it 'returns a Doctype instance' do
-      @document.doctype.is_a?(Oga::XML::Doctype).should == true
+      expect(@document.doctype.is_a?(Oga::XML::Doctype)).to eq(true)
     end
 
     it 'sets the name of the doctype' do
-      @document.doctype.name.should == 'html'
+      expect(@document.doctype.name).to eq('html')
     end
 
     it 'sets the type of the doctype' do
-      @document.doctype.type.should == 'PUBLIC'
+      expect(@document.doctype.type).to eq('PUBLIC')
     end
 
     it 'sets the public ID of the doctype' do
-      @document.doctype.public_id.should == 'foo'
+      expect(@document.doctype.public_id).to eq('foo')
     end
   end
 
@@ -61,23 +61,23 @@ describe Oga::XML::Parser do
     end
 
     it 'returns a Doctype instance' do
-      @document.doctype.is_a?(Oga::XML::Doctype).should == true
+      expect(@document.doctype.is_a?(Oga::XML::Doctype)).to eq(true)
     end
 
     it 'sets the name of the doctype' do
-      @document.doctype.name.should == 'html'
+      expect(@document.doctype.name).to eq('html')
     end
 
     it 'sets the type of the doctype' do
-      @document.doctype.type.should == 'PUBLIC'
+      expect(@document.doctype.type).to eq('PUBLIC')
     end
 
     it 'sets the public ID of the doctype' do
-      @document.doctype.public_id.should == 'foo'
+      expect(@document.doctype.public_id).to eq('foo')
     end
 
     it 'sets the system ID of the doctype' do
-      @document.doctype.system_id.should == 'bar'
+      expect(@document.doctype.system_id).to eq('bar')
     end
   end
 
@@ -87,11 +87,11 @@ describe Oga::XML::Parser do
     end
 
     it 'returns a Doctype instance' do
-      @document.doctype.is_a?(Oga::XML::Doctype).should == true
+      expect(@document.doctype.is_a?(Oga::XML::Doctype)).to eq(true)
     end
 
     it 'sets the inline doctype rules' do
-      @document.doctype.inline_rules.should == '<!ELEMENT foo>'
+      expect(@document.doctype.inline_rules).to eq('<!ELEMENT foo>')
     end
   end
 
@@ -101,7 +101,7 @@ describe Oga::XML::Parser do
     end
 
     it 'sets the inline doctype rules' do
-      @document.doctype.inline_rules.should == "\nfoo"
+      expect(@document.doctype.inline_rules).to eq("\nfoo")
     end
   end
 
@@ -111,27 +111,27 @@ describe Oga::XML::Parser do
     end
 
     it 'returns a Doctype instance' do
-      @document.doctype.should be_an_instance_of(Oga::XML::Doctype)
+      expect(@document.doctype).to be_an_instance_of(Oga::XML::Doctype)
     end
 
     it 'sets the name of the doctype' do
-      @document.doctype.name.should == 'svg'
+      expect(@document.doctype.name).to eq('svg')
     end
 
     it 'sets the type of the doctype' do
-      @document.doctype.type.should == 'PUBLIC'
+      expect(@document.doctype.type).to eq('PUBLIC')
     end
 
     it 'sets the public ID of the doctype' do
-      @document.doctype.public_id.should == 'foo'
+      expect(@document.doctype.public_id).to eq('foo')
     end
 
     it 'sets the system ID of the doctype' do
-      @document.doctype.system_id.should == 'bar'
+      expect(@document.doctype.system_id).to eq('bar')
     end
 
     it 'sets the inline rules of the doctype' do
-      @document.doctype.inline_rules.should == 'rule1'
+      expect(@document.doctype.inline_rules).to eq('rule1')
     end
   end
 
@@ -145,14 +145,14 @@ describe Oga::XML::Parser do
       # doctypes at arbitrary locations would come at a hefty performance
       # impact, and requires doctypes to reach back into their owning documents
       # (which leads to ugly code).
-      @document.doctype.should be_nil
+      expect(@document.doctype).to be_nil
     end
 
     it 'sets the next node of the doctype' do
       doctype = @document.children[0].children[0]
       bar = @document.children[0].children[1]
 
-      doctype.next.should == bar
+      expect(doctype.next).to eq(bar)
     end
   end
 end
diff --git a/spec/oga/xml/parser/documents_spec.rb b/spec/oga/xml/parser/documents_spec.rb
index d12a1a2..ac5bb81 100644
--- a/spec/oga/xml/parser/documents_spec.rb
+++ b/spec/oga/xml/parser/documents_spec.rb
@@ -7,7 +7,7 @@ describe Oga::XML::Parser do
     end
 
     it 'returns a Document instance' do
-      @document.is_a?(Oga::XML::Document).should == true
+      expect(@document.is_a?(Oga::XML::Document)).to eq(true)
     end
   end
 
@@ -17,11 +17,11 @@ describe Oga::XML::Parser do
     end
 
     it 'returns a Document instance' do
-      @document.is_a?(Oga::XML::Document).should == true
+      expect(@document.is_a?(Oga::XML::Document)).to eq(true)
     end
 
     it 'sets the document type' do
-      @document.type.should == :xml
+      expect(@document.type).to eq(:xml)
     end
   end
 
@@ -42,23 +42,23 @@ describe Oga::XML::Parser do
     end
 
     it 'returns a Document instance' do
-      @document.is_a?(Oga::XML::Document).should == true
+      expect(@document.is_a?(Oga::XML::Document)).to eq(true)
     end
 
     it 'sets the document type' do
-      @document.type.should == :html
+      expect(@document.type).to eq(:html)
     end
 
     it 'sets the doctype of the document' do
-      @document.doctype.is_a?(Oga::XML::Doctype).should == true
+      expect(@document.doctype.is_a?(Oga::XML::Doctype)).to eq(true)
     end
 
     it 'sets the XML declaration of the document' do
-      @document.xml_declaration.is_a?(Oga::XML::XmlDeclaration).should == true
+      expect(@document.xml_declaration.is_a?(Oga::XML::XmlDeclaration)).to eq(true)
     end
 
     it 'sets the children of the document' do
-      @document.children.empty?.should == false
+      expect(@document.children.empty?).to eq(false)
     end
   end
 end
diff --git a/spec/oga/xml/parser/elements_spec.rb b/spec/oga/xml/parser/elements_spec.rb
index 95a4a77..6b58e5c 100644
--- a/spec/oga/xml/parser/elements_spec.rb
+++ b/spec/oga/xml/parser/elements_spec.rb
@@ -7,15 +7,15 @@ describe Oga::XML::Parser do
     end
 
     it 'returns an Element instance' do
-      @element.is_a?(Oga::XML::Element).should == true
+      expect(@element.is_a?(Oga::XML::Element)).to eq(true)
     end
 
     it 'sets the name of the element' do
-      @element.name.should == 'p'
+      expect(@element.name).to eq('p')
     end
 
     it 'does not set a namespace' do
-      @element.namespace.should be_nil
+      expect(@element.namespace).to be_nil
     end
   end
 
@@ -25,15 +25,15 @@ describe Oga::XML::Parser do
     end
 
     it 'returns an Element instance' do
-      @element.is_a?(Oga::XML::Element).should == true
+      expect(@element.is_a?(Oga::XML::Element)).to eq(true)
     end
 
     it 'sets the name of the element' do
-      @element.name.should == 'p'
+      expect(@element.name).to eq('p')
     end
 
     it 'sets the namespace of the element' do
-      @element.namespace.name.should == 'foo'
+      expect(@element.namespace.name).to eq('foo')
     end
   end
 
@@ -46,19 +46,19 @@ describe Oga::XML::Parser do
     end
 
     it 'sets the namespace name of the <foo> element' do
-      @foo.namespace.name.should == 'xmlns'
+      expect(@foo.namespace.name).to eq('xmlns')
     end
 
     it 'sets the namespace URI of the <foo> element' do
-      @foo.namespace.uri.should == 'bar'
+      expect(@foo.namespace.uri).to eq('bar')
     end
 
     it 'sets the namespace name of the <bar> element' do
-      @bar.namespace.name.should == 'xmlns'
+      expect(@bar.namespace.name).to eq('xmlns')
     end
 
     it 'sets the namespace URI of the <bar> element' do
-      @bar.namespace.uri.should == 'bar'
+      expect(@bar.namespace.uri).to eq('bar')
     end
   end
 
@@ -68,15 +68,15 @@ describe Oga::XML::Parser do
     end
 
     it 'returns an Element instance' do
-      @element.is_a?(Oga::XML::Element).should == true
+      expect(@element.is_a?(Oga::XML::Element)).to eq(true)
     end
 
     it 'sets the bar attribute' do
-      @element.attribute('bar').value.should == 'baz'
+      expect(@element.attribute('bar').value).to eq('baz')
     end
 
     it 'does not set the attribute namespace' do
-      @element.attribute('bar').namespace.should be_nil
+      expect(@element.attribute('bar').namespace).to be_nil
     end
   end
 
@@ -86,11 +86,11 @@ describe Oga::XML::Parser do
     end
 
     it 'returns an Element instance' do
-      @element.is_a?(Oga::XML::Element).should == true
+      expect(@element.is_a?(Oga::XML::Element)).to eq(true)
     end
 
     it 'sets the bar attribute' do
-      @element.attribute('bar').value.should be_nil
+      expect(@element.attribute('bar').value).to be_nil
     end
   end
 
@@ -100,11 +100,11 @@ describe Oga::XML::Parser do
     end
 
     it 'returns an Element instance' do
-      @element.is_a?(Oga::XML::Element).should == true
+      expect(@element.is_a?(Oga::XML::Element)).to eq(true)
     end
 
     it 'sets the bar attribute' do
-      @element.attribute('bar').value.should == ''
+      expect(@element.attribute('bar').value).to eq('')
     end
   end
 
@@ -114,19 +114,19 @@ describe Oga::XML::Parser do
     end
 
     it 'returns an Element instance' do
-      @element.is_a?(Oga::XML::Element).should == true
+      expect(@element.is_a?(Oga::XML::Element)).to eq(true)
     end
 
     it 'includes the namespace of the attribute' do
-      @element.attribute('x:bar').namespace.name.should == 'x'
+      expect(@element.attribute('x:bar').namespace.name).to eq('x')
     end
 
     it 'includes the name of the attribute' do
-      @element.attribute('x:bar').name.should == 'bar'
+      expect(@element.attribute('x:bar').name).to eq('bar')
     end
 
     it 'includes the value of the attribute' do
-      @element.attribute('x:bar').value.should == 'baz'
+      expect(@element.attribute('x:bar').value).to eq('baz')
     end
   end
 
@@ -136,15 +136,15 @@ describe Oga::XML::Parser do
     end
 
     it 'sets the name of the outer element' do
-      @element.name.should == 'a'
+      expect(@element.name).to eq('a')
     end
 
     it 'sets the child elements' do
-      @element.children[0].is_a?(Oga::XML::Element).should == true
+      expect(@element.children[0].is_a?(Oga::XML::Element)).to eq(true)
     end
 
     it 'sets the name of the child element' do
-      @element.children[0].name.should == 'b'
+      expect(@element.children[0].name).to eq('b')
     end
   end
 
@@ -154,11 +154,11 @@ describe Oga::XML::Parser do
     end
 
     it 'includes the text node of the outer element' do
-      @element.children[0].is_a?(Oga::XML::Text).should == true
+      expect(@element.children[0].is_a?(Oga::XML::Text)).to eq(true)
     end
 
     it 'includes the text node of the inner element' do
-      @element.children[1].children[0].is_a?(Oga::XML::Text).should == true
+      expect(@element.children[1].children[0].is_a?(Oga::XML::Text)).to eq(true)
     end
   end
 
@@ -171,22 +171,22 @@ describe Oga::XML::Parser do
     end
 
     it 'returns the namespaces of the <root> node' do
-      @root.namespaces['a'].name.should == 'a'
-      @root.namespaces['a'].uri.should  == '1'
+      expect(@root.namespaces['a'].name).to eq('a')
+      expect(@root.namespaces['a'].uri).to  eq('1')
     end
 
     it 'returns the namespaces of the <foo> node' do
-      @foo.namespaces['b'].name.should == 'b'
-      @foo.namespaces['b'].uri.should  == '2'
+      expect(@foo.namespaces['b'].name).to eq('b')
+      expect(@foo.namespaces['b'].uri).to  eq('2')
     end
 
     it 'returns the available namespaces of the <root> node' do
-      @root.available_namespaces['a'].name.should == 'a'
+      expect(@root.available_namespaces['a'].name).to eq('a')
     end
 
     it 'returns the available namespaces of the <foo> node' do
-      @foo.available_namespaces['a'].name.should == 'a'
-      @foo.available_namespaces['b'].name.should == 'b'
+      expect(@foo.available_namespaces['a'].name).to eq('a')
+      expect(@foo.available_namespaces['b'].name).to eq('b')
     end
   end
 end
diff --git a/spec/oga/xml/parser/error_spec.rb b/spec/oga/xml/parser/error_spec.rb
index 66e1894..5161bab 100644
--- a/spec/oga/xml/parser/error_spec.rb
+++ b/spec/oga/xml/parser/error_spec.rb
@@ -11,15 +11,15 @@ describe Oga::XML::Parser do
     end
 
     it 'includes the line number when using a String as input' do
-      parse_error(@invalid_xml).should =~ /on line 1/
+      expect(parse_error(@invalid_xml)).to match(/on line 1/)
     end
 
     it 'includes the line number when using an IO as input' do
-      parse_error(StringIO.new(@invalid_xml)).should =~ /on line 1/
+      expect(parse_error(StringIO.new(@invalid_xml))).to match(/on line 1/)
     end
 
     it 'uses more friendly error messages when available' do
-      parse_error('<x:y:z>').should =~ /Unexpected element namespace/
+      expect(parse_error('<x:y:z>')).to match(/Unexpected element namespace/)
     end
   end
 end
diff --git a/spec/oga/xml/parser/hierarchy_spec.rb b/spec/oga/xml/parser/hierarchy_spec.rb
index fa5e4e3..39b48ca 100644
--- a/spec/oga/xml/parser/hierarchy_spec.rb
+++ b/spec/oga/xml/parser/hierarchy_spec.rb
@@ -7,11 +7,11 @@ describe Oga::XML::Parser do
     end
 
     it 'returns an Element instance for the parent' do
-      @parent.children[0].parent.is_a?(Oga::XML::Element).should == true
+      expect(@parent.children[0].parent.is_a?(Oga::XML::Element)).to eq(true)
     end
 
     it 'sets the correct parent' do
-      @parent.children[0].parent.should == @parent
+      expect(@parent.children[0].parent).to eq(@parent)
     end
   end
 
@@ -21,11 +21,11 @@ describe Oga::XML::Parser do
     end
 
     it 'returns an Element instance for the parent' do
-      @parent.children[0].parent.is_a?(Oga::XML::Element).should == true
+      expect(@parent.children[0].parent.is_a?(Oga::XML::Element)).to eq(true)
     end
 
     it 'sets the correct parent' do
-      @parent.children[0].parent.should == @parent
+      expect(@parent.children[0].parent).to eq(@parent)
     end
   end
 
@@ -35,19 +35,19 @@ describe Oga::XML::Parser do
     end
 
     it 'returns an Element instance for the next element' do
-      @document.children[0].next.is_a?(Oga::XML::Element).should == true
+      expect(@document.children[0].next.is_a?(Oga::XML::Element)).to eq(true)
     end
 
     it 'sets the correct next element' do
-      @document.children[0].next.should == @document.children[1]
+      expect(@document.children[0].next).to eq(@document.children[1])
     end
 
     it 'returns an Element instance for the previous element' do
-      @document.children[1].previous.is_a?(Oga::XML::Element).should == true
+      expect(@document.children[1].previous.is_a?(Oga::XML::Element)).to eq(true)
     end
 
     it 'sets the correct previous element' do
-      @document.children[1].previous.should == @document.children[0]
+      expect(@document.children[1].previous).to eq(@document.children[0])
     end
   end
 end
diff --git a/spec/oga/xml/parser/html_void_elements_spec.rb b/spec/oga/xml/parser/html_void_elements_spec.rb
index d641d12..0913fbf 100644
--- a/spec/oga/xml/parser/html_void_elements_spec.rb
+++ b/spec/oga/xml/parser/html_void_elements_spec.rb
@@ -7,11 +7,11 @@ describe Oga::XML::Parser do
     end
 
     it 'returns an Element instance' do
-      @node.is_a?(Oga::XML::Element).should == true
+      expect(@node.is_a?(Oga::XML::Element)).to eq(true)
     end
 
     it 'sets the name of the element' do
-      @node.name.should == 'link'
+      expect(@node.name).to eq('link')
     end
   end
 
@@ -21,11 +21,11 @@ describe Oga::XML::Parser do
     end
 
     it 'sets the name of the outer element' do
-      @node.name.should == 'head'
+      expect(@node.name).to eq('head')
     end
 
     it 'sets the name of the inner element' do
-      @node.children[0].name.should == 'link'
+      expect(@node.children[0].name).to eq('link')
     end
   end
 
@@ -35,11 +35,11 @@ describe Oga::XML::Parser do
     end
 
     it 'parses void elements with different casing' do
-      @node_uc.is_a?(Oga::XML::Element).should == true
+      expect(@node_uc.is_a?(Oga::XML::Element)).to eq(true)
     end
 
     it 'sets the name of the void element to match casing' do
-      @node_uc.name.should == 'BR'
+      expect(@node_uc.name).to eq('BR')
     end
   end
 
@@ -49,11 +49,11 @@ describe Oga::XML::Parser do
     end
 
     it 'sets the name of the element' do
-      @node.name.should == 'link'
+      expect(@node.name).to eq('link')
     end
 
     it 'sets the attributes' do
-      @node.attribute('href').value.should == 'foo'
+      expect(@node.attribute('href').value).to eq('foo')
     end
   end
 end
diff --git a/spec/oga/xml/parser/io_spec.rb b/spec/oga/xml/parser/io_spec.rb
index ec8b571..157bcc5 100644
--- a/spec/oga/xml/parser/io_spec.rb
+++ b/spec/oga/xml/parser/io_spec.rb
@@ -6,14 +6,14 @@ describe Oga::XML::Parser do
       io  = StringIO.new("<foo bar='\n10'></foo>")
       doc = parse(io)
 
-      doc.children[0].attributes[0].value.should == "\n10"
+      expect(doc.children[0].attributes[0].value).to eq("\n10")
     end
 
     it 'parses an attribute value split in two by a newline' do
       io  = StringIO.new("<foo bar='foo\nbar'></foo>")
       doc = parse(io)
 
-      doc.children[0].attributes[0].value.should == "foo\nbar"
+      expect(doc.children[0].attributes[0].value).to eq("foo\nbar")
     end
   end
 end
diff --git a/spec/oga/xml/parser/processing_instruction_spec.rb b/spec/oga/xml/parser/processing_instruction_spec.rb
index e0ad6d9..d32aba6 100644
--- a/spec/oga/xml/parser/processing_instruction_spec.rb
+++ b/spec/oga/xml/parser/processing_instruction_spec.rb
@@ -7,11 +7,11 @@ describe Oga::XML::Parser do
     end
 
     it 'returns a ProcessingInstruction instance' do
-      @node.is_a?(Oga::XML::ProcessingInstruction).should == true
+      expect(@node.is_a?(Oga::XML::ProcessingInstruction)).to eq(true)
     end
 
     it 'sets the name of the instruction' do
-      @node.name.should == 'foo'
+      expect(@node.name).to eq('foo')
     end
   end
 
@@ -21,22 +21,22 @@ describe Oga::XML::Parser do
     end
 
     it 'returns a ProcessingInstruction instance' do
-      @node.is_a?(Oga::XML::ProcessingInstruction).should == true
+      expect(@node.is_a?(Oga::XML::ProcessingInstruction)).to eq(true)
     end
 
     it 'sets the name of the instruction' do
-      @node.name.should == 'foo'
+      expect(@node.name).to eq('foo')
     end
 
     it 'sets the text of the instruction' do
-      @node.text.should == ' bar '
+      expect(@node.text).to eq(' bar ')
     end
   end
 
   it 'parses a processing instruction with a namespace prefix' do
     node = parse('<?foo:bar ?>').children[0]
 
-    node.should be_an_instance_of(Oga::XML::ProcessingInstruction)
-    node.name.should == 'foo:bar'
+    expect(node).to be_an_instance_of(Oga::XML::ProcessingInstruction)
+    expect(node.name).to eq('foo:bar')
   end
 end
diff --git a/spec/oga/xml/parser/text_spec.rb b/spec/oga/xml/parser/text_spec.rb
index 93607e2..3dff388 100644
--- a/spec/oga/xml/parser/text_spec.rb
+++ b/spec/oga/xml/parser/text_spec.rb
@@ -7,11 +7,11 @@ describe Oga::XML::Parser do
     end
 
     it 'returns a Text instance' do
-      @node.is_a?(Oga::XML::Text).should == true
+      expect(@node.is_a?(Oga::XML::Text)).to eq(true)
     end
 
     it 'sets the text' do
-      @node.text.should == 'foo'
+      expect(@node.text).to eq('foo')
     end
   end
 end
diff --git a/spec/oga/xml/parser/xml_declaration_spec.rb b/spec/oga/xml/parser/xml_declaration_spec.rb
index a410e02..13b2374 100644
--- a/spec/oga/xml/parser/xml_declaration_spec.rb
+++ b/spec/oga/xml/parser/xml_declaration_spec.rb
@@ -7,15 +7,15 @@ describe Oga::XML::Parser do
     end
 
     it 'returns an XmlDeclaration instance' do
-      @node.is_a?(Oga::XML::XmlDeclaration).should == true
+      expect(@node.is_a?(Oga::XML::XmlDeclaration)).to eq(true)
     end
 
     it 'sets the default XML version' do
-      @node.version.should == '1.0'
+      expect(@node.version).to eq('1.0')
     end
 
     it 'sets the default encoding' do
-      @node.encoding.should == 'UTF-8'
+      expect(@node.encoding).to eq('UTF-8')
     end
   end
 
@@ -25,39 +25,39 @@ describe Oga::XML::Parser do
     end
 
     it 'returns an XmlDeclaration instance' do
-      @node.is_a?(Oga::XML::XmlDeclaration).should == true
+      expect(@node.is_a?(Oga::XML::XmlDeclaration)).to eq(true)
     end
 
     it 'sets the XML version' do
-      @node.version.should == '1.5'
+      expect(@node.version).to eq('1.5')
     end
 
     it 'sets the encoding' do
-      @node.encoding.should == 'foo'
+      expect(@node.encoding).to eq('foo')
     end
   end
 
   it 'parses an XML declaration inside an element' do
     document = parse('<foo><?xml ?></foo>')
 
-    document.children[0].should be_an_instance_of(Oga::XML::Element)
-    document.children[0].children[0].should be_an_instance_of(Oga::XML::XmlDeclaration)
+    expect(document.children[0]).to be_an_instance_of(Oga::XML::Element)
+    expect(document.children[0].children[0]).to be_an_instance_of(Oga::XML::XmlDeclaration)
   end
 
   it 'parses an XML declaration preceded by an element' do
     document = parse('<foo /><?xml ?>')
 
-    document.xml_declaration.should be_an_instance_of(Oga::XML::XmlDeclaration)
-    document.children[0].should be_an_instance_of(Oga::XML::Element)
+    expect(document.xml_declaration).to be_an_instance_of(Oga::XML::XmlDeclaration)
+    expect(document.children[0]).to be_an_instance_of(Oga::XML::Element)
   end
 
   it 'parses an XML declaration preceded by an element with a common ancestor' do
     document = parse('<root><a /><?xml ?></root>')
     root = document.children[0]
 
-    root.children[0].should be_an_instance_of(Oga::XML::Element)
-    root.children[1].should be_an_instance_of(Oga::XML::XmlDeclaration)
+    expect(root.children[0]).to be_an_instance_of(Oga::XML::Element)
+    expect(root.children[1]).to be_an_instance_of(Oga::XML::XmlDeclaration)
 
-    root.children[1].previous.should == root.children[0]
+    expect(root.children[1].previous).to eq(root.children[0])
   end
 end
diff --git a/spec/oga/xml/processing_instruction_spec.rb b/spec/oga/xml/processing_instruction_spec.rb
index 2619b61..1d6f75e 100644
--- a/spec/oga/xml/processing_instruction_spec.rb
+++ b/spec/oga/xml/processing_instruction_spec.rb
@@ -3,11 +3,11 @@ require 'spec_helper'
 describe Oga::XML::ProcessingInstruction do
   describe '#initialize' do
     it 'sets the name of the node' do
-      described_class.new(:name => 'foo').name.should == 'foo'
+      expect(described_class.new(:name => 'foo').name).to eq('foo')
     end
 
     it 'sets the text of the node' do
-      described_class.new(:text => 'foo').text.should == 'foo'
+      expect(described_class.new(:text => 'foo').text).to eq('foo')
     end
   end
 
@@ -15,7 +15,7 @@ describe Oga::XML::ProcessingInstruction do
     it 'convers the node into XML' do
       node = described_class.new(:name => 'foo', :text => ' bar ')
 
-      node.to_xml.should == '<?foo bar ?>'
+      expect(node.to_xml).to eq('<?foo bar ?>')
     end
   end
 
@@ -23,7 +23,7 @@ describe Oga::XML::ProcessingInstruction do
     it 'returns the inspect value of the node' do
       node = described_class.new(:name => 'foo', :text => ' bar ')
 
-      node.inspect.should == 'ProcessingInstruction(name: "foo" text: " bar ")'
+      expect(node.inspect).to eq('ProcessingInstruction(name: "foo" text: " bar ")')
     end
   end
 end
diff --git a/spec/oga/xml/pull_parser/context_parsing_spec.rb b/spec/oga/xml/pull_parser/context_parsing_spec.rb
index e4e1a8b..e353b10 100644
--- a/spec/oga/xml/pull_parser/context_parsing_spec.rb
+++ b/spec/oga/xml/pull_parser/context_parsing_spec.rb
@@ -5,7 +5,7 @@ describe Oga::XML::PullParser do
     before do
       @parser = Oga::XML::PullParser.new('<a><b></b></a>')
 
-      @parser.stub(:node).and_return(Oga::XML::Text.new)
+      allow(@parser).to receive(:node).and_return(Oga::XML::Text.new)
     end
 
     it 'does not yield if the node types do not match' do
@@ -21,7 +21,7 @@ describe Oga::XML::PullParser do
     end
 
     it 'yields if the node type and the nesting matches' do
-      @parser.stub(:nesting).and_return(%w{a b})
+      allow(@parser).to receive(:nesting).and_return(%w{a b})
 
       expect { |b| @parser.on(:text, %w{a b}, &b) }.to yield_control
     end
diff --git a/spec/oga/xml/pull_parser/doctype_spec.rb b/spec/oga/xml/pull_parser/doctype_spec.rb
index d986495..85205e2 100644
--- a/spec/oga/xml/pull_parser/doctype_spec.rb
+++ b/spec/oga/xml/pull_parser/doctype_spec.rb
@@ -13,7 +13,7 @@ describe Oga::XML::PullParser do
         amount += 1
       end
 
-      amount.should == 0
+      expect(amount).to eq(0)
     end
   end
 end
diff --git a/spec/oga/xml/pull_parser/element_nesting_spec.rb b/spec/oga/xml/pull_parser/element_nesting_spec.rb
index 873a17b..4a05251 100644
--- a/spec/oga/xml/pull_parser/element_nesting_spec.rb
+++ b/spec/oga/xml/pull_parser/element_nesting_spec.rb
@@ -8,14 +8,14 @@ describe Oga::XML::PullParser do
 
     it 'sets the nesting for the outer element' do
       @parser.parse do |node|
-        @parser.nesting.should == %w{a} if node.name == 'a'
+        expect(@parser.nesting).to eq(%w{a}) if node.name == 'a'
 
-        @parser.nesting.should == %w{a b} if node.name == 'b'
+        expect(@parser.nesting).to eq(%w{a b}) if node.name == 'b'
       end
     end
 
     it 'pops element names after leaving an element' do
-      @parser.nesting.should_receive(:pop).twice
+      expect(@parser.nesting).to receive(:pop).twice
 
       @parser.parse { |node| }
     end
diff --git a/spec/oga/xml/pull_parser/element_spec.rb b/spec/oga/xml/pull_parser/element_spec.rb
index 86541d8..481b594 100644
--- a/spec/oga/xml/pull_parser/element_spec.rb
+++ b/spec/oga/xml/pull_parser/element_spec.rb
@@ -13,7 +13,7 @@ describe Oga::XML::PullParser do
         name = node.name if node.is_a?(Oga::XML::Element)
       end
 
-      name.should == 'person'
+      expect(name).to eq('person')
     end
 
     it 'parses the text of an element' do
@@ -23,7 +23,7 @@ describe Oga::XML::PullParser do
         text = node.text if node.is_a?(Oga::XML::Text)
       end
 
-      text.should == 'Alice'
+      expect(text).to eq('Alice')
     end
   end
 end
diff --git a/spec/oga/xml/pull_parser/general_spec.rb b/spec/oga/xml/pull_parser/general_spec.rb
index c8ccee7..130035e 100644
--- a/spec/oga/xml/pull_parser/general_spec.rb
+++ b/spec/oga/xml/pull_parser/general_spec.rb
@@ -8,7 +8,7 @@ describe Oga::XML::PullParser do
 
     it 'tracks the current node' do
       @parser.parse do
-        @parser.node.is_a?(Oga::XML::Element).should == true
+        expect(@parser.node.is_a?(Oga::XML::Element)).to eq(true)
       end
     end
   end
diff --git a/spec/oga/xml/pull_parser/processing_instruction_spec.rb b/spec/oga/xml/pull_parser/processing_instruction_spec.rb
index 0b23d83..1c7d9ad 100644
--- a/spec/oga/xml/pull_parser/processing_instruction_spec.rb
+++ b/spec/oga/xml/pull_parser/processing_instruction_spec.rb
@@ -11,15 +11,15 @@ describe Oga::XML::PullParser do
     end
 
     it 'returns a ProcessingInstruction node' do
-      @node.is_a?(Oga::XML::ProcessingInstruction).should == true
+      expect(@node.is_a?(Oga::XML::ProcessingInstruction)).to eq(true)
     end
 
     it 'sets the name of the node' do
-      @node.name.should == 'foo'
+      expect(@node.name).to eq('foo')
     end
 
     it 'sets the text of the node' do
-      @node.text.should == ' bar '
+      expect(@node.text).to eq(' bar ')
     end
   end
 end
diff --git a/spec/oga/xml/querying_spec.rb b/spec/oga/xml/querying_spec.rb
index 437ec72..e0400e1 100644
--- a/spec/oga/xml/querying_spec.rb
+++ b/spec/oga/xml/querying_spec.rb
@@ -7,41 +7,41 @@ describe Oga::XML::Querying do
 
   describe '#xpath' do
     it 'queries a document' do
-      @document.xpath('a')[0].name.should == 'a'
+      expect(@document.xpath('a')[0].name).to eq('a')
     end
 
     it 'queries an element' do
-      @document.children[0].xpath('text()')[0].text.should == 'foo'
+      expect(@document.children[0].xpath('text()')[0].text).to eq('foo')
     end
 
     it 'evaluates an expression using a variable' do
-      @document.xpath('$number', 'number' => 10).should == 10
+      expect(@document.xpath('$number', 'number' => 10)).to eq(10)
     end
   end
 
   describe '#at_xpath' do
     it 'queries a document' do
-      @document.at_xpath('a').name.should == 'a'
+      expect(@document.at_xpath('a').name).to eq('a')
     end
 
     it 'queries an element' do
-      @document.children[0].at_xpath('text()').text.should == 'foo'
+      expect(@document.children[0].at_xpath('text()').text).to eq('foo')
     end
 
     it 'evaluates an expression using a variable' do
-      @document.at_xpath('$number', 'number' => 10).should == 10
+      expect(@document.at_xpath('$number', 'number' => 10)).to eq(10)
     end
   end
 
   describe '#css' do
     it 'queries a document' do
-      @document.css('a').should == @document.children
+      expect(@document.css('a')).to eq(@document.children)
     end
   end
 
   describe '#at_css' do
     it 'queries a document' do
-      @document.at_css('a').should == @document.children[0]
+      expect(@document.at_css('a')).to eq(@document.children[0])
     end
   end
 end
diff --git a/spec/oga/xml/sax_parser_spec.rb b/spec/oga/xml/sax_parser_spec.rb
index 57deb46..dd90cf7 100644
--- a/spec/oga/xml/sax_parser_spec.rb
+++ b/spec/oga/xml/sax_parser_spec.rb
@@ -21,7 +21,7 @@ describe Oga::XML::SaxParser do
     it 'ignores return values of callback methods' do
       parser = described_class.new(@handler.new, 'foo')
 
-      parser.parse.should be_nil
+      expect(parser.parse).to be_nil
     end
 
     it 'uses custom callback methods if defined' do
@@ -30,7 +30,7 @@ describe Oga::XML::SaxParser do
 
       parser.parse
 
-      handler.name.should == 'foo'
+      expect(handler.name).to eq('foo')
     end
 
     it 'always passes element names to after_element' do
@@ -39,15 +39,15 @@ describe Oga::XML::SaxParser do
 
       parser.parse
 
-      handler.after_name.should      == 'foo'
-      handler.after_namespace.should == 'namespace'
+      expect(handler.after_name).to      eq('foo')
+      expect(handler.after_namespace).to eq('namespace')
     end
 
     it 'ignores callbacks that are not defined in the handler' do
       parser = described_class.new(@handler.new, '<!--foo-->')
 
       # This would raise if undefined callbacks were _not_ ignored.
-      lambda { parser.parse }.should_not raise_error
+      expect { parser.parse }.not_to raise_error
     end
 
     it 'passes the attributes to the on_element callback' do
@@ -56,7 +56,7 @@ describe Oga::XML::SaxParser do
 
       parser.parse
 
-      handler.attrs.should == {'b' => '10', 'x:c' => '20'}
+      expect(handler.attrs).to eq({'b' => '10', 'x:c' => '20'})
     end
 
     describe 'when parsing XML documents' do
@@ -73,7 +73,7 @@ describe Oga::XML::SaxParser do
 
         parser.parse
 
-        handler.text.should == '<'
+        expect(handler.text).to eq('<')
       end
     end
 
@@ -91,7 +91,7 @@ describe Oga::XML::SaxParser do
 
         parser.parse
 
-        handler.text.should == Oga::HTML::Entities::DECODE_MAPPING['&nbsp;']
+        expect(handler.text).to eq(Oga::HTML::Entities::DECODE_MAPPING['&nbsp;'])
       end
     end
   end
@@ -111,14 +111,14 @@ describe Oga::XML::SaxParser do
       parser = described_class.new(@handler_without, '<a x:foo="bar" />')
       hash   = parser.on_attribute('foo', 'x', 'bar')
 
-      hash.should == {'x:foo' => 'bar'}
+      expect(hash).to eq({'x:foo' => 'bar'})
     end
 
     it 'returns the return value of a custom callback' do
       parser = described_class.new(@handler_with, nil)
       hash   = parser.on_attribute('foo', 'x', 'bar')
 
-      hash.should == {'FOO' => 'bar'}
+      expect(hash).to eq({'FOO' => 'bar'})
     end
 
     describe 'when parsing an XML document' do
@@ -126,7 +126,7 @@ describe Oga::XML::SaxParser do
         parser = described_class.new(@handler_without, '<a a="&lt;" />')
         hash   = parser.on_attribute('a', nil, '&lt;')
 
-        hash.should == {'a' => '<'}
+        expect(hash).to eq({'a' => '<'})
       end
     end
 
@@ -140,7 +140,7 @@ describe Oga::XML::SaxParser do
 
         hash = parser.on_attribute('a', nil, '&nbsp;')
 
-        hash.should == {'a' => Oga::HTML::Entities::DECODE_MAPPING['&nbsp;']}
+        expect(hash).to eq({'a' => Oga::HTML::Entities::DECODE_MAPPING['&nbsp;']})
       end
     end
   end
@@ -160,14 +160,14 @@ describe Oga::XML::SaxParser do
       parser = described_class.new(@handler_without, nil)
       hash   = parser.on_attributes([{'a' => 'b'}, {'c' => 'd'}])
 
-      hash.should == {'a' => 'b', 'c' => 'd'}
+      expect(hash).to eq({'a' => 'b', 'c' => 'd'})
     end
 
     it 'returns the return value of a custom callback' do
       parser = described_class.new(@handler_with, nil)
       retval = parser.on_attributes([{'a' => 'b'}, {'c' => 'd'}])
 
-      retval.should == %w{Alice Bob}
+      expect(retval).to eq(%w{Alice Bob})
     end
   end
 
@@ -185,7 +185,7 @@ describe Oga::XML::SaxParser do
 
       parser.on_text('foo')
 
-      handler.text.should == 'FOO'
+      expect(handler.text).to eq('FOO')
     end
 
     describe 'when parsing an XML document' do
@@ -204,7 +204,7 @@ describe Oga::XML::SaxParser do
       it 'decodes XML entities' do
         @parser.on_text('&lt;')
 
-        @handler.text.should == '<'
+        expect(@handler.text).to eq('<')
       end
     end
 
@@ -224,24 +224,25 @@ describe Oga::XML::SaxParser do
       it 'decodes HTML entities' do
         @parser.on_text('&nbsp;')
 
-        @handler.text.should ==
+        expect(@handler.text).to eq(
           Oga::HTML::Entities::DECODE_MAPPING['&nbsp;']
+        )
       end
 
       it 'does not decode HTML entities of script tags' do
-        @parser.stub(:inside_literal_html?).and_return(true)
+        allow(@parser).to receive(:inside_literal_html?).and_return(true)
 
         @parser.on_text('&nbsp;')
 
-        @handler.text.should == '&nbsp;'
+        expect(@handler.text).to eq('&nbsp;')
       end
 
       it 'does not decode HTML entities of style tags' do
-        @parser.stub(:inside_literal_html?).and_return(true)
+        allow(@parser).to receive(:inside_literal_html?).and_return(true)
 
         @parser.on_text('&nbsp;')
 
-        @handler.text.should == '&nbsp;'
+        expect(@handler.text).to eq('&nbsp;')
       end
     end
   end
diff --git a/spec/oga/xml/text_spec.rb b/spec/oga/xml/text_spec.rb
index 95998af..f106050 100644
--- a/spec/oga/xml/text_spec.rb
+++ b/spec/oga/xml/text_spec.rb
@@ -3,48 +3,48 @@ require 'spec_helper'
 describe Oga::XML::Text do
   describe 'setting attributes' do
     it 'sets the text via the constructor' do
-      described_class.new(:text => 'foo').text.should == 'foo'
+      expect(described_class.new(:text => 'foo').text).to eq('foo')
     end
 
     it 'sets the text via a setter' do
       instance = described_class.new
       instance.text = 'foo'
 
-      instance.text.should == 'foo'
+      expect(instance.text).to eq('foo')
     end
   end
 
   describe '#text' do
     describe 'with XML entities' do
       it 'converts &amp; to &' do
-        described_class.new(:text => '&amp;').text.should == '&'
+        expect(described_class.new(:text => '&amp;').text).to eq('&')
       end
 
       it 'converts &lt; to <' do
-        described_class.new(:text => '&lt;').text.should == '<'
+        expect(described_class.new(:text => '&lt;').text).to eq('<')
       end
 
       it 'converts &gt; to >' do
-        described_class.new(:text => '&gt;').text.should == '>'
+        expect(described_class.new(:text => '&gt;').text).to eq('>')
       end
 
       it 'caches the converted text' do
         node = described_class.new(:text => '&amp;')
 
-        Oga::XML::Entities.should_receive(:decode).once.and_call_original
+        expect(Oga::XML::Entities).to receive(:decode).once.and_call_original
 
-        node.text.should == '&'
-        node.text.should == '&'
+        expect(node.text).to eq('&')
+        expect(node.text).to eq('&')
       end
 
       it 'converts new text set using text=' do
         node = described_class.new(:text => '&amp;')
 
-        node.text.should == '&'
+        expect(node.text).to eq('&')
 
         node.text = '&lt;'
 
-        node.text.should == '<'
+        expect(node.text).to eq('<')
       end
     end
 
@@ -58,7 +58,7 @@ describe Oga::XML::Text do
 
         @document.children << node
 
-        node.text.should == '&'
+        expect(node.text).to eq('&')
       end
 
       it 'converts &lt; to <' do
@@ -66,7 +66,7 @@ describe Oga::XML::Text do
 
         @document.children << node
 
-        node.text.should == '<'
+        expect(node.text).to eq('<')
       end
 
       it 'converts &gt; to >' do
@@ -74,7 +74,7 @@ describe Oga::XML::Text do
 
         @document.children << node
 
-        node.text.should == '>'
+        expect(node.text).to eq('>')
       end
 
       it 'converts &nbsp; into a space' do
@@ -82,7 +82,7 @@ describe Oga::XML::Text do
 
         @document.children << node
 
-        node.text.should == [160].pack('U')
+        expect(node.text).to eq([160].pack('U'))
       end
     end
 
@@ -98,7 +98,7 @@ describe Oga::XML::Text do
       it 'does not decode any entities' do
         @element.inner_text = '&foo;'
 
-        @element.inner_text.should == '&foo;'
+        expect(@element.inner_text).to eq('&foo;')
       end
     end
 
@@ -114,7 +114,7 @@ describe Oga::XML::Text do
       it 'does not decode any entities' do
         @element.inner_text = '&foo;'
 
-        @element.inner_text.should == '&foo;'
+        expect(@element.inner_text).to eq('&foo;')
       end
     end
   end
@@ -123,13 +123,13 @@ describe Oga::XML::Text do
     it 'generates the corresponding XML' do
       node = described_class.new(:text => 'foo')
 
-      node.to_xml.should == 'foo'
+      expect(node.to_xml).to eq('foo')
     end
 
     it 'encodes special characters as XML entities' do
       node = described_class.new(:text => '&<>')
 
-      node.to_xml.should == '&amp;&lt;&gt;'
+      expect(node.to_xml).to eq('&amp;&lt;&gt;')
     end
 
     describe 'inside an XML document' do
@@ -141,7 +141,7 @@ describe Oga::XML::Text do
         script.children   << text
         document.children << script
 
-        text.to_xml.should == 'x &gt; y'
+        expect(text.to_xml).to eq('x &gt; y')
       end
     end
 
@@ -154,7 +154,7 @@ describe Oga::XML::Text do
         script.children   << text
         document.children << script
 
-        text.to_xml.should == 'x > y'
+        expect(text.to_xml).to eq('x > y')
       end
     end
 
@@ -167,7 +167,7 @@ describe Oga::XML::Text do
         style.children    << text
         document.children << style
 
-        text.to_xml.should == 'x > y'
+        expect(text.to_xml).to eq('x > y')
       end
     end
   end
@@ -178,7 +178,7 @@ describe Oga::XML::Text do
     end
 
     it 'returns the inspect value' do
-      @instance.inspect.should == 'Text("foo")'
+      expect(@instance.inspect).to eq('Text("foo")')
     end
   end
 end
diff --git a/spec/oga/xml/traversal_spec.rb b/spec/oga/xml/traversal_spec.rb
index 0ee0762..bfadb7e 100644
--- a/spec/oga/xml/traversal_spec.rb
+++ b/spec/oga/xml/traversal_spec.rb
@@ -22,7 +22,7 @@ describe Oga::XML::Traversal do
         names << (node.is_a?(Oga::XML::Element) ? node.name : node.text)
       end
 
-      names.should == %w{books book1 title1 Foo book2 title2 Bar}
+      expect(names).to eq(%w{books book1 title1 Foo book2 title2 Bar})
     end
 
     it 'skips child nodes when skip_children is thrown' do
@@ -38,7 +38,7 @@ describe Oga::XML::Traversal do
         end
       end
 
-      names.should == %w{books book2 title2}
+      expect(names).to eq(%w{books book2 title2})
     end
   end
 end
diff --git a/spec/oga/xml/xml_declaration_spec.rb b/spec/oga/xml/xml_declaration_spec.rb
index 094f287..2b7e102 100644
--- a/spec/oga/xml/xml_declaration_spec.rb
+++ b/spec/oga/xml/xml_declaration_spec.rb
@@ -3,14 +3,14 @@ require 'spec_helper'
 describe Oga::XML::XmlDeclaration do
   describe 'setting attributes' do
     it 'sets the version via the constructor' do
-      described_class.new(:version => '1.0').version.should == '1.0'
+      expect(described_class.new(:version => '1.0').version).to eq('1.0')
     end
 
     it 'sets the version via a setter' do
       instance = described_class.new
       instance.version = '1.0'
 
-      instance.version.should == '1.0'
+      expect(instance.version).to eq('1.0')
     end
   end
 
@@ -20,17 +20,17 @@ describe Oga::XML::XmlDeclaration do
     end
 
     it 'sets the default version' do
-      @instance.version.should == '1.0'
+      expect(@instance.version).to eq('1.0')
     end
 
     it 'sets the default encoding' do
-      @instance.encoding.should == 'UTF-8'
+      expect(@instance.encoding).to eq('UTF-8')
     end
   end
 
   describe '#name' do
     it 'returns the name of the node' do
-      described_class.new.name.should == 'xml'
+      expect(described_class.new.name).to eq('xml')
     end
   end
 
@@ -44,8 +44,8 @@ describe Oga::XML::XmlDeclaration do
     end
 
     it 'generates the corresponding XML' do
-      @instance.to_xml
-        .should == '<?xml version="1.0" encoding="UTF-8" standalone="yes" ?>'
+      expect(@instance.to_xml)
+        .to eq('<?xml version="1.0" encoding="UTF-8" standalone="yes" ?>')
     end
   end
 
@@ -55,7 +55,7 @@ describe Oga::XML::XmlDeclaration do
     end
 
     it 'pretty-prints the node' do
-      @instance.inspect.should == <<-EOF.strip
+      expect(@instance.inspect).to eq <<-EOF.strip
 XmlDeclaration(version: "1.0" encoding: "UTF-8")
       EOF
     end
diff --git a/spec/oga/xpath/compiler/axes/ancestor_or_self_spec.rb b/spec/oga/xpath/compiler/axes/ancestor_or_self_spec.rb
index 9caa061..a80c819 100644
--- a/spec/oga/xpath/compiler/axes/ancestor_or_self_spec.rb
+++ b/spec/oga/xpath/compiler/axes/ancestor_or_self_spec.rb
@@ -12,7 +12,7 @@ describe Oga::XPath::Compiler do
   describe 'relative to a document' do
     describe 'ancestor-or-self::a' do
       it 'returns an empty NodeSet' do
-        evaluate_xpath(@document).should == node_set
+        expect(evaluate_xpath(@document)).to eq(node_set)
       end
     end
   end
@@ -20,13 +20,13 @@ describe Oga::XPath::Compiler do
   describe 'relative to an attribute' do
     describe 'ancestor-or-self::a' do
       it 'returns a NodeSet' do
-        evaluate_xpath(@a1.attribute('foo')).should == node_set(@a1)
+        expect(evaluate_xpath(@a1.attribute('foo'))).to eq(node_set(@a1))
       end
     end
 
     describe 'ancestor-or-self::foo' do
       it 'returns an empty NodeSet' do
-        evaluate_xpath(@a1.attribute('foo')).should == node_set
+        expect(evaluate_xpath(@a1.attribute('foo'))).to eq(node_set)
       end
     end
   end
@@ -34,43 +34,43 @@ describe Oga::XPath::Compiler do
   describe 'relative to an element' do
     describe 'ancestor-or-self::a' do
       it 'returns a NodeSet' do
-        evaluate_xpath(@c1).should == node_set(@a1)
+        expect(evaluate_xpath(@c1)).to eq(node_set(@a1))
       end
     end
 
     describe 'ancestor-or-self::b' do
       it 'returns a NodeSet' do
-        evaluate_xpath(@c1).should == node_set(@b1)
+        expect(evaluate_xpath(@c1)).to eq(node_set(@b1))
       end
     end
 
     describe 'ancestor-or-self::c' do
       it 'returns a NodeSet' do
-        evaluate_xpath(@c1).should == node_set(@c1)
+        expect(evaluate_xpath(@c1)).to eq(node_set(@c1))
       end
     end
 
     describe 'ancestor-or-self::*[1]' do
       it 'returns a NodeSet' do
-        evaluate_xpath(@c1).should == node_set(@c1)
+        expect(evaluate_xpath(@c1)).to eq(node_set(@c1))
       end
     end
 
     describe 'ancestor-or-self::*' do
       it 'returns a NodeSet' do
-        evaluate_xpath(@c1).should == node_set(@c1, @b1, @a1)
+        expect(evaluate_xpath(@c1)).to eq(node_set(@c1, @b1, @a1))
       end
     end
 
     describe 'ancestor-or-self::foo' do
       it 'returns an empty NodeSet' do
-        evaluate_xpath(@c1).should == node_set
+        expect(evaluate_xpath(@c1)).to eq(node_set)
       end
     end
 
     describe 'ancestor-or-self::*/ancestor-or-self::a' do
       it 'returns a NodeSet' do
-        evaluate_xpath(@c1).should == node_set(@a1)
+        expect(evaluate_xpath(@c1)).to eq(node_set(@a1))
       end
     end
   end
diff --git a/spec/oga/xpath/compiler/axes/ancestor_spec.rb b/spec/oga/xpath/compiler/axes/ancestor_spec.rb
index cd7d50b..d6d3781 100644
--- a/spec/oga/xpath/compiler/axes/ancestor_spec.rb
+++ b/spec/oga/xpath/compiler/axes/ancestor_spec.rb
@@ -12,7 +12,7 @@ describe Oga::XPath::Compiler do
   describe 'relative to a document' do
     describe 'ancestor::a' do
       it 'returns an empty NodeSet' do
-        evaluate_xpath(@document).should == node_set
+        expect(evaluate_xpath(@document)).to eq(node_set)
       end
     end
   end
@@ -20,7 +20,7 @@ describe Oga::XPath::Compiler do
   describe 'relative to an attribute' do
     describe 'ancestor-or-self::a' do
       it 'returns a NodeSet' do
-        evaluate_xpath(@a1.attribute('foo')).should == node_set(@a1)
+        expect(evaluate_xpath(@a1.attribute('foo'))).to eq(node_set(@a1))
       end
     end
   end
@@ -28,37 +28,37 @@ describe Oga::XPath::Compiler do
   describe 'relative to an element' do
     describe 'ancestor::a' do
       it 'returns a NodeSet' do
-        evaluate_xpath(@c1).should == node_set(@a1)
+        expect(evaluate_xpath(@c1)).to eq(node_set(@a1))
       end
     end
 
     describe 'ancestor::b' do
       it 'returns a NodeSet' do
-        evaluate_xpath(@c1).should == node_set(@b1)
+        expect(evaluate_xpath(@c1)).to eq(node_set(@b1))
       end
     end
 
     describe 'ancestor::*[1]' do
       it 'returns a NodeSet' do
-        evaluate_xpath(@c1).should == node_set(@b1)
+        expect(evaluate_xpath(@c1)).to eq(node_set(@b1))
       end
     end
 
     describe 'ancestor::*' do
       it 'returns a NodeSet' do
-        evaluate_xpath(@c1).should == node_set(@b1, @a1)
+        expect(evaluate_xpath(@c1)).to eq(node_set(@b1, @a1))
       end
     end
 
     describe 'ancestor::c' do
       it 'returns an empty NodeSet' do
-        evaluate_xpath(@c1).should == node_set
+        expect(evaluate_xpath(@c1)).to eq(node_set)
       end
     end
 
     describe 'ancestor::*/ancestor::a' do
       it 'returns a NodeSet' do
-        evaluate_xpath(@c1).should == node_set(@a1)
+        expect(evaluate_xpath(@c1)).to eq(node_set(@a1))
       end
     end
   end
diff --git a/spec/oga/xpath/compiler/axes/attribute_spec.rb b/spec/oga/xpath/compiler/axes/attribute_spec.rb
index c669951..1b3affb 100644
--- a/spec/oga/xpath/compiler/axes/attribute_spec.rb
+++ b/spec/oga/xpath/compiler/axes/attribute_spec.rb
@@ -11,7 +11,7 @@ describe Oga::XPath::Compiler do
   describe 'relative to a document' do
     describe 'attribute::foo' do
       it 'returns an empty NodeSet' do
-        evaluate_xpath(@document).should == node_set
+        expect(evaluate_xpath(@document)).to eq(node_set)
       end
     end
   end
@@ -19,25 +19,25 @@ describe Oga::XPath::Compiler do
   describe 'relative to an element' do
     describe 'attribute::foo' do
       it 'returns a NodeSet' do
-        evaluate_xpath(@a1).should == node_set(@attr)
+        expect(evaluate_xpath(@a1)).to eq(node_set(@attr))
       end
     end
 
     describe '@foo' do
       it 'returns a NodeSet' do
-        evaluate_xpath(@a1).should == node_set(@attr)
+        expect(evaluate_xpath(@a1)).to eq(node_set(@attr))
       end
     end
 
     describe 'attribute::bar' do
       it 'returns an empty NodeSet' do
-        evaluate_xpath(@a1).should == node_set
+        expect(evaluate_xpath(@a1)).to eq(node_set)
       end
     end
 
     describe 'attribute::foo/bar' do
       it 'returns an empty NodeSet' do
-        evaluate_xpath(@a1).should == node_set
+        expect(evaluate_xpath(@a1)).to eq(node_set)
       end
     end
   end
diff --git a/spec/oga/xpath/compiler/axes/child_spec.rb b/spec/oga/xpath/compiler/axes/child_spec.rb
index 4173178..4d96ef2 100644
--- a/spec/oga/xpath/compiler/axes/child_spec.rb
+++ b/spec/oga/xpath/compiler/axes/child_spec.rb
@@ -11,13 +11,13 @@ describe Oga::XPath::Compiler do
   describe 'relative to a document' do
     describe 'child::a' do
       it 'returns a NodeSet' do
-        evaluate_xpath(@document).should == node_set(@a1)
+        expect(evaluate_xpath(@document)).to eq(node_set(@a1))
       end
     end
 
     describe 'child::a/child::b' do
       it 'returns a NodeSet' do
-        evaluate_xpath(@document).should == node_set(@b1)
+        expect(evaluate_xpath(@document)).to eq(node_set(@b1))
       end
     end
   end
@@ -25,19 +25,19 @@ describe Oga::XPath::Compiler do
   describe 'relative to an element' do
     describe 'child::a' do
       it 'returns an empty NodeSet' do
-        evaluate_xpath(@a1).should == node_set
+        expect(evaluate_xpath(@a1)).to eq(node_set)
       end
     end
 
     describe 'child::b' do
       it 'returns a NodeSet' do
-        evaluate_xpath(@a1).should == node_set(@b1)
+        expect(evaluate_xpath(@a1)).to eq(node_set(@b1))
       end
     end
 
     describe 'child::x' do
       it 'returns an empty NodeSet' do
-        evaluate_xpath(@a1).should == node_set
+        expect(evaluate_xpath(@a1)).to eq(node_set)
       end
     end
   end
diff --git a/spec/oga/xpath/compiler/axes/descendant_or_self_spec.rb b/spec/oga/xpath/compiler/axes/descendant_or_self_spec.rb
index a591eb0..dfd6f8c 100644
--- a/spec/oga/xpath/compiler/axes/descendant_or_self_spec.rb
+++ b/spec/oga/xpath/compiler/axes/descendant_or_self_spec.rb
@@ -13,79 +13,79 @@ describe Oga::XPath::Compiler do
   describe 'relative to a document' do
     describe 'descendant-or-self::b' do
       it 'returns a NodeSet' do
-        evaluate_xpath(@document).should == node_set(@b1, @b2)
+        expect(evaluate_xpath(@document)).to eq(node_set(@b1, @b2))
       end
     end
 
     describe 'descendant-or-self::c' do
       it 'returns a NodeSet' do
-        evaluate_xpath(@document).should == node_set(@c1)
+        expect(evaluate_xpath(@document)).to eq(node_set(@c1))
       end
     end
 
     describe 'descendant-or-self::a/descendant-or-self::*' do
       it 'returns a NodeSet' do
-        evaluate_xpath(@document).should == node_set(@a1, @b1, @b2, @c1)
+        expect(evaluate_xpath(@document)).to eq(node_set(@a1, @b1, @b2, @c1))
       end
     end
 
     describe 'descendant-or-self::c[@class="x"]' do
       it 'returns a NodeSet' do
-        evaluate_xpath(@document).should == node_set(@c1)
+        expect(evaluate_xpath(@document)).to eq(node_set(@c1))
       end
     end
 
     describe 'a/descendant-or-self::b' do
       it 'returns a NodeSet' do
-        evaluate_xpath(@document).should == node_set(@b1, @b2)
+        expect(evaluate_xpath(@document)).to eq(node_set(@b1, @b2))
       end
     end
 
     describe 'descendant-or-self::a' do
       it 'returns a NodeSet' do
-        evaluate_xpath(@document).should == node_set(@a1)
+        expect(evaluate_xpath(@document)).to eq(node_set(@a1))
       end
     end
 
     describe 'a/b/b/c/descendant-or-self::c' do
       it 'returns a NodeSet' do
-        evaluate_xpath(@document).should == node_set(@c1)
+        expect(evaluate_xpath(@document)).to eq(node_set(@c1))
       end
     end
 
     describe 'descendant-or-self::b[1]' do
       it 'returns a NodeSet' do
-        evaluate_xpath(@document).should == node_set(@b1)
+        expect(evaluate_xpath(@document)).to eq(node_set(@b1))
       end
     end
 
     describe 'descendant-or-self::foobar' do
       it 'returns an empty NodeSet' do
-        evaluate_xpath(@document).should == node_set
+        expect(evaluate_xpath(@document)).to eq(node_set)
       end
     end
 
     describe '//b' do
       it 'returns a NodeSet' do
-        evaluate_xpath(@document).should == node_set(@b1, @b2)
+        expect(evaluate_xpath(@document)).to eq(node_set(@b1, @b2))
       end
     end
 
     describe '//a//*' do
       it 'returns a NodeSet' do
-        evaluate_xpath(@document).should == node_set(@b1, @b2, @c1)
+        expect(evaluate_xpath(@document)).to eq(node_set(@b1, @b2, @c1))
       end
     end
 
     describe '//a/b' do
       it 'returns a NodeSet' do
-        evaluate_xpath(@document).should == node_set(@b1)
+        expect(evaluate_xpath(@document)).to eq(node_set(@b1))
       end
     end
 
     describe 'a/@foo/descendant-or-self::*' do
       it 'returns an empty NodeSet' do
-        evaluate_xpath(@document).should == node_set
+        expect(evaluate_xpath(@document)).to eq(node_set)
       end
     end
   end
@@ -93,19 +93,19 @@ describe Oga::XPath::Compiler do
   describe 'relative to an element' do
     describe 'descendant-or-self::b' do
       it 'returns a NodeSet' do
-        evaluate_xpath(@b1).should == node_set(@b1, @b2)
+        expect(evaluate_xpath(@b1)).to eq(node_set(@b1, @b2))
       end
     end
 
     describe 'descendant-or-self::c' do
       it 'returns a NodeSet' do
-        evaluate_xpath(@c1).should == node_set(@c1)
+        expect(evaluate_xpath(@c1)).to eq(node_set(@c1))
       end
     end
 
     describe '//b' do
       it 'returns a NodeSet' do
-        evaluate_xpath(@c1).should == node_set(@b1, @b2)
+        expect(evaluate_xpath(@c1)).to eq(node_set(@b1, @b2))
       end
     end
   end
diff --git a/spec/oga/xpath/compiler/axes/descendant_spec.rb b/spec/oga/xpath/compiler/axes/descendant_spec.rb
index 3d34da2..54fa9be 100644
--- a/spec/oga/xpath/compiler/axes/descendant_spec.rb
+++ b/spec/oga/xpath/compiler/axes/descendant_spec.rb
@@ -13,31 +13,31 @@ describe Oga::XPath::Compiler do
   describe 'relative to a document' do
     describe 'descendant::a' do
       it 'returns a NodeSet' do
-        evaluate_xpath(@document).should == node_set(@a1, @a2)
+        expect(evaluate_xpath(@document)).to eq(node_set(@a1, @a2))
       end
     end
 
     describe 'descendant::c' do
       it 'returns a NodeSet' do
-        evaluate_xpath(@document).should == node_set(@c1)
+        expect(evaluate_xpath(@document)).to eq(node_set(@c1))
       end
     end
 
     describe 'a/descendant::a' do
       it 'returns a NodeSet' do
-        evaluate_xpath(@document).should == node_set(@a2)
+        expect(evaluate_xpath(@document)).to eq(node_set(@a2))
       end
     end
 
     describe 'descendant::a[1]' do
       it 'returns a NodeSet' do
-        evaluate_xpath(@document).should == node_set(@a1)
+        expect(evaluate_xpath(@document)).to eq(node_set(@a1))
       end
     end
 
     describe 'a/b/c/descendant::c' do
       it 'returns an empty NodeSet' do
-        evaluate_xpath(@document).should == node_set
+        expect(evaluate_xpath(@document)).to eq(node_set)
       end
     end
   end
@@ -45,7 +45,7 @@ describe Oga::XPath::Compiler do
   describe 'relative to an element' do
     describe 'descendant::b' do
       it 'returns a NodeSet' do
-        evaluate_xpath(@a1).should == node_set(@b1)
+        expect(evaluate_xpath(@a1)).to eq(node_set(@b1))
       end
     end
   end
@@ -53,7 +53,7 @@ describe Oga::XPath::Compiler do
   describe 'relative to an attribute' do
     describe 'descendant::b' do
       it 'returns an empty NodeSet' do
-        evaluate_xpath(@a1.attribute('foo')).should == node_set
+        expect(evaluate_xpath(@a1.attribute('foo'))).to eq(node_set)
       end
     end
   end
diff --git a/spec/oga/xpath/compiler/axes/following_sibling_spec.rb b/spec/oga/xpath/compiler/axes/following_sibling_spec.rb
index 671e9a1..035a242 100644
--- a/spec/oga/xpath/compiler/axes/following_sibling_spec.rb
+++ b/spec/oga/xpath/compiler/axes/following_sibling_spec.rb
@@ -26,19 +26,19 @@ describe Oga::XPath::Compiler do
       # This should return an empty set since the document doesn't have any
       # following nodes.
       it 'returns an empty NodeSet' do
-        evaluate_xpath(@document).should == node_set
+        expect(evaluate_xpath(@document)).to eq(node_set)
       end
     end
 
     describe 'root/foo/following-sibling::baz' do
       it 'returns a NodeSet' do
-        evaluate_xpath(@document).should == node_set(@baz3)
+        expect(evaluate_xpath(@document)).to eq(node_set(@baz3))
       end
     end
 
     describe 'root/foo/bar/following-sibling::baz' do
       it 'returns a NodeSet' do
-        evaluate_xpath(@document).should == node_set(@baz1)
+        expect(evaluate_xpath(@document)).to eq(node_set(@baz1))
       end
     end
   end
@@ -46,7 +46,7 @@ describe Oga::XPath::Compiler do
   describe 'relative to an element' do
     describe 'following-sibling::baz' do
       it 'returns a NodeSet' do
-        evaluate_xpath(@bar1).should == node_set(@baz1)
+        expect(evaluate_xpath(@bar1)).to eq(node_set(@baz1))
       end
     end
   end
@@ -56,7 +56,7 @@ describe Oga::XPath::Compiler do
       it 'returns an empty NodeSet' do
         root = @document.children[0]
 
-        evaluate_xpath(root.attribute('foo')).should == node_set
+        expect(evaluate_xpath(root.attribute('foo'))).to eq(node_set)
       end
     end
   end
diff --git a/spec/oga/xpath/compiler/axes/following_spec.rb b/spec/oga/xpath/compiler/axes/following_spec.rb
index 68b6c7f..f3d23c9 100644
--- a/spec/oga/xpath/compiler/axes/following_spec.rb
+++ b/spec/oga/xpath/compiler/axes/following_spec.rb
@@ -26,19 +26,19 @@ describe Oga::XPath::Compiler do
     # following nodes.
     describe 'following::foo' do
       it 'returns an empty NodeSet' do
-        evaluate_xpath(@document).should == node_set
+        expect(evaluate_xpath(@document)).to eq(node_set)
       end
     end
 
     describe 'root/foo/following::baz' do
       it 'returns a NodeSet' do
-        evaluate_xpath(@document).should == node_set(@baz3)
+        expect(evaluate_xpath(@document)).to eq(node_set(@baz3))
       end
     end
 
     describe 'root/foo/bar/following::baz' do
       it 'returns a NodeSet' do
-        evaluate_xpath(@document).should == node_set(@baz1, @baz2, @baz3)
+        expect(evaluate_xpath(@document)).to eq(node_set(@baz1, @baz2, @baz3))
       end
     end
   end
@@ -46,7 +46,7 @@ describe Oga::XPath::Compiler do
   describe 'relative to an element' do
     describe 'following::baz' do
       it 'returns a NodeSet' do
-        evaluate_xpath(@bar1).should == node_set(@baz1, @baz2, @baz3)
+        expect(evaluate_xpath(@bar1)).to eq(node_set(@baz1, @baz2, @baz3))
       end
     end
   end
@@ -56,7 +56,7 @@ describe Oga::XPath::Compiler do
       it 'returns an empty NodeSet' do
         root = @document.children[0]
 
-        evaluate_xpath(root.attribute('foo')).should == node_set
+        expect(evaluate_xpath(root.attribute('foo'))).to eq(node_set)
       end
     end
   end
diff --git a/spec/oga/xpath/compiler/axes/namespace_spec.rb b/spec/oga/xpath/compiler/axes/namespace_spec.rb
index d2e5cfb..cedb8c3 100644
--- a/spec/oga/xpath/compiler/axes/namespace_spec.rb
+++ b/spec/oga/xpath/compiler/axes/namespace_spec.rb
@@ -11,25 +11,25 @@ describe Oga::XPath::Compiler do
   describe 'relative to a document' do
     describe 'namespace::*' do
       it 'returns an empty NodeSet' do
-        evaluate_xpath(@document).should == node_set
+        expect(evaluate_xpath(@document)).to eq(node_set)
       end
     end
 
     describe 'root/namespace::x' do
       it 'returns a NodeSet' do
-        evaluate_xpath(@document).should == node_set(@ns_x)
+        expect(evaluate_xpath(@document)).to eq(node_set(@ns_x))
       end
     end
 
     describe 'root/foo/namespace::*' do
       it 'returns a NodeSet' do
-        evaluate_xpath(@document).should == node_set(@ns_y, @ns_x)
+        expect(evaluate_xpath(@document)).to eq(node_set(@ns_y, @ns_x))
       end
     end
 
     describe 'root/namespace::*' do
       it 'returns a NodeSet' do
-        evaluate_xpath(@document).should == node_set(@ns_x)
+        expect(evaluate_xpath(@document)).to eq(node_set(@ns_x))
       end
     end
   end
@@ -39,7 +39,7 @@ describe Oga::XPath::Compiler do
       it 'returns a NodeSet' do
         root = @document.children[0]
 
-        evaluate_xpath(root).should == node_set(@ns_x)
+        expect(evaluate_xpath(root)).to eq(node_set(@ns_x))
       end
     end
   end
@@ -49,7 +49,7 @@ describe Oga::XPath::Compiler do
       it 'returns an empty NodeSet' do
         root = @document.children[0]
 
-        evaluate_xpath(root.attribute('foo')).should == node_set
+        expect(evaluate_xpath(root.attribute('foo'))).to eq(node_set)
       end
     end
   end
diff --git a/spec/oga/xpath/compiler/axes/parent_spec.rb b/spec/oga/xpath/compiler/axes/parent_spec.rb
index ff3b0cf..4761bcb 100644
--- a/spec/oga/xpath/compiler/axes/parent_spec.rb
+++ b/spec/oga/xpath/compiler/axes/parent_spec.rb
@@ -11,19 +11,19 @@ describe Oga::XPath::Compiler do
   describe 'relative to a document' do
     describe 'parent::a' do
       it 'returns an empty NodeSet' do
-        evaluate_xpath(@document).should == node_set
+        expect(evaluate_xpath(@document)).to eq(node_set)
       end
     end
 
     describe 'a/b/parent::a' do
       it 'returns a NodeSet' do
-        evaluate_xpath(@document).should == node_set(@a1)
+        expect(evaluate_xpath(@document)).to eq(node_set(@a1))
       end
     end
 
     describe 'a/b/..' do
       it 'returns a NodeSet' do
-        evaluate_xpath(@document).should == node_set(@a1)
+        expect(evaluate_xpath(@document)).to eq(node_set(@a1))
       end
     end
   end
@@ -31,7 +31,7 @@ describe Oga::XPath::Compiler do
   describe 'relative to an element' do
     describe 'parent::a' do
       it 'returns a NodeSet' do
-        evaluate_xpath(@b1).should == node_set(@a1)
+        expect(evaluate_xpath(@b1)).to eq(node_set(@a1))
       end
     end
   end
@@ -39,7 +39,7 @@ describe Oga::XPath::Compiler do
   describe 'relative to the root element' do
     describe 'parent::*' do
       it 'returns an empty NodeSet' do
-        evaluate_xpath(@a1).should == node_set
+        expect(evaluate_xpath(@a1)).to eq(node_set)
       end
     end
   end
@@ -47,7 +47,7 @@ describe Oga::XPath::Compiler do
   describe 'relative to an attribute' do
     describe 'parent::a' do
       it 'returns a NodeSet' do
-        evaluate_xpath(@a1.attribute('foo')).should == node_set(@a1)
+        expect(evaluate_xpath(@a1.attribute('foo'))).to eq(node_set(@a1))
       end
     end
   end
diff --git a/spec/oga/xpath/compiler/axes/preceding_sibling_spec.rb b/spec/oga/xpath/compiler/axes/preceding_sibling_spec.rb
index 3666725..3731388 100644
--- a/spec/oga/xpath/compiler/axes/preceding_sibling_spec.rb
+++ b/spec/oga/xpath/compiler/axes/preceding_sibling_spec.rb
@@ -21,19 +21,19 @@ describe Oga::XPath::Compiler do
   describe 'relative to a document' do
     describe 'preceding-sibling::*' do
       it 'returns an empty NodeSet' do
-        evaluate_xpath(@document).should == node_set
+        expect(evaluate_xpath(@document)).to eq(node_set)
       end
     end
 
     describe 'root/bar/preceding-sibling::foo' do
       it 'returns a NodeSet' do
-        evaluate_xpath(@document).should == node_set(@foo1)
+        expect(evaluate_xpath(@document)).to eq(node_set(@foo1))
       end
     end
 
     describe 'root/bar/baz/preceding-sibling::foo' do
       it 'returns a NodeSet' do
-        evaluate_xpath(@document).should == node_set(@foo2)
+        expect(evaluate_xpath(@document)).to eq(node_set(@foo2))
       end
     end
   end
@@ -41,7 +41,7 @@ describe Oga::XPath::Compiler do
   describe 'relative to an element' do
     describe 'preceding-sibling::foo' do
       it 'returns a NodeSet' do
-        evaluate_xpath(@bar1).should == node_set(@foo1)
+        expect(evaluate_xpath(@bar1)).to eq(node_set(@foo1))
       end
     end
   end
@@ -49,7 +49,7 @@ describe Oga::XPath::Compiler do
   describe 'relative to the root element' do
     describe 'preceding-sibling::*' do
       it 'returns an empty NodeSet' do
-        evaluate_xpath(@document.children[0]).should == node_set
+        expect(evaluate_xpath(@document.children[0])).to eq(node_set)
       end
     end
   end
@@ -59,7 +59,7 @@ describe Oga::XPath::Compiler do
       it 'returns an empty NodeSet' do
         root = @document.children[0]
 
-        evaluate_xpath(root.attribute('foo')).should == node_set
+        expect(evaluate_xpath(root.attribute('foo'))).to eq(node_set)
       end
     end
   end
diff --git a/spec/oga/xpath/compiler/axes/preceding_spec.rb b/spec/oga/xpath/compiler/axes/preceding_spec.rb
index d56298b..421e1bf 100644
--- a/spec/oga/xpath/compiler/axes/preceding_spec.rb
+++ b/spec/oga/xpath/compiler/axes/preceding_spec.rb
@@ -24,19 +24,19 @@ describe Oga::XPath::Compiler do
   describe 'relative to a document' do
     describe 'preceding::*' do
       it 'returns an empty NodeSet' do
-        evaluate_xpath(@document).should == node_set
+        expect(evaluate_xpath(@document)).to eq(node_set)
       end
     end
 
     describe 'root/foo/baz/preceding::bar' do
       it 'returns a NodeSet' do
-        evaluate_xpath(@document).should == node_set(@bar1)
+        expect(evaluate_xpath(@document)).to eq(node_set(@bar1))
       end
     end
 
     describe 'root/baz/preceding::baz' do
       it 'returns a NodeSet' do
-        evaluate_xpath(@document).should == node_set(@baz1, @baz2)
+        expect(evaluate_xpath(@document)).to eq(node_set(@baz1, @baz2))
       end
     end
   end
@@ -44,13 +44,13 @@ describe Oga::XPath::Compiler do
   describe 'relative to an element' do
     describe 'preceding::root' do
       it 'returns a NodeSet' do
-        evaluate_xpath(@foo1).should == @document.children
+        expect(evaluate_xpath(@foo1)).to eq(@document.children)
       end
     end
 
     describe 'preceding::baz' do
       it 'returns a NodeSet' do
-        evaluate_xpath(@baz3).should == node_set(@baz1, @baz2)
+        expect(evaluate_xpath(@baz3)).to eq(node_set(@baz1, @baz2))
       end
     end
   end
@@ -58,7 +58,7 @@ describe Oga::XPath::Compiler do
   describe 'relative to the root element' do
     describe 'preceding::*' do
       it 'returns an empty NodeSet' do
-        evaluate_xpath(@document.children[0]).should == node_set
+        expect(evaluate_xpath(@document.children[0])).to eq(node_set)
       end
     end
   end
@@ -68,7 +68,7 @@ describe Oga::XPath::Compiler do
       it 'returns an empty NodeSet' do
         root = @document.children[0]
 
-        evaluate_xpath(root.attribute('foo')).should == node_set
+        expect(evaluate_xpath(root.attribute('foo'))).to eq(node_set)
       end
     end
   end
diff --git a/spec/oga/xpath/compiler/axes/self_spec.rb b/spec/oga/xpath/compiler/axes/self_spec.rb
index d18ac65..5592cc1 100644
--- a/spec/oga/xpath/compiler/axes/self_spec.rb
+++ b/spec/oga/xpath/compiler/axes/self_spec.rb
@@ -12,43 +12,43 @@ describe Oga::XPath::Compiler do
   describe 'relative to a document' do
     describe 'a/self::a' do
       it 'returns a NodeSet' do
-        evaluate_xpath(@document).should == node_set(@a1)
+        expect(evaluate_xpath(@document)).to eq(node_set(@a1))
       end
     end
 
     describe 'a/self::b' do
       it 'returns an empty NodeSet' do
-        evaluate_xpath(@document).should == node_set
+        expect(evaluate_xpath(@document)).to eq(node_set)
       end
     end
 
     describe 'a/.' do
       it 'returns a NodeSet' do
-        evaluate_xpath(@document).should == node_set(@a1)
+        expect(evaluate_xpath(@document)).to eq(node_set(@a1))
       end
     end
 
     describe 'a/b[. = "foo"]' do
       it 'returns a NodeSet' do
-        evaluate_xpath(@document).should == node_set(@b1)
+        expect(evaluate_xpath(@document)).to eq(node_set(@b1))
       end
     end
 
     describe 'a/b[c/. = "test"]' do
       it 'returns a NodeSet' do
-        evaluate_xpath(@document).should == node_set(@b2)
+        expect(evaluate_xpath(@document)).to eq(node_set(@b2))
       end
     end
 
     describe 'a/b[c[. = "test"]]' do
       it 'returns a NodeSet' do
-        evaluate_xpath(@document).should == node_set(@b2)
+        expect(evaluate_xpath(@document)).to eq(node_set(@b2))
       end
     end
 
     describe 'self::node()' do
       it 'returns a NodeSet' do
-        evaluate_xpath(@document).should == node_set(@document)
+        expect(evaluate_xpath(@document)).to eq(node_set(@document))
       end
     end
   end
@@ -56,7 +56,7 @@ describe Oga::XPath::Compiler do
   describe 'relative to an element' do
     describe 'self::node()' do
       it 'returns a NodeSet' do
-        evaluate_xpath(@a1).should == node_set(@a1)
+        expect(evaluate_xpath(@a1)).to eq(node_set(@a1))
       end
     end
   end
@@ -66,7 +66,7 @@ describe Oga::XPath::Compiler do
       it 'returns a NodeSet' do
         attr = @a1.attribute('foo')
 
-        evaluate_xpath(attr).should == node_set(attr)
+        expect(evaluate_xpath(attr)).to eq(node_set(attr))
       end
     end
   end
diff --git a/spec/oga/xpath/compiler/calls/boolean_spec.rb b/spec/oga/xpath/compiler/calls/boolean_spec.rb
index 5e5d8c2..e964c76 100644
--- a/spec/oga/xpath/compiler/calls/boolean_spec.rb
+++ b/spec/oga/xpath/compiler/calls/boolean_spec.rb
@@ -7,51 +7,51 @@ describe Oga::XPath::Compiler do
     end
 
     it 'returns true for a non empty string literal' do
-      evaluate_xpath(@document, 'boolean("foo")').should == true
+      expect(evaluate_xpath(@document, 'boolean("foo")')).to eq(true)
     end
 
     it 'returns false for an empty string' do
-      evaluate_xpath(@document, 'boolean("")').should == false
+      expect(evaluate_xpath(@document, 'boolean("")')).to eq(false)
     end
 
     it 'returns true for a positive integer' do
-      evaluate_xpath(@document, 'boolean(10)').should == true
+      expect(evaluate_xpath(@document, 'boolean(10)')).to eq(true)
     end
 
     it 'returns true for a boolean true' do
-      evaluate_xpath(@document, 'boolean(true())').should == true
+      expect(evaluate_xpath(@document, 'boolean(true())')).to eq(true)
     end
 
     it 'returns false for a boolean false' do
-      evaluate_xpath(@document, 'boolean(false())').should == false
+      expect(evaluate_xpath(@document, 'boolean(false())')).to eq(false)
     end
 
     it 'returns true for a positive float' do
-      evaluate_xpath(@document, 'boolean(10.5)').should == true
+      expect(evaluate_xpath(@document, 'boolean(10.5)')).to eq(true)
     end
 
     it 'returns true for a negative integer' do
-      evaluate_xpath(@document, 'boolean(-5)').should == true
+      expect(evaluate_xpath(@document, 'boolean(-5)')).to eq(true)
     end
 
     it 'returns true for a negative float' do
-      evaluate_xpath(@document, 'boolean(-5.2)').should == true
+      expect(evaluate_xpath(@document, 'boolean(-5.2)')).to eq(true)
     end
 
     it 'returns false for a zero integer' do
-      evaluate_xpath(@document, 'boolean(0)').should == false
+      expect(evaluate_xpath(@document, 'boolean(0)')).to eq(false)
     end
 
     it 'returns false for a zero float' do
-      evaluate_xpath(@document, 'boolean(0.0)').should == false
+      expect(evaluate_xpath(@document, 'boolean(0.0)')).to eq(false)
     end
 
     it 'returns true for a non empty node set' do
-      evaluate_xpath(@document, 'boolean(root/a)').should == true
+      expect(evaluate_xpath(@document, 'boolean(root/a)')).to eq(true)
     end
 
     it 'returns false for an empty node set' do
-      evaluate_xpath(@document, 'boolean(root/b)').should == false
+      expect(evaluate_xpath(@document, 'boolean(root/b)')).to eq(false)
     end
   end
 end
diff --git a/spec/oga/xpath/compiler/calls/ceiling_spec.rb b/spec/oga/xpath/compiler/calls/ceiling_spec.rb
index 15432f5..fbbd764 100644
--- a/spec/oga/xpath/compiler/calls/ceiling_spec.rb
+++ b/spec/oga/xpath/compiler/calls/ceiling_spec.rb
@@ -7,23 +7,23 @@ describe Oga::XPath::Compiler do
     end
 
     it 'returns the ceiling of a literal number' do
-      evaluate_xpath(@document, 'ceiling(10.123)').should == 11.0
+      expect(evaluate_xpath(@document, 'ceiling(10.123)')).to eq(11.0)
     end
 
     it 'returns the ceiling of a literal string' do
-      evaluate_xpath(@document, 'ceiling("10.123")').should == 11.0
+      expect(evaluate_xpath(@document, 'ceiling("10.123")')).to eq(11.0)
     end
 
     it 'returns the ceiling of a node set' do
-      evaluate_xpath(@document, 'ceiling(root)').should == 11.0
+      expect(evaluate_xpath(@document, 'ceiling(root)')).to eq(11.0)
     end
 
     it 'returns NaN for empty node sets' do
-      evaluate_xpath(@document, 'ceiling(foo)').should be_nan
+      expect(evaluate_xpath(@document, 'ceiling(foo)')).to be_nan
     end
 
     it 'returns NaN for an empty literal string' do
-      evaluate_xpath(@document, 'ceiling("")').should be_nan
+      expect(evaluate_xpath(@document, 'ceiling("")')).to be_nan
     end
   end
 end
diff --git a/spec/oga/xpath/compiler/calls/concat_spec.rb b/spec/oga/xpath/compiler/calls/concat_spec.rb
index 3a1222a..289ddfd 100644
--- a/spec/oga/xpath/compiler/calls/concat_spec.rb
+++ b/spec/oga/xpath/compiler/calls/concat_spec.rb
@@ -7,23 +7,23 @@ describe Oga::XPath::Compiler do
     end
 
     it 'concatenates two strings' do
-      evaluate_xpath(@document, 'concat("foo", "bar")').should == 'foobar'
+      expect(evaluate_xpath(@document, 'concat("foo", "bar")')).to eq('foobar')
     end
 
     it 'concatenates two integers' do
-      evaluate_xpath(@document, 'concat(10, 20)').should == '1020'
+      expect(evaluate_xpath(@document, 'concat(10, 20)')).to eq('1020')
     end
 
     it 'concatenates two floats' do
-      evaluate_xpath(@document, 'concat(10.5, 20.5)').should == '10.520.5'
+      expect(evaluate_xpath(@document, 'concat(10.5, 20.5)')).to eq('10.520.5')
     end
 
     it 'concatenates two node sets' do
-      evaluate_xpath(@document, 'concat(root/a, root/b)').should == 'foobar'
+      expect(evaluate_xpath(@document, 'concat(root/a, root/b)')).to eq('foobar')
     end
 
     it 'concatenates a node set and a string' do
-      evaluate_xpath(@document, 'concat(root/a, "baz")').should == 'foobaz'
+      expect(evaluate_xpath(@document, 'concat(root/a, "baz")')).to eq('foobaz')
     end
   end
 end
diff --git a/spec/oga/xpath/compiler/calls/contains_spec.rb b/spec/oga/xpath/compiler/calls/contains_spec.rb
index 7c94242..a959800 100644
--- a/spec/oga/xpath/compiler/calls/contains_spec.rb
+++ b/spec/oga/xpath/compiler/calls/contains_spec.rb
@@ -10,38 +10,38 @@ describe Oga::XPath::Compiler do
 
     describe 'at the top-level' do
       it 'returns true if the 1st string contains the 2nd string' do
-        evaluate_xpath(@document, 'contains("foobar", "oo")').should == true
+        expect(evaluate_xpath(@document, 'contains("foobar", "oo")')).to eq(true)
       end
 
       it "returns false if the 1st string doesn't contain the 2nd string" do
-        evaluate_xpath(@document, 'contains("foobar", "baz")').should == false
+        expect(evaluate_xpath(@document, 'contains("foobar", "baz")')).to eq(false)
       end
 
       it 'returns true if the 1st node set contains the 2nd string' do
-        evaluate_xpath(@document, 'contains(root/a, "oo")').should == true
+        expect(evaluate_xpath(@document, 'contains(root/a, "oo")')).to eq(true)
       end
 
       it 'returns true if the 1st node set contains the 2nd node set' do
-        evaluate_xpath(@document, 'contains(root/b, root/a)').should == true
+        expect(evaluate_xpath(@document, 'contains(root/b, root/a)')).to eq(true)
       end
 
       it "returns false if the 1st node doesn't contain the 2nd node set" do
-        evaluate_xpath(@document, 'contains(root/a, root/b)').should == false
+        expect(evaluate_xpath(@document, 'contains(root/a, root/b)')).to eq(false)
       end
 
       it 'returns true if the 1st string contains the 2nd node set' do
-        evaluate_xpath(@document, 'contains("foobar", root/a)').should == true
+        expect(evaluate_xpath(@document, 'contains("foobar", root/a)')).to eq(true)
       end
 
       it 'returns true when using two empty strings' do
-        evaluate_xpath(@document, 'contains("", "")').should == true
+        expect(evaluate_xpath(@document, 'contains("", "")')).to eq(true)
       end
     end
 
     describe 'in a predicate' do
       it 'returns a NodeSet containing all matching nodes' do
-        evaluate_xpath(@document, 'root/a[contains("foo", "foo")]')
-          .should == node_set(@a1)
+        expect(evaluate_xpath(@document, 'root/a[contains("foo", "foo")]'))
+          .to eq(node_set(@a1))
       end
     end
   end
diff --git a/spec/oga/xpath/compiler/calls/count_spec.rb b/spec/oga/xpath/compiler/calls/count_spec.rb
index e8d31f8..50381ab 100644
--- a/spec/oga/xpath/compiler/calls/count_spec.rb
+++ b/spec/oga/xpath/compiler/calls/count_spec.rb
@@ -7,31 +7,31 @@ describe Oga::XPath::Compiler do
     end
 
     it 'returns the amount of nodes as a Float' do
-      evaluate_xpath(@document, 'count(root)').is_a?(Float).should == true
+      expect(evaluate_xpath(@document, 'count(root)').is_a?(Float)).to eq(true)
     end
 
     it 'counts the amount of <root> nodes' do
-      evaluate_xpath(@document, 'count(root)').should == 1
+      expect(evaluate_xpath(@document, 'count(root)')).to eq(1)
     end
 
     it 'counts the amount of <a> nodes' do
-      evaluate_xpath(@document, 'count(root/a)').should == 2
+      expect(evaluate_xpath(@document, 'count(root/a)')).to eq(2)
     end
 
     it 'counts the amount of <b> nodes' do
-      evaluate_xpath(@document, 'count(root/a/b)').should == 1
+      expect(evaluate_xpath(@document, 'count(root/a/b)')).to eq(1)
     end
 
     it 'raises ArgumentError if no arguments are given' do
       block = -> { evaluate_xpath(@document, 'count()') }
 
-      block.should raise_error(ArgumentError)
+      expect(block).to raise_error(ArgumentError)
     end
 
     it 'raises TypeError if the argument is not a NodeSet' do
       block = -> { evaluate_xpath(@document, 'count(1)') }
 
-      block.should raise_error(TypeError)
+      expect(block).to raise_error(TypeError)
     end
   end
 end
diff --git a/spec/oga/xpath/compiler/calls/false_spec.rb b/spec/oga/xpath/compiler/calls/false_spec.rb
index 72ef2e1..971281d 100644
--- a/spec/oga/xpath/compiler/calls/false_spec.rb
+++ b/spec/oga/xpath/compiler/calls/false_spec.rb
@@ -7,7 +7,7 @@ describe Oga::XPath::Compiler do
     end
 
     it 'returns false' do
-      evaluate_xpath(@document, 'false()').should == false
+      expect(evaluate_xpath(@document, 'false()')).to eq(false)
     end
   end
 end
diff --git a/spec/oga/xpath/compiler/calls/floor_spec.rb b/spec/oga/xpath/compiler/calls/floor_spec.rb
index 7ef4d26..7b06f78 100644
--- a/spec/oga/xpath/compiler/calls/floor_spec.rb
+++ b/spec/oga/xpath/compiler/calls/floor_spec.rb
@@ -7,23 +7,23 @@ describe Oga::XPath::Compiler do
     end
 
     it 'returns the floor of a literal number' do
-      evaluate_xpath(@document, 'floor(10.123)').should == 10.0
+      expect(evaluate_xpath(@document, 'floor(10.123)')).to eq(10.0)
     end
 
     it 'returns the floor of a literal string' do
-      evaluate_xpath(@document, 'floor("10.123")').should == 10.0
+      expect(evaluate_xpath(@document, 'floor("10.123")')).to eq(10.0)
     end
 
     it 'returns the floor of a node set' do
-      evaluate_xpath(@document, 'floor(root)').should == 10.0
+      expect(evaluate_xpath(@document, 'floor(root)')).to eq(10.0)
     end
 
     it 'returns NaN for empty node sets' do
-      evaluate_xpath(@document, 'floor(foo)').should be_nan
+      expect(evaluate_xpath(@document, 'floor(foo)')).to be_nan
     end
 
     it 'returns NaN for an empty literal string' do
-      evaluate_xpath(@document, 'floor("")').should be_nan
+      expect(evaluate_xpath(@document, 'floor("")')).to be_nan
     end
   end
 end
diff --git a/spec/oga/xpath/compiler/calls/id_spec.rb b/spec/oga/xpath/compiler/calls/id_spec.rb
index 13f3b21..50a43b6 100644
--- a/spec/oga/xpath/compiler/calls/id_spec.rb
+++ b/spec/oga/xpath/compiler/calls/id_spec.rb
@@ -12,19 +12,19 @@ describe Oga::XPath::Compiler do
     describe 'at the top level' do
       describe 'using a string' do
         it 'returns a NodeSet' do
-          evaluate_xpath(@document, 'id("a1")').should == node_set(@a1)
+          expect(evaluate_xpath(@document, 'id("a1")')).to eq(node_set(@a1))
         end
       end
 
       describe 'using a space separated string' do
         it 'returns a NodeSet' do
-          evaluate_xpath(@document, 'id("a1 a2")').should == node_set(@a1, @a2)
+          expect(evaluate_xpath(@document, 'id("a1 a2")')).to eq(node_set(@a1, @a2))
         end
       end
 
       describe 'using a path' do
         it 'returns a NodeSet' do
-          evaluate_xpath(@document, 'id(root/a[2])').should == node_set(@a1)
+          expect(evaluate_xpath(@document, 'id(root/a[2])')).to eq(node_set(@a1))
         end
       end
     end
@@ -32,12 +32,12 @@ describe Oga::XPath::Compiler do
     describe 'in a predicate' do
       describe 'using a string' do
         it 'matches nodes when a non-empty NodeSet is returned' do
-          evaluate_xpath(@document, 'root/a[id("a1")]')
-            .should == node_set(@a1, @a2)
+          expect(evaluate_xpath(@document, 'root/a[id("a1")]'))
+            .to eq(node_set(@a1, @a2))
         end
 
         it 'does not match nodes when an empty NodeSet is returned' do
-          evaluate_xpath(@document, 'root/a[id("foo")]').should == node_set
+          expect(evaluate_xpath(@document, 'root/a[id("foo")]')).to eq(node_set)
         end
       end
     end
diff --git a/spec/oga/xpath/compiler/calls/lang_spec.rb b/spec/oga/xpath/compiler/calls/lang_spec.rb
index a7ecc73..73c24f1 100644
--- a/spec/oga/xpath/compiler/calls/lang_spec.rb
+++ b/spec/oga/xpath/compiler/calls/lang_spec.rb
@@ -11,15 +11,15 @@ describe Oga::XPath::Compiler do
     end
 
     it 'returns a node set containing nodes with language "en"' do
-      evaluate_xpath(@document, 'root[lang("en")]').should == node_set(@root)
+      expect(evaluate_xpath(@document, 'root[lang("en")]')).to eq(node_set(@root))
     end
 
     it 'returns a node  set containing the nodes with language "nl"' do
-      evaluate_xpath(@document, 'root/a[lang("nl")]').should == node_set(@a2)
+      expect(evaluate_xpath(@document, 'root/a[lang("nl")]')).to eq(node_set(@a2))
     end
 
     it 'returns a node set containing the nodes with an inherited language' do
-      evaluate_xpath(@document, 'root/a[lang("en")]').should == node_set(@a1)
+      expect(evaluate_xpath(@document, 'root/a[lang("en")]')).to eq(node_set(@a1))
     end
   end
 end
diff --git a/spec/oga/xpath/compiler/calls/last_spec.rb b/spec/oga/xpath/compiler/calls/last_spec.rb
index b3f0694..34d343a 100644
--- a/spec/oga/xpath/compiler/calls/last_spec.rb
+++ b/spec/oga/xpath/compiler/calls/last_spec.rb
@@ -11,12 +11,12 @@ describe Oga::XPath::Compiler do
 
     describe 'in a predicate' do
       it 'returns a NodeSet containing the last node' do
-        evaluate_xpath(@document, 'root/a[last()]').should == node_set(@a2)
+        expect(evaluate_xpath(@document, 'root/a[last()]')).to eq(node_set(@a2))
       end
 
       it 'returns a NodeSet matching all <a> nodes' do
-        evaluate_xpath(@document, 'root/a[1 < last()]')
-          .should == node_set(@a1, @a2)
+        expect(evaluate_xpath(@document, 'root/a[1 < last()]'))
+          .to eq(node_set(@a1, @a2))
       end
     end
   end
diff --git a/spec/oga/xpath/compiler/calls/local_name_spec.rb b/spec/oga/xpath/compiler/calls/local_name_spec.rb
index e822ec9..5e49a4a 100644
--- a/spec/oga/xpath/compiler/calls/local_name_spec.rb
+++ b/spec/oga/xpath/compiler/calls/local_name_spec.rb
@@ -7,34 +7,34 @@ describe Oga::XPath::Compiler do
     end
 
     it 'returns the local name of the <x:a> node' do
-      evaluate_xpath(@document, 'local-name(root/x:a)').should == 'a'
+      expect(evaluate_xpath(@document, 'local-name(root/x:a)')).to eq('a')
     end
 
     it 'returns the local name of the <b> node' do
-      evaluate_xpath(@document, 'local-name(root/b)').should == 'b'
+      expect(evaluate_xpath(@document, 'local-name(root/b)')).to eq('b')
     end
 
     it 'returns the local name for the "num" attribute' do
-      evaluate_xpath(@document, 'local-name(root/b/@x:num)').should == 'num'
+      expect(evaluate_xpath(@document, 'local-name(root/b/@x:num)')).to eq('num')
     end
 
     it 'returns only the name of the first node in the set' do
-      evaluate_xpath(@document, 'local-name(root/*)').should == 'a'
+      expect(evaluate_xpath(@document, 'local-name(root/*)')).to eq('a')
     end
 
     it 'returns an empty string by default' do
-      evaluate_xpath(@document, 'local-name(foo)').should == ''
+      expect(evaluate_xpath(@document, 'local-name(foo)')).to eq('')
     end
 
     it 'raises a TypeError for invalid argument types' do
       block = -> { evaluate_xpath(@document, 'local-name("foo")') }
 
-      block.should raise_error(TypeError)
+      expect(block).to raise_error(TypeError)
     end
 
     it 'returns a node set containing nodes with a local name' do
-      evaluate_xpath(@document, 'root/b[local-name()]')
-        .should == node_set(@document.children[0].children[1])
+      expect(evaluate_xpath(@document, 'root/b[local-name()]'))
+        .to eq(node_set(@document.children[0].children[1]))
     end
   end
 end
diff --git a/spec/oga/xpath/compiler/calls/name_spec.rb b/spec/oga/xpath/compiler/calls/name_spec.rb
index 579c6d6..4050a16 100644
--- a/spec/oga/xpath/compiler/calls/name_spec.rb
+++ b/spec/oga/xpath/compiler/calls/name_spec.rb
@@ -7,34 +7,34 @@ describe Oga::XPath::Compiler do
     end
 
     it 'returns the name of the <x:a> node' do
-      evaluate_xpath(@document, 'name(root/x:a)').should == 'x:a'
+      expect(evaluate_xpath(@document, 'name(root/x:a)')).to eq('x:a')
     end
 
     it 'returns the name of the <b> node' do
-      evaluate_xpath(@document, 'name(root/b)').should == 'b'
+      expect(evaluate_xpath(@document, 'name(root/b)')).to eq('b')
     end
 
     it 'returns the local name for the "num" attribute' do
-      evaluate_xpath(@document, 'name(root/b/@x:num)').should == 'x:num'
+      expect(evaluate_xpath(@document, 'name(root/b/@x:num)')).to eq('x:num')
     end
 
     it 'returns only the name of the first node in the set' do
-      evaluate_xpath(@document, 'name(root/*)').should == 'x:a'
+      expect(evaluate_xpath(@document, 'name(root/*)')).to eq('x:a')
     end
 
     it 'returns an empty string by default' do
-      evaluate_xpath(@document, 'name(foo)').should == ''
+      expect(evaluate_xpath(@document, 'name(foo)')).to eq('')
     end
 
     it 'raises a TypeError for invalid argument types' do
       block = -> { evaluate_xpath(@document, 'name("foo")') }
 
-      block.should raise_error(TypeError)
+      expect(block).to raise_error(TypeError)
     end
 
     it 'returns a node set containing nodes with a name' do
-      evaluate_xpath(@document, 'root/b[name()]')
-        .should == node_set(@document.children[0].children[1])
+      expect(evaluate_xpath(@document, 'root/b[name()]'))
+        .to eq(node_set(@document.children[0].children[1]))
     end
   end
 end
diff --git a/spec/oga/xpath/compiler/calls/namespace_uri_spec.rb b/spec/oga/xpath/compiler/calls/namespace_uri_spec.rb
index 9d679cb..a1e1480 100644
--- a/spec/oga/xpath/compiler/calls/namespace_uri_spec.rb
+++ b/spec/oga/xpath/compiler/calls/namespace_uri_spec.rb
@@ -7,26 +7,26 @@ describe Oga::XPath::Compiler do
     end
 
     it 'returns the namespace URI of the <x:a> node' do
-      evaluate_xpath(@document, 'namespace-uri(root/x:a)').should == 'y'
+      expect(evaluate_xpath(@document, 'namespace-uri(root/x:a)')).to eq('y')
     end
 
     it 'returns the namespace URI of the "num" attribute' do
-      evaluate_xpath(@document, 'namespace-uri(root/b/@x:num)').should == 'y'
+      expect(evaluate_xpath(@document, 'namespace-uri(root/b/@x:num)')).to eq('y')
     end
 
     it 'returns an empty string when there is no namespace URI' do
-      evaluate_xpath(@document, 'namespace-uri(root/b)').should == ''
+      expect(evaluate_xpath(@document, 'namespace-uri(root/b)')).to eq('')
     end
 
     it 'raises TypeError for invalid argument types' do
       block = -> { evaluate_xpath(@document, 'namespace-uri("foo")') }
 
-      block.should raise_error(TypeError)
+      expect(block).to raise_error(TypeError)
     end
 
     it 'returns a node set containing nodes with a namespace URI' do
-      evaluate_xpath(@document, 'root/*[namespace-uri()]')
-        .should == node_set(@document.children[0].children[0])
+      expect(evaluate_xpath(@document, 'root/*[namespace-uri()]'))
+        .to eq(node_set(@document.children[0].children[0]))
     end
   end
 end
diff --git a/spec/oga/xpath/compiler/calls/normalize_space_spec.rb b/spec/oga/xpath/compiler/calls/normalize_space_spec.rb
index c59d516..2c0b6b8 100644
--- a/spec/oga/xpath/compiler/calls/normalize_space_spec.rb
+++ b/spec/oga/xpath/compiler/calls/normalize_space_spec.rb
@@ -7,24 +7,24 @@ describe Oga::XPath::Compiler do
     end
 
     it 'normalizes a literal string' do
-      evaluate_xpath(@document, 'normalize-space(" fo  o ")').should == 'fo o'
+      expect(evaluate_xpath(@document, 'normalize-space(" fo  o ")')).to eq('fo o')
     end
 
     it 'normalizes a string in a node set' do
-      evaluate_xpath(@document, 'normalize-space(root/a)').should == 'fo o'
+      expect(evaluate_xpath(@document, 'normalize-space(root/a)')).to eq('fo o')
     end
 
     it 'normalizes an integer' do
-      evaluate_xpath(@document, 'normalize-space(10)').should == '10'
+      expect(evaluate_xpath(@document, 'normalize-space(10)')).to eq('10')
     end
 
     it 'normalizes a float' do
-      evaluate_xpath(@document, 'normalize-space(10.5)').should == '10.5'
+      expect(evaluate_xpath(@document, 'normalize-space(10.5)')).to eq('10.5')
     end
 
     it 'returns a node set containing nodes with normalized spaces' do
-      evaluate_xpath(@document, 'root/a[normalize-space()]')
-        .should == node_set(@document.children[0].children[0])
+      expect(evaluate_xpath(@document, 'root/a[normalize-space()]'))
+        .to eq(node_set(@document.children[0].children[0]))
     end
   end
 end
diff --git a/spec/oga/xpath/compiler/calls/not_spec.rb b/spec/oga/xpath/compiler/calls/not_spec.rb
index 367411b..10ed782 100644
--- a/spec/oga/xpath/compiler/calls/not_spec.rb
+++ b/spec/oga/xpath/compiler/calls/not_spec.rb
@@ -10,26 +10,26 @@ describe Oga::XPath::Compiler do
 
     describe 'at the top-level' do
       it 'returns false when the argument is a non-zero integer' do
-        evaluate_xpath(@document, 'not(10)').should == false
+        expect(evaluate_xpath(@document, 'not(10)')).to eq(false)
       end
 
       it 'returns true when the argument is a zero integer' do
-        evaluate_xpath(@document, 'not(0)').should == true
+        expect(evaluate_xpath(@document, 'not(0)')).to eq(true)
       end
 
       it 'returns false when the argument is a non-empty node set' do
-        evaluate_xpath(@document, 'not(root)').should == false
+        expect(evaluate_xpath(@document, 'not(root)')).to eq(false)
       end
 
       it 'returns itrue when the argument is an empty node set' do
-        evaluate_xpath(@document, 'not(foo)').should == true
+        expect(evaluate_xpath(@document, 'not(foo)')).to eq(true)
       end
     end
 
     describe 'in a predicate' do
       it 'returns a NodeSet containing all matching nodes ' do
-        evaluate_xpath(@document, 'root[not(comment())]')
-          .should == node_set(@root)
+        expect(evaluate_xpath(@document, 'root[not(comment())]'))
+          .to eq(node_set(@root))
       end
     end
   end
diff --git a/spec/oga/xpath/compiler/calls/number_spec.rb b/spec/oga/xpath/compiler/calls/number_spec.rb
index 0d7bcf2..3932745 100644
--- a/spec/oga/xpath/compiler/calls/number_spec.rb
+++ b/spec/oga/xpath/compiler/calls/number_spec.rb
@@ -7,43 +7,43 @@ describe Oga::XPath::Compiler do
     end
 
     it 'converts a literal string to a number' do
-      evaluate_xpath(@document, 'number("10")').should == 10.0
+      expect(evaluate_xpath(@document, 'number("10")')).to eq(10.0)
     end
 
     it 'converts a literal string with deciamsl to a number' do
-      evaluate_xpath(@document, 'number("10.5")').should == 10.5
+      expect(evaluate_xpath(@document, 'number("10.5")')).to eq(10.5)
     end
 
     it 'converts boolean true to a number' do
-      evaluate_xpath(@document, 'number(true())').should == 1.0
+      expect(evaluate_xpath(@document, 'number(true())')).to eq(1.0)
     end
 
     it 'converts boolean false to a number' do
-      evaluate_xpath(@document, 'number(false())').should be_zero
+      expect(evaluate_xpath(@document, 'number(false())')).to be_zero
     end
 
     it 'converts a node set to a number' do
-      evaluate_xpath(@document, 'number(root/a)').should == 10.0
+      expect(evaluate_xpath(@document, 'number(root/a)')).to eq(10.0)
     end
 
     it 'converts a node set with decimals to a number' do
-      evaluate_xpath(@document, 'number(root/b)').should == 10.5
+      expect(evaluate_xpath(@document, 'number(root/b)')).to eq(10.5)
     end
 
     it 'converts a comment to a number' do
-      evaluate_xpath(@document, 'number(root/comment())').should == 10.0
+      expect(evaluate_xpath(@document, 'number(root/comment())')).to eq(10.0)
     end
 
     it 'returns NaN for values that can not be converted to floats' do
-      evaluate_xpath(@document, 'number("a")').should be_nan
+      expect(evaluate_xpath(@document, 'number("a")')).to be_nan
     end
 
     it 'returns NaN for empty node sets' do
-      evaluate_xpath(@document, 'number(foo)').should be_nan
+      expect(evaluate_xpath(@document, 'number(foo)')).to be_nan
     end
 
     it 'returns NaN for empty strings' do
-      evaluate_xpath(@document, 'number("")').should be_nan
+      expect(evaluate_xpath(@document, 'number("")')).to be_nan
     end
   end
 end
diff --git a/spec/oga/xpath/compiler/calls/position_spec.rb b/spec/oga/xpath/compiler/calls/position_spec.rb
index efbcacb..ac9fc7f 100644
--- a/spec/oga/xpath/compiler/calls/position_spec.rb
+++ b/spec/oga/xpath/compiler/calls/position_spec.rb
@@ -10,13 +10,13 @@ describe Oga::XPath::Compiler do
     end
 
     it 'returns a node set containing the first node' do
-      evaluate_xpath(@document, 'root/a[position() = 1]')
-        .should == node_set(@a1)
+      expect(evaluate_xpath(@document, 'root/a[position() = 1]'))
+        .to eq(node_set(@a1))
     end
 
     it 'returns a node set containing the second node' do
-      evaluate_xpath(@document, 'root/a[position() = 2]')
-        .should == node_set(@a2)
+      expect(evaluate_xpath(@document, 'root/a[position() = 2]'))
+        .to eq(node_set(@a2))
     end
   end
 end
diff --git a/spec/oga/xpath/compiler/calls/round_spec.rb b/spec/oga/xpath/compiler/calls/round_spec.rb
index cea3555..a2ef08e 100644
--- a/spec/oga/xpath/compiler/calls/round_spec.rb
+++ b/spec/oga/xpath/compiler/calls/round_spec.rb
@@ -7,23 +7,23 @@ describe Oga::XPath::Compiler do
     end
 
     it 'returns the rounded value of a literal number' do
-      evaluate_xpath(@document, 'round(10.123)').should == 10.0
+      expect(evaluate_xpath(@document, 'round(10.123)')).to eq(10.0)
     end
 
     it 'returns the rounded value of a literal string' do
-      evaluate_xpath(@document, 'round("10.123")').should == 10.0
+      expect(evaluate_xpath(@document, 'round("10.123")')).to eq(10.0)
     end
 
     it 'returns the rounded value of a node set' do
-      evaluate_xpath(@document, 'round(root)').should == 10.0
+      expect(evaluate_xpath(@document, 'round(root)')).to eq(10.0)
     end
 
     it 'returns NaN for empty node sets' do
-      evaluate_xpath(@document, 'round(foo)').should be_nan
+      expect(evaluate_xpath(@document, 'round(foo)')).to be_nan
     end
 
     it 'returns NaN for an empty literal string' do
-      evaluate_xpath(@document, 'round("")').should be_nan
+      expect(evaluate_xpath(@document, 'round("")')).to be_nan
     end
   end
 end
diff --git a/spec/oga/xpath/compiler/calls/starts_with_spec.rb b/spec/oga/xpath/compiler/calls/starts_with_spec.rb
index 4c9e9a4..0fd996f 100644
--- a/spec/oga/xpath/compiler/calls/starts_with_spec.rb
+++ b/spec/oga/xpath/compiler/calls/starts_with_spec.rb
@@ -10,38 +10,38 @@ describe Oga::XPath::Compiler do
 
     describe 'at the top-level' do
       it 'returns true if the 1st string starts with the 2nd string' do
-        evaluate_xpath(@document, 'starts-with("foobar", "foo")').should == true
+        expect(evaluate_xpath(@document, 'starts-with("foobar", "foo")')).to eq(true)
       end
 
       it "returns false if the 1st string doesn't start with the 2nd string" do
-        evaluate_xpath(@document, 'starts-with("foobar", "baz")').should == false
+        expect(evaluate_xpath(@document, 'starts-with("foobar", "baz")')).to eq(false)
       end
 
       it 'returns true if the 1st node set starts with the 2nd string' do
-        evaluate_xpath(@document, 'starts-with(root/a, "foo")').should == true
+        expect(evaluate_xpath(@document, 'starts-with(root/a, "foo")')).to eq(true)
       end
 
       it 'returns true if the 1st node set starts with the 2nd node set' do
-        evaluate_xpath(@document, 'starts-with(root/b, root/a)').should == true
+        expect(evaluate_xpath(@document, 'starts-with(root/b, root/a)')).to eq(true)
       end
 
       it "returns false if the 1st node set doesn't start with the 2nd string" do
-        evaluate_xpath(@document, 'starts-with(root/a, "baz")').should == false
+        expect(evaluate_xpath(@document, 'starts-with(root/a, "baz")')).to eq(false)
       end
 
       it 'returns true if the 1st string starts with the 2nd node set' do
-        evaluate_xpath(@document, 'starts-with("foobar", root/a)').should == true
+        expect(evaluate_xpath(@document, 'starts-with("foobar", root/a)')).to eq(true)
       end
 
       it 'returns true when using two empty strings' do
-        evaluate_xpath(@document, 'starts-with("", "")').should == true
+        expect(evaluate_xpath(@document, 'starts-with("", "")')).to eq(true)
       end
     end
 
     describe 'in a predicate' do
       it 'returns a NodeSet containing all matching nodes' do
-        evaluate_xpath(@document, 'root/a[starts-with("foo", "foo")]')
-          .should == node_set(@a1)
+        expect(evaluate_xpath(@document, 'root/a[starts-with("foo", "foo")]'))
+          .to eq(node_set(@a1))
       end
     end
   end
diff --git a/spec/oga/xpath/compiler/calls/string_length_spec.rb b/spec/oga/xpath/compiler/calls/string_length_spec.rb
index 453e6f4..1bffa40 100644
--- a/spec/oga/xpath/compiler/calls/string_length_spec.rb
+++ b/spec/oga/xpath/compiler/calls/string_length_spec.rb
@@ -7,25 +7,25 @@ describe Oga::XPath::Compiler do
     end
 
     it 'returns the length of a literal string' do
-      evaluate_xpath(@document, 'string-length("foo")').should == 3.0
+      expect(evaluate_xpath(@document, 'string-length("foo")')).to eq(3.0)
     end
 
     it 'returns the length of a literal integer' do
-      evaluate_xpath(@document, 'string-length(10)').should == 2.0
+      expect(evaluate_xpath(@document, 'string-length(10)')).to eq(2.0)
     end
 
     it 'returns the length of a literal float' do
       # This includes the counting of the dot. That is, "10.5".length => 4
-      evaluate_xpath(@document, 'string-length(10.5)').should == 4.0
+      expect(evaluate_xpath(@document, 'string-length(10.5)')).to eq(4.0)
     end
 
     it 'returns the length of a string in a node set' do
-      evaluate_xpath(@document, 'string-length(root)').should == 1.0
+      expect(evaluate_xpath(@document, 'string-length(root)')).to eq(1.0)
     end
 
     it 'returns a node set containing nodes with a specific text length' do
-      evaluate_xpath(@document, 'root/a[string-length() = 1]')
-        .should == node_set(@document.children[0].children[0])
+      expect(evaluate_xpath(@document, 'root/a[string-length() = 1]'))
+        .to eq(node_set(@document.children[0].children[0]))
     end
   end
 end
diff --git a/spec/oga/xpath/compiler/calls/string_spec.rb b/spec/oga/xpath/compiler/calls/string_spec.rb
index e38cd16..575f5d4 100644
--- a/spec/oga/xpath/compiler/calls/string_spec.rb
+++ b/spec/oga/xpath/compiler/calls/string_spec.rb
@@ -14,55 +14,55 @@ describe Oga::XPath::Compiler do
     end
 
     it 'converts the <root> node to a string' do
-      evaluate_xpath(@document, 'string(root)')
-        .should == "\n  a1\n  b1\n  \n  foobar\n"
+      expect(evaluate_xpath(@document, 'string(root)'))
+        .to eq("\n  a1\n  b1\n  \n  foobar\n")
     end
 
     it 'converts the <a> node to a string' do
-      evaluate_xpath(@document, 'string(root/a)').should == 'a1'
+      expect(evaluate_xpath(@document, 'string(root/a)')).to eq('a1')
     end
 
     it 'converts the <b> node to a string' do
-      evaluate_xpath(@document, 'string(root/b)').should == 'b1'
+      expect(evaluate_xpath(@document, 'string(root/b)')).to eq('b1')
     end
 
     it 'converts the "num" attribute to a string' do
-      evaluate_xpath(@document, 'string(root/b/@num)').should == '10'
+      expect(evaluate_xpath(@document, 'string(root/b/@num)')).to eq('10')
     end
 
     it 'converts the first node in a set to a string' do
-      evaluate_xpath(@document, 'string(root/*)').should == 'a1'
+      expect(evaluate_xpath(@document, 'string(root/*)')).to eq('a1')
     end
 
     it 'converts an integer to a string' do
-      evaluate_xpath(@document, 'string(10)').should == '10'
+      expect(evaluate_xpath(@document, 'string(10)')).to eq('10')
     end
 
     it 'converts a float to a string' do
-      evaluate_xpath(@document, 'string(10.5)').should == '10.5'
+      expect(evaluate_xpath(@document, 'string(10.5)')).to eq('10.5')
     end
 
     it 'converts a string to a string' do
-      evaluate_xpath(@document, 'string("foo")').should == 'foo'
+      expect(evaluate_xpath(@document, 'string("foo")')).to eq('foo')
     end
 
     it 'converts a comment to a string' do
-      evaluate_xpath(@document, 'string(root/c/comment())').should == 'foo'
+      expect(evaluate_xpath(@document, 'string(root/c/comment())')).to eq('foo')
     end
 
     it 'converts a CDATA to a string' do
-      evaluate_xpath(@document, 'string(root/d/node())').should == 'foobar'
+      expect(evaluate_xpath(@document, 'string(root/d/node())')).to eq('foobar')
     end
 
     it 'returns an empty string by default' do
-      evaluate_xpath(@document, 'string(foobar)').should == ''
+      expect(evaluate_xpath(@document, 'string(foobar)')).to eq('')
     end
 
     it 'returns a node set containing nodes with certain text' do
       b = @document.children[0].children[1].next_element
 
-      evaluate_xpath(@document, 'root/b[string() = "b1"]')
-        .should == node_set(b)
+      expect(evaluate_xpath(@document, 'root/b[string() = "b1"]'))
+        .to eq(node_set(b))
     end
   end
 end
diff --git a/spec/oga/xpath/compiler/calls/substring_after_spec.rb b/spec/oga/xpath/compiler/calls/substring_after_spec.rb
index 8492d90..1ae4cc7 100644
--- a/spec/oga/xpath/compiler/calls/substring_after_spec.rb
+++ b/spec/oga/xpath/compiler/calls/substring_after_spec.rb
@@ -10,31 +10,31 @@ describe Oga::XPath::Compiler do
 
     describe 'at the top-level' do
       it 'returns the substring of the 1st string after the 2nd string' do
-        evaluate_xpath(@document, 'substring-after("a-b-c", "-")').should == 'b-c'
+        expect(evaluate_xpath(@document, 'substring-after("a-b-c", "-")')).to eq('b-c')
       end
 
       it 'returns an empty string if the 2nd string is not present' do
-        evaluate_xpath(@document, 'substring-after("a-b-c", "x")').should == ''
+        expect(evaluate_xpath(@document, 'substring-after("a-b-c", "x")')).to eq('')
       end
 
       it 'returns the substring of the 1st node set after the 2nd string' do
-        evaluate_xpath(@document, 'substring-after(root/b, "-")').should == 'b-c'
+        expect(evaluate_xpath(@document, 'substring-after(root/b, "-")')).to eq('b-c')
       end
 
       it 'returns the substring of the 1st node set after the 2nd node set' do
-        evaluate_xpath(@document, 'substring-after(root/b, root/a)')
-          .should == 'b-c'
+        expect(evaluate_xpath(@document, 'substring-after(root/b, root/a)'))
+          .to eq('b-c')
       end
 
       it 'returns an empty string when using two empty strings' do
-        evaluate_xpath(@document, 'substring-after("", "")').should == ''
+        expect(evaluate_xpath(@document, 'substring-after("", "")')).to eq('')
       end
     end
 
     describe 'in a predicate' do
       it 'returns a NodeSet containing all matching nodes' do
-        evaluate_xpath(@document, 'root/a[substring-after("foo-bar", "-")]')
-          .should == node_set(@a1)
+        expect(evaluate_xpath(@document, 'root/a[substring-after("foo-bar", "-")]'))
+          .to eq(node_set(@a1))
       end
     end
   end
diff --git a/spec/oga/xpath/compiler/calls/substring_before_spec.rb b/spec/oga/xpath/compiler/calls/substring_before_spec.rb
index 14013a3..a5f66f1 100644
--- a/spec/oga/xpath/compiler/calls/substring_before_spec.rb
+++ b/spec/oga/xpath/compiler/calls/substring_before_spec.rb
@@ -10,31 +10,31 @@ describe Oga::XPath::Compiler do
 
     describe 'at the top-level' do
       it 'returns the substring of the 1st string before the 2nd string' do
-        evaluate_xpath(@document, 'substring-before("a-b-c", "-")').should == 'a'
+        expect(evaluate_xpath(@document, 'substring-before("a-b-c", "-")')).to eq('a')
       end
 
       it 'returns an empty string if the 2nd string is not present' do
-        evaluate_xpath(@document, 'substring-before("a-b-c", "x")').should == ''
+        expect(evaluate_xpath(@document, 'substring-before("a-b-c", "x")')).to eq('')
       end
 
       it 'returns the substring of the 1st node set before the 2nd string' do
-        evaluate_xpath(@document, 'substring-before(root/b, "-")').should == 'a'
+        expect(evaluate_xpath(@document, 'substring-before(root/b, "-")')).to eq('a')
       end
 
       it 'returns the substring of the 1st node set before the 2nd node set' do
-        evaluate_xpath(@document, 'substring-before(root/b, root/a)')
-          .should == 'a'
+        expect(evaluate_xpath(@document, 'substring-before(root/b, root/a)'))
+          .to eq('a')
       end
 
       it 'returns an empty string when using two empty strings' do
-        evaluate_xpath(@document, 'substring-before("", "")').should == ''
+        expect(evaluate_xpath(@document, 'substring-before("", "")')).to eq('')
       end
     end
 
     describe 'in a predicate' do
       it 'returns a NodeSet containing all matching nodes' do
-        evaluate_xpath(@document, 'root/a[substring-before("foo-bar", "-")]')
-          .should == node_set(@a1)
+        expect(evaluate_xpath(@document, 'root/a[substring-before("foo-bar", "-")]'))
+          .to eq(node_set(@a1))
       end
     end
   end
diff --git a/spec/oga/xpath/compiler/calls/substring_spec.rb b/spec/oga/xpath/compiler/calls/substring_spec.rb
index 172e465..bf10fb7 100644
--- a/spec/oga/xpath/compiler/calls/substring_spec.rb
+++ b/spec/oga/xpath/compiler/calls/substring_spec.rb
@@ -10,30 +10,30 @@ describe Oga::XPath::Compiler do
 
     describe 'at the top-level' do
       it 'returns the substring of a string' do
-        evaluate_xpath(@document, 'substring("foo", 2)').should == 'oo'
+        expect(evaluate_xpath(@document, 'substring("foo", 2)')).to eq('oo')
       end
 
       it 'returns the substring of a string using a custom length' do
-        evaluate_xpath(@document, 'substring("foo", 2, 1)').should == 'o'
+        expect(evaluate_xpath(@document, 'substring("foo", 2, 1)')).to eq('o')
       end
 
       it 'returns the substring of a node set' do
-        evaluate_xpath(@document, 'substring(root/a, 2)').should == 'oobar'
+        expect(evaluate_xpath(@document, 'substring(root/a, 2)')).to eq('oobar')
       end
 
       it 'returns the substring of a node set with a node set as the length' do
-        evaluate_xpath(@document, 'substring(root/a, 1, root/b)').should == 'foo'
+        expect(evaluate_xpath(@document, 'substring(root/a, 1, root/b)')).to eq('foo')
       end
 
       it 'returns an empty string when the source string is empty' do
-        evaluate_xpath(@document, 'substring("", 1, 3)').should == ''
+        expect(evaluate_xpath(@document, 'substring("", 1, 3)')).to eq('')
       end
     end
 
     describe 'in a predicate' do
       it 'returns a NodeSet containing all matching nodes' do
-        evaluate_xpath(@document, 'root/a[substring("foo", 1, 2)]')
-          .should == node_set(@a1)
+        expect(evaluate_xpath(@document, 'root/a[substring("foo", 1, 2)]'))
+          .to eq(node_set(@a1))
       end
     end
   end
diff --git a/spec/oga/xpath/compiler/calls/sum_spec.rb b/spec/oga/xpath/compiler/calls/sum_spec.rb
index 1e4b890..0fb6498 100644
--- a/spec/oga/xpath/compiler/calls/sum_spec.rb
+++ b/spec/oga/xpath/compiler/calls/sum_spec.rb
@@ -11,28 +11,28 @@ describe Oga::XPath::Compiler do
     describe 'at the top-level' do
       it 'returns the sum of the <root> node' do
         # The test of <root> is "12", which is then converted to a number.
-        evaluate_xpath(@document, 'sum(root)').should == 12.0
+        expect(evaluate_xpath(@document, 'sum(root)')).to eq(12.0)
       end
 
       it 'returns the sum of the child nodes of the <root> node' do
-        evaluate_xpath(@document, 'sum(root/*)').should == 3.0
+        expect(evaluate_xpath(@document, 'sum(root/*)')).to eq(3.0)
       end
 
       it 'returns zero by default' do
-        evaluate_xpath(@document, 'sum(foo)').should be_zero
+        expect(evaluate_xpath(@document, 'sum(foo)')).to be_zero
       end
 
       it 'raises a TypeError for non node set arguments' do
         block = -> { evaluate_xpath(@document, 'sum("foo")') }
 
-        block.should raise_error(TypeError)
+        expect(block).to raise_error(TypeError)
       end
     end
 
     describe 'in a predicate' do
       it 'returns a NodeSet containing the first <a> node' do
-        evaluate_xpath(@document, 'root/a[sum(/root/a)]')
-          .should == node_set(@a1)
+        expect(evaluate_xpath(@document, 'root/a[sum(/root/a)]'))
+          .to eq(node_set(@a1))
       end
     end
   end
diff --git a/spec/oga/xpath/compiler/calls/translate_spec.rb b/spec/oga/xpath/compiler/calls/translate_spec.rb
index e437118..101ce91 100644
--- a/spec/oga/xpath/compiler/calls/translate_spec.rb
+++ b/spec/oga/xpath/compiler/calls/translate_spec.rb
@@ -7,32 +7,32 @@ describe Oga::XPath::Compiler do
     end
 
     it 'translates a string using all string literals' do
-      evaluate_xpath(@document, 'translate("bar", "abc", "ABC")')
-        .should == 'BAr'
+      expect(evaluate_xpath(@document, 'translate("bar", "abc", "ABC")'))
+        .to eq('BAr')
     end
 
     it "removes characters that don't occur in the replacement string" do
-      evaluate_xpath(@document, 'translate("-aaa-", "abc-", "ABC")')
-        .should == 'AAA'
+      expect(evaluate_xpath(@document, 'translate("-aaa-", "abc-", "ABC")'))
+        .to eq('AAA')
     end
 
     it 'uses the first character occurence in the search string' do
-      evaluate_xpath(@document, 'translate("ab", "aba", "123")').should == '12'
+      expect(evaluate_xpath(@document, 'translate("ab", "aba", "123")')).to eq('12')
     end
 
     it 'ignores excess characters in the replacement string' do
-      evaluate_xpath(@document, 'translate("abc", "abc", "123456")')
-        .should == '123'
+      expect(evaluate_xpath(@document, 'translate("abc", "abc", "123456")'))
+        .to eq('123')
     end
 
     it 'translates a node set string using string literals' do
-      evaluate_xpath(@document, 'translate(root/a, "abc", "ABC")')
-        .should == 'BAr'
+      expect(evaluate_xpath(@document, 'translate(root/a, "abc", "ABC")'))
+        .to eq('BAr')
     end
 
     it 'translates a node set string using other node set strings' do
-      evaluate_xpath(@document, 'translate(root/a, root/b, root/c)')
-        .should == 'BAr'
+      expect(evaluate_xpath(@document, 'translate(root/a, root/b, root/c)'))
+        .to eq('BAr')
     end
   end
 end
diff --git a/spec/oga/xpath/compiler/calls/true_spec.rb b/spec/oga/xpath/compiler/calls/true_spec.rb
index ea51a49..1fc9990 100644
--- a/spec/oga/xpath/compiler/calls/true_spec.rb
+++ b/spec/oga/xpath/compiler/calls/true_spec.rb
@@ -7,7 +7,7 @@ describe Oga::XPath::Compiler do
     end
 
     it 'returns true' do
-      evaluate_xpath(@document, 'true()').should == true
+      expect(evaluate_xpath(@document, 'true()')).to eq(true)
     end
   end
 end
diff --git a/spec/oga/xpath/compiler/html_spec.rb b/spec/oga/xpath/compiler/html_spec.rb
index a29c340..c21aa0e 100644
--- a/spec/oga/xpath/compiler/html_spec.rb
+++ b/spec/oga/xpath/compiler/html_spec.rb
@@ -9,7 +9,7 @@ describe Oga::XPath::Compiler do
   describe 'relative to an HTML document' do
     describe 'html/body' do
       it 'returns a NodeSet' do
-        evaluate_xpath(@document).should == node_set(@body)
+        expect(evaluate_xpath(@document)).to eq(node_set(@body))
       end
     end
   end
diff --git a/spec/oga/xpath/compiler/operators/add_spec.rb b/spec/oga/xpath/compiler/operators/add_spec.rb
index cc3cf0f..6188fea 100644
--- a/spec/oga/xpath/compiler/operators/add_spec.rb
+++ b/spec/oga/xpath/compiler/operators/add_spec.rb
@@ -7,27 +7,27 @@ describe Oga::XPath::Compiler do
     end
 
     it 'adds two numbers' do
-      evaluate_xpath(@document, '1 + 2').should == 3.0
+      expect(evaluate_xpath(@document, '1 + 2')).to eq(3.0)
     end
 
     it 'adds a number and a string' do
-      evaluate_xpath(@document, '1 + "2"').should == 3.0
+      expect(evaluate_xpath(@document, '1 + "2"')).to eq(3.0)
     end
 
     it 'adds two strings' do
-      evaluate_xpath(@document, '"1" + "2"').should == 3.0
+      expect(evaluate_xpath(@document, '"1" + "2"')).to eq(3.0)
     end
 
     it 'adds a number and a node set' do
-      evaluate_xpath(@document, 'root/a + 2').should == 3.0
+      expect(evaluate_xpath(@document, 'root/a + 2')).to eq(3.0)
     end
 
     it 'adds two node sets' do
-      evaluate_xpath(@document, 'root/a + root/b').should == 3.0
+      expect(evaluate_xpath(@document, 'root/a + root/b')).to eq(3.0)
     end
 
     it 'returns NaN when trying to add invalid values' do
-      evaluate_xpath(@document, '"" + 1').should be_nan
+      expect(evaluate_xpath(@document, '"" + 1')).to be_nan
     end
   end
 end
diff --git a/spec/oga/xpath/compiler/operators/and_spec.rb b/spec/oga/xpath/compiler/operators/and_spec.rb
index c04b0b6..a91fae6 100644
--- a/spec/oga/xpath/compiler/operators/and_spec.rb
+++ b/spec/oga/xpath/compiler/operators/and_spec.rb
@@ -7,19 +7,19 @@ describe Oga::XPath::Compiler do
     end
 
     it 'returns true if both boolean literals are true' do
-      evaluate_xpath(@document, 'true() and true()').should == true
+      expect(evaluate_xpath(@document, 'true() and true()')).to eq(true)
     end
 
     it 'returns false if one of the boolean literals is false' do
-      evaluate_xpath(@document, 'true() and false()').should == false
+      expect(evaluate_xpath(@document, 'true() and false()')).to eq(false)
     end
 
     it 'returns true if both node sets are non empty' do
-      evaluate_xpath(@document, 'root/a and root/b').should == true
+      expect(evaluate_xpath(@document, 'root/a and root/b')).to eq(true)
     end
 
     it 'returns false if one of the node sets is empty' do
-      evaluate_xpath(@document, 'root/a and root/c').should == false
+      expect(evaluate_xpath(@document, 'root/a and root/c')).to eq(false)
     end
   end
 end
diff --git a/spec/oga/xpath/compiler/operators/div_spec.rb b/spec/oga/xpath/compiler/operators/div_spec.rb
index 388d23b..0286ae2 100644
--- a/spec/oga/xpath/compiler/operators/div_spec.rb
+++ b/spec/oga/xpath/compiler/operators/div_spec.rb
@@ -7,27 +7,27 @@ describe Oga::XPath::Compiler do
     end
 
     it 'divides two numbers' do
-      evaluate_xpath(@document, '1 div 2').should == 0.5
+      expect(evaluate_xpath(@document, '1 div 2')).to eq(0.5)
     end
 
     it 'divides a number and a string' do
-      evaluate_xpath(@document, '1 div "2"').should == 0.5
+      expect(evaluate_xpath(@document, '1 div "2"')).to eq(0.5)
     end
 
     it 'divides two strings' do
-      evaluate_xpath(@document, '"1" div "2"').should == 0.5
+      expect(evaluate_xpath(@document, '"1" div "2"')).to eq(0.5)
     end
 
     it 'divides a number and a node set' do
-      evaluate_xpath(@document, 'root/a div 2').should == 0.5
+      expect(evaluate_xpath(@document, 'root/a div 2')).to eq(0.5)
     end
 
     it 'divides two node sets' do
-      evaluate_xpath(@document, 'root/a div root/b').should == 0.5
+      expect(evaluate_xpath(@document, 'root/a div root/b')).to eq(0.5)
     end
 
     it 'returns NaN when trying to divide invalid values' do
-      evaluate_xpath(@document, '"" div 1').should be_nan
+      expect(evaluate_xpath(@document, '"" div 1')).to be_nan
     end
   end
 end
diff --git a/spec/oga/xpath/compiler/operators/eq_spec.rb b/spec/oga/xpath/compiler/operators/eq_spec.rb
index 24b1752..60d97be 100644
--- a/spec/oga/xpath/compiler/operators/eq_spec.rb
+++ b/spec/oga/xpath/compiler/operators/eq_spec.rb
@@ -7,77 +7,77 @@ describe Oga::XPath::Compiler do
     end
 
     it 'returns true if two numbers are equal' do
-      evaluate_xpath(@document, '10 = 10').should == true
+      expect(evaluate_xpath(@document, '10 = 10')).to eq(true)
     end
 
     it 'returns true if two numbers and 1 are equal' do
-      evaluate_xpath(@document, '10 = 10 = 1').should == true
+      expect(evaluate_xpath(@document, '10 = 10 = 1')).to eq(true)
     end
 
     it 'returns false if two numbers and 0 are not equal' do
-      evaluate_xpath(@document, '10 = 10 = 0').should == false
+      expect(evaluate_xpath(@document, '10 = 10 = 0')).to eq(false)
     end
 
     it 'returns false if two numbers are not equal' do
-      evaluate_xpath(@document, '10 = 15').should == false
+      expect(evaluate_xpath(@document, '10 = 15')).to eq(false)
     end
 
     it 'returns true if a number and a string are equal' do
-      evaluate_xpath(@document, '10 = "10"').should == true
+      expect(evaluate_xpath(@document, '10 = "10"')).to eq(true)
     end
 
     it 'returns true if two strings are equal' do
-      evaluate_xpath(@document, '"10" = "10"').should == true
+      expect(evaluate_xpath(@document, '"10" = "10"')).to eq(true)
     end
 
     it 'returns true if a string and a number are equal' do
-      evaluate_xpath(@document, '"10" = 10').should == true
+      expect(evaluate_xpath(@document, '"10" = 10')).to eq(true)
     end
 
     it 'returns false if two strings are not equal' do
-      evaluate_xpath(@document, '"a" = "b"').should == false
+      expect(evaluate_xpath(@document, '"a" = "b"')).to eq(false)
     end
 
     it 'returns true if two node sets are equal' do
-      evaluate_xpath(@document, 'root/a = root/b').should == true
+      expect(evaluate_xpath(@document, 'root/a = root/b')).to eq(true)
     end
 
     it 'returns true if two node sets and 1 are equal' do
-      evaluate_xpath(@document, 'root/a = root/b = 1').should == true
+      expect(evaluate_xpath(@document, 'root/a = root/b = 1')).to eq(true)
     end
 
     it 'returns false if two node sets and 0 are not equal' do
-      evaluate_xpath(@document, 'root/a = root/b = 0').should == false
+      expect(evaluate_xpath(@document, 'root/a = root/b = 0')).to eq(false)
     end
 
     it 'returns false if two node sets are not equal' do
-      evaluate_xpath(@document, 'root/a = root/c').should == false
+      expect(evaluate_xpath(@document, 'root/a = root/c')).to eq(false)
     end
 
     it 'returns true if a node set and a number are equal' do
-      evaluate_xpath(@document, 'root/a = 10').should == true
+      expect(evaluate_xpath(@document, 'root/a = 10')).to eq(true)
     end
 
     it 'returns true if a node set and a string are equal' do
-      evaluate_xpath(@document, 'root/a = "10"').should == true
+      expect(evaluate_xpath(@document, 'root/a = "10"')).to eq(true)
     end
 
     it 'returns true if a node set wildcard and a number are equal' do
-      evaluate_xpath(@document, 'root/* = 10').should == true
+      expect(evaluate_xpath(@document, 'root/* = 10')).to eq(true)
     end
 
     it 'returns true if a number and a node set wildcard are equal' do
-      evaluate_xpath(@document, '10 = root/*').should == true
+      expect(evaluate_xpath(@document, '10 = root/*')).to eq(true)
     end
 
     it 'returns true if an attribute and string are equal' do
-      evaluate_xpath(@document, 'root/b/@class = "foo"').should == true
+      expect(evaluate_xpath(@document, 'root/b/@class = "foo"')).to eq(true)
     end
 
     it 'returns true if an axis and a string are equal' do
       element = @document.children[0].children[1]
 
-      evaluate_xpath(element, '@class = "foo"').should == true
+      expect(evaluate_xpath(element, '@class = "foo"')).to eq(true)
     end
   end
 end
diff --git a/spec/oga/xpath/compiler/operators/gt_spec.rb b/spec/oga/xpath/compiler/operators/gt_spec.rb
index b575ad3..206ca89 100644
--- a/spec/oga/xpath/compiler/operators/gt_spec.rb
+++ b/spec/oga/xpath/compiler/operators/gt_spec.rb
@@ -7,35 +7,35 @@ describe Oga::XPath::Compiler do
     end
 
     it 'returns true if a number is greater than another number' do
-      evaluate_xpath(@document, '20 > 10').should == true
+      expect(evaluate_xpath(@document, '20 > 10')).to eq(true)
     end
 
     it 'returns false if a number is not greater than another number' do
-      evaluate_xpath(@document, '10 > 20').should == false
+      expect(evaluate_xpath(@document, '10 > 20')).to eq(false)
     end
 
     it 'returns true if a number is greater than a string' do
-      evaluate_xpath(@document, '20 > "10"').should == true
+      expect(evaluate_xpath(@document, '20 > "10"')).to eq(true)
     end
 
     it 'returns true if a string is greater than a number' do
-      evaluate_xpath(@document, '"20" > 10').should == true
+      expect(evaluate_xpath(@document, '"20" > 10')).to eq(true)
     end
 
     it 'returns true if a string is greater than another string' do
-      evaluate_xpath(@document, '"20" > "10"').should == true
+      expect(evaluate_xpath(@document, '"20" > "10"')).to eq(true)
     end
 
     it 'returns true if a number is greater than a node set' do
-      evaluate_xpath(@document, '20 > root/a').should == true
+      expect(evaluate_xpath(@document, '20 > root/a')).to eq(true)
     end
 
     it 'returns true if a string is greater than a node set' do
-      evaluate_xpath(@document, '"20" > root/a').should == true
+      expect(evaluate_xpath(@document, '"20" > root/a')).to eq(true)
     end
 
     it 'returns true if a node set is greater than another node set' do
-      evaluate_xpath(@document, 'root/b > root/a').should == true
+      expect(evaluate_xpath(@document, 'root/b > root/a')).to eq(true)
     end
   end
 end
diff --git a/spec/oga/xpath/compiler/operators/gte_spec.rb b/spec/oga/xpath/compiler/operators/gte_spec.rb
index b9d20df..23bd765 100644
--- a/spec/oga/xpath/compiler/operators/gte_spec.rb
+++ b/spec/oga/xpath/compiler/operators/gte_spec.rb
@@ -7,59 +7,59 @@ describe Oga::XPath::Compiler do
     end
 
     it 'returns true if a number is greater than another number' do
-      evaluate_xpath(@document, '20 >= 10').should == true
+      expect(evaluate_xpath(@document, '20 >= 10')).to eq(true)
     end
 
     it 'returns true if a number is equal to another number' do
-      evaluate_xpath(@document, '10 >= 10').should == true
+      expect(evaluate_xpath(@document, '10 >= 10')).to eq(true)
     end
 
     it 'returns false if a number is not greater than/equal to another number' do
-      evaluate_xpath(@document, '10 >= 20').should == false
+      expect(evaluate_xpath(@document, '10 >= 20')).to eq(false)
     end
 
     it 'returns true if a number is greater than a string' do
-      evaluate_xpath(@document, '20 >= "10"').should == true
+      expect(evaluate_xpath(@document, '20 >= "10"')).to eq(true)
     end
 
     it 'returns true if a number is equal to a string' do
-      evaluate_xpath(@document, '10 >= "10"').should == true
+      expect(evaluate_xpath(@document, '10 >= "10"')).to eq(true)
     end
 
     it 'returns true if a string is greater than a number' do
-      evaluate_xpath(@document, '"20" >= 10').should == true
+      expect(evaluate_xpath(@document, '"20" >= 10')).to eq(true)
     end
 
     it 'returns true if a string is equal to a number' do
-      evaluate_xpath(@document, '"10" >= 10').should == true
+      expect(evaluate_xpath(@document, '"10" >= 10')).to eq(true)
     end
 
     it 'returns true if a string is greater than another string' do
-      evaluate_xpath(@document, '"20" >= "10"').should == true
+      expect(evaluate_xpath(@document, '"20" >= "10"')).to eq(true)
     end
 
     it 'returns true if a number is greater than a node set' do
-      evaluate_xpath(@document, '20 >= root/a').should == true
+      expect(evaluate_xpath(@document, '20 >= root/a')).to eq(true)
     end
 
     it 'returns true if a number is equal to a node set' do
-      evaluate_xpath(@document, '20 >= root/b').should == true
+      expect(evaluate_xpath(@document, '20 >= root/b')).to eq(true)
     end
 
     it 'returns true if a string is greater than a node set' do
-      evaluate_xpath(@document, '"20" >= root/a').should == true
+      expect(evaluate_xpath(@document, '"20" >= root/a')).to eq(true)
     end
 
     it 'returns true if a string is equal to a node set' do
-      evaluate_xpath(@document, '"10" >= root/a').should == true
+      expect(evaluate_xpath(@document, '"10" >= root/a')).to eq(true)
     end
 
     it 'returns true if a node set is greater than another node set' do
-      evaluate_xpath(@document, 'root/b >= root/a').should == true
+      expect(evaluate_xpath(@document, 'root/b >= root/a')).to eq(true)
     end
 
     it 'returns true if a node set is equal to another node set' do
-      evaluate_xpath(@document, 'root/b >= root/b').should == true
+      expect(evaluate_xpath(@document, 'root/b >= root/b')).to eq(true)
     end
   end
 end
diff --git a/spec/oga/xpath/compiler/operators/lt_spec.rb b/spec/oga/xpath/compiler/operators/lt_spec.rb
index df71a22..c92ab63 100644
--- a/spec/oga/xpath/compiler/operators/lt_spec.rb
+++ b/spec/oga/xpath/compiler/operators/lt_spec.rb
@@ -7,35 +7,35 @@ describe Oga::XPath::Compiler do
     end
 
     it 'returns true if a number is lower than another number' do
-      evaluate_xpath(@document, '10 < 20').should == true
+      expect(evaluate_xpath(@document, '10 < 20')).to eq(true)
     end
 
     it 'returns false if a number is not lower than another number' do
-      evaluate_xpath(@document, '20 < 10').should == false
+      expect(evaluate_xpath(@document, '20 < 10')).to eq(false)
     end
 
     it 'returns true if a number is lower than a string' do
-      evaluate_xpath(@document, '10 < "20"').should == true
+      expect(evaluate_xpath(@document, '10 < "20"')).to eq(true)
     end
 
     it 'returns true if a string is lower than a number' do
-      evaluate_xpath(@document, '"10" < 20').should == true
+      expect(evaluate_xpath(@document, '"10" < 20')).to eq(true)
     end
 
     it 'returns true if a string is lower than another string' do
-      evaluate_xpath(@document, '"10" < "20"').should == true
+      expect(evaluate_xpath(@document, '"10" < "20"')).to eq(true)
     end
 
     it 'returns true if a number is lower than a node set' do
-      evaluate_xpath(@document, '10 < root/b').should == true
+      expect(evaluate_xpath(@document, '10 < root/b')).to eq(true)
     end
 
     it 'returns true if a string is lower than a node set' do
-      evaluate_xpath(@document, '"10" < root/b').should == true
+      expect(evaluate_xpath(@document, '"10" < root/b')).to eq(true)
     end
 
     it 'returns true if a node set is lower than another node set' do
-      evaluate_xpath(@document, 'root/a < root/b').should == true
+      expect(evaluate_xpath(@document, 'root/a < root/b')).to eq(true)
     end
   end
 end
diff --git a/spec/oga/xpath/compiler/operators/lte_spec.rb b/spec/oga/xpath/compiler/operators/lte_spec.rb
index 5075daa..18aece8 100644
--- a/spec/oga/xpath/compiler/operators/lte_spec.rb
+++ b/spec/oga/xpath/compiler/operators/lte_spec.rb
@@ -7,59 +7,59 @@ describe Oga::XPath::Compiler do
     end
 
     it 'returns true if a number is lower than another number' do
-      evaluate_xpath(@document, '10 <= 20').should == true
+      expect(evaluate_xpath(@document, '10 <= 20')).to eq(true)
     end
 
     it 'returns true if a number is equal to another number' do
-      evaluate_xpath(@document, '10 <= 10').should == true
+      expect(evaluate_xpath(@document, '10 <= 10')).to eq(true)
     end
 
     it 'returns false if a number is not lower than/equal to another number' do
-      evaluate_xpath(@document, '20 <= 10').should == false
+      expect(evaluate_xpath(@document, '20 <= 10')).to eq(false)
     end
 
     it 'returns true if a number is lower than a string' do
-      evaluate_xpath(@document, '10 <= "20"').should == true
+      expect(evaluate_xpath(@document, '10 <= "20"')).to eq(true)
     end
 
     it 'returns true if a number is equal to a string' do
-      evaluate_xpath(@document, '10 <= "10"').should == true
+      expect(evaluate_xpath(@document, '10 <= "10"')).to eq(true)
     end
 
     it 'returns true if a string is lower than a number' do
-      evaluate_xpath(@document, '"10" <= 20').should == true
+      expect(evaluate_xpath(@document, '"10" <= 20')).to eq(true)
     end
 
     it 'returns true if a string is equal to a number' do
-      evaluate_xpath(@document, '"10" <= 10').should == true
+      expect(evaluate_xpath(@document, '"10" <= 10')).to eq(true)
     end
 
     it 'returns true if a string is lower than another string' do
-      evaluate_xpath(@document, '"10" <= "20"').should == true
+      expect(evaluate_xpath(@document, '"10" <= "20"')).to eq(true)
     end
 
     it 'returns true if a number is lower than a node set' do
-      evaluate_xpath(@document, '10 <= root/b').should == true
+      expect(evaluate_xpath(@document, '10 <= root/b')).to eq(true)
     end
 
     it 'returns true if a number is equal to a node set' do
-      evaluate_xpath(@document, '10 <= root/a').should == true
+      expect(evaluate_xpath(@document, '10 <= root/a')).to eq(true)
     end
 
     it 'returns true if a string is lower than a node set' do
-      evaluate_xpath(@document, '"10" <= root/b').should == true
+      expect(evaluate_xpath(@document, '"10" <= root/b')).to eq(true)
     end
 
     it 'returns true if a string is equal to a node set' do
-      evaluate_xpath(@document, '"10" <= root/a').should == true
+      expect(evaluate_xpath(@document, '"10" <= root/a')).to eq(true)
     end
 
     it 'returns true if a node set is lower than another node set' do
-      evaluate_xpath(@document, 'root/a <= root/b').should == true
+      expect(evaluate_xpath(@document, 'root/a <= root/b')).to eq(true)
     end
 
     it 'returns true if a node set is equal to another node set' do
-      evaluate_xpath(@document, 'root/b <= root/b').should == true
+      expect(evaluate_xpath(@document, 'root/b <= root/b')).to eq(true)
     end
   end
 end
diff --git a/spec/oga/xpath/compiler/operators/mod_spec.rb b/spec/oga/xpath/compiler/operators/mod_spec.rb
index 37777ee..f8cf022 100644
--- a/spec/oga/xpath/compiler/operators/mod_spec.rb
+++ b/spec/oga/xpath/compiler/operators/mod_spec.rb
@@ -7,27 +7,27 @@ describe Oga::XPath::Compiler do
     end
 
     it 'returns the modulo of two numbers' do
-      evaluate_xpath(@document, '2 mod 3').should == 2.0
+      expect(evaluate_xpath(@document, '2 mod 3')).to eq(2.0)
     end
 
     it 'returns the modulo of a number and a string' do
-      evaluate_xpath(@document, '2 mod "3"').should == 2.0
+      expect(evaluate_xpath(@document, '2 mod "3"')).to eq(2.0)
     end
 
     it 'returns the modulo of two strings' do
-      evaluate_xpath(@document, '"2" mod "3"').should == 2.0
+      expect(evaluate_xpath(@document, '"2" mod "3"')).to eq(2.0)
     end
 
     it 'returns the modulo of a node set and a number' do
-      evaluate_xpath(@document, 'root/a mod 3').should == 2.0
+      expect(evaluate_xpath(@document, 'root/a mod 3')).to eq(2.0)
     end
 
     it 'returns the modulo of two node sets' do
-      evaluate_xpath(@document, 'root/a mod root/b').should == 2.0
+      expect(evaluate_xpath(@document, 'root/a mod root/b')).to eq(2.0)
     end
 
     it 'returns NaN when trying to get the modulo of invalid values' do
-      evaluate_xpath(@document, '"" mod 1').should be_nan
+      expect(evaluate_xpath(@document, '"" mod 1')).to be_nan
     end
   end
 end
diff --git a/spec/oga/xpath/compiler/operators/mul_spec.rb b/spec/oga/xpath/compiler/operators/mul_spec.rb
index 2e44a35..e6bcf31 100644
--- a/spec/oga/xpath/compiler/operators/mul_spec.rb
+++ b/spec/oga/xpath/compiler/operators/mul_spec.rb
@@ -7,27 +7,27 @@ describe Oga::XPath::Compiler do
     end
 
     it 'multiplies two numbers' do
-      evaluate_xpath(@document, '2 * 3').should == 6.0
+      expect(evaluate_xpath(@document, '2 * 3')).to eq(6.0)
     end
 
     it 'multiplies a number and a string' do
-      evaluate_xpath(@document, '2 * "3"').should == 6.0
+      expect(evaluate_xpath(@document, '2 * "3"')).to eq(6.0)
     end
 
     it 'multiplies two strings' do
-      evaluate_xpath(@document, '"2" * "3"').should == 6.0
+      expect(evaluate_xpath(@document, '"2" * "3"')).to eq(6.0)
     end
 
     it 'multiplies a node set and a number' do
-      evaluate_xpath(@document, 'root/a * 3').should == 6.0
+      expect(evaluate_xpath(@document, 'root/a * 3')).to eq(6.0)
     end
 
     it 'multiplies two node sets' do
-      evaluate_xpath(@document, 'root/a * root/b').should == 6.0
+      expect(evaluate_xpath(@document, 'root/a * root/b')).to eq(6.0)
     end
 
     it 'returns NaN when trying to multiply invalid values' do
-      evaluate_xpath(@document, '"" * 1').should be_nan
+      expect(evaluate_xpath(@document, '"" * 1')).to be_nan
     end
   end
 end
diff --git a/spec/oga/xpath/compiler/operators/neq_spec.rb b/spec/oga/xpath/compiler/operators/neq_spec.rb
index 5f316c0..e210489 100644
--- a/spec/oga/xpath/compiler/operators/neq_spec.rb
+++ b/spec/oga/xpath/compiler/operators/neq_spec.rb
@@ -7,43 +7,43 @@ describe Oga::XPath::Compiler do
     end
 
     it 'returns true if two numbers are not equal' do
-      evaluate_xpath(@document, '10 != 20').should == true
+      expect(evaluate_xpath(@document, '10 != 20')).to eq(true)
     end
 
     it 'returns false if two numbers are equal' do
-      evaluate_xpath(@document, '10 != 10').should == false
+      expect(evaluate_xpath(@document, '10 != 10')).to eq(false)
     end
 
     it 'returns true if a number and a string are not equal' do
-      evaluate_xpath(@document, '10 != "20"').should == true
+      expect(evaluate_xpath(@document, '10 != "20"')).to eq(true)
     end
 
     it 'returns true if two strings are not equal' do
-      evaluate_xpath(@document, '"10" != "20"').should == true
+      expect(evaluate_xpath(@document, '"10" != "20"')).to eq(true)
     end
 
     it 'returns true if a string and a number are not equal' do
-      evaluate_xpath(@document, '"10" != 20').should == true
+      expect(evaluate_xpath(@document, '"10" != 20')).to eq(true)
     end
 
     it 'returns false if two strings are equal' do
-      evaluate_xpath(@document, '"a" != "a"').should == false
+      expect(evaluate_xpath(@document, '"a" != "a"')).to eq(false)
     end
 
     it 'returns true if two node sets are not equal' do
-      evaluate_xpath(@document, 'root != root/b').should == true
+      expect(evaluate_xpath(@document, 'root != root/b')).to eq(true)
     end
 
     it 'returns false if two node sets are equal' do
-      evaluate_xpath(@document, 'root/a != root/b').should == false
+      expect(evaluate_xpath(@document, 'root/a != root/b')).to eq(false)
     end
 
     it 'returns true if a node set and a number are not equal' do
-      evaluate_xpath(@document, 'root/a != 20').should == true
+      expect(evaluate_xpath(@document, 'root/a != 20')).to eq(true)
     end
 
     it 'returns true if a node set and a string are not equal' do
-      evaluate_xpath(@document, 'root/a != "20"').should == true
+      expect(evaluate_xpath(@document, 'root/a != "20"')).to eq(true)
     end
   end
 end
diff --git a/spec/oga/xpath/compiler/operators/or_spec.rb b/spec/oga/xpath/compiler/operators/or_spec.rb
index e1461fb..5aa84db 100644
--- a/spec/oga/xpath/compiler/operators/or_spec.rb
+++ b/spec/oga/xpath/compiler/operators/or_spec.rb
@@ -7,27 +7,27 @@ describe Oga::XPath::Compiler do
     end
 
     it 'returns true if both boolean literals are true' do
-      evaluate_xpath(@document, 'true() or true()').should == true
+      expect(evaluate_xpath(@document, 'true() or true()')).to eq(true)
     end
 
     it 'returns true if one of the boolean literals is false' do
-      evaluate_xpath(@document, 'true() or false()').should == true
+      expect(evaluate_xpath(@document, 'true() or false()')).to eq(true)
     end
 
     it 'returns true if the left node set is not empty' do
-      evaluate_xpath(@document, 'root/a or root/x').should == true
+      expect(evaluate_xpath(@document, 'root/a or root/x')).to eq(true)
     end
 
     it 'returns true if the right node set is not empty' do
-      evaluate_xpath(@document, 'root/x or root/b').should == true
+      expect(evaluate_xpath(@document, 'root/x or root/b')).to eq(true)
     end
 
     it 'returns true if both node sets are not empty' do
-      evaluate_xpath(@document, 'root/a or root/b').should == true
+      expect(evaluate_xpath(@document, 'root/a or root/b')).to eq(true)
     end
 
     it 'returns false if both node sets are empty' do
-      evaluate_xpath(@document, 'root/x or root/y').should == false
+      expect(evaluate_xpath(@document, 'root/x or root/y')).to eq(false)
     end
   end
 end
diff --git a/spec/oga/xpath/compiler/operators/pipe_spec.rb b/spec/oga/xpath/compiler/operators/pipe_spec.rb
index b9ebbed..bf13635 100644
--- a/spec/oga/xpath/compiler/operators/pipe_spec.rb
+++ b/spec/oga/xpath/compiler/operators/pipe_spec.rb
@@ -12,45 +12,45 @@ describe Oga::XPath::Compiler do
     end
 
     it 'merges two node sets' do
-      evaluate_xpath(@document, 'root/a | root/b').should == node_set(@a1, @b1)
+      expect(evaluate_xpath(@document, 'root/a | root/b')).to eq(node_set(@a1, @b1))
     end
 
     it 'merges two sets when the left hand side is empty' do
-      evaluate_xpath(@document, 'foo | root/b').should == node_set(@b1)
+      expect(evaluate_xpath(@document, 'foo | root/b')).to eq(node_set(@b1))
     end
 
     it 'merges two sets when the right hand side is empty' do
-      evaluate_xpath(@document, 'root/a | foo').should == node_set(@a1)
+      expect(evaluate_xpath(@document, 'root/a | foo')).to eq(node_set(@a1))
     end
 
     it 'merges two identical sets' do
-      evaluate_xpath(@document, 'root/a | root/a').should == node_set(@a1)
+      expect(evaluate_xpath(@document, 'root/a | root/a')).to eq(node_set(@a1))
     end
 
     it 'merges three sets' do
-      evaluate_xpath(@document, 'root/a | root/b | root/c')
-        .should == node_set(@a1, @b1, @c1)
+      expect(evaluate_xpath(@document, 'root/a | root/b | root/c'))
+        .to eq(node_set(@a1, @b1, @c1))
     end
 
     it 'merges three identical sets' do
-      evaluate_xpath(@document, 'root/a | root/a | root/a')
-        .should == node_set(@a1)
+      expect(evaluate_xpath(@document, 'root/a | root/a | root/a'))
+        .to eq(node_set(@a1))
     end
 
     it 'merges two non-empty sets in a predicate' do
-      evaluate_xpath(@document, 'root[a | b]').should == node_set(@root)
+      expect(evaluate_xpath(@document, 'root[a | b]')).to eq(node_set(@root))
     end
 
     it 'merges three non-empty sets in a predicate' do
-      evaluate_xpath(@document, 'root[a | b | c]').should == node_set(@root)
+      expect(evaluate_xpath(@document, 'root[a | b | c]')).to eq(node_set(@root))
     end
 
     it 'merges two empty sets in a predicate' do
-      evaluate_xpath(@document, 'root[x | y]').should == node_set
+      expect(evaluate_xpath(@document, 'root[x | y]')).to eq(node_set)
     end
 
     it 'merges three empty sets in a predicate' do
-      evaluate_xpath(@document, 'root[x | y | z]').should == node_set
+      expect(evaluate_xpath(@document, 'root[x | y | z]')).to eq(node_set)
     end
   end
 end
diff --git a/spec/oga/xpath/compiler/operators/sub_spec.rb b/spec/oga/xpath/compiler/operators/sub_spec.rb
index 4df3d46..4240c90 100644
--- a/spec/oga/xpath/compiler/operators/sub_spec.rb
+++ b/spec/oga/xpath/compiler/operators/sub_spec.rb
@@ -7,27 +7,27 @@ describe Oga::XPath::Compiler do
     end
 
     it 'subtracts two numbers' do
-      evaluate_xpath(@document, '2 - 3').should == -1.0
+      expect(evaluate_xpath(@document, '2 - 3')).to eq(-1.0)
     end
 
     it 'subtracts a number and a string' do
-      evaluate_xpath(@document, '2 - "3"').should == -1.0
+      expect(evaluate_xpath(@document, '2 - "3"')).to eq(-1.0)
     end
 
     it 'subtracts two strings' do
-      evaluate_xpath(@document, '"2" - "3"').should == -1.0
+      expect(evaluate_xpath(@document, '"2" - "3"')).to eq(-1.0)
     end
 
     it 'subtracts a node set and a number' do
-      evaluate_xpath(@document, 'root/a - 3').should == -1.0
+      expect(evaluate_xpath(@document, 'root/a - 3')).to eq(-1.0)
     end
 
     it 'subtracts two node sets' do
-      evaluate_xpath(@document, 'root/a - root/b').should == -1.0
+      expect(evaluate_xpath(@document, 'root/a - root/b')).to eq(-1.0)
     end
 
     it 'returns NaN when trying to subtract invalid values' do
-      evaluate_xpath(@document, '"" - 1').should be_nan
+      expect(evaluate_xpath(@document, '"" - 1')).to be_nan
     end
   end
 end
diff --git a/spec/oga/xpath/compiler/paths_spec.rb b/spec/oga/xpath/compiler/paths_spec.rb
index 0b4745d..2f00413 100644
--- a/spec/oga/xpath/compiler/paths_spec.rb
+++ b/spec/oga/xpath/compiler/paths_spec.rb
@@ -12,49 +12,49 @@ describe Oga::XPath::Compiler do
   describe 'relative to a document' do
     describe '/a' do
       it 'returns a NodeSet' do
-        evaluate_xpath(@document).should == node_set(@a1)
+        expect(evaluate_xpath(@document)).to eq(node_set(@a1))
       end
     end
 
     describe '/A' do
       it 'returns a NodeSet' do
-        evaluate_xpath(@document).should == node_set(@a1)
+        expect(evaluate_xpath(@document)).to eq(node_set(@a1))
       end
     end
 
     describe '/' do
       it 'returns a NodeSet' do
-        evaluate_xpath(@document).should == node_set(@document)
+        expect(evaluate_xpath(@document)).to eq(node_set(@document))
       end
     end
 
     describe 'a' do
       it 'returns a NodeSet' do
-        evaluate_xpath(@document).should == node_set(@a1)
+        expect(evaluate_xpath(@document)).to eq(node_set(@a1))
       end
     end
 
     describe 'x/a' do
       it 'returns a NodeSet' do
-        evaluate_xpath(@document).should == node_set
+        expect(evaluate_xpath(@document)).to eq(node_set)
       end
     end
 
     describe '/a/b' do
       it 'returns a NodeSet' do
-        evaluate_xpath(@document).should == node_set(@b1, @b2)
+        expect(evaluate_xpath(@document)).to eq(node_set(@b1, @b2))
       end
     end
 
     describe '/x/a' do
       it 'returns a NodeSet' do
-        evaluate_xpath(@document).should == node_set
+        expect(evaluate_xpath(@document)).to eq(node_set)
       end
     end
 
     describe 'a/ns1:c' do
       it 'returns a NodeSet' do
-        evaluate_xpath(@document).should == node_set(@a1.children[-1])
+        expect(evaluate_xpath(@document)).to eq(node_set(@a1.children[-1]))
       end
     end
   end
@@ -64,7 +64,7 @@ describe Oga::XPath::Compiler do
       it 'returns a NodeSet' do
         b_node = @document.children[0].children[0]
 
-        evaluate_xpath(b_node, '/a').should == node_set(@a1)
+        expect(evaluate_xpath(b_node, '/a')).to eq(node_set(@a1))
       end
     end
   end
diff --git a/spec/oga/xpath/compiler/predicates_spec.rb b/spec/oga/xpath/compiler/predicates_spec.rb
index 40a4be8..a118d79 100644
--- a/spec/oga/xpath/compiler/predicates_spec.rb
+++ b/spec/oga/xpath/compiler/predicates_spec.rb
@@ -13,19 +13,19 @@ describe Oga::XPath::Compiler do
   describe 'relative to a document' do
     describe 'root/a[1]' do
       it 'returns a NodeSet' do
-        evaluate_xpath(@document).should == node_set(@a1)
+        expect(evaluate_xpath(@document)).to eq(node_set(@a1))
       end
     end
 
     describe 'root/a[1.5]' do
       it 'returns a NodeSet' do
-        evaluate_xpath(@document).should == node_set(@a1)
+        expect(evaluate_xpath(@document)).to eq(node_set(@a1))
       end
     end
 
     describe 'root/a[b]' do
       it 'returns a NodeSet' do
-        evaluate_xpath(@document).should == node_set(@a2)
+        expect(evaluate_xpath(@document)).to eq(node_set(@a2))
       end
     end
   end
diff --git a/spec/oga/xpath/compiler/type_tests/comment_spec.rb b/spec/oga/xpath/compiler/type_tests/comment_spec.rb
index abdd7e0..1e879a7 100644
--- a/spec/oga/xpath/compiler/type_tests/comment_spec.rb
+++ b/spec/oga/xpath/compiler/type_tests/comment_spec.rb
@@ -11,13 +11,13 @@ describe Oga::XPath::Compiler do
   describe 'relative to a document' do
     describe 'a/comment()' do
       it 'returns a NodeSet' do
-        evaluate_xpath(@document).should == node_set(@comment1)
+        expect(evaluate_xpath(@document)).to eq(node_set(@comment1))
       end
     end
 
     describe 'a/b/comment()' do
       it 'returns a NodeSet' do
-        evaluate_xpath(@document).should == node_set(@comment2)
+        expect(evaluate_xpath(@document)).to eq(node_set(@comment2))
       end
     end
   end
diff --git a/spec/oga/xpath/compiler/type_tests/node_spec.rb b/spec/oga/xpath/compiler/type_tests/node_spec.rb
index cd4e65a..c06b35f 100644
--- a/spec/oga/xpath/compiler/type_tests/node_spec.rb
+++ b/spec/oga/xpath/compiler/type_tests/node_spec.rb
@@ -13,25 +13,25 @@ describe Oga::XPath::Compiler do
   describe 'relative to a document' do
     describe 'node()' do
       it 'returns a NodeSet' do
-        evaluate_xpath(@document).should == node_set(@a1)
+        expect(evaluate_xpath(@document)).to eq(node_set(@a1))
       end
     end
 
     describe 'a/node()' do
       it 'returns a NodeSet' do
-        evaluate_xpath(@document).should == node_set(@b1, @comment1, @cdata1)
+        expect(evaluate_xpath(@document)).to eq(node_set(@b1, @comment1, @cdata1))
       end
     end
 
     describe 'a/b/node()' do
       it 'returns NodeSet' do
-        evaluate_xpath(@document).should == node_set(@b1.children[0])
+        expect(evaluate_xpath(@document)).to eq(node_set(@b1.children[0]))
       end
     end
 
     describe 'node()/b' do
       it 'returns a NodeSet' do
-        evaluate_xpath(@document).should == node_set(@b1)
+        expect(evaluate_xpath(@document)).to eq(node_set(@b1))
       end
     end
   end
diff --git a/spec/oga/xpath/compiler/type_tests/processing_instruction_spec.rb b/spec/oga/xpath/compiler/type_tests/processing_instruction_spec.rb
index 6d9e4c6..0db731c 100644
--- a/spec/oga/xpath/compiler/type_tests/processing_instruction_spec.rb
+++ b/spec/oga/xpath/compiler/type_tests/processing_instruction_spec.rb
@@ -12,13 +12,13 @@ describe Oga::XPath::Compiler do
     describe 'relative to a document' do
       describe 'a/processing-instruction()' do
         it 'returns a NodeSet' do
-          evaluate_xpath(@document).should == node_set(@proc_ins1)
+          expect(evaluate_xpath(@document)).to eq(node_set(@proc_ins1))
         end
       end
 
       describe 'a/b/processing-instruction()' do
         it 'returns a NodeSet' do
-          evaluate_xpath(@document).should == node_set(@proc_ins2)
+          expect(evaluate_xpath(@document)).to eq(node_set(@proc_ins2))
         end
       end
     end
@@ -29,8 +29,8 @@ describe Oga::XPath::Compiler do
       document = parse('<root><?xml version="1.0" ?></root>')
       xml_decl = document.children[0].children[0]
 
-      evaluate_xpath(document, 'root/processing-instruction()')
-        .should == node_set(xml_decl)
+      expect(evaluate_xpath(document, 'root/processing-instruction()'))
+        .to eq(node_set(xml_decl))
     end
   end
 end
diff --git a/spec/oga/xpath/compiler/type_tests/text_spec.rb b/spec/oga/xpath/compiler/type_tests/text_spec.rb
index 11de6c0..406e04f 100644
--- a/spec/oga/xpath/compiler/type_tests/text_spec.rb
+++ b/spec/oga/xpath/compiler/type_tests/text_spec.rb
@@ -11,13 +11,13 @@ describe Oga::XPath::Compiler do
   describe 'relative to a document' do
     describe 'a/text()' do
       it 'returns a NodeSet' do
-        evaluate_xpath(@document).should == node_set(@text1)
+        expect(evaluate_xpath(@document)).to eq(node_set(@text1))
       end
     end
 
     describe 'a/b/text()' do
       it 'returns a NodeSet' do
-        evaluate_xpath(@document).should == node_set(@text2)
+        expect(evaluate_xpath(@document)).to eq(node_set(@text2))
       end
     end
   end
diff --git a/spec/oga/xpath/compiler/types/float_spec.rb b/spec/oga/xpath/compiler/types/float_spec.rb
index cd0a0b6..34fe875 100644
--- a/spec/oga/xpath/compiler/types/float_spec.rb
+++ b/spec/oga/xpath/compiler/types/float_spec.rb
@@ -7,15 +7,15 @@ describe Oga::XPath::Compiler do
     end
 
     it 'returns a float' do
-      evaluate_xpath(@document, '1.2').should == 1.2
+      expect(evaluate_xpath(@document, '1.2')).to eq(1.2)
     end
 
     it 'returns a negative float' do
-      evaluate_xpath(@document, '-1.2').should == -1.2
+      expect(evaluate_xpath(@document, '-1.2')).to eq(-1.2)
     end
 
     it 'returns floats as a Float' do
-      evaluate_xpath(@document, '1.2').is_a?(Float).should == true
+      expect(evaluate_xpath(@document, '1.2').is_a?(Float)).to eq(true)
     end
   end
 end
diff --git a/spec/oga/xpath/compiler/types/int_spec.rb b/spec/oga/xpath/compiler/types/int_spec.rb
index f03b7bb..e752720 100644
--- a/spec/oga/xpath/compiler/types/int_spec.rb
+++ b/spec/oga/xpath/compiler/types/int_spec.rb
@@ -7,15 +7,15 @@ describe Oga::XPath::Compiler do
     end
 
     it 'returns an integer' do
-      evaluate_xpath(@document, '1').should == 1
+      expect(evaluate_xpath(@document, '1')).to eq(1)
     end
 
     it 'returns a negative integer' do
-      evaluate_xpath(@document, '-2').should == -2
+      expect(evaluate_xpath(@document, '-2')).to eq(-2)
     end
 
     it 'returns integers as a Float' do
-      evaluate_xpath(@document, '1').is_a?(Float).should == true
+      expect(evaluate_xpath(@document, '1').is_a?(Float)).to eq(true)
     end
   end
 end
diff --git a/spec/oga/xpath/compiler/types/string_spec.rb b/spec/oga/xpath/compiler/types/string_spec.rb
index d4ac449..4f45c2c 100644
--- a/spec/oga/xpath/compiler/types/string_spec.rb
+++ b/spec/oga/xpath/compiler/types/string_spec.rb
@@ -7,7 +7,7 @@ describe Oga::XPath::Compiler do
     end
 
     it 'returns the literal string' do
-      evaluate_xpath(@document, '"foo"').should == 'foo'
+      expect(evaluate_xpath(@document, '"foo"')).to eq('foo')
     end
   end
 end
diff --git a/spec/oga/xpath/compiler/variables_spec.rb b/spec/oga/xpath/compiler/variables_spec.rb
index 753843d..1f19207 100644
--- a/spec/oga/xpath/compiler/variables_spec.rb
+++ b/spec/oga/xpath/compiler/variables_spec.rb
@@ -2,27 +2,25 @@ require 'spec_helper'
 
 describe Oga::XPath::Compiler do
   describe 'using variable bindings' do
-    before do
-      @document = parse('<a></a>')
-      @compiler = described_class.new
-    end
+    let(:document) { parse('<a></a>') }
+    let(:compiler) { described_class.new }
 
     describe 'when a variable is defined' do
       it 'returns the value of a variable' do
         ast   = parse_xpath('$number')
-        block = @compiler.compile(ast)
+        block = compiler.compile(ast)
 
-        block.call(@document, 'number' => 10.0).should == 10.0
+        expect(block.call(document, 'number' => 10.0)).to eq(10.0)
       end
     end
 
     describe 'when a variable is undefined' do
       it 'raises RuntimeError' do
         ast   = parse_xpath('$number')
-        block = @compiler.compile(ast)
+        block = compiler.compile(ast)
 
-        proc { block.call(@document) }.should
-          raise_error 'Undefined XPath variable: number'
+        expect { block.call(document) }
+          .to raise_error('Undefined XPath variable: number')
       end
     end
   end
diff --git a/spec/oga/xpath/compiler/wildcard_spec.rb b/spec/oga/xpath/compiler/wildcard_spec.rb
index 19ea2f6..c3e8066 100644
--- a/spec/oga/xpath/compiler/wildcard_spec.rb
+++ b/spec/oga/xpath/compiler/wildcard_spec.rb
@@ -13,25 +13,25 @@ describe Oga::XPath::Compiler do
   describe 'relative to a document' do
     describe 'a/*' do
       it 'returns a NodeSet' do
-        evaluate_xpath(@document).should == @a1.children
+        expect(evaluate_xpath(@document)).to eq(@a1.children)
       end
     end
 
     describe 'a/*:b' do
       it 'returns a NodeSet' do
-        evaluate_xpath(@document).should == node_set(@b1, @b2)
+        expect(evaluate_xpath(@document)).to eq(node_set(@b1, @b2))
       end
     end
 
     describe 'a/ns1:*' do
       it 'returns a NodeSet' do
-        evaluate_xpath(@document).should == node_set(@c1)
+        expect(evaluate_xpath(@document)).to eq(node_set(@c1))
       end
     end
 
     describe 'a/*:*' do
       it 'returns a NodeSet' do
-        evaluate_xpath(@document).should == @a1.children
+        expect(evaluate_xpath(@document)).to eq(@a1.children)
       end
     end
   end
diff --git a/spec/oga/xpath/compiler_spec.rb b/spec/oga/xpath/compiler_spec.rb
index d982672..f3e9ea7 100644
--- a/spec/oga/xpath/compiler_spec.rb
+++ b/spec/oga/xpath/compiler_spec.rb
@@ -14,20 +14,20 @@ describe Oga::XPath::Compiler do
       ast   = parse_xpath('foo')
       block = described_class.compile_with_cache(ast)
 
-      block.should be_an_instance_of(Proc)
-      block.lambda?.should == true
+      expect(block).to be_an_instance_of(Proc)
+      expect(block.lambda?).to eq(true)
     end
 
     it 'caches a compiled Proc' do
       ast = parse_xpath('foo')
 
-      described_class.any_instance
-        .should_receive(:compile)
+      expect_any_instance_of(described_class)
+        .to receive(:compile)
         .once
         .and_call_original
 
-      described_class.compile_with_cache(ast).should be_an_instance_of(Proc)
-      described_class.compile_with_cache(ast).should be_an_instance_of(Proc)
+      expect(described_class.compile_with_cache(ast)).to be_an_instance_of(Proc)
+      expect(described_class.compile_with_cache(ast)).to be_an_instance_of(Proc)
     end
   end
 
@@ -36,8 +36,8 @@ describe Oga::XPath::Compiler do
       ast   = parse_xpath('foo')
       block = @compiler.compile(ast)
 
-      block.should be_an_instance_of(Proc)
-      block.lambda?.should == true
+      expect(block).to be_an_instance_of(Proc)
+      expect(block.lambda?).to eq(true)
     end
 
     describe 'calling the compiled Proc' do
@@ -46,7 +46,7 @@ describe Oga::XPath::Compiler do
         ast   = parse_xpath('foo')
         block = @compiler.compile(ast)
 
-        block.call(doc).should be_an_instance_of(Oga::XML::NodeSet)
+        expect(block.call(doc)).to be_an_instance_of(Oga::XML::NodeSet)
       end
     end
 
@@ -64,7 +64,7 @@ describe Oga::XPath::Compiler do
 
             binding_context = block.binding.send(binding_method)
 
-            binding_context.should be_an_instance_of(Oga::XPath::Context)
+            expect(binding_context).to be_an_instance_of(Oga::XPath::Context)
           end
         end
 
diff --git a/spec/oga/xpath/context_spec.rb b/spec/oga/xpath/context_spec.rb
index 6c9ca98..cca8278 100644
--- a/spec/oga/xpath/context_spec.rb
+++ b/spec/oga/xpath/context_spec.rb
@@ -5,7 +5,7 @@ describe Oga::XPath::Context do
     it 'returns the result of eval()' do
       context = described_class.new
 
-      context.evaluate('10').should == 10
+      expect(context.evaluate('10')).to eq(10)
     end
 
     describe 'assigning a variable in a lambda' do
diff --git a/spec/oga/xpath/conversion_spec.rb b/spec/oga/xpath/conversion_spec.rb
index 2b0ad5a..52288a2 100644
--- a/spec/oga/xpath/conversion_spec.rb
+++ b/spec/oga/xpath/conversion_spec.rb
@@ -8,8 +8,8 @@ describe Oga::XPath::Conversion do
 
       left, right = described_class.to_compatible_types(set1, set2)
 
-      left.should  == 'foo'
-      right.should == 'bar'
+      expect(left).to  eq('foo')
+      expect(right).to eq('bar')
     end
 
     it 'returns two Strings when using two Nodes' do
@@ -18,8 +18,8 @@ describe Oga::XPath::Conversion do
 
       left, right = described_class.to_compatible_types(n1, n2)
 
-      left.should  == 'foo'
-      right.should == 'bar'
+      expect(left).to  eq('foo')
+      expect(right).to eq('bar')
     end
 
     it 'returns two Strings when using two Attributes' do
@@ -28,8 +28,8 @@ describe Oga::XPath::Conversion do
 
       left, right = described_class.to_compatible_types(n1, n2)
 
-      left.should  == 'foo'
-      right.should == 'bar'
+      expect(left).to  eq('foo')
+      expect(right).to eq('bar')
     end
 
     it 'returns two Strings when using a NodeSet and Float' do
@@ -37,8 +37,8 @@ describe Oga::XPath::Conversion do
 
       left, right = described_class.to_compatible_types(set, 10.5)
 
-      left.should  == 'foo'
-      right.should == '10.5'
+      expect(left).to  eq('foo')
+      expect(right).to eq('10.5')
     end
 
     it 'returns two Floats when using a Float and NodeSet' do
@@ -46,36 +46,36 @@ describe Oga::XPath::Conversion do
 
       left, right = described_class.to_compatible_types(10.5, set)
 
-      left.should  == 10.5
-      right.should == 20.0
+      expect(left).to  eq(10.5)
+      expect(right).to eq(20.0)
     end
 
     it 'returns two Strings when using a String and a Float' do
       left, right = described_class.to_compatible_types('foo', 10.5)
 
-      left.should  == 'foo'
-      right.should == '10.5'
+      expect(left).to  eq('foo')
+      expect(right).to eq('10.5')
     end
 
     it 'returns two booleans when using a boolean and a non-zero Fixnum' do
       left, right = described_class.to_compatible_types(true, 10)
 
-      left.should  == true
-      right.should == true
+      expect(left).to  eq(true)
+      expect(right).to eq(true)
     end
 
     it 'returns two booleans when using a boolean and 0' do
       left, right = described_class.to_compatible_types(true, 0)
 
-      left.should  == true
-      right.should == false
+      expect(left).to  eq(true)
+      expect(right).to eq(false)
     end
 
     it 'returns two booleans when using a boolean and a negative Fixnum' do
       left, right = described_class.to_compatible_types(true, -5)
 
-      left.should  == true
-      right.should == true
+      expect(left).to  eq(true)
+      expect(right).to eq(true)
     end
 
     it 'returns two booleans when using a boolean and a non-empty NodeSet' do
@@ -83,8 +83,8 @@ describe Oga::XPath::Conversion do
 
       left, right = described_class.to_compatible_types(true, set)
 
-      left.should  == true
-      right.should == true
+      expect(left).to  eq(true)
+      expect(right).to eq(true)
     end
 
     it 'returns two booleans when using a boolean and an empty NodeSet' do
@@ -92,19 +92,19 @@ describe Oga::XPath::Conversion do
 
       left, right = described_class.to_compatible_types(true, set)
 
-      left.should  == true
-      right.should == false
+      expect(left).to  eq(true)
+      expect(right).to eq(false)
     end
   end
 
   describe 'to_string' do
     describe 'using a Float' do
       it 'converts 10.0 to a String' do
-        described_class.to_string(10.0).should == '10'
+        expect(described_class.to_string(10.0)).to eq('10')
       end
 
       it 'converts 10.5 to a String' do
-        described_class.to_string(10.5).should == '10.5'
+        expect(described_class.to_string(10.5)).to eq('10.5')
       end
     end
 
@@ -113,13 +113,13 @@ describe Oga::XPath::Conversion do
         node = Oga::XML::Element.new(:name => 'p')
         node.inner_text = 'foo'
 
-        described_class.to_string(node).should == 'foo'
+        expect(described_class.to_string(node)).to eq('foo')
       end
 
       it 'converts a Text to a String' do
         node = Oga::XML::Text.new(:text => 'foo')
 
-        described_class.to_string(node).should == 'foo'
+        expect(described_class.to_string(node)).to eq('foo')
       end
     end
 
@@ -129,17 +129,17 @@ describe Oga::XPath::Conversion do
         node2 = Oga::XML::Text.new(:text => 'bar')
         set   = node_set(node1, node2)
 
-        described_class.to_string(set).should == 'foo'
+        expect(described_class.to_string(set)).to eq('foo')
       end
 
       it 'returns an empty String for an empty NodeSet' do
-        described_class.to_string(node_set).should == ''
+        expect(described_class.to_string(node_set)).to eq('')
       end
     end
 
     describe 'using a Fixnum' do
       it 'converts 10 to a String' do
-        described_class.to_string(10).should == '10'
+        expect(described_class.to_string(10)).to eq('10')
       end
     end
   end
@@ -147,17 +147,17 @@ describe Oga::XPath::Conversion do
   describe 'to_float' do
     describe 'using a Float' do
       it 'returns the input Float' do
-        described_class.to_float(10.5).should == 10.5
+        expect(described_class.to_float(10.5)).to eq(10.5)
       end
     end
 
     describe 'using a String' do
       it 'returns a Float for a valid value' do
-        described_class.to_float('10.5').should == 10.5
+        expect(described_class.to_float('10.5')).to eq(10.5)
       end
 
       it 'returns Float::NAN for an invalid value' do
-        described_class.to_float('foo').nan?.should == true
+        expect(described_class.to_float('foo').nan?).to eq(true)
       end
     end
 
@@ -165,7 +165,7 @@ describe Oga::XPath::Conversion do
       it 'returns a Float using the text of the first node' do
         set = node_set(Oga::XML::Text.new(:text => '10.5'))
 
-        described_class.to_float(set).should == 10.5
+        expect(described_class.to_float(set)).to eq(10.5)
       end
     end
 
@@ -173,76 +173,76 @@ describe Oga::XPath::Conversion do
       it 'returns a Float using the text of the node' do
         node = Oga::XML::Text.new(:text => '10.5')
 
-        described_class.to_float(node).should == 10.5
+        expect(described_class.to_float(node)).to eq(10.5)
       end
     end
 
     describe 'using a NilClass' do
       it 'returns Float::NAN' do
-        described_class.to_float(nil).should be_nan
+        expect(described_class.to_float(nil)).to be_nan
       end
     end
 
     describe 'using a TrueClass' do
       it 'returns 1.0' do
-        described_class.to_float(true).should == 1.0
+        expect(described_class.to_float(true)).to eq(1.0)
       end
     end
 
     describe 'using a FalseClass' do
       it 'returns 0.0' do
-        described_class.to_float(false).should == 0.0
+        expect(described_class.to_float(false)).to eq(0.0)
       end
     end
   end
 
   describe 'to_boolean' do
     it 'returns true for a non-empty String' do
-      described_class.to_boolean('foo').should == true
+      expect(described_class.to_boolean('foo')).to eq(true)
     end
 
     it 'returns false for an empty String' do
-      described_class.to_boolean('').should == false
+      expect(described_class.to_boolean('')).to eq(false)
     end
 
     it 'returns true for a positive Fixnum' do
-      described_class.to_boolean(10).should == true
+      expect(described_class.to_boolean(10)).to eq(true)
     end
 
     it 'returns true for a positive Float' do
-      described_class.to_boolean(10.0).should == true
+      expect(described_class.to_boolean(10.0)).to eq(true)
     end
 
     it 'returns true for a negative Fixnum' do
-      described_class.to_boolean(-10).should == true
+      expect(described_class.to_boolean(-10)).to eq(true)
     end
 
     it 'returns true for a negative Float' do
-      described_class.to_boolean(-10.0).should == true
+      expect(described_class.to_boolean(-10.0)).to eq(true)
     end
 
     it 'returns false for 0' do
-      described_class.to_boolean(0).should == false
+      expect(described_class.to_boolean(0)).to eq(false)
     end
 
     it 'returns false for 0.0' do
-      described_class.to_boolean(0.0).should == false
+      expect(described_class.to_boolean(0.0)).to eq(false)
     end
 
     it 'returns true for a non-empty NodeSet' do
       set = node_set(Oga::XML::Node.new)
 
-      described_class.to_boolean(set).should == true
+      expect(described_class.to_boolean(set)).to eq(true)
     end
 
     it 'returns false for an empty NodeSet' do
-      described_class.to_boolean(node_set).should == false
+      expect(described_class.to_boolean(node_set)).to eq(false)
     end
 
     it 'returns true for an Element' do
       element = Oga::XML::Element.new(:name => 'foo')
 
-      described_class.to_boolean(element).should == true
+      expect(described_class.to_boolean(element)).to eq(true)
     end
   end
 end
diff --git a/spec/oga/xpath/lexer/axes_spec.rb b/spec/oga/xpath/lexer/axes_spec.rb
index 196bfcf..3f784ac 100644
--- a/spec/oga/xpath/lexer/axes_spec.rb
+++ b/spec/oga/xpath/lexer/axes_spec.rb
@@ -3,152 +3,152 @@ require 'spec_helper'
 describe Oga::XPath::Lexer do
   describe 'full axes' do
     it 'lexes the ancestor axis' do
-      lex_xpath('/ancestor::A').should == [
+      expect(lex_xpath('/ancestor::A')).to eq([
         [:T_SLASH, nil],
         [:T_AXIS, 'ancestor'],
         [:T_IDENT, 'A']
-      ]
+      ])
     end
 
     it 'lexes the ancestor-or-self axis' do
-      lex_xpath('/ancestor-or-self::A').should == [
+      expect(lex_xpath('/ancestor-or-self::A')).to eq([
         [:T_SLASH, nil],
         [:T_AXIS, 'ancestor-or-self'],
         [:T_IDENT, 'A'],
-      ]
+      ])
     end
 
     it 'lexes the attribute axis' do
-      lex_xpath('/attribute::class').should == [
+      expect(lex_xpath('/attribute::class')).to eq([
         [:T_SLASH, nil],
         [:T_AXIS, 'attribute'],
         [:T_IDENT, 'class'],
-      ]
+      ])
     end
 
     it 'lexes the child axis' do
-      lex_xpath('/child::A').should == [
+      expect(lex_xpath('/child::A')).to eq([
         [:T_SLASH, nil],
         [:T_AXIS, 'child'],
         [:T_IDENT, 'A'],
-      ]
+      ])
     end
 
     it 'lexes the descendant axis' do
-      lex_xpath('/descendant::A').should == [
+      expect(lex_xpath('/descendant::A')).to eq([
         [:T_SLASH, nil],
         [:T_AXIS, 'descendant'],
         [:T_IDENT, 'A'],
-      ]
+      ])
     end
 
     it 'lexes the descendant-or-self axis' do
-      lex_xpath('/descendant-or-self::A').should == [
+      expect(lex_xpath('/descendant-or-self::A')).to eq([
         [:T_SLASH, nil],
         [:T_AXIS, 'descendant-or-self'],
         [:T_IDENT, 'A'],
-      ]
+      ])
     end
 
     it 'lexes the following axis' do
-      lex_xpath('/following::A').should == [
+      expect(lex_xpath('/following::A')).to eq([
         [:T_SLASH, nil],
         [:T_AXIS, 'following'],
         [:T_IDENT, 'A'],
-      ]
+      ])
     end
 
     it 'lexes the following-sibling axis' do
-      lex_xpath('/following-sibling::A').should == [
+      expect(lex_xpath('/following-sibling::A')).to eq([
         [:T_SLASH, nil],
         [:T_AXIS, 'following-sibling'],
         [:T_IDENT, 'A'],
-      ]
+      ])
     end
 
     it 'lexes the namespace axis' do
-      lex_xpath('/namespace::A').should == [
+      expect(lex_xpath('/namespace::A')).to eq([
         [:T_SLASH, nil],
         [:T_AXIS, 'namespace'],
         [:T_IDENT, 'A'],
-      ]
+      ])
     end
 
     it 'lexes the parent axis' do
-      lex_xpath('/parent::A').should == [
+      expect(lex_xpath('/parent::A')).to eq([
         [:T_SLASH, nil],
         [:T_AXIS, 'parent'],
         [:T_IDENT, 'A'],
-      ]
+      ])
     end
 
     it 'lexes the preceding axis' do
-      lex_xpath('/preceding::A').should == [
+      expect(lex_xpath('/preceding::A')).to eq([
         [:T_SLASH, nil],
         [:T_AXIS, 'preceding'],
         [:T_IDENT, 'A'],
-      ]
+      ])
     end
 
     it 'lexes the preceding-sibling axis' do
-      lex_xpath('/preceding-sibling::A').should == [
+      expect(lex_xpath('/preceding-sibling::A')).to eq([
         [:T_SLASH, nil],
         [:T_AXIS, 'preceding-sibling'],
         [:T_IDENT, 'A'],
-      ]
+      ])
     end
 
     it 'lexes the self axis' do
-      lex_xpath('/self::A').should == [
+      expect(lex_xpath('/self::A')).to eq([
         [:T_SLASH, nil],
         [:T_AXIS, 'self'],
         [:T_IDENT, 'A'],
-      ]
+      ])
     end
   end
 
   describe 'short axes' do
     it 'lexes the @attribute axis' do
-      lex_xpath('/@A').should == [
+      expect(lex_xpath('/@A')).to eq([
         [:T_SLASH, nil],
         [:T_AXIS, 'attribute'],
         [:T_IDENT, 'A']
-      ]
+      ])
     end
 
     it 'lexes the // axis' do
-      lex_xpath('//A').should == [
+      expect(lex_xpath('//A')).to eq([
         [:T_SLASH, nil],
         [:T_AXIS, 'descendant-or-self'],
         [:T_TYPE_TEST, 'node'],
         [:T_SLASH, nil],
         [:T_IDENT, 'A']
-      ]
+      ])
     end
 
     it 'lexes the .. axis' do
-      lex_xpath('/..').should == [
+      expect(lex_xpath('/..')).to eq([
         [:T_SLASH, nil],
         [:T_AXIS, 'parent'],
         [:T_TYPE_TEST, 'node']
-      ]
+      ])
     end
 
     it 'lexes the . axis' do
-      lex_xpath('/.').should == [
+      expect(lex_xpath('/.')).to eq([
         [:T_SLASH, nil],
         [:T_AXIS, 'self'],
         [:T_TYPE_TEST, 'node']
-      ]
+      ])
     end
 
     it 'lexes the . axis followed by a path' do
-      lex_xpath('./foo').should == [
+      expect(lex_xpath('./foo')).to eq([
         [:T_AXIS, 'self'],
         [:T_TYPE_TEST, 'node'],
         [:T_SLASH, nil],
         [:T_IDENT, 'foo']
-      ]
+      ])
     end
   end
 end
diff --git a/spec/oga/xpath/lexer/calls_spec.rb b/spec/oga/xpath/lexer/calls_spec.rb
index 25e2f39..3f8e7ed 100644
--- a/spec/oga/xpath/lexer/calls_spec.rb
+++ b/spec/oga/xpath/lexer/calls_spec.rb
@@ -3,24 +3,24 @@ require 'spec_helper'
 describe Oga::XPath::Lexer do
   describe 'function calls' do
     it 'lexes a function call without arguments' do
-      lex_xpath('count()').should == [
+      expect(lex_xpath('count()')).to eq([
         [:T_IDENT, 'count'],
         [:T_LPAREN, nil],
         [:T_RPAREN, nil]
-      ]
+      ])
     end
 
     it 'lexes a function call with a single argument' do
-      lex_xpath('count(foo)').should == [
+      expect(lex_xpath('count(foo)')).to eq([
         [:T_IDENT, 'count'],
         [:T_LPAREN, nil],
         [:T_IDENT, 'foo'],
         [:T_RPAREN, nil]
-      ]
+      ])
     end
 
     it 'lexes a function call with two arguments' do
-      lex_xpath('count(/foo, "bar")').should == [
+      expect(lex_xpath('count(/foo, "bar")')).to eq([
         [:T_IDENT, 'count'],
         [:T_LPAREN, nil],
         [:T_SLASH, nil],
@@ -28,7 +28,7 @@ describe Oga::XPath::Lexer do
         [:T_COMMA, nil],
         [:T_STRING, 'bar'],
         [:T_RPAREN, nil]
-      ]
+      ])
     end
   end
 end
diff --git a/spec/oga/xpath/lexer/floats_spec.rb b/spec/oga/xpath/lexer/floats_spec.rb
index d721dc0..d86a96e 100644
--- a/spec/oga/xpath/lexer/floats_spec.rb
+++ b/spec/oga/xpath/lexer/floats_spec.rb
@@ -3,11 +3,11 @@ require 'spec_helper'
 describe Oga::XPath::Lexer do
   describe 'floats' do
     it 'lexes a float' do
-      lex_xpath('10.0').should == [[:T_FLOAT, 10.0]]
+      expect(lex_xpath('10.0')).to eq([[:T_FLOAT, 10.0]])
     end
 
     it 'lexes a negative float' do
-      lex_xpath('-10.0').should == [[:T_FLOAT, -10.0]]
+      expect(lex_xpath('-10.0')).to eq([[:T_FLOAT, -10.0]])
     end
   end
 end
diff --git a/spec/oga/xpath/lexer/general_spec.rb b/spec/oga/xpath/lexer/general_spec.rb
index 37648d0..60d8cce 100644
--- a/spec/oga/xpath/lexer/general_spec.rb
+++ b/spec/oga/xpath/lexer/general_spec.rb
@@ -5,52 +5,52 @@ require 'spec_helper'
 describe Oga::XPath::Lexer do
   describe 'general' do
     it 'lexes a simple expression' do
-      lex_xpath('/foo').should == [[:T_SLASH, nil], [:T_IDENT, 'foo']]
+      expect(lex_xpath('/foo')).to eq([[:T_SLASH, nil], [:T_IDENT, 'foo']])
     end
 
     it 'lexes an expression using Unicode identifiers' do
-      lex_xpath('fóó').should == [[:T_IDENT, 'fóó']]
+      expect(lex_xpath('fóó')).to eq([[:T_IDENT, 'fóó']])
     end
 
     it 'lexes an expression using Unicode plus ASCII identifiers' do
-      lex_xpath('fóóbar').should == [[:T_IDENT, 'fóóbar']]
+      expect(lex_xpath('fóóbar')).to eq([[:T_IDENT, 'fóóbar']])
     end
 
     it 'lexes an expression using an identifier with a dot' do
-      lex_xpath('foo.bar').should == [[:T_IDENT, 'foo.bar']]
+      expect(lex_xpath('foo.bar')).to eq([[:T_IDENT, 'foo.bar']])
     end
 
     it 'lexes a simple expression with a test starting with an underscore' do
-      lex_xpath('/_foo').should == [[:T_SLASH, nil], [:T_IDENT, '_foo']]
+      expect(lex_xpath('/_foo')).to eq([[:T_SLASH, nil], [:T_IDENT, '_foo']])
     end
 
     it 'lexes a node test using a namespace' do
-      lex_xpath('/foo:bar').should == [
+      expect(lex_xpath('/foo:bar')).to eq([
         [:T_SLASH, nil],
         [:T_IDENT, 'foo'],
         [:T_COLON, nil],
         [:T_IDENT, 'bar']
-      ]
+      ])
     end
 
     it 'lexes a whildcard node test' do
-      lex_xpath('/*').should == [[:T_SLASH, nil], [:T_IDENT, '*']]
+      expect(lex_xpath('/*')).to eq([[:T_SLASH, nil], [:T_IDENT, '*']])
     end
 
     it 'lexes a wildcard node test for a namespace' do
-      lex_xpath('/*:foo').should == [
+      expect(lex_xpath('/*:foo')).to eq([
         [:T_SLASH, nil],
         [:T_IDENT, '*'],
         [:T_COLON, nil],
         [:T_IDENT, 'foo']
-      ]
+      ])
     end
 
     # The following are a bunch of examples taken from Wikipedia and the W3
     # spec to see how the lexer handles them.
 
     it 'lexes an descendant-or-self expression' do
-      lex_xpath('/wikimedia//editions').should == [
+      expect(lex_xpath('/wikimedia//editions')).to eq([
         [:T_SLASH, nil],
         [:T_IDENT, 'wikimedia'],
         [:T_SLASH, nil],
@@ -58,13 +58,13 @@ describe Oga::XPath::Lexer do
         [:T_TYPE_TEST, 'node'],
         [:T_SLASH, nil],
         [:T_IDENT, 'editions']
-      ]
+      ])
     end
 
     it 'lexes a complex expression using predicates and function calls' do
       path = '/wikimedia/projects/project[@name="Wikipedia"]/editions/edition/text()'
 
-      lex_xpath(path).should == [
+      expect(lex_xpath(path)).to eq([
         [:T_SLASH, nil],
         [:T_IDENT, 'wikimedia'],
         [:T_SLASH, nil],
@@ -83,7 +83,7 @@ describe Oga::XPath::Lexer do
         [:T_IDENT, 'edition'],
         [:T_SLASH, nil],
         [:T_TYPE_TEST, 'text']
-      ]
+      ])
     end
   end
 end
diff --git a/spec/oga/xpath/lexer/integers_spec.rb b/spec/oga/xpath/lexer/integers_spec.rb
index 4756f94..9d7076b 100644
--- a/spec/oga/xpath/lexer/integers_spec.rb
+++ b/spec/oga/xpath/lexer/integers_spec.rb
@@ -3,11 +3,11 @@ require 'spec_helper'
 describe Oga::XPath::Lexer do
   describe 'integers' do
     it 'lexes an integer' do
-      lex_xpath('10').should == [[:T_INT, 10]]
+      expect(lex_xpath('10')).to eq([[:T_INT, 10]])
     end
 
     it 'lexes a negative integer' do
-      lex_xpath('-10').should == [[:T_INT, -10]]
+      expect(lex_xpath('-10')).to eq([[:T_INT, -10]])
     end
   end
 end
diff --git a/spec/oga/xpath/lexer/node_type_spec.rb b/spec/oga/xpath/lexer/node_type_spec.rb
index 6c09bd1..1be9794 100644
--- a/spec/oga/xpath/lexer/node_type_spec.rb
+++ b/spec/oga/xpath/lexer/node_type_spec.rb
@@ -3,21 +3,21 @@ require 'spec_helper'
 describe Oga::XPath::Lexer do
   describe 'node types' do
     it 'lexes the "node" type' do
-      lex_xpath('node()').should == [[:T_TYPE_TEST, 'node']]
+      expect(lex_xpath('node()')).to eq([[:T_TYPE_TEST, 'node']])
     end
 
     it 'lexes the "comment" type' do
-      lex_xpath('comment()').should == [[:T_TYPE_TEST, 'comment']]
+      expect(lex_xpath('comment()')).to eq([[:T_TYPE_TEST, 'comment']])
     end
 
     it 'lexes the "text" type' do
-      lex_xpath('text()').should == [[:T_TYPE_TEST, 'text']]
+      expect(lex_xpath('text()')).to eq([[:T_TYPE_TEST, 'text']])
     end
 
     it 'lexes the "processing-instruction" type' do
-      lex_xpath('processing-instruction()').should == [
+      expect(lex_xpath('processing-instruction()')).to eq([
         [:T_TYPE_TEST, 'processing-instruction']
-      ]
+      ])
     end
   end
 end
diff --git a/spec/oga/xpath/lexer/operators_spec.rb b/spec/oga/xpath/lexer/operators_spec.rb
index f7fcdc3..ff96a0a 100644
--- a/spec/oga/xpath/lexer/operators_spec.rb
+++ b/spec/oga/xpath/lexer/operators_spec.rb
@@ -3,59 +3,59 @@ require 'spec_helper'
 describe Oga::XPath::Lexer do
   describe 'operators' do
     it 'lexes the pipe operator' do
-      lex_xpath('|').should == [[:T_PIPE, nil]]
+      expect(lex_xpath('|')).to eq([[:T_PIPE, nil]])
     end
 
     it 'lexes the and operator' do
-      lex_xpath(' and ').should == [[:T_AND, nil]]
+      expect(lex_xpath(' and ')).to eq([[:T_AND, nil]])
     end
 
     it 'lexes the or operator' do
-      lex_xpath(' or ').should == [[:T_OR, nil]]
+      expect(lex_xpath(' or ')).to eq([[:T_OR, nil]])
     end
 
     it 'lexes the plus operator' do
-      lex_xpath('+').should == [[:T_ADD, nil]]
+      expect(lex_xpath('+')).to eq([[:T_ADD, nil]])
     end
 
     it 'lexes the div operator' do
-      lex_xpath(' div ').should == [[:T_DIV, nil]]
+      expect(lex_xpath(' div ')).to eq([[:T_DIV, nil]])
     end
 
     it 'lexes the mod operator' do
-      lex_xpath(' mod ').should == [[:T_MOD, nil]]
+      expect(lex_xpath(' mod ')).to eq([[:T_MOD, nil]])
     end
 
     it 'lexes the equals operator' do
-      lex_xpath('=').should == [[:T_EQ, nil]]
+      expect(lex_xpath('=')).to eq([[:T_EQ, nil]])
     end
 
     it 'lexes the not-equals operator' do
-      lex_xpath('!=').should == [[:T_NEQ, nil]]
+      expect(lex_xpath('!=')).to eq([[:T_NEQ, nil]])
     end
 
     it 'lexes the lower-than operator' do
-      lex_xpath('<').should == [[:T_LT, nil]]
+      expect(lex_xpath('<')).to eq([[:T_LT, nil]])
     end
 
     it 'lexes the greater-than operator' do
-      lex_xpath('>').should == [[:T_GT, nil]]
+      expect(lex_xpath('>')).to eq([[:T_GT, nil]])
     end
 
     it 'lexes the lower-or-equal operator' do
-      lex_xpath('<=').should == [[:T_LTE, nil]]
+      expect(lex_xpath('<=')).to eq([[:T_LTE, nil]])
     end
 
     it 'lexes the greater-or-equal operator' do
-      lex_xpath('>=').should == [[:T_GTE, nil]]
+      expect(lex_xpath('>=')).to eq([[:T_GTE, nil]])
     end
 
     it 'lexes the mul operator' do
-      lex_xpath(' * ').should == [[:T_MUL, nil]]
+      expect(lex_xpath(' * ')).to eq([[:T_MUL, nil]])
     end
 
     it 'lexes the subtraction operator' do
-      lex_xpath(' - ').should == [[:T_SUB, nil]]
+      expect(lex_xpath(' - ')).to eq([[:T_SUB, nil]])
     end
   end
 end
diff --git a/spec/oga/xpath/lexer/predicates_spec.rb b/spec/oga/xpath/lexer/predicates_spec.rb
index 1cfbfbc..7349f53 100644
--- a/spec/oga/xpath/lexer/predicates_spec.rb
+++ b/spec/oga/xpath/lexer/predicates_spec.rb
@@ -3,17 +3,17 @@ require 'spec_helper'
 describe Oga::XPath::Lexer do
   describe 'predicates' do
     it 'lexes a simple predicate expression' do
-      lex_xpath('/foo[bar]').should == [
+      expect(lex_xpath('/foo[bar]')).to eq([
         [:T_SLASH, nil],
         [:T_IDENT, 'foo'],
         [:T_LBRACK, nil],
         [:T_IDENT, 'bar'],
         [:T_RBRACK, nil]
-      ]
+      ])
     end
 
     it 'lexes a predicate that checks for equality' do
-      lex_xpath('/foo[@bar="baz"]').should == [
+      expect(lex_xpath('/foo[@bar="baz"]')).to eq([
         [:T_SLASH, nil],
         [:T_IDENT, 'foo'],
         [:T_LBRACK, nil],
@@ -22,31 +22,31 @@ describe Oga::XPath::Lexer do
         [:T_EQ, nil],
         [:T_STRING, 'baz'],
         [:T_RBRACK, nil]
-      ]
+      ])
     end
 
     it 'lexes a predicate that user an integer' do
-      lex_xpath('/foo[1]').should == [
+      expect(lex_xpath('/foo[1]')).to eq([
         [:T_SLASH, nil],
         [:T_IDENT, 'foo'],
         [:T_LBRACK, nil],
         [:T_INT, 1],
         [:T_RBRACK, nil]
-      ]
+      ])
     end
 
     it 'lexes a predicate that uses a float' do
-      lex_xpath('/foo[1.5]').should == [
+      expect(lex_xpath('/foo[1.5]')).to eq([
         [:T_SLASH, nil],
         [:T_IDENT, 'foo'],
         [:T_LBRACK, nil],
         [:T_FLOAT, 1.5],
         [:T_RBRACK, nil]
-      ]
+      ])
     end
 
     it 'lexes a predicate using a function' do
-      lex_xpath('/foo[bar()]').should == [
+      expect(lex_xpath('/foo[bar()]')).to eq([
         [:T_SLASH, nil],
         [:T_IDENT, 'foo'],
         [:T_LBRACK, nil],
@@ -54,11 +54,11 @@ describe Oga::XPath::Lexer do
         [:T_LPAREN, nil],
         [:T_RPAREN, nil],
         [:T_RBRACK, nil]
-      ]
+      ])
     end
 
     it 'lexes a predicate expression using the div operator' do
-      lex_xpath('/div[@number=4 div 2]').should == [
+      expect(lex_xpath('/div[@number=4 div 2]')).to eq([
         [:T_SLASH, nil],
         [:T_IDENT, 'div'],
         [:T_LBRACK, nil],
@@ -69,11 +69,11 @@ describe Oga::XPath::Lexer do
         [:T_DIV, nil],
         [:T_INT, 2],
         [:T_RBRACK, nil]
-      ]
+      ])
     end
 
     it 'lexes a predicate expression using the * operator' do
-      lex_xpath('/div[@number=4 * 2]').should == [
+      expect(lex_xpath('/div[@number=4 * 2]')).to eq([
         [:T_SLASH, nil],
         [:T_IDENT, 'div'],
         [:T_LBRACK, nil],
@@ -84,11 +84,11 @@ describe Oga::XPath::Lexer do
         [:T_MUL, nil],
         [:T_INT, 2],
         [:T_RBRACK, nil]
-      ]
+      ])
     end
 
     it 'lexes a predicate expression using axes' do
-      lex_xpath('/div[/foo/bar]').should == [
+      expect(lex_xpath('/div[/foo/bar]')).to eq([
         [:T_SLASH, nil],
         [:T_IDENT, 'div'],
         [:T_LBRACK, nil],
@@ -97,11 +97,11 @@ describe Oga::XPath::Lexer do
         [:T_SLASH, nil],
         [:T_IDENT, 'bar'],
         [:T_RBRACK, nil]
-      ]
+      ])
     end
 
     it 'lexes a predicate expression using a wildcard' do
-      lex_xpath('/div[/foo/*]').should == [
+      expect(lex_xpath('/div[/foo/*]')).to eq([
         [:T_SLASH, nil],
         [:T_IDENT, 'div'],
         [:T_LBRACK, nil],
@@ -110,7 +110,7 @@ describe Oga::XPath::Lexer do
         [:T_SLASH, nil],
         [:T_IDENT, '*'],
         [:T_RBRACK, nil]
-      ]
+      ])
     end
   end
 end
diff --git a/spec/oga/xpath/lexer/strings_spec.rb b/spec/oga/xpath/lexer/strings_spec.rb
index 6d97796..27c7a09 100644
--- a/spec/oga/xpath/lexer/strings_spec.rb
+++ b/spec/oga/xpath/lexer/strings_spec.rb
@@ -3,19 +3,19 @@ require 'spec_helper'
 describe Oga::XPath::Lexer do
   describe 'strings' do
     it 'lexes a double quoted string' do
-      lex_xpath('"foo"').should == [[:T_STRING, 'foo']]
+      expect(lex_xpath('"foo"')).to eq([[:T_STRING, 'foo']])
     end
 
     it 'lexes a single quoted string' do
-      lex_xpath("'foo'").should == [[:T_STRING, 'foo']]
+      expect(lex_xpath("'foo'")).to eq([[:T_STRING, 'foo']])
     end
 
     it 'lexes an empty double quoted string' do
-      lex_xpath('""').should == [[:T_STRING, '']]
+      expect(lex_xpath('""')).to eq([[:T_STRING, '']])
     end
 
     it 'lexes an empty single quoted string' do
-      lex_xpath("''").should == [[:T_STRING, '']]
+      expect(lex_xpath("''")).to eq([[:T_STRING, '']])
     end
   end
 end
diff --git a/spec/oga/xpath/lexer/variable_spec.rb b/spec/oga/xpath/lexer/variable_spec.rb
index 3ccb35f..3ebc481 100644
--- a/spec/oga/xpath/lexer/variable_spec.rb
+++ b/spec/oga/xpath/lexer/variable_spec.rb
@@ -3,7 +3,7 @@ require 'spec_helper'
 describe Oga::XPath::Lexer do
   describe 'variables' do
     it 'lexes a variable reference' do
-      lex_xpath('$foo').should == [[:T_VAR, 'foo']]
+      expect(lex_xpath('$foo')).to eq([[:T_VAR, 'foo']])
     end
   end
 end
diff --git a/spec/oga/xpath/parser/axes_spec.rb b/spec/oga/xpath/parser/axes_spec.rb
index 8468b83..4081738 100644
--- a/spec/oga/xpath/parser/axes_spec.rb
+++ b/spec/oga/xpath/parser/axes_spec.rb
@@ -3,114 +3,114 @@ require 'spec_helper'
 describe Oga::XPath::Parser do
   describe 'full axes' do
     it 'parses the ancestor axis' do
-      parse_xpath('/ancestor::A').should == s(
+      expect(parse_xpath('/ancestor::A')).to eq(s(
         :absolute_path,
         s(:axis, 'ancestor', s(:test, nil, 'A'))
-      )
+      ))
     end
 
     it 'parses the ancestor axis with a predicate' do
-      parse_xpath('/ancestor::A[1]').should == s(
+      expect(parse_xpath('/ancestor::A[1]')).to eq(s(
         :absolute_path,
         s(:predicate, s(:axis, 'ancestor', s(:test, nil, 'A')), s(:int, 1))
-      )
+      ))
     end
 
     it 'parses the ancestor-or-self axis' do
-      parse_xpath('/ancestor-or-self::A').should == s(
+      expect(parse_xpath('/ancestor-or-self::A')).to eq(s(
         :absolute_path,
         s(:axis, 'ancestor-or-self', s(:test, nil, 'A'))
-      )
+      ))
     end
 
     it 'parses the attribute axis' do
-      parse_xpath('/attribute::A').should == s(
+      expect(parse_xpath('/attribute::A')).to eq(s(
         :absolute_path,
         s(:axis, 'attribute', s(:test, nil, 'A'))
-      )
+      ))
     end
 
     it 'parses the child axis' do
-      parse_xpath('/child::A').should == s(
+      expect(parse_xpath('/child::A')).to eq(s(
         :absolute_path,
         s(:axis, 'child', s(:test, nil, 'A'))
-      )
+      ))
     end
 
     it 'parses the descendant axis' do
-      parse_xpath('/descendant::A').should == s(
+      expect(parse_xpath('/descendant::A')).to eq(s(
         :absolute_path,
         s(:axis, 'descendant', s(:test, nil, 'A'))
-      )
+      ))
     end
 
     it 'parses the descendant-or-self axis' do
-      parse_xpath('/descendant-or-self::A').should == s(
+      expect(parse_xpath('/descendant-or-self::A')).to eq(s(
         :absolute_path,
         s(:axis, 'descendant-or-self', s(:test, nil, 'A'))
-      )
+      ))
     end
 
     it 'parses the following axis' do
-      parse_xpath('/following::A').should == s(
+      expect(parse_xpath('/following::A')).to eq(s(
         :absolute_path,
         s(:axis, 'following', s(:test, nil, 'A'))
-      )
+      ))
     end
 
     it 'parses the following-sibling axis' do
-      parse_xpath('/following-sibling::A').should == s(
+      expect(parse_xpath('/following-sibling::A')).to eq(s(
         :absolute_path,
         s(:axis, 'following-sibling', s(:test, nil, 'A'))
-      )
+      ))
     end
 
     it 'parses the namespace axis' do
-      parse_xpath('/namespace::A').should == s(
+      expect(parse_xpath('/namespace::A')).to eq(s(
         :absolute_path,
         s(:axis, 'namespace', s(:test, nil, 'A'))
-      )
+      ))
     end
 
     it 'parses the parent axis' do
-      parse_xpath('/parent::A').should == s(
+      expect(parse_xpath('/parent::A')).to eq(s(
         :absolute_path,
         s(:axis, 'parent', s(:test, nil, 'A'))
-      )
+      ))
     end
 
     it 'parses the preceding axis' do
-      parse_xpath('/preceding::A').should == s(
+      expect(parse_xpath('/preceding::A')).to eq(s(
         :absolute_path,
         s(:axis, 'preceding', s(:test, nil, 'A'))
-      )
+      ))
     end
 
     it 'parses the preceding-sibling axis' do
-      parse_xpath('/preceding-sibling::A').should == s(
+      expect(parse_xpath('/preceding-sibling::A')).to eq(s(
         :absolute_path,
         s(:axis, 'preceding-sibling', s(:test, nil, 'A'))
-      )
+      ))
     end
 
     it 'parses the self axis' do
-      parse_xpath('/self::A').should == s(
+      expect(parse_xpath('/self::A')).to eq(s(
         :absolute_path,
         s(:axis, 'self', s(:test, nil, 'A'))
-      )
+      ))
     end
   end
 
   describe 'short axes' do
     it 'parses the @attribute axis' do
-      parse_xpath('/@A').should == s(
+      expect(parse_xpath('/@A')).to eq(s(
         :absolute_path,
         s(:axis, 'attribute', s(:test, nil, 'A'))
-      )
+      ))
     end
 
     it 'parses the // axis' do
-      parse_xpath('//A').should == s(
+      expect(parse_xpath('//A')).to eq(s(
         :absolute_path,
         s(
           :axis,
@@ -118,21 +118,21 @@ describe Oga::XPath::Parser do
           s(:type_test, 'node'),
           s(:axis, 'child', s(:test, nil, 'A'))
         ),
-      )
+      ))
     end
 
     it 'parses the .. axis' do
-      parse_xpath('/..').should == s(
+      expect(parse_xpath('/..')).to eq(s(
         :absolute_path,
         s(:axis, 'parent', s(:type_test, 'node'))
-      )
+      ))
     end
 
     it 'parses the . axis' do
-      parse_xpath('/.').should == s(
+      expect(parse_xpath('/.')).to eq(s(
         :absolute_path,
         s(:axis, 'self', s(:type_test, 'node'))
-      )
+      ))
     end
   end
 end
diff --git a/spec/oga/xpath/parser/cache_spec.rb b/spec/oga/xpath/parser/cache_spec.rb
index c1eecb6..f4c6e5b 100644
--- a/spec/oga/xpath/parser/cache_spec.rb
+++ b/spec/oga/xpath/parser/cache_spec.rb
@@ -7,21 +7,21 @@ describe Oga::XPath::Parser do
     end
 
     it 'parses an expression' do
-      described_class.parse_with_cache('foo')
-        .should == s(:axis, 'child', s(:test, nil, 'foo'))
+      expect(described_class.parse_with_cache('foo'))
+        .to eq(s(:axis, 'child', s(:test, nil, 'foo')))
     end
 
     it 'caches an expression after parsing it' do
-      described_class.any_instance
-        .should_receive(:parse)
+      expect_any_instance_of(described_class)
+        .to receive(:parse)
         .once
         .and_call_original
 
-      described_class.parse_with_cache('foo')
-        .should == s(:axis, 'child', s(:test, nil, 'foo'))
+      expect(described_class.parse_with_cache('foo'))
+        .to eq(s(:axis, 'child', s(:test, nil, 'foo')))
 
-      described_class.parse_with_cache('foo')
-        .should == s(:axis, 'child', s(:test, nil, 'foo'))
+      expect(described_class.parse_with_cache('foo'))
+        .to eq(s(:axis, 'child', s(:test, nil, 'foo')))
     end
   end
 end
diff --git a/spec/oga/xpath/parser/calls_spec.rb b/spec/oga/xpath/parser/calls_spec.rb
index b94549a..f214af7 100644
--- a/spec/oga/xpath/parser/calls_spec.rb
+++ b/spec/oga/xpath/parser/calls_spec.rb
@@ -3,40 +3,41 @@ require 'spec_helper'
 describe Oga::XPath::Parser do
   describe 'function calls' do
     it 'parses a function call without arguments' do
-      parse_xpath('count()').should == s(:call, 'count')
+      expect(parse_xpath('count()')).to eq(s(:call, 'count'))
     end
 
     it 'parses a function call with a single argument' do
-      parse_xpath('count(/foo)').should == s(
+      expect(parse_xpath('count(/foo)')).to eq(s(
         :call,
         'count',
         s(:absolute_path, s(:axis, 'child', s(:test, nil, 'foo')))
-      )
+      ))
     end
 
     it 'parses a function call with two arguments' do
-      parse_xpath('count(/foo, "bar")').should == s(
+      expect(parse_xpath('count(/foo, "bar")')).to eq(s(
         :call,
         'count',
         s(:absolute_path, s(:axis, 'child', s(:test, nil, 'foo'))),
         s(:string, 'bar')
-      )
+      ))
     end
 
     it 'parses a relative path with a function call' do
-      parse_xpath('foo/bar()').should ==
-        s(:axis, 'child', s(:test, nil, 'foo'), s(:call, 'bar'))
-    end
-
-    it 'parses an absolute path with a function call' do
-      parse_xpath('/foo/bar()').should == s(
-        :absolute_path,
+      expect(parse_xpath('foo/bar()')).to eq(
         s(:axis, 'child', s(:test, nil, 'foo'), s(:call, 'bar'))
       )
     end
 
+    it 'parses an absolute path with a function call' do
+      expect(parse_xpath('/foo/bar()')).to eq(s(
+        :absolute_path,
+        s(:axis, 'child', s(:test, nil, 'foo'), s(:call, 'bar'))
+      ))
+    end
+
     it 'parses a predicate followed by a function call' do
-      parse_xpath('div[@class="foo"]/bar()').should == s(
+      expect(parse_xpath('div[@class="foo"]/bar()')).to eq(s(
         :predicate,
         s(:axis, 'child', s(:test, nil, 'div')),
         s(
@@ -45,11 +46,11 @@ describe Oga::XPath::Parser do
           s(:string, 'foo')
         ),
         s(:call, 'bar')
-      )
+      ))
     end
 
     it 'parses two predicates followed by a function call' do
-      parse_xpath('A[@x]/B[@x]/bar()').should == s(
+      expect(parse_xpath('A[@x]/B[@x]/bar()')).to eq(s(
         :predicate,
         s(:axis, 'child', s(:test, nil, 'A')),
         s(:axis, 'attribute', s(:test, nil, 'x')),
@@ -59,15 +60,15 @@ describe Oga::XPath::Parser do
           s(:axis, 'attribute', s(:test, nil, 'x')),
           s(:call, 'bar')
         )
-      )
+      ))
     end
 
     it 'parses a function call inside a predicate' do
-      parse_xpath('A[foo()]').should == s(
+      expect(parse_xpath('A[foo()]')).to eq(s(
         :predicate,
         s(:axis, 'child', s(:test, nil, 'A')),
         s(:call, 'foo')
-      )
+      ))
     end
   end
 end
diff --git a/spec/oga/xpath/parser/grouping_spec.rb b/spec/oga/xpath/parser/grouping_spec.rb
index 01c656e..53347f3 100644
--- a/spec/oga/xpath/parser/grouping_spec.rb
+++ b/spec/oga/xpath/parser/grouping_spec.rb
@@ -3,7 +3,7 @@ require 'spec_helper'
 describe Oga::XPath::Parser do
   describe 'grouping of expressions' do
     it 'parses "A + (B + C)"' do
-      parse_xpath('A + (B + C)').should == s(
+      expect(parse_xpath('A + (B + C)')).to eq(s(
         :add,
         s(:axis, 'child', s(:test, nil, 'A')),
         s(
@@ -11,11 +11,11 @@ describe Oga::XPath::Parser do
           s(:axis, 'child', s(:test, nil, 'B')),
           s(:axis, 'child', s(:test, nil, 'C'))
         )
-      )
+      ))
     end
 
     it 'parses "A or (B or C)"' do
-      parse_xpath('A or (B or C)').should == s(
+      expect(parse_xpath('A or (B or C)')).to eq(s(
         :or,
         s(:axis, 'child', s(:test, nil, 'A')),
         s(
@@ -23,11 +23,11 @@ describe Oga::XPath::Parser do
           s(:axis, 'child', s(:test, nil, 'B')),
           s(:axis, 'child', s(:test, nil, 'C'))
         )
-      )
+      ))
     end
 
     it 'parses "(A or B) and C"' do
-      parse_xpath('(A or B) and C').should == s(
+      expect(parse_xpath('(A or B) and C')).to eq(s(
         :and,
         s(
           :or,
@@ -35,7 +35,7 @@ describe Oga::XPath::Parser do
           s(:axis, 'child', s(:test, nil, 'B'))
         ),
         s(:axis, 'child', s(:test, nil, 'C'))
-      )
+      ))
     end
   end
 end
diff --git a/spec/oga/xpath/parser/operator_precedence_spec.rb b/spec/oga/xpath/parser/operator_precedence_spec.rb
index 0d6f07a..6d644ed 100644
--- a/spec/oga/xpath/parser/operator_precedence_spec.rb
+++ b/spec/oga/xpath/parser/operator_precedence_spec.rb
@@ -3,7 +3,7 @@ require 'spec_helper'
 describe Oga::XPath::Parser do
   describe 'operator precedence' do
     it 'parses "A or B or C"' do
-      parse_xpath('A or B or C').should == s(
+      expect(parse_xpath('A or B or C')).to eq(s(
         :or,
         s(
           :or,
@@ -11,11 +11,11 @@ describe Oga::XPath::Parser do
           s(:axis, 'child', s(:test, nil, 'B'))
         ),
         s(:axis, 'child', s(:test, nil, 'C'))
-      )
+      ))
     end
 
     it 'parses "A and B and C"' do
-      parse_xpath('A and B and C').should == s(
+      expect(parse_xpath('A and B and C')).to eq(s(
         :and,
         s(
           :and,
@@ -23,11 +23,11 @@ describe Oga::XPath::Parser do
           s(:axis, 'child', s(:test, nil, 'B'))
         ),
         s(:axis, 'child', s(:test, nil, 'C'))
-      )
+      ))
     end
 
     it 'parses "A = B = C"' do
-      parse_xpath('A = B = C').should == s(
+      expect(parse_xpath('A = B = C')).to eq(s(
         :eq,
         s(
           :eq,
@@ -35,11 +35,11 @@ describe Oga::XPath::Parser do
           s(:axis, 'child', s(:test, nil, 'B'))
         ),
         s(:axis, 'child', s(:test, nil, 'C'))
-      )
+      ))
     end
 
     it 'parses "A != B != C"' do
-      parse_xpath('A != B != C').should == s(
+      expect(parse_xpath('A != B != C')).to eq(s(
         :neq,
         s(
           :neq,
@@ -47,11 +47,11 @@ describe Oga::XPath::Parser do
           s(:axis, 'child', s(:test, nil, 'B'))
         ),
         s(:axis, 'child', s(:test, nil, 'C'))
-      )
+      ))
     end
 
     it 'parses "A <= B <= C"' do
-      parse_xpath('A <= B <= C').should == s(
+      expect(parse_xpath('A <= B <= C')).to eq(s(
         :lte,
         s(
           :lte,
@@ -59,11 +59,11 @@ describe Oga::XPath::Parser do
           s(:axis, 'child', s(:test, nil, 'B'))
         ),
         s(:axis, 'child', s(:test, nil, 'C'))
-      )
+      ))
     end
 
     it 'parses "A < B < C"' do
-      parse_xpath('A < B < C').should == s(
+      expect(parse_xpath('A < B < C')).to eq(s(
         :lt,
         s(
           :lt,
@@ -71,11 +71,11 @@ describe Oga::XPath::Parser do
           s(:axis, 'child', s(:test, nil, 'B'))
         ),
         s(:axis, 'child', s(:test, nil, 'C'))
-      )
+      ))
     end
 
     it 'parses "A >= B >= C"' do
-      parse_xpath('A >= B >= C').should == s(
+      expect(parse_xpath('A >= B >= C')).to eq(s(
         :gte,
         s(
           :gte,
@@ -83,11 +83,11 @@ describe Oga::XPath::Parser do
           s(:axis, 'child', s(:test, nil, 'B'))
         ),
         s(:axis, 'child', s(:test, nil, 'C'))
-      )
+      ))
     end
 
     it 'parses "A > B > C"' do
-      parse_xpath('A > B > C').should == s(
+      expect(parse_xpath('A > B > C')).to eq(s(
         :gt,
         s(
           :gt,
@@ -95,11 +95,11 @@ describe Oga::XPath::Parser do
           s(:axis, 'child', s(:test, nil, 'B'))
         ),
         s(:axis, 'child', s(:test, nil, 'C'))
-      )
+      ))
     end
 
     it 'parses "A or B and C"' do
-      parse_xpath('A or B and C').should == s(
+      expect(parse_xpath('A or B and C')).to eq(s(
         :or,
         s(:axis, 'child', s(:test, nil, 'A')),
         s(
@@ -107,11 +107,11 @@ describe Oga::XPath::Parser do
           s(:axis, 'child', s(:test, nil, 'B')),
           s(:axis, 'child', s(:test, nil, 'C'))
         )
-      )
+      ))
     end
 
     it 'parses "A and B = C"' do
-      parse_xpath('A and B = C').should == s(
+      expect(parse_xpath('A and B = C')).to eq(s(
         :and,
         s(:axis, 'child', s(:test, nil, 'A')),
         s(
@@ -119,11 +119,11 @@ describe Oga::XPath::Parser do
           s(:axis, 'child', s(:test, nil, 'B')),
           s(:axis, 'child', s(:test, nil, 'C'))
         )
-      )
+      ))
     end
 
     it 'parses "A = B < C"' do
-      parse_xpath('A = B < C').should == s(
+      expect(parse_xpath('A = B < C')).to eq(s(
         :eq,
         s(:axis, 'child', s(:test, nil, 'A')),
         s(
@@ -131,11 +131,11 @@ describe Oga::XPath::Parser do
           s(:axis, 'child', s(:test, nil, 'B')),
           s(:axis, 'child', s(:test, nil, 'C'))
         )
-      )
+      ))
     end
 
     it 'parses "A < B | C"' do
-      parse_xpath('A < B | C').should == s(
+      expect(parse_xpath('A < B | C')).to eq(s(
         :lt,
         s(:axis, 'child', s(:test, nil, 'A')),
         s(
@@ -143,11 +143,11 @@ describe Oga::XPath::Parser do
           s(:axis, 'child', s(:test, nil, 'B')),
           s(:axis, 'child', s(:test, nil, 'C'))
         )
-      )
+      ))
     end
 
     it 'parses "A > B or C"' do
-      parse_xpath('A > B or C').should == s(
+      expect(parse_xpath('A > B or C')).to eq(s(
         :or,
         s(
           :gt,
@@ -155,7 +155,7 @@ describe Oga::XPath::Parser do
           s(:axis, 'child', s(:test, nil, 'B'))
         ),
         s(:axis, 'child', s(:test, nil, 'C'))
-      )
+      ))
     end
   end
 end
diff --git a/spec/oga/xpath/parser/operators_spec.rb b/spec/oga/xpath/parser/operators_spec.rb
index 02c1f39..3da5525 100644
--- a/spec/oga/xpath/parser/operators_spec.rb
+++ b/spec/oga/xpath/parser/operators_spec.rb
@@ -3,15 +3,15 @@ require 'spec_helper'
 describe Oga::XPath::Parser do
   describe 'operators' do
     it 'parses the pipe operator' do
-      parse_xpath('A | B').should == s(
+      expect(parse_xpath('A | B')).to eq(s(
         :pipe,
         s(:axis, 'child', s(:test, nil, 'A')),
         s(:axis, 'child', s(:test, nil, 'B'))
-      )
+      ))
     end
 
     it 'parses the pipe operator using two paths' do
-      parse_xpath('A/B | C/D').should == s(
+      expect(parse_xpath('A/B | C/D')).to eq(s(
         :pipe,
         s(
           :axis,
@@ -25,111 +25,111 @@ describe Oga::XPath::Parser do
           s(:test, nil, 'C'),
           s(:axis, 'child', s(:test, nil, 'D'))
         )
-      )
+      ))
     end
 
     it 'parses the and operator' do
-      parse_xpath('A and B').should == s(
+      expect(parse_xpath('A and B')).to eq(s(
         :and,
         s(:axis, 'child', s(:test, nil, 'A')),
         s(:axis, 'child', s(:test, nil, 'B'))
-      )
+      ))
     end
 
     it 'parses the or operator' do
-      parse_xpath('A or B').should == s(
+      expect(parse_xpath('A or B')).to eq(s(
         :or,
         s(:axis, 'child', s(:test, nil, 'A')),
         s(:axis, 'child', s(:test, nil, 'B'))
-      )
+      ))
     end
 
     it 'parses the plus operator' do
-      parse_xpath('A + B').should == s(
+      expect(parse_xpath('A + B')).to eq(s(
         :add,
         s(:axis, 'child', s(:test, nil, 'A')),
         s(:axis, 'child', s(:test, nil, 'B'))
-      )
+      ))
     end
 
     it 'parses the div operator' do
-      parse_xpath('A div B').should == s(
+      expect(parse_xpath('A div B')).to eq(s(
         :div,
         s(:axis, 'child', s(:test, nil, 'A')),
         s(:axis, 'child', s(:test, nil, 'B'))
-      )
+      ))
     end
 
     it 'parses the mod operator' do
-      parse_xpath('A mod B').should == s(
+      expect(parse_xpath('A mod B')).to eq(s(
         :mod,
         s(:axis, 'child', s(:test, nil, 'A')),
         s(:axis, 'child', s(:test, nil, 'B'))
-      )
+      ))
     end
 
     it 'parses the equals operator' do
-      parse_xpath('A = B').should == s(
+      expect(parse_xpath('A = B')).to eq(s(
         :eq,
         s(:axis, 'child', s(:test, nil, 'A')),
         s(:axis, 'child', s(:test, nil, 'B'))
-      )
+      ))
     end
 
     it 'parses the not-equals operator' do
-      parse_xpath('A != B').should == s(
+      expect(parse_xpath('A != B')).to eq(s(
         :neq,
         s(:axis, 'child', s(:test, nil, 'A')),
         s(:axis, 'child', s(:test, nil, 'B'))
-      )
+      ))
     end
 
     it 'parses the lower-than operator' do
-      parse_xpath('A < B').should == s(
+      expect(parse_xpath('A < B')).to eq(s(
         :lt,
         s(:axis, 'child', s(:test, nil, 'A')),
         s(:axis, 'child', s(:test, nil, 'B'))
-      )
+      ))
     end
 
     it 'parses the greater-than operator' do
-      parse_xpath('A > B').should == s(
+      expect(parse_xpath('A > B')).to eq(s(
         :gt,
         s(:axis, 'child', s(:test, nil, 'A')),
         s(:axis, 'child', s(:test, nil, 'B'))
-      )
+      ))
     end
 
     it 'parses the lower-or-equal operator' do
-      parse_xpath('A <= B').should == s(
+      expect(parse_xpath('A <= B')).to eq(s(
         :lte,
         s(:axis, 'child', s(:test, nil, 'A')),
         s(:axis, 'child', s(:test, nil, 'B'))
-      )
+      ))
     end
 
     it 'parses the greater-or-equal operator' do
-      parse_xpath('A >= B').should == s(
+      expect(parse_xpath('A >= B')).to eq(s(
         :gte,
         s(:axis, 'child', s(:test, nil, 'A')),
         s(:axis, 'child', s(:test, nil, 'B'))
-      )
+      ))
     end
 
     it 'parses the mul operator' do
-      parse_xpath('A * B').should == s(
+      expect(parse_xpath('A * B')).to eq(s(
         :mul,
         s(:axis, 'child', s(:test, nil, 'A')),
         s(:axis, 'child', s(:test, nil, 'B'))
-      )
+      ))
     end
 
     it 'parses the subtraction operator' do
-      parse_xpath('A - B').should == s(
+      expect(parse_xpath('A - B')).to eq(s(
         :sub,
         s(:axis, 'child', s(:test, nil, 'A')),
         s(:axis, 'child', s(:test, nil, 'B'))
-      )
+      ))
     end
   end
 end
diff --git a/spec/oga/xpath/parser/paths_spec.rb b/spec/oga/xpath/parser/paths_spec.rb
index 02bafd8..f1049cd 100644
--- a/spec/oga/xpath/parser/paths_spec.rb
+++ b/spec/oga/xpath/parser/paths_spec.rb
@@ -3,27 +3,27 @@ require 'spec_helper'
 describe Oga::XPath::Parser do
   describe 'paths' do
     it 'parses an absolute path' do
-      parse_xpath('/A').should == s(
+      expect(parse_xpath('/A')).to eq(s(
         :absolute_path,
         s(:axis, 'child', s(:test, nil, 'A'))
-      )
+      ))
     end
 
     it 'parses a relative path' do
-      parse_xpath('A').should == s(:axis, 'child', s(:test, nil, 'A'))
+      expect(parse_xpath('A')).to eq(s(:axis, 'child', s(:test, nil, 'A')))
     end
 
     it 'parses a relative path using two steps' do
-      parse_xpath('A/B').should == s(
+      expect(parse_xpath('A/B')).to eq(s(
         :axis,
         'child',
         s(:test, nil, 'A'),
         s(:axis, 'child', s(:test, nil, 'B'))
-      )
+      ))
     end
 
     it 'parses a relative path using three steps' do
-      parse_xpath('A/B/C').should == s(
+      expect(parse_xpath('A/B/C')).to eq(s(
         :axis,
         'child',
         s(:test, nil, 'A'),
@@ -33,11 +33,11 @@ describe Oga::XPath::Parser do
           s(:test, nil, 'B'),
           s(:axis, 'child', s(:test, nil, 'C'))
         )
-      )
+      ))
     end
 
     it 'parses an expression using two paths' do
-      parse_xpath('/A/B').should == s(
+      expect(parse_xpath('/A/B')).to eq(s(
         :absolute_path,
         s(
           :axis,
@@ -45,11 +45,11 @@ describe Oga::XPath::Parser do
           s(:test, nil, 'A'),
           s(:axis, 'child', s(:test, nil, 'B'))
         )
-      )
+      ))
     end
 
     it 'parses an expression using three paths' do
-      parse_xpath('/A/B/C').should == s(
+      expect(parse_xpath('/A/B/C')).to eq(s(
         :absolute_path,
         s(
           :axis,
@@ -62,11 +62,11 @@ describe Oga::XPath::Parser do
             s(:axis, 'child', s(:test, nil, 'C'))
           )
         )
-      )
+      ))
     end
 
     it 'parses an absolute path without a node test' do
-      parse_xpath('/').should == s(:absolute_path)
+      expect(parse_xpath('/')).to eq(s(:absolute_path))
     end
   end
 end
diff --git a/spec/oga/xpath/parser/predicates_spec.rb b/spec/oga/xpath/parser/predicates_spec.rb
index d87316d..0e4a581 100644
--- a/spec/oga/xpath/parser/predicates_spec.rb
+++ b/spec/oga/xpath/parser/predicates_spec.rb
@@ -3,7 +3,7 @@ require 'spec_helper'
 describe Oga::XPath::Parser do
   describe 'predicates' do
     it 'parses a single predicate' do
-      parse_xpath('foo[@class="bar"]').should == s(
+      expect(parse_xpath('foo[@class="bar"]')).to eq(s(
         :predicate,
         s(:axis, 'child', s(:test, nil, 'foo')),
         s(
@@ -11,11 +11,11 @@ describe Oga::XPath::Parser do
           s(:axis, 'attribute', s(:test, nil, 'class')),
           s(:string, 'bar')
         )
-      )
+      ))
     end
 
     it 'parses a predicate using the or operator' do
-      parse_xpath('foo[@x="bar" or @x="baz"]').should == s(
+      expect(parse_xpath('foo[@x="bar" or @x="baz"]')).to eq(s(
         :predicate,
         s(:axis, 'child', s(:test, nil, 'foo')),
         s(
@@ -23,7 +23,7 @@ describe Oga::XPath::Parser do
           s(:eq, s(:axis, 'attribute', s(:test, nil, 'x')), s(:string, 'bar')),
           s(:eq, s(:axis, 'attribute', s(:test, nil, 'x')), s(:string, 'baz')),
         )
-      )
+      ))
     end
   end
 end
diff --git a/spec/oga/xpath/parser/type_tests_spec.rb b/spec/oga/xpath/parser/type_tests_spec.rb
index 61ff344..c3562a9 100644
--- a/spec/oga/xpath/parser/type_tests_spec.rb
+++ b/spec/oga/xpath/parser/type_tests_spec.rb
@@ -3,58 +3,59 @@ require 'spec_helper'
 describe Oga::XPath::Parser do
   describe 'node() type test' do
     it 'parses the standalone type test' do
-      parse_xpath('node()').should == s(:axis, 'child', s(:type_test, 'node'))
+      expect(parse_xpath('node()')).to eq(s(:axis, 'child', s(:type_test, 'node')))
     end
 
     it 'parses the type test in a predicate' do
-      parse_xpath('node()[1]').should == s(
+      expect(parse_xpath('node()[1]')).to eq(s(
         :predicate,
         s(:axis, 'child', s(:type_test, 'node')),
         s(:int, 1)
-      )
+      ))
     end
   end
 
   describe 'comment() type test' do
     it 'parses the standalone type test' do
-      parse_xpath('comment()').should == s(:axis, 'child', s(:type_test, 'comment'))
+      expect(parse_xpath('comment()')).to eq(s(:axis, 'child', s(:type_test, 'comment')))
     end
 
     it 'parses the type test in a predicate' do
-      parse_xpath('comment()[1]').should == s(
+      expect(parse_xpath('comment()[1]')).to eq(s(
         :predicate,
         s(:axis, 'child', s(:type_test, 'comment')),
         s(:int, 1)
-      )
+      ))
     end
   end
 
   describe 'text() type test' do
     it 'parses the standalone type test' do
-      parse_xpath('text()').should == s(:axis, 'child', s(:type_test, 'text'))
+      expect(parse_xpath('text()')).to eq(s(:axis, 'child', s(:type_test, 'text')))
     end
 
     it 'parses the type test in a predicate' do
-      parse_xpath('text()[1]').should == s(
+      expect(parse_xpath('text()[1]')).to eq(s(
         :predicate,
         s(:axis, 'child', s(:type_test, 'text')),
         s(:int, 1)
-      )
+      ))
     end
   end
 
   describe 'processing-instruction() type test' do
     it 'parses the standalone type test' do
-      parse_xpath('processing-instruction()').should ==
+      expect(parse_xpath('processing-instruction()')).to eq(
         s(:axis, 'child', s(:type_test, 'processing-instruction'))
+      )
     end
 
     it 'parses the type test in a predicate' do
-      parse_xpath('processing-instruction()[1]').should == s(
+      expect(parse_xpath('processing-instruction()[1]')).to eq(s(
         :predicate,
         s(:axis, 'child', s(:type_test, 'processing-instruction')),
         s(:int, 1)
-      )
+      ))
     end
   end
 end
diff --git a/spec/oga/xpath/parser/variable_spec.rb b/spec/oga/xpath/parser/variable_spec.rb
index 026b6b0..2392cf3 100644
--- a/spec/oga/xpath/parser/variable_spec.rb
+++ b/spec/oga/xpath/parser/variable_spec.rb
@@ -3,15 +3,15 @@ require 'spec_helper'
 describe Oga::XPath::Parser do
   describe 'variables' do
     it 'parses a variable reference' do
-      parse_xpath('$foo').should == s(:var, 'foo')
+      expect(parse_xpath('$foo')).to eq(s(:var, 'foo'))
     end
 
     it 'parses a variable reference in a predicate' do
-      parse_xpath('foo[$bar]').should == s(
+      expect(parse_xpath('foo[$bar]')).to eq(s(
         :predicate,
         s(:axis, 'child', s(:test, nil, 'foo')),
         s(:var, 'bar')
-      )
+      ))
     end
   end
 end
diff --git a/spec/oga/xpath/parser/wildcard_spec.rb b/spec/oga/xpath/parser/wildcard_spec.rb
index b2eb1f9..5eabf09 100644
--- a/spec/oga/xpath/parser/wildcard_spec.rb
+++ b/spec/oga/xpath/parser/wildcard_spec.rb
@@ -3,15 +3,15 @@ require 'spec_helper'
 describe Oga::XPath::Parser do
   describe 'wildcards' do
     it 'parses a wildcard name test' do
-      parse_xpath('*').should == s(:axis, 'child', s(:test, nil, '*'))
+      expect(parse_xpath('*')).to eq(s(:axis, 'child', s(:test, nil, '*')))
     end
 
     it 'parses a wildcard namespace test' do
-      parse_xpath('*:A').should == s(:axis, 'child', s(:test, '*', 'A'))
+      expect(parse_xpath('*:A')).to eq(s(:axis, 'child', s(:test, '*', 'A')))
     end
 
     it 'parses a wildcard namespace and name test' do
-      parse_xpath('*:*').should == s(:axis, 'child', s(:test, '*', '*'))
+      expect(parse_xpath('*:*')).to eq(s(:axis, 'child', s(:test, '*', '*')))
     end
   end
 end
diff --git a/spec/spec_helper.rb b/spec/spec_helper.rb
index 0fb1667..12e40ae 100644
--- a/spec/spec_helper.rb
+++ b/spec/spec_helper.rb
@@ -16,12 +16,4 @@ RSpec.configure do |config|
   config.include Oga::ParsingHelpers
   config.include Oga::EvaluationHelpers
   config.include Oga::ThreadingHelpers
-
-  config.expect_with :rspec do |c|
-    c.syntax = [:should, :expect]
-  end
-
-  config.mock_with :rspec do |c|
-    c.syntax = [:should, :expect]
-  end
 end