hexapdf 0.47.0 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 15f4c7590b5f2ce321519ac0b4871971c12073a9d4b0df36ab2f2e3c156f09ab
-  data.tar.gz: 76dac6196e06e80fd88dade3f831b7744c2b763f004d3c389d3efebcace3be82
+  metadata.gz: 2889ba1d03e2c351efd694b1583063023fff97c0da636ff5103f88538255735c
+  data.tar.gz: 6fb4727db05900e8fccba2ad4e093d1092e17305e5b5616ded97a76cf835673c
 SHA512:
-  metadata.gz: 8ea19ed17370cad1a1fa48a7e0cb85c16e3ff62b344d2a9a90c42d2ac98d5ce5f75c356facf6bb8276822db460e2d9f912f523783c82b3539200e33f9de9f383
-  data.tar.gz: bdf2d93feade9f0654366bbf89711b670cbd03ee88b81f197f756c2032305f9ee7b9265973f31c5a4e18e7afd3e4f9dfd08b46a0483502b896774494294c111a
+  metadata.gz: 00be8ed2c306a88e5bfc0eada97a7e6bf802ec269e832bb21b3521d4077b18ecad11946ddc6f8a6d575820e66339059e59ba2c4cdd2b74d6c7d6defd0f2f5256
+  data.tar.gz: 94c6a8178ead2a986921b72b07ef5dc388a5fa6a67945573eec921db30c9940d241d3f47591c8fbbf9bdcf313df0dda536f0fc78e0e946e27dfa3bc13dad9a28

data/CHANGELOG.md

@@ -1,3 +1,37 @@
+## 1.0.0 - 2024-10-26
+
+### Added
+
+* [HexaPDF::Task::MergeAcroForm] for merging AcroForm information for imported
+  pages
+* [HexaPDF::Document#write_to_string] and [HexaPDF::Composer#write_to_string]
+  for easily writing a document to a String
+* [HexaPDF::Font::CMap::Writer#create_cid_cmap] for creating a character code to
+  CID CMap file
+
+### Changed
+
+* [HexaPDF::Type::AcroForm::Form] text-like field creation methods to always set
+  a default appearance string and the quadding
+* Convenience methods for accessing resources to not add the deprecated /ProcSet
+  entry by default
+* [HexaPDF::DigitalSignature::CMSHandler] to add informational output regarding
+  the certificate chain on verification
+* Validation of [HexaPDF::Type::FontType1] to ensure correct /Encoding value
+
+### Fixed
+
+* [HexaPDF::DigitalSignature::Signature#signed_data] to work for invalid offsets
+* [HexaPDF::DigitalSignature::Signing::DefaultHandler] to update the document's
+  version to 2.0 when using PAdES
+* Parsing of invalid `)` character in PDF objects and content streams
+* Handling of files that contain stream length values that are indirect objects
+  that do not exist
+* [HexaPDF::Font::TrueTypeWrapper] to correctly handle the situation when
+  multiple codepoints refer to the same glyph ID
+* [HexaPDF::Type::Page#contents] to handle null values in /Contents array
+
+
 ## 0.47.0 - 2024-09-07
 
 ### Added
@@ -53,7 +87,7 @@
   signatures
 * [HexaPDF::DigitalSignature::CMSHandler#signing_time] to use time from an
   embedded timestamp authority signature if possible
-* [HexaPDF::Layout::Box#fit] to return success for boxes with content
+* HexaPDF::Layout::Box#fit to return success for boxes with content
   width/height of zero
 * [HexaPDF::Importer::copy] to optionally allow copying the catalog and page
   tree nodes
@@ -61,7 +95,7 @@
 ### Fixed
 
 * Setting of correct x-position in fit result for boxes with flow positioning
-* [HexaPDF::Layout::ListBox#fit] to respect the set height
+* HexaPDF::Layout::ListBox#fit to respect the set height
 * CLI command `hexapdf inspect` to work in case of missing Unicde mappings
 * [HexaPDF::Type::AcroForm::Form#delete_field] to correctly work for fields with
   an embedded widget
@@ -80,7 +114,7 @@
 
 ### Changed
 
-* [HexaPDF::Layout::Box#fit] to set width/height correctly for boxes with
+* HexaPDF::Layout::Box#fit to set width/height correctly for boxes with
   position `:flow`
 
 ### Fixed
@@ -126,9 +160,9 @@
 
 ### Fixed
 
-* [HexaPDF::Layout::TextBox#fit] to correctly calculate width in case of flowing
+* HexaPDF::Layout::TextBox#fit to correctly calculate width in case of flowing
   text around other boxes
-* [HexaPDF::Layout::TextBox#draw] to correctly draw border, background... on
+* HexaPDF::Layout::TextBox#draw to correctly draw border, background... on
   boxes using position 'flow'
 * Comparison of Hash with [HexaPDF::Dictionary] objects by implementing
   `#to_hash`
@@ -182,7 +216,7 @@
   JavaScript action that formats the field's value
 * [HexaPDF::Type::AcroForm::TextField#set_calculate_action] for setting a
   JavaScript action that calculates the field's value
-* [HexaPDF::Type::AcroForm#recalculate_fields] for recalculating fields
+* [HexaPDF::Type::AcroForm::Form#recalculate_fields] for recalculating fields
 
 ### Changed
 
@@ -239,7 +273,7 @@
 
 ### Changed
 
-* [HexaPDF::Layout::Frame::FitResult#draw] to provide better optional content
+* HexaPDF::Layout::Frame::FitResult#draw to provide better optional content
   group names
 
 ### Fixed
@@ -318,8 +352,8 @@
 
 ### Changed
 
-* [HexaPDF::Layout::Frame::FitResult#draw] to allow drawing at an offset
-* [HexaPDF::Layout::Box#fit] to delegate the actual content fitting to the
+* HexaPDF::Layout::Frame::FitResult#draw to allow drawing at an offset
+* HexaPDF::Layout::Box#fit to delegate the actual content fitting to the
   `#fit_content` method
 * [HexaPDF::Document::Layout#box] to allow using the block as drawing block for
   the base box class
@@ -396,8 +430,8 @@
 
 ### Fixed
 
-* [HexaPDF::Layout::ColumnBox#fit] to correctly take initial height into account
-* [HexaPDF::Layout::ColumnBox#fit] to ensure correct results in case the
+* HexaPDF::Layout::ColumnBox#fit to correctly take initial height into account
+* HexaPDF::Layout::ColumnBox#fit to ensure correct results in case the
   requested dimensions are larger than the current region
 * [HexaPDF::Document::Layout#formatted_text_box] to correctly handle properties
 * [HexaPDF::Layout::Frame#fit] to raise an error if an invalid value for the
@@ -443,7 +477,7 @@
   context argument (a page or Form XObject instance)
 * [HexaPDF::Layout::ListBox] to use its 'fill_color' style property for the item
   marker color
-* [HexaPDF::Layout::Frame::FitResult#draw] to use optional content groups for
+* HexaPDF::Layout::Frame::FitResult#draw to use optional content groups for
   debug output
 
 ### Fixed
@@ -452,7 +486,7 @@
   default range starting at page 1
 * [HexaPDF::Type::Page#flatten_annotations] to correctly handle scaled
   appearances
-* Using an unknown style name in [HexaPDF:Document::Layout] method by providing
+* Using an unknown style name in [HexaPDF::Document::Layout] method by providing
   a useful error message
 * [HexaPDF::Layout::Box::new] to ensure that the properties attribute is always
   a hash
@@ -513,7 +547,7 @@
   final box positions into account
 * [HexaPDF::Content::Canvas#text] to set the leading only when multiple lines
   are drawn
-* [HexaPDF::Layout::TextBox#split] to use float comparison
+* HexaPDF::Layout::TextBox#split to use float comparison
 * Validation of standard encryption dictionary to auto-correct invalid /U and /O
   fields in case they are padded with zeros
 * [HexaPDF::Document#wrap] handling of sub-type mapping in case of missing type
@@ -930,7 +964,7 @@
 * [HexaPDF::Layout::WidthFromPolygon] to work correctly in case of very small
   floating point errors
 * HexaPDF::Layout::TextFragment#inspect to work in case of interspersed numbers
-* [HexaPDF::Layout::TextBox#split] to work for position :flow when box is wider
+* HexaPDF::Layout::TextBox#split to work for position :flow when box is wider
   than the initial available width
 * [HexaPDF::Layout::Frame#fit] to create minimally sized mask rectangles
 * [HexaPDF::Content::GraphicObject::Geom2D] to close the path when drawing
@@ -1866,7 +1900,7 @@
   objects
 * [HexaPDF::Revision#each_modified_object] for iterating over all modified
   objects of a revision
-* [HexaPDF::Layout::Box#split] and [HexaPDF::Layout::TextBox#split] for
+* [HexaPDF::Layout::Box#split] and HexaPDF::Layout::TextBox#split for
   splitting a box into two parts
 * [HexaPDF::Layout::Frame#full?] for testing whether the frame has any space
   left

data/lib/hexapdf/composer.rb

@@ -231,6 +231,13 @@ module HexaPDF
       @document.write(output, optimize: optimize, **options)
     end
 
+    # Writes the created PDF document to a string and returns that string.
+    #
+    # See HexaPDF::Document#write for details.
+    def write_to_string(optimize: true, **options)
+      @document.write_to_string(optimize: optimize, **options)
+    end
+
     # :call-seq:
     #    composer.style(name)                              -> style
     #    composer.style(name, base: :base, **properties)   -> style

data/lib/hexapdf/configuration.rb

@@ -598,6 +598,7 @@ module HexaPDF
                         optimize: 'HexaPDF::Task::Optimize',
                         dereference: 'HexaPDF::Task::Dereference',
                         pdfa: 'HexaPDF::Task::PDFA',
+                        merge_acro_form: 'HexaPDF::Task::MergeAcroForm',
                       })
 
   # The global configuration object, providing the following options:
@@ -720,6 +721,7 @@ module HexaPDF
                         Metadata: 'HexaPDF::Type::Metadata',
                         OutputIntent: 'HexaPDF::Type::OutputIntent',
                         XXDestOutputProfileRef: 'HexaPDF::Type::OutputIntent::DestOutputProfileRef',
+                        ExData: 'HexaPDF::Type::Annotations::MarkupAnnotation::ExData',
                       },
                       'object.subtype_map' => {
                         nil => {

data/lib/hexapdf/content/parser.rb

@@ -112,7 +112,9 @@ module HexaPDF
         elsif byte == 93 # ]
           @ss.pos += 1
           TOKEN_ARRAY_END
-        elsif byte == 123 || byte == 125 # { }
+        elsif byte == 41 # )
+          raise HexaPDF::MalformedPDFError.new("Delimiter ')' found at invalid position", pos: pos)
+        elsif byte == 123 || byte == 125 # { } )
           Token.new(@ss.get_byte)
         elsif byte == 37 # %
           unless @ss.skip_until(/(?=[\r\n])/)

data/lib/hexapdf/digital_signature/cms_handler.rb

@@ -155,6 +155,19 @@ module HexaPDF
           result.log(:error, "Signature verification failed")
         end
 
+        certs = [signer_certificate]
+        cur_cert = certs.first
+        while true
+          cur_cert = certificate_chain.find {|cert| cert.subject == cur_cert.issuer }
+          if cur_cert && !certs.include?(cur_cert)
+            certs << cur_cert
+          else
+            break
+          end
+        end
+        cert_subjects = certs.map {|cert| cert.subject.to_a.assoc("CN")&.[](1) }
+        result.log(:info, "Certificate chain: #{cert_subjects.join(" -> ")}")
+
         result
       end
 

data/lib/hexapdf/digital_signature/signature.rb

@@ -211,7 +211,7 @@ module HexaPDF
         data = ''.b
         self[:ByteRange]&.each_slice(2) do |offset, length|
           io.pos = offset
-          data << io.read(length)
+          data << io.read(length).to_s
         end
         data
       end

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

@@ -289,6 +289,7 @@ module HexaPDF
           signature[:Location] = location if location
           signature[:ContactInfo] = contact_info if contact_info
           signature[:Prop_Build] = {App: {Name: :HexaPDF, REx: HexaPDF::VERSION}}
+          signature.document.version = '2.0' if signature_type == :pades
 
           if doc_mdp_permissions
             doc = signature.document

data/lib/hexapdf/document.rb

@@ -724,10 +724,12 @@ module HexaPDF
     end
 
     # :call-seq:
-    #   doc.write(filename, incremental: false, validate: true, update_fields: true, optimize: false)
-    #   doc.write(io, incremental: false, validate: true, update_fields: true, optimize: false)
+    #   doc.write(filename, incremental: false, validate: true, update_fields: true, optimize: false) -> [start_xref, section]
+    #   doc.write(io, incremental: false, validate: true, update_fields: true, optimize: false) -> [start_xref, section]
     #
-    # Writes the document to the given file (in case +io+ is a String) or IO stream.
+    # Writes the document to the given file (in case +io+ is a String) or IO stream. Returns the
+    # file position of the start of the last cross-reference section and the last XRefSection object
+    # written.
     #
     # Before the document is written, it is validated using #validate and an error is raised if the
     # document is not valid. However, this step can be skipped if needed.
@@ -784,6 +786,15 @@ module HexaPDF
       end
     end
 
+    # Writes the document to a string and returns the string.
+    #
+    # See #write for further information and details on the available arguments.
+    def write_to_string(**args)
+      io = StringIO.new(''.b)
+      write(io)
+      io.string
+    end
+
     def inspect #:nodoc:
       "<#{self.class.name}:#{object_id}>"
     end

data/lib/hexapdf/font/cmap/writer.rb

@@ -40,9 +40,7 @@ module HexaPDF
   module Font
     class CMap
 
-      # Creates a CMap file.
-      #
-      # Currently only ToUnicode CMaps are supported.
+      # Creates a CMap file, either a ToUnicode CMap or a CID CMap.
       class Writer
 
         # Maximum number of entries in one section.
@@ -74,6 +72,28 @@ module HexaPDF
           to_unicode_template % result.chop!
         end
 
+        # Returns a CID CMap for the given input code to CID mapping which needs to be sorted by
+        # input codes.
+        #
+        # Note that the returned CMap always uses a 16-bit input code space!
+        def create_cid_cmap(mapping)
+          return cid_template % '' if mapping.empty?
+
+          chars, ranges = compute_section_entries(mapping)
+
+          result = create_sections("cidchar", chars.size / 2) do |index|
+            index *= 2
+            sprintf("<%04X>", chars[index]) << " #{chars[index + 1]}\n"
+          end
+
+          result << create_sections("cidrange", ranges.size / 3) do |index|
+            index *= 3
+            sprintf("<%04X><%04X>", ranges[index], ranges[index + 1]) << " #{ranges[index + 2]}\n"
+          end
+
+          cid_template % result.chop!
+        end
+
         private
 
         # Computes the entries for the "char" and "range" sections based on the given mapping.
@@ -146,7 +166,7 @@ module HexaPDF
           result
         end
 
-        # Returns the CMap file template for a ToUnicode CMap.
+        # Returns the template for a ToUnicode CMap.
         def to_unicode_template
           <<~TEMPLATE
             /CIDInit /ProcSet findresource begin
@@ -170,6 +190,40 @@ module HexaPDF
           TEMPLATE
         end
 
+        # Returns the template for a CID CMap.
+        def cid_template
+          <<~TEMPLATE
+            %%!PS-Adobe-3.0 Resource-CMap
+            %%%%DocumentNeededResources: ProcSet (CIDInit)
+            %%%%IncludeResource: ProcSet (CIDInit)
+            %%%%BeginResource: CMap (Custom)
+            %%%%Title: (Custom Adobe Identity 0)
+            %%%%Version: 1
+            /CIDInit /ProcSet findresource begin
+            12 dict begin
+            begincmap
+            /CIDSystemInfo 3 dict dup begin
+              /Registry (Adobe) def
+              /Ordering (Identity) def
+              /Supplement 0 def
+            end def
+            /CMapName /Custom def
+            /CMapType 1 def
+            /CMapVersion 1 def
+            /WMode 0 def
+            1 begincodespacerange
+            <0000> <FFFF>
+            endcodespacerange
+            %s
+            endcmap
+            CMapName currentdict /CMap defineresource pop
+            end
+            end
+            %%%%EndResource
+            %%%%EOF
+          TEMPLATE
+        end
+
       end
 
     end

data/lib/hexapdf/font/cmap.rb

@@ -85,6 +85,13 @@ module HexaPDF
         Writer.new.create_to_unicode_cmap(mapping)
       end
 
+      # Returns a string containing a CID CMap that represents the given code to CID mapping.
+      #
+      # See: Writer#create_cid_cmap
+      def self.create_cid_cmap(mapping)
+        Writer.new.create_cid_cmap(mapping)
+      end
+
       # The registry part of the CMap version.
       attr_accessor :registry
 

data/lib/hexapdf/font/true_type_wrapper.rb

@@ -57,6 +57,10 @@ module HexaPDF
     class TrueTypeWrapper
 
       # Represents a single glyph of the wrapped font.
+      #
+      # Since some characters/strings may be mapped to the same glyph id by the font's builtin cmap
+      # table, it is possible that different Glyph instances with the same #id but different #str
+      # exist.
       class Glyph
 
         # The associated TrueTypeWrapper object.
@@ -152,6 +156,7 @@ module HexaPDF
         @id_to_glyph = {}
         @codepoint_to_glyph = {}
         @encoded_glyphs = {}
+        @last_char_code = 0
       end
 
       # Returns the type of the font, i.e. :TrueType.
@@ -179,14 +184,15 @@ module HexaPDF
         !@subsetter.nil?
       end
 
-      # Returns a Glyph object for the given glyph ID.
+      # Returns a Glyph object for the given glyph ID and +str+ pair.
       #
-      # The optional argument +str+ should be the string representation of the glyph. Only use it if
-      # it is known,
+      # The optional argument +str+ should be the string representation of the glyph. It is possible
+      # that multiple strings map to the same glyph (e.g. hyphen and soft-hyphen could be
+      # represented by the same glyph).
       #
       # Note: Although this method is public, it should normally not be used by application code!
       def glyph(id, str = nil)
-        @id_to_glyph[id] ||=
+        @id_to_glyph[[id, str]] ||=
           if id >= 0 && id < @wrapped_font[:maxp].num_glyphs
             Glyph.new(self, id, str || (+'' << (@cmap.gid_to_code(id) || 0xFFFD)))
           else
@@ -228,14 +234,12 @@ module HexaPDF
 
       # Encodes the glyph and returns the code string.
       def encode(glyph)
-        (@encoded_glyphs[glyph.id] ||=
+        (@encoded_glyphs[glyph] ||=
           begin
             raise HexaPDF::MissingGlyphError.new(glyph) if glyph.kind_of?(InvalidGlyph)
-            if @subsetter
-              [[@subsetter.use_glyph(glyph.id)].pack('n'), glyph]
-            else
-              [[glyph.id].pack('n'), glyph]
-            end
+            @subsetter.use_glyph(glyph.id) if @subsetter
+            @last_char_code += 1
+            [[@last_char_code].pack('n'), @last_char_code]
           end)[0]
       end
 
@@ -286,7 +290,7 @@ module HexaPDF
                                                  Supplement: 0},
                                  CIDToGIDMap: :Identity})
         dict = document.add({Type: :Font, Subtype: :Type0, BaseFont: cid_font[:BaseFont],
-                             Encoding: :'Identity-H', DescendantFonts: [cid_font]})
+                             DescendantFonts: [cid_font]})
         dict.font_wrapper = self
 
         document.register_listener(:complete_objects) do
@@ -294,6 +298,7 @@ module HexaPDF
           embed_font(dict, document)
           complete_width_information(dict)
           create_to_unicode_cmap(dict, document)
+          add_encoding_information_cmap(dict, document)
         end
 
         dict
@@ -306,7 +311,7 @@ module HexaPDF
         return unless @subsetter
 
         tag = +''
-        data = @encoded_glyphs.each_with_object(''.b) {|(id, v), s| s << id.to_s << v[0] }
+        data = @encoded_glyphs.each_with_object(''.b) {|(g, v), s| s << g.id.to_s << v[0] }
         hash = Digest::MD5.hexdigest(data << @wrapped_font.font_name).to_i(16)
         while hash != 0 && tag.length < 6
           hash, mod = hash.divmod(UPPERCASE_LETTERS.length)
@@ -336,8 +341,8 @@ module HexaPDF
       # Adds the /DW and /W fields to the CIDFont dictionary.
       def complete_width_information(dict)
         default_width = glyph(3, " ").width.to_i
-        widths = @encoded_glyphs.reject {|_, v| v[1].width == default_width }.map do |id, v|
-          [(@subsetter ? @subsetter.subset_glyph_id(id) : id), v[1].width]
+        widths = @encoded_glyphs.reject {|g, _| g.width == default_width }.map do |g, _|
+          [(@subsetter ? @subsetter.subset_glyph_id(g.id) : g.id), g.width]
         end.sort!
         dict[:DescendantFonts].first.set_widths(widths, default_width: default_width)
       end
@@ -346,9 +351,10 @@ module HexaPDF
       # correctly.
       def create_to_unicode_cmap(dict, document)
         stream = HexaPDF::StreamData.new do
-          mapping = @encoded_glyphs.keys.map! do |id|
+          mapping = @encoded_glyphs.map do |glyph, (_, char_code)|
             # Using 0xFFFD as mentioned in Adobe #5411, last line before section 1.5
-            [(@subsetter ? @subsetter.subset_glyph_id(id) : id), @cmap.gid_to_code(id) || 0xFFFD]
+            # TODO: glyph.str assumed to consist of single char, No support for multiple chars
+            [char_code, glyph.str.ord || 0xFFFD]
           end.sort_by!(&:first)
           HexaPDF::Font::CMap.create_to_unicode_cmap(mapping)
         end
@@ -357,6 +363,25 @@ module HexaPDF
         dict[:ToUnicode] = stream_obj
       end
 
+      # Adds the /Encoding entry to the +dict+.
+      #
+      # This can either be the identity mapping or, if some Unicode codepoints are mapped to the
+      # same glyph, a custom CMap.
+      def add_encoding_information_cmap(dict, document)
+        mapping = @encoded_glyphs.map do |glyph, (_, char_code)|
+          # Using 0xFFFD as mentioned in Adobe #5411, last line before section 1.5
+          [char_code, (@subsetter ? @subsetter.subset_glyph_id(glyph.id) : glyph.id)]
+        end.sort_by!(&:first)
+        if mapping.all? {|char_code, cid| char_code == cid }
+          dict[:Encoding] = :'Identity-H'
+        else
+          stream = HexaPDF::StreamData.new { HexaPDF::Font::CMap.create_cid_cmap(mapping) }
+          stream_obj = document.add({}, stream: stream)
+          stream_obj.set_filter(:FlateDecode)
+          dict[:Encoding] = stream_obj
+        end
+      end
+
     end
 
   end

data/lib/hexapdf/layout/text_fragment.rb

@@ -235,6 +235,7 @@ module HexaPDF
           end
         end
 
+        in_text_object = (canvas.graphics_object == :text)
         canvas.begin_text
         tlm = canvas.graphics_state.tlm
         tx = x - tlm.e
@@ -248,7 +249,7 @@ module HexaPDF
         elsif ty.abs < PRECISION
           canvas.move_text_cursor(offset: [tx, 0], absolute: false)
         else
-          canvas.move_text_cursor(offset: [x, y])
+          canvas.move_text_cursor(offset: [x, y], absolute: in_text_object)
         end
         canvas.show_glyphs_only(items)
 

data/lib/hexapdf/object.rb

@@ -372,7 +372,7 @@ module HexaPDF
 
     # Computes the hash value based on the object and generation numbers.
     def hash
-      oid.hash ^ gen.hash
+      [oid, gen].hash
     end
 
     def inspect #:nodoc:

data/lib/hexapdf/parser.rb

@@ -184,7 +184,7 @@ module HexaPDF
         length = if object[:Length].kind_of?(Integer)
                    object[:Length]
                  elsif object[:Length].kind_of?(Reference)
-                   @document.deref(object[:Length]).value
+                   @document.deref(object[:Length])&.value || 0
                  else
                    0
                  end

data/lib/hexapdf/reference.rb

@@ -87,7 +87,7 @@ module HexaPDF
 
     # Computes the hash value based on the object and generation numbers.
     def hash
-      oid.hash ^ gen.hash
+      [oid, gen].hash
     end
 
     # Returns the object identifier as "oid,gen".