hexapdf 0.42.0 → 0.44.0

data/test/hexapdf/layout/test_table_box.rb

@@ -75,7 +75,7 @@ describe HexaPDF::Layout::TableBox::Cell do
   describe "fit" do
     it "fits a single box" do
       cell = create_cell(children: HexaPDF::Layout::Box.create(width: 20, height: 10))
-      cell.fit(100, 100, @frame)
+      assert(cell.fit(100, 100, @frame).success?)
       assert_equal(100, cell.width)
       assert_equal(22, cell.height)
       assert_equal(32, cell.preferred_width)
@@ -84,7 +84,7 @@ describe HexaPDF::Layout::TableBox::Cell do
 
     it "fits a single box with horizontal aligning not being :left" do
       cell = create_cell(children: HexaPDF::Layout::Box.create(width: 20, height: 10, align: :center))
-      cell.fit(100, 100, @frame)
+      assert(cell.fit(100, 100, @frame).success?)
       assert_equal(66, cell.preferred_width)
     end
 
@@ -92,7 +92,7 @@ describe HexaPDF::Layout::TableBox::Cell do
       box1 = HexaPDF::Layout::Box.create(width: 20, height: 10)
       box2 = HexaPDF::Layout::Box.create(width: 50, height: 15)
       cell = create_cell(children: [box1, box2])
-      cell.fit(100, 100, @frame)
+      assert(cell.fit(100, 100, @frame).success?)
       assert_equal(100, cell.width)
       assert_equal(37, cell.height)
       assert_equal(62, cell.preferred_width)
@@ -103,13 +103,13 @@ describe HexaPDF::Layout::TableBox::Cell do
       box1 = HexaPDF::Layout::Box.create(width: 20, height: 10, align: :center)
       box2 = HexaPDF::Layout::Box.create(width: 50, height: 15)
       cell = create_cell(children: [box1, box2])
-      cell.fit(100, 100, @frame)
+      assert(cell.fit(100, 100, @frame).success?)
       assert_equal(66, cell.preferred_width)
     end
 
     it "fits the cell even if it has no content" do
       cell = create_cell(children: nil)
-      cell.fit(100, 100, @frame)
+      assert(cell.fit(100, 100, @frame).success?)
       assert_equal(100, cell.width)
       assert_equal(12, cell.height)
       assert_equal(12, cell.preferred_width)
@@ -118,8 +118,8 @@ describe HexaPDF::Layout::TableBox::Cell do
 
     it "doesn't fit anything if the available width or height are too small" do
       cell = create_cell(children: nil)
-      refute(cell.fit(10, 100, @frame))
-      refute(cell.fit(100, 10, @frame))
+      assert(cell.fit(10, 100, @frame).failure?)
+      assert(cell.fit(100, 10, @frame).failure?)
     end
   end
 
@@ -370,8 +370,8 @@ describe HexaPDF::Layout::TableBox do
     HexaPDF::Layout::TableBox.new(cells: [@fixed_size_boxes[0, 2], @fixed_size_boxes[2, 2]], **kwargs)
   end
 
-  def check_box(box, does_fit, width, height, cell_data = nil)
-    assert(does_fit == box.fit(@frame.available_width, @frame.available_height, @frame), "box didn't fit")
+  def check_box(box, fit_status, width, height, cell_data = nil)
+    assert_equal(fit_status, box.fit(@frame.available_width, @frame.available_height, @frame).status)
     assert_equal(width, box.width, "box width")
     assert_equal(height, box.height, "box height")
     if cell_data
@@ -431,8 +431,8 @@ describe HexaPDF::Layout::TableBox do
       footer = lambda {|_| [[nil]] }
       box = create_box(header: header, footer: footer, cells: [[nil], [nil]],
                        cell_style: {background_color: 'black'})
-      refute(box.fit(100, 40, @frame))
-      box_a, box_b = box.split(100, 40, nil)
+      assert(box.fit(100, 40, @frame).overflow?)
+      box_a, box_b = box.split
       assert_same(box_a, box)
       assert_equal('black', box_b.header_cells[0, 0].style.background_color)
       assert_equal('black', box_b.footer_cells[0, 0].style.background_color)
@@ -482,23 +482,13 @@ describe HexaPDF::Layout::TableBox do
       assert_equal(61, box.height)
     end
 
-    it "cannot fit the table if the available width smaller than the initial width" do
-      box = create_box(width: 200)
-      refute(box.fit(@frame.available_width, @frame.available_height, @frame))
-    end
-
-    it "cannot fit the table if the available height smaller than the initial height" do
-      box = create_box(height: 200)
-      refute(box.fit(@frame.available_width, @frame.available_height, @frame))
-    end
-
-    it "cannot fit the table if the specified column widths are smaller than the available width" do
+    it "cannot fit the table if the specified column widths are greater than the available width" do
       box = create_box(column_widths: [200])
-      refute(box.fit(@frame.available_width, @frame.available_height, @frame))
+      assert(box.fit(@frame.available_width, @frame.available_height, @frame).failure?)
     end
 
     it "fits a simple table" do
-      check_box(create_box, true, 160, 45,
+      check_box(create_box, :success, 160, 45,
                 [[0, 0, 79.5, 22], [79.5, 0, 79.5, 22], [0, 22, 79.5, 22], [79.5, 22, 79.5, 22]])
     end
 
@@ -507,7 +497,7 @@ describe HexaPDF::Layout::TableBox do
                [{col_span: 2, row_span: 2, content: @fixed_size_boxes[3]}, *@fixed_size_boxes[4, 2]],
                [{row_span: 2, content: @fixed_size_boxes[6]}, @fixed_size_boxes[7]],
                @fixed_size_boxes[8, 3]]
-      check_box(create_box(cells: cells), true, 160, 89,
+      check_box(create_box(cells: cells), :success, 160, 89,
                 [[0, 0, 39.75, 22], [39.75, 0, 79.5, 22], [39.75, 0, 79.50, 22], [119.25, 0, 39.75, 22],
                  [0, 22, 79.5, 44], [0, 22, 79.5, 44], [79.5, 22, 39.75, 22], [119.25, 22, 39.75, 22],
                  [0, 22, 79.5, 44], [0, 22, 79.5, 44], [79.5, 44, 39.75, 44], [119.25, 44, 39.75, 22],
@@ -518,7 +508,7 @@ describe HexaPDF::Layout::TableBox do
       result = [[0, 0, 80, 10], [80, 0, 80, 10], [0, 10, 80, 10], [80, 10, 80, 10]]
       header = lambda {|_| [@fixed_size_boxes[10, 2], @fixed_size_boxes[12, 2]] }
       box = create_box(header: header, cell_style: {padding: 0, border: {width: 0}})
-      box = check_box(box, true, 160, 40, result)
+      box = check_box(box, :success, 160, 40, result)
       assert_equal(result, cell_infos(box.header_cells))
     end
 
@@ -526,7 +516,7 @@ describe HexaPDF::Layout::TableBox do
       result = [[0, 0, 80, 10], [80, 0, 80, 10], [0, 10, 80, 10], [80, 10, 80, 10]]
       footer = lambda {|_| [@fixed_size_boxes[10, 2], @fixed_size_boxes[12, 2]] }
       box = create_box(footer: footer, cell_style: {padding: 0, border: {width: 0}})
-      box = check_box(box, true, 160, 40, result)
+      box = check_box(box, :success, 160, 40, result)
       assert_equal(result, cell_infos(box.footer_cells))
     end
 
@@ -535,14 +525,22 @@ describe HexaPDF::Layout::TableBox do
       cell_creator = lambda {|_| [@fixed_size_boxes[10, 2], @fixed_size_boxes[12, 2]] }
       box = create_box(header: cell_creator, footer: cell_creator,
                        cell_style: {padding: 0, border: {width: 0}})
-      box = check_box(box, true, 160, 60, result)
+      box = check_box(box, :success, 160, 60, result)
       assert_equal(result, cell_infos(box.header_cells))
       assert_equal(result, cell_infos(box.footer_cells))
     end
 
+    it "fails if the header or footer rows don't fit" do
+      cells_creator = lambda {|_| [@fixed_size_boxes[10, 2]] }
+      [{header: cells_creator}, {footer: cells_creator}].each do |args|
+        box = create_box(**args, cell_style: {padding: 0, border: {width: 0}})
+        assert(box.fit(100, 15, @frame).failure?)
+      end
+    end
+
     it "partially fits a table if not enough height is available" do
       box = create_box(height: 10, cell_style: {padding: 0, border: {width: 0}})
-      check_box(box, false, 160, 10,
+      check_box(box, :overflow, 160, 10,
                 [[0, 0, 80, 10], [80, 0, 80, 10], [nil, nil, 80, 0], [nil, nil, 0, 0]])
     end
   end
@@ -550,8 +548,8 @@ describe HexaPDF::Layout::TableBox do
   describe "split" do
     it "splits the table if some rows could not be fit into the available region" do
       box = create_box
-      refute(box.fit(100, 25, @frame))
-      box_a, box_b = box.split(100, 25, @frame)
+      assert(box.fit(100, 25, @frame).overflow?)
+      box_a, box_b = box.split
       assert_same(box_a, box)
       assert(box_b.split_box?)
 
@@ -567,8 +565,8 @@ describe HexaPDF::Layout::TableBox do
                [HexaPDF::Layout::Box.new(width: 20, height: 150, &@draw_block)]]
       box = create_box(cells: cells)
 
-      refute(box.fit(100, 100, @frame))
-      box_a, box_b = box.split(100, 100, @frame)
+      assert(box.fit(100, 100, @frame).overflow?)
+      box_a, box_b = box.split
       assert_same(box_a, box)
       assert(box_b.split_box?)
       assert_equal(0, box_a.start_row_index)
@@ -576,8 +574,8 @@ describe HexaPDF::Layout::TableBox do
       assert_equal(1, box_b.start_row_index)
       assert_equal(-1, box_b.last_fitted_row_index)
 
-      refute(box_b.fit(100, 100, @frame))
-      box_c, box_d = box_b.split(100, 100, @frame)
+      assert(box_b.fit(100, 100, @frame).failure?)
+      box_c, box_d = box_b.split
       assert_nil(box_c)
       assert_same(box_d, box_b)
       assert(box_d.split_box?)
@@ -585,24 +583,12 @@ describe HexaPDF::Layout::TableBox do
       assert_equal(-1, box_d.last_fitted_row_index)
     end
 
-    it "splits the table if the header or footer rows don't fit" do
-      cells_creator = lambda {|_| [@fixed_size_boxes[10, 2]] }
-      [{header: cells_creator}, {footer: cells_creator}].each do |args|
-        box = create_box(**args)
-        box.cells.style(padding: 0, border: {width: 0})
-        refute(box.fit(100, 25, @frame))
-        box_a, box_b = box.split(100, 25, @frame)
-        assert_nil(box_a)
-        assert_same(box_b, box)
-      end
-    end
-
     it "splits a table with a header or a footer" do
       cells_creator = lambda {|_| [@fixed_size_boxes[10, 2]] }
       [{header: cells_creator}, {footer: cells_creator}].each do |args|
         box = create_box(**args)
-        refute(box.fit(100, 50, @frame))
-        box_a, box_b = box.split(100, 50, @frame)
+        assert(box.fit(100, 50, @frame).overflow?)
+        box_a, box_b = box.split
         assert_same(box_a, box)
 
         assert_equal(0, box_a.start_row_index)
@@ -681,9 +667,9 @@ describe HexaPDF::Layout::TableBox do
 
     it "correctly works for split boxes" do
       box = create_box(cell_style: {padding: 0, border: {width: 0}})
-      refute(box.fit(100, 10, @frame))
-      _, split_box = box.split(100, 10, @frame)
-      assert(split_box.fit(100, 100, @frame))
+      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)
@@ -714,7 +700,7 @@ describe HexaPDF::Layout::TableBox do
       box = create_box(header: lambda {|_| [@fixed_size_boxes[10, 1]] },
                        footer: lambda {|_| [@fixed_size_boxes[12, 1]] },
                        cell_style: {padding: 0, border: {width: 0}})
-      box.fit(100, 100, @frame)
+      assert(box.fit(100, 100, @frame).success?)
       box.draw(@canvas, 20, 10)
       operators = [[:save_graphics_state],
                    [:concatenate_matrix, [1, 0, 0, 1, 20, 40]],

data/test/hexapdf/layout/test_text_box.rb

@@ -36,29 +36,31 @@ describe HexaPDF::Layout::TextBox do
   describe "fit" do
     it "fits into a rectangular area" do
       box = create_box([@inline_box] * 5, style: {padding: 10})
-      assert(box.fit(100, 100, @frame))
+      assert(box.fit(100, 100, @frame).success?)
       assert_equal(70, box.width)
       assert_equal(30, box.height)
     end
 
     it "respects the set width and height" do
       box = create_box([@inline_box], width: 40, height: 50, style: {padding: 10})
-      assert(box.fit(100, 100, @frame))
+      assert(box.fit(100, 100, @frame).success?)
       assert_equal(40, box.width)
       assert_equal(50, box.height)
       assert_equal([10], box.instance_variable_get(:@result).lines.map(&:width))
     end
 
     it "fits into the frame's outline" do
+      @frame.remove_area(Geom2D::Rectangle(0, 80, 20, 20))
+      @frame.remove_area(Geom2D::Rectangle(80, 70, 20, 20))
       box = create_box([@inline_box] * 20, style: {position: :flow})
-      assert(box.fit(100, 100, @frame))
+      assert(box.fit(100, 100, @frame).success?)
       assert_equal(100, box.width)
-      assert_equal(20, box.height)
+      assert_equal(30, box.height)
     end
 
     it "takes the style option last_line_gap into account" do
       box = create_box([@inline_box] * 5, style: {last_line_gap: true, line_spacing: :double})
-      assert(box.fit(100, 100, @frame))
+      assert(box.fit(100, 100, @frame).success?)
       assert_equal(50, box.width)
       assert_equal(20, box.height)
     end
@@ -66,7 +68,7 @@ describe HexaPDF::Layout::TextBox do
     it "uses the whole available width when aligning to the center or right" do
       [:center, :right].each do |align|
         box = create_box([@inline_box], style: {text_align: align})
-        assert(box.fit(100, 100, @frame))
+        assert(box.fit(100, 100, @frame).success?)
         assert_equal(100, box.width)
       end
     end
@@ -74,91 +76,62 @@ describe HexaPDF::Layout::TextBox do
     it "uses the whole available height when vertically aligning to the center or bottom" do
       [:center, :bottom].each do |valign|
         box = create_box([@inline_box], style: {text_valign: valign})
-        assert(box.fit(100, 100, @frame))
+        assert(box.fit(100, 100, @frame).success?)
         assert_equal(100, box.height)
       end
     end
 
-    it "respects the style property overflow when fitting too much text" do
+    it "can fit part of the box" do
       box = create_box([@inline_box] * 20, height: 15)
-      refute(box.fit(100, 100, @frame))
-      box.style.overflow = :truncate
-      assert(box.fit(100, 100, @frame))
-
-      box = create_box([@inline_box] * 20, style: {overflow: :truncate})
-      refute(box.fit(100, 15, @frame))
+      assert(box.fit(100, 100, @frame).overflow?)
     end
 
-    it "can't fit the text box if the set width is bigger than the available width" do
-      box = create_box([@inline_box], width: 101)
-      refute(box.fit(100, 100, @frame))
-    end
-
-    it "can't fit the text box if the set height is bigger than the available height" do
-      box = create_box([@inline_box], height: 101)
-      refute(box.fit(100, 100, @frame))
+    it "correctly handles text indentation for split boxes" do
+      [{}, {position: :flow}].each do |styles|
+        box = create_box([@inline_box] * 202, style: {text_indent: 50, **styles})
+        assert(box.fit(100, 100, @frame).overflow?)
+        _, box_b = box.split
+        assert_equal(107, box_b.instance_variable_get(:@items).length)
+        assert(box_b.fit(100, 100, @frame).overflow?)
+        _, box_b = box_b.split
+        assert_equal(7, box_b.instance_variable_get(:@items).length)
+      end
     end
-  end
 
-  describe "split" do
-    it "works for an empty text box" do
+    it "fits an empty text box" do
       box = create_box([])
-      assert_equal([box], box.split(100, 100, @frame))
+      assert(box.fit(100, 100, @frame).success?)
     end
 
-    it "doesn't need to split the box if it completely fits" do
-      box = create_box([@inline_box] * 5)
-      assert_equal([box], box.split(50, 100, @frame))
-    end
-
-    it "works if no item of the text box fits" do
+    it "fails if no item of the text box fits due to the width" do
       box = create_box([@inline_box])
-      assert_equal([nil, box], box.split(5, 20, @frame))
-    end
-
-    it "works if the whole text box doesn't fits" do
-      box = create_box([@inline_box], width: 102)
-      assert_equal([nil, box], box.split(100, 100, @frame))
-
-      box = create_box([@inline_box], height: 102)
-      assert_equal([nil, box], box.split(100, 100, @frame))
+      assert(box.fit(5, 20, @frame).failure?)
     end
 
-    it "works if the box fits exactly (+/- float divergence)" do
-      box = create_box([@inline_box] * 5)
-      box.fit(50, 10, @frame)
-      box.instance_variable_set(:@width, 50.00000000006)
-      box.instance_variable_set(:@height, 10.00000000003)
-      assert_equal([box], box.split(50, 10, @frame))
+    it "fails if no item of the text box fits due to the height" do
+      box = create_box([@inline_box])
+      assert(box.fit(20, 5, @frame).failure?)
     end
+  end
 
+  describe "split" do
     it "splits the box if necessary when using non-flowing text" do
       box = create_box([@inline_box] * 10)
-      boxes = box.split(50, 10, @frame)
-      assert_equal(2, boxes.length)
-      assert_equal(box, boxes[0])
-      refute(boxes[0].split_box?)
-      assert(boxes[1].split_box?)
-      assert_equal(5, boxes[1].instance_variable_get(:@items).length)
+      box.fit(50, 10, @frame)
+      box_a, box_b = box.split
+      assert_same(box, box_a)
+      refute(box_a.split_box?)
+      assert(box_b.split_box?)
+      assert_equal(5, box_b.instance_variable_get(:@items).length)
     end
 
     it "splits the box if necessary when using flowing text that results in a wider box" do
       @frame.remove_area(Geom2D::Polygon.new([[0, 100], [50, 100], [50, 10], [0, 10]]))
       box = create_box([@inline_box] * 60, style: {position: :flow})
-      boxes = box.split(50, 100, @frame)
-      assert_equal(2, boxes.length)
-      assert_equal(box, boxes[0])
-      assert_equal(5, boxes[1].instance_variable_get(:@items).length)
-    end
-
-    it "correctly handles text indentation for split boxes" do
-      [{}, {position: :flow}].each do |styles|
-        box = create_box([@inline_box] * 202, style: {text_indent: 50, **styles})
-        boxes = box.split(100, 100, @frame)
-        assert_equal(107, boxes[1].instance_variable_get(:@items).length)
-        boxes = boxes[1].split(100, 100, @frame)
-        assert_equal(7, boxes[1].instance_variable_get(:@items).length)
-      end
+      box.fit(50, 100, @frame)
+      box_a, box_b = box.split
+      assert_same(box, box_a)
+      assert_equal(5, box_b.instance_variable_get(:@items).length)
     end
   end
 
@@ -190,8 +163,33 @@ describe HexaPDF::Layout::TextBox do
                                           [:restore_graphics_state]])
     end
 
+    it "correctly draws borders, backgrounds... for position :flow" do
+      @frame.remove_area(Geom2D::Rectangle(0, 0, 40, 100))
+      box = create_box([@inline_box], style: {position: :flow, border: {width: 1}})
+      box.fit(60, 100, @frame)
+      box.draw(@canvas, 0, 90)
+      assert_operators(@canvas.contents, [[:save_graphics_state],
+                                          [:append_rectangle, [40, 90, 10, 10]],
+                                          [:clip_path_non_zero],
+                                          [:end_path],
+                                          [:append_rectangle, [40.5, 90.5, 9.0, 9.0]],
+                                          [:stroke_path],
+                                          [:restore_graphics_state],
+                                          [:save_graphics_state],
+                                          [:restore_graphics_state],
+                                          [:save_graphics_state],
+                                          [:concatenate_matrix, [1, 0, 0, 1, 41, 89]],
+                                          [:save_graphics_state],
+                                          [:concatenate_matrix, [1, 0, 0, 1, 0, 0]],
+                                          [:restore_graphics_state],
+                                          [:restore_graphics_state],
+                                          [:save_graphics_state],
+                                          [:restore_graphics_state]])
+    end
+
     it "draws nothing onto the canvas if the box is empty" do
       box = create_box([])
+      box.fit(100, 100, @frame)
       box.draw(@canvas, 5, 5)
       assert_operators(@canvas.contents, [])
     end

data/test/hexapdf/test_composer.rb

@@ -263,6 +263,12 @@ describe HexaPDF::Composer do
                         [:restore_graphics_state]])
     end
 
+    it "handles truncated boxes correctly" do
+      box = create_box(height: 400, style: {overflow: :truncate})
+      box.define_singleton_method(:fit_content) {|*| fit_result.overflow! }
+      assert_same(box, @composer.draw_box(box))
+    end
+
     it "returns the last drawn box" do
       box = create_box(height: 400)
       assert_same(box, @composer.draw_box(box))

data/test/hexapdf/test_dictionary.rb

@@ -323,11 +323,13 @@ describe HexaPDF::Dictionary do
     end
   end
 
-  describe "to_h" do
-    it "returns a shallow copy of the value" do
-      obj = @dict.to_h
+  describe "to_hash" do
+    it "returns a copy of the value where each entry is pre-processed" do
+      @dict[:value] = HexaPDF::Reference.new(1, 0)
+      obj = @dict.to_hash
       refute_equal(obj.object_id, @dict.value.object_id)
-      assert_equal(obj, @dict.value)
+      assert_equal(:obj, obj[:Object])
+      assert_equal("deref", obj[:value])
     end
   end
 

data/test/hexapdf/test_parser.rb

@@ -358,6 +358,14 @@ describe HexaPDF::Parser do
     it "finds the startxref anywhere in file" do
       create_parser("startxref\n5\n%%EOF" << "\nhallo" * 5000)
       assert_equal(5, @parser.startxref_offset)
+    end
+
+    it "handles the case where %%EOF is the on the 1. line of the 1024 byte search block" do
+      create_parser("startxref\n5\n%%EOF\n" << "h" * 1018)
+      assert_equal(5, @parser.startxref_offset)
+    end
+
+    it "handles the case where %%EOF is the on the 2. line of the 1024 byte search block" do
       create_parser("startxref\n5\n%%EOF\n" << "h" * 1017)
       assert_equal(5, @parser.startxref_offset)
     end
@@ -367,6 +375,11 @@ describe HexaPDF::Parser do
       assert_equal(5, @parser.startxref_offset)
     end
 
+    it "handles the case of multiple %%EOF and the last one being invalid" do
+      create_parser("startxref\n5\n%%EOF\ntartxref\n3\n%%EOF")
+      assert_equal(5, @parser.startxref_offset)
+    end
+
     it "fails even in big files when nothing is found" do
       create_parser("\nhallo" * 5000)
       exp = assert_raises(HexaPDF::MalformedPDFError) { @parser.startxref_offset }
@@ -402,6 +415,13 @@ describe HexaPDF::Parser do
       exp = assert_raises(HexaPDF::MalformedPDFError) { @parser.startxref_offset }
       assert_match(/startxref on same line/, exp.message)
     end
+
+    it "fails on strict parsing if there are multiple %%EOF and the last one is invalid" do
+      @document.config['parser.on_correctable_error'] = proc { true }
+      create_parser("startxref\n5\n%%EOF\ntartxref\n3\n%%EOF")
+      exp = assert_raises(HexaPDF::MalformedPDFError) { @parser.startxref_offset }
+      assert_match(/missing startxref keyword/, exp.message)
+    end
   end
 
   describe "file_header_version" do

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

@@ -128,6 +128,12 @@ describe HexaPDF::Type::AcroForm::Form do
       @acro_form = @doc.acro_form(create: true)
     end
 
+    it "creates a pure namespace field" do
+      field = @acro_form.create_namespace_field('text')
+      assert_equal('text', field.full_field_name)
+      assert_nil(field.concrete_field_type)
+    end
+
     describe "handles the general case" do
       it "works for names with a dot" do
         @acro_form[:Fields] = [{T: "root"}]
@@ -142,8 +148,13 @@ describe HexaPDF::Type::AcroForm::Form do
         assert([field], @acro_form[:Fields])
       end
 
-      it "fails if the parent field is not found" do
-        assert_raises(HexaPDF::Error) { @acro_form.create_text_field("root.field") }
+      it "creates the parent fields as namespace fields if necessary" do
+        field = @acro_form.create_text_field("root.sub.field")
+        level1 = @acro_form.field_by_name('root')
+        assert_equal(1, level1[:Kids].size)
+        level2 = @acro_form.field_by_name('root.sub')
+        assert_equal(1, level2[:Kids].size)
+        assert_same(field, level2[:Kids][0])
       end
     end
 
@@ -241,6 +252,56 @@ describe HexaPDF::Type::AcroForm::Form do
     end
   end
 
+  describe "delete_field" do
+    before do
+      @field = @acro_form.create_signature_field("sig")
+    end
+
+    it "deletes a field via name" do
+      @acro_form.delete_field('sig')
+      assert_equal(0, @acro_form.root_fields.size)
+    end
+
+    it "deletes a field via field object" do
+      @acro_form.delete_field(@field)
+      assert_equal(0, @acro_form.root_fields.size)
+    end
+
+    it "deletes the set signature object" do
+      obj = @doc.add({})
+      @field.field_value = obj
+      @acro_form.delete_field(@field)
+      assert(obj.null?)
+    end
+
+    it "deletes all widget annotations from the document and the annotation array" do
+      widget1 = @field.create_widget(@doc.pages.add, Rect: [0, 0, 0, 0])
+      widget2 = @field.create_widget(@doc.pages.add, Rect: [0, 0, 0, 0])
+      refute(@doc.pages[1][:Annots].empty?)
+      @acro_form.delete_field(@field)
+      assert(@doc.pages[0][:Annots].empty?)
+      assert(@doc.pages[1][:Annots].empty?)
+      assert(@doc.object(widget1).null?)
+      assert(@doc.object(widget2).null?)
+    end
+
+    it "deletes the field from the field hierarchy" do
+      @acro_form.delete_field('sig')
+      refute(@acro_form.field_by_name('sig'))
+      assert(@acro_form[:Fields].empty?)
+
+      @acro_form.create_signature_field("sub.sub.sig")
+      @acro_form.delete_field("sub.sub.sig")
+      refute(@acro_form.field_by_name('sub.sub.sig'))
+      assert(@acro_form[:Fields][0][:Kids][0][:Kids].empty?)
+    end
+
+    it "deletes the field itself" do
+      @acro_form.delete_field('sig')
+      assert(@doc.object(@field).null?)
+    end
+  end
+
   describe "fill" do
     it "works for text field types" do
       field = @acro_form.create_text_field('test')

data/test/hexapdf/type/test_file_specification.rb

@@ -97,10 +97,11 @@ describe HexaPDF::Type::FileSpecification do
     end
 
     it "embeds the given file and registers it with the global name registry" do
-      stream = @obj.embed(@file.path)
+      stream = @obj.embed(@file.path, mime_type: 'application/xml')
       assert_equal(stream, @obj[:EF][:UF])
       assert_equal(stream, @obj[:EF][:F])
       assert_equal(File.basename(@file.path), @obj.path)
+      assert_equal(:'application/xml', stream[:Subtype])
       assert_equal(@obj, @doc.catalog[:Names][:EmbeddedFiles].find_entry(@obj.path))
       assert_equal(:FlateDecode, stream[:Filter])
       assert_equal('embed-test', stream.stream)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: hexapdf
 version: !ruby/object:Gem::Version
-  version: 0.42.0
+  version: 0.44.0
 platform: ruby
 authors:
 - Thomas Leitner
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-05-12 00:00:00.000000000 Z
+date: 2024-06-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: cmdparse