pdf-reader 2.6.0 → 2.8.0

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,15 @@ 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)
-      @runs = merge_runs(runs)
+      @mediabox = process_mediabox(mediabox)
+      @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 +48,14 @@ class PDF::Reader
 
     private
 
+    def page_width
+      @mediabox.width
+    end
+
+    def page_height
+      @mediabox.height
+    end
+
     # given an array of strings, return a new array with empty rows from the
     # beginning and end removed.
     #
@@ -66,19 +74,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)
@@ -97,32 +105,20 @@ class PDF::Reader
       end
     end
 
-    # take a collection of TextRun objects and merge any that are in close
-    # proximity
-    def merge_runs(runs)
-      runs.group_by { |char|
-        char.y.to_i
-      }.map { |y, chars|
-        group_chars_into_runs(chars.sort)
-      }.flatten.sort
+    def local_string_insert(haystack, needle, index)
+      haystack[Range.new(index, index + needle.length - 1)] = String.new(needle)
     end
 
-    def group_chars_into_runs(chars)
-      runs = []
-      while head = chars.shift
-        if runs.empty?
-          runs << head
-        elsif runs.last.mergable?(head)
-          runs[-1] = runs.last + head
-        else
-          runs << head
-        end
+    def process_mediabox(mediabox)
+      if mediabox.is_a?(Array)
+        msg = "Passing the mediabox to PageLayout as an Array is deprecated," +
+          " please use a Rectangle instead"
+        $stderr.puts msg
+        PDF::Reader::Rectangle.from_array(mediabox)
+      else
+        mediabox
       end
-      runs
     end
 
-    def local_string_insert(haystack, needle, index)
-      haystack[Range.new(index, index + needle.length - 1)] = String.new(needle)
-    end
   end
 end

data/lib/pdf/reader/page_state.rb

@@ -1,4 +1,5 @@
 # coding: utf-8
+# typed: true
 # frozen_string_literal: true
 
 require 'pdf/reader/transformation_matrix'
@@ -312,7 +313,7 @@ class PDF::Reader
       #                 may need to be added
       #
       def process_glyph_displacement(w0, tj, word_boundary)
-        fs = font_size # font size
+        fs = state[:text_font_size]
         tc = state[:char_spacing]
         if word_boundary
           tw = state[:word_spacing]
@@ -330,16 +331,16 @@ class PDF::Reader
           # apply horizontal scaling to spacing values but not font size
           tx = ((w0 * fs) + tc + tw) * th
         end
-
-        # TODO: I'm pretty sure that tx shouldn't need to be divided by
-        #       ctm[0] here, but this gets my tests green and I'm out of
-        #       ideas for now
         # TODO: support ty > 0
-        if ctm.a == 1 || ctm.a == 0
-          @text_matrix.horizontal_displacement_multiply!(tx)
-        else
-          @text_matrix.horizontal_displacement_multiply!(tx/ctm.a)
-        end
+        ty = 0
+        temp = TransformationMatrix.new(1, 0,
+                                        0, 1,
+                                        tx, ty)
+        @text_matrix = temp.multiply!(
+          @text_matrix.a, @text_matrix.b,
+          @text_matrix.c, @text_matrix.d,
+          @text_matrix.e, @text_matrix.f
+        )
         @font_size = @text_rendering_matrix = nil # invalidate cached value
       end
 

data/lib/pdf/reader/page_text_receiver.rb

@@ -1,4 +1,5 @@
 # coding: utf-8
+# typed: true
 # frozen_string_literal: true
 
 require 'forwardable'
@@ -44,14 +45,34 @@ module PDF
         @page = page
         @content = []
         @characters = []
-        @mediabox = page.objects.deref(page.attributes[:MediaBox])
-        device_bl = apply_rotation(*@state.ctm_transform(@mediabox[0], @mediabox[1]))
-        device_tr = apply_rotation(*@state.ctm_transform(@mediabox[2], @mediabox[3]))
-        @device_mediabox = [ device_bl.first, device_bl.last, device_tr.first, device_tr.last]
       end
 
+      def runs(opts = {})
+        runs = @characters
+
+        if rect = opts.fetch(:rect, @page.rectangles[:CropBox])
+          runs = BoundingRectangleRunsFilter.runs_within_rect(runs, rect)
+        end
+
+        if opts.fetch(:skip_zero_width, true)
+          runs = ZeroWidthRunsFilter.exclude_zero_width_runs(runs)
+        end
+
+        if opts.fetch(:skip_overlapping, true)
+          runs = OverlappingRunsFilter.exclude_redundant_runs(runs)
+        end
+
+        if opts.fetch(:merge, true)
+          runs = merge_runs(runs)
+        end
+
+        runs
+      end
+
+      # deprecated
       def content
-        PageLayout.new(@characters, @device_mediabox).to_s
+        mediabox = @page.rectangles[:MediaBox]
+        PageLayout.new(runs, mediabox).to_s
       end
 
       #####################################################
@@ -111,7 +132,7 @@ module PDF
 
           # apply to glyph displacment for the current glyph so the next
           # glyph will appear in the correct position
-          glyph_width = @state.current_font.glyph_width(glyph_code) / 1000.0
+          glyph_width = @state.current_font.glyph_width_in_text_space(glyph_code)
           th = 1
           scaled_glyph_width = glyph_width * @state.font_size * th
           unless utf8_chars == SPACE
@@ -128,14 +149,37 @@ module PDF
           y = tmp * -1
         elsif @page.rotate == 180
           y *= -1
+          x *= -1
         elsif @page.rotate == 270
-          tmp = x
-          x = y * -1
-          y = tmp * -1
+          tmp = y
+          y = x
+          x = tmp * -1
         end
         return x, y
       end
 
+      # take a collection of TextRun objects and merge any that are in close
+      # proximity
+      def merge_runs(runs)
+        runs.group_by { |char|
+          char.y.to_i
+        }.map { |y, chars|
+          group_chars_into_runs(chars.sort)
+        }.flatten.sort
+      end
+
+      def group_chars_into_runs(chars)
+        chars.each_with_object([]) do |char, runs|
+          if runs.empty?
+            runs << char
+          elsif runs.last.mergable?(char)
+            runs[-1] = runs.last + char
+          else
+            runs << char
+          end
+        end
+      end
+
     end
   end
 end

data/lib/pdf/reader/pages_strategy.rb

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

data/lib/pdf/reader/parser.rb

@@ -1,4 +1,5 @@
 # coding: utf-8
+# typed: true
 # frozen_string_literal: true
 
 ################################################################################
@@ -166,7 +167,9 @@ class PDF::Reader
 
       # add a missing digit if required, as required by the spec
       str << "0" unless str.size % 2 == 0
-      str.scan(/../).map {|i| i.hex.chr}.join.force_encoding("binary")
+      str.chars.each_slice(2).map { |nibbles|
+        nibbles.join("").hex.chr
+      }.join.force_encoding("binary")
     end
     ################################################################################
     # Reads a PDF String from the buffer and converts it to a Ruby String
@@ -207,6 +210,9 @@ class PDF::Reader
       raise MalformedPDFError, "PDF malformed, missing stream length" unless dict.has_key?(:Length)
       if @objects
         length = @objects.deref(dict[:Length])
+        if dict[:Filter]
+          dict[:Filter] = @objects.deref(dict[:Filter])
+        end
       else
         length = dict[:Length] || 0
       end

data/lib/pdf/reader/point.rb

@@ -0,0 +1,25 @@
+# coding: utf-8
+# typed: true
+# frozen_string_literal: true
+
+module PDF
+  class Reader
+
+    # PDFs are all about positioning content on a page, so there's lots of need to
+    # work with a set of X,Y coordinates.
+    #
+    class Point
+
+      attr_reader :x, :y
+
+      def initialize(x, y)
+        @x, @y = x, y
+      end
+
+      def ==(other)
+        other.respond_to?(:x) && other.respond_to?(:y) && x == other.x && y == other.y
+      end
+
+    end
+  end
+end

data/lib/pdf/reader/print_receiver.rb

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

data/lib/pdf/reader/rectangle.rb

@@ -0,0 +1,113 @@
+# coding: utf-8
+# typed: true
+# frozen_string_literal: true
+
+module PDF
+  class Reader
+
+    # PDFs represent rectangles all over the place. They're 4 element arrays, like this:
+    #
+    #     [A, B, C, D]
+    #
+    # Four element arrays are yucky to work with though, so here's a class that's better.
+    # Initialize it with the 4 elements, and get utility functions (width, height, etc)
+    # for free.
+    #
+    # By convention the first two elements are x1, y1, the co-ords for the bottom left corner
+    # of the rectangle. The third and fourth elements are x2, y2, the co-ords for the top left
+    # corner of the rectangle. It's valid for the alternative corners to be used though, so
+    # we don't assume which is which.
+    #
+    class Rectangle
+
+      attr_reader :bottom_left, :bottom_right, :top_left, :top_right
+
+      def initialize(x1, y1, x2, y2)
+        set_corners(x1, y1, x2, y2)
+      end
+
+      def self.from_array(arr)
+        if arr.size != 4
+          raise ArgumentError, "Only 4-element Arrays can be converted to a Rectangle"
+        end
+
+        PDF::Reader::Rectangle.new(
+          arr[0].to_f,
+          arr[1].to_f,
+          arr[2].to_f,
+          arr[3].to_f,
+        )
+      end
+
+      def ==(other)
+        to_a == other.to_a
+      end
+
+      def height
+        top_right.y - bottom_right.y
+      end
+
+      def width
+        bottom_right.x - bottom_left.x
+      end
+
+      def contains?(point)
+        point.x >= bottom_left.x && point.x <= top_right.x &&
+          point.y >= bottom_left.y && point.y <= top_right.y
+      end
+
+      # A pdf-style 4-number array
+      def to_a
+        [
+          bottom_left.x,
+          bottom_left.y,
+          top_right.x,
+          top_right.y,
+        ]
+      end
+
+      def apply_rotation(degrees)
+        return if degrees != 90 && degrees != 180 && degrees != 270
+
+        if degrees == 90
+          new_x1 = bottom_left.x
+          new_y1 = bottom_left.y - width
+          new_x2 = bottom_left.x + height
+          new_y2 = bottom_left.y
+        elsif degrees == 180
+          new_x1 = bottom_left.x - width
+          new_y1 = bottom_left.y - height
+          new_x2 = bottom_left.x
+          new_y2 = bottom_left.y
+        elsif degrees == 270
+          new_x1 = bottom_left.x - height
+          new_y1 = bottom_left.y
+          new_x2 = bottom_left.x
+          new_y2 = bottom_left.y + width
+        end
+        set_corners(new_x1, new_y1, new_x2, new_y2)
+      end
+
+      private
+
+      def set_corners(x1, y1, x2, y2)
+        @bottom_left = PDF::Reader::Point.new(
+          [x1, x2].min,
+          [y1, y2].min,
+        )
+        @bottom_right = PDF::Reader::Point.new(
+          [x1, x2].max,
+          [y1, y2].min,
+        )
+        @top_left = PDF::Reader::Point.new(
+          [x1, x2].min,
+          [y1, y2].max,
+        )
+        @top_right = PDF::Reader::Point.new(
+          [x1, x2].max,
+          [y1, y2].max,
+        )
+      end
+    end
+  end
+end

data/lib/pdf/reader/reference.rb

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

data/lib/pdf/reader/register_receiver.rb

@@ -1,4 +1,5 @@
 # coding: utf-8
+# typed: strict
 # frozen_string_literal: true
 
 # Copyright (C) 2010 James Healy (jimmy@deefa.com)

data/lib/pdf/reader/resource_methods.rb

@@ -1,12 +1,17 @@
 # coding: utf-8
+# typed: false
 # frozen_string_literal: true
 
+# Setting this file to "typed: true" is difficult because it's a mixin that assumes some things
+# are aavailable from the class, like @objects and resources. Sorbet doesn't know about them.
+
 module PDF
   class Reader
 
     # mixin for common methods in Page and FormXobjects
     #
     module ResourceMethods
+
       # Returns a Hash of color spaces that are available to this page
       #
       # NOTE: this method de-serialise objects from the underlying PDF

data/lib/pdf/reader/standard_security_handler.rb

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

data/lib/pdf/reader/standard_security_handler_v5.rb

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

data/lib/pdf/reader/stream.rb

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

data/lib/pdf/reader/synchronized_cache.rb

@@ -1,4 +1,5 @@
 # encoding: utf-8
+# typed: true
 # frozen_string_literal: true
 
 # utilities.rb : General-purpose utility classes which don't fit anywhere else

data/lib/pdf/reader/text_run.rb

@@ -1,4 +1,5 @@
 # coding: utf-8
+# typed: true
 # frozen_string_literal: true
 
 class PDF::Reader
@@ -6,15 +7,14 @@ class PDF::Reader
   class TextRun
     include Comparable
 
-    attr_reader :x, :y, :width, :font_size, :text
+    attr_reader :origin, :width, :font_size, :text
 
     alias :to_s :text
 
     def initialize(x, y, width, font_size, text)
-      @x = x
-      @y = y
+      @origin = PDF::Reader::Point.new(x, y)
       @width = width
-      @font_size = font_size.floor
+      @font_size = font_size
       @text = text
     end
 
@@ -34,12 +34,20 @@ class PDF::Reader
       end
     end
 
+    def x
+      @origin.x
+    end
+
+    def y
+      @origin.y
+    end
+
     def endx
-      @endx ||= x + width
+      @endx ||= @origin.x + width
     end
 
     def endy
-      @endy ||= y + font_size
+      @endy ||= @origin.y + font_size
     end
 
     def mean_character_width

data/lib/pdf/reader/token.rb

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

data/lib/pdf/reader/transformation_matrix.rb

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

data/lib/pdf/reader/unimplemented_security_handler.rb

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

data/lib/pdf/reader/width_calculator/built_in.rb

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

data/lib/pdf/reader/width_calculator/composite.rb

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

data/lib/pdf/reader/width_calculator/true_type.rb

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

data/lib/pdf/reader/width_calculator/type_one_or_three.rb

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

data/lib/pdf/reader/width_calculator/type_zero.rb

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

data/lib/pdf/reader/width_calculator.rb

@@ -1,4 +1,5 @@
 # coding: utf-8
+# typed: strict
 # frozen_string_literal: true
 
 # PDF files may define fonts in a number of ways. Each approach means we must

data/lib/pdf/reader/xref.rb

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

data/lib/pdf/reader/zero_width_runs_filter.rb

@@ -1,4 +1,6 @@
 # coding: utf-8
+# typed: strict
+# frozen_string_literal: true
 
 class PDF::Reader
   # There's no point rendering zero-width characters