pdf-reader 2.9.2 → 2.15.0

data/lib/pdf/reader/print_receiver.rb

@@ -8,16 +8,12 @@ class PDF::Reader
   #
   class PrintReceiver
 
-    attr_accessor :callbacks
-
-    def initialize
-      @callbacks = []
-    end
-
+    #: (untyped) -> bool
     def respond_to?(meth)
       true
     end
 
+    #: (Symbol, *untyped) -> void
     def method_missing(methodname, *args)
       puts "#{methodname} => #{args.inspect}"
     end

data/lib/pdf/reader/rc4_security_handler.rb

@@ -12,6 +12,7 @@ class PDF::Reader
   #
   class Rc4SecurityHandler
 
+    #: (String) -> void
     def initialize(key)
       @encrypt_key = key
     end
@@ -25,6 +26,7 @@ class PDF::Reader
     # buf - a string to decrypt
     # ref - a PDF::Reader::Reference for the object to decrypt
     #
+    #: (String, PDF::Reader::Reference) -> String
     def decrypt( buf, ref )
       objKey = @encrypt_key.dup
       (0..2).each { |e| objKey << (ref.id >> e*8 & 0xFF ) }

data/lib/pdf/reader/rectangle.rb

@@ -20,12 +20,28 @@ module PDF
     #
     class Rectangle
 
-      attr_reader :bottom_left, :bottom_right, :top_left, :top_right
+      #: PDF::Reader::Point
+      attr_reader :bottom_left
 
+      #: PDF::Reader::Point
+      attr_reader :bottom_right
+
+      #: PDF::Reader::Point
+      attr_reader :top_left
+
+      #: PDF::Reader::Point
+      attr_reader :top_right
+
+      #: (Numeric, Numeric, Numeric, Numeric) -> void
       def initialize(x1, y1, x2, y2)
+        @bottom_left = Point.new(0,0) #: PDF::Reader::Point
+        @bottom_right = Point.new(0,0) #: PDF::Reader::Point
+        @top_left = Point.new(0,0) #: PDF::Reader::Point
+        @top_right = Point.new(0,0) #: PDF::Reader::Point
         set_corners(x1, y1, x2, y2)
       end
 
+      #: (Array[Numeric]) -> PDF::Reader::Rectangle
       def self.from_array(arr)
         if arr.size != 4
           raise ArgumentError, "Only 4-element Arrays can be converted to a Rectangle"
@@ -39,24 +55,29 @@ module PDF
         )
       end
 
+      #: (PDF::Reader::Rectangle) -> bool
       def ==(other)
         to_a == other.to_a
       end
 
+      #: () -> Numeric
       def height
         top_right.y - bottom_right.y
       end
 
+      #: () -> Numeric
       def width
         bottom_right.x - bottom_left.x
       end
 
+      #: (PDF::Reader::Point) -> bool
       def contains?(point)
         point.x >= bottom_left.x && point.x <= top_right.x &&
           point.y >= bottom_left.y && point.y <= top_right.y
       end
 
       # A pdf-style 4-number array
+      #: () -> Array[Numeric]
       def to_a
         [
           bottom_left.x,
@@ -66,6 +87,7 @@ module PDF
         ]
       end
 
+      #: (Integer) -> void
       def apply_rotation(degrees)
         return if degrees != 90 && degrees != 180 && degrees != 270
 
@@ -90,6 +112,7 @@ module PDF
 
       private
 
+      #: (Numeric, Numeric, Numeric, Numeric) -> void
       def set_corners(x1, y1, x2, y2)
         @bottom_left = PDF::Reader::Point.new(
           [x1, x2].min,

data/lib/pdf/reader/reference.rb

@@ -1,5 +1,5 @@
 # coding: utf-8
-# typed: true
+# typed: strict
 # frozen_string_literal: true
 
 ################################################################################
@@ -31,25 +31,34 @@ class PDF::Reader
   ################################################################################
   # An internal PDF::Reader class that represents an indirect reference to a PDF Object
   class Reference
-    attr_reader :id, :gen
+    #: Integer
+    attr_reader :id
+
+    #: Integer
+    attr_reader :gen
     ################################################################################
     # Create a new Reference to an object with the specified id and revision number
+    #: (Integer, Integer) -> void
     def initialize(id, gen)
-      @id, @gen = id, gen
+      @id = id
+      @gen = gen
     end
     ################################################################################
     # returns the current Reference object in an array with a single element
+    #: () -> Array[PDF::Reader::Reference]
     def to_a
       [self]
     end
     ################################################################################
     # returns the ID of this reference. Use with caution, ignores the generation id
+    #: () -> Integer
     def to_i
       self.id
     end
     ################################################################################
     # returns true if the provided object points to the same PDF Object as the
     # current object
+    #: (Object) -> bool
     def ==(obj)
       return false unless obj.kind_of?(PDF::Reader::Reference)
 
@@ -60,6 +69,7 @@ class PDF::Reader
     # returns a hash based on the PDF::Reference this object points to. Two
     # different Reference objects that point to the same PDF Object will
     # return an identical hash
+    #: () -> Integer
     def hash
       "#{self.id}:#{self.gen}".hash
     end

data/lib/pdf/reader/register_receiver.rb

@@ -22,45 +22,55 @@ class PDF::Reader
   #
   class RegisterReceiver
 
+    #: Array[Hash[Symbol, untyped]]
     attr_accessor :callbacks
 
+    #: () -> void
     def initialize
-      @callbacks = []
+      @callbacks = [] #: Array[Hash[Symbol, untyped]]
     end
 
+    #: (untyped) -> bool
     def respond_to?(meth)
       true
     end
 
+    #: (Symbol, *untyped) -> void
     def method_missing(methodname, *args)
       callbacks << {:name => methodname.to_sym, :args => args}
     end
 
     # count the number of times a callback fired
+    #: (Symbol) -> Integer
     def count(methodname)
       callbacks.count { |cb| cb[:name] == methodname}
     end
 
     # return the details for every time the specified callback was fired
+    #: (Symbol) -> Array[Hash[Symbol, untyped]]
     def all(methodname)
       callbacks.select { |cb| cb[:name] == methodname }
     end
 
+    #: (Symbol) -> Array[Array[untyped]]
     def all_args(methodname)
       all(methodname).map { |cb| cb[:args] }
     end
 
     # return the details for the first time the specified callback was fired
+    #: (Symbol) -> Hash[Symbol, untyped]?
     def first_occurance_of(methodname)
       callbacks.find { |cb| cb[:name] == methodname }
     end
 
     # return the details for the final time the specified callback was fired
+    #: (Symbol) -> Hash[Symbol, untyped]?
     def final_occurance_of(methodname)
       all(methodname).last
     end
 
     # return the first occurance of a particular series of callbacks
+    #: (*Symbol) -> Array[Hash[Symbol, untyped]]?
     def series(*methods)
       return nil if methods.empty?
 
@@ -70,7 +80,10 @@ class PDF::Reader
       indexes.each do |idx|
         count = methods.size
         method_indexes.each do |midx|
-          count -= 1 if callbacks[idx+midx] && callbacks[idx+midx][:name] == methods[midx]
+          res = callbacks[idx+midx]
+          if res && res[:name] == methods[midx]
+            count -= 1
+          end
         end
         if count == 0
           return callbacks[idx, methods.size]

data/lib/pdf/reader/resources.rb

@@ -1,5 +1,5 @@
 # coding: utf-8
-# typed: true
+# typed: strict
 # frozen_string_literal: true
 
 module PDF
@@ -9,6 +9,7 @@ module PDF
     #
     class Resources
 
+      #: (PDF::Reader::ObjectHash, Hash[untyped, untyped]) -> void
       def initialize(objects, resources)
         @objects = objects
         @resources = resources
@@ -20,6 +21,7 @@ module PDF
       #       with no caching. You will want to cache the results instead
       #       of calling it over and over.
       #
+      #: () -> Hash[Symbol, untyped]
       def color_spaces
         @objects.deref_hash!(@resources[:ColorSpace]) || {}
       end
@@ -30,6 +32,7 @@ module PDF
       #       with no caching. You will want to cache the results instead
       #       of calling it over and over.
       #
+      #: () -> Hash[Symbol, untyped]
       def fonts
         @objects.deref_hash!(@resources[:Font]) || {}
       end
@@ -41,6 +44,7 @@ module PDF
       #       with no caching. You will want to cache the results instead
       #       of calling it over and over.
       #
+      #: () -> Hash[Symbol, untyped]
       def graphic_states
         @objects.deref_hash!(@resources[:ExtGState]) || {}
       end
@@ -51,6 +55,7 @@ module PDF
       #       with no caching. You will want to cache the results instead
       #       of calling it over and over.
       #
+      #: () -> Hash[Symbol, untyped]
       def patterns
         @objects.deref_hash!(@resources[:Pattern]) || {}
       end
@@ -61,6 +66,7 @@ module PDF
       #       with no caching. You will want to cache the results instead
       #       of calling it over and over.
       #
+      #: () -> Array[Symbol]
       def procedure_sets
         @objects.deref_array!(@resources[:ProcSet]) || []
       end
@@ -71,6 +77,7 @@ module PDF
       #       with no caching. You will want to cache the results instead
       #       of calling it over and over.
       #
+      #: () -> Hash[Symbol, untyped]
       def properties
         @objects.deref_hash!(@resources[:Properties]) || {}
       end
@@ -81,6 +88,7 @@ module PDF
       #       with no caching. You will want to cache the results instead
       #       of calling it over and over.
       #
+      #: () -> Hash[Symbol, untyped]
       def shadings
         @objects.deref_hash!(@resources[:Shading]) || {}
       end
@@ -91,8 +99,10 @@ module PDF
       #       with no caching. You will want to cache the results instead
       #       of calling it over and over.
       #
+      #: () -> Hash[Symbol, PDF::Reader::Stream]
       def xobjects
-        @objects.deref_hash!(@resources[:XObject]) || {}
+        dict = @objects.deref_hash!(@resources[:XObject]) || {}
+        TypeCheck.cast_to_pdf_dict_with_stream_values!(dict)
       end
 
     end

data/lib/pdf/reader/security_handler_factory.rb

@@ -7,6 +7,13 @@ class PDF::Reader
   # able to decrypt the file.
   class SecurityHandlerFactory
 
+    #: (Hash[Symbol, untyped], Array[untyped] | nil, String | nil) -> (
+    #|   NullSecurityHandler |
+    #|   AesV2SecurityHandler |
+    #|   Rc4SecurityHandler |
+    #|   AesV3SecurityHandler |
+    #|   UnimplementedSecurityHandler
+    #| )
     def self.build(encrypt, doc_id, password)
       doc_id   ||= []
       password ||= ""
@@ -22,6 +29,9 @@ class PDF::Reader
       end
     end
 
+    #: (Hash[Symbol, untyped], Array[untyped], String) -> (
+    #|    AesV2SecurityHandler | Rc4SecurityHandler
+    #| )
     def self.build_standard_handler(encrypt, doc_id, password)
       encmeta = !encrypt.has_key?(:EncryptMetadata) || encrypt[:EncryptMetadata].to_s == "true"
       key_builder = StandardKeyBuilder.new(
@@ -41,6 +51,7 @@ class PDF::Reader
       end
     end
 
+    #: (Hash[Symbol, untyped], Array[untyped], String) -> (AesV3SecurityHandler)
     def self.build_v5_handler(encrypt, doc_id, password)
       key_builder = KeyBuilderV5.new(
         owner_key: encrypt[:O],
@@ -52,6 +63,7 @@ class PDF::Reader
     end
 
     # This handler supports all encryption that follows upto PDF 1.5 spec (revision 4)
+    #: (Hash[Symbol, untyped]) -> bool
     def self.standard?(encrypt)
       return false if encrypt.nil?
 
@@ -65,6 +77,7 @@ class PDF::Reader
     # This handler supports both
     # - AES-256 encryption defined in PDF 1.7 Extension Level 3 ('revision 5')
     # - AES-256 encryption defined in PDF 2.0 ('revision 6')
+    #: (Hash[Symbol, untyped]) -> untyped
     def self.standard_v5?(encrypt)
       return false if encrypt.nil?
 

data/lib/pdf/reader/standard_key_builder.rb

@@ -1,4 +1,5 @@
 # coding: utf-8
+# typed: strict
 
 require 'digest/md5'
 require 'rc4'
@@ -23,16 +24,17 @@ class PDF::Reader
     PassPadBytes = [ 0x28, 0xbf, 0x4e, 0x5e, 0x4e, 0x75, 0x8a, 0x41,
                      0x64, 0x00, 0x4e, 0x56, 0xff, 0xfa, 0x01, 0x08,
                      0x2e, 0x2e, 0x00, 0xb6, 0xd0, 0x68, 0x3e, 0x80,
-                     0x2f, 0x0c, 0xa9, 0xfe, 0x64, 0x53, 0x69, 0x7a ]
+                     0x2f, 0x0c, 0xa9, 0xfe, 0x64, 0x53, 0x69, 0x7a ] #: Array[Integer]
 
+    #: (?Hash[Symbol, untyped]) -> void
     def initialize(opts = {})
-      @key_length    = opts[:key_length].to_i/8
-      @revision      = opts[:revision].to_i
-      @owner_key     = opts[:owner_key]
-      @user_key      = opts[:user_key]
-      @permissions   = opts[:permissions].to_i
-      @encryptMeta   = opts.fetch(:encrypted_metadata, true)
-      @file_id       = opts[:file_id] || ""
+      @key_length    = opts[:key_length].to_i/8 #: Integer
+      @revision      = opts[:revision].to_i #: Integer
+      @owner_key     = opts[:owner_key] #: String?
+      @user_key      = opts[:user_key] #: String?
+      @permissions   = opts[:permissions].to_i #: Integer
+      @encryptMeta   = opts.fetch(:encrypted_metadata, true) #: bool
+      @file_id       = opts[:file_id] || "" #: String
 
       if @key_length != 5 && @key_length != 16
         msg = "StandardKeyBuilder only supports 40 and 128 bit\
@@ -47,8 +49,8 @@ class PDF::Reader
     # decrypting the file will be returned. If the password doesn't match the file,
     # and exception will be raised.
     #
-    def key(pass)
-      pass ||= ""
+    #: (?String) -> String
+    def key(pass = "")
       encrypt_key   = auth_owner_pass(pass)
       encrypt_key ||= auth_user_pass(pass)
 
@@ -60,14 +62,17 @@ class PDF::Reader
 
     # Pads supplied password to 32bytes using PassPadBytes as specified on
     # pp61 of spec
+    #
+    #: (?String?) -> String
     def pad_pass(p="")
-      if p.nil? || p.empty?
-        PassPadBytes.pack('C*')
-      else
-        p[0, 32] + PassPadBytes[0, 32-p.length].pack('C*')
-      end
+      return PassPadBytes.pack('C*') if p.nil? || p.empty?
+
+      pTrimmedLength = [p.bytesize, 32].min
+      pad = PassPadBytes[0, 32 - pTrimmedLength] || []
+      p[0, 32].to_s + pad.pack('C*')
     end
 
+    #: (String, Integer) -> String
     def xor_each_byte(buf, int)
       buf.each_byte.map{ |b| b^int}.pack("C*")
     end
@@ -84,6 +89,7 @@ class PDF::Reader
     # if the supplied password is not a valid owner password for this document
     # then it returns nil
     #
+    #: (String) -> String?
     def auth_owner_pass(pass)
       md5 = Digest::MD5.digest(pad_pass(pass))
       if @revision > 2 then
@@ -92,7 +98,13 @@ class PDF::Reader
         #first iteration decrypt owner_key
         out = @owner_key
         #RC4 keyed with (keyBegins XOR with iteration #) to decrypt previous out
-        19.downto(0).each { |i| out=RC4.new(xor_each_byte(keyBegins,i)).decrypt(out) }
+        19.downto(0).each { |i|
+          # The RC4 gem doen't have type annotations, so the type checker doesn't
+          # know decrypt() returns a string
+          out = TypeCheck.cast_to_string!(
+            RC4.new(xor_each_byte(keyBegins,i)).decrypt(out)
+          )
+        }
       else
         out = RC4.new( md5[0, 5] ).decrypt( @owner_key )
       end
@@ -110,6 +122,7 @@ class PDF::Reader
     # if the supplied password is not a valid user password for this document
     # then it returns nil
     #
+    #: (String) -> String?
     def auth_user_pass(pass)
       keyBegins = make_file_key(pass)
       if @revision >= 3
@@ -117,28 +130,29 @@ class PDF::Reader
         out = Digest::MD5.digest(PassPadBytes.pack("C*") + @file_id)
         #zero doesn't matter -> so from 0-19
         20.times{ |i| out=RC4.new(xor_each_byte(keyBegins, i)).encrypt(out) }
-        pass = @user_key[0, 16] == out
+        pass = @user_key.to_s[0, 16] == out
       else
         pass = RC4.new(keyBegins).encrypt(PassPadBytes.pack("C*")) == @user_key
       end
       pass ? keyBegins : nil
     end
 
+    #: (String) -> String
     def make_file_key( user_pass )
       # a) if there's a password, pad it to 32 bytes, else, just use the padding.
-      @buf  = pad_pass(user_pass)
+      buf  = pad_pass(user_pass)
       # c) add owner key
-      @buf << @owner_key
+      buf << @owner_key
       # d) add permissions 1 byte at a time, in little-endian order
-      (0..24).step(8){|e| @buf << (@permissions >> e & 0xFF)}
+      (0..24).step(8){|e| buf << (@permissions >> e & 0xFF)}
       # e) add the file ID
-      @buf << @file_id
+      buf << @file_id
       # f) if revision >= 4 and metadata not encrypted then add 4 bytes of 0xFF
       if @revision >= 4 && !@encryptMeta
-        @buf << [0xFF,0xFF,0xFF,0xFF].pack('C*')
+        buf << [0xFF,0xFF,0xFF,0xFF].pack('C*')
       end
       # b) init MD5 digest + g) finish the hash
-      md5 = Digest::MD5.digest(@buf)
+      md5 = Digest::MD5.digest(buf)
       # h) spin hash 50 times
       if @revision >= 3
         50.times {

data/lib/pdf/reader/stream.rb

@@ -34,18 +34,24 @@ class PDF::Reader
   # compression, etc) and a stream of bytes.
   #
   class Stream
-    attr_accessor :hash, :data
+    #: Hash[Symbol, untyped]
+    attr_accessor :hash
+
+    #: String
+    attr_accessor :data
 
     ################################################################################
     # Creates a new stream with the specified dictionary and data. The dictionary
     # should be a standard ruby hash, the data should be a standard ruby string.
+    #: (Hash[Symbol, untyped], String) -> void
     def initialize(hash, data)
-      @hash = hash
+      @hash = TypeCheck.cast_to_pdf_dict!(hash) #: Hash[Symbol, untyped]
       @data = data
-      @udata = nil
+      @udata = nil #: String | nil
     end
     ################################################################################
     # apply this streams filters to its data and return the result.
+    #: () -> String
     def unfiltered_data
       return @udata if @udata
       @udata = data.dup

data/lib/pdf/reader/synchronized_cache.rb

@@ -1,5 +1,5 @@
 # encoding: utf-8
-# typed: true
+# typed: strict
 # frozen_string_literal: true
 
 # utilities.rb : General-purpose utility classes which don't fit anywhere else
@@ -20,13 +20,16 @@ class PDF::Reader
   # same time, we don't want to throw away thread safety We have two
   # interchangeable thread-safe cache implementations:
   class SynchronizedCache
+    #: () -> void
     def initialize
-      @cache = {}
-      @mutex = Mutex.new
+      @cache = {} #: Hash[Object, untyped]
+      @mutex = Mutex.new #: Mutex
     end
+    #: (Object) -> untyped
     def [](key)
       @mutex.synchronize { @cache[key] }
     end
+    #: (Object, (Object | nil)) -> untyped
     def []=(key,value)
       @mutex.synchronize { @cache[key] = value }
     end

data/lib/pdf/reader/text_run.rb

@@ -1,5 +1,5 @@
 # coding: utf-8
-# typed: true
+# typed: strict
 # frozen_string_literal: true
 
 class PDF::Reader
@@ -7,19 +7,34 @@ class PDF::Reader
   class TextRun
     include Comparable
 
-    attr_reader :origin, :width, :font_size, :text
+    #: PDF::Reader::Point
+    attr_reader :origin
+
+    #: Numeric
+    attr_reader :width
+
+    #: Numeric
+    attr_reader :font_size
+
+    #: String
+    attr_reader :text
 
     alias :to_s :text
 
+    #: (Numeric, Numeric, Numeric, Numeric, String) -> void
     def initialize(x, y, width, font_size, text)
-      @origin = PDF::Reader::Point.new(x, y)
+      @origin = PDF::Reader::Point.new(x, y) #: PDF::Reader::Point
       @width = width
       @font_size = font_size
       @text = text
+      @endx = nil #: Numeric | nil
+      @endy = nil #: Numeric | nil
+      @mergable_range = nil #: Range[Numeric] | nil
     end
 
     # Allows collections of TextRun objects to be sorted. They will be sorted
     # in order of their position on a cartesian plain - Top Left to Bottom Right
+    #: (PDF::Reader::Point) -> Numeric
     def <=>(other)
       if x == other.x && y == other.y
         0
@@ -31,33 +46,42 @@ class PDF::Reader
         -1
       elsif x > other.x
         1
+      else
+        0 # Unreachable?
       end
     end
 
+    #: () -> Numeric
     def x
       @origin.x
     end
 
+    #: () -> Numeric
     def y
       @origin.y
     end
 
+    #: () -> Numeric
     def endx
       @endx ||= @origin.x + width
     end
 
+    #: () -> Numeric
     def endy
       @endy ||= @origin.y + font_size
     end
 
+    #: () -> Numeric
     def mean_character_width
       @width / character_count
     end
 
+    #: (PDF::Reader::TextRun) -> bool
     def mergable?(other)
       y.to_i == other.y.to_i && font_size == other.font_size && mergable_range.include?(other.x)
     end
 
+    #: (PDF::Reader::TextRun) -> PDF::Reader::TextRun
     def +(other)
       raise ArgumentError, "#{other} cannot be merged with this run" unless mergable?(other)
 
@@ -68,16 +92,19 @@ class PDF::Reader
       end
     end
 
+    #: () -> String
     def inspect
       "#{text} w:#{width} f:#{font_size} @#{x},#{y}"
     end
 
+    #: (PDF::Reader::TextRun) -> bool
     def intersect?(other_run)
       x <= other_run.endx && endx >= other_run.x &&
         endy >= other_run.y && y <= other_run.endy
     end
 
     # return what percentage of this text run is overlapped by another run
+    #: (PDF::Reader::TextRun) -> Numeric
     def intersection_area_percent(other_run)
       return 0 unless intersect?(other_run)
 
@@ -90,16 +117,19 @@ class PDF::Reader
 
     private
 
+    #: () -> Numeric
     def area
       (endx - x) * (endy - y)
     end
 
+    #: () -> Range[Numeric]
     def mergable_range
       @mergable_range ||= Range.new(endx - 3, endx + font_size)
     end
 
     # Assume string encoding is marked correctly and we can trust String#size to return a
     # character count
+    #: () -> Float
     def character_count
       @text.size.to_f
     end

data/lib/pdf/reader/token.rb

@@ -35,6 +35,7 @@ class PDF::Reader
   class Token < String # :nodoc:
     ################################################################################
     # Creates a new token with the specified value
+    #: (untyped) -> void
     def initialize(val)
       super
     end