hexapdf 0.15.8 → 0.17.1

data/test/hexapdf/type/test_catalog.rb

@@ -1,48 +0,0 @@
-# -*- encoding: utf-8 -*-
-
-require 'test_helper'
-require 'hexapdf/document'
-require 'hexapdf/type/catalog'
-
-describe HexaPDF::Type::Catalog do
-  before do
-    @doc = HexaPDF::Document.new
-    @catalog = @doc.add({Type: :Catalog})
-  end
-
-  it "must always be indirect" do
-    @catalog.must_be_indirect = false
-    assert(@catalog.must_be_indirect?)
-  end
-
-  it "creates the page tree on access" do
-    assert_nil(@catalog[:Pages])
-    pages = @catalog.pages
-    assert_equal(:Pages, pages.type)
-  end
-
-  describe "acro_form" do
-    it "returns an existing form object" do
-      @catalog[:AcroForm] = :test
-      assert_equal(:test, @catalog.acro_form)
-    end
-
-    it "returns an existing form object even if create: true" do
-      @catalog[:AcroForm] = :test
-      assert_equal(:test, @catalog.acro_form(create: true))
-    end
-
-    it "creates a new AcroForm object with defaults if create: true" do
-      form = @catalog.acro_form(create: true)
-      assert_kind_of(HexaPDF::Type::AcroForm::Form, form)
-      assert(form[:DA])
-    end
-  end
-
-  describe "validation" do
-    it "creates the page tree if necessary" do
-      refute(@catalog.validate(auto_correct: false))
-      assert(@catalog.validate)
-    end
-  end
-end

data/test/hexapdf/type/test_cid_font.rb

@@ -1,61 +0,0 @@
-# -*- 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].value)
-    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_file_specification.rb

@@ -1,141 +0,0 @@
-# -*- encoding: utf-8 -*-
-
-require 'test_helper'
-require 'tempfile'
-require 'stringio'
-require 'hexapdf/type/file_specification'
-require 'hexapdf/document'
-
-describe HexaPDF::Type::FileSpecification do
-  before do
-    @doc = HexaPDF::Document.new
-    @obj = HexaPDF::Type::FileSpecification.new({}, document: @doc)
-  end
-
-  it "can be asked whether it is a URL or a file" do
-    refute(@obj.url?)
-    @obj[:FS] = :URL
-    assert(@obj.url?)
-  end
-
-  describe "path" do
-    it "returns the first useable file spec string" do
-      @obj[:DOS] = 'hälo'.b
-      assert_equal('hälo'.b, @obj.path)
-
-      @obj[:UF] = 'hälo'
-      assert_equal('hälo', @obj.path)
-    end
-
-    it "unescapes the path string according to the PDF spec" do
-      @obj[:F] = "dir/in\\/out\\too"
-      assert_equal('dir/in/out/too', @obj.path)
-    end
-  end
-
-  describe "path=" do
-    it "only sets /UF and /F, deleting /Mac, /Unix, /DOS entries if they exist" do
-      @obj[:Unix] = @obj[:Mac] = @obj[:DOS] = 'a'
-      @obj.path = 'file/test'
-      assert_equal('file/test', @obj[:UF])
-      assert_equal('file/test', @obj[:F])
-      refute(@obj.key?(:Unix))
-      refute(@obj.key?(:Mac))
-      refute(@obj.key?(:DOS))
-    end
-
-    it 'resets the /FS value' do
-      @obj[:FS] = :Something
-      @obj.path = 'file'
-      refute(@obj.key?(:FS))
-    end
-  end
-
-  describe "url=" do
-    it "sets the path and the file system entry" do
-      url = 'http://example.com/some?test=ing#done'
-      @obj.url = url
-      assert_equal(url, @obj.path)
-      assert(@obj.url?)
-    end
-
-    it "fails if the provided string is not a valid URL" do
-      assert_raises(HexaPDF::Error) { @obj.url = "a false \\ URL" }
-    end
-  end
-
-  describe "embedded_file?" do
-    it "checks whether the specification has an embedded file" do
-      refute(@obj.embedded_file?)
-      @obj[:EF] = {UF: {}}
-      assert(@obj.embedded_file?)
-    end
-  end
-
-  describe "embedded_file_stream" do
-    it "returns the associated embedded file stream" do
-      assert_nil(@obj.embedded_file_stream)
-      @obj[:EF] = {F: 'data'}
-      assert_equal('data', @obj.embedded_file_stream)
-    end
-  end
-
-  describe "embed/unembed" do
-    before do
-      @file = Tempfile.new('file-embed-test')
-      @file.write("embed-test")
-      @file.close
-    end
-
-    after do
-      @file.unlink
-    end
-
-    it "requires the name argument when given an IO object" do
-      assert_raises(ArgumentError) { @obj.embed(StringIO.new) }
-    end
-
-    it "embeds the given file and registers it with the global name registry" do
-      stream = @obj.embed(@file.path)
-      assert_equal(stream, @obj[:EF][:UF])
-      assert_equal(stream, @obj[:EF][:F])
-      assert_equal(File.basename(@file.path), @obj.path)
-      assert_equal(@obj, @doc.catalog[:Names][:EmbeddedFiles].find_entry(@obj.path))
-      assert_equal(:FlateDecode, stream[:Filter])
-      assert_equal('embed-test', stream.stream)
-    end
-
-    it "embeds the given IO object" do
-      @file.open
-      stream = @obj.embed(@file, name: 'test')
-      assert_equal('embed-test', stream.stream)
-
-      stream = @obj.embed(StringIO.new('test'), name: 'test')
-      assert_equal('test', stream.stream)
-    end
-
-    it "allows overriding the name" do
-      @obj.embed(@file.path, name: 'test')
-      assert_equal('test', @obj.path)
-      assert_equal(@obj, @doc.catalog[:Names][:EmbeddedFiles].find_entry('test'))
-    end
-
-    it "doesn't register the embedded file if instructed to do so" do
-      @obj.embed(@file.path, name: 'test', register: false)
-      assert_nil(@doc.catalog[:Names])
-    end
-
-    it "replaces the value of an already registered name" do
-      (@doc.catalog[:Names] ||= {})[:EmbeddedFiles] = {}
-      @doc.catalog[:Names][:EmbeddedFiles].add_entry('test', 'data')
-      @obj.embed(@file.path, name: 'test')
-      assert_equal(@obj, @doc.catalog[:Names][:EmbeddedFiles].find_entry('test'))
-    end
-
-    it "unembeds an already embedded file before embedding the new one" do
-      @obj.embed(@file.path, name: 'test1')
-      @obj.embed(@file.path, name: 'test2')
-      assert_equal([['test2', @obj]], @doc.catalog[:Names][:EmbeddedFiles].each_entry.to_a)
-    end
-  end
-end

data/test/hexapdf/type/test_font.rb

@@ -1,67 +0,0 @@
-# -*- encoding: utf-8 -*-
-
-require 'test_helper'
-require 'hexapdf/document'
-require 'hexapdf/type/font'
-
-describe HexaPDF::Type::Font do
-  before do
-    @doc = HexaPDF::Document.new
-    cmap = @doc.add({}, stream: <<-EOF)
-      2 beginbfchar
-      <20> <0041>
-      <22> <0042>
-      endbfchar
-    EOF
-    fd = @doc.add({Type: :FontDescriptor, FontBBox: [0, 1, 2, 3]})
-    @font = @doc.add({Type: :Font, BaseFont: :TestFont, FontDescriptor: fd, ToUnicode: cmap})
-  end
-
-  it "allows setting and returning a font wrapper object" do
-    @font.font_wrapper = :fake_wrapper
-    assert_equal(:fake_wrapper, @font.font_wrapper)
-  end
-
-  it "must always be an indirect" do
-    assert(@font.must_be_indirect?)
-  end
-
-  describe "to_utf" 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_raises(HexaPDF::Error) { @font.to_utf8(0) }
-    end
-
-    it "calls the configured proc if no /ToUnicode CMap is available" do
-      @font.delete(:ToUnicode)
-      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_descriptor.rb

@@ -1,61 +0,0 @@
-# -*- encoding: utf-8 -*-
-
-require 'test_helper'
-require 'hexapdf/document'
-require 'hexapdf/type/font_descriptor'
-
-describe HexaPDF::Type::FontDescriptor do
-  before do
-    @doc = HexaPDF::Document.new
-    @font_desc = @doc.add({Type: :FontDescriptor, FontName: :Test, Flags: 0b1001001,
-                           ItalicAngle: 10})
-  end
-
-  describe "flags" do
-    it "returns all flags" do
-      assert_equal([:fixed_pitch, :script, :italic], @font_desc.flags)
-    end
-  end
-
-  describe "flagged?" do
-    it "returns true if the given flag is set" do
-      assert(@font_desc.flagged?(:fixed_pitch))
-      refute(@font_desc.flagged?(:serif))
-    end
-
-    it "raises an error if an unknown flag name is provided" do
-      assert_raises(ArgumentError) { @font_desc.flagged?(:unknown) }
-    end
-  end
-
-  describe "flag" do
-    it "sets the given flag bits" do
-      @font_desc.flag(:serif)
-      assert_equal([:fixed_pitch, :serif, :script, :italic], @font_desc.flags)
-      @font_desc.flag(:symbolic, clear_existing: true)
-      assert_equal([:symbolic], @font_desc.flags)
-    end
-  end
-
-  describe "validation" do
-    it "fails if more than one of /FontFile{,2,3} are set" do
-      assert(@font_desc.validate {|*args| p args })
-      @font_desc[:FontFile] = @font_desc[:FontFile2] = @doc.add({}, stream: 'test')
-      refute(@font_desc.validate)
-    end
-
-    it "deletes the /FontWeight value if it doesn't contain a valid value" do
-      @font_desc[:FontWeight] = 350
-      refute(@font_desc.validate(auto_correct: false))
-      assert(@font_desc.validate)
-      refute(@font_desc.key?(:FontWeight))
-    end
-
-    it "updates the /Descent value if it is not a negative number" do
-      @font_desc[:Descent] = 5
-      refute(@font_desc.validate(auto_correct: false))
-      assert(@font_desc.validate)
-      assert_equal(-5, @font_desc[:Descent])
-    end
-  end
-end

data/test/hexapdf/type/test_font_simple.rb

@@ -1,176 +0,0 @@
-# -*- encoding: utf-8 -*-
-
-require 'test_helper'
-require 'hexapdf/document'
-require 'hexapdf/type/font_simple'
-
-describe HexaPDF::Type::FontSimple do
-  before do
-    @doc = HexaPDF::Document.new
-    cmap = @doc.add({}, stream: <<-EOF)
-      2 beginbfchar
-      <20> <0041>
-      <22> <0042>
-      endbfchar
-    EOF
-    font_descriptor = @doc.add({Type: :FontDescriptor, FontName: :Embedded, Flags: 0b100,
-                                FontBBox: [0, 1, 2, 3], ItalicAngle: 0, Ascent: 900,
-                                Descent: -100, CapHeight: 800, StemV: 20})
-    @font = @doc.add({Type: :Font, Encoding: :WinAnsiEncoding,
-                      BaseFont: :Embedded, FontDescriptor: font_descriptor, ToUnicode: cmap,
-                      FirstChar: 32, LastChar: 34, Widths: [600, 0, 700]},
-                     type: HexaPDF::Type::FontSimple)
-  end
-
-  describe "encoding" do
-    it "fails if /Encoding is absent because encoding_from_font is not implemented" do
-      @font.delete(:Encoding)
-      assert_raises(NotImplementedError) { @font.encoding }
-    end
-
-    describe "/Encoding is a name" do
-      it "returns a predefined encoding if /Encoding specifies one" do
-        assert_equal(HexaPDF::Font::Encoding.for_name(:WinAnsiEncoding), @font.encoding)
-      end
-
-      it "fails if /Encoding is an invalid name because encoding_from_font is not implemented" do
-        @font[:Encoding] = :SomethingUnknown
-        assert_raises(NotImplementedError) { @font.encoding }
-      end
-    end
-
-    describe "/Encoding is a dictionary" do
-      before do
-        @font[:Encoding] = {}
-      end
-
-      describe "no /BaseEncoding is specified" do
-        it "fails if the font is embedded because encoding_from_font is not implemented" do
-          @font[:FontDescriptor][:FontFile] = 5
-          assert_raises(NotImplementedError) { @font.encoding }
-        end
-
-        it "fails for a symbolic non-embedded font because encoding_from_font is not implemented" do
-          @font[:FontDescriptor].flag(:symbolic, clear_existing: true)
-          assert_raises(NotImplementedError) { @font.encoding }
-        end
-
-        it "returns the StandardEncoding for a non-symbolic non-embedded font" do
-          @font[:FontDescriptor].flag(clear_existing: true)
-          assert_equal(HexaPDF::Font::Encoding.for_name(:StandardEncoding), @font.encoding)
-        end
-      end
-
-      it "returns the encoding specified by /BaseEncoding" do
-        @font[:Encoding] = {BaseEncoding: :WinAnsiEncoding}
-        assert_equal(HexaPDF::Font::Encoding.for_name(:WinAnsiEncoding), @font.encoding)
-      end
-
-      it "fails if /BaseEncoding is invalid because encoding_from_font is not implemented" do
-        @font[:Encoding] = {BaseEncoding: :SomethingUnknown}
-        assert_raises(NotImplementedError) { @font.encoding }
-      end
-
-      it "returns a difference encoding if /Differences is specified" do
-        @font[:FontDescriptor].flag(clear_existing: true)
-        @font[:Encoding][:Differences] = [32, :A, :B, 34, :Z]
-        refute_equal(HexaPDF::Font::Encoding.for_name(:StandardEncoding), @font.encoding)
-        assert_equal(:A, @font.encoding.name(32))
-        assert_equal(:B, @font.encoding.name(33))
-        assert_equal(:Z, @font.encoding.name(34))
-      end
-
-      it "fails if the /Differences array contains invalid data" do
-        @font[:Encoding][:BaseEncoding] = :WinAnsiEncoding
-        @font[:Encoding][:Differences] = [:B, 32, :A, :B, 34, :Z]
-        assert_raises(HexaPDF::Error) { @font.encoding }
-
-        @font[:Encoding][:Differences] = [32, "data", :A, :B, 34, :Z]
-        assert_raises(HexaPDF::Error) { @font.encoding }
-      end
-    end
-
-    it "fails if /Encoding contains an invalid value" do
-      @font[:Encoding] = 5
-      assert_raises(HexaPDF::Error) { @font.encoding }
-    end
-  end
-
-  describe "decode" do
-    it "just returns the bytes of the string since this is a simple 1-byte-per-code font" do
-      assert_equal([65, 66], @font.decode("AB"))
-    end
-  end
-
-  describe "to_utf" do
-    it "uses a /ToUnicode CMap if it is available" do
-      assert_equal("A", @font.to_utf8(32))
-    end
-
-    it "uses the font's encoding to map the code to an UTF-8 string if the /ToUnicode is missing" do
-      @font.delete(:ToUnicode)
-      assert_equal(" ", @font.to_utf8(32))
-    end
-
-    it "calls the configured proc if no correct mapping could be found" do
-      @font.delete(:ToUnicode)
-      assert_raises(HexaPDF::Error) { @font.to_utf8(0) }
-    end
-  end
-
-  describe "writing_mode" do
-    it "is always horizontal" do
-      assert_equal(:horizontal, @font.writing_mode)
-    end
-  end
-
-  describe "width" do
-    it "returns the glyph width for a valid code point" do
-      assert_equal(600, @font.width(32))
-    end
-
-    it "returns the /MissingWidth of a /FontDescriptor if available and the width was not found" do
-      assert_equal(0, @font.width(0))
-      @font[:FontDescriptor][:MissingWidth] = 99
-      assert_equal(99, @font.width(0))
-    end
-
-    it "returns 0 for a missing code point when FontDescriptor is not available" do
-      @font.delete(:FontDescriptor)
-      assert_equal(0, @font.width(0))
-    end
-  end
-
-  describe "symbolic?" do
-    it "return true if the font is symbolic" do
-      @font[:FontDescriptor].flag(clear_existing: true)
-      refute(@font.symbolic?)
-
-      @font[:FontDescriptor].flag(:symbolic)
-      assert(@font.symbolic?)
-    end
-
-    it "returns nil if it cannot be determined whether the font is symbolic" do
-      @font.delete(:FontDescriptor)
-      assert_nil(@font.symbolic?)
-    end
-  end
-
-  it "defines word spacing as always applicable" do
-    assert(@font.word_spacing_applicable?)
-  end
-
-  describe "validation" do
-    before { assert(@font.validate) }
-
-    it "validates the existence of required keys" do
-      @font.delete(:FirstChar)
-      refute(@font.validate)
-    end
-
-    it "validates the lengths of the /Widths field" do
-      @font[:Widths] = [65]
-      refute(@font.validate)
-    end
-  end
-end

data/test/hexapdf/type/test_font_true_type.rb

@@ -1,31 +0,0 @@
-# -*- encoding: utf-8 -*-
-
-require 'test_helper'
-require 'hexapdf/document'
-require 'hexapdf/type/font_true_type'
-
-describe HexaPDF::Type::FontTrueType do
-  before do
-    @doc = HexaPDF::Document.new
-    font_descriptor = @doc.add({Type: :FontDescriptor, FontName: :Something, Flags: 0b100,
-                                FontBBox: [0, 1, 2, 3], ItalicAngle: 0, Ascent: 900,
-                                Descent: -100, CapHeight: 800, StemV: 20})
-    @font = @doc.add({Type: :Font, Subtype: :TrueType, Encoding: :WinAnsiEncoding,
-                      FirstChar: 32, LastChar: 34, Widths: [600, 0, 700],
-                      BaseFont: :Something, FontDescriptor: font_descriptor})
-  end
-
-  describe "validation" do
-    it "ignores some missing fields if the font name is one of the standard PDF fonts" do
-      @font[:BaseFont] = :'Arial,Bold'
-      [:FirstChar, :LastChar, :Widths, :FontDescriptor].each {|field| @font.delete(field) }
-      assert(@font.validate)
-    end
-
-    it "requires that the FontDescriptor key is set" do
-      assert(@font.validate)
-      @font.delete(:FontDescriptor)
-      refute(@font.validate)
-    end
-  end
-end