pdf-reader 1.4.1 → 2.5.0

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
@@ -45,6 +46,7 @@ class PDF::Reader
       @pdf_version = read_version
       @trailer     = @xref.trailer
       @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?(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
@@ -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)
 
-      enc = deref(trailer[:Encrypt])
-      case enc[:Filter]
-      when :Standard
-        StandardSecurityHandler.new(enc, deref(trailer[:ID]), opts[:password])
+      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
-        raise PDF::Reader::EncryptedPDFError, "Unsupported encryption method (#{enc[:Filter]})"
+        object
       end
     end
 
-    def decrypt(ref, obj)
-      return obj unless sec_handler?
+    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)
@@ -312,11 +362,15 @@ 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

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

@@ -1,4 +1,5 @@
 # coding: utf-8
+# frozen_string_literal: true
 
 class PDF::Reader
   # Small util class for detecting the orientation of a single PDF page. Accounts
@@ -21,12 +22,12 @@ class PDF::Reader
     def detect_orientation
       llx,lly,urx,ury = @attributes[:MediaBox]
       rotation        = @attributes[:Rotate].to_i
-      width           = urx.to_i - llx.to_i
-      height          = ury.to_i - lly.to_i
+      width           = (urx.to_i - llx.to_i).abs
+      height          = (ury.to_i - lly.to_i).abs
       if width > height
-        [0,180].include?(rotation) ? 'landscape' : 'portrait'
+        (rotation % 180).zero? ? 'landscape' : 'portrait'
       else
-        [0,180].include?(rotation) ? 'portrait' : 'landscape'
+        (rotation % 180).zero? ? 'portrait' : 'landscape'
       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

data/lib/pdf/reader/page.rb

@@ -1,4 +1,5 @@
 # coding: utf-8
+# frozen_string_literal: true
 
 module PDF
   class Reader
@@ -36,7 +37,7 @@ module PDF
         @cache       = options[:cache] || {}
 
         unless @page_object.is_a?(::Hash)
-          raise ArgumentError, "invalid page: #{pagenum}"
+          raise InvalidPageError, "Invalid page: #{pagenum}"
         end
       end
 
@@ -123,6 +124,34 @@ module PDF
         }.join(" ")
       end
 
+      # returns the angle to rotate the page clockwise. Always 0, 90, 180 or 270
+      #
+      def rotate
+        value = attributes[:Rotate].to_i
+        case value
+        when 0, 90, 180, 270
+          value
+        else
+          0
+        end
+      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 boxes
+        mediabox = attributes[:MediaBox]
+        cropbox = attributes[:Cropbox] || mediabox
+
+        {
+          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)
+        }
+      end
+
       private
 
       def root

data/lib/pdf/reader/page_layout.rb

@@ -1,4 +1,7 @@
 # coding: utf-8
+# frozen_string_literal: true
+
+require 'pdf/reader/overlapping_runs_filter'
 
 class PDF::Reader
 
@@ -8,28 +11,33 @@ class PDF::Reader
   # media box should be a 4 number array that describes the dimensions of the
   # page to be rendered as described by the page's MediaBox attribute
   class PageLayout
+
+    DEFAULT_FONT_SIZE = 12
+
     def initialize(runs, mediabox)
       raise ArgumentError, "a mediabox must be provided" if mediabox.nil?
 
-      @runs    = merge_runs(runs)
-      @mean_font_size   = mean(@runs.map(&:font_size)) || 0
+      @runs    = merge_runs(OverlappingRunsFilter.exclude_redundant_runs(runs))
+      @mean_font_size   = mean(@runs.map(&:font_size)) || DEFAULT_FONT_SIZE
+      @mean_font_size = DEFAULT_FONT_SIZE if @mean_font_size == 0
       @mean_glyph_width = mean(@runs.map(&:mean_character_width)) || 0
-      @page_width  = mediabox[2] - mediabox[0]
-      @page_height = mediabox[3] - mediabox[1]
-      @x_offset = @runs.map(&:x).sort.first
-      @current_platform_is_rbx_19 = RUBY_DESCRIPTION =~ /\Arubinius 2.0.0/ &&
-                                      RUBY_VERSION >= "1.9.0"
+      @page_width  = (mediabox[2] - mediabox[0]).abs
+      @page_height = (mediabox[3] - mediabox[1]).abs
+      @x_offset = @runs.map(&:x).sort.first || 0
+      lowest_y = @runs.map(&:y).sort.first || 0
+      @y_offset = lowest_y > 0 ? 0 : lowest_y
     end
 
     def to_s
       return "" if @runs.empty?
+      return "" if row_count == 0
 
       page = row_count.times.map { |i| " " * col_count }
       @runs.each do |run|
         x_pos = ((run.x - @x_offset) / col_multiplier).round
-        y_pos = row_count - (run.y / row_multiplier).round
-        if y_pos < row_count && y_pos >= 0 && x_pos < col_count && x_pos >= 0
-          local_string_insert(page[y_pos], run.text, x_pos)
+        y_pos = row_count - ((run.y - @y_offset) / row_multiplier).round
+        if y_pos <= row_count && y_pos >= 0 && x_pos <= col_count && x_pos >= 0
+          local_string_insert(page[y_pos-1], run.text, x_pos)
         end
       end
       interesting_rows(page).map(&:rstrip).join("\n")
@@ -110,21 +118,8 @@ class PDF::Reader
       runs
     end
 
-    # This is a simple alternative to String#[]=. We can't use the string
-    # method as it's buggy on rubinius 2.0rc1 (in 1.9 mode)
-    #
-    # See my bug report at https://github.com/rubinius/rubinius/issues/1985
     def local_string_insert(haystack, needle, index)
-      if @current_platform_is_rbx_19
-        char_count = needle.length
-        haystack.replace(
-          (haystack[0,index] || "") +
-          needle +
-          (haystack[index+char_count,500] || "")
-        )
-      else
-        haystack[Range.new(index, index + needle.length - 1)] = String.new(needle)
-      end
+      haystack[Range.new(index, index + needle.length - 1)] = String.new(needle)
     end
   end
 end

data/lib/pdf/reader/page_state.rb

@@ -1,4 +1,5 @@
 # coding: utf-8
+# frozen_string_literal: true
 
 require 'pdf/reader/transformation_matrix'
 
@@ -29,7 +30,7 @@ class PDF::Reader
         @xobject_stack = [page.xobjects]
         @cs_stack      = [page.color_spaces]
         @stack         = [DEFAULT_GRAPHICS_STATE.dup]
-        state[:ctm]    = identity_matrix
+        state[:ctm]  = identity_matrix
       end
 
       #####################################################
@@ -321,11 +322,13 @@ class PDF::Reader
         th = state[:h_scaling]
         # optimise the common path to reduce Float allocations
         if th == 1 && tj == 0 && tc == 0 && tw == 0
-          glyph_width = w0 * fs
-          tx = glyph_width
+          tx = w0 * fs
+        elsif tj != 0
+          # don't apply spacing to TJ displacement
+          tx = (w0 - (tj/1000.0)) * fs * th
         else
-          glyph_width = ((w0 - (tj/1000.0)) * fs) * th
-          tx = glyph_width + ((tc + tw) * th)
+          # apply horizontal scaling to spacing values but not font size
+          tx = ((w0 * fs) + tc + tw) * th
         end
 
         # TODO: I'm pretty sure that tx shouldn't need to be divided by

data/lib/pdf/reader/page_text_receiver.rb

@@ -1,4 +1,5 @@
 # coding: utf-8
+# frozen_string_literal: true
 
 require 'forwardable'
 require 'pdf/reader/page_layout'
@@ -40,13 +41,17 @@ module PDF
       # starting a new page
       def page=(page)
         @state = PageState.new(page)
+        @page = page
         @content = []
         @characters = []
         @mediabox = page.objects.deref(page.attributes[:MediaBox])
+        device_bl = @state.ctm_transform(@mediabox[0], @mediabox[1])
+        device_tr = @state.ctm_transform(@mediabox[2], @mediabox[3])
+        @device_mediabox = [ device_bl.first, device_bl.last, device_tr.first, device_tr.last]
       end
 
       def content
-        PageLayout.new(@characters, @mediabox).to_s
+        PageLayout.new(@characters, @device_mediabox).to_s
       end
 
       #####################################################
@@ -100,6 +105,8 @@ module PDF
         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)
+
           utf8_chars = @state.current_font.to_utf8(glyph_code)
 
           # apply to glyph displacment for the current glyph so the next
@@ -114,6 +121,21 @@ module PDF
         end
       end
 
+      def apply_rotation(x, y)
+        if @page.rotate == 90
+          tmp = x
+          x = y
+          y = tmp * -1
+        elsif @page.rotate == 180
+          y *= -1
+        elsif @page.rotate == 270
+          tmp = x
+          x = y * -1
+          y = tmp * -1
+        end
+        return x, y
+      end
+
     end
   end
 end