manual fixes after amp did its thing

In teh previous commit I used amp [1] to start converting the RBI file into
inline RBS style type annotations. It got me a fair way, but..... I spent
enough money on the experiment and it was gonna cost a whole lot more to
get it done. If I'd even get there.

I flipped into manual fixup mode and got `srb tc` passing.

[1] https://ampcode.com/manual

Author: yob

lib/pdf/reader.rb

@@ -118,9 +118,11 @@ class Reader
     #
     #: (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

lib/pdf/reader/advanced_text_run_filter.rb

@@ -60,7 +60,7 @@ def self.exclude(text_runs, filter_hash)
 
     #: Array[PDF::Reader::TextRun]
     attr_reader :text_runs
-    
+
     #: Hash[Symbol, untyped]
     attr_reader :filter_hash
 
@@ -70,18 +70,21 @@ def initialize(text_runs, filter_hash)
       @filter_hash = filter_hash
     end
 
+    #: () -> Array[PDF::Reader::TextRun]
     def only
       return text_runs if filter_hash.empty?
       text_runs.select { |text_run| evaluate_filter(text_run) }
     end
 
+    #: () -> Array[PDF::Reader::TextRun]
     def exclude
       return text_runs if filter_hash.empty?
       text_runs.reject { |text_run| evaluate_filter(text_run) }
     end
 
     private
 
+    #: (PDF::Reader::TextRun) -> bool
     def evaluate_filter(text_run)
       if filter_hash[:or]
         evaluate_or_filters(text_run, filter_hash[:or])
@@ -92,24 +95,28 @@ def evaluate_filter(text_run)
       end
     end
 
+    #: (PDF::Reader::TextRun, Array[Hash[Symbol, untyped]]) -> bool
     def evaluate_or_filters(text_run, conditions)
       conditions.any? do |condition|
         evaluate_filters(text_run, condition)
       end
     end
 
+    #: (PDF::Reader::TextRun, Array[Hash[Symbol, untyped]]) -> bool
     def evaluate_and_filters(text_run, conditions)
       conditions.all? do |condition|
         evaluate_filters(text_run, condition)
       end
     end
 
+    #: (PDF::Reader::TextRun, Hash[Symbol, untyped]) -> bool
     def evaluate_filters(text_run, filter_hash)
       filter_hash.all? do |attribute, conditions|
         evaluate_attribute_conditions(text_run, attribute, conditions)
       end
     end
 
+    #: (PDF::Reader::TextRun, Symbol, Hash[Symbol, untyped]) -> bool
     def evaluate_attribute_conditions(text_run, attribute, conditions)
       conditions.all? do |operator, value|
         unless VALID_OPERATORS.include?(operator)
@@ -120,6 +127,7 @@ def evaluate_attribute_conditions(text_run, attribute, conditions)
       end
     end
 
+    #: (untyped, Symbol, untyped) -> bool
     def apply_operator(attribute_value, operator, filter_value)
       case operator
       when :equal

lib/pdf/reader/aes_v3_security_handler.rb

@@ -15,7 +15,7 @@ class AesV3SecurityHandler
     #: (String) -> void
     def initialize(key)
       @encrypt_key = key
-      @cipher = "AES-256-CBC"
+      @cipher = "AES-256-CBC" #: String
     end
 
     ##7.6.2 General Encryption Algorithm

lib/pdf/reader/buffer.rb

@@ -80,11 +80,11 @@ class Buffer
     #: ((StringIO | Tempfile | IO), ?Hash[Symbol, untyped]) -> void
     def initialize(io, opts = {})
       @io = io
-      @tokens = []
-      @in_content_stream = opts[:content_stream]
+      @tokens = [] #: Array[String | PDF::Reader::Reference]
+      @in_content_stream = opts[:content_stream] #: bool
 
       @io.seek(opts[:seek]) if opts[:seek]
-      @pos = @io.pos
+      @pos = @io.pos #: Integer
     end
 
     # return true if there are no more tokens left
@@ -202,6 +202,7 @@ def save_pos
 
     # attempt to prime the buffer with the next few tokens.
     #
+    #: () -> void
     def prepare_tokens
       10.times do
         case state
@@ -218,6 +219,7 @@ def prepare_tokens
     # tokenising behaves slightly differently based on the current context.
     # Determine the current context/state by examining the last token we found
     #
+    #: () -> Symbol
     def state
       case @tokens.last
       when LEFT_PAREN then :literal_string
@@ -246,6 +248,7 @@ def state
     # indirect reference, so test for that case first and avoid the relatively
     # expensive regexp checks if possible.
     #
+    #: () -> void
     def merge_indirect_reference
       return if @tokens.size < 3
       return if @tokens[2] != "R"
@@ -263,6 +266,7 @@ def merge_indirect_reference
     # If the EI follows white-space the space is dropped from the data
     # The EI must followed by white-space or end of buffer
     # This is to reduce the chance of accidentally matching an embedded EI
+    #: () -> void
     def prepare_inline_token
       idstart = @io.pos
       prevchr = ''
@@ -309,6 +313,7 @@ def prepare_inline_token
     # if we're currently inside a hex string, read hex nibbles until
     # we find a closing >
     #
+    #: () -> void
     def prepare_hex_token
       str = "".dup
 
@@ -338,6 +343,7 @@ def prepare_hex_token
     # processing to fix things like escaped new lines, but that's someone else's
     # problem.
     #
+    #: () -> void
     def prepare_literal_token
       str = "".dup
       count = 1
@@ -368,6 +374,7 @@ def prepare_literal_token
     # What each byte means is complex, check out section "3.1.1 Character Set" of the 1.7 spec
     # to read up on it.
     #
+    #: () -> void
     def prepare_regular_token
       tok = "".dup
 
@@ -445,6 +452,7 @@ def prepare_regular_token
     # peek at the next character in the io stream, leaving the stream position
     # untouched
     #
+    #: () -> (Integer | nil)
     def peek_byte
       byte = @io.getbyte
       @io.seek(-1, IO::SEEK_CUR) if byte

lib/pdf/reader/cid_widths.rb

@@ -18,12 +18,14 @@ class CidWidths
     # Graphics State Operators
     def_delegators :@widths, :[], :fetch
 
+    #: (Numeric, Array[Numeric]) -> void
     def initialize(default, array)
-      @widths = parse_array(default, array.dup)
+      @widths = parse_array(default, array.dup) #: Hash[Numeric, Numeric]
     end
 
     private
 
+    #: (Numeric, Array[Numeric]) -> Hash[Numeric, Numeric]
     def parse_array(default, array)
       widths  = Hash.new(default)
       params = []
@@ -43,6 +45,8 @@ def parse_array(default, array)
 
     # this is the form 10 [234 63 234 346 47 234] where width of index 10 is
     # 234, index 11 is 63, etc
+    #
+    #: (Integer, Array[Numeric]) -> Hash[Numeric, Numeric]
     def parse_first_form(first, widths)
       widths.inject({}) { |accum, glyph_width|
         accum[first + accum.size] = glyph_width
@@ -51,6 +55,8 @@ def parse_first_form(first, widths)
     end
 
     # this is the form 10 20 123 where all index between 10 and 20 have width 123
+    #
+    #: (Integer, Integer, Numeric) -> Hash[Numeric, Numeric]
     def parse_second_form(first, final, width)
       if first > final
         raise MalformedPDFError, "CidWidths: #{first} must be less than #{final}"

lib/pdf/reader/cmap.rb

@@ -46,7 +46,7 @@ class CMap # :nodoc:
       "def" => :noop
     } #: Hash[String, Symbol]
 
-    #: () -> Hash[Integer, Array[Integer]]
+    #: Hash[Integer, Array[Integer]]
     attr_reader :map
 
     #: (String) -> void
@@ -71,7 +71,7 @@ def decode(c)
 
     private
 
-    #: (String, Symbol) -> void
+    #: (String, ?Symbol) -> void
     def process_data(data, initial_mode = :none)
       parser = build_parser(data)
       mode = initial_mode

lib/pdf/reader/encoding.rb

@@ -40,19 +40,23 @@ class Encoding # :nodoc:
 
     #: (untyped) -> void
     def initialize(enc)
-      @mapping  = default_mapping # maps from character codes to Unicode codepoints
-      @string_cache  = {} # maps from character codes to UTF-8 strings.
+      # maps from character codes to Unicode codepoints
+      @mapping  = default_mapping #: Hash[Integer, Integer]
 
-      @enc_name = if enc.kind_of?(Hash)
-        enc[:Encoding] || enc[:BaseEncoding]
+      # maps from character codes to UTF-8 strings.
+      @string_cache  = {} #: Hash[Integer, String]
+
+      @enc_name = :StandardEncoding #: Symbol
+      if enc.kind_of?(Hash)
+        @enc_name = enc[:Encoding] || enc[:BaseEncoding]
       elsif enc && enc.respond_to?(:to_sym)
-        enc.to_sym
-      else
-        :StandardEncoding
+        @enc_name = enc.to_sym
       end
 
-      @unpack   = get_unpack(@enc_name)
-      @map_file = get_mapping_file(@enc_name)
+      @unpack   = get_unpack(@enc_name) #: String
+      @map_file = get_mapping_file(@enc_name) #: String | nil
+      @differences = nil #: Hash[Integer, Integer] | nil
+      @glyphlist = nil #: PDF::Reader::GlyphHash | nil
 
       load_mapping(@map_file) if @map_file
 
@@ -131,7 +135,12 @@ def int_to_name(glyph_code)
       elsif differences[glyph_code]
         [differences[glyph_code]]
       elsif @mapping[glyph_code]
-        glyphlist.unicode_to_name(@mapping[glyph_code])
+        val = @mapping[glyph_code]
+        if val
+          glyphlist.unicode_to_name(val)
+        else
+          []
+        end
       else
         []
       end

lib/pdf/reader/error.rb

@@ -31,30 +31,36 @@ class PDF::Reader
   # are valid
   class Error # :nodoc:
     ################################################################################
+    #: (untyped, untyped, ?untyped) -> untyped
     def self.str_assert(lvalue, rvalue, chars=nil)
       raise MalformedPDFError, "PDF malformed, expected string but found #{lvalue.class} instead" if chars and !lvalue.kind_of?(String)
       lvalue = lvalue[0,chars] if chars
       raise MalformedPDFError, "PDF malformed, expected '#{rvalue}' but found '#{lvalue}' instead"  if lvalue != rvalue
     end
     ################################################################################
+    #: (untyped, untyped, ?untyped) -> untyped
     def self.str_assert_not(lvalue, rvalue, chars=nil)
       raise MalformedPDFError, "PDF malformed, expected string but found #{lvalue.class} instead" if chars and !lvalue.kind_of?(String)
       lvalue = lvalue[0,chars] if chars
       raise MalformedPDFError, "PDF malformed, expected '#{rvalue}' but found '#{lvalue}' instead"  if lvalue == rvalue
     end
     ################################################################################
+    #: (untyped, untyped) -> untyped
     def self.assert_equal(lvalue, rvalue)
       raise MalformedPDFError, "PDF malformed, expected '#{rvalue}' but found '#{lvalue}' instead" if lvalue != rvalue
     end
     ################################################################################
+    #: (Object, String, Module) -> void
     def self.validate_type(object, name, klass)
       raise ArgumentError, "#{name} (#{object}) must be a #{klass}" unless object.is_a?(klass)
     end
     ################################################################################
+    #: (Object, String, Module) -> void
     def self.validate_type_as_malformed(object, name, klass)
       raise MalformedPDFError, "#{name} (#{object}) must be a #{klass}" unless object.is_a?(klass)
     end
     ################################################################################
+    #: (Object, String) -> void
     def self.validate_not_nil(object, name)
       raise ArgumentError, "#{object} must not be nil" if object.nil?
     end

lib/pdf/reader/filter/depredict.rb

@@ -36,6 +36,7 @@ def filter(data)
       private
 
       ################################################################################
+      #: (untyped) -> String
       def tiff_depredict(data)
         data        = data.unpack("C*")
         unfiltered  = ''
@@ -62,6 +63,7 @@ def tiff_depredict(data)
         unfiltered
       end
       ################################################################################
+      #: (untyped) -> String
       def png_depredict(data)
         return data if @options[:Predictor].to_i < 10
 

lib/pdf/reader/font.rb

@@ -36,34 +36,34 @@ class PDF::Reader
   class Font
     #: Symbol?
     attr_accessor :subtype
-    
+
     #: PDF::Reader::Encoding
     attr_accessor :encoding
-    
+
     #: Array[PDF::Reader::Font]
     attr_accessor :descendantfonts
-    
+
     #: PDF::Reader::CMap
     attr_accessor :tounicode
 
     #: Array[Integer]
     attr_reader :widths
-    
+
     #: Integer?
     attr_reader :first_char
-    
+
     #: Integer?
     attr_reader :last_char
-    
+
     #: Symbol?
     attr_reader :basefont
-    
+
     #: PDF::Reader::FontDescriptor?
     attr_reader :font_descriptor
-    
+
     #: Array[Numeric]
     attr_reader :cid_widths
-    
+
     #: Numeric
     attr_reader :cid_default_width
 
@@ -228,7 +228,7 @@ def extract_descriptor(obj)
       if obj[:FontDescriptor]
         # create a font descriptor object if we can, in other words, unless this is
         # a CID Font
-        fd = @ohash.deref_hash(obj[:FontDescriptor])
+        fd = @ohash.deref_hash(obj[:FontDescriptor]) || {}
         @font_descriptor = PDF::Reader::FontDescriptor.new(@ohash, fd)
       else
         @font_descriptor = nil
@@ -240,9 +240,9 @@ def extract_descendants(obj)
       # A one-element array specifying the CIDFont dictionary that is the
       # descendant of this Type 0 font.
       if obj[:DescendantFonts]
-        descendants = @ohash.deref_array(obj[:DescendantFonts])
+        descendants = @ohash.deref_array(obj[:DescendantFonts]) || []
         @descendantfonts = descendants.map { |desc|
-          PDF::Reader::Font.new(@ohash, @ohash.deref_hash(desc))
+          PDF::Reader::Font.new(@ohash, @ohash.deref_hash(desc) || {})
         }
       else
         @descendantfonts = []