hexapdf 0.3.0 → 0.4.0

data/test/hexapdf/font/test_true_type_wrapper.rb

@@ -73,58 +73,75 @@ describe HexaPDF::Font::TrueTypeWrapper do
     end
   end
 
-  it "creates the necessary PDF dictionaries" do
-    @font_wrapper.encode(@font_wrapper.glyph(3))
-    glyph = @font_wrapper.decode_utf8('H').first
-    @font_wrapper.encode(glyph)
-    @doc.dispatch_message(:complete_objects)
-
-    dict = @font_wrapper.dict
-
-    # Checking Type 0 font dictionary
-    assert_equal(:Font, dict[:Type])
-    assert_equal(:Type0, dict[:Subtype])
-    assert_equal(:'Identity-H', dict[:Encoding])
-    assert_equal(1, dict[:DescendantFonts].length)
-    assert_equal(dict[:BaseFont], dict[:DescendantFonts][0][:BaseFont])
-    assert_equal(HexaPDF::Font::CMap.create_to_unicode_cmap([[3, ' '.ord], [glyph.id, 'H'.ord]]),
-                 dict[:ToUnicode].stream)
-    assert_match(/\A[A-Z]{6}\+Ubuntu-Title\z/, dict[:BaseFont])
-
-    # Checking CIDFont dictionary
-    cidfont = dict[:DescendantFonts][0]
-    assert_equal(:Font, cidfont[:Type])
-    assert_equal(:CIDFontType2, cidfont[:Subtype])
-    assert_equal({Registry: "Adobe", Ordering: "Identity", Supplement: 0}, cidfont[:CIDSystemInfo])
-    assert_equal(:Identity, cidfont[:CIDToGIDMap])
-    assert_equal(@font_wrapper.glyph(3).width, cidfont[:DW])
-    assert_equal([glyph.id, [glyph.width]], cidfont[:W])
-
-    # Checking font descriptor
-    fd = cidfont[:FontDescriptor]
-    assert_equal(dict[:BaseFont], fd[:FontName])
-    assert(fd.flagged?(:symbolic))
-    assert(fd.key?(:FontFile2))
-    assert(fd.validate)
-
-    # Two special cases for determining cap height and x-height
-    @cmap.stub(:[], nil) do
-      @font[:'OS/2'].typo_ascender = 1000
+  describe "creates the necessary PDF dictionaries" do
+    it "with fonts that are subset" do
+      @font_wrapper.encode(@font_wrapper.glyph(3))
+      glyph = @font_wrapper.decode_utf8('H').first
+      @font_wrapper.encode(glyph)
+      @doc.dispatch_message(:complete_objects)
+
+      dict = @font_wrapper.dict
+
+      # Checking Type 0 font dictionary
+      assert_equal(:Font, dict[:Type])
+      assert_equal(:Type0, dict[:Subtype])
+      assert_equal(:'Identity-H', dict[:Encoding])
+      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)
+      assert_match(/\A[A-Z]{6}\+Ubuntu-Title\z/, dict[:BaseFont])
+
+      # Checking CIDFont dictionary
+      cidfont = dict[:DescendantFonts][0]
+      assert_equal(:Font, cidfont[:Type])
+      assert_equal(:CIDFontType2, cidfont[:Subtype])
+      assert_equal({Registry: "Adobe", Ordering: "Identity", Supplement: 0}, cidfont[:CIDSystemInfo])
+      assert_equal(:Identity, cidfont[:CIDToGIDMap])
+      assert_equal(@font_wrapper.glyph(3).width, cidfont[:DW])
+      assert_equal([2, [glyph.width]], cidfont[:W])
+      assert(cidfont.validate)
+
+      # Checking font descriptor
+      fd = cidfont[:FontDescriptor]
+      assert_equal(dict[:BaseFont], fd[:FontName])
+      assert(fd.flagged?(:symbolic))
+      assert(fd.key?(:FontFile2))
+      assert(fd.validate)
+
+      # Two special cases for determining cap height and x-height
+      @cmap.stub(:[], nil) do
+        @font[:'OS/2'].typo_ascender = 1000
+        font_wrapper = HexaPDF::Font::TrueTypeWrapper.new(@doc, @font)
+        font_wrapper.encode(glyph)
+        fd = font_wrapper.dict[:DescendantFonts][0][:FontDescriptor]
+        assert_equal(800, fd[:CapHeight])
+        assert_equal(500, fd[:XHeight])
+      end
+
+      @font[:'OS/2'].version = 2
+      @font[:'OS/2'].x_height = 500 * @font[:head].units_per_em / 1000
+      @font[:'OS/2'].cap_height = 1000 * @font[:head].units_per_em / 1000
       font_wrapper = HexaPDF::Font::TrueTypeWrapper.new(@doc, @font)
       font_wrapper.encode(glyph)
       fd = font_wrapper.dict[:DescendantFonts][0][:FontDescriptor]
-      assert_equal(800, fd[:CapHeight])
+      assert_equal(1000, fd[:CapHeight])
       assert_equal(500, fd[:XHeight])
     end
 
-    @font[:'OS/2'].version = 2
-    @font[:'OS/2'].x_height = 500 * @font[:head].units_per_em / 1000
-    @font[:'OS/2'].cap_height = 1000 * @font[:head].units_per_em / 1000
-    font_wrapper = HexaPDF::Font::TrueTypeWrapper.new(@doc, @font)
-    font_wrapper.encode(glyph)
-    fd = font_wrapper.dict[:DescendantFonts][0][:FontDescriptor]
-    assert_equal(1000, fd[:CapHeight])
-    assert_equal(500, fd[:XHeight])
+    it "with fonts that are not subset (only differences to other case)" do
+      @font_wrapper = HexaPDF::Font::TrueTypeWrapper.new(@doc, @font, subset: false)
+      @font_wrapper.encode(@font_wrapper.glyph(3))
+      glyph = @font_wrapper.decode_utf8('H').first
+      @font_wrapper.encode(glyph)
+      @doc.dispatch_message(:complete_objects)
+
+      dict = @font_wrapper.dict
+
+      assert_equal(HexaPDF::Font::CMap.create_to_unicode_cmap([[3, ' '.ord], [glyph.id, 'H'.ord]]),
+                   dict[:ToUnicode].stream)
+      assert_equal([glyph.id, [glyph.width]], dict[:DescendantFonts][0][:W])
+    end
   end
 
   describe "font file embedding" do

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

@@ -0,0 +1,37 @@
+# -*- encoding: utf-8 -*-
+
+require 'stringio'
+require 'test_helper'
+require 'hexapdf/font/true_type'
+require 'hexapdf/font/true_type/builder'
+
+describe HexaPDF::Font::TrueType::Builder do
+  before do
+    font_file = File.join(TEST_DATA_DIR, "fonts", "Ubuntu-Title.ttf")
+    @font = HexaPDF::Font::TrueType::Font.new(File.open(font_file))
+    @subsetter = HexaPDF::Font::TrueType::Subsetter.new(@font)
+  end
+
+  after do
+    @font.io.close
+  end
+
+  it "builds the font file" do
+    tables = {
+      "head" => @font[:head].raw_data,
+      "glyf" => @font[:glyf].raw_data,
+      "loca" => @font[:loca].raw_data,
+      "maxp" => @font[:maxp].raw_data,
+    }
+    font_data = HexaPDF::Font::TrueType::Builder.build(tables)
+    built_font = HexaPDF::Font::TrueType::Font.new(StringIO.new(font_data))
+
+    assert(built_font[:head].checksum_valid?)
+    assert_equal(@font[:glyf].raw_data, built_font[:glyf].raw_data)
+    assert(built_font[:glyf].checksum_valid?)
+    assert_equal(@font[:loca].raw_data, built_font[:loca].raw_data)
+    assert(built_font[:loca].checksum_valid?)
+    assert_equal(@font[:maxp].raw_data, built_font[:maxp].raw_data)
+    assert(built_font[:maxp].checksum_valid?)
+  end
+end

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

@@ -0,0 +1,27 @@
+# -*- encoding: utf-8 -*-
+
+require 'stringio'
+require 'test_helper'
+require 'hexapdf/font/true_type'
+
+describe HexaPDF::Font::TrueType::Optimizer do
+  before do
+    font_file = File.join(TEST_DATA_DIR, "fonts", "Ubuntu-Title.ttf")
+    @font = HexaPDF::Font::TrueType::Font.new(File.open(font_file))
+    @subsetter = HexaPDF::Font::TrueType::Subsetter.new(@font)
+  end
+
+  after do
+    @font.io.close
+  end
+
+  describe "build_for_pdf" do
+    it "builds a font file that is optimized for use with PDFs" do
+      font_data = HexaPDF::Font::TrueType::Optimizer.build_for_pdf(@font)
+      built_font = HexaPDF::Font::TrueType::Font.new(StringIO.new(font_data))
+      %I(FFTM GDEF GPOS GSUB name post).each do |table|
+        refute(built_font[table])
+      end
+    end
+  end
+end

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

@@ -21,24 +21,17 @@ describe HexaPDF::Font::TrueType::Subsetter do
     assert_equal(1, @subsetter.use_glyph(5))
   end
 
+  it "returns the subset glyph ID for already subset glyphs" do
+    assert_nil(@subsetter.subset_glyph_id(5))
+    value = @subsetter.use_glyph(5)
+    assert_equal(value, @subsetter.subset_glyph_id(5))
+  end
+
   it "creates the subset font file" do
     gid = @font[:cmap].preferred_table[0x41]
     @subsetter.use_glyph(gid)
     subset = HexaPDF::Font::TrueType::Font.new(StringIO.new(@subsetter.build_font))
 
-    assert(subset[:head])
-    assert(subset[:head].checksum_valid?)
-    assert(subset[:hhea])
-    assert(subset[:hhea].checksum_valid?)
-    assert(subset[:glyf])
-    assert(subset[:glyf].checksum_valid?)
-    assert(subset[:loca])
-    assert(subset[:loca].checksum_valid?)
-    assert(subset[:maxp])
-    assert(subset[:maxp].checksum_valid?)
-    assert(subset[:hmtx])
-    assert(subset[:hmtx].checksum_valid?)
-
     assert(Time.now - subset[:head].modified < 10)
     assert_equal(2, subset[:maxp].num_glyphs)
     assert_equal(2, subset[:hhea].num_of_long_hor_metrics)

data/test/hexapdf/test_configuration.rb

@@ -60,19 +60,24 @@ describe HexaPDF::Configuration do
       assert_equal(HexaPDF, @config.constantize('test', 1))
     end
 
-    it "returns nil for an unknown option" do
-      assert_nil(@config.constantize('unknown'))
+    def assert_constantize_error # :nodoc:
+      exp = assert_raises(HexaPDF::Error) { yield }
+      assert_match(/Error getting constant for configuration option/, exp.message)
     end
 
-    it "returns nil for an unknown constant" do
+    it "raises an error for an unknown option" do
+      assert_constantize_error { @config.constantize('unknown') }
+    end
+
+    it "raises an error for an unknown constant" do
       @config['test'] = 'SomeUnknownConstant'
-      assert_nil(@config.constantize('test'))
+      assert_constantize_error { @config.constantize('test') }
     end
 
-    it "returns nil for an unknown constant using a nested option" do
+    it "raises an error for an unknown constant using a nested option" do
       @config['test'] = {}
-      assert_nil(@config.constantize('test', 'test'))
-      assert_nil(@config.constantize('test', nil))
+      assert_constantize_error { @config.constantize('test', 'test') }
+      assert_constantize_error { @config.constantize('test', nil) }
     end
 
     it "returns the result of the given block when no constant is found" do

data/test/hexapdf/test_document.rb

@@ -564,4 +564,28 @@ EOF
       assert_equal([[:callable, [:arg]], [:block, [:arg]]], args)
     end
   end
+
+  describe "caching interface" do
+    it "allows setting and retrieving values" do
+      assert_equal(:test, @doc.cache(:a, :b, :test))
+      assert_equal(:test, @doc.cache(:a, :b, :other))
+      assert_equal(:other, @doc.cache(:a, :c) { :other })
+      assert(@doc.cached?(:a, :b))
+      assert(@doc.cached?(:a, :c))
+    end
+
+    it "allows clearing cached values" do
+      @doc.cache(:a, :b, :c)
+      @doc.cache(:b, :c, :d)
+      @doc.clear_cache(:a)
+      refute(@doc.cached?(:a, :b))
+      assert(@doc.cached?(:b, :c))
+      @doc.clear_cache
+      refute(@doc.cached?(:a, :c))
+    end
+
+    it "fails if no cached value exists and neither a value nor a block is given" do
+      assert_raises(LocalJumpError) { @doc.cache(:a, :b) }
+    end
+  end
 end

data/test/hexapdf/test_importer.rb

@@ -8,7 +8,8 @@ describe HexaPDF::Importer do
   before do
     @source = HexaPDF::Document.new
     obj = @source.add("test")
-    @obj = @source.add(hash: {key: "value"}, array: ["one", "two"],
+    @hash = @source.wrap(key: "value")
+    @obj = @source.add(hash: @hash, array: ["one", "two"],
                        ref: HexaPDF::Reference.new(obj.oid, obj.gen),
                        others: [:symbol, 5, 5.5, nil, true, false])
     @source.pages.add
@@ -24,6 +25,13 @@ describe HexaPDF::Importer do
   end
 
   describe "import" do
+    it "updates the associated document" do
+      obj = @importer.import(@obj)
+      assert_same(obj.document, @dest)
+      obj = @importer.import(@hash)
+      assert_same(obj.document, @dest)
+    end
+
     it "imports an object only once" do
       obj = @importer.import(@obj)
       assert_same(obj, @importer.import(@obj))

data/test/hexapdf/test_writer.rb

@@ -40,7 +40,7 @@ startxref
 219
 %%EOF
 3 0 obj
-<</Producer(HexaPDF version 0.3.0)>>
+<</Producer(HexaPDF version 0.4.0)>>
 endobj
 xref
 3 1
@@ -72,7 +72,7 @@ startxref
 141
 %%EOF
 6 0 obj
-<</Producer(HexaPDF version 0.3.0)>>
+<</Producer(HexaPDF version 0.4.0)>>
 endobj
 2 0 obj
 <</Length 10>>stream

data/test/hexapdf/type/test_cid_font.rb

@@ -0,0 +1,61 @@
+# -*- encoding: utf-8 -*-
+
+require 'test_helper'
+require 'hexapdf/document'
+require 'hexapdf/type/cid_font'
+
+describe HexaPDF::Type::CIDFont do
+  before do
+    @doc = HexaPDF::Document.new
+    @font = @doc.wrap(Type: :Font, Subtype: :CIDFontType2, W: [1, 2, 3], DW: 100,
+                      CIDSystemInfo: {Registry: 'Adobe', Ordering: 'Japan1', Supplement: 1})
+  end
+
+  describe "width" do
+    before do
+      @font[:W] = [1, [1], 2, [2, 3, 4], 5, 6, 10, 20, [20, 21], 30, 32, 40]
+    end
+
+    it "returns the glyph width for a CID defined via the /W array" do
+      assert_equal(1, @font.width(1))
+      assert_equal(2, @font.width(2))
+      assert_equal(3, @font.width(3))
+      assert_equal(4, @font.width(4))
+      assert_equal(10, @font.width(5))
+      assert_equal(10, @font.width(6))
+      assert_equal(20, @font.width(20))
+      assert_equal(21, @font.width(21))
+      assert_equal(40, @font.width(32))
+    end
+
+    it "returns the /DW value for CIDs not in the /W array" do
+      assert_equal(100, @font.width(100))
+      @font.delete(:DW)
+      assert_equal(1000, @font.width(100))
+    end
+  end
+
+  describe "set_widths" do
+    it "allows setting the widths" do
+      @font.set_widths([[1, 1], [2, 2], [4, 4], [5, 5], [7, 7.1]], default_width: 5.1)
+      assert_equal(5, @font[:DW])
+      assert_equal([1, [1, 2], 4, [4, 5], 7, [7]], @font[:W])
+    end
+
+    it "handles an empty widths array correctly" do
+      @font.set_widths([], default_width: 100)
+      refute(@font.key?(:W))
+      assert_equal(100, @font[:DW])
+
+      @font.set_widths([])
+      refute(@font.key?(:W))
+    end
+
+    it "handles setting /DW to the default value correctly" do
+      @font.set_widths([])
+      refute(@font.key?(:DW))
+      @font.set_widths([[1, 1]])
+      refute(@font.key?(:DW))
+    end
+  end
+end

data/test/hexapdf/type/test_font.rb

@@ -13,7 +13,8 @@ describe HexaPDF::Type::Font do
       <22> <0042>
       endbfchar
     EOF
-    @font = @doc.add({Type: :Font, BaseFont: :TestFont, ToUnicode: cmap})
+    fd = @doc.add(Type: :FontDescriptor, FontBBox: [0, 1, 2, 3])
+    @font = @doc.add(Type: :Font, BaseFont: :TestFont, FontDescriptor: fd, ToUnicode: cmap)
   end
 
   it "must always be an indirect" do
@@ -24,12 +25,38 @@ describe HexaPDF::Type::Font do
     it "uses the /ToUnicode CMap if it is available" do
       assert_equal("A", @font.to_utf8(32))
       assert_equal("B", @font.to_utf8(34))
-      assert_equal("", @font.to_utf8(0))
+      assert_raises(HexaPDF::Error) { @font.to_utf8(0) }
     end
 
-    it "returns an empty string if no /ToUnicode CMap is available" do
+    it "calls the configured proc if no /ToUnicode CMap is available" do
       @font.delete(:ToUnicode)
-      assert_equal("", @font.to_utf8(32))
+      assert_raises(HexaPDF::Error) { @font.to_utf8(32) }
+    end
+  end
+
+  describe "bounding_box" do
+    it "returns the bounding box" do
+      assert_equal([0, 1, 2, 3], @font.bounding_box)
+    end
+
+    it "returns nil if no bounding box information can be found" do
+      @font[:FontDescriptor].delete(:FontBBox)
+      assert_nil(@font.bounding_box)
+    end
+  end
+
+  describe "embedded" do
+    it "returns true if the font is embedded" do
+      refute(@font.embedded?)
+      @font[:FontDescriptor][:FontFile] = 5
+      assert(@font.embedded?)
+    end
+  end
+
+  describe "font_file" do
+    it "returns the stream object representing the embedded font file" do
+      @font[:FontDescriptor][:FontFile] = 5
+      assert_equal(5, @font.font_file)
     end
   end
 end

data/test/hexapdf/type/test_font_simple.rb

@@ -112,9 +112,9 @@ describe HexaPDF::Type::FontSimple do
       assert_equal(" ", @font.to_utf8(32))
     end
 
-    it "returns an empty string if no correct mapping could be found" do
+    it "calls the configured proc if no correct mapping could be found" do
       @font.delete(:ToUnicode)
-      assert_equal("", @font.to_utf8(0))
+      assert_raises(HexaPDF::Error) { @font.to_utf8(0) }
     end
   end
 
@@ -141,25 +141,6 @@ describe HexaPDF::Type::FontSimple do
     end
   end
 
-  describe "bounding_box" do
-    it "returns the bounding box" do
-      assert_equal([0, 1, 2, 3], @font.bounding_box)
-    end
-
-    it "returns nil if no bounding box information can be found" do
-      @font[:FontDescriptor].delete(:FontBBox)
-      assert_nil(@font.bounding_box)
-    end
-  end
-
-  describe "embedded" do
-    it "returns true if the font is embedded" do
-      refute(@font.embedded?)
-      @font[:FontDescriptor][:FontFile] = 5
-      assert(@font.embedded?)
-    end
-  end
-
   describe "symbolic?" do
     it "return true if the font is symbolic" do
       @font[:FontDescriptor].flag(clear_existing: true)
@@ -175,6 +156,10 @@ describe HexaPDF::Type::FontSimple do
     end
   end
 
+  it "defines word spacing as always applicable" do
+    assert(@font.word_spacing_applicable?)
+  end
+
   describe "validation" do
     it "validates the existence of required keys" do
       assert(@font.validate)