pdf-reader 2.9.2 → 2.15.0

data/lib/pdf/reader/cid_widths.rb

@@ -1,9 +1,7 @@
 # coding: utf-8
-# typed: true
+# typed: strict
 # frozen_string_literal: true
 
-#
-
 require 'forwardable'
 
 class PDF::Reader
@@ -20,12 +18,14 @@ class PDF::Reader
     # 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 = []
@@ -33,10 +33,10 @@ class PDF::Reader
         params << array.shift
 
         if params.size == 2 && params.last.is_a?(Array)
-          widths.merge! parse_first_form(params.first, params.last)
+          widths.merge! parse_first_form(params.first.to_i, Array(params.last))
           params = []
         elsif params.size == 3
-          widths.merge! parse_second_form(params[0], params[1], params[2])
+          widths.merge! parse_second_form(params[0].to_i, params[1].to_i, params[2].to_i)
           params = []
         end
       end
@@ -45,6 +45,8 @@ class PDF::Reader
 
     # 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
@@ -53,7 +55,13 @@ class PDF::Reader
     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}"
+      end
+
       (first..final).inject({}) { |accum, index|
         accum[index] = width
         accum

data/lib/pdf/reader/cmap.rb

@@ -1,5 +1,5 @@
 # coding: utf-8
-# typed: true
+# typed: strict
 # frozen_string_literal: true
 
 ################################################################################
@@ -44,15 +44,18 @@ class PDF::Reader
       "begin" => :noop,
       "begincmap" => :noop,
       "def" => :noop
-    }
+    } #: Hash[String, Symbol]
 
+    #: Hash[Integer, Array[Integer]]
     attr_reader :map
 
+    #: (String) -> void
     def initialize(data)
-      @map = {}
+      @map = {} #: Hash[Integer, Array[Integer]]
       process_data(data)
     end
 
+    #: () -> Integer
     def size
       @map.size
     end
@@ -61,12 +64,14 @@ class PDF::Reader
     #
     # Returns an array of Integers.
     #
+    #: (Integer) -> Array[Integer]
     def decode(c)
       @map.fetch(c, [])
     end
 
     private
 
+    #: (String, ?Symbol) -> void
     def process_data(data, initial_mode = :none)
       parser = build_parser(data)
       mode = initial_mode
@@ -96,6 +101,7 @@ class PDF::Reader
     end
 
 
+    #: (String) -> PDF::Reader::Parser
     def build_parser(instructions)
       buffer = Buffer.new(StringIO.new(instructions))
       Parser.new(buffer)
@@ -109,6 +115,7 @@ class PDF::Reader
     # However, some cmaps contain broken surrogate pairs and the ruby encoding support raises an
     # exception when we try converting broken UTF-16 to UTF-8
     #
+    #: (String) -> Array[Integer]
     def str_to_int(str)
       unpacked_string = if str.bytesize == 1 # UTF-8
         str.unpack("C*")
@@ -118,8 +125,8 @@ class PDF::Reader
       result = []
       while unpacked_string.any? do
         if unpacked_string.size >= 2 &&
-            unpacked_string.first.to_i > 0xD800 &&
-            unpacked_string.first.to_i < 0xDBFF
+            unpacked_string.first.to_i >= 0xD800 &&
+            unpacked_string.first.to_i <= 0xDBFF
           # this is a Unicode UTF-16 "Surrogate Pair" see Unicode Spec. Chapter 3.7
           # lets convert to a UTF-32. (the high bit is between 0xD800-0xDBFF, the
           # low bit is between 0xDC00-0xDFFF) for example: U+1D44E (U+D835 U+DC4E)
@@ -133,6 +140,7 @@ class PDF::Reader
       result
     end
 
+    #: (Array[String]) -> void
     def process_bfchar_instructions(instructions)
       instructions.each_slice(2) do |one, two|
         find    = str_to_int(one.to_s)
@@ -143,6 +151,7 @@ class PDF::Reader
       end
     end
 
+    #: (Array[Array[String] | String]) -> void
     def process_bfrange_instructions(instructions)
       instructions.each_slice(3) do |start, finish, to|
         if start.kind_of?(String) && finish.kind_of?(String) && to.kind_of?(String)
@@ -155,6 +164,7 @@ class PDF::Reader
       end
     end
 
+    #: (String, String, String) -> void
     def bfrange_type_one(start_code, end_code, dst)
       start_code = str_to_int(start_code).first
       end_code   = str_to_int(end_code).first
@@ -168,6 +178,7 @@ class PDF::Reader
       end
     end
 
+    #: (String, String, Array[String]) -> void
     def bfrange_type_two(start_code, end_code, dst)
       start_code = str_to_int(start_code).first
       end_code   = str_to_int(end_code).first

data/lib/pdf/reader/encoding.rb

@@ -1,5 +1,5 @@
 # coding: utf-8
-# typed: true
+# typed: strict
 # frozen_string_literal: true
 
 ################################################################################
@@ -32,25 +32,31 @@ class PDF::Reader
   # convert strings of various PDF-dialect encodings into UTF-8.
   class Encoding # :nodoc:
     CONTROL_CHARS = [0,1,2,3,4,5,6,7,8,11,12,14,15,16,17,18,19,20,21,22,23,
-                     24,25,26,27,28,29,30,31]
-    UNKNOWN_CHAR = 0x25AF # ▯
+                     24,25,26,27,28,29,30,31] #: Array[Integer]
+    UNKNOWN_CHAR = 0x25AF #: Integer # ▯
 
+    #: String
     attr_reader :unpack
 
+    #: (Hash[Symbol, untyped] | Symbol | nil) -> 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
 
@@ -68,6 +74,7 @@ class PDF::Reader
     # To save space the following array is also valid and equivalent to the previous one
     #
     #   [25, :A, :B]
+    #: (Array[Integer | Symbol]) -> Hash[Integer, Integer]
     def differences=(diff)
       PDF::Reader::Error.validate_type(diff, "diff", Array)
 
@@ -76,15 +83,16 @@ class PDF::Reader
       diff.each do |val|
         if val.kind_of?(Numeric)
           byte = val.to_i
-        else
+        elsif codepoint = glyphlist.name_to_unicode(val)
           @differences[byte] = val
-          @mapping[byte] = glyphlist.name_to_unicode(val)
+          @mapping[byte] = codepoint
           byte += 1
         end
       end
       @differences
     end
 
+    #: () -> Hash[Integer, Integer]
     def differences
       # this method is only used by the spec tests
       @differences ||= {}
@@ -101,6 +109,7 @@ class PDF::Reader
     # * pack the final array of Unicode codepoints into a utf-8 string
     # * mark the string as utf-8 if we're running on a M17N aware VM
     #
+    #: (String) -> String
     def to_utf8(str)
       if utf8_conversion_impossible?
         little_boxes(str.unpack(unpack).size)
@@ -109,6 +118,7 @@ class PDF::Reader
       end
     end
 
+    #: (Integer) -> String
     def int_to_utf8_string(glyph_code)
       @string_cache[glyph_code] ||= internal_int_to_utf8_string(glyph_code)
     end
@@ -118,13 +128,19 @@ class PDF::Reader
     #     int_to_name(65)
     #     => [:A]
     #
+    #: (Integer) -> Array[Symbol]
     def int_to_name(glyph_code)
-      if @enc_name == "Identity-H" || @enc_name == "Identity-V"
+      if @enc_name == :"Identity-H" || @enc_name == :"Identity-V"
         []
       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
@@ -137,16 +153,17 @@ class PDF::Reader
     # - leaves all other bytes <= 255 unchaged
     #
     # Each specific encoding will change this default as required for their glyphs
+    #: () -> Hash[Integer, Integer]
     def default_mapping
       all_bytes = (0..255).to_a
       tuples = all_bytes.map {|i|
         CONTROL_CHARS.include?(i) ? [i, UNKNOWN_CHAR] : [i,i]
       }
       mapping = Hash[tuples]
-      mapping[nil] = UNKNOWN_CHAR
       mapping
     end
 
+    #: (Integer) -> String
     def internal_int_to_utf8_string(glyph_code)
       ret = [
         @mapping[glyph_code.to_i] || glyph_code.to_i
@@ -155,10 +172,12 @@ class PDF::Reader
       ret
     end
 
+    #: () -> bool
     def utf8_conversion_impossible?
       @enc_name == :"Identity-H" || @enc_name == :"Identity-V"
     end
 
+    #: (Integer) -> String
     def little_boxes(times)
       codepoints = [ PDF::Reader::Encoding::UNKNOWN_CHAR ] * times
       ret = codepoints.pack("U*")
@@ -166,12 +185,14 @@ class PDF::Reader
       ret
     end
 
+    #: (String) -> String
     def convert_to_utf8(str)
-      ret = str.unpack(unpack).map! { |c| @mapping[c] || c }.pack("U*")
+      ret = str.unpack(unpack).map! { |c| @mapping[c.to_i] || c }.pack("U*")
       ret.force_encoding("UTF-8")
       ret
     end
 
+    #: (Symbol) -> String
     def get_unpack(enc)
       case enc
       when :"Identity-H", :"Identity-V", :UTF16Encoding
@@ -181,6 +202,7 @@ class PDF::Reader
       end
     end
 
+    #: (Symbol) -> String?
     def get_mapping_file(enc)
       case enc
       when :"Identity-H", :"Identity-V", :UTF16Encoding then
@@ -202,10 +224,12 @@ class PDF::Reader
       end
     end
 
+    #: () -> PDF::Reader::GlyphHash
     def glyphlist
       @glyphlist ||= PDF::Reader::GlyphHash.new
     end
 
+    #: (String) -> void
     def load_mapping(file)
       File.open(file, "r:BINARY") do |f|
         f.each do |l|

data/lib/pdf/reader/error.rb

@@ -31,37 +31,39 @@ 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
-    ################################################################################
-    def self.validate_not_nil_as_malformed(object, name)
-      raise MalformedPDFError, "#{object} must not be nil" if object.nil?
-    end
   end
 
   ################################################################################

data/lib/pdf/reader/filter/ascii85.rb

@@ -9,6 +9,7 @@ class PDF::Reader
     # implementation of the Ascii85 filter
     class Ascii85
 
+      #: (?Hash[untyped, untyped]) -> void
       def initialize(options = {})
         @options = options
       end
@@ -17,6 +18,7 @@ class PDF::Reader
       # Decode the specified data using the Ascii85 algorithm. Relies on the AScii85
       # rubygem.
       #
+      #: (String) -> String
       def filter(data)
         data = "<~#{data}" unless data.to_s[0,2] == "<~"
         if defined?(::Ascii85Native)

data/lib/pdf/reader/filter/ascii_hex.rb

@@ -8,6 +8,7 @@ class PDF::Reader
     # implementation of the AsciiHex stream filter
     class AsciiHex
 
+      #: (?Hash[untyped, untyped]) -> void
       def initialize(options = {})
         @options = options
       end
@@ -15,6 +16,7 @@ class PDF::Reader
       ################################################################################
       # Decode the specified data using the AsciiHex algorithm.
       #
+      #: (String) -> String
       def filter(data)
         data.chop! if data[-1,1] == ">"
         data = data[1,data.size] if data[0,1] == "<"

data/lib/pdf/reader/filter/depredict.rb

@@ -1,5 +1,5 @@
 # coding: utf-8
-# typed: true
+# typed: strict
 # frozen_string_literal: true
 
 class PDF::Reader
@@ -8,6 +8,7 @@ class PDF::Reader
     # improve compression
     class Depredict
 
+      #: (?Hash[untyped, untyped]) -> void
       def initialize(options = {})
         @options = options
       end
@@ -16,6 +17,7 @@ class PDF::Reader
       # Streams can be preprocessed to improve compression. This reverses the
       # preprocessing
       #
+      #: (String) -> String
       def filter(data)
         predictor = @options[:Predictor].to_i
 
@@ -34,6 +36,7 @@ class PDF::Reader
       private
 
       ################################################################################
+      #: (untyped) -> String
       def tiff_depredict(data)
         data        = data.unpack("C*")
         unfiltered  = ''
@@ -60,6 +63,7 @@ class PDF::Reader
         unfiltered
       end
       ################################################################################
+      #: (untyped) -> String
       def png_depredict(data)
         return data if @options[:Predictor].to_i < 10
 
@@ -125,7 +129,7 @@ class PDF::Reader
               row_data[index] = (byte + paeth) % 256
             end
           else
-            raise ArgumentError, "Invalid filter algorithm #{filter}"
+            raise MalformedPDFError, "Invalid filter algorithm #{filter}"
           end
 
           s = []

data/lib/pdf/reader/filter/flate.rb

@@ -10,15 +10,17 @@ class PDF::Reader
     # implementation of the Flate (zlib) stream filter
     class Flate
 
-      ZLIB_AUTO_DETECT_ZLIB_OR_GZIP = 47  # Zlib::MAX_WBITS + 32
-      ZLIB_RAW_DEFLATE              = -15 # Zlib::MAX_WBITS * -1
+      ZLIB_AUTO_DETECT_ZLIB_OR_GZIP = 47 #: Integer  # Zlib::MAX_WBITS + 32
+      ZLIB_RAW_DEFLATE              = -15 #: Integer # Zlib::MAX_WBITS * -1
 
+      #: (?Hash[untyped, untyped]) -> void
       def initialize(options = {})
         @options = options
       end
 
       ################################################################################
       # Decode the specified data with the Zlib compression algorithm
+      #: (String) -> String
       def filter(data)
         deflated = zlib_inflate(data) || zlib_inflate(data[0, data.bytesize-1])
 
@@ -31,6 +33,7 @@ class PDF::Reader
 
       private
 
+      #: (untyped) -> untyped
       def zlib_inflate(data)
         begin
           return Zlib::Inflate.new(ZLIB_AUTO_DETECT_ZLIB_OR_GZIP).inflate(data)

data/lib/pdf/reader/filter/lzw.rb

@@ -8,12 +8,14 @@ class PDF::Reader
     # implementation of the LZW stream filter
     class Lzw
 
+      #: (?Hash[untyped, untyped]) -> void
       def initialize(options = {})
         @options = options
       end
 
       ################################################################################
       # Decode the specified data with the LZW compression algorithm
+      #: (String) -> String
       def filter(data)
         data = PDF::Reader::LZW.decode(data)
         Depredict.new(@options).filter(data)

data/lib/pdf/reader/filter/null.rb

@@ -6,10 +6,12 @@ class PDF::Reader
   module Filter # :nodoc:
     # implementation of the null stream filter
     class Null
+      #: (?Hash[untyped, untyped]) -> void
       def initialize(options = {})
         @options = options
       end
 
+      #: (String) -> String
       def filter(data)
         data
       end

data/lib/pdf/reader/filter/run_length.rb

@@ -8,12 +8,14 @@ class PDF::Reader # :nodoc:
     # implementation of the run length stream filter
     class RunLength
 
+      #: (?Hash[untyped, untyped]) -> void
       def initialize(options = {})
         @options = options
       end
 
       ################################################################################
       # Decode the specified data with the RunLengthDecode compression algorithm
+      #: (String) -> String
       def filter(data)
         pos = 0
         out = "".dup

data/lib/pdf/reader/filter.rb

@@ -41,6 +41,7 @@ class PDF::Reader
     # Filters that are only used to encode image data are accepted, but the data is
     # returned untouched. At this stage PDF::Reader has no need to decode images.
     #
+    #: (Symbol, ?Hash[untyped, untyped]) -> untyped
     def self.with(name, options = {})
       case name
       when :ASCII85Decode, :A85   then PDF::Reader::Filter::Ascii85.new(options)