pdf-reader 2.15.0 → 2.16.0

data/lib/pdf/reader/font.rb

@@ -97,12 +97,21 @@ class PDF::Reader
       extract_descriptor(obj)
       extract_descendants(obj)
       @width_calc = build_width_calculator #: widthCalculator
+      @utf8_cache = {} #: Hash[Integer, String]
     end
 
     #: (Integer | String | Array[Integer | String]) -> String
     def to_utf8(params)
       if @tounicode
-        to_utf8_via_cmap(params, @tounicode)
+        if params.is_a?(Integer)
+          cached = @utf8_cache[params]
+          return cached unless cached.nil?
+          result = to_utf8_via_cmap(params, @tounicode)
+          @utf8_cache[params] = result
+          result
+        else
+          to_utf8_via_cmap(params, @tounicode)
+        end
       else
         to_utf8_via_encoding(params)
       end
@@ -134,9 +143,9 @@ class PDF::Reader
       glyph_width_in_glyph_space = glyph_width(code_point)
 
       if @subtype == :Type3
-        x1, _y1 = font_matrix_transform(0,0)
-        x2, _y2 = font_matrix_transform(glyph_width_in_glyph_space, 0)
-        (x2 - x1).abs.round(2)
+        pt1 = font_matrix_transform(Point::ZERO_ZERO)
+        pt2 = font_matrix_transform(Point.new(glyph_width_in_glyph_space, 0))
+        (pt2.x - pt1.x).abs.round(2)
       else
         glyph_width_in_glyph_space / 1000.0
       end
@@ -145,9 +154,13 @@ class PDF::Reader
     private
 
     # Only valid for Type3 fonts
-    #: (Numeric, Numeric) -> [Numeric, Numeric]
-    def font_matrix_transform(x, y)
-      return x, y if @font_matrix.nil?
+    #
+    # transforming (0,0) is a really common case, so optimise for it to
+    # avoid unnecessary object allocations
+    #
+    #: (PDF::Reader::Point) -> PDF::Reader::Point
+    def font_matrix_transform(pt)
+      return pt if @font_matrix.nil?
 
       matrix = TransformationMatrix.new(
         @font_matrix[0] || 0, @font_matrix[1] || 0,
@@ -155,13 +168,13 @@ class PDF::Reader
         @font_matrix[4] || 0, @font_matrix[5] || 0,
       )
 
-      if x == 0 && y == 0
-        [matrix.e, matrix.f]
+      if pt.x == 0 && pt.y == 0
+        Point.new(matrix.e, matrix.f)
       else
-        [
-          (matrix.a * x) + (matrix.c * y) + (matrix.e),
-          (matrix.b * x) + (matrix.d * y) + (matrix.f)
-        ]
+        Point.new(
+          (matrix.a * pt.x) + (matrix.c * pt.y) + (matrix.e),
+          (matrix.b * pt.x) + (matrix.d * pt.y) + (matrix.f)
+        )
       end
     end
 
@@ -235,9 +248,17 @@ class PDF::Reader
 
       if obj[:ToUnicode]
         # ToUnicode is optional for Type1 and Type3
-        stream = @ohash.deref_stream(obj[:ToUnicode])
-        if stream
-          @tounicode = PDF::Reader::CMap.new(stream.unfiltered_data)
+        begin
+          stream = @ohash.deref_stream(obj[:ToUnicode])
+          if stream
+            @tounicode = PDF::Reader::CMap.new(stream.unfiltered_data)
+          end
+        rescue PDF::Reader::MalformedPDFError => e
+          # If ToUnicode exists but isn't a stream, lets pretend it didn't exist. We
+          # can't do anything with it unless it's a stream with a CMap
+          unless e.message == "expected object to be a Stream or nil"
+            raise e
+          end
         end
       end
     end
@@ -282,13 +303,11 @@ class PDF::Reader
     def to_utf8_via_cmap(params, cmap)
       case params
       when Integer
-        [
-          cmap.decode(params)
-        ].flatten.pack("U*")
+        cmap.decode(params).pack("U*")
       when String
-        unpack_string_to_array_of_ints(params, encoding.unpack).map { |code_point|
+        unpack_string_to_array_of_ints(params, encoding.unpack).flat_map { |code_point|
           cmap.decode(code_point)
-        }.flatten.pack("U*")
+        }.pack("U*")
       when Array
         params.collect { |param| to_utf8_via_cmap(param, cmap) }.join("")
       end

data/lib/pdf/reader/form_xobject.rb

@@ -103,9 +103,12 @@ module PDF
       def tokens
         @cache[cached_tokens_key] ||= begin
                       buffer = Buffer.new(StringIO.new(raw_content), :content_stream => true)
-                      parser = Parser.new(buffer, @objects)
+                      parser = Parser.new(
+                        buffer,
+                        operators: PagesStrategy::OPERATORS, objects: @objects
+                      )
                       result = []
-                      while (token = parser.parse_token(PagesStrategy::OPERATORS))
+                      while (token = parser.parse_token)
                         result << token
                       end
                       result

data/lib/pdf/reader/key_builder_v5.rb

@@ -3,7 +3,6 @@
 # frozen_string_literal: true
 
 require 'digest/md5'
-require 'rc4'
 
 class PDF::Reader
 

data/lib/pdf/reader/object_cache.rb

@@ -17,18 +17,18 @@ class PDF::Reader
     # avoid lots of repetitive (and expensive) tokenising
     CACHEABLE_TYPES = [:Catalog, :Page, :Pages] #: Array[Symbol]
 
-    #: untyped
+    #: Integer
     attr_reader :hits
 
-    #: untyped
+    #: Integer
     attr_reader :misses
 
     #: (?untyped) -> void
     def initialize(lru_size = 1000)
-      @objects = {}
-      @lru_cache = Hashery::LRUHash.new(lru_size.to_i)
-      @hits = 0
-      @misses = 0
+      @objects = {} #: Hash[untyped, untyped]
+      @lru_cache = Hashery::LRUHash.new(lru_size.to_i) #: Hashery::LRUHash
+      @hits = 0 #: Integer
+      @misses = 0 #: Integer
     end
 
     def [](key)
@@ -46,7 +46,7 @@ class PDF::Reader
 
     def fetch(key, local_default = nil)
       update_stats(key)
-      @objects[key] || @lru_cache.fetch(key, local_default)
+      @objects[key] || @lru_cache.fetch(key) { local_default }
     end
 
     def each(&block)
@@ -85,14 +85,17 @@ class PDF::Reader
       @objects.has_value?(value) || @lru_cache.has_value?(value)
     end
 
+    #: () -> String
     def to_s
       "<PDF::Reader::ObjectCache size: #{self.size}>"
     end
 
+    #: () -> Array[untyped]
     def keys
       @objects.keys + @lru_cache.keys
     end
 
+    #: () -> Array[untyped]
     def values
       @objects.values + @lru_cache.values
     end
@@ -107,6 +110,7 @@ class PDF::Reader
       end
     end
 
+    #: (untyped) -> bool?
     def cacheable?(obj)
       obj.is_a?(Hash) && CACHEABLE_TYPES.include?(obj[:Type])
     end

data/lib/pdf/reader/object_hash.rb

@@ -59,9 +59,9 @@ class PDF::Reader
     #
     #   :password - the user password to decrypt the source PDF
     #
-    #: ((IO | Tempfile | StringIO | String), ?Hash[Symbol, untyped]) -> void
+    #: (untyped, ?Hash[Symbol, untyped]) -> void
     def initialize(input, opts = {})
-      @io          = extract_io_from(input) #: IO | Tempfile | StringIO
+      @io          = extract_io_from(input) #: untyped
       @xref        = PDF::Reader::XRef.new(@io) #: PDF::Reader::XRef[PDF::Reader::Reference]
       @pdf_version = read_version #: Float
       @trailer     = @xref.trailer #: Hash[Symbol, untyped]
@@ -127,6 +127,7 @@ class PDF::Reader
     # Guaranteed to only return an Array or nil. If the dereference results in
     # any other type then a MalformedPDFError exception will raise. Useful when
     # expecting an Array and no other type will do.
+    #
     #: (untyped) -> Array[untyped]?
     def deref_array(key)
       obj = deref(key)
@@ -146,6 +147,7 @@ class PDF::Reader
     # expecting an Array and no other type will do.
     #
     # Some effort to cast array elements to a number is made for any non-numeric elements.
+    #
     #: (untyped) -> Array[Numeric]?
     def deref_array_of_numbers(key)
       arr = deref(key)
@@ -172,7 +174,8 @@ class PDF::Reader
     #
     # Guaranteed to only return a Hash or nil. If the dereference results in
     # any other type then a MalformedPDFError exception will raise. Useful when
-    # expecting an Array and no other type will do.
+    # expecting a Hash and no other type will do.
+    #
     #: (untyped) -> Hash[Symbol, untyped]?
     def deref_hash(key)
       obj = deref(key)
@@ -189,9 +192,10 @@ class PDF::Reader
     #
     # Guaranteed to only return a PDF name (Symbol) or nil. If the dereference results in
     # any other type then a MalformedPDFError exception will raise. Useful when
-    # expecting an Array and no other type will do.
+    # expecting a PDF Name and no other type will do.
     #
     # Some effort to cast to a symbol is made when the reference points to a non-symbol.
+    #
     #: (untyped) -> Symbol?
     def deref_name(key)
       obj = deref(key)
@@ -214,7 +218,7 @@ class PDF::Reader
     #
     # Guaranteed to only return an Integer or nil. If the dereference results in
     # any other type then a MalformedPDFError exception will raise. Useful when
-    # expecting an Array and no other type will do.
+    # expecting an Integer and no other type will do.
     #
     # Some effort to cast to an int is made when the reference points to a non-integer.
     #: (untyped) -> Integer?
@@ -239,7 +243,7 @@ class PDF::Reader
     #
     # Guaranteed to only return a Numeric or nil. If the dereference results in
     # any other type then a MalformedPDFError exception will raise. Useful when
-    # expecting an Array and no other type will do.
+    # expecting a Number and no other type will do.
     #
     # Some effort to cast to a number is made when the reference points to a non-number.
     #: (untyped) -> Numeric?
@@ -267,6 +271,7 @@ class PDF::Reader
     # Guaranteed to only return a PDF::Reader::Stream or nil. If the dereference results in
     # any other type then a MalformedPDFError exception will raise. Useful when
     # expecting a stream and no other type will do.
+    #
     #: (untyped) -> PDF::Reader::Stream?
     def deref_stream(key)
       obj = deref(key)
@@ -553,7 +558,7 @@ class PDF::Reader
     def fetch_object(key)
       if xref[key].is_a?(Integer)
         buf = new_buffer(xref[key])
-        decrypt(key, Parser.new(buf, self).object(key.id, key.gen))
+        decrypt(key, Parser.new(buf, objects: self).object(key.id, key.gen))
       end
     end
 
@@ -703,9 +708,9 @@ class PDF::Reader
       version.to_f
     end
 
-    #: (IO | Tempfile | StringIO | String) -> (IO | Tempfile | StringIO)
+    #: (untyped) -> untyped
     def extract_io_from(input)
-      if input.is_a?(IO) || input.is_a?(StringIO) || input.is_a?(Tempfile)
+      if input.respond_to?(:read) && input.respond_to?(:seek)
         input
       elsif File.file?(input.to_s)
         StringIO.new read_as_binary(input.to_s)

data/lib/pdf/reader/page.rb

@@ -274,10 +274,10 @@ module PDF
       #: (Array[untyped], String) -> void
       def content_stream(receivers, instructions)
         buffer       = Buffer.new(StringIO.new(instructions), :content_stream => true)
-        parser       = Parser.new(buffer, @objects)
+        parser       = Parser.new(buffer, operators: PagesStrategy::OPERATORS, objects: @objects)
         params       = []
 
-        while (token = parser.parse_token(PagesStrategy::OPERATORS))
+        while (token = parser.parse_token)
           if token.kind_of?(Token) && method_name = PagesStrategy::OPERATORS[token]
             callback(receivers, method_name, params)
             params.clear

data/lib/pdf/reader/page_layout.rb

@@ -122,7 +122,7 @@ class PDF::Reader
 
     #: (untyped, untyped, untyped) -> untyped
     def local_string_insert(haystack, needle, index)
-      haystack[Range.new(index, index + needle.length - 1)] = String.new(needle)
+      haystack[index, needle.length] = needle
     end
 
     #: (untyped) -> untyped

data/lib/pdf/reader/page_state.rb

@@ -119,9 +119,9 @@ class PDF::Reader
 
       def font_size
         @font_size ||= begin
-                         _, zero = trm_transform(0,0)
-                         _, one  = trm_transform(1,1)
-                         (zero - one).abs.round(10)
+                         bl = trm_transform_point(Point::ZERO_ZERO)
+                         tr = trm_transform_point(Point::ONE_ONE)
+                         (bl.y - tr.y).abs.round(10)
                        end
       end
 
@@ -146,14 +146,7 @@ class PDF::Reader
       #####################################################
 
       def move_text_position(x, y) # Td
-        temp = TransformationMatrix.new(1, 0,
-                                        0, 1,
-                                        x, y)
-        @text_line_matrix = temp.multiply!(
-          @text_line_matrix.a, @text_line_matrix.b,
-          @text_line_matrix.c, @text_line_matrix.d,
-          @text_line_matrix.e, @text_line_matrix.f
-        )
+        @text_line_matrix.prepend_translation!(x, y)
         @text_matrix = @text_line_matrix.dup
         @font_size = @text_rendering_matrix = nil # invalidate cached value
       end
@@ -227,28 +220,83 @@ class PDF::Reader
       # transform x and y co-ordinates from the current user space to the
       # underlying device space.
       #
+      # Deprecated. Prefer ctm_transform_point()
+      #
+      #: (Numeric, Numeric) -> [Numeric]
       def ctm_transform(x, y)
+        # TODO print a deprecation warning
+        res = ctm_transform_point(x, y)
         [
-          (ctm.a * x) + (ctm.c * y) + (ctm.e),
-          (ctm.b * x) + (ctm.d * y) + (ctm.f)
+          res.x,
+          res.y
         ]
       end
 
+      # transform x and y co-ordinates from the current user space to the
+      # underlying device space.
+      #
+      # Recommended usage:
+      #
+      #     ctm_transform_point(Point.new(0,1))
+      #
+      # Also supported:
+      #
+      #     ctm_transform_point(0,1)
+      #
+      #: (PDF::Reader::Point | Numeric, ?Numeric) -> PDF::Reader::Point
+      def ctm_transform_point(pt, opt_y = -1)
+        unless pt.is_a?(Point)
+          pt = Point.new(pt.to_i, opt_y.to_i)
+        end
+        Point.new(
+          (ctm.a * pt.x) + (ctm.c * pt.y) + (ctm.e),
+          (ctm.b * pt.x) + (ctm.d * pt.y) + (ctm.f)
+        )
+      end
+
       # transform x and y co-ordinates from the current text space to the
       # underlying device space.
       #
+      # Deprecated. Prefer trm_transform_point()
+      #
+      #: (Numeric, Numeric) -> Array[Numeric]
+      def trm_transform(x, y)
+        # TODO print a deprecation warning
+        res = trm_transform_point(x, y)
+        [
+          res.x,
+          res.y
+        ]
+      end
+
+      # transform x and y co-ordinates from the current text space to the
+      # underlying device space.
+      #
+      # Recommended usage:
+      #
+      #     trm_transform_point(Point.new(0,1))
+      #
+      # Also supported:
+      #
+      #     trm_transform_point(0,1)
+      #
       # transforming (0,0) is a really common case, so optimise for it to
       # avoid unnecessary object allocations
       #
-      def trm_transform(x, y)
+      #: (PDF::Reader::Point | Numeric, ?Numeric) -> PDF::Reader::Point
+      def trm_transform_point(pt, opt_y = -1)
+        unless pt.is_a?(Point)
+          pt = Point.new(pt.to_i, opt_y.to_i)
+        end
+
         trm = text_rendering_matrix
-        if x == 0 && y == 0
-          [trm.e, trm.f]
+        if pt.x == 0 && pt.y == 0
+          Point.new(trm.e, trm.f)
         else
-          [
-            (trm.a * x) + (trm.c * y) + (trm.e),
-            (trm.b * x) + (trm.d * y) + (trm.f)
-          ]
+          Point.new(
+            (trm.a * pt.x) + (trm.c * pt.y) + (trm.e),
+            (trm.b * pt.x) + (trm.d * pt.y) + (trm.f)
+          )
         end
       end
 
@@ -342,15 +390,11 @@ class PDF::Reader
         end
         # TODO: support ty > 0
         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
+        @text_matrix.prepend_translation!(tx, ty)
+        @text_rendering_matrix = nil # invalidate cached value
+        # we used to invalidate @font_size here too, but it's not required
+        # font_size depends only on trm.b/trm.d (scale/rotation), not trm.e/f (translation),
+        # so it remains valid after a glyph displacement and does not need invalidation
       end
 
       private

data/lib/pdf/reader/page_text_receiver.rb

@@ -49,6 +49,8 @@ module PDF
         @page = page
         @content = []
         @characters = []
+        @actual_text = nil
+        @actual_text_consumed = false
       end
 
       def runs(opts = {})
@@ -84,6 +86,7 @@ module PDF
       end
 
       # deprecated
+      #: () -> String
       def content
         mediabox = @page.rectangles[:MediaBox]
         PageLayout.new(runs, mediabox).to_s
@@ -120,6 +123,21 @@ module PDF
         move_to_next_line_and_show_text(string)
       end
 
+      #####################################################
+      # Marked Content
+      #####################################################
+      def begin_marked_content_with_pl(tag, properties)
+        if properties.is_a?(Hash) && properties[:ActualText]
+          @actual_text = properties[:ActualText]
+          @actual_text_consumed = false
+        end
+      end
+
+      def end_marked_content
+        @actual_text = nil
+        @actual_text_consumed = false
+      end
+
       #####################################################
       # XObjects
       #####################################################
@@ -134,6 +152,7 @@ module PDF
 
       private
 
+      #: (String) -> void
       def internal_show_text(string)
         PDF::Reader::Error.validate_type_as_malformed(string, "string", String)
         if @state.current_font.nil?
@@ -142,41 +161,52 @@ module PDF
         glyphs = @state.current_font.unpack(string)
         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)
+          bl = @state.trm_transform_point(Point::ZERO_ZERO)
+          text_origin = apply_rotation(bl)
 
           utf8_chars = @state.current_font.to_utf8(glyph_code)
 
+          # Use ActualText from marked content if available (PDF 32000-1 §14.9.4).
+          # ActualText replaces all text within a BDC/EMC span.
+          if @actual_text
+            if !@actual_text_consumed
+              text = @actual_text
+              utf8_chars = PDF::Reader::EncodingUtils.string_to_utf8(text)
+              @actual_text_consumed = true
+            else
+              utf8_chars = ""
+            end
+          end
+
           # 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_in_text_space(glyph_code)
           th = 1
           scaled_glyph_width = glyph_width * @state.font_size * th
           unless utf8_chars == SPACE
-            @characters << TextRun.new(newx, newy, scaled_glyph_width, @state.font_size, utf8_chars)
+            @characters << TextRun.new(text_origin.x, text_origin.y, scaled_glyph_width, @state.font_size, utf8_chars)
           end
           @state.process_glyph_displacement(glyph_width, 0, utf8_chars == SPACE)
         end
       end
 
-      def apply_rotation(x, y)
+      #: (Point) -> Point
+      def apply_rotation(pt)
         if @page.rotate == 90
-          tmp = x
-          x = y
-          y = tmp * -1
+          Point.new(pt.y, pt.x * -1)
         elsif @page.rotate == 180
-          y *= -1
-          x *= -1
+          Point.new(pt.x * -1, pt.y * -1)
         elsif @page.rotate == 270
-          tmp = y
-          y = x
-          x = tmp * -1
+          Point.new(pt.y * -1, pt.x)
+        else
+          pt
         end
-        return x, y
       end
 
       # take a collection of TextRun objects and merge any that are in close
       # proximity
+      #
+      #: (Array[PDF::Reader::TextRun]) -> Array[PDF::Reader::TextRun]
       def merge_runs(runs)
         runs.group_by { |char|
           char.y.to_i

data/lib/pdf/reader/pages_strategy.rb

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