pdf-reader 2.2.0 → 2.11.0

data/lib/pdf/reader/synchronized_cache.rb

@@ -1,4 +1,5 @@
 # encoding: utf-8
+# typed: strict
 # 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: strict
 # frozen_string_literal: true
 
 class PDF::Reader
@@ -6,15 +7,17 @@ class PDF::Reader
   class TextRun
     include Comparable
 
-    attr_reader :x, :y, :width, :font_size, :text
+    attr_reader :origin
+    attr_reader :width
+    attr_reader :font_size
+    attr_reader :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,8 +37,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 ||= @origin.y + font_size
     end
 
     def mean_character_width
@@ -60,8 +75,28 @@ class PDF::Reader
       "#{text} w:#{width} f:#{font_size} @#{x},#{y}"
     end
 
+    def intersect?(other_run)
+      x <= other_run.endx && endx >= other_run.x &&
+        endy >= other_run.y && y <= other_run.endy
+    end
+
+    # return what percentage of this text run is overlapped by another run
+    def intersection_area_percent(other_run)
+      return 0 unless intersect?(other_run)
+
+      dx = [endx, other_run.endx].min - [x, other_run.x].max
+      dy = [endy, other_run.endy].min - [y, other_run.y].max
+      intersection_area = dx*dy
+
+      intersection_area.to_f / area
+    end
+
     private
 
+    def area
+      (endx - x) * (endy - y)
+    end
+
     def mergable_range
       @mergable_range ||= Range.new(endx - 3, endx + font_size)
     end

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: strict
 # frozen_string_literal: true
 
 class PDF::Reader
@@ -50,7 +51,7 @@ class PDF::Reader
     #       displacement to speed up processing documents that use vertical
     #       writing systems
     #
-    def multiply!(a,b=nil,c=nil, d=nil,e=nil,f=nil)
+    def multiply!(a,b,c, d,e,f)
       if a == 1 && b == 0 && c == 0 && d == 1 && e == 0 && f == 0
         # the identity matrix, no effect
         self
@@ -163,12 +164,12 @@ class PDF::Reader
     #   [ e f 1 ]   [ e f 1 ]
     #
     def regular_multiply!(a2,b2,c2,d2,e2,f2)
-      newa = (@a * a2) + (@b * c2) + (0 * e2)
-      newb = (@a * b2) + (@b * d2) + (0 * f2)
-      newc = (@c * a2) + (@d * c2) + (0 * e2)
-      newd = (@c * b2) + (@d * d2) + (0 * f2)
-      newe = (@e * a2) + (@f * c2) + (1 * e2)
-      newf = (@e * b2) + (@f * d2) + (1 * f2)
+      newa = (@a * a2) + (@b * c2) + (e2 * 0)
+      newb = (@a * b2) + (@b * d2) + (f2 * 0)
+      newc = (@c * a2) + (@d * c2) + (e2 * 0)
+      newd = (@c * b2) + (@d * d2) + (f2 * 0)
+      newe = (@e * a2) + (@f * c2) + (e2 * 1)
+      newf = (@e * b2) + (@f * d2) + (f2 * 1)
       @a, @b, @c, @d, @e, @f = newa, newb, newc, newd, newe, newf
     end
 

data/lib/pdf/reader/type_check.rb

@@ -0,0 +1,98 @@
+# coding: utf-8
+# typed: strict
+# frozen_string_literal: true
+
+module PDF
+  class Reader
+
+    # Cast untrusted input (usually parsed out of a PDF file) to a known type
+    #
+    class TypeCheck
+
+      def self.cast_to_int!(obj)
+        if obj.is_a?(Integer)
+          obj
+        elsif obj.nil?
+          0
+        elsif obj.respond_to?(:to_i)
+          obj.to_i
+        else
+          raise MalformedPDFError, "Unable to cast to integer"
+        end
+      end
+
+      def self.cast_to_numeric!(obj)
+        if obj.is_a?(Numeric)
+          obj
+        elsif obj.nil?
+          0
+        elsif obj.respond_to?(:to_f)
+          obj.to_f
+        elsif obj.respond_to?(:to_i)
+          obj.to_i
+        else
+          raise MalformedPDFError, "Unable to cast to numeric"
+        end
+      end
+
+      def self.cast_to_string!(string)
+        if string.is_a?(String)
+          string
+        elsif string.nil?
+          ""
+        elsif string.respond_to?(:to_s)
+          string.to_s
+        else
+          raise MalformedPDFError, "Unable to cast to string"
+        end
+      end
+
+      def self.cast_to_symbol(obj)
+        if obj.is_a?(Symbol)
+          obj
+        elsif obj.nil?
+          nil
+        elsif obj.respond_to?(:to_sym)
+          obj.to_sym
+        else
+          raise MalformedPDFError, "Unable to cast to symbol"
+        end
+      end
+
+      def self.cast_to_symbol!(obj)
+        res = cast_to_symbol(obj)
+        if res
+          res
+        else
+          raise MalformedPDFError, "Unable to cast to symbol"
+        end
+      end
+
+      def self.cast_to_pdf_dict!(obj)
+        if obj.is_a?(Hash)
+          obj
+        elsif obj.respond_to?(:to_h)
+          obj.to_h
+        else
+          raise MalformedPDFError, "Unable to cast to hash"
+        end
+      end
+
+      def self.cast_to_pdf_dict_with_stream_values!(obj)
+        if obj.is_a?(Hash)
+          result = Hash.new
+          obj.each do |k, v|
+            raise MalformedPDFError, "Expected a stream" unless v.is_a?(PDF::Reader::Stream)
+            result[cast_to_symbol!(k)] = v
+          end
+          result
+        elsif obj.respond_to?(:to_h)
+          cast_to_pdf_dict_with_stream_values!(obj.to_h)
+        else
+          raise MalformedPDFError, "Unable to cast to hash"
+        end
+      end
+    end
+  end
+end
+

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/validating_receiver.rb

@@ -0,0 +1,262 @@
+# coding: utf-8
+# typed: strict
+# frozen_string_literal: true
+
+module PDF
+  class Reader
+
+    # Page#walk will execute the content stream of a page, calling methods on a receiver class
+    # provided by the user. Each operator has a specific set of parameters it expects, and we
+    # wrap the users receiver class in this one to verify the PDF uses valid parameters.
+    #
+    # Without these checks, users can't be confident about the number of parameters they'll receive
+    # for an operator, or what the type of those parameters will be. Everyone ends up building their
+    # own type safety guard clauses and it's tedious.
+    #
+    # Not all operators have type safety implemented yet, but we can expand the number over time.
+    class ValidatingReceiver
+
+      def initialize(wrapped)
+        @wrapped = wrapped
+      end
+
+      def page=(page)
+        call_wrapped(:page=, page)
+      end
+
+      #####################################################
+      # Graphics State Operators
+      #####################################################
+      def save_graphics_state(*args)
+        call_wrapped(:save_graphics_state)
+      end
+
+      def restore_graphics_state(*args)
+        call_wrapped(:restore_graphics_state)
+      end
+
+      #####################################################
+      # Matrix Operators
+      #####################################################
+
+      def concatenate_matrix(*args)
+        a, b, c, d, e, f = *args
+        call_wrapped(
+          :concatenate_matrix,
+          TypeCheck.cast_to_numeric!(a),
+          TypeCheck.cast_to_numeric!(b),
+          TypeCheck.cast_to_numeric!(c),
+          TypeCheck.cast_to_numeric!(d),
+          TypeCheck.cast_to_numeric!(e),
+          TypeCheck.cast_to_numeric!(f),
+        )
+      end
+
+      #####################################################
+      # Text Object Operators
+      #####################################################
+
+      def begin_text_object(*args)
+        call_wrapped(:begin_text_object)
+      end
+
+      def end_text_object(*args)
+        call_wrapped(:end_text_object)
+      end
+
+      #####################################################
+      # Text State Operators
+      #####################################################
+      def set_character_spacing(*args)
+        char_spacing, _ = *args
+        call_wrapped(
+          :set_character_spacing,
+          TypeCheck.cast_to_numeric!(char_spacing)
+        )
+      end
+
+      def set_horizontal_text_scaling(*args)
+        h_scaling, _ = *args
+        call_wrapped(
+          :set_horizontal_text_scaling,
+          TypeCheck.cast_to_numeric!(h_scaling)
+        )
+      end
+
+      def set_text_font_and_size(*args)
+        label, size, _ = *args
+        call_wrapped(
+          :set_text_font_and_size,
+          TypeCheck.cast_to_symbol(label),
+          TypeCheck.cast_to_numeric!(size)
+        )
+      end
+
+      def set_text_leading(*args)
+        leading, _ = *args
+        call_wrapped(
+          :set_text_leading,
+          TypeCheck.cast_to_numeric!(leading)
+        )
+      end
+
+      def set_text_rendering_mode(*args)
+        mode, _ = *args
+        call_wrapped(
+          :set_text_rendering_mode,
+          TypeCheck.cast_to_numeric!(mode)
+        )
+      end
+
+      def set_text_rise(*args)
+        rise, _ = *args
+        call_wrapped(
+          :set_text_rise,
+          TypeCheck.cast_to_numeric!(rise)
+        )
+      end
+
+      def set_word_spacing(*args)
+        word_spacing, _ = *args
+        call_wrapped(
+          :set_word_spacing,
+          TypeCheck.cast_to_numeric!(word_spacing)
+        )
+      end
+
+      #####################################################
+      # Text Positioning Operators
+      #####################################################
+
+      def move_text_position(*args) # Td
+        x, y, _ = *args
+        call_wrapped(
+          :move_text_position,
+          TypeCheck.cast_to_numeric!(x),
+          TypeCheck.cast_to_numeric!(y)
+        )
+      end
+
+      def move_text_position_and_set_leading(*args) # TD
+        x, y, _ = *args
+        call_wrapped(
+          :move_text_position_and_set_leading,
+          TypeCheck.cast_to_numeric!(x),
+          TypeCheck.cast_to_numeric!(y)
+        )
+      end
+
+      def set_text_matrix_and_text_line_matrix(*args) # Tm
+        a, b, c, d, e, f = *args
+        call_wrapped(
+          :set_text_matrix_and_text_line_matrix,
+          TypeCheck.cast_to_numeric!(a),
+          TypeCheck.cast_to_numeric!(b),
+          TypeCheck.cast_to_numeric!(c),
+          TypeCheck.cast_to_numeric!(d),
+          TypeCheck.cast_to_numeric!(e),
+          TypeCheck.cast_to_numeric!(f),
+        )
+      end
+
+      def move_to_start_of_next_line(*args) # T*
+        call_wrapped(:move_to_start_of_next_line)
+      end
+
+      #####################################################
+      # Text Showing Operators
+      #####################################################
+      def show_text(*args) # Tj (AWAY)
+        string, _ = *args
+        call_wrapped(
+          :show_text,
+          TypeCheck.cast_to_string!(string)
+        )
+      end
+
+      def show_text_with_positioning(*args) # TJ [(A) 120 (WA) 20 (Y)]
+        params, _ = *args
+        unless params.is_a?(Array)
+          raise MalformedPDFError, "TJ operator expects a single Array argument"
+        end
+
+        call_wrapped(
+          :show_text_with_positioning,
+          params
+        )
+      end
+
+      def move_to_next_line_and_show_text(*args) # '
+        string, _ = *args
+        call_wrapped(
+          :move_to_next_line_and_show_text,
+          TypeCheck.cast_to_string!(string)
+        )
+      end
+
+      def set_spacing_next_line_show_text(*args) # "
+        aw, ac, string = *args
+        call_wrapped(
+          :set_spacing_next_line_show_text,
+          TypeCheck.cast_to_numeric!(aw),
+          TypeCheck.cast_to_numeric!(ac),
+          TypeCheck.cast_to_string!(string)
+        )
+      end
+
+      #####################################################
+      # Form XObject Operators
+      #####################################################
+
+      def invoke_xobject(*args)
+        label, _ = *args
+
+        call_wrapped(
+          :invoke_xobject,
+          TypeCheck.cast_to_symbol(label)
+        )
+      end
+
+      #####################################################
+      # Inline Image Operators
+      #####################################################
+
+      def begin_inline_image(*args)
+        call_wrapped(:begin_inline_image)
+      end
+
+      def begin_inline_image_data(*args)
+        # We can't use call_wrapped() here because sorbet won't allow splat args with a dynamic
+        # number of elements
+        @wrapped.begin_inline_image_data(*args) if @wrapped.respond_to?(:begin_inline_image_data)
+      end
+
+      def end_inline_image(*args)
+        data, _ = *args
+
+        call_wrapped(
+          :end_inline_image,
+          TypeCheck.cast_to_string!(data)
+        )
+      end
+
+      #####################################################
+      # Final safety net for any operators that don't have type checking enabled yet
+      #####################################################
+
+      def respond_to?(meth)
+        @wrapped.respond_to?(meth)
+      end
+
+      def method_missing(methodname, *args)
+        @wrapped.send(methodname, *args)
+      end
+
+      private
+
+      def call_wrapped(methodname, *args)
+        @wrapped.send(methodname, *args) if @wrapped.respond_to?(methodname)
+      end
+    end
+  end
+end

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

@@ -1,4 +1,5 @@
 # coding: utf-8
+# typed: strict
 # frozen_string_literal: true
 
 require 'afm'
@@ -12,11 +13,20 @@ class PDF::Reader
     # see Section 9.6.2.2, PDF 32000-1:2008, pp 256
     class BuiltIn
 
+      BUILTINS = [
+        :Courier, :"Courier-Bold", :"Courier-BoldOblique", :"Courier-Oblique",
+        :Helvetica, :"Helvetica-Bold", :"Helvetica-BoldOblique", :"Helvetica-Oblique",
+        :Symbol,
+        :"Times-Roman", :"Times-Bold", :"Times-BoldItalic", :"Times-Italic",
+        :ZapfDingbats
+      ]
+
       def initialize(font)
         @font = font
         @@all_metrics ||= PDF::Reader::SynchronizedCache.new
 
-        metrics_path = File.join(File.dirname(__FILE__), "..","afm","#{font.basefont}.afm")
+        basefont = extract_basefont(font.basefont)
+        metrics_path = File.join(File.dirname(__FILE__), "..","afm","#{basefont}.afm")
 
         if File.file?(metrics_path)
           @metrics = @@all_metrics[metrics_path] ||= AFM::Font.new(metrics_path)
@@ -28,32 +38,32 @@ class PDF::Reader
       def glyph_width(code_point)
         return 0 if code_point.nil? || code_point < 0
 
-        m = @metrics.char_metrics_by_code[code_point]
-        if m.nil?
-          names = @font.encoding.int_to_name(code_point)
-
-          m = names.map { |name|
-            @metrics.char_metrics[name.to_s]
-          }.compact.first
-        end
+        names = @font.encoding.int_to_name(code_point)
+        metrics = names.map { |name|
+          @metrics.char_metrics[name.to_s]
+        }.compact.first
 
-        if m
-          m[:wx]
-        elsif @font.widths[code_point - 1]
-          @font.widths[code_point - 1]
-        elsif control_character?(code_point)
-          0
+        if metrics
+          metrics[:wx]
         else
-          0
+          @font.widths[code_point - 1] || 0
         end
       end
 
       private
 
       def control_character?(code_point)
-        @font.encoding.int_to_name(code_point).first.to_s[/\Acontrol..\Z/]
+        match = @font.encoding.int_to_name(code_point).first.to_s[/\Acontrol..\Z/]
+        match ? true : false
       end
 
+      def extract_basefont(font_name)
+        if BUILTINS.include?(font_name)
+          font_name.to_s
+        else
+          "Times-Roman"
+        end
+      end
     end
   end
 end

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

@@ -1,4 +1,5 @@
 # coding: utf-8
+# typed: strict
 # frozen_string_literal: true
 
 class PDF::Reader
@@ -21,7 +22,11 @@ class PDF::Reader
 
         w = @widths[code_point]
         # 0 is a valid width
-        return w.to_f unless w.nil?
+        if w
+          w.to_f
+        else
+          0
+        end
       end
     end
   end

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

@@ -1,4 +1,5 @@
 # coding: utf-8
+# typed: strict
 # frozen_string_literal: true
 
 class PDF::Reader
@@ -9,8 +10,8 @@ class PDF::Reader
       def initialize(font)
         @font = font
 
-        if @font.font_descriptor
-          @missing_width = @font.font_descriptor.missing_width
+        if fd = @font.font_descriptor
+          @missing_width = fd.missing_width
         else
           @missing_width = 0
         end
@@ -29,25 +30,23 @@ class PDF::Reader
 
         # in ruby a negative index is valid, and will go from the end of the array
         # which is undesireable in this case.
-        if @font.first_char <= code_point
-          @font.widths.fetch(code_point - @font.first_char, @missing_width).to_f
+        first_char = @font.first_char
+        if first_char && first_char <= code_point
+          @font.widths.fetch(code_point - first_char, @missing_width.to_i).to_f
         else
           @missing_width.to_f
         end
       end
 
       def glyph_width_from_descriptor(code_point)
-        return unless @font.font_descriptor
-
         # true type fonts will have most of their information contained
         # with-in a program inside the font descriptor, however the widths
         # may not be in standard PDF glyph widths (1000 units => 1 text space unit)
         # so this width will need to be scaled
-        w = @font.font_descriptor.glyph_width(code_point)
-        if w
-          w.to_f * @font.font_descriptor.glyph_to_pdf_scale_factor
-        else
-          nil
+        if fd = @font.font_descriptor
+          if w = fd.glyph_width(code_point)
+            w.to_f * fd.glyph_to_pdf_scale_factor.to_f
+          end
         end
       end
     end

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

@@ -1,4 +1,5 @@
 # coding: utf-8
+# typed: strict
 # frozen_string_literal: true
 
 class PDF::Reader
@@ -9,8 +10,8 @@ class PDF::Reader
       def initialize(font)
         @font = font
 
-        if @font.font_descriptor
-          @missing_width = @font.font_descriptor.missing_width
+        if fd = @font.font_descriptor
+          @missing_width = fd.missing_width
         else
           @missing_width = 0
         end
@@ -22,8 +23,9 @@ class PDF::Reader
 
         # in ruby a negative index is valid, and will go from the end of the array
         # which is undesireable in this case.
-        if @font.first_char <= code_point
-          @font.widths.fetch(code_point - @font.first_char, @missing_width).to_f
+        first_char = @font.first_char
+        if first_char && first_char <= code_point
+          @font.widths.fetch(code_point - first_char, @missing_width.to_i).to_f
         else
           @missing_width.to_f
         end

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

@@ -1,4 +1,5 @@
 # coding: utf-8
+# typed: strict
 # frozen_string_literal: true
 
 class PDF::Reader
@@ -12,13 +13,16 @@ class PDF::Reader
 
       def initialize(font)
         @font = font
-        @descendant_font = @font.descendantfonts.first
       end
 
       def glyph_width(code_point)
         return 0 if code_point.nil? || code_point < 0
 
-        @descendant_font.glyph_width(code_point).to_f
+        if descendant_font = @font.descendantfonts.first
+          descendant_font.glyph_width(code_point).to_f
+        else
+          0
+        end
       end
     end
   end

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