hexapdf 0.12.3 → 0.13.0

data/lib/hexapdf/document/files.rb

@@ -117,7 +117,6 @@ module HexaPDF
 
           @document.pages.each do |page|
             page[:Annots]&.each do |annot|
-              annot = @document.deref(annot)
               next unless annot[:Subtype] == :FileAttachment
               spec = @document.deref(annot[:FS])
               yield(spec) unless seen.key?(spec)

data/lib/hexapdf/encryption/fast_arc4.rb

@@ -49,7 +49,7 @@ module HexaPDF
 
       # Creates a new FastARC4 object using the given encryption key.
       def initialize(key)
-        @cipher = OpenSSL::Cipher::RC4.new
+        @cipher = OpenSSL::Cipher.new('rc4')
         @cipher.key_len = key.length
         @cipher.key = key
       end

data/lib/hexapdf/encryption/security_handler.rb

@@ -72,6 +72,7 @@ module HexaPDF
         super
         unless [1, 2, 4, 5].include?(value[:V])
           yield("Value of /V is not one of 1, 2, 4 or 5", false)
+          return
         end
         if value[:V] == 2 && (!key?(:Length) || value[:Length] < 40 ||
           value[:Length] > 128 || value[:Length] % 8 != 0)

data/lib/hexapdf/encryption/standard_security_handler.rb

@@ -69,6 +69,7 @@ module HexaPDF
         when 6
           if !key?(:OE) || !key?(:UE) || !key?(:Perms)
             yield("Value of /OE, /UE or /Perms is missing for dictionary revision 6", false)
+            return
           end
           if value[:U].length != 48 || value[:O].length != 48 || value[:UE].length != 32 ||
               value[:OE].length != 32 || value[:Perms].length != 16

data/lib/hexapdf/font/cmap.rb

@@ -100,10 +100,7 @@ module HexaPDF
       # The writing mode of the CMap: 0 for horizontal, 1 for vertical writing.
       attr_accessor :wmode
 
-      attr_reader :codespace_ranges     #: nodoc:
-      attr_reader :cid_mapping          # :nodoc:
-      attr_reader :cid_range_mappings   # :nodoc:
-      attr_reader :unicode_mapping      # :nodoc:
+      attr_reader :codespace_ranges, :cid_mapping, :cid_range_mappings, :unicode_mapping # :nodoc:
       protected :codespace_ranges, :cid_mapping, :cid_range_mappings, :unicode_mapping
 
       # Creates a new CMap object.

data/lib/hexapdf/font/true_type/table/head.rb

@@ -76,6 +76,7 @@ module HexaPDF
 
           # Apple Mac style information.
           attr_accessor :mac_style
+
           bit_field(:mac_style, {bold: 0, italic: 1, underline: 2, outline: 3, shadow: 4,
                                  condensed: 5, extended: 6})
 

data/lib/hexapdf/font/true_type/table/os2.rb

@@ -65,6 +65,7 @@ module HexaPDF
 
           # Characteristics and properties of this font.
           attr_accessor :type
+
           bit_field(:type, {restricted_license_embedding: 1, preview_and_print_embedding: 2,
                             editable_embedding: 3, no_subsetting: 8, bitmap_embedding_only: 9})
 
@@ -112,6 +113,7 @@ module HexaPDF
 
           # Information concerning the nature of the font patterns.
           attr_accessor :selection
+
           bit_field(:selection, {italic: 0, underscore: 1, negative: 2, outlined: 3, strikeout: 4,
                                  bold: 5, regular: 6, use_typo_metrics: 7, wws: 8, oblique: 9})
 

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/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_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.
@@ -339,17 +336,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).
+    #
+    # 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 stream objects:
+    # 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
 
@@ -86,6 +87,8 @@ module HexaPDF
       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.
@@ -235,14 +238,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
@@ -313,6 +316,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 +346,60 @@ 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
+        pos = @tokenizer.pos
+        @tokenizer.scan_until(/(\n|\r\n?)+|\z/)
+        next_new_line_pos = @tokenizer.pos
+        @tokenizer.pos = pos
+
+        token = @tokenizer.next_token rescue nil
+        if token.kind_of?(Integer)
+          gen = @tokenizer.next_token rescue nil
+          tok = @tokenizer.next_token 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)

data/lib/hexapdf/pdf_array.rb

@@ -83,7 +83,7 @@ module HexaPDF
     # subclasses) and the given data has not (including subclasses), the data is stored inside the
     # HexaPDF::Object.
     def []=(index, data)
-      if value[index].class == HexaPDF::Object && !data.kind_of?(HexaPDF::Object) &&
+      if value[index].instance_of?(HexaPDF::Object) && !data.kind_of?(HexaPDF::Object) &&
           !data.kind_of?(HexaPDF::Reference)
         value[index].value = data
       else
@@ -113,6 +113,13 @@ module HexaPDF
       value.delete_at(index)
     end
 
+    # Deletes all values from the PDFArray that are equal to the given object.
+    #
+    # Returns the last deleted item, or +nil+ if no matching item is found.
+    def delete(object)
+      value.delete(object)
+    end
+
     # :call-seq:
     #   array.slice!(index)             -> obj or nil
     #   array.slice!(start, length)     -> new_array or nil
@@ -196,7 +203,7 @@ module HexaPDF
         data = document.deref(data)
         value[index] = data if index
       end
-      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
       data

data/lib/hexapdf/revisions.rb

@@ -67,30 +67,38 @@ module HexaPDF
         object_loader = lambda {|xref_entry| parser.load_object(xref_entry) }
 
         revisions = []
-        xref_section, trailer = parser.load_revision(parser.startxref_offset)
-        revisions << Revision.new(document.wrap(trailer, type: :XXTrailer),
-                                  xref_section: xref_section, loader: object_loader)
-        seen_xref_offsets = {parser.startxref_offset => true}
-
-        while (prev = revisions[0].trailer.value[:Prev]) &&
-            !seen_xref_offsets.key?(prev)
-          # PDF1.7 s7.5.5 states that :Prev needs to be indirect, Adobe's reference 3.4.4 says it
-          # should be direct. Adobe's POV is followed here. Same with :XRefStm.
-          xref_section, trailer = parser.load_revision(prev)
-          seen_xref_offsets[prev] = true
-
-          stm = revisions[0].trailer.value[:XRefStm]
-          if stm && !seen_xref_offsets.key?(stm)
-            stm_xref_section, = parser.load_revision(stm)
-            xref_section.merge!(stm_xref_section)
-            seen_xref_offsets[stm] = true
+        begin
+          xref_section, trailer = parser.load_revision(parser.startxref_offset)
+          revisions << Revision.new(document.wrap(trailer, type: :XXTrailer),
+                                    xref_section: xref_section, loader: object_loader)
+          seen_xref_offsets = {parser.startxref_offset => true}
+
+          while (prev = revisions[0].trailer.value[:Prev]) &&
+              !seen_xref_offsets.key?(prev)
+            # PDF1.7 s7.5.5 states that :Prev needs to be indirect, Adobe's reference 3.4.4 says it
+            # should be direct. Adobe's POV is followed here. Same with :XRefStm.
+            xref_section, trailer = parser.load_revision(prev)
+            seen_xref_offsets[prev] = true
+
+            stm = revisions[0].trailer.value[:XRefStm]
+            if stm && !seen_xref_offsets.key?(stm)
+              stm_xref_section, = parser.load_revision(stm)
+              xref_section.merge!(stm_xref_section)
+              seen_xref_offsets[stm] = true
+            end
+
+            revisions.unshift(Revision.new(document.wrap(trailer, type: :XXTrailer),
+                                           xref_section: xref_section, loader: object_loader))
           end
-
-          revisions.unshift(Revision.new(document.wrap(trailer, type: :XXTrailer),
-                                         xref_section: xref_section, loader: object_loader))
+        rescue HexaPDF::MalformedPDFError
+          reconstructed_revision = parser.reconstructed_revision
+          unless revisions.empty?
+            reconstructed_revision.trailer.data.value = revisions.last.trailer.data.value
+          end
+          revisions << reconstructed_revision
         end
 
-        document.version = parser.file_header_version
+        document.version = parser.file_header_version rescue '1.0'
         new(document, initial_revisions: revisions, parser: parser)
       end