hexapdf 1.8.0 → 1.9.0

data/test/hexapdf/digital_signature/common.rb

@@ -26,7 +26,7 @@ module HexaPDF
       def signer_certificate
         @signer_certificate ||=
           begin
-            cert = create_cert(name: '/CN=RSA signer/DC=gettalong', serial: 2,
+            cert = create_cert(name: '/CN=RSA signer', serial: 1,
                                public_key: signer_key, issuer: ca_certificate)
             add_extensions(cert, ca_certificate, ca_key, key_usage: 'digitalSignature')
             cert
@@ -36,7 +36,7 @@ module HexaPDF
       def non_repudiation_signer_certificate
         @non_repudiation_signer_certificate ||=
           begin
-            cert = create_cert(name: '/CN=Non repudiation signer/DC=gettalong', serial: 2,
+            cert = create_cert(name: '/CN=Non repudiation signer', serial: 2,
                                public_key: signer_key, issuer: ca_certificate)
             add_extensions(cert, ca_certificate, ca_key, key_usage: 'nonRepudiation')
             cert
@@ -50,7 +50,7 @@ module HexaPDF
       def dsa_signer_certificate
         @dsa_signer_certificate ||=
           begin
-            cert = create_cert(name: '/CN=DSA signer/DC=gettalong', serial: 3,
+            cert = create_cert(name: '/CN=DSA signer', serial: 3,
                                public_key: dsa_signer_key, issuer: ca_certificate)
             add_extensions(cert, ca_certificate, ca_key, key_usage: 'digitalSignature')
             cert
@@ -64,7 +64,7 @@ module HexaPDF
       def ecdsa_signer_certificate
         @ecdsa_signer_certificate ||=
           begin
-            cert = create_cert(name: '/CN=ECDSA signer/DC=gettalong', serial: 4,
+            cert = create_cert(name: '/CN=ECDSA signer', serial: 4,
                                public_key: ecdsa_signer_key, issuer: ca_certificate)
             add_extensions(cert, ca_certificate, ca_key, key_usage: 'digitalSignature')
             cert
@@ -74,7 +74,7 @@ module HexaPDF
       def timestamp_certificate
         @timestamp_certificate ||=
           begin
-            cert = create_cert(name: '/CN=timestamp/DC=gettalong', serial: 3,
+            cert = create_cert(name: '/CN=timestamp', serial: 5,
                                public_key: signer_key, issuer: ca_certificate)
             add_extensions(cert, ca_certificate, ca_key, key_usage: 'digitalSignature',
                            extended_key_usage: 'timeStamping')

data/test/hexapdf/digital_signature/test_cms_handler.rb

@@ -43,7 +43,7 @@ describe HexaPDF::DigitalSignature::CMSHandler do
   it "allows access to the signer information" do
     info = @handler.signer_info
     assert(info)
-    assert_equal(2, info.serial)
+    assert_equal(1, info.serial)
     assert_equal(CERTIFICATES.signer_certificate.issuer, info.issuer)
   end
 

data/test/hexapdf/document/test_annotations.rb

@@ -72,4 +72,14 @@ describe HexaPDF::Document::Annotations do
       assert_equal(annot, @page[:Annots].first)
     end
   end
+
+  describe "create_scribble" do
+    it "creates an appropriate ink annotation object" do
+      annot = @annots.create(:scribble, @page, 10, 10, 20, 15)
+      assert_equal(:Annot, annot[:Type])
+      assert_equal(:Ink, annot[:Subtype])
+      assert_equal([[10, 10, 20, 15]], annot.paths)
+      assert_equal(annot, @page[:Annots].first)
+    end
+  end
 end

data/test/hexapdf/document/test_layout.rb

@@ -513,19 +513,22 @@ describe HexaPDF::Document::Layout do
       assert_equal(10, box.width)
       assert_equal(15, box.height)
       items = box.instance_variable_get(:@items)
-      assert_equal(HexaPDF::Document::Layout::LOREM_IPSUM.join(" ").size, items[0].items.length)
+      assert_equal(HexaPDF::Document::Layout::LOREM_IPSUM.join(" ").size,
+                   items.sum {|i| i.items.length })
     end
 
     it "can use just some sentences from the lorem ipsum text" do
       box = @layout.lorem_ipsum_box(sentences: 1)
       items = box.instance_variable_get(:@items)
-      assert_equal(HexaPDF::Document::Layout::LOREM_IPSUM[0].size, items[0].items.length)
+      assert_equal(HexaPDF::Document::Layout::LOREM_IPSUM[0].size,
+                   items.sum {|i| i.items.length })
     end
 
     it "can use multiple of the selected sentences" do
       box = @layout.lorem_ipsum_box(sentences: 2, count: 2)
       items = box.instance_variable_get(:@items)
-      assert_equal(HexaPDF::Document::Layout::LOREM_IPSUM[0, 2].join(" ").size * 2 + 2, items[0].items.length)
+      assert_equal(HexaPDF::Document::Layout::LOREM_IPSUM[0, 2].join(" ").size * 2 + 2,
+                   items.sum {|i| i.items.length })
     end
   end
 

data/test/hexapdf/font/cmap/test_writer.rb

@@ -19,8 +19,9 @@ describe HexaPDF::Font::CMap::Writer do
       1 begincodespacerange
       <0000> <FFFF>
       endcodespacerange
-      2 beginbfchar
+      3 beginbfchar
       <0060><0090>
+      <00A0><00410042>
       <3A51><d840dc3e>
       endbfchar
       2 beginbfrange
@@ -79,6 +80,7 @@ describe HexaPDF::Font::CMap::Writer do
     0x1379.upto(0x137B) do |i|
       @to_unicode_mapping << [i, 0x90FE + i - 0x1379]
     end
+    @to_unicode_mapping << [0x00A0, "AB"]
     @to_unicode_mapping << [0x3A51, 0x2003E]
   end
 
@@ -89,17 +91,17 @@ describe HexaPDF::Font::CMap::Writer do
     end
 
     it "works if the last item is a range" do
-      @to_unicode_mapping.pop
-      @to_unicode_cmap_data.sub!(/2 beginbfchar/, '1 beginbfchar')
-      @to_unicode_cmap_data.sub!(/<3A51><d840dc3e>\n/, '')
+      @to_unicode_mapping[-2, 2] = []
+      @to_unicode_cmap_data.sub!(/3 beginbfchar/, '1 beginbfchar')
+      @to_unicode_cmap_data.sub!(/<00A0>.*<d840dc3e>\n/m, '')
       assert_equal(@to_unicode_cmap_data,
                    HexaPDF::Font::CMap.create_to_unicode_cmap(@to_unicode_mapping))
     end
 
     it "works with only ranges" do
-      @to_unicode_mapping.delete_at(-1)
+      @to_unicode_mapping[-2, 2] = []
       @to_unicode_mapping.delete_at(0x5f)
-      @to_unicode_cmap_data.sub!(/\n2 beginbfchar.*endbfchar/m, '')
+      @to_unicode_cmap_data.sub!(/\n3 beginbfchar.*endbfchar/m, '')
       assert_equal(@to_unicode_cmap_data,
                    HexaPDF::Font::CMap.create_to_unicode_cmap(@to_unicode_mapping))
     end

data/test/hexapdf/font/test_true_type_wrapper.rb

@@ -37,6 +37,10 @@ describe HexaPDF::Font::TrueTypeWrapper do
     refute(HexaPDF::Font::TrueTypeWrapper.new(@doc, @font, subset: false).subset?)
   end
 
+  it "can be asked for the filename from which the wrapped font was created" do
+    assert_equal(@font_file, @font_wrapper.filename)
+  end
+
   describe "decode_*" do
     it "decode_utf8 returns an array of glyph objects" do
       assert_equal("Test",

data/test/hexapdf/layout/test_container_box.rb

@@ -71,9 +71,11 @@ describe HexaPDF::Layout::ContainerBox do
     end
 
     it "splits the box if splitting is allowed and the content is too big" do
-      box = create_box([child_box(height: 80), child_box(height: 30)], splitable: true)
+      box = create_box([child_box(width: 30, height: 80), child_box(height: 30)], splitable: true)
       box.fit(@frame.available_width, @frame.available_height, @frame)
       assert(box.fit_result.overflow?)
+      assert_equal(100, box.width)
+      assert_equal(80, box.height)
     end
   end
 

data/test/hexapdf/layout/test_style.rb

@@ -785,6 +785,10 @@ describe HexaPDF::Layout::Style do
     assert_equal(100, @style.horizontal_scaling)
     assert_equal(0, @style.text_rise)
     assert_equal({}, @style.font_features)
+    assert_nil(@style.font_script)
+    assert_equal(:ltr, @style.direction)
+    assert_nil(@style.language)
+    assert_equal(:internal, @style.shaping_engine)
     assert_equal(HexaPDF::Content::TextRenderingMode::FILL, @style.text_rendering_mode)
     assert_equal([0], @style.fill_color.components)
     assert_equal(1, @style.fill_alpha)

data/test/hexapdf/layout/test_table_box.rb

@@ -128,6 +128,20 @@ describe HexaPDF::Layout::TableBox::Cell do
       assert_equal(32, cell.height)
     end
 
+    it "can split a cell if necessary" do
+      children = [HexaPDF::Layout::Box.create(width: 70, height: 60),
+                  HexaPDF::Layout::Box.create(width: 70, height: 60)]
+      container = HexaPDF::Layout::ContainerBox.new(children: children, splitable: true)
+      [container, container.children].each do |used_children|
+        cell = create_cell(children: used_children)
+        assert(cell.fit(100, 100, @frame).overflow?)
+        assert_equal(100, cell.width)
+        assert_equal(72, cell.height)
+        assert_equal(used_children == container ? 100 : 82, cell.preferred_width)
+        assert_equal(72, cell.preferred_height)
+      end
+    end
+
     it "doesn't fit children that are too big" do
       cell = create_cell(children: HexaPDF::Layout::Box.create(width: 300, height: 20))
       assert(cell.fit(100, 100, @frame).failure?)
@@ -142,6 +156,18 @@ describe HexaPDF::Layout::TableBox::Cell do
     end
   end
 
+  describe "split" do
+    it "assigns the overflown boxes to the split box" do
+      children = [HexaPDF::Layout::Box.create(width: 70, height: 60),
+                  HexaPDF::Layout::Box.create(width: 70, height: 60)]
+      cell = create_cell(children: children)
+      assert(cell.fit(100, 100, @frame).overflow?)
+      box, overflow_box = cell.split
+      assert_same(cell, box)
+      assert_equal([children[1]], overflow_box.children)
+    end
+  end
+
   describe "draw" do
     before do
       @canvas = HexaPDF::Document.new.pages.add.canvas
@@ -349,6 +375,13 @@ describe HexaPDF::Layout::TableBox::Cells do
       cells = create_cells([[:a, :b], [:c], [:d, :e]])
       assert_equal([[:a, :b], [:c], [:d, :e]], cells.each_row.map {|cols| cols.map(&:children) })
     end
+
+    it "allows iterating over rows containing an overridden one" do
+      cells = create_cells([[:a, :b], [:c], [:d, :e]])
+      cells.instance_variable_set(:@overridden_row_index, 1)
+      cells.instance_variable_set(:@overridden_row_cells, [cells[2, 1], cells[2, 0]])
+      assert_equal([[:a, :b], [:e, :d], [:d, :e]], cells.each_row.map {|cols| cols.map(&:children) })
+    end
   end
 
   describe "style" do
@@ -612,6 +645,29 @@ describe HexaPDF::Layout::TableBox do
       check_box(box, :overflow, 160, 10,
                 [[0, 0, 80, 10], [80, 0, 80, 10], [nil, nil, 80, 0], [nil, nil, 0, 0]])
     end
+
+    it "fails if not even enough height for the first row is available" do
+      check_box(create_box(height: 10), :failure, 160, 10)
+    end
+
+    describe "last row splitting" do
+      before do
+        @boxes = [[80, 50], [80, 40], [80, 70]].map do |w, h|
+          HexaPDF::Layout::Box.new(width: w, height: h, &@draw_block)
+        end
+      end
+
+      it "splits the last row if necessary" do
+        box = create_box(cells: [[@boxes[0], @boxes[1, 2]]], cell_style: {padding: 0, border: {width: 0}})
+        check_box(box, :overflow, 160, 50, [[0, 0, 80, 50], [80, 0, 80, 50]])
+      end
+
+      it "doesn't split the last row if it is part of a row span" do
+        cells = [[@boxes[0], {content: @boxes[1, 2], row_span: 2}]]
+        box = create_box(cells: cells, cell_style: {padding: 0, border: {width: 0}})
+        check_box(box, :failure, 160, 0)
+      end
+    end
   end
 
   describe "split" do
@@ -672,6 +728,23 @@ describe HexaPDF::Layout::TableBox do
         end
       end
     end
+
+    it "splits the last row of a table" do
+      box = create_box(cells: [[@fixed_size_boxes[0], @fixed_size_boxes[1, 3]]],
+                       cell_style: {padding: 0, border: {width: 0}})
+      assert(box.fit(100, 15, @frame).overflow?)
+      box_a, box_b = box.split
+      assert_same(box_a, box)
+
+      assert_equal(0, box_a.start_row_index)
+      assert_equal(0, box_a.last_fitted_row_index)
+      assert_equal(0, box_b.start_row_index)
+      assert_equal(-1, box_b.last_fitted_row_index)
+
+      assert_nil(box_b.cells[0, 0].children)
+      assert_same(box_a.cells[0, 0].style, box_b.cells[0, 0].style)
+      assert_equal(@fixed_size_boxes[2, 2], box_b.cells[0, 1].children)
+    end
   end
 
   describe "draw_content" do
@@ -722,7 +795,7 @@ describe HexaPDF::Layout::TableBox do
       assert_operators(@canvas.contents, operators)
     end
 
-    it "correctly works for split boxes" do
+    it "correctly works for split tables" do
       box = create_box(cell_style: {padding: 0, border: {width: 0}})
       assert(box.fit(100, 10, @frame).overflow?)
       _, split_box = box.split
@@ -753,6 +826,49 @@ describe HexaPDF::Layout::TableBox do
       assert_operators(@canvas.contents, operators)
     end
 
+    it "correctly works for split cells" do
+      box = create_box(cells: [[@fixed_size_boxes[0], @fixed_size_boxes[1, 3]]],
+                       cell_style: {padding: 0, border: {width: 0}})
+      box.cells[0, 0].style.background_color = 'red'
+      assert(box.fit(100, 10, @frame).overflow?)
+      _, split_box = box.split
+      assert(split_box.fit(100, 100, @frame).success?)
+
+      box.draw(@canvas, 20, 10)
+      split_box.draw(@canvas, 0, 50)
+      operators = [[:save_graphics_state],
+                   [:set_device_rgb_non_stroking_color, [1, 0, 0]],
+                   [:append_rectangle, [20, 10, 50, 10]],
+                   [:fill_path_non_zero],
+                   [:restore_graphics_state],
+                   [:save_graphics_state],
+                   [:concatenate_matrix, [1, 0, 0, 1, 20, 10]],
+                   [:move_to, [0, 0]],
+                   [:end_path],
+                   [:restore_graphics_state],
+                   [:save_graphics_state],
+                   [:concatenate_matrix, [1, 0, 0, 1, 70, 10]],
+                   [:move_to, [0, 0]],
+                   [:end_path],
+                   [:restore_graphics_state],
+                   [:save_graphics_state],
+                   [:set_device_rgb_non_stroking_color, [1, 0, 0]],
+                   [:append_rectangle, [0, 50, 50, 20]],
+                   [:fill_path_non_zero],
+                   [:restore_graphics_state],
+                   [:save_graphics_state],
+                   [:concatenate_matrix, [1, 0, 0, 1, 50, 60]],
+                   [:move_to, [0, 0]],
+                   [:end_path],
+                   [:restore_graphics_state],
+                   [:save_graphics_state],
+                   [:concatenate_matrix, [1, 0, 0, 1, 50, 50]],
+                   [:move_to, [0, 0]],
+                   [:end_path],
+                   [:restore_graphics_state]]
+      assert_operators(@canvas.contents, operators)
+    end
+
     it "correctly works for tables with headers and footers" do
       box = create_box(header: lambda {|_| [@fixed_size_boxes[10, 1]] },
                        footer: lambda {|_| [@fixed_size_boxes[12, 1]] },

data/test/hexapdf/layout/test_text_fragment.rb

@@ -50,24 +50,29 @@ describe HexaPDF::Layout::TextFragment do
     it "replaces invalid glyphs with the result of the block" do
       zapf_dingbats = @doc.fonts.add('ZapfDingbats')
       i = 0
-      fallback = lambda do |codepoint, _invalid_glyph|
-        case (i += 1) % 3
+      fallback = lambda do |codepoint, invalid_glyph|
+        case (i += 1) % 4
         when 0 then []
         when 1 then [zapf_dingbats.decode_codepoint(codepoint)]
         when 2 then @font.decode_utf8("Tom")
+        when 3 then [invalid_glyph]
         end
       end
       style = HexaPDF::Layout::Style.new(font: @font, font_size: 20, font_features: {kern: true})
 
-      frags = HexaPDF::Layout::TextFragment.create_with_fallback_glyphs("✂Tom✂✂Tom✂", style, &fallback)
-      assert_equal(5, frags.size)
+      frags = HexaPDF::Layout::TextFragment.create_with_fallback_glyphs("✂Tom✂Tom✂Tom✂Tom\u{ad}",
+                                                                        style, &fallback)
+      assert_equal(8, frags.size)
       assert_equal(zapf_dingbats, frags[0].style.font)
       assert_equal(:a2, frags[0].items[0].name)
+      assert_equal("Tom", frags[1].text)
+      assert_equal("Tom", frags[2].text)
       assert_equal(@font, frags[2].style.font)
-
-      frags = HexaPDF::Layout::TextFragment.create_with_fallback_glyphs("Tom✂Tom", style, &fallback)
-      assert_equal(3, frags.size)
-      assert_equal(frags[0].width, frags[1].width)
+      assert_equal("Tom", frags[3].text)
+      assert_equal(:'.notdef', frags[4].items[0].name)
+      assert_equal("Tom", frags[5].text)
+      assert_equal("Tom", frags[6].text)
+      assert_equal("\u{ad}", frags[7].text)
     end
   end
 
@@ -173,6 +178,11 @@ describe HexaPDF::Layout::TextFragment do
                                             [:move_text_next_line]])
       end
 
+      it "without any horizontal or vertical movement" do
+        @fragment.draw(@canvas, 0, 0, ignore_text_properties: true)
+        assert_operators(@canvas.contents, [[:begin_text]])
+      end
+
       it "only horizontal movement" do
         @fragment.draw(@canvas, 20, 0, ignore_text_properties: true)
         assert_operators(@canvas.contents, [[:begin_text],

data/test/hexapdf/layout/test_text_shaper.rb

@@ -15,7 +15,7 @@ describe HexaPDF::Layout::TextShaper do
   end
 
   def setup_fragment(items, **options)
-    style = HexaPDF::Layout::Style.new(font: @font, font_size: 20, font_features: options)
+    style = HexaPDF::Layout::Style.new(font: @font, font_size: 20, **options)
     HexaPDF::Layout::TextFragment.new(items, style)
   end
 
@@ -26,14 +26,15 @@ describe HexaPDF::Layout::TextShaper do
 
     it "handles ligatures" do
       fragment = setup_fragment(@font.decode_utf8('fish fish fi').insert(1, 100).
-        insert(0, 100), liga: true)
+        insert(0, 100), font_features: {liga: true})
       @shaper.shape_text(fragment)
       assert_equal([100, :fi, :s, :h, :space, :fi, :s, :h, :space, :fi],
                    fragment.items.map {|item| item.kind_of?(Numeric) ? item : item.id })
     end
 
     it "handles kerning" do
-      fragment = setup_fragment(@font.decode_utf8('fish fish wow').insert(1, 100), kern: true)
+      fragment = setup_fragment(@font.decode_utf8('fish fish wow').insert(1, 100),
+                                font_features: {kern: true})
       @shaper.shape_text(fragment)
       assert_equal([:f, 100, :i, :s, :h, :space, :f, 20, :i, :s, :h, :space, :w, 10, :o, 25, :w],
                    fragment.items.map {|item| item.kind_of?(Numeric) ? item : item.id })
@@ -47,16 +48,65 @@ describe HexaPDF::Layout::TextShaper do
       @font = HexaPDF::Font::TrueTypeWrapper.new(@doc, @wrapped_font)
     end
 
-    it "handles kerning" do
+    it "handles kerning via the kern table" do
       data = [0, 1].pack('n2') <<
         [0, 6 + 8 + 12, 0x1].pack('n3') <<
         [2, 0, 0, 0, 53, 80, -20, 80, 81, -10].pack('n4n2s>n2s>')
       table = create_table(:Kern, data, standalone: true)
       @wrapped_font.instance_eval { @tables[:kern] = table }
-      fragment = setup_fragment(@font.decode_utf8('Top Top').insert(1, 100), kern: true)
+      fragment = setup_fragment(@font.decode_utf8('Top Top').insert(1, 100),
+                                shaping_engine: :internal, font_features: {kern: true})
       @shaper.shape_text(fragment)
       assert_equal([53, [100], 80, [10], 81, 3, 53, [20], 80, [10], 81],
                    fragment.items.map {|item| item.kind_of?(Numeric) ? [item] : item.id })
     end
+
+    describe "HarfBuzz OpenType shaper" do
+      before do
+        @font = @doc.fonts.add('Inter')
+        skip if Gem.win_platform?
+      end
+
+      it "performs the shaping" do
+        # Test composition of o+diaresis, invalid char \n, kerning WA, x/y offsets with marks
+        fragment = setup_fragment(@font.decode_utf8("ö\nWAď̄"), shaping_engine: :harfbuzz,
+                                  font_features: {kern: true})
+        assert_equal(8, fragment.items.size)
+        result = @shaper.shape_text(fragment)
+        assert_equal(2, result.size)
+        [[791, 0, 459, [56.640625], 2, 603],
+         [[664.55078125], 1773, [-664.55078125]]].each_with_index do |expected, index|
+          assert_equal(expected,
+                       result[index].items.map {|item| item.kind_of?(Numeric) ? [item] : item.id })
+        end
+        assert_equal("\n", result[0].items[1].str)
+      end
+
+      it "handles glyphs with the same cluster number" do
+        # Force Harfbuzz into cluster level 0 to force the same cluster numbers
+        cluster_level_method = HarfBuzz::Buffer.instance_method(:cluster_level=)
+        HarfBuzz::Buffer.remove_method(:cluster_level=)
+        HarfBuzz::Buffer.define_method(:cluster_level=) {|val| }
+
+        fragment = setup_fragment(@font.decode_utf8("ď̄aď̄"), shaping_engine: :harfbuzz)
+        result = @shaper.shape_text(fragment)
+        assert_equal("ď̄", result[0].items[0].str)
+        assert_equal("", result[1].items[1].str)
+      ensure
+        HarfBuzz::Buffer.remove_method(:cluster_level=)
+        HarfBuzz::Buffer.define_method(:cluster_level=, cluster_level_method)
+      end
+
+      it "raises an error if the harfbuzz-ruby gem is not available" do
+        Object.send(:remove_const, :HARFBUZZ_AVAILABLE)
+        Object.const_set(:HARFBUZZ_AVAILABLE, false)
+        fragment = setup_fragment(@font.decode_utf8('test'), shaping_engine: :harfbuzz)
+        error = assert_raises(HexaPDF::Error) { @shaper.shape_text(fragment) }
+        assert_match(/harfbuzz-ruby/, error.message)
+      ensure
+        Object.send(:remove_const, :HARFBUZZ_AVAILABLE)
+        Object.const_set(:HARFBUZZ_AVAILABLE, true)
+      end
+    end
   end
 end

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

@@ -605,4 +605,67 @@ describe HexaPDF::Type::Annotations::AppearanceGenerator do
                         [:fill_and_stroke_path_non_zero]], range: 6..-1)
     end
   end
+
+  describe "ink" do
+    before do
+      @ink = @doc.add({Type: :Annot, Subtype: :Ink, C: [0],
+                       InkList: [[100, 100, 200, 150], [210, 80, 110, 160]]})
+      @generator = HexaPDF::Type::Annotations::AppearanceGenerator.new(@ink)
+    end
+
+    it "sets the print flag and unsets the hidden flag" do
+      @ink.flag(:hidden)
+      @generator.create_appearance
+      assert(@ink.flagged?(:print))
+      refute(@ink.flagged?(:hidden))
+    end
+
+    it "creates the appearance" do
+      @generator.create_appearance
+      assert_equal([96, 76, 214, 164], @ink[:Rect])
+      assert_equal([96, 76, 214, 164], @ink.appearance[:BBox])
+      assert_operators(@ink.appearance.stream,
+                       [[:move_to, [100, 100]],
+                        [:line_to, [200, 150]],
+                        [:move_to, [210, 80]],
+                        [:line_to, [110, 160]],
+                        [:stroke_path]])
+    end
+
+    describe "stroke color" do
+      it "uses the specified border color for stroking operations" do
+        @ink.border_style(color: "red")
+        @generator.create_appearance
+        assert_operators(@ink.appearance.stream,
+                         [:set_device_rgb_stroking_color, [1, 0, 0]], range: 0)
+      end
+
+      it "works with a transparent border" do
+        @ink.border_style(color: :transparent)
+        @generator.create_appearance
+        assert_operators(@ink.appearance.stream, [:end_path], range: 4)
+      end
+    end
+
+    it "sets the specified border line width" do
+      @ink.border_style(width: 4)
+      @generator.create_appearance
+      assert_operators(@ink.appearance.stream,
+                       [:set_line_width, [4]], range: 0)
+    end
+
+    it "sets the specified line dash pattern if it is an array" do
+      @ink.border_style(style: [5, 2])
+      @generator.create_appearance
+      assert_operators(@ink.appearance.stream,
+                       [:set_line_dash_pattern, [[5, 2], 0]], range: 0)
+    end
+
+    it "sets the specified opacity" do
+      @ink.opacity(fill_alpha: 0.5, stroke_alpha: 0.5)
+      @generator.create_appearance
+      assert_operators(@ink.appearance.stream,
+                       [:set_graphics_state_parameters, [:GS1]], range: 0)
+    end
+  end
 end

data/test/hexapdf/type/annotations/test_ink.rb

@@ -0,0 +1,31 @@
+# -*- encoding: utf-8 -*-
+
+require 'test_helper'
+require 'hexapdf/document'
+require 'hexapdf/type/annotations/ink'
+
+describe HexaPDF::Type::Annotations::Ink do
+  before do
+    @doc = HexaPDF::Document.new
+    @annot = @doc.add({Type: :Annot, Subtype: :Ink, Rect: [0, 0, 0, 0]})
+  end
+
+  it "returns the paths" do
+    assert_equal([], @annot.paths)
+    @annot[:InkList] = [[10, 20, 30, 40], [50, 60, 70, 80]]
+    assert_equal([[10, 20, 30, 40], [50, 60, 70, 80]], @annot.paths)
+  end
+
+  describe "add_paths" do
+    it "adds the given path" do
+      assert_same(@annot, @annot.add_path(1, 2, 3, 4, 5, 6))
+      assert_equal([[1, 2, 3, 4, 5, 6]], @annot[:InkList])
+      @annot.add_path(7, 8, 9, 10)
+      assert_equal([[1, 2, 3, 4, 5, 6], [7, 8, 9, 10]], @annot[:InkList])
+    end
+
+    it "raises an ArgumentError if an uneven number of arguments is provided" do
+      assert_raises(ArgumentError) { @annot.add_path(1, 2, 3) }
+    end
+  end
+end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: hexapdf
 version: !ruby/object:Gem::Version
-  version: 1.8.0
+  version: 1.9.0
 platform: ruby
 authors:
 - Thomas Leitner
 bindir: bin
 cert_chain: []
-date: 1980-01-02 00:00:00.000000000 Z
+date: 2026-06-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: cmdparse
@@ -77,6 +77,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: 3.1.2
+- !ruby/object:Gem::Dependency
+  name: harfbuzz-ruby
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
 - !ruby/object:Gem::Dependency
   name: brotli
   requirement: !ruby/object:Gem::Requirement
@@ -315,6 +329,11 @@ files:
 - data/hexapdf/cmap/V
 - data/hexapdf/encoding/glyphlist.txt
 - data/hexapdf/encoding/zapfdingbats.txt
+- data/hexapdf/fonts/Inter-Bold.ttf
+- data/hexapdf/fonts/Inter-BoldItalic.ttf
+- data/hexapdf/fonts/Inter-Italic.ttf
+- data/hexapdf/fonts/Inter-Regular.ttf
+- data/hexapdf/fonts/OFL.txt
 - data/hexapdf/sRGB2014.icc
 - data/hexapdf/sRGB2014.icc.LICENSE
 - examples/001-hello_world.rb
@@ -350,6 +369,7 @@ files:
 - examples/031-acro_form_java_script.rb
 - examples/032-acro_form_list_and_fill.rb
 - examples/033-text_extraction.rb
+- examples/034-text_shaping.rb
 - examples/emoji-smile.png
 - examples/emoji-wink.png
 - examples/machupicchu.jpg
@@ -546,6 +566,7 @@ files:
 - lib/hexapdf/type/annotations/border_effect.rb
 - lib/hexapdf/type/annotations/border_styling.rb
 - lib/hexapdf/type/annotations/circle.rb
+- lib/hexapdf/type/annotations/ink.rb
 - lib/hexapdf/type/annotations/interior_color.rb
 - lib/hexapdf/type/annotations/line.rb
 - lib/hexapdf/type/annotations/line_ending_styling.rb
@@ -842,6 +863,7 @@ files:
 - test/hexapdf/type/annotations/test_appearance_generator.rb
 - test/hexapdf/type/annotations/test_border_effect.rb
 - test/hexapdf/type/annotations/test_border_styling.rb
+- test/hexapdf/type/annotations/test_ink.rb
 - test/hexapdf/type/annotations/test_interior_color.rb
 - test/hexapdf/type/annotations/test_line.rb
 - test/hexapdf/type/annotations/test_line_ending_styling.rb
@@ -903,7 +925,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.3
+rubygems_version: 3.6.2
 specification_version: 4
 summary: HexaPDF - A Versatile PDF Creation and Manipulation Library For Ruby
 test_files: []