pdf-reader 2.9.2 → 2.15.0

data/lib/pdf/reader/xref.rb

@@ -1,5 +1,5 @@
 # coding: utf-8
-# typed: true
+# typed: strict
 # frozen_string_literal: true
 
 ################################################################################
@@ -46,8 +46,11 @@ class PDF::Reader
   # the Enumerable mixin. The key difference is no []= method - the hash
   # is read only.
   #
+  #: [Elem]
   class XRef
     include Enumerable
+
+    #: Hash[Symbol, untyped]
     attr_reader :trailer
 
     ################################################################################
@@ -55,16 +58,19 @@ class PDF::Reader
     #
     # io - must be an IO object, generally either a file or a StringIO
     #
+    #: (IO | Tempfile | StringIO) -> void
     def initialize(io)
       @io = io
-      @junk_offset = calc_junk_offset(io) || 0
-      @xref = {}
-      @trailer = load_offsets
+      @junk_offset = calc_junk_offset(io) || 0 #: Integer
+      @xref = {} #: Hash[Integer, Hash[Integer, Integer | PDF::Reader::Reference]]
+      @trailer = load_offsets #: Hash[Symbol, untyped]
     end
 
     ################################################################################
     # return the number of objects in this file. Objects with multiple generations are
     # only counter once.
+    #
+    #: () -> untyped
     def size
       @xref.size
     end
@@ -72,18 +78,22 @@ class PDF::Reader
     # returns the byte offset for the specified PDF object.
     #
     # ref - a PDF::Reader::Reference object containing an object ID and revision number
+    #: (untyped) -> untyped
     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
     ################################################################################
     # iterate over each object in the xref table
+    #
+    # @override(allow_incompatible: true)
+    #: () { (PDF::Reader::Reference) -> untyped } -> void
     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
     ################################################################################
@@ -97,6 +107,7 @@ class PDF::Reader
     # After seeking to the offset, processing is handed of to either load_xref_table()
     # or load_xref_stream() based on what we find there.
     #
+    #: (?Integer?) -> Hash[Symbol, untyped]
     def load_offsets(offset = nil)
       offset ||= new_buffer.find_first_xref_offset
       offset += @junk_offset
@@ -117,7 +128,9 @@ class PDF::Reader
         # 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)
+        if stream.is_a?(PDF::Reader::Stream)
+          return load_xref_stream(stream)
+        end
       end
 
       raise PDF::Reader::MalformedPDFError,
@@ -126,6 +139,8 @@ class PDF::Reader
     ################################################################################
     # Assumes the underlying buffer is positioned at the start of a traditional
     # Xref table and processes it into memory.
+    #
+    #: (PDF::Reader::Buffer) -> Hash[Symbol, untyped]
     def load_xref_table(buf)
       params = []
 
@@ -169,8 +184,9 @@ class PDF::Reader
     ################################################################################
     # Read an XRef stream from the underlying buffer instead of a traditional xref table.
     #
+    #: (PDF::Reader::Stream) -> Hash[Symbol, untyped]
     def load_xref_stream(stream)
-      unless stream.is_a?(PDF::Reader::Stream) && stream.hash[:Type] == :XRef
+      unless stream.hash[:Type] == :XRef
         raise PDF::Reader::MalformedPDFError, "xref stream not found when expected"
       end
       trailer = Hash[stream.hash.select { |key, value|
@@ -216,8 +232,9 @@ class PDF::Reader
     # XRef streams pack info into integers 1-N bytes wide. Depending on the number of
     # bytes they need to be converted to an int in different ways.
     #
+    #: (String?) -> Integer
     def unpack_bytes(bytes)
-      if bytes.to_s.size == 0
+      res = if bytes.nil? || bytes == ""
         0
       elsif bytes.size == 1
         bytes.unpack("C")[0]
@@ -232,6 +249,7 @@ class PDF::Reader
       else
         raise UnsupportedFeatureError, "Unable to unpack xref stream entries of #{bytes.size} bytes"
       end
+      TypeCheck.cast_to_int!(res)
     end
     ################################################################################
     # Wrap the io stream we're working with in a buffer that can tokenise it for us.
@@ -239,12 +257,14 @@ class PDF::Reader
     # We create multiple buffers so we can be tokenising multiple sections of the file
     # at the same time without worrying about clearing the buffers contents.
     #
+    #: (?Integer) -> PDF::Reader::Buffer
     def new_buffer(offset = 0)
       PDF::Reader::Buffer.new(@io, :seek => offset)
     end
     ################################################################################
     # Stores an offset value for a particular PDF object ID and revision number
     #
+    #: (Integer, Integer, Integer | PDF::Reader::Reference) -> (Integer | PDF::Reader::Reference)
     def store(id, gen, offset)
       (@xref[id] ||= {})[gen] ||= offset
     end
@@ -258,6 +278,7 @@ class PDF::Reader
     # 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
     #
+    #: (IO | Tempfile | StringIO) -> Integer?
     def calc_junk_offset(io)
       io.rewind
       offset = io.pos

data/lib/pdf/reader/zero_width_runs_filter.rb

@@ -6,6 +6,7 @@ class PDF::Reader
   # There's no point rendering zero-width characters
   class ZeroWidthRunsFilter
 
+    #: (Array[PDF::Reader::TextRun]) -> Array[PDF::Reader::TextRun]
     def self.exclude_zero_width_runs(runs)
       runs.reject { |run| run.width == 0 }
     end

data/lib/pdf/reader.rb

@@ -1,5 +1,5 @@
 # coding: utf-8
-# typed: true
+# typed: strict
 # frozen_string_literal: true
 
 ################################################################################
@@ -95,6 +95,7 @@ module PDF
   class Reader
 
     # lowlevel hash-like access to all objects in the underlying PDF
+    #: PDF::Reader::ObjectHash
     attr_reader :objects
 
     # creates a new document reader for the provided PDF.
@@ -115,22 +116,27 @@ module PDF
     # Using this method directly is supported, but it's more common to use
     # `PDF::Reader.open`
     #
+    #: (String | Tempfile | IO | StringIO, ?Hash[untyped, untyped]) -> void
     def initialize(input, opts = {})
-      @cache   = PDF::Reader::ObjectCache.new
+      @cache   = PDF::Reader::ObjectCache.new #: PDF::Reader::ObjectCache
       opts.merge!(:cache => @cache)
-      @objects = PDF::Reader::ObjectHash.new(input, opts)
+      @objects = PDF::Reader::ObjectHash.new(input, opts) #: PDF::Reader::ObjectHash
+      @page_count = nil #: Integer | nil
+      @root = nil #: Hash[Symbol, untyped] | nil
     end
 
     # Return a Hash with some basic information about the PDF file
     #
+    #: () -> Hash[untyped, untyped]?
     def info
       dict = @objects.deref_hash(@objects.trailer[:Info]) || {}
       doc_strings_to_utf8(dict)
     end
 
-    # Return a Hash with extra metadata provided by the author of the PDF file. Not
+    # Return a String with extra XML metadata provided by the author of the PDF file. Not
     # always present.
     #
+    #: () -> String?
     def metadata
       stream = @objects.deref_stream(root[:Metadata])
       if stream.nil?
@@ -144,6 +150,7 @@ module PDF
 
     # To number of pages in this PDF
     #
+    #: () -> Integer
     def page_count
       pages = @objects.deref_hash(root[:Pages])
       unless pages.kind_of?(::Hash)
@@ -154,6 +161,7 @@ module PDF
 
     # The PDF version this file uses
     #
+    #: () -> Float
     def pdf_version
       @objects.pdf_version
     end
@@ -171,6 +179,7 @@ module PDF
     #     puts reader.pdf_version
     #   end
     #
+    #: (String | Tempfile | IO, ?Hash[untyped, untyped]) { (PDF::Reader) -> void } -> untyped
     def self.open(input, opts = {}, &block)
       yield PDF::Reader.new(input, opts)
     end
@@ -182,13 +191,14 @@ module PDF
     #
     #   reader.pages.each do |page|
     #     puts page.fonts
-    #     puts page.images
+    #     puts page.rectangles
     #     puts page.text
     #   end
     #
     # See the docs for PDF::Reader::Page to read more about the
     # methods available on each page
     #
+    #: () -> Array[PDF::Reader::Page]
     def pages
       return [] if page_count <= 0
 
@@ -213,6 +223,7 @@ module PDF
     # See the docs for PDF::Reader::Page to read more about the
     # methods available on each page
     #
+    #: (Integer) -> PDF::Reader::Page
     def page(num)
       num = num.to_i
       if num < 1 || num > self.page_count
@@ -225,6 +236,7 @@ module PDF
 
     # recursively convert strings from outside a content stream into UTF-8
     #
+    #: (untyped) -> untyped
     def doc_strings_to_utf8(obj)
       case obj
       when ::Hash then
@@ -246,6 +258,7 @@ module PDF
       end
     end
 
+    #: (String) -> bool
     def has_utf16_bom?(str)
       first_bytes = str[0,2]
 
@@ -256,6 +269,7 @@ module PDF
 
     # TODO find a PDF I can use to spec this behaviour
     #
+    #: (String) -> String
     def pdfdoc_to_utf8(obj)
       obj.force_encoding("utf-8")
       obj
@@ -264,6 +278,7 @@ module PDF
     # one day we'll all run on a 1.9 compatible VM and I can just do this with
     # String#encode
     #
+    #: (String) -> String
     def utf16_to_utf8(obj)
       str = obj[2, obj.size].to_s
       str = str.unpack("n*").pack("U*")
@@ -271,14 +286,9 @@ module PDF
       str
     end
 
+    #: () -> Hash[Symbol, untyped]
     def root
-      @root ||= begin
-        obj = @objects.deref_hash(@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
@@ -286,6 +296,7 @@ end
 ################################################################################
 
 require 'pdf/reader/resources'
+require 'pdf/reader/advanced_text_run_filter'
 require 'pdf/reader/buffer'
 require 'pdf/reader/bounding_rectangle_runs_filter'
 require 'pdf/reader/cid_widths'
@@ -315,6 +326,7 @@ 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/security_handler_factory'
 require 'pdf/reader/standard_key_builder'