diff --git a/spec/helpers/truncate_html_helper_spec.rb b/spec/helpers/truncate_html_helper_spec.rb
index 805bbc7..a438122 100644
--- a/spec/helpers/truncate_html_helper_spec.rb
+++ b/spec/helpers/truncate_html_helper_spec.rb
@@ -13,31 +13,31 @@ def truncator
   end
 
   it 'is included in ActionView::Base' do
-    ActionView::Base.included_modules.should include(TruncateHtmlHelper)
+    expect(ActionView::Base.included_modules).to include(TruncateHtmlHelper)
   end
 
   before(:each) do
     @original_html = '<p>foo</p>'
-    @original_html.stub(:html_safe).and_return(@original_html)
+    allow(@original_html).to receive(:html_safe).and_return(@original_html)
   end
 
   it 'creates an instance of HtmlTruncator and calls truncate on it' do
     truncator = double(truncate: @original_html)
-    TruncateHtml::HtmlTruncator.should_receive(:new).and_return(truncator)
+    expect(TruncateHtml::HtmlTruncator).to receive(:new).and_return(truncator)
     truncator.truncate_html(@original_html)
   end
 
   it 'calls truncate on the HtmlTruncator object' do
     truncator = double(truncate: @original_html)
-    TruncateHtml::HtmlTruncator.stub(:new).and_return(truncator)
-    truncator.should_receive(:truncate).and_return(@original_html)
+    allow(TruncateHtml::HtmlTruncator).to receive(:new).and_return(truncator)
+    expect(truncator).to receive(:truncate).and_return(@original_html)
     truncator.truncate_html('foo')
   end
 
   context 'the input html is nil' do
     it 'returns an empty string' do
-      truncator.truncate_html(nil).should be_empty
-      truncator.truncate_html(nil).should be_kind_of(String)
+      expect(truncator.truncate_html(nil)).to be_empty
+      expect(truncator.truncate_html(nil)).to be_kind_of(String)
     end
   end
 
diff --git a/spec/truncate_html/configuration_spec.rb b/spec/truncate_html/configuration_spec.rb
index 7c503bb..cb982d7 100644
--- a/spec/truncate_html/configuration_spec.rb
+++ b/spec/truncate_html/configuration_spec.rb
@@ -5,12 +5,12 @@
   describe 'self.configure' do
 
     it 'yields the configuration object' do
-      lambda do
+      expect do
         TruncateHtml.configure do |config|
-          config.should be_kind_of(TruncateHtml::Configuration)
+          expect(config).to be_kind_of(TruncateHtml::Configuration)
           throw :yay_it_yielded
         end
-      end.should throw_symbol(:yay_it_yielded)
+      end.to throw_symbol(:yay_it_yielded)
     end
 
   end
diff --git a/spec/truncate_html/html_string_spec.rb b/spec/truncate_html/html_string_spec.rb
index 064f87b..bf2945c 100644
--- a/spec/truncate_html/html_string_spec.rb
+++ b/spec/truncate_html/html_string_spec.rb
@@ -10,51 +10,53 @@ def html_string(original_string)
   describe '#html_tokens' do
     it 'returns each token in the string as an array element removing any consecutive whitespace from the string' do
       html = '<h1>Hi there</h1> <p>This          is sweet!</p> <p> squaremeter m² </p>'
-      html_string(html).html_tokens.should == ['<h1>', 'Hi', ' ', 'there', '</h1>', ' ', '<p>', 'This', ' ', 'is', ' ', 'sweet!', '</p>',
-        ' ', '<p>', ' ', 'squaremeter', ' ', 'm²', ' ', '</p>']
+      expect(html_string(html).html_tokens).
+        to eq ['<h1>', 'Hi', ' ', 'there', '</h1>', ' ', '<p>', 'This', ' ',
+               'is', ' ', 'sweet!', '</p>', ' ', '<p>', ' ', 'squaremeter', ' ',
+               'm²', ' ', '</p>']
     end
   end
 
   describe '#html_tag?' do
     it 'returns false when the string parameter is not an html tag' do
-      html_string('no tags').should_not be_html_tag
+      expect(html_string('no tags')).not_to be_html_tag
     end
 
     it 'returns true when the string parameter is an html tag' do
-      html_string('<img src="foo">').should be_html_tag
-      html_string('</img>').should be_html_tag
+      expect(html_string('<img src="foo">')).to be_html_tag
+      expect(html_string('</img>')).to be_html_tag
     end
 
     it 'is false for html comments' do
-      html_string('<!-- hi -->').should_not be_html_tag
+      expect(html_string('<!-- hi -->')).not_to be_html_tag
     end
   end
 
   describe '#open_tag?' do
     it 'returns true if the tag is an open tag' do
-      html_string('<a>').should be_open_tag
+      expect(html_string('<a>')).to be_open_tag
     end
 
     context 'the tag is an open tag, and has whitespace and html properties' do
       it 'returns true if it has single quotes' do
-        html_string(" <a href='http://awesomeful.net' >").should be_open_tag
+        expect(html_string(" <a href='http://awesomeful.net' >")).to be_open_tag
       end
 
       it 'returns true if it has double quotes' do
-        html_string(' <a href="http://awesomeful.net">').should be_open_tag
+        expect(html_string(' <a href="http://awesomeful.net">')).to be_open_tag
       end
     end
 
     it 'returns false if the tag is a close tag' do
-      html_string('</a>').should_not be_open_tag
+      expect(html_string('</a>')).not_to be_open_tag
     end
 
     it 'returns false if the string is not an html tag' do
-      html_string('foo bar').should_not be_open_tag
+      expect(html_string('foo bar')).not_to be_open_tag
     end
 
     it 'returns false if it is a <script> tag' do
-      html_string('<script>').should_not be_open_tag
+      expect(html_string('<script>')).not_to be_open_tag
     end
   end
 
@@ -66,17 +68,17 @@ def html_string(original_string)
 
     tag_pairs.each do |open_tag, close_tag|
       it "closes a #{open_tag} and returns #{close_tag}" do
-        html_string(open_tag).matching_close_tag.should == close_tag
+        expect(html_string(open_tag).matching_close_tag).to eq close_tag
       end
     end
   end
 
   describe '#html_comment?' do
     it 'is true for HTML comments' do
-      html_string('<!-- hi -->').should be_html_comment
-      html_string('<a>').should_not be_html_comment
-      html_string('</a>').should_not be_html_comment
-      html_string('foo').should_not be_html_comment
+      expect(html_string('<!-- hi -->')).to be_html_comment
+      expect(html_string('<a>')).not_to be_html_comment
+      expect(html_string('</a>')).not_to be_html_comment
+      expect(html_string('foo')).not_to be_html_comment
     end
   end
 end
diff --git a/spec/truncate_html/html_truncator_spec.rb b/spec/truncate_html/html_truncator_spec.rb
index 0da14d6..d745d2b 100644
--- a/spec/truncate_html/html_truncator_spec.rb
+++ b/spec/truncate_html/html_truncator_spec.rb
@@ -10,72 +10,85 @@ def truncate(html, opts = {})
 
   context 'when the word_boundary option is set to false' do
     it 'truncates to the exact length specified' do
-      truncate('<div>123456789</div>', :length => 5, :omission => '', :word_boundary => false).should == '<div>12345</div>'
+      expect(truncate('<div>123456789</div>',
+                      length: 5, omission: '', word_boundary: false)).
+        to eq '<div>12345</div>'
     end
 
     it 'retains the tags within the text' do
       html = 'some text <span class="caps">CAPS</span> some text'
-      truncate(html, :length => 25, :word_boundary => false).should == 'some text <span class="caps">CAPS</span> some te...'
+      expect(truncate(html, length: 25, word_boundary: false)).
+        to eq 'some text <span class="caps">CAPS</span> some te...'
     end
 
     context 'and a custom omission value is passed' do
       it 'retains the omission text' do
-        truncate("testtest", :length => 10, :omission => '..', :word_boundary => false).should == 'testtest..'
+        expect(
+          truncate("testtest", length: 10, omission: '..', word_boundary: false)
+        ).to eq 'testtest..'
       end
 
       it 'handles multibyte characters' do
-        truncate("prüfenprüfen", :length => 8, :omission => '..', :word_boundary => false). should == 'prüfen..'
+        expect(
+          truncate("prüfenprüfen", length: 8, omission: '..', word_boundary: false)
+        ).to eq 'prüfen..'
       end
     end
   end
 
   context 'when the word_boundary option is set to true' do
     it 'truncates using the default word_boundary option' do
-      truncate('hello there. or maybe not?', :length => 16, :omission => '', :word_boundary => true).should == 'hello there. or'
+      expect(truncate('hello there. or maybe not?',
+                      length: 16, omission: '', word_boundary: true)).
+        to eq 'hello there. or'
     end
   end
 
   context 'when the word_boundary option is a custom value (for splitting on sentences)' do
     it 'truncates to the end of the nearest sentence' do
-      truncate('hello there. or maybe not?', :length => 16, :omission => '', :word_boundary => /\S[\.\?\!]/).should == 'hello there.'
+      expect(truncate('hello there. or maybe not?',
+                      length: 16, omission: '', word_boundary: /\S[\.\?\!]/)).
+        to eq 'hello there.'
     end
 
     it 'is respectful of closing tags' do
-      truncate('<p>hmmm this <em>should</em> be okay. I think...</p>', :length => 28, :omission => '', :word_boundary => /\S[\.\?\!]/).should == "<p>hmmm this <em>should</em> be okay.</p>"
+      expect(truncate('<p>hmmm this <em>should</em> be okay. I think...</p>',
+                      length: 28, omission: '', word_boundary: /\S[\.\?\!]/)).
+        to eq "<p>hmmm this <em>should</em> be okay.</p>"
     end
   end
 
   it "includes the omission text's length in the returned truncated html" do
-    truncate('a b c', :length => 4, :omission => '...').should == 'a...'
+    expect(truncate('a b c', length: 4, omission: '...')).to eq 'a...'
   end
 
   it "includes omission even on the edge (issue #18)" do
-    opts = { :word_boundary => false, :length => 12 }
-    truncate('One two three', opts).should == 'One two t...'
+    opts = { word_boundary: false, length: 12 }
+    expect(truncate('One two three', opts)).to eq 'One two t...'
   end
 
   it "never returns a string longer than :length" do
-    truncate("test this shit", :length => 10).should == 'test...'
+    expect(truncate("test this shit", length: 10)).to eq 'test...'
   end
 
   it 'supports omissions longer than the maximum length' do
-    lambda { truncate('', :length => 1, :omission => '...') }.should_not raise_error
+    expect{ truncate('', length: 1, omission: '...') }.to_not raise_error
   end
 
   it 'returns the omission when the specified length is smaller than the omission' do
-    truncate('a b c', :length => 2, :omission => '...').should == '...'
+    expect(truncate('a b c', length: 2, omission: '...')).to eq '...'
   end
 
   it 'treats script tags as strings with no length' do
     input_html   = "<p>I have a script <script type = text/javascript>document.write('lum dee dum');</script> and more text</p>"
     expected_out = "<p>I have a script <script type = text/javascript>document.write('lum dee dum');</script> and...</p>"
-    truncate(input_html, :length => 23).should == expected_out
+    expect(truncate(input_html, length: 23)).to eq expected_out
   end
 
   it 'in the middle of a link, truncates and closes the <a>, and closes any remaining open tags' do
     html     = '<div><ul><li>Look at <a href = "foo">this</a> link </li></ul></div>'
     expected = '<div><ul><li>Look at <a href = "foo">this...</a></li></ul></div>'
-    truncate(html, :length => 15).should == expected
+    expect(truncate(html, length: 15)).to eq expected
   end
 
   %w(! @ # $ % ^ & * \( \) - _ + = [ ] { } \ | , . / ?).each do |char|
@@ -83,7 +96,7 @@ def truncate(html, opts = {})
       it 'places the punctuation after the tag without any whitespace' do
         html     = "<p>Look at <strong>this</strong>#{char} More words here</p>"
         expected = "<p>Look at <strong>this</strong>#{char}...</p>"
-        truncate(html, :length => 19).should == expected
+        expect(truncate(html, length: 19)).to eq expected
       end
     end
   end
@@ -92,13 +105,13 @@ def truncate(html, opts = {})
     it 'leaves a whitespace between the closing tag and the following word character' do
       html     = '<p>Look at <a href = "awesomeful.net">this</a> link for randomness</p>'
       expected = '<p>Look at <a href = "awesomeful.net">this</a> link...</p>'
-      truncate(html, :length => 21).should == expected
+      expect(truncate(html, length: 21)).to eq expected
     end
   end
 
   it 'handles multibyte characters and leaves them in the result' do
     html     = '<p>Look at our multibyte characters ā ž <a href = "awesomeful.net">this</a> link for randomness ā ž</p>'
-    truncate(html, :length => html.length).should == html
+    expect(truncate(html, length: html.length)).to eq html
   end
 
   #unusual, but just covering my ass
@@ -109,7 +122,7 @@ def truncate(html, opts = {})
 This is ugly html.
 </div>
     END_HTML
-    truncate(html, :length => 12).should == ' <div id="foo" class="bar"> This is...</div>'
+    expect(truncate(html, length: 12)).to eq ' <div id="foo" class="bar"> This is...</div>'
   end
 
   %w(br hr img).each do |unpaired_tag|
@@ -119,8 +132,8 @@ def truncate(html, opts = {})
         it "does not close the #{unpaired_tag} tag" do
           html      = "<div>Some before. <#{unpaired_tag}>and some after</div>"
           html_caps = "<div>Some before. <#{unpaired_tag.capitalize}>and some after</div>"
-          truncate(html, :length => 19).should == "<div>Some before. <#{unpaired_tag}>and...</div>"
-          truncate(html_caps, :length => 19).should == "<div>Some before. <#{unpaired_tag.capitalize}>and...</div>"
+          expect(truncate(html, length: 19)).to eq "<div>Some before. <#{unpaired_tag}>and...</div>"
+          expect(truncate(html_caps, length: 19)).to eq "<div>Some before. <#{unpaired_tag.capitalize}>and...</div>"
         end
       end
 
@@ -128,8 +141,8 @@ def truncate(html, opts = {})
         it "does not close the #{unpaired_tag} tag" do
           html      = "<div>Some before. <#{unpaired_tag} />and some after</div>"
           html_caps = "<div>Some before. <#{unpaired_tag.capitalize} />and some after</div>"
-          truncate(html, :length => 19).should == "<div>Some before. <#{unpaired_tag} />and...</div>"
-          truncate(html_caps, :length => 19).should == "<div>Some before. <#{unpaired_tag.capitalize} />and...</div>"
+          expect(truncate(html, length: 19)).to eq "<div>Some before. <#{unpaired_tag} />and...</div>"
+          expect(truncate(html_caps, length: 19)).to eq "<div>Some before. <#{unpaired_tag.capitalize} />and...</div>"
         end
       end
 
@@ -146,62 +159,87 @@ def truncate(html, opts = {})
     “我现在使用的是中文的拼音。”<br>
     测试一下具体的truncate</em>html功能。</p>"
 
-    result = truncate(html, :omission => "", :length => 50)
-    result.should include "<p>“我现在使用的是中文的拼音。”<br>"
+    expect(truncate(html, omission: "", length: 50)).
+      to include "<p>“我现在使用的是中文的拼音。”<br>"
   end
 
   context 'when the break_token option is set as <!-- truncate -->' do
     it 'does not truncate abnormally if the break_token is not present' do
-      truncate('This is line one. This is line two.', :length => 30, :break_token => '<!-- truncate -->').should == 'This is line one. This is...'
+      expect(truncate('This is line one. This is line two.',
+                      length: 30, break_token: '<!-- truncate -->')).
+        to eq 'This is line one. This is...'
     end
     it 'does not truncate abnormally if the break_token is present, but beyond the length param' do
-      truncate('This is line one. This is line <!-- truncate --> two.', :length => 30, :break_token => '<!-- truncate -->').should == 'This is line one. This is...'
+      expect(truncate('This is line one. This is line <!-- truncate --> two.',
+                      length: 30, break_token: '<!-- truncate -->')).
+        to eq 'This is line one. This is...'
     end
     it 'truncates before the length param if the break_token is before the token at "length"' do
-      truncate('This is line one. <!-- truncate --> This is line two.', :length => 30, :break_token => '<!-- truncate -->').should == 'This is line one.'
+      expect(truncate('This is line one. <!-- truncate --> This is line two.',
+                      length: 30, break_token: '<!-- truncate -->')).
+        to eq 'This is line one.'
     end
   end
 
   context 'when the break_token option is customized as a comment' do
     it 'does not truncate abnormally if the break_token is not present' do
-      truncate('This is line one. This is line two.', :length => 30, :break_token => '<!-- break -->').should == 'This is line one. This is...'
+      expect(truncate('This is line one. This is line two.',
+                      length: 30, break_token: '<!-- break -->')).
+        to eq 'This is line one. This is...'
     end
     it 'does not truncate abnormally if the break_token is present, but beyond the length param' do
-      truncate('This is line one. This is line <!-- break --> two.', :length => 30, :break_token => '<!-- break -->').should == 'This is line one. This is...'
+      expect(truncate('This is line one. This is line <!-- break --> two.',
+                      length: 30, break_token: '<!-- break -->')).
+        to eq 'This is line one. This is...'
     end
     it 'truncates before the length param if the break_token is before the token at "length"' do
-      truncate('This is line one. <!-- break --> This is line two.', :length => 30, :break_token => '<!-- break -->').should == 'This is line one.'
+      expect(truncate('This is line one. <!-- break --> This is line two.',
+                      length: 30, break_token: '<!-- break -->')).
+        to eq 'This is line one.'
     end
   end
 
   context 'when the break_token option is customized as an html tag' do
     it 'does not truncate abnormally if the break_token is not present' do
-      truncate('This is line one. This is line two.', :length => 30, :break_token => '<break />').should == 'This is line one. This is...'
+      expect(truncate('This is line one. This is line two.',
+                      length: 30, break_token: '<break />')).
+        to eq 'This is line one. This is...'
     end
     it 'does not truncate abnormally if the break_token is present, but beyond the length param' do
-      truncate('This is line one. This is line <break /> two.', :length => 30, :break_token => '<break />').should == 'This is line one. This is...'
+      expect(truncate('This is line one. This is line <break /> two.',
+                      length: 30, break_token: '<break />')).
+        to eq 'This is line one. This is...'
     end
     it 'truncates before the length param if the break_token is before the token at "length"' do
-      truncate('This is line one. <break /> This is line two.', :length => 30, :break_token => '<break />').should == 'This is line one.'
+      expect(truncate('This is line one. <break /> This is line two.',
+                      length: 30, break_token: '<break />')).
+        to eq 'This is line one.'
     end
   end
 
   context 'when the break_token option is customized as a word' do
     it 'does not truncate abnormally if the break_token is not present' do
-      truncate('This is line one. This is line two.', :length => 30, :break_token => 'foobar').should == 'This is line one. This is...'
+      expect(truncate('This is line one. This is line two.',
+                      length: 30, break_token: 'foobar')).
+        to eq 'This is line one. This is...'
     end
     it 'does not truncate abnormally if the break_token is present, but beyond the length param' do
-      truncate('This is line one. This is line foobar two.', :length => 30, :break_token => 'foobar').should == 'This is line one. This is...'
+      expect(truncate('This is line one. This is line foobar two.',
+                      length: 30, break_token: 'foobar')).
+        to eq 'This is line one. This is...'
     end
     it 'truncates before the length param if the break_token is before the token at "length"' do
-      truncate('This is line one. foobar This is line two.', :length => 30, :break_token => 'foobar').should == 'This is line one.'
+      expect(truncate('This is line one. foobar This is line two.',
+                      length: 30, break_token: 'foobar')).
+        to eq 'This is line one.'
     end
   end
 
   context 'a string with comments' do
     it 'does not duplicate comments (issue #32)' do
-      truncate('<h1>hello <!-- stuff --> and <!-- la --> goodbye</h1>', length: 15).should ==
-        '<h1>hello <!-- stuff --> and <!-- la -->...</h1>'
+      expect(truncate('<h1>hello <!-- stuff --> and <!-- la --> goodbye</h1>',
+                      length: 15)).
+        to eq '<h1>hello <!-- stuff --> and <!-- la -->...</h1>'
     end
   end
 end
diff --git a/spec/truncate_html/truncate_html_spec.rb b/spec/truncate_html/truncate_html_spec.rb
index 7d19cec..05b312b 100644
--- a/spec/truncate_html/truncate_html_spec.rb
+++ b/spec/truncate_html/truncate_html_spec.rb
@@ -1,15 +1,19 @@
 require File.join(File.dirname(__FILE__), '..', 'spec_helper')
 
 describe TruncateHtml do
-  it "includes itself in ActionController::Base" do
-    ActionController::Base.should_receive(:helper).with(TruncateHtmlHelper)
-    load File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'lib', 'truncate_html.rb'))
+  it 'includes itself in ActionController::Base' do
+    expect(ActionController::Base).to receive(:helper).with(TruncateHtmlHelper)
+    load File.expand_path(
+      File.join(File.dirname(__FILE__), '..', '..', 'lib', 'truncate_html.rb')
+    )
   end
 
-  it "does not error if ActionController is undefined" do
-    hide_const("ActionController")
+  it 'does not error if ActionController is undefined' do
+    hide_const('ActionController')
     expect {
-      load File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'lib', 'truncate_html.rb'))
+      load File.expand_path(
+        File.join(File.dirname(__FILE__), '..', '..', 'lib', 'truncate_html.rb')
+      )
     }.not_to raise_error
   end
 end