hexapdf 0.32.1 → 0.33.0

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 fit?")
+    assert(box.fit(@frame.available_width, @frame.available_height, @frame), "box didn't fit")
     assert_equal(width, box.width, "box width")
     assert_equal(height, box.height, "box height")
     if fit_pos
@@ -46,6 +46,24 @@ describe HexaPDF::Layout::ColumnBox do
     end
   end
 
+  describe "empty?" do
+    it "is empty if nothing is fit yet" do
+      assert(create_box.empty?)
+    end
+
+    it "is empty if no box fits" do
+      box = create_box(children: [@fixed_size_boxes[0]], columns: [10])
+      box.fit(@frame.available_width, @frame.available_height, @frame)
+      assert(box.empty?)
+    end
+
+    it "is not empty if at least one box fits" do
+      box = create_box(children: [@fixed_size_boxes[0]], columns: [30])
+      check_box(box, 30, 10)
+      refute(box.empty?)
+    end
+  end
+
   describe "fit" do
     [:default, :flow].each do |position|
       it "respects the set initial width, position #{position}" do
@@ -132,27 +150,53 @@ describe HexaPDF::Layout::ColumnBox do
     assert_equal(5, box_b.children.size)
   end
 
-  it "draws the result onto the canvas" do
-    box = create_box(children: @fixed_size_boxes)
-    box.fit(100, 100, @frame)
+  describe "draw_content" do
+    before do
+      @canvas = HexaPDF::Document.new.pages.add.canvas
+    end
+
+    it "draws the result onto the canvas" do
+      box = create_box(children: @fixed_size_boxes)
+      box.fit(100, 100, @frame)
+      box.draw(@canvas, 0, 100 - box.height)
+      operators = 90.step(to: 20, by: -10).map do |y|
+        [[:save_graphics_state],
+         [:concatenate_matrix, [1, 0, 0, 1, 0, y]],
+         [:move_to, [0, 0]],
+         [:end_path],
+         [:restore_graphics_state]]
+      end
+      operators.concat(90.step(to: 30, by: -10).map do |y|
+          [[:save_graphics_state],
+           [:concatenate_matrix, [1, 0, 0, 1, 55, y]],
+           [:move_to, [0, 0]],
+           [:end_path],
+           [:restore_graphics_state]]
+      end)
+      operators.flatten!(1)
+      assert_operators(@canvas.contents, operators)
+    end
 
-    @canvas = HexaPDF::Document.new.pages.add.canvas
-    box.draw(@canvas, 0, 0)
-    operators = 90.step(to: 20, by: -10).map do |y|
-      [[:save_graphics_state],
-       [:concatenate_matrix, [1, 0, 0, 1, 0, y]],
-       [:move_to, [0, 0]],
-       [:end_path],
-       [:restore_graphics_state]]
+    it "takes a different final location into account" do
+      box = create_box(children: @fixed_size_boxes[0, 2])
+      box.fit(100, 100, @frame)
+      box.draw(@canvas, 20, 10)
+      operators = [
+        [:save_graphics_state],
+        [:concatenate_matrix, [1, 0, 0, 1, 20, -80]],
+        [:save_graphics_state],
+        [:concatenate_matrix, [1, 0, 0, 1, 0, 90]],
+        [:move_to, [0, 0]],
+        [:end_path],
+        [:restore_graphics_state],
+        [:save_graphics_state],
+        [:concatenate_matrix, [1, 0, 0, 1, 55, 90]],
+        [:move_to, [0, 0]],
+        [:end_path],
+        [:restore_graphics_state],
+        [:restore_graphics_state],
+      ]
+      assert_operators(@canvas.contents, operators)
     end
-    operators.concat(90.step(to: 30, by: -10).map do |y|
-                       [[:save_graphics_state],
-                        [:concatenate_matrix, [1, 0, 0, 1, 55, y]],
-                        [:move_to, [0, 0]],
-                        [:end_path],
-                        [:restore_graphics_state]]
-                     end)
-    operators.flatten!(1)
-    assert_operators(@canvas.contents, operators)
   end
 end

data/test/hexapdf/layout/test_frame.rb

@@ -11,7 +11,7 @@ describe HexaPDF::Layout::Frame do
     canvas = doc.pages.add.canvas
     box = HexaPDF::Layout::Box.create(width: 20, height: 20) {}
     result = HexaPDF::Layout::Frame::FitResult.new(box)
-    result.mask = Geom2D::Polygon([0, 0], [0, 20], [20, 20], [20, 0])
+    result.mask = Geom2D::Rectangle(0, 0, 20, 20)
     result.x = result.y = 0
     result.draw(canvas)
     assert_equal(<<~CONTENTS, canvas.contents)
@@ -19,11 +19,7 @@ describe HexaPDF::Layout::Frame do
       0.0 0.501961 0.0 rg
       0.0 0.392157 0.0 RG
       /GS1 gs
-      0 0 m
-      0 20 l
-      20 20 l
-      20 0 l
-      h
+      0 0 20 20 re
       B
       Q
       q
@@ -90,7 +86,11 @@ describe HexaPDF::Layout::Frame do
       refute_nil(fit_result)
       @frame.draw(@canvas, fit_result)
       assert_equal(mask, fit_result.mask.bbox.to_a)
-      assert_equal(points, @frame.shape.polygons.map(&:to_a))
+      if @frame.shape.respond_to?(:polygons)
+        assert_equal(points, @frame.shape.polygons.map(&:to_a))
+      else
+        assert_equal(points, [@frame.shape.to_a])
+      end
       @canvas.verify
     end
 
@@ -99,9 +99,9 @@ describe HexaPDF::Layout::Frame do
       areas.each do |area|
         @frame.remove_area(
           case area
-          when :left then Geom2D::Polygon([10, 10], [10, 110], [20, 110], [20, 10])
-          when :right then Geom2D::Polygon([100, 10], [100, 110], [110, 110], [110, 10])
-          when :top then Geom2D::Polygon([10, 110], [110, 110], [110, 100], [10, 100])
+          when :left then Geom2D::Rectangle(10, 10, 10, 100)
+          when :right then Geom2D::Rectangle(100, 10, 10, 100)
+          when :top then Geom2D::Rectangle(10, 100, 100, 10)
           end
         )
       end
@@ -323,7 +323,7 @@ describe HexaPDF::Layout::Frame do
     end
 
     it "can't fit the box if there is no available space" do
-      @frame.remove_area(Geom2D::Polygon([0, 0], [110, 0], [110, 110], [0, 110]))
+      @frame.remove_area(Geom2D::Rectangle(0, 0, 110, 110))
       box = HexaPDF::Layout::Box.create
       refute(@frame.fit(box).success?)
     end
@@ -388,7 +388,7 @@ describe HexaPDF::Layout::Frame do
     # +--------+
     it "works for a region with a hole" do
       frame = HexaPDF::Layout::Frame.new(0, 0, 100, 100)
-      frame.remove_area(Geom2D::Polygon([20, 20], [80, 20], [80, 80], [20, 80]))
+      frame.remove_area(Geom2D::Rectangle(20, 20, 60, 60))
       check_regions(frame, [[0, 100, 100, 20], [0, 100, 20, 100],
                             [0, 80, 20, 80], [0, 20, 100, 20]])
     end
@@ -400,7 +400,7 @@ describe HexaPDF::Layout::Frame do
     # +--------+
     it "works for a u-shaped frame" do
       frame = HexaPDF::Layout::Frame.new(0, 0, 100, 100)
-      frame.remove_area(Geom2D::Polygon([30, 100], [70, 100], [70, 60], [30, 60]))
+      frame.remove_area(Geom2D::Rectangle(30, 60, 40, 40))
       check_regions(frame, [[0, 100, 30, 100], [0, 60, 100, 60]])
     end
 
@@ -415,7 +415,7 @@ describe HexaPDF::Layout::Frame do
     it "works for a complicated frame" do
       frame = HexaPDF::Layout::Frame.new(0, 0, 100, 100)
       top_cut = Geom2D::Polygon([20, 100], [20, 80], [40, 80], [40, 90], [60, 90], [60, 100])
-      left_cut = Geom2D::Polygon([0, 20], [30, 20], [30, 40], [0, 40])
+      left_cut = Geom2D::Rectangle(0, 20, 30, 20)
       frame.remove_area(Geom2D::PolygonSet(top_cut, left_cut))
 
       check_regions(frame, [[0, 100, 20, 60], [0, 90, 20, 50], [0, 80, 100, 40],

data/test/hexapdf/layout/test_image_box.rb

@@ -56,6 +56,10 @@ describe HexaPDF::Layout::ImageBox do
     end
   end
 
+  it "always returns false for empty?" do
+    refute(create_box.empty?)
+  end
+
   describe "draw" do
     it "draws the image" do
       box = create_box(height: 40, style: {padding: [10, 4, 6, 2]})

data/test/hexapdf/layout/test_inline_box.rb

@@ -30,6 +30,11 @@ describe HexaPDF::Layout::InlineBox do
       assert_equal(45, ibox.height)
     end
 
+    it "fails if the wrapped box has not width set" do
+      box = HexaPDF::Document.new.layout.text("test is not going good")
+      assert_raises(HexaPDF::Error) { inline_box(box) }
+    end
+
     it "fails if the wrapped box could not be fit" do
       box = HexaPDF::Document.new.layout.text("test is not going good", width: 1)
       assert_raises(HexaPDF::Error) { inline_box(box) }

data/test/hexapdf/layout/test_list_box.rb

@@ -18,7 +18,7 @@ describe HexaPDF::Layout::ListBox do
   end
 
   def check_box(box, width, height, fit_pos = nil)
-    assert(box.fit(@frame.available_width, @frame.available_height, @frame), "box fit?")
+    assert(box.fit(@frame.available_width, @frame.available_height, @frame), "box didn't fit")
     assert_equal(width, box.width, "box width")
     assert_equal(height, box.height, "box height")
     if fit_pos
@@ -47,6 +47,18 @@ describe HexaPDF::Layout::ListBox do
     end
   end
 
+  describe "empty?" do
+    it "is empty if nothing was fit yet" do
+      assert(create_box.empty?)
+    end
+
+    it "is empty if nothing could be fit" do
+      box = create_box(children: [@text_boxes[0]], width: 5)
+      box.fit(@frame.available_width, @frame.available_height, @frame)
+      assert(create_box.empty?)
+    end
+  end
+
   describe "fit" do
     [:default, :flow].each do |position|
       it "respects the set initial width, position #{position}" do
@@ -123,7 +135,7 @@ describe HexaPDF::Layout::ListBox do
     it "draws the result" do
       box = create_box(children: @fixed_size_boxes[0, 2])
       box.fit(100, 100, @frame)
-      box.draw(@canvas, 0, 0)
+      box.draw(@canvas, 0, 100 - box.height)
       operators = [
         [:save_graphics_state],
         [:set_font_and_size, [:F1, 10]],
@@ -153,7 +165,7 @@ describe HexaPDF::Layout::ListBox do
     it "draws a cicle as marker" do
       box = create_box(children: @fixed_size_boxes[0, 1], item_type: :circle)
       box.fit(100, 100, @frame)
-      box.draw(@canvas, 0, 0)
+      box.draw(@canvas, 0, 100 - box.height)
       operators = [
         [:save_graphics_state],
         [:set_font_and_size, [:F1, 5]],
@@ -173,7 +185,7 @@ describe HexaPDF::Layout::ListBox do
     it "draws a square as marker" do
       box = create_box(children: @fixed_size_boxes[0, 1], item_type: :square)
       box.fit(100, 100, @frame)
-      box.draw(@canvas, 0, 0)
+      box.draw(@canvas, 0, 100 - box.height)
       operators = [
         [:save_graphics_state],
         [:set_font_and_size, [:F1, 5]],
@@ -194,7 +206,7 @@ describe HexaPDF::Layout::ListBox do
       box = create_box(children: @fixed_size_boxes[0, 2], item_type: :decimal,
                        content_indentation: 20)
       box.fit(100, 100, @frame)
-      box.draw(@canvas, 0, 0)
+      box.draw(@canvas, 0, 100 - box.height)
       operators = [
         [:save_graphics_state],
         [:set_font_and_size, [:F1, 10]],
@@ -227,7 +239,7 @@ describe HexaPDF::Layout::ListBox do
       end
       box = create_box(children: @fixed_size_boxes[0, 1], item_type: marker)
       box.fit(100, 100, @frame)
-      box.draw(@canvas, 0, 0)
+      box.draw(@canvas, 0, 100 - box.height)
       operators = [
         [:save_graphics_state],
         [:concatenate_matrix, [1, 0, 0, 1, 0, 90]],
@@ -239,6 +251,28 @@ describe HexaPDF::Layout::ListBox do
       assert_operators(@canvas.contents, operators)
     end
 
+    it "takes a different final location into account" do
+      box = create_box(children: @fixed_size_boxes[0, 1])
+      box.fit(100, 100, @frame)
+      box.draw(@canvas, 20, 10)
+      operators = [
+        [:save_graphics_state],
+        [:concatenate_matrix, [1, 0, 0, 1, 20, -80]],
+        [:save_graphics_state],
+        [:set_font_and_size, [:F1, 10]],
+        [:begin_text],
+        [:set_text_matrix, [1, 0, 0, 1, 1.5, 93.17]],
+        [:show_text, ["\x95".b]],
+        [:end_text],
+        [:restore_graphics_state],
+        [:save_graphics_state],
+        [:concatenate_matrix, [1, 0, 0, 1, 10, 90]],
+        [:restore_graphics_state],
+        [:restore_graphics_state],
+      ]
+      assert_operators(@canvas.contents, operators)
+    end
+
     it "fails for unknown item types" do
       box = create_box(children: @fixed_size_boxes[0, 1], item_type: :unknown)
       box.fit(100, 100, @frame)

data/test/hexapdf/layout/test_page_style.rb

@@ -5,11 +5,12 @@ require 'hexapdf/layout/page_style'
 require 'hexapdf/document'
 
 describe HexaPDF::Layout::PageStyle do
-  it "allows assigning the page size, orientation and template on initialization" do
+  it "allows assigning the page size, orientation, next style and template on initialization" do
     block = lambda {}
-    style = HexaPDF::Layout::PageStyle.new(page_size: :A3, orientation: :landscape, &block)
+    style = HexaPDF::Layout::PageStyle.new(page_size: :A3, orientation: :landscape, next_style: :a, &block)
     assert_equal(:A3, style.page_size)
     assert_equal(:landscape, style.orientation)
+    assert_equal(:a, style.next_style)
     assert_same(block, style.template)
   end
 

data/test/hexapdf/layout/test_style.rb

@@ -156,15 +156,24 @@ describe HexaPDF::Layout::Style::Border do
     assert_kind_of(HexaPDF::Layout::Style::Quad, border.style)
   end
 
+  it "has an accessor for the draw-on-bounds option" do
+    border = create_border
+    refute(border.draw_on_bounds)
+    border.draw_on_bounds = true
+    assert(border.draw_on_bounds)
+  end
+
   it "can be duplicated" do
     border = create_border
     copy = border.dup
     border.width.top = 10
     border.color.top = :red
     border.style.top = :dotted
+    border.draw_on_bounds = true
     assert_equal(0, copy.width.top)
     assert_equal(0, copy.color.top)
     assert_equal(:solid, copy.style.top)
+    refute(copy.draw_on_bounds)
   end
 
   it "can be asked whether a border is defined" do
@@ -259,6 +268,19 @@ describe HexaPDF::Layout::Style::Border do
                [:restore_graphics_state]]
         assert_operators(@canvas.contents, ops)
       end
+
+      it "works if the border is drawn on the bounds" do
+        border = create_border(width: 10, color: 0.5, style: :solid, draw_on_bounds: true)
+        border.draw(@canvas, 0, 0, 100, 100)
+        assert_operators(@canvas.contents, [[:save_graphics_state],
+                                            [:set_device_gray_stroking_color, [0.5]],
+                                            [:set_line_width, [10]],
+                                            [:append_rectangle, [-5, -5, 110, 110]],
+                                            [:clip_path_non_zero], [:end_path],
+                                            [:append_rectangle, [0, 0, 100, 100]],
+                                            [:stroke_path],
+                                            [:restore_graphics_state]])
+      end
     end
 
     describe "complex borders where edges have different width/color/style values" do
@@ -369,6 +391,34 @@ describe HexaPDF::Layout::Style::Border do
                [:restore_graphics_state], [:restore_graphics_state]]
         assert_operators(@canvas.contents, ops)
       end
+
+      it "works if the border is drawn on the bounds" do
+        border = create_border(width: [20, 10, 40, 30], draw_on_bounds: true)
+        border.draw(@canvas, 0, 0, 100, 200)
+        ops = [[:save_graphics_state],
+               [:save_graphics_state],
+               [:move_to, [-15, 210]], [:line_to, [105, 210]],
+               [:line_to, [95, 190]], [:line_to, [15, 190]], [:clip_path_non_zero], [:end_path],
+               [:set_line_width, [20]],
+               [:move_to, [-15, 200]], [:line_to, [105, 200]], [:stroke_path],
+               [:restore_graphics_state], [:save_graphics_state],
+               [:move_to, [105, 210]], [:line_to, [105, -20]],
+               [:line_to, [95, 20]], [:line_to, [95, 190]], [:clip_path_non_zero], [:end_path],
+               [:set_line_width, [10]],
+               [:move_to, [100, 210]], [:line_to, [100, -20]], [:stroke_path],
+               [:restore_graphics_state], [:save_graphics_state],
+               [:move_to, [105, -20]], [:line_to, [-15, -20]],
+               [:line_to, [15, 20]], [:line_to, [95, 20]], [:clip_path_non_zero], [:end_path],
+               [:set_line_width, [40]],
+               [:move_to, [105, 0]], [:line_to, [-15, 0]], [:stroke_path],
+               [:restore_graphics_state], [:save_graphics_state],
+               [:move_to, [-15, -20]], [:line_to, [-15, 210]],
+               [:line_to, [15, 190]], [:line_to, [15, 20]], [:clip_path_non_zero], [:end_path],
+               [:set_line_width, [30]],
+               [:move_to, [0, -20]], [:line_to, [0, 210]], [:stroke_path],
+               [:restore_graphics_state], [:restore_graphics_state]]
+        assert_operators(@canvas.contents, ops)
+      end
     end
 
     describe "border width greater than edge length" do