hexapdf 0.12.0 → 0.14.0

data/test/hexapdf/test_document.rb

@@ -441,21 +441,21 @@ describe HexaPDF::Document do
 
   describe "validate" do
     before do
-      @doc.trailer.validate # to create a valid document
+      @doc.validate # to create a valid document
     end
 
     it "validates indirect objects" do
-      obj = @doc.add({Type: :Catalog})
+      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(@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) })
+      refute(@doc.validate {|_, _, obj| assert_same(@doc.trailer, obj) })
     end
 
     it "validates only loaded objects" do
@@ -609,16 +609,24 @@ describe HexaPDF::Document do
 
   describe "caching interface" do
     it "allows setting and retrieving values" do
-      assert_equal(:test, @doc.cache(:a, :b, :test))
-      assert_equal(:test, @doc.cache(:a, :b, :other))
-      assert_equal(:other, @doc.cache(:a, :c) { :other })
+      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.cache(:a, :b) { :c }
+      @doc.cache(:b, :c) { :d }
       @doc.clear_cache(:a)
       refute(@doc.cached?(:a, :b))
       assert(@doc.cached?(:b, :c))
@@ -626,7 +634,7 @@ describe HexaPDF::Document do
       refute(@doc.cached?(:a, :c))
     end
 
-    it "fails if no cached value exists and neither a value nor a block is given" do
+    it "fails if no cached value exists and no block is given" do
       assert_raises(LocalJumpError) { @doc.cache(:a, :b) }
     end
   end

data/test/hexapdf/test_object.rb

@@ -3,18 +3,10 @@
 require 'test_helper'
 require 'hexapdf/object'
 require 'hexapdf/reference'
+require 'hexapdf/document'
 
 describe HexaPDF::Object do
   describe "class.deep_copy" do
-    it "handles not-duplicatable classes" do
-      assert_equal(5, HexaPDF::Object.deep_copy(5))
-      assert_equal(5.5, HexaPDF::Object.deep_copy(5.5))
-      assert_nil(HexaPDF::Object.deep_copy(nil))
-      assert_equal(true, HexaPDF::Object.deep_copy(true))
-      assert_equal(false, HexaPDF::Object.deep_copy(false))
-      assert_equal(:Name, HexaPDF::Object.deep_copy(:Name))
-    end
-
     it "handles general, duplicatable classes" do
       x = "test"
       assert_equal("test", HexaPDF::Object.deep_copy(x))
@@ -103,30 +95,57 @@ describe HexaPDF::Object do
   end
 
   describe "validate" do
-    it "invokes perform_validation correctly via #validate" do
-      obj = HexaPDF::Object.new(5)
-      invoked = {}
-      obj.define_singleton_method(:perform_validation) do |&block|
-        invoked[:method] = true
+    before do
+      @obj = HexaPDF::Object.new(5)
+    end
+
+    it "invokes perform_validation correctly" do
+      invoked = false
+      @obj.define_singleton_method(:perform_validation) { invoked = true }
+      assert(@obj.validate)
+      assert(invoked)
+    end
+
+    it "yields all arguments yieled by perform_validation" do
+      invoked = []
+      @obj.define_singleton_method(:perform_validation) do |&block|
+        block.call("error", true, :object)
+      end
+      assert(@obj.validate {|*a| invoked << a })
+      assert_equal([["error", true, :object]], invoked)
+    end
+
+    it "provides self as third argument if none is yielded by perform_validation" do
+      invoked = []
+      @obj.define_singleton_method(:perform_validation) do |&block|
         block.call("error", true)
       end
-      assert(obj.validate {|*a| invoked[:block] = a })
-      assert_equal([:method, :block], invoked.keys)
-      assert_equal(["error", true], invoked[:block])
+      assert(@obj.validate {|*a| invoked << a })
+      assert_equal([["error", true, @obj]], invoked)
+    end
 
-      refute(obj.validate(auto_correct: false))
+    it "yields all problems when auto_correct is true" do
+      invoked = []
+      @obj.define_singleton_method(:perform_validation) do |&block|
+        invoked << :before
+        block.call("error", false)
+        invoked << :after
+        block.call("error2", true)
+        invoked << :last
+      end
+      refute(@obj.validate)
+      assert_equal([:before, :after, :last], invoked)
     end
 
-    it "stops validating on an uncorrectable problem" do
-      obj = HexaPDF::Object.new(5)
-      invoked = {}
-      obj.define_singleton_method(:perform_validation) do |&block|
-        invoked[:before] = true
+    it "stops at the first uncorrectable problem if auto_correct is false" do
+      invoked = []
+      @obj.define_singleton_method(:perform_validation) do |&block|
+        invoked << :before
         block.call("error", false)
-        invoked[:after] = true
+        invoked << :after
       end
-      refute(obj.validate {|*a| invoked[:block] = a })
-      refute(invoked.key?(:after))
+      refute(@obj.validate(auto_correct: false))
+      assert_equal([:before], invoked)
     end
   end
 
@@ -181,6 +200,32 @@ describe HexaPDF::Object do
     end
   end
 
+  describe "caching" do
+    before do
+      @obj = HexaPDF::Object.new({}, document: HexaPDF::Document.new)
+    end
+
+    it "can set and return a cached value" do
+      assert_equal(:value, @obj.cache(:data, :value))
+      assert_equal(:value, @obj.cache(:data, :other))
+      assert_equal(:value, @obj.cache(:block) { :value })
+      assert_equal(:other, @obj.cache(:data, :other, update: true))
+    end
+
+    it "can check for the existence of a cached value" do
+      refute(@obj.cached?(:data))
+      @obj.cache(:data, :value)
+      assert(@obj.cached?(:data))
+    end
+
+    it "can clear all cached values" do
+      @obj.cache(:data, :value)
+      assert(@obj.cached?(:data))
+      @obj.clear_cache
+      refute(@obj.cached?(:data))
+    end
+  end
+
   describe "validation" do
     before do
       @doc = Object.new

data/test/hexapdf/test_parser.rb

@@ -8,6 +8,7 @@ require 'stringio'
 describe HexaPDF::Parser do
   before do
     @document = HexaPDF::Document.new
+    @document.config['parser.try_xref_reconstruction'] = false
     @document.add(@document.wrap(10, oid: 1, gen: 0))
 
     create_parser(<<~EOF)
@@ -132,6 +133,48 @@ describe HexaPDF::Parser do
       exp = assert_raises(HexaPDF::MalformedPDFError) { @parser.parse_indirect_object(0) }
       assert_match(/stream.*followed by.*endstream/i, exp.message)
     end
+
+    describe "with strict parsing" do
+      before do
+        @document.config['parser.on_correctable_error'] = proc { true }
+      end
+
+      it "fails if an empty indirect object is found" do
+        create_parser("1 0 obj\nendobj")
+        exp = assert_raises(HexaPDF::MalformedPDFError) { @parser.parse_indirect_object }
+        assert_match(/no indirect object value/i, exp.message)
+      end
+
+      it "fails if keyword stream is followed only by CR without LF" do
+        create_parser("1 0 obj<</Length 2>> stream\r12\nendstream endobj")
+        exp = assert_raises(HexaPDF::MalformedPDFError) { @parser.parse_indirect_object }
+        assert_match(/not CR alone/, exp.message)
+      end
+
+      it "fails if the stream length value is invalid" do
+        create_parser("1 0 obj<</Length 4>> stream\n12endstream endobj")
+        exp = assert_raises(HexaPDF::MalformedPDFError) { @parser.parse_indirect_object }
+        assert_match(/invalid stream length/i, exp.message)
+      end
+
+      it "fails if the keyword endobj is mangled" do
+        create_parser("1 0 obj\n<< >>\nendobjd\n")
+        exp = assert_raises(HexaPDF::MalformedPDFError) { @parser.parse_indirect_object }
+        assert_match(/keyword endobj/, exp.message)
+      end
+
+      it "fails if the keyword endobj is missing" do
+        create_parser("1 0 obj\n<< >>")
+        exp = assert_raises(HexaPDF::MalformedPDFError) { @parser.parse_indirect_object }
+        assert_match(/keyword endobj/, exp.message)
+      end
+
+      it "fails if there is data between 'endstream' and 'endobj'" do
+        create_parser("1 0 obj\n<< >>\nstream\nendstream\ntest\nendobj\n")
+        exp = assert_raises(HexaPDF::MalformedPDFError) { @parser.parse_indirect_object(0) }
+        assert_match(/keyword endobj/, exp.message)
+      end
+    end
   end
 
   describe "load_object" do
@@ -205,7 +248,7 @@ describe HexaPDF::Parser do
     end
 
     it "ignores garbage at the end of the file" do
-      create_parser("startxref\n5\n%%EOF" + "\nhallo" * 150)
+      create_parser("startxref\n5\n%%EOF" << "\nhallo" * 150)
       assert_equal(5, @parser.startxref_offset)
     end
 
@@ -215,9 +258,9 @@ describe HexaPDF::Parser do
     end
 
     it "finds the startxref anywhere in file" do
-      create_parser("startxref\n5\n%%EOF" + "\nhallo" * 5000)
+      create_parser("startxref\n5\n%%EOF" << "\nhallo" * 5000)
       assert_equal(5, @parser.startxref_offset)
-      create_parser("startxref\n5\n%%EOF\n" + "h" * 1017)
+      create_parser("startxref\n5\n%%EOF\n" << "h" * 1017)
       assert_equal(5, @parser.startxref_offset)
     end
 
@@ -242,6 +285,13 @@ describe HexaPDF::Parser do
       exp = assert_raises(HexaPDF::MalformedPDFError) { @parser.startxref_offset }
       assert_match(/missing startxref/, exp.message)
     end
+
+    it "fails on strict parsing if the startxref is not in the last part of the file" do
+      @document.config['parser.on_correctable_error'] = proc { true }
+      create_parser("startxref\n5\n%%EOF" << "\nhallo" * 5000)
+      exp = assert_raises(HexaPDF::MalformedPDFError) { @parser.startxref_offset }
+      assert_match(/end-of-file marker not found/, exp.message)
+    end
   end
 
   describe "file_header_version" do
@@ -262,7 +312,7 @@ describe HexaPDF::Parser do
     end
 
     it "ignores junk at the beginning of the file and correctly calculates offset" do
-      create_parser("junk" * 200 + "\n%PDF-1.4\n")
+      create_parser("junk" * 200 << "\n%PDF-1.4\n")
       assert_equal('1.4', @parser.file_header_version)
       assert_equal(801, @parser.instance_variable_get(:@header_offset))
     end
@@ -318,6 +368,12 @@ describe HexaPDF::Parser do
       assert_match(/invalid cross-reference subsection/i, exp.message)
     end
 
+    it "fails if a sub section entry is mangled" do
+      create_parser("xref\n0 2\n000a000000 00000 n\n0000000000 65535 n\ntrailer\n<<>>\n")
+      exp = assert_raises(HexaPDF::MalformedPDFError) { @parser.parse_xref_section_and_trailer(0) }
+      assert_match(/invalid cross-reference entry/i, exp.message)
+    end
+
     it "fails if there is no trailer" do
       create_parser("xref\n0 1\n0000000000 00000 n \n")
       exp = assert_raises(HexaPDF::MalformedPDFError) { @parser.parse_xref_section_and_trailer(0) }
@@ -329,6 +385,71 @@ describe HexaPDF::Parser do
       exp = assert_raises(HexaPDF::MalformedPDFError) { @parser.parse_xref_section_and_trailer(0) }
       assert_match(/dictionary/, exp.message)
     end
+
+    describe "invalid numbering of main xref section" do
+      it "handles the xref if the numbering is off by N" do
+        create_parser(" 1 0 obj 1 endobj\n" \
+          "xref\n1 2\n0000000000 65535 f \n0000000001 00000 n \ntrailer\n<<>>\n")
+        section, _trailer = @parser.parse_xref_section_and_trailer(17)
+        assert_equal(HexaPDF::XRefSection.in_use_entry(1, 0, 1), section[1])
+      end
+
+      it "fails if the first entry is not the one for oid=0" do
+        create_parser(" 1 0 obj 1 endobj\n" \
+          "xref\n1 2\n0000000000 00005 f \n0000000001 00000 n \ntrailer\n<<>>\n")
+        exp = assert_raises(HexaPDF::MalformedPDFError) { @parser.parse_xref_section_and_trailer(17) }
+        assert_match(/Main.*invalid numbering/i, exp.message)
+
+        create_parser(" 1 0 obj 1 endobj\n" \
+          "xref\n1 2\n0000000001 00000 n \n0000000001 00000 n \ntrailer\n<<>>\n")
+        exp = assert_raises(HexaPDF::MalformedPDFError) { @parser.parse_xref_section_and_trailer(17) }
+        assert_match(/Main.*invalid numbering/i, exp.message)
+      end
+
+      it "fails if the tested entry position is invalid" do
+        create_parser(" 1 0 obj 1 endobj\n" \
+          "xref\n1 2\n0000000000 65535 f \n0000000005 00000 n \ntrailer\n<<>>\n")
+        exp = assert_raises(HexaPDF::MalformedPDFError) { @parser.parse_xref_section_and_trailer(17) }
+        assert_match(/Main.*invalid numbering/i, exp.message)
+      end
+
+      it "fails if the tested entry position's oid doesn't match the corrected entry oid" do
+        create_parser(" 2 0 obj 1 endobj\n" \
+          "xref\n1 2\n0000000000 65535 f \n0000000001 00000 n \ntrailer\n<<>>\n")
+        exp = assert_raises(HexaPDF::MalformedPDFError) { @parser.parse_xref_section_and_trailer(17) }
+        assert_match(/Main.*invalid numbering/i, exp.message)
+      end
+    end
+
+    describe "with strict parsing" do
+      before do
+        @document.config['parser.on_correctable_error'] = proc { true }
+      end
+
+      it "fails if xref type=n with offset=0" do
+        create_parser("xref\n0 2\n0000000000 00000 n \n0000000000 00000 n \ntrailer\n<<>>\n")
+        exp = assert_raises(HexaPDF::MalformedPDFError) { @parser.parse_xref_section_and_trailer(0) }
+        assert_match(/invalid.*cross-reference entry/i, exp.message)
+      end
+
+      it " fails xref type=n with gen>65535" do
+        create_parser("xref\n0 2\n0000000000 00000 n \n0000000000 65536 n \ntrailer\n<<>>\n")
+        exp = assert_raises(HexaPDF::MalformedPDFError) { @parser.parse_xref_section_and_trailer(0) }
+        assert_match(/invalid.*cross-reference entry/i, exp.message)
+      end
+
+      it "fails if trailing second whitespace is missing" do
+        create_parser("xref\n0 1\n0000000000 00000 n\ntrailer\n<<>>\n")
+        exp = assert_raises(HexaPDF::MalformedPDFError) { @parser.parse_xref_section_and_trailer(0) }
+        assert_match(/invalid.*cross-reference entry/i, exp.message)
+      end
+
+      it "fails if the main cross-reference section has invalid numbering" do
+        create_parser("xref\n1 1\n0000000001 00000 n \ntrailer\n<<>>\n")
+        exp = assert_raises(HexaPDF::MalformedPDFError) { @parser.parse_xref_section_and_trailer(0) }
+        assert_match(/Main.*invalid numbering/i, exp.message)
+      end
+    end
   end
 
   describe "load_revision" do
@@ -348,75 +469,60 @@ describe HexaPDF::Parser do
       exp = assert_raises(HexaPDF::MalformedPDFError) { @parser.load_revision(10) }
       assert_match(/not a cross-reference stream/, exp.message)
     end
-  end
 
-  describe "with strict parsing enabled" do
-    before do
+    it "fails on strict parsing if the cross-reference stream doesn't contain an entry for itself" do
       @document.config['parser.on_correctable_error'] = proc { true }
+      create_parser("2 0 obj\n<</Type/XRef/Length 3/W [1 1 1]/Size 1>>" \
+                    "stream\n\x01\x0A\x00\nendstream endobj")
+      exp = assert_raises(HexaPDF::MalformedPDFError) { @parser.load_revision(0) }
+      assert_match(/entry for itself/, exp.message)
     end
+  end
 
-    it "startxref_offset fails if the startxref is not in the last part of the file" do
-      create_parser("startxref\n5\n%%EOF" + "\nhallo" * 5000)
-      exp = assert_raises(HexaPDF::MalformedPDFError) { @parser.startxref_offset }
-      assert_match(/end-of-file marker not found/, exp.message)
-    end
-
-    it "parse_xref_section_and_trailer fails if xref type=n with offset=0" do
-      create_parser("xref\n0 2\n0000000000 00000 n \n0000000000 00000 n \ntrailer\n<<>>\n")
-      exp = assert_raises(HexaPDF::MalformedPDFError) { @parser.parse_xref_section_and_trailer(0) }
-      assert_match(/invalid.*cross-reference entry/i, exp.message)
+  describe "reconstruct_revision" do
+    before do
+      @document.config['parser.try_xref_reconstruction'] = true
+      @xref = HexaPDF::XRefSection.in_use_entry(1, 0, 100)
     end
 
-    it "parse_xref_section_and_trailer fails xref type=n with gen>65535" do
-      create_parser("xref\n0 2\n0000000000 00000 n \n0000000000 65536 n \ntrailer\n<<>>\n")
-      exp = assert_raises(HexaPDF::MalformedPDFError) { @parser.parse_xref_section_and_trailer(0) }
-      assert_match(/invalid.*cross-reference entry/i, exp.message)
+    it "serially parses the contents" do
+      create_parser("1 0 obj\n5\nendobj\n1 0 obj\n6\nendobj\ntrailer\n<</Size 1>>")
+      assert_equal(6, @parser.load_object(@xref).value)
     end
 
-    it "parse_xref_section_and_trailer fails if trailing second whitespace is missing" do
-      create_parser("xref\n0 1\n0000000000 00000 n\ntrailer\n<<>>\n")
-      exp = assert_raises(HexaPDF::MalformedPDFError) { @parser.parse_xref_section_and_trailer(0) }
-      assert_match(/invalid.*cross-reference subsection entry/i, exp.message)
+    it "ignores parts where the starting line is split across lines" do
+      create_parser("1 0 obj\n5\nendobj\n1 0\nobj\n6\nendobj\ntrailer\n<</Size 1>>")
+      assert_equal(5, @parser.load_object(@xref).value)
     end
 
-    it "parse_indirect_object fails if an empty indirect object is found" do
-      create_parser("1 0 obj\nendobj")
-      exp = assert_raises(HexaPDF::MalformedPDFError) { @parser.parse_indirect_object }
-      assert_match(/no indirect object value/i, exp.message)
+    it "handles cases where the line contains an invalid string that exceeds the read buffer" do
+      create_parser("(1" << "(abc" * 32188 << "\n1 0 obj\n6\nendobj\ntrailer\n<</Size 1>>")
+      assert_equal(6, @parser.load_object(@xref).value)
     end
 
-    it "parse_indirect_object fails if keyword stream is followed only by CR without LF" do
-      create_parser("1 0 obj<</Length 2>> stream\r12\nendstream endobj")
-      exp = assert_raises(HexaPDF::MalformedPDFError) { @parser.parse_indirect_object }
-      assert_match(/not CR alone/, exp.message)
+    it "ignores invalid objects" do
+      create_parser("1 x obj\n5\nendobj\n1 0 xobj\n6\nendobj\n1 0 obj 4\nendobj\ntrailer\n<</Size 1>>")
+      assert_equal(4, @parser.load_object(@xref).value)
     end
 
-    it "parse_indirect_object fails if the stream length value is invalid" do
-      create_parser("1 0 obj<</Length 4>> stream\n12endstream endobj")
-      exp = assert_raises(HexaPDF::MalformedPDFError) { @parser.parse_indirect_object }
-      assert_match(/invalid stream length/i, exp.message)
+    it "ignores invalid lines" do
+      create_parser("1 0 obj\n5\nendobj\nhello there\n1 0 obj\n6\nendobj\ntrailer\n<</Size 1>>")
+      assert_equal(6, @parser.load_object(@xref).value)
     end
 
-    it "parse_indirect_object fails if the keyword endobj is missing or mangled" do
-      create_parser("1 0 obj\n<< >>\nendobjd\n")
-      exp = assert_raises(HexaPDF::MalformedPDFError) { @parser.parse_indirect_object }
-      assert_match(/keyword endobj/, exp.message)
-      create_parser("1 0 obj\n<< >>")
-      exp = assert_raises(HexaPDF::MalformedPDFError) { @parser.parse_indirect_object }
-      assert_match(/keyword endobj/, exp.message)
+    it "uses the last trailer" do
+      create_parser("trailer <</Size 1>>\ntrailer <</Size 2/Prev 342>>")
+      assert_equal({Size: 2}, @parser.reconstructed_revision.trailer.value)
     end
 
-    it "parse_indirect_object fails if there is data between 'endstream' and 'endobj'" do
-      create_parser("1 0 obj\n<< >>\nstream\nendstream\ntest\nendobj\n")
-      exp = assert_raises(HexaPDF::MalformedPDFError) { @parser.parse_indirect_object(0) }
-      assert_match(/keyword endobj/, exp.message)
+    it "uses the first trailer in case of a linearized file" do
+      create_parser("trailer <</Size 1/Prev 342>>\ntrailer <</Size 2>>")
+      assert_equal({Size: 1}, @parser.reconstructed_revision.trailer.value)
     end
 
-    it "load_revision fails if the cross-reference stream doesn't contain an entry for itself" do
-      create_parser("2 0 obj\n<</Type/XRef/Length 3/W [1 1 1]/Size 1>>" \
-                    "stream\n\x01\x0A\x00\nendstream endobj")
-      exp = assert_raises(HexaPDF::MalformedPDFError) { @parser.load_revision(0) }
-      assert_match(/entry for itself/, exp.message)
+    it "fails if no valid trailer is found" do
+      create_parser("1 0 obj\n5\nendobj")
+      assert_raises(HexaPDF::MalformedPDFError) { @parser.load_object(@xref) }
     end
   end
 end