hexapdf 0.12.3 → 0.13.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 889b4bf1bc77da0a3fdfc62d2b5b09042aa1b5a567d5ed80ae382e6cdeb193f9
-  data.tar.gz: 67f217de3dbd01653e9df4e8f8af7e8dba3745cd772e6d6ab930411ff3d1cfb3
+  metadata.gz: 77d9895ece62ee8b8df5afb5a44035868c6b33eb7b43a7cb5b85bd730bee56bc
+  data.tar.gz: 16b61502ef5c35df588c6a2fd53e1099b80f584276c07ec7a3c23343705ccb42
 SHA512:
-  metadata.gz: 71affdceb736e0645c45b181a585b3a425135c0b22fba1daf28d89aaa6e73e5226f18a1e420fb75325653c87274f66664526d8ca55baaaa5251b4f822617b986
-  data.tar.gz: 63aceaac41dd2ea797f92e7335a381bea5d1bdd2f7388c583431323e7ac9fae0855a404a84fbed70222130bd5eded126dae5385be2291d76c91021633d03a3bb
+  metadata.gz: 490fca7cfa535ebfab2af613dacf3ff9e9a6b0b2b76c865ceeb98a45d1cc7b668772dbd3a46ea00a5b82eb1374f36cb42b604754bbb1353e103cde726bc7e886
+  data.tar.gz: 1f85edaa9b2214218bb586d8c5409c9f741893fa0effdb60c64d294be231893ed96f1efa9db286d9a98f094caeb3fb272d318782dc7977adb8b252425d72cfb4

data/CHANGELOG.md

@@ -1,3 +1,41 @@
+## 0.13.0 - 2020-11-15
+
+### Added
+
+* Cross-reference table reconstruction for damaged PDFs, controllable via the
+  new 'parser.try_xref_reconstruction' option
+* Two new `hexapdf inspect` commands for showing page objects and page content
+  streams by page number
+* Flag `--check` to the CLI command `hexapdf info` for checking a file for
+  parse and validation errors
+* [HexaPDF::Type::AcroForm::Field#embedded_widget?] for checking if a widget is
+  embedded in the field object
+* [HexaPDF::Type::AcroForm::Field#delete_widget] for deleting a widget
+* [HexaPDF::PDFArray#delete] for deleting an object from a PDF array
+* [HexaPDF::Type::Page#ancestor_nodes] for retrieving all ancestor page tree
+  nodes of a page
+* [HexaPDF::Type::PageTreeNode#move_page] for moving a page to another index
+
+### Changed
+
+* **Breaking change**: Overhauled document/object validation interfaces and
+  internals to be more similar and to allow for reporting of multiple validation
+  problems
+* Validation of TrueType fonts to ignore missing fields if the font name
+  suggests that the font is one of the standard 14 PDF fonts
+* Option `-p` of CLI command `hexapdf image2pdf` to also allow lowercase page
+  size names
+
+### Fixed
+
+* Reporting of cross-reference section entry parsing error
+* PDF version used by default for dictionary fields
+* Error in CLI command `hexapdf inspect` when parsing an invalid object number
+* Output of error messages in CLI command `hexapdf inspect` to go to `$stderr`
+* Bug in [HexaPDF::Type::AcroForm::TextField] validation due to missing nil
+  handling
+
+
 ## 0.12.3 - 2020-08-22
 
 ### Changed

data/lib/hexapdf/cli/command.rb

@@ -100,6 +100,7 @@ module HexaPDF
       def pdf_options(password)
         hash = {decryption_opts: {password: password}, config: {}}
         HexaPDF::GlobalConfiguration['filter.predictor.strict'] = command_parser.strict
+        hash[:config]['parser.try_xref_reconstruction'] = !command_parser.strict
         hash[:config]['parser.on_correctable_error'] =
           if command_parser.strict
             proc { true }
@@ -277,14 +278,15 @@ module HexaPDF
       #
       # See: #define_encryption_options
       def apply_encryption_options(doc)
-        if @out_options.encryption == :add
+        case @out_options.encryption
+        when :add
           doc.encrypt(algorithm: @out_options.enc_algorithm,
                       key_length: @out_options.enc_key_length,
                       force_v4: @out_options.enc_force_v4,
                       permissions: @out_options.enc_permissions,
                       owner_password: @out_options.enc_owner_pwd,
                       user_password: @out_options.enc_user_pwd)
-        elsif @out_options.encryption == :remove
+        when :remove
           doc.encrypt(name: nil)
         end
       end

data/lib/hexapdf/cli/image2pdf.rb

@@ -64,7 +64,8 @@ module HexaPDF
                            orientation = :landscape
                            page_size.delete_suffix!('-landscape')
                          end
-                         HexaPDF::Type::Page.media_box(page_size.to_sym, orientation: orientation)
+                         page_size = page_size.capitalize.to_sym
+                         HexaPDF::Type::Page.media_box(page_size, orientation: orientation)
                        end
         end
         options.on("--[no-]auto-rotate", "Automatically rotate pages based on image dimesions. " \

data/lib/hexapdf/cli/info.rb

@@ -55,13 +55,21 @@ module HexaPDF
         long_desc(<<~EOF)
           This command extracts information from the Info dictionary of a PDF file as well
           as some other useful information like the used PDF version and encryption information.
+
+          If the --check option is specified, the PDF file will also be checked for parse and
+          validation errors. And if the process doesn't abort, HexaPDF is still able to handle the
+          file by correcting the errors.
         EOF
+        options.on("--check", "-c", "Check the PDF file for parse errors and validity") do |check|
+          @check_file = check
+        end
         options.on("--password PASSWORD", "-p", String,
                    "The password for decryption. Use - for reading from standard input.") do |pwd|
           @password = (pwd == '-' ? read_password : pwd)
         end
         @password = nil
         @auto_decrypt = true
+        @check_file = false
       end
 
       def execute(file) #:nodoc:
@@ -79,8 +87,30 @@ module HexaPDF
         options = pdf_options(@password)
         options[:config]['document.auto_decrypt'] = @auto_decrypt
         HexaPDF::Document.open(file, **options) do |doc|
+          if @check_file
+            indirect_object = nil
+            validation_block = lambda do |msg, correctable, object|
+              object = indirect_object unless object.indirect? || object.type == :XXTrailer
+              object_type = if object.type == :XXTrailer
+                              'trailer'
+                            elsif !object.type.to_s.start_with?("XX")
+                              "object type #{object.type} (#{object.oid},#{object.gen})"
+                            else
+                              "object (#{object.oid},#{object.gen})"
+                            end
+              object_type = "sub-object of #{object_type}" if object == indirect_object
+              puts "WARNING: Validation error for #{object_type}: #{msg} " \
+                "#{correctable ? '(correctable)' : ''}"
+            end
+            doc.trailer.validate(auto_correct: true, &validation_block)
+            doc.each(only_current: false, only_loaded: false) do |obj|
+              indirect_object = obj
+              obj.validate(auto_correct: true, &validation_block)
+            end
+          end
+
           output_line("File name", file)
-          output_line("File size", File.stat(file).size.to_s + " bytes")
+          output_line("File size", File.stat(file).size.to_s << " bytes")
           @auto_decrypt && INFO_KEYS.each do |name|
             next unless doc.trailer.info.key?(name)
             output_line(name.to_s, doc.trailer.info[name].to_s)
@@ -110,10 +140,29 @@ module HexaPDF
         else
           raise
         end
+      rescue HexaPDF::MalformedPDFError => e
+        $stderr.puts "Error: PDF file #{file} is damaged and cannot be recovered"
+        $stderr.puts "       #{e}"
+      end
+
+      # Use custom options if we are checking the PDF file for errors.
+      def pdf_options(password)
+        if @check_file
+          options = {decryption_opts: {password: password}, config: {}}
+          HexaPDF::GlobalConfiguration['filter.predictor.strict'] = false
+          options[:config]['parser.try_xref_reconstruction'] = true
+          options[:config]['parser.on_correctable_error'] = lambda do |_, msg, pos|
+            puts "WARNING: Parse error at position #{pos}: #{msg}"
+            false
+          end
+          options
+        else
+          super
+        end
       end
 
       def output_line(header, text) #:nodoc:
-        puts((header + ":").ljust(COLUMN_WIDTH) << text)
+        puts(("#{header}:").ljust(COLUMN_WIDTH) << text)
       end
 
     end

data/lib/hexapdf/cli/inspect.rb

@@ -122,22 +122,22 @@ module HexaPDF
           case command
           when /^\d+(,\d+)?$/, 'o', 'object'
             arg = (command.start_with?('o') ? data.shift : command)
-            obj = pdf_object_from_string_reference(arg) rescue puts($!.message)
-            if obj.data.stream && command_parser.verbosity_info?
+            obj = pdf_object_from_string_reference(arg) rescue $stderr.puts($!.message)
+            if obj&.data&.stream && command_parser.verbosity_info?
               $stderr.puts("Note: Object also has stream data")
             end
             serialize(obj.value, recursive: false) if obj
 
           when 'r', 'recursive'
             obj = if (obj = data.shift)
-                    pdf_object_from_string_reference(obj) rescue puts($!.message)
+                    pdf_object_from_string_reference(obj) rescue $stderr.puts($!.message)
                   else
                     @doc.trailer
                   end
             serialize(obj.value, recursive: true) if obj
 
           when 's', 'stream', 'raw', 'raw-stream'
-            if (obj = pdf_object_from_string_reference(data.shift) rescue puts($!.message)) &&
+            if (obj = pdf_object_from_string_reference(data.shift) rescue $stderr.puts($!.message)) &&
                 obj.kind_of?(HexaPDF::Stream)
               source = (command.start_with?('raw') ? obj.stream_source : obj.stream_decoder)
               while source.alive? && (stream_data = source.resume)
@@ -148,7 +148,7 @@ module HexaPDF
             end
 
           when 'x', 'xref'
-            if (obj = pdf_object_from_string_reference(data.shift) rescue puts($!.message))
+            if (obj = pdf_object_from_string_reference(data.shift) rescue $stderr.puts($!.message))
               @doc.revisions.reverse_each do |rev|
                 if (xref = rev.xref(obj))
                   puts xref
@@ -178,6 +178,26 @@ module HexaPDF
               puts str
             end
 
+          when 'po', 'ps'
+            page_number_str = data.shift
+            unless page_number_str
+              $stderr.puts("Error: Missing PAGE argument to #{command}")
+              next
+            end
+            page_number = parse_pages_specification(page_number_str, @doc.pages.count).first&.first
+            unless page_number
+              $stderr.puts("Error: Invalid page number #{page_number_str}")
+              next
+            end
+            page = @doc.pages[page_number]
+            if command.start_with?('ps')
+              $stdout.write(page.contents)
+            else
+              puts "#{page.oid} #{page.gen} obj"
+              serialize(page.value, recursive: false)
+              puts "endobj"
+            end
+
           when 'pc', 'page-count'
             puts @doc.pages.count
 
@@ -217,9 +237,9 @@ module HexaPDF
         if str.nil?
           raise "Error: Missing argument object identifier OID[,GEN]"
         elsif !str.match?(/^\d+(,\d+)?$/)
-          raise "Error: Invalid argument: Must be of form OID[,GEN]"
+          raise "Error: Invalid argument: Must be of form OID[,GEN], not '#{str}'"
         elsif !(obj = @doc.object(pdf_reference_from_string(str)))
-          raise "Error: No object with the given object identifier found"
+          raise "Error: No object with the given object identifier '#{str}' found"
         else
           obj
         end
@@ -240,7 +260,7 @@ module HexaPDF
           puts "<<"
           (recursive ? val.sort : val).each do |k, v|
             next if v.nil? || (v.respond_to?(:null?) && v.null?)
-            print '  ' * (indent + 1) + @serializer.serialize_symbol(k) + " "
+            print '%s%s ' % ['  ' * (indent + 1), @serializer.serialize_symbol(k)]
             serialize(v, recursive: recursive, seen: seen, indent: indent + 1)
             puts
           end
@@ -283,6 +303,8 @@ module HexaPDF
         ["c[atalog]", "Print the catalog dictionary"],
         ["t[railer]", "Print the trailer dictionary"],
         ["p[ages] [RANGE]",  "Print information about pages"],
+        ["po PAGE", "Print the page object"],
+        ["ps PAGE", "Print the content stream of the page"],
         ["pc | page-count", "Print the number of pages"],
         ["search REGEXP", "Print objects matching the pattern"],
         ["h[elp]", "Show the help"],

data/lib/hexapdf/cli/merge.rb

@@ -122,7 +122,7 @@ module HexaPDF
 
         # Assemble pages
         target = (@initial_empty ? HexaPDF::Document.new : @files.first.file)
-        page_tree = target.add(Type: :Pages)
+        page_tree = target.add({Type: :Pages})
         import_pages(page_tree)
         target.catalog[:Pages] = page_tree
         remove_unused_pages(target)

data/lib/hexapdf/configuration.rb

@@ -334,6 +334,20 @@ module HexaPDF
   #    The value needs to be an object that responds to \#call(document, message, position) and
   #    returns +true+ if an error should be raised.
   #
+  # parser.try_xref_reconstruction::
+  #    A boolean specifying whether non-recoverable parsing errors should lead to reconstructing the
+  #    main cross-reference table.
+  #
+  #    The reconstructed cross-reference table might make damaged files usable but there is no way
+  #    to ensure that the reconstructed file is equal to the undamaged original file (though
+  #    generally it works out).
+  #
+  #    There is also the possibility that reconstructing doesn't work because the algorithm has to
+  #    assume that the PDF was written in a certain way (which is recommended by the PDF
+  #    specification).
+  #
+  #    Defaults to +true+.
+  #
   # sorted_tree.max_leaf_node_size::
   #    The maximum number of nodes that should be in a leaf node of a node tree.
   #
@@ -412,6 +426,7 @@ module HexaPDF
                       'page.default_media_box' => :A4,
                       'page.default_media_orientation' => :portrait,
                       'parser.on_correctable_error' => proc { false },
+                      'parser.try_xref_reconstruction' => true,
                       'sorted_tree.max_leaf_node_size' => 64,
                       'style.layers_map' => {
                         link: 'HexaPDF::Layout::Style::LinkLayer',

data/lib/hexapdf/content/graphic_object/arc.rb

@@ -45,7 +45,7 @@ module HexaPDF
       # all either in clockwise or counterclockwise direction and optionally inclined in respect to
       # the x-axis.
       #
-      # See: ELL - https://www.spaceroots.org/documents/ellipse/elliptical-arc.pdf
+      # See: ELL - https://spaceroots.org/documents/ellipse/elliptical-arc.pdf
       class Arc
 
         include HexaPDF::Utils::MathHelpers
@@ -202,8 +202,8 @@ module HexaPDF
             p2x_prime, p2y_prime = derivative_evaluate(eta2)
 
             result << [p2x, p2y,
-                       p1: [p1x + alpha * p1x_prime, p1y + alpha * p1y_prime],
-                       p2: [p2x - alpha * p2x_prime, p2y - alpha * p2y_prime]]
+                       {p1: [p1x + alpha * p1x_prime, p1y + alpha * p1y_prime],
+                        p2: [p2x - alpha * p2x_prime, p2y - alpha * p2y_prime]}]
           end
 
           result

data/lib/hexapdf/dictionary.rb

@@ -97,7 +97,7 @@ module HexaPDF
     #
     # version:: Specifies the minimum version of the PDF specification needed for this value.
     def self.define_field(name, type:, required: false, default: nil, indirect: nil,
-                          allowed_values: nil, version: '1.2')
+                          allowed_values: nil, version: '1.0')
       @fields ||= {}
       @fields[name] = Field.new(type, required: required, default: default, indirect: indirect,
                                 allowed_values: allowed_values, version: version)
@@ -163,7 +163,7 @@ module HexaPDF
                value[name] = field.default
              end
       value[name] = data = document.deref(data) if data.kind_of?(HexaPDF::Reference)
-      if data.class == HexaPDF::Object || (data.kind_of?(HexaPDF::Object) && data.value.nil?)
+      if data.instance_of?(HexaPDF::Object) || (data.kind_of?(HexaPDF::Object) && data.value.nil?)
         data = data.value
       end
       if (result = field&.convert(data, document))
@@ -182,7 +182,7 @@ module HexaPDF
         raise ArgumentError, "Only Symbol (Name) keys are allowed to be used in PDF dictionaries"
       end
 
-      if value[name].class == HexaPDF::Object && !data.kind_of?(HexaPDF::Object) &&
+      if value[name].instance_of?(HexaPDF::Object) && !data.kind_of?(HexaPDF::Object) &&
           !data.kind_of?(HexaPDF::Reference)
         value[name].value = data
       else
@@ -273,7 +273,7 @@ module HexaPDF
         # Check that required fields are set
         if field.required? && obj.nil?
           yield("Required field #{name} is not set", field.default?)
-          self[name] = obj = field.default
+          self[name] = obj = field.default if field.default?
         end
 
         # Check if the document version is set high enough

data/lib/hexapdf/dictionary_fields.rb

@@ -151,17 +151,9 @@ module HexaPDF
       # Returns a duplicated default value, automatically taking unduplicatable classes into
       # account.
       def default
-        duplicatable_default? ? @default.dup : @default
+        @default.dup
       end
 
-      # Returns +true+ if the default value can safely be duplicated with #dup.
-      def duplicatable_default?
-        @duplicatable_default ||= HexaPDF::Object::NOT_DUPLICATABLE_CLASSES.none? do |klass|
-          @default.kind_of?(klass)
-        end
-      end
-      private :duplicatable_default?
-
       # Returns +true+ if the given object is valid for this field.
       def valid_object?(obj)
         type.any? {|t| obj.kind_of?(t) } ||

data/lib/hexapdf/document.rb

@@ -69,15 +69,35 @@ module HexaPDF
 
   autoload(:Composer, 'hexapdf/composer')
 
+  # == HexaPDF::Document
+  #
   # Represents one PDF document.
   #
   # A PDF document consists of (indirect) objects, so the main job of this class is to provide
   # methods for working with these objects. However, since a PDF document may also be
   # incrementally updated and can therefore contain one or more revisions, there are also methods
-  # to work with these revisions.
+  # for working with these revisions.
   #
   # Note: This class provides everything to work on PDF documents on a low-level basis. This means
-  # that there are no convenience methods for higher PDF functionality whatsoever.
+  # that there are no convenience methods for higher PDF functionality. Those can be found in the
+  # objects linked from here, like #catalog.
+  #
+  # == Known Messages
+  #
+  # The document object provides a basic message dispatch system via #register_listener and
+  # #dispatch_message.
+  #
+  # Following are the messages that are used by HexaPDF itself:
+  #
+  # :complete_objects::
+  #      This message is called before the first step of writing a document. Listeners should
+  #      complete PDF objects that are missing some information.
+  #
+  #      For example, the font system uses this message to complete the font objects with
+  #      information that is only available once all the used glyphs are known.
+  #
+  # :before_write::
+  #      This message is called before a document is actually serialized and written.
   class Document
 
     autoload(:Pages, 'hexapdf/document/pages')
@@ -400,11 +420,11 @@ module HexaPDF
     # object in the PDF document. The block may either accept only the object or the object and the
     # revision it is in.
     #
-    # By default, only the current version of each object is returned which implies that each
-    # object number is yielded exactly once. If the +current+ option is +false+, all stored
-    # objects from newest to oldest are returned, not only the current version of each object.
+    # By default, only the current version of each object is returned which implies that each object
+    # number is yielded exactly once. If the +only_current+ option is +false+, all stored objects
+    # from newest to oldest are returned, not only the current version of each object.
     #
-    # The +current+ option can make a difference because the document can contain multiple
+    # The +only_current+ option can make a difference because the document can contain multiple
     # revisions:
     #
     # * Multiple revisions may contain objects with the same object and generation numbers, e.g.
@@ -442,6 +462,9 @@ module HexaPDF
     end
 
     # Dispatches the message +name+ with the given arguments to all registered listeners.
+    #
+    # See the main Document documentation for an overview of messages that are used by HexaPDF
+    # itself.
     def dispatch_message(name, *args)
       @listeners[name]&.each {|obj| obj.call(*args) }
     end
@@ -594,13 +617,9 @@ module HexaPDF
     # If a block is given, it is called on validation problems.
     #
     # See HexaPDF::Object#validate for more information.
-    def validate(auto_correct: true, only_loaded: false) #:yield: object, msg, correctable
-      cur_obj = trailer
-      block = (block_given? ? lambda {|msg, correctable| yield(cur_obj, msg, correctable) } : nil)
-
+    def validate(auto_correct: true, only_loaded: false, &block) #:yield: msg, correctable, object
       result = trailer.validate(auto_correct: auto_correct, &block)
       each(only_current: false, only_loaded: only_loaded) do |obj|
-        cur_obj = obj
         result &&= obj.validate(auto_correct: auto_correct, &block)
       end
       result
@@ -643,7 +662,7 @@ module HexaPDF
       end
 
       if validate
-        self.validate(auto_correct: true) do |obj, msg, correctable|
+        self.validate(auto_correct: true) do |msg, correctable, obj|
           next if correctable
           raise HexaPDF::Error, "Validation error for (#{obj.oid},#{obj.gen}): #{msg}"
         end