hexapdf 0.2.0 → 0.3.0

data/test/hexapdf/content/test_operator.rb

@@ -521,8 +521,8 @@ describe_operator :MoveTextAndSetLeading, :TD do
     @processor.operators[:Td] = td
 
     invoke(1.56, 1.78)
-    tl.verify
-    td.verify
+    assert(tl.verify)
+    assert(td.verify)
   end
 
   it "serializes correctly" do
@@ -554,7 +554,7 @@ describe_operator :MoveTextNextLine, :'T*' do
 
     @processor.graphics_state.leading = 1.78
     invoke
-    td.verify
+    assert(td.verify)
   end
 end
 
@@ -576,8 +576,8 @@ describe_operator :MoveTextNextLineAndShowText, :"'" do
     @processor.operators[:Tj] = tj
 
     invoke(text)
-    tstar.verify
-    tj.verify
+    assert(tstar.verify)
+    assert(tj.verify)
   end
 
   it "serializes correctly" do
@@ -602,9 +602,9 @@ describe_operator :SetSpacingMoveTextNextLineAndShowText, :'"' do
     @processor.operators[:"'"] = tapos
 
     invoke(word_spacing, char_spacing, text)
-    tw.verify
-    tc.verify
-    tapos.verify
+    assert(tw.verify)
+    assert(tc.verify)
+    assert(tapos.verify)
   end
 
   it "serializes correctly" do

data/test/hexapdf/content/test_processor.rb

@@ -76,7 +76,7 @@ describe HexaPDF::Content::Processor do
       op.expect(:invoke, nil, [@processor, :arg])
       @processor.operators[:test] = op
       @processor.process(:test, [:arg])
-      op.verify
+      assert(op.verify)
     end
 
     it "invokes the mapped message name" do

data/test/hexapdf/encryption/test_security_handler.rb

@@ -138,7 +138,7 @@ describe HexaPDF::Encryption::SecurityHandler do
       [[40, nil], [48, 48], [128, 128], [256, nil]].each do |key_length, result|
         algorithm = (key_length == 256 ? :aes : :arc4)
         @handler.set_up_encryption(key_length: key_length, algorithm: algorithm)
-        assert_equal(result, @handler.dict[:Length])
+        assert(result == @handler.dict[:Length])
       end
     end
 

data/test/hexapdf/font/test_true_type_wrapper.rb

@@ -7,8 +7,8 @@ require 'hexapdf/document'
 describe HexaPDF::Font::TrueTypeWrapper do
   before do
     @doc = HexaPDF::Document.new
-    font_file = File.join(TEST_DATA_DIR, "fonts", "Ubuntu-Title.ttf")
-    @font = HexaPDF::Font::TrueType::Font.new(File.open(font_file))
+    @font_file = File.join(TEST_DATA_DIR, "fonts", "Ubuntu-Title.ttf")
+    @font = HexaPDF::Font::TrueType::Font.new(File.open(@font_file))
     @cmap = @font[:cmap].preferred_table
     @font_wrapper = HexaPDF::Font::TrueTypeWrapper.new(@doc, @font)
   end
@@ -24,6 +24,11 @@ describe HexaPDF::Font::TrueTypeWrapper do
     end
   end
 
+  it "can be asked whether font wil be subset" do
+    assert(@font_wrapper.subset?)
+    refute(HexaPDF::Font::TrueTypeWrapper.new(@doc, @font, subset: false).subset?)
+  end
+
   describe "decode_utf8" do
     it "returns an array of glyph objects" do
       assert_equal("Test",
@@ -34,7 +39,7 @@ describe HexaPDF::Font::TrueTypeWrapper 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(128513, gotten)
+      assert_equal(128_513, gotten)
     end
   end
 
@@ -52,59 +57,95 @@ describe HexaPDF::Font::TrueTypeWrapper do
   end
 
   describe "encode" do
-    it "returns the PDF font dictionary and the encoded glyph" do
-      dict = @font_wrapper.dict
+    it "returns the encoded glyph ID for fonts that are subset" do
+      code = @font_wrapper.encode(@font_wrapper.glyph(3))
+      assert_equal([1].pack('n'), code)
+      code = @font_wrapper.encode(@font_wrapper.glyph(10))
+      assert_equal([2].pack('n'), code)
+    end
 
+    it "returns the encoded glyph ID for fonts that are not subset" do
+      @font_wrapper = HexaPDF::Font::TrueTypeWrapper.new(@doc, @font, subset: false)
       code = @font_wrapper.encode(@font_wrapper.glyph(3))
       assert_equal([3].pack('n'), code)
-      glyph = @font_wrapper.decode_utf8('H').first
-      code = @font_wrapper.encode(glyph)
-      assert_equal([glyph.id].pack('n'), code)
-
-      @doc.dispatch_message(:complete_objects)
+      code = @font_wrapper.encode(@font_wrapper.glyph(10))
+      assert_equal([10].pack('n'), code)
+    end
+  end
 
-      # 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)
-
-      # 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)
-
-      @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
+  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
       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(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(1000, fd[:CapHeight])
+    assert_equal(500, fd[:XHeight])
+  end
+
+  describe "font file embedding" do
+    it "embeds subset fonts" do
+      @font_wrapper.encode(@font_wrapper.glyph(10))
+      @doc.dispatch_message(:complete_objects)
+
+      font_data = @font_wrapper.dict[:DescendantFonts][0][:FontDescriptor][:FontFile2].stream
+      font = HexaPDF::Font::TrueType::Font.new(StringIO.new(font_data))
+      assert_equal(@font[:glyf][0].raw_data, font[:glyf][0].raw_data)
+      assert_equal(@font[:glyf][10].raw_data, font[:glyf][1].raw_data)
+    end
+
+    it "embeds full fonts" do
+      @font_wrapper = HexaPDF::Font::TrueTypeWrapper.new(@doc, @font, subset: false)
+      @doc.dispatch_message(:complete_objects)
+
+      assert_equal(File.size(@font_file),
+                   @font_wrapper.dict[:DescendantFonts][0][:FontDescriptor][:FontFile2][:Length1])
+      assert_equal(File.binread(@font_file),
+                   @font_wrapper.dict[:DescendantFonts][0][:FontDescriptor][:FontFile2].stream)
+    end
   end
 end

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

@@ -50,6 +50,7 @@ describe HexaPDF::Font::TrueType::Table::Glyf do
       assert_equal(-100, glyph.x_max)
       assert_equal(-150, glyph.y_max)
       assert_equal([1, 2, 3, 4, 1], glyph.components)
+      assert_equal([12, 18, 28, 40, 56], glyph.component_offsets)
     end
   end
 end

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

@@ -0,0 +1,70 @@
+# -*- encoding: utf-8 -*-
+
+require 'test_helper'
+require 'stringio'
+require 'hexapdf/font/true_type'
+
+describe HexaPDF::Font::TrueType::Subsetter 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 "adds glyphs to the subset" do
+    assert_equal(1, @subsetter.use_glyph(5))
+    assert_equal(2, @subsetter.use_glyph(6))
+    assert_equal(1, @subsetter.use_glyph(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)
+    assert_equal(3, subset[:loca].offsets.length)
+
+    assert_equal(subset[:hmtx][0], @font[:hmtx][0])
+    assert_equal(subset[:hmtx][1], @font[:hmtx][gid])
+
+    assert_equal(subset[:glyf][1].raw_data, @font[:glyf][gid].raw_data)
+  end
+
+  it "correctly subsets compound glyphs" do
+    font_file = "/usr/share/fonts/truetype/dejavu/DejaVuSans.ttf"
+    skip unless File.exist?(font_file)
+
+    begin
+      @font = HexaPDF::Font::TrueType::Font.new(File.open(font_file))
+      @subsetter = HexaPDF::Font::TrueType::Subsetter.new(@font)
+
+      @subsetter.use_glyph(@font[:cmap].preferred_table['À'.ord])
+      subset = HexaPDF::Font::TrueType::Font.new(StringIO.new(@subsetter.build_font))
+
+      assert_equal(4, subset[:maxp].num_glyphs)
+      assert_equal([2, 3], subset[:glyf][1].components)
+    ensure
+      @font.io.close
+    end
+  end
+end

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

@@ -29,4 +29,20 @@ describe HexaPDF::Font::TrueType::Table do
       assert(table.checksum_valid?)
     end
   end
+
+  describe "read_fixed" do
+    it "works for unsigned values" do
+      @file.io.string = [1, 20480].pack('nn')
+      @entry.length = @file.io.string.length
+      table = TestHelper::TrueTypeTestTable.new(@file, @entry)
+      assert_equal(1 + Rational(20480, 65536), table.send(:read_fixed))
+    end
+
+    it "works for signed values" do
+      @file.io.string = [-1, 20480].pack('nn')
+      @entry.length = @file.io.string.length
+      table = TestHelper::TrueTypeTestTable.new(@file, @entry)
+      assert_equal(-1 + Rational(20480, 65536), table.send(:read_fixed))
+    end
+  end
 end

data/test/hexapdf/font_loader/test_from_configuration.rb

@@ -17,6 +17,13 @@ describe HexaPDF::FontLoader::FromConfiguration do
     assert_equal("Ubuntu-Title", wrapper.wrapped_font.font_name)
   end
 
+  it "passes the subset value to the wrapper" do
+    wrapper = @klass.call(@doc, "font")
+    assert(wrapper.subset?)
+    wrapper = @klass.call(@doc, "font", subset: false)
+    refute(wrapper.subset?)
+  end
+
   it "fails if the font file cannot be read" do
     @doc.config['font.map']['font'][:none] << "unknown"
     assert_raises(HexaPDF::Error) { @klass.call(@doc, "font") }

data/test/hexapdf/test_document.rb

@@ -392,7 +392,7 @@ EOF
       objs = [[10, 20, 30], [200, nil]]
       data = @io_doc.revisions.map.with_index {|rev, i| objs[i].map {|o| [o, rev]}}.reverse.flatten
       @io_doc.each(current: false) do |obj, rev|
-        assert_equal(data.shift, obj.value)
+        assert(data.shift == obj.value)
         assert_equal(data.shift, rev)
       end
     end

data/test/hexapdf/test_object.rb

@@ -9,7 +9,7 @@ describe HexaPDF::Object do
     it "handles not-duplicatable classes" do
       assert_equal(5, HexaPDF::Object.deep_copy(5))
       assert_equal(5.5, HexaPDF::Object.deep_copy(5.5))
-      assert_equal(nil, HexaPDF::Object.deep_copy(nil))
+      assert_nil(HexaPDF::Object.deep_copy(nil))
       assert_equal(true, HexaPDF::Object.deep_copy(true))
       assert_equal(false, HexaPDF::Object.deep_copy(false))
       assert_equal(:Name, HexaPDF::Object.deep_copy(:Name))

data/test/hexapdf/test_revisions.rb

@@ -28,17 +28,42 @@ startxref
 47
 %%EOF
 
+2 0 obj
+300
+endobj
+
+3 0 obj
+<< /Type /XRef /Size 4 /Index [2 1] /W [1 1 1] /Filter /ASCIIHexDecode /Length 6
+>>stream
+019E00
+endstream
+endobj
+
 2 0 obj
 200
 endobj
 
+xref
+2 2
+0000000301 00000 n 
+0000000178 00000 n 
+trailer
+<< /Size 4 /Prev 47 >>
+startxref
+321
+%%EOF
+
+2 0 obj
+400
+endobj
+
 xref
 2 1
-0000000158 00000 n 
+0000000422 00000 n 
 trailer
-<< /Size 3 /Prev 47 >>
+<< /Size 4 /Prev 321 /XRefStm 178 >>
 startxref
-178
+442
 %%EOF
 EOF
     @doc = HexaPDF::Document.new(io: @io)
@@ -48,7 +73,7 @@ EOF
   describe "add" do
     it "adds an empty revision as the current revision" do
       rev = @revisions.add
-      assert_equal({Size: 3}, rev.trailer.value)
+      assert_equal({Size: 4}, rev.trailer.value)
       assert_equal(rev, @revisions.current)
     end
   end
@@ -74,27 +99,28 @@ EOF
   describe "merge" do
     it "does nothing when only one revision is specified" do
       @revisions.merge(1..1)
-      assert_equal(2, @revisions.each.to_a.size)
+      assert_equal(3, @revisions.each.to_a.size)
     end
 
     it "merges the higher into the the lower revision" do
       @revisions.merge
       assert_equal(1, @revisions.each.to_a.size)
-      assert_equal([10, 200], @revisions.current.each.to_a.sort.map(&:value))
+      assert_equal([10, 400, @doc.object(3).value], @revisions.current.each.to_a.sort.map(&:value))
     end
 
     it "handles objects correctly that are in multiple revisions" do
       @revisions.current.add(@revisions[0].object(1))
       @revisions.merge
       assert_equal(1, @revisions.each.to_a.size)
-      assert_equal([10, 200], @revisions.current.each.to_a.sort.map(&:value))
+      assert_equal([10, 400, @doc.object(3).value], @revisions.current.each.to_a.sort.map(&:value))
     end
   end
 
   describe "initialize" do
     it "automatically loads all revisions from the underlying IO object" do
       assert_equal(20, @revisions.revision(0).object(2).value)
-      assert_equal(200, @revisions[1].object(2).value)
+      assert_equal(300, @revisions[1].object(2).value)
+      assert_equal(400, @revisions[2].object(2).value)
     end
   end
 end