prawn 2.0.1 → 2.0.2

data/spec/formatted_text_arranger_spec.rb

@@ -11,22 +11,22 @@ describe "Core::Text::Formatted::Arranger#format_array" do
              { :text => "are", :styles => [:bold, :italic] },
              { :text => " you?" }]
     arranger.format_array = array
-    arranger.unconsumed[0].should == { :text => "hello " }
-    arranger.unconsumed[1].should == { :text => "world how ",
-                                              :styles => [:bold] }
-    arranger.unconsumed[2].should == { :text => "are",
-                                              :styles => [:bold, :italic] }
-    arranger.unconsumed[3].should == { :text => " you?" }
+    expect(arranger.unconsumed[0]).to eq(:text => "hello ")
+    expect(arranger.unconsumed[1]).to eq(:text => "world how ",
+                                         :styles => [:bold])
+    expect(arranger.unconsumed[2]).to eq(:text => "are",
+                                         :styles => [:bold, :italic])
+    expect(arranger.unconsumed[3]).to eq(:text => " you?")
   end
   it "should split newlines into their own elements" do
     create_pdf
     arranger = Prawn::Text::Formatted::Arranger.new(@pdf)
     array = [{ :text => "\nhello\nworld" }]
     arranger.format_array = array
-    arranger.unconsumed[0].should == { :text => "\n" }
-    arranger.unconsumed[1].should == { :text => "hello" }
-    arranger.unconsumed[2].should == { :text => "\n" }
-    arranger.unconsumed[3].should == { :text => "world" }
+    expect(arranger.unconsumed[0]).to eq(:text => "\n")
+    expect(arranger.unconsumed[1]).to eq(:text => "hello")
+    expect(arranger.unconsumed[2]).to eq(:text => "\n")
+    expect(arranger.unconsumed[3]).to eq(:text => "world")
   end
 end
 describe "Core::Text::Formatted::Arranger#preview_next_string" do
@@ -36,14 +36,14 @@ describe "Core::Text::Formatted::Arranger#preview_next_string" do
     array = [{ :text => "hello" }]
     arranger.format_array = array
     arranger.preview_next_string
-    arranger.consumed.should == []
+    expect(arranger.consumed).to eq([])
   end
   it "should not consumed array" do
     create_pdf
     arranger = Prawn::Text::Formatted::Arranger.new(@pdf)
     array = [{ :text => "hello" }]
     arranger.format_array = array
-    arranger.preview_next_string.should == "hello"
+    expect(arranger.preview_next_string).to eq("hello")
   end
 end
 describe "Core::Text::Formatted::Arranger#next_string" do
@@ -56,22 +56,22 @@ describe "Core::Text::Formatted::Arranger#next_string" do
              { :text => " you?" }]
     @arranger.format_array = array
   end
-  it "should raise_error an error if called after a line was finalized and" +
+  it "should raise_error an error if called after a line was finalized and" \
      " before a new line was initialized" do
     @arranger.finalize_line
-    lambda do
+    expect do
       @arranger.next_string
-    end.should raise_error(RuntimeError)
+    end.to raise_error(RuntimeError)
   end
   it "should populate consumed array" do
     while string = @arranger.next_string
     end
-    @arranger.consumed[0].should == { :text => "hello " }
-    @arranger.consumed[1].should == { :text => "world how ",
-                                              :styles => [:bold] }
-    @arranger.consumed[2].should == { :text => "are",
-                                              :styles => [:bold, :italic] }
-    @arranger.consumed[3].should == { :text => " you?" }
+    expect(@arranger.consumed[0]).to eq(:text => "hello ")
+    expect(@arranger.consumed[1]).to eq(:text => "world how ",
+                                        :styles => [:bold])
+    expect(@arranger.consumed[2]).to eq(:text => "are",
+                                        :styles => [:bold, :italic])
+    expect(@arranger.consumed[3]).to eq(:text => " you?")
   end
   it "should populate current_format_state array" do
     create_pdf
@@ -85,13 +85,13 @@ describe "Core::Text::Formatted::Arranger#next_string" do
     while string = arranger.next_string
       case counter
       when 0
-        arranger.current_format_state.should == { }
+        expect(arranger.current_format_state).to eq({})
       when 1
-        arranger.current_format_state.should == { :styles => [:bold] }
+        expect(arranger.current_format_state).to eq(:styles => [:bold])
       when 2
-        arranger.current_format_state.should == { :styles => [:bold, :italic] }
+        expect(arranger.current_format_state).to eq(:styles => [:bold, :italic])
       when 3
-        arranger.current_format_state.should == { }
+        expect(arranger.current_format_state).to eq({})
       end
       counter += 1
     end
@@ -109,11 +109,11 @@ describe "Core::Text::Formatted::Arranger#retrieve_fragment" do
     arranger.format_array = array
     while string = arranger.next_string
     end
-    lambda do
+    expect do
       arranger.retrieve_fragment
-    end.should raise_error(RuntimeError)
+    end.to raise_error(RuntimeError)
   end
-  it "should return the consumed fragments in order of consumption" +
+  it "should return the consumed fragments in order of consumption" \
      " and update" do
     create_pdf
     arranger = Prawn::Text::Formatted::Arranger.new(@pdf)
@@ -125,10 +125,10 @@ describe "Core::Text::Formatted::Arranger#retrieve_fragment" do
     while string = arranger.next_string
     end
     arranger.finalize_line
-    arranger.retrieve_fragment.text.should == "hello "
-    arranger.retrieve_fragment.text.should == "world how "
-    arranger.retrieve_fragment.text.should == "are"
-    arranger.retrieve_fragment.text.should == " you?"
+    expect(arranger.retrieve_fragment.text).to eq("hello ")
+    expect(arranger.retrieve_fragment.text).to eq("world how ")
+    expect(arranger.retrieve_fragment.text).to eq("are")
+    expect(arranger.retrieve_fragment.text).to eq(" you?")
   end
   it "should never return a fragment whose text is an empty string" do
     create_pdf
@@ -147,7 +147,7 @@ describe "Core::Text::Formatted::Arranger#retrieve_fragment" do
     end
     arranger.finalize_line
     while fragment = arranger.retrieve_fragment
-      fragment.text.should_not be_empty
+      expect(fragment.text).not_to be_empty
     end
   end
   it "should not alter the current font style" do
@@ -162,12 +162,12 @@ describe "Core::Text::Formatted::Arranger#retrieve_fragment" do
     end
     arranger.finalize_line
     arranger.retrieve_fragment
-    arranger.current_format_state[:styles].should be_nil
+    expect(arranger.current_format_state[:styles]).to be_nil
   end
 end
 
 describe "Core::Text::Formatted::Arranger#update_last_string" do
-  it "should update the last retrieved string with what actually fit on" +
+  it "should update the last retrieved string with what actually fit on" \
      "the line and the list of unconsumed with what did not" do
     create_pdf
     arranger = Prawn::Text::Formatted::Arranger.new(@pdf)
@@ -179,10 +179,10 @@ describe "Core::Text::Formatted::Arranger#update_last_string" do
     while string = arranger.next_string
     end
     arranger.update_last_string(" you", " now?", nil)
-    arranger.consumed[3].should == { :text => " you",
-                                     :styles => [:bold, :italic] }
-    arranger.unconsumed.should == [{ :text => " now?",
-                                     :styles => [:bold, :italic] }]
+    expect(arranger.consumed[3]).to eq(:text => " you",
+                                       :styles => [:bold, :italic])
+    expect(arranger.unconsumed).to eq([{ :text => " now?",
+                                         :styles => [:bold, :italic] }])
   end
   it "should set the format state to the previously processed fragment" do
     create_pdf
@@ -193,24 +193,26 @@ describe "Core::Text::Formatted::Arranger#update_last_string" do
              { :text => " you now?" }]
     arranger.format_array = array
     3.times { arranger.next_string }
-    arranger.current_format_state.should == { :styles => [:bold, :italic] }
+    expect(arranger.current_format_state).to eq(:styles => [:bold, :italic])
     arranger.update_last_string("", "are", "-")
-    arranger.current_format_state.should == { :styles => [:bold] }
+    expect(arranger.current_format_state).to eq(:styles => [:bold])
   end
 
   context "when the entire string was used" do
     it "should not push empty string onto unconsumed" do
-    create_pdf
-    arranger = Prawn::Text::Formatted::Arranger.new(@pdf)
-    array = [{ :text => "hello " },
-             { :text => "world how ", :styles => [:bold] },
-             { :text => "are", :styles => [:bold, :italic] },
-             { :text => " you now?" }]
-    arranger.format_array = array
+      create_pdf
+      arranger = Prawn::Text::Formatted::Arranger.new(@pdf)
+      array = [
+        { :text => "hello " },
+        { :text => "world how ", :styles => [:bold] },
+        { :text => "are", :styles => [:bold, :italic] },
+        { :text => " you now?" }
+      ]
+      arranger.format_array = array
       while string = arranger.next_string
       end
       arranger.update_last_string(" you now?", "", nil)
-      arranger.unconsumed.should == []
+      expect(arranger.unconsumed).to eq([])
     end
   end
 end
@@ -227,17 +229,17 @@ describe "Core::Text::Formatted::Arranger#space_count" do
     end
   end
   it "should raise_error an error if called before finalize_line was called" do
-    lambda do
+    expect do
       @arranger.space_count
-    end.should raise_error(RuntimeError)
+    end.to raise_error(RuntimeError)
   end
   it "should return the total number of spaces in all fragments" do
     @arranger.finalize_line
-    @arranger.space_count.should == 4
+    expect(@arranger.space_count).to eq(4)
   end
 end
 describe "Core::Text::Formatted::Arranger#finalize_line" do
-  it "should make it so that all trailing white space fragments " +
+  it "should make it so that all trailing white space fragments " \
      "exclude trailing white space" do
     create_pdf
     arranger = Prawn::Text::Formatted::Arranger.new(@pdf)
@@ -248,16 +250,16 @@ describe "Core::Text::Formatted::Arranger#finalize_line" do
     while string = arranger.next_string
     end
     arranger.finalize_line
-    arranger.fragments.length.should == 3
+    expect(arranger.fragments.length).to eq(3)
 
     fragment = arranger.retrieve_fragment
-    fragment.text.should == "hello "
+    expect(fragment.text).to eq("hello ")
 
     fragment = arranger.retrieve_fragment
-    fragment.text.should == "world how"
+    expect(fragment.text).to eq("world how")
 
     fragment = arranger.retrieve_fragment
-    fragment.text.should == ""
+    expect(fragment.text).to eq("")
   end
 end
 
@@ -272,13 +274,13 @@ describe "Core::Text::Formatted::Arranger#line_width" do
     end
   end
   it "should raise_error an error if called before finalize_line was called" do
-    lambda do
+    expect do
       @arranger.line_width
-    end.should raise_error(RuntimeError)
+    end.to raise_error(RuntimeError)
   end
   it "should return the width of the complete line" do
     @arranger.finalize_line
-    @arranger.line_width.should be > 0
+    expect(@arranger.line_width).to be > 0
   end
 end
 
@@ -296,15 +298,14 @@ describe "Core::Text::Formatted::Arranger#line_width with character_spacing > 0"
 
     base_line_width = arranger.line_width
 
-
     array = [{ :text => "hello " },
              { :text => "world", :styles => [:bold],
-               :character_spacing => 7}]
+               :character_spacing => 7 }]
     arranger.format_array = array
     while string = arranger.next_string
     end
     arranger.finalize_line
-    arranger.line_width.should be > base_line_width
+    expect(arranger.line_width).to be > base_line_width
   end
 end
 
@@ -319,13 +320,13 @@ describe "Core::Text::Formatted::Arranger#line" do
     end
   end
   it "should raise_error an error if called before finalize_line was called" do
-    lambda do
+    expect do
       @arranger.line
-    end.should raise_error(RuntimeError)
+    end.to raise_error(RuntimeError)
   end
   it "should return the complete line" do
     @arranger.finalize_line
-    @arranger.line.should == "hello world"
+    expect(@arranger.line).to eq("hello world")
   end
 end
 
@@ -338,7 +339,7 @@ describe "Core::Text::Formatted::Arranger#unconsumed" do
              { :text => "are", :styles => [:bold, :italic] },
              { :text => " you now?" }]
     arranger.format_array = array
-    arranger.unconsumed.should == array
+    expect(arranger.unconsumed).to eq(array)
   end
   it "should return an empty array if everything was consumed" do
     create_pdf
@@ -350,7 +351,7 @@ describe "Core::Text::Formatted::Arranger#unconsumed" do
     arranger.format_array = array
     while string = arranger.next_string
     end
-    arranger.unconsumed.should == []
+    expect(arranger.unconsumed).to eq([])
   end
 end
 
@@ -366,7 +367,7 @@ describe "Core::Text::Formatted::Arranger#finished" do
     while string = arranger.next_string
     end
     arranger.update_last_string(" you", "now?", nil)
-    arranger.should_not be_finished
+    expect(arranger).not_to be_finished
   end
   it "should be_false if everything was printed" do
     create_pdf
@@ -378,7 +379,7 @@ describe "Core::Text::Formatted::Arranger#finished" do
     arranger.format_array = array
     while string = arranger.next_string
     end
-    arranger.should be_finished
+    expect(arranger).to be_finished
   end
 end
 
@@ -395,7 +396,7 @@ describe "Core::Text::Formatted::Arranger.max_line_height" do
     while string = arranger.next_string
     end
     arranger.finalize_line
-    arranger.max_line_height.should be_within(0.0001).of(33.32)
+    expect(arranger.max_line_height).to be_within(0.0001).of(33.32)
   end
 end
 
@@ -414,8 +415,9 @@ describe "Core::Text::Formatted::Arranger#repack_unretrieved" do
     arranger.retrieve_fragment
     arranger.retrieve_fragment
     arranger.repack_unretrieved
-    arranger.unconsumed.should == [
-             { :text => "are", :styles => [:bold, :italic] },
-             { :text => " you now?" }]
+    expect(arranger.unconsumed).to eq([
+      { :text => "are", :styles => [:bold, :italic] },
+      { :text => " you now?" }
+    ])
   end
 end

data/spec/formatted_text_box_spec.rb

@@ -9,13 +9,13 @@ describe "Text::Formatted::Box wrapping" do
 
   it "should not wrap between two fragments" do
     texts = [
-      {:text => "Hello "},
-      {:text => "World"},
-      {:text => "2", :styles => [:superscript]},
-      ]
+      { :text => "Hello " },
+      { :text => "World" },
+      { :text => "2", :styles => [:superscript] }
+    ]
     text_box = Prawn::Text::Formatted::Box.new(texts, :document => @pdf, :width => @pdf.width_of("Hello World"))
     text_box.render
-    text_box.text.should == "Hello\nWorld2"
+    expect(text_box.text).to eq("Hello\nWorld2")
   end
 
   it "should not raise an Encoding::CompatibilityError when keeping a TTF and an AFM font together" do
@@ -25,9 +25,11 @@ describe "Text::Formatted::Box wrapping" do
       :normal => { :file => file, :font => "Kai" }
     }
 
-    texts = [{ :text => "Hello " },
-              { :text => "再见", :font => "Kai"},
-              { :text => "World" }]
+    texts = [
+      { :text => "Hello " },
+      { :text => "再见", :font => "Kai" },
+      { :text => "World" }
+    ]
     text_box = Prawn::Text::Formatted::Box.new(texts, :document => @pdf, :width => @pdf.width_of("Hello World"))
 
     text_box.render
@@ -35,55 +37,55 @@ describe "Text::Formatted::Box wrapping" do
 
   it "should wrap between two fragments when the preceding fragment ends with white space" do
     texts = [
-      {:text => "Hello "},
-      {:text => "World "},
-      {:text => "2", :styles => [:superscript]},
-      ]
+      { :text => "Hello " },
+      { :text => "World " },
+      { :text => "2", :styles => [:superscript] }
+    ]
     text_box = Prawn::Text::Formatted::Box.new(texts, :document => @pdf, :width => @pdf.width_of("Hello World"))
     text_box.render
-    text_box.text.should == "Hello World\n2"
+    expect(text_box.text).to eq("Hello World\n2")
 
     texts = [
-      {:text => "Hello "},
-      {:text => "World\n"},
-      {:text => "2", :styles => [:superscript]},
-      ]
+      { :text => "Hello " },
+      { :text => "World\n" },
+      { :text => "2", :styles => [:superscript] }
+    ]
     text_box = Prawn::Text::Formatted::Box.new(texts, :document => @pdf, :width => @pdf.width_of("Hello World"))
     text_box.render
-    text_box.text.should == "Hello World\n2"
+    expect(text_box.text).to eq("Hello World\n2")
   end
 
   it "should wrap between two fragments when the final fragment begins with white space" do
     texts = [
-      {:text => "Hello "},
-      {:text => "World"},
-      {:text => " 2", :styles => [:superscript]},
-      ]
+      { :text => "Hello " },
+      { :text => "World" },
+      { :text => " 2", :styles => [:superscript] }
+    ]
     text_box = Prawn::Text::Formatted::Box.new(texts, :document => @pdf, :width => @pdf.width_of("Hello World"))
     text_box.render
-    text_box.text.should == "Hello World\n2"
+    expect(text_box.text).to eq("Hello World\n2")
 
     texts = [
-      {:text => "Hello "},
-      {:text => "World"},
-      {:text => "\n2", :styles => [:superscript]},
-      ]
+      { :text => "Hello " },
+      { :text => "World" },
+      { :text => "\n2", :styles => [:superscript] }
+    ]
     text_box = Prawn::Text::Formatted::Box.new(texts, :document => @pdf, :width => @pdf.width_of("Hello World"))
     text_box.render
-    text_box.text.should == "Hello World\n2"
+    expect(text_box.text).to eq("Hello World\n2")
   end
 
   it "should properly handle empty slices using default encoding" do
     texts = [{ :text => "Noua Delineatio Geographica generalis | Apostolicarum peregrinationum | S FRANCISCI XAUERII | Indiarum & Iaponiæ Apostoli", :font => 'Courier', :size => 10 }]
     text_box = Prawn::Text::Formatted::Box.new(texts, :document => @pdf, :width => @pdf.width_of("Noua Delineatio Geographica gen"))
-    lambda {
+    expect {
       text_box.render
-    }.should_not raise_error
-    text_box.text.should == "Noua Delineatio Geographica\ngeneralis | Apostolicarum\nperegrinationum | S FRANCISCI\nXAUERII | Indiarum & Iaponi\346\nApostoli"
+    }.not_to raise_error
+    expect(text_box.text).to eq("Noua Delineatio Geographica\ngeneralis | Apostolicarum\nperegrinationum | S FRANCISCI\nXAUERII | Indiarum & Iaponi\346\nApostoli")
   end
 end
 
-describe "Text::Formatted::Box with :fallback_fonts option that includes" +
+describe "Text::Formatted::Box with :fallback_fonts option that includes" \
   "a Chinese font and set of Chinese glyphs not in the current font" do
   it "should change the font to the Chinese font for the Chinese glyphs" do
     create_pdf
@@ -98,20 +100,20 @@ describe "Text::Formatted::Box with :fallback_fonts option that includes" +
     text = PDF::Inspector::Text.analyze(@pdf.render)
 
     fonts_used = text.font_settings.map { |e| e[:name] }
-    fonts_used.length.should == 4
-    fonts_used[0].should == :"Helvetica"
-    fonts_used[1].to_s.should =~ /GBZenKai-Medium/
-    fonts_used[2].to_s.should =~ /GBZenKai-Medium/
-    fonts_used[3].should == :"Helvetica"
+    expect(fonts_used.length).to eq(4)
+    expect(fonts_used[0]).to eq(:Helvetica)
+    expect(fonts_used[1].to_s).to match(/GBZenKai-Medium/)
+    expect(fonts_used[2].to_s).to match(/GBZenKai-Medium/)
+    expect(fonts_used[3]).to eq(:Helvetica)
 
-    text.strings[0].should == "hello"
-    text.strings[1].should == "你好"
-    text.strings[2].should == "再见"
-    text.strings[3].should == "goodbye"
+    expect(text.strings[0]).to eq("hello")
+    expect(text.strings[1]).to eq("你好")
+    expect(text.strings[2]).to eq("再见")
+    expect(text.strings[3]).to eq("goodbye")
   end
 end
 
-describe "Text::Formatted::Box with :fallback_fonts option that includes" +
+describe "Text::Formatted::Box with :fallback_fonts option that includes" \
   "an AFM font and Win-Ansi glyph not in the current Chinese font" do
   it "should change the font to the AFM font for the Win-Ansi glyph" do
     create_pdf
@@ -127,20 +129,20 @@ describe "Text::Formatted::Box with :fallback_fonts option that includes" +
     text = PDF::Inspector::Text.analyze(@pdf.render)
 
     fonts_used = text.font_settings.map { |e| e[:name] }
-    fonts_used.length.should == 4
-    fonts_used[0].to_s.should =~ /GBZenKai-Medium/
-    fonts_used[1].to_s.should =~ /GBZenKai-Medium/
-    fonts_used[2].to_s.should =~ /GBZenKai-Medium/
-    fonts_used[3].should == :"Helvetica"
+    expect(fonts_used.length).to eq(4)
+    expect(fonts_used[0].to_s).to match(/GBZenKai-Medium/)
+    expect(fonts_used[1].to_s).to match(/GBZenKai-Medium/)
+    expect(fonts_used[2].to_s).to match(/GBZenKai-Medium/)
+    expect(fonts_used[3]).to eq(:Helvetica)
 
-    text.strings[0].should == "hello"
-    text.strings[1].should == "你好"
-    text.strings[2].should == "再见"
-    text.strings[3].should == "€"
+    expect(text.strings[0]).to eq("hello")
+    expect(text.strings[1]).to eq("你好")
+    expect(text.strings[2]).to eq("再见")
+    expect(text.strings[3]).to eq("€")
   end
 end
 
-describe "Text::Formatted::Box with :fallback_fonts option and fragment " +
+describe "Text::Formatted::Box with :fallback_fonts option and fragment " \
   "level font" do
   it "should use the fragment level font except for glyphs not in that font" do
     create_pdf
@@ -161,16 +163,16 @@ describe "Text::Formatted::Box with :fallback_fonts option and fragment " +
     text = PDF::Inspector::Text.analyze(@pdf.render)
 
     fonts_used = text.font_settings.map { |e| e[:name] }
-    fonts_used.length.should == 4
-    fonts_used[0].should == :"Helvetica"
-    fonts_used[1].to_s.should =~ /GBZenKai-Medium/
-    fonts_used[2].to_s.should =~ /GBZenKai-Medium/
-    fonts_used[3].should == :"Times-Roman"
+    expect(fonts_used.length).to eq(4)
+    expect(fonts_used[0]).to eq(:Helvetica)
+    expect(fonts_used[1].to_s).to match(/GBZenKai-Medium/)
+    expect(fonts_used[2].to_s).to match(/GBZenKai-Medium/)
+    expect(fonts_used[3]).to eq(:"Times-Roman")
 
-    text.strings[0].should == "hello"
-    text.strings[1].should == "你好"
-    text.strings[2].should == "再见"
-    text.strings[3].should == "goodbye"
+    expect(text.strings[0]).to eq("hello")
+    expect(text.strings[1]).to eq("你好")
+    expect(text.strings[2]).to eq("再见")
+    expect(text.strings[3]).to eq("goodbye")
   end
 end
 
@@ -187,13 +189,12 @@ describe "Text::Formatted::Box" do
       :normal => { :file => file }
     }
 
-
     @formatted_text = [{ :text => "hello你好" }]
     @pdf.fallback_fonts(["Kai"])
     @pdf.fallback_fonts = ["Kai"]
   end
   it "#fallback_fonts should return the document-wide fallback fonts" do
-    @pdf.fallback_fonts.should == ["Kai"]
+    expect(@pdf.fallback_fonts).to eq(["Kai"])
   end
   it "should be able to set text fallback_fonts document-wide" do
     @pdf.formatted_text_box(@formatted_text)
@@ -201,9 +202,9 @@ describe "Text::Formatted::Box" do
     text = PDF::Inspector::Text.analyze(@pdf.render)
 
     fonts_used = text.font_settings.map { |e| e[:name] }
-    fonts_used.length.should == 2
-    fonts_used[0].should == :"Helvetica"
-    fonts_used[1].to_s.should =~ /GBZenKai-Medium/
+    expect(fonts_used.length).to eq(2)
+    expect(fonts_used[0]).to eq(:Helvetica)
+    expect(fonts_used[1].to_s).to match(/GBZenKai-Medium/)
   end
   it "should be able to override document-wide fallback_fonts" do
     @pdf.fallback_fonts = ["DejaVu Sans"]
@@ -212,11 +213,11 @@ describe "Text::Formatted::Box" do
     text = PDF::Inspector::Text.analyze(@pdf.render)
 
     fonts_used = text.font_settings.map { |e| e[:name] }
-    fonts_used.length.should == 2
-    fonts_used[0].should == :"Helvetica"
-    fonts_used[1].should =~ /Kai/
+    expect(fonts_used.length).to eq(2)
+    expect(fonts_used[0]).to eq(:Helvetica)
+    expect(fonts_used[1]).to match(/Kai/)
   end
-  it "should omit the fallback fonts overhead when passing an empty array " +
+  it "should omit the fallback fonts overhead when passing an empty array " \
     "as the :fallback_fonts" do
     @pdf.font("Kai")
 
@@ -240,17 +241,16 @@ describe "Text::Formatted::Box" do
   end
 end
 
-describe "Text::Formatted::Box with :fallback_fonts option " +
+describe "Text::Formatted::Box with :fallback_fonts option " \
   "with glyphs not in the primary or the fallback fonts" do
-
   it "should raise an exception" do
-   file = "#{Prawn::DATADIR}/fonts/gkai00mp.ttf"
+    file = "#{Prawn::DATADIR}/fonts/gkai00mp.ttf"
     create_pdf
     formatted_text = [{ :text => "hello world. 世界你好。" }]
 
-    lambda {
+    expect {
       @pdf.formatted_text_box(formatted_text, :fallback_fonts => ["Courier"])
-    }.should raise_error(Prawn::Errors::IncompatibleStringEncoding)
+    }.to raise_error(Prawn::Errors::IncompatibleStringEncoding)
   end
 end
 
@@ -261,16 +261,16 @@ describe "Text::Formatted::Box#extensions" do
     @pdf.formatted_text_box([{ :text => "hello world" }], {})
     Prawn::Text::Formatted::Box.extensions.delete(TestFormattedWrapOverride)
     text = PDF::Inspector::Text.analyze(@pdf.render)
-    text.strings[0].should == "all your base are belong to us"
+    expect(text.strings[0]).to eq("all your base are belong to us")
   end
-  it "overriding Text::Formatted::Box line wrapping should not affect " +
+  it "overriding Text::Formatted::Box line wrapping should not affect " \
      "Text::Box wrapping" do
     create_pdf
     Prawn::Text::Formatted::Box.extensions << TestFormattedWrapOverride
     @pdf.text_box("hello world", {})
     Prawn::Text::Formatted::Box.extensions.delete(TestFormattedWrapOverride)
     text = PDF::Inspector::Text.analyze(@pdf.render)
-    text.strings[0].should == "hello world"
+    expect(text.strings[0]).to eq("hello world")
   end
   it "overriding Text::Box line wrapping should override Text::Box wrapping" do
     create_pdf
@@ -278,73 +278,73 @@ describe "Text::Formatted::Box#extensions" do
     @pdf.text_box("hello world", {})
     Prawn::Text::Box.extensions.delete(TestFormattedWrapOverride)
     text = PDF::Inspector::Text.analyze(@pdf.render)
-    text.strings[0].should == "all your base are belong to us"
+    expect(text.strings[0]).to eq("all your base are belong to us")
   end
 end
 
 describe "Text::Formatted::Box#render" do
   it "should handle newlines" do
     create_pdf
-    array = [{ :text => "hello\nworld"}]
+    array = [{ :text => "hello\nworld" }]
     options = { :document => @pdf }
     text_box = Prawn::Text::Formatted::Box.new(array, options)
     text_box.render
-    text_box.text.should == "hello\nworld"
+    expect(text_box.text).to eq("hello\nworld")
   end
   it "should omit spaces from the beginning of the line" do
     create_pdf
-    array = [{ :text => " hello\n world"}]
+    array = [{ :text => " hello\n world" }]
     options = { :document => @pdf }
     text_box = Prawn::Text::Formatted::Box.new(array, options)
     text_box.render
-    text_box.text.should == "hello\nworld"
+    expect(text_box.text).to eq("hello\nworld")
   end
   it "should be okay printing a line of whitespace" do
     create_pdf
-    array = [{ :text => "hello\n    \nworld"}]
+    array = [{ :text => "hello\n    \nworld" }]
     options = { :document => @pdf }
     text_box = Prawn::Text::Formatted::Box.new(array, options)
     text_box.render
-    text_box.text.should == "hello\n\nworld"
+    expect(text_box.text).to eq("hello\n\nworld")
 
-
-    array = [{ :text => "hello" + " " * 500},
+    array = [{ :text => "hello" + " " * 500 },
              { :text => " " * 500 },
-             { :text => " " * 500 + "\n"},
-             { :text => "world"}]
+             { :text => " " * 500 + "\n" },
+             { :text => "world" }]
     options = { :document => @pdf }
     text_box = Prawn::Text::Formatted::Box.new(array, options)
     text_box.render
-    text_box.text.should == "hello\n\nworld"
+    expect(text_box.text).to eq("hello\n\nworld")
   end
   it "should enable fragment level direction setting" do
     create_pdf
     number_of_hellos = 18
     array = [
-             { :text => "hello " * number_of_hellos },
-             { :text => "world", :direction => :ltr },
-             { :text => ", how are you?" }
-            ]
+      { :text => "hello " * number_of_hellos },
+      { :text => "world", :direction => :ltr },
+      { :text => ", how are you?" }
+    ]
     options = { :document => @pdf, :direction => :rtl }
     text_box = Prawn::Text::Formatted::Box.new(array, options)
     text_box.render
     text = PDF::Inspector::Text.analyze(@pdf.render)
-    text.strings[0].should == "era woh ,"
-    text.strings[1].should == "world"
-    text.strings[2].should == " olleh" * number_of_hellos
-    text.strings[3].should == "?uoy"
+    expect(text.strings[0]).to eq("era woh ,")
+    expect(text.strings[1]).to eq("world")
+    expect(text.strings[2]).to eq(" olleh" * number_of_hellos)
+    expect(text.strings[3]).to eq("?uoy")
   end
 end
 
 describe "Text::Formatted::Box#render" do
   it "should be able to perform fragment callbacks" do
     create_pdf
-    callback_object = TestFragmentCallback.new("something", 7,
-                                               :document => @pdf)
+    callback_object = TestFragmentCallback.new("something", 7, :document => @pdf)
     callback_object.expects(:render_behind).with(
-                                      kind_of(Prawn::Text::Formatted::Fragment))
+      kind_of(Prawn::Text::Formatted::Fragment)
+    )
     callback_object.expects(:render_in_front).with(
-                                      kind_of(Prawn::Text::Formatted::Fragment))
+      kind_of(Prawn::Text::Formatted::Fragment)
+    )
     array = [{ :text => "hello world " },
              { :text => "callback now",
                :callback => callback_object }]
@@ -354,19 +354,21 @@ describe "Text::Formatted::Box#render" do
   it "should be able to perform fragment callbacks on multiple objects" do
     create_pdf
 
-    callback_object = TestFragmentCallback.new("something", 7,
-                                               :document => @pdf)
+    callback_object = TestFragmentCallback.new("something", 7, :document => @pdf)
     callback_object.expects(:render_behind).with(
-                                      kind_of(Prawn::Text::Formatted::Fragment))
+      kind_of(Prawn::Text::Formatted::Fragment)
+    )
     callback_object.expects(:render_in_front).with(
-                                      kind_of(Prawn::Text::Formatted::Fragment))
+      kind_of(Prawn::Text::Formatted::Fragment)
+    )
 
-    callback_object2 = TestFragmentCallback.new("something else", 14,
-                                               :document => @pdf)
+    callback_object2 = TestFragmentCallback.new("something else", 14, :document => @pdf)
     callback_object2.expects(:render_behind).with(
-                                      kind_of(Prawn::Text::Formatted::Fragment))
+      kind_of(Prawn::Text::Formatted::Fragment)
+    )
     callback_object2.expects(:render_in_front).with(
-                                      kind_of(Prawn::Text::Formatted::Fragment))
+      kind_of(Prawn::Text::Formatted::Fragment)
+    )
 
     array = [{ :text => "hello world " },
              { :text => "callback now",
@@ -398,10 +400,10 @@ describe "Text::Formatted::Box#render" do
     text_box.render
     contents = PDF::Inspector::Text.analyze(@pdf.render)
     fonts = contents.font_settings.map { |e| e[:name] }
-    fonts.should == [:Helvetica, :"Times-Bold", :Helvetica]
-    contents.strings[0].should == "this contains "
-    contents.strings[1].should == "Times-Bold"
-    contents.strings[2].should == " text"
+    expect(fonts).to eq([:Helvetica, :"Times-Bold", :Helvetica])
+    expect(contents.strings[0]).to eq("this contains ")
+    expect(contents.strings[1]).to eq("Times-Bold")
+    expect(contents.strings[2]).to eq(" text")
   end
   it "should be able to set bold" do
     create_pdf
@@ -412,10 +414,10 @@ describe "Text::Formatted::Box#render" do
     text_box.render
     contents = PDF::Inspector::Text.analyze(@pdf.render)
     fonts = contents.font_settings.map { |e| e[:name] }
-    fonts.should == [:Helvetica, :"Helvetica-Bold", :Helvetica]
-    contents.strings[0].should == "this contains "
-    contents.strings[1].should == "bold"
-    contents.strings[2].should == " text"
+    expect(fonts).to eq([:Helvetica, :"Helvetica-Bold", :Helvetica])
+    expect(contents.strings[0]).to eq("this contains ")
+    expect(contents.strings[1]).to eq("bold")
+    expect(contents.strings[2]).to eq(" text")
   end
   it "should be able to set italics" do
     create_pdf
@@ -426,7 +428,7 @@ describe "Text::Formatted::Box#render" do
     text_box.render
     contents = PDF::Inspector::Text.analyze(@pdf.render)
     fonts = contents.font_settings.map { |e| e[:name] }
-    fonts.should == [:Helvetica, :"Helvetica-Oblique", :Helvetica]
+    expect(fonts).to eq([:Helvetica, :"Helvetica-Oblique", :Helvetica])
   end
   it "should be able to set subscript" do
     create_pdf
@@ -436,8 +438,8 @@ describe "Text::Formatted::Box#render" do
     text_box = Prawn::Text::Formatted::Box.new(array, :document => @pdf)
     text_box.render
     contents = PDF::Inspector::Text.analyze(@pdf.render)
-    contents.font_settings[0][:size].should == 12
-    contents.font_settings[1][:size].should be_within(0.0001).of(18 * 0.583)
+    expect(contents.font_settings[0][:size]).to eq(12)
+    expect(contents.font_settings[1][:size]).to be_within(0.0001).of(18 * 0.583)
   end
   it "should be able to set superscript" do
     create_pdf
@@ -447,8 +449,8 @@ describe "Text::Formatted::Box#render" do
     text_box = Prawn::Text::Formatted::Box.new(array, :document => @pdf)
     text_box.render
     contents = PDF::Inspector::Text.analyze(@pdf.render)
-    contents.font_settings[0][:size].should == 12
-    contents.font_settings[1][:size].should be_within(0.0001).of(18 * 0.583)
+    expect(contents.font_settings[0][:size]).to eq(12)
+    expect(contents.font_settings[1][:size]).to be_within(0.0001).of(18 * 0.583)
   end
   it "should be able to set compound bold and italic text" do
     create_pdf
@@ -459,7 +461,7 @@ describe "Text::Formatted::Box#render" do
     text_box.render
     contents = PDF::Inspector::Text.analyze(@pdf.render)
     fonts = contents.font_settings.map { |e| e[:name] }
-    fonts.should == [:Helvetica, :"Helvetica-BoldOblique", :Helvetica]
+    expect(fonts).to eq([:Helvetica, :"Helvetica-BoldOblique", :Helvetica])
   end
   it "should be able to underline" do
     create_pdf
@@ -469,7 +471,7 @@ describe "Text::Formatted::Box#render" do
     text_box = Prawn::Text::Formatted::Box.new(array, :document => @pdf)
     text_box.render
     line_drawing = PDF::Inspector::Graphics::Line.analyze(@pdf.render)
-    line_drawing.points.length.should == 2
+    expect(line_drawing.points.length).to eq(2)
   end
   it "should be able to strikethrough" do
     create_pdf
@@ -479,12 +481,16 @@ describe "Text::Formatted::Box#render" do
     text_box = Prawn::Text::Formatted::Box.new(array, :document => @pdf)
     text_box.render
     line_drawing = PDF::Inspector::Graphics::Line.analyze(@pdf.render)
-    line_drawing.points.length.should == 2
+    expect(line_drawing.points.length).to eq(2)
   end
   it "should be able to add URL links" do
     create_pdf
-    @pdf.expects(:link_annotation).with(kind_of(Array), :Border => [0,0,0],
-           :A => { :Type => :Action, :S => :URI, :URI => "http://example.com" })
+    @pdf.expects(:link_annotation).with(kind_of(Array), :Border => [0, 0, 0],
+                                                        :A => {
+                                                          :Type => :Action,
+                                                          :S => :URI,
+                                                          :URI => "http://example.com"
+                                                        })
     array = [{ :text => "click " },
              { :text => "here", :link => "http://example.com" },
              { :text => " to visit" }]
@@ -493,8 +499,8 @@ describe "Text::Formatted::Box#render" do
   end
   it "should be able to add destination links" do
     create_pdf
-    @pdf.expects(:link_annotation).with(kind_of(Array), :Border => [0,0,0],
-                                        :Dest => "ToC")
+    @pdf.expects(:link_annotation).with(kind_of(Array), :Border => [0, 0, 0],
+                                                        :Dest => "ToC")
     array = [{ :text => "Go to the " },
              { :text => "Table of Contents", :anchor => "ToC" }]
     text_box = Prawn::Text::Formatted::Box.new(array, :document => @pdf)
@@ -502,8 +508,13 @@ describe "Text::Formatted::Box#render" do
   end
   it "should be able to add local actions" do
     create_pdf
-    @pdf.expects(:link_annotation).with(kind_of(Array), :Border => [0,0,0],
-           :A => { :Type => :Action, :S => :Launch, :F => "../example.pdf", :NewWindow => true })
+    @pdf.expects(:link_annotation).with(kind_of(Array), :Border => [0, 0, 0],
+                                                        :A => {
+                                                          :Type => :Action,
+                                                          :S => :Launch,
+                                                          :F => "../example.pdf",
+                                                          :NewWindow => true
+                                                        })
     array = [{ :text => "click " },
              { :text => "here", :local => "../example.pdf" },
              { :text => " to open a local file" }]
@@ -518,8 +529,8 @@ describe "Text::Formatted::Box#render" do
     text_box = Prawn::Text::Formatted::Box.new(array, :document => @pdf)
     text_box.render
     contents = PDF::Inspector::Text.analyze(@pdf.render)
-    contents.font_settings[0][:size].should == 12
-    contents.font_settings[1][:size].should == 24
+    expect(contents.font_settings[0][:size]).to eq(12)
+    expect(contents.font_settings[1][:size]).to eq(24)
   end
   it "should set the baseline based on the tallest fragment on a given line" do
     create_pdf
@@ -529,7 +540,7 @@ describe "Text::Formatted::Box#render" do
     text_box = Prawn::Text::Formatted::Box.new(array, :document => @pdf)
     text_box.render
     @pdf.font_size(24) do
-      text_box.height.should be_within(0.001).of(@pdf.font.ascender + @pdf.font.descender)
+      expect(text_box.height).to be_within(0.001).of(@pdf.font.ascender + @pdf.font.descender)
     end
   end
   it "should be able to set color via an rgb hex string" do
@@ -539,8 +550,8 @@ describe "Text::Formatted::Box#render" do
     text_box = Prawn::Text::Formatted::Box.new(array, :document => @pdf)
     text_box.render
     colors = PDF::Inspector::Graphics::Color.analyze(@pdf.render)
-    colors.fill_color_count.should == 2
-    colors.stroke_color_count.should == 2
+    expect(colors.fill_color_count).to eq(2)
+    expect(colors.stroke_color_count).to eq(2)
   end
   it "should be able to set color using a cmyk array" do
     create_pdf
@@ -549,8 +560,8 @@ describe "Text::Formatted::Box#render" do
     text_box = Prawn::Text::Formatted::Box.new(array, :document => @pdf)
     text_box.render
     colors = PDF::Inspector::Graphics::Color.analyze(@pdf.render)
-    colors.fill_color_count.should == 2
-    colors.stroke_color_count.should == 2
+    expect(colors.fill_color_count).to eq(2)
+    expect(colors.stroke_color_count).to eq(2)
   end
 end
 
@@ -570,9 +581,9 @@ describe "Text::Formatted::Box#render(:dry_run => true)" do
     text_box.render(:dry_run => true)
 
     state_after = PDF::Inspector::Graphics::Color.analyze(@pdf.render)
-    state_after.fill_color_count.should == fill_color_count
-    state_after.stroke_color_count.should == stroke_color_count
-    state_after.stroke_color_space_count.should == stroke_color_space_count
+    expect(state_after.fill_color_count).to eq(fill_color_count)
+    expect(state_after.stroke_color_count).to eq(stroke_color_count)
+    expect(state_after.stroke_color_space_count).to eq(stroke_color_space_count)
   end
 end
 
@@ -585,7 +596,7 @@ describe "Text::Formatted::Box#render with fragment level :character_spacing opt
     text_box = Prawn::Text::Formatted::Box.new(array, options)
     text_box.render
     contents = PDF::Inspector::Text.analyze(@pdf.render)
-    contents.character_spacing[0].should == 7
+    expect(contents.character_spacing[0]).to eq(7)
   end
   it "should draw the character spacing to the document" do
     create_pdf
@@ -597,7 +608,7 @@ describe "Text::Formatted::Box#render with fragment level :character_spacing opt
                 :overflow => :expand }
     text_box = Prawn::Text::Formatted::Box.new(array, options)
     text_box.render
-    text_box.text.should == "hello\nworld"
+    expect(text_box.text).to eq("hello\nworld")
   end
 end
 
@@ -611,7 +622,7 @@ describe "Text::Formatted::Box#render with :align => :justify" do
     text_box = Prawn::Text::Formatted::Box.new(array, options)
     text_box.render
     contents = PDF::Inspector::Text.analyze(@pdf.render)
-    contents.word_spacing.should be_empty
+    expect(contents.word_spacing).to be_empty
   end
 end
 
@@ -622,19 +633,19 @@ describe "Text::Formatted::Box#render with :valign => :center" do
     y = 450
     array = [{ :text => 'Vertical Align' }]
     options = {
-     :document => @pdf,
-     :valign => :center,
-     :at => [0,y],
-     :width => 100,
-     :height => box_height,
-     :size => 16
+      :document => @pdf,
+      :valign => :center,
+      :at => [0, y],
+      :width => 100,
+      :height => box_height,
+      :size => 16
     }
     text_box = Prawn::Text::Formatted::Box.new(array, options)
     text_box.render
     line_padding = (box_height - text_box.height + text_box.descender) * 0.5
     baseline = y - line_padding
 
-    text_box.at[1].should be_within(0.01).of(baseline)
+    expect(text_box.at[1]).to be_within(0.01).of(baseline)
   end
 end
 
@@ -645,18 +656,18 @@ describe "Text::Formatted::Box#render with :valign => :bottom" do
     y = 450
     array = [{ :text => 'Vertical Align' }]
     options = {
-     :document => @pdf,
-     :valign => :bottom,
-     :at => [0,y],
-     :width => 100,
-     :height => box_height,
-     :size => 16
+      :document => @pdf,
+      :valign => :bottom,
+      :at => [0, y],
+      :width => 100,
+      :height => box_height,
+      :size => 16
     }
     text_box = Prawn::Text::Formatted::Box.new(array, options)
     text_box.render
     top_padding = y - (box_height - text_box.height)
 
-    text_box.at[1].should be_within(0.01).of(top_padding)
+    expect(text_box.at[1]).to be_within(0.01).of(top_padding)
   end
 end