hexapdf 0.44.0 → 0.46.0

data/test/hexapdf/layout/test_list_box.rb

@@ -65,13 +65,13 @@ describe HexaPDF::Layout::ListBox do
   describe "fit" do
     [:default, :flow].each do |position|
       it "respects the set initial width, position #{position}" do
-        box = create_box(children: @text_boxes[0, 2], width: 50, style: {position: position})
-        check_box(box, 50, 80)
+        box = create_box(children: @text_boxes[0, 2], width: 55, style: {position: position})
+        check_box(box, 55, 80)
       end
 
       it "respects the set initial height, position #{position}" do
-        box = create_box(children: @text_boxes[0, 2], height: 50, style: {position: position})
-        check_box(box, 100, 40)
+        box = create_box(children: @text_boxes[0, 2], height: 55, style: {position: position})
+        check_box(box, 100, 55)
       end
 
       it "respects the set initial height even when it doesn't fit completely" do
@@ -123,7 +123,7 @@ describe HexaPDF::Layout::ListBox do
 
     it "fails if not even a part of the first list item fits" do
       box = create_box(children: @text_boxes[0, 2], height: 5)
-      check_box(box, 100, 0, status: :failure)
+      check_box(box, 100, 5, status: :failure)
     end
 
     it "fails for unknown marker types" do
@@ -134,13 +134,13 @@ describe HexaPDF::Layout::ListBox do
 
   describe "split" do
     it "splits before a list item if no part of it will fit" do
-      box = create_box(children: @text_boxes[0, 2])
-      assert(box.fit(100, 20, @frame).overflow?)
+      box = create_box(children: @text_boxes[0, 3])
+      assert(box.fit(100, 22, @frame).overflow?)
       box_a, box_b = box.split
       assert_same(box, box_a)
       assert_equal(:show_first_marker, box_b.split_box?)
       assert_equal(1, box_a.instance_variable_get(:@results)[0].box_fitter.fit_results.size)
-      assert_equal(1, box_b.children.size)
+      assert_equal(2, box_b.children.size)
       assert_equal(2, box_b.start_number)
     end
 

data/test/hexapdf/layout/test_page_style.rb

@@ -44,8 +44,13 @@ describe HexaPDF::Layout::PageStyle do
 
     it "works when no template is set" do
       style = HexaPDF::Layout::PageStyle.new
-      page = style.create_page(@doc)
-      assert_equal("", page.contents)
+      page1 = style.create_page(@doc)
+      frame1 = style.frame
+      assert_equal("", page1.contents)
+      assert_equal(523.275591, style.frame.width)
+
+      page2 = style.create_page(@doc)
+      refute_same(frame1, style.frame)
     end
 
     it "creates a default frame if none is set beforehand or during template execution" do

data/test/hexapdf/layout/test_table_box.rb

@@ -116,7 +116,14 @@ describe HexaPDF::Layout::TableBox::Cell do
       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)
       assert(cell.fit(10, 100, @frame).failure?)
       assert(cell.fit(100, 10, @frame).failure?)

data/test/hexapdf/layout/test_text_box.rb

@@ -42,31 +42,32 @@ describe HexaPDF::Layout::TextBox do
     end
 
     it "respects the set width and height" do
-      box = create_box([@inline_box], width: 40, height: 50, style: {padding: 10})
+      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(40, box.width)
+      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).success?)
-      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).success?)
-      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).success?)
         assert_equal(100, box.width)
@@ -103,6 +104,33 @@ describe HexaPDF::Layout::TextBox do
       assert(box.fit(100, 100, @frame).success?)
     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 "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 "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
+
     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?)
@@ -150,15 +178,12 @@ describe HexaPDF::Layout::TextBox do
       assert_operators(@canvas.contents, [[:save_graphics_state],
                                           [:restore_graphics_state],
                                           [:save_graphics_state],
-                                          [:concatenate_matrix, [1, 0, 0, 1, 5, 10]],
-                                          [:save_graphics_state],
-                                          [:append_rectangle, [0, 0, 10, 10]],
+                                          [:append_rectangle, [5, 10, 10, 10]],
                                           [:clip_path_non_zero],
                                           [:end_path],
-                                          [:append_rectangle, [0.5, 0.5, 9.0, 9.0]],
+                                          [:append_rectangle, [5.5, 10.5, 9.0, 9.0]],
                                           [:stroke_path],
                                           [:restore_graphics_state],
-                                          [:restore_graphics_state],
                                           [:save_graphics_state],
                                           [:restore_graphics_state]])
     end
@@ -167,21 +192,18 @@ 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, 40, 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],
                                           [: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]])

data/test/hexapdf/layout/test_text_layouter.rb

@@ -812,11 +812,8 @@ describe HexaPDF::Layout::TextLayouter do
                                           [:restore_graphics_state],
                                           [:save_graphics_state],
                                           [:concatenate_matrix, [1, 0, 0, 1, 10, -40]],
-                                          [:save_graphics_state],
-                                          [:concatenate_matrix, [1, 0, 0, 1, 0, 0]],
                                           [:set_line_width, [2]],
                                           [:restore_graphics_state],
-                                          [:restore_graphics_state],
                                           [:save_graphics_state],
                                           [:restore_graphics_state]])
     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],
@@ -273,9 +281,10 @@ describe HexaPDF::Composer 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_document.rb

@@ -568,4 +568,31 @@ describe HexaPDF::Document do
   it "can be inspected and the output is not too large" do
     assert_match(/HexaPDF::Document:\d+/, @doc.inspect)
   end
+
+  describe "duplicate" do
+    it "creates an in-memory copy" do
+      doc = HexaPDF::Document.new
+      doc.pages.add.canvas.line_width(10)
+      doc.trailer.info[:Author] = 'HexaPDF'
+      doc.dispatch_message(:complete_objects)
+
+      dupped = doc.duplicate
+      assert_equal('HexaPDF', dupped.trailer.info[:Author])
+      doc.pages[0].canvas.line_cap_style(:round)
+      assert_equal("10 w\n", dupped.pages[0].contents)
+    end
+
+    it "doesn't copy the encryption state" do
+      doc = HexaPDF::Document.new
+      doc.pages.add.canvas.line_width(10)
+      doc.encrypt
+      io = StringIO.new
+      doc.write(io)
+
+      doc = HexaPDF::Document.new(io: io)
+      dupped = doc.duplicate
+      assert_equal("10 w\n", dupped.pages[0].contents)
+      refute(dupped.encrypted?)
+    end
+  end
 end

data/test/hexapdf/test_importer.rb

@@ -47,6 +47,13 @@ describe HexaPDF::Importer do
       refute_same(obj1, obj2)
       refute_same(obj1[:ref], obj2[:ref])
     end
+
+    it "duplicates the whole document" do
+      trailer = HexaPDF::Importer.copy(@dest, @source.trailer, allow_all: true)
+      refute_same(@source.catalog, trailer[:Root])
+      refute_same(@source.pages.root, trailer[:Root][:Pages])
+      assert_equal(90, trailer[:Root][:Pages][:Kids][0][:Rotate])
+    end
   end
 
   describe "import" do
@@ -121,6 +128,16 @@ describe HexaPDF::Importer do
       refute_same(dst_obj.data.stream, src_obj.data.stream)
     end
 
+    it "duplicates the stream if it is a FiberDoubleForString, e.g. when using Canvas" do
+      src_page = @source.pages[0]
+      src_page.canvas.line_width(10)
+      dst_page = @importer.import(src_page)
+      refute_same(dst_page, src_page)
+      refute_same(dst_page[:Contents].data.stream, src_page[:Contents].data.stream)
+      src_page.canvas.line_width(20)
+      assert_equal("10 w\n", dst_page.contents)
+    end
+
     it "does not import objects of type Catalog or Pages" do
       @obj[:catalog] = @source.catalog
       @obj[:pages] = @source.catalog.pages

data/test/hexapdf/test_revisions.rb

@@ -357,46 +357,59 @@ describe HexaPDF::Revisions do
     end
   end
 
-  it "merges the two revisions of a linearized PDF into one" do
-    io = StringIO.new(<<~EOF)
-      %PDF-1.2
-      5 0 obj
-      <</Linearized 1>>
-      endobj
-      xref
-      5 1
-      0000000009 00000 n
-      trailer
-      <</ID[(a)(b)]/Info 1 0 R/Root 2 0 R/Size 6/Prev 394>>
-      %
-      1 0 obj
-      <</ModDate(D:20221205233910+01'00')/Producer(HexaPDF version 0.27.0)>>
-      endobj
-      2 0 obj
-      <</Type/Catalog/Pages 3 0 R>>
-      endobj
-      3 0 obj
-      <</Type/Pages/Kids[4 0 R]/Count 1>>
-      endobj
-      4 0 obj
-      <</Type/Page/MediaBox[0 0 595 842]/Parent 3 0 R/Resources<<>>>>
-      endobj
-      xref
-      0 5
-      0000000000 65535 f 
-      0000000133 00000 n 
-      0000000219 00000 n 
-      0000000264 00000 n 
-      0000000315 00000 n 
-      trailer
-      <</ID[(a)(b)]/Info 1 0 R/Root 2 0 R/Size 5>>
-      startxref
-      41
-      %%EOF
-    EOF
-    doc = HexaPDF::Document.new(io: io, config: {'parser.try_xref_reconstruction' => false})
-    assert(doc.revisions.parser.linearized?)
-    assert_equal(1, doc.revisions.count)
-    assert_same(5, doc.revisions.current.xref_section.max_oid)
+  describe "linearzied PDFs" do
+    before  do
+      @io = StringIO.new(<<~EOF)
+        %PDF-1.2
+        5 0 obj
+        <</Linearized 1>>
+        endobj
+        xref
+        5 1
+        0000000009 00000 n
+        trailer
+        <</ID[(a)(b)]/Info 1 0 R/Root 2 0 R/Size 6/Prev 394>>
+        %
+        1 0 obj
+        <</ModDate(D:20221205233910+01'00')/Producer(HexaPDF version 0.27.0)>>
+        endobj
+        2 0 obj
+        <</Type/Catalog/Pages 3 0 R>>
+        endobj
+        3 0 obj
+        <</Type/Pages/Kids[4 0 R]/Count 1>>
+        endobj
+        4 0 obj
+        <</Type/Page/MediaBox[0 0 595 842]/Parent 3 0 R/Resources<<>>>>
+        endobj
+        xref
+        0 5
+        0000000000 65535 f 
+        0000000133 00000 n 
+        0000000219 00000 n 
+        0000000264 00000 n 
+        0000000315 00000 n 
+        trailer
+        <</ID[(a)(b)]/Info 1 0 R/Root 2 0 R/Size 5>>
+        startxref
+        41
+        %%EOF
+      EOF
+    end
+
+    it "merges the two revisions of a linearized PDF into one" do
+      doc = HexaPDF::Document.new(io: @io, config: {'parser.try_xref_reconstruction' => false})
+      assert(doc.revisions.parser.linearized?)
+      assert_equal(1, doc.revisions.count)
+      assert_same(5, doc.revisions.current.xref_section.max_oid)
+    end
+
+    it "works for a fake linearized PDF where the first xref section isn't actually used" do
+      @io.string[-9..-1] = "394\n%%EOF\n"
+      doc = HexaPDF::Document.new(io: @io, config: {'parser.try_xref_reconstruction' => false})
+      assert(doc.revisions.parser.linearized?)
+      assert_equal(1, doc.revisions.count)
+      assert_same(4, doc.revisions.current.xref_section.max_oid)
+    end
   end
 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/acro_form/test_form.rb

@@ -274,6 +274,15 @@ describe HexaPDF::Type::AcroForm::Form do
       assert(obj.null?)
     end
 
+    it "deletes a field with an embedded widget annotation" do
+      widget = @field.create_widget(@doc.pages.add, Rect: [0, 0, 0, 0])
+      assert_equal(widget, @field)
+      refute(@doc.pages[0][:Annots].empty?)
+      @acro_form.delete_field(@field)
+      assert(@doc.pages[0][:Annots].empty?)
+      assert(@field.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])

metadata

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