hexapdf 0.12.0 → 0.14.0

data/lib/hexapdf/type/resources.rb

@@ -219,6 +219,7 @@ module HexaPDF
         super
         val = self[:ProcSet]
         if !val
+          yield("No procedure set specified", true)
           self[:ProcSet] = [:PDF, :Text, :ImageB, :ImageC, :ImageI]
         else
           val.reject! do |name|

data/lib/hexapdf/type/trailer.rb

@@ -97,7 +97,7 @@ module HexaPDF
       private
 
       # Validates the trailer.
-      def perform_validation
+      def perform_validation(&block)
         super
         unless value[:ID]
           msg = if value[:Encrypt]
@@ -111,8 +111,7 @@ module HexaPDF
 
         unless value[:Root]
           yield("A PDF document must have a Catalog dictionary", true)
-          value[:Root] = document.add({Type: :Catalog})
-          value[:Root].validate {|message, correctable| yield(message, correctable) }
+          catalog.validate(&block)
         end
 
         if value[:Encrypt] && (!document.security_handler ||

data/lib/hexapdf/utils/object_hash.rb

@@ -125,7 +125,6 @@ module HexaPDF
       def oids
         @oids.keys
       end
-      private :oids
 
     end
 

data/lib/hexapdf/utils/sorted_tree_node.rb

@@ -143,12 +143,12 @@ module HexaPDF
         stack.reverse_each.inject do |nested_node, node|
           if (!nested_node[container_name] || nested_node[container_name].empty?) &&
               (!nested_node[:Kids] || nested_node[:Kids].empty?)
-            node[:Kids].delete_at(node[:Kids].index {|n| document.deref(n) == nested_node })
+            node[:Kids].delete(nested_node)
             document.delete(nested_node)
           end
           if !node[:Kids].empty? && node[:Limits]
-            node[:Limits][0] = document.deref(node[:Kids][0])[:Limits][0]
-            node[:Limits][1] = document.deref(node[:Kids][-1])[:Limits][1]
+            node[:Limits][0] = node[:Kids][0][:Limits][0]
+            node[:Limits][1] = node[:Kids][-1][:Limits][1]
           end
           node
         end
@@ -167,11 +167,11 @@ module HexaPDF
           if node.key?(container_name)
             index = find_in_leaf_node(node[container_name], key)
             if node[container_name][index] == key
-              result = document.deref(node[container_name][index + 1])
+              result = node[container_name][index + 1]
             end
           elsif node.key?(:Kids)
             index = find_in_intermediate_node(node[:Kids], key)
-            node = document.deref(node[:Kids][index])
+            node = node[:Kids][index]
             break unless key >= node[:Limits][0] && key <= node[:Limits][1]
           else
             break
@@ -192,12 +192,12 @@ module HexaPDF
         container_name = leaf_node_container_name
         stack = [self]
         until stack.empty?
-          node = document.deref(stack.pop)
+          node = stack.pop
           if node.key?(container_name)
             data = node[container_name]
             index = 0
             while index < data.length
-              yield(data[index], document.deref(data[index + 1]))
+              yield(data[index], data[index + 1])
               index += 2
             end
           elsif node.key?(:Kids)
@@ -215,7 +215,7 @@ module HexaPDF
       def path_to_key(node, key, stack)
         return unless node.key?(:Kids)
         index = find_in_intermediate_node(node[:Kids], key)
-        stack << document.deref(node[:Kids][index])
+        stack << node[:Kids][index]
         path_to_key(stack.last, key, stack)
       end
 
@@ -226,7 +226,7 @@ module HexaPDF
         right = array.length - 1
         while left < right
           mid = (left + right) / 2
-          limits = document.deref(array[mid])[:Limits]
+          limits = array[mid][:Limits]
           if limits[1] < key
             left = mid + 1
           elsif limits[0] > key
@@ -295,7 +295,7 @@ module HexaPDF
           node[container_name] = leaf_node[container_name].slice!(split_point..-1)
           node[:Limits] = node[container_name].values_at(0, -2)
           leaf_node[:Limits][1] = leaf_node[container_name][-2]
-          index = 1 + parent[:Kids].index {|o| document.deref(o) == leaf_node }
+          index = 1 + parent[:Kids].index {|o| o == leaf_node }
           parent[:Kids].insert(index, node)
         end
       end
@@ -307,10 +307,10 @@ module HexaPDF
 
         # All kids entries must be indirect objects
         if key?(:Kids)
-          self[:Kids].each do |kid|
-            unless (kid.kind_of?(HexaPDF::Object) && kid.indirect?) ||
-                kid.kind_of?(HexaPDF::Reference)
-              yield("Child entries of sorted tree nodes must be indirect objects", false)
+          self[:Kids].each_with_index do |kid, index|
+            unless kid.kind_of?(HexaPDF::Object) && kid.indirect?
+              yield("Child entries of sorted tree nodes must be indirect objects", true)
+              value[:Kids][index] = document.add(kid)
             end
           end
         end
@@ -321,15 +321,18 @@ module HexaPDF
           container = self[container_name]
           if container.length.odd?
             yield("Sorted tree leaf node contains odd number of entries", false)
+            return
           end
           index = 0
           old = nil
           while index < container.length
-            key = document.unwrap(container[index])
+            key = container[index]
             if !key.kind_of?(key_type)
               yield("A key must be a #{key_type} object, not a #{key.class}", false)
+              return
             elsif old && old > key
               yield("Sorted tree leaf node entries are not correctly sorted", false)
+              return
             end
             old = key
             index += 2

data/lib/hexapdf/version.rb

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

data/test/hexapdf/common_tokenizer_tests.rb

@@ -121,6 +121,11 @@ module CommonTokenizerTests
     assert(token.kind_of?(HexaPDF::Tokenizer::Token))
   end
 
+  it "next_token: should not fail when reading super long numbers" do
+    create_tokenizer("1" << "0" * 10_000)
+    assert_equal(10**10_000, @tokenizer.next_token)
+  end
+
   it "next_object: works for all PDF object types, including array and dictionary" do
     create_tokenizer(<<-EOF.chomp.gsub(/^ {8}/, ''))
         true false null 123 34.5 (string) <4E6F76> /Name
@@ -157,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/encoding/test_base.rb

@@ -32,4 +32,14 @@ describe HexaPDF::Font::Encoding::Base do
       assert_nil(@base.unicode(66))
     end
   end
+
+  describe "code" do
+    it "returns the code for an existing glyph name" do
+      assert_equal(65, @base.code(:A))
+    end
+
+    it "returns nil if the glyph name is not referenced" do
+      assert_nil(@base.code(:Unknown))
+    end
+  end
 end

data/test/hexapdf/font/encoding/test_difference_encoding.rb

@@ -18,4 +18,12 @@ describe HexaPDF::Font::Encoding::DifferenceEncoding do
       assert_equal(:B, @enc.name(66))
     end
   end
+
+  describe "code" do
+    it "takes the encoding differences into account" do
+      assert_equal(65, @enc.code(:A))
+      @enc.code_to_name[65] = :Known
+      assert_equal(65, @enc.code(:Known))
+    end
+  end
 end

data/test/hexapdf/font/test_type1_wrapper.rb

@@ -13,11 +13,12 @@ describe HexaPDF::Font::Type1Wrapper do
   end
 
   it "can be used with an existing PDF object" do
-    font = @doc.add({Type: :Font, Subtype: :Type1, Encoding: :WinAnsiEncoding,
+    font = @doc.add({Type: :Font, Subtype: :Type1, Encoding: {Differences: [65, :B]},
                      BaseFont: :"Times-Roman"})
     wrapper = HexaPDF::Font::Type1Wrapper.new(@doc, FONT_TIMES, pdf_object: font)
-    assert_equal([:T, :e, :s, :t], wrapper.decode_utf8("Test").map(&:name))
-    assert_equal("a", wrapper.encode(wrapper.glyph(:a)))
+    assert_equal([:B, :E, :A, :S, :T], wrapper.decode_utf8("BEAST").map(&:name))
+    assert_equal("A", wrapper.encode(wrapper.glyph(:A)))
+    assert_equal("A", wrapper.encode(wrapper.glyph(:B)))
   end
 
   it "returns 1 for the scaling factor" do

data/test/hexapdf/layout/test_style.rb

@@ -537,7 +537,7 @@ describe HexaPDF::Layout::Style::LinkLayer do
     end
 
     it "does nothing if the context is not a page object" do
-      @canvas = HexaPDF::Document.new.add({Type: :XObject, Subtype: :Form}).canvas
+      @canvas = HexaPDF::Document.new.add({Type: :XObject, Subtype: :Form, BBox: [0, 0, 1, 1]}).canvas
       assert_nil(call_link(dest: true))
     end
 

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)

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,7 +230,7 @@ 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