hexapdf 0.14.4 → 0.15.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 958692ab2c53f74fe599c0ba8c9c046aa41b38d2bf840a47dec8f0e258fd86e0
-  data.tar.gz: b41d46ccb39d36d351cc143ba0afc145e785307b2a7ae90bc0f32d1ab76949af
+  metadata.gz: 6901d1281fa7f0585e2fe02b27985c9b7ff26770015902566c72ea62f5398e10
+  data.tar.gz: 4b1a82d17d4d1144b47dbb713552bb5e977896b94210a54c7b83871399d393ac
 SHA512:
-  metadata.gz: c16e231aeeb12b55daf75a28a8e3918f6807127257655f42d1f3433c76cb25f0ea42daafc8dd20bd37099f9ef5f6f2a6a3e3b2468acf000c041452a32908e1ee
-  data.tar.gz: a9a1fff7c7ff699c2b48333d89fae1aa67cd7ce61003845f76e4855cfc2f2ad5969ae668359091cd3fa225ea9a8b99fb9883e28b07fe6fcd985c7f83b842969d
+  metadata.gz: 1d4acb6e9f867195e998b3fd900102013a8d4b74c576f3c3243225a515bbcf2be8b62852db95cbcd9213ec06334b174fba4db406dfb8e228083d9a527eb8a5a1
+  data.tar.gz: 3306a678655f59c35b3349cd247606ca7e45a34e033dd9b9b3bad33c20a3fda95ba07bff88acdb7c5666c23b1ab63d293963e68db7e12371c56106645df7d9bb

data/CHANGELOG.md

@@ -1,3 +1,71 @@
+## 0.15.4 - 2021-05-27
+
+### Fixed
+
+* [HexaPDF::Type::Annotation#appearance] to handle cases where there is
+  no valid appearance stream
+
+
+## 0.15.3 - 2021-05-01
+
+### Fixed
+
+* Handling of general (not document-level), unencrypted metadata streams
+
+
+## 0.15.2 - 2021-05-01
+
+### Fixed
+
+* Handling of unencrypted metadata streams
+
+
+## 0.15.1 - 2021-04-15
+
+### Fixed
+
+* Potential division by zero when calculating the scaling for XObjects
+* Handling of XObjects with a width or height of zero when drawing on canvas
+
+
+## 0.15.0 - 2021-04-12
+
+### Added
+
+* [HexaPDF::Type::Page#flatten_annotations] for flattening the annotations of a
+  page
+* [HexaPDF::Type::AcroForm::Form#flatten] for flattening interactive forms
+* [HexaPDF::Revision#update] for updating the stored wrapper class of a PDF
+  object
+* [HexaPDF::Type::AcroForm::SignatureField] for working with AcroForm signature
+  fields
+* Support for form field flattening to the `hexapdf form` CLI command
+
+### Changed
+
+* **Breaking change**: Overhauled the interface for accessing appearances of
+  annotations to make it more convenient
+* Validation of [HexaPDF::Type::FontDescriptor] to delete invalid `/FontWeight`
+  value
+* [HexaPDF::MalformedPDFError#pos] an accessor instead of a reader and update
+  the exception message
+* Configuration option 'acro_form.fallback_font' to allow a callable object for
+  more advanced fallback font handling
+
+### Fixed
+
+* [HexaPDF::Type::Annotations::Widget#background_color] to correctly handle
+  empty background color arrays
+* [HexaPDF::Type::AcroForm::Field#delete_widget] to update the wrapper object
+  stored in the document in case the widget is embedded
+* Processing of invalid PDF files containing a space,CR,LF combination after
+  the 'stream' keyword
+* Cross-reference stream reconstruction with respect to detection of linearized
+  files
+* Detection of existing appearances for AcroForm push button fields when
+  creating appearances
+
+
 ## 0.14.4 - 2021-02-27
 
 ### Added

data/lib/hexapdf/cli/form.rb

@@ -52,18 +52,26 @@ module HexaPDF
           If the the output file name is not given, all form fields are listed in page order. Use
           the global --verbose option to show additional information like field type and location.
 
-          If the output file name is given, the fields can be interactively filled out. By
-          additionally using the --template option, the data for the fields is read from the given
-          template file instead of the standard input.
+          If the output file name is given, the fields can be filled out interactively, via a
+          template or just flattened by using the respective options. Form field flattening can also
+          be activated in addition to filling out the form. If neither --fill, --template nor
+          --flatten is specified, --fill is implied.
         EOF
 
         options.on("--password PASSWORD", "-p", String,
                    "The password for decryption. Use - for reading from standard input.") do |pwd|
           @password = (pwd == '-' ? read_password : pwd)
         end
+        options.on("--fill", "Fill out the form") do
+          @fill = true
+        end
         options.on("--template TEMPLATE_FILE", "-t TEMPLATE_FILE",
-                   "Use the template file for the field values") do |template|
+                   "Use the template file for the field values (implies --fill)") do |template|
           @template = template
+          @fill = true
+        end
+        options.on('--flatten', 'Flatten the form fields') do
+          @flatten = true
         end
         options.on("--[no-]viewer-override", "Let the PDF viewer override the visual " \
                    "appearance. Default: use setting from input PDF") do |need_appearances|
@@ -75,6 +83,8 @@ module HexaPDF
         end
 
         @password = nil
+        @fill = false
+        @flatten = false
         @template = nil
         @need_appearances = nil
         @incremental = true
@@ -82,16 +92,28 @@ module HexaPDF
 
       def execute(in_file, out_file = nil) #:nodoc:
         maybe_raise_on_existing_file(out_file) if out_file
+        if (@fill || @flatten) && !out_file
+          raise "Output file missing"
+        end
         with_document(in_file, password: @password, out_file: out_file,
                       incremental: @incremental) do |doc|
           if !doc.acro_form
             raise "This PDF doesn't contain an interactive form"
           elsif out_file
             doc.acro_form[:NeedAppearances] = @need_appearances unless @need_appearances.nil?
-            if @template
-              fill_form_with_template(doc)
-            else
-              fill_form(doc)
+            if @fill || !@flatten
+              if @template
+                fill_form_with_template(doc)
+              else
+                fill_form(doc)
+              end
+            end
+            if @flatten
+              unless doc.acro_form.flatten.empty?
+                $stderr.puts "Warning: Not all form fields could be flattened"
+                doc.catalog.delete(:AcroForm)
+                doc.delete(doc.acro_form)
+              end
             end
           else
             list_form_fields(doc)

data/lib/hexapdf/configuration.rb

@@ -164,9 +164,20 @@ module HexaPDF
   # acro_form.fallback_font::
   #    The font that should be used when a variable text field references a font that cannot be used.
   #
-  #    Can either be the name of a font, like 'Helvetica', or an array consisting of the font name
-  #    and a hash of font options, like ['Helvetica', variant: :italic]. If set to +nil+, the use of
-  #    the fallback font is disabled.
+  #    Can be one of the following:
+  #
+  #    * The name of a font, like 'Helvetica'.
+  #
+  #    * An array consisting of the font name and a hash of font options, like ['Helvetica',
+  #      variant: :italic].
+  #
+  #    * A callable object receiving the field and the font object (or +nil+ if no valid font object
+  #      was found) and which has to return either a font name or an array consisting of the font
+  #      name and a hash of font options. This way the response can be different depending on the
+  #      original font and it would also allow e.g. modifying the configured fonts to add custom
+  #      ones.
+  #
+  #    If set to +nil+, the use of the fallback font is disabled.
   #
   #    Default is 'Helvetica'.
   #
@@ -516,6 +527,9 @@ module HexaPDF
                         XXAcroFormField: 'HexaPDF::Type::AcroForm::Field',
                         XXAppearanceDictionary: 'HexaPDF::Type::Annotation::AppearanceDictionary',
                         Border: 'HexaPDF::Type::Annotation::Border',
+                        SigFieldLock: 'HexaPDF::Type::AcroForm::SignatureField::LockDictionary',
+                        SV: 'HexaPDF::Type::AcroForm::SignatureField::SeedValueDictionary',
+                        SVCert: 'HexaPDF::Type::AcroForm::SignatureField::CertificateSeedValueDictionary',
                       },
                       'object.subtype_map' => {
                         nil => {
@@ -561,6 +575,7 @@ module HexaPDF
                           Tx: 'HexaPDF::Type::AcroForm::TextField',
                           Btn: 'HexaPDF::Type::AcroForm::ButtonField',
                           Ch: 'HexaPDF::Type::AcroForm::ChoiceField',
+                          Sig: 'HexaPDF::Type::AcroForm::SignatureField',
                         },
                       })
 

data/lib/hexapdf/content/canvas.rb

@@ -1260,6 +1260,7 @@ module HexaPDF
         unless obj.kind_of?(HexaPDF::Stream)
           obj = context.document.images.add(obj)
         end
+        return obj if obj.width == 0 || obj.height == 0
 
         width, height = calculate_dimensions(obj.width, obj.height,
                                              rwidth: width, rheight: height)

data/lib/hexapdf/encryption/standard_security_handler.rb

@@ -240,6 +240,22 @@ module HexaPDF
         end
       end
 
+      def decrypt(obj) #:nodoc:
+        if dict[:V] >= 4 && obj.type == :Metadata && obj[:Subtype] == :XML && !dict[:EncryptMetadata]
+          obj
+        else
+          super
+        end
+      end
+
+      def encrypt_stream(obj) #:nodoc
+        if dict[:V] >= 4 && obj.type == :Metadata && obj[:Subtype] == :XML && !dict[:EncryptMetadata]
+          obj.stream_encoder
+        else
+          super
+        end
+      end
+
       private
 
       # Prepares the security handler for use in encrypting the document.

data/lib/hexapdf/error.rb

@@ -43,18 +43,19 @@ module HexaPDF
   class MalformedPDFError < Error
 
     # The byte position in the PDF file where the error occured.
-    attr_reader :pos
+    attr_accessor :pos
 
     # Creates a new malformed PDF error object for the given exception message.
     #
-    # The byte position where the error occured can be given via the +pos+ argument.
+    # The byte position where the error occured can either be given via the +pos+ argument or later
+    # via the #pos accessor but must be set before the exception message is retrieved.
     def initialize(message, pos: nil)
       super(message)
       @pos = pos
     end
 
     def message # :nodoc:
-      "PDF malformed#{pos ? "around position #{pos}" : ''}: #{super}"
+      "PDF malformed around position #{pos}: #{super}"
     end
 
   end

data/lib/hexapdf/parser.rb

@@ -140,11 +140,13 @@ module HexaPDF
           raise_malformed("A stream needs a dictionary, not a(n) #{object.class}", pos: offset)
         end
         tok1 = @tokenizer.next_byte
-        tok2 = @tokenizer.next_byte if tok1 == 13 # 13=CR, 10=LF
+        if tok1 == 32 # space
+          maybe_raise("Keyword stream followed by space instead of LF or CR/LF", pos: @tokenizer.pos)
+          tok1 = @tokenizer.next_byte
+        end
+        tok2 = @tokenizer.next_byte if tok1 == 13 # CR
         if tok1 != 10 && tok1 != 13
-          tok2 = @tokenizer.next_byte
-          maybe_raise("Keyword stream must be followed by LF or CR/LF", pos: @tokenizer.pos,
-                      force: tok1 != 32 || (tok2 != 10 && tok2 != 13)) # 32=space
+          raise_malformed("Keyword stream must be followed by LF or CR/LF", pos: @tokenizer.pos)
         elsif tok1 == 13 && tok2 != 10
           maybe_raise("Keyword stream must be followed by LF or CR/LF, not CR alone",
                       pos: @tokenizer.pos)
@@ -214,7 +216,12 @@ module HexaPDF
         unless obj.respond_to?(:xref_section)
           raise_malformed("Object is not a cross-reference stream", pos: pos)
         end
-        xref_section = obj.xref_section
+        begin
+          xref_section = obj.xref_section
+        rescue MalformedPDFError => e
+          e.pos = pos
+          raise
+        end
         trailer = obj.trailer
         unless xref_section.entry?(obj.oid, obj.gen)
           maybe_raise("Cross-reference stream doesn't contain entry for itself", pos: pos)
@@ -401,6 +408,7 @@ module HexaPDF
 
       xref = XRefSection.new
       @tokenizer.pos = 0
+      linearized = nil
       while true
         @tokenizer.skip_whitespace
         pos = @tokenizer.pos
@@ -416,13 +424,17 @@ module HexaPDF
             @tokenizer.pos = next_new_line_pos
           elsif gen.kind_of?(Integer) && tok.kind_of?(Tokenizer::Token) && tok == 'obj'
             xref.add_in_use_entry(token, gen, pos)
+            if linearized.nil?
+              obj = @tokenizer.next_object rescue nil
+              linearized = obj.kind_of?(Hash) && obj.key?(:Linearized)
+            end
             @tokenizer.scan_until(/(?:\n|\r\n?)endobj\b/)
           end
         elsif token.kind_of?(Tokenizer::Token) && token == 'trailer'
           obj = @tokenizer.next_object rescue nil
           # Use last trailer found in case of multiple revisions but use first trailer in case of
           # linearized file.
-          trailer = obj if obj.kind_of?(Hash) && (obj.key?(:Prev) || trailer.nil?)
+          trailer = obj if obj.kind_of?(Hash) && (!linearized || trailer.nil?)
         elsif token == Tokenizer::NO_MORE_TOKENS
           break
         else

data/lib/hexapdf/revision.rb

@@ -158,6 +158,22 @@ module HexaPDF
       add_without_check(obj)
     end
 
+    # :call-seq:
+    #   revision.update(obj)   -> obj or nil
+    #
+    # Updates the stored object to point to the given HexaPDF::Object wrapper, returning the object
+    # if successful or +nil+ otherwise.
+    #
+    # If +obj+ isn't stored in this revision or the stored object doesn't contain the same
+    # HexaPDF::PDFData object as the given object, nothing is done.
+    #
+    # This method should only be used if the wrong wrapper class is stored (e.g. because
+    # auto-detection didn't or couldn't work correctly) and thus needs correction.
+    def update(obj)
+      return nil if object(obj)&.data != obj.data
+      add_without_check(obj)
+    end
+
     # :call-seq:
     #   revision.delete(ref, mark_as_free: true)
     #   revision.delete(oid, mark_as_free: true)

data/lib/hexapdf/type/acro_form.rb

@@ -48,6 +48,7 @@ module HexaPDF
       autoload(:TextField, 'hexapdf/type/acro_form/text_field')
       autoload(:ButtonField, 'hexapdf/type/acro_form/button_field')
       autoload(:ChoiceField, 'hexapdf/type/acro_form/choice_field')
+      autoload(:SignatureField, 'hexapdf/type/acro_form/signature_field')
 
       autoload(:AppearanceGenerator, 'hexapdf/type/acro_form/appearance_generator')
 

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

@@ -120,7 +120,7 @@ module HexaPDF
         #   widget.marker_style(style: :cross)
         #   # => no visible rectangle, gray background, cross mark when checked
         def create_check_box_appearances
-          unless @widget.appearance&.normal_appearance&.value&.size == 2
+          unless @widget.appearance_dict&.normal_appearance&.value&.size == 2
             raise HexaPDF::Error, "Widget of check box doesn't define name for on state"
           end
           border_style = @widget.border_style
@@ -128,11 +128,11 @@ module HexaPDF
 
           rect = update_widget(@field[:V], border_width)
 
-          off_form = @widget.appearance.normal_appearance[:Off] =
+          off_form = @widget.appearance_dict.normal_appearance[:Off] =
             @document.add({Type: :XObject, Subtype: :Form, BBox: [0, 0, rect.width, rect.height]})
           apply_background_and_border(border_style, off_form.canvas)
 
-          on_form = @widget.appearance.normal_appearance[@field.check_box_on_name] =
+          on_form = @widget.appearance_dict.normal_appearance[@field.check_box_on_name] =
             @document.add({Type: :XObject, Subtype: :Form, BBox: [0, 0, rect.width, rect.height]})
           canvas = on_form.canvas
           apply_background_and_border(border_style, canvas)
@@ -169,22 +169,22 @@ module HexaPDF
         #   widget.marker_style(style: :circle, size: 0, color: 0)
         #   # => default appearance
         def create_radio_button_appearances
-          unless @widget.appearance&.normal_appearance&.value&.size == 2
+          unless @widget.appearance_dict&.normal_appearance&.value&.size == 2
             raise HexaPDF::Error, "Widget of radio button doesn't define unique name for on state"
           end
 
-          on_name = (@widget.appearance.normal_appearance.value.keys - [:Off]).first
+          on_name = (@widget.appearance_dict.normal_appearance.value.keys - [:Off]).first
           border_style = @widget.border_style
           marker_style = @widget.marker_style
 
           rect = update_widget(@field[:V] == on_name ? on_name : :Off, border_style.width)
 
-          off_form = @widget.appearance.normal_appearance[:Off] =
+          off_form = @widget.appearance_dict.normal_appearance[:Off] =
             @document.add({Type: :XObject, Subtype: :Form, BBox: [0, 0, rect.width, rect.height]})
           apply_background_and_border(border_style, off_form.canvas,
                                       circular: marker_style.style == :circle)
 
-          on_form = @widget.appearance.normal_appearance[on_name] =
+          on_form = @widget.appearance_dict.normal_appearance[on_name] =
             @document.add({Type: :XObject, Subtype: :Form, BBox: [0, 0, rect.width, rect.height]})
           canvas = on_form.canvas
           apply_background_and_border(border_style, canvas,
@@ -219,17 +219,8 @@ module HexaPDF
         #
         # Note: Multiline, comb and rich text fields are currently not supported!
         def create_text_appearances
-          font_name, font_size = @field.parse_default_appearance_string
           default_resources = @document.acro_form.default_resources
-          font = default_resources.font(font_name).font_wrapper rescue nil
-          unless font
-            fallback_font_name, fallback_font_options = @document.config['acro_form.fallback_font']
-            if fallback_font_name
-              font = @document.fonts.add(fallback_font_name, **(fallback_font_options || {}))
-            else
-              raise(HexaPDF::Error, "Font #{font_name} of the AcroForm's default resources not usable")
-            end
-          end
+          font, font_size = retrieve_font_information(default_resources)
           style = HexaPDF::Layout::Style.new(font: font)
           border_style = @widget.border_style
           padding = [1, border_style.width].max
@@ -482,6 +473,27 @@ module HexaPDF
           end
         end
 
+        # Returns the font wrapper and font size to be used for a variable text field.
+        def retrieve_font_information(resources)
+          font_name, font_size = @field.parse_default_appearance_string
+          font_object = resources.font(font_name) rescue nil
+          font = font_object&.font_wrapper
+          unless font
+            fallback_font = @document.config['acro_form.fallback_font']
+            fallback_font_name, fallback_font_options = if fallback_font.respond_to?(:call)
+                                                          fallback_font.call(@field, font_object)
+                                                        else
+                                                          fallback_font
+                                                        end
+            if fallback_font_name
+              font = @document.fonts.add(fallback_font_name, **(fallback_font_options || {}))
+            else
+              raise(HexaPDF::Error, "Font #{font_name} of the AcroForm's default resources not usable")
+            end
+          end
+          [font, font_size]
+        end
+
         # Calculates the font size for text fields based on the font and font size of the default
         # appearance string, the annotation rectangle and the border style.
         def calculate_font_size(font, font_size, rect, border_style)

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

@@ -184,7 +184,7 @@ module HexaPDF
         #
         # Defaults to :Yes if no other name could be determined.
         def check_box_on_name
-          each_widget.to_a.first&.appearance&.normal_appearance&.value&.each_key&.
+          each_widget.to_a.first&.appearance_dict&.normal_appearance&.value&.each_key&.
             find {|key| key != :Off } || :Yes
         end
 
@@ -192,7 +192,7 @@ module HexaPDF
         # button.
         def radio_button_values
           each_widget.map do |widget|
-            widget.appearance&.normal_appearance&.value&.each_key&.find {|key| key != :Off }
+            widget.appearance_dict&.normal_appearance&.value&.each_key&.find {|key| key != :Off }
           end.compact
         end
 
@@ -233,7 +233,11 @@ module HexaPDF
         def create_appearances(force: false)
           appearance_generator_class = document.config.constantize('acro_form.appearance_generator')
           each_widget do |widget|
-            next if !force && widget.appearance?
+            normal_appearance = widget.appearance_dict&.normal_appearance
+            next if !force && normal_appearance &&
+              ((!push_button? && normal_appearance.value.length == 2 &&
+                normal_appearance.value.each_value.all?(HexaPDF::Stream)) ||
+               (push_button? && normal_appearance.kind_of?(HexaPDF::Stream)))
             if check_box?
               appearance_generator_class.new(widget).create_check_box_appearances
             elsif radio_button?
@@ -250,7 +254,7 @@ module HexaPDF
           create_appearances
           value = self[:V]
           each_widget do |widget|
-            widget[:AS] = (widget.appearance&.normal_appearance&.value&.key?(value) ? value : :Off)
+            widget[:AS] = (widget.appearance_dict&.normal_appearance&.key?(value) ? value : :Off)
           end
         end