pdf-reader 2.6.0 → 2.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ccc4d14f5820ca798f6eafa1c0978207759ec1668c6f6307acb7cd43bcd0626e
-  data.tar.gz: 466bfe0a91f57463a56d9697ccd2529f981c6917e4ed578b4103f2bc87065522
+  metadata.gz: 6182ffd59631afba6a2c234547a428382b1ec2d7b414d89830b1143f1a0e1704
+  data.tar.gz: 6c0e6a7d32cf24912edc3aa96d72b7f70497d2fdd0e0913b86f871bbf9fa104f
 SHA512:
-  metadata.gz: 45d6c16b3d9ed029e6eb5a45cc64aa95e7ada2950e052053cbe0b6f5aae632f824a86f0505a5cee660abd1cd896177a0637a2f2f5a3f3633e829e8d46fb59817
-  data.tar.gz: e3e566344bd5560387577597dea20b2f7da40aed2a7fa8b8d074c0742486db59d7e349f6c38c91c8dcd9b0a8cf2aa4c19a00d0ee097003449504b3f06f18ca3c
+  metadata.gz: 42dafbe0c36ce838da4c3120bf2187efde647e486971896d9a9c59c37dac3da0f2ccf3ecd98d8dd1d3acc5404bfcf26e64a327d7797648646afd6b40be02fec2
+  data.tar.gz: 40f0b0958024b558d6aca7eb2b3b6f042f034059c8fca52ce97fab7d55a39c313797605341331c65efd1099a1310ccbe386c354024dbd3cbc61c1d96c423842d

data/CHANGELOG

@@ -1,6 +1,26 @@
+v2.8.0 (28th Decemeber 2021)
+- Add PDF::Reader::Page#runs for extracting text from a page with positioning metadata (http://github.com/yob/pdf-reader/pull/411)
+- Add options to PDF::Reader::Page#text to make some behaviour configurable (http://github.com/yob/pdf-reader/pull/411)
+    - including extracting the text for only part of the page
+- Improve text positioning and extraction for Type3 fonts (http://github.com/yob/pdf-reader/pull/412)
+- Skip extracting text that is positioned outside the page (http://github.com/yob/pdf-reader/pull/413)
+- Fix occasional crash when reading some streams (http://github.com/yob/pdf-reader/pull/405)
+
+v2.7.0 (13th December 2021)
+- Include RBI type files in the gem
+  - Downstream users of pdf-reader who also use sorbet *should* find many parts of the API will
+    now be typed checked by sorbet
+- Fix glyph positioning in some rotation scenarios (http://github.com/yob/pdf-reader/pull/403)
+  - Improved text extraction on some rotated pages, and rotated text on normal pages
+- Add PDF::Reader::Page#rectangles (http://github.com/yob/pdf-reader/pull/402)
+  - Returns page boxes (MediaBox, etc) with rotation applied, and as PORO rather than arrays of numbers
+- Add PDF::Reader::Page#origin (http://github.com/yob/pdf-reader/pull/400)
+- Add PDF::Reader::Page#{height,width} (http://github.com/yob/pdf-reader/pull/399)
+- Overlap filter should only drop characters that overlap *and* match (http://github.com/yob/pdf-reader/pull/401)
+
 v2.6.0 (12th November 2021)
 - Text extraction improvements
-  - Improved text layout on pages with a variery of font sizes (http://github.com/yob/pdf-reader/pull/355)
+  - Improved text layout on pages with a variety of font sizes (http://github.com/yob/pdf-reader/pull/355)
   - Fixed text positioning for some rotated pages (http://github.com/yob/pdf-reader/pull/356)
   - Improved character width calculation for PDFs using built-in (non-embedded) ZapfDingbats (http://github.com/yob/pdf-reader/pull/373)
   - Skip zero-width characters (http://github.com/yob/pdf-reader/pull/372)

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 = 32
+  cane.max_violations = 28
 
   cane.use Morecane::EncodingCheck, :encoding_glob => "{app,lib,spec}/**/*.rb"
 end

data/examples/rspec.rb

@@ -1,5 +1,6 @@
 #!/usr/bin/env ruby
 # coding: utf-8
+# typed: ignore
 
 #  Basic RSpec of a generated PDF
 #

data/lib/pdf/reader/bounding_rectangle_runs_filter.rb

@@ -0,0 +1,16 @@
+# coding: utf-8
+# typed: strict
+# frozen_string_literal: true
+
+class PDF::Reader
+
+  # Filter our text/characters that are positioned outside a rectangle. Usually the page
+  # MediaBox or CropBox, but could be a user specified rectangle too
+  class BoundingRectangleRunsFilter
+
+    def self.runs_within_rect(runs, rect)
+      runs.select { |run| rect.contains?(run.origin) }
+    end
+  end
+end
+

data/lib/pdf/reader/buffer.rb

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

data/lib/pdf/reader/cid_widths.rb

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

data/lib/pdf/reader/cmap.rb

@@ -1,4 +1,5 @@
 # coding: utf-8
+# typed: false
 # frozen_string_literal: true
 
 ################################################################################
@@ -32,6 +33,7 @@ class PDF::Reader
   # extracting various useful information.
   #
   class CMap # :nodoc:
+
     CMAP_KEYWORDS = {
       "begincodespacerange" => 1,
       "endcodespacerange" => 1,
@@ -53,7 +55,7 @@ class PDF::Reader
 
     def process_data(data)
       parser = build_parser(data)
-      mode = nil
+      mode = :none
       instructions = []
 
       while token = parser.parse_token(CMAP_KEYWORDS)
@@ -62,13 +64,13 @@ class PDF::Reader
         elsif token == "endbfchar"
           process_bfchar_instructions(instructions)
           instructions = []
-          mode = nil
+          mode = :none
         elsif token == "beginbfrange"
           mode = :range
         elsif token == "endbfrange"
           process_bfrange_instructions(instructions)
           instructions = []
-          mode = nil
+          mode = :none
         elsif mode == :char || mode == :range
           instructions << token
         end

data/lib/pdf/reader/encoding.rb

@@ -1,4 +1,5 @@
 # coding: utf-8
+# typed: true
 # frozen_string_literal: true
 
 ################################################################################
@@ -68,7 +69,7 @@ class PDF::Reader
     #
     #   [25, :A, :B]
     def differences=(diff)
-      raise ArgumentError, "diff must be an array" unless diff.kind_of?(Array)
+      PDF::Reader::Error.validate_type(diff, "diff", Array)
 
       @differences = {}
       byte = 0

data/lib/pdf/reader/error.rb

@@ -1,4 +1,5 @@
 # coding: utf-8
+# typed: strict
 # frozen_string_literal: true
 
 ################################################################################
@@ -46,6 +47,13 @@ class PDF::Reader
       raise MalformedPDFError, "PDF malformed, expected '#{rvalue}' but found '#{lvalue}' instead" if lvalue != rvalue
     end
     ################################################################################
+    def self.validate_type(object, name, klass)
+      raise ArgumentError, "#{name} (#{object}) must be a #{klass}" unless object.is_a?(klass)
+    end
+    ################################################################################
+    def self.validate_not_nil(object, name)
+      raise ArgumentError, "#{object} must not be nil" if object.nil?
+    end
   end
 
   ################################################################################

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

@@ -1,4 +1,5 @@
 # coding: utf-8
+# typed: false
 # frozen_string_literal: true
 
 require 'ascii85'
@@ -7,6 +8,7 @@ class PDF::Reader
   module Filter # :nodoc:
     # implementation of the Ascii85 filter
     class Ascii85
+
       def initialize(options = {})
         @options = options
       end

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

@@ -1,4 +1,5 @@
 # coding: utf-8
+# typed: true
 # frozen_string_literal: true
 
 #
@@ -6,6 +7,7 @@ class PDF::Reader
   module Filter # :nodoc:
     # implementation of the AsciiHex stream filter
     class AsciiHex
+
       def initialize(options = {})
         @options = options
       end
@@ -16,9 +18,12 @@ class PDF::Reader
       def filter(data)
         data.chop! if data[-1,1] == ">"
         data = data[1,data.size] if data[0,1] == "<"
+
+        return "" if data.nil?
+
         data.gsub!(/[^A-Fa-f0-9]/,"")
         data << "0" if data.size % 2 == 1
-        data.scan(/.{2}/).map { |s| s.hex.chr }.join("")
+        data.scan(/.{2}/).flatten.map { |s| s.hex.chr }.join("")
       rescue Exception => e
         # Oops, there was a problem decoding the stream
         raise MalformedPDFError,

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

@@ -1,4 +1,5 @@
 # coding: utf-8
+# typed: true
 # frozen_string_literal: true
 
 class PDF::Reader
@@ -6,6 +7,7 @@ class PDF::Reader
     # some filter implementations support preprocessing of the  data to
     # improve compression
     class Depredict
+
       def initialize(options = {})
         @options = options || {}
       end
@@ -67,7 +69,7 @@ class PDF::Reader
         scanline_length = (pixel_bytes * @options[:Columns]) + 1
         row = 0
         pixels = []
-        paeth, pa, pb, pc = nil
+        paeth, pa, pb, pc = 0, 0, 0, 0
         until data.empty? do
           row_data = data.slice! 0, scanline_length
           filter = row_data.shift
@@ -94,17 +96,17 @@ class PDF::Reader
               row_data[index] = (byte + ((left + upper)/2).floor) % 256
             end
           when 4 # Paeth
-            left = upper = upper_left = nil
+            left = upper = upper_left = 0
             row_data.each_with_index do |byte, index|
               col = index / pixel_bytes
 
-              left = index < pixel_bytes ? 0 : row_data[index - pixel_bytes]
+              left = index < pixel_bytes ? 0 : Integer(row_data[index - pixel_bytes])
               if row.zero?
                 upper = upper_left = 0
               else
-                upper = pixels[row-1][col][index % pixel_bytes]
+                upper = Integer(pixels[row-1][col][index % pixel_bytes])
                 upper_left = col.zero? ? 0 :
-                  pixels[row-1][col-1][index % pixel_bytes]
+                  Integer(pixels[row-1][col-1][index % pixel_bytes])
               end
 
               p = left + upper - upper_left

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

@@ -1,4 +1,5 @@
 # coding: utf-8
+# typed: true
 # frozen_string_literal: true
 
 
@@ -8,6 +9,7 @@ class PDF::Reader
   module Filter # :nodoc:
     # 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
 

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

@@ -1,4 +1,5 @@
 # coding: utf-8
+# typed: true
 # frozen_string_literal: true
 
 #
@@ -6,6 +7,7 @@ class PDF::Reader
   module Filter # :nodoc:
     # implementation of the LZW stream filter
     class Lzw
+
       def initialize(options = {})
         @options = options
       end

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

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

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

@@ -1,4 +1,5 @@
 # coding: utf-8
+# typed: true
 # frozen_string_literal: true
 
 #
@@ -6,6 +7,7 @@ class PDF::Reader # :nodoc:
   module Filter # :nodoc:
     # implementation of the run length stream filter
     class RunLength
+
       def initialize(options = {})
         @options = options
       end
@@ -20,19 +22,23 @@ class PDF::Reader # :nodoc:
           length = data.getbyte(pos)
           pos += 1
 
-          case
-          when length == 128
-            break
-          when length < 128
-            # When the length is < 128, we copy the following length+1 bytes
-            # literally.
-            out << data[pos, length + 1]
-            pos += length
-          else
-            # When the length is > 128, we copy the next byte (257 - length)
-            # times; i.e., "\xFA\x00" ([250, 0]) will expand to
-            # "\x00\x00\x00\x00\x00\x00\x00".
-            out << data[pos, 1] * (257 - length)
+          unless length.nil?
+            case
+              # nothing
+            when length == 128
+              break
+            when length < 128
+              # When the length is < 128, we copy the following length+1 bytes
+              # literally.
+              out << data[pos, length + 1]
+              pos += length
+            else
+              # When the length is > 128, we copy the next byte (257 - length)
+              # times; i.e., "\xFA\x00" ([250, 0]) will expand to
+              # "\x00\x00\x00\x00\x00\x00\x00".
+              previous_byte = data[pos, 1] || ""
+              out << previous_byte * (257 - length)
+            end
           end
 
           pos += 1

data/lib/pdf/reader/filter.rb

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

data/lib/pdf/reader/font.rb

@@ -1,4 +1,5 @@
 # coding: utf-8
+# typed: true
 # frozen_string_literal: true
 
 ################################################################################
@@ -42,6 +43,7 @@ class PDF::Reader
       @tounicode = nil
 
       extract_base_info(obj)
+      extract_type3_info(obj)
       extract_descriptor(obj)
       extract_descendants(obj)
       @width_calc = build_width_calculator
@@ -72,8 +74,44 @@ class PDF::Reader
       @cached_widths[code_point] ||= @width_calc.glyph_width(code_point)
     end
 
+    # In most cases glyph width is converted into text space with a simple divide by 1000.
+    #
+    # However, Type3 fonts provide their own FontMatrix that's used for the transformation.
+    #
+    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)
+        (x2 - x1).abs.round(2)
+      else
+        glyph_width_in_glyph_space / 1000.0
+      end
+    end
+
     private
 
+    # Only valid for Type3 fonts
+    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],
+      )
+
+      if x == 0 && y == 0
+        [matrix.e, matrix.f]
+      else
+        [
+          (matrix.a * x) + (matrix.c * y) + (matrix.e),
+          (matrix.b * x) + (matrix.d * y) + (matrix.f)
+        ]
+      end
+    end
+
     def default_encoding(font_name)
       case font_name.to_s
       when "Symbol" then
@@ -137,6 +175,12 @@ class PDF::Reader
       end
     end
 
+    def extract_type3_info(obj)
+      if @subtype == :Type3
+        @font_matrix = @ohash.object(obj[:FontMatrix]) || [ 0.001, 0, 0, 0.001, 0, 0 ]
+      end
+    end
+
     def extract_descriptor(obj)
       if obj[:FontDescriptor]
         # create a font descriptor object if we can, in other words, unless this is

data/lib/pdf/reader/font_descriptor.rb

@@ -1,4 +1,5 @@
 # coding: utf-8
+# typed: true
 # frozen_string_literal: true
 
 require 'ttfunk'

data/lib/pdf/reader/form_xobject.rb

@@ -1,4 +1,5 @@
 # coding: utf-8
+# typed: true
 # frozen_string_literal: true
 
 require 'digest/md5'

data/lib/pdf/reader/glyph_hash.rb

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

data/lib/pdf/reader/lzw.rb

@@ -1,4 +1,5 @@
 # coding: utf-8
+# typed: true
 # frozen_string_literal: true
 
 module PDF
@@ -35,9 +36,9 @@ module PDF
 
         def read
           bits_left_in_chunk = @bits_in_chunk
-          chunk = nil
+          chunk = -1
           while bits_left_in_chunk > 0 and @current_pos < @data.size
-            chunk = 0 if chunk.nil?
+            chunk = 0 if chunk < 0
             codepoint = @data[@current_pos, 1].unpack("C*")[0]
             current_byte = codepoint & (2**@bits_left_in_byte - 1) #clear consumed bits
             dif = bits_left_in_chunk - @bits_left_in_byte
@@ -83,6 +84,7 @@ module PDF
       #
       def self.decode(data)
         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
           if code == CODE_CLEAR_TABLE

data/lib/pdf/reader/null_security_handler.rb

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

data/lib/pdf/reader/object_cache.rb

@@ -1,4 +1,5 @@
 # coding: utf-8
+# typed: true
 # frozen_string_literal: true
 
 require 'hashery/lru_hash'

data/lib/pdf/reader/object_hash.rb

@@ -1,4 +1,5 @@
 # coding: utf-8
+# typed: true
 # frozen_string_literal: true
 
 class PDF::Reader
@@ -336,8 +337,10 @@ class PDF::Reader
         obj.data = sec_handler.decrypt(obj.data, ref) unless obj.hash[:Type] == :XRef
         obj
       when Hash                then
-        arr = obj.map { |key,val| [key, decrypt(ref, val)] }.flatten(1)
-        Hash[*arr]
+        arr = obj.map { |key,val| [key, decrypt(ref, val)] }
+        arr.each_with_object({}) { |(k,v), accum|
+          accum[k] = v
+        }
       when Array               then
         obj.collect { |item| decrypt(ref, item) }
       when String

data/lib/pdf/reader/object_stream.rb

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

data/lib/pdf/reader/overlapping_runs_filter.rb

@@ -1,4 +1,6 @@
+# typed: true
 # coding: utf-8
+# frozen_string_literal: true
 
 class PDF::Reader
   # remove duplicates from a collection of TextRun objects. This can be helpful when a PDF
@@ -38,7 +40,8 @@ class PDF::Reader
 
     def self.detect_intersection(sweep_line_status, event_point)
       sweep_line_status.each do |open_text_run|
-        if event_point.x >= open_text_run.x &&
+        if open_text_run.text == event_point.run.text &&
+            event_point.x >= open_text_run.x &&
             event_point.x <= open_text_run.endx &&
             open_text_run.intersection_area_percent(event_point.run) >= OVERLAPPING_THRESHOLD
           return true
@@ -51,10 +54,14 @@ class PDF::Reader
   # Utility class used to avoid modifying the underlying TextRun objects while we're
   # looking for duplicates
   class EventPoint
-    attr_reader :x, :run
 
-    def initialize x, run
-      @x, @run = x, run
+    attr_reader :x
+
+    attr_reader :run
+
+    def initialize(x, run)
+      @x = x
+      @run = run
     end
 
     def start?

data/lib/pdf/reader/page.rb

@@ -1,4 +1,5 @@
 # coding: utf-8
+# typed: true
 # frozen_string_literal: true
 
 module PDF
@@ -68,22 +69,56 @@ module PDF
         @attributes
       end
 
+      def height
+        rect = Rectangle.new(*attributes[:MediaBox])
+        rect.apply_rotation(rotate) if rotate > 0
+        rect.height
+      end
+
+      def width
+        rect = Rectangle.new(*attributes[:MediaBox])
+        rect.apply_rotation(rotate) if rotate > 0
+        rect.width
+      end
+
+      def origin
+        rect = Rectangle.new(*attributes[:MediaBox])
+        rect.apply_rotation(rotate) if rotate > 0
+
+        rect.bottom_left
+      end
+
       # Convenience method to identify the page's orientation.
       #
       def orientation
-        OrientationDetector.new(attributes).orientation
+        if height > width
+          "portrait"
+        else
+          "landscape"
+        end
       end
 
       # returns the plain text content of this page encoded as UTF-8. Any
       # characters that can't be translated will be returned as a ▯
       #
-      def text
+      def text(opts = {})
         receiver = PageTextReceiver.new
         walk(receiver)
-        receiver.content
+        runs = receiver.runs(opts)
+
+        # rectangles[:MediaBox] can never be nil, but I have no easy way to tell sorbet that atm
+        mediabox = rectangles[:MediaBox] || Rectangle.new(0, 0, 0, 0)
+
+        PageLayout.new(runs, mediabox).to_s
       end
       alias :to_s :text
 
+      def runs(opts = {})
+        receiver = PageTextReceiver.new
+        walk(receiver)
+        receiver.runs(opts)
+      end
+
       # processes the raw content stream for this page in sequential order and
       # passes callbacks to the receiver objects.
       #
@@ -139,23 +174,50 @@ module PDF
       # returns the "boxes" that define the page object.
       # values are defaulted according to section 7.7.3.3 of the PDF Spec 1.7
       #
+      # DEPRECATED. Recommend using Page#rectangles instead
+      #
       def boxes
-        mediabox = attributes[:MediaBox]
-        cropbox = attributes[:Cropbox] || mediabox
+        # In ruby 2.4+ we could use Hash#transform_values
+        Hash[rectangles.map{ |k,rect| [k,rect.to_a] } ]
+      end
+
+      # returns the "boxes" that define the page object.
+      # values are defaulted according to section 7.7.3.3 of the PDF Spec 1.7
+      #
+      def rectangles
+        mediabox = objects.deref!(attributes[:MediaBox])
+        cropbox = objects.deref!(attributes[:Cropbox]) || mediabox
+        bleedbox = objects.deref!(attributes[:BleedBox]) || cropbox
+        trimbox = objects.deref!(attributes[:TrimBox]) || cropbox
+        artbox = objects.deref!(attributes[:ArtBox]) || cropbox
+
+        mediarect = Rectangle.new(*mediabox)
+        croprect = Rectangle.new(*cropbox)
+        bleedrect = Rectangle.new(*bleedbox)
+        trimrect = Rectangle.new(*trimbox)
+        artrect = Rectangle.new(*artbox)
+
+        if rotate > 0
+          mediarect.apply_rotation(rotate)
+          croprect.apply_rotation(rotate)
+          bleedrect.apply_rotation(rotate)
+          trimrect.apply_rotation(rotate)
+          artrect.apply_rotation(rotate)
+        end
 
         {
-          MediaBox: objects.deref!(mediabox),
-          CropBox: objects.deref!(cropbox),
-          BleedBox: objects.deref!(attributes[:BleedBox] || cropbox),
-          TrimBox: objects.deref!(attributes[:TrimBox] || cropbox),
-          ArtBox: objects.deref!(attributes[:ArtBox] || cropbox)
+          MediaBox: mediarect,
+          CropBox: croprect,
+          BleedBox: bleedrect,
+          TrimBox: trimrect,
+          ArtBox: artrect,
         }
       end
 
       private
 
       def root
-        root ||= objects.deref(@objects.trailer[:Root])
+       @root ||= objects.deref(@objects.trailer[:Root])
       end
 
       # Returns the resources that accompany this page. Includes