pdf-reader 2.2.0 → 2.11.0

data/lib/pdf/reader/object_hash.rb

@@ -1,6 +1,9 @@
 # coding: utf-8
+# typed: true
 # frozen_string_literal: true
 
+require 'tempfile'
+
 class PDF::Reader
   # Provides low level access to the objects in a PDF file via a hash-like
   # object.
@@ -47,7 +50,11 @@ class PDF::Reader
       @trailer     = @xref.trailer
       @cache       = opts[:cache] || PDF::Reader::ObjectCache.new
       @sec_handler = NullSecurityHandler.new
-      @sec_handler = build_security_handler(opts)
+      @sec_handler = SecurityHandlerFactory.build(
+        deref(trailer[:Encrypt]),
+        deref(trailer[:ID]),
+        opts[:password]
+      )
     end
 
     # returns the type of object a ref points to
@@ -78,16 +85,7 @@ class PDF::Reader
         key = PDF::Reader::Reference.new(key.to_i, 0)
       end
 
-      if @cache.has_key?(key)
-        @cache[key]
-      elsif xref[key].is_a?(Integer)
-        buf = new_buffer(xref[key])
-        @cache[key] = decrypt(key, Parser.new(buf, self).object(key.id, key.gen))
-      elsif xref[key].is_a?(PDF::Reader::Reference)
-        container_key = xref[key]
-        object_streams[container_key] ||= PDF::Reader::ObjectStream.new(object(container_key))
-        @cache[key] = object_streams[container_key][key.id]
-      end
+      @cache[key] ||= fetch_object(key) || fetch_object_stream(key)
     rescue InvalidObjectError
       return default
     end
@@ -100,6 +98,218 @@ class PDF::Reader
     end
     alias :deref :object
 
+    # If key is a PDF::Reader::Reference object, lookup the corresponding
+    # object in the PDF and return it. Otherwise return key untouched.
+    #
+    # 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.
+    def deref_array(key)
+      obj = deref(key)
+
+      return obj if obj.nil?
+
+      obj.tap { |obj|
+        raise MalformedPDFError, "expected object to be an Array or nil" if !obj.is_a?(Array)
+      }
+    end
+
+    # If key is a PDF::Reader::Reference object, lookup the corresponding
+    # object in the PDF and return it. Otherwise return key untouched.
+    #
+    # Guaranteed to only return an Array of Numerics 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.
+    #
+    # Some effort to cast array elements to a number is made for any non-numeric elements.
+    def deref_array_of_numbers(key)
+      arr = deref(key)
+
+      return arr if arr.nil?
+
+      raise MalformedPDFError, "expected object to be an Array" unless arr.is_a?(Array)
+
+      arr.map { |item|
+        if item.is_a?(Numeric)
+          item
+        elsif item.respond_to?(:to_f)
+          item.to_f
+        elsif item.respond_to?(:to_i)
+          item.to_i
+        else
+          raise MalformedPDFError, "expected object to be a number"
+        end
+      }
+    end
+
+    # If key is a PDF::Reader::Reference object, lookup the corresponding
+    # object in the PDF and return it. Otherwise return key untouched.
+    #
+    # 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.
+    def deref_hash(key)
+      obj = deref(key)
+
+      return obj if obj.nil?
+
+      obj.tap { |obj|
+        raise MalformedPDFError, "expected object to be a Hash or nil" if !obj.is_a?(Hash)
+      }
+    end
+
+    # If key is a PDF::Reader::Reference object, lookup the corresponding
+    # object in the PDF and return it. Otherwise return key untouched.
+    #
+    # 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.
+    #
+    # Some effort to cast to a symbol is made when the reference points to a non-symbol.
+    def deref_name(key)
+      obj = deref(key)
+
+      return obj if obj.nil?
+
+      if !obj.is_a?(Symbol)
+        if obj.respond_to?(:to_sym)
+          obj = obj.to_sym
+        else
+          raise MalformedPDFError, "expected object to be a Name"
+        end
+      end
+
+      obj
+    end
+
+    # If key is a PDF::Reader::Reference object, lookup the corresponding
+    # object in the PDF and return it. Otherwise return key untouched.
+    #
+    # 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.
+    #
+    # Some effort to cast to an int is made when the reference points to a non-integer.
+    def deref_integer(key)
+      obj = deref(key)
+
+      return obj if obj.nil?
+
+      if !obj.is_a?(Integer)
+        if obj.respond_to?(:to_i)
+          obj = obj.to_i
+        else
+          raise MalformedPDFError, "expected object to be an Integer"
+        end
+      end
+
+      obj
+    end
+
+    # If key is a PDF::Reader::Reference object, lookup the corresponding
+    # object in the PDF and return it. Otherwise return key untouched.
+    #
+    # 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.
+    #
+    # Some effort to cast to a number is made when the reference points to a non-number.
+    def deref_number(key)
+      obj = deref(key)
+
+      return obj if obj.nil?
+
+      if !obj.is_a?(Numeric)
+        if obj.respond_to?(:to_f)
+          obj = obj.to_f
+        elsif obj.respond_to?(:to_i)
+          obj.to_i
+        else
+          raise MalformedPDFError, "expected object to be a number"
+        end
+      end
+
+      obj
+    end
+
+    # If key is a PDF::Reader::Reference object, lookup the corresponding
+    # object in the PDF and return it. Otherwise return key untouched.
+    #
+    # 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.
+    def deref_stream(key)
+      obj = deref(key)
+
+      return obj if obj.nil?
+
+      obj.tap { |obj|
+        if !obj.is_a?(PDF::Reader::Stream)
+          raise MalformedPDFError, "expected object to be a Stream or nil"
+        end
+      }
+    end
+
+    # If key is a PDF::Reader::Reference object, lookup the corresponding
+    # object in the PDF and return it. Otherwise return key untouched.
+    #
+    # Guaranteed to only return a String or nil. If the dereference results in
+    # any other type then a MalformedPDFError exception will raise. Useful when
+    # expecting a string and no other type will do.
+    #
+    # Some effort to cast to a string is made when the reference points to a non-string.
+    def deref_string(key)
+      obj = deref(key)
+
+      return obj if obj.nil?
+
+      if !obj.is_a?(String)
+        if obj.respond_to?(:to_s)
+          obj = obj.to_s
+        else
+          raise MalformedPDFError, "expected object to be a string"
+        end
+      end
+
+      obj
+    end
+
+    # If key is a PDF::Reader::Reference object, lookup the corresponding
+    # object in the PDF and return it. Otherwise return key untouched.
+    #
+    # Guaranteed to only return a PDF Name (symbol), Array or nil. If the dereference results in
+    # any other type then a MalformedPDFError exception will raise. Useful when
+    # expecting a Name or Array and no other type will do.
+    def deref_name_or_array(key)
+      obj = deref(key)
+
+      return obj if obj.nil?
+
+      obj.tap { |obj|
+        if !obj.is_a?(Symbol) && !obj.is_a?(Array)
+          raise MalformedPDFError, "expected object to be an Array or Name"
+        end
+      }
+    end
+
+    # If key is a PDF::Reader::Reference object, lookup the corresponding
+    # object in the PDF and return it. Otherwise return key untouched.
+    #
+    # Guaranteed to only return a PDF::Reader::Stream, Array or nil. If the dereference results in
+    # any other type then a MalformedPDFError exception will raise. Useful when
+    # expecting a stream or Array and no other type will do.
+    def deref_stream_or_array(key)
+      obj = deref(key)
+
+      return obj if obj.nil?
+
+      obj.tap { |obj|
+        if !obj.is_a?(PDF::Reader::Stream) && !obj.is_a?(Array)
+          raise MalformedPDFError, "expected object to be an Array or Stream"
+        end
+      }
+    end
+
     # Recursively dereferences the object refered to be +key+. If +key+ is not
     # a PDF::Reader::Reference, the key is returned unchanged.
     #
@@ -107,6 +317,22 @@ class PDF::Reader
       deref_internal!(key, {})
     end
 
+    def deref_array!(key)
+      deref!(key).tap { |obj|
+        if !obj.nil? && !obj.is_a?(Array)
+          raise MalformedPDFError, "expected object (#{obj.inspect}) to be an Array or nil"
+        end
+      }
+    end
+
+    def deref_hash!(key)
+      deref!(key).tap { |obj|
+        if !obj.nil? && !obj.is_a?(Hash)
+          raise MalformedPDFError, "expected object (#{obj.inspect}) to be a Hash or nil"
+        end
+      }
+    end
+
     # Access an object from the PDF. key can be an int or a PDF::Reader::Reference
     # object.
     #
@@ -241,7 +467,10 @@ class PDF::Reader
     #
     def page_references
       root  = fetch(trailer[:Root])
-      @page_references ||= get_page_objects(root[:Pages]).flatten
+      @page_references ||= begin
+                             pages_root = deref_hash(root[:Pages]) || {}
+                             get_page_objects(pages_root)
+                           end
     end
 
     def encrypted?
@@ -254,6 +483,28 @@ class PDF::Reader
 
     private
 
+    # parse a traditional object from the PDF, starting from the byte offset indicated
+    # in the xref table
+    #
+    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))
+      end
+    end
+
+    # parse a object that's embedded in an object stream in the PDF
+    #
+    def fetch_object_stream(key)
+      if xref[key].is_a?(PDF::Reader::Reference)
+        container_key = xref[key]
+        stream = deref_stream(container_key)
+        raise MalformedPDFError, "Object Stream cannot be nil" if stream.nil?
+        object_streams[container_key] ||= PDF::Reader::ObjectStream.new(stream)
+        object_streams[container_key][key.id]
+      end
+    end
+
     # Private implementation of deref!, which exists to ensure the `seen` argument
     # isn't publicly available. It's used to avoid endless loops in the recursion, and
     # doesn't need to be part of the public API.
@@ -287,44 +538,18 @@ class PDF::Reader
       end
     end
 
-    def build_security_handler(opts = {})
-      encrypt = deref(trailer[:Encrypt])
-      if NullSecurityHandler.supports?(encrypt)
-        NullSecurityHandler.new
-      elsif StandardSecurityHandler.supports?(encrypt)
-        encmeta = !encrypt.has_key?(:EncryptMetadata) || encrypt[:EncryptMetadata].to_s == "true"
-        StandardSecurityHandler.new(
-          key_length: (encrypt[:Length] || 40).to_i,
-          revision: encrypt[:R],
-          owner_key: encrypt[:O],
-          user_key: encrypt[:U],
-          permissions: encrypt[:P].to_i,
-          encrypted_metadata: encmeta,
-          file_id: (deref(trailer[:ID]) || []).first,
-          password: opts[:password],
-          cfm: encrypt.fetch(:CF, {}).fetch(encrypt[:StmF], {}).fetch(:CFM, nil)
-        )
-      elsif StandardSecurityHandlerV5.supports?(encrypt)
-        StandardSecurityHandlerV5.new(
-            O: encrypt[:O],
-            U: encrypt[:U],
-            OE: encrypt[:OE],
-            UE: encrypt[:UE],
-            password: opts[:password]
-        )
-      else
-        UnimplementedSecurityHandler.new
-      end
-    end
-
     def decrypt(ref, obj)
       case obj
       when PDF::Reader::Stream then
-        obj.data = sec_handler.decrypt(obj.data, ref)
+        # PDF 32000-1:2008 7.5.8.2: "The cross-reference stream shall not be encrypted [...]."
+        # Therefore we shouldn't try to decrypt it.
+        obj.data = sec_handler.decrypt(obj.data, ref) unless obj.hash[:Type] == :XRef
         obj
       when Hash                then
-        arr = obj.map { |key,val| [key, decrypt(ref, val)] }.flatten(1)
-        Hash[*arr]
+        arr = obj.map { |key,val| [key, decrypt(ref, val)] }
+        arr.each_with_object({}) { |(k,v), accum|
+          accum[k] = v
+        }
       when Array               then
         obj.collect { |item| decrypt(ref, item) }
       when String
@@ -343,39 +568,43 @@ class PDF::Reader
     end
 
     def object_streams
-      @object_stream ||= {}
+      @object_streams ||= {}
     end
 
-    # returns a nested array of object references for all pages in this object store.
+    # returns an array of object references for all pages in this object store. The ordering of
+    # the Array is significant and matches the page ordering of the document
     #
-    def get_page_objects(ref)
-      obj = deref(ref)
-
-      unless obj.kind_of?(::Hash)
-        raise MalformedPDFError, "Dereferenced page object must be a dict"
-      end
-
-      if obj[:Type] == :Page
-        ref
-      elsif obj[:Kids]
-        deref(obj[:Kids]).map { |kid| get_page_objects(kid) }
+    def get_page_objects(obj)
+      derefed_obj = deref_hash(obj)
+
+      if derefed_obj.nil?
+        raise MalformedPDFError, "Expected Page or Pages object, got nil"
+      elsif derefed_obj[:Type] == :Page
+        [obj]
+      elsif derefed_obj[:Kids]
+        kids = deref_array(derefed_obj[:Kids]) || []
+        kids.map { |kid|
+          get_page_objects(kid)
+        }.flatten
+      else
+        raise MalformedPDFError, "Expected Page or Pages object"
       end
     end
 
     def read_version
       @io.seek(0)
-      _m, version = *@io.read(10).match(/PDF-(\d.\d)/)
+      _m, version = *@io.read(10).to_s.match(/PDF-(\d.\d)/)
       @io.seek(0)
       version.to_f
     end
 
     def extract_io_from(input)
-      if input.respond_to?(:seek) && input.respond_to?(:read)
+      if input.is_a?(IO) || input.is_a?(StringIO) || input.is_a?(Tempfile)
         input
       elsif File.file?(input.to_s)
-        StringIO.new read_as_binary(input)
+        StringIO.new read_as_binary(input.to_s)
       else
-        raise ArgumentError, "input must be an IO-like object or a filename"
+        raise ArgumentError, "input must be an IO-like object or a filename (#{input.class})"
       end
     end
 
@@ -383,7 +612,7 @@ class PDF::Reader
       if File.respond_to?(:binread)
         File.binread(input.to_s)
       else
-        File.open(input.to_s,"rb") { |f| f.read }
+        File.open(input.to_s,"rb") { |f| f.read } || ""
       end
     end
 

data/lib/pdf/reader/object_stream.rb

@@ -1,4 +1,5 @@
 # coding: utf-8
+# typed: strict
 # frozen_string_literal: true
 
 class PDF::Reader
@@ -23,7 +24,7 @@ class PDF::Reader
     end
 
     def size
-      @dict[:N]
+      TypeCheck.cast_to_int!(@dict[:N])
     end
 
     private
@@ -39,7 +40,7 @@ class PDF::Reader
     end
 
     def first
-      @dict[:First]
+      TypeCheck.cast_to_int!(@dict[:First])
     end
 
     def buffer

data/lib/pdf/reader/overlapping_runs_filter.rb

@@ -0,0 +1,72 @@
+# coding: utf-8
+# frozen_string_literal: true
+# typed: strict
+
+class PDF::Reader
+  # remove duplicates from a collection of TextRun objects. This can be helpful when a PDF
+  # uses slightly offset overlapping characters to achieve a fake 'bold' effect.
+  class OverlappingRunsFilter
+
+    # This should be between 0 and 1. If TextRun B obscures this much of TextRun A (and they
+    # have identical characters) then one will be discarded
+    OVERLAPPING_THRESHOLD = 0.5
+
+    def self.exclude_redundant_runs(runs)
+      sweep_line_status = Array.new
+      event_point_schedule = Array.new
+      to_exclude = []
+
+      runs.each do |run|
+        event_point_schedule << EventPoint.new(run.x, run)
+        event_point_schedule << EventPoint.new(run.endx, run)
+      end
+
+      event_point_schedule.sort! { |a,b| a.x <=> b.x }
+
+      event_point_schedule.each do |event_point|
+        run = event_point.run
+
+        if event_point.start?
+          if detect_intersection(sweep_line_status, event_point)
+            to_exclude << run
+          end
+          sweep_line_status.push(run)
+        else
+          sweep_line_status.delete(run)
+        end
+      end
+      runs - to_exclude
+    end
+
+    def self.detect_intersection(sweep_line_status, event_point)
+      sweep_line_status.each do |open_text_run|
+        if open_text_run.text == event_point.run.text &&
+            event_point.x >= open_text_run.x &&
+            event_point.x <= open_text_run.endx &&
+            open_text_run.intersection_area_percent(event_point.run) >= OVERLAPPING_THRESHOLD
+          return true
+        end
+      end
+      return false
+    end
+  end
+
+  # Utility class used to avoid modifying the underlying TextRun objects while we're
+  # looking for duplicates
+  class EventPoint
+
+    attr_reader :x
+
+    attr_reader :run
+
+    def initialize(x, run)
+      @x = x
+      @run = run
+    end
+
+    def start?
+      @x == @run.x
+    end
+  end
+
+end