pdf-reader 2.10.0 → 2.12.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 55bfae4c5211a0f3ac70845500183e237d3d5f9cc81d548a27f4b8c5fd5acfc9
-  data.tar.gz: 9e9000474695100c4874afd9abf5f6290ea0b59ffa773c3d03a4a3fc3d2a0a4c
+  metadata.gz: e3b00946c8b23b65d19ace187550b15bb3fd2537e518c778f4c12da28672c9d8
+  data.tar.gz: 4c2ebeb19dada9f257fa65c2add2f2f6d64f011cb13e997533a4b63fc81baa6d
 SHA512:
-  metadata.gz: 2dc96f064c3b233bd499a5a8140bb6f61fd1bdadb2582ac9bc569adff911e63aaadc16188d6624e0ed766481d453912bf5e0057add84262d753681cc40f51776
-  data.tar.gz: 64dfac4dd2b73a5302be95c47e74e7ca8b94fc6daeaea30c7a33cca6b4be79b68facc571d209f44a59de2632f6241166a290fe0f2835498b2b7d611906b05a31
+  metadata.gz: 99c9ac879424056221f616d7f7299d03dfc9906c6b81c333ad255439780cf56d2dfc0c31a62347a7a163bcdb4075f8d0c914e2deeebb5d78e8ebc34e19cd7abc
+  data.tar.gz: 50ef8b5e1061dd1d6b24a7727b5537664bcb22473757274b4cc2b92c89b9ba5ea7516f055571f5c8b72d678f7cef549858631408c86a6984196ba7d1773daaca

data/CHANGELOG

@@ -1,3 +1,12 @@
+v2.12.0 (26th December 2023)
+- Fix a sorbet method signature (http://github.com/yob/pdf-reader/pull/512)
+- Reduce allocations when parsing PDFs with hex strings (http://github.com/yob/pdf-reader/pull/528)
+- Fix text extraction of some rare unicode codepoints (http://github.com/yob/pdf-reader/pull/529)
+
+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

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

@@ -300,13 +300,12 @@ class PDF::Reader
     # we find a closing >
     #
     def prepare_hex_token
-      finished = :false
       str = "".dup
 
-      until finished == :true
+      loop do
         byte = @io.getbyte
         if byte.nil?
-          finished = :true # unbalanced params
+          break
         elsif (48..57).include?(byte) || (65..90).include?(byte) || (97..122).include?(byte)
           str << byte
         elsif byte <= 32
@@ -315,7 +314,7 @@ class PDF::Reader
           @tokens << str if str.size > 0
           @tokens << ">" if byte != 0x3E # '>'
           @tokens << byte.chr
-          finished = :true
+          break
         end
       end
     end

data/lib/pdf/reader/cid_widths.rb

@@ -52,7 +52,9 @@ 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)
-      raise MalformedPDFError, "CidWidths: #{first} must be less than #{final}" unless first < final
+      if first > final
+        raise MalformedPDFError, "CidWidths: #{first} must be less than #{final}"
+      end
 
       (first..final).inject({}) { |accum, index|
         accum[index] = width

data/lib/pdf/reader/cmap.rb

@@ -118,8 +118,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)

data/lib/pdf/reader/encoding.rb

@@ -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
@@ -119,7 +119,7 @@ class PDF::Reader
     #     => [:A]
     #
     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]]
@@ -143,7 +143,6 @@ class PDF::Reader
         CONTROL_CHARS.include?(i) ? [i, UNKNOWN_CHAR] : [i,i]
       }
       mapping = Hash[tuples]
-      mapping[nil] = UNKNOWN_CHAR
       mapping
     end
 
@@ -167,7 +166,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/filter/depredict.rb

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

data/lib/pdf/reader/font.rb

@@ -82,8 +82,8 @@ class PDF::Reader
       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

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

@@ -42,7 +42,7 @@ module PDF
           while bits_left_in_chunk > 0 and @current_pos < @data.size
             chunk = 0 if chunk < 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
+            current_byte = codepoint & (2**@bits_left_in_byte - 1).to_i #clear consumed bits
             dif = bits_left_in_chunk - @bits_left_in_byte
             if dif > 0 then  current_byte <<= dif
             elsif dif < 0 then  current_byte >>= dif.abs

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.
@@ -566,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
@@ -591,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
 

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

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
 

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_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/parser.rb

@@ -173,9 +173,7 @@ class PDF::Reader
 
       # add a missing digit if required, as required by the spec
       str << "0" unless str.size % 2 == 0
-      str.chars.each_slice(2).map { |nibbles|
-        nibbles.join("").hex.chr
-      }.join.force_encoding("binary")
+      [str].pack('H*')
     end
     ################################################################################
     # Reads a PDF String from the buffer and converts it to a Ruby String

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

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
 

data/lib/pdf/reader/transformation_matrix.rb

@@ -1,5 +1,5 @@
 # coding: utf-8
-# typed: true
+# typed: strict
 # frozen_string_literal: true
 
 class PDF::Reader
@@ -51,7 +51,7 @@ class PDF::Reader
     #       displacement to speed up processing documents that use vertical
     #       writing systems
     #
-    def multiply!(a,b=nil,c=nil, d=nil,e=nil,f=nil)
+    def multiply!(a,b,c, d,e,f)
       if a == 1 && b == 0 && c == 0 && d == 1 && e == 0 && f == 0
         # the identity matrix, no effect
         self
@@ -164,12 +164,12 @@ class PDF::Reader
     #   [ e f 1 ]   [ e f 1 ]
     #
     def regular_multiply!(a2,b2,c2,d2,e2,f2)
-      newa = (@a * a2) + (@b * c2) + (0 * e2)
-      newb = (@a * b2) + (@b * d2) + (0 * f2)
-      newc = (@c * a2) + (@d * c2) + (0 * e2)
-      newd = (@c * b2) + (@d * d2) + (0 * f2)
-      newe = (@e * a2) + (@f * c2) + (1 * e2)
-      newf = (@e * b2) + (@f * d2) + (1 * f2)
+      newa = (@a * a2) + (@b * c2) + (e2 * 0)
+      newb = (@a * b2) + (@b * d2) + (f2 * 0)
+      newc = (@c * a2) + (@d * c2) + (e2 * 0)
+      newd = (@c * b2) + (@d * d2) + (f2 * 0)
+      newe = (@e * a2) + (@f * c2) + (e2 * 1)
+      newf = (@e * b2) + (@f * d2) + (f2 * 1)
       @a, @b, @c, @d, @e, @f = newa, newb, newc, newd, newe, newf
     end
 

data/lib/pdf/reader/xref.rb

@@ -73,7 +73,7 @@ class PDF::Reader
     #
     # ref - a PDF::Reader::Reference object containing an object ID and revision number
     def [](ref)
-      @xref[ref.id][ref.gen]
+      @xref.fetch(ref.id, {}).fetch(ref.gen)
     rescue
       raise InvalidObjectError, "Object #{ref.id}, Generation #{ref.gen} is invalid"
     end
@@ -82,8 +82,8 @@ class PDF::Reader
     def each(&block)
       ids = @xref.keys.sort
       ids.each do |id|
-        gen = @xref[id].keys.sort[-1]
-        yield PDF::Reader::Reference.new(id, gen)
+        gen = @xref.fetch(id, {}).keys.sort[-1]
+        yield PDF::Reader::Reference.new(id, gen.to_i)
       end
     end
     ################################################################################

data/lib/pdf/reader.rb

@@ -1,5 +1,5 @@
 # coding: utf-8
-# typed: true
+# typed: strict
 # frozen_string_literal: true
 
 ################################################################################
@@ -128,7 +128,7 @@ module PDF
       doc_strings_to_utf8(dict)
     end
 
-    # Return a Hash with extra metadata provided by the author of the PDF file. Not
+    # Return a String with extra XML metadata provided by the author of the PDF file. Not
     # always present.
     #
     def metadata
@@ -182,7 +182,7 @@ module PDF
     #
     #   reader.pages.each do |page|
     #     puts page.fonts
-    #     puts page.images
+    #     puts page.rectangles
     #     puts page.text
     #   end
     #
@@ -272,13 +272,7 @@ module PDF
     end
 
     def root
-      @root ||= begin
-        obj = @objects.deref_hash(@objects.trailer[:Root]) || {}
-        unless obj.kind_of?(::Hash)
-          raise MalformedPDFError, "PDF malformed, trailer Root should be a dictionary"
-        end
-        obj
-      end
+      @root ||= @objects.deref_hash(@objects.trailer[:Root]) || {}
     end
 
   end
@@ -315,6 +309,7 @@ require 'pdf/reader/print_receiver'
 require 'pdf/reader/rectangle'
 require 'pdf/reader/reference'
 require 'pdf/reader/register_receiver'
+require 'pdf/reader/no_text_filter'
 require 'pdf/reader/null_security_handler'
 require 'pdf/reader/security_handler_factory'
 require 'pdf/reader/standard_key_builder'