hexapdf 0.20.2 → 0.21.0

data/test/hexapdf/test_composer.rb

@@ -19,7 +19,7 @@ describe HexaPDF::Composer do
       assert_equal(36, @composer.frame.bottom)
       assert_equal(523, @composer.frame.width)
       assert_equal(770, @composer.frame.height)
-      assert_equal("Times", @composer.base_style.font)
+      assert_kind_of(HexaPDF::Layout::Style, @composer.style(:base))
     end
 
     it "allows the customization of the page size" do
@@ -86,83 +86,144 @@ describe HexaPDF::Composer do
     assert_equal(806, @composer.y)
   end
 
+  describe "style" do
+    it "creates a new style if it does not exist based on the base argument" do
+      @composer.style(:base, font_size: 20)
+      assert_equal(20, @composer.style(:newstyle, subscript: true).font_size)
+      refute( @composer.style(:base).subscript)
+      assert_equal(10, @composer.style(:another_new, base: nil).font_size)
+      assert(@composer.style(:yet_another_new, base: :newstyle).subscript)
+    end
+
+    it "returns the named style" do
+      assert_kind_of(HexaPDF::Layout::Style, @composer.style(:base))
+    end
+
+    it "updates the style with the given properties" do
+      assert_equal(20, @composer.style(:base, font_size: 20).font_size)
+    end
+  end
+
   describe "text" do
-    it "creates a text box and draws it on the canvas" do
-      box = nil
-      @composer.define_singleton_method(:draw_box) {|arg| box = arg }
+    before do
+      test_self = self
+      @composer.define_singleton_method(:draw_box) do |arg|
+        test_self.instance_variable_set(:@box, arg)
+      end
+    end
 
+    it "creates a text box and draws it on the canvas" do
       @composer.text("Test", width: 10, height: 15)
-      assert_equal(10, box.width)
-      assert_equal(15, box.height)
-      assert_same(@composer.document.fonts.add("Times"), box.style.font)
-      items = box.instance_variable_get(:@items)
+      assert_equal(10, @box.width)
+      assert_equal(15, @box.height)
+      assert_same(@composer.document.fonts.add("Times"), @box.style.font)
+      items = @box.instance_variable_get(:@items)
       assert_equal(1, items.length)
-      assert_same(box.style, items.first.style)
+      assert_same(@box.style, items.first.style)
     end
 
     it "allows setting of a custom style" do
-      box = nil
-      @composer.define_singleton_method(:draw_box) {|arg| box = arg }
-
-      @composer.text("Test", style: HexaPDF::Layout::Style.new(font_size: 20))
-      assert_same(@composer.document.fonts.add("Times"), box.style.font)
-      assert_equal(20, box.style.font_size)
+      style = HexaPDF::Layout::Style.new(font_size: 20, font: ['Times', {variant: :bold}])
+      @composer.text("Test", style: style)
+      assert_same(@box.style, style)
+      assert_same(@composer.document.fonts.add("Times", variant: :bold), @box.style.font)
+      assert_equal(20, @box.style.font_size)
+
+      @composer.text("Test", style: {font_size: 20})
+      assert_equal(20, @box.style.font_size)
+
+      @composer.style(:named, font_size: 20)
+      @composer.text("Test", style: :named)
+      assert_equal(20, @box.style.font_size)
     end
 
     it "updates the used style with the provided options" do
-      box = nil
-      @composer.define_singleton_method(:draw_box) {|arg| box = arg }
+      @composer.text("Test", style: {subscript: true}, font_size: 20)
+      assert_equal(20, @box.style.font_size)
+    end
 
-      @composer.text("Test", style: HexaPDF::Layout::Style.new, font_size: 20)
-      assert_equal(20, box.style.font_size)
+    it "allows using a box style different from the text style" do
+      style = HexaPDF::Layout::Style.new(font_size: 20)
+      @composer.text("Test", box_style: style)
+      refute_same(@box.instance_variable_get(:@items).first.style, style)
+      assert_same(@box.style, style)
+
+      @composer.style(:named, font_size: 20)
+      @composer.text("Test", box_style: :named)
+      assert_equal(20, @box.style.font_size)
     end
   end
 
   describe "formatted_text" do
-    it "creates a text box with the formatted text and draws it on the canvas" do
-      box = nil
-      @composer.define_singleton_method(:draw_box) {|arg| box = arg }
+    before do
+      test_self = self
+      @composer.define_singleton_method(:draw_box) do |arg|
+        test_self.instance_variable_set(:@box, arg)
+      end
+    end
 
+    it "creates a text box with the given text and draws it on the canvas" do
       @composer.formatted_text(["Test"], width: 10, height: 15)
-      assert_equal(10, box.width)
-      assert_equal(15, box.height)
-      assert_equal(1, box.instance_variable_get(:@items).length)
+      assert_equal(10, @box.width)
+      assert_equal(15, @box.height)
+      assert_equal(1, @box.instance_variable_get(:@items).length)
     end
 
-    it "a hash can be used for custom style properties" do
-      box = nil
-      @composer.define_singleton_method(:draw_box) {|arg| box = arg }
+    it "allows using a hash with :text key instead of a simple string" do
+      @composer.formatted_text([{text: "Test"}])
+      items = @box.instance_variable_get(:@items)
+      assert_equal(4, items[0].items.length)
+    end
 
-      @composer.formatted_text([{text: "Test", font_size: 20}], align: :center)
-      items = box.instance_variable_get(:@items)
-      assert_equal(1, items.length)
-      assert_equal(20, items.first.style.font_size)
-      assert_equal(:center, items.first.style.align)
-      assert_equal(10, box.style.font_size)
+    it "uses an empty string if the :text key for a hash is not specified" do
+      @composer.formatted_text([{font_size: "Test"}])
+      items = @box.instance_variable_get(:@items)
+      assert_equal(0, items[0].items.length)
     end
 
-    it "a hash can be used to provide a custom style" do
-      box = nil
-      @composer.define_singleton_method(:draw_box) {|arg| box = arg }
+    it "allows setting a custom base style for all parts" do
+      @composer.formatted_text(["Test", "other"], font_size: 20)
+      items = @box.instance_variable_get(:@items)
+      assert_equal(20, @box.style.font_size)
+      assert_equal(20, items[0].style.font_size)
+      assert_equal(20, items[1].style.font_size)
+    end
+
+    it "allows using custom style properties for a single part" do
+      @composer.formatted_text([{text: "Test", font_size: 20}, "test"], align: :center)
+      items = @box.instance_variable_get(:@items)
+      assert_equal(10, @box.style.font_size)
 
-      @composer.formatted_text([{text: "Test", style: HexaPDF::Layout::Style.new(fill_color: 128),
-                                 font_size: 20}], align: :center)
-      items = box.instance_variable_get(:@items)
-      assert_equal(20, items.first.style.font_size)
-      assert_equal(128, items.first.style.fill_color)
-      assert_equal(:center, items.first.style.align)
+      assert_equal(20, items[0].style.font_size)
+      assert_equal(:center, items[0].style.align)
+
+      assert_equal(10, items[1].style.font_size)
+      assert_equal(:center, items[1].style.align)
     end
 
-    it "a hash can be used to link to an URL" do
-      box = nil
-      @composer.define_singleton_method(:draw_box) {|arg| box = arg }
+    it "allows using a custom style as basis for a single part" do
+      @composer.formatted_text([{text: "Test", style: {font_size: 20}, subscript: true}, "test"],
+                               align: :center)
+      items = @box.instance_variable_get(:@items)
+      assert_equal(10, @box.style.font_size)
 
-      @composer.formatted_text([{text: "Test", link: "URI"}, {link: "URI"}])
-      items = box.instance_variable_get(:@items)
-      assert_equal(2, items.length)
-      assert_equal(4, items[0].items.length)
-      assert_equal(3, items[1].items.length)
+      assert_equal(20, items[0].style.font_size)
+      assert_equal(:left, items[0].style.align)
+      assert(items[0].style.subscript)
+
+      assert_equal(10, items[1].style.font_size)
+      assert_equal(:center, items[1].style.align)
+      refute(items[1].style.subscript)
+    end
+
+    it "allows specifying a link to an URL via the :link key" do
+      @composer.formatted_text([{text: "Test", link: "URI"}, {link: "URI"}, "test"])
+      items = @box.instance_variable_get(:@items)
+      assert_equal(3, items.length)
+      assert_equal(4, items[0].items.length, "text should be Test")
+      assert_equal(3, items[1].items.length, "text should be URI")
       assert_equal([:link, {uri: 'URI'}], items[0].style.overlays.instance_variable_get(:@layers)[0])
+      refute(items[2].style.overlays?)
     end
   end
 
@@ -172,9 +233,11 @@ describe HexaPDF::Composer do
       @composer.define_singleton_method(:draw_box) {|arg| box = arg }
       image_path = File.join(TEST_DATA_DIR, 'images', 'gray.jpg')
 
-      @composer.image(image_path, width: 10, height: 15)
+      @composer.image(image_path, width: 10, height: 15, style: {font_size: 20}, subscript: true)
       assert_equal(10, box.width)
       assert_equal(15, box.height)
+      assert_equal(20, box.style.font_size)
+      assert(box.style.subscript)
       assert_same(@composer.document.images.add(image_path), box.image)
     end
   end

data/test/hexapdf/test_dictionary.rb

@@ -19,8 +19,8 @@ describe HexaPDF::Dictionary do
     klass.new(obj, oid: 1)
   end
 
-  def delete(_obj)
-    _obj.data.value = nil
+  def delete(obj)
+    obj.data.value = nil
   end
 
   def wrap(obj, type:)

data/test/hexapdf/test_document.rb

@@ -476,16 +476,14 @@ describe HexaPDF::Document do
 
   describe "write" do
     it "writes the document to a file" do
-      begin
-        file = Tempfile.new('hexapdf-write')
-        file.close
-        @io_doc.write(file.path)
-        HexaPDF::Document.open(file.path) do |doc|
-          assert_equal(200, doc.object(2).value)
-        end
-      ensure
-        file.unlink
+      file = Tempfile.new('hexapdf-write')
+      file.close
+      @io_doc.write(file.path)
+      HexaPDF::Document.open(file.path) do |doc|
+        assert_equal(200, doc.object(2).value)
       end
+    ensure
+      file.unlink
     end
 
     it "writes the document to an IO object" do
@@ -666,4 +664,8 @@ describe HexaPDF::Document do
       assert_raises(LocalJumpError) { @doc.cache(:a, :b) }
     end
   end
+
+  it "can be inspected and the output is not too large" do
+    assert_match(/HexaPDF::Document:\d+/, @doc.inspect)
+  end
 end

data/test/hexapdf/test_object.rb

@@ -68,7 +68,7 @@ describe HexaPDF::Object do
 
     it "works for arrays" do
       obj = HexaPDF::PDFArray.new([:b, HexaPDF::Object.new(:a, oid: 3, document: @doc)],
-                                    oid: 1, document: @doc)
+                                  oid: 1, document: @doc)
       assert_equal([:b, :a], HexaPDF::Object.make_direct(obj))
     end
   end

data/test/hexapdf/test_parser.rb

@@ -109,7 +109,7 @@ describe HexaPDF::Parser do
 
     it "treats indirect objects with invalid values as null objects" do
       create_parser("1 0 obj <</test ( /other (end)>> endobj")
-      object, * =  @parser.parse_indirect_object
+      object, * = @parser.parse_indirect_object
       assert_nil(object)
     end
 
@@ -475,33 +475,33 @@ describe HexaPDF::Parser do
     describe "invalid numbering of main xref section" do
       it "handles the xref if the numbering is off by N" do
         create_parser(" 1 0 obj 1 endobj\n" \
-          "xref\n1 2\n0000000000 65535 f \n0000000001 00000 n \ntrailer\n<<>>\n")
+                      "xref\n1 2\n0000000000 65535 f \n0000000001 00000 n \ntrailer\n<<>>\n")
         section, _trailer = @parser.parse_xref_section_and_trailer(17)
         assert_equal(HexaPDF::XRefSection.in_use_entry(1, 0, 1), section[1])
       end
 
       it "fails if the first entry is not the one for oid=0" do
         create_parser(" 1 0 obj 1 endobj\n" \
-          "xref\n1 2\n0000000000 00005 f \n0000000001 00000 n \ntrailer\n<<>>\n")
+                      "xref\n1 2\n0000000000 00005 f \n0000000001 00000 n \ntrailer\n<<>>\n")
         exp = assert_raises(HexaPDF::MalformedPDFError) { @parser.parse_xref_section_and_trailer(17) }
         assert_match(/Main.*invalid numbering/i, exp.message)
 
         create_parser(" 1 0 obj 1 endobj\n" \
-          "xref\n1 2\n0000000001 00000 n \n0000000001 00000 n \ntrailer\n<<>>\n")
+                      "xref\n1 2\n0000000001 00000 n \n0000000001 00000 n \ntrailer\n<<>>\n")
         exp = assert_raises(HexaPDF::MalformedPDFError) { @parser.parse_xref_section_and_trailer(17) }
         assert_match(/Main.*invalid numbering/i, exp.message)
       end
 
       it "fails if the tested entry position is invalid" do
         create_parser(" 1 0 obj 1 endobj\n" \
-          "xref\n1 2\n0000000000 65535 f \n0000000005 00000 n \ntrailer\n<<>>\n")
+                      "xref\n1 2\n0000000000 65535 f \n0000000005 00000 n \ntrailer\n<<>>\n")
         exp = assert_raises(HexaPDF::MalformedPDFError) { @parser.parse_xref_section_and_trailer(17) }
         assert_match(/Main.*invalid numbering/i, exp.message)
       end
 
       it "fails if the tested entry position's oid doesn't match the corrected entry oid" do
         create_parser(" 2 0 obj 1 endobj\n" \
-          "xref\n1 2\n0000000000 65535 f \n0000000001 00000 n \ntrailer\n<<>>\n")
+                      "xref\n1 2\n0000000000 65535 f \n0000000001 00000 n \ntrailer\n<<>>\n")
         exp = assert_raises(HexaPDF::MalformedPDFError) { @parser.parse_xref_section_and_trailer(17) }
         assert_match(/Main.*invalid numbering/i, exp.message)
       end
@@ -580,6 +580,12 @@ describe HexaPDF::Parser do
       @xref = HexaPDF::XRefSection.in_use_entry(1, 0, 100)
     end
 
+    it "can tell us if the cross-reference table was reconstructed" do
+      create_parser("1 0 obj\n5\nendobj\ntrailer\n<</Size 1>>")
+      @parser.load_object(@xref)
+      assert(@parser.reconstructed?)
+    end
+
     it "serially parses the contents" do
       create_parser("1 0 obj\n5\nendobj\n1 0 obj\n6\nendobj\ntrailer\n<</Size 1>>")
       assert_equal(6, @parser.load_object(@xref).value)
@@ -643,7 +649,7 @@ describe HexaPDF::Parser do
     end
 
     it "uses the first trailer in case of a linearized file" do
-      create_parser("1 0 obj\n<</Linearized true>>\nendobj\ntrailer <</Size 1/Prev 342>>\ntrailer <</Size 2>>")
+      create_parser("1 0 obj\n<</Linearized true>>\nendobj\ntrailer <</Size 1/Prev 34>>\ntrailer <</Size 2>>")
       assert_equal({Size: 1}, @parser.reconstructed_revision.trailer.value)
     end
 

data/test/hexapdf/test_serializer.rb

@@ -70,16 +70,16 @@ describe HexaPDF::Serializer do
 
   it "serializes symbols" do
     assert_serialized("/Name", :Name)
-    assert_serialized("/A;Name_With-Various***Chars?", 'A;Name_With-Various***Chars?'.intern)
-    assert_serialized("/1.2", '1.2'.intern)
-    assert_serialized("/$$", '$$'.intern)
-    assert_serialized("/@pattern", '@pattern'.intern)
-    assert_serialized('/.notdef', '.notdef'.intern)
-    assert_serialized('/lime#20Green', 'lime Green'.intern)
-    assert_serialized('/paired#28#29parentheses', 'paired()parentheses'.intern)
-    assert_serialized('/The_Key_of_F#23_Minor', 'The_Key_of_F#_Minor'.intern)
-    assert_serialized('/ ', ''.intern)
-    assert_serialized('/H#c3#b6#c3#9fgang', "Hößgang".intern)
+    assert_serialized("/A;Name_With-Various***Chars?", :'A;Name_With-Various***Chars?')
+    assert_serialized("/1.2", :'1.2')
+    assert_serialized("/$$", :$$)
+    assert_serialized("/@pattern", :@pattern)
+    assert_serialized('/.notdef', :'.notdef')
+    assert_serialized('/lime#20Green', :'lime Green')
+    assert_serialized('/paired#28#29parentheses', :'paired()parentheses')
+    assert_serialized('/The_Key_of_F#23_Minor', :'The_Key_of_F#_Minor')
+    assert_serialized('/ ', :"")
+    assert_serialized('/H#c3#b6#c3#9fgang', :Hößgang)
     assert_serialized('/H#e8lp', "H\xE8lp".force_encoding('BINARY').intern)
   end
 
@@ -101,18 +101,16 @@ describe HexaPDF::Serializer do
   end
 
   it "serializes time like objects" do
-    begin
-      tz = ENV['TZ']
-      ENV['TZ'] = 'Europe/Vienna'
-      assert_serialized("(D:20150416094100)", Time.new(2015, 04, 16, 9, 41, 0, 0))
-      assert_serialized("(D:20150416094100+01'00')", Time.new(2015, 04, 16, 9, 41, 0, 3600))
-      assert_serialized("(D:20150416094100-01'20')", Time.new(2015, 04, 16, 9, 41, 0, -4800))
-      assert_serialized("(D:20150416000000+02'00')", Date.parse("2015-04-16 9:41:00 +02:00"))
-      assert_serialized("(D:20150416094100+02'00')",
-                        Time.parse("2015-04-16 9:41:00 +02:00").to_datetime)
-    ensure
-      ENV['TZ'] = tz
-    end
+    tz = ENV['TZ']
+    ENV['TZ'] = 'Europe/Vienna'
+    assert_serialized("(D:20150416094100)", Time.new(2015, 04, 16, 9, 41, 0, 0))
+    assert_serialized("(D:20150416094100+01'00')", Time.new(2015, 04, 16, 9, 41, 0, 3600))
+    assert_serialized("(D:20150416094100-01'20')", Time.new(2015, 04, 16, 9, 41, 0, -4800))
+    assert_serialized("(D:20150416000000+02'00')", Date.parse("2015-04-16 9:41:00 +02:00"))
+    assert_serialized("(D:20150416094100+02'00')",
+                      Time.parse("2015-04-16 9:41:00 +02:00").to_datetime)
+  ensure
+    ENV['TZ'] = tz
   end
 
   it "serializes HexaPDF objects" do

data/test/hexapdf/test_stream.rb

@@ -47,15 +47,13 @@ describe HexaPDF::StreamData do
     end
 
     it "returns a fiber for a string representing a file name" do
-      begin
-        file = Tempfile.new('hexapdf-stream')
-        file.write('source')
-        file.close
-        s = HexaPDF::StreamData.new(file.path)
-        assert_equal('source', s.fiber.resume)
-      ensure
-        file.unlink
-      end
+      file = Tempfile.new('hexapdf-stream')
+      file.write('source')
+      file.close
+      s = HexaPDF::StreamData.new(file.path)
+      assert_equal('source', s.fiber.resume)
+    ensure
+      file.unlink
     end
   end
 

data/test/hexapdf/test_writer.rb

@@ -40,7 +40,7 @@ describe HexaPDF::Writer do
       219
       %%EOF
       3 0 obj
-      <</Producer(HexaPDF version 0.20.2)>>
+      <</Producer(HexaPDF version 0.21.0)>>
       endobj
       xref
       3 1
@@ -72,7 +72,7 @@ describe HexaPDF::Writer do
       141
       %%EOF
       6 0 obj
-      <</Producer(HexaPDF version 0.20.2)>>
+      <</Producer(HexaPDF version 0.21.0)>>
       endobj
       2 0 obj
       <</Length 10>>stream
@@ -123,6 +123,17 @@ describe HexaPDF::Writer do
       HexaPDF::Writer.write(doc, output_io, incremental: true)
       refute_match(/^trailer/, output_io.string)
     end
+
+    it "raises an error if the used encryption was changed" do
+      io = StringIO.new
+      doc = HexaPDF::Document.new
+      doc.encrypt
+      doc.write(io)
+
+      doc = HexaPDF::Document.new(io: io)
+      doc.encrypt(owner_password: 'test')
+      assert_raises(HexaPDF::Error) { doc.write('notused', incremental: true) }
+    end
   end
 
   it "creates an xref stream if no xref stream is in a revision but object streams are" do

data/test/hexapdf/type/acro_form/test_appearance_generator.rb

@@ -602,8 +602,7 @@ describe HexaPDF::Type::AcroForm::AppearanceGenerator do
                           [:end_text],
                           [:restore_graphics_state],
                           [:restore_graphics_state],
-                          [:end_marked_content]],
-                        )
+                          [:end_marked_content]])
       end
     end
 

data/test/hexapdf/type/acro_form/test_choice_field.rb

@@ -120,7 +120,7 @@ describe HexaPDF::Type::AcroForm::ChoiceField do
 
   describe "option items" do
     before do
-      @items = [["a", "Zx"], "\xFE\xFF".b << "Töne".encode('UTF-16BE').b, "H\xe4llo".b,]
+      @items = [["a", "Zx"], "\xFE\xFF".b << "Töne".encode('UTF-16BE').b, "H\xe4llo".b]
     end
 
     it "sets the option items" do

data/test/hexapdf/type/signature/common.rb

@@ -9,7 +9,7 @@ module TestHelper
     end
 
     def ca_certificate
-      @ca_cert ||=
+      @ca_certificate ||=
         begin
           ca_name = OpenSSL::X509::Name.parse('/C=AT/O=HexaPDF/CN=HexaPDF Test Root CA')
 

data/test/hexapdf/type/test_annotation.rb

@@ -77,7 +77,13 @@ describe HexaPDF::Type::Annotation do
     stream[:BBox] = [1, 2, 3, 4]
     appearance = @annot.appearance
     assert_same(stream.data, appearance.data)
-    assert_equal(:Form, appearance[:Subtype])
+    assert_kind_of(HexaPDF::Type::Form, appearance)
+
+    stream[:Type] = :XObject
+    stream[:Subtype] = :Form
+    appearance = @annot.appearance
+    assert_same(stream.data, appearance.data)
+    assert_kind_of(HexaPDF::Type::Form, appearance)
 
     @annot[:AP][:N] = {X: {}}
     assert_nil(@annot.appearance)

data/test/hexapdf/type/test_font_type0.rb

@@ -112,7 +112,7 @@ describe HexaPDF::Type::FontType0 do
     end
 
     it "calls the configured proc if no mapping is available" do
-      @font[:Encoding] = :"Identity-H"
+      @font[:Encoding] = :'Identity-H'
       @cid_font[:CIDSystemInfo][:Registry] = :Unknown
       assert_raises(HexaPDF::Error) { @font.to_utf8(32) }
     end

data/test/hexapdf/type/test_font_type1.rb

@@ -10,24 +10,24 @@ describe HexaPDF::Type::FontType1::StandardFonts do
   end
 
   it "checks whether a given name corresponds to a standard font via #standard_font?" do
-    assert(@obj.standard_font?(:"Times-Roman"))
+    assert(@obj.standard_font?(:'Times-Roman'))
     assert(@obj.standard_font?(:TimesNewRoman))
     refute(@obj.standard_font?(:LibreSans))
   end
 
   it "returns the standard PDF name for an alias via #standard_name" do
-    assert_equal(:"Times-Roman", @obj.standard_name(:TimesNewRoman))
+    assert_equal(:'Times-Roman', @obj.standard_name(:TimesNewRoman))
   end
 
   describe "font" do
     it "returns the Type1 font object for a given standard name" do
-      font = @obj.font(:"Times-Roman")
+      font = @obj.font(:'Times-Roman')
       assert_equal("Times Roman", font.full_name)
     end
 
     it "caches the font for reuse" do
-      font = @obj.font(:"Times-Roman")
-      assert_same(font, @obj.font(:"Times-Roman"))
+      font = @obj.font(:'Times-Roman')
+      assert_same(font, @obj.font(:'Times-Roman'))
     end
 
     it "returns nil if the given name doesn't belong to a standard font" do
@@ -40,7 +40,7 @@ describe HexaPDF::Type::FontType1 do
   before do
     @doc = HexaPDF::Document.new
     @font = @doc.add({Type: :Font, Subtype: :Type1, Encoding: :WinAnsiEncoding,
-                      BaseFont: :"Times-Roman"})
+                      BaseFont: :'Times-Roman'})
 
     font_file = @doc.add({}, stream: <<-EOF)
       /Encoding 256 array
@@ -95,7 +95,7 @@ describe HexaPDF::Type::FontType1 do
 
   describe "bounding_box" do
     it "returns the bounding box for a standard font" do
-      font = HexaPDF::Type::FontType1::StandardFonts.font(:"Times-Roman")
+      font = HexaPDF::Type::FontType1::StandardFonts.font(:'Times-Roman')
       assert_equal(font.bounding_box, @font.bounding_box)
     end
 

data/test/hexapdf/type/test_image.rb

@@ -165,26 +165,22 @@ describe HexaPDF::Type::Image do
     end
 
     it "writes JPEG images to a file with .jpg extension" do
-      begin
-        file = Tempfile.new(['hexapdf-image-write-test', '.jpg'])
-        image = @doc.images.add(@jpg)
-        image.write(file.path)
-        assert_equal(File.binread(@jpg), File.binread(file.path))
-      ensure
-        file.unlink
-      end
+      file = Tempfile.new(['hexapdf-image-write-test', '.jpg'])
+      image = @doc.images.add(@jpg)
+      image.write(file.path)
+      assert_equal(File.binread(@jpg), File.binread(file.path))
+    ensure
+      file.unlink
     end
 
     it "writes JPEG2000 images to a file with .jpx extension" do
-      begin
-        file = Tempfile.new(['hexapdf-image-write-test', '.jpx'])
-        image = @doc.images.add(@jpg)
-        image.set_filter(:JPXDecode) # fake it
-        image.write(file.path)
-        assert_equal(File.binread(@jpg), File.binread(file.path))
-      ensure
-        file.unlink
-      end
+      file = Tempfile.new(['hexapdf-image-write-test', '.jpx'])
+      image = @doc.images.add(@jpg)
+      image.set_filter(:JPXDecode) # fake it
+      image.write(file.path)
+      assert_equal(File.binread(@jpg), File.binread(file.path))
+    ensure
+      file.unlink
     end
 
     Dir.glob(File.join(TEST_DATA_DIR, 'images', '*.png')).each do |png_file|

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: hexapdf
 version: !ruby/object:Gem::Version
-  version: 0.20.2
+  version: 0.21.0
 platform: ruby
 authors:
 - Thomas Leitner
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2022-01-17 00:00:00.000000000 Z
+date: 2022-03-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: cmdparse