hexapdf 0.43.0 → 0.45.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,23 +103,30 @@ 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)
       assert_equal(12, cell.preferred_height)
     end
 
-    it "doesn't fit anything if the available width or height are too small" do
+    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?)
+      cell = create_cell(children: [HexaPDF::Layout::Box.create(width: 300, height: 20)])
+      assert(cell.fit(100, 100, @frame).failure?)
+    end
+
+    it "doesn't fit anything if the available width or height are too small even if there are no children" 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 +377,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 +438,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 +489,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 +504,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 +515,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 +523,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 +532,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 +555,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 +572,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 +581,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 +590,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 +674,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 +707,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,39 +36,40 @@ 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_equal(40, box.width)
+      box = create_box([@inline_box] * 5, width: 44, height: 50,
+                       style: {padding: 10, text_align: :right, text_valign: :bottom})
+      assert(box.fit(100, 100, @frame).success?)
+      assert_equal(44, box.width)
       assert_equal(50, box.height)
-      assert_equal([10], box.instance_variable_get(:@result).lines.map(&:width))
+      assert_equal([20, 20, 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_equal(100, box.width)
-      assert_equal(30, box.height)
-    end
+    describe "style option last_line_gap" do
+      it "is taken into account" do
+        box = create_box([@inline_box] * 5, style: {last_line_gap: true, line_spacing: :double})
+        assert(box.fit(100, 100, @frame).success?)
+        assert_equal(50, box.width)
+        assert_equal(20, 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_equal(50, box.width)
-      assert_equal(20, box.height)
+      it "will have no effect for fixed-height boxes" do
+        box = create_box([@inline_box] * 5, height: 40, style: {last_line_gap: true, line_spacing: :double})
+        assert(box.fit(100, 100, @frame).success?)
+        assert_equal(50, box.width)
+        assert_equal(40, box.height)
+      end
     end
 
-    it "uses the whole available width when aligning to the center or right" do
-      [:center, :right].each do |align|
+    it "uses the whole available width when aligning to the center, right or justified" do
+      [:center, :right, :justify].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
@@ -76,91 +77,89 @@ 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))
-    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))
+      assert(box.fit(100, 100, @frame).overflow?)
     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
+    describe "position :flow" do
+      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).success?)
+        assert_equal(100, box.width)
+        assert_equal(30, box.height)
+      end
 
-    it "works if no item of the text box fits" do
-      box = create_box([@inline_box])
-      assert_equal([nil, box], box.split(5, 20, @frame))
-    end
+      it "respects a set initial height" do
+        box = create_box([@inline_box] * 20, height: 13, style: {position: :flow})
+        assert(box.fit(100, 100, @frame).overflow?)
+        assert_equal(100, box.width)
+        assert_equal(13, box.height)
+      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))
+      it "respects top/bottom padding/border" do
+        @frame.remove_area(Geom2D::Rectangle(0, 80, 20, 20))
+        box = create_box([@inline_box] * 20, style: {position: :flow, padding: 10, border: {width: 2}})
+        assert(box.fit(100, 100, @frame).success?)
+        assert_equal(124, box.width)
+        assert_equal(54, box.height)
+        assert_equal([80, 100, 20], box.instance_variable_get(:@result).lines.map(&:width))
+      end
+    end
 
-      box = create_box([@inline_box], height: 102)
-      assert_equal([nil, box], box.split(100, 100, @frame))
+    it "fails if no item of the text box fits due to the width" do
+      box = create_box([@inline_box])
+      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
 
@@ -196,12 +195,12 @@ describe HexaPDF::Layout::TextBox 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)
+      box.draw(@canvas, 0, 88)
       assert_operators(@canvas.contents, [[:save_graphics_state],
-                                          [:append_rectangle, [40, 90, 10, 10]],
+                                          [:append_rectangle, [40, 88, 12, 12]],
                                           [:clip_path_non_zero],
                                           [:end_path],
-                                          [:append_rectangle, [40.5, 90.5, 9.0, 9.0]],
+                                          [:append_rectangle, [40.5, 88.5, 11.0, 11.0]],
                                           [:stroke_path],
                                           [:restore_graphics_state],
                                           [:save_graphics_state],
@@ -218,6 +217,7 @@ describe HexaPDF::Layout::TextBox do
 
     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

@@ -119,6 +119,13 @@ describe HexaPDF::Composer do
     end
   end
 
+  describe "styles" do
+    it "delegates to layout.styles" do
+      @composer.styles(base: {font_size: 30}, other: {font_size: 40})
+      assert_equal([:base, :other], @composer.document.layout.styles.keys)
+    end
+  end
+
   describe "page_style" do
     it "returns the page style if no argument or block is given" do
       page_style = @composer.page_style(:default)
@@ -225,8 +232,9 @@ describe HexaPDF::Composer do
       first_page_contents = @composer.canvas.contents
       @composer.draw_box(create_box(height: 400))
 
-      box = create_box(height: 400)
-      box.define_singleton_method(:split) do |*|
+      box = create_box
+      box.define_singleton_method(:fit_content) {|*| fit_result.overflow! }
+      box.define_singleton_method(:split_content) do |*|
         [box, HexaPDF::Layout::Box.new(height: 100) {}]
       end
       @composer.draw_box(box)
@@ -235,7 +243,7 @@ describe HexaPDF::Composer do
                         [:concatenate_matrix, [1, 0, 0, 1, 36, 405.889764]],
                         [:restore_graphics_state],
                         [:save_graphics_state],
-                        [:concatenate_matrix, [1, 0, 0, 1, 36, 5.889764]],
+                        [:concatenate_matrix, [1, 0, 0, 1, 36, 36]],
                         [:restore_graphics_state]])
       assert_operators(@composer.canvas.contents,
                        [[:save_graphics_state],
@@ -263,13 +271,20 @@ 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))
 
-      box = create_box(height: 400)
       split_box = create_box(height: 100)
-      box.define_singleton_method(:split) {|*| [box, split_box] }
+      box = create_box
+      box.define_singleton_method(:fit_content) {|*| fit_result.overflow! }
+      box.define_singleton_method(:split_content) {|*| [box, split_box] }
       assert_same(split_box, @composer.draw_box(box))
     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

data/test/hexapdf/test_serializer.rb

@@ -89,6 +89,7 @@ describe HexaPDF::Serializer do
     assert_serialized('/ ', :"")
     assert_serialized('/H#c3#b6#c3#9fgang', :Hößgang)
     assert_serialized('/H#e8lp', "H\xE8lp".force_encoding('BINARY').intern)
+    assert_serialized('/#00#09#0a#0c#0d#20', :"\x00\t\n\f\r ")
   end
 
   it "serializes arrays" do

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.43.0
+  version: 0.45.0
 platform: ruby
 authors:
 - Thomas Leitner
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-05-26 00:00:00.000000000 Z
+date: 2024-06-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: cmdparse