pdf-reader 2.14.0 → 2.15.0

data/lib/pdf/reader/font_descriptor.rb

@@ -1,5 +1,5 @@
 # coding: utf-8
-# typed: true
+# typed: strict
 # frozen_string_literal: true
 
 require 'ttfunk'
@@ -9,29 +9,75 @@ class PDF::Reader
   # Font descriptors are outlined in Section 9.8, PDF 32000-1:2008, pp 281-288
   class FontDescriptor
 
-    attr_reader :font_name, :font_family, :font_stretch, :font_weight,
-                :font_bounding_box, :cap_height, :ascent, :descent, :leading,
-                :avg_width, :max_width, :missing_width, :italic_angle, :stem_v,
-                :x_height, :font_flags
+    #: String
+    attr_reader :font_name
 
+    #: String?
+    attr_reader :font_family
+
+    #: Symbol
+    attr_reader :font_stretch
+
+    #: Numeric
+    attr_reader :font_weight
+
+    #: Array[Numeric]
+    attr_reader :font_bounding_box
+
+    #: Numeric
+    attr_reader :cap_height
+
+    #: Numeric
+    attr_reader :ascent
+
+    #: Numeric
+    attr_reader :descent
+
+    #: Numeric
+    attr_reader :leading
+
+    #: Numeric
+    attr_reader :avg_width
+
+    #: Numeric
+    attr_reader :max_width
+
+    #: Numeric
+    attr_reader :missing_width
+
+    #: Numeric?
+    attr_reader :italic_angle
+
+    #: Numeric?
+    attr_reader :stem_v
+
+    #: Numeric?
+    attr_reader :x_height
+
+    #: Integer
+    attr_reader :font_flags
+
+    #: (PDF::Reader::ObjectHash, Hash[untyped, untyped]) -> void
     def initialize(ohash, fd_hash)
       # TODO change these to typed derefs
-      @ascent                = ohash.deref_number(fd_hash[:Ascent])    || 0
-      @descent               = ohash.deref_number(fd_hash[:Descent])   || 0
-      @missing_width         = ohash.deref_number(fd_hash[:MissingWidth]) || 0
-      @font_bounding_box     = ohash.deref_array_of_numbers(fd_hash[:FontBBox])  || [0,0,0,0]
-      @avg_width             = ohash.deref_number(fd_hash[:AvgWidth])  || 0
-      @cap_height            = ohash.deref_number(fd_hash[:CapHeight]) || 0
-      @font_flags            = ohash.deref_integer(fd_hash[:Flags])     || 0
-      @italic_angle          = ohash.deref_number(fd_hash[:ItalicAngle])
-      @font_name             = ohash.deref_name(fd_hash[:FontName]).to_s
-      @leading               = ohash.deref_number(fd_hash[:Leading])   || 0
-      @max_width             = ohash.deref_number(fd_hash[:MaxWidth])  || 0
-      @stem_v                = ohash.deref_number(fd_hash[:StemV])
-      @x_height              = ohash.deref_number(fd_hash[:XHeight])
-      @font_stretch          = ohash.deref_name(fd_hash[:FontStretch]) || :Normal
-      @font_weight           = ohash.deref_number(fd_hash[:FontWeight])  || 400
-      @font_family           = ohash.deref_string(fd_hash[:FontFamily])
+      @ascent                = ohash.deref_number(fd_hash[:Ascent])    || 0 #: Numeric
+      @descent               = ohash.deref_number(fd_hash[:Descent])   || 0 #: Numeric
+      @missing_width         = ohash.deref_number(fd_hash[:MissingWidth]) || 0 #: Numeric
+      @font_bounding_box     = ohash.deref_array_of_numbers(
+        fd_hash[:FontBBox]
+      ) || [0,0,0,0] #: Array[Numeric]
+      @avg_width             = ohash.deref_number(fd_hash[:AvgWidth])  || 0 #: Numeric
+      @cap_height            = ohash.deref_number(fd_hash[:CapHeight]) || 0 #: Numeric
+      @font_flags            = ohash.deref_integer(fd_hash[:Flags])     || 0 #: Integer
+      @italic_angle          = ohash.deref_number(fd_hash[:ItalicAngle]) #: Numeric?
+      @font_name             = ohash.deref_name(fd_hash[:FontName]).to_s #: String
+      @leading               = ohash.deref_number(fd_hash[:Leading])   || 0 #: Numeric
+      @max_width             = ohash.deref_number(fd_hash[:MaxWidth])  || 0 #: Numeric
+      @stem_v                = ohash.deref_number(fd_hash[:StemV]) #: Numeric?
+      @x_height              = ohash.deref_number(fd_hash[:XHeight]) #: Numeric?
+      @font_stretch          = ohash.deref_name(fd_hash[:FontStretch]) || :Normal #: Symbol
+      @font_weight           = ohash.deref_number(fd_hash[:FontWeight])  || 400 #: Numeric
+      @font_family           = ohash.deref_string(fd_hash[:FontFamily]) #: String?
 
       # A FontDescriptor may have an embedded font program in FontFile
       # (Type 1 Font Program), FontFile2 (TrueType font program), or
@@ -41,12 +87,15 @@ class PDF::Reader
       # 2) CIDFontType0C: Type 0 Font Program in Compact Font Format
       # 3) OpenType:      OpenType Font Program
       # see Section 9.9, PDF 32000-1:2008, pp 288-292
-      @font_program_stream = ohash.deref_stream(fd_hash[:FontFile2])
+      @font_program_stream = ohash.deref_stream(fd_hash[:FontFile2]) #: PDF::Reader::Stream?
       #TODO handle FontFile and FontFile3
+      @ttf_program_stream = nil #: TTFunk::File?
 
-      @is_ttf = true if @font_program_stream
+      @is_ttf = @font_program_stream ? true : false #: bool
+      @glyph_to_pdf_sf = nil #: Numeric?
     end
 
+    #: (Integer) -> Numeric
     def glyph_width(char_code)
       if @is_ttf
         if ttf_program_stream.cmap.unicode.length > 0
@@ -65,6 +114,7 @@ class PDF::Reader
 
     # PDF states that a glyph is 1000 units wide, true type doesn't enforce
     # any behavior, but uses units/em to define how wide the 'M' is (the widest letter)
+    #: () -> Numeric
     def glyph_to_pdf_scale_factor
       if @is_ttf
         @glyph_to_pdf_sf ||= (1.0 / ttf_program_stream.header.units_per_em) * 1000.0
@@ -76,7 +126,10 @@ class PDF::Reader
 
     private
 
+    #: () -> TTFunk::File
     def ttf_program_stream
+      raise MalformedPDFError, "No font_program_stream" unless @font_program_stream
+
       @ttf_program_stream ||= TTFunk::File.new(@font_program_stream.unfiltered_data)
     end
   end

data/lib/pdf/reader/form_xobject.rb

@@ -17,6 +17,7 @@ module PDF
     class FormXObject
       extend Forwardable
 
+      #: untyped
       attr_reader :xobject
 
       def_delegators :resources, :color_spaces
@@ -28,6 +29,7 @@ module PDF
       def_delegators :resources, :shadings
       def_delegators :resources, :xobjects
 
+      #: (untyped, untyped, ?Hash[untyped, untyped]) -> void
       def initialize(page, xobject, options = {})
         @page    = page
         @objects = page.objects
@@ -42,6 +44,7 @@ module PDF
       # The values are a PDF::Reader::Font instances that provide access
       # to most available metrics for each font.
       #
+      #: () -> untyped
       def font_objects
         raw_fonts = @objects.deref_hash(fonts)
         ::Hash[raw_fonts.map { |label, font|
@@ -54,6 +57,7 @@ module PDF
       #
       # See the comments on PDF::Reader::Page#walk for more detail.
       #
+      #: (*untyped) -> untyped
       def walk(*receivers)
         receivers = receivers.map { |receiver|
           ValidatingReceiver.new(receiver)
@@ -64,6 +68,7 @@ module PDF
       # returns the raw content stream for this page. This is plumbing, nothing to
       # see here unless you're a PDF nerd like me.
       #
+      #: () -> untyped
       def raw_content
         @xobject.unfiltered_data
       end
@@ -72,24 +77,29 @@ module PDF
 
       # Returns the resources that accompany this form.
       #
+      #: () -> untyped
       def resources
         @resources ||= Resources.new(@objects, @objects.deref_hash(@xobject.hash[:Resources]) || {})
       end
 
+      #: (untyped, untyped, ?Array[untyped]) -> untyped
       def callback(receivers, name, params=[])
         receivers.each do |receiver|
           receiver.send(name, *params) if receiver.respond_to?(name)
         end
       end
 
+      #: () -> untyped
       def content_stream_md5
         @content_stream_md5 ||= Digest::MD5.hexdigest(raw_content)
       end
 
+      #: () -> untyped
       def cached_tokens_key
         @cached_tokens_key ||= "tokens-#{content_stream_md5}"
       end
 
+      #: () -> untyped
       def tokens
         @cache[cached_tokens_key] ||= begin
                       buffer = Buffer.new(StringIO.new(raw_content), :content_stream => true)
@@ -102,6 +112,7 @@ module PDF
                     end
       end
 
+      #: (untyped, untyped) -> untyped
       def content_stream(receivers, instructions)
         params       = []
 

data/lib/pdf/reader/glyph_hash.rb

@@ -32,18 +32,37 @@ class PDF::Reader
   # The mapping is read from a data file on disk the first time it's needed.
   #
   class GlyphHash # :nodoc:
+    @@by_codepoint_cache = nil #: Hash[Integer, Array[Symbol]] | nil
+    @@by_name_cache = nil #: Hash[Symbol, Integer] | nil
+
+    # An internal class for returning multiple pieces of data and keep sorbet happy
+    class ReturnData
+      #: Hash[Symbol, Integer]
+      attr_reader :by_name
+
+      #: Hash[Integer, Array[Symbol]]
+      attr_reader :by_codepoint
+
+      #:(Hash[Symbol, Integer], Hash[Integer, Array[Symbol]]) -> void
+      def initialize(by_name, by_codepoint)
+        @by_name = by_name
+        @by_codepoint = by_codepoint
+      end
+    end
+
+    #: () -> void
     def initialize
       @@by_codepoint_cache ||= nil
       @@by_name_cache ||= nil
 
       # only parse the glyph list once, and cache the results (for performance)
       if @@by_codepoint_cache != nil && @@by_name_cache != nil
-        @by_name      = @@by_name_cache
-        @by_codepoint = @@by_codepoint_cache
+        @by_name      = @@by_name_cache #: Hash[Symbol, Integer]
+        @by_codepoint = @@by_codepoint_cache #: Hash[Integer, Array[Symbol]]
       else
-        by_name, by_codepoint = load_adobe_glyph_mapping
-        @by_name      = @@by_name_cache ||= by_name
-        @by_codepoint = @@by_codepoint_cache ||= by_codepoint
+        res = load_adobe_glyph_mapping
+        @by_name      = @@by_name_cache ||= res.by_name
+        @by_codepoint = @@by_codepoint_cache ||= res.by_codepoint
       end
     end
 
@@ -67,6 +86,7 @@ class PDF::Reader
     #   h.name_to_unicode(:34)
     #   => 34
     #
+    #: (Symbol | nil) -> (Integer | nil)
     def name_to_unicode(name)
       return nil unless name.is_a?(Symbol)
 
@@ -104,6 +124,7 @@ class PDF::Reader
     #   h.unicode_to_name(34)
     #   => [:34]
     #
+    #: (Integer) -> Array[Symbol]
     def unicode_to_name(codepoint)
       @by_codepoint[codepoint.to_i] || []
     end
@@ -113,9 +134,10 @@ class PDF::Reader
     # returns a hash that maps glyph names to unicode codepoints. The mapping is based on
     # a text file supplied by Adobe at:
     # https://github.com/adobe-type-tools/agl-aglfn
+    #: () -> ReturnData
     def load_adobe_glyph_mapping
-      keyed_by_name      = {}
-      keyed_by_codepoint = {}
+      keyed_by_name      = {} #: Hash[Symbol, Integer]
+      keyed_by_codepoint = {} #: Hash[Integer, Array[Symbol]]
 
       paths = [
         File.dirname(__FILE__) + "/glyphlist.txt",
@@ -129,13 +151,16 @@ class PDF::Reader
               cp = "0x#{code}".hex
               keyed_by_name[name.to_sym]   = cp
               keyed_by_codepoint[cp]     ||= []
-              keyed_by_codepoint[cp]     << name.to_sym
+              arr = keyed_by_codepoint[cp]
+              if arr
+                arr.push(name.to_sym)
+              end
             end
           end
         end
       end
 
-      return keyed_by_name.freeze, keyed_by_codepoint.freeze
+      ReturnData.new(keyed_by_name.freeze, keyed_by_codepoint.freeze)
     end
 
   end

data/lib/pdf/reader/key_builder_v5.rb

@@ -16,20 +16,21 @@ class PDF::Reader
   #
   class KeyBuilderV5
 
+    #: (?Hash[Symbol, String]) -> void
     def initialize(opts = {})
-      @key_length   = 256
+      @key_length   = 256 #: Integer
 
       # hash(32B) + validation salt(8B) + key salt(8B)
-      @owner_key    = opts[:owner_key] || ""
+      @owner_key    = opts[:owner_key] || "" #: String
 
       # hash(32B) + validation salt(8B) + key salt(8B)
-      @user_key     = opts[:user_key] || ""
+      @user_key     = opts[:user_key] || "" #: String
 
       # decryption key, encrypted w/ owner password
-      @owner_encryption_key = opts[:owner_encryption_key] || ""
+      @owner_encryption_key = opts[:owner_encryption_key] || "" #: String
 
       # decryption key, encrypted w/ user password
-      @user_encryption_key  = opts[:user_encryption_key] || ""
+      @user_encryption_key  = opts[:user_encryption_key] || "" #: String
     end
 
     # Takes a string containing a user provided password.
@@ -38,6 +39,7 @@ class PDF::Reader
     # decrypting the file will be returned. If the password doesn't match the file,
     # and exception will be raised.
     #
+    #: (String) -> String
     def key(pass)
       pass = pass.byteslice(0...127).to_s   # UTF-8 encoded password. first 127 bytes
 
@@ -58,28 +60,31 @@ class PDF::Reader
     #
     # if the string is a valid user/owner password, this will return the decryption key
     #
+    #: (String) -> (String | nil)
     def auth_owner_pass(password)
-      if Digest::SHA256.digest(password + @owner_key[32..39] + @user_key) == @owner_key[0..31]
+      if Digest::SHA256.digest(password + @owner_key[32..39].to_s + @user_key) == @owner_key[0..31]
         cipher = OpenSSL::Cipher.new('AES-256-CBC')
         cipher.decrypt
-        cipher.key = Digest::SHA256.digest(password + @owner_key[40..-1] + @user_key)
+        cipher.key = Digest::SHA256.digest(password + @owner_key[40..-1].to_s + @user_key)
         cipher.iv = "\x00" * 16
         cipher.padding = 0
         cipher.update(@owner_encryption_key) + cipher.final
       end
     end
 
+    #: (String) -> (String | nil)
     def auth_user_pass(password)
-      if Digest::SHA256.digest(password + @user_key[32..39]) == @user_key[0..31]
+      if Digest::SHA256.digest(password + @user_key[32..39].to_s) == @user_key[0..31]
         cipher = OpenSSL::Cipher.new('AES-256-CBC')
         cipher.decrypt
-        cipher.key = Digest::SHA256.digest(password + @user_key[40..-1])
+        cipher.key = Digest::SHA256.digest(password + @user_key[40..-1].to_s)
         cipher.iv = "\x00" * 16
         cipher.padding = 0
         cipher.update(@user_encryption_key) + cipher.final
       end
     end
 
+    #: (String) -> (String | nil)
     def auth_owner_pass_r6(password)
       if r6_digest(password, @owner_key[32..39].to_s, @user_key[0,48].to_s) == @owner_key[0..31]
         cipher = OpenSSL::Cipher.new('AES-256-CBC')
@@ -91,6 +96,7 @@ class PDF::Reader
       end
     end
 
+    #: (String) -> (String | nil)
     def auth_user_pass_r6(password)
       if r6_digest(password, @user_key[32..39].to_s) == @user_key[0..31]
         cipher = OpenSSL::Cipher.new('AES-256-CBC')
@@ -104,6 +110,7 @@ class PDF::Reader
 
     # PDF 2.0 spec, 7.6.4.3.4
     # Algorithm 2.B: Computing a hash (revision 6 and later)
+    #: (String, String, ?String) -> String
     def r6_digest(password, salt, user_key = '')
       k = Digest::SHA256.digest(password + salt + user_key)
       e = ''
@@ -128,6 +135,7 @@ class PDF::Reader
       k[0, 32].to_s
     end
 
+    #: (String) -> Integer
     def unpack_128bit_bigendian_int(str)
       ints = str[0,16].to_s.unpack("N*")
       (ints[0].to_i << 96) + (ints[1].to_i << 64) + (ints[2].to_i << 32) + ints[3].to_i

data/lib/pdf/reader/lzw.rb

@@ -22,20 +22,24 @@ 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")
+          @current_pos = 0 #: Integer
+          @bits_left_in_byte = 8 #: Integer
+          @bits_in_chunk = 0 #: Integer
           set_bits_in_chunk(bits_in_chunk)
-          @current_pos = 0
-          @bits_left_in_byte = 8
         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
@@ -59,19 +63,23 @@ 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
+        #: Integer
         attr_reader :string_table_pos
 
+        #: () -> void
         def initialize
-          @data = Hash.new
-          @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
             @data[key]
@@ -80,6 +88,7 @@ module PDF
           end
         end
 
+        #: (String) -> void
         def add(string)
           @data.store(@string_table_pos, string)
           @string_table_pos += 1
@@ -88,6 +97,7 @@ module PDF
 
       # 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
         string_table = StringTable.new
@@ -125,6 +135,7 @@ module PDF
         result
       end
 
+      #: (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?
 

data/lib/pdf/reader/no_text_filter.rb

@@ -6,6 +6,7 @@ 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

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)