hexapdf 0.17.1 → 0.17.2

data/test/hexapdf/test_document.rb

@@ -0,0 +1,641 @@
+# -*- encoding: utf-8 -*-
+
+require 'tempfile'
+require 'test_helper'
+require 'hexapdf/document'
+require 'stringio'
+
+describe HexaPDF::Document do
+  before do
+    @io = StringIO.new(<<~EOF)
+      %PDF-1.7
+      1 0 obj
+      10
+      endobj
+
+      2 0 obj
+      20
+      endobj
+
+      3 0 obj
+      30
+      endobj
+
+      xref
+      0 4
+      0000000000 65535 f 
+      0000000009 00000 n 
+      0000000028 00000 n 
+      0000000047 00000 n 
+      trailer
+      << /Size 4 >>
+      startxref
+      66
+      %%EOF
+
+      2 0 obj
+      200
+      endobj
+
+      xref
+      2 2
+      0000000197 00000 n 
+      0000000000 00001 f 
+      trailer
+      << /Size 4 /Prev 66 >>
+      startxref
+      217
+      %%EOF
+    EOF
+    @io_doc = HexaPDF::Document.new(io: @io)
+    @doc = HexaPDF::Document.new
+  end
+
+  describe "::open" do
+    before do
+      @file = Tempfile.new('hexapdf-document')
+      @io_doc.write(@file)
+      @file.close
+    end
+
+    after do
+      @file.unlink
+    end
+
+    it "works without block" do
+      doc = HexaPDF::Document.open(@file.path)
+      assert_equal(200, doc.object(2).value)
+    end
+
+    it "works with a block" do
+      HexaPDF::Document.open(@file.path) do |doc|
+        assert_equal(200, doc.object(2).value)
+      end
+    end
+  end
+
+  describe "initialize" do
+    it "doesn't need any arguments" do
+      doc = HexaPDF::Document.new
+      assert_equal(:A4, doc.config['page.default_media_box'])
+    end
+
+    it "takes a configuration hash as option" do
+      doc = HexaPDF::Document.new(config: {'page.default_media_box' => :A5})
+      assert_equal(:A5, doc.config['page.default_media_box'])
+    end
+
+    it "takes an IO object as option" do
+      doc = HexaPDF::Document.new(io: @io)
+      assert_equal(10, doc.object(1).value)
+    end
+  end
+
+  describe "object" do
+    it "accepts a Reference object as argument" do
+      assert_equal(10, @io_doc.object(HexaPDF::Reference.new(1, 0)).value)
+    end
+
+    it "accepts an object number as arguments" do
+      assert_equal(10, @io_doc.object(1).value)
+    end
+
+    it "returns added objects" do
+      obj = @io_doc.add(@io_doc.wrap({Type: :Test}, oid: 100))
+      assert_equal(obj, @io_doc.object(100))
+    end
+
+    it "returns nil for unknown object references" do
+      assert_nil(@io_doc.object(100))
+    end
+
+    it "returns only the newest version of an object" do
+      assert_equal(200, @io_doc.object(2).value)
+      assert_equal(200, @io_doc.object(HexaPDF::Reference.new(2, 0)).value)
+      assert_nil(@io_doc.object(3).value)
+      assert_nil(@io_doc.object(HexaPDF::Reference.new(3, 1)).value)
+      assert_equal(30, @io_doc.object(HexaPDF::Reference.new(3, 0)).value)
+    end
+  end
+
+  describe "object?" do
+    it "works with a Reference object as argument" do
+      assert(@io_doc.object?(HexaPDF::Reference.new(1, 0)))
+    end
+
+    it "works with an object number as arguments" do
+      assert(@io_doc.object?(1))
+    end
+  end
+
+  describe "deref" do
+    it "returns a dereferenced object when given a Reference object" do
+      assert_equal(@io_doc.object(1), @io_doc.deref(HexaPDF::Reference.new(1, 0)))
+    end
+
+    it "returns the given object when it is not a Reference object" do
+      assert_equal(5, @io_doc.deref(5))
+    end
+  end
+
+  describe "add" do
+    it "automatically assigns free object numbers" do
+      assert_equal(1, @doc.add(5).oid)
+      assert_equal(2, @doc.add(5).oid)
+      @doc.revisions.add
+      assert_equal(3, @doc.add(5).oid)
+    end
+
+    it "assigns the object's document" do
+      obj = @doc.add(5)
+      assert_equal(@doc, obj.document)
+    end
+
+    it "allows adding a native ruby object" do
+      obj = @doc.add(5)
+      assert_equal(5, obj.value)
+    end
+
+    it "allows passing arguments to the wrap call" do
+      obj = @doc.add({}, type: HexaPDF::Dictionary)
+      assert_equal(HexaPDF::Dictionary, obj.class)
+    end
+
+    it "allows adding a HexaPDF::Object" do
+      obj = @doc.add(HexaPDF::Object.new(5))
+      assert_equal(5, obj.value)
+    end
+
+    it "returns the given object if it is already stored in the document" do
+      obj = @doc.add(5)
+      assert_same(obj, @doc.add(obj))
+    end
+
+    it "allows specifying a revision to which the object should be added" do
+      @doc.revisions.add
+      @doc.revisions.add
+
+      @doc.add(@doc.wrap(5, oid: 1), revision: 0)
+      assert_equal(5, @doc.object(1).value)
+
+      @doc.add(@doc.wrap(10, oid: 1), revision: 2)
+      assert_equal(10, @doc.object(1).value)
+
+      @doc.add(@doc.wrap(7.5, oid: 1), revision: 1)
+      assert_equal(10, @doc.object(1).value)
+    end
+
+    it "fails if the specified revision index is invalid" do
+      assert_raises(ArgumentError) { @doc.add(5, revision: 5) }
+    end
+
+    it "fails if the object to be added is associated with another document" do
+      doc = HexaPDF::Document.new
+      obj = doc.add(5)
+      assert_raises(HexaPDF::Error) { @doc.add(obj) }
+    end
+
+    it "fails if the object number is already associated with another object" do
+      obj = @doc.add(5)
+      assert_raises(HexaPDF::Error) { @doc.add(@doc.wrap(5, oid: obj.oid, gen: 1)) }
+    end
+  end
+
+  describe "delete" do
+    it "works with a Reference object as argument" do
+      obj = @doc.add(5)
+      @doc.delete(obj, mark_as_free: false)
+      refute(@doc.object?(obj))
+    end
+
+    it "works with an object number as arguments" do
+      @doc.add(5)
+      @doc.delete(1, mark_as_free: false)
+      refute(@doc.object?(1))
+    end
+
+    describe "with an object in multiple revisions" do
+      before do
+        @ref = HexaPDF::Reference.new(2, 3)
+        obj = @doc.wrap(5, oid: @ref.oid, gen: @ref.gen)
+        @doc.revisions.add
+        @doc.add(obj, revision: 0)
+        @doc.add(obj, revision: 1)
+      end
+
+      it "deletes an object for all revisions when revision = :all" do
+        @doc.delete(@ref, revision: :all, mark_as_free: false)
+        refute(@doc.object?(@ref))
+      end
+
+      it "deletes an object only in the current revision when revision = :current" do
+        @doc.delete(@ref, revision: :current, mark_as_free: false)
+        assert(@doc.object?(@ref))
+      end
+
+      it "marks the object as PDF null object when using mark_as_free=true" do
+        @doc.delete(@ref, revision: :current)
+        assert(@doc.object(@ref).null?)
+      end
+    end
+
+    it "fails if the revision argument is invalid" do
+      assert_raises(ArgumentError) { @doc.delete(1, revision: :invalid) }
+    end
+  end
+
+  describe "import" do
+    it "allows importing objects from another document" do
+      obj = @doc.import(@io_doc.object(2))
+      assert_equal(200, obj.value)
+      refute_equal(0, obj.oid)
+    end
+
+    it "fails if the given object is not a PDF object" do
+      assert_raises(ArgumentError) { @doc.import(5) }
+    end
+
+    it "fails if the given object is associated with no or the destination document" do
+      assert_raises(ArgumentError) { @doc.import(HexaPDF::Object.new(5)) }
+      obj = @doc.add(5)
+      assert_raises(ArgumentError) { @doc.import(obj) }
+    end
+  end
+
+  describe "wrap" do
+    before do
+      @myclass = Class.new(HexaPDF::Dictionary)
+      @myclass.define_type(:MyClass)
+      @myclass2 = Class.new(HexaPDF::Dictionary)
+      @myclass2.define_field(:Test, type: String, required: true)
+      HexaPDF::GlobalConfiguration['object.type_map'][:MyClass] = @myclass
+      HexaPDF::GlobalConfiguration['object.subtype_map'][nil][:Global] = @myclass2
+      HexaPDF::GlobalConfiguration['object.subtype_map'][:MyClass] = {TheSecond: @myclass2}
+    end
+
+    after do
+      HexaPDF::GlobalConfiguration['object.type_map'].delete(:MyClass)
+      HexaPDF::GlobalConfiguration['object.subtype_map'][nil].delete(:Global)
+      HexaPDF::GlobalConfiguration['object.subtype_map'][:MyClass].delete(:TheSecond)
+    end
+
+    it "uses a suitable default type if no special type is specified" do
+      assert_instance_of(HexaPDF::Object, @doc.wrap(5))
+      assert_instance_of(HexaPDF::Stream, @doc.wrap({a: 5}, stream: ''))
+      assert_instance_of(HexaPDF::Dictionary, @doc.wrap({a: 5}))
+      assert_instance_of(HexaPDF::PDFArray, @doc.wrap([1, 2]))
+    end
+
+    it "returns an object of type HexaPDF::Object" do
+      assert_kind_of(HexaPDF::Object, @doc.wrap(5))
+      assert_kind_of(HexaPDF::Object, @doc.wrap({}, stream: ''))
+    end
+
+    it "associates the returned object with the document" do
+      assert_equal(@doc, @doc.wrap(5).document)
+    end
+
+    it "sets the given object (not === HexaPDF::Object) as value for the PDF object" do
+      assert_equal(5, @doc.wrap(5).value)
+    end
+
+    it "uses the data of the given PDF object for re-wrapping" do
+      obj = @doc.wrap({a: :b}, oid: 10, gen: 20, stream: 'hallo')
+      new_obj = @doc.wrap(obj)
+      assert_equal({a: :b}, new_obj.value)
+      assert_equal('hallo', new_obj.raw_stream)
+      assert_equal(10, new_obj.oid)
+      assert_equal(20, new_obj.gen)
+      refute_same(obj, new_obj)
+
+      obj = @doc.wrap({a: :b}, oid: 10, gen: 20)
+      new_obj = @doc.wrap(obj)
+      refute_same(obj, new_obj)
+    end
+
+    it "allows overrding the data of the given PDF object" do
+      obj = @doc.wrap({a: :b}, oid: 10, gen: 20, stream: 'hallo')
+      new_obj = @doc.wrap(obj, oid: 15, gen: 25, stream: 'not')
+      assert_equal('not', new_obj.raw_stream)
+      assert_equal(15, new_obj.oid)
+      assert_equal(25, new_obj.gen)
+    end
+
+    it "sets the given oid/gen values on the returned object" do
+      obj = @doc.wrap(5, oid: 10, gen: 20)
+      assert_equal(10, obj.oid)
+      assert_equal(20, obj.gen)
+    end
+
+    it "uses the type/subtype information in the hash that should be wrapped" do
+      assert_kind_of(@myclass, @doc.wrap({Type: :MyClass}))
+      refute_kind_of(@myclass2, @doc.wrap({Subtype: :TheSecond}))
+      refute_kind_of(@myclass2, @doc.wrap({Subtype: :Global}))
+      assert_kind_of(@myclass2, @doc.wrap({Subtype: :Global, Test: "true"}))
+      assert_kind_of(@myclass2, @doc.wrap({Type: :MyClass, S: :TheSecond}))
+      assert_kind_of(@myclass, @doc.wrap({Type: :MyClass, Subtype: :TheThird}))
+    end
+
+    it "respects the given type/subtype arguments" do
+      assert_kind_of(@myclass, @doc.wrap({Type: :Other}, type: :MyClass))
+      refute_kind_of(@myclass2, @doc.wrap({Subtype: :Other}, subtype: :Global))
+      assert_kind_of(@myclass2, @doc.wrap({Subtype: :Other, Test: "true"}, subtype: :Global))
+      assert_kind_of(@myclass2, @doc.wrap({Type: :Other, Subtype: :Other},
+                                          type: :MyClass, subtype: :TheSecond))
+      assert_kind_of(@myclass2, @doc.wrap({Subtype: :TheSecond}, type: @myclass))
+    end
+
+    it "directly uses a class given via the type argument" do
+      obj = @doc.wrap({a: :b}, type: @myclass, oid: 5)
+      assert_kind_of(@myclass, obj)
+      obj = @doc.wrap(obj, type: @myclass2)
+      assert_kind_of(@myclass2, obj)
+      assert_equal(:b, obj.value[:a])
+      assert_equal(5, obj.oid)
+    end
+  end
+
+  describe "unwrap" do
+    it "returns a simple native ruby type" do
+      assert_equal(5, @doc.unwrap(5))
+    end
+
+    it "recursively unwraps arrays" do
+      assert_equal([5, 10, [200], [200]],
+                   @io_doc.unwrap([5, HexaPDF::Reference.new(1, 0), [HexaPDF::Reference.new(2, 0)],
+                                   [HexaPDF::Reference.new(2, 0)]]))
+    end
+
+    it "recursively unwraps hashes" do
+      assert_equal({a: 5, b: 10, c: [200], d: [200]},
+                   @io_doc.unwrap({a: 5, b: HexaPDF::Reference.new(1, 0),
+                                   c: [HexaPDF::Reference.new(2, 0)],
+                                   d: [HexaPDF::Reference.new(2, 0)]}))
+    end
+
+    it "recursively unwraps PDF objects" do
+      assert_equal({a: 10}, @io_doc.unwrap(@io_doc.wrap({a: HexaPDF::Reference.new(1, 0)})))
+      value = {a: HexaPDF::Object.new({b: HexaPDF::Object.new(10)})}
+      assert_equal({a: {b: 10}}, @doc.unwrap(value))
+    end
+
+    it "fails to unwrap recursive structures" do
+      obj1 = @doc.add({})
+      obj2 = @doc.add({})
+      obj1.value[2] = obj2
+      obj2.value[1] = obj1
+      assert_raises(HexaPDF::Error) { @doc.unwrap({a: obj1}) }
+    end
+  end
+
+  describe "each" do
+    it "iterates over the current objects" do
+      assert_equal([10, 200, nil], @io_doc.each(only_current: true).sort.map(&:value))
+    end
+
+    it "iterates over all objects" do
+      assert_equal([10, 200, 20, 30, nil], @io_doc.each(only_current: false).sort.map(&:value))
+    end
+
+    it "iterates over all loaded objects" do
+      assert_equal(200, @io_doc.object(2).value)
+      assert_equal([200], @io_doc.each(only_loaded: true).sort.map(&:value))
+    end
+
+    it "yields the revision as second argument if the block accepts exactly two arguments" do
+      objs = [[10, 20, 30], [200, nil]]
+      data = @io_doc.revisions.map.with_index {|rev, i| objs[i].map {|o| [o, rev] } }.reverse.flatten
+      @io_doc.each(only_current: false) do |obj, rev|
+        assert(data.shift == obj.value)
+        assert_equal(data.shift, rev)
+      end
+    end
+  end
+
+  describe "encryption" do
+    it "checks for encryption based on the existence of the trailer's /Encrypt dictionary" do
+      refute(@doc.encrypted?)
+      @doc.trailer[:Encrypt] = {Filter: :Standard}
+      assert(@doc.encrypted?)
+    end
+
+    it "can set or delete a security handler via #encrypt" do
+      @doc.encrypt
+      refute_nil(@doc.security_handler)
+      assert(@doc.encrypted?)
+
+      @doc.encrypt(name: nil)
+      assert_nil(@doc.security_handler)
+      refute(@doc.encrypted?)
+    end
+
+    it "doesn't decrypt the document if document.auto_encrypt=false" do
+      test_file = File.join(TEST_DATA_DIR, 'standard-security-handler', 'nopwd-arc4-40bit-V1.pdf')
+      doc = HexaPDF::Document.new(io: StringIO.new(File.read(test_file)),
+                                  config: {'document.auto_decrypt' => false})
+      assert_kind_of(String, doc.trailer[:Info][:ModDate])
+      handler = HexaPDF::Encryption::SecurityHandler.set_up_decryption(doc)
+      assert_kind_of(Time, handler.decrypt(doc.trailer[:Info])[:ModDate])
+    end
+  end
+
+  describe "validate" do
+    before do
+      @doc.validate # to create a valid document
+    end
+
+    it "validates indirect objects" do
+      obj = @doc.add({Type: :Page, MediaBox: [1, 1, 1, 1], Parent: @doc.pages.root})
+      refute(@doc.validate(auto_correct: false))
+
+      called = false
+      assert(@doc.validate {|_, _, o| assert_same(obj, o); called = true })
+      assert(called)
+    end
+
+    it "validates the trailer object" do
+      @doc.trailer[:ID] = :Symbol
+      refute(@doc.validate {|_, _, obj| assert_same(@doc.trailer, obj) })
+    end
+
+    it "validates only loaded objects" do
+      io = StringIO.new
+      doc = HexaPDF::Document.new
+      doc.pages.add.delete(:Resources)
+      page = doc.pages.add
+      page[:Annots] = [doc.add({Type: :Annot, Subtype: :Link, Rect: [0, 0, 1, 1], H: :Z})]
+      doc.write(io, validate: false)
+      doc = HexaPDF::Document.new(io: io)
+      doc.pages[0] # force loading of the first page
+
+      refute(doc.validate(auto_correct: false, only_loaded: true)) # bc of Resources
+      assert(doc.validate(only_loaded: true))
+      refute(doc.validate(auto_correct: false)) # bc of annot key H
+    end
+  end
+
+  describe "write" do
+    it "writes the document to a file" do
+      begin
+        file = Tempfile.new('hexapdf-write')
+        file.close
+        @io_doc.write(file.path)
+        HexaPDF::Document.open(file.path) do |doc|
+          assert_equal(200, doc.object(2).value)
+        end
+      ensure
+        file.unlink
+      end
+    end
+
+    it "writes the document to an IO object" do
+      io = StringIO.new(''.b)
+      @doc.write(io)
+      refute(io.string.empty?)
+    end
+
+    it "writes the document incrementally" do
+      io = StringIO.new
+      @io_doc.write(io, incremental: true)
+      assert_equal(@io.string, io.string[0, @io.string.length])
+    end
+
+    it "fails if the document is not valid" do
+      @doc.trailer[:Size] = :Symbol
+      assert_raises(HexaPDF::Error) { @doc.write(StringIO.new(''.b)) }
+    end
+
+    it "update the ID and the Info's ModDate field" do
+      _, id1 = @doc.trailer.set_random_id
+
+      @doc.write(StringIO.new(''.b), update_fields: false)
+      assert_same(id1, @doc.trailer[:ID][1])
+      refute(@doc.trailer.info.key?(:ModDate))
+
+      @doc.write(StringIO.new(''.b))
+      refute_same(id1, (id2 = @doc.trailer[:ID][1]))
+      assert(@doc.trailer.info.key?(:ModDate))
+
+      @doc.trailer.info[:Author] = 'Me'
+      @doc.write(StringIO.new(''.b))
+      refute_same(id2, @doc.trailer[:ID][1])
+      assert(@doc.trailer.info.key?(:ModDate))
+      assert(@doc.trailer.info.key?(:Author))
+    end
+
+    it "it doesn't optimize the file by default" do
+      io = StringIO.new(''.b)
+      @io_doc.write(io)
+      doc = HexaPDF::Document.new(io: io)
+      assert_equal(0, doc.each.count {|o| o.type == :ObjStm })
+    end
+
+    it "allows optimizing the file by using object streams" do
+      io = StringIO.new(''.b)
+      @io_doc.write(io, optimize: true)
+      doc = HexaPDF::Document.new(io: io)
+      assert_equal(2, doc.each.count {|o| o.type == :ObjStm })
+    end
+  end
+
+  describe "version" do
+    it "uses the file header version of a loaded document" do
+      assert_equal('1.7', @io_doc.version)
+    end
+
+    it "uses the default version for a new document" do
+      assert_equal('1.2', @doc.version)
+    end
+
+    it "uses the catalog's /Version entry if it points to a later version" do
+      (@doc.trailer[:Root] ||= {})[:Version] = '1.4'
+      assert_equal('1.4', @doc.version)
+    end
+
+    it "allows setting the version" do
+      @doc.version = '1.4'
+      assert_equal('1.4', @doc.version)
+    end
+
+    it "fails setting a version with an invalid format" do
+      assert_raises(ArgumentError) { @doc.version = 'bla' }
+    end
+  end
+
+  describe "task" do
+    it "executes the given task with options" do
+      @doc.config['task.map'][:test] = lambda do |doc, arg1:|
+        assert_equal(doc, @doc)
+        assert_equal(:arg1, arg1)
+      end
+      @doc.task(:test, arg1: :arg1)
+    end
+
+    it "executes the given task with a block" do
+      @doc.config['task.map'][:test] = lambda do |doc, **, &block|
+        assert_equal(doc, @doc)
+        block.call('inside')
+      end
+      assert_equal(:done, @doc.task(:test) {|msg| assert_equal('inside', msg); :done })
+    end
+
+    it "fails if the given task is not available" do
+      assert_raises(HexaPDF::Error) { @doc.task(:unknown) }
+    end
+  end
+
+  describe "acro_form" do
+    it "returns the main AcroForm object" do
+      assert_nil(@doc.acro_form)
+      @doc.catalog[:AcroForm] = 5
+      assert_equal(5, @doc.acro_form)
+    end
+
+    it "create the AcroForm object if instructed" do
+      assert_equal(:XXAcroForm, @doc.acro_form(create: true).type)
+    end
+  end
+
+  describe "listener interface" do
+    it "allows registering and dispatching messages" do
+      args = []
+      callable = lambda {|*a| args << [:callable, a] }
+      @doc.register_listener(:something, callable)
+      @doc.register_listener(:something) {|*a| args << [:block, a] }
+      @doc.dispatch_message(:something, :arg)
+      assert_equal([[:callable, [:arg]], [:block, [:arg]]], args)
+    end
+  end
+
+  describe "caching interface" do
+    it "allows setting and retrieving values" do
+      assert_equal(:test, @doc.cache(:a, :b, :test) { :notused })
+      assert_equal(:test, @doc.cache(:a, :b) { :other })
+      assert_equal(:test, @doc.cache(:a, :b))
+      assert_nil(@doc.cache(:a, :c, nil))
+      assert_nil(@doc.cache(:a, :c) { :other })
+      assert_nil(@doc.cache(:a, :c))
+      assert(@doc.cached?(:a, :b))
+      assert(@doc.cached?(:a, :c))
+    end
+
+    it "allows updating a value" do
+      @doc.cache(:a, :b) { :test }
+      assert_equal(:new, @doc.cache(:a, :b, update: true) { :new })
+    end
+
+    it "allows clearing cached values" do
+      @doc.cache(:a, :b) { :c }
+      @doc.cache(:b, :c) { :d }
+      @doc.clear_cache(:a)
+      refute(@doc.cached?(:a, :b))
+      assert(@doc.cached?(:b, :c))
+      @doc.clear_cache
+      refute(@doc.cached?(:a, :c))
+    end
+
+    it "fails if no cached value exists and no block is given" do
+      assert_raises(LocalJumpError) { @doc.cache(:a, :b) }
+    end
+  end
+end