hexapdf 0.17.1 → 0.17.2

data/test/hexapdf/type/test_annotation.rb

@@ -0,0 +1,97 @@
+# -*- encoding: utf-8 -*-
+
+require 'test_helper'
+require 'hexapdf/document'
+require 'hexapdf/type/annotation'
+
+describe HexaPDF::Type::Annotation::AppearanceDictionary do
+  before do
+    @doc = HexaPDF::Document.new
+    @ap = @doc.add({N: :n, D: :d, R: :r}, type: :XXAppearanceDictionary)
+  end
+
+  it "resolves the normal appearance" do
+    assert_equal(:n, @ap.normal_appearance)
+  end
+
+  it "resolves the rollover appearance" do
+    assert_equal(:r, @ap.rollover_appearance)
+    @ap.delete(:R)
+    assert_equal(:n, @ap.rollover_appearance)
+  end
+
+  it "resolves the down appearance" do
+    assert_equal(:d, @ap.down_appearance)
+    @ap.delete(:D)
+    assert_equal(:n, @ap.down_appearance)
+  end
+end
+
+describe HexaPDF::Type::Annotation do
+  before do
+    @doc = HexaPDF::Document.new
+    @annot = @doc.add({Type: :Annot, F: 0b100011})
+  end
+
+  it "must always be indirect" do
+    @annot.must_be_indirect = false
+    assert(@annot.must_be_indirect?)
+  end
+
+  it "returns the appearance dictionary" do
+    @annot[:AP] = :yes
+    assert_equal(:yes, @annot.appearance_dict)
+  end
+
+  it "returns the appearance stream of the given type" do
+    assert_nil(@annot.appearance)
+
+    @annot[:AP] = {N: {}}
+    assert_nil(@annot.appearance)
+
+    stream = @doc.wrap({}, stream: '')
+    @annot[:AP][:N] = stream
+    assert_nil(@annot.appearance)
+
+    stream[:BBox] = [1, 2, 3, 4]
+    appearance = @annot.appearance
+    assert_same(stream.data, appearance.data)
+    assert_equal(:Form, appearance[:Subtype])
+
+    @annot[:AP][:N] = {X: {}}
+    assert_nil(@annot.appearance)
+
+    @annot[:AS] = :X
+    @annot[:AP][:N][:X] = stream
+    assert_same(stream.data, @annot.appearance.data)
+
+    @annot[:AP][:D] = {X: stream}
+    assert_same(stream.data, @annot.appearance(:down).data)
+  end
+
+  describe "flags" do
+    it "returns all flags" do
+      assert_equal([:invisible, :hidden, :no_view], @annot.flags)
+    end
+  end
+
+  describe "flagged?" do
+    it "returns true if the given flag is set" do
+      assert(@annot.flagged?(:hidden))
+      refute(@annot.flagged?(:locked))
+    end
+
+    it "raises an error if an unknown flag name is provided" do
+      assert_raises(ArgumentError) { @annot.flagged?(:unknown) }
+    end
+  end
+
+  describe "flag" do
+    it "sets the given flag bits" do
+      @annot.flag(:locked)
+      assert_equal([:invisible, :hidden, :no_view, :locked], @annot.flags)
+      @annot.flag(:locked, clear_existing: true)
+      assert_equal([:locked], @annot.flags)
+    end
+  end
+end

data/test/hexapdf/type/test_catalog.rb

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

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

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

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

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

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

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