hexapdf 0.14.2 → 0.15.2

data/lib/hexapdf/pdf_array.rb

@@ -65,6 +65,9 @@ module HexaPDF
     # * Returns the native Ruby object for values with class HexaPDF::Object. However, all
     #   subclasses of HexaPDF::Object are returned as is (it makes no sense, for example, to return
     #   the hash that describes the Catalog instead of the Catalog object).
+    #
+    # Note: Hash or Array values will always be returned as-is, i.e. not wrapped with Dictionary or
+    # PDFArray.
     def [](arg1, arg2 = nil)
       data = arg2 ? value[arg1, arg2] : value[arg1]
       return if data.nil?

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/serializer.rb

@@ -191,7 +191,13 @@ module HexaPDF
     #
     # See: PDF1.7 s7.3.3
     def serialize_float(obj)
-      -0.0001 < obj && obj < 0.0001 && obj != 0 ? sprintf("%.6f", obj) : obj.round(6).to_s
+      if -0.0001 < obj && obj < 0.0001 && obj != 0
+        sprintf("%.6f", obj)
+      elsif obj.finite?
+        obj.round(6).to_s
+      else
+        raise HexaPDF::Error, "Can't serialize special floating point number #{obj}"
+      end
     end
 
     # The regexp matches all characters that need to be escaped and the substs hash contains the
@@ -343,6 +349,7 @@ module HexaPDF
           @io << data.freeze
         end
         @io << "\nendstream"
+        @in_object = false
 
         nil
       else
@@ -350,12 +357,12 @@ module HexaPDF
         obj.value[:Length] = data.size
 
         str = serialize_hash(obj.value)
+        @in_object = false
+
         str << "stream\n"
         str << data
         str << "\nendstream"
       end
-    ensure
-      @in_object = false
     end
 
     # Invokes the correct serialization method for the object.

data/lib/hexapdf/tokenizer.rb

@@ -73,11 +73,15 @@ module HexaPDF
     # The IO object from the tokens are read.
     attr_reader :io
 
-    # Creates a new tokenizer.
-    def initialize(io)
+    # Creates a new tokenizer for the given IO stream.
+    #
+    # If +on_correctable_error+ is set to an object responding to +call(msg, pos)+, errors for
+    # correctable situations are only raised if the return value of calling the object is +true+.
+    def initialize(io, on_correctable_error: nil)
       @io = io
       @ss = StringScanner.new(''.b)
       @original_pos = -1
+      @on_correctable_error = on_correctable_error || proc { false }
       self.pos = 0
     end
 
@@ -180,7 +184,8 @@ module HexaPDF
           end
         else
           unless allow_keyword
-            raise HexaPDF::MalformedPDFError.new("Invalid object, got token #{token}", pos: pos)
+            maybe_raise("Invalid object, got token #{token}", force: token !~ /^-?(nan|inf)$/i)
+            token = 0
           end
         end
       end
@@ -188,6 +193,28 @@ module HexaPDF
       token
     end
 
+    # Returns a single integer or keyword token read from the current position and advances the scan
+    # pointer. If the current position doesn't contain such a token, +nil+ is returned without
+    # advancing the scan pointer. The value +NO_MORE_TOKENS+ is returned if there are no more tokens
+    # available.
+    #
+    # Initial runs of whitespace characters are ignored.
+    #
+    # Note: This is a special method meant for use with reconstructing the cross-reference table!
+    def next_integer_or_keyword
+      skip_whitespace
+      byte = @ss.string.getbyte(@ss.pos) || -1
+      if 48 <= byte && byte <= 57
+        parse_number
+      elsif (97 <= byte && byte <= 122) || (65 <= byte && byte <= 90)
+        parse_keyword
+      elsif byte == -1 # we reached the end of the file
+        NO_MORE_TOKENS
+      else
+        nil
+      end
+    end
+
     # Reads the byte (an integer) at the current position and advances the scan pointer.
     def next_byte
       prepare_string_scanner(1)
@@ -406,6 +433,20 @@ module HexaPDF
       true
     end
 
+    # Calls the @on_correctable_error callable object with the given message and the current
+    # position. If the returned value is +true+, raises a HexaPDF::MalformedPDFError. Otherwise the
+    # error is corrected (by the caller) and tokenization continues.
+    #
+    # If the option +force+ is used, the callable object is not called and the error is raised
+    # immediately.
+    def maybe_raise(msg, force: false)
+      if force || @on_correctable_error.call(msg, pos)
+        error = HexaPDF::MalformedPDFError.new(msg, pos: pos)
+        error.set_backtrace(caller(1))
+        raise error
+      end
+    end
+
   end
 
 end

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
@@ -245,6 +236,9 @@ module HexaPDF
           end
 
           form = (@widget[:AP] ||= {})[:N] ||= @document.add({Type: :XObject, Subtype: :Form})
+          # Wrap existing object in Form class in case the PDF writer didn't include the /Subtype
+          # key; we can do this since we know this has to be a Form object
+          form = @document.wrap(form, type: :XObject, subtype: :Form) unless form[:Subtype] == :Form
           form.value.replace({Type: :XObject, Subtype: :Form, BBox: [0, 0, rect.width, rect.height]})
           form.contents = ''
           form[:Resources] = HexaPDF::Object.deep_copy(default_resources)
@@ -479,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
 

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

@@ -315,6 +315,7 @@ module HexaPDF
 
           if embedded_widget?
             WIDGET_FIELDS.each {|key| delete(key) }
+            document.revisions.each {|revision| break if revision.update(self)}
           else
             self[:Kids].delete_at(widget_index)
             document.delete(widget)

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

@@ -331,6 +331,43 @@ module HexaPDF
           end
         end
 
+        # Flattens the whole interactive form or only the given fields, and returns the fields that
+        # couldn't be flattened.
+        #
+        # Flattening means making the appearance streams of the field widgets part of the respective
+        # page's content stream and removing the fields themselves.
+        #
+        # If the whole interactive form is flattened, the form object itself is also removed if all
+        # fields were flattened.
+        #
+        # The +create_appearances+ argument controls whether missing appearances should
+        # automatically be created.
+        #
+        # See: HexaPDF::Type::Page#flatten_annotations
+        def flatten(fields: nil, create_appearances: true)
+          remove_form = fields.nil?
+          fields ||= each_field.to_a
+          if create_appearances
+            fields.each {|field| field.create_appearances if field.respond_to?(:create_appearances) }
+          end
+
+          not_flattened = fields.map {|field| field.each_widget.to_a }.flatten
+          document.pages.each {|page| not_flattened = page.flatten_annotations(not_flattened) }
+          fields -= not_flattened.map(&:form_field)
+
+          fields.each do |field|
+            (field[:Parent]&.[](:Kids) || self[:Fields]).delete(field)
+            document.delete(field)
+          end
+
+          if remove_form && not_flattened.empty?
+            document.catalog.delete(:AcroForm)
+            document.delete(self)
+          end
+
+          not_flattened
+        end
+
         private
 
         # Helper method for bit field getter access.

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

@@ -0,0 +1,223 @@
+# -*- 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-2021 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/type/acro_form/field'
+require 'hexapdf/type/acro_form/appearance_generator'
+
+module HexaPDF
+  module Type
+    module AcroForm
+
+      # AcroForm signature fields represent a digital signature.
+      #
+      # It serves two purposes: To visually display the signature and to hold the information of the
+      # digital signature itself.
+      #
+      # If the signature should not be visible, the associated widget annotation should have zero
+      # width and height; and/or the 'hidden' or 'no_view' flags of the annotation should be set.
+      #
+      # See: PDF1.7 s12.7.4.5
+      class SignatureField < Field
+
+        # A signature field lock dictionary specifies a set of form fields that should be locked
+        # once the associated signature field is signed.
+        #
+        # See: PDF1.7 s12.7.4.5
+        class LockDictionary < Dictionary
+
+          define_type :SigFieldLock
+
+          define_field :Type,   type: Symbol, default: type
+          define_field :Action, type: Symbol, required: true,
+            allowed_values: [:All, :Include, :Exclude]
+          define_field :Fields, type: PDFArray
+
+          private
+
+          def perform_validation #:nodoc:
+            if self[:Action] != :All && !key?(:Fields)
+              yield("The /Fields key of the signature lock dictionary is missing")
+            end
+          end
+
+        end
+
+        # A seed value dictionary contains information that constrains the properties of a signature
+        # that is applied to the associated signature field.
+        #
+        # == Flags
+        #
+        # If a flag is set it means that the associated entry is a required constraint. Otherwise it
+        # is optional.
+        #
+        # The available flags are: filter, sub_filter, v, reasons, legal_attestation, add_rev_info
+        # and digest_method.
+        #
+        # See: PDF1.7 s12.7.4.5
+        class SeedValueDictionary < Dictionary
+
+          extend Utils::BitField
+
+          define_type :SV
+
+          define_field :Type,             type: Symbol, default: type
+          define_field :Ff,               type: Integer, default: 0
+          define_field :Filter,           type: Symbol
+          define_field :SubFilter,        type: PDFArray
+          define_field :DigestMethod,     type: PDFArray, version: '1.7'
+          define_field :V,                type: Float
+          define_field :Cert,             type: :SVCert
+          define_field :Reasons,          type: PDFArray
+          define_field :MDP,              type: Dictionary, version: '1.6'
+          define_field :TimeStamp,        type: Dictionary, version: '1.6'
+          define_field :LegalAttestation, type: PDFArray, version: '1.6'
+          define_field :AddRevInfo,       type: Boolean, version: '1.7'
+
+          ##
+          # :method: flags
+          #
+          # Returns an array of flag names representing the set bit flags.
+          #
+
+          ##
+          # :method: flagged?
+          # :call-seq:
+          #   flagged?(flag)
+          #
+          # Returns +true+ if the given flag is set. The argument can either be the flag name or the
+          # bit index.
+          #
+
+          ##
+          # :method: flag
+          # :call-seq:
+          #   flag(*flags, clear_existing: false)
+          #
+          # Sets the given flags, given as flag names or bit indices. If +clear_existing+ is +true+,
+          # all prior flags will be cleared.
+          #
+          bit_field(:flags, {filter: 0, sub_filter: 1, v: 2, reasons: 3, legal_attestation: 4,
+                             add_rev_info: 5, digest_method: 6},
+                    lister: "flags", getter: "flagged?", setter: "flag", unsetter: "unflag",
+                    value_getter: "self[:Ff]", value_setter: "self[:Ff]")
+
+        end
+
+        # A certificate seed value dictionary contains information about the characteristics of the
+        # certificate that shall be used when signing.
+        #
+        # == Flags
+        #
+        # The flags describe the entries that a signer is required to use.
+        #
+        # The available flags are: subject, issuer, oid, subject_dn, reserved,  key_usage and url.
+        #
+        # See: PDF1.7 s12.7.4.5
+        class CertificateSeedValueDictionary < Dictionary
+
+          extend Utils::BitField
+
+          define_type :SVCert
+
+          define_field :Type,      type: Symbol, default: type
+          define_field :Ff,        type: Integer, default: 0
+          define_field :Subject,   type: PDFArray
+          define_field :SubjectDN, type: PDFArray, version: '1.7'
+          define_field :KeyUsage,  type: PDFArray, version: '1.7'
+          define_field :Issuer,    type: PDFArray
+          define_field :OID,       type: PDFArray
+          define_field :URL,       type: String
+          define_field :URLType,   type: Symbol, default: :Browser
+
+          ##
+          # :method: flags
+          #
+          # Returns an array of flag names representing the set bit flags.
+          #
+
+          ##
+          # :method: flagged?
+          # :call-seq:
+          #   flagged?(flag)
+          #
+          # Returns +true+ if the given flag is set. The argument can either be the flag name or the
+          # bit index.
+          #
+
+          ##
+          # :method: flag
+          # :call-seq:
+          #   flag(*flags, clear_existing: false)
+          #
+          # Sets the given flags, given as flag names or bit indices. If +clear_existing+ is +true+,
+          # all prior flags will be cleared.
+          #
+          bit_field(:flags, {subject: 0, issuer: 1, oid: 2, subject_dn: 3, reserved: 4,
+                             key_usage: 5, url: 6},
+                    lister: "flags", getter: "flagged?", setter: "flag", unsetter: "unflag",
+                    value_getter: "self[:Ff]", value_setter: "self[:Ff]")
+
+        end
+
+        define_field :Lock, type: :SigFieldLock, indirect: true, version: '1.5'
+        define_field :SV, type: :SV, indirect: true, version: '1.5'
+
+        # Returns the associated signature dictionary or +nil+ if the signature is not filled in.
+        def field_value
+          self[:V]
+        end
+
+        # Sets the signature dictionary as value of this signature field.
+        def field_value=(sig_dict)
+          self[:V] = sig_dict
+        end
+
+        private
+
+        def perform_validation #:nodoc:
+          if field_type != :Sig
+            yield("Field /FT of AcroForm signature field has to be :Sig", true)
+            self[:FT] = :Sig
+          end
+
+          super
+        end
+
+      end
+
+    end
+  end
+end