hexapdf 0.12.3 → 0.14.3

data/lib/hexapdf/image_loader/png.rb

@@ -162,9 +162,10 @@ module HexaPDF
                 io.seek(length, IO::SEEK_CUR)
               end
             when 'tRNS' # PNG s11.3.2
-              if @color_type == INDEXED
+              case @color_type
+              when INDEXED
                 trns = io.read(length).unpack('C*')
-              elsif @color_type == TRUECOLOR || @color_type == GREYSCALE
+              when TRUECOLOR, GREYSCALE
                 dict[:Mask] = io.read(length).unpack('n*').map {|val| [val, val] }.flatten
               else
                 io.seek(length, IO::SEEK_CUR)

data/lib/hexapdf/importer.rb

@@ -90,7 +90,7 @@ module HexaPDF
     #
     # An error is raised if the object doesn't belong to the +source+ document.
     def import(object)
-      mapped_object = @mapper[object.data] if object.kind_of?(HexaPDF::Object)
+      mapped_object = @mapper[object.data]&.__getobj__ if object.kind_of?(HexaPDF::Object)
       if object.kind_of?(HexaPDF::Object) && object.document? && @source != object.document
         raise HexaPDF::Error, "Import error: Incorrect document object for importer"
       elsif mapped_object && mapped_object == @destination.object(mapped_object)
@@ -118,7 +118,8 @@ module HexaPDF
         if object.type == :Catalog || object.type == :Pages
           @mapper[object.data] = nil
         else
-          obj = @mapper[object.data] = object.dup
+          obj = object.dup
+          @mapper[object.data] = NullableWeakRef.new(obj)
           obj.document = @destination.__getobj__
           obj.instance_variable_set(:@data, obj.data.dup)
           obj.data.oid = 0

data/lib/hexapdf/layout/line.rb

@@ -198,7 +198,7 @@ module HexaPDF
       # Note: The cache is not cleared!
       def add(item)
         last = @items.last
-        if last.class == item.class && item.kind_of?(TextFragment) && last.style == item.style
+        if last.instance_of?(item.class) && item.kind_of?(TextFragment) && last.style == item.style
           if last.items.frozen?
             @items[-1] = last = last.dup
             last.items = last.items.dup

data/lib/hexapdf/layout/style.rb

@@ -524,7 +524,7 @@ module HexaPDF
       #   Style.new(font_size: 15, align: :center, valign: center)
       def initialize(**properties)
         update(**properties)
-        @scaled_item_widths = {}
+        @scaled_item_widths = {}.compare_by_identity
       end
 
       # Duplicates the complex properties that can be modified, as well as the cache.
@@ -883,41 +883,41 @@ module HexaPDF
         [:text_rise, 0],
         [:font_features, {}],
         [:text_rendering_mode, "Content::TextRenderingMode::FILL",
-         setter: "Content::TextRenderingMode.normalize(value)"],
+         {setter: "Content::TextRenderingMode.normalize(value)"}],
         [:subscript, false,
-         setter: "value; superscript(false) if superscript",
-         valid_values: [true, false]],
+         {setter: "value; superscript(false) if superscript",
+          valid_values: [true, false]}],
         [:superscript, false,
-         setter: "value; subscript(false) if subscript",
-         valid_values: [true, false]],
-        [:underline, false, valid_values: [true, false]],
-        [:strikeout, false, valid_values: [true, false]],
+         {setter: "value; subscript(false) if subscript",
+          valid_values: [true, false]}],
+        [:underline, false, {valid_values: [true, false]}],
+        [:strikeout, false, {valid_values: [true, false]}],
         [:fill_color, "default_color"],
         [:fill_alpha, 1],
         [:stroke_color, "default_color"],
         [:stroke_alpha, 1],
         [:stroke_width, 1],
         [:stroke_cap_style, "Content::LineCapStyle::BUTT_CAP",
-         setter: "Content::LineCapStyle.normalize(value)"],
+         {setter: "Content::LineCapStyle.normalize(value)"}],
         [:stroke_join_style, "Content::LineJoinStyle::MITER_JOIN",
-         setter: "Content::LineJoinStyle.normalize(value)"],
+         {setter: "Content::LineJoinStyle.normalize(value)"}],
         [:stroke_miter_limit, 10.0],
         [:stroke_dash_pattern, "Content::LineDashPattern.new",
-         setter: "Content::LineDashPattern.normalize(value, phase)", extra_args: ", phase = 0"],
-        [:align, :left, valid_values: [:left, :center, :right, :justify]],
-        [:valign, :top, valid_values: [:top, :center, :bottom]],
+         {setter: "Content::LineDashPattern.normalize(value, phase)", extra_args: ", phase = 0"}],
+        [:align, :left, {valid_values: [:left, :center, :right, :justify]}],
+        [:valign, :top, {valid_values: [:top, :center, :bottom]}],
         [:text_indent, 0],
         [:line_spacing, "LineSpacing.new(type: :single)",
-         setter: "LineSpacing.new(**(value.kind_of?(Symbol) ? {type: value, value: extra_arg} : value))",
-         extra_args: ", extra_arg = nil"],
-        [:last_line_gap, false, valid_values: [true, false]],
+         {setter: "LineSpacing.new(**(value.kind_of?(Symbol) ? {type: value, value: extra_arg} : value))",
+          extra_args: ", extra_arg = nil"}],
+        [:last_line_gap, false, {valid_values: [true, false]}],
         [:background_color, nil],
-        [:padding, "Quad.new(0)", setter: "Quad.new(value)"],
-        [:margin, "Quad.new(0)", setter: "Quad.new(value)"],
-        [:border, "Border.new", setter: "Border.new(**value)"],
-        [:overlays, "Layers.new", setter: "Layers.new(value)"],
-        [:underlays, "Layers.new", setter: "Layers.new(value)"],
-        [:position, :default, valid_values: [:default, :float, :flow, :absolute]],
+        [:padding, "Quad.new(0)", {setter: "Quad.new(value)"}],
+        [:margin, "Quad.new(0)", {setter: "Quad.new(value)"}],
+        [:border, "Border.new", {setter: "Border.new(**value)"}],
+        [:overlays, "Layers.new", {setter: "Layers.new(value)"}],
+        [:underlays, "Layers.new", {setter: "Layers.new(value)"}],
+        [:position, :default, {valid_values: [:default, :float, :flow, :absolute]}],
         [:position_hint, nil],
       ].each do |name, default, options = {}|
         default = default.inspect unless default.kind_of?(String)
@@ -1075,7 +1075,7 @@ module HexaPDF
       # The item may be a (singleton) glyph object or an integer/float, i.e. items that can appear
       # inside a TextFragment.
       def scaled_item_width(item)
-        @scaled_item_widths[item.object_id] ||=
+        @scaled_item_widths[item] ||=
           begin
             if item.kind_of?(Numeric)
               -item * scaled_font_size

data/lib/hexapdf/layout/text_layouter.rb

@@ -388,7 +388,7 @@ module HexaPDF
               end
             when :penalty
               if item.penalty <= -Penalty::INFINITY
-                add_box_item(item.item) if item.item
+                add_box_item(item.item) if item.width > 0
                 break unless yield(create_unjustified_line, item)
                 reset_after_line_break(index + 1)
               elsif item.penalty >= Penalty::INFINITY
@@ -458,7 +458,7 @@ module HexaPDF
               end
             when :penalty
               if item.penalty <= -Penalty::INFINITY
-                add_box_item(item.item) if item.item
+                add_box_item(item.item) if item.width > 0
                 break unless (action = yield(create_unjustified_line, item))
                 reset_after_line_break_variable_width(index + 1, true, action)
               elsif item.penalty >= Penalty::INFINITY

data/lib/hexapdf/layout/text_shaper.rb

@@ -68,9 +68,10 @@ module HexaPDF
           text_fragment.clear_cache
         end
         if text_fragment.style.font_features[:kern] && font.wrapped_font.features.include?(:kern)
-          if font.font_type == :TrueType
+          case font.font_type
+          when :TrueType
             process_true_type_kerning(text_fragment)
-          elsif font.font_type == :Type1
+          when :Type1
             process_type1_kerning(text_fragment)
           end
           text_fragment.clear_cache

data/lib/hexapdf/object.rb

@@ -122,9 +122,6 @@ module HexaPDF
 
     include Comparable
 
-    # A list of classes whose objects cannot be duplicated.
-    NOT_DUPLICATABLE_CLASSES = [NilClass, FalseClass, TrueClass, Symbol, Integer, Float].freeze
-
     # :call-seq:
     #   HexaPDF::Object.deep_copy(object)    -> copy
     #
@@ -139,8 +136,6 @@ module HexaPDF
         (object.indirect? || object.must_be_indirect? ? object : deep_copy(object.value))
       when HexaPDF::Reference
         object
-      when *NOT_DUPLICATABLE_CLASSES
-        object
       else
         object.dup
       end
@@ -251,29 +246,31 @@ module HexaPDF
     end
 
     # :call-seq:
-    #   obj.validate(auto_correct: true)                               -> true or false
-    #   obj.validate(auto_correct: true) {|msg, correctable| block }   -> true or false
+    #   obj.validate(auto_correct: true)                                    -> true or false
+    #   obj.validate(auto_correct: true) {|msg, correctable, obj| block }   -> true or false
     #
-    # Validates the object and, optionally, corrects problems when the option +auto_correct+ is set.
-    # The validation routine itself has to be implemented in the #perform_validation method - see
-    # its documentation for more information.
+    # Validates the object, optionally corrects problems when the option +auto_correct+ is set and
+    # returns +true+ if the object is deemed valid and +false+ otherwise.
     #
     # If a block is given, it is called on validation problems with a problem description and
-    # whether the problem is correctable.
+    # whether the problem is automatically correctable. The third argument to the block is usually
+    # this object but may be another object if during auto-correction a new object was created and
+    # validated.
     #
-    # Returns +true+ if the object is deemed valid and +false+ otherwise.
+    # The validation routine itself has to be implemented in the #perform_validation method - see
+    # its documentation for more information.
     #
     # *Note*: Even if the return value is +true+ there may be problems since HexaPDF doesn't
     # currently implement the full PDF spec. However, if the return value is +false+, there is
     # certainly a problem!
     def validate(auto_correct: true)
-      catch do |catch_tag|
-        perform_validation do |msg, correctable|
-          yield(msg, correctable) if block_given?
-          throw(catch_tag, false) unless auto_correct && correctable
-        end
-        true
+      result = true
+      perform_validation do |msg, correctable, object|
+        yield(msg, correctable, object || self) if block_given?
+        result = false unless correctable
+        return false unless auto_correct
       end
+      result
     end
 
     # Makes a deep copy of the source PDF object and resets the object identifier.
@@ -287,6 +284,28 @@ module HexaPDF
       obj
     end
 
+    # Caches and returns the given +value+ or the value of the block under the given cache key. If
+    # there is already a cached value for the key and +update+ is +false+, it is just returned.
+    #
+    # Set +update+ to +true+ to force an update of the cached value.
+    #
+    # This uses Document#cache internally.
+    def cache(key, value = Document::UNSET, update: false, &block)
+      document.cache(@data, key, value, update: update, &block)
+    end
+
+    # Returns +true+ if there is a cached value for the given key.
+    #
+    # This uses Document#cached? internally.
+    def cached?(key)
+      document.cached?(@data, key)
+    end
+
+    # Clears the cache for this object.
+    def clear_cache
+      document.clear_cache(@data)
+    end
+
     # Compares this object to another object.
     #
     # If the other object does not respond to +oid+ or +gen+, +nil+ is returned. Otherwise objects
@@ -339,17 +358,25 @@ module HexaPDF
     # are also performed!
     #
     # When the validation routine finds that the object is invalid, it has to yield a problem
-    # description and whether the problem can be corrected. After yielding, the problem has to be
-    # corrected which poses no problem because the #validate method makes sure that the yield only
-    # returns if the problem is actually correctable and if it should be corrected.
+    # description and whether the problem can be corrected. An optional third argument may contain
+    # the object that gets validated if it is different from this object (may happen when
+    # auto-correction is used).
     #
-    # Here is a sample validation routine for stream objects:
+    # After yielding, the problem has to be corrected if it is correctable. If it is not correctable
+    # and not correcting would lead to exceptions the method has to return early.
+    #
+    # Here is a sample validation routine for a dictionary object type:
     #
     #   def perform_validation
     #     super
-    #     unless value.kind_of?(Hash)
-    #       yield("A stream object needs a Hash as value")
-    #       self.value = {}
+    #
+    #     if value[:SomeKey].length != 7
+    #       yield("Length of /SomeKey is invalid")
+    #       # No need to return early here because following check doesn't rely on /SomeKey
+    #     end
+    #
+    #     if value[:OtherKey] % 2 == 0
+    #       yield("/OtherKey needs to contain an odd number of elements")
     #     end
     #   end
     def perform_validation(&block)

data/lib/hexapdf/parser.rb

@@ -59,6 +59,7 @@ module HexaPDF
       @tokenizer = Tokenizer.new(io)
       @document = document
       @object_stream_data = {}
+      @reconstructed_revision = nil
       retrieve_pdf_header_offset_and_version
     end
 
@@ -71,7 +72,13 @@ module HexaPDF
       obj, oid, gen, stream =
         case xref_entry.type
         when :in_use
-          parse_indirect_object(xref_entry.pos)
+          if xref_entry.pos == 0 && xref_entry.oid != 0
+            # Handle seen-in-the-wild objects with invalid offset 0
+            maybe_raise("Indirect object (#{xref_entry.oid},#{xref_entry.gen}) has offset 0", pos: 0)
+            [nil, xref_entry.oid, xref_entry.gen, nil]
+          else
+            parse_indirect_object(xref_entry.pos)
+          end
         when :free
           [nil, xref_entry.oid, xref_entry.gen, nil]
         when :compressed
@@ -82,10 +89,12 @@ module HexaPDF
 
       if xref_entry.oid != 0 && (oid != xref_entry.oid || gen != xref_entry.gen)
         raise_malformed("The oid,gen (#{oid},#{gen}) values of the indirect object don't match " \
-          "the values (#{xref_entry.oid},#{xref_entry.gen}) from the xref")
+                        "the values (#{xref_entry.oid},#{xref_entry.gen}) from the xref")
       end
 
       @document.wrap(obj, oid: oid, gen: gen, stream: stream)
+    rescue HexaPDF::MalformedPDFError
+      reconstructed_revision.object(xref_entry)
     end
 
     # Parses the indirect object at the specified offset.
@@ -110,7 +119,15 @@ module HexaPDF
         maybe_raise("No indirect object value between 'obj' and 'endobj'", pos: @tokenizer.pos)
         object = nil
       else
-        object = @tokenizer.next_object
+        begin
+          object = @tokenizer.next_object
+        rescue MalformedPDFError
+          # Handle often found invalid indirect object with missing whitespace after number
+          maybe_raise("Invalid object value after 'obj'", pos: @tokenizer.pos,
+                      force: !(tok.kind_of?(Tokenizer::Token) && tok =~ /\A\d+endobj\z/))
+          object = tok.to_i
+          @tokenizer.pos -= 6
+        end
       end
 
       tok = @tokenizer.next_token
@@ -122,7 +139,9 @@ module HexaPDF
         tok1 = @tokenizer.next_byte
         tok2 = @tokenizer.next_byte if tok1 == 13 # 13=CR, 10=LF
         if tok1 != 10 && tok1 != 13
-          raise_malformed("Keyword stream must be followed by LF or CR/LF", pos: @tokenizer.pos)
+          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
         elsif tok1 == 13 && tok2 != 10
           maybe_raise("Keyword stream must be followed by LF or CR/LF, not CR alone",
                       pos: @tokenizer.pos)
@@ -235,14 +254,14 @@ module HexaPDF
         @tokenizer.skip_whitespace
         start.upto(start + number_of_entries - 1) do |oid|
           pos, gen, type = @tokenizer.next_xref_entry do |matched_size|
-            maybe_raise("Invalid cross-reference subsection entry", pos: @tokenizer.pos,
-                        force: matched_size == 20)
+            maybe_raise("Invalid cross-reference entry", pos: @tokenizer.pos,
+                        force: !matched_size)
           end
           if xref.entry?(oid)
             next
           elsif type == 'n'
             if pos == 0 || gen > 65535
-              maybe_raise("Invalid in use cross-reference entry in cross-reference section",
+              maybe_raise("Invalid in use cross-reference entry",
                           pos: @tokenizer.pos)
               xref.add_free_entry(oid, gen)
             else
@@ -264,6 +283,27 @@ module HexaPDF
         raise_malformed("Trailer is #{trailer.class} instead of dictionary ", pos: @tokenizer.pos)
       end
 
+      unless trailer[:Prev] || xref.max_oid == 0 || xref.entry?(0)
+        first_entry = xref[xref.oids[0]]
+        test_entry = xref[xref.oids[-1]]
+        @tokenizer.pos = test_entry.pos + @header_offset
+        test_oid = @tokenizer.next_token
+        first_oid = first_entry.oid
+
+        force_failure = !first_entry.free? || first_entry.gen != 65535 ||
+          !test_oid.kind_of?(Integer) || xref.oids[-1] - test_oid != first_oid
+        maybe_raise("Main cross-reference section has invalid numbering",
+                    pos: offset + @header_offset, force: force_failure)
+
+        new_xref = XRefSection.new
+        xref.oids.each do |oid|
+          entry = xref[oid]
+          entry.oid -= first_oid
+          new_xref.send(:[]=, entry.oid, entry.gen, entry)
+        end
+        xref = new_xref
+      end
+
       [xref, trailer]
     end
 
@@ -313,6 +353,11 @@ module HexaPDF
       @startxref_offset = lines[eof_index - 1].to_i
     end
 
+    # Returns the reconstructed revision.
+    def reconstructed_revision
+      @reconstructed_revision ||= reconstruct_revision
+    end
+
     # Returns the PDF version number that is stored in the file header.
     #
     # See: PDF1.7 s7.5.2
@@ -338,6 +383,61 @@ module HexaPDF
       @header_version = $1
     end
 
+    # Tries to reconstruct the PDF document's main cross-reference table by serially parsing the
+    # file and returning a Revision object for loading the found objects.
+    #
+    # If the file contains multiple cross-reference sections, all objects will be put into a single
+    # cross-reference table, later objects overwriting prior ones.
+    def reconstruct_revision
+      raise unless @document.config['parser.try_xref_reconstruction']
+      msg = "#{$!} - trying cross-reference table reconstruction"
+      @document.config['parser.on_correctable_error'].call(@document, msg, @tokenizer.pos)
+
+      xref = XRefSection.new
+      @tokenizer.pos = 0
+      while true
+        @tokenizer.skip_whitespace
+        pos = @tokenizer.pos
+        @tokenizer.scan_until(/(\n|\r\n?)+|\z/)
+        next_new_line_pos = @tokenizer.pos
+        @tokenizer.pos = pos
+
+        token = @tokenizer.next_integer_or_keyword rescue nil
+        if token.kind_of?(Integer)
+          gen = @tokenizer.next_integer_or_keyword rescue nil
+          tok = @tokenizer.next_integer_or_keyword rescue nil
+          if @tokenizer.pos > next_new_line_pos
+            @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)
+            @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?)
+        elsif token == Tokenizer::NO_MORE_TOKENS
+          break
+        else
+          @tokenizer.pos = next_new_line_pos
+        end
+      end
+
+      trailer&.delete(:Prev) # no need for this and may wreak havoc
+      if !trailer || trailer.empty?
+        raise_malformed("Could not reconstruct malformed PDF because trailer was not found", pos: 0)
+      end
+
+      loader = lambda do |xref_entry|
+        obj, oid, gen, stream = parse_indirect_object(xref_entry.pos)
+        @document.wrap(obj, oid: oid, gen: gen, stream: stream)
+      end
+
+      Revision.new(@document.wrap(trailer, type: :XXTrailer), xref_section: xref,
+                   loader: loader)
+    end
+
     # Raises a HexaPDF::MalformedPDFError with the given message and source position.
     def raise_malformed(msg, pos: nil)
       raise HexaPDF::MalformedPDFError.new(msg, pos: pos)