prawn 2.0.1 → 2.0.2

data/spec/jpg_spec.rb

@@ -7,7 +7,6 @@
 require File.join(File.expand_path(File.dirname(__FILE__)), "spec_helper")
 
 describe "When reading a JPEG file" do
-
   before(:each) do
     @filename = "#{Prawn::DATADIR}/images/pigs.jpg"
     @img_data = File.open(@filename, "rb") { |f| f.read }
@@ -16,10 +15,9 @@ describe "When reading a JPEG file" do
   it "should read the basic attributes correctly" do
     jpg = Prawn::Images::JPG.new(@img_data)
 
-    jpg.width.should == 604
-    jpg.height.should == 453
-    jpg.bits.should == 8
-    jpg.channels.should == 3
+    expect(jpg.width).to eq(604)
+    expect(jpg.height).to eq(453)
+    expect(jpg.bits).to eq(8)
+    expect(jpg.channels).to eq(3)
   end
 end
-

data/spec/line_wrap_spec.rb

@@ -14,31 +14,31 @@ describe "Core::Text::Formatted::LineWrap#wrap_line" do
              { :text => "goodbye  ", :style => [:bold] }]
     @arranger.format_array = array
     string = @line_wrap.wrap_line(:arranger => @arranger,
-                                 :width => 300,
-                                 :document => @pdf)
-    string.should == "hello world, goodbye"
+                                  :width => 300,
+                                  :document => @pdf)
+    expect(string).to eq("hello world, goodbye")
   end
-  it "should strip trailing spaces when a white-space-only fragment was" +
-     " successfully pushed onto the end of a line but no other non-white" +
+  it "should strip trailing spaces when a white-space-only fragment was" \
+     " successfully pushed onto the end of a line but no other non-white" \
      " space fragment fits after it" do
     array = [{ :text => "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa " },
              { :text => "  ", :style => [:bold] },
              { :text => " bbbbbbbbbbbbbbbbbbbbbbbbbbbb" }]
     @arranger.format_array = array
     string = @line_wrap.wrap_line(:arranger => @arranger,
-                                 :width => 300,
-                                 :document => @pdf)
-    string.should == "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
+                                  :width => 300,
+                                  :document => @pdf)
+    expect(string).to eq("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa")
   end
   it "should raise_error CannotFit if a too-small width is given" do
     array = [{ :text => " hello world, " },
              { :text => "goodbye  ", :style => [:bold] }]
     @arranger.format_array = array
-    lambda do
+    expect do
       @line_wrap.wrap_line(:arranger => @arranger,
                            :width => 1,
                            :document => @pdf)
-    end.should raise_error(Prawn::Errors::CannotFit)
+    end.to raise_error(Prawn::Errors::CannotFit)
   end
 
   it "should break on space" do
@@ -47,7 +47,7 @@ describe "Core::Text::Formatted::LineWrap#wrap_line" do
     string = @line_wrap.wrap_line(:arranger => @arranger,
                                   :width => @one_word_width,
                                   :document => @pdf)
-    string.should == "hello"
+    expect(string).to eq("hello")
   end
 
   it "should break on zero-width space" do
@@ -57,7 +57,7 @@ describe "Core::Text::Formatted::LineWrap#wrap_line" do
     string = @line_wrap.wrap_line(:arranger => @arranger,
                                   :width => @one_word_width,
                                   :document => @pdf)
-    string.should == "hello"
+    expect(string).to eq("hello")
   end
 
   it "should not display zero-width space" do
@@ -67,7 +67,7 @@ describe "Core::Text::Formatted::LineWrap#wrap_line" do
     string = @line_wrap.wrap_line(:arranger => @arranger,
                                   :width => 300,
                                   :document => @pdf)
-    string.should == "helloworld"
+    expect(string).to eq("helloworld")
   end
 
   it "should break on tab" do
@@ -76,7 +76,7 @@ describe "Core::Text::Formatted::LineWrap#wrap_line" do
     string = @line_wrap.wrap_line(:arranger => @arranger,
                                   :width => @one_word_width,
                                   :document => @pdf)
-    string.should == "hello"
+    expect(string).to eq("hello")
   end
 
   it "should break on hyphens" do
@@ -85,24 +85,24 @@ describe "Core::Text::Formatted::LineWrap#wrap_line" do
     string = @line_wrap.wrap_line(:arranger => @arranger,
                                   :width => @one_word_width,
                                   :document => @pdf)
-    string.should == "hello-"
+    expect(string).to eq("hello-")
   end
 
-  it "should not break after a hyphen that follows white space and" +
+  it "should not break after a hyphen that follows white space and" \
      "precedes a word" do
     array = [{ :text => "hello -" }]
     @arranger.format_array = array
     string = @line_wrap.wrap_line(:arranger => @arranger,
                                   :width => @one_word_width,
                                   :document => @pdf)
-    string.should == "hello -"
+    expect(string).to eq("hello -")
 
     array = [{ :text => "hello -world" }]
     @arranger.format_array = array
     string = @line_wrap.wrap_line(:arranger => @arranger,
                                   :width => @one_word_width,
                                   :document => @pdf)
-    string.should == "hello"
+    expect(string).to eq("hello")
   end
 
   it "should break on a soft hyphen" do
@@ -114,7 +114,7 @@ describe "Core::Text::Formatted::LineWrap#wrap_line" do
                                   :document => @pdf)
     expected = @pdf.font.normalize_encoding("hello#{Prawn::Text::SHY}")
     expected.force_encoding(Encoding::UTF_8)
-    string.should == expected
+    expect(string).to eq(expected)
 
     @pdf.font("#{Prawn::DATADIR}/fonts/DejaVuSans.ttf")
     @line_wrap = Prawn::Text::Formatted::LineWrap.new
@@ -125,16 +125,16 @@ describe "Core::Text::Formatted::LineWrap#wrap_line" do
     string = @line_wrap.wrap_line(:arranger => @arranger,
                                   :width => @one_word_width,
                                   :document => @pdf)
-    string.should == "hello#{Prawn::Text::SHY}"
+    expect(string).to eq("hello#{Prawn::Text::SHY}")
   end
 
-  it "should ignore width of a soft-hyphen during adding fragments to line", :issue =>775 do
+  it "should ignore width of a soft-hyphen during adding fragments to line", :issue => 775 do
     hyphen_string = "Hy#{Prawn::Text::SHY}phe#{Prawn::Text::SHY}nat#{Prawn::Text::SHY}ions "
     string1 = @pdf.font.normalize_encoding(hyphen_string * 5)
     string2 = @pdf.font.normalize_encoding("Hyphenations " * 3 + hyphen_string)
 
-    array1 = [{text: string1}]
-    array2 = [{text: string2}]
+    array1 = [{ text: string1 }]
+    array2 = [{ text: string2 }]
 
     @arranger.format_array = array1
 
@@ -149,10 +149,10 @@ describe "Core::Text::Formatted::LineWrap#wrap_line" do
     res2 = @line_wrap.wrap_line(:arranger => @arranger,
                                 :width => 300,
                                 :document => @pdf)
-    res1.should == res2
+    expect(res1).to eq(res2)
   end
 
-  it "should not display soft hyphens except at the end of a line " +
+  it "should not display soft hyphens except at the end of a line " \
      "for more than one element in format_array", :issue => 347 do
     @pdf.font("#{Prawn::DATADIR}/fonts/DejaVuSans.ttf")
     @line_wrap = Prawn::Text::Formatted::LineWrap.new
@@ -164,7 +164,7 @@ describe "Core::Text::Formatted::LineWrap#wrap_line" do
     string = @line_wrap.wrap_line(:arranger => @arranger,
                                   :width => 300,
                                   :document => @pdf)
-    string.should == "helloworld hiearth"
+    expect(string).to eq("helloworld hiearth")
   end
 
   it "should not break before a hard hyphen that follows a word" do
@@ -175,14 +175,14 @@ describe "Core::Text::Formatted::LineWrap#wrap_line" do
     string = @line_wrap.wrap_line(:arranger => @arranger,
                                   :width => enough_width_for_hello_world,
                                   :document => @pdf)
-    string.should == "hello world"
+    expect(string).to eq("hello world")
 
     array = [{ :text => "hello world-" }]
     @arranger.format_array = array
     string = @line_wrap.wrap_line(:arranger => @arranger,
                                   :width => enough_width_for_hello_world,
                                   :document => @pdf)
-    string.should == "hello"
+    expect(string).to eq("hello")
 
     @pdf.font("#{Prawn::DATADIR}/fonts/DejaVuSans.ttf")
     @line_wrap = Prawn::Text::Formatted::LineWrap.new
@@ -193,17 +193,17 @@ describe "Core::Text::Formatted::LineWrap#wrap_line" do
     string = @line_wrap.wrap_line(:arranger => @arranger,
                                   :width => enough_width_for_hello_world,
                                   :document => @pdf)
-    string.should == "hello world"
+    expect(string).to eq("hello world")
 
     array = [{ :text => "hello world-" }]
     @arranger.format_array = array
     string = @line_wrap.wrap_line(:arranger => @arranger,
                                   :width => enough_width_for_hello_world,
                                   :document => @pdf)
-    string.should == "hello"
+    expect(string).to eq("hello")
   end
 
-  it "should not break after a hard hyphen that follows a soft hyphen and" +
+  it "should not break after a hard hyphen that follows a soft hyphen and" \
     "precedes a word" do
     string = @pdf.font.normalize_encoding("hello#{Prawn::Text::SHY}-")
     array = [{ :text => string }]
@@ -211,7 +211,7 @@ describe "Core::Text::Formatted::LineWrap#wrap_line" do
     string = @line_wrap.wrap_line(:arranger => @arranger,
                                   :width => @one_word_width,
                                   :document => @pdf)
-    string.should == "hello-"
+    expect(string).to eq("hello-")
 
     string = @pdf.font.normalize_encoding("hello#{Prawn::Text::SHY}-world")
     array = [{ :text => string }]
@@ -221,7 +221,7 @@ describe "Core::Text::Formatted::LineWrap#wrap_line" do
                                   :document => @pdf)
     expected = @pdf.font.normalize_encoding("hello#{Prawn::Text::SHY}")
     expected.force_encoding(Encoding::UTF_8)
-    string.should == expected
+    expect(string).to eq(expected)
 
     @pdf.font("#{Prawn::DATADIR}/fonts/DejaVuSans.ttf")
     @line_wrap = Prawn::Text::Formatted::LineWrap.new
@@ -232,7 +232,7 @@ describe "Core::Text::Formatted::LineWrap#wrap_line" do
     string = @line_wrap.wrap_line(:arranger => @arranger,
                                   :width => @one_word_width,
                                   :document => @pdf)
-    string.should == "hello-"
+    expect(string).to eq("hello-")
 
     string = "hello#{Prawn::Text::SHY}-world"
     array = [{ :text => string }]
@@ -240,7 +240,7 @@ describe "Core::Text::Formatted::LineWrap#wrap_line" do
     string = @line_wrap.wrap_line(:arranger => @arranger,
                                   :width => @one_word_width,
                                   :document => @pdf)
-    string.should == "hello#{Prawn::Text::SHY}"
+    expect(string).to eq("hello#{Prawn::Text::SHY}")
   end
 
   it "should process UTF-8 chars", :unresolved, :issue => 693 do
@@ -251,7 +251,7 @@ describe "Core::Text::Formatted::LineWrap#wrap_line" do
     string = @line_wrap.wrap_line(:arranger => @arranger,
                                   :width => 300,
                                   :document => @pdf)
-    string.should == "Ｔｅｓｔ"
+    expect(string).to eq("Ｔｅｓｔ")
   end
 end
 
@@ -266,18 +266,18 @@ describe "Core::Text::Formatted::LineWrap#space_count" do
              { :text => "goodbye", :style => [:bold] }]
     @arranger.format_array = array
     @line_wrap.wrap_line(:arranger => @arranger,
-                        :width => 300,
-                        :document => @pdf)
-    @line_wrap.space_count.should == 2
+                         :width => 300,
+                         :document => @pdf)
+    expect(@line_wrap.space_count).to eq(2)
   end
   it "should exclude preceding and trailing spaces from the count" do
     array = [{ :text => " hello world, " },
              { :text => "goodbye  ", :style => [:bold] }]
     @arranger.format_array = array
     @line_wrap.wrap_line(:arranger => @arranger,
-                        :width => 300,
-                        :document => @pdf)
-    @line_wrap.space_count.should == 2
+                         :width => 300,
+                         :document => @pdf)
+    expect(@line_wrap.space_count).to eq(2)
   end
 end
 
@@ -296,22 +296,22 @@ describe "Core::Text::Formatted::LineWrap" do
     @arranger.format_array = array
     @line_wrap = Prawn::Text::Formatted::LineWrap.new
   end
-  it "should only return an empty string if nothing fit or there" +
+  it "should only return an empty string if nothing fit or there" \
      "was nothing to wrap" do
     8.times do
       line = @line_wrap.wrap_line(:arranger => @arranger,
-                                 :width => 200,
-                                 :document => @pdf)
-      line.should_not be_empty
+                                  :width => 200,
+                                  :document => @pdf)
+      expect(line).not_to be_empty
     end
     line = @line_wrap.wrap_line(:arranger => @arranger,
-                               :width => 200,
-                               :document => @pdf)
-    line.should be_empty
+                                :width => 200,
+                                :document => @pdf)
+    expect(line).to be_empty
   end
   it "should tokenize a string using the scan_pattern" do
     tokens = @line_wrap.tokenize("one two three")
-    tokens.length.should == 6
+    expect(tokens.length).to eq(6)
   end
 end
 
@@ -329,7 +329,7 @@ describe "Core::Text::Formatted::LineWrap#paragraph_finished?" do
                                   :width => @one_word_width,
                                   :document => @pdf)
 
-    @line_wrap.paragraph_finished?.should == false
+    expect(@line_wrap.paragraph_finished?).to eq(false)
   end
   it "should be_true when the last printed line is the last fragment to print" do
     array = [{ :text => "hello world" }]
@@ -341,7 +341,7 @@ describe "Core::Text::Formatted::LineWrap#paragraph_finished?" do
                                   :width => @one_word_width,
                                   :document => @pdf)
 
-    @line_wrap.paragraph_finished?.should == true
+    expect(@line_wrap.paragraph_finished?).to eq(true)
   end
   it "should be_true when a newline exists on the current line" do
     array = [{ :text => "hello\n world" }]
@@ -350,7 +350,7 @@ describe "Core::Text::Formatted::LineWrap#paragraph_finished?" do
                                   :width => @one_word_width,
                                   :document => @pdf)
 
-    @line_wrap.paragraph_finished?.should == true
+    expect(@line_wrap.paragraph_finished?).to eq(true)
   end
   it "should be_true when a newline exists in the next fragment" do
     array = [{ :text => "hello " },
@@ -361,7 +361,6 @@ describe "Core::Text::Formatted::LineWrap#paragraph_finished?" do
                                   :width => @one_word_width,
                                   :document => @pdf)
 
-    @line_wrap.paragraph_finished?.should == true
+    expect(@line_wrap.paragraph_finished?).to eq(true)
   end
 end
-

data/spec/measurement_units_spec.rb

@@ -4,22 +4,19 @@ require File.join(File.expand_path(File.dirname(__FILE__)), "spec_helper")
 require "prawn/measurement_extensions"
 
 describe "Measurement units" do
-
   it "should convert units to PostScriptPoints" do
-    1.mm.should be_within(0.000000001).of(2.834645669)
-    1.mm.should == (72 / 25.4)
-    2.mm.should == (2 * 72 / 25.4)
-    3.mm.should == 3 * 72 / 25.4
-    -3.mm.should == -3 * 72/25.4
-    1.cm.should == 10 * 72 / 25.4
-    1.dm.should == 100 * 72 / 25.4
-    1.m.should == 1000 * 72 / 25.4
+    expect(1.mm).to be_within(0.000000001).of(2.834645669)
+    expect(1.mm).to eq(72 / 25.4)
+    expect(2.mm).to eq(2 * 72 / 25.4)
+    expect(3.mm).to eq(3 * 72 / 25.4)
+    expect(-3.mm).to eq(-3 * 72 / 25.4)
+    expect(1.cm).to eq(10 * 72 / 25.4)
+    expect(1.dm).to eq(100 * 72 / 25.4)
+    expect(1.m).to eq(1000 * 72 / 25.4)
 
-    1.in.should == 72
-    1.ft.should == 72 * 12
-    1.yd.should == 72 * 12 * 3
-    1.pt.should == 1
+    expect(1.in).to eq(72)
+    expect(1.ft).to eq(72 * 12)
+    expect(1.yd).to eq(72 * 12 * 3)
+    expect(1.pt).to eq(1)
   end
-
 end
-

data/spec/outline_spec.rb

@@ -3,7 +3,7 @@ require File.join(File.expand_path(File.dirname(__FILE__)), "spec_helper")
 
 describe "Outline" do
   before(:each) do
-    @pdf = Prawn::Document.new() do
+    @pdf = Prawn::Document.new do
       text "Page 1. This is the first Chapter. "
       start_new_page
       text "Page 2. More in the first Chapter. "
@@ -24,7 +24,7 @@ describe "Outline" do
         if obj.is_a?(Hash) && obj[:Title]
           title = obj[:Title].dup
           title.force_encoding(Encoding::UTF_16LE)
-          title.valid_encoding?.should == true
+          expect(title.valid_encoding?).to eq(true)
         end
       end
     end
@@ -36,55 +36,50 @@ describe "Outline" do
     end
 
     it "should create a root outline dictionary item" do
-      @outline_root.should_not be_nil
+      expect(@outline_root).not_to be_nil
     end
 
     it "should set the first and last top items of the root outline dictionary item" do
-      referenced_object(@outline_root[:First]).should == @section_1
-      referenced_object(@outline_root[:Last]).should == @section_1
+      expect(referenced_object(@outline_root[:First])).to eq(@section_1)
+      expect(referenced_object(@outline_root[:Last])).to eq(@section_1)
     end
 
     describe "#create_outline_item" do
       it "should create outline items for each section and page" do
-        [@section_1, @page_1, @page_2].each {|item| item.should_not be_nil}
+        [@section_1, @page_1, @page_2].each { |item| expect(item).not_to be_nil }
       end
     end
 
     describe "#set_relations, #set_variables_for_block, and #reset_parent" do
       it "should link sibling items" do
-        referenced_object(@page_1[:Next]).should == @page_2
-        referenced_object(@page_2[:Prev]).should == @page_1
+        expect(referenced_object(@page_1[:Next])).to eq(@page_2)
+        expect(referenced_object(@page_2[:Prev])).to eq(@page_1)
       end
 
       it "should link child items to parent item" do
-        [@page_1, @page_2].each {|page| referenced_object(page[:Parent]).should == @section_1 }
+        [@page_1, @page_2].each { |page| expect(referenced_object(page[:Parent])).to eq(@section_1) }
       end
 
       it "should set the first and last child items for parent item" do
-        referenced_object(@section_1[:First]).should == @page_1
-        referenced_object(@section_1[:Last]).should == @page_2
+        expect(referenced_object(@section_1[:First])).to eq(@page_1)
+        expect(referenced_object(@section_1[:Last])).to eq(@page_2)
       end
     end
 
     describe "#increase_count" do
-
       it "should add the count of all descendant items" do
-        @outline_root[:Count].should == 3
-        @section_1[:Count].abs.should == 2
-        @page_1[:Count].should == 0
-        @page_2[:Count].should == 0
+        expect(@outline_root[:Count]).to eq(3)
+        expect(@section_1[:Count].abs).to eq(2)
+        expect(@page_1[:Count]).to eq(0)
+        expect(@page_2[:Count]).to eq(0)
       end
-
     end
 
     describe "closed option" do
-
       it "should set the item's integer count to negative" do
-        @section_1[:Count].should == -2
+        expect(@section_1[:Count]).to eq(-2)
       end
-
     end
-
   end
 
   describe "adding a custom destination" do
@@ -100,13 +95,12 @@ describe "Outline" do
     end
 
     it "should create an outline item" do
-      @custom_dest.should_not be_nil
+      expect(@custom_dest).not_to be_nil
     end
 
     it "should reference the custom destination" do
-      referenced_object(@custom_dest[:Dest].first).should == referenced_object(@pages.last)
+      expect(referenced_object(@custom_dest[:Dest].first)).to eq(referenced_object(@pages.last))
     end
-
   end
 
   describe "addding a section later with outline#section" do
@@ -122,31 +116,29 @@ describe "Outline" do
     end
 
     it "should add new outline items to document" do
-      [@section_2, @page_3].each { |item| item.should_not be_nil}
+      [@section_2, @page_3].each { |item| expect(item).not_to be_nil }
     end
 
     it "should reset the last items for root outline dictionary" do
-      referenced_object(@outline_root[:First]).should == @section_1
-      referenced_object(@outline_root[:Last]).should == @section_2
+      expect(referenced_object(@outline_root[:First])).to eq(@section_1)
+      expect(referenced_object(@outline_root[:Last])).to eq(@section_2)
     end
 
     it "should reset the next relation for the previous last top level item" do
-      referenced_object(@section_1[:Next]).should == @section_2
+      expect(referenced_object(@section_1[:Next])).to eq(@section_2)
     end
 
     it "should set the previous relation of the addded to section" do
-      referenced_object(@section_2[:Prev]).should == @section_1
+      expect(referenced_object(@section_2[:Prev])).to eq(@section_1)
     end
 
     it "should increase the count of root outline dictionary" do
-      @outline_root[:Count].should == 5
+      expect(@outline_root[:Count]).to eq(5)
     end
-
   end
 
   describe "#outline.add_subsection_to" do
     context "positioned last" do
-
       before(:each) do
         @pdf.start_new_page
         @pdf.text "Page 3. An added subsection "
@@ -161,39 +153,36 @@ describe "Outline" do
       end
 
       it "should add new outline items to document" do
-        [@subsection, @added_page_3].each { |item| item.should_not be_nil}
+        [@subsection, @added_page_3].each { |item| expect(item).not_to be_nil }
       end
 
       it "should reset the last item for parent item dictionary" do
-        referenced_object(@section_1[:First]).should == @page_1
-        referenced_object(@section_1[:Last]).should == @subsection
+        expect(referenced_object(@section_1[:First])).to eq(@page_1)
+        expect(referenced_object(@section_1[:Last])).to eq(@subsection)
       end
 
       it "should set the prev relation for the new subsection to its parent's old last item" do
-        referenced_object(@subsection[:Prev]).should == @page_2
+        expect(referenced_object(@subsection[:Prev])).to eq(@page_2)
       end
 
-
       it "the subsection should become the next relation for its parent's old last item" do
-         referenced_object(@page_2[:Next]).should == @subsection
-       end
+        expect(referenced_object(@page_2[:Next])).to eq(@subsection)
+      end
 
       it "should set the first relation for the new subsection" do
-        referenced_object(@subsection[:First]).should == @added_page_3
+        expect(referenced_object(@subsection[:First])).to eq(@added_page_3)
       end
 
       it "should set the correct last relation of the added to section" do
-        referenced_object(@subsection[:Last]).should == @added_page_3
+        expect(referenced_object(@subsection[:Last])).to eq(@added_page_3)
       end
 
       it "should increase the count of root outline dictionary" do
-        @outline_root[:Count].should == 5
+        expect(@outline_root[:Count]).to eq(5)
       end
-
     end
 
     context "positioned first" do
-
       before(:each) do
         @pdf.start_new_page
         @pdf.text "Page 3. An added subsection "
@@ -208,38 +197,37 @@ describe "Outline" do
       end
 
       it "should add new outline items to document" do
-        [@subsection, @added_page_3].each { |item| item.should_not be_nil}
+        [@subsection, @added_page_3].each { |item| expect(item).not_to be_nil }
       end
 
       it "should reset the first item for parent item dictionary" do
-        referenced_object(@section_1[:First]).should == @subsection
-        referenced_object(@section_1[:Last]).should == @page_2
+        expect(referenced_object(@section_1[:First])).to eq(@subsection)
+        expect(referenced_object(@section_1[:Last])).to eq(@page_2)
       end
 
       it "should set the next relation for the new subsection to its parent's old first item" do
-        referenced_object(@subsection[:Next]).should == @page_1
+        expect(referenced_object(@subsection[:Next])).to eq(@page_1)
       end
 
       it "the subsection should become the prev relation for its parent's old first item" do
-         referenced_object(@page_1[:Prev]).should == @subsection
-       end
+        expect(referenced_object(@page_1[:Prev])).to eq(@subsection)
+      end
 
       it "should set the first relation for the new subsection" do
-        referenced_object(@subsection[:First]).should == @added_page_3
+        expect(referenced_object(@subsection[:First])).to eq(@added_page_3)
       end
 
       it "should set the correct last relation of the added to section" do
-        referenced_object(@subsection[:Last]).should == @added_page_3
+        expect(referenced_object(@subsection[:Last])).to eq(@added_page_3)
       end
 
       it "should increase the count of root outline dictionary" do
-        @outline_root[:Count].should == 5
+        expect(@outline_root[:Count]).to eq(5)
       end
-
     end
 
     it "should require an existing title" do
-      lambda do
+      expect do
         @pdf.go_to_page 1
         @pdf.start_new_page
         @pdf.text "Inserted Page"
@@ -249,7 +237,7 @@ describe "Outline" do
           end
         end
         render_and_find_objects
-      end.should raise_error(Prawn::Errors::UnknownOutlineTitle)
+      end.to raise_error(Prawn::Errors::UnknownOutlineTitle)
     end
   end
 
@@ -268,38 +256,35 @@ describe "Outline" do
 
       it "should insert new outline items to document" do
         render_and_find_objects
-        @inserted_page.should_not be_nil
+        expect(@inserted_page).not_to be_nil
       end
 
       it "should adjust the count of all ancestors" do
         render_and_find_objects
-        @outline_root[:Count].should == 4
-        @section_1[:Count].abs.should == 3
+        expect(@outline_root[:Count]).to eq(4)
+        expect(@section_1[:Count].abs).to eq(3)
       end
 
       describe "#adjust_relations" do
-
         it "should reset the sibling relations of adjoining items to inserted item" do
           render_and_find_objects
-          referenced_object(@page_1[:Next]).should == @inserted_page
-          referenced_object(@page_2[:Prev]).should == @inserted_page
+          expect(referenced_object(@page_1[:Next])).to eq(@inserted_page)
+          expect(referenced_object(@page_2[:Prev])).to eq(@inserted_page)
         end
 
         it "should set the sibling relation of added item to adjoining items" do
           render_and_find_objects
-          referenced_object(@inserted_page[:Next]).should == @page_2
-          referenced_object(@inserted_page[:Prev]).should == @page_1
+          expect(referenced_object(@inserted_page[:Next])).to eq(@page_2)
+          expect(referenced_object(@inserted_page[:Prev])).to eq(@page_1)
         end
 
         it "should not affect the first and last relations of parent item" do
           render_and_find_objects
-          referenced_object(@section_1[:First]).should == @page_1
-          referenced_object(@section_1[:Last]).should == @page_2
+          expect(referenced_object(@section_1[:First])).to eq(@page_1)
+          expect(referenced_object(@section_1[:Last])).to eq(@page_2)
         end
-
       end
 
-
       context "when adding another section afterwards" do
         it "should have reset the root position so that a new section is added at the end of root sections" do
           @pdf.start_new_page
@@ -310,48 +295,43 @@ describe "Outline" do
             end
           end
           render_and_find_objects
-          referenced_object(@outline_root[:Last]).should == @section_2
-          referenced_object(@section_1[:Next]).should == @section_2
+          expect(referenced_object(@outline_root[:Last])).to eq(@section_2)
+          expect(referenced_object(@section_1[:Next])).to eq(@section_2)
         end
       end
-
-   end
-
+    end
 
     describe "inserting at the end of another section" do
-
       before(:each) do
         @pdf.go_to_page 2
-         @pdf.start_new_page
-         @pdf.text "Inserted Page"
-         @pdf.outline.update do
-           insert_section_after 'Page 2' do
-             page :destination => page_number, :title => "Inserted Page"
-           end
-         end
-         render_and_find_objects
+        @pdf.start_new_page
+        @pdf.text "Inserted Page"
+        @pdf.outline.update do
+          insert_section_after 'Page 2' do
+            page :destination => page_number, :title => "Inserted Page"
+          end
+        end
+        render_and_find_objects
       end
 
       describe "#adjust_relations" do
-
         it "should reset the sibling relations of adjoining item to inserted item" do
-           referenced_object(@page_2[:Next]).should == @inserted_page
+          expect(referenced_object(@page_2[:Next])).to eq(@inserted_page)
         end
 
         it "should set the sibling relation of added item to adjoining items" do
-          referenced_object(@inserted_page[:Next]).should be_nil
-          referenced_object(@inserted_page[:Prev]).should == @page_2
+          expect(referenced_object(@inserted_page[:Next])).to be_nil
+          expect(referenced_object(@inserted_page[:Prev])).to eq(@page_2)
         end
 
         it "should adjust the last relation of parent item" do
-          referenced_object(@section_1[:Last]).should == @inserted_page
+          expect(referenced_object(@section_1[:Last])).to eq(@inserted_page)
         end
-
       end
     end
 
     it "should require an existing title" do
-      lambda do
+      expect do
         @pdf.go_to_page 1
         @pdf.start_new_page
         @pdf.text "Inserted Page"
@@ -361,28 +341,27 @@ describe "Outline" do
           end
         end
         render_and_find_objects
-      end.should raise_error(Prawn::Errors::UnknownOutlineTitle)
+      end.to raise_error(Prawn::Errors::UnknownOutlineTitle)
     end
-
   end
 
   describe "#page" do
     it "should require a title option to be set" do
-      lambda do
-        @pdf = Prawn::Document.new() do
+      expect do
+        @pdf = Prawn::Document.new do
           text "Page 1. This is the first Chapter. "
           outline.define do
             page :destination => 1, :title => nil
           end
         end
-      end.should raise_error(Prawn::Errors::RequiredOption)
+      end.to raise_error(Prawn::Errors::RequiredOption)
     end
   end
 end
 
 describe "foreign character encoding" do
   before(:each) do
-    pdf = Prawn::Document.new() do
+    pdf = Prawn::Document.new do
       outline.define do
         section 'La pomme croquée', :destination => 1, :closed => true
       end
@@ -392,15 +371,15 @@ describe "foreign character encoding" do
 
   it "should handle other encodings for the title" do
     object = find_by_title('La pomme croquée')
-    object.should_not == nil
+    expect(object).not_to be_nil
   end
 end
 
 def render_and_find_objects
   output = StringIO.new(@pdf.render, 'r+')
   @hash = PDF::Reader::ObjectHash.new(output)
-  @outline_root = @hash.values.find {|obj| obj.is_a?(Hash) && obj[:Type] == :Outlines}
-  @pages = @hash.values.find {|obj| obj.is_a?(Hash) && obj[:Type] == :Pages}[:Kids]
+  @outline_root = @hash.values.find { |obj| obj.is_a?(Hash) && obj[:Type] == :Outlines }
+  @pages = @hash.values.find { |obj| obj.is_a?(Hash) && obj[:Type] == :Pages }[:Kids]
   @section_1 = find_by_title('Chapter 1')
   @page_1 = find_by_title('Page 1')
   @page_2 = find_by_title('Page 2')