hexapdf 0.15.8 → 0.17.1

data/test/hexapdf/layout/test_text_box.rb

@@ -1,140 +0,0 @@
-# -*- encoding: utf-8 -*-
-
-require 'test_helper'
-require_relative '../content/common'
-require 'hexapdf/document'
-require 'hexapdf/layout/text_box'
-
-describe HexaPDF::Layout::TextBox do
-  before do
-    @frame = HexaPDF::Layout::Frame.new(0, 0, 100, 100)
-    @inline_box = HexaPDF::Layout::InlineBox.create(width: 10, height: 10) {}
-  end
-
-  def create_box(items, **kwargs)
-    HexaPDF::Layout::TextBox.new(items, **kwargs)
-  end
-
-  describe "initialize" do
-    it "takes the inline items to be layed out in the box" do
-      box = create_box([], width: 100)
-      assert_equal(100, box.width)
-    end
-  end
-
-  describe "fit" do
-    it "fits into a rectangular area" do
-      box = create_box([@inline_box] * 5, style: {padding: 10})
-      assert(box.fit(100, 100, @frame))
-      assert_equal(70, box.width)
-      assert_equal(30, box.height)
-    end
-
-    it "respects the set width and height" do
-      box = create_box([@inline_box], width: 40, height: 50, style: {padding: 10})
-      assert(box.fit(100, 100, @frame))
-      assert_equal(40, box.width)
-      assert_equal(50, box.height)
-      assert_equal([10], box.instance_variable_get(:@result).lines.map(&:width))
-    end
-
-    it "fits into the frame's outline" do
-      inline_box = HexaPDF::Layout::InlineBox.create(width: 10, height: 10) {}
-      box = create_box([inline_box] * 20, style: {position: :flow})
-      assert(box.fit(100, 100, @frame))
-      assert_equal(100, 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))
-      assert_equal(50, box.width)
-      assert_equal(20, box.height)
-    end
-
-    it "can't fit the text box if the set width is bigger than the available width" do
-      box = create_box([@inline_box], width: 101)
-      refute(box.fit(100, 100, @frame))
-    end
-
-    it "can't fit the text box if the set height is bigger than the available height" do
-      box = create_box([@inline_box], height: 101)
-      refute(box.fit(100, 100, @frame))
-    end
-  end
-
-  describe "split" do
-    it "works for an empty text box" do
-      box = create_box([])
-      assert_equal([box], box.split(100, 100, @frame))
-    end
-
-    it "doesn't need to split the box if it completely fits" do
-      box = create_box([@inline_box] * 5)
-      assert_equal([box], box.split(50, 100, @frame))
-    end
-
-    it "works if no item of the text box fits" do
-      box = create_box([@inline_box])
-      assert_equal([nil, box], box.split(5, 20, @frame))
-    end
-
-    it "works if the whole text box doesn't fits" do
-      box = create_box([@inline_box], width: 102)
-      assert_equal([nil, box], box.split(100, 100, @frame))
-
-      box = create_box([@inline_box], height: 102)
-      assert_equal([nil, box], box.split(100, 100, @frame))
-    end
-
-    it "splits the box if necessary" do
-      box = create_box([@inline_box] * 10)
-      boxes = box.split(50, 10, @frame)
-      assert_equal(2, boxes.length)
-      assert_equal(box, boxes[0])
-      assert_equal(5, boxes[1].instance_variable_get(:@items).length)
-    end
-  end
-
-  describe "draw" do
-    it "draws the layed out inline items onto the canvas" do
-      inline_box = HexaPDF::Layout::InlineBox.create(width: 10, height: 10,
-                                                     border: {width: 1})
-      box = create_box([inline_box], width: 100, height: 30, style: {padding: [10, 5]})
-      box.fit(100, 100, nil)
-
-      @canvas = HexaPDF::Document.new.pages.add.canvas
-      box.draw(@canvas, 0, 0)
-      assert_operators(@canvas.contents, [[:save_graphics_state],
-                                          [:restore_graphics_state],
-                                          [:save_graphics_state],
-                                          [:append_rectangle, [5, 10, 10, 10]],
-                                          [:clip_path_non_zero],
-                                          [:end_path],
-                                          [:append_rectangle, [5.5, 10.5, 9, 9]],
-                                          [:stroke_path],
-                                          [:restore_graphics_state],
-                                          [:save_graphics_state],
-                                          [:restore_graphics_state]])
-    end
-
-    it "draws nothing onto the canvas if the box is empty" do
-      @canvas = HexaPDF::Document.new.pages.add.canvas
-      box = create_box([])
-      box.draw(@canvas, 5, 5)
-      assert_operators(@canvas.contents, [])
-    end
-  end
-
-  it "is empty if there is a result without any text lines" do
-    box = create_box([])
-    assert(box.empty?)
-    box.fit(100, 100, @frame)
-    assert(box.empty?)
-
-    box = create_box([@inline_box])
-    box.fit(100, 100, @frame)
-    refute(box.empty?)
-  end
-end

data/test/hexapdf/layout/test_text_fragment.rb

@@ -1,375 +0,0 @@
-# -*- encoding: utf-8 -*-
-
-require 'test_helper'
-require_relative '../content/common'
-require 'hexapdf/document'
-require 'hexapdf/layout/text_fragment'
-
-# Numeric values were manually calculated using the information from the AFM file.
-describe HexaPDF::Layout::TextFragment do
-  before do
-    @doc = HexaPDF::Document.new
-    @font = @doc.fonts.add("Times", custom_encoding: true)
-  end
-
-  def setup_fragment(items, text_rise = 0)
-    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, style)
-  end
-
-  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
-    before do
-      @items = @font.decode_utf8("Tom")
-    end
-
-    it "can use a Style object" do
-      style = HexaPDF::Layout::Style.new(font: @font, font_size: 20)
-      frag = HexaPDF::Layout::TextFragment.new(@items, style)
-      assert_equal(20, frag.style.font_size)
-    end
-
-    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
-
-  it "returns :text for valign" do
-    assert_equal(:text, setup_fragment([]).valign)
-  end
-
-  describe "draw" do
-    def setup_with_style(**styles)
-      setup_fragment(@font.decode_utf8('H'), 2)
-      styles.each {|name, value| @fragment.style.send(name, value) }
-      @canvas = @doc.pages.add.canvas
-      @fragment.draw(@canvas, 10, 15)
-    end
-
-    def assert_draw_operators(*args, front: [], middle: args, back: [])
-      ops = [
-        *front,
-        [:set_font_and_size, [:F1, 20]],
-        [:set_horizontal_scaling, [200]],
-        [:set_character_spacing, [1]],
-        [:set_word_spacing, [2]],
-        [:set_text_rise, [2]],
-        *middle,
-        [:begin_text],
-        [:set_text_matrix, [1, 0, 0, 1, 10, 15]],
-        [:show_text, ['!']],
-        *back,
-      ].compact
-      assert_operators(@canvas.contents, ops)
-    end
-
-    it "draws text onto the canvas" do
-      setup_with_style
-      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]],
-                            [:set_device_gray_non_stroking_color, [0.5]])
-      assert_equal({Type: :ExtGState, CA: 1, ca: 0.5}, @canvas.resources[:ExtGState][:GS1])
-    end
-
-    it "draws style stroked text" do
-      setup_with_style(text_rendering_mode: :stroke,
-                       stroke_color: [1.0, 0, 0], stroke_alpha: 0.5, stroke_width: 2,
-                       stroke_cap_style: :round, stroke_join_style: :round, stroke_miter_limit: 5,
-                       stroke_dash_pattern: [1, 2, 3])
-      assert_draw_operators([:set_text_rendering_mode, [1]],
-                            [:set_graphics_state_parameters, [:GS1]],
-                            [:set_device_rgb_stroking_color, [1, 0, 0]],
-                            [:set_line_width, [2]],
-                            [:set_line_cap_style, [1]],
-                            [:set_line_join_style, [1]],
-                            [:set_miter_limit, [5]],
-                            [:set_line_dash_pattern, [[1, 2, 3], 0]])
-      assert_equal({Type: :ExtGState, CA: 0.5, ca: 1}, @canvas.resources[:ExtGState][:GS1])
-    end
-
-    it "invokes the underlays" do
-      setup_with_style(underlays: [proc { @canvas.stroke_color(0.5) }])
-      assert_draw_operators(front: [[:save_graphics_state],
-                                    [:concatenate_matrix, [1, 0, 0, 1, 10, 15 + @fragment.y_min]],
-                                    [:save_graphics_state],
-                                    [:set_device_gray_stroking_color, [0.5]],
-                                    [:restore_graphics_state],
-                                    [:restore_graphics_state]])
-    end
-
-    it "invokes the overlays" do
-      setup_with_style(overlays: [proc { @canvas.stroke_color(0.5) }])
-      assert_draw_operators(back: [[:end_text],
-                                   [:save_graphics_state],
-                                   [:concatenate_matrix, [1, 0, 0, 1, 10, 15 + @fragment.y_min]],
-                                   [:save_graphics_state],
-                                   [:set_device_gray_stroking_color, [0.5]],
-                                   [:restore_graphics_state],
-                                   [:restore_graphics_state]])
-    end
-
-    it "draws the underline" do
-      setup_with_style(underline: true, text_rendering_mode: :stroke,
-                       stroke_width: 5, stroke_color: [0.5], stroke_cap_style: :round,
-                       stroke_dash_pattern: 5)
-      assert_draw_operators(middle: [[:set_text_rendering_mode, [1]],
-                                     [:set_device_gray_stroking_color, [0.5]],
-                                     [:set_line_width, [5]],
-                                     [:set_line_cap_style, [1]],
-                                     [:set_line_dash_pattern, [[5], 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]],
-               [:move_to, [10, 15]],
-               [:line_to, [40.88, 15]],
-               [:stroke_path],
-               [:restore_graphics_state]])
-    end
-
-    it "draws the strikeout line" do
-      setup_with_style(strikeout: true, text_rendering_mode: :stroke,
-                       stroke_width: 5, stroke_color: [0.5], stroke_cap_style: :round,
-                       stroke_dash_pattern: 5)
-      assert_draw_operators(middle: [[:set_text_rendering_mode, [1]],
-                                     [:set_device_gray_stroking_color, [0.5]],
-                                     [:set_line_width, [5]],
-                                     [:set_line_cap_style, [1]],
-                                     [:set_line_dash_pattern, [[5], 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]],
-               [:move_to, [10, 21.01]],
-               [:line_to, [40.88, 21.01]],
-               [:stroke_path],
-               [:restore_graphics_state]])
-    end
-  end
-
-  describe "empty fragment" do
-    before do
-      setup_fragment([])
-    end
-
-    it "calculates the x_min" do
-      assert_equal(0, @fragment.x_min)
-    end
-
-    it "calculates the x_max" do
-      assert_equal(0, @fragment.x_max)
-    end
-
-    it "calculates the y_min" do
-      assert_equal(-4.34, @fragment.y_min)
-    end
-
-    it "calculates the y_max" do
-      assert_equal(13.66, @fragment.y_max)
-    end
-
-    it "calculates the width" do
-      assert_equal(0, @fragment.width)
-    end
-
-    it "calculates the height" do
-      assert_equal(13.66 + 4.34, @fragment.height)
-    end
-  end
-
-  describe "normal text" do
-    before do
-      setup_fragment(@font.decode_utf8("Hal lo").insert(2, -35).insert(1, -10))
-    end
-
-    it "calculates the x_min" do
-      assert_in_delta(0.76, @fragment.x_min)
-    end
-
-    it "calculates the x_max" do
-      assert_in_delta(116.68 - 1.2 - 2, @fragment.x_max)
-    end
-
-    it "calculates the exact y_min" do
-      assert_in_delta(-0.2, @fragment.exact_y_min)
-    end
-
-    it "calculates the exact y_max" do
-      assert_in_delta(13.66, @fragment.exact_y_max)
-    end
-
-    it "calculates the y_min" do
-      assert_in_delta(-4.34, @fragment.y_min)
-    end
-
-    it "calculates the y_max" do
-      assert_in_delta(13.66, @fragment.y_max)
-    end
-
-    it "calculates the width" do
-      assert_in_delta(116.68, @fragment.width)
-    end
-
-    it "calculates the height" do
-      assert_in_delta(13.66 + 4.34, @fragment.height)
-    end
-  end
-
-  describe "with a positive text rise" do
-    before do
-      setup_fragment(@font.decode_utf8("l,"), 4)
-    end
-
-    it "calculates the y_min" do
-      assert_in_delta(-4.34 + 4, @fragment.y_min)
-    end
-
-    it "calculates the y_max" do
-      assert_in_delta(13.66 + 4, @fragment.y_max)
-    end
-
-    it "calculates the height" do
-      assert_in_delta(13.66 + 4 + 0.34, @fragment.height)
-    end
-  end
-
-  describe "with a negative text rise" do
-    before do
-      setup_fragment(@font.decode_utf8("l,"), -15)
-    end
-
-    it "calculates the y_min" do
-      assert_in_delta(-4.34 - 15, @fragment.y_min)
-    end
-
-    it "calculates the y_max" do
-      assert_in_delta(13.66 - 15, @fragment.y_max)
-    end
-
-    it "calculates the height" do
-      assert_in_delta(4.34 + 15, @fragment.height)
-    end
-  end
-
-  describe "with a glyph without outline as last item" do
-    before do
-      setup_fragment(@font.decode_utf8("H "))
-    end
-
-    it "calculates the x_max" do
-      assert_in_delta(46.88 - 2 - 4, @fragment.x_max)
-    end
-
-    it "calculates the width" do
-      assert_in_delta(46.88, @fragment.width)
-    end
-  end
-
-  describe "with a glyph with x_min < 0 and x_max > width as first and last item" do
-    before do
-      setup_fragment(@font.decode_utf8("\u{2044}o\u{2044}".unicode_normalize(:nfd)))
-    end
-
-    it "calculates the x_min" do
-      assert_in_delta(-6.72, @fragment.x_min)
-    end
-
-    it "calculates the x_max" do
-      assert_in_delta(39.36 + 6.56 - 2, @fragment.x_max)
-    end
-
-    it "calculates the width" do
-      assert_in_delta(39.36, @fragment.width)
-    end
-  end
-
-  describe "with positive kerning values as first and last items" do
-    before do
-      setup_fragment([100, 100] + @font.decode_utf8("Hallo") + [100, 100])
-    end
-
-    it "calculates the x_min" do
-      assert_in_delta(-7.24, @fragment.x_min)
-    end
-
-    it "calculates the x_max" do
-      assert_in_delta(82.88 - 1.2 - 2 - -4 - -4, @fragment.x_max)
-    end
-
-    it "calculates the width" do
-      assert_in_delta(82.88, @fragment.width)
-    end
-  end
-
-  it "can be inspected" do
-    frag = setup_fragment(@font.decode_utf8("H"))
-    assert_match(/:H/, frag.inspect)
-  end
-end