hexapdf 0.15.8 → 0.17.1

data/test/hexapdf/test_pdf_array.rb

@@ -1,169 +0,0 @@
-# -*- 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

@@ -1,73 +0,0 @@
-# -*- 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

@@ -1,50 +0,0 @@
-# -*- 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

@@ -1,188 +0,0 @@
-# -*- 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

@@ -1,196 +0,0 @@
-# -*- 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