hexapdf 0.15.8 → 0.17.1

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

@@ -1,73 +0,0 @@
-# -*- 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

@@ -1,48 +0,0 @@
-# -*- 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

@@ -1,6 +0,0 @@
-# -*- 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

@@ -1,65 +0,0 @@
-# -*- 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

@@ -1,104 +0,0 @@
-# -*- 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

@@ -1,22 +0,0 @@
-# -*- 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

@@ -1,37 +0,0 @@
-# -*- 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

@@ -1,43 +0,0 @@
-# -*- 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

@@ -1,36 +0,0 @@
-# -*- 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

@@ -1,33 +0,0 @@
-# -*- 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

@@ -1,93 +0,0 @@
-# -*- 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

@@ -1,47 +0,0 @@
-# -*- 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