pdf-reader 2.2.0 → 2.11.0

data/lib/pdf/reader/xref.rb

@@ -1,4 +1,5 @@
 # coding: utf-8
+# typed: true
 # frozen_string_literal: true
 
 ################################################################################
@@ -72,7 +73,7 @@ class PDF::Reader
     #
     # ref - a PDF::Reader::Reference object containing an object ID and revision number
     def [](ref)
-      @xref[ref.id][ref.gen]
+      @xref.fetch(ref.id, {}).fetch(ref.gen)
     rescue
       raise InvalidObjectError, "Object #{ref.id}, Generation #{ref.gen} is invalid"
     end
@@ -81,8 +82,8 @@ class PDF::Reader
     def each(&block)
       ids = @xref.keys.sort
       ids.each do |id|
-        gen = @xref[id].keys.sort[-1]
-        yield PDF::Reader::Reference.new(id, gen)
+        gen = @xref.fetch(id, {}).keys.sort[-1]
+        yield PDF::Reader::Reference.new(id, gen.to_i)
       end
     end
     ################################################################################
@@ -103,13 +104,18 @@ class PDF::Reader
       buf = new_buffer(offset)
       tok_one = buf.token
 
+      # we have a traditional xref table
       return load_xref_table(buf) if tok_one == "xref" || tok_one == "ref"
 
       tok_two   = buf.token
       tok_three = buf.token
 
+      # we have an XRef stream
       if tok_one.to_i >= 0 && tok_two.to_i >= 0 && tok_three == "obj"
         buf = new_buffer(offset)
+        # Maybe we should be parsing the ObjectHash second argument to the Parser here,
+        # to handle the case where an XRef Stream has the Length specified via an
+        # indirect object
         stream = PDF::Reader::Parser.new(buf).object(tok_one.to_i, tok_two.to_i)
         return load_xref_stream(stream)
       end
@@ -125,12 +131,19 @@ class PDF::Reader
 
       while !params.include?("trailer") && !params.include?(nil)
         if params.size == 2
+          unless params[0].to_s.match(/\A\d+\z/)
+            raise MalformedPDFError, "invalid xref table, expected object ID"
+          end
+
           objid, count = params[0].to_i, params[1].to_i
           count.times do
             offset = buf.token.to_i
             generation = buf.token.to_i
             state = buf.token
 
+            # Some PDF writers start numbering at 1 instead of 0. Fix up the number.
+            # TODO should this fix be logged?
+            objid = 0 if objid == 1 and offset == 0 and generation == 65535 and state == 'f'
             store(objid, generation, offset + @junk_offset) if state == "n" && offset > 0
             objid += 1
             params.clear
@@ -139,14 +152,16 @@ class PDF::Reader
         params << buf.token
       end
 
-      trailer = Parser.new(buf, self).parse_token
+      trailer = Parser.new(buf).parse_token
 
       unless trailer.kind_of?(Hash)
         raise MalformedPDFError, "PDF malformed, trailer should be a dictionary"
       end
 
       load_offsets(trailer[:XRefStm])   if trailer.has_key?(:XRefStm)
-      load_offsets(trailer[:Prev].to_i) if trailer.has_key?(:Prev)
+      # Some PDF creators seem to use '/Prev 0' in trailer if there is no previous xref
+      # It's not possible for an xref to appear at offset 0, so can safely skip the ref
+      load_offsets(trailer[:Prev].to_i) if trailer.has_key?(:Prev) and trailer[:Prev].to_i != 0
 
       trailer
     end
@@ -162,8 +177,16 @@ class PDF::Reader
         [:Size, :Prev, :Root, :Encrypt, :Info, :ID].include?(key)
       }]
 
-      widths       = stream.hash[:W]
-      entry_length = widths.inject(0) { |s, w| s + w }
+      widths = stream.hash[:W]
+
+      PDF::Reader::Error.validate_type_as_malformed(widths, "xref stream widths", Array)
+
+      entry_length = widths.inject(0) { |s, w|
+        unless w.is_a?(Integer)
+          w = 0
+        end
+        s + w
+      }
       raw_data     = StringIO.new(stream.unfiltered_data)
       if stream.hash[:Index]
         index = stream.hash[:Index]
@@ -230,18 +253,21 @@ class PDF::Reader
     # should always be 0, but all sort of crazy junk is prefixed to PDF files
     # in the real world.
     #
-    # Checks up to 50 chars into the file, returns nil if no PDF data detected.
+    # Checks up to 1024 chars into the file,
+    # returns nil if no PDF data detected.
+    # Adobe PDF 1.4 spec (3.4.1) 12. Acrobat viewers require only that the
+    # header appear somewhere within the first 1024 bytes of the file
     #
     def calc_junk_offset(io)
       io.rewind
       offset = io.pos
-      until (c = io.readchar) == '%' || c == 37 || offset > 50
+      until (c = io.readchar) == '%' || c == 37 || offset > 1024
         offset += 1
       end
       io.rewind
-      offset < 50 ? offset : nil
+      offset < 1024 ? offset : nil
     rescue EOFError
-      return nil
+      nil
     end
   end
   ################################################################################

data/lib/pdf/reader/zero_width_runs_filter.rb

@@ -0,0 +1,13 @@
+# coding: utf-8
+# typed: strict
+# frozen_string_literal: true
+
+class PDF::Reader
+  # There's no point rendering zero-width characters
+  class ZeroWidthRunsFilter
+
+    def self.exclude_zero_width_runs(runs)
+      runs.reject { |run| run.width == 0 }
+    end
+  end
+end

data/lib/pdf/reader.rb

@@ -1,4 +1,5 @@
 # coding: utf-8
+# typed: strict
 # frozen_string_literal: true
 
 ################################################################################
@@ -111,19 +112,27 @@ module PDF
     #
     #   reader = PDF::Reader.new("somefile.pdf", :password => "apples")
     #
+    # Using this method directly is supported, but it's more common to use
+    # `PDF::Reader.open`
+    #
     def initialize(input, opts = {})
       @cache   = PDF::Reader::ObjectCache.new
       opts.merge!(:cache => @cache)
       @objects = PDF::Reader::ObjectHash.new(input, opts)
     end
 
+    # Return a Hash with some basic information about the PDF file
+    #
     def info
-      dict = @objects.deref(@objects.trailer[:Info])
+      dict = @objects.deref_hash(@objects.trailer[:Info]) || {}
       doc_strings_to_utf8(dict)
     end
 
+    # Return a String with extra XML metadata provided by the author of the PDF file. Not
+    # always present.
+    #
     def metadata
-      stream = @objects.deref(root[:Metadata])
+      stream = @objects.deref_stream(root[:Metadata])
       if stream.nil?
         nil
       else
@@ -133,20 +142,24 @@ module PDF
       end
     end
 
+    # To number of pages in this PDF
+    #
     def page_count
-      pages = @objects.deref(root[:Pages])
+      pages = @objects.deref_hash(root[:Pages])
       unless pages.kind_of?(::Hash)
-        raise MalformedPDFError, 'Pages structure is missing'
+        raise MalformedPDFError, "Pages structure is missing #{pages.class}"
       end
-      @page_count ||= @objects.deref(pages[:Count])
+      @page_count ||= @objects.deref_integer(pages[:Count]) || 0
     end
 
+    # The PDF version this file uses
+    #
     def pdf_version
       @objects.pdf_version
     end
 
-    # syntactic sugar for opening a PDF file. Accepts the same arguments
-    # as new().
+    # syntactic sugar for opening a PDF file and the most common approach. Accepts the
+    # same arguments as new().
     #
     #   PDF::Reader.open("somefile.pdf") do |reader|
     #     puts reader.pdf_version
@@ -169,7 +182,7 @@ module PDF
     #
     #   reader.pages.each do |page|
     #     puts page.fonts
-    #     puts page.images
+    #     puts page.rectangles
     #     puts page.text
     #   end
     #
@@ -177,10 +190,12 @@ module PDF
     # methods available on each page
     #
     def pages
+      return [] if page_count <= 0
+
       (1..self.page_count).map do |num|
         begin
           PDF::Reader::Page.new(@objects, num, :cache => @cache)
-        rescue InvalidPageError => ex
+        rescue InvalidPageError
           raise MalformedPDFError, "Missing data for page: #{num}"
         end
       end
@@ -221,16 +236,24 @@ module PDF
       when Array then
         obj.map { |item| doc_strings_to_utf8(item) }
       when String then
-        if obj[0,2].unpack("C*") == [254, 255]
+        if has_utf16_bom?(obj)
           utf16_to_utf8(obj)
         else
           pdfdoc_to_utf8(obj)
         end
       else
-        @objects.deref(obj)
+        obj
       end
     end
 
+    def has_utf16_bom?(str)
+      first_bytes = str[0,2]
+
+      return false if first_bytes.nil?
+
+      first_bytes.unpack("C*") == [254, 255]
+    end
+
     # TODO find a PDF I can use to spec this behaviour
     #
     def pdfdoc_to_utf8(obj)
@@ -242,28 +265,23 @@ module PDF
     # String#encode
     #
     def utf16_to_utf8(obj)
-      str = obj[2, obj.size]
+      str = obj[2, obj.size].to_s
       str = str.unpack("n*").pack("U*")
       str.force_encoding("utf-8")
       str
     end
 
     def root
-      @root ||= begin
-        obj = @objects.deref(@objects.trailer[:Root])
-        unless obj.kind_of?(::Hash)
-          raise MalformedPDFError, "PDF malformed, trailer Root should be a dictionary"
-        end
-        obj
-      end
+      @root ||= @objects.deref_hash(@objects.trailer[:Root]) || {}
     end
 
   end
 end
 ################################################################################
 
-require 'pdf/reader/resource_methods'
+require 'pdf/reader/resources'
 require 'pdf/reader/buffer'
+require 'pdf/reader/bounding_rectangle_runs_filter'
 require 'pdf/reader/cid_widths'
 require 'pdf/reader/cmap'
 require 'pdf/reader/encoding'
@@ -286,19 +304,26 @@ require 'pdf/reader/object_hash'
 require 'pdf/reader/object_stream'
 require 'pdf/reader/pages_strategy'
 require 'pdf/reader/parser'
+require 'pdf/reader/point'
 require 'pdf/reader/print_receiver'
+require 'pdf/reader/rectangle'
 require 'pdf/reader/reference'
 require 'pdf/reader/register_receiver'
+require 'pdf/reader/no_text_filter'
 require 'pdf/reader/null_security_handler'
-require 'pdf/reader/standard_security_handler'
-require 'pdf/reader/standard_security_handler_v5'
+require 'pdf/reader/security_handler_factory'
+require 'pdf/reader/standard_key_builder'
+require 'pdf/reader/key_builder_v5'
+require 'pdf/reader/aes_v2_security_handler'
+require 'pdf/reader/aes_v3_security_handler'
+require 'pdf/reader/rc4_security_handler'
 require 'pdf/reader/unimplemented_security_handler'
 require 'pdf/reader/stream'
 require 'pdf/reader/text_run'
+require 'pdf/reader/type_check'
 require 'pdf/reader/page_state'
 require 'pdf/reader/page_text_receiver'
 require 'pdf/reader/token'
 require 'pdf/reader/xref'
-require 'pdf/reader/orientation_detector'
 require 'pdf/reader/page'
-require 'pdf/hash'
+require 'pdf/reader/validating_receiver'

data/lib/pdf-reader.rb

@@ -1,4 +1,5 @@
 # coding: utf-8
+# typed: strict
 # frozen_string_literal: true
 
 require "pdf/reader"