hexapdf 0.42.0 → 0.44.0

data/test/hexapdf/layout/test_box.rb

@@ -4,6 +4,37 @@ require 'test_helper'
 require 'hexapdf/document'
 require 'hexapdf/layout/box'
 
+describe HexaPDF::Layout::Box::FitResult do
+  it "shows the box's mask area on #draw when using debug output" do
+    doc = HexaPDF::Document.new(config: {'debug' => true})
+    canvas = doc.pages.add.canvas
+    box = HexaPDF::Layout::Box.create(width: 20, height: 20) {}
+    frame = HexaPDF::Layout::Frame.new(5, 10, 100, 150)
+    result = HexaPDF::Layout::Box::FitResult.new(box, frame: frame)
+    result.mask = Geom2D::Rectangle(0, 0, 20, 20)
+    result.x = result.y = 0
+    result.draw(canvas, dx: 10, dy: 15)
+    assert_equal(<<~CONTENTS, canvas.contents)
+      /OC /P1 BDC
+      q
+      1 0 0 1 10 15 cm
+      0.0 0.501961 0.0 rg
+      0.0 0.392157 0.0 RG
+      /GS1 gs
+      0 0 20 20 re
+      B
+      Q
+      EMC
+      q
+      1 0 0 1 10 15 cm
+      Q
+    CONTENTS
+    ocg = doc.optional_content.ocgs.first
+    assert_equal([['Debug', ['Page 1', ocg]]], doc.optional_content.default_configuration[:Order])
+    assert_match(/10,15-20x20/, ocg.name)
+  end
+end
+
 describe HexaPDF::Layout::Box do
   before do
     @frame = Object.new
@@ -78,7 +109,7 @@ describe HexaPDF::Layout::Box do
   describe "fit" do
     it "fits a fixed sized box" do
       box = create_box(width: 50, height: 50, style: {padding: 5})
-      assert(box.fit(100, 100, @frame))
+      assert(box.fit(100, 100, @frame).success?)
       assert_equal(50, box.width)
       assert_equal(50, box.height)
       assert_equal(5, box.instance_variable_get(:@fit_x))
@@ -87,28 +118,45 @@ describe HexaPDF::Layout::Box do
 
     it "uses the maximum available width" do
       box = create_box(height: 50)
-      assert(box.fit(100, 100, @frame))
+      assert(box.fit(100, 100, @frame).success?)
       assert_equal(100, box.width)
       assert_equal(50, box.height)
     end
 
     it "uses the maximum available height" do
       box = create_box(width: 50)
-      assert(box.fit(100, 100, @frame))
+      assert(box.fit(100, 100, @frame).success?)
       assert_equal(50, box.width)
       assert_equal(100, box.height)
     end
 
     it "uses float comparison" do
       box = create_box(width: 50.0000002, height: 49.9999996)
-      assert(box.fit(50, 50, @frame))
+      assert(box.fit(50, 50, @frame).success?)
       assert_equal(50.0000002, box.width)
       assert_equal(49.9999996, box.height)
     end
 
-    it "returns false if the box doesn't fit" do
+    it "fails if the box doesn't fit, position != :flow and its width is greater than the available width" do
       box = create_box(width: 101)
-      refute(box.fit(100, 100, @frame))
+      assert(box.fit(100, 100, @frame).failure?)
+    end
+
+    it "fails if the box doesn't fit, position != :flow and its width is greater than the available width" do
+      box = create_box(height: 101)
+      assert(box.fit(100, 100, @frame).failure?)
+    end
+
+    it "fails if its content width is zero" do
+      box = create_box(height: 100)
+      box.style.padding = [0, 100]
+      assert(box.fit(150, 150, @frame).failure?)
+    end
+
+    it "fails if its content height is zero" do
+      box = create_box(width: 100)
+      box.style.padding = [100, 0]
+      assert(box.fit(150, 150, @frame).failure?)
     end
 
     it "can use the #content_width/#content_height helper methods" do
@@ -116,9 +164,9 @@ describe HexaPDF::Layout::Box do
       box.define_singleton_method(:fit_content) do |_aw, _ah, _frame|
         update_content_width { 10 }
         update_content_height { 20 }
-        true
+        fit_result.success!
       end
-      assert(box.fit(100, 100, @frame))
+      assert(box.fit(100, 100, @frame).success?)
       assert_equal(10, box.width)
       assert_equal(20, box.height)
 
@@ -126,49 +174,40 @@ describe HexaPDF::Layout::Box do
       box.define_singleton_method(:fit_content) do |_aw, _ah, _frame|
         update_content_width { 10 }
         update_content_height { 20 }
-        true
+        fit_result.success!
       end
-      assert(box.fit(100, 100, @frame))
+      assert(box.fit(100, 100, @frame).success?)
       assert_equal(30, box.width)
       assert_equal(50, box.height)
     end
   end
 
   describe "split" do
-    before do
-      @box = create_box(width: 100, height: 100)
-      @box.fit(100, 100, @frame)
-    end
-
     it "doesn't need to be split if it completely fits" do
-      assert_equal([@box, nil], @box.split(100, 100, @frame))
-    end
-
-    it "can't be split if it doesn't (completely) fit and its width is greater than the available width" do
-      @box.fit(90, 100, nil)
-      assert_equal([nil, @box], @box.split(50, 150, @frame))
-    end
-
-    it "can't be split if it doesn't (completely) fit and its height is greater than the available height" do
-      @box.fit(90, 100, nil)
-      assert_equal([nil, @box], @box.split(150, 50, @frame))
+      box = create_box(width: 100, height: 100)
+      box.fit(100, 100, @frame)
+      assert_equal([box, nil], box.split)
     end
 
-    it "can't be split if it doesn't (completely) fit and its content width is zero" do
-      box = create_box(width: 0, height: 100)
-      assert_equal([nil, box], box.split(150, 150, @frame))
+    it "is not split if no part of it fits" do
+      box = create_box(width: 150)
+      box.fit(100, 100, @frame)
+      assert_equal([nil, box], box.split)
     end
 
-    it "can't be split if it doesn't (completely) fit and its content height is zero" do
-      box = create_box(width: 100, height: 0)
-      assert_equal([nil, box], box.split(150, 150, @frame))
+    it "is not split if a height for the box is specified and it doesn't completely fit" do
+      box = create_box(height: 50)
+      box.define_singleton_method(:fit_content) {|*| fit_result.overflow! }
+      box.fit(100, 100, @frame)
+      assert_equal([box, nil], box.split)
     end
 
-    it "can't be split if it doesn't (completely) fit as the default implementation " \
+    it "can't be split if it doesn't completely fit as the default implementation " \
       "knows nothing about the content" do
-      @box.style.position = :flow # make sure we would generally be splitable
-      @box.fit(90, 100, nil)
-      assert_equal([nil, @box], @box.split(150, 150, @frame))
+      box = create_box
+      box.define_singleton_method(:fit_content) {|*| fit_result.overflow! }
+      box.fit(100, 100, @frame)
+      assert_equal([nil, box], box.split)
     end
   end
 
@@ -177,7 +216,7 @@ describe HexaPDF::Layout::Box do
     box.fit(100, 100, @frame)
     cloned_box = box.send(:create_split_box)
     assert(cloned_box.split_box?)
-    refute(cloned_box.instance_variable_get(:@fit_successful))
+    refute_same(box.fit_result, cloned_box.fit_result)
     assert_equal(0, cloned_box.width)
     assert_equal(0, cloned_box.height)
   end
@@ -240,6 +279,12 @@ describe HexaPDF::Layout::Box do
       refute(box.style.overlays?)
     end
 
+    it "raises an error if the style property :overflow is set to error and the box doesn't completely fit" do
+      box = create_box(height: 50, style: {overflow: :error})
+      box.fit_result.overflow!
+      assert_raises(HexaPDF::Error) { box.draw(@canvas, 0, 0) }
+    end
+
     it "wraps the box in optional content markers if the optional_content property is set" do
       box = create_box(properties: {'optional_content' => 'Text'})
       box.draw(@canvas, 0, 0)

data/test/hexapdf/layout/test_box_fitter.rb

@@ -20,13 +20,13 @@ describe HexaPDF::Layout::BoxFitter do
     @box_fitter.fit(HexaPDF::Layout::TextBox.new(items: [ibox] * count))
   end
 
-  def check_result(*pos, content_heights:, successful: true, boxes_remain: false)
+  def check_result(*pos, content_heights:, success: true, boxes_remain: false)
     pos.each_slice(2).with_index do |(x, y), index|
       assert_equal(x, @box_fitter.fit_results[index].x, "x #{index}")
       assert_equal(y, @box_fitter.fit_results[index].y, "y #{index}")
     end
     assert_equal(content_heights, @box_fitter.content_heights)
-    successful ? assert(@box_fitter.fit_successful?) : refute(@box_fitter.fit_successful?)
+    success ? assert(@box_fitter.success?) : refute(@box_fitter.success?)
     rboxes = @box_fitter.remaining_boxes.empty?
     boxes_remain ? refute(rboxes) : assert(rboxes)
   end
@@ -50,12 +50,19 @@ describe HexaPDF::Layout::BoxFitter do
     check_result(10, 20, 0, 0, 100, 130, 100, 110, content_heights: [90, 40])
   end
 
+  it "correctly handles truncated boxes" do
+    box = HexaPDF::Layout::Box.new(height: 50) {}
+    box.define_singleton_method(:fit_content) {|*| fit_result.overflow! }
+    @box_fitter.fit(box)
+    check_result(10, 40, content_heights: [50, 0])
+  end
+
   it "fails when some boxes can't be fitted" do
     fit_box(9)
     fit_box(70)
     fit_box(40)
     fit_box(20)
-    check_result(10, 80, 0, 10, 0, 0, 100, 100, successful: false, boxes_remain: true,
+    check_result(10, 80, 0, 10, 0, 0, 100, 100, success: false, boxes_remain: true,
                  content_heights: [90, 50])
     assert_equal(2, @box_fitter.remaining_boxes.size)
   end

data/test/hexapdf/layout/test_column_box.rb

@@ -22,7 +22,7 @@ describe HexaPDF::Layout::ColumnBox do
   end
 
   def check_box(box, width, height, fit_pos = nil)
-    assert(box.fit(@frame.available_width, @frame.available_height, @frame), "box didn't fit")
+    assert(box.fit(@frame.available_width, @frame.available_height, @frame).success?, "box didn't fit")
     assert_equal(width, box.width, "box width")
     assert_equal(height, box.height, "box height")
     if fit_pos
@@ -73,9 +73,6 @@ describe HexaPDF::Layout::ColumnBox do
         box = create_box(columns: 1, children: @fixed_size_boxes[0..0], width: 50,
                          style: {position: position})
         check_box(box, 50, 10)
-
-        box = create_box(children: @fixed_size_boxes[0..0], width: 110)
-        refute(box.fit(@frame.available_width, @frame.available_height, @frame))
       end
 
       it "respects the set initial height, position #{position}" do
@@ -86,9 +83,6 @@ describe HexaPDF::Layout::ColumnBox do
         box = create_box(children: @text_boxes[0..1], height: 50, equal_height: true,
                          style: {position: position})
         check_box(box, 100, 50)
-
-        box = create_box(children: @fixed_size_boxes[0..0], height: 110)
-        refute(box.fit(@frame.available_width, @frame.available_height, @frame))
       end
 
       it "respects the border and padding around all columns, position #{position}" do
@@ -150,15 +144,15 @@ describe HexaPDF::Layout::ColumnBox do
 
       it "fails if the necessary width is larger than the available one" do
         box = create_box(children: @fixed_size_boxes[0..2], columns: 4, gaps: [40])
-        refute(box.fit(100, 100, @frame))
+        assert(box.fit(100, 100, @frame).failure?)
       end
     end
   end
 
   it "splits the children if they are too big to fill the colums" do
-    box = create_box(children: @fixed_size_boxes, width: 50, height: 50)
-    box.fit(100, 100, @frame)
-    box_a, box_b = box.split(100, 100, @frame)
+    box = create_box(children: @fixed_size_boxes, width: 50)
+    assert(box.fit(100, 50, @frame).overflow?)
+    box_a, box_b = box.split
     assert_same(box, box_a)
     assert(box_b.split_box?)
     assert_equal(5, box_b.children.size)
@@ -171,7 +165,7 @@ describe HexaPDF::Layout::ColumnBox do
 
     it "draws the result onto the canvas" do
       box = create_box(children: @fixed_size_boxes)
-      box.fit(100, 100, @frame)
+      assert(box.fit(100, 100, @frame).success?)
       box.draw(@canvas, 0, 100 - box.height)
       operators = 90.step(to: 20, by: -10).map do |y|
         [[:save_graphics_state],
@@ -193,7 +187,7 @@ describe HexaPDF::Layout::ColumnBox do
 
     it "takes a different final location into account" do
       box = create_box(children: @fixed_size_boxes[0, 2], style: {padding: [2, 4, 6, 8]})
-      box.fit(100, 100, @frame)
+      assert(box.fit(100, 100, @frame).success?)
       box.draw(@canvas, 20, 10)
       operators = [
         [:save_graphics_state],

data/test/hexapdf/layout/test_container_box.rb

@@ -15,7 +15,7 @@ describe HexaPDF::Layout::ContainerBox do
   end
 
   def check_box(box, width, height, fit_pos = nil)
-    assert(box.fit(@frame.available_width, @frame.available_height, @frame), "box didn't fit")
+    assert(box.fit(@frame.available_width, @frame.available_height, @frame).success?, "box didn't fit")
     assert_equal(width, box.width, "box width")
     assert_equal(height, box.height, "box height")
     if fit_pos

data/test/hexapdf/layout/test_frame.rb

@@ -5,37 +5,6 @@ require 'hexapdf/layout/frame'
 require 'hexapdf/layout/box'
 require 'hexapdf/document'
 
-describe HexaPDF::Layout::Frame::FitResult do
-  it "shows the box's mask area on #draw when using debug output" do
-    doc = HexaPDF::Document.new(config: {'debug' => true})
-    canvas = doc.pages.add.canvas
-    box = HexaPDF::Layout::Box.create(width: 20, height: 20) {}
-    frame = HexaPDF::Layout::Frame.new(5, 10, 100, 150)
-    result = HexaPDF::Layout::Frame::FitResult.new(frame, box)
-    result.mask = Geom2D::Rectangle(0, 0, 20, 20)
-    result.x = result.y = 0
-    result.draw(canvas, dx: 10, dy: 15)
-    assert_equal(<<~CONTENTS, canvas.contents)
-      /OC /P1 BDC
-      q
-      1 0 0 1 10 15 cm
-      0.0 0.501961 0.0 rg
-      0.0 0.392157 0.0 RG
-      /GS1 gs
-      0 0 20 20 re
-      B
-      Q
-      EMC
-      q
-      1 0 0 1 10 15 cm
-      Q
-    CONTENTS
-    ocg = doc.optional_content.ocgs.first
-    assert_equal([['Debug', ['Page 1', ocg]]], doc.optional_content.default_configuration[:Order])
-    assert_match(/10,15-20x20/, ocg.name)
-  end
-end
-
 describe HexaPDF::Layout::Frame do
   before do
     @frame = HexaPDF::Layout::Frame.new(5, 10, 100, 150)
@@ -454,23 +423,6 @@ describe HexaPDF::Layout::Frame do
       box = HexaPDF::Layout::Box.create
       refute(@frame.fit(box).success?)
     end
-
-    it "handles (but doesn't draw) the box if the its height or width is zero" do
-      result = Minitest::Mock.new
-      box = Minitest::Mock.new
-
-      result.expect(:box, box)
-      box.expect(:height, 0)
-      @frame.draw(@canvas, result)
-
-      result.expect(:box, box)
-      box.expect(:height, 5)
-      result.expect(:box, box)
-      box.expect(:width, 0)
-      @frame.draw(@canvas, result)
-
-      result.verify
-    end
   end
 
   describe "split" do

data/test/hexapdf/layout/test_image_box.rb

@@ -9,6 +9,9 @@ describe HexaPDF::Layout::ImageBox do
     @image = HexaPDF::Stream.new({Subtype: :Image}, stream: '')
     @image.define_singleton_method(:width) { 40 }
     @image.define_singleton_method(:height) { 20 }
+    @frame = Object.new
+    def @frame.x; 0; end
+    def @frame.y; 100; end
   end
 
   def create_box(**kwargs)
@@ -25,35 +28,40 @@ describe HexaPDF::Layout::ImageBox do
   describe "fit" do
     it "fits with fixed dimensions" do
       box = create_box(width: 50, height: 30, style: {padding: [10, 4, 6, 2]})
-      assert(box.fit(100, 100, nil))
+      assert(box.fit(100, 100, @frame).success?)
       assert_equal(50, box.width)
       assert_equal(30, box.height)
     end
 
     it "fits with a fixed width" do
       box = create_box(width: 60, style: {padding: [10, 4, 6, 2]})
-      assert(box.fit(100, 100, nil))
+      assert(box.fit(100, 100, @frame).success?)
       assert_equal(60, box.width)
       assert_equal(43, box.height)
     end
 
     it "fits with a fixed height" do
       box = create_box(height: 40, style: {padding: [10, 4, 6, 2]})
-      assert(box.fit(100, 100, nil))
+      assert(box.fit(100, 100, @frame).success?)
       assert_equal(54, box.width)
       assert_equal(40, box.height)
     end
 
     it "fits with auto-scaling to available space" do
       box = create_box(style: {padding: [10, 4, 6, 2]})
-      assert(box.fit(100, 100, nil))
+      assert(box.fit(100, 100, @frame).success?)
       assert_equal(100, box.width)
       assert_equal(63, box.height)
 
-      assert(box.fit(100, 30, nil))
+      assert(box.fit(100, 30, @frame).success?)
       assert_equal(34, box.width)
       assert_equal(30, box.height)
     end
+
+    it "fails if one of the calculated dimensions is larger than the available space" do
+      box = create_box(height: 60)
+      assert(box.fit(100, 100, @frame).failure?)
+    end
   end
 
   it "always returns false for empty?" do
@@ -63,7 +71,7 @@ describe HexaPDF::Layout::ImageBox do
   describe "draw" do
     it "draws the image" do
       box = create_box(height: 40, style: {padding: [10, 4, 6, 2]})
-      box.fit(100, 100, nil)
+      box.fit(100, 100, @frame)
 
       @canvas = HexaPDF::Document.new.pages.add.canvas
       box.draw(@canvas, 0, 0)

data/test/hexapdf/layout/test_list_box.rb

@@ -19,8 +19,9 @@ describe HexaPDF::Layout::ListBox do
     HexaPDF::Layout::ListBox.new(content_indentation: 10, **kwargs)
   end
 
-  def check_box(box, width, height, fit_pos = nil)
-    assert(box.fit(@frame.available_width, @frame.available_height, @frame), "box didn't fit")
+  def check_box(box, width, height, status: :success, fit_pos: nil)
+    result = box.fit(@frame.available_width, @frame.available_height, @frame)
+    assert_equal(result.status, status)
     assert_equal(width, box.width, "box width")
     assert_equal(height, box.height, "box height")
     if fit_pos
@@ -73,45 +74,44 @@ describe HexaPDF::Layout::ListBox do
         check_box(box, 100, 40)
       end
 
-      it "respects the set initial height and the property overflow=:truncate" do
-        box = create_box(children: @text_boxes[0, 2], height: 20,
-                         style: {overflow: :truncate, position: position})
-        check_box(box, 100, 20)
+      it "respects the set initial height even when it doesn't fit completely" do
+        box = create_box(children: @text_boxes[0, 2], height: 20, style: {position: position})
+        check_box(box, 100, 20, status: :overflow)
       end
 
       it "respects the border and padding around all list items, position #{position}" do
         box = create_box(children: @text_boxes[0, 2],
                          style: {border: {width: [5, 4, 3, 2]}, padding: [5, 4, 3, 2], position: position})
-        check_box(box, 100, 76, [[14, 60], [14, 30]])
+        check_box(box, 100, 76, fit_pos: [[14, 60], [14, 30]])
       end
     end
 
     it "uses the frame's current cursor position and available width/height when position=:default" do
       @frame.remove_area(Geom2D::Polygon([0, 0], [10, 0], [10, 90], [100, 90], [100, 100], [0, 100]))
       box = create_box(children: @text_boxes[0, 2])
-      check_box(box, 90, 40, [[20, 70], [20, 50]])
+      check_box(box, 90, 40, fit_pos: [[20, 70], [20, 50]])
     end
 
     it "respects the frame's shape when style position=:flow" do
       @frame.remove_area(Geom2D::Polygon([0, 0], [0, 40], [40, 40], [40, 0]))
       box = create_box(children: @text_boxes[0, 4], style: {position: :flow})
-      check_box(box, 100, 90, [[10, 80], [10, 60], [10, 40], [50, 10]])
+      check_box(box, 100, 90, fit_pos: [[10, 80], [10, 60], [10, 40], [50, 10]])
     end
 
     it "calculates the correct height if the marker is higher than the content" do
       box = create_box(children: @text_boxes[0, 1], content_indentation: 20,
                        style: {font_size: 30})
-      check_box(box, 100, 27, [[20, 80]])
+      check_box(box, 100, 27, fit_pos: [[20, 80]])
     end
 
     it "respects the content indentation" do
       box = create_box(children: @text_boxes[0, 1], content_indentation: 30)
-      check_box(box, 100, 30, [[30, 70]])
+      check_box(box, 100, 30, fit_pos: [[30, 70]])
     end
 
     it "respects the spacing between list items" do
       box = create_box(children: @text_boxes[0, 2], item_spacing: 30)
-      check_box(box, 100, 70, [[10, 80], [10, 30]])
+      check_box(box, 100, 70, fit_pos:  [[10, 80], [10, 30]])
     end
 
     it "creates a new box for each marker even if the marker is the same" do
@@ -121,6 +121,11 @@ describe HexaPDF::Layout::ListBox do
       refute_same(results[0].marker, results[1].marker)
     end
 
+    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)
+    end
+
     it "fails for unknown marker types" do
       box = create_box(children: @text_boxes[0, 1], marker_type: :unknown)
       assert_raises(HexaPDF::Error) { box.fit(100, 100, @frame) }
@@ -129,9 +134,9 @@ 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], height: 20)
-      box.fit(100, 100, @frame)
-      box_a, box_b = box.split(100, 100, @frame)
+      box = create_box(children: @text_boxes[0, 2])
+      assert(box.fit(100, 20, @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)
@@ -140,9 +145,9 @@ describe HexaPDF::Layout::ListBox do
     end
 
     it "splits a list item if some part of it will fit" do
-      box = create_box(children: @text_boxes[0, 2], height: 10)
-      box.fit(100, 100, @frame)
-      box_a, box_b = box.split(100, 100, @frame)
+      box = create_box(children: @text_boxes[0, 2])
+      assert(box.fit(100, 10, @frame).overflow?)
+      box_a, box_b = box.split
       assert_same(box, box_a)
       assert_equal(:hide_first_marker, box_b.split_box?)
       assert_equal(1, box_a.instance_variable_get(:@results)[0].box_fitter.fit_results.size)
@@ -152,8 +157,8 @@ describe HexaPDF::Layout::ListBox do
 
     it "splits a list item containg multiple boxes along box lines" do
       box = create_box(children: [@text_boxes[0], @text_boxes[1, 2]])
-      box.fit(100, 40, @frame)
-      box_a, box_b = box.split(100, 40, @frame)
+      assert(box.fit(100, 40, @frame).overflow?)
+      box_a, box_b = box.split
       assert_same(box, box_a)
       assert_equal(:hide_first_marker, box_b.split_box?)
       assert_equal(1, box_a.instance_variable_get(:@results)[1].box_fitter.fit_results.size)
@@ -338,11 +343,5 @@ describe HexaPDF::Layout::ListBox do
       assert_operators(@canvas.contents, [:set_font_and_size, [:F1, 5]], range: 1)
       assert_equal(:ZapfDingbats, @canvas.resources.font(:F1)[:BaseFont])
     end
-
-    it "fails if the initial height is set and property overflow is set to :error" do
-      box = create_box(children: @fixed_size_boxes[0, 2], height: 10)
-      box.fit(100, 100, @frame)
-      assert_raises(HexaPDF::Error) { box.draw(@canvas, 0, 100 - box.height) }
-    end
   end
 end