prawn 2.0.1 → 2.0.2

data/spec/column_box_spec.rb

@@ -5,30 +5,28 @@ require File.join(File.expand_path(File.dirname(__FILE__)), "spec_helper")
 describe "A column box" do
   it "has sensible left and right values" do
     create_pdf
-    @pdf.column_box [0, @pdf.cursor], :width => @pdf.bounds.width,
-      :height => 200, :columns => 3, :spacer => 25 do
-        left = @pdf.bounds.left
-        right = @pdf.bounds.right
+    @pdf.column_box [0, @pdf.cursor], :width => @pdf.bounds.width, :height => 200, :columns => 3, :spacer => 25 do
+      left = @pdf.bounds.left
+      right = @pdf.bounds.right
 
-        @pdf.bounds.move_past_bottom # next column
+      @pdf.bounds.move_past_bottom # next column
 
-        @pdf.bounds.left.should be > left
-        @pdf.bounds.left.should be > right
-        @pdf.bounds.right.should be > @pdf.bounds.left
-      end
+      expect(@pdf.bounds.left).to be > left
+      expect(@pdf.bounds.left).to be > right
+      expect(@pdf.bounds.right).to be > @pdf.bounds.left
+    end
   end
 
   it "includes spacers between columns but not at the end" do
     create_pdf
-    @pdf.column_box [0, @pdf.cursor], :width => 500,
-      :height => 200, :columns => 3, :spacer => 25 do
-        @pdf.bounds.width.should == 150 # (500 - (25 * 2)) / 3
+    @pdf.column_box [0, @pdf.cursor], :width => 500, :height => 200, :columns => 3, :spacer => 25 do
+      expect(@pdf.bounds.width).to eq(150) # (500 - (25 * 2)) / 3
 
-        @pdf.bounds.move_past_bottom
-        @pdf.bounds.move_past_bottom
+      @pdf.bounds.move_past_bottom
+      @pdf.bounds.move_past_bottom
 
-        @pdf.bounds.right.should == 500
-      end
+      expect(@pdf.bounds.right).to eq(500)
+    end
   end
 
   it "does not reset the top margin on a new page by default" do
@@ -36,15 +34,13 @@ describe "A column box" do
     page_top = @pdf.cursor
     @pdf.move_down 50
     init_column_top = @pdf.cursor
-    @pdf.column_box [0, @pdf.cursor], :width => 500,
-      :height => 200, :columns => 2 do
+    @pdf.column_box [0, @pdf.cursor], :width => 500, :height => 200, :columns => 2 do
+      @pdf.bounds.move_past_bottom
+      @pdf.bounds.move_past_bottom
 
-        @pdf.bounds.move_past_bottom
-        @pdf.bounds.move_past_bottom
-
-        @pdf.bounds.absolute_top.should == init_column_top
-        @pdf.bounds.absolute_top.should_not == page_top
-      end
+      expect(@pdf.bounds.absolute_top).to eq(init_column_top)
+      expect(@pdf.bounds.absolute_top).not_to eq(page_top)
+    end
   end
 
   it "does reset the top margin when reflow_margins is set" do
@@ -52,14 +48,12 @@ describe "A column box" do
     page_top = @pdf.cursor
     @pdf.move_down 50
     init_column_top = @pdf.cursor
-    @pdf.column_box [0, @pdf.cursor], :width => 500, :reflow_margins => true,
-      :height => 200, :columns => 2 do
-
-        @pdf.bounds.move_past_bottom
-        @pdf.bounds.move_past_bottom
+    @pdf.column_box [0, @pdf.cursor], :width => 500, :reflow_margins => true, :height => 200, :columns => 2 do
+      @pdf.bounds.move_past_bottom
+      @pdf.bounds.move_past_bottom
 
-        @pdf.bounds.absolute_top.should == page_top
-        @pdf.bounds.absolute_top.should_not == init_column_top
-      end
+      expect(@pdf.bounds.absolute_top).to eq(page_top)
+      expect(@pdf.bounds.absolute_top).not_to eq(init_column_top)
+    end
   end
 end

data/spec/destinations_spec.rb

@@ -3,13 +3,11 @@
 require File.join(File.expand_path(File.dirname(__FILE__)), "spec_helper")
 
 describe "When creating destinations" do
-
   before(:each) { create_pdf }
 
   it "should add entry to Dests name tree" do
-    @pdf.dests.data.empty?.should == true
+    expect(@pdf.dests.data.empty?).to eq(true)
     @pdf.add_dest "candy", "chocolate"
-    @pdf.dests.data.size.should == 1
+    expect(@pdf.dests.data.size).to eq(1)
   end
-
 end

data/spec/document_spec.rb

@@ -5,27 +5,27 @@ require File.join(File.expand_path(File.dirname(__FILE__)), "spec_helper")
 
 describe "Prawn::Document.new" do
   it "should not modify its argument" do
-    options = {:page_layout => :landscape}
+    options = { :page_layout => :landscape }
     Prawn::Document.new(options)
-    options.should == {:page_layout => :landscape}
+    expect(options).to eq(:page_layout => :landscape)
   end
 end
 
 describe "The cursor" do
   it "should == pdf.y - bounds.absolute_bottom" do
     pdf = Prawn::Document.new
-    pdf.cursor.should == pdf.bounds.top
+    expect(pdf.cursor).to eq(pdf.bounds.top)
 
     pdf.y = 300
-    pdf.cursor.should == pdf.y - pdf.bounds.absolute_bottom
+    expect(pdf.cursor).to eq(pdf.y - pdf.bounds.absolute_bottom)
   end
 
   it "should be able to move relative to the bottom margin" do
     pdf = Prawn::Document.new
     pdf.move_cursor_to(10)
 
-    pdf.cursor.should == 10
-    pdf.y.should == pdf.cursor + pdf.bounds.absolute_bottom
+    expect(pdf.cursor).to eq(10)
+    expect(pdf.y).to eq(pdf.cursor + pdf.bounds.absolute_bottom)
   end
 end
 
@@ -51,7 +51,7 @@ describe "when generating a document with a custom text formatter" do
     pdf = Prawn::Document.new text_formatter: TestTextFormatter
     pdf.text "Dr. Who?", inline_format: true
     text = PDF::Inspector::Text.analyze(pdf.render)
-    text.strings.first.should == "Just 'The Doctor'."
+    expect(text.strings.first).to eq("Just 'The Doctor'.")
   end
 end
 
@@ -59,8 +59,8 @@ describe "when generating a document from a subclass" do
   it "should be an instance of the subclass" do
     custom_document = Class.new(Prawn::Document)
     custom_document.generate(Tempfile.new("generate_test").path) do |e|
-      e.class.should == custom_document
-      e.should be_a_kind_of(Prawn::Document)
+      expect(e.class).to eq(custom_document)
+      expect(e).to be_a_kind_of(Prawn::Document)
     end
   end
 
@@ -71,44 +71,40 @@ describe "when generating a document from a subclass" do
     Prawn::Document.extensions << mod1 << mod2
 
     custom_document = Class.new(Prawn::Document)
-    custom_document.extensions.should == [mod1, mod2]
+    expect(custom_document.extensions).to eq([mod1, mod2])
 
     # remove the extensions we added to prawn document
     Prawn::Document.extensions.delete(mod1)
     Prawn::Document.extensions.delete(mod2)
 
-    Prawn::Document.new.respond_to?(:test_extensions1).should be_false
-    Prawn::Document.new.respond_to?(:test_extensions2).should be_false
+    expect(Prawn::Document.new.respond_to?(:test_extensions1)).to be_false
+    expect(Prawn::Document.new.respond_to?(:test_extensions2)).to be_false
 
     # verify these still exist on custom class
-    custom_document.extensions.should == [mod1, mod2]
+    expect(custom_document.extensions).to eq([mod1, mod2])
 
-    custom_document.new.respond_to?(:test_extensions1).should be_true
-    custom_document.new.respond_to?(:test_extensions2).should be_true
+    expect(custom_document.new.respond_to?(:test_extensions1)).to be_true
+    expect(custom_document.new.respond_to?(:test_extensions2)).to be_true
   end
-
 end
 
-
 describe "When creating multi-page documents" do
-
   before(:each) { create_pdf }
 
   it "should initialize with a single page" do
     page_counter = PDF::Inspector::Page.analyze(@pdf.render)
 
-    page_counter.pages.size.should == 1
-    @pdf.page_count.should == 1
+    expect(page_counter.pages.size).to eq(1)
+    expect(@pdf.page_count).to eq(1)
   end
 
   it "should provide an accurate page_count" do
     3.times { @pdf.start_new_page }
     page_counter = PDF::Inspector::Page.analyze(@pdf.render)
 
-    page_counter.pages.size.should == 4
-    @pdf.page_count.should == 4
+    expect(page_counter.pages.size).to eq(4)
+    expect(@pdf.page_count).to eq(4)
   end
-
 end
 
 describe "When beginning each new page" do
@@ -121,11 +117,11 @@ describe "When beginning each new page" do
       output = @pdf.render
       images = PDF::Inspector::XObject.analyze(output)
       # there should be 2 images in the page resources
-      images.page_xobjects.first.size.should == 1
+      expect(images.page_xobjects.first.size).to eq(1)
     end
     it "should place a background image if it is in options block" do
-      @pdf.instance_variable_defined?(:@background).should == true
-      @pdf.instance_variable_get(:@background).should == @filename
+      expect(@pdf.instance_variable_defined?(:@background)).to eq(true)
+      expect(@pdf.instance_variable_get(:@background)).to eq(@filename)
     end
   end
 end
@@ -135,7 +131,7 @@ describe "Prawn::Document#float" do
     create_pdf
     orig_y = @pdf.y
     @pdf.float { @pdf.text "Foo" }
-    @pdf.y.should == orig_y
+    expect(@pdf.y).to eq(orig_y)
   end
 
   it "should teleport across pages if necessary" do
@@ -149,30 +145,29 @@ describe "Prawn::Document#float" do
     @pdf.text "Baz"
 
     pages = PDF::Inspector::Page.analyze(@pdf.render).pages
-    pages.size.should == 2
-    pages[0][:strings].should == ["Foo", "Baz"]
-    pages[1][:strings].should == ["Bar"]
+    expect(pages.size).to eq(2)
+    expect(pages[0][:strings]).to eq(["Foo", "Baz"])
+    expect(pages[1][:strings]).to eq(["Bar"])
   end
 end
 
 describe "The page_number method" do
   it "should be 1 for a new document" do
     pdf = Prawn::Document.new
-    pdf.page_number.should == 1
+    expect(pdf.page_number).to eq(1)
   end
 
   it "should be 0 for documents with no pages" do
     pdf = Prawn::Document.new(:skip_page_creation => true)
-    pdf.page_number.should == 0
+    expect(pdf.page_number).to eq(0)
   end
 
   it "should be changed by go_to_page" do
     pdf = Prawn::Document.new
     10.times { pdf.start_new_page }
     pdf.go_to_page 3
-    pdf.page_number.should == 3
+    expect(pdf.page_number).to eq(3)
   end
-
 end
 
 describe "on_page_create callback" do
@@ -191,11 +186,11 @@ describe "on_page_create callback" do
 
     @pdf.start_new_page
 
-    called_with.should == [@pdf]
+    expect(called_with).to eq([@pdf])
   end
 
   it "should be invoked for each new page" do
-    trigger = mock()
+    trigger = mock
     trigger.expects(:fire).times(5)
 
     @pdf.renderer.on_page_create { trigger.fire }
@@ -204,40 +199,37 @@ describe "on_page_create callback" do
   end
 
   it "should be replaceable" do
-      trigger1 = mock()
-      trigger1.expects(:fire).times(1)
+    trigger1 = mock
+    trigger1.expects(:fire).times(1)
 
-      trigger2 = mock()
-      trigger2.expects(:fire).times(1)
+    trigger2 = mock
+    trigger2.expects(:fire).times(1)
 
-      @pdf.renderer.on_page_create { trigger1.fire }
+    @pdf.renderer.on_page_create { trigger1.fire }
 
-      @pdf.start_new_page
+    @pdf.start_new_page
 
-      @pdf.renderer.on_page_create { trigger2.fire }
+    @pdf.renderer.on_page_create { trigger2.fire }
 
-      @pdf.start_new_page
+    @pdf.start_new_page
   end
 
   it "should be clearable by calling on_page_create without a block" do
-      trigger = mock()
-      trigger.expects(:fire).times(1)
+    trigger = mock
+    trigger.expects(:fire).times(1)
 
-      @pdf.renderer.on_page_create { trigger.fire }
+    @pdf.renderer.on_page_create { trigger.fire }
 
-      @pdf.start_new_page
+    @pdf.start_new_page
 
-      @pdf.renderer.on_page_create
+    @pdf.renderer.on_page_create
 
-      @pdf.start_new_page
+    @pdf.start_new_page
   end
-
 end
 
 describe "Document compression" do
-
   it "should not compress the page content stream if compression is disabled" do
-
     pdf = Prawn::Document.new(:compress => false)
     pdf.page.content.stream.stubs(:compress!).returns(true)
     pdf.page.content.stream.expects(:compress!).never
@@ -247,7 +239,6 @@ describe "Document compression" do
   end
 
   it "should compress the page content stream if compression is enabled" do
-
     pdf = Prawn::Document.new(:compress => true)
     pdf.page.content.stream.stubs(:compress!).returns(true)
     pdf.page.content.stream.expects(:compress!).once
@@ -260,21 +251,21 @@ describe "Document compression" do
     doc_uncompressed = Prawn::Document.new
     doc_compressed   = Prawn::Document.new(:compress => true)
     [doc_compressed, doc_uncompressed].each do |pdf|
-       pdf.font "#{Prawn::DATADIR}/fonts/gkai00mp.ttf"
-       pdf.text "更可怕的是，同质化竞争对手可以按照URL中后面这个ID来遍历" * 10
+      pdf.font "#{Prawn::DATADIR}/fonts/gkai00mp.ttf"
+      pdf.text "更可怕的是，同质化竞争对手可以按照URL中后面这个ID来遍历" * 10
     end
 
-    doc_compressed.render.length.should be < doc_uncompressed.render.length
+    expect(doc_compressed.render.length).to be < doc_uncompressed.render.length
   end
-
 end
 
 describe "Document metadata" do
   it "should output strings as UTF-16 with a byte order mark" do
-    pdf = Prawn::Document.new(:info => {:Author => "Lóránt"})
-    pdf.state.store.info.object.should =~
+    pdf = Prawn::Document.new(:info => { :Author => "Lóránt" })
+    expect(pdf.state.store.info.object).to match(
       # UTF-16:     BOM L   ó   r   á   n   t
       %r{/Author\s*<feff004c00f3007200e1006e0074>}i
+    )
   end
 end
 
@@ -295,17 +286,21 @@ describe "When reopening pages" do
 
   it "should insert pages after the current page when calling start_new_page" do
     pdf = Prawn::Document.new
-    3.times { |i| pdf.text "Old page #{i+1}"; pdf.start_new_page }
+    3.times do |i|
+      pdf.text "Old page #{i + 1}"
+      pdf.start_new_page
+    end
+
     pdf.go_to_page 1
     pdf.start_new_page
     pdf.text "New page 2"
 
-    pdf.page_number.should == 2
+    expect(pdf.page_number).to eq(2)
 
     pages = PDF::Inspector::Page.analyze(pdf.render).pages
-    pages.size.should == 5
-    pages[1][:strings].should == ["New page 2"]
-    pages[2][:strings].should == ["Old page 2"]
+    expect(pages.size).to eq(5)
+    expect(pages[1][:strings]).to eq(["New page 2"])
+    expect(pages[2][:strings]).to eq(["Old page 2"])
   end
 
   it "should restore the layout of the page" do
@@ -325,7 +320,7 @@ describe "When reopening pages" do
 
       start_new_page(:margin => [200, 200])
 
-      [bounds.width, bounds.height].should == [page1_bounds.width  - 200,
+      [bounds.width, bounds.height].should == [page1_bounds.width - 200,
                                                page1_bounds.height - 200]
 
       go_to_page(1)
@@ -333,7 +328,6 @@ describe "When reopening pages" do
       bounds.width.should == page1_bounds.width
       bounds.height.should == page1_bounds.height
     end
-
   end
 end
 
@@ -341,40 +335,38 @@ describe "When setting page size" do
   it "should default to LETTER" do
     @pdf = Prawn::Document.new
     pages = PDF::Inspector::Page.analyze(@pdf.render).pages
-    pages.first[:size].should == PDF::Core::PageGeometry::SIZES["LETTER"]
+    expect(pages.first[:size]).to eq(PDF::Core::PageGeometry::SIZES["LETTER"])
   end
 
   (PDF::Core::PageGeometry::SIZES.keys - ["LETTER"]).each do |k|
     it "should provide #{k} geometry" do
       @pdf = Prawn::Document.new(:page_size => k)
       pages = PDF::Inspector::Page.analyze(@pdf.render).pages
-      pages.first[:size].should == PDF::Core::PageGeometry::SIZES[k]
+      expect(pages.first[:size]).to eq(PDF::Core::PageGeometry::SIZES[k])
     end
   end
 
   it "should allow custom page size" do
-    @pdf = Prawn::Document.new(:page_size => [1920, 1080] )
+    @pdf = Prawn::Document.new(:page_size => [1920, 1080])
     pages = PDF::Inspector::Page.analyze(@pdf.render).pages
-    pages.first[:size].should == [1920, 1080]
+    expect(pages.first[:size]).to eq([1920, 1080])
   end
 
-
   it "should retain page size by default when starting a new page" do
     @pdf = Prawn::Document.new(:page_size => "LEGAL")
     @pdf.start_new_page
     pages = PDF::Inspector::Page.analyze(@pdf.render).pages
     pages.each do |page|
-      page[:size].should == PDF::Core::PageGeometry::SIZES["LEGAL"]
+      expect(page[:size]).to eq(PDF::Core::PageGeometry::SIZES["LEGAL"])
     end
   end
-
 end
 
 describe "When setting page layout" do
   it "should reverse coordinates for landscape" do
     @pdf = Prawn::Document.new(:page_size => "A4", :page_layout => :landscape)
     pages = PDF::Inspector::Page.analyze(@pdf.render).pages
-    pages.first[:size].should == PDF::Core::PageGeometry::SIZES["A4"].reverse
+    expect(pages.first[:size]).to eq(PDF::Core::PageGeometry::SIZES["A4"].reverse)
   end
 
   it "should retain page layout by default when starting a new page" do
@@ -382,7 +374,7 @@ describe "When setting page layout" do
     @pdf.start_new_page(:trace => true)
     pages = PDF::Inspector::Page.analyze(@pdf.render).pages
     pages.each do |page|
-      page[:size].should == PDF::Core::PageGeometry::SIZES["LETTER"].reverse
+      expect(page[:size]).to eq(PDF::Core::PageGeometry::SIZES["LETTER"].reverse)
     end
   end
 
@@ -390,7 +382,7 @@ describe "When setting page layout" do
     @pdf = Prawn::Document.new
     size = [@pdf.bounds.width, @pdf.bounds.height]
     @pdf.start_new_page(:layout => :landscape)
-    [@pdf.bounds.width, @pdf.bounds.height].should == size.reverse
+    expect([@pdf.bounds.width, @pdf.bounds.height]).to eq(size.reverse)
   end
 end
 
@@ -401,19 +393,22 @@ describe "The mask() feature" do
     @pdf.mask(:y, :line_width) do
       @pdf.y = y + 1
       @pdf.line_width = line_width + 1
-      @pdf.y.should_not == y
-      @pdf.line_width.should_not == line_width
+      expect(@pdf.y).not_to eq(y)
+      expect(@pdf.line_width).not_to eq(line_width)
     end
-    @pdf.y.should == y
-    @pdf.line_width.should == line_width
+    expect(@pdf.y).to eq(y)
+    expect(@pdf.line_width).to eq(line_width)
   end
 end
 
 describe "The group() feature" do
   xit "should return a true value if the content fits on one page" do
     pdf = Prawn::Document.new do
-      val = group { text "Hello"; text "World" }
-      (!!val).should == true
+      val = group {
+        text "Hello"
+        text "World"
+      }
+      expect(!!val).to eq(true)
     end
   end
 
@@ -426,25 +421,25 @@ describe "The group() feature" do
       end
 
       # group should return a false value since a new page was started
-      (!!val).should == false
+      expect(!!val).to eq(false)
     end
     pages = PDF::Inspector::Page.analyze(pdf.render).pages
-    pages.size.should == 2
-    pages[0][:strings].should == []
-    pages[1][:strings].should == ["Hello", "World"]
+    expect(pages.size).to eq(2)
+    expect(pages[0][:strings]).to eq([])
+    expect(pages[1][:strings]).to eq(["Hello", "World"])
   end
 
   xit "should raise_error CannotGroup if the content is too tall" do
-    lambda {
+    expect {
       Prawn::Document.new do
         group do
           100.times { text "Too long" }
         end
       end.render
-    }.should raise_error(Prawn::Errors::CannotGroup)
+    }.to raise_error(Prawn::Errors::CannotGroup)
   end
 
-   xit "should group within individual column boxes" do
+  xit "should group within individual column boxes" do
     pdf = Prawn::Document.new do
       # Set up columns with grouped blocks of 0..49. 0 to 49 is slightly short
       # of the height of one page / column, so each column should get its own
@@ -458,18 +453,17 @@ describe "The group() feature" do
 
     # Second page should start with a 0 because it's a new group.
     pages = PDF::Inspector::Page.analyze(pdf.render).pages
-    pages.size.should == 2
-    pages[1][:strings].first.should == '0'
+    expect(pages.size).to eq(2)
+    expect(pages[1][:strings].first).to eq('0')
   end
-
 end
 
 describe "The render() feature" do
   it "should return a 8 bit encoded string on a m17n aware VM" do
     @pdf = Prawn::Document.new(:page_size => "A4", :page_layout => :landscape)
-    @pdf.line [100,100], [200,200]
+    @pdf.line [100, 100], [200, 200]
     str = @pdf.render
-    str.encoding.to_s.should == "ASCII-8BIT"
+    expect(str.encoding.to_s).to eq("ASCII-8BIT")
   end
 
   it "should trigger before_render callbacks just before rendering" do
@@ -479,7 +473,7 @@ describe "The render() feature" do
 
     # Verify the order: finalize -> fire callbacks -> render body
     pdf.renderer.expects(:finalize_all_page_contents).in_sequence(seq)
-    trigger = mock()
+    trigger = mock
     trigger.expects(:fire).in_sequence(seq)
 
     # Store away the render_body method to be called below
@@ -498,7 +492,7 @@ describe "The render() feature" do
 
     contents  = pdf.render
     contents2 = pdf.render
-    contents2.should == contents
+    expect(contents2).to eq(contents)
   end
 end
 
@@ -506,19 +500,19 @@ describe "PDF file versions" do
   it "should default to 1.3" do
     @pdf = Prawn::Document.new
     str = @pdf.render
-    str[0,8].should == "%PDF-1.3"
+    expect(str[0, 8]).to eq("%PDF-1.3")
   end
 
   it "should allow the default to be changed" do
     @pdf = Prawn::Document.new
     @pdf.renderer.min_version(1.4)
     str = @pdf.render
-    str[0,8].should == "%PDF-1.4"
+    expect(str[0, 8]).to eq("%PDF-1.4")
   end
 end
 
 describe "Documents that use go_to_page" do
- it "should have 2 pages after calling start_new_page and go_to_page" do
+  it "should have 2 pages after calling start_new_page and go_to_page" do
     @pdf = Prawn::Document.new
     @pdf.text "James"
     @pdf.start_new_page
@@ -527,7 +521,7 @@ describe "Documents that use go_to_page" do
     @pdf.text "Healy"
 
     page_counter = PDF::Inspector::Page.analyze(@pdf.render)
-    page_counter.pages.size.should == 2
+    expect(page_counter.pages.size).to eq(2)
   end
 
   it "should correctly add text to pages" do
@@ -540,15 +534,15 @@ describe "Documents that use go_to_page" do
 
     text = PDF::Inspector::Text.analyze(@pdf.render)
 
-    text.strings.size.should == 3
-    text.strings.include?("James").should == true
-    text.strings.include?("Anthony").should == true
-    text.strings.include?("Healy").should == true
+    expect(text.strings.size).to eq(3)
+    expect(text.strings.include?("James")).to eq(true)
+    expect(text.strings.include?("Anthony")).to eq(true)
+    expect(text.strings.include?("Healy")).to eq(true)
   end
 end
 
 describe "content stream characteristics" do
- it "should have 1 single content stream for a single page PDF" do
+  it "should have 1 single content stream for a single page PDF" do
     @pdf = Prawn::Document.new
     @pdf.text "James"
     output = StringIO.new(@pdf.render)
@@ -556,10 +550,10 @@ describe "content stream characteristics" do
 
     streams = hash.values.select { |obj| obj.kind_of?(PDF::Reader::Stream) }
 
-    streams.size.should == 1
+    expect(streams.size).to eq(1)
   end
 
- it "should have 1 single content stream for a single page PDF, even if go_to_page is used" do
+  it "should have 1 single content stream for a single page PDF, even if go_to_page is used" do
     @pdf = Prawn::Document.new
     @pdf.text "James"
     @pdf.go_to_page(1)
@@ -569,7 +563,7 @@ describe "content stream characteristics" do
 
     streams = hash.values.select { |obj| obj.kind_of?(PDF::Reader::Stream) }
 
-    streams.size.should == 1
+    expect(streams.size).to eq(1)
   end
 end
 
@@ -580,20 +574,20 @@ describe "The number_pages method" do
 
   it "replaces the '<page>' string with the proper page number" do
     @pdf.start_new_page
-    @pdf.expects(:text_box).with("1, test", { :height => 50 })
-    @pdf.number_pages "<page>, test", {:page_filter => :all}
+    @pdf.expects(:text_box).with("1, test", :height => 50)
+    @pdf.number_pages "<page>, test", :page_filter => :all
   end
 
   it "replaces the '<total>' string with the total page count" do
     @pdf.start_new_page
-    @pdf.expects(:text_box).with("test, 1", { :height => 50 })
-    @pdf.number_pages "test, <total>", {:page_filter => :all}
+    @pdf.expects(:text_box).with("test, 1", :height => 50)
+    @pdf.number_pages "test, <total>", :page_filter => :all
   end
 
   it "must print each page if given the :all page_filter" do
     10.times { @pdf.start_new_page }
     @pdf.expects(:text_box).times(10)
-    @pdf.number_pages "test", {:page_filter => :all}
+    @pdf.number_pages "test", :page_filter => :all
   end
 
   it "must print each page if no :page_filter is specified" do
@@ -605,7 +599,7 @@ describe "The number_pages method" do
   it "must not print the page number if given a nil filter" do
     10.times { @pdf.start_new_page }
     @pdf.expects(:text_box).never
-    @pdf.number_pages "test", {:page_filter => nil}
+    @pdf.number_pages "test", :page_filter => nil
   end
 
   context "start_count_at option" do
@@ -613,9 +607,9 @@ describe "The number_pages method" do
       context "equal to #{startat}" do
         it "increments the pages" do
           2.times { @pdf.start_new_page }
-          options = {:page_filter => :all, :start_count_at => startat}
-          @pdf.expects(:text_box).with("#{startat} 2", { :height => 50 })
-          @pdf.expects(:text_box).with("#{startat+1} 2", { :height => 50 })
+          options = { :page_filter => :all, :start_count_at => startat }
+          @pdf.expects(:text_box).with("#{startat} 2", :height => 50)
+          @pdf.expects(:text_box).with("#{startat + 1} 2", :height => 50)
           @pdf.number_pages "<page> <total>", options
         end
       end
@@ -625,10 +619,10 @@ describe "The number_pages method" do
       context "equal to #{val}" do
         it "defaults to start at page 1" do
           3.times { @pdf.start_new_page }
-          options = {:page_filter => :all, :start_count_at => val}
-          @pdf.expects(:text_box).with("1 3", { :height => 50 })
-          @pdf.expects(:text_box).with("2 3", { :height => 50 })
-          @pdf.expects(:text_box).with("3 3", { :height => 50 })
+          options = { :page_filter => :all, :start_count_at => val }
+          @pdf.expects(:text_box).with("1 3", :height => 50)
+          @pdf.expects(:text_box).with("2 3", :height => 50)
+          @pdf.expects(:text_box).with("3 3", :height => 50)
           @pdf.number_pages "<page> <total>", options
         end
       end
@@ -638,8 +632,8 @@ describe "The number_pages method" do
   context "total_pages option" do
     it "allows the total pages count to be overridden" do
       2.times { @pdf.start_new_page }
-      @pdf.expects(:text_box).with("1 10", { :height => 50 })
-      @pdf.expects(:text_box).with("2 10", { :height => 50 })
+      @pdf.expects(:text_box).with("1 10", :height => 50)
+      @pdf.expects(:text_box).with("2 10", :height => 50)
       @pdf.number_pages "<page> <total>", :page_filter => :all, :total_pages => 10
     end
   end
@@ -648,9 +642,9 @@ describe "The number_pages method" do
     context "such as :odd" do
       it "increments the pages" do
         3.times { @pdf.start_new_page }
-        @pdf.expects(:text_box).with("1 3", { :height => 50 })
-        @pdf.expects(:text_box).with("3 3", { :height => 50 })
-        @pdf.expects(:text_box).with("2 3", { :height => 50 }).never
+        @pdf.expects(:text_box).with("1 3", :height => 50)
+        @pdf.expects(:text_box).with("3 3", :height => 50)
+        @pdf.expects(:text_box).with("2 3", :height => 50).never
         @pdf.number_pages "<page> <total>", :page_filter => :odd
       end
     end
@@ -667,23 +661,23 @@ describe "The number_pages method" do
     context "such as :odd and 7" do
       it "increments the pages" do
         3.times { @pdf.start_new_page }
-        @pdf.expects(:text_box).with("1 3", { :height => 50 }).never
-        @pdf.expects(:text_box).with("5 3", { :height => 50 }) # page 1
-        @pdf.expects(:text_box).with("6 3", { :height => 50 }).never # page 2
-        @pdf.expects(:text_box).with("7 3", { :height => 50 }) # page 3
+        @pdf.expects(:text_box).with("1 3", :height => 50).never
+        @pdf.expects(:text_box).with("5 3", :height => 50) # page 1
+        @pdf.expects(:text_box).with("6 3", :height => 50).never # page 2
+        @pdf.expects(:text_box).with("7 3", :height => 50) # page 3
         @pdf.number_pages "<page> <total>", :page_filter => :odd, :start_count_at => 5
       end
     end
     context "some crazy proc and 2" do
       it "increments the pages" do
         6.times { @pdf.start_new_page }
-        options = {:page_filter => lambda {|p| p != 2 && p != 5}, :start_count_at => 4}
-        @pdf.expects(:text_box).with("4 6", { :height => 50 }) # page 1
-        @pdf.expects(:text_box).with("5 6", { :height => 50 }).never # page 2
-        @pdf.expects(:text_box).with("6 6", { :height => 50 }) # page 3
-        @pdf.expects(:text_box).with("7 6", { :height => 50 }) # page 4
-        @pdf.expects(:text_box).with("8 6", { :height => 50 }).never # page 5
-        @pdf.expects(:text_box).with("9 6", { :height => 50 }) # page 6
+        options = { :page_filter => lambda { |p| p != 2 && p != 5 }, :start_count_at => 4 }
+        @pdf.expects(:text_box).with("4 6", :height => 50) # page 1
+        @pdf.expects(:text_box).with("5 6", :height => 50).never # page 2
+        @pdf.expects(:text_box).with("6 6", :height => 50) # page 3
+        @pdf.expects(:text_box).with("7 6", :height => 50) # page 4
+        @pdf.expects(:text_box).with("8 6", :height => 50).never # page 5
+        @pdf.expects(:text_box).with("9 6", :height => 50) # page 6
         @pdf.number_pages "<page> <total>", options
       end
     end
@@ -695,17 +689,17 @@ describe "The number_pages method" do
     end
 
     it "with 10 height" do
-      @pdf.expects(:text_box).with("1 1", { :height => 10 })
+      @pdf.expects(:text_box).with("1 1", :height => 10)
       @pdf.number_pages "<page> <total>", :height => 10
     end
 
     it "with nil height" do
-      @pdf.expects(:text_box).with("1 1", { :height => nil })
+      @pdf.expects(:text_box).with("1 1", :height => nil)
       @pdf.number_pages "<page> <total>", :height => nil
     end
 
     it "with no height" do
-      @pdf.expects(:text_box).with("1 1", { :height => 50 })
+      @pdf.expects(:text_box).with("1 1", :height => 50)
       @pdf.number_pages "<page> <total>"
     end
   end
@@ -714,35 +708,35 @@ end
 describe "The page_match? method" do
   before do
     @pdf = Prawn::Document.new(:skip_page_creation => true)
-    10.times {@pdf.start_new_page}
+    10.times { @pdf.start_new_page }
   end
 
   it "returns nil given no filter" do
-    @pdf.page_match?(:nil, 1).should be_false
+    expect(@pdf.page_match?(:nil, 1)).to be_false
   end
 
   it "must provide an :all filter" do
-    (1..@pdf.page_count).all? { |i| @pdf.page_match?(:all, i) }.should be_true
+    expect((1..@pdf.page_count).all? { |i| @pdf.page_match?(:all, i) }).to be_true
   end
 
   it "must provide an :odd filter" do
-    odd, even = (1..@pdf.page_count).partition { |e| e % 2 == 1 }
-    odd.all? { |i| @pdf.page_match?(:odd, i) }.should be_true
-    even.any? { |i| @pdf.page_match?(:odd, i) }.should be_false
+    odd, even = (1..@pdf.page_count).partition(&:odd?)
+    expect(odd.all? { |i| @pdf.page_match?(:odd, i) }).to be_true
+    expect(even.any? { |i| @pdf.page_match?(:odd, i) }).to be_false
   end
 
   it "must be able to filter by an array of page numbers" do
-    fltr = [1,2,7]
-    (1..10).select { |i| @pdf.page_match?(fltr, i) }.should == [1,2,7]
+    fltr = [1, 2, 7]
+    expect((1..10).select { |i| @pdf.page_match?(fltr, i) }).to eq([1, 2, 7])
   end
 
   it "must be able to filter by a range of page numbers" do
     fltr = 2..4
-    (1..10).select { |i| @pdf.page_match?(fltr, i) }.should == [2,3,4]
+    expect((1..10).select { |i| @pdf.page_match?(fltr, i) }).to eq([2, 3, 4])
   end
 
   it "must be able to filter by an arbitrary proc" do
     fltr = lambda { |x| x == 1 or x % 3 == 0 }
-    (1..10).select { |i| @pdf.page_match?(fltr, i) }.should == [1,3,6,9]
+    expect((1..10).select { |i| @pdf.page_match?(fltr, i) }).to eq([1, 3, 6, 9])
   end
 end