hexapdf 0.6.0 → 0.7.0

data/test/hexapdf/task/test_dereference.rb

@@ -21,8 +21,8 @@ describe HexaPDF::Task::Dereference do
 
     checker = lambda do |val, done = {}|
       case val
-      when Array then val.all? {|v| checker.call(v, done)}
-      when Hash then val.all? {|_, v| checker.call(v, done)}
+      when Array then val.all? {|v| checker.call(v, done) }
+      when Hash then val.all? {|_, v| checker.call(v, done) }
       when HexaPDF::Reference
         false
       when HexaPDF::Object

data/test/hexapdf/task/test_optimize.rb

@@ -6,7 +6,9 @@ require 'hexapdf/task/optimize'
 
 describe HexaPDF::Task::Optimize do
   class TestType < HexaPDF::Dictionary
+
     define_field :Optional, type: Symbol, default: :Optional
+
   end
 
   before do
@@ -21,20 +23,20 @@ describe HexaPDF::Task::Optimize do
   end
 
   def assert_objstms_generated
-    assert(@doc.revisions.all? {|rev| rev.any? {|obj| obj.type == :ObjStm}})
-    assert(@doc.revisions.all? {|rev| rev.any? {|obj| obj.type == :XRef}})
+    assert(@doc.revisions.all? {|rev| rev.any? {|obj| obj.type == :ObjStm } })
+    assert(@doc.revisions.all? {|rev| rev.any? {|obj| obj.type == :XRef } })
   end
 
   def assert_xrefstms_generated
-    assert(@doc.revisions.all? {|rev| rev.any? {|obj| obj.type == :XRef}})
+    assert(@doc.revisions.all? {|rev| rev.find_all {|obj| obj.type == :XRef }.size == 1 })
   end
 
   def assert_no_objstms
-    assert(@doc.each(current: false).all? {|obj| obj.type != :ObjStm})
+    assert(@doc.each(current: false).all? {|obj| obj.type != :ObjStm })
   end
 
   def assert_no_xrefstms
-    assert(@doc.each(current: false).all? {|obj| obj.type != :XRef})
+    assert(@doc.each(current: false).all? {|obj| obj.type != :XRef })
   end
 
   def assert_default_deleted
@@ -90,12 +92,13 @@ describe HexaPDF::Task::Optimize do
       assert_objstms_generated
       assert_default_deleted
       assert_nil(@doc.object(objstm).value)
-      assert(3, @doc.revisions.current.find_all {|obj| obj.type == :ObjStm}.size)
-      assert([xref], @doc.revisions.current.find_all {|obj| obj.type == :XRef})
+      assert(3, @doc.revisions.current.find_all {|obj| obj.type == :ObjStm }.size)
+      assert([xref], @doc.revisions.current.find_all {|obj| obj.type == :XRef })
     end
 
     it "deletes object and xref streams" do
       @doc.add(Type: :ObjStm)
+      @doc.add(Type: :XRef)
       @doc.task(:optimize, object_streams: :delete, xref_streams: :delete)
       assert_no_objstms
       assert_no_xrefstms
@@ -118,6 +121,12 @@ describe HexaPDF::Task::Optimize do
       assert_default_deleted
     end
 
+    it "reuses an xref stream in generatation mode" do
+      @doc.add(Type: :XRef)
+      @doc.task(:optimize, xref_streams: :generate)
+      assert_xrefstms_generated
+    end
+
     it "deletes xref streams" do
       @doc.add(Type: :XRef)
       @doc.task(:optimize, xref_streams: :delete)

data/test/hexapdf/test_configuration.rb

@@ -87,7 +87,7 @@ describe HexaPDF::Configuration do
     end
 
     it "returns the result of the given block when no constant is found" do
-      assert_equal(:test, @config.constantize('unk') {|name| assert_equal('unk', name); :test})
+      assert_equal(:test, @config.constantize('unk') {|name| assert_equal('unk', name); :test })
     end
   end
 end

data/test/hexapdf/test_data_dir.rb

@@ -19,13 +19,13 @@ describe 'HexaPDF.data_dir' do
   end
 
   it "returns the global data directory if the local one isn't found" do
-    File.stub(:directory?, lambda {|path| path == @local ? false : true}) do
+    File.stub(:directory?, lambda {|path| path != @local }) do
       assert_equal(@global, HexaPDF.data_dir)
     end
   end
 
   it "fails if no data directory is found" do
-    File.stub(:directory?, lambda {|_path| false}) do
+    File.stub(:directory?, lambda {|_path| false }) do
       assert_raises { HexaPDF.data_dir }
     end
   end

data/test/hexapdf/test_dictionary.rb

@@ -62,7 +62,7 @@ describe HexaPDF::Dictionary do
     it "can iterate over all fields" do
       @inherited_class = Class.new(@test_class)
       @inherited_class.define_field(:Inherited, type: [Array, Symbol])
-      assert_equal([:Boolean, :Array, :TestClass, :Inherited], @inherited_class.each_field.map {|k, _| k})
+      assert_equal([:Boolean, :Array, :TestClass, :Inherited], @inherited_class.each_field.map {|k, _| k })
     end
 
     it "allows field access without subclassing" do
@@ -149,7 +149,7 @@ describe HexaPDF::Dictionary do
       assert_equal(7, @dict.value[:NewValue])
     end
 
-    it "stores the value inside the current value HexaPDF::Object but only if the given one is not such an object" do
+    it "stores the value in an existing HexaPDF::Object but only if it is not such an object" do
       @dict[:Object] = [4, 5]
       assert_equal([4, 5], @dict.value[:Object].value)
 
@@ -256,7 +256,10 @@ describe HexaPDF::Dictionary do
     end
 
     it "validates direct PDF objects nested in hashes" do
-      @obj[:TestClass] = {Inherited: :symbol, Nested: {Nested: {TestClass: @test_class.new(nil, document: self)}}}
+      @obj[:TestClass] = {
+        Inherited: :symbol,
+        Nested: {Nested: {TestClass: @test_class.new(nil, document: self)}},
+      }
       refute(@obj.validate)
       @obj[:TestClass][:Nested][:Nested][:TestClass][:Inherited] = :symbol
       assert(@obj.validate)

data/test/hexapdf/test_dictionary_fields.rb

@@ -123,20 +123,21 @@ describe HexaPDF::DictionaryFields do
       refute(@field.convert?('test'.b))
       assert(@field.convert?(date))
 
-      [["D:1998", [1998, 01, 01, 00, 00, 00, "-00:00"]],
-       ["D:199812", [1998, 12, 01, 00, 00, 00, "-00:00"]],
-       ["D:19981223", [1998, 12, 23, 00, 00, 00, "-00:00"]],
-       ["D:1998122319", [1998, 12, 23, 19, 00, 00, "+00:00"]],
-       ["D:199812231952", [1998, 12, 23, 19, 52, 00, "+00:00"]],
-       ["D:19981223195210", [1998, 12, 23, 19, 52, 10, "+00:00"]],
-       ["D:19981223195210-08'00'", [1998, 12, 23, 19, 52, 10, "-08:00"]],
-       ["D:1998122319-08'00'", [1998, 12, 23, 19, 00, 00, "-08:00"]],
-       ["D:19981223-08'00'", [1998, 12, 23, 00, 00, 00, "-08:00"]],
-       ["D:199812-08'00'", [1998, 12, 01, 00, 00, 00, "-08:00"]],
-       ["D:1998-08'00'", [1998, 01, 01, 00, 00, 00, "-08:00"]],
-       ["D:19981223195210-08", [1998, 12, 23, 19, 52, 10, "-08:00"]], # non-standard bc missing '
-       ["D:19981223195210-08'00", [1998, 12, 23, 19, 52, 10, "-08:00"]], # non-standard bc missing '
-       ].each do |str, data|
+      [
+        ["D:1998", [1998, 01, 01, 00, 00, 00, "-00:00"]],
+        ["D:199812", [1998, 12, 01, 00, 00, 00, "-00:00"]],
+        ["D:19981223", [1998, 12, 23, 00, 00, 00, "-00:00"]],
+        ["D:1998122319", [1998, 12, 23, 19, 00, 00, "+00:00"]],
+        ["D:199812231952", [1998, 12, 23, 19, 52, 00, "+00:00"]],
+        ["D:19981223195210", [1998, 12, 23, 19, 52, 10, "+00:00"]],
+        ["D:19981223195210-08'00'", [1998, 12, 23, 19, 52, 10, "-08:00"]],
+        ["D:1998122319-08'00'", [1998, 12, 23, 19, 00, 00, "-08:00"]],
+        ["D:19981223-08'00'", [1998, 12, 23, 00, 00, 00, "-08:00"]],
+        ["D:199812-08'00'", [1998, 12, 01, 00, 00, 00, "-08:00"]],
+        ["D:1998-08'00'", [1998, 01, 01, 00, 00, 00, "-08:00"]],
+        ["D:19981223195210-08", [1998, 12, 23, 19, 52, 10, "-08:00"]], # non-standard, missing '
+        ["D:19981223195210-08'00", [1998, 12, 23, 19, 52, 10, "-08:00"]], # non-standard, missing '
+      ].each do |str, data|
         obj = @field.convert(str, self)
         assert_equal(Time.new(*data), obj, "date str used: #{str}")
       end

data/test/hexapdf/test_document.rb

@@ -7,46 +7,46 @@ require 'stringio'
 
 describe HexaPDF::Document do
   before do
-    @io = StringIO.new(<<EOF)
-%PDF-1.7
-1 0 obj
-10
-endobj
-
-2 0 obj
-20
-endobj
-
-3 0 obj
-30
-endobj
-
-xref
-0 4
-0000000000 65535 f 
-0000000009 00000 n 
-0000000028 00000 n 
-0000000047 00000 n 
-trailer
-<< /Size 4 >>
-startxref
-66
-%%EOF
-
-2 0 obj
-200
-endobj
-
-xref
-2 2
-0000000197 00000 n 
-0000000000 00001 f 
-trailer
-<< /Size 4 /Prev 66 >>
-startxref
-217
-%%EOF
-EOF
+    @io = StringIO.new(<<~EOF)
+      %PDF-1.7
+      1 0 obj
+      10
+      endobj
+
+      2 0 obj
+      20
+      endobj
+
+      3 0 obj
+      30
+      endobj
+
+      xref
+      0 4
+      0000000000 65535 f 
+      0000000009 00000 n 
+      0000000028 00000 n 
+      0000000047 00000 n 
+      trailer
+      << /Size 4 >>
+      startxref
+      66
+      %%EOF
+
+      2 0 obj
+      200
+      endobj
+
+      xref
+      2 2
+      0000000197 00000 n 
+      0000000000 00001 f 
+      trailer
+      << /Size 4 /Prev 66 >>
+      startxref
+      217
+      %%EOF
+    EOF
     @io_doc = HexaPDF::Document.new(io: @io)
     @doc = HexaPDF::Document.new
   end
@@ -195,7 +195,7 @@ EOF
       assert_raises(HexaPDF::Error) { @doc.add(obj) }
     end
 
-    it "fails if the object number of the object to be added is already associated with another object" do
+    it "fails if the object number is already associated with another object" do
       obj = @doc.add(5)
       assert_raises(HexaPDF::Error) { @doc.add(@doc.wrap(5, oid: obj.oid, gen: 1)) }
     end
@@ -395,7 +395,7 @@ EOF
 
     it "yields the revision as second argument if the block accepts exactly two arguments" do
       objs = [[10, 20, 30], [200, nil]]
-      data = @io_doc.revisions.map.with_index {|rev, i| objs[i].map {|o| [o, rev]}}.reverse.flatten
+      data = @io_doc.revisions.map.with_index {|rev, i| objs[i].map {|o| [o, rev] } }.reverse.flatten
       @io_doc.each(current: false) do |obj, rev|
         assert(data.shift == obj.value)
         assert_equal(data.shift, rev)
@@ -450,7 +450,6 @@ EOF
     end
   end
 
-
   describe "write" do
     it "writes the document to a file" do
       begin
@@ -498,14 +497,14 @@ EOF
       io = StringIO.new(''.b)
       @io_doc.write(io)
       doc = HexaPDF::Document.new(io: io)
-      assert_equal(0, doc.each.count {|o| o.type == :ObjStm})
+      assert_equal(0, doc.each.count {|o| o.type == :ObjStm })
     end
 
     it "allows optimizing the file by using object streams" do
       io = StringIO.new(''.b)
       @io_doc.write(io, optimize: true)
       doc = HexaPDF::Document.new(io: io)
-      assert_equal(2, doc.each.count {|o| o.type == :ObjStm})
+      assert_equal(2, doc.each.count {|o| o.type == :ObjStm })
     end
   end
 
@@ -547,7 +546,7 @@ EOF
         assert_equal(doc, @doc)
         block.call('inside')
       end
-      assert_equal(:done, @doc.task(:test) {|msg| assert_equal('inside', msg); :done})
+      assert_equal(:done, @doc.task(:test) {|msg| assert_equal('inside', msg); :done })
     end
 
     it "fails if the given task is not available" do
@@ -558,9 +557,9 @@ EOF
   describe "listener interface" do
     it "allows registering and dispatching messages" do
       args = []
-      callable = lambda {|*a| args << [:callable, a]}
+      callable = lambda {|*a| args << [:callable, a] }
       @doc.register_listener(:something, callable)
-      @doc.register_listener(:something) {|*a| args << [:block, a]}
+      @doc.register_listener(:something) {|*a| args << [:block, a] }
       @doc.dispatch_message(:something, :arg)
       assert_equal([[:callable, [:arg]], [:block, [:arg]]], args)
     end

data/test/hexapdf/test_filter.rb

@@ -29,32 +29,34 @@ describe HexaPDF::Filter 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, collector(@obj.source_from_io(@io)))
+      assert_equal(@str, from_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(@str, from_io(pos: -10))
+      assert_equal(@str[10..-1], from_io(pos: 10))
+      assert_equal("", from_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("", 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, 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, 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], 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)))
+      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) do
-        collector(@obj.source_from_io(@io, length: 200))
-      end
+      assert_raises(HexaPDF::FilterError) { from_io(length: 200) }
     end
   end
 
@@ -69,21 +71,23 @@ describe HexaPDF::Filter 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(@obj.source_from_file(@file.path)))
-      assert_equal(@file.size, @obj.source_from_file(@file.path).length)
+      assert_equal(@str, collector(from_file))
+      assert_equal(@file.size, from_file.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[100..-1], collector(from_file(pos: 100)))
+      assert_equal(@str[100..-1].length, from_file(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)
+      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) do
-        collector(@obj.source_from_file(@file.path, length: 200))
-      end
+      assert_raises(HexaPDF::FilterError) { collector(from_file(length: 200)) }
     end
   end
 

data/test/hexapdf/test_importer.rb

@@ -4,6 +4,14 @@ 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
+    obj = HexaPDF::Importer::NullableWeakRef.new(Object.new)
+    GC.start
+    assert_equal("", obj.to_s)
+  end
+end
+
 describe HexaPDF::Importer do
   before do
     @source = HexaPDF::Document.new
@@ -63,6 +71,12 @@ describe HexaPDF::Importer do
       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

data/test/hexapdf/test_object.rb

@@ -91,6 +91,11 @@ describe HexaPDF::Object do
     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?)
@@ -105,7 +110,7 @@ describe HexaPDF::Object do
         invoked[:method] = true
         block.call("error", true)
       end
-      assert(obj.validate {|*a| invoked[:block] = a})
+      assert(obj.validate {|*a| invoked[:block] = a })
       assert_equal([:method, :block], invoked.keys)
       assert_equal(["error", true], invoked[:block])
 
@@ -120,7 +125,7 @@ describe HexaPDF::Object do
         block.call("error", false)
         invoked[:after] = true
       end
-      refute(obj.validate {|*a| invoked[:block] = a})
+      refute(obj.validate {|*a| invoked[:block] = a })
       refute(invoked.key?(:after))
     end
   end
@@ -150,11 +155,12 @@ describe HexaPDF::Object do
     assert_equal(:two, hash[HexaPDF::Object.new(:data, oid: 2)])
   end
 
-  it "can be sorted together with Reference objects" do
+  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
@@ -165,12 +171,18 @@ describe HexaPDF::Object do
       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 "validation" do
     before do
       @doc = Object.new
-      @doc.define_singleton_method(:add) {|obj| obj.oid = 1}
+      @doc.define_singleton_method(:add) {|obj| obj.oid = 1 }
     end
 
     it "validates that the object is indirect if it must be indirect" do