prawn 2.0.1 → 2.0.2

data/spec/grid_spec.rb

@@ -8,20 +8,20 @@ describe "A document's grid" do
 
   it "should allow definition of a grid" do
     @pdf.define_grid(:columns => 5, :rows => 8, :gutter => 0.1)
-    @pdf.grid.columns.should == 5
-    @pdf.grid.rows.should == 8
-    @pdf.grid.gutter.should == 0.1
+    expect(@pdf.grid.columns).to eq(5)
+    expect(@pdf.grid.rows).to eq(8)
+    expect(@pdf.grid.gutter).to eq(0.1)
   end
 
   it "should allow re-definition of a grid" do
     @pdf.define_grid(:columns => 5, :rows => 8, :gutter => 0.1)
-    @pdf.grid.columns.should == 5
-    @pdf.grid.rows.should == 8
-    @pdf.grid.gutter.should == 0.1
+    expect(@pdf.grid.columns).to eq(5)
+    expect(@pdf.grid.rows).to eq(8)
+    expect(@pdf.grid.gutter).to eq(0.1)
     @pdf.define_grid(:columns => 3, :rows => 6, :gutter => 0.1)
-    @pdf.grid.columns.should == 3
-    @pdf.grid.rows.should == 6
-    @pdf.grid.gutter.should == 0.1
+    expect(@pdf.grid.columns).to eq(3)
+    expect(@pdf.grid.rows).to eq(6)
+    expect(@pdf.grid.gutter).to eq(0.1)
   end
 
   describe "when a grid is defined" do
@@ -37,49 +37,48 @@ describe "A document's grid" do
     end
 
     it "should compute the column width" do
-      (@pdf.grid.column_width * @num_columns.to_f +
-        @gutter * (@num_columns - 1).to_f).should == @pdf.bounds.width
+      expect(@pdf.grid.column_width * @num_columns.to_f +
+        @gutter * (@num_columns - 1).to_f).to eq(@pdf.bounds.width)
     end
 
     it "should compute the row height" do
-      (@pdf.grid.row_height * @num_rows.to_f +
-        @gutter * (@num_rows - 1).to_f).should == @pdf.bounds.height
+      expect(@pdf.grid.row_height * @num_rows.to_f +
+        @gutter * (@num_rows - 1).to_f).to eq(@pdf.bounds.height)
     end
 
     it "should give the edges of a grid box" do
       grid_width = (@pdf.bounds.width.to_f -
-        (@gutter * (@num_columns - 1).to_f )) / @num_columns.to_f
+        (@gutter * (@num_columns - 1).to_f)) / @num_columns.to_f
       grid_height = (@pdf.bounds.height.to_f -
-        (@gutter * (@num_rows - 1).to_f ))/ @num_rows.to_f
+        (@gutter * (@num_rows - 1).to_f)) / @num_rows.to_f
 
       exp_tl_x = (grid_width + @gutter.to_f) * 4.0
       exp_tl_y = @pdf.bounds.height.to_f - (grid_height + @gutter.to_f)
 
-      @pdf.grid(1,4).top_left.should      == [exp_tl_x, exp_tl_y]
-      @pdf.grid(1,4).top_right.should     == [exp_tl_x + grid_width, exp_tl_y]
-      @pdf.grid(1,4).bottom_left.should   == [exp_tl_x, exp_tl_y - grid_height]
-      @pdf.grid(1,4).bottom_right.should  == [exp_tl_x + grid_width, exp_tl_y - grid_height]
+      expect(@pdf.grid(1, 4).top_left).to eq([exp_tl_x, exp_tl_y])
+      expect(@pdf.grid(1, 4).top_right).to eq([exp_tl_x + grid_width, exp_tl_y])
+      expect(@pdf.grid(1, 4).bottom_left).to eq([exp_tl_x, exp_tl_y - grid_height])
+      expect(@pdf.grid(1, 4).bottom_right).to eq([exp_tl_x + grid_width, exp_tl_y - grid_height])
     end
 
     it "should give the edges of a multiple grid boxes" do
       # Hand verified.  Cheating a bit.  Don't tell.
-      @pdf.grid([1,3], [2,5]).top_left.should     == [330.0, 628.75]
-      @pdf.grid([1,3], [2,5]).top_right.should    == [650.0, 628.75]
-      @pdf.grid([1,3], [2,5]).bottom_left.should  == [330.0, 456.25]
-      @pdf.grid([1,3], [2,5]).bottom_right.should == [650.0, 456.25]
+      expect(@pdf.grid([1, 3], [2, 5]).top_left).to eq([330.0, 628.75])
+      expect(@pdf.grid([1, 3], [2, 5]).top_right).to eq([650.0, 628.75])
+      expect(@pdf.grid([1, 3], [2, 5]).bottom_left).to eq([330.0, 456.25])
+      expect(@pdf.grid([1, 3], [2, 5]).bottom_right).to eq([650.0, 456.25])
     end
 
     it "should draw outlines without changing global default colors to grid color" do
       @pdf.grid.show_all('cccccc')
 
       colors = PDF::Inspector::Graphics::Color.analyze(@pdf.render)
-      colors.fill_color.should_not   == [0.8,0.8,0.8]
-      colors.stroke_color.should_not == [0.8,0.8,0.8]
+      expect(colors.fill_color).not_to eq([0.8, 0.8, 0.8])
+      expect(colors.stroke_color).not_to eq([0.8, 0.8, 0.8])
 
       # Hardcoded default color as I haven't been able to come up with a stable converter
       # between fill_color without lots code.
-      #colors.fill_color.should   == [0.0,0.0,0.0]
-      colors.stroke_color.should == [0.0,0.0,0.0]
+      expect(colors.stroke_color).to eq([0.0, 0.0, 0.0])
     end
 
     it "should draw outlines without curent color settings" do
@@ -89,8 +88,8 @@ describe "A document's grid" do
       @pdf.grid.show_all
 
       colors = PDF::Inspector::Graphics::Color.analyze(@pdf.render)
-      colors.fill_color.should   == [0.8,1.0,0.0]
-      colors.stroke_color.should == [1.0,0.8,0.0]
+      expect(colors.fill_color).to eq([0.8, 1.0, 0.0])
+      expect(colors.stroke_color).to eq([1.0, 0.8, 0.0])
     end
   end
 end

data/spec/image_handler_spec.rb

@@ -15,7 +15,7 @@ describe "ImageHandler" do
     image_handler.register(handler_b)
 
     handler = image_handler.find("arbitrary blob")
-    handler.should == handler_a
+    expect(handler).to eq(handler_a)
   end
 
   it "can prepend handlers" do
@@ -25,7 +25,7 @@ describe "ImageHandler" do
     image_handler.register!(handler_b)
 
     handler = image_handler.find("arbitrary blob")
-    handler.should == handler_b
+    expect(handler).to eq(handler_b)
   end
 
   it "can unregister a handler" do
@@ -37,7 +37,7 @@ describe "ImageHandler" do
     image_handler.unregister(handler_a)
 
     handler = image_handler.find('arbitrary blob')
-    handler.should == handler_b
+    expect(handler).to eq(handler_b)
   end
 
   it "raises an error when no matching handler is found" do
@@ -48,7 +48,6 @@ describe "ImageHandler" do
     image_handler.register(handler_b)
 
     expect { image_handler.find("arbitrary blob") }.
-       to(raise_error(Prawn::Errors::UnsupportedImageType))
+      to(raise_error(Prawn::Errors::UnsupportedImageType))
   end
-
 end

data/spec/images_spec.rb

@@ -5,37 +5,36 @@ require 'set'
 require 'pathname'
 
 describe "the image() function" do
-
   before(:each) do
     @filename = "#{Prawn::DATADIR}/images/pigs.jpg"
     create_pdf
   end
 
   it "should only embed an image once, even if it's added multiple times" do
-    @pdf.image @filename, :at => [100,100]
-    @pdf.image @filename, :at => [300,300]
+    @pdf.image @filename, :at => [100, 100]
+    @pdf.image @filename, :at => [300, 300]
 
     output = @pdf.render
     images = PDF::Inspector::XObject.analyze(output)
     # there should be 2 images in the page resources
-    images.page_xobjects.first.size.should == 2
+    expect(images.page_xobjects.first.size).to eq(2)
     # but only 1 image xobject
-    output.scan(/\/Type \/XObject/).size.should == 1
+    expect(output.scan(/\/Type \/XObject/).size).to eq(1)
   end
 
   it "should return the image info object" do
     info =  @pdf.image(@filename)
 
-    info.should be_a_kind_of(Prawn::Images::JPG)
+    expect(info).to be_a_kind_of(Prawn::Images::JPG)
 
-    info.height.should == 453
+    expect(info.height).to eq(453)
   end
 
   it "should accept IO objects" do
     file = File.open(@filename, "rb")
     info = @pdf.image(file)
 
-    info.height.should == 453
+    expect(info.height).to eq(453)
   end
 
   it "rewinds IO objects to be able to embed them multiply" do
@@ -43,12 +42,12 @@ describe "the image() function" do
 
     @pdf.image(file)
     info = @pdf.image(file)
-    info.height.should == 453
+    expect(info.height).to eq(453)
   end
 
   it "should accept Pathname objects" do
     info = @pdf.image(Pathname.new(@filename))
-    info.height.should == 453
+    expect(info.height).to eq(453)
   end
 
   context "setting the length of the bytestream" do
@@ -70,25 +69,25 @@ describe "the image() function" do
 
   it "should raise_error an UnsupportedImageType if passed a BMP" do
     filename = "#{Prawn::DATADIR}/images/tru256.bmp"
-    lambda { @pdf.image filename, :at => [100,100] }.should raise_error(Prawn::Errors::UnsupportedImageType)
+    expect { @pdf.image filename, :at => [100, 100] }.to raise_error(Prawn::Errors::UnsupportedImageType)
   end
 
   it "should raise_error an UnsupportedImageType if passed an interlaced PNG" do
     filename = "#{Prawn::DATADIR}/images/dice_interlaced.png"
-    lambda { @pdf.image filename, :at => [100,100] }.should raise_error(Prawn::Errors::UnsupportedImageType)
+    expect { @pdf.image filename, :at => [100, 100] }.to raise_error(Prawn::Errors::UnsupportedImageType)
   end
 
   it "should bump PDF version to 1.5 or greater on embedding 16-bit PNGs" do
     @pdf.image "#{Prawn::DATADIR}/images/16bit.png"
-    @pdf.state.version.should >= 1.5
+    expect(@pdf.state.version).to be >= 1.5
   end
 
   it "should embed 16-bit alpha channels for 16-bit PNGs" do
     @pdf.image "#{Prawn::DATADIR}/images/16bit.png"
 
     output = @pdf.render
-    output.should =~ /\/BitsPerComponent 16/
-    output.should_not =~ /\/BitsPerComponent 8/
+    expect(output).to match(/\/BitsPerComponent 16/)
+    expect(output).not_to match(/\/BitsPerComponent 8/)
   end
 
   it "should flow an image to a new page if it will not fit on a page" do
@@ -96,10 +95,10 @@ describe "the image() function" do
     @pdf.image @filename, :fit => [600, 600]
     output = StringIO.new(@pdf.render, 'r+')
     hash = PDF::Reader::ObjectHash.new(output)
-    pages = hash.values.find {|obj| obj.is_a?(Hash) && obj[:Type] == :Pages}[:Kids]
-    pages.size.should == 2
-    hash[pages[0]][:Resources][:XObject].keys.should == [:I1]
-    hash[pages[1]][:Resources][:XObject].keys.should == [:I2]
+    pages = hash.values.find { |obj| obj.is_a?(Hash) && obj[:Type] == :Pages }[:Kids]
+    expect(pages.size).to eq(2)
+    expect(hash[pages[0]][:Resources][:XObject].keys).to eq([:I1])
+    expect(hash[pages[1]][:Resources][:XObject].keys).to eq([:I2])
   end
 
   it "should not flow an image to a new page if it will fit on one page" do
@@ -107,10 +106,11 @@ describe "the image() function" do
     @pdf.image @filename, :fit => [400, 400]
     output = StringIO.new(@pdf.render, 'r+')
     hash = PDF::Reader::ObjectHash.new(output)
-    pages = hash.values.find {|obj| obj.is_a?(Hash) && obj[:Type] == :Pages}[:Kids]
-    pages.size.should == 1
-    Set.new(hash[pages[0]][:Resources][:XObject].keys).should ==
+    pages = hash.values.find { |obj| obj.is_a?(Hash) && obj[:Type] == :Pages }[:Kids]
+    expect(pages.size).to eq(1)
+    expect(Set.new(hash[pages[0]][:Resources][:XObject].keys)).to eq(
       Set.new([:I1, :I2])
+    )
   end
 
   it "should not start a new page just for a stretchy bounding box" do
@@ -122,32 +122,46 @@ describe "the image() function" do
 
   describe ":fit option" do
     it "should fit inside the defined constraints" do
-      info = @pdf.image @filename, :fit => [100,400]
-      info.scaled_width.should <= 100
-      info.scaled_height.should <= 400
+      info = @pdf.image @filename, :fit => [100, 400]
+      expect(info.scaled_width).to be <= 100
+      expect(info.scaled_height).to be <= 400
 
-      info = @pdf.image @filename, :fit => [400,100]
-      info.scaled_width.should <= 400
-      info.scaled_height.should <= 100
+      info = @pdf.image @filename, :fit => [400, 100]
+      expect(info.scaled_width).to be <= 400
+      expect(info.scaled_height).to be <= 100
 
-      info = @pdf.image @filename, :fit => [604,453]
-      info.scaled_width.should == 604
-      info.scaled_height.should == 453
+      info = @pdf.image @filename, :fit => [604, 453]
+      expect(info.scaled_width).to eq(604)
+      expect(info.scaled_height).to eq(453)
     end
     it "should move text position" do
       @y = @pdf.y
-      info = @pdf.image @filename, :fit => [100,400]
-      @pdf.y.should < @y
+      info = @pdf.image @filename, :fit => [100, 400]
+      expect(@pdf.y).to be < @y
     end
   end
 
   describe ":at option" do
     it "should not move text position" do
       @y = @pdf.y
-      info = @pdf.image @filename, :at => [100,400]
-      @pdf.y.should == @y
+      info = @pdf.image @filename, :at => [100, 400]
+      expect(@pdf.y).to eq(@y)
     end
   end
 
-end
+  describe ":width option without :height option" do
+    it "scales the width and height" do
+      info = @pdf.image @filename, :width => 225
+      expect(info.scaled_height).to eq(168.75)
+      expect(info.scaled_width).to eq(225.0)
+    end
+  end
 
+  describe ":height option without :width option" do
+    it "scales the width and height" do
+      info = @pdf.image @filename, :height => 225
+      expect(info.scaled_height).to eq(225.0)
+      expect(info.scaled_width).to eq(300.0)
+    end
+  end
+end

data/spec/inline_formatted_text_parser_spec.rb

@@ -5,443 +5,442 @@ describe "Text::Formatted::Parser#format" do
   it "should handle sup" do
     string = "<sup>superscript</sup>"
     array = Prawn::Text::Formatted::Parser.format(string)
-    array[0].should == { :text => "superscript",
-                         :styles => [:superscript],
-                         :color => nil,
-                         :link => nil,
-                         :anchor => nil,
-                         :local => nil,
-                         :font => nil,
-                         :size => nil,
-                         :character_spacing => nil }
+    expect(array[0]).to eq(:text => "superscript",
+                           :styles => [:superscript],
+                           :color => nil,
+                           :link => nil,
+                           :anchor => nil,
+                           :local => nil,
+                           :font => nil,
+                           :size => nil,
+                           :character_spacing => nil)
   end
   it "should handle sub" do
     string = "<sub>subscript</sub>"
     array = Prawn::Text::Formatted::Parser.format(string)
-    array[0].should == { :text => "subscript",
-                         :styles => [:subscript],
-                         :color => nil,
-                         :link => nil,
-                         :anchor => nil,
-                         :local => nil,
-                         :font => nil,
-                         :size => nil,
-                         :character_spacing => nil }
+    expect(array[0]).to eq(:text => "subscript",
+                           :styles => [:subscript],
+                           :color => nil,
+                           :link => nil,
+                           :anchor => nil,
+                           :local => nil,
+                           :font => nil,
+                           :size => nil,
+                           :character_spacing => nil)
   end
   it "should handle rgb" do
     string = "<color rgb='#ff0000'>red text</color>"
     array = Prawn::Text::Formatted::Parser.format(string)
-    array[0].should == { :text => "red text",
-                         :styles => [],
-                         :color => "ff0000",
-                         :link => nil,
-                         :anchor => nil,
-                         :local => nil,
-                         :font => nil,
-                         :size => nil,
-                         :character_spacing => nil }
+    expect(array[0]).to eq(:text => "red text",
+                           :styles => [],
+                           :color => "ff0000",
+                           :link => nil,
+                           :anchor => nil,
+                           :local => nil,
+                           :font => nil,
+                           :size => nil,
+                           :character_spacing => nil)
   end
   it "# should be optional in rgb" do
     string = "<color rgb='ff0000'>red text</color>"
     array = Prawn::Text::Formatted::Parser.format(string)
-    array[0].should == { :text => "red text",
-                         :styles => [],
-                         :color => "ff0000",
-                         :link => nil,
-                         :anchor => nil,
-                         :local => nil,
-                         :font => nil,
-                         :size => nil,
-                         :character_spacing => nil }
+    expect(array[0]).to eq(:text => "red text",
+                           :styles => [],
+                           :color => "ff0000",
+                           :link => nil,
+                           :anchor => nil,
+                           :local => nil,
+                           :font => nil,
+                           :size => nil,
+                           :character_spacing => nil)
   end
   it "should handle cmyk" do
     string = "<color c='0' m='100' y='0' k='0'>magenta text</color>"
     array = Prawn::Text::Formatted::Parser.format(string)
-    array[0].should == { :text => "magenta text",
-                         :styles => [],
-                         :color => [0, 100, 0, 0],
-                         :link => nil,
-                         :anchor => nil,
-                         :local => nil,
-                         :font => nil,
-                         :size => nil,
-                         :character_spacing => nil }
+    expect(array[0]).to eq(:text => "magenta text",
+                           :styles => [],
+                           :color => [0, 100, 0, 0],
+                           :link => nil,
+                           :anchor => nil,
+                           :local => nil,
+                           :font => nil,
+                           :size => nil,
+                           :character_spacing => nil)
   end
   it "should handle fonts" do
     string = "<font name='Courier'>Courier text</font>"
     array = Prawn::Text::Formatted::Parser.format(string)
-    array[0].should == { :text => "Courier text",
-                         :styles => [],
-                         :color => nil,
-                         :link => nil,
-                         :anchor => nil,
-                         :local => nil,
-                         :font => "Courier",
-                         :size => nil,
-                         :character_spacing => nil }
+    expect(array[0]).to eq(:text => "Courier text",
+                           :styles => [],
+                           :color => nil,
+                           :link => nil,
+                           :anchor => nil,
+                           :local => nil,
+                           :font => "Courier",
+                           :size => nil,
+                           :character_spacing => nil)
   end
   it "should handle size" do
     string = "<font size='14'>14 point text</font>"
     array = Prawn::Text::Formatted::Parser.format(string)
-    array[0].should == { :text => "14 point text",
-                         :styles => [],
-                         :color => nil,
-                         :link => nil,
-                         :anchor => nil,
-                         :local => nil,
-                         :font => nil,
-                         :size => 14,
-                         :character_spacing => nil }
+    expect(array[0]).to eq(:text => "14 point text",
+                           :styles => [],
+                           :color => nil,
+                           :link => nil,
+                           :anchor => nil,
+                           :local => nil,
+                           :font => nil,
+                           :size => 14,
+                           :character_spacing => nil)
   end
   it "should handle character_spacing" do
     string = "<font character_spacing='2.5'>extra character spacing</font>"
     array = Prawn::Text::Formatted::Parser.format(string)
-    array[0].should == { :text => "extra character spacing",
-                         :styles => [],
-                         :color => nil,
-                         :link => nil,
-                         :anchor => nil,
-                         :local => nil,
-                         :font => nil,
-                         :size => nil,
-                         :character_spacing => 2.5 }
+    expect(array[0]).to eq(:text => "extra character spacing",
+                           :styles => [],
+                           :color => nil,
+                           :link => nil,
+                           :anchor => nil,
+                           :local => nil,
+                           :font => nil,
+                           :size => nil,
+                           :character_spacing => 2.5)
   end
   it "should handle links" do
     string = "<link href='http://example.com'>external link</link>"
     array = Prawn::Text::Formatted::Parser.format(string)
-    array[0].should == { :text => "external link",
-                         :styles => [],
-                         :color => nil,
-                         :link => "http://example.com",
-                         :anchor => nil,
-                         :local => nil,
-                         :font => nil,
-                         :size => nil,
-                         :character_spacing => nil }
+    expect(array[0]).to eq(:text => "external link",
+                           :styles => [],
+                           :color => nil,
+                           :link => "http://example.com",
+                           :anchor => nil,
+                           :local => nil,
+                           :font => nil,
+                           :size => nil,
+                           :character_spacing => nil)
   end
   it "should handle local links" do
     string = "<link local='/home/example/foo.bar'>local link</link>"
     array = Prawn::Text::Formatted::Parser.format(string)
-    array[0].should == { :text => "local link",
-                         :styles => [],
-                         :color => nil,
-                         :link => nil,
-                         :anchor => nil,
-                         :local => "/home/example/foo.bar",
-                         :font => nil,
-                         :size => nil,
-                         :character_spacing => nil }
+    expect(array[0]).to eq(:text => "local link",
+                           :styles => [],
+                           :color => nil,
+                           :link => nil,
+                           :anchor => nil,
+                           :local => "/home/example/foo.bar",
+                           :font => nil,
+                           :size => nil,
+                           :character_spacing => nil)
   end
   it "should handle anchors" do
     string = "<link anchor='ToC'>internal link</link>"
     array = Prawn::Text::Formatted::Parser.format(string)
-    array[0].should == { :text => "internal link",
-                         :styles => [],
-                         :color => nil,
-                         :link => nil,
-                         :anchor => "ToC",
-                         :local => nil,
-                         :font => nil,
-                         :size => nil,
-                         :character_spacing => nil }
+    expect(array[0]).to eq(:text => "internal link",
+                           :styles => [],
+                           :color => nil,
+                           :link => nil,
+                           :anchor => "ToC",
+                           :local => nil,
+                           :font => nil,
+                           :size => nil,
+                           :character_spacing => nil)
   end
   it "should handle higher order characters properly" do
     string = "<b>©\n©</b>"
     array = Prawn::Text::Formatted::Parser.format(string)
-    array[0].should == { :text => "©",
-                         :styles => [:bold],
-                         :color => nil,
-                         :link => nil,
-                         :anchor => nil,
-                         :local => nil,
-                         :font => nil,
-                         :size => nil,
-                         :character_spacing => nil }
-    array[1].should == { :text => "\n",
-                         :styles => [:bold],
-                         :color => nil,
-                         :link => nil,
-                         :anchor => nil,
-                         :local => nil,
-                         :font => nil,
-                         :size => nil,
-                         :character_spacing => nil }
-    array[2].should == { :text => "©",
-                         :styles => [:bold],
-                         :color => nil,
-                         :link => nil,
-                         :anchor => nil,
-                         :local => nil,
-                         :font => nil,
-                         :size => nil,
-                         :character_spacing => nil }
+    expect(array[0]).to eq(:text => "©",
+                           :styles => [:bold],
+                           :color => nil,
+                           :link => nil,
+                           :anchor => nil,
+                           :local => nil,
+                           :font => nil,
+                           :size => nil,
+                           :character_spacing => nil)
+    expect(array[1]).to eq(:text => "\n",
+                           :styles => [:bold],
+                           :color => nil,
+                           :link => nil,
+                           :anchor => nil,
+                           :local => nil,
+                           :font => nil,
+                           :size => nil,
+                           :character_spacing => nil)
+    expect(array[2]).to eq(:text => "©",
+                           :styles => [:bold],
+                           :color => nil,
+                           :link => nil,
+                           :anchor => nil,
+                           :local => nil,
+                           :font => nil,
+                           :size => nil,
+                           :character_spacing => nil)
   end
   it "should convert &lt; &gt;, and &amp; to <, >, and &, respectively" do
     string = "hello <b>&lt;, &gt;, and &amp;</b>"
     array = Prawn::Text::Formatted::Parser.format(string)
-    array[1].should == { :text => "<, >, and &",
-                         :styles => [:bold],
-                         :color => nil,
-                         :link => nil,
-                         :anchor => nil,
-                         :local => nil,
-                         :font => nil,
-                         :size => nil,
-                         :character_spacing => nil }
+    expect(array[1]).to eq(:text => "<, >, and &",
+                           :styles => [:bold],
+                           :color => nil,
+                           :link => nil,
+                           :anchor => nil,
+                           :local => nil,
+                           :font => nil,
+                           :size => nil,
+                           :character_spacing => nil)
   end
   it "should handle double qoutes around tag attributes" do
     string = 'some <font size="14">sized</font> text'
     array = Prawn::Text::Formatted::Parser.format(string)
-    array[1].should == { :text => "sized",
-                         :styles => [],
-                         :color => nil,
-                         :link => nil,
-                         :anchor => nil,
-                         :local => nil,
-                         :font => nil,
-                         :size => 14,
-                         :character_spacing => nil }
+    expect(array[1]).to eq(:text => "sized",
+                           :styles => [],
+                           :color => nil,
+                           :link => nil,
+                           :anchor => nil,
+                           :local => nil,
+                           :font => nil,
+                           :size => 14,
+                           :character_spacing => nil)
   end
   it "should handle single qoutes around tag attributes" do
     string = "some <font size='14'>sized</font> text"
     array = Prawn::Text::Formatted::Parser.format(string)
-    array[1].should == { :text => "sized",
-                         :styles => [],
-                         :color => nil,
-                         :link => nil,
-                         :anchor => nil,
-                         :local => nil,
-                         :font => nil,
-                         :size => 14,
-                         :character_spacing => nil }
+    expect(array[1]).to eq(:text => "sized",
+                           :styles => [],
+                           :color => nil,
+                           :link => nil,
+                           :anchor => nil,
+                           :local => nil,
+                           :font => nil,
+                           :size => 14,
+                           :character_spacing => nil)
   end
   it "should construct a formatted text array from a string" do
     string = "hello <b>world\nhow <i>are</i></b> you?"
     array = Prawn::Text::Formatted::Parser.format(string)
 
-    array[0].should == { :text => "hello ",
-                         :styles => [],
-                         :color => nil,
-                         :link => nil,
-                         :anchor => nil,
-                         :local => nil,
-                         :font => nil,
-                         :size => nil,
-                         :character_spacing => nil }
-    array[1].should == { :text => "world",
-                         :styles => [:bold],
-                         :color => nil,
-                         :link => nil,
-                         :anchor => nil,
-                         :local => nil,
-                         :font => nil,
-                         :size => nil,
-                         :character_spacing => nil }
-    array[2].should == { :text => "\n",
-                         :styles => [:bold],
-                         :color => nil,
-                         :link => nil,
-                         :anchor => nil,
-                         :local => nil,
-                         :font => nil,
-                         :size => nil,
-                         :character_spacing => nil }
-    array[3].should == { :text => "how ",
-                         :styles => [:bold],
-                         :color => nil,
-                         :link => nil,
-                         :anchor => nil,
-                         :local => nil,
-                         :font => nil,
-                         :size => nil,
-                         :character_spacing => nil }
-    array[4].should == { :text => "are",
-                         :styles => [:bold, :italic],
-                         :color => nil,
-                         :link => nil,
-                         :anchor => nil,
-                         :local => nil,
-                         :font => nil,
-                         :size => nil,
-                         :character_spacing => nil }
-    array[5].should == { :text => " you?",
-                         :styles => [],
-                         :color => nil,
-                         :link => nil,
-                         :anchor => nil,
-                         :local => nil,
-                         :font => nil,
-                         :size => nil,
-                         :character_spacing => nil }
+    expect(array[0]).to eq(:text => "hello ",
+                           :styles => [],
+                           :color => nil,
+                           :link => nil,
+                           :anchor => nil,
+                           :local => nil,
+                           :font => nil,
+                           :size => nil,
+                           :character_spacing => nil)
+    expect(array[1]).to eq(:text => "world",
+                           :styles => [:bold],
+                           :color => nil,
+                           :link => nil,
+                           :anchor => nil,
+                           :local => nil,
+                           :font => nil,
+                           :size => nil,
+                           :character_spacing => nil)
+    expect(array[2]).to eq(:text => "\n",
+                           :styles => [:bold],
+                           :color => nil,
+                           :link => nil,
+                           :anchor => nil,
+                           :local => nil,
+                           :font => nil,
+                           :size => nil,
+                           :character_spacing => nil)
+    expect(array[3]).to eq(:text => "how ",
+                           :styles => [:bold],
+                           :color => nil,
+                           :link => nil,
+                           :anchor => nil,
+                           :local => nil,
+                           :font => nil,
+                           :size => nil,
+                           :character_spacing => nil)
+    expect(array[4]).to eq(:text => "are",
+                           :styles => [:bold, :italic],
+                           :color => nil,
+                           :link => nil,
+                           :anchor => nil,
+                           :local => nil,
+                           :font => nil,
+                           :size => nil,
+                           :character_spacing => nil)
+    expect(array[5]).to eq(:text => " you?",
+                           :styles => [],
+                           :color => nil,
+                           :link => nil,
+                           :anchor => nil,
+                           :local => nil,
+                           :font => nil,
+                           :size => nil,
+                           :character_spacing => nil)
   end
   it "should accept <strong> as an alternative to <b>" do
     string = "<strong>bold</strong> not bold"
     array = Prawn::Text::Formatted::Parser.format(string)
 
-    array[0].should == { :text => "bold",
-                         :styles => [:bold],
-                         :color => nil,
-                         :link => nil,
-                         :anchor => nil,
-                         :local => nil,
-                         :font => nil,
-                         :size => nil,
-                         :character_spacing => nil }
-    array[1].should == { :text => " not bold",
-                         :styles => [],
-                         :color => nil,
-                         :link => nil,
-                         :anchor => nil,
-                         :local => nil,
-                         :font => nil,
-                         :size => nil,
-                         :character_spacing => nil }
+    expect(array[0]).to eq(:text => "bold",
+                           :styles => [:bold],
+                           :color => nil,
+                           :link => nil,
+                           :anchor => nil,
+                           :local => nil,
+                           :font => nil,
+                           :size => nil,
+                           :character_spacing => nil)
+    expect(array[1]).to eq(:text => " not bold",
+                           :styles => [],
+                           :color => nil,
+                           :link => nil,
+                           :anchor => nil,
+                           :local => nil,
+                           :font => nil,
+                           :size => nil,
+                           :character_spacing => nil)
   end
   it "should accept <em> as an alternative to <i>" do
     string = "<em>italic</em> not italic"
     array = Prawn::Text::Formatted::Parser.format(string)
 
-    array[0].should == { :text => "italic",
-                         :styles => [:italic],
-                         :color => nil,
-                         :link => nil,
-                         :anchor => nil,
-                         :local => nil,
-                         :font => nil,
-                         :size => nil,
-                         :character_spacing => nil }
-    array[1].should == { :text => " not italic",
-                         :styles => [],
-                         :color => nil,
-                         :link => nil,
-                         :anchor => nil,
-                         :local => nil,
-                         :font => nil,
-                         :size => nil,
-                         :character_spacing => nil }
+    expect(array[0]).to eq(:text => "italic",
+                           :styles => [:italic],
+                           :color => nil,
+                           :link => nil,
+                           :anchor => nil,
+                           :local => nil,
+                           :font => nil,
+                           :size => nil,
+                           :character_spacing => nil)
+    expect(array[1]).to eq(:text => " not italic",
+                           :styles => [],
+                           :color => nil,
+                           :link => nil,
+                           :anchor => nil,
+                           :local => nil,
+                           :font => nil,
+                           :size => nil,
+                           :character_spacing => nil)
   end
   it "should accept <a> as an alternative to <link>" do
     string = "<a href='http://example.com'>link</a> not a link"
     array = Prawn::Text::Formatted::Parser.format(string)
 
-    array[0].should == { :text => "link",
-                         :styles => [],
-                         :color => nil,
-                         :link => "http://example.com",
-                         :anchor => nil,
-                         :local => nil,
-                         :font => nil,
-                         :size => nil,
-                         :character_spacing => nil }
-    array[1].should == { :text => " not a link",
-                         :styles => [],
-                         :color => nil,
-                         :link => nil,
-                         :anchor => nil,
-                         :local => nil,
-                         :font => nil,
-                         :size => nil,
-                         :character_spacing => nil }
+    expect(array[0]).to eq(:text => "link",
+                           :styles => [],
+                           :color => nil,
+                           :link => "http://example.com",
+                           :anchor => nil,
+                           :local => nil,
+                           :font => nil,
+                           :size => nil,
+                           :character_spacing => nil)
+    expect(array[1]).to eq(:text => " not a link",
+                           :styles => [],
+                           :color => nil,
+                           :link => nil,
+                           :anchor => nil,
+                           :local => nil,
+                           :font => nil,
+                           :size => nil,
+                           :character_spacing => nil)
   end
 
   it "should turn <br>, <br/> into newline" do
     array = Prawn::Text::Formatted::Parser.format("hello<br>big<br/>world")
-    array.map { |frag| frag[:text] }.join.should == "hello\nbig\nworld"
+    expect(array.map { |frag| frag[:text] }.join).to eq("hello\nbig\nworld")
   end
 end
 
-
 describe "Text::Formatted::Parser#to_string" do
   it "should handle sup" do
     string = "<sup>superscript</sup>"
     array = [{ :text => "superscript",
-                         :styles => [:superscript],
-                         :color => nil,
-                         :link => nil,
-                         :anchor => nil,
-                         :local => nil,
-                         :font => nil,
-                         :size => nil,
-                         :character_spacing => nil }]
-    Prawn::Text::Formatted::Parser.to_string(array).should == string
+               :styles => [:superscript],
+               :color => nil,
+               :link => nil,
+               :anchor => nil,
+               :local => nil,
+               :font => nil,
+               :size => nil,
+               :character_spacing => nil }]
+    expect(Prawn::Text::Formatted::Parser.to_string(array)).to eq(string)
   end
   it "should handle sub" do
     string = "<sub>subscript</sub>"
     array = [{ :text => "subscript",
-                         :styles => [:subscript],
-                         :color => nil,
-                         :link => nil,
-                         :anchor => nil,
-                         :local => nil,
-                         :font => nil,
-                         :size => nil,
-                         :character_spacing => nil }]
-    Prawn::Text::Formatted::Parser.to_string(array).should == string
+               :styles => [:subscript],
+               :color => nil,
+               :link => nil,
+               :anchor => nil,
+               :local => nil,
+               :font => nil,
+               :size => nil,
+               :character_spacing => nil }]
+    expect(Prawn::Text::Formatted::Parser.to_string(array)).to eq(string)
   end
   it "should handle rgb" do
     string = "<color rgb='ff0000'>red text</color>"
     array = [{ :text => "red text",
-                         :styles => [],
-                         :color => "ff0000",
-                         :link => nil,
-                         :anchor => nil,
-                         :local => nil,
-                         :font => nil,
-                         :size => nil,
-                         :character_spacing => nil }]
-    Prawn::Text::Formatted::Parser.to_string(array).should == string
+               :styles => [],
+               :color => "ff0000",
+               :link => nil,
+               :anchor => nil,
+               :local => nil,
+               :font => nil,
+               :size => nil,
+               :character_spacing => nil }]
+    expect(Prawn::Text::Formatted::Parser.to_string(array)).to eq(string)
   end
   it "should handle cmyk" do
     string = "<color c='0' m='100' y='0' k='0'>magenta text</color>"
     array = [{ :text => "magenta text",
-                         :styles => [],
-                         :color => [0, 100, 0, 0],
-                         :link => nil,
-                         :anchor => nil,
-                         :local => nil,
-                         :font => nil,
-                         :size => nil,
-                         :character_spacing => nil }]
-    Prawn::Text::Formatted::Parser.to_string(array).should == string
+               :styles => [],
+               :color => [0, 100, 0, 0],
+               :link => nil,
+               :anchor => nil,
+               :local => nil,
+               :font => nil,
+               :size => nil,
+               :character_spacing => nil }]
+    expect(Prawn::Text::Formatted::Parser.to_string(array)).to eq(string)
   end
   it "should handle fonts" do
     string = "<font name='Courier'>Courier text</font>"
     array = [{ :text => "Courier text",
-                         :styles => [],
-                         :color => nil,
-                         :link => nil,
-                         :anchor => nil,
-                         :local => nil,
-                         :font => "Courier",
-                         :size => nil,
-                         :character_spacing => nil }]
-    Prawn::Text::Formatted::Parser.to_string(array).should == string
+               :styles => [],
+               :color => nil,
+               :link => nil,
+               :anchor => nil,
+               :local => nil,
+               :font => "Courier",
+               :size => nil,
+               :character_spacing => nil }]
+    expect(Prawn::Text::Formatted::Parser.to_string(array)).to eq(string)
   end
   it "should handle size" do
     string = "<font size='14'>14 point text</font>"
     array = [{ :text => "14 point text",
-                         :styles => [],
-                         :color => nil,
-                         :link => nil,
-                         :anchor => nil,
-                         :local => nil,
-                         :font => nil,
-                         :size => 14,
-                         :character_spacing => nil }]
-    Prawn::Text::Formatted::Parser.to_string(array).should == string
+               :styles => [],
+               :color => nil,
+               :link => nil,
+               :anchor => nil,
+               :local => nil,
+               :font => nil,
+               :size => 14,
+               :character_spacing => nil }]
+    expect(Prawn::Text::Formatted::Parser.to_string(array)).to eq(string)
   end
   it "should handle character spacing" do
     string = "<font character_spacing='2.5'>2.5 extra character spacing</font>"
     array = [{ :text => "2.5 extra character spacing",
-                         :styles => [],
-                         :color => nil,
-                         :link => nil,
-                         :anchor => nil,
-                         :local => nil,
-                         :font => nil,
-                         :size => nil,
-                         :character_spacing => 2.5 }]
-    Prawn::Text::Formatted::Parser.to_string(array).should == string
+               :styles => [],
+               :color => nil,
+               :link => nil,
+               :anchor => nil,
+               :local => nil,
+               :font => nil,
+               :size => nil,
+               :character_spacing => 2.5 }]
+    expect(Prawn::Text::Formatted::Parser.to_string(array)).to eq(string)
   end
   it "should handle links" do
     array = [{ :text => "external link",
@@ -454,7 +453,7 @@ describe "Text::Formatted::Parser#to_string" do
                :size => nil,
                :character_spacing => nil }]
     string = "<link href='http://example.com'>external link</link>"
-    Prawn::Text::Formatted::Parser.to_string(array).should == string
+    expect(Prawn::Text::Formatted::Parser.to_string(array)).to eq(string)
   end
   it "should handle anchors" do
     array = [{ :text => "internal link",
@@ -466,74 +465,79 @@ describe "Text::Formatted::Parser#to_string" do
                :size => nil,
                :character_spacing => nil }]
     string = "<link anchor='ToC'>internal link</link>"
-    Prawn::Text::Formatted::Parser.to_string(array).should == string
+    expect(Prawn::Text::Formatted::Parser.to_string(array)).to eq(string)
   end
   it "should convert <, >, and & to &lt; &gt;, and &amp;, respectively" do
-    array = [{ :text => "hello ",
-               :styles => [],
-               :color => nil,
-               :link => nil,
-               :font => nil,
-               :size => nil,
-               :character_spacing => nil },
-            { :text => "<, >, and &",
-               :styles => [:bold],
-               :color => nil,
-               :link => nil,
-               :font => nil,
-               :size => nil,
-               :character_spacing => nil }]
+    array = [
+      {
+        :text => "hello ",
+        :styles => [],
+        :color => nil,
+        :link => nil,
+        :font => nil,
+        :size => nil,
+        :character_spacing => nil
+      },
+      {
+        :text => "<, >, and &",
+        :styles => [:bold],
+        :color => nil,
+        :link => nil,
+        :font => nil,
+        :size => nil,
+        :character_spacing => nil
+      }
+    ]
     string = "hello <b>&lt;, &gt;, and &amp;</b>"
-    Prawn::Text::Formatted::Parser.to_string(array).should == string
+    expect(Prawn::Text::Formatted::Parser.to_string(array)).to eq(string)
   end
-  it "should construct an HTML-esque string from a formatted" +
-    " text array" do
+  it "should construct an HTML-esque string from a formatted text array" do
     array = [
-             { :text => "hello ",
-               :styles => [],
-               :color => nil,
-               :link => nil,
-               :font => nil,
-               :size => 14,
-               :character_spacing => nil },
-             { :text => "world",
-               :styles => [:bold],
-               :color => nil,
-               :link => nil,
-               :font => nil,
-               :size => nil,
-               :character_spacing => nil },
-             { :text => "\n",
-               :styles => [:bold],
-               :color => nil,
-               :link => nil,
-               :font => nil,
-               :size => nil,
-               :character_spacing => nil },
-             { :text => "how ",
-               :styles => [:bold],
-               :color => nil,
-               :link => nil,
-               :font => nil,
-               :size => nil,
-               :character_spacing => nil },
-             { :text => "are",
-               :styles => [:bold, :italic],
-               :color => nil,
-               :link => nil,
-               :font => nil,
-               :size => nil,
-               :character_spacing => nil },
-             { :text => " you?",
-               :styles => [],
-               :color => nil,
-               :link => nil,
-               :font => nil,
-               :size => nil,
-               :character_spacing => nil }
-             ]
+      { :text => "hello ",
+        :styles => [],
+        :color => nil,
+        :link => nil,
+        :font => nil,
+        :size => 14,
+        :character_spacing => nil },
+      { :text => "world",
+        :styles => [:bold],
+        :color => nil,
+        :link => nil,
+        :font => nil,
+        :size => nil,
+        :character_spacing => nil },
+      { :text => "\n",
+        :styles => [:bold],
+        :color => nil,
+        :link => nil,
+        :font => nil,
+        :size => nil,
+        :character_spacing => nil },
+      { :text => "how ",
+        :styles => [:bold],
+        :color => nil,
+        :link => nil,
+        :font => nil,
+        :size => nil,
+        :character_spacing => nil },
+      { :text => "are",
+        :styles => [:bold, :italic],
+        :color => nil,
+        :link => nil,
+        :font => nil,
+        :size => nil,
+        :character_spacing => nil },
+      { :text => " you?",
+        :styles => [],
+        :color => nil,
+        :link => nil,
+        :font => nil,
+        :size => nil,
+        :character_spacing => nil }
+    ]
     string = "<font size='14'>hello </font><b>world</b><b>\n</b><b>how </b><b><i>are</i></b> you?"
-    Prawn::Text::Formatted::Parser.to_string(array).should == string
+    expect(Prawn::Text::Formatted::Parser.to_string(array)).to eq(string)
   end
 end
 
@@ -544,14 +548,14 @@ describe "Text::Formatted::Parser#array_paragraphs" do
              { :text => "how" },
              { :text => "are" },
              { :text => "you" }]
-    target = [[{ :text => "\n"}],
+    target = [[{ :text => "\n" }],
               [{ :text => "hello" }],
               [{ :text => "world" }],
-              [{ :text => "\n"}],
+              [{ :text => "\n" }],
               [{ :text => "how" },
                { :text => "are" },
                { :text => "you" }]]
-    Prawn::Text::Formatted::Parser.array_paragraphs(array).should == target
+    expect(Prawn::Text::Formatted::Parser.array_paragraphs(array)).to eq(target)
   end
 
   it "should work properly if ending in an empty paragraph" do
@@ -559,6 +563,6 @@ describe "Text::Formatted::Parser#array_paragraphs" do
     target = [[{ :text => "\n" }],
               [{ :text => "hello" }],
               [{ :text => "world" }]]
-    Prawn::Text::Formatted::Parser.array_paragraphs(array).should == target
+    expect(Prawn::Text::Formatted::Parser.array_paragraphs(array)).to eq(target)
   end
 end