pdf-reader 2.9.2 → 2.15.0

data/lib/pdf/reader/font.rb

@@ -1,5 +1,5 @@
 # coding: utf-8
-# typed: true
+# typed: strict
 # frozen_string_literal: true
 
 ################################################################################
@@ -29,48 +29,99 @@
 
 require 'pdf/reader/width_calculator'
 
+
 class PDF::Reader
   # Represents a single font PDF object and provides some useful methods
   # for extracting info. Mainly used for converting text to UTF-8.
   #
   class Font
-    attr_accessor :subtype, :encoding, :descendantfonts, :tounicode
-    attr_reader :widths, :first_char, :last_char, :basefont, :font_descriptor,
-                :cid_widths, :cid_default_width
+    #: type widthCalculator = (
+    #|   PDF::Reader::WidthCalculator::TypeZero |
+    #|   PDF::Reader::WidthCalculator::BuiltIn |
+    #|   PDF::Reader::WidthCalculator::TypeOneOrThree |
+    #|   PDF::Reader::WidthCalculator::TrueType |
+    #|   PDF::Reader::WidthCalculator::Composite
+    #| )
+
+    #: Symbol?
+    attr_accessor :subtype
+
+    #: PDF::Reader::Encoding
+    attr_accessor :encoding
+
+    #: Array[PDF::Reader::Font]
+    attr_accessor :descendantfonts
+
+    #: PDF::Reader::CMap | nil
+    attr_accessor :tounicode
+
+    #: Array[Numeric]
+    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
+
+    #: (PDF::Reader::ObjectHash, Hash[Symbol, untyped]) -> void
     def initialize(ohash, obj)
       @ohash = ohash
-      @tounicode = nil
+      @tounicode = nil #: PDF::Reader::CMap | nil
+      @descendantfonts = [] #: Array[PDF::Reader::Font]
+      @widths = [] #: Array[Numeric]
+      @first_char = nil #: Integer?
+      @last_char = nil #: Integer?
+      @basefont = nil #: Symbol?
+      @font_descriptor = nil #: PDF::Reader::FontDescriptor?
+      @cid_widths = [] #: Array[Numeric]
+      @cid_default_width = 0 #: Numeric
+      @encoding = PDF::Reader::Encoding.new(:StandardEncoding) #: PDF::Reader::Encoding
+      @cached_widths = {} #: Hash[Integer, Numeric]
+      @font_matrix = nil #: Array[Numeric] | nil
 
       extract_base_info(obj)
       extract_type3_info(obj)
       extract_descriptor(obj)
       extract_descendants(obj)
-      @width_calc = build_width_calculator
-
-      @encoding ||= PDF::Reader::Encoding.new(:StandardEncoding)
+      @width_calc = build_width_calculator #: widthCalculator
     end
 
+    #: (Integer | String | Array[Integer | String]) -> String
     def to_utf8(params)
       if @tounicode
-        to_utf8_via_cmap(params)
+        to_utf8_via_cmap(params, @tounicode)
       else
         to_utf8_via_encoding(params)
       end
     end
 
+    #: (String) -> (Array[Integer | Float | String | nil] | nil)
     def unpack(data)
       data.unpack(encoding.unpack)
     end
 
     # looks up the specified codepoint and returns a value that is in (pdf)
     # glyph space, which is 1000 glyph units = 1 text space unit
+    #: (Integer | String) -> Numeric
     def glyph_width(code_point)
       if code_point.is_a?(String)
-        code_point = code_point.unpack(encoding.unpack).first
+        code_point = unpack_string_to_array_of_ints(code_point, encoding.unpack).first
+        raise MalformedPDFError, "code point missing" if code_point.nil?
       end
 
-      @cached_widths ||= {}
       @cached_widths[code_point] ||= @width_calc.glyph_width(code_point)
     end
 
@@ -78,12 +129,13 @@ class PDF::Reader
     #
     # However, Type3 fonts provide their own FontMatrix that's used for the transformation.
     #
+    #: (Integer | String) -> Numeric
     def glyph_width_in_text_space(code_point)
       glyph_width_in_glyph_space = glyph_width(code_point)
 
       if @subtype == :Type3
-        x1, y1 = font_matrix_transform(0,0)
-        x2, y2 = font_matrix_transform(glyph_width_in_glyph_space, 0)
+        x1, _y1 = font_matrix_transform(0,0)
+        x2, _y2 = font_matrix_transform(glyph_width_in_glyph_space, 0)
         (x2 - x1).abs.round(2)
       else
         glyph_width_in_glyph_space / 1000.0
@@ -93,13 +145,14 @@ class PDF::Reader
     private
 
     # Only valid for Type3 fonts
+    #: (Numeric, Numeric) -> [Numeric, Numeric]
     def font_matrix_transform(x, y)
       return x, y if @font_matrix.nil?
 
       matrix = TransformationMatrix.new(
-        @font_matrix[0], @font_matrix[1],
-        @font_matrix[2], @font_matrix[3],
-        @font_matrix[4], @font_matrix[5],
+        @font_matrix[0] || 0, @font_matrix[1] || 0,
+        @font_matrix[2] || 0, @font_matrix[3] || 0,
+        @font_matrix[4] || 0, @font_matrix[5] || 0,
       )
 
       if x == 0 && y == 0
@@ -112,6 +165,7 @@ class PDF::Reader
       end
     end
 
+    #: (Symbol | String | nil) -> PDF::Reader::Encoding
     def default_encoding(font_name)
       case font_name.to_s
       when "Symbol" then
@@ -123,6 +177,7 @@ class PDF::Reader
       end
     end
 
+    #: () -> widthCalculator
     def build_width_calculator
       if @subtype == :Type0
         PDF::Reader::WidthCalculator::TypeZero.new(self)
@@ -149,6 +204,7 @@ class PDF::Reader
       end
     end
 
+    #: (Hash[Symbol, untyped]) -> PDF::Reader::Encoding
     def build_encoding(obj)
       if obj[:Encoding].is_a?(Symbol)
         # one of the standard encodings, referenced by name
@@ -163,6 +219,7 @@ class PDF::Reader
       end
     end
 
+    #: (Hash[Symbol, untyped]) -> void
     def extract_base_info(obj)
       @subtype  = @ohash.deref_name(obj[:Subtype])
       @basefont = @ohash.deref_name(obj[:BaseFont])
@@ -185,6 +242,7 @@ class PDF::Reader
       end
     end
 
+    #: (Hash[Symbol, untyped]) -> void
     def extract_type3_info(obj)
       if @subtype == :Type3
         @font_matrix = @ohash.deref_array_of_numbers(obj[:FontMatrix]) || [
@@ -193,45 +251,50 @@ class PDF::Reader
       end
     end
 
+    #: (Hash[Symbol, untyped]) -> void
     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
       end
     end
 
+    #: (Hash[Symbol, untyped]) -> void
     def extract_descendants(obj)
-      return unless obj[:DescendantFonts]
       # per PDF 32000-1:2008 pp. 280 :DescendentFonts is:
       # A one-element array specifying the CIDFont dictionary that is the
       # descendant of this Type 0 font.
-      descendants = @ohash.deref_array(obj[:DescendantFonts])
-      @descendantfonts = descendants.map { |desc|
-        PDF::Reader::Font.new(@ohash, @ohash.deref_hash(desc))
-      }
+      if obj[:DescendantFonts]
+        descendants = @ohash.deref_array(obj[:DescendantFonts]) || []
+        @descendantfonts = descendants.map { |desc|
+          PDF::Reader::Font.new(@ohash, @ohash.deref_hash(desc) || {})
+        }
+      else
+        @descendantfonts = []
+      end
     end
 
-    def to_utf8_via_cmap(params)
+    #: (Integer | String | Array[Integer | String], PDF::Reader::CMap) -> String
+    def to_utf8_via_cmap(params, cmap)
       case params
       when Integer
         [
-          @tounicode.decode(params) || PDF::Reader::Encoding::UNKNOWN_CHAR
+          cmap.decode(params)
         ].flatten.pack("U*")
       when String
-        params.unpack(encoding.unpack).map { |c|
-          @tounicode.decode(c) || PDF::Reader::Encoding::UNKNOWN_CHAR
+        unpack_string_to_array_of_ints(params, encoding.unpack).map { |code_point|
+          cmap.decode(code_point)
         }.flatten.pack("U*")
       when Array
-        params.collect { |param| to_utf8_via_cmap(param) }
-      else
-        params
+        params.collect { |param| to_utf8_via_cmap(param, cmap) }.join("")
       end
     end
 
+    #: (Integer | String | Array[Integer | String]) -> String
     def to_utf8_via_encoding(params)
       if encoding.kind_of?(String)
         raise UnsupportedFeatureError, "font encoding '#{encoding}' currently unsupported"
@@ -243,11 +306,15 @@ class PDF::Reader
       when String
         encoding.to_utf8(params)
       when Array
-        params.collect { |param| to_utf8_via_encoding(param) }
-      else
-        params
+        params.collect { |param| to_utf8_via_encoding(param) }.join("")
       end
     end
 
+    #: (String, String) -> Array[Integer]
+    def unpack_string_to_array_of_ints(unpack_me, unpack_arg)
+      unpack_me.unpack(unpack_arg).map { |code_point|
+        code_point = TypeCheck.cast_to_int!(code_point)
+      }
+    end
   end
 end

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
@@ -56,13 +105,16 @@ class PDF::Reader
         end
         char_metric = ttf_program_stream.horizontal_metrics.metrics[glyph_id]
         if char_metric
-          return char_metric.advance_width
+          char_metric.advance_width
+        else
+          0
         end
       end
     end
 
     # 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
@@ -74,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,10 +44,11 @@ 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|
-          [label, PDF::Reader::Font.new(@objects, @objects.deref_hash(font))]
+          [label, PDF::Reader::Font.new(@objects, @objects.deref_hash(font) || {})]
         }]
       end
 
@@ -54,13 +57,18 @@ 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)
+        }
         content_stream(receivers, raw_content)
       end
 
       # 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
@@ -69,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)
@@ -99,6 +112,7 @@ module PDF
                     end
       end
 
+      #: (untyped, untyped) -> untyped
       def content_stream(receivers, instructions)
         params       = []
 

data/lib/pdf/reader/glyph_hash.rb

@@ -1,5 +1,5 @@
 # coding: utf-8
-# typed: true
+# typed: strict
 # frozen_string_literal: true
 
 ################################################################################
@@ -32,11 +32,38 @@ 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)
-      adobe = @@cache ||= load_adobe_glyph_mapping
-      @by_name      = adobe.first
-      @by_codepoint = adobe.last
+      if @@by_codepoint_cache != nil && @@by_name_cache != nil
+        @by_name      = @@by_name_cache #: Hash[Symbol, Integer]
+        @by_codepoint = @@by_codepoint_cache #: Hash[Integer, Array[Symbol]]
+      else
+        res = load_adobe_glyph_mapping
+        @by_name      = @@by_name_cache ||= res.by_name
+        @by_codepoint = @@by_codepoint_cache ||= res.by_codepoint
+      end
     end
 
     # attempt to convert a PDF Name to a unicode codepoint. Returns nil
@@ -59,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)
 
@@ -96,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
@@ -105,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",
@@ -121,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
 
-      [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