hexapdf 0.1.0

data/test/hexapdf/test_filter.rb

@@ -0,0 +1,96 @@
+# -*- 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
+
+    it "converts an IO into a source via #source_from_io" do
+      assert_equal(@str, collector(@obj.source_from_io(@io)))
+
+      assert_equal(@str, collector(@obj.source_from_io(@io, pos: -10)))
+      assert_equal(@str[10..-1], collector(@obj.source_from_io(@io, pos: 10)))
+      assert_equal("", collector(@obj.source_from_io(@io, pos: 200)))
+
+      assert_equal("", collector(@obj.source_from_io(@io, length: 0)))
+      assert_equal(@str[0...100], collector(@obj.source_from_io(@io, length: 100)))
+      assert_equal(@str, collector(@obj.source_from_io(@io, length: -15)))
+      assert_equal(100, @obj.source_from_io(@io, length: 100).length)
+
+      assert_equal(@str, collector(@obj.source_from_io(@io, chunk_size: -15)))
+      assert_equal(@str, collector(@obj.source_from_io(@io, chunk_size: 0)))
+      assert_equal(@str, collector(@obj.source_from_io(@io, chunk_size: 100)))
+      assert_equal(@str, collector(@obj.source_from_io(@io, chunk_size: 200)))
+
+      assert_equal(@str[0...20], collector(@obj.source_from_io(@io, length: 20, chunk_size: 100)))
+      assert_equal(@str[20...40], collector(@obj.source_from_io(@io, pos: 20, length: 20, chunk_size: 100)))
+      assert_equal(@str[20...40], collector(@obj.source_from_io(@io, pos: 20, length: 20, chunk_size: 5)))
+    end
+
+    it "fails if not all requested bytes could be read" do
+      assert_raises(HexaPDF::FilterError) do
+        collector(@obj.source_from_io(@io, length: 200))
+      end
+    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
+
+    it "converts the file into a source fiber" do
+      assert_equal(@str, collector(@obj.source_from_file(@file.path)))
+      assert_equal(@file.size, @obj.source_from_file(@file.path).length)
+
+      assert_equal(@str[100..-1], collector(@obj.source_from_file(@file.path, pos: 100)))
+      assert_equal(@str[100..-1].length, @obj.source_from_file(@file.path, pos: 100).length)
+
+      assert_equal(@str[50...100], collector(@obj.source_from_file(@file.path, pos: 50, length: 50)))
+      assert_equal(50, @obj.source_from_file(@file.path, length: 50).length)
+    end
+
+    it "fails if more bytes are requested than stored in the file" do
+      assert_raises(HexaPDF::FilterError) do
+        collector(@obj.source_from_file(@file.path, length: 200))
+      end
+    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_font_utils.rb

@@ -0,0 +1,47 @@
+# -*- encoding: utf-8 -*-
+
+require 'test_helper'
+require 'hexapdf/font_utils'
+require 'hexapdf/document'
+
+describe HexaPDF::FontUtils do
+  before do
+    @doc = HexaPDF::Document.new
+    @doc.config['font_loader'] = []
+  end
+
+  describe "load" do
+    before do
+      @doc.config['font_loader'] << lambda do |doc, name, **options|
+        assert_equal(@doc, doc)
+        if name == :TestFont
+          x = Object.new
+          x.define_singleton_method(:name) do
+            options[:variant] == :bold ? :BoldFont : :NormalFont
+          end
+          x
+        else
+          nil
+        end
+      end
+    end
+
+    it "loads the specified font" do
+      assert_equal(:NormalFont, @doc.fonts.load(:TestFont).name)
+      assert_equal(:BoldFont, @doc.fonts.load(:TestFont, variant: :bold).name)
+    end
+
+    it "caches loaded fonts" do
+      assert_same(@doc.fonts.load(:TestFont), @doc.fonts.load(:TestFont))
+    end
+
+    it "fails if the requested font is not found"  do
+      assert_raises(HexaPDF::Error) { @doc.fonts.load("Unknown") }
+    end
+
+    it "raises an error if a font loader cannot be correctly retrieved" do
+      @doc.config['font_loader'][0] = 'UnknownFontLoader'
+      assert_raises(HexaPDF::Error) { @doc.fonts.load(:Other) }
+    end
+  end
+end

data/test/hexapdf/test_importer.rb

@@ -0,0 +1,78 @@
+# -*- encoding: utf-8 -*-
+
+require 'test_helper'
+require 'hexapdf/importer'
+require 'hexapdf/document'
+
+describe HexaPDF::Importer do
+  before do
+    @source = HexaPDF::Document.new
+    obj = @source.add("test")
+    @obj = @source.add(hash: {key: "value"}, array: ["one", "two"],
+                       ref: HexaPDF::Reference.new(obj.oid, obj.gen),
+                       others: [:symbol, 5, 5.5, nil, true, false])
+    @source.pages.add_page
+    @source.pages[: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 "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 "does not import objects of type Catalog or Pages" do
+      @obj[:catalog] = @source.catalog
+      @obj[:pages] = @source.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.page(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,177 @@
+# -*- encoding: utf-8 -*-
+
+require 'test_helper'
+require 'hexapdf/object'
+require 'hexapdf/reference'
+
+describe HexaPDF::Object do
+  describe "class.deep_copy" do
+    it "handles not-duplicatable classes" do
+      assert_equal(5, HexaPDF::Object.deep_copy(5))
+      assert_equal(5.5, HexaPDF::Object.deep_copy(5.5))
+      assert_equal(nil, HexaPDF::Object.deep_copy(nil))
+      assert_equal(true, HexaPDF::Object.deep_copy(true))
+      assert_equal(false, HexaPDF::Object.deep_copy(false))
+      assert_equal(:Name, HexaPDF::Object.deep_copy(:Name))
+    end
+
+    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.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
+
+  describe "null?" do
+    it "works for nil values" do
+      assert(HexaPDF::Object.new(nil).null?)
+    end
+  end
+
+  describe "validate" do
+    it "invokes perform_validation correctly via #validate" do
+      obj = HexaPDF::Object.new(5)
+      invoked = {}
+      obj.define_singleton_method(:perform_validation) do |&block|
+        invoked[:method] = true
+        block.call("error", true)
+      end
+      assert(obj.validate {|*a| invoked[:block] = a})
+      assert_equal([:method, :block], invoked.keys)
+      assert_equal(["error", true], invoked[:block])
+
+      refute(obj.validate(auto_correct: false))
+    end
+
+    it "stops validating on an uncorrectable problem" do
+      obj = HexaPDF::Object.new(5)
+      invoked = {}
+      obj.define_singleton_method(:perform_validation) do |&block|
+        invoked[:before] = true
+        block.call("error", false)
+        invoked[:after] = true
+      end
+      refute(obj.validate {|*a| invoked[:block] = a})
+      refute(invoked.key?(:after))
+    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" 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))
+  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 "can be sorted together with Reference objects" 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)
+  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
+  end
+
+  it "validates that the object is indirect if it must be indirect" do
+    doc = Object.new
+    def doc.add(obj) obj.oid = 1 end
+    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
+end