hexapdf 1.4.0 → 1.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 82d0430964f9f4c6925af5bb076a2e641908c3a4cb6796acc64dbe1303bc3407
-  data.tar.gz: 689a86b637a86331ca203d7d7ac90a9fb3c50c275f07b21d8109013faa509f07
+  metadata.gz: de7c1790b3c958a91f071b5c20063eafea93fed12a034b89890242fec25c3026
+  data.tar.gz: 0e201dc452930a2a81461be5bf9cd27d2749b92815498c06b37a1e2635a20d7d
 SHA512:
-  metadata.gz: 4cfe8038379e5dc7f3bebeb38b44525676b934cb2b2355ac7575fa7a4466a6c4ec9ab9e0a80a184aebab32b2aa87e06dff735c10915abebe11541ada95d8129c
-  data.tar.gz: 62562b4bae557ad3dac03cb51913a8d1d6796d6cad9ce0626bc901cc15afeb301e42d061c345a1ebcb30e09a018dbe4b7c26fc4c567423c262f67607d04b95c9
+  metadata.gz: 1d1b13a5c28c83ca8ec4730cfc0af3016ceb14831c16587b000d8b69d0c7482d166bed21542f4929a8e4614fc732208c5670451a34339776b78a66dea8374949
+  data.tar.gz: 309e3aa2a80ec92b4fd35e72e9ab0c114fe4022467be9fb6fb5805085d6616ea8301ab30345a7322b009aeeffa5d6b052abfb8f0bafbaa9ca8b2223af3a6b223

data/CHANGELOG.md

@@ -1,3 +1,48 @@
+## 1.5.0 - 2025-12-08
+
+### Added
+
+* Support for basic authentication to
+  [HexaPDF::DigitalSignature::Signing::TimestampHandler]
+
+### Changed
+
+* Dictionary validation to delete field entries that have an invalid type
+* CLI command `hexapdf images` to create directories specified in the `--prefix`
+* CLI command `hexapdf images` to omit the dash in the file names if `--prefix`
+  points to a directory
+
+## Fixed
+
+* [HexaPDF::Type::Annotation#appearance] to work in case /AP contains a value of
+  an invalid type
+* [HexaPDF::DigitalSignature::CMSHandler] to throw an appropriate error when
+  encountering invalid signature contents
+
+
+## 1.4.1 - 2025-09-23
+
+### Added
+
+* [HexaPDF::Font::Encoding::Base#to_compact_array] for creating a compact array
+  representation of the encoding
+
+### Changed
+
+- CLI to handle missing file errors better
+
+### Fixed
+
+* Serialization of strings that need to be UTF-16 encoded when using encryption
+* [HexaPDF::Document#write_to_string] to pass on arguments to `#write`
+* [HexaPDF::Type::FontType1] validation to handle PDFs with an invalid value of
+  /SymbolEncoding for the /Encoding key
+* [HexaPDF::Type::FontType1] validation to handle PDFs with an invalid value of
+  /StandardEncoding for the /Encoding key
+* CLI command `hexapdf form` to ignore widgets that don't belong to any field
+* Validation of invalid sorted tree root nodes with odd number of direct entries
+
+
 ## 1.4.0 - 2025-08-03
 
 ### Added
@@ -24,8 +69,8 @@
   of a table cell
 * [HexaPDF::Layout::Style::Quad#set] to allow setting a subset of values using a
   hash
-* CLI command `hp form` to show the names of radio button widgets
-* CLI command `hp form` to show position and size of widgets in easier to
+* CLI command `hexapdf form` to show the names of radio button widgets
+* CLI command `hexapdf form` to show position and size of widgets in easier to
   understand form
 * Default signing handler to not set /DigestMethod entry on signature reference
   dictionary anymore

data/lib/hexapdf/cli/form.rb

@@ -290,7 +290,7 @@ module HexaPDF
           page.each_annotation do |annotation|
             next unless annotation[:Subtype] == :Widget
             field = annotation.form_field
-            next if field.concrete_field_type == :push_button
+            next if !field.concrete_field_type || field.concrete_field_type == :push_button
             if with_seen || !seen[field.full_field_name]
               yield(page, page_index, field, annotation)
               seen[field.full_field_name] = true

data/lib/hexapdf/cli/images.rb

@@ -35,6 +35,7 @@
 #++
 
 require 'set'
+require 'fileutils'
 require 'hexapdf/cli/command'
 
 module HexaPDF
@@ -132,7 +133,7 @@ module HexaPDF
         printf("%5s %5s %9s %6s %6s %5s %4s %3s %5s %5s %6s %5s %8s\n",
                "index", "page", "oid", "width", "height", "color", "comp", "bpc",
                "x-ppi", "y-ppi", "size", "type", "writable")
-        puts("-" * 77)
+        puts("-" * 84)
         each_image(doc) do |image, index, pindex, (x_ppi, y_ppi)|
           info = image.info
           size = human_readable_file_size(image[:Length] + image[:SMask]&.[](:Length).to_i)
@@ -145,20 +146,34 @@ module HexaPDF
 
       # Extracts the images with the given indices.
       def extract_images(doc)
+        FileUtils.mkdir_p(File.dirname("#{@prefix}filename"))
+        prefix = File.directory?(@prefix) ? @prefix : "@{prefix}-"
+
         done = Set.new
+        count = total = 0
         each_image(doc) do |image, index, _|
           next unless (@indices.include?(index) || @indices.include?(0)) && !done.include?(index)
+          total += 1
           info = image.info
           if info.writable
-            path = "#{@prefix}-#{index}.#{image.info.extension}"
+            count += 1
+            path = "#{@prefix}#{index}.#{image.info.extension}"
             maybe_raise_on_existing_file(path)
-            puts "Extracting #{path}..." if command_parser.verbosity_info?
+            if command_parser.verbosity_info?
+              puts "Extracting image #{index} (#{image.width}x#{image.height}, " \
+                   "#{info.color_space}, #{info.type}) to #{path}..."
+            end
             image.write(path)
             done << index
+            if info.color_space == :cmyk && info.type == :jpeg
+              $stderr.puts "Note (image #{path}): JPEG uses CMYK colorspace and may " \
+                           "need color post-processing"
+            end
           elsif command_parser.verbosity_warning?
             $stderr.puts "Warning (image #{index}): PDF image format not supported for writing"
           end
         end
+        puts "Created #{count} image files (out of #{total} selected)" if command_parser.verbosity_info?
       end
 
       # Iterates over all images.

data/lib/hexapdf/cli.rb

@@ -61,6 +61,9 @@ module HexaPDF
     # Runs the CLI application.
     def self.run(args = ARGV)
       Application.new.parse(args)
+    rescue Errno::ENOENT => e
+      path = e.message.scan(/(?<= - ).*?$/).first
+      $stderr.puts "Problem encountered: No such file - #{path}"
     rescue StandardError => e
       $stderr.puts "Problem encountered: #{e.message}"
       unless e.kind_of?(HexaPDF::Error)

data/lib/hexapdf/dictionary.rb

@@ -301,7 +301,13 @@ module HexaPDF
             yield(msg, true)
             self[name] = obj.intern
           else
-            yield(msg, false)
+            yield(msg, !field.required? || field.default?)
+            if field.required? && field.default?
+              self[name] = obj = field.default
+            else
+              delete(name)
+              next
+            end
           end
         end
 

data/lib/hexapdf/digital_signature/cms_handler.rb

@@ -49,7 +49,11 @@ module HexaPDF
       # Creates a new signature handler for the given signature dictionary.
       def initialize(signature_dict)
         super
-        @pkcs7 = OpenSSL::PKCS7.new(signature_dict.contents)
+        begin
+          @pkcs7 = OpenSSL::PKCS7.new(signature_dict.contents)
+        rescue
+          raise HexaPDF::Error, "Signature contents is invalid"
+        end
       end
 
       # Returns the common name of the signer.

data/lib/hexapdf/digital_signature/signing/timestamp_handler.rb

@@ -53,8 +53,8 @@ module HexaPDF
       # == Usage
       #
       # It is necessary to provide at least the URL of the timestamp authority server (TSA) via
-      # #tsa_url, everything else is optional and uses default values. The TSA server must not use
-      # authentication to be usable.
+      # #tsa_url, everything else is optional and uses default values. The TSA server can optionally
+      # use HTTP basic authentication.
       #
       # Example:
       #
@@ -66,6 +66,18 @@ module HexaPDF
         # This value is required.
         attr_accessor :tsa_url
 
+        # The username for basic authentication to the TSA server.
+        #
+        # If the username is not set, no basic authentication is done.
+        #
+        # See: #tsa_password
+        attr_accessor :tsa_username
+
+        # The password for basic authentication to the TSA server.
+        #
+        # See: #tsa_username
+        attr_accessor :tsa_password
+
         # The hash algorithm to use for timestamping. Defaults to SHA512.
         attr_accessor :tsa_hash_algorithm
 
@@ -127,8 +139,14 @@ module HexaPDF
           req.message_imprint = digest.digest
           req.policy_id = tsa_policy_id if tsa_policy_id
 
-          http_response = Net::HTTP.post(URI(tsa_url), req.to_der,
-                                         'content-type' => 'application/timestamp-query')
+          url = URI(tsa_url)
+          http_request = Net::HTTP::Post.new(url, 'Content-Type' => 'application/timestamp-query')
+          http_request.body = req.to_der
+          http_request.basic_auth(tsa_username, tsa_password) if tsa_username
+          http_response = Net::HTTP.start(url.hostname, url.port, use_ssl: (url.scheme == 'https')) do |http|
+            http.request(http_request)
+          end
+
           if http_response.kind_of?(Net::HTTPOK)
             response = OpenSSL::Timestamp::Response.new(http_response.body)
             if response.status == 0
@@ -136,6 +154,8 @@ module HexaPDF
             else
               raise HexaPDF::Error, "Timestamp token could not be created: #{response.failure_info}"
             end
+          elsif http_response.kind_of?(Net::HTTPUnauthorized)
+            raise HexaPDF::Error, "Basic authentication to the server failed: #{http_response.body}"
           else
             raise HexaPDF::Error, "Invalid TSA server response: #{http_response.body}"
           end

data/lib/hexapdf/document.rb

@@ -823,7 +823,7 @@ module HexaPDF
     # See #write for further information and details on the available arguments.
     def write_to_string(**args)
       io = StringIO.new(''.b)
-      write(io)
+      write(io, **args)
       io.string
     end
 

data/lib/hexapdf/font/encoding/base.rb

@@ -81,6 +81,33 @@ module HexaPDF
           @code_to_name.key(name)
         end
 
+        # Returns the encoding in a compact array form.
+        #
+        # If the optional +base_encoding+ argument is specified, all codes that have the same value
+        # in the base encoding are ignored.
+        #
+        # The returned array is of the form:
+        #
+        #   code1 name1 name2 ... code2 name3 name4 ...
+        #
+        # This means that name1 is associated with code1, name2 with code1 + 1 and so on.
+        #
+        # See: PDF 2.0 s9.6.5.1
+        def to_compact_array(base_encoding: nil)
+          result = []
+          last_code = -3
+          @code_to_name.sort.each do |code, name|
+            next if base_encoding&.name(code) == name
+            if last_code + 1 == code
+              result << name
+            else
+              result << code << name
+            end
+            last_code = code
+          end
+          result
+        end
+
       end
 
     end

data/lib/hexapdf/font/type1_wrapper.rb

@@ -279,9 +279,7 @@ module HexaPDF
           if VALID_ENCODING_NAMES.include?(@encoding.encoding_name)
             dict[:Encoding] = @encoding.encoding_name
           elsif @encoding != @wrapped_font.encoding
-            differences = [min]
-            (min..max).each {|code| differences << @encoding.name(code) }
-            dict[:Encoding] = {Differences: differences}
+            dict[:Encoding] = {Differences: @encoding.to_compact_array}
           end
         end
 

data/lib/hexapdf/layout/table_box.rb

@@ -131,8 +131,8 @@ module HexaPDF
     # fixed height (only if the actual content is smaller or equal than it):
     #
     #  #>pdf-composer
-    #  cells = [[{content: layout.text('A'), height: 5}, layout.text('B')],
-    #           [{content: layout.text('C'), height: 40}, layout.text('D')]]
+    #  cells = [[{content: layout.text('A'), min_height: 5}, layout.text('B')],
+    #           [{content: layout.text('C'), min_height: 40}, layout.text('D')]]
     #  composer.table(cells)
     #
     # The cells can be styled using a callable object for more complex styling:

data/lib/hexapdf/serializer.rb

@@ -276,16 +276,16 @@ module HexaPDF
     #
     # See: PDF2.0 s7.3.4
     def serialize_string(obj)
+      if obj.encoding != Encoding::BINARY && obj.match?(/[^ -~\t\r\n]/)
+        utf16_encoded = true
+        obj = "\xFE\xFF".b << obj.encode(Encoding::UTF_16BE).force_encoding(Encoding::BINARY)
+      end
       obj = if @encrypter && @object.kind_of?(HexaPDF::Object) && @object.indirect?
               encrypter.encrypt_string(obj, @object)
-            elsif obj.encoding != Encoding::BINARY
-              if obj.match?(/[^ -~\t\r\n]/)
-                "\xFE\xFF".b << obj.encode(Encoding::UTF_16BE).force_encoding(Encoding::BINARY)
-              else
-                obj.b
-              end
+            elsif utf16_encoded
+              obj
             else
-              obj.dup
+              obj.b
             end
       obj.gsub!(/[()\\\r]/n, STRING_ESCAPE_MAP)
       "(#{obj})"

data/lib/hexapdf/type/annotation.rb

@@ -243,7 +243,7 @@ module HexaPDF
       # The appearance state in /AS or the one provided via +state_name+ is taken into account if
       # necessary.
       def appearance(type: :normal, state_name: self[:AS])
-        entry = appearance_dict&.send("#{type}_appearance")
+        entry = appearance_dict&.send("#{type}_appearance") rescue nil
         if entry.kind_of?(HexaPDF::Dictionary) && !entry.kind_of?(HexaPDF::Stream)
           entry = entry[state_name]
         end

data/lib/hexapdf/type/font_type1.rb

@@ -183,7 +183,18 @@ module HexaPDF
 
         encoding = self[:Encoding]
         if encoding.kind_of?(Symbol) && !PREDEFINED_ENCODING.include?(encoding)
-          yield("The /Encoding value '#{encoding}' is invalid", false)
+          correctable = (self[:BaseFont] == :Symbol && encoding == :SymbolEncoding) ||
+                        (!symbolic? && encoding == :StandardEncoding)
+          yield("The /Encoding value '#{encoding}' is invalid", correctable)
+          if correctable
+            if encoding == :SymbolEncoding
+              delete(:Encoding)
+            else
+              diffs = HexaPDF::Font::Encoding.for_name(:StandardEncoding).
+                to_compact_array(base_encoding: HexaPDF::Font::Encoding.for_name(:WinAnsiEncoding))
+              self[:Encoding] = {BaseEncoding: :WinAnsiEncoding, Differences: diffs}
+            end
+          end
         end
       end
 

data/lib/hexapdf/utils/sorted_tree_node.rb

@@ -322,7 +322,10 @@ module HexaPDF
         if key?(container_name)
           container = self[container_name]
           if container.length.odd?
-            yield("Sorted tree leaf node contains odd number of entries", false)
+            root_node = !key?(:Limits)
+            yield("Sorted tree #{root_node ? 'root' : 'leaf'} node contains odd number of entries",
+                  root_node)
+            container.value.clear if root_node
             return
           end
           index = 0

data/lib/hexapdf/version.rb

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

data/test/hexapdf/digital_signature/common.rb

@@ -112,7 +112,12 @@ module HexaPDF
         @tsa_server.mount_proc('/') do |request, response|
           @tsr = OpenSSL::Timestamp::Request.new(request.body)
           case @tsr.policy_id || '1.2.3.4.0'
-          when '1.2.3.4.0', '1.2.3.4.2'
+          when '1.2.3.4.0', '1.2.3.4.2', '1.2.3.4.3'
+            if @tsr.policy_id == '1.2.3.4.3'
+              WEBrick::HTTPAuth.basic_auth(request, response, 'HexaPDF Auth') do |username, password|
+                username == 'hexatest' && password == 'hexapwd'
+              end
+            end
             fac = OpenSSL::Timestamp::Factory.new
             fac.gen_time = Time.now
             fac.serial_number = 1

data/test/hexapdf/digital_signature/signing/test_timestamp_handler.rb

@@ -67,6 +67,18 @@ describe HexaPDF::DigitalSignature::Signing::TimestampHandler do
       assert_equal("1.2.3.4.2", policy_id)
     end
 
+    it "allows using basic authentication on the server" do
+      @handler.tsa_policy_id = '1.2.3.4.3'
+      @handler.tsa_username = 'hexatest'
+      @handler.tsa_password = 'invalid'
+      msg = assert_raises(HexaPDF::Error) { @handler.sign(@data, @range) }
+      assert_match(/Basic authentication/, msg.message)
+
+      @handler.tsa_password = 'hexapwd'
+      token = OpenSSL::PKCS7.new(@handler.sign(@data, @range))
+      assert_equal(CERTIFICATES.ca_certificate.subject, token.signers[0].issuer)
+    end
+
     it "returns the serialized timestamp token" do
       token = OpenSSL::PKCS7.new(@handler.sign(@data, @range))
       assert_equal(CERTIFICATES.ca_certificate.subject, token.signers[0].issuer)

data/test/hexapdf/digital_signature/test_cms_handler.rb

@@ -17,6 +17,12 @@ describe HexaPDF::DigitalSignature::CMSHandler do
     @handler = HexaPDF::DigitalSignature::CMSHandler.new(@dict)
   end
 
+  it "fails with an appropriate error if the the signature contents is invalid" do
+    @dict.contents = :Unknown
+    msg = assert_raises(HexaPDF::Error) { HexaPDF::DigitalSignature::CMSHandler.new(@dict) }
+    assert_match(/contents is invalid/, msg.message)
+  end
+
   it "returns the signer name" do
     assert_equal("RSA signer", @handler.signer_name)
   end

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

@@ -1,6 +1,7 @@
 # -*- encoding: utf-8 -*-
 
 require 'test_helper'
+require 'hexapdf/font/encoding'
 require 'hexapdf/font/encoding/base'
 
 describe HexaPDF::Font::Encoding::Base do
@@ -42,4 +43,23 @@ describe HexaPDF::Font::Encoding::Base do
       assert_nil(@base.code(:Unknown))
     end
   end
+
+  describe "to_compact_array" do
+    before do
+      @base.code_to_name[66] = :B
+      @base.code_to_name[67] = :C
+      @base.code_to_name[20] = :space
+      @base.code_to_name[28] = :D
+      @base.code_to_name[29] = :E
+    end
+
+    it "returns the difference array" do
+      assert_equal([20, :space, 28, :D, :E, 65, :A, :B, :C], @base.to_compact_array)
+    end
+
+    it "ignores the codes that are the same in the base encoding" do
+      std_encoding = HexaPDF::Font::Encoding.for_name(:StandardEncoding)
+      assert_equal([20, :space, 28, :D, :E, ], @base.to_compact_array(base_encoding: std_encoding))
+    end
+  end
 end

data/test/hexapdf/test_dictionary.rb

@@ -251,8 +251,23 @@ describe HexaPDF::Dictionary do
       refute(@obj.validate(auto_correct: false))
       assert(@obj.validate(auto_correct: true))
       @obj.value[:NameField] = "string"
+      refute(@obj.validate(auto_correct: false))
       assert(@obj.validate(auto_correct: true))
+
+      @test_class.define_field(:RequiredDefault, type: String, required: true, default: 'str')
+      @obj.value[:RequiredDefault] = 20
+      refute(@obj.validate(auto_correct: false))
+      assert_equal(20, @obj.value[:RequiredDefault])
       assert(@obj.validate(auto_correct: true))
+      assert_equal("str", @obj.value[:RequiredDefault])
+
+      @obj.value[:AllowedValues] = '20'
+      assert(@obj.validate(auto_correct: true))
+      refute(@obj.key?(:AllowedValues))
+
+      @obj.value[:Inherited] = 20
+      refute(@obj.validate(auto_correct: true))
+      refute(@obj.key?(:Inherited))
     end
 
     it "checks whether the value is an allowed one" do

data/test/hexapdf/test_document.rb

@@ -347,7 +347,7 @@ describe HexaPDF::Document do
 
     it "validates the trailer object" do
       @doc.trailer[:ID] = :Symbol
-      refute(@doc.validate {|_, _, obj| assert_same(@doc.trailer, obj) })
+      assert(@doc.validate {|_a, _b, obj| assert_same(@doc.trailer, obj) })
     end
 
     it "validates only loaded objects" do
@@ -391,7 +391,7 @@ describe HexaPDF::Document do
     end
 
     it "fails if the document is not valid" do
-      @doc.trailer[:Size] = :Symbol
+      @doc.catalog[:PageLayout] = :invalid_value
       assert_raises(HexaPDF::Error) { @doc.write(StringIO.new(''.b)) }
     end
 
@@ -611,5 +611,6 @@ describe HexaPDF::Document do
     assert_equal(Encoding::ASCII_8BIT, str.encoding)
     doc = HexaPDF::Document.new(io: StringIO.new(str))
     assert_equal(:test, doc.trailer.info[:test])
+    assert_nil(doc.trailer.info[:ModDate])
   end
 end

data/test/hexapdf/test_serializer.rb

@@ -181,7 +181,8 @@ describe HexaPDF::Serializer do
 
     it "encrypts strings in indirect PDF objects" do
       assert_serialized("(enc:1:test)", HexaPDF::Object.new("test", oid: 1))
-      assert_serialized("<</x[(enc:1:test)]>>", HexaPDF::Object.new({x: ["test"]}, oid: 1))
+      assert_serialized("<</x[(enc:1:\xFE\xFF\x00t\x00e\x00s\x00t\x00\xF6)]>>".b,
+                        HexaPDF::Object.new({x: ["testö"]}, oid: 1))
     end
 
     it "doesn't encrypt strings in direct PDF objects" do

data/test/hexapdf/type/annotations/test_widget.rb

@@ -52,6 +52,14 @@ describe HexaPDF::Type::Annotations::Widget do
       assert_kind_of(HexaPDF::Type::AcroForm::TextField, result)
       refute_same(@widget.data, result.data)
     end
+
+    it "works when the type of the field is defined higher up in the field hierarchy" do
+      @widget[:Parent] = {T: 'parent', Kids: [@widget]}
+      @widget[:Parent][:Parent] = {FT: :Tx, Kids: [@widget[:Parent]]}
+      result = @widget.form_field
+      assert_kind_of(HexaPDF::Type::AcroForm::TextField, result)
+      refute_same(@widget.data, result.data)
+    end
   end
 
   describe "background_color" do

data/test/hexapdf/type/test_annotation.rb

@@ -67,6 +67,9 @@ describe HexaPDF::Type::Annotation do
   it "returns the appearance stream of the given type" do
     assert_nil(@annot.appearance)
 
+    @annot[:AP] = 'some invalid type'
+    assert_nil(@annot.appearance)
+
     @annot[:AP] = {N: {}}
     assert_nil(@annot.appearance)
 

data/test/hexapdf/type/test_font_type1.rb

@@ -143,5 +143,19 @@ describe HexaPDF::Type::FontType1 do
       @font[:Encoding] = :Other
       refute(@font.validate)
     end
+
+    it "works around certain invalid PDFs with a /SymbolEncoding value for /Encoding" do
+      @font[:Encoding] = :SymbolEncoding
+      @font[:BaseFont] = :Symbol
+      assert(@font.validate)
+      refute(@font.key?(:Encoding))
+    end
+
+    it "works around certain invalid PDFs with a /StandardEncoding value for /Encoding" do
+      @font[:Encoding] = :StandardEncoding
+      assert(@font.validate)
+      assert(:WinAnsiEncoding, @font[:Encoding][:BaseEncoding])
+      assert_equal([39, :quoteright, 96, :quoteleft], @font[:Encoding][:Differences][0, 4])
+    end
   end
 end

data/test/hexapdf/utils/test_sorted_tree_node.rb

@@ -219,11 +219,21 @@ describe HexaPDF::Utils::SortedTreeNode do
     it "checks that leaf node containers have an even number of entries" do
       @kid11[:Names].delete_at(0)
       refute(@kid11.validate do |message, c|
-               assert_match(/odd number/, message)
+               assert_match(/leaf.*odd number/, message)
                refute(c)
              end)
     end
 
+    it "corrects a root node container with an odd number of entries" do
+      @root.value.clear
+      @root[:Names] = ['Test']
+      assert(@root.validate do |message, c|
+        assert_match(/root.*odd number/, message)
+        assert(c)
+      end)
+      assert(@root[:Names].empty?)
+    end
+
     it "checks that the keys are of the correct type" do
       @kid11[:Names][2] = 5
       refute(@kid11.validate do |message, c|

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: hexapdf
 version: !ruby/object:Gem::Version
-  version: 1.4.0
+  version: 1.5.0
 platform: ruby
 authors:
 - Thomas Leitner
 bindir: bin
 cert_chain: []
-date: 2025-08-03 00:00:00.000000000 Z
+date: 2025-12-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: cmdparse