hexapdf 0.15.8 → 0.17.1

data/test/hexapdf/test_filter.rb

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

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

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