hexapdf 0.12.3 → 0.14.3

data/lib/hexapdf/version.rb

@@ -37,6 +37,6 @@
 module HexaPDF
 
   # The version of HexaPDF.
-  VERSION = '0.12.3'
+  VERSION = '0.14.3'
 
 end

data/test/hexapdf/common_tokenizer_tests.rb

@@ -122,7 +122,7 @@ module CommonTokenizerTests
   end
 
   it "next_token: should not fail when reading super long numbers" do
-    create_tokenizer("1" + "0" * 10_000)
+    create_tokenizer("1" << "0" * 10_000)
     assert_equal(10**10_000, @tokenizer.next_token)
   end
 
@@ -162,7 +162,7 @@ module CommonTokenizerTests
   end
 
   it "returns the correct position on operations" do
-    create_tokenizer("hallo du" + " " * 50000 + "hallo du")
+    create_tokenizer("hallo du" << " " * 50000 << "hallo du")
     @tokenizer.next_token
     assert_equal(5, @tokenizer.pos)
 

data/test/hexapdf/content/graphic_object/test_arc.rb

@@ -68,14 +68,14 @@ describe HexaPDF::Content::GraphicObject::Arc do
       arc.max_curves = 4
       curves = arc.curves
       assert_equal(2, curves.size)
-      assert_curve_values([0, 1, p1: [1, 0.548584], p2: [0.548584, 1]], curves[0])
-      assert_curve_values([-1, 0, p1: [-0.548584, 1], p2: [-1, 0.548584]], curves[1])
+      assert_curve_values([0, 1, {p1: [1, 0.548584], p2: [0.548584, 1]}], curves[0])
+      assert_curve_values([-1, 0, {p1: [-0.548584, 1], p2: [-1, 0.548584]}], curves[1])
 
       arc.configure(clockwise: true)
       curves = arc.curves
       assert_equal(2, curves.size)
-      assert_curve_values([0, -1, p1: [1, -0.548584], p2: [0.548584, -1]], curves[0])
-      assert_curve_values([-1, 0, p1: [-0.548584, -1], p2: [-1, -0.548584]], curves[1])
+      assert_curve_values([0, -1, {p1: [1, -0.548584], p2: [0.548584, -1]}], curves[0])
+      assert_curve_values([-1, 0, {p1: [-0.548584, -1], p2: [-1, -0.548584]}], curves[1])
     end
   end
 

data/test/hexapdf/content/test_canvas.rb

@@ -531,7 +531,7 @@ describe HexaPDF::Content::Canvas do
     end
 
     it "invokes the polygon method when radius != 0" do
-      args = [0, 0, 10, 0, 10, 10, 0, 10, radius: 5]
+      args = [0, 0, 10, 0, 10, 10, 0, 10, {radius: 5}]
       assert_method_invoked(@canvas, :polygon, args) do
         @canvas.rectangle(0, 0, 10, 10, radius: 5)
       end
@@ -631,7 +631,7 @@ describe HexaPDF::Content::Canvas do
 
   describe "circle" do
     it "uses arc for the hard work" do
-      assert_method_invoked(@canvas, :arc, [5, 6, a: 7]) do
+      assert_method_invoked(@canvas, :arc, [5, 6, {a: 7}]) do
         @canvas.graphics_object = :path
         @canvas.circle(5, 6, 7)
       end
@@ -651,7 +651,7 @@ describe HexaPDF::Content::Canvas do
 
   describe "ellipse" do
     it "uses arc for the hard work" do
-      assert_method_invoked(@canvas, :ellipse, [5, 6, a: 7, b: 5, inclination: 10]) do
+      assert_method_invoked(@canvas, :ellipse, [5, 6, {a: 7, b: 5, inclination: 10}]) do
         @canvas.ellipse(5, 6, a: 7, b: 5, inclination: 10)
       end
     end

data/test/hexapdf/content/test_color_space.rb

@@ -155,7 +155,7 @@ describe HexaPDF::Content::ColorSpace::DeviceGray do
 
   before do
     @color_space = HexaPDF::Content::ColorSpace::DeviceGray.new
-    @color_space_family = @color_space_definition =  :DeviceGray
+    @color_space_family = @color_space_definition = :DeviceGray
     @color = @color_space.default_color
     @other_color = @color_space.color(128)
     @colors = [128]

data/test/hexapdf/encryption/test_aes.rb

@@ -101,13 +101,13 @@ describe HexaPDF::Encryption::AES do
       result = TestHelper.collector(@algorithm_class.decryption_fiber('some' * 4, f))
       assert_equal('a' * 16, result)
 
-      f = Fiber.new { 'a' * 31 + "\x00" }
+      f = Fiber.new { 'a' * 31 << "\x00" }
       result = TestHelper.collector(@algorithm_class.decryption_fiber('some' * 4, f))
-      assert_equal('a' * 15 + "\x00", result)
+      assert_equal('a' * 15 << "\x00", result)
 
-      f = Fiber.new { 'a' * 29 + "\x00\x01\x03" }
+      f = Fiber.new { 'a' * 29 << "\x00\x01\x03" }
       result = TestHelper.collector(@algorithm_class.decryption_fiber('some' * 4, f))
-      assert_equal('a' * 13 + "\x00\x01\x03", result)
+      assert_equal('a' * 13 << "\x00\x01\x03", result)
     end
 
     it "fails on decryption if not enough bytes are provided" do

data/test/hexapdf/encryption/test_standard_security_handler.rb

@@ -53,24 +53,24 @@ describe HexaPDF::Encryption::StandardEncryptionDictionary do
 end
 
 describe HexaPDF::Encryption::StandardSecurityHandler do
-  TEST_FILES = Dir[File.join(TEST_DATA_DIR, 'standard-security-handler', '*.pdf')].sort
-  USER_PASSWORD = 'uhexapdf'
-  OWNER_PASSWORD = 'ohexapdf'
+  test_files = Dir[File.join(TEST_DATA_DIR, 'standard-security-handler', '*.pdf')].sort
+  user_password = 'uhexapdf'
+  owner_password = 'ohexapdf'
 
-  MINIMAL_DOC = HexaPDF::Document.new(io: StringIO.new(MINIMAL_PDF))
+  minimal_doc = HexaPDF::Document.new(io: StringIO.new(MINIMAL_PDF))
 
-  TEST_FILES.each do |file|
+  test_files.each do |file|
     basename = File.basename(file)
     it "can decrypt, encrypt and decrypt the encrypted file #{basename} with the user password" do
       begin
         doc = HexaPDF::Document.new(io: StringIO.new(File.binread(file)),
-                                    decryption_opts: {password: USER_PASSWORD})
-        assert_equal(MINIMAL_DOC.trailer[:Info][:ModDate], doc.trailer[:Info][:ModDate])
+                                    decryption_opts: {password: user_password})
+        assert_equal(minimal_doc.trailer[:Info][:ModDate], doc.trailer[:Info][:ModDate])
 
         out = StringIO.new(''.b)
         HexaPDF::Writer.new(doc, out).write
-        doc = HexaPDF::Document.new(io: out, decryption_opts: {password: USER_PASSWORD})
-        assert_equal(MINIMAL_DOC.trailer[:Info][:ModDate], doc.trailer[:Info][:ModDate])
+        doc = HexaPDF::Document.new(io: out, decryption_opts: {password: user_password})
+        assert_equal(minimal_doc.trailer[:Info][:ModDate], doc.trailer[:Info][:ModDate])
       rescue HexaPDF::EncryptionError => e
         flunk("Error processing #{basename}: #{e}")
       end
@@ -80,8 +80,8 @@ describe HexaPDF::Encryption::StandardSecurityHandler do
       it "can decrypt the encrypted file #{basename} with the owner password" do
         begin
           doc = HexaPDF::Document.new(io: StringIO.new(File.binread(file)),
-                                      decryption_opts: {password: OWNER_PASSWORD})
-          assert_equal(MINIMAL_DOC.trailer[:Info][:ModDate], doc.trailer[:Info][:ModDate])
+                                      decryption_opts: {password: owner_password})
+          assert_equal(minimal_doc.trailer[:Info][:ModDate], doc.trailer[:Info][:ModDate])
         rescue HexaPDF::EncryptionError => e
           flunk("Error processing #{basename}: #{e}")
         end

data/test/hexapdf/filter/test_ascii85_decode.rb

@@ -33,7 +33,7 @@ describe HexaPDF::Filter::ASCII85Decode do
     end
 
     it "ignores data after the EOD marker" do
-      assert_equal(@decoded, collector(@obj.decoder(feeder(@encoded.dup + "~>abcdefg"))))
+      assert_equal(@decoded, collector(@obj.decoder(feeder(@encoded << "~>abcdefg"))))
     end
 
     it "fails if the input contains invalid characters" do

data/test/hexapdf/filter/test_ascii_hex_decode.rb

@@ -24,7 +24,7 @@ describe HexaPDF::Filter::ASCIIHexDecode do
     end
 
     it "ignores data after the EOD marker" do
-      assert_equal(@decoded, collector(@obj.decoder(feeder(@encoded + '4e6f7gzz'))))
+      assert_equal(@decoded, collector(@obj.decoder(feeder(@encoded << '4e6f7gzz'))))
     end
 
     it "assumes the missing char is '0' if the input length is odd" do

data/test/hexapdf/font/true_type/table/test_post.rb

@@ -72,7 +72,7 @@ describe HexaPDF::Font::TrueType::Table::Post do
       assert_equal('.notdef', table[0])
 
       @font.config['font.true_type.unknown_format'] = :raise
-      assert_raises(HexaPDF::Error) { create_table(:Post) }
+      assert_raises(HexaPDF::Error) { create_table(:Post)[0] }
     end
   end
 end

data/test/hexapdf/font/true_type/test_subsetter.rb

@@ -27,6 +27,16 @@ describe HexaPDF::Font::TrueType::Subsetter do
     assert_equal(value, @subsetter.subset_glyph_id(5))
   end
 
+  it "doesn't use certain subset glyph IDs for performance reasons" do
+    1.upto(93) {|i| @subsetter.use_glyph(i) }
+    # glyph 0, 93 used glyph, 4 special glyphs
+    assert_equal(1 + 93 + 4, @subsetter.instance_variable_get(:@glyph_map).size)
+    1.upto(12) {|i| assert_equal(i, @subsetter.subset_glyph_id(i), "id=#{i}") }
+    13.upto(38) {|i| assert_equal(i + 1, @subsetter.subset_glyph_id(i), "id=#{i}") }
+    39.upto(88) {|i| assert_equal(i + 3, @subsetter.subset_glyph_id(i), "id=#{i}") }
+    89.upto(93) {|i| assert_equal(i + 4, @subsetter.subset_glyph_id(i), "id=#{i}") }
+  end
+
   it "creates the subset font file" do
     gid = @font[:cmap].preferred_table[0x41]
     @subsetter.use_glyph(gid)

data/test/hexapdf/font_loader/test_from_configuration.rb

@@ -8,13 +8,17 @@ describe HexaPDF::FontLoader::FromConfiguration do
   before do
     @doc = HexaPDF::Document.new
     font_file = File.join(TEST_DATA_DIR, "fonts", "Ubuntu-Title.ttf")
-    @doc.config['font.map'] = {'font' => {none: font_file}}
+    @font_obj = HexaPDF::Font::TrueType::Font.new(File.open(font_file, 'rb'))
+    @doc.config['font.map'] = {'font' => {none: font_file}, 'font1' => {none: @font_obj}}
     @klass = HexaPDF::FontLoader::FromConfiguration
   end
 
   it "loads the configured font" do
     wrapper = @klass.call(@doc, "font")
     assert_equal("Ubuntu-Title", wrapper.wrapped_font.font_name)
+    wrapper = @klass.call(@doc, "font1")
+    assert_equal("Ubuntu-Title", wrapper.wrapped_font.font_name)
+    assert_same(@font_obj, wrapper.wrapped_font)
   end
 
   it "passes the subset value to the wrapper" do
@@ -24,7 +28,7 @@ describe HexaPDF::FontLoader::FromConfiguration do
     refute(wrapper.subset?)
   end
 
-  it "fails if the font file cannot be read" do
+  it "fails if the provided font is invalid" do
     @doc.config['font.map']['font'][:none] << "unknown"
     assert_raises(HexaPDF::Error) { @klass.call(@doc, "font") }
   end
@@ -34,6 +38,6 @@ describe HexaPDF::FontLoader::FromConfiguration do
   end
 
   it "returns a hash with all configured fonts" do
-    assert_equal({'font' => [:none]}, @klass.available_fonts(@doc))
+    assert_equal({'font' => [:none], 'font1' => [:none]}, @klass.available_fonts(@doc))
   end
 end

data/test/hexapdf/font_loader/test_from_file.rb

@@ -16,6 +16,13 @@ describe HexaPDF::FontLoader::FromFile do
     assert_equal("Ubuntu-Title", wrapper.wrapped_font.font_name)
   end
 
+  it "loads the specified font object" do
+    font = HexaPDF::Font::TrueType::Font.new(File.open(@font_file, 'rb'))
+    wrapper = @klass.call(@doc, font)
+    assert_equal("Ubuntu-Title", wrapper.wrapped_font.font_name)
+    assert_same(font, wrapper.wrapped_font)
+  end
+
   it "passes the subset value to the wrapper" do
     wrapper = @klass.call(@doc, @font_file)
     assert(wrapper.subset?)

data/test/hexapdf/layout/test_text_layouter.rb

@@ -591,25 +591,33 @@ describe HexaPDF::Layout::TextLayouter do
 
     describe "horizontal alignment" do
       before do
-        @items = boxes(*[[20, 20]] * 4)
+        @items = boxes(*[[20, 20]] * 4) + [glue(10), penalty(-5000, boxes(0).first.item)]
       end
 
       it "aligns the contents to the left" do
         @style.align = :left
         result = @layouter.fit(@items, 100, 100)
         assert_equal(0, result.lines[0].x_offset)
+        assert_equal(80, result.lines[0].width)
+        result = @layouter.fit(@items, proc { 100 }, 100)
+        assert_equal(0, result.lines[0].x_offset)
+        assert_equal(80, result.lines[0].width)
       end
 
       it "aligns the contents to the center" do
         @style.align = :center
         result = @layouter.fit(@items, 100, 100)
         assert_equal(10, result.lines[0].x_offset)
+        result = @layouter.fit(@items, proc { 100 }, 100)
+        assert_equal(10, result.lines[0].x_offset)
       end
 
       it "aligns the contents to the right" do
         @style.align = :right
         result = @layouter.fit(@items, 100, 100)
         assert_equal(20, result.lines[0].x_offset)
+        result = @layouter.fit(@items, proc { 100 }, 100)
+        assert_equal(20, result.lines[0].x_offset)
       end
     end
 
@@ -674,10 +682,9 @@ describe HexaPDF::Layout::TextLayouter do
       pos = [0, 0]
       result.select! {|name, _| name == :set_text_matrix || name == :move_text_next_line }.
         map! do |name, ops|
-        if name == :set_text_matrix
-          pos = ops[-2, 2]
-        elsif name == :move_text_next_line
-          pos[1] -= leading
+        case name
+        when :set_text_matrix then pos = ops[-2, 2]
+        when :move_text_next_line then pos[1] -= leading
         end
         pos.dup
       end

data/test/hexapdf/test_configuration.rb

@@ -66,8 +66,8 @@ describe HexaPDF::Configuration do
       assert_equal(HexaPDF, @config.constantize('test', 1))
     end
 
-    def assert_constantize_error # :nodoc:
-      exp = assert_raises(HexaPDF::Error) { yield }
+    def assert_constantize_error(&block) # :nodoc:
+      exp = assert_raises(HexaPDF::Error, &block)
       assert_match(/Error getting constant for configuration option/, exp.message)
     end
 

data/test/hexapdf/test_dictionary.rb

@@ -14,7 +14,9 @@ describe HexaPDF::Dictionary do
   end
 
   def add(obj)
-    HexaPDF::Object.new(obj, oid: 1)
+    klass = HexaPDF::Object
+    klass = HexaPDF::Dictionary if obj.kind_of?(HexaPDF::Dictionary) || obj.kind_of?(Hash)
+    klass.new(obj, oid: 1)
   end
 
   def delete(_obj)
@@ -281,6 +283,11 @@ describe HexaPDF::Dictionary do
       @obj[:TestClass][:Nested][:Nested][:TestClass][:Inherited] = :symbol
       assert(@obj.validate)
     end
+
+    it "makes sure validation works in special case where the dictionary is modified" do
+      @dict[:Array] = 5
+      refute(@dict.validate {|_, _, object| object[:Boolean] })
+    end
   end
 
   describe "delete" do

data/test/hexapdf/test_dictionary_fields.rb

@@ -222,7 +222,7 @@ describe HexaPDF::DictionaryFields do
 
     it "allows conversion to a Rectangle from an Array" do
       doc = Minitest::Mock.new
-      doc.expect(:wrap, :data, [[0, 1, 2, 3], type: HexaPDF::Rectangle])
+      doc.expect(:wrap, :data, [[0, 1, 2, 3], {type: HexaPDF::Rectangle}])
       @field.convert([0, 1, 2, 3], doc)
       doc.verify
     end
@@ -230,9 +230,16 @@ describe HexaPDF::DictionaryFields do
     it "allows conversion to a Rectangle from a HexaPDF::PDFArray" do
       data = HexaPDF::PDFArray.new([0, 1, 2, 3])
       doc = Minitest::Mock.new
-      doc.expect(:wrap, :data, [data, type: HexaPDF::Rectangle])
+      doc.expect(:wrap, :data, [data, {type: HexaPDF::Rectangle}])
       @field.convert(data, doc)
       doc.verify
     end
+
+    it "converts to a null value if an (invalid) empty array is given" do
+      doc = Minitest::Mock.new
+      doc.expect(:wrap, :data, [nil])
+      @field.convert([], doc)
+      doc.verify
+    end
   end
 end

data/test/hexapdf/test_document.rb

@@ -441,21 +441,21 @@ describe HexaPDF::Document do
 
   describe "validate" do
     before do
-      @doc.trailer.validate # to create a valid document
+      @doc.validate # to create a valid document
     end
 
     it "validates indirect objects" do
-      obj = @doc.add({Type: :Catalog})
+      obj = @doc.add({Type: :Page, MediaBox: [1, 1, 1, 1], Parent: @doc.pages.root})
       refute(@doc.validate(auto_correct: false))
 
       called = false
-      assert(@doc.validate {|o| assert_same(obj, o); called = true })
+      assert(@doc.validate {|_, _, o| assert_same(obj, o); called = true })
       assert(called)
     end
 
     it "validates the trailer object" do
       @doc.trailer[:ID] = :Symbol
-      refute(@doc.validate {|obj| assert_same(@doc.trailer, obj) })
+      refute(@doc.validate {|_, _, obj| assert_same(@doc.trailer, obj) })
     end
 
     it "validates only loaded objects" do
@@ -609,16 +609,24 @@ describe HexaPDF::Document do
 
   describe "caching interface" do
     it "allows setting and retrieving values" do
-      assert_equal(:test, @doc.cache(:a, :b, :test))
-      assert_equal(:test, @doc.cache(:a, :b, :other))
-      assert_equal(:other, @doc.cache(:a, :c) { :other })
+      assert_equal(:test, @doc.cache(:a, :b, :test) { :notused })
+      assert_equal(:test, @doc.cache(:a, :b) { :other })
+      assert_equal(:test, @doc.cache(:a, :b))
+      assert_nil(@doc.cache(:a, :c, nil))
+      assert_nil(@doc.cache(:a, :c) { :other })
+      assert_nil(@doc.cache(:a, :c))
       assert(@doc.cached?(:a, :b))
       assert(@doc.cached?(:a, :c))
     end
 
+    it "allows updating a value" do
+      @doc.cache(:a, :b) { :test }
+      assert_equal(:new, @doc.cache(:a, :b, update: true) { :new })
+    end
+
     it "allows clearing cached values" do
-      @doc.cache(:a, :b, :c)
-      @doc.cache(:b, :c, :d)
+      @doc.cache(:a, :b) { :c }
+      @doc.cache(:b, :c) { :d }
       @doc.clear_cache(:a)
       refute(@doc.cached?(:a, :b))
       assert(@doc.cached?(:b, :c))
@@ -626,7 +634,7 @@ describe HexaPDF::Document do
       refute(@doc.cached?(:a, :c))
     end
 
-    it "fails if no cached value exists and neither a value nor a block is given" do
+    it "fails if no cached value exists and no block is given" do
       assert_raises(LocalJumpError) { @doc.cache(:a, :b) }
     end
   end

data/test/hexapdf/test_object.rb

@@ -3,18 +3,10 @@
 require 'test_helper'
 require 'hexapdf/object'
 require 'hexapdf/reference'
+require 'hexapdf/document'
 
 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_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))
@@ -103,30 +95,57 @@ describe HexaPDF::Object do
   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
+    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[:block] = a })
-      assert_equal([:method, :block], invoked.keys)
-      assert_equal(["error", true], invoked[:block])
+      assert(@obj.validate {|*a| invoked << a })
+      assert_equal([["error", true, @obj]], invoked)
+    end
 
-      refute(obj.validate(auto_correct: false))
+    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 validating on an uncorrectable problem" do
-      obj = HexaPDF::Object.new(5)
-      invoked = {}
-      obj.define_singleton_method(:perform_validation) do |&block|
-        invoked[:before] = true
+    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] = true
+        invoked << :after
       end
-      refute(obj.validate {|*a| invoked[:block] = a })
-      refute(invoked.key?(:after))
+      refute(@obj.validate(auto_correct: false))
+      assert_equal([:before], invoked)
     end
   end
 
@@ -181,6 +200,32 @@ describe HexaPDF::Object do
     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