hexapdf 0.24.2 → 0.25.0

data/test/hexapdf/test_revisions.rb

@@ -267,6 +267,49 @@ describe HexaPDF::Revisions do
     assert_equal(2, doc.revisions.count)
   end
 
+  it "merges a completely empty revision with just a /XRefStm with the previous revision" do
+    io = StringIO.new(<<~EOF) # 2 28 3 47
+      %PDF-1.7
+      1 0 obj
+      10
+      endobj
+
+      2 0 obj
+      20
+      endobj
+
+      3 0 obj
+      << /Type /XRef /Size 3 /Index [2 1] /W [1 1 1] /Filter /ASCIIHexDecode /Length 6
+      >>stream
+      011C00
+      endstream
+      endobj
+
+      xref
+      0 4
+      0000000000 65535 f 
+      0000000009 00000 n 
+      0000000000 65535 f 
+      0000000047 00000 n 
+      trailer
+      << /Size 3 >>
+      startxref
+      170
+      %%EOF
+
+      xref
+      0 0
+      trailer
+      << /Size 3 /Prev 170 /XRefStm 47>>
+      startxref
+      302
+      %%EOF
+    EOF
+    doc = HexaPDF::Document.new(io: io)
+    assert_equal(1, doc.revisions.count)
+    assert_equal(20, doc.object(2).value)
+  end
+
   it "uses the reconstructed revision if errors are found when loading from an IO" do
     io = StringIO.new(<<~EOF)
       %PDF-1.7
@@ -300,5 +343,9 @@ describe HexaPDF::Revisions do
     doc = HexaPDF::Document.new(io: io)
     assert_equal(2, doc.revisions.count)
     assert_same(doc.revisions.all[0].trailer.value, doc.revisions.all[1].trailer.value)
+
+    assert_raises(HexaPDF::MalformedPDFError) do
+      HexaPDF::Document.new(io: io, config: {'parser.try_xref_reconstruction' => false})
+    end
   end
 end

data/test/hexapdf/test_writer.rb

@@ -40,7 +40,7 @@ describe HexaPDF::Writer do
       219
       %%EOF
       3 0 obj
-      <</Producer(HexaPDF version 0.24.2)>>
+      <</Producer(HexaPDF version 0.25.0)>>
       endobj
       xref
       3 1
@@ -72,7 +72,7 @@ describe HexaPDF::Writer do
       141
       %%EOF
       6 0 obj
-      <</Producer(HexaPDF version 0.24.2)>>
+      <</Producer(HexaPDF version 0.25.0)>>
       endobj
       2 0 obj
       <</Length 10>>stream
@@ -206,7 +206,7 @@ describe HexaPDF::Writer do
       <</Type/Page/MediaBox[0 0 595 842]/Parent 2 0 R/Resources<<>>>>
       endobj
       5 0 obj
-      <</Producer(HexaPDF version 0.24.2)>>
+      <</Producer(HexaPDF version 0.25.0)>>
       endobj
       4 0 obj
       <</Root 1 0 R/Info 5 0 R/Size 6/Type/XRef/W[1 1 2]/Index[0 6]/Filter/FlateDecode/DecodeParms<</Columns 4/Predictor 12>>/Length 33>>stream

data/test/hexapdf/type/test_catalog.rb

@@ -29,6 +29,13 @@ describe HexaPDF::Type::Catalog do
     assert_same(other, names)
   end
 
+  it "creates the document outline on access" do
+    assert_nil(@catalog[:Outlines])
+    outline = @catalog.outline
+    assert_equal(:Outlines, outline.type)
+    assert_same(outline, @catalog.outline)
+  end
+
   describe "acro_form" do
     it "returns an existing form object" do
       @catalog[:AcroForm] = :test

data/test/hexapdf/type/test_object_stream.rb

@@ -26,39 +26,40 @@ describe HexaPDF::Type::ObjectStream do
     def (@doc).trailer
       @trailer ||= {Encrypt: HexaPDF::Object.new({}, oid: 9)}
     end
-    @obj = HexaPDF::Type::ObjectStream.new({}, oid: 1, document: @doc)
+    @obj = HexaPDF::Type::ObjectStream.new({N: 2, First: 8}, oid: 1, document: @doc,
+                                           stream: "1 0 5 2 5 [1 2]")
   end
 
   it "correctly parses stream data" do
-    @obj.value = {N: 2, First: 8}
-    @obj.stream = "1 0 5 2 5 [1 2]"
     data = @obj.parse_stream
     assert_equal([5, 1], data.object_by_index(0))
     assert_equal([[1, 2], 5], data.object_by_index(1))
   end
 
-  it "allows adding and deleting object as well as determining their index" do
+  it "allows adding and deleting objects as well as determining their index" do
     @obj.add_object(5)
     @obj.add_object(7)
     @obj.add_object(9)
     @obj.add_object(5)
-    assert_equal(0, @obj.object_index(5))
-    assert_equal(1, @obj.object_index(7))
-    assert_equal(2, @obj.object_index(9))
+    assert_equal(2, @obj.object_index(5))
+    assert_equal(3, @obj.object_index(7))
+    assert_equal(4, @obj.object_index(9))
 
     @obj.delete_object(5)
     @obj.delete_object(5)
-    assert_equal(0, @obj.object_index(9))
-    assert_equal(1, @obj.object_index(7))
+    assert_equal(2, @obj.object_index(9))
+    assert_equal(3, @obj.object_index(7))
     assert_nil(@obj.object_index(5))
 
     @obj.delete_object(7)
     @obj.delete_object(9)
-    assert_nil(@obj.object_index(5))
+    assert_nil(@obj.object_index(7))
   end
 
   describe "write objects to stream" do
     before do
+      @obj.delete_object(HexaPDF::Reference.new(1))
+      @obj.delete_object(HexaPDF::Reference.new(5))
       @revision = Object.new
       def @revision.object(obj); obj; end
     end

data/test/hexapdf/type/test_outline.rb

@@ -0,0 +1,69 @@
+# -*- encoding: utf-8 -*-
+
+require 'test_helper'
+require 'hexapdf/document'
+require 'hexapdf/type/outline'
+
+describe HexaPDF::Type::Outline do
+  before do
+    @doc = HexaPDF::Document.new
+    @outline = @doc.add({}, type: :Outlines)
+  end
+
+  it "delegates add_item to the outline item wrapper" do
+    item = @outline.add_item("test", position: :first, text_color: "blue", flags: [:italic])
+    assert_equal("test", item.title)
+    assert_equal([0, 0, 1], item.text_color.components)
+    assert_equal([:italic], item.flags)
+  end
+
+  it "recursively iterates over all items by delegating to the outline item wrapper" do
+    @outline.add_item("Item1") do |item1|
+      item1.add_item("Item2")
+      item1.add_item("Item3") do |item3|
+        item3.add_item("Item4")
+      end
+      item1.add_item("Item5")
+    end
+    assert_equal(%w[Item1 Item2 Item3 Item4 Item5], @outline.each_item.map(&:title))
+  end
+
+  describe "perform_validation" do
+    before do
+      5.times { @outline.add_item("Test1") }
+    end
+
+    it "fixes a missing /First entry" do
+      @outline.delete(:First)
+      called = false
+      @outline.validate do |msg, correctable, _|
+        called = true
+        assert_match(/missing an endpoint reference/, msg)
+        assert(correctable)
+      end
+      assert(called)
+    end
+
+    it "fixes a missing /Last entry" do
+      @outline.delete(:Last)
+      called = false
+      @outline.validate do |msg, correctable, _|
+        called = true
+        assert_match(/missing an endpoint reference/, msg)
+        assert(correctable)
+      end
+      assert(called)
+    end
+
+    it "deletes the /Count entry if no /First and /Last entries exist" do
+      @outline.delete(:Last)
+      @outline.delete(:First)
+      assert_equal(5, @outline[:Count])
+      @outline.validate do |msg, correctable, _|
+        assert_match(/key \/Count set but no items exist/, msg)
+        assert(correctable)
+      end
+      refute(@outline.key?(:Count))
+    end
+  end
+end

data/test/hexapdf/type/test_outline_item.rb

@@ -0,0 +1,292 @@
+# -*- encoding: utf-8 -*-
+
+require 'test_helper'
+require 'hexapdf/document'
+require 'hexapdf/type/outline_item'
+
+describe HexaPDF::Type::OutlineItem do
+  before do
+    @doc = HexaPDF::Document.new
+    @item = @doc.add({Title: "root", Count: 0}, type: :XXOutlineItem)
+  end
+
+  describe "title" do
+    it "returns the set title" do
+      @item[:Title] = 'Test'
+      assert_equal('Test', @item.title)
+    end
+
+    it "sets the title to the given value" do
+      @item.title('Test')
+      assert_equal('Test', @item[:Title])
+    end
+  end
+
+  describe "text_color" do
+    it "returns the default color if none is set" do
+      assert_equal([0, 0, 0], @item.text_color.components)
+    end
+
+    it "returns the set color" do
+      @item[:C] = [0, 0.5, 1]
+      assert_equal([0, 0.5, 1], @item.text_color.components)
+    end
+
+    it "sets the text color to the given value" do
+      @item.text_color([51, 51, 255])
+      assert_equal([0.2, 0.2, 1], @item[:C])
+    end
+
+    it "fails if a color in another color space is set" do
+      assert_raises(ArgumentError) { @item.text_color(5) }
+    end
+  end
+
+  describe "destination" do
+    it "returns the set destination" do
+      @item[:Dest] = [5, :Fit]
+      assert_equal([5, :Fit], @item.destination)
+    end
+
+    it "sets the destination to the given value" do
+      @item.destination(@doc.pages.add)
+      assert_equal([@doc.pages[0], :Fit], @item[:Dest])
+    end
+
+    it "deletes an existing action entry when setting a value" do
+      @item[:A] = {S: :GoTo}
+      @item.destination(@doc.pages.add)
+      refute(@item.key?(:A))
+    end
+  end
+
+  describe "action" do
+    it "returns the set action" do
+      @item[:A] = {S: :GoTo}
+      assert_equal({S: :GoTo}, @item.action.value)
+    end
+
+    it "sets the action to the given value" do
+      @item.action({S: :GoTo})
+      assert_equal({S: :GoTo}, @item[:A].value)
+    end
+
+    it "deletes an existing destination entry when setting a value" do
+      @item[:Dest] = [1, :Fit]
+      @item.action({S: :GoTo})
+      refute(@item.key?(:Dest))
+    end
+  end
+
+  describe "add" do
+    it "returns the created item" do
+      new_item = @item.add_item("Test")
+      assert_equal("Test", new_item.title)
+      assert_equal(0, new_item[:Count])
+      assert_same(@item, new_item[:Parent])
+      assert(new_item.indirect?)
+    end
+
+    it "sets the item's text color" do
+      new_item = @item.add_item("Test", text_color: "red")
+      assert_equal([1, 0, 0], new_item.text_color.components)
+    end
+
+    it "sets the item's flags" do
+      new_item = @item.add_item("Test", flags: [:bold, :italic])
+      assert_equal([:italic, :bold], new_item.flags)
+    end
+
+    it "doesn't set the item's /Count when it should not be open" do
+      new_item = @item.add_item("Test", open: false)
+      refute(new_item.key?(:Count))
+    end
+
+    it "sets the item's destination if given" do
+      new_item = @item.add_item("Test", destination: @doc.pages.add)
+      assert_equal([@doc.pages[0], :Fit], new_item.destination)
+    end
+
+    it "sets the item's action if given" do
+      new_item = @item.add_item("Test", action: {S: :GoTo, D: [1, :Fit]})
+      assert_equal({S: :GoTo, D: [1, :Fit]}, new_item.action.value)
+    end
+
+    it "yields the item" do
+      yielded_item = nil
+      new_item = @item.add_item("Test") {|i| yielded_item = i }
+      assert_same(new_item, yielded_item)
+    end
+
+    describe "position" do
+      it "works for an empty item" do
+        new_item = @item.add_item("Test")
+        assert_same(new_item, @item[:First])
+        assert_same(new_item, @item[:Last])
+        assert_nil(new_item[:Next])
+        assert_nil(new_item[:Prev])
+      end
+
+      it "inserts an item at the last position with at least one existing sub-item" do
+        first_item = @item.add_item("Test")
+        second_item = @item.add_item("Test", position: :last)
+        assert_same(first_item, @item[:First])
+        assert_same(second_item, @item[:Last])
+        assert_same(second_item, first_item[:Next])
+        assert_same(first_item, second_item[:Prev])
+      end
+
+      it "inserts an item at the first position with at least one existing sub-item" do
+        second_item = @item.add_item("Test")
+        first_item = @item.add_item("Test", position: :first)
+        assert_same(first_item, @item[:First])
+        assert_same(second_item, @item[:Last])
+        assert_same(second_item, first_item[:Next])
+        assert_same(first_item, second_item[:Prev])
+      end
+
+      it "inserts an item at an arbitrary positive index" do
+        5.times {|i| @item.add_item("Test#{i}") }
+        @item.add_item("Test", position: 3)
+        item = @item[:First]
+        %w[Test0 Test1 Test2 Test Test3 Test4].each do |title|
+          assert_equal(title, item.title)
+          item = item[:Next]
+        end
+      end
+
+      it "inserts an item at an arbitrary negative index" do
+        5.times {|i| @item.add_item("Test#{i}") }
+        @item.add_item("Test", position: -3)
+        item = @item[:First]
+        %w[Test0 Test1 Test2 Test Test3 Test4].each do |title|
+          assert_equal(title, item.title)
+          item = item[:Next]
+        end
+      end
+
+      it "raises an out of bounds error for invalid integer values" do
+        5.times {|i| @item.add_item("Test#{i}") }
+        assert_raises(ArgumentError) { @item.add_item("Test", position: 10) }
+        assert_raises(ArgumentError) { @item.add_item("Test", position: -10) }
+      end
+
+      it "raises an error for an invalid value" do
+        assert_raises(ArgumentError) { @item.add_item("Test", position: :luck) }
+      end
+    end
+
+    it "calculcates the /Count values correctly" do
+      [
+        [[true, true], [6, 4, 0, 1, 0, 0, 0]],
+        [[true, false], [5, 3, 0, -1, 0, 0, 0]],
+        [[false, true], [2, -4, 0, 1, 0, 0, 0]],
+        [[false, false], [2, -3, 0, -1, 0, 0, 0]],
+      ].each do |(states, result)|
+        # reset list
+        @item[:First] = @item[:Last] = nil
+        @item[:Count] = 0
+
+        items = [@item]
+        @item.add_item("Document", open: states[0]) do |idoc|
+          items << idoc
+          items << idoc.add_item("Section 1", open: false)
+          idoc.add_item("Section 2", open: states[1]) do |isec|
+            items << isec
+            items << isec.add_item("Subsection 1")
+          end
+          items << idoc.add_item("Section 3")
+        end
+        items << @item.add_item("Summary")
+        items.each_with_index {|item, index| assert_equal(result.shift, item[:Count] || 0, "item#{index}") }
+      end
+    end
+  end
+
+  it "recursively iterates over all descendant items" do
+    @item.add_item("Item1") do |item1|
+      item1.add_item("Item2")
+      item1.add_item("Item3") do |item3|
+        item3.add_item("Item4")
+      end
+      item1.add_item("Item5")
+    end
+    assert_equal(%w[Item1 Item2 Item3 Item4 Item5], @item.each_item.map(&:title))
+  end
+
+  describe "perform_validation" do
+    before do
+      5.times { @item.add_item("Test1") }
+      @item[:Parent] = @doc.add({})
+    end
+
+    it "fixes a missing /First entry" do
+      @item.delete(:First)
+      called = false
+      @item.validate do |msg, correctable, _|
+        called = true
+        assert_match(/missing an endpoint reference/, msg)
+        assert(correctable)
+      end
+      assert(called)
+    end
+
+    it "fixes a missing /Last entry" do
+      @item.delete(:Last)
+      called = false
+      @item.validate do |msg, correctable, _|
+        called = true
+        assert_match(/missing an endpoint reference/, msg)
+        assert(correctable)
+      end
+      assert(called)
+    end
+
+    it "deletes the /Count entry if no /First and /Last entries exist" do
+      @item.delete(:Last)
+      @item.delete(:First)
+      assert_equal(5, @item[:Count])
+      @item.validate do |msg, correctable, _|
+        assert_match(/\/Count set but no descendants/, msg)
+        assert(correctable)
+      end
+      refute(@item.key?(:Count))
+    end
+
+    it "fails validation if the previous item's /Next points somewhere else" do
+      item = @item[:First][:Next]
+      item[:Prev][:Next] = item[:Next]
+      item.validate do |msg, correctable, _|
+        assert_match(/\/Prev points to item whose \/Next points somewhere else/, msg)
+        refute(correctable)
+      end
+    end
+
+    it "corrects the previous item's missing /Next entry" do
+      item = @item[:First][:Next]
+      item[:Prev].delete(:Next)
+      item.validate do |msg, correctable, _|
+        assert_match(/\/Prev points to item without \/Next/, msg)
+        assert(correctable)
+      end
+    end
+
+    it "fails validation if the next item's /Prev points somewhere else" do
+      item = @item[:First][:Next]
+      item[:Next][:Prev] = item[:Prev]
+      item.validate do |msg, correctable, _|
+        assert_match(/\/Next points to item whose \/Prev points somewhere else/, msg)
+        refute(correctable)
+      end
+    end
+
+    it "corrects the next item's missing /Prev entry" do
+      item = @item[:First][:Next]
+      item[:Next].delete(:Prev)
+      item.validate do |msg, correctable, _|
+        assert_match(/\/Next points to item without \/Prev/, msg)
+        assert(correctable)
+      end
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: hexapdf
 version: !ruby/object:Gem::Version
-  version: 0.24.2
+  version: 0.25.0
 platform: ruby
 authors:
 - Thomas Leitner
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2022-08-30 00:00:00.000000000 Z
+date: 2022-10-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: cmdparse
@@ -233,6 +233,7 @@ files:
 - examples/019-acro_form.rb
 - examples/020-column_box.rb
 - examples/021-list_box.rb
+- examples/022-outline.rb
 - examples/emoji-smile.png
 - examples/emoji-wink.png
 - examples/machupicchu.jpg
@@ -421,6 +422,8 @@ files:
 - lib/hexapdf/type/info.rb
 - lib/hexapdf/type/names.rb
 - lib/hexapdf/type/object_stream.rb
+- lib/hexapdf/type/outline.rb
+- lib/hexapdf/type/outline_item.rb
 - lib/hexapdf/type/page.rb
 - lib/hexapdf/type/page_tree_node.rb
 - lib/hexapdf/type/resources.rb
@@ -664,6 +667,8 @@ files:
 - test/hexapdf/type/test_info.rb
 - test/hexapdf/type/test_names.rb
 - test/hexapdf/type/test_object_stream.rb
+- test/hexapdf/type/test_outline.rb
+- test/hexapdf/type/test_outline_item.rb
 - test/hexapdf/type/test_page.rb
 - test/hexapdf/type/test_page_tree_node.rb
 - test/hexapdf/type/test_resources.rb
@@ -698,7 +703,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.32
+rubygems_version: 3.3.3
 signing_key: 
 specification_version: 4
 summary: HexaPDF - A Versatile PDF Creation and Manipulation Library For Ruby