hexapdf 0.20.3 → 0.21.1

data/test/hexapdf/layout/test_style.rb

@@ -604,6 +604,26 @@ describe HexaPDF::Layout::Style do
     end
   end
 
+  describe "self.create" do
+    it "returns the provided style argument" do
+      assert_same(@style, HexaPDF::Layout::Style.create(@style))
+    end
+
+    it "creates a new Style object based on the passed hash" do
+      style = HexaPDF::Layout::Style.create(font_size: 10, fill_color: 'green')
+      assert_equal(10, style.font_size)
+      assert_equal('green', style.fill_color)
+    end
+
+    it "creates an empty Style object if nil is passed" do
+      assert_kind_of(HexaPDF::Layout::Style, HexaPDF::Layout::Style.create(nil))
+    end
+
+    it "raises an error if an invalid object is provided" do
+      assert_raises(ArgumentError) { HexaPDF::Layout::Style.create(5) }
+    end
+  end
+
   it "can assign values on initialization" do
     style = HexaPDF::Layout::Style.new(font_size: 10)
     assert_equal(10, style.font_size)
@@ -692,6 +712,9 @@ describe HexaPDF::Layout::Style do
 
     @style.stroke_dash_pattern(5, 2)
     assert_equal([[5], 2], @style.stroke_dash_pattern.to_operands)
+
+    @style.line_spacing(1.2)
+    assert_equal([:proportional, 1.2], [@style.line_spacing.type, @style.line_spacing.value])
   end
 
   it "allows checking for valid values" do

data/test/hexapdf/layout/test_text_fragment.rb

@@ -20,7 +20,7 @@ describe HexaPDF::Layout::TextFragment do
   end
 
   describe "create" do
-    it "creates a TextFragment from text and options" do
+    it "creates a TextFragment from text and style" do
       frag = HexaPDF::Layout::TextFragment.create("Tom", font: @font, font_size: 20,
                                                   font_features: {kern: true})
       assert_equal(4, frag.items.length)
@@ -180,16 +180,16 @@ describe HexaPDF::Layout::TextFragment do
                                      [:set_line_width, [5]],
                                      [:set_line_cap_style, [1]],
                                      [:set_line_dash_pattern, [[5], 0]]],
-        back: [[:end_text],
-               [:save_graphics_state],
-               [:set_device_gray_stroking_color, [0]],
-               [:set_line_width, [@fragment.style.calculated_underline_thickness]],
-               [:set_line_cap_style, [0]],
-               [:set_line_dash_pattern, [[], 0]],
-               [:move_to, [10, 15]],
-               [:line_to, [40.88, 15]],
-               [:stroke_path],
-               [:restore_graphics_state]])
+                            back: [[:end_text],
+                                   [:save_graphics_state],
+                                   [:set_device_gray_stroking_color, [0]],
+                                   [:set_line_width, [@fragment.style.calculated_underline_thickness]],
+                                   [:set_line_cap_style, [0]],
+                                   [:set_line_dash_pattern, [[], 0]],
+                                   [:move_to, [10, 15]],
+                                   [:line_to, [40.88, 15]],
+                                   [:stroke_path],
+                                   [:restore_graphics_state]])
     end
 
     it "draws the strikeout line" do
@@ -201,16 +201,16 @@ describe HexaPDF::Layout::TextFragment do
                                      [:set_line_width, [5]],
                                      [:set_line_cap_style, [1]],
                                      [:set_line_dash_pattern, [[5], 0]]],
-        back: [[:end_text],
-               [:save_graphics_state],
-               [:set_device_gray_stroking_color, [0]],
-               [:set_line_width, [@fragment.style.calculated_strikeout_thickness]],
-               [:set_line_cap_style, [0]],
-               [:set_line_dash_pattern, [[], 0]],
-               [:move_to, [10, 21.01]],
-               [:line_to, [40.88, 21.01]],
-               [:stroke_path],
-               [:restore_graphics_state]])
+                            back: [[:end_text],
+                                   [:save_graphics_state],
+                                   [:set_device_gray_stroking_color, [0]],
+                                   [:set_line_width, [@fragment.style.calculated_strikeout_thickness]],
+                                   [:set_line_cap_style, [0]],
+                                   [:set_line_dash_pattern, [[], 0]],
+                                   [:move_to, [10, 21.01]],
+                                   [:line_to, [40.88, 21.01]],
+                                   [:stroke_path],
+                                   [:restore_graphics_state]])
     end
   end
 

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.3)>>
+      <</Producer(HexaPDF version 0.21.1)>>
       endobj
       xref
       3 1
@@ -72,7 +72,7 @@ describe HexaPDF::Writer do
       141
       %%EOF
       6 0 obj
-      <</Producer(HexaPDF version 0.20.3)>>
+      <</Producer(HexaPDF version 0.21.1)>>
       endobj
       2 0 obj
       <</Length 10>>stream

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_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