hexapdf 0.4.0 → 0.5.0

data/test/hexapdf/common_tokenizer_tests.rb

@@ -115,6 +115,13 @@ module CommonTokenizerTests
     assert_raises(HexaPDF::MalformedPDFError) { @tokenizer.next_token }
   end
 
+  it "next_token: returns a PDF keyword for a solitary plus sign" do
+    create_tokenizer("+")
+    token = @tokenizer.next_token
+    assert_equal("+", token)
+    assert(token.kind_of?(HexaPDF::Tokenizer::Token))
+  end
+
   it "next_object: works for all PDF object types, including array and dictionary" do
     create_tokenizer(<<-EOF.chomp.gsub(/^ {8}/, ''))
         true false null 123 34.5 (string) <4E6F76> /Name

data/test/hexapdf/content/common.rb

@@ -28,4 +28,12 @@ module TestHelper
 
   end
 
+  # Asserts that the content string contains the operators.
+  def assert_operators(content, operators, only_names: false)
+    processor = TestHelper::OperatorRecorder.new
+    HexaPDF::Content::Parser.new.parse(content, processor)
+    result = processor.recorded_ops
+    result.map!(&:first) if only_names
+    assert_equal(operators, result)
+  end
 end

data/test/hexapdf/content/test_canvas.rb

@@ -9,22 +9,12 @@ require 'hexapdf/content/parser'
 
 describe HexaPDF::Content::Canvas do
   before do
-    @processor = TestHelper::OperatorRecorder.new
-    @parser = HexaPDF::Content::Parser.new
-
     @doc = HexaPDF::Document.new
     @doc.config['graphic_object.arc.max_curves'] = 4
     @page = @doc.pages.add
     @canvas = @page.canvas
   end
 
-  # Asserts that the content string contains the operators.
-  def assert_operators(content, operators)
-    @processor.recorded_ops.clear
-    @parser.parse(content, @processor)
-    assert_equal(operators, @processor.recorded_ops)
-  end
-
   # Asserts that a specific operator is invoked when the block is executed.
   def assert_operator_invoked(op, *args)
     mock = Minitest::Mock.new
@@ -638,10 +628,9 @@ describe HexaPDF::Content::Canvas do
 
     it "serializes correctly" do
       @canvas.circle(0, 0, 1)
-      @processor.recorded_ops.clear
-      @parser.parse(@canvas.contents, @processor)
-      assert_equal([:move_to, :curve_to, :curve_to, :curve_to, :curve_to, :close_subpath],
-                   @processor.recorded_ops.map(&:first))
+      assert_operators(@canvas.contents,
+                       [:move_to, :curve_to, :curve_to, :curve_to, :curve_to, :close_subpath],
+                       only_names: true)
     end
 
     it "returns the canvas object" do
@@ -658,10 +647,9 @@ describe HexaPDF::Content::Canvas do
 
     it "serializes correctly" do
       @canvas.ellipse(0, 0, a: 10, b: 5, inclination: 10)
-      @processor.recorded_ops.clear
-      @parser.parse(@canvas.contents, @processor)
-      assert_equal([:move_to, :curve_to, :curve_to, :curve_to, :curve_to, :close_subpath],
-                   @processor.recorded_ops.map(&:first))
+      assert_operators(@canvas.contents,
+                       [:move_to, :curve_to, :curve_to, :curve_to, :curve_to, :close_subpath],
+                       only_names: true)
     end
 
     it "returns the canvas object" do
@@ -916,8 +904,7 @@ describe HexaPDF::Content::Canvas do
       @canvas.begin_text
       @canvas.begin_text
       @canvas.begin_text(force_new: true)
-      @parser.parse(@canvas.contents, @processor)
-      assert_equal([:begin_text, :end_text, :begin_text], @processor.recorded_ops.map(&:first))
+      assert_operators(@canvas.contents, [:begin_text, :end_text, :begin_text], only_names: true)
     end
 
     it "returns the canvas object" do
@@ -947,8 +934,7 @@ describe HexaPDF::Content::Canvas do
       @canvas.begin_text
       @canvas.end_text
       @canvas.end_text
-      @parser.parse(@page.contents, @processor)
-      assert_equal([:begin_text, :end_text], @processor.recorded_ops.map(&:first))
+      assert_operators(@page.contents, [:begin_text, :end_text], only_names: true)
     end
 
     it "returns the canvas object" do
@@ -1014,6 +1000,8 @@ describe HexaPDF::Content::Canvas do
       assert_nil(@canvas.font)
       @canvas.font("Times", size: 10)
       assert_same(@doc.fonts.load("Times"), @canvas.font)
+      @canvas.font(@canvas.font)
+      assert_same(@doc.fonts.load("Times"), @canvas.font)
       @canvas.font("Helvetica", size: 10)
       assert_operators(@canvas.contents, [[:set_font_and_size, [:F1, 10]],
                                           [:set_leading, [12.0]],

data/test/hexapdf/content/test_processor.rb

@@ -99,7 +99,10 @@ describe HexaPDF::Content::Processor do
       @processor.resources = resources = Object.new
       @processor.resources.define_singleton_method(:xobject) do |_name|
         obj = {Matrix: [2, 0, 0, 2, 10, 10], Subtype: :Form}
-        obj.define_singleton_method(:process_contents) {|processor| processor.process(:w, [10])}
+        obj.define_singleton_method(:process_contents) do |processor, original_resources:|
+          test_case.assert_same(resources, original_resources)
+          processor.process(:w, [10])
+        end
         obj
       end
 

data/test/hexapdf/document/test_pages.rb

@@ -20,6 +20,22 @@ describe HexaPDF::Document::Pages do
       assert_equal([page], @doc.pages.root[:Kids])
     end
 
+    it "adds a new empty page with the given dimensions" do
+      page = @doc.pages.add([0, 0, 20, 20])
+      assert_same(page, @doc.pages[0])
+      assert_equal([0, 0, 20, 20], @doc.pages[0].box(:media).value)
+    end
+
+    it "adds a new empty page with the given page format" do
+      page = @doc.pages.add(:A4)
+      assert_same(page, @doc.pages[0])
+      assert_equal([0, 0, 595, 842], @doc.pages[0].box(:media).value)
+    end
+
+    it "fails if an unknown page format is given" do
+      assert_raises(HexaPDF::Error) { @doc.pages.add(:A953) }
+    end
+
     it "adds a given page to the end" do
       page = @doc.pages.add
       new_page = @doc.add(Type: :Page)

data/test/hexapdf/font/test_invalid_glyph.rb

@@ -0,0 +1,34 @@
+# -*- encoding: utf-8 -*-
+
+require 'test_helper'
+require 'hexapdf/font/invalid_glyph'
+
+describe HexaPDF::Font::InvalidGlyph do
+  before do
+    font = Object.new
+    font.define_singleton_method(:missing_glyph_id) { 0 }
+    font.define_singleton_method(:full_name) { "Test Roman" }
+    @glyph = HexaPDF::Font::InvalidGlyph.new(font, "str")
+  end
+
+  it "returns the missing glyph id for id/name" do
+    assert_equal(0, @glyph.id)
+    assert_equal(0, @glyph.name)
+  end
+
+  it "returns 0 for all glyph dimensions" do
+    assert_equal(0, @glyph.x_min)
+    assert_equal(0, @glyph.x_max)
+    assert_equal(0, @glyph.y_min)
+    assert_equal(0, @glyph.y_max)
+  end
+
+  it "doesn't allow the application of word spacing" do
+    refute(@glyph.apply_word_spacing?)
+  end
+
+  it "can represent itself for debug purposes" do
+    assert_equal('#<HexaPDF::Font::InvalidGlyph font="Test Roman" id=0 "str">',
+                 @glyph.inspect)
+  end
+end

data/test/hexapdf/font/test_true_type_wrapper.rb

@@ -35,24 +35,34 @@ describe HexaPDF::Font::TrueTypeWrapper do
                    @font_wrapper.decode_utf8("Test").map {|g| @cmap.gid_to_code(g.id)}.pack('U*'))
     end
 
-    it "UTF-8 characters for which no glyph exists are mapped to the .notdef glyph" do
-      gotten = nil
-      @doc.config['font.on_missing_glyph'] = proc {|c| gotten = c; 0 }
-      assert_equal([0], @font_wrapper.decode_utf8("😁").map(&:id))
-      assert_equal(128_513, gotten)
+    it "invokes font.on_missing_glyph for UTF-8 characters for which no glyph exists" do
+      glyphs = @font_wrapper.decode_utf8("😁")
+      assert_equal(1, glyphs.length)
+      assert_kind_of(HexaPDF::Font::InvalidGlyph, glyphs.first)
+      assert_equal('' << 128_513, glyphs.first.str)
     end
   end
 
   describe "glyph" do
     it "returns the glyph object for the given id" do
-      glyph = @font_wrapper.glyph(3)
-      assert_equal(3, glyph.id)
-      assert_equal(338, glyph.width)
-      assert(glyph.space?)
+      glyph = @font_wrapper.glyph(17)
+      assert_equal(17, glyph.id)
+      assert_equal("0", glyph.str)
+      assert_equal(628, glyph.width)
+      assert_equal(47, glyph.x_min)
+      assert_equal(0, glyph.y_min)
+      assert_equal(584, glyph.x_max)
+      assert_equal(696, glyph.y_max)
+      refute(glyph.apply_word_spacing?)
+      assert_equal('#<HexaPDF::Font::TrueTypeWrapper::Glyph font="Ubuntu-Title" id=17 "0">',
+                   glyph.inspect)
     end
 
     it "invokes font.on_missing_glyph for missing glyphs" do
-      assert_raises(HexaPDF::Error) { @font_wrapper.glyph(9999) }
+      glyph = @font_wrapper.glyph(9999)
+      assert_kind_of(HexaPDF::Font::InvalidGlyph, glyph)
+      assert_equal(0, glyph.id)
+      assert_equal('' << 0xFFFD, glyph.str)
     end
   end
 
@@ -71,6 +81,10 @@ describe HexaPDF::Font::TrueTypeWrapper do
       code = @font_wrapper.encode(@font_wrapper.glyph(10))
       assert_equal([10].pack('n'), code)
     end
+
+    it "raises an error if an InvalidGlyph is encoded" do
+      assert_raises(HexaPDF::Error) { @font_wrapper.encode(@font_wrapper.glyph(9999)) }
+    end
   end
 
   describe "creates the necessary PDF dictionaries" do
@@ -89,7 +103,7 @@ describe HexaPDF::Font::TrueTypeWrapper do
       assert_equal(1, dict[:DescendantFonts].length)
       assert_equal(dict[:BaseFont], dict[:DescendantFonts][0][:BaseFont])
       assert_equal(HexaPDF::Font::CMap.create_to_unicode_cmap([[1, ' '.ord], [2, 'H'.ord]]),
-        dict[:ToUnicode].stream)
+                   dict[:ToUnicode].stream)
       assert_match(/\A[A-Z]{6}\+Ubuntu-Title\z/, dict[:BaseFont])
 
       # Checking CIDFont dictionary

data/test/hexapdf/font/test_type1_wrapper.rb

@@ -1,12 +1,10 @@
 # -*- encoding: utf-8 -*-
 
 require 'test_helper'
+require_relative 'type1/common'
 require 'hexapdf/font/type1_wrapper'
 require 'hexapdf/document'
 
-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"))
-
 describe HexaPDF::Font::Type1Wrapper do
   before do
     @doc = HexaPDF::Document.new
@@ -14,16 +12,20 @@ describe HexaPDF::Font::Type1Wrapper do
     @symbol_wrapper = HexaPDF::Font::Type1Wrapper.new(@doc, FONT_SYMBOL)
   end
 
+  it "returns 1 for the scaling factor" do
+    assert_equal(1, @times_wrapper.scaling_factor)
+  end
+
   describe "decode_utf8" do
     it "returns an array of glyph objects" do
       assert_equal([:T, :e, :s, :t], @times_wrapper.decode_utf8("Test").map(&:name))
     end
 
-    it "UTF-8 characters for which no glyph name exist are mapped to themselves" do
-      gotten = nil
-      @doc.config['font.on_missing_glyph'] = proc {|c| gotten = c; :A }
-      assert_equal([:A], @times_wrapper.decode_utf8("😁").map(&:name))
-      assert_equal("😁", gotten)
+    it "UTF-8 characters for which no glyph name exists, are mapped to InvalidGlyph objects" do
+      glyphs = @times_wrapper.decode_utf8("😁")
+      assert_equal(1, glyphs.length)
+      assert_kind_of(HexaPDF::Font::InvalidGlyph, glyphs.first)
+      assert_equal('' << 128_513, glyphs.first.str)
     end
   end
 
@@ -31,12 +33,22 @@ describe HexaPDF::Font::Type1Wrapper do
     it "returns the glyph object for the given name" do
       glyph = @times_wrapper.glyph(:A)
       assert_equal(:A, glyph.name)
+      assert_equal("A", glyph.str)
       assert_equal(722, glyph.width)
-      refute(glyph.space?)
+      assert_equal(15, glyph.x_min)
+      assert_equal(0, glyph.y_min)
+      assert_equal(706, glyph.x_max)
+      assert_equal(674, glyph.y_max)
+      refute(glyph.apply_word_spacing?)
+      assert_equal('#<HexaPDF::Font::Type1Wrapper::Glyph font="Times Roman" id=:A "A">',
+                   glyph.inspect)
     end
 
     it "invokes font.on_missing_glyph for missing glyphs" do
-      assert_raises(HexaPDF::Error) { @times_wrapper.glyph(:ffi) }
+      glyph = @times_wrapper.glyph(:ffi)
+      assert_kind_of(HexaPDF::Font::InvalidGlyph, glyph)
+      assert_equal(:'.notdef', glyph.name)
+      assert_equal('ffi', glyph.str)
     end
   end
 
@@ -49,6 +61,10 @@ describe HexaPDF::Font::Type1Wrapper do
         assert_equal(:WinAnsiEncoding, @times_wrapper.dict[:Encoding])
       end
 
+      it "fails if an InvalidGlyph is encoded" do
+        assert_raises(HexaPDF::Error) { @times_wrapper.encode(@times_wrapper.glyph(:ffi)) }
+      end
+
       it "fails if the encoding does not support the given glyph" do
         assert_raises(HexaPDF::Error) { @times_wrapper.encode(@times_wrapper.glyph(:uring)) }
       end

data/test/hexapdf/font/true_type/table/common.rb

@@ -0,0 +1,27 @@
+# -*- encoding: utf-8 -*-
+
+require 'test_helper'
+require 'stringio'
+require 'hexapdf/font/true_type'
+
+module TestHelper
+
+  def set_up_stub_true_type_font(initial_data = ''.b, register_vars: true)
+    font = Object.new
+    font.define_singleton_method(:io) { @io ||= StringIO.new(initial_data) }
+    font.define_singleton_method(:config) { @config ||= {} }
+    entry = HexaPDF::Font::TrueType::Table::Directory::Entry.new('mock', 0, 0, initial_data.length)
+    @font, @entry = font, entry if register_vars
+    [font, entry]
+  end
+
+  def create_table(name, data = nil, standalone: false)
+    font, entry = !standalone ? [@font, @entry] : set_up_stub_true_type_font(register_vars: false)
+    if data
+      font.io.string = data
+      entry.length = font.io.length
+    end
+    HexaPDF::Font::TrueType::Table.const_get(name).new(font, entry)
+  end
+
+end

data/test/hexapdf/font/true_type/table/test_cmap.rb

@@ -1,53 +1,47 @@
 # -*- encoding: utf-8 -*-
 
 require 'test_helper'
-require 'stringio'
+require_relative 'common'
 require 'hexapdf/font/true_type/table/cmap'
 
 describe HexaPDF::Font::TrueType::Table::Cmap do
   before do
     f0 = [0, 262, 0].pack('n3') + (0..255).to_a.pack('C*')
-    data = [0, 3].pack('n2') << [[0, 1, 28],
-                                 [3, 1, 28 + f0.length],
-                                 [1, 0, 28],
-                                ].map {|a| a.pack('n2N')}.join('') << \
-      f0 << f0
-    io = StringIO.new(data)
-    config = @config = {}
-    @file = Object.new
-    @file.define_singleton_method(:io) { io }
-    @file.define_singleton_method(:config) { config }
-    @entry = HexaPDF::Font::TrueType::Table::Directory::Entry.new('cmap', 0, 0, io.length)
+    data = [0, 3].pack('n2') << [
+      [0, 1, 28],
+      [3, 1, 28 + f0.length],
+      [1, 0, 28],
+    ].map {|a| a.pack('n2N')}.join('') << f0 << f0
+    set_up_stub_true_type_font(data)
   end
 
   describe "initialize" do
     it "reads the data from the associated file" do
-      table = HexaPDF::Font::TrueType::Table::Cmap.new(@file, @entry)
+      table = create_table(:Cmap)
       assert_equal(0, table.version)
       assert_equal(3, table.tables.length)
     end
 
     it "ignores unknown subtable when the config option is set to :ignore" do
-      @file.io.string = [0, 1].pack('n2') << [3, 1, 12].pack('n2N') << "\x00\x03"
-      table = HexaPDF::Font::TrueType::Table::Cmap.new(@file, @entry)
+      table = create_table(:Cmap, [0, 1].pack('n2') << [3, 1, 12].pack('n2N') << "\x00\x03")
       assert_equal(0, table.tables.length)
     end
 
     it "raises an error when an unsupported subtable is found and the option is set to :raise" do
-      @file.io.string = [0, 1].pack('n2') << [3, 1, 12].pack('n2N') << "\x00\x03"
-      @file.config['font.true_type.cmap.unknown_format'] = :raise
-      assert_raises(HexaPDF::Error) { HexaPDF::Font::TrueType::Table::Cmap.new(@file, @entry) }
+      data = [0, 1].pack('n2') << [3, 1, 12].pack('n2N') << "\x00\x03"
+      @font.config['font.true_type.unknown_format'] = :raise
+      assert_raises(HexaPDF::Error) { create_table(:Cmap, data) }
     end
 
     it "loads data from subtables with identical offsets only once" do
-      table = HexaPDF::Font::TrueType::Table::Cmap.new(@file, @entry)
+      table = create_table(:Cmap)
       assert_same(table.tables[0].gid_map, table.tables[2].gid_map)
       refute_same(table.tables[0].gid_map, table.tables[1].gid_map)
     end
   end
 
   it "returns the preferred table" do
-    table = HexaPDF::Font::TrueType::Table::Cmap.new(@file, @entry)
+    table = create_table(:Cmap)
     assert_equal(table.tables[1], table.preferred_table)
   end
 end

data/test/hexapdf/font/true_type/table/test_cmap_subtable.rb

@@ -90,6 +90,13 @@ describe HexaPDF::Font::TrueType::Table::CmapSubtable do
       assert_equal(65535, t.gid_to_code(84))
     end
 
+    it "works for format 4 with invalid 0xffff entry" do
+      f4 = [2, 0, 0, 0, 65535, 0, 65535, 0, 32767].pack('n*')
+      t = table([4, f4.length + 6, 0].pack('n3') << f4)
+      assert_nil(t[65535])
+      assert_equal(65535, t.gid_to_code(0))
+    end
+
     it "works for format 6" do
       t = table(([6, 30, 0, 1024, 10] + (1..10).to_a).pack('n*'))
       assert_nil(t[0])

data/test/hexapdf/font/true_type/table/test_glyf.rb

@@ -1,12 +1,11 @@
 # -*- encoding: utf-8 -*-
 
 require 'test_helper'
-require 'stringio'
+require_relative 'common'
 require 'hexapdf/font/true_type/table/glyf'
 
 describe HexaPDF::Font::TrueType::Table::Glyf do
   before do
-    @file = Object.new
     loca = Object.new
     loca.define_singleton_method(:offsets) { @offsets ||= [] }
     loca.define_singleton_method(:offset) {|i| @offsets[i]}
@@ -21,17 +20,20 @@ describe HexaPDF::Font::TrueType::Table::Glyf do
     data << [0b10100001, 4, 20, 30, 40, 50, 60, 70].pack('n2n2n4')
     data << [0b00000000, 1, 20, 30].pack('n2C2')
     loca.offsets << data.size
-    @file.define_singleton_method(:io) { @io ||= StringIO.new(data) }
-    @file.define_singleton_method(:[]) {|_arg| loca }
-    @entry = HexaPDF::Font::TrueType::Table::Directory::Entry.new('glyf', 0, 0, @file.io.length)
+    set_up_stub_true_type_font(data)
+    @font.define_singleton_method(:[]) {|_arg| loca }
   end
 
   describe "initialize" do
     it "reads the data from the associated file" do
-      table = HexaPDF::Font::TrueType::Table::Glyf.new(@file, @entry)
+      table = create_table(:Glyf)
       glyph = table[0]
       refute(glyph.compound?)
       assert_equal(0, glyph.number_of_contours)
+      assert_equal(0, glyph.x_min)
+      assert_equal(0, glyph.y_min)
+      assert_equal(0, glyph.x_max)
+      assert_equal(0, glyph.y_max)
 
       glyph = table[1]
       refute(glyph.compound?)