hexapdf 0.6.0 → 0.7.0

data/test/hexapdf/layout/test_text_fragment.rb

@@ -16,15 +16,23 @@ describe HexaPDF::Layout::TextFragment do
     style = HexaPDF::Layout::Style.new(font: @font, font_size: 20,
                                        horizontal_scaling: 200, character_spacing: 1,
                                        word_spacing: 2, text_rise: text_rise)
-    @fragment = HexaPDF::Layout::TextFragment.new(items: items, style: style)
+    @fragment = HexaPDF::Layout::TextFragment.new(items, style)
   end
 
-  it "creates a TextFragment from text and options" do
-    frag = HexaPDF::Layout::TextFragment.create("Tom", font: @font, font_size: 20,
-                                                font_features: {kern: true})
-    assert_equal(4, frag.items.length)
-    assert_equal(36.18, frag.width)
-    assert_equal(13.66 + 4.34, frag.height)
+  describe "create" do
+    it "creates a TextFragment from text and options" do
+      frag = HexaPDF::Layout::TextFragment.create("Tom", font: @font, font_size: 20,
+                                                  font_features: {kern: true})
+      assert_equal(4, frag.items.length)
+      assert_equal(36.18, frag.width)
+      assert_equal(13.66 + 4.34, frag.height)
+    end
+
+    it "creates a TextFragment from text and a Style object" do
+      style = HexaPDF::Layout::Style.new(font: @font)
+      frag = HexaPDF::Layout::TextFragment.create("Tom", style)
+      assert_equal(style, frag.style)
+    end
   end
 
   describe "initialize" do
@@ -34,12 +42,12 @@ describe HexaPDF::Layout::TextFragment do
 
     it "can use a Style object" do
       style = HexaPDF::Layout::Style.new(font: @font, font_size: 20)
-      frag = HexaPDF::Layout::TextFragment.new(items: @items, style: style)
+      frag = HexaPDF::Layout::TextFragment.new(@items, style)
       assert_equal(20, frag.style.font_size)
     end
 
-    it "can use a style options" do
-      frag = HexaPDF::Layout::TextFragment.new(items: @items, style: {font: @font, font_size: 20})
+    it "can use style options" do
+      frag = HexaPDF::Layout::TextFragment.new(@items, font: @font, font_size: 20)
       assert_equal(20, frag.style.font_size)
     end
   end
@@ -51,7 +59,7 @@ describe HexaPDF::Layout::TextFragment do
   describe "draw" do
     def setup_with_style(**styles)
       setup_fragment(@font.decode_utf8('H'), 2)
-      styles.each {|name, value| @fragment.style.send(name, value)}
+      styles.each {|name, value| @fragment.style.send(name, value) }
       @canvas = @doc.pages.add.canvas
       @fragment.draw(@canvas, 10, 15)
     end
@@ -59,16 +67,15 @@ describe HexaPDF::Layout::TextFragment do
     def assert_draw_operators(*args, front: [], middle: args, back: [])
       ops = [
         *front,
-        [:begin_text],
-        [:set_text_matrix, [1, 0, 0, 1, 10, 15]],
         [:set_font_and_size, [:F1, 20]],
-        [:set_leading, [24.0]],
         [:set_horizontal_scaling, [200]],
         [:set_character_spacing, [1]],
         [:set_word_spacing, [2]],
         [:set_text_rise, [2]],
         *middle,
-        [:show_text_with_positioning, [['!']]],
+        [:begin_text],
+        [:set_text_matrix, [1, 0, 0, 1, 10, 15]],
+        [:show_text, ['!']],
         *back,
       ].compact
       assert_operators(@canvas.contents, ops)
@@ -79,6 +86,47 @@ describe HexaPDF::Layout::TextFragment do
       assert_draw_operators
     end
 
+    it "doesn't set the text properties if instructed to do so" do
+      setup_fragment([])
+      @canvas = @doc.pages.add.canvas
+      @fragment.draw(@canvas, 10, 15, ignore_text_properties: true)
+      assert_operators(@canvas.contents, [[:begin_text],
+                                          [:set_text_matrix, [1, 0, 0, 1, 10, 15]]])
+    end
+
+    describe "uses an appropriate text position setter" do
+      before do
+        setup_fragment([])
+        @canvas = @doc.pages.add.canvas
+      end
+
+      it "with text leading graphics state" do
+        @canvas.begin_text.leading(10)
+        @fragment.draw(@canvas, 0, -10, ignore_text_properties: true)
+        assert_operators(@canvas.contents, [[:begin_text],
+                                            [:set_leading, [10]],
+                                            [:move_text_next_line]])
+      end
+
+      it "only horizontal movement" do
+        @fragment.draw(@canvas, 20, 0, ignore_text_properties: true)
+        assert_operators(@canvas.contents, [[:begin_text],
+                                            [:move_text, [20, 0]]])
+      end
+
+      it "only vertical movement" do
+        @fragment.draw(@canvas, 0, 10, ignore_text_properties: true)
+        assert_operators(@canvas.contents, [[:begin_text],
+                                            [:move_text, [0, 10]]])
+      end
+
+      it "horizontal and vertical movement" do
+        @fragment.draw(@canvas, 10, 10, ignore_text_properties: true)
+        assert_operators(@canvas.contents, [[:begin_text],
+                                            [:set_text_matrix, [1, 0, 0, 1, 10, 10]]])
+      end
+    end
+
     it "draws styled filled text" do
       setup_with_style(fill_color: 0.5, fill_alpha: 0.5)
       assert_draw_operators([:set_graphics_state_parameters, [:GS1]],
@@ -132,14 +180,16 @@ describe HexaPDF::Layout::TextFragment do
                                      [:set_line_width, [5]],
                                      [:set_line_cap_style, [1]],
                                      [:set_line_dash_pattern, [[5], 0]]],
-        back: [[:set_device_gray_stroking_color, [0]],
+        back: [[:end_text],
+               [:save_graphics_state],
+               [:set_device_gray_stroking_color, [0]],
                [:set_line_width, [@fragment.style.calculated_underline_thickness]],
                [:set_line_cap_style, [0]],
                [:set_line_dash_pattern, [[], 0]],
-               [:end_text],
                [:move_to, [10, 15]],
                [:line_to, [40.88, 15]],
-               [:stroke_path]])
+               [:stroke_path],
+               [:restore_graphics_state]])
     end
 
     it "draws the strikeout line" do
@@ -151,14 +201,16 @@ describe HexaPDF::Layout::TextFragment do
                                      [:set_line_width, [5]],
                                      [:set_line_cap_style, [1]],
                                      [:set_line_dash_pattern, [[5], 0]]],
-        back: [[:set_device_gray_stroking_color, [0]],
+        back: [[:end_text],
+               [:save_graphics_state],
+               [:set_device_gray_stroking_color, [0]],
                [:set_line_width, [@fragment.style.calculated_strikeout_thickness]],
                [:set_line_cap_style, [0]],
                [:set_line_dash_pattern, [[], 0]],
-               [:end_text],
                [:move_to, [10, 21.01]],
                [:line_to, [40.88, 21.01]],
-               [:stroke_path]])
+               [:stroke_path],
+               [:restore_graphics_state]])
     end
   end
 
@@ -190,12 +242,6 @@ describe HexaPDF::Layout::TextFragment do
     it "calculates the height" do
       assert_equal(13.66 + 4.34, @fragment.height)
     end
-
-    it "draws nothing" do
-      canvas = @doc.pages.add.canvas
-      @fragment.draw(canvas, 10, 15)
-      assert_operators(canvas.contents, [])
-    end
   end
 
   describe "normal text" do

data/test/hexapdf/layout/test_text_layouter.rb

@@ -48,6 +48,13 @@ module TestTextLayouterHelpers
       assert_equal(item.items, obj.item.items)
     end
   end
+
+  def assert_line_wrapping(result, widths)
+    rest, lines = *result
+    assert(rest.empty?)
+    assert_equal(widths.length, lines.count)
+    widths.each_with_index {|width, index| assert_equal(width, lines[index].width) }
+  end
 end
 
 describe HexaPDF::Layout::TextLayouter::SimpleTextSegmentation do
@@ -61,14 +68,14 @@ describe HexaPDF::Layout::TextLayouter::SimpleTextSegmentation do
 
   def setup_fragment(text, style = nil)
     if style
-      HexaPDF::Layout::TextFragment.new(items: style.font.decode_utf8(text), style: style)
+      HexaPDF::Layout::TextFragment.create(text, style)
     else
       HexaPDF::Layout::TextFragment.create(text, font: @font)
     end
   end
 
   it "handles InlineBox objects" do
-    input = HexaPDF::Layout::InlineBox.create(width: 10, height: 10) { }
+    input = HexaPDF::Layout::InlineBox.create(width: 10, height: 10) {}
     result = @obj.call([input, input])
     assert_equal(2, result.size)
     assert_box(result[0], input)
@@ -103,11 +110,12 @@ describe HexaPDF::Layout::TextLayouter::SimpleTextSegmentation do
   end
 
   it "insert a mandatory break when an Unicode line boundary characters is encountered" do
-    frag = setup_fragment("A\rB\r\nC\nD\vE\fF\u{85}G\u{2029}H\u{2028}I")
+    frag = setup_fragment("A\rB\r\nC\nD\vE\fF\u{85}G\u{2029}H\u{2028}I\r")
+    frag.items << 5 << frag.items[-2]
 
     result = @obj.call([frag])
-    assert_equal(17, result.size)
-    [1, 3, 5, 7, 9, 11, 13].each do |index|
+    assert_equal(20, result.size)
+    [1, 3, 5, 7, 9, 11, 13, 17, 19].each do |index|
       assert_penalty(result[index],
                      HexaPDF::Layout::TextLayouter::Penalty::MandatoryParagraphBreak.penalty)
     end
@@ -163,98 +171,83 @@ module CommonLineWrappingTests
 
   it "breaks before a box if it doesn't fit onto the line anymore" do
     rest, lines = call(boxes(25, 50, 25, 10))
-    assert(rest.empty?)
-    assert_equal(2, lines.count)
-    lines.each {|line| line.items.each {|item| assert_kind_of(HexaPDF::Layout::InlineBox, item)}}
-    assert_equal(100, lines[0].width)
-    assert_equal(10, lines[1].width)
+    assert_line_wrapping([rest, lines], [100, 10])
+    lines.each {|line| line.items.each {|item| assert_kind_of(HexaPDF::Layout::InlineBox, item) } }
   end
 
   it "breaks at a glue and ignores it if it doesn't fit onto the line anymore" do
-    rest, lines = call(boxes(90, 20).insert(-2, glue(20)))
-    assert(rest.empty?)
-    assert_equal(2, lines.count)
-    assert_equal(90, lines[0].width)
-    assert_equal(20, lines[1].width)
+    result = call(boxes(90) + [glue(20)] + boxes(20))
+    assert_line_wrapping(result, [90, 20])
   end
 
   it "handles spaces at the start of a line" do
-    rest, lines = call(boxes(25, 50).unshift(glue(15)))
-    assert(rest.empty?)
-    assert_equal(1, lines.count)
-    assert_equal(75, lines[0].width)
+    rest, lines = call([glue(15)] + boxes(25, 50))
+    assert_line_wrapping([rest, lines], [75])
     assert_equal(25, lines[0].items[0].width)
   end
 
   it "handles spaces at the end of a line" do
-    rest, lines = call(boxes(20, 50, 20).insert(-2, glue(10)).insert(-2, glue(10)))
-    assert(rest.empty?)
-    assert_equal(2, lines.count)
-    assert_equal(70, lines[0].width)
-    assert_equal(20, lines[1].width)
+    rest, lines = call(boxes(20, 50) + [glue(10), glue(10)] + boxes(20))
+    assert_line_wrapping([rest, lines], [70, 20])
     assert_equal(50, lines[0].items[-1].width)
   end
 
   it "handles spaces at the end of a line before a mandatory break" do
-    rest, lines = call(boxes(20, 50, 20).insert(-2, glue(10)).insert(-2, penalty(-5000)))
-    assert(rest.empty?)
-    assert_equal(2, lines.count)
-    assert_equal(70, lines[0].width)
-    assert_equal(20, lines[1].width)
+    rest, lines = call(boxes(20, 50) + [glue(10), penalty(-5000)] + boxes(20))
+    assert_line_wrapping([rest, lines], [70, 20])
     assert_equal(50, lines[0].items[-1].width)
   end
 
   it "handles multiple glue items after another" do
-    rest, lines = call(boxes(20, 20, 50, 20).insert(1, glue(20)).insert(1, glue(20)))
-    assert(rest.empty?)
-    assert_equal(2, lines.count)
-    assert_equal(80, lines[0].width)
-    assert_equal(70, lines[1].width)
+    result = call(boxes(20) + [glue(20), glue(20)] + boxes(20, 50, 20))
+    assert_line_wrapping(result, [80, 70])
   end
 
   it "handles mandatory line breaks" do
-    rest, lines = call(boxes(20, 20).insert(-2, penalty(-5000)))
-    assert(rest.empty?)
-    assert_equal(2, lines.count)
-    assert_equal(20, lines[0].width)
-    assert_equal(20, lines[1].width)
+    rest, lines = call(boxes(20) + [penalty(-5000)] + boxes(20))
+    assert_line_wrapping([rest, lines], [20, 20])
     assert(lines[0].ignore_justification?)
   end
 
   it "handles breaking at penalties with zero width" do
-    rest, lines = call(boxes(80, 10, 20).insert(1, penalty(0)).insert(-2, penalty(0)))
-    assert(rest.empty?)
-    assert_equal(2, lines.count)
-    assert_equal(90, lines[0].width)
-    assert_equal(20, lines[1].width)
+    result = call(boxes(80) + [penalty(0)] + boxes(10) + [penalty(0)] + boxes(20))
+    assert_line_wrapping(result, [90, 20])
   end
 
   it "handles breaking at penalties with non-zero width if they fit on the line" do
-    item = HexaPDF::Layout::InlineBox.create(width: 20) {}
-    rest, lines = call(boxes(20, 60, 30).insert(1, penalty(0, item)).insert(-2, penalty(0, item)))
-    assert(rest.empty?)
-    assert_equal(2, lines.count)
-    assert_equal(100, lines[0].width)
-    assert_equal(30, lines[1].width)
-    assert_same(item, lines[0].items[-1])
+    pitem = penalty(0, boxes(20).first)
+    rest, lines = call(boxes(20) + [pitem] + boxes(50) + [glue(10), pitem] + boxes(30))
+    assert_line_wrapping([rest, lines], [100, 30])
+    assert_same(pitem.item, lines[0].items[-1])
+  end
+
+  it "handles breaking at penalties with non-zero width that fit on the line and are followed by 1+ penalties" do
+    pitem = penalty(0, boxes(20).first)
+    result = call(boxes(80) + [pitem, penalty(0), penalty(0)] + boxes(30))
+    assert_line_wrapping(result, [100, 30])
   end
 
   it "handles penalties with non-zero width if they don't fit on the line" do
-    item = HexaPDF::Layout::InlineBox.create(width: 20) {}
-    rest, lines = call(boxes(70) + [glue(10)] + boxes(10) + [penalty(0, item)] + boxes(30))
-    assert(rest.empty?)
-    assert_equal(2, lines.count)
-    assert_equal(70, lines[0].width)
-    assert_equal(40, lines[1].width)
+    item = boxes(20).first
+    result = call(boxes(70) + [glue(10)] + boxes(10) + [penalty(0, item)] + boxes(30))
+    assert_line_wrapping(result, [70, 40])
   end
 
-  it "handles breaking at prohibited breakpoints by back-tracking to the last valid breakpoint " do
-    item = HexaPDF::Layout::InlineBox.create(width: 20) {}
-    rest, lines = call(boxes(70) + [glue(10)] + boxes(10) + [penalty(5000, item)] + boxes(30))
-    assert(rest.empty?)
-    assert_equal(2, lines.count)
-    assert_equal(70, lines[0].width)
-    assert_equal(60, lines[1].width)
+  it "handles breaking at penalties with non-zero width surrounded by glue" do
+    item = boxes(20).first
+    result = call(boxes(70) + [glue(10)] + [penalty(0, item)] + [glue(30)] + boxes(30))
+    assert_line_wrapping(result, [100, 30])
+  end
+
+  it "handles prohibited breakpoint penalties with zero width" do
+    result = call(boxes(70) + [glue(10)] + boxes(10) + [penalty(5000)] + boxes(30))
+    assert_line_wrapping(result, [70, 40])
+  end
+
+  it "handles prohibited breakpoint penalties with non-zero width" do
+    item = boxes(20).first
+    result = call(boxes(70) + [glue(10)] + boxes(10) + [penalty(5000, item)] + boxes(30))
+    assert_line_wrapping(result, [70, 60])
   end
 
   it "stops when nil is returned by the block: last item is a box" do
@@ -527,7 +520,7 @@ describe HexaPDF::Layout::TextLayouter do
         rest, reason = layouter.fit
         assert(rest.empty?)
         assert_equal(:success, reason)
-        assert_equal(str.strip.length, layouter.lines.sum {|l| l.items.sum {|i| i.items.count}})
+        assert_equal(str.strip.length, layouter.lines.sum {|l| l.items.sum {|i| i.items.count } })
         assert_equal(45, layouter.actual_height)
 
         layouter = HexaPDF::Layout::TextLayouter.new(items: [frag], width: 1, height: height,
@@ -564,7 +557,7 @@ describe HexaPDF::Layout::TextLayouter do
     end
 
     it "applies the optional horizontal offsets if set" do
-      x_offsets = lambda {|height, line_height| height + line_height}
+      x_offsets = lambda {|height, line_height| height + line_height }
       layouter = HexaPDF::Layout::TextLayouter.new(items: boxes(*([[20, 10]] * 7)), width: 60,
                                                    x_offsets: x_offsets, height: 100, style: @style)
       rest, reason = layouter.fit
@@ -582,7 +575,17 @@ describe HexaPDF::Layout::TextLayouter do
       processor = TestHelper::OperatorRecorder.new
       HexaPDF::Content::Parser.new.parse(content, processor)
       result = processor.recorded_ops
-      result.select! {|name, _| name == :set_text_matrix}.map! {|_, ops| ops[-2, 2]}
+      leading = (result.select {|name, _| name == :set_leading } || [0]).map(&:last).flatten.first
+      pos = [0, 0]
+      result.select! {|name, _| name == :set_text_matrix || name == :move_text_next_line }.
+        map! do |name, ops|
+        if name == :set_text_matrix
+          pos = ops[-2, 2]
+        elsif name == :move_text_next_line
+          pos[1] -= leading
+        end
+        pos.dup
+      end
       positions.each_with_index do |(x, y), index|
         assert_in_delta(x, result[index][0], 0.00001)
         assert_in_delta(y, result[index][1], 0.00001)
@@ -600,6 +603,19 @@ describe HexaPDF::Layout::TextLayouter do
       @line2w = HexaPDF::Layout::TextFragment.create("more text.", font: @font).width
     end
 
+    it "returns the result of #fit if #fit needs to be run" do
+      rest, reason = @layouter.draw(@canvas, 0, 0)
+      assert(rest.empty?)
+      assert_equal(:success, reason)
+
+      @layouter.items = [HexaPDF::Layout::InlineBox.create(width: @width + 10) {}]
+      rest, reason = @layouter.draw(@canvas, 0, 0)
+      assert_equal(1, rest.size)
+      assert_equal(:box, reason)
+
+      assert_nil(@layouter.draw(@canvas, 0, 0))
+    end
+
     it "can horizontally align the contents to the left" do
       top = 100
       @layouter.style.align = :left
@@ -697,7 +713,7 @@ describe HexaPDF::Layout::TextLayouter do
 
     it "makes sure that text fragments don't pollute the graphics state for inline boxes" do
       frag = HexaPDF::Layout::TextFragment.create("Demo", font: @font)
-      inline_box = HexaPDF::Layout::InlineBox.create(width: 10, height: 10) {|c, _| c.text("A")}
+      inline_box = HexaPDF::Layout::InlineBox.create(width: 10, height: 10) {|c, _| c.text("A") }
       layouter = HexaPDF::Layout::TextLayouter.new(items: [frag, inline_box], width: 200)
       assert_raises(HexaPDF::Error) { layouter.draw(@canvas, 0, 0) }
     end

data/test/hexapdf/layout/test_text_shaper.rb

@@ -16,7 +16,7 @@ describe HexaPDF::Layout::TextShaper do
 
   def setup_fragment(items, **options)
     style = HexaPDF::Layout::Style.new(font: @font, font_size: 20, font_features: options)
-    HexaPDF::Layout::TextFragment.new(items: items, style: style)
+    HexaPDF::Layout::TextFragment.new(items, style)
   end
 
   describe "Type1 font features" do
@@ -29,14 +29,14 @@ describe HexaPDF::Layout::TextShaper do
         insert(0, 100), liga: true)
       @shaper.shape_text(fragment)
       assert_equal([100, :fi, :s, :h, :space, :fi, :s, :h, :space, :fi],
-                   fragment.items.map {|item| item.kind_of?(Numeric) ? item : item.id})
+                   fragment.items.map {|item| item.kind_of?(Numeric) ? item : item.id })
     end
 
     it "handles kerning" do
       fragment = setup_fragment(@font.decode_utf8('fish fish wow').insert(1, 100), kern: true)
       @shaper.shape_text(fragment)
       assert_equal([:f, 100, :i, :s, :h, :space, :f, 20, :i, :s, :h, :space, :w, 10, :o, 25, :w],
-                   fragment.items.map {|item| item.kind_of?(Numeric) ? item : item.id})
+                   fragment.items.map {|item| item.kind_of?(Numeric) ? item : item.id })
     end
   end
 
@@ -56,9 +56,7 @@ describe HexaPDF::Layout::TextShaper do
       fragment = setup_fragment(@font.decode_utf8('Top Top').insert(1, 100), kern: true)
       @shaper.shape_text(fragment)
       assert_equal([53, [100], 80, [10], 81, 3, 53, [20], 80, [10], 81],
-                   fragment.items.map {|item| item.kind_of?(Numeric) ? [item] : item.id})
+                   fragment.items.map {|item| item.kind_of?(Numeric) ? [item] : item.id })
     end
   end
 end
-
-