hexapdf 0.17.1 → 0.17.2

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

@@ -0,0 +1,73 @@
+# -*- 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 "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 "doesn't use certain subset glyph IDs for performance reasons" do
+    1.upto(93) {|i| @subsetter.use_glyph(i) }
+    # glyph 0, 93 used glyph, 4 special glyphs
+    assert_equal(1 + 93 + 4, @subsetter.instance_variable_get(:@glyph_map).size)
+    1.upto(12) {|i| assert_equal(i, @subsetter.subset_glyph_id(i), "id=#{i}") }
+    13.upto(38) {|i| assert_equal(i + 1, @subsetter.subset_glyph_id(i), "id=#{i}") }
+    39.upto(88) {|i| assert_equal(i + 3, @subsetter.subset_glyph_id(i), "id=#{i}") }
+    89.upto(93) {|i| assert_equal(i + 4, @subsetter.subset_glyph_id(i), "id=#{i}") }
+  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(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

@@ -0,0 +1,48 @@
+# -*- encoding: utf-8 -*-
+
+require 'test_helper'
+require 'stringio'
+require 'hexapdf/font/true_type/table'
+require_relative 'common'
+
+describe HexaPDF::Font::TrueType::Table do
+  before do
+    io = StringIO.new('some string')
+    @file = Object.new
+    @file.define_singleton_method(:io) { io }
+    @entry = HexaPDF::Font::TrueType::Table::Directory::Entry.new('tagg', 0, 0, @file.io.string.length)
+  end
+
+  describe "initialize" do
+    it "reads the data from the associated file" do
+      table = TestHelper::TrueTypeTestTable.new(@file, @entry)
+      assert_equal(@file.io.string, table.data)
+    end
+  end
+
+  describe "checksum_valid?" do
+    it "checks whether an entry's checksum is valid" do
+      @file.io.string = 254.chr * 17 + 0.chr * 3
+      @entry.checksum = (0xfefefefe * 4 + 0xfe000000) % 2**32
+      @entry.length = @file.io.string.length
+      table = TestHelper::TrueTypeTestTable.new(@file, @entry)
+      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/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

@@ -0,0 +1,65 @@
+# -*- encoding: utf-8 -*-
+
+require 'test_helper'
+require_relative 'common'
+require 'hexapdf/font/type1'
+require 'hexapdf/data_dir'
+require 'tempfile'
+require 'stringio'
+
+describe HexaPDF::Font::Type1::AFMParser do
+  describe "::parse" do
+    before do
+      @file = Tempfile.new('hexapdf-afm')
+      @file.write("StartFontMetrics 4.1\nFontName Test\nEndFontMetrics\nFontName Other\n")
+      @file.close
+    end
+
+    after do
+      @file.unlink
+    end
+
+    it "can work with file names" do
+      assert_equal('Test', HexaPDF::Font::Type1::AFMParser.parse(@file.path).font_name)
+    end
+
+    it "can work with IO streams" do
+      @file.open
+      assert_equal('Test', HexaPDF::Font::Type1::AFMParser.parse(@file).font_name)
+    end
+  end
+
+  it "can parse the 14 core PDF font files" do
+    Dir[File.join(HexaPDF.data_dir, 'afm', '*.afm')].each do |file|
+      metrics = HexaPDF::Font::Type1::AFMParser.parse(file)
+      basename = File.basename(file, '.*')
+      assert_equal(basename, metrics.font_name, basename)
+      assert_equal(basename.sub(/-.*/, ''), metrics.family_name, basename)
+      refute(metrics.character_metrics.empty?, basename)
+    end
+  end
+
+  it "parses until EOF if no end token is found" do
+    io = StringIO.new("StartFontMetrics 4.1\nFontName Test")
+    assert_equal('Test', HexaPDF::Font::Type1::AFMParser.parse(io).font_name)
+  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)
+    assert_equal(metrics.bounding_box[3], metrics.ascender)
+  end
+
+  it "fails if the file doesn't start with the correct line" do
+    file = StringIO.new("some\nthing")
+    assert_raises(HexaPDF::Error) { HexaPDF::Font::Type1::AFMParser.parse(file) }
+  end
+end

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

@@ -0,0 +1,104 @@
+# -*- encoding: utf-8 -*-
+
+require 'test_helper'
+require_relative 'common'
+require 'hexapdf/font/type1'
+
+describe HexaPDF::Font::Type1::Font do
+  before do
+    metrics = HexaPDF::Font::Type1::FontMetrics.new
+    @font = HexaPDF::Font::Type1::Font.new(metrics)
+  end
+
+  describe "::from_afm" do
+    it "can load the Font object from an AFM file" do
+      font = HexaPDF::Font::Type1::Font.from_afm(File.join(HexaPDF.data_dir, 'afm/Symbol.afm'))
+      assert_equal('Symbol', font.family_name)
+    end
+  end
+
+  describe "encoding" do
+    it "uses the StandardEncoding if possible" do
+      @font.metrics.encoding_scheme = 'AdobeStandardEncoding'
+      assert_equal(HexaPDF::Font::Encoding.for_name(:StandardEncoding), @font.encoding)
+    end
+
+    it "handles the special case of the ZapfDingbats font" do
+      @font.metrics.font_name = "ZapfDingbats"
+      assert_equal(HexaPDF::Font::Encoding.for_name(:ZapfDingbatsEncoding), @font.encoding)
+    end
+
+    it "handles the special case of the Symbol font" do
+      @font.metrics.font_name = "Symbol"
+      assert_equal(HexaPDF::Font::Encoding.for_name(:SymbolEncoding), @font.encoding)
+    end
+
+    it "generates an encoding object if necessary" do
+      char_metrics = HexaPDF::Font::Type1::CharacterMetrics.new
+      char_metrics.code = 5
+      char_metrics.name = :A
+      @font.metrics.character_metrics[5] = char_metrics.dup
+      char_metrics.code = 6
+      char_metrics.name = :Z
+      @font.metrics.character_metrics[6] = char_metrics.dup
+
+      assert_equal({5 => :A, 6 => :Z}, @font.encoding.code_to_name)
+    end
+  end
+
+  describe "width" do
+    before do
+      @char_metrics = HexaPDF::Font::Type1::CharacterMetrics.new
+      @char_metrics.width = 100
+    end
+
+    it "returns the width for a code point in the built-in encoding" do
+      @font.metrics.character_metrics[5] = @char_metrics
+      assert_equal(100, @font.width(5))
+    end
+
+    it "returns the width for a named glyph" do
+      @font.metrics.character_metrics[:A] = @char_metrics
+      assert_equal(100, @font.width(:A))
+    end
+  end
+
+  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
+
+  describe "underline properties" do
+    before do
+      @font.metrics.underline_position = -100
+      @font.metrics.underline_thickness = 50
+    end
+
+    it "returns the underline position" do
+      assert_equal(-75, @font.underline_position)
+    end
+
+    it "returns the underline thickness" do
+      assert_equal(50, @font.underline_thickness)
+    end
+  end
+
+  describe "strikeout properties" do
+    it "returns the strikeout position" do
+      assert_equal(225, @font.strikeout_position)
+    end
+
+    it "returns the strikeout thickness" do
+      assert_equal(50, @font.strikeout_thickness)
+
+      emdash = HexaPDF::Font::Type1::CharacterMetrics.new
+      emdash.bbox = [0, 200, 1000, 240]
+      @font.metrics.character_metrics[:emdash] = emdash
+      assert_equal(40, @font.strikeout_thickness)
+    end
+  end
+end

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

@@ -0,0 +1,22 @@
+# -*- encoding: utf-8 -*-
+
+require 'test_helper'
+require 'hexapdf/font/type1'
+
+describe HexaPDF::Font::Type1::FontMetrics do
+  before do
+    @metrics = HexaPDF::Font::Type1::FontMetrics.new
+  end
+
+  describe "weight_class" do
+    it "converts known weight names" do
+      @metrics.weight = 'Bold'
+      assert_equal(700, @metrics.weight_class)
+    end
+
+    it "returns 0 for unknown weight names" do
+      @metrics.weight = 'Unknown'
+      assert_equal(0, @metrics.weight_class)
+    end
+  end
+end

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

@@ -0,0 +1,37 @@
+# -*- encoding: utf-8 -*-
+
+require 'test_helper'
+require 'hexapdf/font/type1'
+
+describe HexaPDF::Font::Type1::PFBParser do
+  describe "::encoding" do
+    it "can extract the encoding specified as StandardEncoding" do
+      data = "bla bla bla /Encoding StandardEncoding def bla bla"
+      assert_same(HexaPDF::Font::Encoding.for_name(:StandardEncoding),
+                  HexaPDF::Font::Type1::PFBParser.encoding(data))
+    end
+
+    it "can extract the encoding specified as array" do
+      data = <<-EOF
+      bla bla bla
+      /Encoding 256 array
+      0 1 255 {1 index exch /.notdef put} for
+      dup 32 /space put
+      dup 33 /exclam put
+      dup 34 /universal put
+      dup 35 /numbersign put
+      dup 36 /existential put
+      readonly def
+      bla bla bla
+      EOF
+      enc = HexaPDF::Font::Type1::PFBParser.encoding(data)
+      assert_equal(:space, enc.name(32))
+      assert_equal(:existential, enc.name(36))
+    end
+
+    it "fails if the encoding can't be extracted" do
+      data = "something without an encoding"
+      assert_raises(HexaPDF::Error) { HexaPDF::Font::Type1::PFBParser.encoding(data) }
+    end
+  end
+end

data/test/hexapdf/font_loader/test_from_configuration.rb

@@ -0,0 +1,43 @@
+# -*- encoding: utf-8 -*-
+
+require 'test_helper'
+require 'hexapdf/font_loader'
+require 'hexapdf/document'
+
+describe HexaPDF::FontLoader::FromConfiguration do
+  before do
+    @doc = HexaPDF::Document.new
+    font_file = File.join(TEST_DATA_DIR, "fonts", "Ubuntu-Title.ttf")
+    @font_obj = HexaPDF::Font::TrueType::Font.new(File.open(font_file, 'rb'))
+    @doc.config['font.map'] = {'font' => {none: font_file}, 'font1' => {none: @font_obj}}
+    @klass = HexaPDF::FontLoader::FromConfiguration
+  end
+
+  it "loads the configured font" do
+    wrapper = @klass.call(@doc, "font")
+    assert_equal("Ubuntu-Title", wrapper.wrapped_font.font_name)
+    wrapper = @klass.call(@doc, "font1")
+    assert_equal("Ubuntu-Title", wrapper.wrapped_font.font_name)
+    assert_same(@font_obj, wrapper.wrapped_font)
+  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 provided font is invalid" do
+    @doc.config['font.map']['font'][:none] << "unknown"
+    assert_raises(HexaPDF::Error) { @klass.call(@doc, "font") }
+  end
+
+  it "returns nil for unknown fonts" do
+    assert_nil(@klass.call(@doc, "Unknown"))
+  end
+
+  it "returns a hash with all configured fonts" do
+    assert_equal({'font' => [:none], 'font1' => [:none]}, @klass.available_fonts(@doc))
+  end
+end

data/test/hexapdf/font_loader/test_from_file.rb

@@ -0,0 +1,36 @@
+# -*- encoding: utf-8 -*-
+
+require 'test_helper'
+require 'hexapdf/font_loader'
+require 'hexapdf/document'
+
+describe HexaPDF::FontLoader::FromFile do
+  before do
+    @doc = HexaPDF::Document.new
+    @font_file = File.join(TEST_DATA_DIR, "fonts", "Ubuntu-Title.ttf")
+    @klass = HexaPDF::FontLoader::FromFile
+  end
+
+  it "loads the specified font file" do
+    wrapper = @klass.call(@doc, @font_file)
+    assert_equal("Ubuntu-Title", wrapper.wrapped_font.font_name)
+  end
+
+  it "loads the specified font object" do
+    font = HexaPDF::Font::TrueType::Font.new(File.open(@font_file, 'rb'))
+    wrapper = @klass.call(@doc, font)
+    assert_equal("Ubuntu-Title", wrapper.wrapped_font.font_name)
+    assert_same(font, wrapper.wrapped_font)
+  end
+
+  it "passes the subset value to the wrapper" do
+    wrapper = @klass.call(@doc, @font_file)
+    assert(wrapper.subset?)
+    wrapper = @klass.call(@doc, @font_file, subset: false)
+    refute(wrapper.subset?)
+  end
+
+  it "returns nil if the given name doesn't represent a file" do
+    assert_nil(@klass.call(@doc, "Unknown"))
+  end
+end

data/test/hexapdf/font_loader/test_standard14.rb

@@ -0,0 +1,33 @@
+# -*- encoding: utf-8 -*-
+
+require 'test_helper'
+require 'hexapdf/font_loader'
+require 'hexapdf/document'
+
+describe HexaPDF::FontLoader::Standard14 do
+  before do
+    @doc = HexaPDF::Document.new
+    @obj = HexaPDF::FontLoader::Standard14
+  end
+
+  it "loads the font if it is a standard PDF built-in font" do
+    wrapper = @obj.call(@doc, "Times")
+    assert_equal("Times-Roman", wrapper.wrapped_font.font_name)
+    wrapper = @obj.call(@doc, "Helvetica", variant: :bold)
+    assert_equal("Helvetica-Bold", wrapper.wrapped_font.font_name)
+  end
+
+  it "returns nil for unknown fonts" do
+    assert_nil(@obj.call(@doc, "Unknown"))
+  end
+
+  it "returns a hash with all standard PDF fonts" do
+    assert_equal({
+                   'Times' => [:none, :bold, :italic, :bold_italic],
+                   'Helvetica' => [:none, :bold, :italic, :bold_italic],
+                   'Courier' => [:none, :bold, :italic, :bold_italic],
+                   'Symbol' => [:none], 'ZapfDingbats' => [:none]
+                 },
+                 @obj.available_fonts(@doc))
+  end
+end

data/test/hexapdf/image_loader/test_jpeg.rb

@@ -0,0 +1,93 @@
+# -*- encoding: utf-8 -*-
+
+require 'test_helper'
+require 'hexapdf/document'
+require 'hexapdf/image_loader/jpeg'
+
+describe HexaPDF::ImageLoader::JPEG do
+  before do
+    @images = Dir.glob(File.join(TEST_DATA_DIR, 'images', '*.jpg'))
+    @doc = HexaPDF::Document.new
+    @loader = HexaPDF::ImageLoader::JPEG
+  end
+
+  describe "handles?" do
+    it "works for jpeg files" do
+      @images.each do |image|
+        assert(@loader.handles?(image))
+        File.open(image, 'rb') {|file| assert(@loader.handles?(file)) }
+      end
+    end
+  end
+
+  describe "load" do
+    it "can work with an IO stream instead of a file" do
+      jpeg = @images.grep(/rgb\.jpg/).first
+      File.open(jpeg, 'rb') do |file|
+        image = @loader.load(@doc, file)
+        assert_equal(File.binread(jpeg), image.stream)
+      end
+    end
+
+    it "works for a grayscale jpeg" do
+      jpeg = @images.grep(/gray\.jpg/).first
+      image = @loader.load(@doc, jpeg)
+      assert_equal(5, image[:Width])
+      assert_equal(5, image[:Height])
+      assert_equal(:DeviceGray, image[:ColorSpace])
+      assert_equal(File.binread(jpeg), image.stream)
+    end
+
+    it "works for a standard RGB jpeg" do
+      jpeg = @images.grep(/rgb\.jpg/).first
+      image = @loader.load(@doc, jpeg)
+      assert_equal(5, image[:Width])
+      assert_equal(5, image[:Height])
+      assert_equal(:DeviceRGB, image[:ColorSpace])
+      assert_equal(File.binread(jpeg), image.stream)
+    end
+
+    it "works for a jpeg image containing fill bytes" do
+      jpeg = @images.grep(/fillbytes\.jpg/).first
+      image = @loader.load(@doc, jpeg)
+      assert_equal(5, image[:Width])
+      assert_equal(5, image[:Height])
+      assert_equal(:DeviceRGB, image[:ColorSpace])
+      assert_equal(File.binread(jpeg), image.stream)
+    end
+
+    it "works for a CMYK jpeg" do
+      jpeg = @images.grep(/cmyk\.jpg/).first
+      image = @loader.load(@doc, jpeg)
+      assert_equal(5, image[:Width])
+      assert_equal(5, image[:Height])
+      assert_equal(:DeviceCMYK, image[:ColorSpace])
+      assert_equal([1.0, 0.0, 1.0, 0.0, 1.0, 0.0, 1.0, 0.0], image[:Decode].value)
+      assert_equal(File.binread(jpeg), image.stream)
+    end
+
+    it "works for a YCCK jpeg" do
+      jpeg = @images.grep(/ycck\.jpg/).first
+      image = @loader.load(@doc, jpeg)
+      assert_equal(5, image[:Width])
+      assert_equal(5, image[:Height])
+      assert_equal(:DeviceCMYK, image[:ColorSpace])
+      refute(image.key?(:Decode))
+      assert_equal(File.binread(jpeg), image.stream)
+    end
+
+    it "fails if the JPEG is corrupt" do
+      exp = assert_raises(HexaPDF::Error) do
+        @loader.load(@doc, StringIO.new("some non JPEG data"))
+      end
+      assert_match(/marker code/, exp.message)
+    end
+
+    it "fails if the JPEG contains components with more/less bits than 8" do
+      exp = assert_raises(HexaPDF::Error) do
+        @loader.load(@doc, StringIO.new("\xFF\xD8\xFF\xC0\x00\x06\x04\x00\x05\x00\x05\x03".b))
+      end
+      assert_match(/Unsupported.*bits.*4/, exp.message)
+    end
+  end
+end

data/test/hexapdf/image_loader/test_pdf.rb

@@ -0,0 +1,47 @@
+# -*- encoding: utf-8 -*-
+
+require 'test_helper'
+require 'hexapdf/document'
+require 'hexapdf/image_loader/pdf'
+
+describe HexaPDF::ImageLoader::PDF do
+  before do
+    @doc = HexaPDF::Document.new
+    @loader = HexaPDF::ImageLoader::PDF
+    @pdf = File.join(TEST_DATA_DIR, 'minimal.pdf')
+  end
+
+  describe "handles?" do
+    it "works for PDF files" do
+      assert(@loader.handles?(@pdf))
+      File.open(@pdf, 'rb') {|file| assert(@loader.handles?(file)) }
+    end
+  end
+
+  describe "load" do
+    it "works for PDF files using a File object" do
+      File.open(@pdf, 'rb') do |file|
+        form = @loader.load(@doc, file)
+        assert_equal(:Form, form[:Subtype])
+      end
+    end
+
+    it "works for PDF files using a string object and use_stringio=true" do
+      @doc.config['image_loader.pdf.use_stringio'] = true
+      form = @loader.load(@doc, @pdf)
+      assert_equal(:Form, form[:Subtype])
+    end
+
+    it "works for PDF files using a string object and use_stringio=false" do
+      begin
+        @doc.config['image_loader.pdf.use_stringio'] = false
+        form = @loader.load(@doc, @pdf)
+        assert_equal(:Form, form[:Subtype])
+      ensure
+        ObjectSpace.each_object(File) do |file|
+          file.close if file.path == @pdf && !file.closed?
+        end
+      end
+    end
+  end
+end