hexapdf 0.17.1 → 0.17.2

data/test/hexapdf/test_pdf_array.rb

@@ -0,0 +1,169 @@
+# -*- encoding: utf-8 -*-
+
+require 'test_helper'
+require 'hexapdf/pdf_array'
+require 'hexapdf/reference'
+require 'hexapdf/dictionary'
+
+describe HexaPDF::PDFArray do
+  def deref(obj)
+    if obj.kind_of?(HexaPDF::Reference)
+      HexaPDF::Object.new('deref', oid: obj.oid, gen: obj.gen)
+    else
+      obj
+    end
+  end
+
+  def add(obj)
+    HexaPDF::Object.new(obj, oid: 1)
+  end
+
+  def delete(_obj)
+  end
+
+  def wrap(obj, type:)
+    type.new(obj, document: self)
+  end
+
+  before do
+    @array = HexaPDF::PDFArray.new([1, HexaPDF::Object.new(:data), HexaPDF::Reference.new(1, 0),
+                                    HexaPDF::Dictionary.new({a: 'b'})], document: self)
+  end
+
+  describe "after_data_change" do
+    it "uses an empty array if nil is provided" do
+      array = HexaPDF::PDFArray.new(nil)
+      assert_equal([], array.value)
+    end
+    it "fails if the value is not an array" do
+      assert_raises(ArgumentError) { HexaPDF::PDFArray.new(:Name) }
+    end
+  end
+
+  describe "[]" do
+    it "allows retrieving values by index" do
+      assert_equal(1, @array[0])
+    end
+
+    it "allows retrieving values by start/length" do
+      assert_equal([1, :data], @array[0, 2])
+    end
+
+    it "allows retrieving values by range" do
+      assert_equal([1, :data], @array[0..1])
+    end
+
+    it "fetches the value out of a HexaPDF::Object" do
+      assert_equal(:data, @array[1])
+    end
+
+    it "resolves references and stores the resolved object in place of the reference" do
+      assert_equal('deref', @array[2])
+      assert_kind_of(HexaPDF::Object, @array.value[2])
+    end
+  end
+
+  describe "[]=" do
+    it "directly stores the value if the stored value is no HexaPDF::Object" do
+      @array[0] = 2
+      assert_equal(2, @array.value[0])
+    end
+
+    it "stores the value in an existing HexaPDF::Object but only if it is not such an object" do
+      @array[1] = [4, 5]
+      assert_equal([4, 5], @array.value[1].value)
+
+      @array[1] = temp = HexaPDF::Object.new(:other)
+      assert_equal(temp, @array.value[1])
+    end
+
+    it "doesn't store the value inside the existing object for subclasses of HexaPDF::Object" do
+      @array[3] = [4, 5]
+      assert_equal([4, 5], @array.value[3])
+    end
+
+    it "doesn't store the value inside for HexaPDF::Reference objects" do
+      @array[1] = HexaPDF::Reference.new(5, 0)
+      assert_kind_of(HexaPDF::Reference, @array.value[1])
+    end
+  end
+
+  it "allows getting multiple values at once" do
+    assert_equal([1, :data, @array[3]], @array.values_at(0, 1, 3))
+  end
+
+  it "allows adding values to the end" do
+    @array << 5
+    assert_equal(5, @array[4])
+  end
+
+  it "allows inserting values like Array#insert" do
+    @array.insert(1, :a, :b)
+    assert_equal([1, :a, :b, :data], @array[0, 4])
+  end
+
+  it "allows deleting values at a certain index" do
+    @array.delete_at(2)
+    assert_equal([1, :data, @array[2]], @array[0, 5])
+  end
+
+  it "allows deleting an object" do
+    obj = @array.value[1]
+    assert_same(obj, @array.delete(obj))
+    ref = HexaPDF::Object.new(:test, oid: 1)
+    assert_equal(ref, @array.delete(ref))
+  end
+
+  describe "slice!" do
+    it "allows deleting a single element" do
+      @array.slice!(2)
+      assert_equal([1, :data, @array[2]], @array[0, 5])
+    end
+
+    it "allows deleting elements given by start/length" do
+      @array.slice!(1, 2)
+      assert_equal([1, @array[1]], @array[0, 5])
+    end
+
+    it "allows deleting elements given a range" do
+      @array.slice!(1..2)
+      assert_equal([1, @array[1]], @array[0, 5])
+    end
+  end
+
+  it "allows deleting elements that are selected using a block" do
+    @array.reject! {|item| item == :data }
+    assert_equal([1, "deref", @array[2]], @array[0, 5])
+  end
+
+  describe "index" do
+    it "allows getting the index of an element" do
+      assert_equal(2, @array.index("deref"))
+    end
+
+    it "allows getting the index of the first element for which a block returns true" do
+      assert_equal(2, @array.index {|item| item == "deref" })
+    end
+  end
+
+  it "returns the length of the array" do
+    assert_equal(4, @array.length)
+  end
+
+  it "allows checking for emptiness" do
+    refute(@array.empty?)
+    @array.slice!(0, 5)
+    assert(@array.empty?)
+  end
+
+  describe "each" do
+    it "iterates over all elements in the dictionary" do
+      data = [1, :data, "deref", @array[3]]
+      @array.each {|value| assert_equal(data.shift, value) }
+    end
+  end
+
+  it "can be converted to a simple array" do
+    assert_equal([1, :data, "deref", @array[3]], @array.to_ary)
+  end
+end

data/test/hexapdf/test_rectangle.rb

@@ -0,0 +1,73 @@
+# -*- encoding: utf-8 -*-
+
+require 'test_helper'
+require 'hexapdf/rectangle'
+require 'hexapdf/document'
+
+describe HexaPDF::Rectangle do
+  describe "after_data_change" do
+    it "fails if the rectangle doesn't contain four numbers" do
+      assert_raises(ArgumentError) { HexaPDF::Rectangle.new([1, 2, 3]) }
+      assert_raises(ArgumentError) { HexaPDF::Rectangle.new([1, 2, 3, :a]) }
+    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
+
+  it "allows setting all fields of the rectangle" do
+    rect = HexaPDF::Rectangle.new([2, 1, 0, 5])
+    rect.left = 5
+    rect.right = 1
+    rect.bottom = 2
+    rect.top = 3
+    assert_equal([5, 2, 1, 3], rect.value)
+
+    rect.width = 10
+    assert_equal(15, rect.right)
+    rect.height = 10
+    assert_equal(12, rect.top)
+  end
+
+  it "allows comparison to arrays" do
+    rect = HexaPDF::Rectangle.new([0, 1, 2, 5])
+    assert(rect == [0, 1, 2, 5])
+    rect.oid = 5
+    refute(rect == [0, 1, 2, 5])
+  end
+
+  describe "validation" do
+    it "ensures that it is a correct PDF rectangle" do
+      doc = HexaPDF::Document.new
+      rect = HexaPDF::Rectangle.new([0, 1, 2, 3], document: doc)
+      assert(rect.validate)
+
+      rect.value.shift
+      refute(rect.validate)
+
+      rect.value.unshift(:A)
+      refute(rect.validate)
+    end
+  end
+end

data/test/hexapdf/test_reference.rb

@@ -0,0 +1,50 @@
+# -*- encoding: utf-8 -*-
+
+require 'test_helper'
+require 'hexapdf/reference'
+require 'hexapdf/object'
+
+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 w.r.t to other objects implementing #oid and #gen" do
+    obj = Object.new
+    obj.define_singleton_method(:oid) { 1 }
+    obj.define_singleton_method(:gen) { 0 }
+    obj.define_singleton_method(:<=>) {|o| HexaPDF::Reference.new(oid, gen) <=> o }
+    assert_equal([obj, HexaPDF::Reference.new(1, 1), HexaPDF::Reference.new(5, 7)],
+                 [HexaPDF::Reference.new(5, 7), HexaPDF::Reference.new(1, 1), obj].sort)
+    assert_nil(HexaPDF::Reference.new(1, 0) <=> 5)
+  end
+
+  it "is comparable to objects that have an oid and gen" 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))
+    assert_equal(HexaPDF::Reference.new(5, 7), HexaPDF::Object.new(:data, oid: 5, gen: 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 the PDF serialization as string representation " do
+    assert_equal("5 7 R", HexaPDF::Reference.new(5, 7).to_s)
+  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,188 @@
+# -*- 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 "xref" do
+    it "returns the xref structure" do
+      assert_equal(@xref_section[2, 0], @rev.xref(HexaPDF::Reference.new(2, 0)))
+      assert_equal(@xref_section[2, 0], @rev.xref(2))
+    end
+
+    it "returns nil if no xref entry is found" do
+      assert_nil(@rev.xref(@ref))
+      assert_nil(@rev.xref(1))
+    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 using 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 "update" do
+    before do
+      @rev.add(@obj)
+    end
+
+    it "updates the object if it has the same data instance" do
+      x = HexaPDF::Object.new(@obj.data)
+      y = @rev.update(x)
+      assert_same(x, y)
+      refute_same(x, @obj)
+      assert_same(x, @rev.object(@ref))
+    end
+
+    it "doesn't update the object if it refers to a different data instance" do
+      x = HexaPDF::Object.new(:value, oid: 5)
+      assert_nil(@rev.update(x))
+      x.data.oid = 1
+      assert_nil(@rev.update(x))
+    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?)
+      assert_raises(HexaPDF::Error) { @obj.document }
+    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?)
+      assert_raises(HexaPDF::Error) { @obj.document }
+    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?)
+      assert_raises(HexaPDF::Error) { @obj.document }
+    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
+
+    it "iterates only over loaded objects" do
+      obj = @rev.object(2)
+      assert_equal([obj], @rev.each(only_loaded: true).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
+
+  it "can iterate over all modified objects" do
+    obj = @rev.object(2)
+    assert_equal([], @rev.each_modified_object.to_a)
+    obj.value = :Other
+    @rev.add(@obj)
+    assert_equal([obj, @obj], @rev.each_modified_object.to_a)
+  end
+end

data/test/hexapdf/test_revisions.rb

@@ -0,0 +1,196 @@
+# -*- 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
+      300
+      endobj
+
+      3 0 obj
+      << /Type /XRef /Size 4 /Index [2 1] /W [1 1 1] /Filter /ASCIIHexDecode /Length 6
+      >>stream
+      019E00
+      endstream
+      endobj
+
+      2 0 obj
+      200
+      endobj
+
+      xref
+      2 2
+      0000000301 00000 n 
+      0000000178 00000 n 
+      trailer
+      << /Size 4 /Prev 47 >>
+      startxref
+      321
+      %%EOF
+
+      2 0 obj
+      400
+      endobj
+
+      xref
+      2 1
+      0000000422 00000 n 
+      trailer
+      << /Size 4 /Prev 321 /XRefStm 178 >>
+      startxref
+      442
+      %%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: 4}, 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(3, @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, 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.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
+      1 0 obj
+      10
+      endobj
+
+      xref
+      0 2
+      0000000000 65535 f 
+      0000000009 00000 n 
+      trailer
+      << /Size 2 /Prev 148>>
+      startxref
+      28
+      %%EOF
+
+      2 0 obj
+      300
+      endobj
+
+      xref
+      2 1
+      0000000301 00000 n 
+      trailer
+      << /Size 3 /Prev 28 /XRefStm 148>>
+      startxref
+      148
+      %%EOF
+    EOF
+    doc = HexaPDF::Document.new(io: io)
+    assert_equal(2, doc.revisions.count)
+  end
+
+  it "uses the reconstructed revision if errors are found when loading from an IO" do
+    io = StringIO.new(<<~EOF)
+      %PDF-1.7
+      1 0 obj
+      10
+      endobj
+
+      xref
+      0 2
+      0000000000 65535 f 
+      0000000009 00000 n 
+      trailer
+      << /Size 5 >>
+      startxref
+      28
+      %%EOF
+
+      2 0 obj
+      300
+      endobj
+
+      xref
+      2 1
+      0000000301 00000 n 
+        trailer
+      << /Size 3 /Prev 100>>
+      startxref
+      139
+      %%EOF
+    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)
+  end
+end