prawn 2.0.1 → 2.0.2

data/manual/security/encryption.rb

@@ -16,14 +16,12 @@
 require File.expand_path(File.join(File.dirname(__FILE__),
                                    %w[.. example_helper]))
 
-
 # Bare encryption. No password needed.
 Prawn::ManualBuilder::Example.generate("bare_encryption.pdf") do
   text "See, no password was asked but the document is still encrypted."
   encrypt_document
 end
 
-
 # Simple password. All permissions granted.
 Prawn::ManualBuilder::Example.generate("simple_password.pdf") do
   text "You was asked for a password."

data/manual/security/permissions.rb

@@ -18,7 +18,6 @@
 require File.expand_path(File.join(File.dirname(__FILE__),
                                    %w[.. example_helper]))
 
-
 # User cannot print the document.
 Prawn::ManualBuilder::Example.generate("cannot_print.pdf") do
   text "If you used the user password you won't be able to print the doc."
@@ -26,7 +25,6 @@ Prawn::ManualBuilder::Example.generate("cannot_print.pdf") do
                    :permissions => { :print_document => false })
 end
 
-
 # All permissions revoked and owner password set to random
 Prawn::ManualBuilder::Example.generate("no_permissions.pdf") do
   text "You may only view this and won't be able to use the owner password."

data/manual/security/security.rb

@@ -6,9 +6,7 @@ require File.expand_path(File.join(File.dirname(__FILE__),
                                    %w[.. example_helper]))
 
 Prawn::ManualBuilder::Example.generate("security.pdf", :page_size => "FOLIO") do
-
   package "security" do |p|
-
     p.example "encryption",  :eval_source => false, :full_source => true
     p.example "permissions", :eval_source => false, :full_source => true
 
@@ -23,6 +21,5 @@ Prawn::ManualBuilder::Example.generate("security.pdf", :page_size => "FOLIO") do
             "How to set a owner password that bypass the document permissions"
           )
     end
-
   end
 end

data/manual/text/alignment.rb

@@ -22,16 +22,16 @@ Prawn::ManualBuilder::Example.generate(filename) do
   text "This text should be right aligned", :align => :right
 
   bounding_box([0, 220], :width => 250, :height => 220) do
-    text "This text is flowing from the left. "   * 4
+    text "This text is flowing from the left. " * 4
 
     move_down 15
     text "This text is flowing from the center. " * 3, :align => :center
 
     move_down 15
-    text "This text is flowing from the right. "  * 4, :align => :right
+    text "This text is flowing from the right. " * 4, :align => :right
 
     move_down 15
-    text "This text is justified. "  * 6, :align => :justify
+    text "This text is justified. " * 6, :align => :justify
     transparent(0.5) { stroke_bounds }
   end
 

data/manual/text/color.rb

@@ -21,4 +21,3 @@ Prawn::ManualBuilder::Example.generate(filename) do
        :color => "0000FF",
        :inline_format => true
 end
-

data/manual/text/column_box.rb

@@ -29,4 +29,3 @@ Prawn::ManualBuilder::Example.generate(filename) do
     END
   end
 end
-

data/manual/text/fallback_fonts.rb

@@ -16,7 +16,7 @@ Prawn::ManualBuilder::Example.generate(filename) do
 
   file = "#{Prawn::DATADIR}/fonts/Panic+Sans.dfont"
   font_families["Panic Sans"] = {
-    :normal => { :file => file, :font => "PanicSans" },
+    :normal => { :file => file, :font => "PanicSans" }
   }
 
   font("Panic Sans") do
@@ -31,7 +31,7 @@ Prawn::ManualBuilder::Example.generate(filename) do
   move_down 20
 
   formatted_text([ { :text => "Fallback fonts can even override" },
-                   { :text => "fragment fonts (你好)", :font => "Times-Roman" },
+                   { :text => "fragment fonts (你好)", :font => "Times-Roman" }
                  ],
                  :fallback_fonts => ["Times-Roman", "Kai"])
 end

data/manual/text/formatted_callbacks.rb

@@ -25,8 +25,9 @@ Prawn::ManualBuilder::Example.generate(filename) do
     def render_behind(fragment)
       original_color       = @document.fill_color
       @document.fill_color = @color
-      @document.fill_rectangle(fragment.top_left, fragment.width,
-                                                  fragment.height)
+      @document.fill_rectangle(fragment.top_left,
+                               fragment.width,
+                               fragment.height)
       @document.fill_color = original_color
     end
   end

data/manual/text/paragraph_indentation.rb

@@ -28,7 +28,6 @@ Prawn::ManualBuilder::Example.generate(filename) do
 
   text "FROM RIGHT TO LEFT:"
   text "This paragraph will be indented. " * 10 +
-        "\n" + "This one will too. " * 10,
-        :indent_paragraphs => 60, :direction => :rtl
-
+       "\n" + "This one will too. " * 10,
+       :indent_paragraphs => 60, :direction => :rtl
 end

data/manual/text/registering_families.rb

@@ -14,9 +14,11 @@ require File.expand_path(File.join(File.dirname(__FILE__),
 filename = File.basename(__FILE__).gsub('.rb', '.pdf')
 Prawn::ManualBuilder::Example.generate(filename) do
   # Registering a single TTF font
-  font_families.update("DejaVu Sans" => {
-    :normal => "#{Prawn::DATADIR}/fonts/DejaVuSans.ttf"
-  })
+  font_families.update(
+    "DejaVu Sans" => {
+      :normal => "#{Prawn::DATADIR}/fonts/DejaVuSans.ttf"
+    }
+  )
 
   font("DejaVu Sans") do
     text "Using the DejaVu Sans font providing only its name to the font method"
@@ -25,12 +27,14 @@ Prawn::ManualBuilder::Example.generate(filename) do
 
   # Registering a DFONT package
   font_path = "#{Prawn::DATADIR}/fonts/Panic+Sans.dfont"
-  font_families.update("Panic Sans" => {
-    :normal      => { :file => font_path, :font => "PanicSans" },
-    :italic      => { :file => font_path, :font => "PanicSans-Italic" },
-    :bold        => { :file => font_path, :font => "PanicSans-Bold" },
-    :bold_italic => { :file => font_path, :font => "PanicSans-BoldItalic" }
-  })
+  font_families.update(
+    "Panic Sans" => {
+      :normal      => { :file => font_path, :font => "PanicSans" },
+      :italic      => { :file => font_path, :font => "PanicSans-Italic" },
+      :bold        => { :file => font_path, :font => "PanicSans-Bold" },
+      :bold_italic => { :file => font_path, :font => "PanicSans-BoldItalic" }
+    }
+  )
 
   font "Panic Sans"
   text "Also using Panic Sans by providing only its name"

data/manual/text/rotation.rb

@@ -30,7 +30,6 @@ Prawn::ManualBuilder::Example.generate(filename) do
 
   [:lower_left, :upper_left,
    :lower_right, :upper_right].each_with_index do |corner, index|
-
     y = y - 100 if index == 2
     stroke_rectangle [x + (index % 2) * 200, y], width, height
     text_box("This text was rotated around the #{corner} corner.",

data/manual/text/text.rb

@@ -6,9 +6,7 @@ require File.expand_path(File.join(File.dirname(__FILE__),
                                    %w[.. example_helper]))
 
 Prawn::ManualBuilder::Example.generate("text.pdf", :page_size => "FOLIO") do
-
   package "text" do |p|
-
     p.section "Basics" do |s|
       s.example "free_flowing_text"
       s.example "positioned_text"
@@ -68,6 +66,5 @@ Prawn::ManualBuilder::Example.generate("text.pdf", :page_size => "FOLIO") do
             "What happens when rendering text in different languages"
           )
     end
-
   end
 end

data/manual/text/text_box_overflow.rb

@@ -29,8 +29,9 @@ Prawn::ManualBuilder::Example.generate(filename) do
   y_position = cursor - 20
   [:truncate, :expand, :shrink_to_fit].each_with_index do |mode, i|
     text_box string, :at => [i * 150, y_position],
-             :width => 100, :height => 50,
-             :overflow => mode
+                     :width => 100,
+                     :height => 50,
+                     :overflow => mode
   end
 
   string = "If the box is too small for the text, :shrink_to_fit " +
@@ -41,8 +42,9 @@ Prawn::ManualBuilder::Example.generate(filename) do
   y_position = cursor - 20
   [nil, 8, 10, 12].each_with_index do |value, index|
     text_box string, :at => [index * 150, y_position],
-             :width => 50, :height => 50,
-             :overflow => :shrink_to_fit,
-             :min_font_size => value
+                     :width => 50,
+                     :height => 50,
+                     :overflow => :shrink_to_fit,
+                     :min_font_size => value
   end
 end

data/manual/text/utf8.rb

@@ -13,7 +13,7 @@ Prawn::ManualBuilder::Example.generate(filename) do
   text "€", :size => 32
   move_down 20
 
-  text "This works, because €  is one of the few "+
+  text "This works, because €  is one of the few " +
        "non-ASCII glyphs supported in PDF built-in fonts."
 
   move_down 20

data/manual/text/win_ansi_charset.rb

@@ -47,11 +47,11 @@ Prawn::ManualBuilder::Example.generate(filename) do
         case align
         when :left   then offset = 0
         when :right  then offset = total_width - width
-        when :center then offset = (total_width - width)/2
+        when :center then offset = (total_width - width) / 2
         end
 
         text_box(field.force_encoding("windows-1252").encode("UTF-8"),
-          :at => [dx + offset, y])
+                 :at => [dx + offset, y])
       end
 
       dx += total_width

data/prawn.gemspec

@@ -19,13 +19,13 @@ Gem::Specification.new do |spec|
   spec.required_rubygems_version = ">= 1.3.6"
 
   spec.test_files = Dir[ "spec/*_spec.rb" ]
-  spec.authors = ["Gregory Brown","Brad Ediger","Daniel Nelson","Jonathan Greenberg","James Healy"]
-  spec.email = ["gregory.t.brown@gmail.com","brad@bradediger.com","dnelson@bluejade.com","greenberg@entryway.net","jimmy@deefa.com"]
+  spec.authors = ["Gregory Brown", "Brad Ediger", "Daniel Nelson", "Jonathan Greenberg", "James Healy"]
+  spec.email = ["gregory.t.brown@gmail.com", "brad@bradediger.com", "dnelson@bluejade.com", "greenberg@entryway.net", "jimmy@deefa.com"]
   spec.rubyforge_project = "prawn"
   spec.licenses = ['RUBY', 'GPL-2', 'GPL-3']
 
   spec.add_dependency('ttfunk', '~> 1.4.0')
-  spec.add_dependency('pdf-core', "~> 0.5.1")
+  spec.add_dependency('pdf-core', "~> 0.6.0")
 
   spec.add_development_dependency('pdf-inspector', '~> 1.2.0')
   spec.add_development_dependency('yard')
@@ -35,7 +35,7 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency('simplecov')
   spec.add_development_dependency('prawn-manual_builder', ">= 0.2.0")
   spec.add_development_dependency('pdf-reader', '~>1.2')
-  spec.add_development_dependency('rubocop', '0.28.0')
+  spec.add_development_dependency('rubocop', '0.30.1')
   spec.add_development_dependency('code_statistics', '0.2.13')
 
   spec.homepage = "http://prawn.majesticseacreature.com"

data/spec/acceptance/png.rb

@@ -3,11 +3,11 @@
 require_relative "../../lib/prawn"
 
 images = [
-      ["Type 0", "#{Prawn::BASEDIR}/data/images/web-links.png"],
-      ["Type 2", "#{Prawn::BASEDIR}/data/images/ruport.png"],
-      ["Type 3", "#{Prawn::BASEDIR}/data/images/indexed_color.png"],
-      ["Type 4", "#{Prawn::BASEDIR}/data/images/page_white_text.png"],
-      ["Type 6", "#{Prawn::BASEDIR}/data/images/dice.png"],
+  ["Type 0", "#{Prawn::BASEDIR}/data/images/web-links.png"],
+  ["Type 2", "#{Prawn::BASEDIR}/data/images/ruport.png"],
+  ["Type 3", "#{Prawn::BASEDIR}/data/images/indexed_color.png"],
+  ["Type 4", "#{Prawn::BASEDIR}/data/images/page_white_text.png"],
+  ["Type 6", "#{Prawn::BASEDIR}/data/images/dice.png"]
 ]
 
 Prawn::Document.generate("png_types.pdf", :page_size => "A5") do
@@ -19,7 +19,6 @@ Prawn::Document.generate("png_types.pdf", :page_size => "A5") do
     fill_rectangle bounds.top_left, bounds.width, bounds.height
     text header
 
-    image file, :at => [50,450]
+    image file, :at => [50, 450]
   end
 end
-

data/spec/annotations_spec.rb

@@ -2,73 +2,66 @@
 
 require File.join(File.expand_path(File.dirname(__FILE__)), "spec_helper")
 
-
 describe "When creating annotations" do
-
   before(:each) { create_pdf }
 
   it "should append annotation to current page" do
     @pdf.start_new_page
-    @pdf.annotate(:Rect => [0,0,10,10], :Subtype => :Text, :Contents => "Hello world!")
+    @pdf.annotate(:Rect => [0, 0, 10, 10], :Subtype => :Text, :Contents => "Hello world!")
     PDF::Reader.open(StringIO.new(@pdf.render)) do |pdf|
-      pdf.page(1).attributes[:Annots].should be_nil
-      pdf.page(2).attributes[:Annots].size.should == 1
+      expect(pdf.page(1).attributes[:Annots]).to be_nil
+      expect(pdf.page(2).attributes[:Annots].size).to eq(1)
     end
   end
 
   it "should force :Type to be :Annot" do
-    opts = @pdf.annotate(:Rect => [0,0,10,10], :Subtype => :Text, :Contents => "Hello world!")
-    opts[:Type].should == :Annot
-    opts = @pdf.annotate(:Type => :Bogus, :Rect => [0,0,10,10], :Subtype => :Text, :Contents => "Hello world!")
-    opts[:Type].should == :Annot
+    opts = @pdf.annotate(:Rect => [0, 0, 10, 10], :Subtype => :Text, :Contents => "Hello world!")
+    expect(opts[:Type]).to eq(:Annot)
+    opts = @pdf.annotate(:Type => :Bogus, :Rect => [0, 0, 10, 10], :Subtype => :Text, :Contents => "Hello world!")
+    expect(opts[:Type]).to eq(:Annot)
   end
-
 end
 
 describe "When creating text annotations" do
-
   before(:each) do
-    @rect = [0,0,10,10]
+    @rect = [0, 0, 10, 10]
     @content = "Hello, world!"
     create_pdf
   end
 
   it "should build appropriate annotation" do
     opts = @pdf.text_annotation(@rect, @content)
-    opts[:Type].should == :Annot
-    opts[:Subtype].should == :Text
-    opts[:Rect].should == @rect
-    opts[:Contents].should == @content
+    expect(opts[:Type]).to eq(:Annot)
+    expect(opts[:Subtype]).to eq(:Text)
+    expect(opts[:Rect]).to eq(@rect)
+    expect(opts[:Contents]).to eq(@content)
   end
 
   it "should merge extra options" do
     opts = @pdf.text_annotation(@rect, @content, :Open => true, :Subtype => :Bogus)
-    opts[:Subtype].should == :Text
-    opts[:Open].should == true
+    expect(opts[:Subtype]).to eq(:Text)
+    expect(opts[:Open]).to eq(true)
   end
-
 end
 
 describe "When creating link annotations" do
-
   before(:each) do
-    @rect = [0,0,10,10]
+    @rect = [0, 0, 10, 10]
     @dest = "home"
     create_pdf
   end
 
   it "should build appropriate annotation" do
     opts = @pdf.link_annotation(@rect, :Dest => @dest)
-    opts[:Type].should == :Annot
-    opts[:Subtype].should == :Link
-    opts[:Rect].should == @rect
-    opts[:Dest].should == @dest
+    expect(opts[:Type]).to eq(:Annot)
+    expect(opts[:Subtype]).to eq(:Link)
+    expect(opts[:Rect]).to eq(@rect)
+    expect(opts[:Dest]).to eq(@dest)
   end
 
   it "should merge extra options" do
     opts = @pdf.link_annotation(@rect, :Dest => @dest, :Subtype => :Bogus)
-    opts[:Subtype].should == :Link
-    opts[:Dest].should == @dest
+    expect(opts[:Subtype]).to eq(:Link)
+    expect(opts[:Dest]).to eq(@dest)
   end
-
 end

data/spec/bounding_box_spec.rb

@@ -3,101 +3,101 @@
 require File.join(File.expand_path(File.dirname(__FILE__)), "spec_helper")
 
 describe "A bounding box" do
-
   before(:each) do
     @x      = 100
     @y      = 125
     @width  = 50
     @height = 75
-    @box = Prawn::Document::BoundingBox.new(nil, nil, [@x,@y],
-      :width  => @width, :height => @height )
+    @box = Prawn::Document::BoundingBox.new(nil,
+                                            nil,
+                                            [@x, @y],
+                                            :width  => @width,
+                                            :height => @height)
   end
 
   it "should have an anchor at (x, y - height)" do
-    @box.anchor.should == [@x,@y-@height]
+    expect(@box.anchor).to eq([@x, @y - @height])
   end
 
   it "should have a left boundary of 0" do
-    @box.left.should == 0
+    expect(@box.left).to eq(0)
   end
 
   it "should have a right boundary equal to the width" do
-    @box.right.should == @width
+    expect(@box.right).to eq(@width)
   end
 
   it "should have a top boundary of height" do
-    @box.top.should == @height
+    expect(@box.top).to eq(@height)
   end
 
   it "should have a bottom boundary of 0" do
-    @box.bottom.should == 0
+    expect(@box.bottom).to eq(0)
   end
 
   it "should have a top-left of [0,height]" do
-    @box.top_left.should == [0,@height]
+    expect(@box.top_left).to eq([0, @height])
   end
 
   it "should have a top-right of [width,height]" do
-    @box.top_right.should == [@width,@height]
+    expect(@box.top_right).to eq([@width, @height])
   end
 
   it "should have a bottom-left of [0,0]" do
-    @box.bottom_left.should == [0,0]
+    expect(@box.bottom_left).to eq([0, 0])
   end
 
   it "should have a bottom-right of [width,0]" do
-    @box.bottom_right.should == [@width,0]
+    expect(@box.bottom_right).to eq([@width, 0])
   end
 
   it "should have an absolute left boundary of x" do
-    @box.absolute_left.should == @x
+    expect(@box.absolute_left).to eq(@x)
   end
 
   it "should have an absolute right boundary of x + width" do
-    @box.absolute_right.should == @x + @width
+    expect(@box.absolute_right).to eq(@x + @width)
   end
 
   it "should have an absolute top boundary of y" do
-    @box.absolute_top.should == @y
+    expect(@box.absolute_top).to eq(@y)
   end
 
   it "should have an absolute bottom boundary of y - height" do
-    @box.absolute_bottom.should == @y - @height
+    expect(@box.absolute_bottom).to eq(@y - @height)
   end
 
   it "should have an absolute bottom-left of [x,y-height]" do
-    @box.absolute_bottom_left.should == [@x, @y - @height]
+    expect(@box.absolute_bottom_left).to eq([@x, @y - @height])
   end
 
   it "should have an absolute bottom-right of [x+width,y-height]" do
-    @box.absolute_bottom_right.should == [@x + @width , @y - @height]
+    expect(@box.absolute_bottom_right).to eq([@x + @width , @y - @height])
   end
 
   it "should have an absolute top-left of [x,y]" do
-    @box.absolute_top_left.should == [@x, @y]
+    expect(@box.absolute_top_left).to eq([@x, @y])
   end
 
   it "should have an absolute top-right of [x+width,y]" do
-    @box.absolute_top_right.should == [@x + @width, @y]
+    expect(@box.absolute_top_right).to eq([@x + @width, @y])
   end
 
   it "should require width to be set" do
-    lambda do
-      Prawn::Document::BoundingBox.new(nil, nil, [100,100])
-    end.should raise_error(ArgumentError)
+    expect do
+      Prawn::Document::BoundingBox.new(nil, nil, [100, 100])
+    end.to raise_error(ArgumentError)
   end
 
   it "should raise_error an ArgumentError if a block is not passed" do
     pdf = Prawn::Document.new
-    lambda do
+    expect do
       pdf.bounding_box([0, 0], :width => 200)
-    end.should raise_error(ArgumentError)
+    end.to raise_error(ArgumentError)
   end
-
 end
 
 describe "drawing bounding boxes" do
-
   before(:each) { create_pdf }
 
   it "should not stomp on the arguments to bounding_box" do
@@ -106,7 +106,7 @@ describe "drawing bounding boxes" do
     pdf.bounding_box x, :width => 100 do
       pdf.text "bork-bork-bork"
     end
-    x.should == [100, 500]
+    expect(x).to eq([100, 500])
   end
 
   it "should restore Document#bounds to the correct margin box on exit" do
@@ -121,26 +121,24 @@ describe "drawing bounding boxes" do
 
     x_min, y_min, x_max, y_max = pdf.page.dimensions
 
-    pdf.bounds.absolute_top_left.should == [x_min, y_max]
-    pdf.bounds.absolute_bottom_right.should == [x_max, y_min]
+    expect(pdf.bounds.absolute_top_left).to eq([x_min, y_max])
+    expect(pdf.bounds.absolute_bottom_right).to eq([x_max, y_min])
   end
 
   it "should restore the parent bounding box when calls are nested" do
-    @pdf.bounding_box [100,500], :width => 300, :height => 300 do
-
-      @pdf.bounds.absolute_top.should  == 500 + @pdf.margin_box.absolute_bottom
-      @pdf.bounds.absolute_left.should == 100 + @pdf.margin_box.absolute_left
+    @pdf.bounding_box [100, 500], :width => 300, :height => 300 do
+      expect(@pdf.bounds.absolute_top).to eq(500 + @pdf.margin_box.absolute_bottom)
+      expect(@pdf.bounds.absolute_left).to eq(100 + @pdf.margin_box.absolute_left)
 
       parent_box = @pdf.bounds
 
-      @pdf.bounding_box [50,200], :width => 100, :height => 100 do
-        @pdf.bounds.absolute_top.should == 200 + parent_box.absolute_bottom
-        @pdf.bounds.absolute_left.should == 50 + parent_box.absolute_left
+      @pdf.bounding_box [50, 200], :width => 100, :height => 100 do
+        expect(@pdf.bounds.absolute_top).to eq(200 + parent_box.absolute_bottom)
+        expect(@pdf.bounds.absolute_left).to eq(50 + parent_box.absolute_left)
       end
 
-      @pdf.bounds.absolute_top.should  == 500 + @pdf.margin_box.absolute_bottom
-      @pdf.bounds.absolute_left.should == 100 + @pdf.margin_box.absolute_left
-
+      expect(@pdf.bounds.absolute_top).to eq(500 + @pdf.margin_box.absolute_bottom)
+      expect(@pdf.bounds.absolute_left).to eq(100 + @pdf.margin_box.absolute_left)
     end
   end
 
@@ -149,7 +147,7 @@ describe "drawing bounding boxes" do
       @pdf.text "The rain in Spain falls mainly on the plains."
     end
 
-    @pdf.y.should be_within(0.001).of(458.384)
+    expect(@pdf.y).to be_within(0.001).of(458.384)
   end
 
   it "should keep track of the max height the box was stretched to" do
@@ -158,77 +156,74 @@ describe "drawing bounding boxes" do
       @pdf.move_up 15
     end
 
-    box.height.should == 100
+    expect(box.height).to eq(100)
   end
 
   it "should advance the y-position by bbox.height by default" do
     orig_y = @pdf.y
-    @pdf.bounding_box [0, @pdf.cursor], :width => @pdf.bounds.width,
-        :height => 30 do
+    @pdf.bounding_box [0, @pdf.cursor], :width => @pdf.bounds.width, :height => 30 do
       @pdf.text "hello"
     end
-    @pdf.y.should be_within(0.001).of(orig_y - 30)
+    expect(@pdf.y).to be_within(0.001).of(orig_y - 30)
   end
 
   it "should not advance y-position if passed :hold_position => true" do
     orig_y = @pdf.y
-    @pdf.bounding_box [0, @pdf.cursor], :width => @pdf.bounds.width,
-        :hold_position => true do
+    @pdf.bounding_box [0, @pdf.cursor], :width => @pdf.bounds.width, :hold_position => true do
       @pdf.text "hello"
     end
     # y only advances by height of one line ("hello")
-    @pdf.y.should be_within(0.001).of(orig_y - @pdf.height_of("hello"))
+    expect(@pdf.y).to be_within(0.001).of(orig_y - @pdf.height_of("hello"))
   end
 
-  it "should not advance y-position of a stretchy bbox if it would stretch " +
+  it "should not advance y-position of a stretchy bbox if it would stretch " \
      "the bbox further" do
     bottom = @pdf.y = @pdf.margin_box.absolute_bottom
     @pdf.bounding_box [0, @pdf.margin_box.top], :width => @pdf.bounds.width do
       @pdf.y = bottom
       @pdf.text "hello" # starts a new page
     end
-    @pdf.page_count.should == 2
+    expect(@pdf.page_count).to eq(2)
 
     # Restoring the position (to the absolute bottom) would stretch the bbox to
     # the bottom of the page, which we don't want. This should be equivalent to
     # a bbox with :hold_position => true, where we only advance by the amount
     # that was actually drawn.
-    @pdf.y.should be_within(0.001).of(
+    expect(@pdf.y).to be_within(0.001).of(
       @pdf.margin_box.absolute_top - @pdf.height_of("hello")
     )
   end
-
 end
 
 describe "Indentation" do
   before(:each) { create_pdf }
 
   it "should temporarily shift the x coordinate and width" do
-    @pdf.bounding_box([100,100], :width => 200) do
+    @pdf.bounding_box([100, 100], :width => 200) do
       @pdf.indent(20) do
-        @pdf.bounds.absolute_left.should == 120
-        @pdf.bounds.width.should == 180
+        expect(@pdf.bounds.absolute_left).to eq(120)
+        expect(@pdf.bounds.width).to eq(180)
       end
     end
   end
 
   it "should restore the x coordinate and width after block exits" do
-    @pdf.bounding_box([100,100], :width => 200) do
+    @pdf.bounding_box([100, 100], :width => 200) do
       @pdf.indent(20) do
         # no-op
       end
-      @pdf.bounds.absolute_left.should == 100
-      @pdf.bounds.width.should == 200
+      expect(@pdf.bounds.absolute_left).to eq(100)
+      expect(@pdf.bounds.width).to eq(200)
     end
   end
 
   it "should restore the x coordinate and width on error" do
-    @pdf.bounding_box([100,100], :width => 200) do
+    @pdf.bounding_box([100, 100], :width => 200) do
       begin
-        @pdf.indent(20) { raise }
+        @pdf.indent(20) { fail }
       rescue
-        @pdf.bounds.absolute_left.should == 100
-        @pdf.bounds.width.should == 200
+        expect(@pdf.bounds.absolute_left).to eq(100)
+        expect(@pdf.bounds.width).to eq(200)
       end
     end
   end
@@ -237,54 +232,52 @@ describe "Indentation" do
     original_left = @pdf.bounds.absolute_left
 
     @pdf.indent(20) do
-      @pdf.bounds.absolute_left.should == original_left + 20
+      expect(@pdf.bounds.absolute_left).to eq(original_left + 20)
       @pdf.start_new_page
-      @pdf.bounds.absolute_left.should == original_left + 20
+      expect(@pdf.bounds.absolute_left).to eq(original_left + 20)
     end
 
-    @pdf.bounds.absolute_left.should == original_left
+    expect(@pdf.bounds.absolute_left).to eq(original_left)
   end
 
   it "should maintain right indentation across a page break" do
     original_width = @pdf.bounds.width
 
     @pdf.indent(0, 20) do
-      @pdf.bounds.width.should == original_width - 20
+      expect(@pdf.bounds.width).to eq(original_width - 20)
       @pdf.start_new_page
-      @pdf.bounds.width.should == original_width - 20
+      expect(@pdf.bounds.width).to eq(original_width - 20)
     end
 
-    @pdf.bounds.width.should == original_width
+    expect(@pdf.bounds.width).to eq(original_width)
   end
 
   it "optionally allows adjustment of the right bound as well" do
-    @pdf.bounding_box([100,100], :width => 200) do
+    @pdf.bounding_box([100, 100], :width => 200) do
       @pdf.indent(20, 30) do
-        @pdf.bounds.absolute_left.should == 120
-        @pdf.bounds.width.should == 150
+        expect(@pdf.bounds.absolute_left).to eq(120)
+        expect(@pdf.bounds.width).to eq(150)
       end
-      @pdf.bounds.absolute_left.should == 100
-      @pdf.bounds.width.should == 200
+      expect(@pdf.bounds.absolute_left).to eq(100)
+      expect(@pdf.bounds.width).to eq(200)
     end
   end
 
   describe "in a ColumnBox" do
     it "should subtract the given indentation from the available width" do
-      @pdf.column_box([0, @pdf.cursor], :width => @pdf.bounds.width,
-                      :height => 200, :columns => 2, :spacer => 20) do
+      @pdf.column_box([0, @pdf.cursor], :width => @pdf.bounds.width, :height => 200, :columns => 2, :spacer => 20) do
         width = @pdf.bounds.width
         @pdf.indent(20) do
-          @pdf.bounds.width.should be_within(0.01).of(width - 20)
+          expect(@pdf.bounds.width).to be_within(0.01).of(width - 20)
         end
       end
     end
 
     it "should subtract right padding from the available width" do
-      @pdf.column_box([0, @pdf.cursor], :width => @pdf.bounds.width,
-                      :height => 200, :columns => 2, :spacer => 20) do
+      @pdf.column_box([0, @pdf.cursor], :width => @pdf.bounds.width, :height => 200, :columns => 2, :spacer => 20) do
         width = @pdf.bounds.width
         @pdf.indent(20, 30) do
-          @pdf.bounds.width.should be_within(0.01).of(width - 50)
+          expect(@pdf.bounds.width).to be_within(0.01).of(width - 50)
         end
       end
     end
@@ -294,7 +287,7 @@ describe "Indentation" do
         3.times do |column|
           x = @pdf.bounds.left_side
           @pdf.indent(20) do
-            @pdf.bounds.left_side.should == x+20
+            expect(@pdf.bounds.left_side).to eq(x + 20)
           end
           @pdf.bounds.move_past_bottom
         end
@@ -306,7 +299,7 @@ describe "Indentation" do
         3.times do |column|
           x = @pdf.bounds.right_side
           @pdf.indent(20) do
-            @pdf.bounds.right_side.should == x
+            expect(@pdf.bounds.right_side).to eq(x)
           end
           @pdf.bounds.move_past_bottom
         end
@@ -318,7 +311,7 @@ describe "Indentation" do
         3.times do |column|
           x = @pdf.bounds.right_side
           @pdf.indent(20, 10) do
-            @pdf.bounds.right_side.should == x-10
+            expect(@pdf.bounds.right_side).to eq(x - 10)
           end
           @pdf.bounds.move_past_bottom
         end
@@ -334,7 +327,7 @@ describe "Indentation" do
             # ...and no right indent here...
             @pdf.indent(20) do
               # right indent is inherited from the parent!
-              @pdf.bounds.right_side.should == x
+              expect(@pdf.bounds.right_side).to eq(x)
             end
           end
           @pdf.bounds.move_past_bottom
@@ -350,7 +343,7 @@ describe "Indentation" do
             # requesting a negative right-indent of equivalent size...
             @pdf.indent(20, -10) do
               # ...resets the right margin to that of the column!
-              @pdf.bounds.right_side.should == x
+              expect(@pdf.bounds.right_side).to eq(x)
             end
           end
           @pdf.bounds.move_past_bottom
@@ -364,7 +357,7 @@ describe "Indentation" do
           w = @pdf.bounds.width
           @pdf.indent(20, 10) do
             @pdf.indent(20, 10) do
-              @pdf.bounds.width.should == w - 60
+              expect(@pdf.bounds.width).to eq(w - 60)
             end
           end
           @pdf.bounds.move_past_bottom
@@ -379,9 +372,9 @@ describe "A canvas" do
 
   it "should use whatever the last set y position is" do
     @pdf.canvas do
-      @pdf.bounding_box([100,500],:width => 200) { @pdf.move_down 50 }
+      @pdf.bounding_box([100, 500], :width => 200) { @pdf.move_down 50 }
     end
-    @pdf.y.should == 450
+    expect(@pdf.y).to eq(450)
   end
 
   it "should restore the original ypos after execution", :issue => 523 do
@@ -392,9 +385,8 @@ describe "A canvas" do
 
     doc.canvas {}
 
-    doc.y.should == original_ypos
+    expect(doc.y).to eq(original_ypos)
   end
-
 end
 
 describe "Deep-copying" do
@@ -403,8 +395,8 @@ describe "Deep-copying" do
       orig = pdf.bounds
       copy = orig.deep_copy
 
-      copy.should_not == pdf.bounds
-      copy.document.should be_nil
+      expect(copy).not_to eq(pdf.bounds)
+      expect(copy.document).to be_nil
     end
   end
 
@@ -415,11 +407,11 @@ describe "Deep-copying" do
         copy = pdf.bounds.deep_copy
 
         # the parent bounds should have the same parameters
-        copy.parent.width.should  == outside.width
-        copy.parent.height.should == outside.height
+        expect(copy.parent.width).to eq(outside.width)
+        expect(copy.parent.height).to eq(outside.height)
 
         # but should not be the same object
-        copy.parent.should_not == outside
+        expect(copy.parent).not_to eq(outside)
       end
     end
   end
@@ -430,7 +422,7 @@ describe "Prawn::Document#reference_bounds" do
 
   it "should return self for non-stretchy bounds" do
     @pdf.bounding_box([0, @pdf.cursor], :width => 100, :height => 100) do
-      @pdf.reference_bounds.should == @pdf.bounds
+      expect(@pdf.reference_bounds).to eq(@pdf.bounds)
     end
   end
 
@@ -438,7 +430,7 @@ describe "Prawn::Document#reference_bounds" do
     @pdf.bounding_box([0, @pdf.cursor], :width => 100, :height => 100) do
       correct_bounds = @pdf.bounds
       @pdf.bounding_box([0, @pdf.cursor], :width => 100) do
-        @pdf.reference_bounds.should == correct_bounds
+        expect(@pdf.reference_bounds).to eq(correct_bounds)
       end
     end
   end
@@ -448,17 +440,17 @@ describe "Prawn::Document#reference_bounds" do
       correct_bounds = @pdf.bounds
       @pdf.bounding_box([0, @pdf.cursor], :width => 100) do
         @pdf.bounding_box([0, @pdf.cursor], :width => 100) do
-          @pdf.reference_bounds.should == correct_bounds
+          expect(@pdf.reference_bounds).to eq(correct_bounds)
         end
       end
     end
   end
 
   it "should return the margin box if there's no explicit bbox" do
-    @pdf.reference_bounds.should == @pdf.margin_box
+    expect(@pdf.reference_bounds).to eq(@pdf.margin_box)
 
     @pdf.bounding_box([0, @pdf.cursor], :width => 100) do
-      @pdf.reference_bounds.should == @pdf.margin_box
+      expect(@pdf.reference_bounds).to eq(@pdf.margin_box)
     end
   end
 
@@ -466,14 +458,13 @@ describe "Prawn::Document#reference_bounds" do
     @pdf.canvas do
       canvas_box = @pdf.bounds
 
-      @pdf.reference_bounds.should == canvas_box
+      expect(@pdf.reference_bounds).to eq(canvas_box)
 
       @pdf.bounding_box([0, @pdf.cursor], :width => 100) do
-        @pdf.reference_bounds.should == canvas_box
+        expect(@pdf.reference_bounds).to eq(canvas_box)
       end
     end
   end
-
 end
 
 describe "BoundingBox#move_past_bottom" do
@@ -484,9 +475,9 @@ describe "BoundingBox#move_past_bottom" do
     @pdf.text "Foo"
 
     pages = PDF::Inspector::Page.analyze(@pdf.render).pages
-    pages.size.should == 2
-    pages[0][:strings].should == []
-    pages[1][:strings].should == ["Foo"]
+    expect(pages.size).to eq(2)
+    expect(pages[0][:strings]).to eq([])
+    expect(pages[1][:strings]).to eq(["Foo"])
   end
 
   it "should move to the top of the next page if it exists already" do
@@ -499,12 +490,12 @@ describe "BoundingBox#move_past_bottom" do
     @pdf.text "Foo"
 
     @pdf.bounds.move_past_bottom
-    @pdf.y.should be_within(0.001).of(top_y)
+    expect(@pdf.y).to be_within(0.001).of(top_y)
     @pdf.text "Bar"
 
     pages = PDF::Inspector::Page.analyze(@pdf.render).pages
-    pages.size.should == 2
-    pages[0][:strings].should == ["Foo"]
-    pages[1][:strings].should == ["Bar"]
+    expect(pages.size).to eq(2)
+    expect(pages[0][:strings]).to eq(["Foo"])
+    expect(pages[1][:strings]).to eq(["Bar"])
   end
 end