prawn 2.0.1 → 2.0.2

data/spec/text_rendering_mode_spec.rb

@@ -9,16 +9,16 @@ describe "#text_rendering_mode" do
       @pdf.text("hello world")
     end
     contents = PDF::Inspector::Text.analyze(@pdf.render)
-    contents.text_rendering_mode.first.should == 1
+    expect(contents.text_rendering_mode.first).to eq(1)
   end
-  it "should not draw the text rendering mode to the document" +
+  it "should not draw the text rendering mode to the document" \
     " when the new mode matches the old" do
     create_pdf
     @pdf.text_rendering_mode(:fill) do
       @pdf.text("hello world")
     end
     contents = PDF::Inspector::Text.analyze(@pdf.render)
-    contents.text_rendering_mode.should be_empty
+    expect(contents.text_rendering_mode).to be_empty
   end
   it "should restore character spacing to 0" do
     create_pdf
@@ -26,20 +26,20 @@ describe "#text_rendering_mode" do
       @pdf.text("hello world")
     end
     contents = PDF::Inspector::Text.analyze(@pdf.render)
-    contents.text_rendering_mode.should == [1,0]
+    expect(contents.text_rendering_mode).to eq([1, 0])
   end
   it "should function as an accessor when no parameter given" do
     create_pdf
     @pdf.text_rendering_mode(:fill_stroke) do
       @pdf.text("hello world")
-      @pdf.text_rendering_mode.should == :fill_stroke
+      expect(@pdf.text_rendering_mode).to eq(:fill_stroke)
     end
-    @pdf.text_rendering_mode.should == :fill
+    expect(@pdf.text_rendering_mode).to eq(:fill)
   end
   it "should raise_error an exception when passed an invalid mode" do
     create_pdf
-    lambda { @pdf.text_rendering_mode(-1) }.should raise_error(ArgumentError)
-    lambda { @pdf.text_rendering_mode(8) }.should raise_error(ArgumentError)
-    lambda { @pdf.text_rendering_mode(:flil) }.should raise_error(ArgumentError)
+    expect { @pdf.text_rendering_mode(-1) }.to raise_error(ArgumentError)
+    expect { @pdf.text_rendering_mode(8) }.to raise_error(ArgumentError)
+    expect { @pdf.text_rendering_mode(:flil) }.to raise_error(ArgumentError)
   end
 end

data/spec/text_spacing_spec.rb

@@ -9,16 +9,16 @@ describe "#character_spacing" do
       @pdf.text("hello world")
     end
     contents = PDF::Inspector::Text.analyze(@pdf.render)
-    contents.character_spacing.first.should == 10.5556
+    expect(contents.character_spacing.first).to eq(10.5556)
   end
-  it "should not draw the character spacing to the document" +
+  it "should not draw the character spacing to the document" \
     " when the new character spacing matches the old" do
     create_pdf
     @pdf.character_spacing(0) do
       @pdf.text("hello world")
     end
     contents = PDF::Inspector::Text.analyze(@pdf.render)
-    contents.character_spacing.should be_empty
+    expect(contents.character_spacing).to be_empty
   end
   it "should restore character spacing to 0" do
     create_pdf
@@ -26,15 +26,15 @@ describe "#character_spacing" do
       @pdf.text("hello world")
     end
     contents = PDF::Inspector::Text.analyze(@pdf.render)
-    contents.character_spacing.last.should == 0
+    expect(contents.character_spacing.last).to eq(0)
   end
   it "should function as an accessor when no parameter given" do
     create_pdf
     @pdf.character_spacing(10.555555) do
       @pdf.text("hello world")
-      @pdf.character_spacing.should == 10.555555
+      expect(@pdf.character_spacing).to eq(10.555555)
     end
-    @pdf.character_spacing.should == 0
+    expect(@pdf.character_spacing).to eq(0)
   end
 
   # ensure that we properly internationalize by using the number of characters
@@ -51,7 +51,7 @@ describe "#character_spacing" do
 
     @pdf.character_spacing(10) do
       # the new width should include seven 10-pt character spaces.
-      @pdf.width_of(str).should be_within(0.001).of(@raw_width + (10 * 7))
+      expect(@pdf.width_of(str)).to be_within(0.001).of(@raw_width + (10 * 7))
     end
   end
 end
@@ -63,16 +63,16 @@ describe "#word_spacing" do
       @pdf.text("hello world")
     end
     contents = PDF::Inspector::Text.analyze(@pdf.render)
-    contents.word_spacing.first.should == 10.5556
+    expect(contents.word_spacing.first).to eq(10.5556)
   end
-  it "should draw the word spacing to the document" +
+  it "should draw the word spacing to the document" \
     " when the new word spacing matches the old" do
     create_pdf
     @pdf.word_spacing(0) do
       @pdf.text("hello world")
     end
     contents = PDF::Inspector::Text.analyze(@pdf.render)
-    contents.word_spacing.should be_empty
+    expect(contents.word_spacing).to be_empty
   end
   it "should restore word spacing to 0" do
     create_pdf
@@ -80,14 +80,14 @@ describe "#word_spacing" do
       @pdf.text("hello world")
     end
     contents = PDF::Inspector::Text.analyze(@pdf.render)
-    contents.word_spacing.last.should == 0
+    expect(contents.word_spacing.last).to eq(0)
   end
   it "should function as an accessor when no parameter given" do
     create_pdf
     @pdf.word_spacing(10.555555) do
       @pdf.text("hello world")
-      @pdf.word_spacing.should == 10.555555
+      expect(@pdf.word_spacing).to eq(10.555555)
     end
-    @pdf.word_spacing.should == 0
+    expect(@pdf.word_spacing).to eq(0)
   end
 end

data/spec/text_spec.rb

@@ -4,40 +4,40 @@ require File.join(File.expand_path(File.dirname(__FILE__)), "spec_helper")
 
 describe "Prawn::Text::NBSP" do
   it "should be defined" do
-    Prawn::Text::NBSP.should == " "
+    expect(Prawn::Text::NBSP).to eq(" ")
   end
 end
 
 describe "#height_of" do
   before(:each) { create_pdf }
 
-  it "should return the height that would be required to print a" +
+  it "should return the height that would be required to print a" \
     "particular string of text" do
     original_y = @pdf.y
     @pdf.text("Foo")
     new_y = @pdf.y
-    @pdf.height_of("Foo").should be_within(0.0001).of(original_y - new_y)
+    expect(@pdf.height_of("Foo")).to be_within(0.0001).of(original_y - new_y)
   end
 
-  it "should omit the gap below the last descender if :final_gap => false " +
+  it "should omit the gap below the last descender if :final_gap => false " \
     "is given" do
     original_y = @pdf.y
     @pdf.text("Foo", :final_gap => false)
     new_y = @pdf.y
-    @pdf.height_of("Foo", :final_gap => false).should be_within(0.0001).of(original_y - new_y)
+    expect(@pdf.height_of("Foo", :final_gap => false)).to be_within(0.0001).of(original_y - new_y)
   end
 
   it "should raise_error CannotFit if a too-small width is given" do
-    lambda do
+    expect do
       @pdf.height_of("text", :width => 1)
-    end.should raise_error(Prawn::Errors::CannotFit)
+    end.to raise_error(Prawn::Errors::CannotFit)
   end
 
   it "should raise_error NotImplementedError if :indent_paragraphs option is provided" do
-    lambda {
+    expect {
       @pdf.height_of("hai", :width => 300,
-                     :indent_paragraphs => 60)
-    }.should raise_error(NotImplementedError)
+                            :indent_paragraphs => 60)
+    }.to raise_error(NotImplementedError)
   end
 
   it "should_not raise_error Prawn::Errors::UnknownOption if :final_gap option is provided" do
@@ -59,45 +59,45 @@ describe "#text" do
     @pdf.text " "
     text = PDF::Inspector::Text.analyze(@pdf.render)
     # If anything is rendered to the page, it should be whitespace.
-    text.strings.each { |str| str.should =~ /\A\s*\z/ }
+    text.strings.each { |str| expect(str).to match(/\A\s*\z/) }
   end
 
   it "should ignore call when string is nil" do
-    @pdf.text(nil).should be_false
+    expect(@pdf.text(nil)).to be_false
   end
 
   it "should correctly render empty paragraphs" do
     @pdf.text "text\n\ntext"
     text = PDF::Inspector::Text.analyze(@pdf.render)
-    @pdf.page_count.should == 1
-    text.strings.reject{ |s| s.empty? }.should == ["text", "text"]
+    expect(@pdf.page_count).to eq(1)
+    expect(text.strings.reject(&:empty?)).to eq(["text", "text"])
   end
 
   it "should correctly render empty paragraphs with :indent_paragraphs" do
     @pdf.text "text\n\ntext", :indent_paragraphs => 5
     text = PDF::Inspector::Text.analyze(@pdf.render)
-    @pdf.page_count.should == 1
-    text.strings.reject{ |s| s.empty? }.should == ["text", "text"]
+    expect(@pdf.page_count).to eq(1)
+    expect(text.strings.reject(&:empty?)).to eq(["text", "text"])
   end
 
-  it "should correctly render strings ending with empty paragraphs and " +
+  it "should correctly render strings ending with empty paragraphs and " \
      ":inline_format and :indent_paragraphs" do
     @pdf.text "text\n\n", :inline_format => true, :indent_paragraphs => 5
     text = PDF::Inspector::Text.analyze(@pdf.render)
-    @pdf.page_count.should == 1
-    text.strings.should == ["text"]
+    expect(@pdf.page_count).to eq(1)
+    expect(text.strings).to eq(["text"])
   end
 
   it "should default to use kerning information" do
     @pdf.text "hello world"
     text = PDF::Inspector::Text.analyze(@pdf.render)
-    text.kerned[0].should be_true
+    expect(text.kerned[0]).to be_true
   end
 
   it "should be able to disable kerning with an option" do
     @pdf.text "hello world", :kerning => false
     text = PDF::Inspector::Text.analyze(@pdf.render)
-    text.kerned[0].should be_false
+    expect(text.kerned[0]).to be_false
   end
 
   it "should be able to disable kerning document-wide" do
@@ -105,95 +105,92 @@ describe "#text" do
     @pdf.default_kerning = false
     @pdf.text "hello world"
     text = PDF::Inspector::Text.analyze(@pdf.render)
-    text.kerned[0].should be_false
+    expect(text.kerned[0]).to be_false
   end
 
   it "option should be able to override document-wide kerning disabling" do
     @pdf.default_kerning = false
     @pdf.text "hello world", :kerning => true
     text = PDF::Inspector::Text.analyze(@pdf.render)
-    text.kerned[0].should be_true
+    expect(text.kerned[0]).to be_true
   end
 
   it "should raise_error ArgumentError if :at option included" do
-    lambda { @pdf.text("hai", :at => [0, 0]) }.should raise_error(ArgumentError)
+    expect { @pdf.text("hai", :at => [0, 0]) }.to raise_error(ArgumentError)
   end
 
   it "should advance down the document based on font_height" do
     position = @pdf.y
     @pdf.text "Foo"
 
-    @pdf.y.should be_within(0.0001).of(position - @pdf.font.height)
+    expect(@pdf.y).to be_within(0.0001).of(position - @pdf.font.height)
 
     position = @pdf.y
     @pdf.text "Foo\nBar\nBaz"
-    @pdf.y.should be_within(0.0001).of(position - 3*@pdf.font.height)
+    expect(@pdf.y).to be_within(0.0001).of(position - 3 * @pdf.font.height)
   end
 
-  it "should advance down the document based on font_height" +
-    " with size option" do
+  it "should advance down the document based on font_height with size option" do
     position = @pdf.y
     @pdf.text "Foo", :size => 15
 
     @pdf.font_size = 15
-    @pdf.y.should be_within(0.0001).of(position - @pdf.font.height)
+    expect(@pdf.y).to be_within(0.0001).of(position - @pdf.font.height)
 
     position = @pdf.y
     @pdf.text "Foo\nBar\nBaz"
-    @pdf.y.should be_within(0.0001).of(position - 3 * @pdf.font.height)
+    expect(@pdf.y).to be_within(0.0001).of(position - 3 * @pdf.font.height)
   end
 
-  it "should advance down the document based on font_height" +
-    " with leading option" do
+  it "should advance down the document based on font_height with leading option" do
     position = @pdf.y
     leading = 2
     @pdf.text "Foo", :leading => leading
 
-    @pdf.y.should be_within(0.0001).of(position - @pdf.font.height - leading)
+    expect(@pdf.y).to be_within(0.0001).of(position - @pdf.font.height - leading)
 
     position = @pdf.y
     @pdf.text "Foo\nBar\nBaz"
-    @pdf.y.should be_within(0.0001).of(position - 3*@pdf.font.height)
+    expect(@pdf.y).to be_within(0.0001).of(position - 3 * @pdf.font.height)
   end
 
-  it "should advance only to the bottom of the final descender "+
-    "if final_gap is false" do
+  it "should advance only to the bottom of the final descender if final_gap is false" do
     position = @pdf.y
     @pdf.text "Foo", :final_gap => false
 
-    @pdf.y.should be_within(0.0001).of(position - @pdf.font.ascender - @pdf.font.descender)
+    expect(@pdf.y).to be_within(0.0001).of(position - @pdf.font.ascender - @pdf.font.descender)
 
     position = @pdf.y
     @pdf.text "Foo\nBar\nBaz", :final_gap => false
-    @pdf.y.should be_within(0.0001).of(position - 2*@pdf.font.height - @pdf.font.ascender - @pdf.font.descender)
+    expect(@pdf.y).to be_within(0.0001).of(position - 2 * @pdf.font.height - @pdf.font.ascender - @pdf.font.descender)
   end
 
   it "should be able to print text starting at the last line of a page" do
     @pdf.move_cursor_to(@pdf.font.height)
     @pdf.text("hello world")
     pages = PDF::Inspector::Page.analyze(@pdf.render).pages
-    pages.size.should == 1
+    expect(pages.size).to eq(1)
   end
 
   it "should default to 12 point helvetica" do
     @pdf.text "Blah"
     text = PDF::Inspector::Text.analyze(@pdf.render)
-    text.font_settings[0][:name].should == :Helvetica
-    text.font_settings[0][:size].should == 12
-    text.strings.first.should == "Blah"
+    expect(text.font_settings[0][:name]).to eq(:Helvetica)
+    expect(text.font_settings[0][:size]).to eq(12)
+    expect(text.strings.first).to eq("Blah")
   end
 
   it "should allow setting font size" do
     @pdf.text "Blah", :size => 16
     text = PDF::Inspector::Text.analyze(@pdf.render)
-    text.font_settings[0][:size].should == 16
+    expect(text.font_settings[0][:size]).to eq(16)
   end
 
   it "should allow setting a default font size" do
     @pdf.font_size = 16
     @pdf.text "Blah"
     text = PDF::Inspector::Text.analyze(@pdf.render)
-    text.font_settings[0][:size].should == 16
+    expect(text.font_settings[0][:size]).to eq(16)
   end
 
   it "should allow overriding default font for a single instance" do
@@ -202,8 +199,8 @@ describe "#text" do
     @pdf.text "Blah", :size => 11
     @pdf.text "Blaz"
     text = PDF::Inspector::Text.analyze(@pdf.render)
-    text.font_settings[0][:size].should == 11
-    text.font_settings[1][:size].should == 16
+    expect(text.font_settings[0][:size]).to eq(11)
+    expect(text.font_settings[1][:size]).to eq(16)
   end
 
   it "should allow setting a font size transaction with a block" do
@@ -214,21 +211,20 @@ describe "#text" do
     @pdf.text 'blah'
 
     text = PDF::Inspector::Text.analyze(@pdf.render)
-    text.font_settings[0][:size].should == 16
-    text.font_settings[1][:size].should == 12
+    expect(text.font_settings[0][:size]).to eq(16)
+    expect(text.font_settings[1][:size]).to eq(12)
   end
 
-  it "should allow manual setting the font size " +
-    "when in a font size block" do
+  it "should allow manual setting the font size when in a font size block" do
     @pdf.font_size(16) do
       @pdf.text 'Foo'
       @pdf.text 'Blah', :size => 11
       @pdf.text 'Blaz'
     end
     text = PDF::Inspector::Text.analyze(@pdf.render)
-    text.font_settings[0][:size].should == 16
-    text.font_settings[1][:size].should == 11
-    text.font_settings[2][:size].should == 16
+    expect(text.font_settings[0][:size]).to eq(16)
+    expect(text.font_settings[1][:size]).to eq(11)
+    expect(text.font_settings[2][:size]).to eq(16)
   end
 
   it "should allow registering of built-in font_settings on the fly" do
@@ -237,8 +233,8 @@ describe "#text" do
     @pdf.font "Courier"
     @pdf.text "Blaz"
     text = PDF::Inspector::Text.analyze(@pdf.render)
-    text.font_settings[0][:name].should == :"Times-Roman"
-    text.font_settings[1][:name].should == :Courier
+    expect(text.font_settings[0][:name]).to eq(:"Times-Roman")
+    expect(text.font_settings[1][:name]).to eq(:Courier)
   end
 
   it "should utilise the same default font across multiple pages" do
@@ -247,13 +243,13 @@ describe "#text" do
     @pdf.text "Blaz"
     text = PDF::Inspector::Text.analyze(@pdf.render)
 
-    text.font_settings.size.should  == 2
-    text.font_settings[0][:name].should == :Helvetica
-    text.font_settings[1][:name].should == :Helvetica
+    expect(text.font_settings.size).to eq(2)
+    expect(text.font_settings[0][:name]).to eq(:Helvetica)
+    expect(text.font_settings[1][:name]).to eq(:Helvetica)
   end
 
   it "should raise_error an exception when an unknown font is used" do
-    lambda { @pdf.font "Pao bu" }.should raise_error(Prawn::Errors::UnknownFont)
+    expect { @pdf.font "Pao bu" }.to raise_error(Prawn::Errors::UnknownFont)
   end
 
   it "should_not raise_error an exception when providing Pathname instance as font" do
@@ -266,7 +262,7 @@ describe "#text" do
 
     # grab the text from the rendered PDF and ensure it matches
     text = PDF::Inspector::Text.analyze(@pdf.render)
-    text.strings.first.should == str
+    expect(text.strings.first).to eq(str)
   end
 
   it "should correctly render a utf-8 string when using a TTF font" do
@@ -276,46 +272,44 @@ describe "#text" do
 
     # grab the text from the rendered PDF and ensure it matches
     text = PDF::Inspector::Text.analyze(@pdf.render)
-    text.strings.first.should == str
+    expect(text.strings.first).to eq(str)
   end
 
-  it "subsets mixed low-ASCII and non-ASCII characters when they can be " +
-     "subsetted together" do
+  it "subsets mixed low-ASCII and non-ASCII characters when they can be subsetted together" do
     str = "It’s super effective!"
     @pdf.font "#{Prawn::DATADIR}/fonts/DejaVuSans.ttf"
     @pdf.text str
 
     text = PDF::Inspector::Text.analyze(@pdf.render)
-    text.strings.first.should == str
+    expect(text.strings.first).to eq(str)
   end
 
-  it "should correctly render a string with higher bit characters across" +
-     " a page break when using a built-in font" do
+  it "should correctly render a string with higher bit characters across a page break when using a built-in font" do
     str = "©"
     @pdf.move_cursor_to(@pdf.font.height)
     @pdf.text(str + "\n" + str)
 
     pages = PDF::Inspector::Page.analyze(@pdf.render).pages
-    pages.size.should == 2
-    pages[0][:strings].should == [str]
-    pages[1][:strings].should == [str]
+    expect(pages.size).to eq(2)
+    expect(pages[0][:strings]).to eq([str])
+    expect(pages[1][:strings]).to eq([str])
   end
 
-  it "should correctly render a string with higher bit characters across" +
+  it "should correctly render a string with higher bit characters across" \
     " a page break when using a built-in font and :indent_paragraphs option" do
     str = "©"
     @pdf.move_cursor_to(@pdf.font.height)
     @pdf.text(str + "\n" + str, :indent_paragraphs => 20)
 
     pages = PDF::Inspector::Page.analyze(@pdf.render).pages
-    pages.size.should == 2
-    pages[0][:strings].should == [str]
-    pages[1][:strings].should == [str]
+    expect(pages.size).to eq(2)
+    expect(pages[0][:strings]).to eq([str])
+    expect(pages[1][:strings]).to eq([str])
   end
 
   it "should raise_error an exception when a utf-8 incompatible string is rendered" do
     str = "Blah \xDD"
-    lambda { @pdf.text str }.should raise_error(
+    expect { @pdf.text str }.to raise_error(
       Prawn::Errors::IncompatibleStringEncoding)
   end
 
@@ -328,15 +322,15 @@ describe "#text" do
     @pdf.text(sjis_str)
   end
 
-  it "should call move_past_bottom when printing more text than can fit" +
+  it "should call move_past_bottom when printing more text than can fit" \
      " between the current document.y and bounds.bottom" do
     @pdf.y = @pdf.font.height
     @pdf.text "Hello"
     @pdf.text "World"
     pages = PDF::Inspector::Page.analyze(@pdf.render).pages
-    pages.size.should == 2
-    pages[0][:strings].should == ["Hello"]
-    pages[1][:strings].should == ["World"]
+    expect(pages.size).to eq(2)
+    expect(pages[0][:strings]).to eq(["Hello"])
+    expect(pages[1][:strings]).to eq(["World"])
   end
 
   describe "with :indent_paragraphs option" do
@@ -345,13 +339,12 @@ describe "#text" do
       hello2 = "hello " * 50
       @pdf.text(hello + "\n" + hello2, :indent_paragraphs => 60)
       text = PDF::Inspector::Text.analyze(@pdf.render)
-      text.strings[0].should == ("hello " * 19).strip
-      text.strings[1].should == ("hello " * 21).strip
-      text.strings[3].should == ("hello " * 19).strip
-      text.strings[4].should == ("hello " * 21).strip
+      expect(text.strings[0]).to eq(("hello " * 19).strip)
+      expect(text.strings[1]).to eq(("hello " * 21).strip)
+      expect(text.strings[3]).to eq(("hello " * 19).strip)
+      expect(text.strings[4]).to eq(("hello " * 21).strip)
     end
 
-
     it "should indent from right side when using :rtl direction" do
       para1 = "The rain in spain falls mainly on the plains " * 3
       para2 = "The rain in spain falls mainly on the plains " * 3
@@ -367,19 +360,19 @@ describe "#text" do
       # text, which isn't necessarily correct. If we change that behavior,
       # this test will need to be updated.
 
-      x_positions[0].should(
+      expect(x_positions[0]).to(
         be_within(0.001).of(@pdf.bounds.absolute_right - 60 -
                             @pdf.width_of(lines[0].reverse, :kerning => true)))
 
-      x_positions[1].should(
+      expect(x_positions[1]).to(
         be_within(0.001).of(@pdf.bounds.absolute_right -
                             @pdf.width_of(lines[1].reverse, :kerning => true)))
 
-      x_positions[2].should(
+      expect(x_positions[2]).to(
         be_within(0.001).of(@pdf.bounds.absolute_right - 60 -
                             @pdf.width_of(lines[2].reverse, :kerning => true)))
 
-      x_positions[3].should(
+      expect(x_positions[3]).to(
         be_within(0.001).of(@pdf.bounds.absolute_right -
                             @pdf.width_of(lines[3].reverse, :kerning => true)))
     end
@@ -400,19 +393,19 @@ describe "#text" do
       # text, which isn't necessarily correct. If we change that behavior,
       # this test will need to be updated.
 
-      x_positions[0].should(
+      expect(x_positions[0]).to(
         be_within(0.001).of(@pdf.bounds.absolute_right - 60 -
                             @pdf.width_of(lines[0].reverse, :kerning => true)))
 
-      x_positions[1].should(
+      expect(x_positions[1]).to(
         be_within(0.001).of(@pdf.bounds.absolute_right -
                             @pdf.width_of(lines[1].reverse, :kerning => true)))
 
-      x_positions[2].should(
+      expect(x_positions[2]).to(
         be_within(0.001).of(@pdf.bounds.absolute_right - 60 -
                             @pdf.width_of(lines[2].reverse, :kerning => true)))
 
-      x_positions[3].should(
+      expect(x_positions[3]).to(
         be_within(0.001).of(@pdf.bounds.absolute_right -
                             @pdf.width_of(lines[3].reverse, :kerning => true)))
     end
@@ -427,11 +420,11 @@ describe "#text" do
 
       x_positions = text.positions.map { |e| e[0] }
 
-      x_positions[0].should == 60
-      x_positions[1].should == 0
+      expect(x_positions[0]).to eq(60)
+      expect(x_positions[1]).to eq(0)
 
-      x_positions[2].should == 60
-      x_positions[3].should == 0
+      expect(x_positions[2]).to eq(60)
+      expect(x_positions[3]).to eq(0)
     end
 
     it "should indent from left side when document has :ltr direction" do
@@ -445,15 +438,15 @@ describe "#text" do
 
       x_positions = text.positions.map { |e| e[0] }
 
-      x_positions[0].should == 60
-      x_positions[1].should == 0
+      expect(x_positions[0]).to eq(60)
+      expect(x_positions[1]).to eq(0)
 
-      x_positions[2].should == 60
-      x_positions[3].should == 0
+      expect(x_positions[2]).to eq(60)
+      expect(x_positions[3]).to eq(0)
     end
 
-    describe "when wrap to new page, and first line of new page" +
-             " is not the start of a new paragraph, that line should" +
+    describe "when wrap to new page, and first line of new page" \
+             " is not the start of a new paragraph, that line should" \
              " not be indented" do
       it "should indent the paragraphs" do
         hello = "hello " * 50
@@ -461,14 +454,14 @@ describe "#text" do
         @pdf.move_cursor_to(@pdf.font.height)
         @pdf.text(hello + "\n" + hello2, :indent_paragraphs => 60)
         text = PDF::Inspector::Text.analyze(@pdf.render)
-        text.strings[0].should == ("hello " * 19).strip
-        text.strings[1].should == ("hello " * 21).strip
-        text.strings[3].should == ("hello " * 19).strip
-        text.strings[4].should == ("hello " * 21).strip
+        expect(text.strings[0]).to eq(("hello " * 19).strip)
+        expect(text.strings[1]).to eq(("hello " * 21).strip)
+        expect(text.strings[3]).to eq(("hello " * 19).strip)
+        expect(text.strings[4]).to eq(("hello " * 21).strip)
       end
     end
-    describe "when wrap to new page, and first line of new page" +
-             " is the start of a new paragraph, that line should" +
+    describe "when wrap to new page, and first line of new page" \
+             " is the start of a new paragraph, that line should" \
              " be indented" do
       it "should indent the paragraphs" do
         hello = "hello " * 50
@@ -476,10 +469,10 @@ describe "#text" do
         @pdf.move_cursor_to(@pdf.font.height * 3)
         @pdf.text(hello + "\n" + hello2, :indent_paragraphs => 60)
         text = PDF::Inspector::Text.analyze(@pdf.render)
-        text.strings[0].should == ("hello " * 19).strip
-        text.strings[1].should == ("hello " * 21).strip
-        text.strings[3].should == ("hello " * 19).strip
-        text.strings[4].should == ("hello " * 21).strip
+        expect(text.strings[0]).to eq(("hello " * 19).strip)
+        expect(text.strings[1]).to eq(("hello " * 21).strip)
+        expect(text.strings[3]).to eq(("hello " * 19).strip)
+        expect(text.strings[4]).to eq(("hello " * 21).strip)
       end
     end
   end
@@ -511,8 +504,7 @@ describe "#text" do
   end
 
   describe "#shrink_to_fit with special utf-8 text" do
-    it "Should not throw an exception",
-        :unresolved, :issue => 603 do
+    it "Should not throw an exception", :unresolved, :issue => 603 do
       pages = 0
       doc = Prawn::Document.new(page_size: 'A4', margin: [2, 2, 2, 2]) do |pdf|
         add_unicode_fonts(pdf)
@@ -524,15 +516,16 @@ describe "#text" do
     end
   end
 
-
   def add_unicode_fonts(pdf)
     dejavu = "#{::Prawn::BASEDIR}/data/fonts/DejaVuSans.ttf"
-    pdf.font_families.update("dejavu" => {
-      :normal      => dejavu,
-      :italic      => dejavu,
-      :bold        => dejavu,
-      :bold_italic => dejavu
-    })
+    pdf.font_families.update(
+      "dejavu" => {
+        :normal      => dejavu,
+        :italic      => dejavu,
+        :bold        => dejavu,
+        :bold_italic => dejavu
+      }
+    )
     pdf.fallback_fonts = ["dejavu"]
   end
 
@@ -548,10 +541,9 @@ describe "#text" do
       text = PDF::Inspector::Text.analyze(@pdf.render)
       fonts_used = text.font_settings.map { |e| e[:name] }
 
-      fonts_used.length.should == 1
-      fonts_used[0].should == :"Times-Italic"
-      text.strings[0].should == "hello"
+      expect(fonts_used.length).to eq(1)
+      expect(fonts_used[0]).to eq(:"Times-Italic")
+      expect(text.strings[0]).to eq("hello")
     end
   end
-
 end