pdf-reader 2.6.0 → 2.9.1

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
 
@@ -383,7 +384,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'
@@ -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
 
       #####################################################
@@ -66,8 +87,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
@@ -98,6 +121,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
@@ -111,7 +135,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 +152,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
 
 ################################################################################
@@ -79,8 +80,8 @@ class PDF::Reader
         token
       elsif operators.has_key? token
         Token.new(token)
-      elsif token.respond_to?(:to_token)
-        token.to_token
+      elsif token.frozen?
+        token
       elsif token =~ /\d*\.\d/
         token.to_f
       else
@@ -95,14 +96,20 @@ class PDF::Reader
     # id  - the object ID to return
     # gen - the object revision number to return
     def object(id, gen)
-      Error.assert_equal(parse_token, id)
+      idCheck = parse_token
+
+      # Sometimes the xref table is corrupt and points to an offset slightly too early in the file.
+      # check the next token, maybe we can find the start of the object we're looking for
+      if idCheck != id
+        Error.assert_equal(parse_token, id)
+      end
       Error.assert_equal(parse_token, gen)
       Error.str_assert(parse_token, "obj")
 
       obj = parse_token
       post_obj = parse_token
 
-      if post_obj == "stream"
+      if obj.is_a?(Hash) && post_obj == "stream"
         stream(obj)
       else
         obj
@@ -120,7 +127,7 @@ class PDF::Reader
         key = parse_token
         break if key.kind_of?(Token) and key == ">>"
         raise MalformedPDFError, "unterminated dict" if @buffer.empty?
-        raise MalformedPDFError, "Dictionary key (#{key.inspect}) is not a name" unless key.kind_of?(Symbol)
+        PDF::Reader::Error.validate_type_as_malformed(key, "Dictionary key", Symbol)
 
         value = parse_token
         value.kind_of?(Token) and Error.str_assert_not(value, ">>")
@@ -166,7 +173,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
@@ -206,14 +215,23 @@ class PDF::Reader
     def stream(dict)
       raise MalformedPDFError, "PDF malformed, missing stream length" unless dict.has_key?(:Length)
       if @objects
-        length = @objects.deref(dict[:Length])
+        length = @objects.deref_integer(dict[:Length])
+        if dict[:Filter]
+          dict[:Filter] = @objects.deref_name_or_array(dict[:Filter])
+        end
       else
         length = dict[:Length] || 0
       end
+
+      PDF::Reader::Error.validate_type_as_malformed(length, "length", Numeric)
+
       data = @buffer.read(length, :skip_eol => true)
 
       Error.str_assert(parse_token, "endstream")
-      Error.str_assert(parse_token, "endobj")
+
+      # We used to assert that the stream had the correct closing token, but it doesn't *really*
+      # matter if it's missing, and other readers seems to handle its absence just fine
+      # Error.str_assert(parse_token, "endobj")
 
       PDF::Reader::Stream.new(dict, data)
     end

data/lib/pdf/reader/point.rb

@@ -0,0 +1,25 @@
+# coding: utf-8
+# typed: strict
+# 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/rc4_security_handler.rb

@@ -0,0 +1,38 @@
+# coding: utf-8
+# typed: strict
+# frozen_string_literal: true
+
+require 'digest/md5'
+require 'rc4'
+
+class PDF::Reader
+
+  # Decrypts data using the RC4 algorithim defined in the PDF spec. Requires
+  # a decryption key, which is usually generated by PDF::Reader::StandardKeyBuilder
+  #
+  class Rc4SecurityHandler
+
+    def initialize(key)
+      @encrypt_key = key
+    end
+
+    ##7.6.2 General Encryption Algorithm
+    #
+    # Algorithm 1: Encryption of data using the RC4 algorithm
+    #
+    # version <=3 or (version == 4 and CFM == V2)
+    #
+    # buf - a string to decrypt
+    # ref - a PDF::Reader::Reference for the object to decrypt
+    #
+    def decrypt( buf, ref )
+      objKey = @encrypt_key.dup
+      (0..2).each { |e| objKey << (ref.id >> e*8 & 0xFF ) }
+      (0..1).each { |e| objKey << (ref.gen >> e*8 & 0xFF ) }
+      length = objKey.length < 16 ? objKey.length : 16
+      rc4 = RC4.new( Digest::MD5.digest(objKey)[0,length] )
+      rc4.decrypt(buf)
+    end
+
+  end
+end

data/lib/pdf/reader/rectangle.rb

@@ -0,0 +1,113 @@
+# coding: utf-8
+# typed: strict
+# 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 || 0, new_y1 || 0, new_x2 || 0, new_y2 || 0)
+      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 → resources.rb}

@@ -1,4 +1,5 @@
 # coding: utf-8
+# typed: true
 # frozen_string_literal: true
 
 module PDF
@@ -6,7 +7,13 @@ module PDF
 
     # mixin for common methods in Page and FormXobjects
     #
-    module ResourceMethods
+    class Resources
+
+      def initialize(objects, resources)
+        @objects = objects
+        @resources = resources
+      end
+
       # Returns a Hash of color spaces that are available to this page
       #
       # NOTE: this method de-serialise objects from the underlying PDF
@@ -14,7 +21,7 @@ module PDF
       #       of calling it over and over.
       #
       def color_spaces
-        @objects.deref!(resources[:ColorSpace]) || {}
+        @objects.deref_hash!(@resources[:ColorSpace]) || {}
       end
 
       # Returns a Hash of fonts that are available to this page
@@ -24,7 +31,7 @@ module PDF
       #       of calling it over and over.
       #
       def fonts
-        @objects.deref!(resources[:Font]) || {}
+        @objects.deref_hash!(@resources[:Font]) || {}
       end
 
       # Returns a Hash of external graphic states that are available to this
@@ -35,7 +42,7 @@ module PDF
       #       of calling it over and over.
       #
       def graphic_states
-        @objects.deref!(resources[:ExtGState]) || {}
+        @objects.deref_hash!(@resources[:ExtGState]) || {}
       end
 
       # Returns a Hash of patterns that are available to this page
@@ -45,7 +52,7 @@ module PDF
       #       of calling it over and over.
       #
       def patterns
-        @objects.deref!(resources[:Pattern]) || {}
+        @objects.deref_hash!(@resources[:Pattern]) || {}
       end
 
       # Returns an Array of procedure sets that are available to this page
@@ -55,7 +62,7 @@ module PDF
       #       of calling it over and over.
       #
       def procedure_sets
-        @objects.deref!(resources[:ProcSet]) || []
+        @objects.deref_array!(@resources[:ProcSet]) || []
       end
 
       # Returns a Hash of properties sets that are available to this page
@@ -65,7 +72,7 @@ module PDF
       #       of calling it over and over.
       #
       def properties
-        @objects.deref!(resources[:Properties]) || {}
+        @objects.deref_hash!(@resources[:Properties]) || {}
       end
 
       # Returns a Hash of shadings that are available to this page
@@ -75,7 +82,7 @@ module PDF
       #       of calling it over and over.
       #
       def shadings
-        @objects.deref!(resources[:Shading]) || {}
+        @objects.deref_hash!(@resources[:Shading]) || {}
       end
 
       # Returns a Hash of XObjects that are available to this page
@@ -85,7 +92,7 @@ module PDF
       #       of calling it over and over.
       #
       def xobjects
-        @objects.deref!(resources[:XObject]) || {}
+        @objects.deref_hash!(@resources[:XObject]) || {}
       end
 
     end