prawn 2.0.1 → 2.0.2

data/spec/png_spec.rb

@@ -10,7 +10,6 @@
 require File.join(File.expand_path(File.dirname(__FILE__)), "spec_helper")
 
 describe "When reading a greyscale PNG file (color type 0)" do
-
   before(:each) do
     @filename = "#{Prawn::DATADIR}/images/web-links.png"
     @data_filename = "#{Prawn::DATADIR}/images/web-links.dat"
@@ -20,24 +19,23 @@ describe "When reading a greyscale PNG file (color type 0)" do
   it "should read the attributes from the header chunk correctly" do
     png = Prawn::Images::PNG.new(@img_data)
 
-    png.width.should == 21
-    png.height.should == 14
-    png.bits.should == 8
-    png.color_type.should == 0
-    png.compression_method.should == 0
-    png.filter_method.should == 0
-    png.interlace_method.should == 0
+    expect(png.width).to eq(21)
+    expect(png.height).to eq(14)
+    expect(png.bits).to eq(8)
+    expect(png.color_type).to eq(0)
+    expect(png.compression_method).to eq(0)
+    expect(png.filter_method).to eq(0)
+    expect(png.interlace_method).to eq(0)
   end
 
   it "should read the image data chunk correctly" do
     png = Prawn::Images::PNG.new(@img_data)
     data = Zlib::Inflate.inflate(File.binread(@data_filename))
-    png.img_data.should == data
+    expect(png.img_data).to eq(data)
   end
 end
 
 describe "When reading a greyscale PNG file with transparency (color type 0)" do
-
   before(:each) do
     @filename = "#{Prawn::DATADIR}/images/ruport_type0.png"
     @img_data = File.binread(@filename)
@@ -49,12 +47,11 @@ describe "When reading a greyscale PNG file with transparency (color type 0)" do
   # http://www.w3.org/TR/PNG/#11tRNS
   it "should read the tRNS chunk correctly" do
     png = Prawn::Images::PNG.new(@img_data)
-    png.transparency[:grayscale].should == 255
+    expect(png.transparency[:grayscale]).to eq(255)
   end
 end
 
 describe "When reading an RGB PNG file (color type 2)" do
-
   before(:each) do
     @filename = "#{Prawn::DATADIR}/images/ruport.png"
     @data_filename = "#{Prawn::DATADIR}/images/ruport_data.dat"
@@ -64,24 +61,23 @@ describe "When reading an RGB PNG file (color type 2)" do
   it "should read the attributes from the header chunk correctly" do
     png = Prawn::Images::PNG.new(@img_data)
 
-    png.width.should == 258
-    png.height.should == 105
-    png.bits.should == 8
-    png.color_type.should == 2
-    png.compression_method.should == 0
-    png.filter_method.should == 0
-    png.interlace_method.should == 0
+    expect(png.width).to eq(258)
+    expect(png.height).to eq(105)
+    expect(png.bits).to eq(8)
+    expect(png.color_type).to eq(2)
+    expect(png.compression_method).to eq(0)
+    expect(png.filter_method).to eq(0)
+    expect(png.interlace_method).to eq(0)
   end
 
   it "should read the image data chunk correctly" do
     png = Prawn::Images::PNG.new(@img_data)
     data = Zlib::Inflate.inflate(File.binread(@data_filename))
-    png.img_data.should == data
+    expect(png.img_data).to eq(data)
   end
 end
 
 describe "When reading an RGB PNG file with transparency (color type 2)" do
-
   before(:each) do
     @filename = "#{Prawn::DATADIR}/images/arrow2.png"
     @img_data = File.binread(@filename)
@@ -94,22 +90,19 @@ describe "When reading an RGB PNG file with transparency (color type 2)" do
   # http://www.w3.org/TR/PNG/#11tRNS
   it "should read the tRNS chunk correctly" do
     png = Prawn::Images::PNG.new(@img_data)
-    png.transparency[:rgb].should == [0, 255, 0]
+    expect(png.transparency[:rgb]).to eq([0, 255, 0])
   end
 end
 
-describe "When reading an indexed color PNG file "+
-         "wiih transparency (color type 3)" do
-
+describe "When reading an indexed color PNG file with transparency (color type 3)" do
   it "raises a not supported error" do
     bin = File.binread("#{Prawn::DATADIR}/images/pal_bk.png")
-    expect { Prawn::Images::PNG.new(bin)}.to(
+    expect { Prawn::Images::PNG.new(bin) }.to(
       raise_error(Prawn::Errors::UnsupportedImageType))
   end
 end
 
 describe "When reading an indexed color PNG file (color type 3)" do
-
   before(:each) do
     @filename = "#{Prawn::DATADIR}/images/indexed_color.png"
     @data_filename = "#{Prawn::DATADIR}/images/indexed_color.dat"
@@ -119,24 +112,23 @@ describe "When reading an indexed color PNG file (color type 3)" do
   it "should read the attributes from the header chunk correctly" do
     png = Prawn::Images::PNG.new(@img_data)
 
-    png.width.should == 150
-    png.height.should == 200
-    png.bits.should == 8
-    png.color_type.should == 3
-    png.compression_method.should == 0
-    png.filter_method.should == 0
-    png.interlace_method.should == 0
+    expect(png.width).to eq(150)
+    expect(png.height).to eq(200)
+    expect(png.bits).to eq(8)
+    expect(png.color_type).to eq(3)
+    expect(png.compression_method).to eq(0)
+    expect(png.filter_method).to eq(0)
+    expect(png.interlace_method).to eq(0)
   end
 
   it "should read the image data chunk correctly" do
     png = Prawn::Images::PNG.new(@img_data)
     data = Zlib::Inflate.inflate(File.binread(@data_filename))
-    png.img_data.should == data
+    expect(png.img_data).to eq(data)
   end
 end
 
 describe "When reading a greyscale+alpha PNG file (color type 4)" do
-
   before(:each) do
     @filename = "#{Prawn::DATADIR}/images/page_white_text.png"
     @color_data_filename = "#{Prawn::DATADIR}/images/page_white_text.color"
@@ -147,32 +139,31 @@ describe "When reading a greyscale+alpha PNG file (color type 4)" do
   it "should read the attributes from the header chunk correctly" do
     png = Prawn::Images::PNG.new(@img_data)
 
-    png.width.should == 16
-    png.height.should == 16
-    png.bits.should == 8
-    png.color_type.should == 4
-    png.compression_method.should == 0
-    png.filter_method.should == 0
-    png.interlace_method.should == 0
+    expect(png.width).to eq(16)
+    expect(png.height).to eq(16)
+    expect(png.bits).to eq(8)
+    expect(png.color_type).to eq(4)
+    expect(png.compression_method).to eq(0)
+    expect(png.filter_method).to eq(0)
+    expect(png.interlace_method).to eq(0)
   end
 
   it "should correctly return the raw image data (with no alpha channel) from the image data chunk" do
     png = Prawn::Images::PNG.new(@img_data)
     png.split_alpha_channel!
     data = File.binread(@color_data_filename)
-    png.img_data.should == data
+    expect(png.img_data).to eq(data)
   end
 
   it "should correctly extract the alpha channel data from the image data chunk" do
     png = Prawn::Images::PNG.new(@img_data)
     png.split_alpha_channel!
     data = File.binread(@alpha_data_filename)
-    png.alpha_channel.should == data
+    expect(png.alpha_channel).to eq(data)
   end
 end
 
 describe "When reading an RGB+alpha PNG file (color type 6)" do
-
   before(:each) do
     @filename = "#{Prawn::DATADIR}/images/dice.png"
     @color_data_filename = "#{Prawn::DATADIR}/images/dice.color"
@@ -183,32 +174,31 @@ describe "When reading an RGB+alpha PNG file (color type 6)" do
   it "should read the attributes from the header chunk correctly" do
     png = Prawn::Images::PNG.new(@img_data)
 
-    png.width.should == 320
-    png.height.should == 240
-    png.bits.should == 8
-    png.color_type.should == 6
-    png.compression_method.should == 0
-    png.filter_method.should == 0
-    png.interlace_method.should == 0
+    expect(png.width).to eq(320)
+    expect(png.height).to eq(240)
+    expect(png.bits).to eq(8)
+    expect(png.color_type).to eq(6)
+    expect(png.compression_method).to eq(0)
+    expect(png.filter_method).to eq(0)
+    expect(png.interlace_method).to eq(0)
   end
 
   it "should correctly return the raw image data (with no alpha channel) from the image data chunk" do
     png = Prawn::Images::PNG.new(@img_data)
     png.split_alpha_channel!
     data = File.binread(@color_data_filename)
-    png.img_data.should == data
+    expect(png.img_data).to eq(data)
   end
 
   it "should correctly extract the alpha channel data from the image data chunk" do
     png = Prawn::Images::PNG.new(@img_data)
     png.split_alpha_channel!
     data = File.binread(@alpha_data_filename)
-    png.alpha_channel.should == data
+    expect(png.alpha_channel).to eq(data)
   end
 end
 
 describe "When reading a 16bit RGB+alpha PNG file (color type 6)" do
-
   before(:each) do
     @filename = "#{Prawn::DATADIR}/images/16bit.png"
     @color_data_filename = "#{Prawn::DATADIR}/images/16bit.color"
@@ -220,26 +210,26 @@ describe "When reading a 16bit RGB+alpha PNG file (color type 6)" do
   it "should read the attributes from the header chunk correctly" do
     png = Prawn::Images::PNG.new(@img_data)
 
-    png.width.should == 32
-    png.height.should == 32
-    png.bits.should == 16
-    png.color_type.should == 6
-    png.compression_method.should == 0
-    png.filter_method.should == 0
-    png.interlace_method.should == 0
+    expect(png.width).to eq(32)
+    expect(png.height).to eq(32)
+    expect(png.bits).to eq(16)
+    expect(png.color_type).to eq(6)
+    expect(png.compression_method).to eq(0)
+    expect(png.filter_method).to eq(0)
+    expect(png.interlace_method).to eq(0)
   end
 
   it "should correctly return the raw image data (with no alpha channel) from the image data chunk" do
     png = Prawn::Images::PNG.new(@img_data)
     png.split_alpha_channel!
     data = File.binread(@color_data_filename)
-    png.img_data.should == data
+    expect(png.img_data).to eq(data)
   end
 
   it "should correctly extract the alpha channel data from the image data chunk" do
     png = Prawn::Images::PNG.new(@img_data)
     png.split_alpha_channel!
     data = File.binread(@alpha_data_filename)
-    png.alpha_channel.should == data
+    expect(png.alpha_channel).to eq(data)
   end
 end

data/spec/reference_spec.rb

@@ -6,20 +6,20 @@ describe "A Reference object" do
   describe "generated via Prawn::Document" do
     it "should return a proper reference on ref!" do
       pdf = Prawn::Document.new
-      pdf.ref!({}).is_a?(PDF::Core::Reference).should == true
+      expect(pdf.ref!({}).is_a?(PDF::Core::Reference)).to eq(true)
     end
 
     it "should return an identifier on ref" do
       pdf = Prawn::Document.new
       r = pdf.ref({})
-      r.is_a?(Integer).should == true
+      expect(r.is_a?(Integer)).to eq(true)
     end
 
     it "should have :Length of stream if it has one when compression disabled" do
       pdf = Prawn::Document.new :compress => false
       ref = pdf.ref!({})
       ref << 'Hello'
-      ref.stream.data[:Length].should == 5
+      expect(ref.stream.data[:Length]).to eq(5)
     end
   end
 end

data/spec/repeater_spec.rb

@@ -3,7 +3,6 @@
 require File.join(File.expand_path(File.dirname(__FILE__)), "spec_helper")
 
 describe "Repeaters" do
-
   it "creates a stamp and increments Prawn::Repeater.count on initialize" do
     orig_count = Prawn::Repeater.count
 
@@ -12,45 +11,45 @@ describe "Repeaters" do
 
     r = repeater(doc, :all) { :do_nothing }
 
-    Prawn::Repeater.count.should == orig_count + 1
+    expect(Prawn::Repeater.count).to eq(orig_count + 1)
   end
 
   it "must provide an :all filter" do
     doc = sample_document
     r = repeater(doc, :all) { :do_nothing }
 
-    (1..doc.page_count).all? { |i| r.match?(i) }.should be_true
+    expect((1..doc.page_count).all? { |i| r.match?(i) }).to be_true
   end
 
   it "must provide an :odd filter" do
     doc = sample_document
     r = repeater(doc, :odd) { :do_nothing }
 
-    odd, even = (1..doc.page_count).partition { |e| e % 2 == 1 }
+    odd, even = (1..doc.page_count).partition(&:odd?)
 
-    odd.all? { |i| r.match?(i) }.should be_true
-    even.any? { |i| r.match?(i) }.should be_false
+    expect(odd.all? { |i| r.match?(i) }).to be_true
+    expect(even.any? { |i| r.match?(i) }).to be_false
   end
 
   it "must be able to filter by an array of page numbers" do
     doc = sample_document
-    r = repeater(doc, [1,2,7]) { :do_nothing }
+    r = repeater(doc, [1, 2, 7]) { :do_nothing }
 
-    (1..10).select { |i| r.match?(i) }.should == [1,2,7]
+    expect((1..10).select { |i| r.match?(i) }).to eq([1, 2, 7])
   end
 
   it "must be able to filter by a range of page numbers" do
     doc = sample_document
     r = repeater(doc, 2..4) { :do_nothing }
 
-    (1..10).select { |i| r.match?(i) }.should == [2,3,4]
+    expect((1..10).select { |i| r.match?(i) }).to eq([2, 3, 4])
   end
 
   it "must be able to filter by an arbitrary proc" do
     doc = sample_document
     r = repeater(doc, lambda { |x| x == 1 or x % 3 == 0 })
 
-    (1..10).select { |i| r.match?(i) }.should == [1,3,6,9]
+    expect((1..10).select { |i| r.match?(i) }).to eq([1, 3, 6, 9])
   end
 
   it "must try to run a stamp if the page number matches" do
@@ -71,21 +70,21 @@ describe "Repeaters" do
     doc = sample_document
 
     doc.expects(:stamp).never
-    (1..10).each { |p| repeater(doc, :all, true){:do_nothing}.run(p) }
+    (1..10).each { |p| repeater(doc, :all, true){ :do_nothing }.run(p) }
   end
 
   it "must try to run a block if the page number matches" do
     doc = sample_document
 
     doc.expects(:draw_text).twice
-    (1..10).each { |p| repeater(doc, [1,2], true){doc.draw_text "foo"}.run(p) }
+    (1..10).each { |p| repeater(doc, [1, 2], true){ doc.draw_text "foo" }.run(p) }
   end
 
   it "must not try to run a block unless the page number matches" do
     doc = sample_document
 
     doc.expects(:draw_text).never
-    repeater(doc, :odd, true){doc.draw_text "foo"}.run(2)
+    repeater(doc, :odd, true){ doc.draw_text "foo" }.run(2)
   end
 
   it "must treat any block as a closure" do
@@ -97,7 +96,7 @@ describe "Repeaters" do
     end
 
     text = PDF::Inspector::Text.analyze(doc.render)
-    text.strings.should == (1..10).to_a.map{|p| "Page #{p}"}
+    expect(text.strings).to eq((1..10).to_a.map{ |p| "Page #{p}" })
   end
 
   it "must treat any block as a closure (Document.new instance_eval form)" do
@@ -112,7 +111,7 @@ describe "Repeaters" do
     end
 
     text = PDF::Inspector::Text.analyze(doc.render)
-    text.strings.should == (1..10).to_a.map{|p| "Page #{p}"}
+    expect(text.strings).to eq((1..10).to_a.map{ |p| "Page #{p}" })
   end
 
   def sample_document
@@ -122,22 +121,20 @@ describe "Repeaters" do
   end
 
   def repeater(*args, &b)
-    Prawn::Repeater.new(*args,&b)
+    Prawn::Repeater.new(*args, &b)
   end
 
   context "graphic state" do
-
     it "should not alter the graphic state stack color space" do
       create_pdf
       starting_color_space = @pdf.state.page.graphic_state.color_space.dup
       @pdf.repeat :all do
         @pdf.text "Testing", :size => 24, :style => :bold
       end
-      @pdf.state.page.graphic_state.color_space.should == starting_color_space
+      expect(@pdf.state.page.graphic_state.color_space).to eq(starting_color_space)
     end
 
     context "dynamic repeaters" do
-
       it "should preserve the graphic state at creation time" do
         create_pdf
         @pdf.repeat :all, :dynamic => true do
@@ -147,14 +144,11 @@ describe "Repeaters" do
         @pdf.fill_color "666666"
         @pdf.cap_style :round
         text = PDF::Inspector::Text.analyze(@pdf.render)
-        text.strings.include?("fill_color: 666666").should == false
-        text.strings.include?("fill_color: 000000").should == true
-        text.strings.include?("cap_style: round").should == false
-        text.strings.include?("cap_style: butt").should == true
+        expect(text.strings.include?("fill_color: 666666")).to eq(false)
+        expect(text.strings.include?("fill_color: 000000")).to eq(true)
+        expect(text.strings.include?("cap_style: round")).to eq(false)
+        expect(text.strings.include?("cap_style: butt")).to eq(true)
       end
-
     end
-
   end
-
 end

data/spec/security_spec.rb

@@ -4,36 +4,32 @@ require "tempfile"
 require File.join(File.expand_path(File.dirname(__FILE__)), "spec_helper")
 
 describe "Document encryption" do
-
   describe "Password padding" do
-
     include Prawn::Document::Security
 
     it "should truncate long passwords" do
       pw = "Long long string" * 30
       padded = pad_password(pw)
-      padded.length.should == 32
-      padded.should == pw[0, 32]
+      expect(padded.length).to eq(32)
+      expect(padded).to eq(pw[0, 32])
     end
 
     it "should pad short passwords" do
       pw = "abcd"
       padded = pad_password(pw)
-      padded.length.should == 32
-      padded.should == pw + Prawn::Document::Security::PasswordPadding[0, 28]
+      expect(padded.length).to eq(32)
+      expect(padded).to eq(pw + Prawn::Document::Security::PasswordPadding[0, 28])
     end
 
     it "should fully pad null passwords" do
       pw = ""
       padded = pad_password(pw)
-      padded.length.should == 32
-      padded.should == Prawn::Document::Security::PasswordPadding
+      expect(padded.length).to eq(32)
+      expect(padded).to eq(Prawn::Document::Security::PasswordPadding)
     end
-
   end
 
   describe "Setting permissions" do
-
     def doc_with_permissions(permissions)
       pdf = Prawn::Document.new
 
@@ -47,31 +43,30 @@ describe "Document encryption" do
     end
 
     it "should default to full permissions" do
-      doc_with_permissions({}).permissions_value.should == 0xFFFFFFFF
-      doc_with_permissions(:print_document     => true,
-                           :modify_contents    => true,
-                           :copy_contents      => true,
-                           :modify_annotations => true).permissions_value.
-        should == 0xFFFFFFFF
+      expect(doc_with_permissions({}).permissions_value).to eq(0xFFFFFFFF)
+      expect(doc_with_permissions(:print_document     => true,
+                                  :modify_contents    => true,
+                                  :copy_contents      => true,
+                                  :modify_annotations => true).permissions_value).
+        to eq(0xFFFFFFFF)
     end
 
     it "should clear the appropriate bits for each permission flag" do
-      doc_with_permissions(:print_document => false).permissions_value.
-        should == 0b1111_1111_1111_1111_1111_1111_1111_1011
-      doc_with_permissions(:modify_contents => false).permissions_value.
-        should == 0b1111_1111_1111_1111_1111_1111_1111_0111
-      doc_with_permissions(:copy_contents => false).permissions_value.
-        should == 0b1111_1111_1111_1111_1111_1111_1110_1111
-      doc_with_permissions(:modify_annotations => false).permissions_value.
-        should == 0b1111_1111_1111_1111_1111_1111_1101_1111
+      expect(doc_with_permissions(:print_document => false).permissions_value).
+        to eq(0b1111_1111_1111_1111_1111_1111_1111_1011)
+      expect(doc_with_permissions(:modify_contents => false).permissions_value).
+        to eq(0b1111_1111_1111_1111_1111_1111_1111_0111)
+      expect(doc_with_permissions(:copy_contents => false).permissions_value).
+        to eq(0b1111_1111_1111_1111_1111_1111_1110_1111)
+      expect(doc_with_permissions(:modify_annotations => false).permissions_value).
+        to eq(0b1111_1111_1111_1111_1111_1111_1101_1111)
     end
 
     it "should raise_error ArgumentError if invalid option is provided" do
-      lambda {
+      expect {
         doc_with_permissions(:modify_document => false)
-      }.should raise_error(ArgumentError)
+      }.to raise_error(ArgumentError)
     end
-
   end
 
   describe "Encryption keys" do
@@ -84,65 +79,64 @@ describe "Document encryption" do
       class << @pdf
         public :owner_password_hash, :user_password_hash, :user_encryption_key
       end
-      @pdf.encrypt_document :user_password => 'foo', :owner_password => 'bar',
-        :permissions => { :print_document => false }
+      @pdf.encrypt_document :user_password => 'foo',
+                            :owner_password => 'bar',
+                            :permissions => { :print_document => false }
     end
 
     it "should calculate the correct owner hash" do
-      @pdf.owner_password_hash.unpack("H*").first.should match(/^61CA855012/i)
+      expect(@pdf.owner_password_hash.unpack("H*").first).to match(/^61CA855012/i)
     end
 
     it "should calculate the correct user hash" do
-      @pdf.user_password_hash.unpack("H*").first.should =~ /^6BC8C51031/i
+      expect(@pdf.user_password_hash.unpack("H*").first).to match(/^6BC8C51031/i)
     end
 
     it "should calculate the correct user_encryption_key" do
-      @pdf.user_encryption_key.unpack("H*").first.upcase.should == "B100AB6429"
+      expect(@pdf.user_encryption_key.unpack("H*").first.upcase).to eq("B100AB6429")
     end
-
-
   end
 
   describe "EncryptedPdfObject" do
-
     it "should delegate to PdfObject for simple types" do
-      PDF::Core::EncryptedPdfObject(true, nil, nil, nil).should == "true"
-      PDF::Core::EncryptedPdfObject(42, nil, nil, nil).should == "42"
+      expect(PDF::Core::EncryptedPdfObject(true, nil, nil, nil)).to eq("true")
+      expect(PDF::Core::EncryptedPdfObject(42, nil, nil, nil)).to eq("42")
     end
 
     it "should encrypt strings properly" do
-      PDF::Core::EncryptedPdfObject("foo", "12345", 123, 0).should == "<4ad6e3>"
+      expect(PDF::Core::EncryptedPdfObject("foo", "12345", 123, 0)).to eq("<4ad6e3>")
     end
 
     it "should encrypt literal strings properly" do
-       PDF::Core::EncryptedPdfObject(PDF::Core::LiteralString.new("foo"), "12345", 123, 0).should == bin_string("(J\xD6\xE3)")
-       PDF::Core::EncryptedPdfObject(PDF::Core::LiteralString.new("lhfbqg3do5u0satu3fjf"), nil, 123, 0).should == bin_string("(\xF1\x8B\\(\b\xBB\xE18S\x130~4*#\\(%\x87\xE7\x8E\\\n)")
+      expect(PDF::Core::EncryptedPdfObject(PDF::Core::LiteralString.new("foo"), "12345", 123, 0)).to eq(bin_string("(J\xD6\xE3)"))
+      expect(PDF::Core::EncryptedPdfObject(PDF::Core::LiteralString.new("lhfbqg3do5u0satu3fjf"), nil, 123, 0)).to eq(bin_string("(\xF1\x8B\\(\b\xBB\xE18S\x130~4*#\\(%\x87\xE7\x8E\\\n)"))
     end
 
     it "should encrypt time properly" do
-       PDF::Core::EncryptedPdfObject(Time.utc(2050, 04, 26, 10, 17, 10), "12345", 123, 0).should == bin_string("(h\x83\xBE\xDC\xEC\x99\x0F\xD7\\)%\x13\xD4$\xB8\xF0\x16\xB8\x80\xC5\xE91+\xCF)")
+      expect(PDF::Core::EncryptedPdfObject(Time.utc(2050, 04, 26, 10, 17, 10), "12345", 123, 0)).to eq(bin_string("(h\x83\xBE\xDC\xEC\x99\x0F\xD7\\)%\x13\xD4$\xB8\xF0\x16\xB8\x80\xC5\xE91+\xCF)"))
     end
 
     it "should properly handle compound types" do
-      PDF::Core::EncryptedPdfObject({:Bar => "foo"}, "12345", 123, 0).should ==
+      expect(PDF::Core::EncryptedPdfObject({ :Bar => "foo" }, "12345", 123, 0)).to eq(
         "<< /Bar <4ad6e3>\n>>"
-      PDF::Core::EncryptedPdfObject(["foo", "bar"], "12345", 123, 0).should ==
+      )
+      expect(PDF::Core::EncryptedPdfObject(["foo", "bar"], "12345", 123, 0)).to eq(
         "[<4ad6e3> <4ed8fe>]"
+      )
     end
-
   end
 
   describe "Reference#encrypted_object" do
     it "should encrypt references properly" do
-      ref = PDF::Core::Reference(1,["foo"])
-      ref.encrypted_object(nil).should == "1 0 obj\n[<4fca3f>]\nendobj\n"
+      ref = PDF::Core::Reference(1, ["foo"])
+      expect(ref.encrypted_object(nil)).to eq("1 0 obj\n[<4fca3f>]\nendobj\n")
     end
 
     it "should encrypt references with streams properly" do
       ref = PDF::Core::Reference(1, {})
       ref << 'foo'
       result = bin_string("1 0 obj\n<< /Length 3\n>>\nstream\nO\xCA?\nendstream\nendobj\n")
-      ref.encrypted_object(nil).should == result
+      expect(ref.encrypted_object(nil)).to eq(result)
     end
   end
 
@@ -151,8 +145,7 @@ describe "Document encryption" do
       stream = PDF::Core::Stream.new
       stream << "foo"
       result = bin_string("stream\nO\xCA?\nendstream\n")
-      stream.encrypted_object(nil, 1, 0).should == result
+      expect(stream.encrypted_object(nil, 1, 0)).to eq(result)
     end
   end
-
 end