hexapdf 0.17.1 → 0.17.2

data/test/hexapdf/test_filter.rb

@@ -0,0 +1,100 @@
+# -*- encoding: utf-8 -*-
+
+require 'test_helper'
+require 'hexapdf/filter'
+require 'stringio'
+require 'tempfile'
+
+describe HexaPDF::Filter do
+  before do
+    @obj = HexaPDF::Filter
+    @str = ''
+    40.times { @str << [rand(2**32)].pack('N') }
+  end
+
+  describe "source_from_string" do
+    it "doesn't modify the given string" do
+      str = @str.dup
+      @obj.source_from_string(@str).resume.slice!(0, 10)
+      assert_equal(str, @str)
+    end
+
+    it "returns the whole string" do
+      assert_equal(@str, collector(@obj.source_from_string(@str)))
+    end
+  end
+
+  describe "source_from_io" do
+    before do
+      @io = StringIO.new(@str.dup)
+    end
+
+    def from_io(**opts)
+      collector(@obj.source_from_io(@io, **opts))
+    end
+
+    it "converts an IO into a source via #source_from_io" do
+      assert_equal(@str, from_io)
+
+      assert_equal(@str, from_io(pos: -10))
+      assert_equal(@str[10..-1], from_io(pos: 10))
+      assert_equal("", from_io(pos: 200))
+
+      assert_equal("", from_io(length: 0))
+      assert_equal(@str[0...100], from_io(length: 100))
+      assert_equal(@str, from_io(length: -15))
+      assert_equal(100, @obj.source_from_io(@io, length: 100).length)
+
+      assert_equal(@str, from_io(chunk_size: -15))
+      assert_equal(@str, from_io(chunk_size: 0))
+      assert_equal(@str, from_io(chunk_size: 100))
+      assert_equal(@str, from_io(chunk_size: 200))
+
+      assert_equal(@str[0...20], from_io(length: 20, chunk_size: 100))
+      assert_equal(@str[20...40], from_io(pos: 20, length: 20, chunk_size: 100))
+      assert_equal(@str[20...40], from_io(pos: 20, length: 20, chunk_size: 5))
+    end
+
+    it "fails if not all requested bytes could be read" do
+      assert_raises(HexaPDF::FilterError) { from_io(length: 200) }
+    end
+  end
+
+  describe "source_from_file" do
+    before do
+      @file = Tempfile.new('hexapdf-filter')
+      @file.write(@str)
+      @file.close
+    end
+
+    after do
+      @file.unlink
+    end
+
+    def from_file(**opts)
+      @obj.source_from_file(@file.path, **opts)
+    end
+
+    it "converts the file into a source fiber" do
+      assert_equal(@str, collector(from_file))
+      assert_equal(@file.size, from_file.length)
+
+      assert_equal(@str[100..-1], collector(from_file(pos: 100)))
+      assert_equal(@str[100..-1].length, from_file(pos: 100).length)
+
+      assert_equal(@str[50..99], collector(from_file(pos: 50, length: 50)))
+      assert_equal(50, from_file(length: 50).length)
+    end
+
+    it "fails if more bytes are requested than stored in the file" do
+      assert_raises(HexaPDF::FilterError) { collector(from_file(length: 200)) }
+    end
+  end
+
+  it "collects the binary string from a source via #string_from_source" do
+    source = @obj.source_from_io(StringIO.new(@str), chunk_size: 50)
+    result = @obj.string_from_source(source)
+    assert_equal(@str, result)
+    assert_equal(Encoding::BINARY, result.encoding)
+  end
+end

data/test/hexapdf/test_importer.rb

@@ -0,0 +1,106 @@
+# -*- encoding: utf-8 -*-
+
+require 'test_helper'
+require 'hexapdf/importer'
+require 'hexapdf/document'
+
+describe HexaPDF::Importer::NullableWeakRef do
+  it "returns nil instead of an error when the referred-to object is GCed" do
+    refs = []
+    obj = nil
+    100.times do
+      refs << HexaPDF::Importer::NullableWeakRef.new(Object.new)
+      ObjectSpace.garbage_collect
+      ObjectSpace.garbage_collect
+      break if (obj = refs.find {|ref| !ref.weakref_alive? })
+    end
+    assert_equal("", obj.to_s)
+  end
+end
+
+describe HexaPDF::Importer do
+  before do
+    @source = HexaPDF::Document.new
+    obj = @source.add("test")
+    @hash = @source.wrap({key: "value"})
+    @obj = @source.add({hash: @hash, array: ["one", "two"],
+                        ref: HexaPDF::Reference.new(obj.oid, obj.gen),
+                        others: [:symbol, 5, 5.5, nil, true, false]})
+    @source.pages.add
+    @source.pages.root[:Rotate] = 90
+    @dest = HexaPDF::Document.new
+    @importer = HexaPDF::Importer.for(source: @source, destination: @dest)
+  end
+
+  describe "::for" do
+    it "caches the importer" do
+      assert_same(@importer, HexaPDF::Importer.for(source: @source, destination: @dest))
+    end
+  end
+
+  describe "import" do
+    it "updates the associated document" do
+      obj = @importer.import(@obj)
+      assert_same(obj.document, @dest)
+      obj = @importer.import(@hash)
+      assert_same(obj.document, @dest)
+    end
+
+    it "imports an object only once" do
+      obj = @importer.import(@obj)
+      assert_same(obj, @importer.import(@obj))
+      assert_equal(2, @dest.each.to_a.size)
+    end
+
+    it "re-imports an object that was imported but then deleted" do
+      obj = @importer.import(@obj)
+      @dest.delete(obj)
+      refute_same(obj, @importer.import(@obj))
+    end
+
+    it "can import a direct object" do
+      obj = @importer.import(key: @obj)
+      assert(@dest.object?(obj[:key]))
+    end
+
+    it "copies the data of the imported objects" do
+      data = {key: @obj, str: "str"}
+      obj = @importer.import(data)
+      obj[:str].upcase!
+      obj[:key][:hash][:key].upcase!
+      obj[:key][:hash][:data] = :value
+      obj[:key][:array].unshift
+      obj[:key][:array][0].upcase!
+
+      assert_equal("str", data[:str])
+      assert_equal("value", @obj[:hash][:key])
+      assert_equal(["one", "two"], @obj[:array])
+    end
+
+    it "duplicates the stream if it is a string" do
+      src_obj = @source.add({}, stream: 'data')
+      dst_obj = @importer.import(src_obj)
+      refute_same(dst_obj.data.stream, src_obj.data.stream)
+    end
+
+    it "does not import objects of type Catalog or Pages" do
+      @obj[:catalog] = @source.catalog
+      @obj[:pages] = @source.catalog.pages
+      obj = @importer.import(@obj)
+
+      assert_nil(obj[:catalog])
+      assert_nil(obj[:pages])
+    end
+
+    it "imports Page objects correctly by copying the inherited values" do
+      page = @importer.import(@source.pages[0])
+      assert_equal(90, page[:Rotate])
+    end
+
+    it "raise an error if the given object doesn't belong to the source document" do
+      other_doc = HexaPDF::Document.new
+      other_obj = other_doc.add("test")
+      assert_raises(HexaPDF::Error) { @importer.import(other_obj) }
+    end
+  end
+end

data/test/hexapdf/test_object.rb

@@ -0,0 +1,258 @@
+# -*- encoding: utf-8 -*-
+
+require 'test_helper'
+require 'hexapdf/object'
+require 'hexapdf/reference'
+require 'hexapdf/document'
+
+describe HexaPDF::Object do
+  describe "class.deep_copy" do
+    it "handles general, duplicatable classes" do
+      x = "test"
+      assert_equal("test", HexaPDF::Object.deep_copy(x))
+      refute_same(x, HexaPDF::Object.deep_copy(x))
+    end
+
+    it "handles arrays" do
+      x = [5, 6, [1, 2, 3]]
+      y = HexaPDF::Object.deep_copy(x)
+      x[2][0] = 4
+      assert_equal([5, 6, [1, 2, 3]], y)
+    end
+
+    it "handles hashes" do
+      x = {a: 5, b: 6, c: {a: 1, b: 2}}
+      y = HexaPDF::Object.deep_copy(x)
+      x[:c][:a] = 4
+      assert_equal({a: 5, b: 6, c: {a: 1, b: 2}}, y)
+    end
+
+    it "handles PDF references" do
+      x = HexaPDF::Reference.new(1, 2)
+      assert_same(x, HexaPDF::Object.deep_copy(x))
+    end
+
+    it "handles PDF objects" do
+      x = HexaPDF::Object.new("test")
+      assert_equal("test", HexaPDF::Object.deep_copy(x))
+
+      x.must_be_indirect = true
+      assert_same(x, HexaPDF::Object.deep_copy(x))
+
+      x.must_be_indirect = false
+      x.oid = 1
+      assert_same(x, HexaPDF::Object.deep_copy(x))
+    end
+  end
+
+  describe "initialize" do
+    it "uses a simple value as is" do
+      obj = HexaPDF::Object.new(5)
+      assert_equal(5, obj.value)
+    end
+
+    it "reuses the data object of a HexaPDF::Object" do
+      obj = HexaPDF::Object.new(5)
+      assert_same(obj.data, HexaPDF::Object.new(obj).data)
+    end
+
+    it "uses a provided PDFData structure" do
+      obj = HexaPDF::PDFData.new(5)
+      assert_equal(obj, HexaPDF::Object.new(obj).data)
+    end
+  end
+
+  describe "getters and setters" do
+    before do
+      @obj = HexaPDF::Object.new(5)
+    end
+
+    it "can get/set oid" do
+      @obj.oid = 7
+      assert_equal(7, @obj.oid)
+    end
+
+    it "can get/set gen" do
+      @obj.gen = 7
+      assert_equal(7, @obj.gen)
+    end
+
+    it "can get/set the value" do
+      @obj.value = :test
+      assert_equal(:test, @obj.value)
+    end
+  end
+
+  it "returns the document or raises an error if none is set" do
+    assert_equal(:document, HexaPDF::Object.new(nil, document: :document).document)
+    assert_raises(HexaPDF::Error) { HexaPDF::Object.new(nil).document }
+  end
+
+  describe "null?" do
+    it "works for nil values" do
+      assert(HexaPDF::Object.new(nil).null?)
+    end
+  end
+
+  describe "validate" do
+    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 << a })
+      assert_equal([["error", true, @obj]], invoked)
+    end
+
+    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 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
+      end
+      refute(@obj.validate(auto_correct: false))
+      assert_equal([:before], invoked)
+    end
+  end
+
+  it "can represent itself during inspection" do
+    obj = HexaPDF::Object.new(5, oid: 5)
+    assert_match(/\[5, 0\].*value=5/, obj.inspect)
+  end
+
+  it "can be compared to another object or reference" do
+    obj = HexaPDF::Object.new(5, oid: 5)
+
+    assert_equal(obj, HexaPDF::Object.new(obj))
+    refute_equal(obj, HexaPDF::Object.new(5, oid: 5))
+    refute_equal(obj, HexaPDF::Object.new(6, oid: 5))
+    refute_equal(obj, HexaPDF::Object.new(5, oid: 1))
+    refute_equal(obj, HexaPDF::Object.new(5, oid: 5, gen: 1))
+
+    assert_equal(obj, HexaPDF::Reference.new(5, 0))
+  end
+
+  it "works correctly as hash key, is interchangable in this regard with Reference objects" do
+    hash = {}
+    hash[HexaPDF::Reference.new(1)] = :one
+    hash[HexaPDF::Object.new(:val, oid: 2)] = :two
+    assert_equal(:one, hash[HexaPDF::Reference.new(1, 0)])
+    assert_equal(:one, hash[HexaPDF::Object.new(:data, oid: 1)])
+    assert_equal(:two, hash[HexaPDF::Reference.new(2)])
+    assert_equal(:two, hash[HexaPDF::Object.new(:data, oid: 2)])
+  end
+
+  it "is sortable w.r.t to other objects implementing #oid and #gen, like Reference" do
+    a = HexaPDF::Object.new(:data, oid: 1)
+    b = HexaPDF::Object.new(:data, oid: 1, gen: 1)
+    c = HexaPDF::Reference.new(5, 7)
+    assert_equal([a, b, c], [b, c, a].sort)
+    assert_nil(HexaPDF::Object.new(:data, oid: 1) <=> 5)
+  end
+
+  describe "deep_copy" do
+    it "creates an independent object" do
+      obj = HexaPDF::Object.new({a: "mystring", b: HexaPDF::Reference.new(1, 0), c: 5})
+      copy = obj.deep_copy
+      refute_equal(copy, obj)
+      assert_equal(copy.value, obj.value)
+      refute_same(copy.value[:a], obj.value[:a])
+    end
+
+    it "duplicates the stream if it is a string" do
+      obj = HexaPDF::Object.new(nil, stream: "data")
+      copy = obj.deep_copy
+      refute_same(copy.data.stream, obj.data.stream)
+    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
+      @doc.define_singleton_method(:add) {|obj| obj.oid = 1 }
+    end
+
+    it "validates that the object is indirect if it must be indirect" do
+      obj = HexaPDF::Object.new(6, document: @doc)
+
+      obj.validate
+      assert_equal(0, obj.oid)
+
+      obj.must_be_indirect = true
+      obj.validate
+      assert_equal(1, obj.oid)
+    end
+
+    it "validates collection values" do
+      x = HexaPDF::Object.new(:x, document: @doc)
+      x.must_be_indirect = true
+      y = HexaPDF::Object.new(:y, document: @doc)
+      y.must_be_indirect = true
+
+      obj = HexaPDF::Object.new([1, 2, 3, [4, x], {X: [y, 5]}])
+      obj.validate
+      assert_equal(1, x.oid)
+      assert_equal(1, y.oid)
+    end
+  end
+end