hexapdf 1.7.0 → 1.9.0

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",
@@ -119,9 +123,9 @@ describe HexaPDF::Font::TrueTypeWrapper do
       assert_equal([3].pack('n'), code)
     end
 
-    it "doesn't use char codes 13, 40, 41 and 92 because they would need to be escaped" do
+    it "doesn't use char codes 10, 13, 40, 41 and 92 because they would need to be escaped" do
       codes = 1.upto(93).map {|i| @font_wrapper.encode(@font_wrapper.glyph(i)) }.join
-      assert_equal([1..12, 14..39, 42..91, 93..97].flat_map(&:to_a).pack('n*'), codes)
+      assert_equal([1..9, 11..12, 14..39, 42..91, 93..98].flat_map(&:to_a).pack('n*'), codes)
     end
 
     it "raises an error if an InvalidGlyph is encoded" do

data/test/hexapdf/font/true_type/test_subsetter.rb

@@ -29,12 +29,13 @@ describe HexaPDF::Font::TrueType::Subsetter do
 
   it "doesn't use certain subset glyph IDs for performance reasons" do
     1.upto(93) {|i| @subsetter.use_glyph(i) }
-    # glyph 0, 93 used glyph, 4 special glyphs
-    assert_equal(1 + 93 + 4, @subsetter.instance_variable_get(:@glyph_map).size)
-    1.upto(12) {|i| assert_equal(i, @subsetter.subset_glyph_id(i), "id=#{i}") }
-    13.upto(38) {|i| assert_equal(i + 1, @subsetter.subset_glyph_id(i), "id=#{i}") }
-    39.upto(88) {|i| assert_equal(i + 3, @subsetter.subset_glyph_id(i), "id=#{i}") }
-    89.upto(93) {|i| assert_equal(i + 4, @subsetter.subset_glyph_id(i), "id=#{i}") }
+    # glyph 0 and 93 are used glyph, 5 special glyphs
+    assert_equal(1 + 93 + 5, @subsetter.instance_variable_get(:@glyph_map).size)
+    1.upto(9) {|i| assert_equal(i, @subsetter.subset_glyph_id(i), "id=#{i}") }
+    10.upto(11) {|i| assert_equal(i + 1, @subsetter.subset_glyph_id(i), "id=#{i}") }
+    12.upto(37) {|i| assert_equal(i + 2, @subsetter.subset_glyph_id(i), "id=#{i}") }
+    38.upto(87) {|i| assert_equal(i + 4, @subsetter.subset_glyph_id(i), "id=#{i}") }
+    88.upto(93) {|i| assert_equal(i + 5, @subsetter.subset_glyph_id(i), "id=#{i}") }
   end
 
   it "creates the subset font file" do

data/test/hexapdf/font_loader/test_from_file.rb

@@ -30,6 +30,13 @@ describe HexaPDF::FontLoader::FromFile do
     refute(wrapper.subset?)
   end
 
+  it "raises an error if the provided font does not contain TrueType outlines" do
+    font = HexaPDF::Font::TrueType::Font.new(File.open(@font_file, 'rb'))
+    font.directory.instance_variable_get(:@tables).delete('glyf')
+    exception = assert_raises(HexaPDF::Error) { @klass.call(@doc, font) }
+    assert_match(/does not contain TrueType but CFF/, exception.message)
+  end
+
   it "returns nil if the given name doesn't represent a file" do
     assert_nil(@klass.call(@doc, "Unknown"))
   end

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/task/test_import_pages.rb

@@ -0,0 +1,126 @@
+# -*- encoding: utf-8 -*-
+
+require 'test_helper'
+require 'hexapdf/document'
+require 'hexapdf/task/import_pages'
+
+describe HexaPDF::Task::ImportPages do
+  before do
+    @doc = HexaPDF::Document.new
+    @pages = [@doc.pages.add, @doc.pages.add]
+    @pages[0][:Page1] = true
+    @pages[1][:Page2] = true
+
+    @target = HexaPDF::Document.new
+  end
+
+  describe "pages argument" do
+    it "imports all pages by default" do
+      @target.task(:import_pages, source: @doc)
+      assert_equal(2, @target.pages.count)
+      assert(@target.pages[0][:Page1])
+      assert(@target.pages[1][:Page2])
+    end
+
+    it "imports the provided page objects" do
+      @target.task(:import_pages, source: @doc, pages: @pages.reverse)
+      assert_equal(2, @target.pages.count)
+      assert(@target.pages[0][:Page2])
+      assert(@target.pages[1][:Page1])
+    end
+
+    it "imports a single page" do
+      @target.task(:import_pages, source: @doc, pages: 1)
+      assert_equal(1, @target.pages.count)
+      assert(@target.pages[0][:Page2])
+    end
+
+    it "imports a page range" do
+      @target.task(:import_pages, source: @doc, pages: 0..-1)
+      assert_equal(2, @target.pages.count)
+      assert(@target.pages[0][:Page1])
+      assert(@target.pages[1][:Page2])
+    end
+
+    it "imports multiple pages" do
+      @target.task(:import_pages, source: @doc, pages: [1, 0..-1],
+                   ocgs: :ignore, acro_form: :ignore)
+      assert_equal(2, @target.pages.count)
+      assert(@target.pages[0][:Page2])
+      assert(@target.pages[1][:Page1])
+    end
+  end
+
+  it "doesn't append the pages if specified so" do
+    result = @target.task(:import_pages, source: @doc, append: false)
+    assert_equal(0, @target.pages.count)
+    assert_equal(2, result.size)
+    assert(result[0][:Page1])
+    assert(result[1][:Page2])
+  end
+
+  it "merges the AcroForm fields" do
+    form = @doc.acro_form(create: true)
+    field = form.create_text_field("Text")
+    field.create_widget(@doc.pages[0], Rect: [0, 0, 0, 0])
+    @doc.dispatch_message(:complete_objects)
+    @doc.validate
+
+    @target.task(:import_pages, source: @doc)
+    assert_equal(1, @target.acro_form.root_fields.size)
+  end
+
+  describe "ocgs argument" do
+    before do
+      @ocg1 = @doc.optional_content.ocg('OCG')
+      @ocg1.add_to_ui(path: @ocg1)
+      @ocg2 = @doc.optional_content.ocg('OCMD')
+      @ocg2.add_to_ui(path: @ocg2)
+      @ocg2.off!
+      @ocmd = @doc.optional_content.create_ocmd(@ocg2)
+    end
+
+    it "doesn't preserve unused ocgs" do
+      @target.task(:import_pages, source: @doc)
+      assert(@target.optional_content.ocgs.empty?)
+    end
+
+    it "preserves OCGs and OCMDs in content streams" do
+      canvas = @doc.pages[0].canvas
+      canvas.optional_content(@ocg1)
+      canvas.optional_content(@ocmd)
+      @target.task(:import_pages, source: @doc)
+      assert_equal(['OCG', 'OCMD'], @target.optional_content.ocgs.map(&:name))
+      assert(@target.optional_content.ocg('OCG').on?)
+      refute(@target.optional_content.ocg('OCMD').on?)
+    end
+
+    it "preserves OCGs/OCMDs associated with XObjects" do
+      canvas = @doc.pages[0].canvas
+      form = canvas.form
+      form[:OC] = @ocg1
+      canvas.xobject(form, at: [0, 0])
+      @target.task(:import_pages, source: @doc)
+      assert_equal(['OCG'], @target.optional_content.ocgs.map(&:name))
+    end
+
+    it "preserves OCGs/OCMDs associated with annotations" do
+      annot = @doc.annotations.create_line(@doc.pages[0], start_point: [0, 0], end_point: [50, 50])
+      annot[:OC] = @ocmd
+      annot.regenerate_appearance
+      @target.task(:import_pages, source: @doc)
+      assert_equal(['OCMD'], @target.optional_content.ocgs.map(&:name))
+      refute(@target.optional_content.ocg('OCMD').on?)
+    end
+
+    it "preserves the radio button group state of imported OCGs" do
+      @doc.pages[0].canvas.optional_content(@ocg1)
+      @doc.optional_content.default_configuration[:RBGroups] = [[@ocg1, @ocg2]]
+      @target.task(:import_pages, source: @doc)
+      assert_equal(['OCG'], @target.optional_content.ocgs.map {|ocg| ocg.name })
+      rb_groups = @target.optional_content.default_configuration[:RBGroups]
+      assert_equal(1, rb_groups.size)
+      assert_equal(['OCG'], rb_groups[0].map(&:name))
+    end
+  end
+end

data/test/hexapdf/test_serializer.rb

@@ -104,7 +104,7 @@ describe HexaPDF::Serializer do
 
   it "serializes strings" do
     assert_serialized("(Hallo)", "Hallo")
-    assert_serialized("(Hallo\\r\n\t\\(\\)\\\\)", "Hallo\r\n\t()\\")
+    assert_serialized("(Hallo\\r\\n\t\\(\\)\\\\)", "Hallo\r\n\t()\\")
     assert_serialized("(\xFE\xFF\x00H\x00a\x00l\x00\f\x00\b\x00\\()".b, "Hal\f\b(")
   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