hexapdf 1.0.1 → 1.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 61b0fb56c6522f2af82eb8ffb10570c45bb11460cf4c048c1bdfe8d9daf71afe
-  data.tar.gz: 91cb053019c367825ac0799a84e4ddad837fe283a6ab2bc6df16ee9ed9f2456d
+  metadata.gz: 7a94d8744657f89cf855604bdb363426637190a5db9615bbcb78e033f9aa5b0f
+  data.tar.gz: b5ea3789c402ce1affb937eca574aba6c3cd21864484f56015aa2aef4acb9b86
 SHA512:
-  metadata.gz: 9a71ee1e9307f0ef67c9dec108c7f68db45166a62f9b6ec60915ce2c089cf0e9ec5bfcd8d74e8b31b63238a09c820a0798689a84e5ea0b1577e2492e5a1d425e
-  data.tar.gz: b20043cead03f7fc7fe527fdbcb3674ab2d1da06b546bac9c1549b6eb6d143232453132709d93ae008d78a83bff36cf85fd0dbc0938da848e7847a1830e6011e
+  metadata.gz: 6c7a881cc83213116e3f818c4df6063a9ebc758fe79d4120e5163d7bd78509ad358a32c122db0ffdfd6b1def50a6ec53a83e429ece1355aff02751b3a886e9a3
+  data.tar.gz: eb82b47d523c96403fd64afcbd5a3a867b74e059890819c816dadd71b8fac0595a431c9ff926dea8a45c2d949e8802fa9a2dccb776a24acb04922f677cac2b66

data/CHANGELOG.md

@@ -1,3 +1,27 @@
+## 1.0.3 - 2024-12-04
+
+### Fixed
+
+* Offsets and lengths of revisions shown using the `inspect rev` CLI command for
+  linearized PDF files
+* [HexaPDF::Type::AcroForm::Form#recalculate_fields] to only consider real
+  fields
+
+
+## 1.0.2 - 2024-11-05
+
+### Added
+
+* [HexaPDF::Type::CMap] for representing CMap streams
+
+### Fixed
+
+* Checksum calculation for TrueType tables
+* Automatic wrapping of dictionary entry /CIDToGIDMap for CID fonts
+* Performance regression when encoding char codes for TrueType fonts
+* PDF/A validation regression for PDFs using TrueType fonts
+
+
 ## 1.0.1 - 2024-11-04
 
 ### Changed

data/lib/hexapdf/cli/inspect.rb

@@ -395,9 +395,12 @@ module HexaPDF
         end
         io = @doc.revisions.parser.io
 
-        startxrefs = @doc.revisions.map {|rev| rev.trailer[:Prev] }
         io.seek(0, IO::SEEK_END)
-        startxrefs.push(@doc.revisions.parser.startxref_offset, io.pos).shift
+        startxrefs = @doc.revisions.map {|rev| rev.trailer[:Prev] } <<
+                     @doc.revisions.parser.startxref_offset <<
+                     io.pos
+        startxrefs.sort!
+        startxrefs.shift
 
         @doc.revisions.each_with_index.map do |rev, index|
           end_index = 0

data/lib/hexapdf/configuration.rb

@@ -722,6 +722,7 @@ module HexaPDF
                         OutputIntent: 'HexaPDF::Type::OutputIntent',
                         XXDestOutputProfileRef: 'HexaPDF::Type::OutputIntent::DestOutputProfileRef',
                         ExData: 'HexaPDF::Type::Annotations::MarkupAnnotation::ExData',
+                        CMap: 'HexaPDF::Type::CMap',
                       },
                       'object.subtype_map' => {
                         nil => {

data/lib/hexapdf/encryption/arc4.rb

@@ -66,14 +66,14 @@ module HexaPDF
         # Encrypts the given +data+ with the +key+.
         #
         # See: PDF2.0 s7.6.3
-        def encrypt(key, data)
+        def encrypt(key, data, &_block)
           new(key).process(data)
         end
         alias decrypt encrypt
 
         # Returns a Fiber object that encrypts the data from the given source fiber with the
         # +key+.
-        def encryption_fiber(key, source)
+        def encryption_fiber(key, source, &_block)
           Fiber.new do
             algorithm = new(key)
             while source.alive? && (data = source.resume)

data/lib/hexapdf/font/true_type/subsetter.rb

@@ -63,16 +63,6 @@ module HexaPDF
         def use_glyph(glyph_id)
           return @glyph_map[glyph_id] if @glyph_map.key?(glyph_id)
           @last_id += 1
-          # Handle codes for ASCII characters \r (13), (, ) (40, 41) and \ (92) specially so that
-          # they never appear in the output (PDF serialization would need to escape them)
-          if @last_id == 13 || @last_id == 40 || @last_id == 92
-            @glyph_map[:"s#{@last_id}"] = @last_id
-            if @last_id == 40
-              @last_id += 1
-              @glyph_map[:"s#{@last_id}"] = @last_id
-            end
-            @last_id += 1
-          end
           @glyph_map[glyph_id] = @last_id
         end
 
@@ -117,7 +107,7 @@ module HexaPDF
           locations = []
 
           @glyph_map.each_key do |old_gid|
-            glyph = orig_glyf[old_gid.kind_of?(Symbol) ? 0 : old_gid]
+            glyph = orig_glyf[old_gid]
             locations << table.size
             data = glyph.raw_data
             if glyph.compound?
@@ -176,10 +166,7 @@ module HexaPDF
         # Adds the components of compound glyphs to the subset.
         def add_glyph_components
           glyf = @font[:glyf]
-          @glyph_map.keys.each do |gid|
-            next if gid.kind_of?(Symbol)
-            glyf[gid].components&.each {|cgid| use_glyph(cgid) }
-          end
+          @glyph_map.keys.each {|gid| glyf[gid].components&.each {|cgid| use_glyph(cgid) } }
         end
 
       end

data/lib/hexapdf/font/true_type/table.rb

@@ -63,7 +63,12 @@ module HexaPDF
 
         # Calculates the checksum for the given data.
         def self.calculate_checksum(data)
-          data.unpack('N*').inject(0) {|sum, long| sum + long } % 2**32
+          checksum = 0
+          if (remainder_length = data.length % 4) != 0
+            checksum = (data[-remainder_length, remainder_length] << "\0" * (4 - remainder_length)).
+              unpack1('N')
+          end
+          checksum + data.unpack('N*').inject(0) {|sum, long| sum + long } % 2**32
         end
 
         # The TrueType font object associated with this table.

data/lib/hexapdf/font/true_type_wrapper.rb

@@ -239,6 +239,11 @@ module HexaPDF
             raise HexaPDF::MissingGlyphError.new(glyph) if glyph.kind_of?(InvalidGlyph)
             @subsetter.use_glyph(glyph.id) if @subsetter
             @last_char_code += 1
+            # Handle codes for ASCII characters \r (13), (, ) (40, 41) and \ (92) specially so that
+            # they never appear in the output (PDF serialization would need to escape them)
+            if @last_char_code == 13 || @last_char_code == 40 || @last_char_code == 92
+              @last_char_code += (@last_char_code == 40 ? 2 : 1)
+            end
             [[@last_char_code].pack('n'), @last_char_code]
           end)[0]
       end
@@ -376,7 +381,11 @@ module HexaPDF
           dict[:Encoding] = :'Identity-H'
         else
           stream = HexaPDF::StreamData.new { HexaPDF::Font::CMap.create_cid_cmap(mapping) }
-          stream_obj = document.add({}, stream: stream)
+          stream_obj = document.add({Type: :CMap,
+                                     CMapName: :Custom,
+                                     CIDSystemInfo: {Registry: "Adobe", Ordering: "Identity",
+                                                     Supplement: 0},
+                                    }, stream: stream)
           stream_obj.set_filter(:FlateDecode)
           dict[:Encoding] = stream_obj
         end

data/lib/hexapdf/test_utils.rb

@@ -92,8 +92,9 @@ module HexaPDF
     # Creates a fiber that yields the given string in +len+ length parts.
     def feeder(string, len = string.length)
       Fiber.new do
+        string = string.b
         until string.empty?
-          Fiber.yield(string.slice!(0, len).force_encoding('BINARY'))
+          Fiber.yield(string.slice!(0, len))
         end
       end
     end

data/lib/hexapdf/type/acro_form/form.rb

@@ -517,7 +517,7 @@ module HexaPDF
         #
         # See: JavaScriptActions
         def recalculate_fields
-          self[:CO]&.each do |field|
+          (each_field.to_a & self[:CO].to_a).each do |field|
             field = Field.wrap(document, field)
             next unless field && (calculation_action = field[:AA]&.[](:C))
             result = JavaScriptActions.calculate(self, calculation_action)

data/lib/hexapdf/type/cid_font.rb

@@ -70,7 +70,7 @@ module HexaPDF
       define_field :W,               type: PDFArray
       define_field :DW2,             type: PDFArray, default: [880, -1100]
       define_field :W2,              type: PDFArray
-      define_field :CIDToGIDMap,     type: [Symbol, Stream]
+      define_field :CIDToGIDMap,     type: [Stream, Symbol]
 
       # Returns the unscaled width of the given CID in glyph units, or 0 if the width for the CID is
       # missing.

data/lib/hexapdf/type/cmap.rb

@@ -0,0 +1,58 @@
+# -*- encoding: utf-8; frozen_string_literal: true -*-
+#
+#--
+# This file is part of HexaPDF.
+#
+# HexaPDF - A Versatile PDF Creation and Manipulation Library For Ruby
+# Copyright (C) 2014-2024 Thomas Leitner
+#
+# HexaPDF is free software: you can redistribute it and/or modify it
+# under the terms of the GNU Affero General Public License version 3 as
+# published by the Free Software Foundation with the addition of the
+# following permission added to Section 15 as permitted in Section 7(a):
+# FOR ANY PART OF THE COVERED WORK IN WHICH THE COPYRIGHT IS OWNED BY
+# THOMAS LEITNER, THOMAS LEITNER DISCLAIMS THE WARRANTY OF NON
+# INFRINGEMENT OF THIRD PARTY RIGHTS.
+#
+# HexaPDF is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+# FITNESS FOR A PARTICULAR PURPOSE. See the GNU Affero General Public
+# License for more details.
+#
+# You should have received a copy of the GNU Affero General Public License
+# along with HexaPDF. If not, see <http://www.gnu.org/licenses/>.
+#
+# The interactive user interfaces in modified source and object code
+# versions of HexaPDF must display Appropriate Legal Notices, as required
+# under Section 5 of the GNU Affero General Public License version 3.
+#
+# In accordance with Section 7(b) of the GNU Affero General Public
+# License, a covered work must retain the producer line in every PDF that
+# is created or manipulated using HexaPDF.
+#
+# If the GNU Affero General Public License doesn't fit your need,
+# commercial licenses are available at <https://gettalong.at/hexapdf/>.
+#++
+
+require 'hexapdf/stream'
+
+module HexaPDF
+  module Type
+
+    # Represents an embedded CMap file.
+    #
+    # See: PDF2.0 s9.7.5.3
+    class CMap < Stream
+
+      define_type :CMap
+
+      define_field :Type, type: Symbol, required: true, default: type
+      define_field :CMapName, type: Symbol, required: true
+      define_field :CIDSystemInfo, type: :XXCIDSystemInfo, required: true
+      define_field :WMode, type: Integer
+      define_field :UseCMap, type: [Stream, Symbol]
+
+    end
+
+  end
+end

data/lib/hexapdf/type.rb

@@ -82,6 +82,7 @@ module HexaPDF
     autoload(:OptionalContentConfiguration, 'hexapdf/type/optional_content_configuration')
     autoload(:Metadata, 'hexapdf/type/metadata')
     autoload(:OutputIntent, 'hexapdf/type/output_intent')
+    autoload(:CMap, 'hexapdf/type/cmap')
 
   end
 

data/lib/hexapdf/version.rb

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

data/test/hexapdf/common_tokenizer_tests.rb

@@ -65,7 +65,7 @@ module CommonTokenizerTests
       :'The_Key_of_F#_Minor', :AB, :"",
       '[', 5, 6, :Name, ']', '[', 5, 6, :Name, ']',
       '<<', :Name, 5, '>>'
-    ].each {|t| t.force_encoding('BINARY') if t.respond_to?(:force_encoding) }
+    ].map {|t| t.respond_to?(:force_encoding) ? t.b : t }
 
     until expected_tokens.empty?
       expected_token = expected_tokens.shift
@@ -127,7 +127,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
 
@@ -182,7 +182,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/encryption/common.rb

@@ -67,7 +67,7 @@ module ARC4EncryptionTests
     super
     @encrypted = ['BBF316E8D940AF0AD3', '1021BF0420', '45A01F645FC35B383552544B9BF5'].
       map {|c| [c].pack('H*') }
-    @plain = ['Plaintext', 'pedia', 'Attack at dawn'].each {|s| s.force_encoding('BINARY') }
+    @plain = ['Plaintext'.b, 'pedia'.b, 'Attack at dawn'.b]
     @keys = ['Key', 'Wiki', 'Secret']
   end
 

data/test/hexapdf/encryption/test_aes.rb

@@ -141,7 +141,7 @@ describe HexaPDF::Encryption::AES do
         collector(@algorithm_class.decryption_fiber('some' * 4, Fiber.new { 'a' * 40 }))
       end
       assert_raises(HexaPDF::EncryptionError) do
-        collector(@algorithm_class.decryption_fiber('some' * 4, Fiber.new { 'a' * 40 })) { true }
+        collector(@algorithm_class.decryption_fiber('some' * 4, Fiber.new { 'a' * 40 }) { true })
       end
     end
   end

data/test/hexapdf/encryption/test_arc4.rb

@@ -11,13 +11,13 @@ describe HexaPDF::Encryption::ARC4 do
       prepend HexaPDF::Encryption::ARC4
 
       def initialize(key)
-        @data = key
+        @data = +key
       end
 
       def process(data)
         raise if data.empty?
         result = @data << data
-        @data = ''
+        @data = +''
         result
       end
     end

data/test/hexapdf/encryption/test_security_handler.rb

@@ -236,7 +236,7 @@ describe HexaPDF::Encryption::SecurityHandler do
         dict[:Filter] = :Test
         @enc.strf = alg
         @enc.set_up_encryption(key_length: length, algorithm: (alg == :identity ? :aes : alg))
-        @obj[:X] = @enc.encrypt_string('data', @obj)
+        @obj[:X] = @enc.encrypt_string(+'data', @obj)
         @handler.set_up_decryption(dict)
         assert_equal('data', @handler.decrypt(@obj)[:X])
       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 << "~>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/filter/test_flate_decode.rb

@@ -8,11 +8,10 @@ describe HexaPDF::Filter::FlateDecode do
 
   before do
     @obj = HexaPDF::Filter::FlateDecode
-    @all_test_cases = [["abcdefg".force_encoding(Encoding::BINARY),
-                        "x\xDAKLJNIMK\a\x00\n\xDB\x02\xBD".force_encoding(Encoding::BINARY)]]
+    @all_test_cases = [["abcdefg".b, "x\xDAKLJNIMK\a\x00\n\xDB\x02\xBD".b]]
     @decoded = @all_test_cases[0][0]
     @encoded = @all_test_cases[0][1]
-    @encoded_predictor = "x\xDAcJdbD@\x00\x05\x8F\x00v".force_encoding(Encoding::BINARY)
+    @encoded_predictor = "x\xDAcJdbD@\x00\x05\x8F\x00v".b
     @predictor_opts = {Predictor: 12}
   end
 

data/test/hexapdf/font/cmap/test_writer.rb

@@ -5,7 +5,7 @@ require 'hexapdf/font/cmap/writer'
 
 describe HexaPDF::Font::CMap::Writer do
   before do
-    @to_unicode_cmap_data = <<~EOF
+    @to_unicode_cmap_data = +<<~EOF
       /CIDInit /ProcSet findresource begin
       12 dict begin
       begincmap
@@ -32,7 +32,7 @@ describe HexaPDF::Font::CMap::Writer do
       end
       end
     EOF
-    @cid_cmap_data = <<~EOF
+    @cid_cmap_data = +<<~EOF
       %!PS-Adobe-3.0 Resource-CMap
       %%DocumentNeededResources: ProcSet (CIDInit)
       %%IncludeResource: ProcSet (CIDInit)

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

@@ -32,7 +32,7 @@ describe HexaPDF::Font::Encoding::GlyphList do
 
     it "maps special uXXXX[XX] names to unicode values" do
       assert_equal("A", @list.name_to_unicode(:u0041))
-      assert_equal("" << "1F000".hex, @list.name_to_unicode(:u1F000))
+      assert_equal(+'' << "1F000".hex, @list.name_to_unicode(:u1F000))
     end
 
     it "maps Zapf Dingbats glyph names to their unicode" do

data/test/hexapdf/font/test_true_type_wrapper.rb

@@ -51,7 +51,7 @@ describe HexaPDF::Font::TrueTypeWrapper do
       glyphs = @font_wrapper.decode_utf8("😁")
       assert_equal(1, glyphs.length)
       assert_kind_of(HexaPDF::Font::InvalidGlyph, glyphs.first)
-      assert_equal('' << 128_513, glyphs.first.str)
+      assert_equal(+'' << 128_513, glyphs.first.str)
     end
   end
 
@@ -81,7 +81,7 @@ describe HexaPDF::Font::TrueTypeWrapper do
       glyph = @font_wrapper.glyph(9999)
       assert_kind_of(HexaPDF::Font::InvalidGlyph, glyph)
       assert_equal(0, glyph.id)
-      assert_equal('' << 0xFFFD, glyph.str)
+      assert_equal(+'' << 0xFFFD, glyph.str)
     end
   end
 
@@ -119,6 +119,11 @@ describe HexaPDF::Font::TrueTypeWrapper do
       assert_equal([3].pack('n'), code)
     end
 
+    it "doesn't use char codes 13, 40, 41 and 92 because they would need to be escaped" do
+      codes = 1.upto(93).map {|i| @font_wrapper.encode(@font_wrapper.glyph(i)) }.join
+      assert_equal([1..12, 14..39, 42..91, 93..97].flat_map(&:to_a).pack('n*'), codes)
+    end
+
     it "raises an error if an InvalidGlyph is encoded" do
       exp = assert_raises(HexaPDF::MissingGlyphError) do
         @font_wrapper.encode(@font_wrapper.decode_utf8("ö").first)

data/test/hexapdf/font/test_type1_wrapper.rb

@@ -56,7 +56,7 @@ describe HexaPDF::Font::Type1Wrapper do
       glyphs = @times_wrapper.decode_utf8("😁")
       assert_equal(1, glyphs.length)
       assert_kind_of(HexaPDF::Font::InvalidGlyph, glyphs.first)
-      assert_equal('' << 128_513, glyphs.first.str)
+      assert_equal(+'' << 128_513, glyphs.first.str)
     end
   end
 

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

@@ -27,16 +27,6 @@ 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/true_type/test_table.rb

@@ -13,6 +13,18 @@ describe HexaPDF::Font::TrueType::Table do
     @entry = HexaPDF::Font::TrueType::Table::Directory::Entry.new('tagg', 0, 0, @file.io.string.length)
   end
 
+  describe "self.calculate_checksum" do
+    it "works for data with a length divisible by four" do
+      klass = HexaPDF::Font::TrueType::Table
+      assert_equal(256, klass.calculate_checksum("\x00\x00\x00\x01\x00\x00\x00\xFF"))
+    end
+
+    it "works for data with a length not divisible by four" do
+      klass = HexaPDF::Font::TrueType::Table
+      assert_equal(512, klass.calculate_checksum("\x00\x00\x00\x01\x00\x00\x00\xFF\x00\x00\x01"))
+    end
+  end
+
   describe "initialize" do
     it "reads the data from the associated file" do
       table = TrueTypeTestTable.new(@file, @entry)

data/test/hexapdf/task/test_merge_acro_form.rb

@@ -81,7 +81,7 @@ describe HexaPDF::Task::MergeAcroForm do
   end
 
   it "updates the /DA entries of widgets and fields" do
-    @pages[0][:Annots][0][:DA] = '/F1 10 Tf'
+    @pages[0][:Annots][0][:DA] = +'/F1 10 Tf'
     @doc.task(:merge_acro_form, source: @doc1, pages: @pages)
     field = @doc.acro_form.field_by_name('merged_1.Text')
     assert_equal('0.0 g /F2 0 Tf', field[:DA])

data/test/hexapdf/test_filter.rb

@@ -8,7 +8,7 @@ require 'tempfile'
 describe HexaPDF::Filter do
   before do
     @obj = HexaPDF::Filter
-    @str = ''
+    @str = +''
     40.times { @str << [rand(2**32)].pack('N') }
   end
 

data/test/hexapdf/test_parser.rb

@@ -11,7 +11,7 @@ describe HexaPDF::Parser do
     @document.config['parser.try_xref_reconstruction'] = false
     @document.add(@document.wrap(10, oid: 1, gen: 0))
 
-    create_parser(<<~EOF)
+    create_parser(+<<~EOF)
       %PDF-1.7
 
       1 0 obj
@@ -354,7 +354,7 @@ describe HexaPDF::Parser do
   describe "startxref_offset" do
     it "caches the offset value" do
       assert_equal(330, @parser.startxref_offset)
-      @parser.instance_eval { @io }.string.sub!(/330\n/, "309\n")
+      @parser.instance_eval { @io.string = @io.string.sub(/330\n/, "309\n") }
       assert_equal(330, @parser.startxref_offset)
     end
 
@@ -363,7 +363,7 @@ describe HexaPDF::Parser do
     end
 
     it "ignores garbage at the end of the file" do
-      create_parser("startxref\n5\n%%EOF" << "\nhallo" * 150)
+      create_parser("startxref\n5\n%%EOF" + "\nhallo" * 150)
       assert_equal(5, @parser.startxref_offset)
     end
 
@@ -373,17 +373,17 @@ describe HexaPDF::Parser do
     end
 
     it "finds the startxref anywhere in file" do
-      create_parser("startxref\n5\n%%EOF" << "\nhallo" * 5000)
+      create_parser("startxref\n5\n%%EOF" + "\nhallo" * 5000)
       assert_equal(5, @parser.startxref_offset)
     end
 
     it "handles the case where %%EOF is the on the 1. line of the 1024 byte search block" do
-      create_parser("startxref\n5\n%%EOF\n" << "h" * 1018)
+      create_parser("startxref\n5\n%%EOF\n" + "h" * 1018)
       assert_equal(5, @parser.startxref_offset)
     end
 
     it "handles the case where %%EOF is the on the 2. line of the 1024 byte search block" do
-      create_parser("startxref\n5\n%%EOF\n" << "h" * 1017)
+      create_parser("startxref\n5\n%%EOF\n" + "h" * 1017)
       assert_equal(5, @parser.startxref_offset)
     end
 
@@ -421,7 +421,7 @@ describe HexaPDF::Parser do
 
     it "fails on strict parsing if the startxref is not in the last part of the file" do
       @document.config['parser.on_correctable_error'] = proc { true }
-      create_parser("startxref\n5\n%%EOF" << "\nhallo" * 5000)
+      create_parser("startxref\n5\n%%EOF" + "\nhallo" * 5000)
       exp = assert_raises(HexaPDF::MalformedPDFError) { @parser.startxref_offset }
       assert_match(/end-of-file marker not found/, exp.message)
     end
@@ -459,7 +459,7 @@ describe HexaPDF::Parser do
     end
 
     it "ignores junk at the beginning of the file and correctly calculates offset" do
-      create_parser("junk" * 200 << "\n%PDF-1.4\n")
+      create_parser("junk" * 200 + "\n%PDF-1.4\n")
       assert_equal('1.4', @parser.file_header_version)
       assert_equal(801, @parser.instance_variable_get(:@header_offset))
     end
@@ -670,13 +670,13 @@ describe HexaPDF::Parser do
     end
 
     it "handles cases where the line contains an invalid string that exceeds the read buffer" do
-      create_parser("(1" << "(abc" * 32188 << "\n1 0 obj\n6\nendobj\ntrailer\n<</Size 1>>")
+      create_parser("(1" + "(abc" * 32188 + "\n1 0 obj\n6\nendobj\ntrailer\n<</Size 1>>")
       assert_equal(6, @parser.load_object(@xref).value)
     end
 
     it "handles pathalogical cases which contain many opened literal strings" do
       time = Time.now
-      create_parser("(1" << "(abc\n" * 10000 << "\n1 0 obj\n6\nendobj\ntrailer\n<</Size 1>>")
+      create_parser("(1" + "(abc\n" * 10000 + "\n1 0 obj\n6\nendobj\ntrailer\n<</Size 1>>")
       assert_equal(6, @parser.load_object(@xref).value)
       assert(Time.now - time < 0.5, "Xref reconstruction takes too long")
     end

data/test/hexapdf/test_revisions.rb

@@ -359,7 +359,7 @@ describe HexaPDF::Revisions do
 
   describe "linearzied PDFs" do
     before  do
-      @io = StringIO.new(<<~EOF)
+      @io = StringIO.new(+<<~EOF)
         %PDF-1.2
         5 0 obj
         <</Linearized 1>>

data/test/hexapdf/test_serializer.rb

@@ -88,7 +88,7 @@ describe HexaPDF::Serializer do
     assert_serialized('/The_Key_of_F#23_Minor', :'The_Key_of_F#_Minor')
     assert_serialized('/ ', :"")
     assert_serialized('/H#c3#b6#c3#9fgang', :Hößgang)
-    assert_serialized('/H#e8lp', "H\xE8lp".force_encoding('BINARY').intern)
+    assert_serialized('/H#e8lp', "H\xE8lp".b.intern)
     assert_serialized('/#00#09#0a#0c#0d#20', :"\x00\t\n\f\r ")
   end
 
@@ -105,8 +105,7 @@ describe HexaPDF::Serializer do
   it "serializes strings" do
     assert_serialized("(Hallo)", "Hallo")
     assert_serialized("(Hallo\\r\n\t\\(\\)\\\\)", "Hallo\r\n\t()\\")
-    assert_serialized("(\xFE\xFF\x00H\x00a\x00l\x00\f\x00\b\x00\\()".force_encoding('BINARY'),
-                      "Hal\f\b(")
+    assert_serialized("(\xFE\xFF\x00H\x00a\x00l\x00\f\x00\b\x00\\()".b, "Hal\f\b(")
   end
 
   it "serializes time like objects" do

data/test/hexapdf/test_tokenizer.rb

@@ -38,7 +38,7 @@ describe HexaPDF::Tokenizer do
   end
 
   it "next_token: should not fail for strings due to use of an internal buffer" do
-    create_tokenizer("(" << ("a" * 8189) << "\\006)")
+    create_tokenizer("(" + ("a" * 8189) + "\\006)")
     assert_equal("a" * 8189 << "\x06", @tokenizer.next_token)
   end
 

data/test/hexapdf/test_writer.rb

@@ -98,7 +98,7 @@ describe HexaPDF::Writer do
   def assert_document_conversion(input_io)
     document = HexaPDF::Document.new(io: input_io)
     document.trailer.info[:Producer] = "unknown"
-    output_io = StringIO.new(''.force_encoding(Encoding::BINARY))
+    output_io = StringIO.new(''.b)
     start_xref_offset, xref_section = HexaPDF::Writer.write(document, output_io)
     assert_kind_of(HexaPDF::XRefSection, xref_section)
     assert_kind_of(Integer, start_xref_offset)
@@ -206,7 +206,7 @@ describe HexaPDF::Writer do
 
   it "doesn't create an xref stream if one was just used for an XRefStm entry" do
     # The following document's structure is built like a typical MS Word created PDF
-    input = StringIO.new(<<~EOF.force_encoding(Encoding::BINARY))
+    input = StringIO.new(<<~EOF.b)
       %PDF-1.2
       %\xCF\xEC\xFF\xE8\xD7\xCB\xCD
       1 0 obj

data/test/hexapdf/type/acro_form/test_form.rb

@@ -494,6 +494,14 @@ describe HexaPDF::Type::AcroForm::Form do
       @acro_form.recalculate_fields
       assert_equal("10", @text3.field_value)
     end
+
+    it "ensures that only entries in /CO that are actually fields are used" do
+      @text1.field_value = "10"
+      @text3.set_calculate_action(:sfn, fields: 'text1')
+      @acro_form[:CO] = [nil, 5, [:some, :array], @doc.pages.root, @text3]
+      @acro_form.recalculate_fields
+      assert_equal("10", @text3.field_value)
+    end
   end
 
   describe "perform_validation" do

data/test/hexapdf/type/test_image.rb

@@ -171,7 +171,7 @@ describe HexaPDF::Type::Image do
 
     def assert_valid_png(filename, original = nil)
       if PNG_CHECK_AVAILABLE
-        result = `pngcheck -q #{filename}`
+        result = `pngcheck -q #{filename} 2>/dev/null`
         assert(result.empty?, "pngcheck error: #{result}")
       else
         skip("Skipping PNG output validity check because pngcheck executable is missing")

data/test/hexapdf/type/test_page_tree_node.rb

@@ -326,9 +326,9 @@ describe HexaPDF::Type::PageTreeNode do
       assert(@root.validate(auto_correct: false) {|m, _| p m })
 
       @doc.delete(@pages[3])
-      refute(@root.validate(auto_correct: false)) do |msg, _|
+      refute(@root.validate(auto_correct: false) do |msg, _|
         assert_match(/invalid object/i, msg)
-      end
+      end)
       assert(@root.validate)
       assert_equal(2, @kid12[:Count])
       assert_equal([@pages[2], @pages[4]], @kid12[:Kids].value)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: hexapdf
 version: !ruby/object:Gem::Version
-  version: 1.0.1
+  version: 1.0.3
 platform: ruby
 authors:
 - Thomas Leitner
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-11-04 00:00:00.000000000 Z
+date: 2024-12-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: cmdparse
@@ -500,6 +500,7 @@ files:
 - lib/hexapdf/type/annotations/widget.rb
 - lib/hexapdf/type/catalog.rb
 - lib/hexapdf/type/cid_font.rb
+- lib/hexapdf/type/cmap.rb
 - lib/hexapdf/type/embedded_file.rb
 - lib/hexapdf/type/file_specification.rb
 - lib/hexapdf/type/font.rb