pdf-reader 2.9.2 → 2.15.0

data/lib/pdf/reader/lzw.rb

@@ -1,5 +1,5 @@
 # coding: utf-8
-# typed: true
+# typed: strict
 # frozen_string_literal: true
 
 module PDF
@@ -22,25 +22,31 @@ module PDF
       # Wraps an LZW encoded string
       class BitStream # :nodoc:
 
+        #: (String, Integer) -> void
         def initialize(data, bits_in_chunk)
           @data = data
           @data.force_encoding("BINARY")
-          @bits_in_chunk = bits_in_chunk
-          @current_pos = 0
-          @bits_left_in_byte = 8
+          @current_pos = 0 #: Integer
+          @bits_left_in_byte = 8 #: Integer
+          @bits_in_chunk = 0 #: Integer
+          set_bits_in_chunk(bits_in_chunk)
         end
 
+        #: (Integer) -> void
         def set_bits_in_chunk(bits_in_chunk)
+          raise MalformedPDFError, "invalid LZW bits" if bits_in_chunk < 9 || bits_in_chunk > 12
+
           @bits_in_chunk = bits_in_chunk
         end
 
+        #: () -> Integer
         def read
           bits_left_in_chunk = @bits_in_chunk
           chunk = -1
           while bits_left_in_chunk > 0 and @current_pos < @data.size
             chunk = 0 if chunk < 0
-            codepoint = @data[@current_pos, 1].unpack("C*")[0]
-            current_byte = codepoint & (2**@bits_left_in_byte - 1) #clear consumed bits
+            codepoint = @data[@current_pos, 1].to_s.unpack("C*")[0].to_i
+            current_byte = codepoint & (2**@bits_left_in_byte - 1).to_i #clear consumed bits
             dif = bits_left_in_chunk - @bits_left_in_byte
             if dif > 0 then  current_byte <<= dif
             elsif dif < 0 then  current_byte >>= dif.abs
@@ -57,33 +63,43 @@ module PDF
         end
       end
 
-      CODE_EOD = 257 #end of data
-      CODE_CLEAR_TABLE = 256 #clear table
+      CODE_EOD = 257 #: Integer #end of data
+      CODE_CLEAR_TABLE = 256 #: Integer #clear table
 
       # stores de pairs code => string
-      class StringTable < Hash # :nodoc:
+      class StringTable
+        #: Integer
         attr_reader :string_table_pos
 
+        #: () -> void
         def initialize
-          super
-          @string_table_pos = 258 #initial code
+          @data = Hash.new #: Hash[Integer, String]
+          # The initial code
+          @string_table_pos = 258 #: Integer
         end
 
         #if code less than 258 return fixed string
+        #: (Integer) -> String?
         def [](key)
-          if key > 257 then super else key.chr end
+          if key > 257
+            @data[key]
+          else
+            key.chr
+          end
         end
 
+        #: (String) -> void
         def add(string)
-          store(@string_table_pos, string)
+          @data.store(@string_table_pos, string)
           @string_table_pos += 1
         end
       end
 
       # Decompresses a LZW compressed string.
       #
+      #: (String) -> String
       def self.decode(data)
-        stream = BitStream.new data.to_s, 9 # size of codes between 9 and 12 bits
+        stream = BitStream.new(data.to_s, 9) # size of codes between 9 and 12 bits
         string_table = StringTable.new
         result = "".dup
         until (code = stream.read) == CODE_EOD
@@ -119,8 +135,18 @@ module PDF
         result
       end
 
-      def self.create_new_string(string_table,some_code, other_code)
-        string_table[some_code] + string_table[other_code][0].chr
+      #: (PDF::Reader::LZW::StringTable, Integer?, Integer?) -> String
+      def self.create_new_string(string_table, some_code, other_code)
+        raise MalformedPDFError, "invalid LZW data" if some_code.nil? || other_code.nil?
+
+        item_one = string_table[some_code]
+        item_two = string_table[other_code]
+
+        if item_one && item_two
+          item_one + item_two.chr
+        else
+          raise MalformedPDFError, "invalid LZW data"
+        end
       end
       private_class_method :create_new_string
 

data/lib/pdf/reader/no_text_filter.rb

@@ -0,0 +1,15 @@
+# coding: utf-8
+# typed: strict
+# frozen_string_literal: true
+
+class PDF::Reader
+  # There's no point rendering zero-width characters
+  class NoTextFilter
+
+    #: (Array[PDF::Reader::TextRun]) -> Array[PDF::Reader::TextRun]
+    def self.exclude_empty_strings(runs)
+      runs.reject { |run| run.text.to_s.size == 0 }
+    end
+  end
+end
+

data/lib/pdf/reader/null_security_handler.rb

@@ -7,6 +7,7 @@ class PDF::Reader
   # A null object security handler. Used when a PDF is unencrypted.
   class NullSecurityHandler
 
+    #: (String, PDF::Reader::Reference) -> String
     def decrypt(buf, _ref)
       buf
     end

data/lib/pdf/reader/object_cache.rb

@@ -15,10 +15,15 @@ class PDF::Reader
     # These object types use little memory and are accessed a heap of times as
     # part of random page access, so we'll cache the unmarshalled objects and
     # avoid lots of repetitive (and expensive) tokenising
-    CACHEABLE_TYPES = [:Catalog, :Page, :Pages]
+    CACHEABLE_TYPES = [:Catalog, :Page, :Pages] #: Array[Symbol]
 
-    attr_reader :hits, :misses
+    #: untyped
+    attr_reader :hits
 
+    #: untyped
+    attr_reader :misses
+
+    #: (?untyped) -> void
     def initialize(lru_size = 1000)
       @objects = {}
       @lru_cache = Hashery::LRUHash.new(lru_size.to_i)

data/lib/pdf/reader/object_hash.rb

@@ -2,6 +2,8 @@
 # typed: true
 # frozen_string_literal: true
 
+require 'tempfile'
+
 class PDF::Reader
   # Provides low level access to the objects in a PDF file via a hash-like
   # object.
@@ -30,8 +32,24 @@ class PDF::Reader
   class ObjectHash
     include Enumerable
 
+    #: type securityHandler = (
+    #|   PDF::Reader::NullSecurityHandler |
+    #|   PDF::Reader::AesV2SecurityHandler |
+    #|   PDF::Reader::Rc4SecurityHandler |
+    #|   PDF::Reader::AesV3SecurityHandler |
+    #|   PDF::Reader::UnimplementedSecurityHandler
+    #| )
+
+    #: untyped
     attr_accessor :default
-    attr_reader :trailer, :pdf_version
+
+    #: Hash[Symbol, untyped]
+    attr_reader :trailer
+
+    #: Float
+    attr_reader :pdf_version
+
+    #: securityHandler
     attr_reader :sec_handler
 
     # Creates a new ObjectHash object. Input can be a string with a valid filename
@@ -41,21 +59,25 @@ class PDF::Reader
     #
     #   :password - the user password to decrypt the source PDF
     #
+    #: ((IO | Tempfile | StringIO | String), ?Hash[Symbol, untyped]) -> void
     def initialize(input, opts = {})
-      @io          = extract_io_from(input)
-      @xref        = PDF::Reader::XRef.new(@io)
-      @pdf_version = read_version
-      @trailer     = @xref.trailer
-      @cache       = opts[:cache] || PDF::Reader::ObjectCache.new
-      @sec_handler = NullSecurityHandler.new
+      @io          = extract_io_from(input) #: IO | Tempfile | StringIO
+      @xref        = PDF::Reader::XRef.new(@io) #: PDF::Reader::XRef[PDF::Reader::Reference]
+      @pdf_version = read_version #: Float
+      @trailer     = @xref.trailer #: Hash[Symbol, untyped]
+      @cache       = opts[:cache] || PDF::Reader::ObjectCache.new #: PDF::Reader::ObjectCache
+      @sec_handler = NullSecurityHandler.new #: securityHandler
       @sec_handler = SecurityHandlerFactory.build(
         deref(trailer[:Encrypt]),
         deref(trailer[:ID]),
         opts[:password]
       )
+      @page_references = nil #: Array[PDF::Reader::Reference | Hash[Symbol, untyped]]?
+      @object_streams = nil #: Hash[PDF::Reader::Reference, PDF::Reader::ObjectStream]?
     end
 
     # returns the type of object a ref points to
+    #: ((Integer | PDF::Reader::Reference)) -> Symbol?
     def obj_type(ref)
       self[ref].class.to_s.to_sym
     rescue
@@ -63,6 +85,7 @@ class PDF::Reader
     end
 
     # returns true if the supplied references points to an object with a stream
+    #: ((Integer | PDF::Reader::Reference)) -> bool
     def stream?(ref)
       self.has_key?(ref) && self[ref].is_a?(PDF::Reader::Stream)
     end
@@ -76,6 +99,7 @@ class PDF::Reader
     # If a PDF::Reader::Reference object is used the exact ID and generation number
     # can be specified.
     #
+    #: ((Integer | PDF::Reader::Reference)) -> untyped
     def [](key)
       return default if key.to_i <= 0
 
@@ -91,6 +115,7 @@ class PDF::Reader
     # If key is a PDF::Reader::Reference object, lookup the corresponding
     # object in the PDF and return it. Otherwise return key untouched.
     #
+    #: (untyped) -> untyped
     def object(key)
       key.is_a?(PDF::Reader::Reference) ? self[key] : key
     end
@@ -102,6 +127,7 @@ class PDF::Reader
     # Guaranteed to only return an Array or nil. If the dereference results in
     # any other type then a MalformedPDFError exception will raise. Useful when
     # expecting an Array and no other type will do.
+    #: (untyped) -> Array[untyped]?
     def deref_array(key)
       obj = deref(key)
 
@@ -120,6 +146,7 @@ class PDF::Reader
     # expecting an Array and no other type will do.
     #
     # Some effort to cast array elements to a number is made for any non-numeric elements.
+    #: (untyped) -> Array[Numeric]?
     def deref_array_of_numbers(key)
       arr = deref(key)
 
@@ -146,6 +173,7 @@ class PDF::Reader
     # Guaranteed to only return a Hash or nil. If the dereference results in
     # any other type then a MalformedPDFError exception will raise. Useful when
     # expecting an Array and no other type will do.
+    #: (untyped) -> Hash[Symbol, untyped]?
     def deref_hash(key)
       obj = deref(key)
 
@@ -164,6 +192,7 @@ class PDF::Reader
     # expecting an Array and no other type will do.
     #
     # Some effort to cast to a symbol is made when the reference points to a non-symbol.
+    #: (untyped) -> Symbol?
     def deref_name(key)
       obj = deref(key)
 
@@ -188,6 +217,7 @@ class PDF::Reader
     # expecting an Array and no other type will do.
     #
     # Some effort to cast to an int is made when the reference points to a non-integer.
+    #: (untyped) -> Integer?
     def deref_integer(key)
       obj = deref(key)
 
@@ -212,6 +242,7 @@ class PDF::Reader
     # expecting an Array and no other type will do.
     #
     # Some effort to cast to a number is made when the reference points to a non-number.
+    #: (untyped) -> Numeric?
     def deref_number(key)
       obj = deref(key)
 
@@ -236,6 +267,7 @@ class PDF::Reader
     # Guaranteed to only return a PDF::Reader::Stream or nil. If the dereference results in
     # any other type then a MalformedPDFError exception will raise. Useful when
     # expecting a stream and no other type will do.
+    #: (untyped) -> PDF::Reader::Stream?
     def deref_stream(key)
       obj = deref(key)
 
@@ -243,7 +275,7 @@ class PDF::Reader
 
       obj.tap { |obj|
         if !obj.is_a?(PDF::Reader::Stream)
-          raise MalformedPDFError, "expected object to be an Array or nil"
+          raise MalformedPDFError, "expected object to be a Stream or nil"
         end
       }
     end
@@ -256,6 +288,7 @@ class PDF::Reader
     # expecting a string and no other type will do.
     #
     # Some effort to cast to a string is made when the reference points to a non-string.
+    #: (untyped) -> String?
     def deref_string(key)
       obj = deref(key)
 
@@ -278,6 +311,7 @@ class PDF::Reader
     # Guaranteed to only return a PDF Name (symbol), Array or nil. If the dereference results in
     # any other type then a MalformedPDFError exception will raise. Useful when
     # expecting a Name or Array and no other type will do.
+    #: (untyped) -> (Symbol | Array[untyped] | nil)
     def deref_name_or_array(key)
       obj = deref(key)
 
@@ -296,6 +330,7 @@ class PDF::Reader
     # Guaranteed to only return a PDF::Reader::Stream, Array or nil. If the dereference results in
     # any other type then a MalformedPDFError exception will raise. Useful when
     # expecting a stream or Array and no other type will do.
+    #: (untyped) -> (PDF::Reader::Stream | Array[untyped] | nil)
     def deref_stream_or_array(key)
       obj = deref(key)
 
@@ -311,10 +346,12 @@ class PDF::Reader
     # Recursively dereferences the object refered to be +key+. If +key+ is not
     # a PDF::Reader::Reference, the key is returned unchanged.
     #
+    #: (untyped) -> untyped
     def deref!(key)
       deref_internal!(key, {})
     end
 
+    #: (untyped) -> Array[untyped]?
     def deref_array!(key)
       deref!(key).tap { |obj|
         if !obj.nil? && !obj.is_a?(Array)
@@ -323,6 +360,7 @@ class PDF::Reader
       }
     end
 
+    #: (untyped) -> Hash[Symbol, untyped]?
     def deref_hash!(key)
       deref!(key).tap { |obj|
         if !obj.nil? && !obj.is_a?(Hash)
@@ -343,6 +381,7 @@ class PDF::Reader
     # local_default is the object that will be returned if the requested key doesn't
     # exist.
     #
+    #: (untyped, ?untyped) -> untyped
     def fetch(key, local_default = nil)
       obj = self[key]
       if obj
@@ -356,6 +395,8 @@ class PDF::Reader
 
     # iterate over each key, value. Just like a ruby hash.
     #
+    # @override(allow_incompatible: true)
+    #: () { (PDF::Reader::Reference, untyped) -> untyped } -> untyped
     def each(&block)
       @xref.each do |ref|
         yield ref, self[ref]
@@ -365,6 +406,7 @@ class PDF::Reader
 
     # iterate over each key. Just like a ruby hash.
     #
+    #: { (PDF::Reader::Reference) -> untyped } -> untyped
     def each_key(&block)
       each do |id, obj|
         yield id
@@ -373,6 +415,7 @@ class PDF::Reader
 
     # iterate over each value. Just like a ruby hash.
     #
+    #: { (untyped) -> untyped } -> untyped
     def each_value(&block)
       each do |id, obj|
         yield obj
@@ -381,6 +424,7 @@ class PDF::Reader
 
     # return the number of objects in the file. An object with multiple generations
     # is counted once.
+    #: () -> Integer
     def size
       xref.size
     end
@@ -388,6 +432,7 @@ class PDF::Reader
 
     # return true if there are no objects in this file
     #
+    #: () -> bool
     def empty?
       size == 0 ? true : false
     end
@@ -395,6 +440,7 @@ class PDF::Reader
     # return true if the specified key exists in the file. key
     # can be an int or a PDF::Reader::Reference
     #
+    #: (untyped) -> bool
     def has_key?(check_key)
       # TODO update from O(n) to O(1)
       each_key do |key|
@@ -412,6 +458,7 @@ class PDF::Reader
 
     # return true if the specifiedvalue exists in the file
     #
+    #: (untyped) -> bool
     def has_value?(value)
       # TODO update from O(n) to O(1)
       each_value do |obj|
@@ -421,12 +468,14 @@ class PDF::Reader
     end
     alias :value? :has_key?
 
+    #: () -> String
     def to_s
       "<PDF::Reader::ObjectHash size: #{self.size}>"
     end
 
     # return an array of all keys in the file
     #
+    #: () -> Array[PDF::Reader::Reference]
     def keys
       ret = []
       each_key { |k| ret << k }
@@ -435,6 +484,7 @@ class PDF::Reader
 
     # return an array of all values in the file
     #
+    #: () -> untyped
     def values
       ret = []
       each_value { |v| ret << v }
@@ -443,12 +493,14 @@ class PDF::Reader
 
     # return an array of all values from the specified keys
     #
+    #: (*untyped) -> untyped
     def values_at(*ids)
       ids.map { |id| self[id] }
     end
 
     # return an array of arrays. Each sub array contains a key/value pair.
     #
+    #: () -> untyped
     def to_a
       ret = []
       each do |id, obj|
@@ -463,6 +515,7 @@ class PDF::Reader
     #
     # Useful for apps that want to extract data from specific pages.
     #
+    #: () -> Array[PDF::Reader::Reference | Hash[Symbol, untyped]]
     def page_references
       root  = fetch(trailer[:Root])
       @page_references ||= begin
@@ -471,10 +524,12 @@ class PDF::Reader
                            end
     end
 
+    #: () -> bool
     def encrypted?
       trailer.has_key?(:Encrypt)
     end
 
+    #: () -> bool
     def sec_handler?
       !!sec_handler
     end
@@ -484,6 +539,17 @@ class PDF::Reader
     # parse a traditional object from the PDF, starting from the byte offset indicated
     # in the xref table
     #
+    #: (PDF::Reader::Reference) -> (
+    #|   PDF::Reader::Reference |
+    #|   PDF::Reader::Token |
+    #|   PDF::Reader::Stream |
+    #|   Numeric |
+    #|   String |
+    #|   Symbol |
+    #|   Array[untyped] |
+    #|   Hash[untyped, untyped] |
+    #|   nil
+    #| )
     def fetch_object(key)
       if xref[key].is_a?(Integer)
         buf = new_buffer(xref[key])
@@ -493,11 +559,25 @@ class PDF::Reader
 
     # parse a object that's embedded in an object stream in the PDF
     #
+    #: (PDF::Reader::Reference) -> (
+    #|   PDF::Reader::Reference |
+    #|   PDF::Reader::Token |
+    #|   PDF::Reader::Stream |
+    #|   Numeric |
+    #|   String |
+    #|   Symbol |
+    #|   Array[untyped] |
+    #|   Hash[untyped, untyped] |
+    #|   nil
+    #| )
     def fetch_object_stream(key)
       if xref[key].is_a?(PDF::Reader::Reference)
         container_key = xref[key]
-        object_streams[container_key] ||= PDF::Reader::ObjectStream.new(object(container_key))
-        object_streams[container_key][key.id]
+        stream = deref_stream(container_key)
+        raise MalformedPDFError, "Object Stream cannot be nil" if stream.nil?
+        if objstream = object_streams[container_key] ||= PDF::Reader::ObjectStream.new(stream)
+          objstream[key.id]
+        end
       end
     end
 
@@ -505,6 +585,17 @@ class PDF::Reader
     # isn't publicly available. It's used to avoid endless loops in the recursion, and
     # doesn't need to be part of the public API.
     #
+    #: (untyped, Hash[Integer, untyped]) -> (
+    #|   PDF::Reader::Reference |
+    #|   PDF::Reader::Token |
+    #|   PDF::Reader::Stream |
+    #|   Numeric |
+    #|   String |
+    #|   Symbol |
+    #|   Array[untyped] |
+    #|   Hash[untyped, untyped] |
+    #|   nil
+    #| )
     def deref_internal!(key, seen)
       seen_key = key.is_a?(PDF::Reader::Reference) ? key : key.object_id
 
@@ -534,6 +625,17 @@ class PDF::Reader
       end
     end
 
+    #: (PDF::Reader::Reference, untyped) -> (
+    #|   PDF::Reader::Reference |
+    #|   PDF::Reader::Token |
+    #|   PDF::Reader::Stream |
+    #|   Numeric |
+    #|   String |
+    #|   Symbol |
+    #|   Array[untyped] |
+    #|   Hash[untyped, untyped] |
+    #|   nil
+    #| )
     def decrypt(ref, obj)
       case obj
       when PDF::Reader::Stream then
@@ -555,25 +657,33 @@ class PDF::Reader
       end
     end
 
+    #: (?Integer) -> PDF::Reader::Buffer
     def new_buffer(offset = 0)
       PDF::Reader::Buffer.new(@io, :seek => offset)
     end
 
+    #: () -> PDF::Reader::XRef[PDF::Reader::Reference]
     def xref
       @xref
     end
 
+    #: () -> Hash[PDF::Reader::Reference, PDF::Reader::ObjectStream]
     def object_streams
-      @object_stream ||= {}
+      @object_streams ||= {}
     end
 
     # returns an array of object references for all pages in this object store. The ordering of
     # the Array is significant and matches the page ordering of the document
     #
+    #: (PDF::Reader::Reference | Hash[Symbol, untyped]) -> (
+    #|   Array[PDF::Reader::Reference | Hash[Symbol, untyped] ]
+    #| )
     def get_page_objects(obj)
       derefed_obj = deref_hash(obj)
 
-      if derefed_obj[:Type] == :Page
+      if derefed_obj.nil?
+        raise MalformedPDFError, "Expected Page or Pages object, got nil"
+      elsif derefed_obj[:Type] == :Page
         [obj]
       elsif derefed_obj[:Kids]
         kids = deref_array(derefed_obj[:Kids]) || []
@@ -585,23 +695,26 @@ class PDF::Reader
       end
     end
 
+    #: () -> Float
     def read_version
       @io.seek(0)
-      _m, version = *@io.read(10).match(/PDF-(\d.\d)/)
+      _m, version = *@io.read(10).to_s.match(/PDF-(\d.\d)/)
       @io.seek(0)
       version.to_f
     end
 
+    #: (IO | Tempfile | StringIO | String) -> (IO | Tempfile | StringIO)
     def extract_io_from(input)
-      if input.respond_to?(:seek) && input.respond_to?(:read)
+      if input.is_a?(IO) || input.is_a?(StringIO) || input.is_a?(Tempfile)
         input
       elsif File.file?(input.to_s)
-        StringIO.new read_as_binary(input)
+        StringIO.new read_as_binary(input.to_s)
       else
-        raise ArgumentError, "input must be an IO-like object or a filename"
+        raise ArgumentError, "input must be an IO-like object or a filename (#{input.class})"
       end
     end
 
+    #: (String) -> (String)
     def read_as_binary(input)
       if File.respond_to?(:binread)
         File.binread(input.to_s)

data/lib/pdf/reader/object_stream.rb

@@ -1,5 +1,5 @@
 # coding: utf-8
-# typed: true
+# typed: strict
 # frozen_string_literal: true
 
 class PDF::Reader
@@ -8,11 +8,24 @@ class PDF::Reader
   # This is done for added compression and is described as an "Object Stream" in the spec.
   #
   class ObjectStream # :nodoc:
+    #: (PDF::Reader::Stream) -> void
     def initialize(stream)
-      @dict = stream.hash
-      @data = stream.unfiltered_data
+      @dict = stream.hash #: Hash[Symbol, untyped]
+      @data = stream.unfiltered_data #: String
+      @offsets = nil #: Hash[Integer, Integer] | nil
+      @buffer = nil #: PDF::Reader::Buffer | nil
     end
 
+    #: (Integer) -> (
+    #|   PDF::Reader::Reference |
+    #|   PDF::Reader::Token |
+    #|   Numeric |
+    #|   String |
+    #|   Symbol |
+    #|   Array[untyped] |
+    #|   Hash[untyped, untyped] |
+    #|   nil
+    #| )
     def [](objid)
       if offsets[objid].nil?
         nil
@@ -23,12 +36,14 @@ class PDF::Reader
       end
     end
 
+    #: () -> Integer
     def size
-      @dict[:N]
+      TypeCheck.cast_to_int!(@dict[:N])
     end
 
     private
 
+    #: () -> Hash[Integer, Integer]
     def offsets
       @offsets ||= {}
       return @offsets if @offsets.keys.size > 0
@@ -39,10 +54,12 @@ class PDF::Reader
       @offsets
     end
 
+    #: () -> Integer
     def first
-      @dict[:First]
+      TypeCheck.cast_to_int!(@dict[:First])
     end
 
+    #: () -> PDF::Reader::Buffer
     def buffer
       @buffer ||= PDF::Reader::Buffer.new(StringIO.new(@data))
     end