hexapdf 0.6.0 → 0.7.0

data/test/hexapdf/font/cmap/test_writer.rb

@@ -5,37 +5,37 @@ require 'hexapdf/font/cmap/writer'
 
 describe HexaPDF::Font::CMap::Writer do
   before do
-    @cmap_data = <<EOF
-/CIDInit /ProcSet findresource begin
-12 dict begin
-begincmap
-/CIDSystemInfo
-<< /Registry (Adobe)
-/Ordering (UCS)
-/Supplement 0
->> def
-/CMapName /Adobe-Identity-UCS def
-/CMapType 2 def
-1 begincodespacerange
-<0000> <FFFF>
-endcodespacerange
-2 beginbfchar
-<0060><0090>
-<3A51><d840dc3e>
-endbfchar
-2 beginbfrange
-<0000><005E><0020>
-<1379><137B><90fe>
-endbfrange
-endcmap
-CMapName currentdict /CMap defineresource pop
-end
-end
-EOF
+    @cmap_data = <<~EOF
+      /CIDInit /ProcSet findresource begin
+      12 dict begin
+      begincmap
+      /CIDSystemInfo
+      << /Registry (Adobe)
+      /Ordering (UCS)
+      /Supplement 0
+      >> def
+      /CMapName /Adobe-Identity-UCS def
+      /CMapType 2 def
+      1 begincodespacerange
+      <0000> <FFFF>
+      endcodespacerange
+      2 beginbfchar
+      <0060><0090>
+      <3A51><d840dc3e>
+      endbfchar
+      2 beginbfrange
+      <0000><005E><0020>
+      <1379><137B><90fe>
+      endbfrange
+      endcmap
+      CMapName currentdict /CMap defineresource pop
+      end
+      end
+    EOF
     @mapping = []
-    0x00.upto(0x5e) {|i| @mapping << [i, 0x20 + i]}
+    0x00.upto(0x5e) {|i| @mapping << [i, 0x20 + i] }
     @mapping << [0x60, 0x90]
-    0x1379.upto(0x137B) {|i| @mapping << [i, 0x90FE + i - 0x1379]}
+    0x1379.upto(0x137B) {|i| @mapping << [i, 0x90FE + i - 0x1379] }
     @mapping << [0x3A51, 0x2003E]
   end
 

data/test/hexapdf/font/test_true_type_wrapper.rb

@@ -32,7 +32,7 @@ describe HexaPDF::Font::TrueTypeWrapper do
   describe "decode_utf8" do
     it "returns an array of glyph objects" do
       assert_equal("Test",
-                   @font_wrapper.decode_utf8("Test").map {|g| @cmap.gid_to_code(g.id)}.pack('U*'))
+                   @font_wrapper.decode_utf8("Test").map {|g| @cmap.gid_to_code(g.id) }.pack('U*'))
     end
 
     it "invokes font.on_missing_glyph for UTF-8 characters for which no glyph exists" do
@@ -110,7 +110,8 @@ describe HexaPDF::Font::TrueTypeWrapper do
       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({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])

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

@@ -5,11 +5,13 @@ require 'hexapdf/font/true_type/table'
 module TestHelper
 
   class TrueTypeTestTable < HexaPDF::Font::TrueType::Table
+
     attr_reader :data
 
     def parse_table
       @data = io.read(directory_entry.length)
     end
+
   end
 
 end

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

@@ -11,7 +11,7 @@ describe HexaPDF::Font::TrueType::Table::Cmap do
       [0, 1, 28],
       [3, 1, 28 + f0.length],
       [1, 0, 28],
-    ].map {|a| a.pack('n2N')}.join('') << f0 << f0
+    ].map {|a| a.pack('n2N') }.join('') << f0 << f0
     set_up_stub_true_type_font(data)
   end
 

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

@@ -38,7 +38,7 @@ describe HexaPDF::Font::TrueType::Table::CmapSubtable do
 
   describe "parse" do
     def table(data)
-      @klass.new(3, 1).tap {|obj| obj.parse(StringIO.new(data), 0)}
+      @klass.new(3, 1).tap {|obj| obj.parse(StringIO.new(data), 0) }
     end
 
     it "works for format 0" do
@@ -49,11 +49,13 @@ describe HexaPDF::Font::TrueType::Table::CmapSubtable do
 
       assert_equal(0, t.gid_to_code(255))
       assert_equal(234, t.gid_to_code(233))
+
+      assert_raises(HexaPDF::Error) { table([0, 20, 0].pack('n3') + "a" * 20) }
     end
 
     it "works for format 2" do
       f2 = ([0, 8] + [0] * 254).pack('n*') + \
-        [[0, 256, 0, 2 + 8], [0x33, 3, 5, 2 + 256 * 2]].map {|a| a.pack('n2s>n')}.join('') + \
+        [[0, 256, 0, 2 + 8], [0x33, 3, 5, 2 + 256 * 2]].map {|a| a.pack('n2s>n') }.join('') + \
         ((0..255).to_a + [35, 65534, 0]).pack('n*')
       t = table([2, f2.length + 6, 0].pack('n3') << f2)
       assert_nil(t[0x0132])
@@ -70,7 +72,7 @@ describe HexaPDF::Font::TrueType::Table::CmapSubtable do
     end
 
     it "works for format 4" do
-      f4 = [6, 8, 2, 4,  35, 134, 65535,  0,  30, 133, 65535,  100, 110, 120,
+      f4 = [6, 8, 2, 4,  35, 134, 65535, 0, 30, 133, 65535, 100, 110, 120,
             0, 6, 2, 65500, 0, 1].pack('n*')
       t = table([4, f4.length + 6, 0].pack('n3') << f4)
       assert_nil(t[25])
@@ -135,6 +137,5 @@ describe HexaPDF::Font::TrueType::Table::CmapSubtable do
     it "returns false if a format is not supported" do
       refute(@klass.new(3, 1).parse(StringIO.new("\x00\x03".b), 0))
     end
-
   end
 end

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

@@ -8,8 +8,8 @@ describe HexaPDF::Font::TrueType::Table::Glyf do
   before do
     loca = Object.new
     loca.define_singleton_method(:offsets) { @offsets ||= [] }
-    loca.define_singleton_method(:offset) {|i| @offsets[i]}
-    loca.define_singleton_method(:length) {|i| @offsets[i + 1] - @offsets[i]}
+    loca.define_singleton_method(:offset) {|i| @offsets[i] }
+    loca.define_singleton_method(:length) {|i| @offsets[i + 1] - @offsets[i] }
     loca.offsets << 0 << 0
     data = [1, -10, -20, 100, 150].pack('s>5')
     loca.offsets << data.size

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

@@ -16,8 +16,8 @@ describe HexaPDF::Font::TrueType::Table::Head do
   describe "initialize" do
     it "reads the data from the associated file" do
       table = create_table(:Head)
-      assert_equal('1.0', '%1.1f' % table.version)
-      assert_equal('2.1', '%1.1f' % table.font_revision)
+      assert_equal('1.0', sprintf('%1.1f', table.version))
+      assert_equal('2.1', sprintf('%1.1f', table.font_revision))
       assert_equal(42, table.checksum_adjustment)
       assert_equal(3, table.flags)
       assert_equal(64, table.units_per_em)

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

@@ -9,7 +9,7 @@ describe HexaPDF::Font::TrueType::Table::Name do
     data = [0, 3, 42].pack('n3') << \
       [1, 0, 0, 0, 4, 0].pack('n6') << \
       [0, 3, 1, 0, 8, 4].pack('n6') << \
-      [0, 3, 2, 1, 14, 12].pack('n6') << \
+      [3, 1, 1033, 1, 14, 12].pack('n6') << \
       'hexa'.encode('MACROMAN').b << \
       'hexa'.encode('UTF-16BE').b <<
       'hexapdf'.encode('UTF-16BE').b
@@ -30,10 +30,12 @@ describe HexaPDF::Font::TrueType::Table::Name do
       assert_equal(3, table[:copyright][1].encoding_id)
       assert_equal(1, table[:copyright][1].language_id)
       assert_equal('hexapdf', table[:font_family][0])
-      assert_equal(0, table[:font_family][0].platform_id)
-      assert_equal(3, table[:font_family][0].encoding_id)
-      assert_equal(2, table[:font_family][0].language_id)
-      assert_equal(table[:copyright][0], table[:copyright].preferred_record)
+      assert_equal(3, table[:font_family][0].platform_id)
+      assert_equal(1, table[:font_family][0].encoding_id)
+      assert_equal(1033, table[:font_family][0].language_id)
+
+      assert_equal(table[0][0], table[0].preferred_record)
+      assert_equal(table[:font_family][0], table[:font_family].preferred_record)
     end
 
     it "reads the data in format 1 from the associated file" do
@@ -55,7 +57,7 @@ describe HexaPDF::Font::TrueType::Table::Name do
       it "returns the correct value" do
         assert(@table[:copyright][0].platform?(:macintosh))
         assert(@table[:copyright][1].platform?(:unicode))
-        refute(@table[:copyright][0].platform?(:microsoft))
+        assert(@table[:font_family][0].platform?(:microsoft))
       end
 
       it "raises an error when called with an unknown identifier" do
@@ -67,6 +69,7 @@ describe HexaPDF::Font::TrueType::Table::Name do
       it "returns true for names in US English that had been converted to UTF-8" do
         assert(@table[:copyright][0].preferred?)
         refute(@table[:copyright][1].preferred?)
+        assert(@table[:font_family][0].preferred?)
       end
     end
   end

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

@@ -9,7 +9,6 @@ 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
@@ -18,9 +17,9 @@ describe HexaPDF::Font::TrueType::Builder do
 
   it "builds the font file" do
     tables = {
+      "loca" => @font[:loca].raw_data << "0",
       "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)
@@ -28,10 +27,16 @@ describe HexaPDF::Font::TrueType::Builder do
 
     assert(built_font[:head].checksum_valid?)
     assert_equal(@font[:glyf].raw_data, built_font[:glyf].raw_data)
+    assert(built_font.directory.entry('glyf').offset % 4 == 0)
     assert(built_font[:glyf].checksum_valid?)
-    assert_equal(@font[:loca].raw_data, built_font[:loca].raw_data)
+    assert_equal(@font[:loca].raw_data << "0", built_font[:loca].raw_data)
     assert(built_font[:loca].checksum_valid?)
+    assert(built_font.directory.entry('loca').offset % 4 == 0)
     assert_equal(@font[:maxp].raw_data, built_font[:maxp].raw_data)
     assert(built_font[:maxp].checksum_valid?)
+    assert(built_font.directory.entry('maxp').offset % 4 == 0)
+
+    tables = built_font.directory.instance_variable_get(:@tables)
+    assert_equal(tables.keys.sort, tables.keys)
   end
 end

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

@@ -8,7 +8,6 @@ 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
@@ -19,7 +18,7 @@ describe HexaPDF::Font::TrueType::Optimizer 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|
+      [:FFTM, :GDEF, :GPOS, :GSUB, :name, :post].each do |table|
         refute(built_font[table])
       end
     end

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

@@ -11,7 +11,7 @@ describe HexaPDF::Font::Type1::AFMParser do
   describe "::parse" do
     before do
       @file = Tempfile.new('hexapdf-afm')
-      @file.write("StartFontMetrics 4.1\nFontName Test\nEndFontMetrics\n")
+      @file.write("StartFontMetrics 4.1\nFontName Test\nEndFontMetrics\nFontName Other\n")
       @file.close
     end
 
@@ -35,7 +35,7 @@ describe HexaPDF::Font::Type1::AFMParser do
       basename = File.basename(file, '.*')
       assert_equal(basename, metrics.font_name, basename)
       assert_equal(basename.sub(/-.*/, ''), metrics.family_name, basename)
-      assert(metrics.character_metrics.size > 0, basename)
+      refute(metrics.character_metrics.empty?, basename)
     end
   end
 

data/test/hexapdf/image_loader/test_jpeg.rb

@@ -15,7 +15,7 @@ describe HexaPDF::ImageLoader::JPEG do
     it "works for jpeg files" do
       @images.each do |image|
         assert(@loader.handles?(image))
-        File.open(image, 'rb') {|file| assert(@loader.handles?(file))}
+        File.open(image, 'rb') {|file| assert(@loader.handles?(file)) }
       end
     end
   end

data/test/hexapdf/image_loader/test_pdf.rb

@@ -14,7 +14,7 @@ describe HexaPDF::ImageLoader::PDF do
   describe "handles?" do
     it "works for PDF files" do
       assert(@loader.handles?(@pdf))
-      File.open(@pdf, 'rb') {|file| assert(@loader.handles?(file))}
+      File.open(@pdf, 'rb') {|file| assert(@loader.handles?(file)) }
     end
   end
 

data/test/hexapdf/image_loader/test_png.rb

@@ -15,7 +15,7 @@ describe HexaPDF::ImageLoader::PNG do
     it "works for png files" do
       @images.each do |image|
         assert(@loader.handles?(image))
-        File.open(image, 'rb') {|file| assert(@loader.handles?(file))}
+        File.open(image, 'rb') {|file| assert(@loader.handles?(file)) }
       end
     end
   end
@@ -30,7 +30,7 @@ describe HexaPDF::ImageLoader::PNG do
     assert_equal(height, image[:Height])
     assert_equal(bpc, image[:BitsPerComponent])
     assert_equal(color_space, image[:ColorSpace]) if color_space
-    data = stream.map {|row| [row.map {|i| i.to_s(2).rjust(bpc, '0')}.join("")].pack('B*')}.join("")
+    data = stream.map {|row| [row.map {|i| i.to_s(2).rjust(bpc, '0') }.join("")].pack('B*') }.join("")
     assert_equal(data, image.stream)
   end
 
@@ -231,7 +231,7 @@ describe HexaPDF::ImageLoader::PNG do
           zip(image[:ColorSpace][1][:Matrix]).each do |r, e|
           assert_in_delta(r, e, 0.0001)
         end
-        if png =~ /srgb/
+        if png.match?(/srgb/)
           assert_equal(:AbsoluteColorimetric, image[:Intent])
         end
       end

data/test/hexapdf/layout/test_inline_box.rb

@@ -8,9 +8,18 @@ describe HexaPDF::Layout::InlineBox do
     @box = HexaPDF::Layout::InlineBox.create(width: 10, height: 15, style: {margin: [15, 10]})
   end
 
+  it "needs a box to wrap and an optional alignment on initialization" do
+    ibox = HexaPDF::Layout::InlineBox.new(@box)
+    assert_equal(@box, ibox.box)
+    assert_equal(:baseline, ibox.valign)
+
+    ibox = HexaPDF::Layout::InlineBox.new(@box, valign: :top)
+    assert_equal(:top, ibox.valign)
+  end
+
   it "draws the wrapped box at the correct position" do
     canvas = Object.new
-    block = ->(c, x, y) do
+    block = lambda do |c, x, y|
       assert_equal(canvas, c)
       assert_equal(10, x)
       assert_equal(15, y)

data/test/hexapdf/layout/test_line.rb

@@ -35,7 +35,7 @@ describe HexaPDF::Layout::Line do
   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)
+      frag2 = HexaPDF::Layout::TextFragment.new(frag1.items.slice!(3, 2), frag1.style)
       line = HexaPDF::Layout::Line.new([frag1, frag2])
       assert_equal(1, line.items.count)
       assert_equal(5, line.items[0].items.count)
@@ -50,7 +50,7 @@ describe HexaPDF::Layout::Line do
 
     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)
+      frag2 = HexaPDF::Layout::TextFragment.new(frag1.items.slice!(2, 2), frag1.style)
       @line << setup_fragment("o") << :other << frag1 << frag2
       assert_equal(3, @line.items.length)
       assert_equal(4, @line.items.last.items.length)
@@ -58,7 +58,7 @@ describe HexaPDF::Layout::Line do
 
     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)
+      frag2 = HexaPDF::Layout::TextFragment.new(frag1.items.slice!(2, 2), frag1.style)
       frag1.items.freeze
       frag2.items.freeze
 
@@ -189,7 +189,7 @@ describe HexaPDF::Layout::Line do
         [@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})
+      assert_equal(result, @line.to_enum(:each).map {|*a| a })
     end
 
     it "fails if an item uses an invalid valign value" do

data/test/hexapdf/layout/test_style.rb

@@ -10,7 +10,7 @@ require 'hexapdf/layout/box'
 describe HexaPDF::Layout::Style::LineSpacing do
   before do
     @line1 = Object.new
-    @line1.define_singleton_method(:y_min) { - 1}
+    @line1.define_singleton_method(:y_min) { - 1 }
     @line1.define_singleton_method(:y_max) { 2 }
     @line2 = Object.new
     @line2.define_singleton_method(:y_min) { -3 }
@@ -87,6 +87,12 @@ describe HexaPDF::Layout::Style::Quad do
       assert_equal(5, quad.right)
       assert_equal(5, quad.bottom)
       assert_equal(5, quad.left)
+
+      quad = create_quad([5])
+      assert_equal(5, quad.top)
+      assert_equal(5, quad.right)
+      assert_equal(5, quad.bottom)
+      assert_equal(5, quad.left)
     end
 
     it "works with two values" do
@@ -351,14 +357,14 @@ describe HexaPDF::Layout::Style::Layers do
   end
 
   it "can be initialized with an array of layers" do
-    data = [-> {}]
+    data = [lambda {}]
     layers = HexaPDF::Layout::Style::Layers.new(data)
     assert_equal(data, layers.enum_for(:each, {}).to_a)
   end
 
   describe "add and each" do
     it "can use a given block" do
-      block = proc { true}
+      block = proc { true }
       @layers.add(&block)
       assert_equal([block], @layers.enum_for(:each, {}).to_a)
     end
@@ -366,9 +372,9 @@ describe HexaPDF::Layout::Style::Layers do
     it "can store a reference" do
       @layers.add(:link, option: :value)
       value = Object.new
-      value.define_singleton_method(:new) {|*args| :new }
+      value.define_singleton_method(:new) {|*| :new }
       config = Object.new
-      config.define_singleton_method(:constantize) {|*args| value }
+      config.define_singleton_method(:constantize) {|*| value }
       assert_equal([:new], @layers.enum_for(:each, config).to_a)
     end
 
@@ -395,7 +401,8 @@ describe HexaPDF::Layout::Style::Layers do
     canvas = HexaPDF::Document.new.pages.add.canvas
     canvas.context.document.config['style.layers_map'][:test] = klass
 
-    @layers.add {|canv, ibox| assert_equal(box, ibox); canv.line_width(10)}
+    @layers.draw(canvas, 10, 15, box)
+    @layers.add {|canv, ibox| assert_equal(box, ibox); canv.line_width(10) }
     @layers.add(:test, option: :value)
     @layers.draw(canvas, 10, 15, box)
     ops = [[:save_graphics_state],
@@ -435,7 +442,12 @@ describe HexaPDF::Layout::Style::LinkLayer do
     def call_link(hash)
       link = HexaPDF::Layout::Style::LinkLayer.new(hash)
       link.call(@canvas, @box)
-      @canvas.context[:Annots][0]
+      @canvas.context[:Annots]&.first
+    end
+
+    it "does nothing if the context is not a page object" do
+      @canvas = HexaPDF::Document.new.add(Type: :XObject, Subtype: :Form).canvas
+      assert_nil(call_link(dest: true))
     end
 
     it "sets general values like /Rect and /QuadPoints" do