pdf-reader 2.5.0 → 2.9.0

data/lib/pdf/reader/object_hash.rb

@@ -1,4 +1,5 @@
 # coding: utf-8
+# typed: true
 # frozen_string_literal: true
 
 class PDF::Reader
@@ -47,7 +48,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
@@ -91,6 +96,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 an Array 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.
     #
@@ -98,6 +315,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.
     #
@@ -232,7 +465,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?
@@ -298,36 +534,6 @@ 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
@@ -336,8 +542,10 @@ class PDF::Reader
         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
@@ -359,19 +567,19 @@ class PDF::Reader
       @object_stream ||= {}
     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
-
+    def get_page_objects(obj)
       if obj[:Type] == :Page
-        ref
+        [obj]
       elsif obj[:Kids]
-        deref(obj[:Kids]).map { |kid| get_page_objects(kid) }
+        kids = deref_array(obj[:Kids]) || []
+        kids.map { |kid|
+          get_page_objects(deref_hash(kid) || {})
+        }.flatten
+      else
+        raise MalformedPDFError, "Expected Page or Pages object"
       end
     end
 

data/lib/pdf/reader/object_stream.rb

@@ -1,4 +1,5 @@
 # coding: utf-8
+# typed: true
 # frozen_string_literal: true
 
 class PDF::Reader

data/lib/pdf/reader/overlapping_runs_filter.rb

@@ -1,4 +1,6 @@
+# typed: true
 # coding: utf-8
+# frozen_string_literal: true
 
 class PDF::Reader
   # remove duplicates from a collection of TextRun objects. This can be helpful when a PDF
@@ -38,7 +40,8 @@ class PDF::Reader
 
     def self.detect_intersection(sweep_line_status, event_point)
       sweep_line_status.each do |open_text_run|
-        if event_point.x >= open_text_run.x &&
+        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
@@ -51,10 +54,14 @@ class PDF::Reader
   # Utility class used to avoid modifying the underlying TextRun objects while we're
   # looking for duplicates
   class EventPoint
-    attr_reader :x, :run
 
-    def initialize x, run
-      @x, @run = x, run
+    attr_reader :x
+
+    attr_reader :run
+
+    def initialize(x, run)
+      @x = x
+      @run = run
     end
 
     def start?

data/lib/pdf/reader/page.rb

@@ -1,4 +1,5 @@
 # coding: utf-8
+# typed: true
 # 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,7 +43,7 @@ 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)
@@ -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,10 +163,10 @@ 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
@@ -139,30 +186,62 @@ module PDF
       # 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
-        mediabox = attributes[:MediaBox]
-        cropbox = attributes[:Cropbox] || mediabox
+        # 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: objects.deref!(mediabox),
-          CropBox: objects.deref!(cropbox),
-          BleedBox: objects.deref!(attributes[:BleedBox] || cropbox),
-          TrimBox: objects.deref!(attributes[:TrimBox] || cropbox),
-          ArtBox: objects.deref!(attributes[:ArtBox] || cropbox)
+          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)
@@ -198,7 +277,8 @@ module PDF
         if origin.nil?
           []
         else
-          obj = objects.deref(origin)
+          obj = objects.deref_hash(origin)
+          PDF::Reader::Error.validate_not_nil_as_malformed(obj, "parent")
           [ select_inheritable(obj) ] + ancestors(obj[:Parent])
         end
       end