hexapdf 1.4.0 → 1.4.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 82d0430964f9f4c6925af5bb076a2e641908c3a4cb6796acc64dbe1303bc3407
-  data.tar.gz: 689a86b637a86331ca203d7d7ac90a9fb3c50c275f07b21d8109013faa509f07
+  metadata.gz: b88ce85ee9bc603011b9f5a278829d588da10f53614c0b84a57e2d7fa38f52dc
+  data.tar.gz: ec2c8739ed69038e1297435550371bf329e516e9ef970fa0456502b15720d07b
 SHA512:
-  metadata.gz: 4cfe8038379e5dc7f3bebeb38b44525676b934cb2b2355ac7575fa7a4466a6c4ec9ab9e0a80a184aebab32b2aa87e06dff735c10915abebe11541ada95d8129c
-  data.tar.gz: 62562b4bae557ad3dac03cb51913a8d1d6796d6cad9ce0626bc901cc15afeb301e42d061c345a1ebcb30e09a018dbe4b7c26fc4c567423c262f67607d04b95c9
+  metadata.gz: 103edc366ef9f48ddd6579f7137b3ab23b4266dc2df0a77ee5b89cb4256419a00727776158a7c7570a0b10075e4f062506d524ec71ee801c00fdd9e4726c8232
+  data.tar.gz: f1f4a1af54445b2e7c3c9fc1adfa81fb9fad84f32461f58378fc550bd5aec16e16b276dadc7516ca5b0b6212394886d06f2cc2a3506dc2b2745b5a1f4c8136d1

data/CHANGELOG.md

@@ -1,3 +1,26 @@
+## 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 +47,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

@@ -132,7 +132,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)
@@ -155,6 +155,10 @@ module HexaPDF
             puts "Extracting #{path}..." if command_parser.verbosity_info?
             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

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/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/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.4.1'
 
 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_document.rb

@@ -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_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.4.1
 platform: ruby
 authors:
 - Thomas Leitner
 bindir: bin
 cert_chain: []
-date: 2025-08-03 00:00:00.000000000 Z
+date: 2025-09-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: cmdparse