pdf-reader 2.9.2 → 2.11.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: cc98ab07b3c66f13f663ea5faf8132b45d769912e0da737917dd054e38318ede
-  data.tar.gz: 0f2928d9778b5b3ea8fca5e723a2b3fa6f275df70b02f1eb4385e077c535ac78
+  metadata.gz: 2c84983c18d983798ff5f2ede514b540ee55a788229501976474b7341bf57fba
+  data.tar.gz: 79b8f092e72a194110062cf7d7e9425c0a6531e145009c9b7c10c2c072b3d1d5
 SHA512:
-  metadata.gz: 210cd8c8cef93b0e0fac1446c091c2a62772ffe8b1786627089e5a330ca7defd501df7cccc0b48d326d38ff74318b162e512220e8a4460260bebe7da0ef8b757
-  data.tar.gz: 047e7f6641411557b1d3b50035dbdf55647c63deede273b6ce4442230b85372045494b81e88c1ffcaa09a7c5ea26823ee33b33c3bf82013328d0e32a95021284
+  metadata.gz: '09c97a875bb46389172ed48ae8b2779ba3a8e032852b6a9943f187de13c23649e2398a5374358c62b64cf9e13bbf7f819bb5072d9aaa6882b9b94e96d23f5c13'
+  data.tar.gz: ed92250acee85f4e355785dd043f7774a5883550fe82b01b3cd9e10011f93a1fcdd500108b0e1f4e2af562bddd833c03ca601078b3eba8ee2e9990fd5e76305a

data/CHANGELOG

@@ -1,3 +1,11 @@
+v2.11.0 (26th October 2022)
+- Various bug fixes
+- Expanded sorbet type annotations
+
+v2.10.0 (12th May 2022)
+- Various bug fixes
+- Expanded sorbet type annotations
+
 v2.9.2 (20th February 2022)
 - Fix PDF::Reader::ObjectHash#page_references to return an Array of PDF::Reader::Reference (http://github.com/yob/pdf-reader/pull/444)
 

data/Rakefile

@@ -14,7 +14,7 @@ desc "Run cane to check quality metrics"
 Cane::RakeTask.new(:quality) do |cane|
   cane.abc_max = 20
   cane.style_measure = 100
-  cane.max_violations = 28
+  cane.max_violations = 33
 
   cane.use Morecane::EncodingCheck, :encoding_glob => "{app,lib,spec}/**/*.rb"
 end

data/lib/pdf/reader/buffer.rb

@@ -1,5 +1,5 @@
 # coding: ASCII-8BIT
-# typed: true
+# typed: strict
 # frozen_string_literal: true
 
 ################################################################################

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
@@ -33,10 +31,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
@@ -54,6 +52,10 @@ class PDF::Reader
 
     # this is the form 10 20 123 where all index between 10 and 20 have width 123
     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
 
 ################################################################################

data/lib/pdf/reader/encoding.rb

@@ -1,5 +1,5 @@
 # coding: utf-8
-# typed: true
+# typed: strict
 # frozen_string_literal: true
 
 ################################################################################
@@ -76,9 +76,9 @@ 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
@@ -167,7 +167,7 @@ class PDF::Reader
     end
 
     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

data/lib/pdf/reader/error.rb

@@ -58,10 +58,6 @@ class PDF::Reader
     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/depredict.rb

@@ -1,5 +1,5 @@
 # coding: utf-8
-# typed: true
+# typed: strict
 # frozen_string_literal: true
 
 class PDF::Reader
@@ -125,7 +125,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/font.rb

@@ -205,14 +205,17 @@ class PDF::Reader
     end
 
     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)
@@ -226,9 +229,7 @@ class PDF::Reader
           @tounicode.decode(c) || PDF::Reader::Encoding::UNKNOWN_CHAR
         }.flatten.pack("U*")
       when Array
-        params.collect { |param| to_utf8_via_cmap(param) }
-      else
-        params
+        params.collect { |param| to_utf8_via_cmap(param) }.join("")
       end
     end
 
@@ -243,9 +244,7 @@ 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
 

data/lib/pdf/reader/font_descriptor.rb

@@ -56,7 +56,9 @@ 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

data/lib/pdf/reader/form_xobject.rb

@@ -45,7 +45,7 @@ module PDF
       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
 
@@ -55,6 +55,9 @@ module PDF
       # See the comments on PDF::Reader::Page#walk for more detail.
       #
       def walk(*receivers)
+        receivers = receivers.map { |receiver|
+          ValidatingReceiver.new(receiver)
+        }
         content_stream(receivers, raw_content)
       end
 

data/lib/pdf/reader/glyph_hash.rb

@@ -1,5 +1,5 @@
 # coding: utf-8
-# typed: true
+# typed: strict
 # frozen_string_literal: true
 
 ################################################################################
@@ -33,10 +33,18 @@ class PDF::Reader
   #
   class GlyphHash # :nodoc:
     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
+        @by_codepoint = @@by_codepoint_cache
+      else
+        by_name, by_codepoint = load_adobe_glyph_mapping
+        @by_name      = @@by_name_cache ||= by_name
+        @by_codepoint = @@by_codepoint_cache ||= by_codepoint
+      end
     end
 
     # attempt to convert a PDF Name to a unicode codepoint. Returns nil
@@ -127,7 +135,7 @@ class PDF::Reader
         end
       end
 
-      [keyed_by_name.freeze, keyed_by_codepoint.freeze]
+      return keyed_by_name.freeze, keyed_by_codepoint.freeze
     end
 
   end

data/lib/pdf/reader/lzw.rb

@@ -1,5 +1,5 @@
 # coding: utf-8
-# typed: true
+# typed: strict
 # frozen_string_literal: true
 
 module PDF
@@ -25,12 +25,14 @@ module PDF
         def initialize(data, bits_in_chunk)
           @data = data
           @data.force_encoding("BINARY")
-          @bits_in_chunk = bits_in_chunk
+          set_bits_in_chunk(bits_in_chunk)
           @current_pos = 0
           @bits_left_in_byte = 8
         end
 
         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
 
@@ -39,7 +41,7 @@ module PDF
           chunk = -1
           while bits_left_in_chunk > 0 and @current_pos < @data.size
             chunk = 0 if chunk < 0
-            codepoint = @data[@current_pos, 1].unpack("C*")[0]
+            codepoint = @data[@current_pos, 1].to_s.unpack("C*")[0].to_i
             current_byte = codepoint & (2**@bits_left_in_byte - 1) #clear consumed bits
             dif = bits_left_in_chunk - @bits_left_in_byte
             if dif > 0 then  current_byte <<= dif
@@ -61,21 +63,25 @@ module PDF
       CODE_CLEAR_TABLE = 256 #clear table
 
       # stores de pairs code => string
-      class StringTable < Hash # :nodoc:
+      class StringTable
         attr_reader :string_table_pos
 
         def initialize
-          super
+          @data = Hash.new
           @string_table_pos = 258 #initial code
         end
 
         #if code less than 258 return fixed string
         def [](key)
-          if key > 257 then super else key.chr end
+          if key > 257
+            @data[key]
+          else
+            key.chr
+          end
         end
 
         def add(string)
-          store(@string_table_pos, string)
+          @data.store(@string_table_pos, string)
           @string_table_pos += 1
         end
       end
@@ -83,7 +89,7 @@ module PDF
       # Decompresses a LZW compressed string.
       #
       def self.decode(data)
-        stream = BitStream.new data.to_s, 9 # size of codes between 9 and 12 bits
+        stream = BitStream.new(data.to_s, 9) # size of codes between 9 and 12 bits
         string_table = StringTable.new
         result = "".dup
         until (code = stream.read) == CODE_EOD
@@ -119,8 +125,17 @@ module PDF
         result
       end
 
-      def self.create_new_string(string_table,some_code, other_code)
-        string_table[some_code] + string_table[other_code][0].chr
+      def self.create_new_string(string_table, some_code, other_code)
+        raise MalformedPDFError, "invalid LZW data" if some_code.nil? || other_code.nil?
+
+        item_one = string_table[some_code]
+        item_two = string_table[other_code]
+
+        if item_one && item_two
+          item_one + item_two.chr
+        else
+          raise MalformedPDFError, "invalid LZW data"
+        end
       end
       private_class_method :create_new_string
 

data/lib/pdf/reader/no_text_filter.rb

@@ -0,0 +1,14 @@
+# coding: utf-8
+# typed: strict
+# frozen_string_literal: true
+
+class PDF::Reader
+  # There's no point rendering zero-width characters
+  class NoTextFilter
+
+    def self.exclude_empty_strings(runs)
+      runs.reject { |run| run.text.to_s.size == 0 }
+    end
+  end
+end
+

data/lib/pdf/reader/object_hash.rb

@@ -2,6 +2,8 @@
 # typed: true
 # frozen_string_literal: true
 
+require 'tempfile'
+
 class PDF::Reader
   # Provides low level access to the objects in a PDF file via a hash-like
   # object.
@@ -243,7 +245,7 @@ class PDF::Reader
 
       obj.tap { |obj|
         if !obj.is_a?(PDF::Reader::Stream)
-          raise MalformedPDFError, "expected object to be an Array or nil"
+          raise MalformedPDFError, "expected object to be a Stream or nil"
         end
       }
     end
@@ -496,7 +498,9 @@ class PDF::Reader
     def fetch_object_stream(key)
       if xref[key].is_a?(PDF::Reader::Reference)
         container_key = xref[key]
-        object_streams[container_key] ||= PDF::Reader::ObjectStream.new(object(container_key))
+        stream = deref_stream(container_key)
+        raise MalformedPDFError, "Object Stream cannot be nil" if stream.nil?
+        object_streams[container_key] ||= PDF::Reader::ObjectStream.new(stream)
         object_streams[container_key][key.id]
       end
     end
@@ -564,7 +568,7 @@ class PDF::Reader
     end
 
     def object_streams
-      @object_stream ||= {}
+      @object_streams ||= {}
     end
 
     # returns an array of object references for all pages in this object store. The ordering of
@@ -573,7 +577,9 @@ class PDF::Reader
     def get_page_objects(obj)
       derefed_obj = deref_hash(obj)
 
-      if derefed_obj[:Type] == :Page
+      if derefed_obj.nil?
+        raise MalformedPDFError, "Expected Page or Pages object, got nil"
+      elsif derefed_obj[:Type] == :Page
         [obj]
       elsif derefed_obj[:Kids]
         kids = deref_array(derefed_obj[:Kids]) || []
@@ -587,18 +593,18 @@ class PDF::Reader
 
     def read_version
       @io.seek(0)
-      _m, version = *@io.read(10).match(/PDF-(\d.\d)/)
+      _m, version = *@io.read(10).to_s.match(/PDF-(\d.\d)/)
       @io.seek(0)
       version.to_f
     end
 
     def extract_io_from(input)
-      if input.respond_to?(:seek) && input.respond_to?(:read)
+      if input.is_a?(IO) || input.is_a?(StringIO) || input.is_a?(Tempfile)
         input
       elsif File.file?(input.to_s)
-        StringIO.new read_as_binary(input)
+        StringIO.new read_as_binary(input.to_s)
       else
-        raise ArgumentError, "input must be an IO-like object or a filename"
+        raise ArgumentError, "input must be an IO-like object or a filename (#{input.class})"
       end
     end
 
@@ -606,7 +612,7 @@ class PDF::Reader
       if File.respond_to?(:binread)
         File.binread(input.to_s)
       else
-        File.open(input.to_s,"rb") { |f| f.read }
+        File.open(input.to_s,"rb") { |f| f.read } || ""
       end
     end
 

data/lib/pdf/reader/object_stream.rb

@@ -1,5 +1,5 @@
 # coding: utf-8
-# typed: true
+# typed: strict
 # frozen_string_literal: true
 
 class PDF::Reader
@@ -24,7 +24,7 @@ class PDF::Reader
     end
 
     def size
-      @dict[:N]
+      TypeCheck.cast_to_int!(@dict[:N])
     end
 
     private
@@ -40,7 +40,7 @@ class PDF::Reader
     end
 
     def first
-      @dict[:First]
+      TypeCheck.cast_to_int!(@dict[:First])
     end
 
     def buffer

data/lib/pdf/reader/overlapping_runs_filter.rb

@@ -1,6 +1,6 @@
-# typed: true
 # coding: utf-8
 # frozen_string_literal: true
+# typed: strict
 
 class PDF::Reader
   # remove duplicates from a collection of TextRun objects. This can be helpful when a PDF

data/lib/pdf/reader/page.rb

@@ -1,5 +1,5 @@
 # coding: utf-8
-# typed: true
+# typed: strict
 # frozen_string_literal: true
 
 module PDF
@@ -43,10 +43,10 @@ module PDF
       #
       def initialize(objects, pagenum, options = {})
         @objects, @pagenum = objects, pagenum
-        @page_object = objects.deref_hash(objects.page_references[pagenum - 1])
+        @page_object = objects.deref_hash(objects.page_references[pagenum - 1]) || {}
         @cache       = options[:cache] || {}
 
-        unless @page_object.is_a?(::Hash)
+        if @page_object.empty?
           raise InvalidPageError, "Invalid page: #{pagenum}"
         end
       end
@@ -250,8 +250,8 @@ module PDF
         params       = []
 
         while (token = parser.parse_token(PagesStrategy::OPERATORS))
-          if token.kind_of?(Token) and PagesStrategy::OPERATORS.has_key?(token)
-            callback(receivers, PagesStrategy::OPERATORS[token], params)
+          if token.kind_of?(Token) && method_name = PagesStrategy::OPERATORS[token]
+            callback(receivers, method_name, params)
             params.clear
           else
             params << token
@@ -263,9 +263,26 @@ module PDF
 
       # calls the name callback method on each receiver object with params as the arguments
       #
+      # The silly style here is because sorbet won't let me use splat arguments
+      #
       def callback(receivers, name, params=[])
         receivers.each do |receiver|
-          receiver.send(name, *params) if receiver.respond_to?(name)
+          if receiver.respond_to?(name)
+            case params.size
+            when 0 then receiver.send(name)
+            when 1 then receiver.send(name, params[0])
+            when 2 then receiver.send(name, params[0], params[1])
+            when 3 then receiver.send(name, params[0], params[1], params[2])
+            when 4 then receiver.send(name, params[0], params[1], params[2], params[3])
+            when 5 then receiver.send(name, params[0], params[1], params[2], params[3], params[4])
+            when 6 then receiver.send(name, params[0], params[1], params[2], params[3], params[4], params[5])
+            when 7 then receiver.send(name, params[0], params[1], params[2], params[3], params[4], params[5], params[6])
+            when 8 then receiver.send(name, params[0], params[1], params[2], params[3], params[4], params[5], params[6], params[7])
+            when 9 then receiver.send(name, params[0], params[1], params[2], params[3], params[4], params[5], params[6], params[7], params[8])
+            else
+              receiver.send(name, params[0], params[1], params[2], params[3], params[4], params[5], params[6], params[7], params[8], params[9])
+            end
+          end
         end
       end
 
@@ -278,7 +295,9 @@ module PDF
           []
         else
           obj = objects.deref_hash(origin)
-          PDF::Reader::Error.validate_not_nil_as_malformed(obj, "parent")
+          if obj.nil?
+            raise MalformedPDFError, "parent mus not be nil"
+          end
           [ select_inheritable(obj) ] + ancestors(obj[:Parent])
         end
       end

data/lib/pdf/reader/page_layout.rb

@@ -1,5 +1,5 @@
 # coding: utf-8
-# typed: true
+# typed: strict
 # frozen_string_literal: true
 
 require 'pdf/reader/overlapping_runs_filter'

data/lib/pdf/reader/page_state.rb

@@ -16,7 +16,7 @@ class PDF::Reader
         :h_scaling      => 1.0,
         :text_leading   => 0,
         :text_font      => nil,
-        :text_font_size => nil,
+        :text_font_size => 0,
         :text_mode      => 0,
         :text_rise      => 0,
         :text_knockout  => 0
@@ -32,6 +32,12 @@ class PDF::Reader
         @cs_stack      = [page.color_spaces]
         @stack         = [DEFAULT_GRAPHICS_STATE.dup]
         state[:ctm]  = identity_matrix
+
+        # These are only valid when inside a `BT` block and we re-initialize them on each
+        # `BT`. However, we need the instance variables set so PDFs with the text operators
+        # out order don't trigger NoMethodError when these are nil
+        @text_matrix      = identity_matrix
+        @text_line_matrix = identity_matrix
       end
 
       #####################################################

data/lib/pdf/reader/page_text_receiver.rb

@@ -62,6 +62,8 @@ module PDF
           runs = OverlappingRunsFilter.exclude_redundant_runs(runs)
         end
 
+        runs = NoTextFilter.exclude_empty_strings(runs)
+
         if opts.fetch(:merge, true)
           runs = merge_runs(runs)
         end

data/lib/pdf/reader/pages_strategy.rb

@@ -1,5 +1,5 @@
 # coding: utf-8
-# typed: true
+# typed: strict
 # frozen_string_literal: true
 
 ################################################################################

data/lib/pdf/reader/reference.rb

@@ -1,5 +1,5 @@
 # coding: utf-8
-# typed: true
+# typed: strict
 # frozen_string_literal: true
 
 ################################################################################
@@ -31,7 +31,8 @@ class PDF::Reader
   ################################################################################
   # An internal PDF::Reader class that represents an indirect reference to a PDF Object
   class Reference
-    attr_reader :id, :gen
+    attr_reader :id
+    attr_reader :gen
     ################################################################################
     # Create a new Reference to an object with the specified id and revision number
     def initialize(id, gen)

data/lib/pdf/reader/resources.rb

@@ -1,5 +1,5 @@
 # coding: utf-8
-# typed: true
+# typed: strict
 # frozen_string_literal: true
 
 module PDF
@@ -92,7 +92,8 @@ module PDF
       #       of calling it over and over.
       #
       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/stream.rb

@@ -40,7 +40,7 @@ class PDF::Reader
     # 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.
     def initialize(hash, data)
-      @hash = hash
+      @hash = TypeCheck.cast_to_pdf_dict!(hash)
       @data = data
       @udata = nil
     end

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

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,7 +7,10 @@ class PDF::Reader
   class TextRun
     include Comparable
 
-    attr_reader :origin, :width, :font_size, :text
+    attr_reader :origin
+    attr_reader :width
+    attr_reader :font_size
+    attr_reader :text
 
     alias :to_s :text