hexapdf 0.22.0 → 0.23.0

data/test/hexapdf/test_document.rb

@@ -91,43 +91,6 @@ describe HexaPDF::Document do
     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)))
@@ -139,13 +102,6 @@ describe HexaPDF::Document do
   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)
@@ -166,82 +122,38 @@ describe HexaPDF::Document do
       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 "defers to @revisions for retrieving an object" do
+    revs = Minitest::Mock.new
+    revs.expect(:object, :retval, [:ref])
+    doc = HexaPDF::Document.new
+    doc.instance_variable_set(:@revisions, revs)
+    doc.object(:ref)
+    revs.verify
+  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 "defers to @revisions for checking for the existence of an object" do
+    revs = Minitest::Mock.new
+    revs.expect(:object?, :retval, [:ref])
+    doc = HexaPDF::Document.new
+    doc.instance_variable_set(:@revisions, revs)
+    doc.object?(:ref)
+    revs.verify
+  end
 
-    it "fails if the revision argument is invalid" do
-      assert_raises(ArgumentError) { @doc.delete(1, revision: :invalid) }
-    end
+  it "defers to @revisions for deleting an object" do
+    revs = Minitest::Mock.new
+    revs.expect(:delete_object, :retval, [:ref])
+    doc = HexaPDF::Document.new
+    doc.instance_variable_set(:@revisions, revs)
+    doc.delete(:ref)
+    revs.verify
   end
 
   describe "import" do
@@ -388,28 +300,13 @@ describe HexaPDF::Document do
     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
+  it "defers to @revisions for iterating over all objects" do
+    revs = Minitest::Mock.new
+    revs.expect(:each_object, :retval, [{only_current: true, only_loaded: true}])
+    doc = HexaPDF::Document.new
+    doc.instance_variable_set(:@revisions, revs)
+    doc.each(only_current: true, only_loaded: true)
+    revs.verify
   end
 
   describe "encryption" do

data/test/hexapdf/test_parser.rb

@@ -548,7 +548,7 @@ describe HexaPDF::Parser do
 
     it "works for a cross-reference stream" do
       xref_section, trailer = @parser.load_revision(212)
-      assert_equal({Size: 2}, trailer)
+      assert_equal({Size: 2, Type: :XRef}, trailer)
       assert(xref_section[1].in_use?)
       assert(@parser.contains_xref_streams?)
     end

data/test/hexapdf/test_revision.rb

@@ -215,4 +215,18 @@ describe HexaPDF::Revision do
       assert_equal([], @rev.each_modified_object.to_a)
     end
   end
+
+  describe "reset_objects" do
+    it "deletes loaded objects" do
+      @rev.object(2)
+      @rev.reset_objects
+      assert(@rev.instance_variable_get(:@objects).oids.empty?)
+    end
+
+    it "deletes added objects" do
+      @rev.add(@obj)
+      @rev.reset_objects
+      assert(@rev.instance_variable_get(:@objects).oids.empty?)
+    end
+  end
 end

data/test/hexapdf/test_revisions.rb

@@ -70,61 +70,169 @@ describe HexaPDF::Revisions do
     @revisions = @doc.revisions
   end
 
-  describe "add" do
-    it "adds an empty revision as the current revision" do
-      rev = @revisions.add
-      assert_equal({Size: 4}, rev.trailer.value)
-      assert_equal(rev, @revisions.current)
+  describe "initialize" do
+    it "automatically loads all revisions from the underlying IO object" do
+      assert_kind_of(HexaPDF::Parser, @revisions.parser)
+      assert_equal(20, @revisions.all[0].object(2).value)
+      assert_equal(200, @revisions.all[1].object(2).value)
+      assert_equal(400, @revisions.all[2].object(2).value)
+    end
+
+    it "creates an empty revision when not using initial revisions" do
+      revisions = HexaPDF::Revisions.new(@doc)
+      assert_equal(1, revisions.all.count)
     end
   end
 
-  describe "delete_revision" do
-    it "allows deleting a revision by index" do
-      rev = @revisions.revision(0)
-      @revisions.delete(0)
-      refute(@revisions.any? {|r| r == rev })
+  it "returns the next free oid" do
+    assert_equal(4, @revisions.next_oid)
+  end
+
+  describe "object" do
+    it "accepts a Reference object as argument" do
+      assert_equal(400, @revisions.object(HexaPDF::Reference.new(2, 0)).value)
+    end
+
+    it "accepts an object number as arguments" do
+      assert_equal(400, @revisions.object(2).value)
     end
 
-    it "allows deleting a revision by specifying a revision" do
-      rev = @revisions.revision(0)
-      @revisions.delete(rev)
-      refute(@revisions.any? {|r| r == rev })
+    it "returns nil for unknown object references" do
+      assert_nil(@revisions.object(100))
     end
 
-    it "fails when trying to delete the only existing revision" do
-      assert_raises(HexaPDF::Error) { @revisions.delete(0) while @revisions.current }
+    it "returns a null object for freed objects" do
+      @revisions.delete_object(2)
+      assert(@revisions.object(2).null?)
+    end
+  end
+
+  describe "object?" do
+    it "works with a Reference object as argument" do
+      assert(@revisions.object?(HexaPDF::Reference.new(2, 0)))
+    end
+
+    it "works with an object number as arguments" do
+      assert(@revisions.object?(2))
+    end
+
+    it "returns false when no object is found" do
+      refute(@revisions.object?(20))
+    end
+
+    it "returns true for freed objects" do
+      @revisions.delete_object(2)
+      assert(@revisions.object?(2))
+    end
+  end
+
+  describe "add_object" do
+    before do
+      @obj = HexaPDF::Object.new(5)
+    end
+
+    it "adds the object to the current revision" do
+      @revisions.add_object(@obj)
+      assert_same(@obj, @revisions.current.object(@obj))
+    end
+
+    it "returns the added object" do
+      obj = @revisions.add_object(@obj)
+      assert_same(@obj, obj)
+    end
+
+    it "returns the given object if it is already stored in the document" do
+      obj = @revisions.add_object(@obj)
+      assert_same(obj, @revisions.add_object(obj))
+    end
+
+    it "fails if the object number is already associated with another object" do
+      @revisions.add_object(@obj)
+      assert_raises(HexaPDF::Error) { @revisions.add_object(@doc.wrap(5, oid: @obj.oid)) }
+    end
+
+    it "automatically assign an object number for direct objects" do
+      assert_equal(4, @revisions.add_object(@obj).oid)
+    end
+  end
+
+  describe "delete_object" do
+    it "works with a Reference object as argument" do
+      @revisions.delete_object(@doc.object(2))
+      assert(@revisions.object(2).null?)
+    end
+
+    it "works with an object number as arguments" do
+      @revisions.delete_object(2)
+      assert(@revisions.object(2).null?)
+    end
+
+    it "deletes an object only in the most recent revision" do
+      @revisions.delete_object(2)
+      assert_equal(20, @revisions.all[0].object(2).value)
+      assert_equal(200, @revisions.all[1].object(2).value)
+      assert(@revisions.all[2].object(2).null?)
+    end
+  end
+
+  describe "each_object" do
+    before do
+      @obj3 = @revisions.object(3).value
+    end
+
+    it "iterates over the current objects" do
+      assert_equal([10, 400, @obj3], @revisions.each_object(only_current: true).sort.map(&:value))
+    end
+
+    it "iterates over all objects" do
+      assert_equal([10, 400, 200, 20, @obj3, @obj3],
+                   @revisions.each_object(only_current: false).sort.map(&:value))
+    end
+
+    it "iterates over all loaded objects" do
+      assert_equal([@obj3], @revisions.each_object(only_loaded: true).map(&:value))
+      assert_equal(400, @revisions.object(2).value)
+      assert_equal([400, @obj3], @revisions.each_object(only_loaded: true).sort.map(&:value))
+    end
+
+    it "yields the revision as second argument if the block accepts exactly two arguments" do
+      data = [@obj3, @revisions.all[-1], 400, @revisions.all[-1], 10, @revisions.all[0]]
+      @revisions.each_object do |obj, rev|
+        assert_equal(data.shift, obj.value)
+        assert_equal(data.shift, rev)
+      end
+      assert(data.empty?)
+    end
+  end
+
+  describe "add" do
+    it "adds an empty revision as the current revision" do
+      rev = @revisions.add
+      assert_equal({Size: 4}, rev.trailer.value)
+      assert_equal(rev, @revisions.current)
     end
   end
 
   describe "merge" do
     it "does nothing when only one revision is specified" do
       @revisions.merge(1..1)
-      assert_equal(3, @revisions.each.to_a.size)
+      assert_equal(3, @revisions.all.size)
     end
 
     it "merges the higher into the the lower revision" do
       @revisions.merge
-      assert_equal(1, @revisions.each.to_a.size)
+      assert_equal(1, @revisions.all.size)
       assert_equal([10, 400, @doc.object(3).value], @revisions.current.each.to_a.sort.map(&:value))
     end
 
     it "handles objects correctly that are in multiple revisions" do
-      @revisions.current.add(@revisions[0].object(1))
+      @revisions.current.add(@revisions.all[0].object(1))
       @revisions.merge
       assert_equal(1, @revisions.each.to_a.size)
       assert_equal([10, 400, @doc.object(3).value], @revisions.current.each.to_a.sort.map(&:value))
     end
   end
 
-  describe "initialize" do
-    it "automatically loads all revisions from the underlying IO object" do
-      assert_kind_of(HexaPDF::Parser, @revisions.parser)
-      assert_equal(20, @revisions.revision(0).object(2).value)
-      assert_equal(300, @revisions[1].object(2).value)
-      assert_equal(400, @revisions[2].object(2).value)
-    end
-  end
-
   it "handles invalid PDFs that have a loop via the xref /Prev or /XRefStm entries" do
     io = StringIO.new(<<~EOF)
       %PDF-1.7
@@ -191,6 +299,6 @@ describe HexaPDF::Revisions do
     EOF
     doc = HexaPDF::Document.new(io: io)
     assert_equal(2, doc.revisions.count)
-    assert_same(doc.revisions[0].trailer.value, doc.revisions[1].trailer.value)
+    assert_same(doc.revisions.all[0].trailer.value, doc.revisions.all[1].trailer.value)
   end
 end

data/test/hexapdf/test_writer.rb

@@ -40,13 +40,13 @@ describe HexaPDF::Writer do
       219
       %%EOF
       3 0 obj
-      <</Producer(HexaPDF version 0.22.0)>>
+      <</Producer(HexaPDF version 0.23.0)>>
       endobj
       xref
       3 1
       0000000296 00000 n 
       trailer
-      <</Prev 219/Size 4/Root<</Type/Catalog>>/Info 3 0 R>>
+      <</Size 4/Root<</Type/Catalog>>/Info 3 0 R/Prev 219>>
       startxref
       349
       %%EOF
@@ -64,7 +64,7 @@ describe HexaPDF::Writer do
       20
       endobj
       3 0 obj
-      <</Size 6/Type/XRef/W[1 1 2]/Index[0 4 5 1]/Filter/FlateDecode/DecodeParms<</Columns 4/Predictor 12>>/Length 31>>stream
+      <</Type/XRef/Size 6/W[1 1 2]/Index[0 4 5 1]/Filter/FlateDecode/DecodeParms<</Columns 4/Predictor 12>>/Length 31>>stream
       x\xDAcb`\xF8\xFF\x9F\x89\x89\x95\x91\x91\xE9\x7F\x19\x03\x03\x13\x83\x10\x88he`\x00\x00B4\x04\x1E
       endstream
       endobj
@@ -72,7 +72,7 @@ describe HexaPDF::Writer do
       141
       %%EOF
       6 0 obj
-      <</Producer(HexaPDF version 0.22.0)>>
+      <</Producer(HexaPDF version 0.23.0)>>
       endobj
       2 0 obj
       <</Length 10>>stream
@@ -80,7 +80,7 @@ describe HexaPDF::Writer do
       endstream
       endobj
       4 0 obj
-      <</Size 7/Prev 141/Root<</Type/Catalog>>/Info 6 0 R/Type/XRef/W[1 2 2]/Index[2 1 4 1 6 1]/Filter/FlateDecode/DecodeParms<</Columns 5/Predictor 12>>/Length 22>>stream
+      <</Type/XRef/Size 7/Root<</Type/Catalog>>/Info 6 0 R/Prev 141/W[1 2 2]/Index[2 1 4 1 6 1]/Filter/FlateDecode/DecodeParms<</Columns 5/Predictor 12>>/Length 22>>stream
       x\xDAcbdlg``b`\xB0\x04\x93\x93\x18\x18\x00\f\e\x01[
       endstream
       endobj
@@ -112,7 +112,7 @@ describe HexaPDF::Writer do
       HexaPDF::Writer.write(doc, output_io, incremental: true)
       assert_equal(output_io.string[0, @std_input_io.string.length], @std_input_io.string)
       doc = HexaPDF::Document.new(io: output_io)
-      assert_equal(4, doc.revisions.size)
+      assert_equal(4, doc.revisions.count)
       assert_equal(2, doc.revisions.current.each.to_a.size)
     end
 
@@ -136,29 +136,58 @@ describe HexaPDF::Writer do
     end
   end
 
+  it "moves modified objects into the last revision" do
+    io = StringIO.new
+    io2 = StringIO.new
+
+    document = HexaPDF::Document.new
+    document.pages.add
+    HexaPDF::Writer.new(document, io).write
+
+    document = HexaPDF::Document.new(io: io)
+    document.pages.add
+    HexaPDF::Writer.new(document, io2).write_incremental
+
+    document = HexaPDF::Document.new(io: io2)
+    document.revisions.add
+    document.pages.add
+    HexaPDF::Writer.new(document, io).write
+
+    document = HexaPDF::Document.new(io: io)
+    assert_equal(3, document.revisions.count)
+    assert_equal(1, document.revisions.all[0].object(2)[:Kids].length)
+    assert_equal(2, document.revisions.all[1].object(2)[:Kids].length)
+    assert_equal(3, document.revisions.all[2].object(2)[:Kids].length)
+  end
+
   it "creates an xref stream if no xref stream is in a revision but object streams are" do
     document = HexaPDF::Document.new
     document.add({Type: :ObjStm})
     HexaPDF::Writer.new(document, StringIO.new).write
-    assert(:XRef, document.object(2).type)
+    assert_equal(:XRef, document.object(4).type)
   end
 
   it "creates an xref stream if a previous revision had one" do
     document = HexaPDF::Document.new
     document.pages.add
-    document.revisions.add
+    io = StringIO.new
+    HexaPDF::Writer.new(document, io).write
+
+    document = HexaPDF::Document.new(io: io)
     document.pages.add
     document.add({Type: :ObjStm})
-    document.revisions.add
+    io2 = StringIO.new
+    HexaPDF::Writer.new(document, io2).write_incremental
+
+    document = HexaPDF::Document.new(io: io2)
     document.pages.add
-    io = StringIO.new
-    HexaPDF::Writer.new(document, io).write
+    HexaPDF::Writer.new(document, io).write_incremental
 
     document = HexaPDF::Document.new(io: io)
     assert_equal(3, document.revisions.count)
-    assert(document.revisions[0].none? {|obj| obj.type == :XRef })
-    assert(document.revisions[1].one? {|obj| obj.type == :XRef })
-    assert(document.revisions[2].one? {|obj| obj.type == :XRef })
+    assert(document.revisions.all[0].none? {|obj| obj.type == :XRef })
+    assert(document.revisions.all[1].one? {|obj| obj.type == :XRef })
+    assert(document.revisions.all[2].one? {|obj| obj.type == :XRef })
   end
 
   it "raises an error if the class is misused and an xref section contains invalid entries" do

data/test/hexapdf/type/acro_form/test_text_field.rb

@@ -115,6 +115,16 @@ describe HexaPDF::Type::AcroForm::TextField do
       @field.flag(:password)
       assert_raises(HexaPDF::Error) { @field.field_value = 'test' }
     end
+
+    it "fails if it is a comb text field without a /MaxLen entry" do
+      @field.initialize_as_comb_text_field
+      assert_raises(HexaPDF::Error) { @field.field_value = 'test' }
+    end
+
+    it "fails if the value exceeds the length set by /MaxLen" do
+      @field[:MaxLen] = 5
+      assert_raises(HexaPDF::Error) { @field.field_value = 'testdf' }
+    end
   end
 
   it "sets and returns the default field value" do
@@ -197,5 +207,12 @@ describe HexaPDF::Type::AcroForm::TextField do
       @field[:V] = nil
       assert(@field.validate)
     end
+
+    it "checks that /MaxLen is set for comb text fields" do
+      @field.initialize_as_comb_text_field
+      refute(@field.validate)
+      @field[:MaxLen] = 2
+      assert(@field.validate)
+    end
   end
 end

data/test/hexapdf/type/test_catalog.rb

@@ -21,6 +21,14 @@ describe HexaPDF::Type::Catalog do
     assert_equal(:Pages, pages.type)
   end
 
+  it "creates the name dictionary on access" do
+    assert_nil(@catalog[:Names])
+    names = @catalog.names
+    assert_equal(:XXNames, names.type)
+    other = @catalog.names
+    assert_same(other, names)
+  end
+
   describe "acro_form" do
     it "returns an existing form object" do
       @catalog[:AcroForm] = :test

data/test/hexapdf/type/test_names.rb

@@ -0,0 +1,20 @@
+# -*- encoding: utf-8 -*-
+
+require 'test_helper'
+require 'hexapdf/document'
+require 'hexapdf/type/names'
+
+describe HexaPDF::Type::Names do
+  before do
+    @doc = HexaPDF::Document.new
+    @names = @doc.add({}, type: :XXNames)
+  end
+
+  it "returns the name tree for the /Dests entry" do
+    refute(@names.key?(:Dests))
+    dests = @names.destinations
+    assert_kind_of(HexaPDF::NameTreeNode, dests)
+    assert_same(dests, @names[:Dests])
+    assert_same(dests, @names.destinations)
+  end
+end

data/test/hexapdf/type/test_xref_stream.rb

@@ -88,10 +88,11 @@ describe HexaPDF::Type::XRefStream do
       @obj[:Index] = [0, 5]
       @obj[:W] = [1, 2, 2]
       dict = @obj.trailer
-      assert_equal(3, dict.length)
+      assert_equal(4, dict.length)
       assert_equal(5, dict[:Size])
       assert_equal(["a", "b"], dict[:ID])
       assert_equal('x', dict[:Root])
+      assert_equal(:XRef, dict[:Type])
     end
   end
 

data/test/hexapdf/utils/test_sorted_tree_node.rb

@@ -135,7 +135,17 @@ describe HexaPDF::Utils::SortedTreeNode do
       assert_nil(@root.find_entry('non'))
     end
 
-    it "works when no entry exists" do
+    it "works when no entry exists and neither /Names nor /Kids are set" do
+      assert_nil(@root.find_entry('non'))
+    end
+
+    it "works when no entry exists and /Names is set" do
+      @root[:Names] = []
+      assert_nil(@root.find_entry('non'))
+    end
+
+    it "works when no entry exists and /Kids is set" do
+      @root[:Kids] = []
       assert_nil(@root.find_entry('non'))
     end
   end