pdf-reader 2.6.0 → 2.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ccc4d14f5820ca798f6eafa1c0978207759ec1668c6f6307acb7cd43bcd0626e
-  data.tar.gz: 466bfe0a91f57463a56d9697ccd2529f981c6917e4ed578b4103f2bc87065522
+  metadata.gz: 5ee0d8c3c55f6a0aebb60a0a6dce92428e8371b96a6beb6d75bfe90602bffae7
+  data.tar.gz: '0911d108353bf577aa9fd7b49b97dda1cf9d54816bf8ff6c4225281eeda63229'
 SHA512:
-  metadata.gz: 45d6c16b3d9ed029e6eb5a45cc64aa95e7ada2950e052053cbe0b6f5aae632f824a86f0505a5cee660abd1cd896177a0637a2f2f5a3f3633e829e8d46fb59817
-  data.tar.gz: e3e566344bd5560387577597dea20b2f7da40aed2a7fa8b8d074c0742486db59d7e349f6c38c91c8dcd9b0a8cf2aa4c19a00d0ee097003449504b3f06f18ca3c
+  metadata.gz: 917db2b1fb977b41e7b057ff3d215b8f249577254d9fe3df72f330b32ff49630874c58f480495ddcd137d9f31d014083438623cdf7260b0d7a87bbe3a5f3685a
+  data.tar.gz: cd9832f025264e54d586e81eff69727379e8646d741f53ae61e90a5b38945d852147853891d468bab683581bdd0beb68a9b7c7f5e54e064e9a3935262ea9d651

data/CHANGELOG

@@ -1,6 +1,18 @@
+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/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/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
 
 ################################################################################

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,10 +69,33 @@ 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
@@ -139,23 +163,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

data/lib/pdf/reader/page_layout.rb

@@ -1,4 +1,5 @@
 # coding: utf-8
+# typed: true
 # frozen_string_literal: true
 
 require 'pdf/reader/overlapping_runs_filter'
@@ -16,16 +17,17 @@ class PDF::Reader
     DEFAULT_FONT_SIZE = 12
 
     def initialize(runs, mediabox)
-      raise ArgumentError, "a mediabox must be provided" if mediabox.nil?
+      # mediabox is a 4-element array for now, but it'd be nice to switch to a
+      # PDF::Reader::Rectangle at some point
+      PDF::Reader::Error.validate_not_nil(mediabox, "mediabox")
 
       runs = ZeroWidthRunsFilter.exclude_zero_width_runs(runs)
       runs = OverlappingRunsFilter.exclude_redundant_runs(runs)
+      @mediabox = mediabox
       @runs = merge_runs(runs)
       @mean_font_size   = mean(@runs.map(&:font_size)) || DEFAULT_FONT_SIZE
       @mean_font_size = DEFAULT_FONT_SIZE if @mean_font_size == 0
       @median_glyph_width = median(@runs.map(&:mean_character_width)) || 0
-      @page_width  = (mediabox[2] - mediabox[0]).abs
-      @page_height = (mediabox[3] - mediabox[1]).abs
       @x_offset = @runs.map(&:x).sort.first || 0
       lowest_y = @runs.map(&:y).sort.first || 0
       @y_offset = lowest_y > 0 ? 0 : lowest_y
@@ -48,6 +50,16 @@ class PDF::Reader
 
     private
 
+    def page_width
+      # TODO once @mediabox is a Rectangle, this can be just `@mediabox.width`
+      (@mediabox[2].to_f - @mediabox[0].to_f).abs
+    end
+
+    def page_height
+      # TODO once @mediabox is a Rectangle, this can be just `@mediabox.height`
+      (@mediabox[3].to_f - @mediabox[1].to_f).abs
+    end
+
     # given an array of strings, return a new array with empty rows from the
     # beginning and end removed.
     #
@@ -66,19 +78,19 @@ class PDF::Reader
     end
 
     def row_count
-      @row_count ||= (@page_height / @mean_font_size).floor
+      @row_count ||= (page_height / @mean_font_size).floor
     end
 
     def col_count
-      @col_count ||= ((@page_width  / @median_glyph_width) * 1.05).floor
+      @col_count ||= ((page_width  / @median_glyph_width) * 1.05).floor
     end
 
     def row_multiplier
-      @row_multiplier ||= @page_height.to_f / row_count.to_f
+      @row_multiplier ||= page_height.to_f / row_count.to_f
     end
 
     def col_multiplier
-      @col_multiplier ||= @page_width.to_f / col_count.to_f
+      @col_multiplier ||= page_width.to_f / col_count.to_f
     end
 
     def mean(collection)
@@ -108,17 +120,15 @@ class PDF::Reader
     end
 
     def group_chars_into_runs(chars)
-      runs = []
-      while head = chars.shift
+      chars.each_with_object([]) do |char, runs|
         if runs.empty?
-          runs << head
-        elsif runs.last.mergable?(head)
-          runs[-1] = runs.last + head
+          runs << char
+        elsif runs.last.mergable?(char)
+          runs[-1] = runs.last + char
         else
-          runs << head
+          runs << char
         end
       end
-      runs
     end
 
     def local_string_insert(haystack, needle, index)