hexapdf 0.4.0 → 0.5.0

data/test/hexapdf/font/true_type/test_font.rb

@@ -93,4 +93,8 @@ describe HexaPDF::Font::TrueType::Font do
   it "is able to return the ID of the missing glyph" do
     assert_equal(0, @font.missing_glyph_id)
   end
+
+  it "returns the features available for a font" do
+    assert(@font.features.empty?)
+  end
 end

data/test/hexapdf/font/type1/common.rb

@@ -0,0 +1,6 @@
+# -*- encoding: utf-8 -*-
+
+require 'hexapdf/font/type1'
+
+FONT_TIMES = HexaPDF::Font::Type1::Font.from_afm(File.join(HexaPDF.data_dir, 'afm', "Times-Roman.afm"))
+FONT_SYMBOL = HexaPDF::Font::Type1::Font.from_afm(File.join(HexaPDF.data_dir, 'afm', "Symbol.afm"))

data/test/hexapdf/font/type1/test_afm_parser.rb

@@ -1,6 +1,7 @@
 # -*- encoding: utf-8 -*-
 
 require 'test_helper'
+require_relative 'common'
 require 'hexapdf/font/type1'
 require 'hexapdf/data_dir'
 require 'tempfile'
@@ -38,6 +39,14 @@ describe HexaPDF::Font::Type1::AFMParser do
     end
   end
 
+  it "extracts kerning and ligature information" do
+    metrics = FONT_TIMES.metrics
+    glyph = metrics.character_metrics[:f]
+    assert_equal([20, 0, 383, 683], glyph.bbox)
+    assert_equal(-20, metrics.kerning_pairs.dig(:f, :i))
+    assert_equal(:fi, metrics.ligature_pairs.dig(:f, :i))
+  end
+
   it "calculates an ascender and descender value from the font bounding box if necessary" do
     metrics = HexaPDF::Font::Type1::AFMParser.parse(File.join(HexaPDF.data_dir, 'afm/Symbol.afm'))
     assert_equal(metrics.bounding_box[1], metrics.descender)

data/test/hexapdf/font/type1/test_font.rb

@@ -1,6 +1,7 @@
 # -*- encoding: utf-8 -*-
 
 require 'test_helper'
+require_relative 'common'
 require 'hexapdf/font/type1'
 
 describe HexaPDF::Font::Type1::Font do
@@ -65,4 +66,9 @@ describe HexaPDF::Font::Type1::Font do
   it "is able to return the ID of the missing glyph" do
     assert_equal(:'.notdef', @font.missing_glyph_id)
   end
+
+  it "returns the features available for a font" do
+    assert_equal([:kern, :liga].to_set, FONT_TIMES.features)
+    assert(FONT_SYMBOL.features.empty?)
+  end
 end

data/test/hexapdf/layout/test_inline_box.rb

@@ -0,0 +1,40 @@
+# -*- encoding: utf-8 -*-
+
+require 'test_helper'
+require 'hexapdf/layout/inline_box'
+
+describe HexaPDF::Layout::InlineBox do
+  before do
+    @box = HexaPDF::Layout::InlineBox.new(10, 15) {|box, canvas| [box, canvas]}
+  end
+
+  describe "draw" do
+    before do
+      @canvas = Object.new
+      @canvas.define_singleton_method(:translate) {|x, y, &block| [x, y, block.call] }
+    end
+
+    it "returns the value of the drawing block" do
+      assert_equal([1, 2, [@box, @canvas]], @box.draw(@canvas, 1, 2))
+    end
+  end
+
+  describe "valign" do
+    it "has a default value of :baseline" do
+      assert_equal(:baseline, @box.valign)
+    end
+
+    it "can be changed on creation" do
+      box = HexaPDF::Layout::InlineBox.new(10, 15, valign: :test) {}
+      assert_equal(:test, box.valign)
+    end
+  end
+
+  it "returns 0 for x_min" do
+    assert_equal(0, @box.x_min)
+  end
+
+  it "returns width for x_max" do
+    assert_equal(10, @box.x_max)
+  end
+end

data/test/hexapdf/layout/test_line_fragment.rb

@@ -0,0 +1,206 @@
+# -*- encoding: utf-8 -*-
+
+require 'test_helper'
+require 'hexapdf/document'
+
+describe HexaPDF::Layout::LineFragment::HeightCalculator do
+  before do
+    @calc = HexaPDF::Layout::LineFragment::HeightCalculator.new
+  end
+
+  it "simulate the height as if an item was added" do
+    @calc << HexaPDF::Layout::InlineBox.new(10, 20, valign: :baseline) {}
+    assert_equal([0, 20, 0, 0], @calc.result)
+    new_item = HexaPDF::Layout::InlineBox.new(10, 30, valign: :top) {}
+    assert_equal(30, @calc.simulate_height(new_item))
+    assert_equal([0, 20, 0, 0], @calc.result)
+  end
+end
+
+describe HexaPDF::Layout::LineFragment do
+  before do
+    @doc = HexaPDF::Document.new
+    @font = @doc.fonts.load("Times", custom_encoding: true)
+    @line = HexaPDF::Layout::LineFragment.new
+  end
+
+  def setup_fragment(text)
+    HexaPDF::Layout::TextFragment.create(text, font: @font, font_size: 10)
+  end
+
+  def setup_box(width, height, valign = :baseline)
+    HexaPDF::Layout::InlineBox.new(width, height, valign: valign) {}
+  end
+
+  describe "initialize" do
+    it "allows setting the items of the line fragment" do
+      frag1 = setup_fragment("Hello")
+      frag2 = HexaPDF::Layout::TextFragment.new(items: frag1.items.slice!(3, 2), style: frag1.style)
+      line = HexaPDF::Layout::LineFragment.new([frag1, frag2])
+      assert_equal(1, line.items.count)
+      assert_equal(5, line.items[0].items.count)
+    end
+  end
+
+  describe "add" do
+    it "adds items to the line" do
+      @line << :test << :other
+      assert_equal([:test, :other], @line.items)
+    end
+
+    it "combines text fragments if possible" do
+      frag1 = setup_fragment("Home")
+      frag2 = HexaPDF::Layout::TextFragment.new(items: frag1.items.slice!(2, 2), style: frag1.style)
+      @line << setup_fragment("o") << :other << frag1 << frag2
+      assert_equal(3, @line.items.length)
+      assert_equal(4, @line.items.last.items.length)
+    end
+
+    it "duplicates the first of two combinable text fragments if its items are frozen" do
+      frag1 = setup_fragment("Home")
+      frag2 = HexaPDF::Layout::TextFragment.new(items: frag1.items.slice!(2, 2), style: frag1.style)
+      frag1.items.freeze
+      frag2.items.freeze
+
+      @line << setup_fragment("o") << frag1 << frag2 << :other
+      assert_equal(3, @line.items.length)
+      assert_equal(4, @line.items[-2].items.length)
+    end
+  end
+
+  describe "with text fragments" do
+    before do
+      @frag_h = setup_fragment("H")
+      @frag_y = setup_fragment("y")
+      @line << @frag_h << @frag_y << @frag_h
+    end
+
+    it "calculates the various x/y values correctly" do
+      assert_equal(@frag_h.x_min, @line.x_min)
+      assert_equal(@frag_h.width + @frag_y.width + @frag_h.x_max, @line.x_max)
+      assert_equal(@frag_y.y_min, @line.y_min)
+      assert_equal(@frag_h.y_max, @line.y_max)
+      assert_equal(@frag_y.y_min, @line.text_y_min)
+      assert_equal(@frag_h.y_max, @line.text_y_max)
+      assert_equal(2 * @frag_h.width + @frag_y.width, @line.width)
+      assert_equal(@frag_h.y_max - @frag_y.y_min, @line.height)
+    end
+
+    describe "and with inline boxes" do
+      it "x_min is correct if an inline box is the first item" do
+        @line.items.unshift(setup_box(10, 10))
+        assert_equal(0, @line.x_min)
+      end
+
+      it "x_max is correct if an inline box is the last item" do
+        @line << setup_box(10, 10)
+        assert_equal(@line.width, @line.x_max)
+      end
+
+      it "doesn't change text_y_min/text_y_max" do
+        text_y_min, text_y_max = @line.text_y_min, @line.text_y_max
+        @line << setup_box(10, 30, :text_top) << setup_box(10, 30, :text_bottom)
+        @line.clear_cache
+        assert_equal(text_y_min, @line.text_y_min)
+        assert_equal(text_y_max, @line.text_y_max)
+      end
+
+      it "y values are not changed if all boxes are smaller than the text's height" do
+        *y_values = @line.y_min, @line.y_max, @line.text_y_min, @line.text_y_max
+        @line << setup_box(10, 5, :baseline)
+        @line.clear_cache
+        assert_equal(y_values, [@line.y_min, @line.y_max, @line.text_y_min, @line.text_y_max])
+      end
+
+      it "changes y_max to fit if baseline boxes are higher than the text" do
+        y_min = @line.y_min
+        box = setup_box(10, 50, :baseline)
+        @line.add(box)
+
+        @line.clear_cache
+        assert_equal(50, @line.y_max)
+        assert_equal(y_min, @line.y_min)
+      end
+
+      it "changes y_max to fit if text_bottom boxes are higher than the text" do
+        y_min = @line.y_min
+        box = setup_box(10, 50, :text_bottom)
+        @line.add(box)
+
+        @line.clear_cache
+        assert_equal(50 + @line.text_y_min, @line.y_max)
+        assert_equal(y_min, @line.y_min)
+      end
+
+      it "changes y_max to fit if bottom boxes are higher than the text" do
+        y_min = @line.y_min
+        box = setup_box(10, 50, :bottom)
+        @line.add(box)
+
+        @line.clear_cache
+        assert_equal(50 + @line.text_y_min, @line.y_max)
+        assert_equal(y_min, @line.y_min)
+      end
+
+      it "changes y_min to fit if text_top/top boxes are higher than the text" do
+        y_max = @line.y_max
+        box = setup_box(10, 50, :text_top)
+        @line.add(box)
+
+        @line.clear_cache
+        assert_equal(@line.text_y_max - 50, @line.y_min)
+        assert_equal(y_max, @line.y_max)
+
+        box.instance_variable_set(:@valign, :top)
+        @line.clear_cache
+        assert_equal(@line.text_y_max - 50, @line.y_min)
+        assert_equal(y_max, @line.y_max)
+      end
+
+      it "changes y_min/y_max to fit if boxes are aligned in both directions" do
+        @line << setup_box(10, 20, :text_top) <<
+          setup_box(10, 20, :text_bottom) <<
+          setup_box(10, 20, :top) <<
+          setup_box(10, 70, :bottom)
+        assert_equal(@line.text_y_max - 20, @line.y_min)
+        assert_equal(@line.text_y_max - 20 + 70, @line.y_max)
+      end
+    end
+  end
+
+  it "fails when accessing a vertical measurement if an item uses an invalid valign value" do
+    @line << setup_box(10, 20, :invalid)
+    assert_raises(HexaPDF::Error) { @line.y_min }
+  end
+
+  describe "each" do
+    it "iterates over all items and yields them with their offset values" do
+      @line << setup_fragment("H") <<
+        setup_box(10, 10, :top) <<
+        setup_box(10, 10, :text_top) <<
+        setup_box(10, 10, :baseline) <<
+        setup_box(10, 10, :text_bottom) <<
+        setup_box(10, 10, :bottom)
+      result = [
+        [@line.items[0], 0, 0],
+        [@line.items[1], @line.items[0].width, @line.y_max - 10],
+        [@line.items[2], @line.items[0].width + 10, @line.text_y_max - 10],
+        [@line.items[3], @line.items[0].width + 20, 0],
+        [@line.items[4], @line.items[0].width + 30, @line.text_y_min],
+        [@line.items[5], @line.items[0].width + 40, @line.y_min],
+      ]
+      assert_equal(result, @line.to_enum(:each).map {|*a| a})
+    end
+
+    it "fails if an item uses an invalid valign value" do
+      @line << setup_box(10, 10, :invalid)
+      assert_raises(HexaPDF::Error) { @line.each {} }
+    end
+  end
+
+  it "allows ignoring line justification" do
+    refute(@line.ignore_justification?)
+    @line.ignore_justification!
+    assert(@line.ignore_justification?)
+  end
+end

data/test/hexapdf/layout/test_style.rb

@@ -0,0 +1,143 @@
+# -*- encoding: utf-8 -*-
+
+require 'test_helper'
+require 'hexapdf/layout/style'
+require 'hexapdf/layout/text_box'
+
+describe HexaPDF::Layout::Style::LineSpacing do
+  before do
+    @line1 = Object.new
+    @line1.define_singleton_method(:y_min) { - 1}
+    @line1.define_singleton_method(:y_max) { 2 }
+    @line2 = Object.new
+    @line2.define_singleton_method(:y_min) { -3 }
+    @line2.define_singleton_method(:y_max) { 4 }
+  end
+
+  def line_spacing(type, value = nil)
+    HexaPDF::Layout::Style::LineSpacing.new(type, value: value)
+  end
+
+  it "allows single line spacing" do
+    obj = line_spacing(:single)
+    assert_equal(:proportional, obj.type)
+    assert_equal(1, obj.value)
+    assert_equal(1 + 4, obj.baseline_distance(@line1, @line2))
+    assert_equal(0, obj.gap(@line1, @line2))
+  end
+
+  it "allows double line spacing" do
+    obj = line_spacing(:double)
+    assert_equal(:proportional, obj.type)
+    assert_equal(2, obj.value)
+    assert_equal((1 + 4) * 2, obj.baseline_distance(@line1, @line2))
+    assert_equal(1 + 4, obj.gap(@line1, @line2))
+  end
+
+  it "allows proportional line spacing" do
+    obj = line_spacing(:proportional, 1.5)
+    assert_equal(:proportional, obj.type)
+    assert_equal(1.5, obj.value)
+    assert_equal((1 + 4) * 1.5, obj.baseline_distance(@line1, @line2))
+    assert_equal((1 + 4) * 0.5, obj.gap(@line1, @line2))
+  end
+
+  it "allows fixed line spacing" do
+    obj = line_spacing(:fixed, 7)
+    assert_equal(:fixed, obj.type)
+    assert_equal(7, obj.value)
+    assert_equal(7, obj.baseline_distance(@line1, @line2))
+    assert_equal(7 - 1 -  4, obj.gap(@line1, @line2))
+  end
+
+  it "allows line spacing using a leading value" do
+    obj = line_spacing(:leading, 3)
+    assert_equal(:leading, obj.type)
+    assert_equal(3, obj.value)
+    assert_equal(1 + 4 + 3, obj.baseline_distance(@line1, @line2))
+    assert_equal(3, obj.gap(@line1, @line2))
+  end
+
+  it "allows using a LineSpacing object as type" do
+    obj = line_spacing(line_spacing(:single))
+    assert_equal(:proportional, obj.type)
+  end
+
+  it "raises an error if a value is needed and none is provided" do
+    assert_raises(ArgumentError) { line_spacing(:proportional) }
+  end
+
+  it "raises an error if an invalid type is provided" do
+    assert_raises(ArgumentError) { line_spacing(:invalid) }
+  end
+end
+
+describe HexaPDF::Layout::Style do
+  before do
+    @style = HexaPDF::Layout::Style.new
+  end
+
+  it "can assign values on initialization" do
+    style = HexaPDF::Layout::Style.new(font_size: 10)
+    assert_equal(10, style.font_size)
+  end
+
+  it "has several dynamically generated properties with default values" do
+    assert_raises(HexaPDF::Error) { @style.font }
+    assert_equal(10, @style.font_size)
+    assert_equal(0, @style.character_spacing)
+    assert_equal(0, @style.word_spacing)
+    assert_equal(100, @style.horizontal_scaling)
+    assert_equal(0, @style.text_rise)
+    assert_equal({}, @style.font_features)
+    assert_equal(:left, @style.align)
+    assert_equal(:top, @style.valign)
+  end
+
+  it "can set and retrieve line spacing objects" do
+    assert_equal([:proportional, 1], [@style.line_spacing.type, @style.line_spacing.value])
+    @style.line_spacing = :double
+    assert_equal([:proportional, 2], [@style.line_spacing.type, @style.line_spacing.value])
+  end
+
+  it "can set and retrieve text segmentation algorithms" do
+    assert_equal(HexaPDF::Layout::TextBox::SimpleTextSegmentation,
+                 @style.text_segmentation_algorithm)
+    block = proc { :y }
+    @style.text_segmentation_algorithm(&block)
+    assert_equal(block, @style.text_segmentation_algorithm)
+  end
+
+  it "can set and retrieve line wrapping algorithms" do
+    assert_equal(HexaPDF::Layout::TextBox::SimpleLineWrapping,
+                 @style.text_line_wrapping_algorithm)
+    @style.text_line_wrapping_algorithm(:callable)
+    assert_equal(:callable, @style.text_line_wrapping_algorithm)
+  end
+
+  it "has methods for some derived and cached values" do
+    assert_equal(0.01, @style.scaled_font_size)
+    assert_equal(0, @style.scaled_character_spacing)
+    assert_equal(0, @style.scaled_word_spacing)
+    assert_equal(1, @style.scaled_horizontal_scaling)
+
+    wrapped_font = Object.new
+    wrapped_font.define_singleton_method(:ascender) { 600 }
+    wrapped_font.define_singleton_method(:descender) { -100 }
+    font = Object.new
+    font.define_singleton_method(:scaling_factor) { 1 }
+    font.define_singleton_method(:wrapped_font) { wrapped_font }
+    @style.font = font
+
+    assert_equal(6, @style.scaled_font_ascender)
+    assert_equal(-1, @style.scaled_font_descender)
+  end
+
+  it "can clear cached values" do
+    assert_equal(0.01, @style.scaled_font_size)
+    @style.font_size = 20
+    assert_equal(0.01, @style.scaled_font_size)
+    @style.clear_cache
+    assert_equal(0.02, @style.scaled_font_size)
+  end
+end