hexapdf 0.1.0

data/test/hexapdf/test_parser.rb

@@ -0,0 +1,394 @@
+# -*- encoding: utf-8 -*-
+
+require 'test_helper'
+require 'hexapdf/document'
+require 'hexapdf/parser'
+require 'stringio'
+
+describe HexaPDF::Parser do
+  before do
+    @document = HexaPDF::Document.new
+    @document.add(@document.wrap(10, oid: 1, gen: 0))
+
+    create_parser(<<EOF)
+%PDF-1.7
+
+1 0 obj
+10
+endobj
+
+2 0 obj
+[ 5 6 <</Length 10 >> (name) <4E6F762073 686D6F7A20	6B612070
+6F702E>]
+endobj
+
+3 15 obj<< /Length 1 0 R/Hallo 6/Filter /Fl/DecodeParms<<>> >>stream
+Hallo PDF!endstream
+endobj
+
+4 0 obj
+<</Type /XRef /Length 3 /W [1 1 1] /Index [1 1] /Size 2 >> stream
+\x01\x0A\x00
+endstream
+endobj
+
+xref
+0 4
+0000000000 65535 f 
+0000000010 00000 n 
+0000000029 00000 n 
+0000000000 65535 f 
+3 1
+0000000556 00000 n 
+trailer
+<< /Test (now) >>
+startxref
+308
+%%EOF
+EOF
+  end
+
+  def create_parser(str)
+    @parser = HexaPDF::Parser.new(StringIO.new(str), @document)
+  end
+
+  describe "parse_indirect_object" do
+    it "reads indirect objects sequentially" do
+      object, oid, gen, stream = @parser.parse_indirect_object
+      assert_equal(1, oid)
+      assert_equal(0, gen)
+      assert_equal(10, object)
+      assert_nil(stream)
+
+      object, oid, gen, stream = @parser.parse_indirect_object
+      assert_equal(2, oid)
+      assert_equal(0, gen)
+      assert_equal([5, 6, {Length: 10}, "name", "Nov shmoz ka pop."], object)
+      assert_nil(stream)
+
+      object, oid, gen, stream = @parser.parse_indirect_object
+      assert_equal(3, oid)
+      assert_equal(15, gen)
+      assert_kind_of(HexaPDF::StreamData, stream)
+      assert_equal([:Fl], stream.filter)
+      assert_equal([{}], stream.decode_parms)
+      assert_equal({Length: 10, Hallo: 6, Filter: :Fl, DecodeParms: {}}, object)
+    end
+
+    it "handles empty indirect objects by using PDF null for them" do
+      create_parser("1 0 obj\nendobj")
+      object, * = @parser.parse_indirect_object
+      assert_nil(object)
+    end
+
+    it "handles keyword stream followed only by CR without LF" do
+      create_parser("1 0 obj<</Length 2>> stream\r12\nendstream endobj")
+      *, stream = @parser.parse_indirect_object
+      assert_equal('12', TestHelper.collector(stream.fiber))
+    end
+
+    it "recovers from an invalid stream length value" do
+      create_parser("1 0 obj<</Length 4>> stream\n12endstream endobj")
+      obj, _, _, stream = @parser.parse_indirect_object
+      assert_equal(2, obj[:Length])
+      assert_equal('12', TestHelper.collector(stream.fiber))
+    end
+
+    it "works even if the keyword endobj is missing or mangled" do
+      create_parser("1 0 obj<</Length 4>>5")
+      object, * = @parser.parse_indirect_object
+      assert_equal({Length: 4}, object)
+      create_parser("1 0 obj<</Length 4>>endobjk")
+      object, * = @parser.parse_indirect_object
+      assert_equal({Length: 4}, object)
+    end
+
+    it "fails if the oid, gen or 'obj' keyword is invalid" do
+      create_parser("a 0 obj\n5\nendobj")
+      exp = assert_raises(HexaPDF::MalformedPDFError) { @parser.parse_indirect_object }
+      assert_match(/No valid object/, exp.message)
+      create_parser("1 a obj\n5\nendobj")
+      exp = assert_raises(HexaPDF::MalformedPDFError) { @parser.parse_indirect_object }
+      assert_match(/No valid object/, exp.message)
+      create_parser("1 0 dobj\n5\nendobj")
+      exp = assert_raises(HexaPDF::MalformedPDFError) { @parser.parse_indirect_object }
+      assert_match(/No valid object/, exp.message)
+    end
+
+    it "fails if the value of a stream is not a dictionary" do
+      create_parser("1 0 obj\n(fail)\nstream\nendstream\nendobj\n")
+      exp = assert_raises(HexaPDF::MalformedPDFError) { @parser.parse_indirect_object }
+      assert_match(/stream.*dictionary/, exp.message)
+    end
+
+    it "fails if the 'stream' keyword isn't followed by EOL" do
+      create_parser("1 0 obj\n<< >>\nstream endstream\nendobj\n")
+      exp = assert_raises(HexaPDF::MalformedPDFError) { @parser.parse_indirect_object(0) }
+      assert_match(/stream.*followed by LF/, exp.message)
+    end
+
+    it "fails if the 'endstream' keyword is missing" do
+      create_parser("1 0 obj\n<< >>\nstream\nendobj\n")
+      exp = assert_raises(HexaPDF::MalformedPDFError) { @parser.parse_indirect_object(0) }
+      assert_match(/stream.*followed by.*endstream/i, exp.message)
+    end
+  end
+
+  describe "load_object" do
+    before do
+      @entry = HexaPDF::XRefSection.in_use_entry(2, 0, 29)
+    end
+
+    it "can load an indirect object" do
+      obj = @parser.load_object(@entry)
+      assert_kind_of(HexaPDF::Object, obj)
+      assert_equal(5, obj.value[0])
+      assert_equal(2, obj.oid)
+      assert_equal(0, obj.gen)
+    end
+
+    it "can load a free object" do
+      obj = @parser.load_object(HexaPDF::XRefSection.free_entry(0, 0))
+      assert_kind_of(HexaPDF::Object, obj)
+      assert_nil(obj.value)
+    end
+
+    it "can load a compressed object" do
+      def (@document).object(_oid)
+        obj = Object.new
+        def obj.parse_stream
+          HexaPDF::Type::ObjectStream::Data.new("5 [1 2]", [1, 2], [0, 2])
+        end
+        obj
+      end
+
+      obj = @parser.load_object(HexaPDF::XRefSection.compressed_entry(2, 3, 1))
+      assert_kind_of(HexaPDF::Object, obj)
+      assert_equal([1, 2], obj.value)
+    end
+
+    it "fails if another object is found instead of an object stream" do
+      def (@document).object(_oid)
+        :invalid
+      end
+      exp = assert_raises(HexaPDF::MalformedPDFError) do
+        @parser.load_object(HexaPDF::XRefSection.compressed_entry(2, 1, 1))
+      end
+      assert_match(/not an object stream/, exp.message)
+    end
+
+    it "fails if the xref entry type is invalid" do
+      exp = assert_raises(HexaPDF::MalformedPDFError) do
+        @parser.load_object(HexaPDF::XRefSection::Entry.new(:invalid))
+      end
+      assert_match(/invalid cross-reference type/i, exp.message)
+    end
+
+    it "fails if the object/generation numbers don't match" do
+      exp = assert_raises(HexaPDF::MalformedPDFError) do
+        @entry.gen = 2
+        @parser.load_object(@entry)
+      end
+      assert_match(/oid,gen.*don't match/, exp.message)
+    end
+  end
+
+  describe "startxref_offset" do
+    it "returns the correct offset" do
+      assert_equal(308, @parser.startxref_offset)
+    end
+
+    it "ignores garbage at the end of the file" do
+      create_parser("startxref\n5\n%%EOF" + "\nhallo" * 150)
+      assert_equal(5, @parser.startxref_offset)
+    end
+
+    it "uses the last startxref if there are more than one" do
+      create_parser("startxref\n5\n%%EOF\n\nsome garbage\n\nstartxref\n555\n%%EOF\n")
+      assert_equal(555, @parser.startxref_offset)
+    end
+
+    it "finds the startxref anywhere in file" do
+      create_parser("startxref\n5\n%%EOF" + "\nhallo" * 5000)
+      assert_equal(5, @parser.startxref_offset)
+      create_parser("startxref\n5\n%%EOF\n" + "h" * 1017)
+      assert_equal(5, @parser.startxref_offset)
+    end
+
+    it "fails even in big files when nothing is found" do
+      create_parser("\nhallo" * 5000)
+      exp = assert_raises(HexaPDF::MalformedPDFError) { @parser.startxref_offset }
+      assert_match(/end-of-file marker not found/, exp.message)
+    end
+
+    it "fails if the %%EOF marker is missing" do
+      create_parser("startxref\n5")
+      exp = assert_raises(HexaPDF::MalformedPDFError) { @parser.startxref_offset }
+      assert_match(/end-of-file marker not found/, exp.message)
+    end
+
+    it "fails if the startxref keyword is missing" do
+      create_parser("somexref\n5\n%%EOF")
+      exp = assert_raises(HexaPDF::MalformedPDFError) { @parser.startxref_offset }
+      assert_match(/missing startxref/, exp.message)
+    end
+  end
+
+  describe "file_header_version" do
+    it "returns the correct version" do
+      assert_equal('1.7', @parser.file_header_version)
+    end
+
+    it "fails if the header is mangled" do
+      create_parser("%PDF-1\n")
+      exp = assert_raises(HexaPDF::MalformedPDFError) { @parser.file_header_version }
+      assert_match(/file header/, exp.message)
+    end
+
+    it "ignores junk at the beginning of the file and correctly calculates offset" do
+      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
+  end
+
+  it "xref_section?" do
+    assert(@parser.xref_section?(@parser.startxref_offset))
+    refute(@parser.xref_section?(53))
+  end
+
+  describe "parse_xref_section_and_trailer" do
+    it "works on a section with multiple sub sections" do
+      section, trailer = @parser.parse_xref_section_and_trailer(@parser.startxref_offset)
+      assert_equal({Test: 'now'}, trailer)
+      assert_equal(HexaPDF::XRefSection.free_entry(0, 65535), section[0, 65535])
+      assert_equal(HexaPDF::XRefSection.free_entry(3, 65535), section[3, 65535])
+      assert_equal(HexaPDF::XRefSection.in_use_entry(1, 0, 10), section[1])
+    end
+
+    it "works for an empty section" do
+      create_parser("xref\n0 0\ntrailer\n<</Name /Value >>\n")
+      _, trailer = @parser.parse_xref_section_and_trailer(0)
+      assert_equal({Name: :Value}, trailer)
+    end
+
+    it "handles xref type=n with offset=0" do
+      create_parser("xref\n0 2\n0000000000 00000 n \n0000000000 00000 n \ntrailer\n<<>>\n")
+      section, _trailer = @parser.parse_xref_section_and_trailer(0)
+      assert_equal(HexaPDF::XRefSection.free_entry(1, 0), section[1])
+    end
+
+    it "handles xref type=n with gen>65535" do
+      create_parser("xref\n0 2\n0000000000 00000 n \n0000000000 65536 n \ntrailer\n<<>>\n")
+      section, _trailer = @parser.parse_xref_section_and_trailer(0)
+      assert_equal(HexaPDF::XRefSection.free_entry(1, 65536), section[1])
+    end
+
+    it "fails if the xref keyword is missing/mangled" do
+      create_parser("xTEf\n0 d\n0000000000 00000 n \ntrailer\n<< >>\n")
+      exp = assert_raises(HexaPDF::MalformedPDFError) { @parser.parse_xref_section_and_trailer(0) }
+      assert_match(/keyword xref/, exp.message)
+    end
+
+    it "fails if a sub section header is mangled" do
+      create_parser("xref\n0 d\n0000000000 00000 n \ntrailer\n<< >>\n")
+      exp = assert_raises(HexaPDF::MalformedPDFError) { @parser.parse_xref_section_and_trailer(0) }
+      assert_match(/invalid cross-reference subsection/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) }
+      assert_match(/keyword trailer/i, exp.message)
+    end
+
+    it "fails if the trailer is not a PDF dictionary" do
+      create_parser("xref\n0 1\n0000000000 00000 n \ntrailer\n(base)")
+      exp = assert_raises(HexaPDF::MalformedPDFError) { @parser.parse_xref_section_and_trailer(0) }
+      assert_match(/dictionary/, exp.message)
+    end
+  end
+
+  describe "load_revision" do
+    it "works for a simple cross-reference section" do
+      xref_section, trailer = @parser.load_revision(@parser.startxref_offset)
+      assert_equal({Test: 'now'}, trailer)
+      assert(xref_section[1].in_use?)
+    end
+
+    it "works for a cross-reference stream" do
+      xref_section, trailer = @parser.load_revision(212)
+      assert_equal({Size: 2}, trailer)
+      assert(xref_section[1].in_use?)
+    end
+
+    it "fails if another object is found instead of a cross-reference stream" 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
+      @document.config['parser.on_correctable_error'] = proc { true }
+    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)
+    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)
+    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)
+    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)
+    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)
+    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)
+    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)
+    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)
+    end
+  end
+end

data/test/hexapdf/test_rectangle.rb

@@ -0,0 +1,36 @@
+# -*- encoding: utf-8 -*-
+
+require 'test_helper'
+require 'hexapdf/rectangle'
+
+describe HexaPDF::Rectangle do
+  describe "after_data_change" do
+    it "fails if the value is not a array" do
+      assert_raises(ArgumentError) { HexaPDF::Rectangle.new(:Name) }
+    end
+
+    it "normalizes the array values" do
+      rect = HexaPDF::Rectangle.new([0, 1, 2, 3])
+      assert_equal([0, 1, 2, 3], rect.value)
+
+      rect = HexaPDF::Rectangle.new([2, 3, 0, 1])
+      assert_equal([0, 1, 2, 3], rect.value)
+
+      rect = HexaPDF::Rectangle.new([0, 3, 2, 1])
+      assert_equal([0, 1, 2, 3], rect.value)
+
+      rect = HexaPDF::Rectangle.new([2, 1, 0, 3])
+      assert_equal([0, 1, 2, 3], rect.value)
+    end
+  end
+
+  it "returns individual fields of the rectangle" do
+    rect = HexaPDF::Rectangle.new([2, 1, 0, 5])
+    assert_equal(0, rect.left)
+    assert_equal(2, rect.right)
+    assert_equal(1, rect.bottom)
+    assert_equal(5, rect.top)
+    assert_equal(2, rect.width)
+    assert_equal(4, rect.height)
+  end
+end

data/test/hexapdf/test_reference.rb

@@ -0,0 +1,41 @@
+# -*- encoding: utf-8 -*-
+
+require 'test_helper'
+require 'hexapdf/reference'
+
+describe HexaPDF::Reference do
+  it "correctly assigns oid and gen on initialization" do
+    r = HexaPDF::Reference.new(5, 7)
+    assert_equal(5, r.oid)
+    assert_equal(7, r.gen)
+  end
+
+  it "raises an error when invalid objects are supplied on initialization" do
+    assert_raises(ArgumentError) { HexaPDF::Reference.new('a', 7) }
+    assert_raises(ArgumentError) { HexaPDF::Reference.new(5, 'b') }
+  end
+
+  it "is sortable" do
+    assert_equal([HexaPDF::Reference.new(1, 0), HexaPDF::Reference.new(1, 1),
+                  HexaPDF::Reference.new(5, 7)],
+                 [HexaPDF::Reference.new(5, 7), HexaPDF::Reference.new(1, 1),
+                  HexaPDF::Reference.new(1, 0)].sort)
+  end
+
+  it "is comparable to itself" do
+    assert_equal(HexaPDF::Reference.new(5, 7), HexaPDF::Reference.new(5, 7))
+    refute_equal(HexaPDF::Reference.new(5, 7), HexaPDF::Reference.new(5, 8))
+    refute_equal(HexaPDF::Reference.new(5, 7), HexaPDF::Reference.new(4, 7))
+  end
+
+  it "behaves correctly as hash key" do
+    h = {}
+    h[HexaPDF::Reference.new(5, 7)] = true
+    assert(h.key?(HexaPDF::Reference.new(5, 7)))
+    refute(h.key?(HexaPDF::Reference.new(5, 8)))
+  end
+
+  it "shows oid and gen on inspection" do
+    assert_match(/\[5, 7\]/, HexaPDF::Reference.new(5, 7).inspect)
+  end
+end

data/test/hexapdf/test_revision.rb

@@ -0,0 +1,139 @@
+# -*- encoding: utf-8 -*-
+
+require 'test_helper'
+require 'hexapdf/revision'
+require 'hexapdf/object'
+require 'hexapdf/reference'
+require 'hexapdf/xref_section'
+require 'stringio'
+
+describe HexaPDF::Revision do
+  before do
+    @xref_section = HexaPDF::XRefSection.new
+    @xref_section.add_in_use_entry(2, 0, 5000)
+    @xref_section.add_free_entry(3, 0)
+    @obj = HexaPDF::Object.new(:val, oid: 1, gen: 0)
+    @ref = HexaPDF::Reference.new(1, 0)
+
+    @loader = lambda do |entry|
+      if entry.type == :free
+        HexaPDF::Object.new(nil, oid: entry.oid, gen: entry.gen)
+      else
+        HexaPDF::Object.new(:Test, oid: entry.oid, gen: entry.gen)
+      end
+    end
+    @rev = HexaPDF::Revision.new({}, xref_section: @xref_section, loader: @loader)
+  end
+
+  it "needs the trailer as first argument on initialization" do
+    rev = HexaPDF::Revision.new({})
+    assert_equal({}, rev.trailer)
+  end
+
+  it "takes an xref section and/or a parser on initialization" do
+    rev = HexaPDF::Revision.new({}, loader: @loader, xref_section: @xref_section)
+    assert_equal(:Test, rev.object(2).value)
+  end
+
+  it "returns the next free object number" do
+    assert_equal(4, @rev.next_free_oid)
+    @obj.oid = 4
+    @rev.add(@obj)
+    assert_equal(5, @rev.next_free_oid)
+  end
+
+  describe "add" do
+    it "works correctly" do
+      @rev.add(@obj)
+      assert(@rev.object?(@ref))
+    end
+
+    it "also returns the supplied object" do
+      assert_equal(@obj, @rev.add(@obj))
+    end
+
+    it "fails if the revision already has an object with the same object number" do
+      @rev.add(@obj)
+      assert_raises(HexaPDF::Error) { @rev.add(@obj) }
+      assert_raises(HexaPDF::Error) { @rev.add(HexaPDF::Object.new(:val, oid: 2)) }
+    end
+
+    it "fails if the given object has an object number of zero" do
+      assert_raises(HexaPDF::Error) { @rev.add(HexaPDF::Object.new(:val)) }
+    end
+  end
+
+  describe "object" do
+    it "returns nil if no object is found" do
+      assert_nil(@rev.object(@ref))
+      assert_nil(@rev.object(1))
+    end
+
+    it "returns an object that was added before" do
+      @rev.add(@obj)
+      assert_equal(@obj, @rev.object(@ref))
+      assert_equal(@obj, @rev.object(1))
+    end
+
+    it "loads an object that is defined in the cross-reference section" do
+      obj = @rev.object(HexaPDF::Reference.new(2, 0))
+      assert_equal(:Test, obj.value)
+      assert_equal(2, obj.oid)
+      assert_equal(0, obj.gen)
+    end
+
+    it "loads an object that is defined in the cross-reference section by using only the object number" do
+      obj = @rev.object(2)
+      refute_nil(obj)
+    end
+
+    it "loads free entries in the cross-reference section as special PDF null objects" do
+      obj = @rev.object(HexaPDF::Reference.new(3, 0))
+      assert_nil(obj.value)
+    end
+  end
+
+  describe "delete" do
+    before do
+      @rev.add(@obj)
+    end
+
+    it "deletes objects specified by reference" do
+      @rev.delete(@ref, mark_as_free: false)
+      refute(@rev.object?(@ref))
+      assert(@obj.null?)
+    end
+
+    it "deletes objects specified by object number" do
+      @rev.delete(@ref.oid, mark_as_free: false)
+      refute(@rev.object?(@ref.oid))
+      assert(@obj.null?)
+    end
+
+    it "marks the object as PDF null object when using mark_as_free=true" do
+      refute(@obj.null?)
+      @rev.delete(@ref)
+      assert(@rev.object(@ref).null?)
+      assert(@obj.null?)
+    end
+  end
+
+  describe "object iteration" do
+    it "iterates over all objects via each" do
+      @rev.add(@obj)
+      obj2 = @rev.object(2)
+      obj3 = @rev.object(3)
+      assert_equal([@obj, obj2, obj3], @rev.each.to_a)
+    end
+  end
+
+  it "works without a cross-reference section" do
+    rev = HexaPDF::Revision.new({})
+    rev.add(@obj)
+    assert_equal(@obj, rev.object(@ref))
+    assert(rev.object?(@ref))
+    assert_equal([@obj], rev.each.to_a)
+    rev.delete(@ref, mark_as_free: false)
+    refute(rev.object?(@ref))
+  end
+end

data/test/hexapdf/test_revisions.rb

@@ -0,0 +1,93 @@
+# -*- encoding: utf-8 -*-
+
+require 'test_helper'
+require 'hexapdf/revisions'
+require 'hexapdf/document'
+require 'stringio'
+
+describe HexaPDF::Revisions do
+  before do
+    @io = StringIO.new(<<EOF)
+%PDF-1.7
+1 0 obj
+10
+endobj
+
+2 0 obj
+20
+endobj
+
+xref
+0 3
+0000000000 65535 f 
+0000000009 00000 n 
+0000000028 00000 n 
+trailer
+<< /Size 3 >>
+startxref
+47
+%%EOF
+
+2 0 obj
+200
+endobj
+
+xref
+2 1
+0000000158 00000 n 
+trailer
+<< /Size 3 /Prev 47 >>
+startxref
+178
+%%EOF
+EOF
+    @doc = HexaPDF::Document.new(io: @io)
+    @revisions = @doc.revisions
+  end
+
+  describe "add" do
+    it "adds an empty revision as the current revision" do
+      rev = @revisions.add
+      assert_equal({Size: 3}, rev.trailer.value)
+      assert_equal(rev, @revisions.current)
+    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})
+    end
+
+    it "allows deleting a revision by specifying a revision" do
+      rev = @revisions.revision(0)
+      @revisions.delete(rev)
+      refute(@revisions.any? {|r| r == rev})
+    end
+
+    it "fails when trying to delete the only existing revision" do
+      assert_raises(HexaPDF::Error) { @revisions.delete(0) while @revisions.current }
+    end
+  end
+
+  describe "merge" do
+    it "does nothing when only one revision is specified" do
+      @revisions.merge(1..1)
+      assert_equal(2, @revisions.each.to_a.size)
+    end
+
+    it "merges the higher into the the lower revision" do
+      @revisions.merge
+      assert_equal(1, @revisions.each.to_a.size)
+      assert_equal([10, 200], @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_equal(20, @revisions.revision(0).object(2).value)
+      assert_equal(200, @revisions[1].object(2).value)
+    end
+  end
+end