hexapdf 0.34.1 → 0.35.0

data/test/hexapdf/layout/test_frame.rb

@@ -114,15 +114,22 @@ describe HexaPDF::Layout::Frame do
           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)
+          when :bottom then Geom2D::Rectangle(10, 10, 100, 10)
           end
         )
       end
     end
 
+    it "fails if an unkown position value is provided" do
+      box = HexaPDF::Layout::Box.create(position: :unknown)
+      exception = assert_raises(HexaPDF::Error)  { @frame.fit(box) }
+      assert_match(/Invalid value 'unknown'/, exception.message)
+    end
+
     describe "absolute position" do
       it "draws the box at the given absolute position" do
         check_box(
-          {width: 50, height: 50, position: :absolute, position_hint: [10, 10]},
+          {width: 50, height: 50, position: [10, 10]},
           [20, 20],
           [20, 20, 70, 70],
           [[[10, 10], [110, 10], [110, 110], [10, 110]],
@@ -132,22 +139,12 @@ describe HexaPDF::Layout::Frame do
 
       it "determines the available space for #fit by using the space to the right and above" do
         check_box(
-          {position: :absolute, position_hint: [10, 10]},
+          {position: [10, 10]},
           [20, 20],
           [20, 20, 110, 110],
           [[[10, 10], [110, 10], [110, 20], [20, 20], [20, 110], [10, 110]]]
         )
       end
-
-      it "always removes the whole margin box from the frame" do
-        check_box(
-          {width: 50, height: 50, position: :absolute, position_hint: [10, 10],
-           margin: [10, 20, 30, 40]},
-          [20, 20],
-          [-20, -10, 90, 80],
-          [[[10, 80], [90, 80], [90, 10], [110, 10], [110, 110], [10, 110]]]
-        )
-      end
     end
 
     describe "default position" do
@@ -159,40 +156,52 @@ describe HexaPDF::Layout::Frame do
       end
 
       it "draws the box on the right side" do
-        check_box({width: 50, height: 50, position_hint: :right},
+        check_box({width: 50, height: 50, align: :right},
                   [60, 60],
                   [10, 60, 110, 110],
                   [[[10, 10], [110, 10], [110, 60], [10, 60]]])
       end
 
       it "draws the box in the center" do
-        check_box({width: 50, height: 50, position_hint: :center},
+        check_box({width: 50, height: 50, align: :center},
                   [35, 60],
                   [10, 60, 110, 110],
                   [[[10, 10], [110, 10], [110, 60], [10, 60]]])
       end
 
+      it "draws the box vertically in the center" do
+        check_box({width: 50, height: 50, valign: :center},
+                  [10, 35],
+                  [10, 35, 110, 110],
+                  [[[10, 10], [110, 10], [110, 35], [10, 35]]])
+      end
+
+      it "draws the box vertically at the bottom" do
+        check_box({width: 50, height: 50, valign: :bottom},
+                  [10, 10], [10, 10, 110, 110], [])
+      end
+
       describe "with margin" do
         [:left, :center, :right].each do |hint|
-          it "ignores all margins if the box fills the whole frame, with position hint #{hint}" do
-            check_box({margin: 10, position_hint: hint},
+          it "ignores all margins if the box fills the whole frame, with alignment #{hint}" do
+            check_box({margin: 10, align: hint},
                       [10, 10], [10, 10, 110, 110], [])
             assert_equal(100, @box.width)
             assert_equal(100, @box.height)
           end
 
           it "ignores the left/top/right margin if the available bounds coincide with the " \
-            "frame's, with position hint #{hint}" do
-            check_box({height: 50, margin: 10, position_hint: hint},
+            "frame's, with alignment #{hint}" do
+            check_box({height: 50, margin: 10, align: hint},
                       [10, 60],
                       [10, 50, 110, 110],
                       [[[10, 10], [110, 10], [110, 50], [10, 50]]])
           end
 
           it "doesn't ignore top margin if the available bounds' top doesn't coincide with the " \
-            "frame's top, with position hint #{hint}" do
+            "frame's top, with alignment #{hint}" do
             remove_area(:top)
-            check_box({height: 50, margin: 10, position_hint: hint},
+            check_box({height: 50, margin: 10, align: hint},
                       [10, 40],
                       [10, 30, 110, 100],
                       [[[10, 10], [110, 10], [110, 30], [10, 30]]])
@@ -200,9 +209,9 @@ describe HexaPDF::Layout::Frame do
           end
 
           it "doesn't ignore left margin if the available bounds' left doesn't coincide with the " \
-            "frame's left, with position hint #{hint}" do
+            "frame's left, with alignment #{hint}" do
             remove_area(:left)
-            check_box({height: 50, margin: 10, position_hint: hint},
+            check_box({height: 50, margin: 10, align: hint},
                       [30, 60],
                       [10, 50, 110, 110],
                       [[[20, 10], [110, 10], [110, 50], [20, 50]]])
@@ -210,9 +219,9 @@ describe HexaPDF::Layout::Frame do
           end
 
           it "doesn't ignore right margin if the available bounds' right doesn't coincide with " \
-            "the frame's right, with position hint #{hint}" do
+            "the frame's right, with alignment #{hint}" do
             remove_area(:right)
-            check_box({height: 50, margin: 10, position_hint: hint},
+            check_box({height: 50, margin: 10, align: hint},
                       [10, 60],
                       [10, 50, 110, 110],
                       [[[10, 10], [100, 10], [100, 50], [10, 50]]])
@@ -220,117 +229,194 @@ describe HexaPDF::Layout::Frame do
           end
         end
 
-        it "perfectly centers a box if possible, margins ignored" do
-          check_box({width: 50, height: 10, margin: [10, 10, 10, 20], position_hint: :center},
+        [:top, :center, :bottom].each do |hint|
+          it "ignores all margins if the box fills the whole frame, with vertical alignment #{hint}" do
+            check_box({margin: 10, valign: hint},
+                      [10, 10], [10, 10, 110, 110], [])
+            assert_equal(100, @box.width)
+            assert_equal(100, @box.height)
+          end
+
+          it "ignores the left/top/bottom margin if the available bounds coincide with the " \
+            "frame's, with vertical alignment #{hint}" do
+            check_box({width: 50, margin: 10, valign: hint},
+                      [10, 10], [10, 10, 110, 110], [])
+            assert_equal(100, @box.height)
+          end
+
+          it "doesn't ignore top margin if the available bounds' top doesn't coincide with the " \
+            "frame's top, with vertical alignment #{hint}" do
+            remove_area(:top)
+            check_box({width: 50, margin: 10, valign: hint},
+                      [10, 10], [10, 10, 110, 100], [])
+            assert_equal(80, @box.height)
+          end
+
+          it "doesn't ignore left margin if the available bounds' left doesn't coincide with the " \
+            "frame's left, with vertical alignment #{hint}" do
+            remove_area(:left)
+            check_box({width: 50, margin: 10, valign: hint},
+                      [30, 10], [10, 10, 110, 110], [])
+            assert_equal(100, @box.height)
+          end
+
+          it "doesn't ignore bottom margin if the available bounds' bottom doesn't coincide with " \
+            "the frame's bottom, with vertical alignment #{hint}" do
+            remove_area(:bottom)
+            check_box({width: 50, margin: 10, valign: hint},
+                      [10, 30], [10, 20, 110, 110], [])
+            assert_equal(80, @box.height)
+          end
+        end
+
+        it "perfectly centers a box horizontally if possible, margins ignored" do
+          check_box({width: 50, height: 10, margin: [10, 10, 10, 20], align: :center},
                     [35, 100],
                     [10, 90, 110, 110],
                     [[[10, 10], [110, 10], [110, 90], [10, 90]]])
         end
 
-        it "perfectly centers a box if possible, margins not ignored" do
+        it "perfectly centers a box horizontally if possible, margins not ignored" do
           remove_area(:left, :right)
-          check_box({width: 40, height: 10, margin: [10, 10, 10, 20], position_hint: :center},
+          check_box({width: 40, height: 10, margin: [10, 10, 10, 20], align: :center},
                     [40, 100],
                     [10, 90, 110, 110],
                     [[[20, 10], [100, 10], [100, 90], [20, 90]]])
         end
 
-        it "centers a box as good as possible when margins aren't equal" do
+        it "horizontally centers a box as good as possible when margins aren't equal" do
           remove_area(:left, :right)
-          check_box({width: 20, height: 10, margin: [10, 10, 10, 40], position_hint: :center},
+          check_box({width: 20, height: 10, margin: [10, 10, 10, 40], align: :center},
                     [65, 100],
                     [10, 90, 110, 110],
                     [[[20, 10], [100, 10], [100, 90], [20, 90]]])
         end
+
+        it "perfectly centers a box vertically if possible, margins ignored" do
+          check_box({width: 10, height: 50, margin: [10, 10, 20, 10], valign: :center},
+                    [10, 35],
+                    [10, 15, 110, 110],
+                    [[[10, 10], [110, 10], [110, 15], [10, 15]]])
+        end
+
+        it "perfectly centers a box vertically if possible, margins not ignored" do
+          remove_area(:top, :bottom)
+          check_box({width: 10, height: 40, margin: [10, 10, 20, 10], valign: :center},
+                    [10, 40], [10, 20, 110, 100], [])
+        end
+
+        it "vertically centers a box as good as possible when margins aren't equal" do
+          remove_area(:top, :bottom)
+          check_box({width: 10, height: 20, margin: [10, 10, 40, 10], valign: :center},
+                    [10, 65],
+                    [10, 25, 110, 100],
+                    [[[10, 20], [110, 20], [110, 25], [10, 25]]])
+        end
       end
     end
 
-    describe "floating boxes" do
-      it "draws the box on the left side" do
-        check_box({width: 50, height: 50, position: :float},
-                  [10, 60],
-                  [10, 60, 60, 110],
-                  [[[10, 10], [110, 10], [110, 110], [60, 110], [60, 60], [10, 60]]])
+    describe "flowing boxes" do
+      it "flows inside the frame's outline" do
+        check_box({width: 10, height: 20, margin: 10, position: :flow},
+                  [0, 90],
+                  [10, 80, 110, 110],
+                  [[[10, 10], [110, 10], [110, 80], [10, 80]]])
       end
 
-      it "draws the box on the right side" do
-        check_box({width: 50, height: 50, position: :float, position_hint: :right},
-                  [60, 60],
-                  [60, 60, 110, 110],
-                  [[[10, 10], [110, 10], [110, 60], [60, 60], [60, 110], [10, 110]]])
+      it "uses position=default if the box indicates it doesn't support flowing contents" do
+        check_box({width: 10, height: 20, margin: 10, position: :flow, doesnt_support_position_flow: true},
+                  [10, 90],
+                  [10, 80, 110, 110],
+                  [[[10, 10], [110, 10], [110, 80], [10, 80]]])
       end
+    end
 
-      it "draws the box in the center" do
-        check_box({width: 50, height: 50, position: :float, position_hint: :center},
-                  [35, 60],
-                  [35, 60, 85, 110],
-                  [[[10, 10], [110, 10], [110, 110], [85, 110], [85, 60], [35, 60],
-                    [35, 110], [10, 110]]])
+    describe "mask mode" do
+      describe "none" do
+        it "doesn't remove any area" do
+          check_box({width: 50, height: 50, mask_mode: :none},
+                    [10, 60],
+                    [10, 60, 10, 60],
+                    [[[10, 10], [110, 10], [110, 110], [10, 110]]]
+                   )
+        end
       end
 
-      describe "with margin" do
-        [:left, :center, :right].each do |hint|
-          it "ignores all margins if the box fills the whole frame, with position hint #{hint}" do
-            check_box({margin: 10, position: :float, position_hint: hint},
-                      [10, 10], [10, 10, 110, 110], [])
-            assert_equal(100, @box.width)
-            assert_equal(100, @box.height)
-          end
+      describe "box" do
+        it "removes the box area" do
+          check_box({width: 50, height: 50, mask_mode: :box},
+                    [10, 60],
+                    [10, 60, 60, 110],
+                    [[[10, 10], [110, 10], [110, 110], [60, 110], [60, 60], [10, 60]]])
         end
 
-        it "ignores the left, but not the right margin if aligned left to the frame border" do
-          check_box({width: 50, height: 50, margin: 10, position: :float, position_hint: :left},
-                    [10, 60],
-                    [10, 50, 70, 110],
-                    [[[10, 10], [110, 10], [110, 110], [70, 110], [70, 50], [10, 50]]])
+        it "ignores the margin if sides are on the frame border" do
+          check_box({margin: 10, mask_mode: :box},
+                    [10, 10], [10, 10, 110, 110], [])
         end
 
-        it "uses the left and the right margin if aligned left and not to the frame border" do
-          remove_area(:left)
-          check_box({width: 50, height: 50, margin: 10, position: :float, position_hint: :left},
-                    [30, 60],
-                    [20, 50, 90, 110],
-                    [[[20, 10], [110, 10], [110, 110], [90, 110], [90, 50], [20, 50]]])
+        it "uses the margin if sides are not on the frame border" do
+          remove_area(:left, :right, :top, :bottom)
+          check_box({margin: 10, mask_mode: :box},
+                    [30, 30], [20, 20, 100, 100], [])
         end
+      end
 
-        it "uses the left and the right margin if aligned center" do
-          check_box({width: 50, height: 50, margin: 10, position: :float, position_hint: :center},
-                    [35, 60],
-                    [25, 50, 95, 110],
-                    [[[10, 10], [110, 10], [110, 110], [95, 110], [95, 50], [25, 50],
-                      [25, 110], [10, 110]]])
+      describe "fill_horizontal" do
+        it "removes the horizontal part to the bottom of the box in the current region" do
+          remove_area(:left, :right)
+          check_box({width: 50, height: 50, mask_mode: :fill_horizontal},
+                    [20, 60],
+                    [20, 60, 100, 110],
+                    [[[20, 10], [100, 10], [100, 60], [20, 60]]])
         end
 
-        it "ignores the right, but not the left margin if aligned right to the frame border" do
-          check_box({width: 50, height: 50, margin: 10, position: :float, position_hint: :right},
-                    [60, 60],
-                    [50, 50, 110, 110],
-                    [[[10, 10], [110, 10], [110, 50], [50, 50], [50, 110], [10, 110]]])
+        it "respects the top and bottom margins for the mask" do
+          remove_area(:top, :bottom)
+          check_box({width: 50, margin: 10, mask_mode: :fill_horizontal},
+                    [10, 30], [10, 20, 110, 100], [])
+        end
+      end
+
+      describe "fill_frame_horizontal" do
+        it "removes the horizontal part to the bottom of the box in the frame" do
+          remove_area(:left, :right)
+          check_box({width: 50, height: 50, mask_mode: :fill_frame_horizontal},
+                    [20, 60],
+                    [10, 60, 110, 110],
+                    [[[20, 10], [100, 10], [100, 60], [20, 60]]])
         end
 
-        it "uses the left and the right margin if aligned right and not to the frame border" do
-          remove_area(:right)
-          check_box({width: 50, height: 50, margin: 10, position: :float, position_hint: :right},
-                    [40, 60],
-                    [30, 50, 100, 110],
-                    [[[10, 10], [100, 10], [100, 50], [30, 50], [30, 110], [10, 110]]])
+        it "respects the bottom margin for the mask" do
+          remove_area(:left, :right, :top, :bottom)
+          check_box({width: 50, margin: 10, mask_mode: :fill_frame_horizontal},
+                    [30, 30], [10, 20, 110, 100], [])
         end
       end
-    end
 
-    describe "flowing boxes" do
-      it "flows inside the frame's outline" do
-        check_box({width: 10, height: 20, margin: 10, position: :flow},
-                  [0, 90],
-                  [10, 80, 110, 110],
-                  [[[10, 10], [110, 10], [110, 80], [10, 80]]])
+      describe "fill_vertical" do
+        it "removes the vertical part covering the box in the current region" do
+          check_box({width: 50, height: 50, mask_mode: :fill_vertical, align: :center},
+                    [35, 60],
+                    [35, 10, 85, 110],
+                    [[[10, 10], [35, 10], [35, 110], [10, 110]],
+                      [[85, 10], [110, 10], [110, 110], [85, 110]]])
+        end
+
+        it "respects the left and right margins for the mask" do
+          check_box({width: 50, height: 50, margin: 10, mask_mode: :fill_vertical, align: :center},
+                    [35, 60],
+                    [25, 10, 95, 110],
+                    [[[10, 10], [25, 10], [25, 110], [10, 110]],
+                      [[95, 10], [110, 10], [110, 110], [95, 110]]])
+        end
       end
 
-      it "uses position=default if the box indicates it doesn't support flowing contents" do
-        check_box({width: 10, height: 20, margin: 10, position: :flow, doesnt_support_position_flow: true},
-                  [10, 90],
-                  [10, 80, 110, 110],
-                  [[[10, 10], [110, 10], [110, 80], [10, 80]]])
+      describe "fill" do
+        it "removes the current region completely" do
+          check_box({width: 50, height: 50, mask_mode: :fill},
+                    [10, 60], [10, 10, 110, 110], [])
+        end
       end
     end
 

data/test/hexapdf/layout/test_list_box.rb

@@ -38,10 +38,10 @@ describe HexaPDF::Layout::ListBox do
 
   describe "initialize" do
     it "creates a new instance with the given arguments" do
-      box = create_box(children: [:a], item_type: :circle, content_indentation: 15,
+      box = create_box(children: [:a], marker_type: :circle, content_indentation: 15,
                        start_number: 4, item_spacing: 20)
       assert_equal([:a], box.children)
-      assert_equal(:circle, box.item_type)
+      assert_equal(:circle, box.marker_type)
       assert_equal(15, box.content_indentation)
       assert_equal(4, box.start_number)
       assert_equal(20, box.item_spacing)
@@ -109,7 +109,7 @@ describe HexaPDF::Layout::ListBox do
     end
 
     it "fails for unknown item types" do
-      box = create_box(children: @text_boxes[0, 1], item_type: :unknown)
+      box = create_box(children: @text_boxes[0, 1], marker_type: :unknown)
       assert_raises(HexaPDF::Error) { box.fit(100, 100, @frame) }
     end
   end
@@ -179,7 +179,7 @@ describe HexaPDF::Layout::ListBox do
     end
 
     it "draws a circle as marker" do
-      box = create_box(children: @fixed_size_boxes[0, 1], item_type: :circle,
+      box = create_box(children: @fixed_size_boxes[0, 1], marker_type: :circle,
                        style: {font_size: 11, fill_color: 0.5})
       box.fit(100, 100, @frame)
       box.draw(@canvas, 0, 100 - box.height)
@@ -201,7 +201,7 @@ describe HexaPDF::Layout::ListBox do
     end
 
     it "draws a square as marker" do
-      box = create_box(children: @fixed_size_boxes[0, 1], item_type: :square,
+      box = create_box(children: @fixed_size_boxes[0, 1], marker_type: :square,
                        style: {font_size: 11, fill_color: 0.5})
       box.fit(100, 100, @frame)
       box.draw(@canvas, 0, 100 - box.height)
@@ -223,7 +223,7 @@ describe HexaPDF::Layout::ListBox do
     end
 
     it "draws decimal numbers as marker" do
-      box = create_box(children: @fixed_size_boxes[0, 2], item_type: :decimal,
+      box = create_box(children: @fixed_size_boxes[0, 2], marker_type: :decimal,
                        style: {font_size: 11, fill_color: 0.5},
                        content_indentation: 20)
       box.fit(100, 100, @frame)
@@ -260,7 +260,7 @@ describe HexaPDF::Layout::ListBox do
       marker = lambda do |_doc, _list_box, _index|
         HexaPDF::Layout::Box.create(width: 10, height: 10) {}
       end
-      box = create_box(children: @fixed_size_boxes[0, 1], item_type: marker)
+      box = create_box(children: @fixed_size_boxes[0, 1], marker_type: marker)
       box.fit(100, 100, @frame)
       box.draw(@canvas, 0, 100 - box.height)
       operators = [

data/test/hexapdf/layout/test_style.rb

@@ -767,8 +767,8 @@ describe HexaPDF::Layout::Style do
     assert_equal(HexaPDF::Content::LineCapStyle::BUTT_CAP, @style.stroke_cap_style)
     assert_equal(HexaPDF::Content::LineJoinStyle::MITER_JOIN, @style.stroke_join_style)
     assert_equal(10.0, @style.stroke_miter_limit)
-    assert_equal(:left, @style.align)
-    assert_equal(:top, @style.valign)
+    assert_equal(:left, @style.text_align)
+    assert_equal(:top, @style.text_valign)
     assert_equal(0, @style.text_indent)
     assert_nil(@style.background_color)
     assert_equal(1, @style.background_alpha)
@@ -785,6 +785,10 @@ describe HexaPDF::Layout::Style do
     refute(@style.fill_horizontal)
     assert_kind_of(HexaPDF::Layout::Style::Layers, @style.underlays)
     assert_kind_of(HexaPDF::Layout::Style::Layers, @style.overlays)
+    assert_equal(:default, @style.position)
+    assert_equal(:left, @style.align)
+    assert_equal(:top, @style.valign)
+    assert_equal(:default, @style.mask_mode)
   end
 
   it "allows using a non-standard setter for generated properties" do
@@ -800,18 +804,18 @@ describe HexaPDF::Layout::Style do
   end
 
   it "allows checking for valid values" do
-    error = assert_raises(ArgumentError) { @style.align = :none }
-    assert_match(/not a valid align value \(:left, :center, :right, :justify\)/, error.message)
+    error = assert_raises(ArgumentError) { @style.text_align = :none }
+    assert_match(/not a valid text_align value \(:left, :center, :right, :justify\)/, error.message)
   end
 
   it "allows checking whether a property has been set or accessed" do
-    refute(@style.align?)
-    assert_equal(:left, @style.align)
-    assert(@style.align?)
+    refute(@style.text_align?)
+    assert_equal(:left, @style.text_align)
+    assert(@style.text_align?)
 
-    refute(@style.valign?)
-    @style.valign = :bottom
-    assert(@style.valign?)
+    refute(@style.text_valign?)
+    @style.text_valign = :bottom
+    assert(@style.text_valign?)
   end
 
   it "has several dynamically generated properties with default values that take blocks" do

data/test/hexapdf/layout/test_table_box.rb

@@ -83,7 +83,7 @@ describe HexaPDF::Layout::TableBox::Cell do
     end
 
     it "fits a single box with horizontal aligning not being :left" do
-      cell = create_cell(children: HexaPDF::Layout::Box.create(width: 20, height: 10, position_hint: :center))
+      cell = create_cell(children: HexaPDF::Layout::Box.create(width: 20, height: 10, align: :center))
       cell.fit(100, 100, @frame)
       assert_equal(66, cell.preferred_width)
     end
@@ -100,7 +100,7 @@ describe HexaPDF::Layout::TableBox::Cell do
     end
 
     it "fits multiple boxes with horizontal aligning not being :left" do
-      box1 = HexaPDF::Layout::Box.create(width: 20, height: 10, position_hint: :center)
+      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)
@@ -130,7 +130,7 @@ describe HexaPDF::Layout::TableBox::Cell do
 
     it "draws the boxes at the correct location" do
       draw_block = lambda {|canvas, _| canvas.move_to(0, 0).end_path }
-      box1 = HexaPDF::Layout::Box.create(width: 20, height: 10, position_hint: :center, &draw_block)
+      box1 = HexaPDF::Layout::Box.create(width: 20, height: 10, align: :center, &draw_block)
       box2 = HexaPDF::Layout::Box.create(width: 50, height: 15, &draw_block)
       box = create_cell(children: [box1, box2])
       box.fit(100, 100, @frame)

data/test/hexapdf/layout/test_text_box.rb

@@ -66,7 +66,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: {align: align})
+        box = create_box([@inline_box], style: {text_align: align})
         assert(box.fit(100, 100, @frame))
         assert_equal(100, box.width)
       end
@@ -74,7 +74,7 @@ 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: {valign: valign})
+        box = create_box([@inline_box], style: {text_valign: valign})
         assert(box.fit(100, 100, @frame))
         assert_equal(100, box.height)
       end

data/test/hexapdf/layout/test_text_fragment.rb

@@ -34,6 +34,43 @@ describe HexaPDF::Layout::TextFragment do
     end
   end
 
+  describe "create_with_fallback_glyphs" do
+    it "creates an array with a single fragment object if no block is given" do
+      frags = HexaPDF::Layout::TextFragment.create_with_fallback_glyphs("Tom", font: @font, font_size: 20)
+      assert_equal(1, frags.size)
+      assert_equal(37.78, frags[0].width)
+    end
+
+    it "allows using a style object instead of directly specifying style properties" do
+      style = HexaPDF::Layout::Style.new(font: @font, font_size: 20)
+      frags = HexaPDF::Layout::TextFragment.create_with_fallback_glyphs("Tom", style)
+      assert_equal(37.78, frags[0].width)
+    end
+
+    it "replaces invalid glyphs with the result of the block" do
+      zapf_dingbats = @doc.fonts.add('ZapfDingbats')
+      i = 0
+      fallback = lambda do |codepoint, invalid_glyph|
+        case (i += 1) % 3
+        when 0 then []
+        when 1 then [zapf_dingbats.decode_codepoint(codepoint)]
+        when 2 then @font.decode_utf8("Tom")
+        end
+      end
+      style = HexaPDF::Layout::Style.new(font: @font, font_size: 20, font_features: {kern: true})
+
+      frags = HexaPDF::Layout::TextFragment.create_with_fallback_glyphs("✂Tom✂✂Tom✂", style, &fallback)
+      assert_equal(5, frags.size)
+      assert_equal(zapf_dingbats, frags[0].style.font)
+      assert_equal(:a2, frags[0].items[0].name)
+      assert_equal(@font, frags[2].style.font)
+
+      frags = HexaPDF::Layout::TextFragment.create_with_fallback_glyphs("Tom✂Tom", style, &fallback)
+      assert_equal(3, frags.size)
+      assert_equal(frags[0].width, frags[1].width)
+    end
+  end
+
   describe "initialize" do
     before do
       @items = @font.decode_utf8("Tom")