pdf-reader 1.1.1 → 2.5.0

data/lib/pdf/reader/lzw.rb

@@ -1,4 +1,5 @@
 # coding: utf-8
+# frozen_string_literal: true
 
 module PDF
 
@@ -17,11 +18,12 @@ module PDF
     #
     class LZW # :nodoc:
 
+      # Wraps an LZW encoded string
       class BitStream # :nodoc:
 
         def initialize(data, bits_in_chunk)
           @data = data
-          @data.force_encoding("BINARY") if @data.respond_to?(:force_encoding)
+          @data.force_encoding("BINARY")
           @bits_in_chunk = bits_in_chunk
           @current_pos = 0
           @bits_left_in_byte = 8
@@ -81,9 +83,10 @@ module PDF
       #
       def self.decode(data)
         stream = BitStream.new data.to_s, 9 # size of codes between 9 and 12 bits
-        result = ''
+        result = "".dup
         until (code = stream.read) == CODE_EOD
           if code == CODE_CLEAR_TABLE
+            stream.set_bits_in_chunk(9)
             string_table = StringTable.new
             code = stream.read
             break if code == CODE_EOD
@@ -114,11 +117,10 @@ module PDF
         result
       end
 
-      private
-
       def self.create_new_string(string_table,some_code, other_code)
         string_table[some_code] + string_table[other_code][0].chr
       end
+      private_class_method :create_new_string
 
     end
   end

data/lib/pdf/reader/null_security_handler.rb

@@ -0,0 +1,17 @@
+# coding: utf-8
+# frozen_string_literal: true
+
+class PDF::Reader
+
+  # A null object security handler. Used when a PDF is unencrypted.
+  class NullSecurityHandler
+
+    def self.supports?(encrypt)
+      encrypt.nil?
+    end
+
+    def decrypt(buf, _ref)
+      buf
+    end
+  end
+end

data/lib/pdf/reader/object_cache.rb

@@ -1,10 +1,13 @@
 # coding: utf-8
+# frozen_string_literal: true
+
+require 'hashery/lru_hash'
 
 class PDF::Reader
 
   # A Hash-like object for caching commonly used objects from a PDF file.
   #
-  # This is an internal class used by PDF::Reader::ObjectHash
+  # This is an internal class, no promises about a stable API.
   #
   class ObjectCache # nodoc
 
@@ -13,53 +16,67 @@ class PDF::Reader
     # avoid lots of repetitive (and expensive) tokenising
     CACHEABLE_TYPES = [:Catalog, :Page, :Pages]
 
-    def initialize
+    attr_reader :hits, :misses
+
+    def initialize(lru_size = 1000)
       @objects = {}
+      @lru_cache = Hashery::LRUHash.new(lru_size.to_i)
+      @hits = 0
+      @misses = 0
     end
 
     def [](key)
-      @objects[key]
+      update_stats(key)
+      @objects[key] || @lru_cache[key]
     end
 
     def []=(key, value)
-      @objects[key] = value if cacheable?(value)
+      if cacheable?(value)
+        @objects[key] = value
+      else
+        @lru_cache[key] = value
+      end
     end
 
     def fetch(key, local_default = nil)
-      @objects.fetch(key, local_default)
+      update_stats(key)
+      @objects[key] || @lru_cache.fetch(key, local_default)
     end
 
     def each(&block)
       @objects.each(&block)
+      @lru_cache.each(&block)
     end
     alias :each_pair :each
 
     def each_key(&block)
       @objects.each_key(&block)
+      @lru_cache.each_key(&block)
     end
 
     def each_value(&block)
       @objects.each_value(&block)
+      @lru_cache.each_value(&block)
     end
 
     def size
-      @objects.size
+      @objects.size + @lru_cache.size
     end
     alias :length :size
 
     def empty?
-      @objects.empty?
+      @objects.empty? && @lru_cache.empty?
     end
 
-    def has_key?(key)
-      @objects.has_key?(key)
+    def include?(key)
+      @objects.include?(key) || @lru_cache.include?(key)
     end
-    alias :include? :has_key?
-    alias :key? :has_key?
-    alias :member? :has_key?
+    alias :has_key? :include?
+    alias :key? :include?
+    alias :member? :include?
 
     def has_value?(value)
-      @objects.has_value?(value)
+      @objects.has_value?(value) || @lru_cache.has_value?(value)
     end
 
     def to_s
@@ -67,19 +84,26 @@ class PDF::Reader
     end
 
     def keys
-      @objects.keys
+      @objects.keys + @lru_cache.keys
     end
 
     def values
-      @objects.values
+      @objects.values + @lru_cache.values
     end
 
     private
 
+    def update_stats(key)
+      if has_key?(key)
+        @hits += 1
+      else
+        @misses += 1
+      end
+    end
+
     def cacheable?(obj)
       obj.is_a?(Hash) && CACHEABLE_TYPES.include?(obj[:Type])
     end
 
-
   end
 end

data/lib/pdf/reader/object_hash.rb

@@ -1,4 +1,5 @@
 # coding: utf-8
+# frozen_string_literal: true
 
 class PDF::Reader
   # Provides low level access to the objects in a PDF file via a hash-like
@@ -41,10 +42,11 @@ class PDF::Reader
     #
     def initialize(input, opts = {})
       @io          = extract_io_from(input)
-      @pdf_version = read_version
       @xref        = PDF::Reader::XRef.new(@io)
+      @pdf_version = read_version
       @trailer     = @xref.trailer
-      @cache       = PDF::Reader::ObjectCache.new
+      @cache       = opts[:cache] || PDF::Reader::ObjectCache.new
+      @sec_handler = NullSecurityHandler.new
       @sec_handler = build_security_handler(opts)
     end
 
@@ -76,16 +78,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?(Fixnum)
-        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
@@ -102,21 +95,7 @@ class PDF::Reader
     # a PDF::Reader::Reference, the key is returned unchanged.
     #
     def deref!(key)
-      case object = deref(key)
-      when Hash
-        {}.tap { |hash|
-          object.each do |k, value|
-            hash[k] = deref!(value)
-          end
-        }
-      when PDF::Reader::Stream
-        object.hash = deref!(object.hash)
-        object
-      when Array
-        object.map { |value| deref!(value) }
-      else
-        object
-      end
+      deref_internal!(key, {})
     end
 
     # Access an object from the PDF. key can be an int or a PDF::Reader::Reference
@@ -266,24 +245,95 @@ class PDF::Reader
 
     private
 
-    def build_security_handler(opts = {})
-      return nil if trailer[:Encrypt].nil?
+    # 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]
+        object_streams[container_key] ||= PDF::Reader::ObjectStream.new(object(container_key))
+        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.
+    #
+    def deref_internal!(key, seen)
+      seen_key = key.is_a?(PDF::Reader::Reference) ? key : key.object_id
+
+      return seen[seen_key] if seen.key?(seen_key)
+
+      case object = deref(key)
+      when Hash
+        seen[seen_key] ||= {}
+        object.each do |k, value|
+          seen[seen_key][k] = deref_internal!(value, seen)
+        end
+        seen[seen_key]
+      when PDF::Reader::Stream
+        seen[seen_key] ||= PDF::Reader::Stream.new({}, object.data)
+        object.hash.each do |k,value|
+          seen[seen_key].hash[k] = deref_internal!(value, seen)
+        end
+        seen[seen_key]
+      when Array
+        seen[seen_key] ||= []
+        object.each do |value|
+          seen[seen_key] << deref_internal!(value, seen)
+        end
+        seen[seen_key]
+      else
+        object
+      end
+    end
 
-      enc = deref(trailer[:Encrypt])
-      case enc[:Filter]
-      when :Standard
-        StandardSecurityHandler.new(enc, deref(trailer[:ID]), opts[:password])
+    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
-        raise PDF::Reader::EncryptedPDFError, "Unsupported encryption method (#{enc[:Filter]})"
+        UnimplementedSecurityHandler.new
       end
     end
 
     def decrypt(ref, obj)
-      return obj unless sec_handler?
-
       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)
@@ -312,18 +362,22 @@ class PDF::Reader
     # returns a nested array of object references for all pages in this object store.
     #
     def get_page_objects(ref)
-      obj = fetch(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[:Type] == :Pages
+      elsif obj[:Kids]
         deref(obj[:Kids]).map { |kid| get_page_objects(kid) }
       end
     end
 
     def read_version
       @io.seek(0)
-      m, version = *@io.read(10).match(/PDF-(\d.\d)/)
+      _m, version = *@io.read(10).match(/PDF-(\d.\d)/)
       @io.seek(0)
       version.to_f
     end

data/lib/pdf/reader/object_stream.rb

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

data/lib/pdf/reader/orientation_detector.rb

@@ -0,0 +1,34 @@
+# coding: utf-8
+# frozen_string_literal: true
+
+class PDF::Reader
+  # Small util class for detecting the orientation of a single PDF page. Accounts
+  # for any page rotation that is in place.
+  #
+  #     OrientationDetector.new(:MediaBox => [0,0,612,792]).orientation
+  #     => "portrait"
+  #
+  class OrientationDetector
+    def initialize(attributes)
+      @attributes = attributes
+    end
+
+    def orientation
+      @orientation ||= detect_orientation
+    end
+
+    private
+
+    def detect_orientation
+      llx,lly,urx,ury = @attributes[:MediaBox]
+      rotation        = @attributes[:Rotate].to_i
+      width           = (urx.to_i - llx.to_i).abs
+      height          = (ury.to_i - lly.to_i).abs
+      if width > height
+        (rotation % 180).zero? ? 'landscape' : 'portrait'
+      else
+        (rotation % 180).zero? ? 'portrait' : 'landscape'
+      end
+    end
+  end
+end

data/lib/pdf/reader/overlapping_runs_filter.rb

@@ -0,0 +1,65 @@
+# coding: utf-8
+
+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 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, :run
+
+    def initialize x, run
+      @x, @run = x, run
+    end
+
+    def start?
+      @x == @run.x
+    end
+  end
+
+end