pdf-reader 2.2.0 → 2.11.0

data/lib/pdf/reader/page.rb

@@ -1,4 +1,5 @@
 # coding: utf-8
+# typed: strict
 # frozen_string_literal: true
 
 module PDF
@@ -13,7 +14,7 @@ module PDF
     # objects accessor to help walk the page dictionary in any useful way.
     #
     class Page
-      include ResourceMethods
+      extend Forwardable
 
       # lowlevel hash-like access to all objects in the underlying PDF
       attr_reader :objects
@@ -26,6 +27,15 @@ module PDF
       # operations
       attr_reader :cache
 
+      def_delegators :resources, :color_spaces
+      def_delegators :resources, :fonts
+      def_delegators :resources, :graphic_states
+      def_delegators :resources, :patterns
+      def_delegators :resources, :procedure_sets
+      def_delegators :resources, :properties
+      def_delegators :resources, :shadings
+      def_delegators :resources, :xobjects
+
       # creates a new page wrapper.
       #
       # * objects - an ObjectHash instance that wraps a PDF file
@@ -33,10 +43,10 @@ module PDF
       #
       def initialize(objects, pagenum, options = {})
         @objects, @pagenum = objects, pagenum
-        @page_object = objects.deref(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
@@ -59,7 +69,7 @@ module PDF
       def attributes
         @attributes ||= {}.tap { |hash|
           page_with_ancestors.reverse.each do |obj|
-            hash.merge!(@objects.deref(obj))
+            hash.merge!(@objects.deref_hash(obj) || {})
           end
         }
         # This shouldn't be necesary, but some non compliant PDFs leave MediaBox
@@ -68,22 +78,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.
       #
@@ -108,6 +152,9 @@ module PDF
       # the program in the correct order and calls out to your implementation.
       #
       def walk(*receivers)
+        receivers = receivers.map { |receiver|
+          ValidatingReceiver.new(receiver)
+        }
         callback(receivers, :page=, [self])
         content_stream(receivers, raw_content)
       end
@@ -116,25 +163,85 @@ module PDF
       # see here unless you're a PDF nerd like me.
       #
       def raw_content
-        contents = objects.deref(@page_object[:Contents])
+        contents = objects.deref_stream_or_array(@page_object[:Contents])
         [contents].flatten.compact.map { |obj|
-          objects.deref(obj)
-        }.map { |obj|
+          objects.deref_stream(obj)
+        }.compact.map { |obj|
           obj.unfiltered_data
         }.join(" ")
       end
 
+      # returns the angle to rotate the page clockwise. Always 0, 90, 180 or 270
+      #
+      def rotate
+        value = attributes[:Rotate].to_i
+        case value
+        when 0, 90, 180, 270
+          value
+        else
+          0
+        end
+      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
+      #
+      # DEPRECATED. Recommend using Page#rectangles instead
+      #
+      def boxes
+        # 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
+        # attributes[:MediaBox] can never be nil, but I have no easy way to tell sorbet that atm
+        mediabox = objects.deref_array_of_numbers(attributes[:MediaBox]) || []
+        cropbox = objects.deref_array_of_numbers(attributes[:CropBox]) || mediabox
+        bleedbox = objects.deref_array_of_numbers(attributes[:BleedBox]) || cropbox
+        trimbox = objects.deref_array_of_numbers(attributes[:TrimBox]) || cropbox
+        artbox = objects.deref_array_of_numbers(attributes[:ArtBox]) || cropbox
+
+        begin
+          mediarect = Rectangle.from_array(mediabox)
+          croprect = Rectangle.from_array(cropbox)
+          bleedrect = Rectangle.from_array(bleedbox)
+          trimrect = Rectangle.from_array(trimbox)
+          artrect = Rectangle.from_array(artbox)
+        rescue ArgumentError => e
+          raise MalformedPDFError, e.message
+        end
+
+        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: mediarect,
+          CropBox: croprect,
+          BleedBox: bleedrect,
+          TrimBox: trimrect,
+          ArtBox: artrect,
+        }
+      end
+
       private
 
       def root
-        root ||= objects.deref(@objects.trailer[:Root])
+        @root ||= objects.deref_hash(@objects.trailer[:Root]) || {}
       end
 
       # Returns the resources that accompany this page. Includes
       # resources inherited from parents.
       #
       def resources
-        @resources ||= @objects.deref(attributes[:Resources]) || {}
+        @resources ||= Resources.new(@objects, @objects.deref_hash(attributes[:Resources]) || {})
       end
 
       def content_stream(receivers, instructions)
@@ -143,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
@@ -156,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
 
@@ -170,7 +294,10 @@ module PDF
         if origin.nil?
           []
         else
-          obj = objects.deref(origin)
+          obj = objects.deref_hash(origin)
+          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,6 +1,10 @@
 # coding: utf-8
+# typed: strict
 # frozen_string_literal: true
 
+require 'pdf/reader/overlapping_runs_filter'
+require 'pdf/reader/zero_width_runs_filter'
+
 class PDF::Reader
 
   # Takes a collection of TextRun objects and renders them into a single
@@ -13,24 +17,28 @@ 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    = 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
-      @mean_glyph_width = mean(@runs.map(&:mean_character_width)) || 0
-      @page_width  = mediabox[2] - mediabox[0]
-      @page_height = mediabox[3] - mediabox[1]
-      @x_offset = @runs.map(&:x).sort.first
+      @median_glyph_width = median(@runs.map(&:mean_character_width)) || 0
+      @x_offset = @runs.map(&:x).sort.first || 0
+      lowest_y = @runs.map(&:y).sort.first || 0
+      @y_offset = lowest_y > 0 ? 0 : lowest_y
     end
 
     def to_s
       return "" if @runs.empty?
+      return "" if row_count == 0
 
       page = row_count.times.map { |i| " " * col_count }
       @runs.each do |run|
         x_pos = ((run.x - @x_offset) / col_multiplier).round
-        y_pos = row_count - (run.y / row_multiplier).round
+        y_pos = row_count - ((run.y - @y_offset) / row_multiplier).round
         if y_pos <= row_count && y_pos >= 0 && x_pos <= col_count && x_pos >= 0
           local_string_insert(page[y_pos-1], run.text, x_pos)
         end
@@ -40,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.
     #
@@ -58,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  / @mean_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)
@@ -81,40 +97,28 @@ class PDF::Reader
       end
     end
 
-    def each_line(&block)
-      @runs.sort.group_by { |run|
-        run.y.to_i
-      }.map { |y, collection|
-        yield y, collection
-      }
+    def median(collection)
+      if collection.size == 0
+        0
+      else
+        collection.sort[(collection.size * 0.5).floor]
+      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'
@@ -15,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
@@ -30,7 +31,13 @@ class PDF::Reader
         @xobject_stack = [page.xobjects]
         @cs_stack      = [page.color_spaces]
         @stack         = [DEFAULT_GRAPHICS_STATE.dup]
-        state[:ctm]    = identity_matrix
+        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
 
       #####################################################
@@ -312,7 +319,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]
@@ -322,22 +329,24 @@ class PDF::Reader
         th = state[:h_scaling]
         # optimise the common path to reduce Float allocations
         if th == 1 && tj == 0 && tc == 0 && tw == 0
-          glyph_width = w0 * fs
-          tx = glyph_width
+          tx = w0 * fs
+        elsif tj != 0
+          # don't apply spacing to TJ displacement
+          tx = (w0 - (tj/1000.0)) * fs * th
         else
-          glyph_width = ((w0 - (tj/1000.0)) * fs) * th
-          tx = glyph_width + ((tc + tw) * th)
+          # 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
 
@@ -381,7 +390,7 @@ class PDF::Reader
       #
       def build_fonts(raw_fonts)
         wrapped_fonts = raw_fonts.map { |label, font|
-          [label, PDF::Reader::Font.new(@objects, @objects.deref(font))]
+          [label, PDF::Reader::Font.new(@objects, @objects.deref_hash(font) || {})]
         }
 
         ::Hash[wrapped_fonts]

data/lib/pdf/reader/page_text_receiver.rb

@@ -1,4 +1,5 @@
 # coding: utf-8
+# typed: true
 # frozen_string_literal: true
 
 require 'forwardable'
@@ -41,13 +42,39 @@ module PDF
       # starting a new page
       def page=(page)
         @state = PageState.new(page)
+        @page = page
         @content = []
         @characters = []
-        @mediabox = page.objects.deref(page.attributes[:MediaBox])
       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
+
+        runs = NoTextFilter.exclude_empty_strings(runs)
+
+        if opts.fetch(:merge, true)
+          runs = merge_runs(runs)
+        end
+
+        runs
+      end
+
+      # deprecated
       def content
-        PageLayout.new(@characters, @mediabox).to_s
+        mediabox = @page.rectangles[:MediaBox]
+        PageLayout.new(runs, mediabox).to_s
       end
 
       #####################################################
@@ -62,8 +89,10 @@ module PDF
         params.each do |arg|
           if arg.is_a?(String)
             internal_show_text(arg)
-          else
+          elsif arg.is_a?(Numeric)
             @state.process_glyph_displacement(0, arg, false)
+          else
+            # skip it
           end
         end
       end
@@ -94,6 +123,7 @@ module PDF
       private
 
       def internal_show_text(string)
+        PDF::Reader::Error.validate_type_as_malformed(string, "string", String)
         if @state.current_font.nil?
           raise PDF::Reader::MalformedPDFError, "current font is invalid"
         end
@@ -101,11 +131,13 @@ module PDF
         glyphs.each_with_index do |glyph_code, index|
           # paint the current glyph
           newx, newy = @state.trm_transform(0,0)
+          newx, newy = apply_rotation(newx, newy)
+
           utf8_chars = @state.current_font.to_utf8(glyph_code)
 
           # 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
@@ -115,6 +147,44 @@ module PDF
         end
       end
 
+      def apply_rotation(x, y)
+        if @page.rotate == 90
+          tmp = x
+          x = y
+          y = tmp * -1
+        elsif @page.rotate == 180
+          y *= -1
+          x *= -1
+        elsif @page.rotate == 270
+          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: strict
 # frozen_string_literal: true
 
 ################################################################################