pdf-reader 2.2.0 → 2.4.2

data/lib/pdf/reader/cmap.rb

@@ -96,25 +96,34 @@ class PDF::Reader
       Parser.new(buffer)
     end
 
+    # The following includes some manual decoding of UTF-16BE strings into unicode codepoints. In
+    # theory we could replace all the UTF-16 code with something based on Ruby's encoding support:
+    #
+    #    str.dup.force_encoding("utf-16be").encode!("utf-8").unpack("U*")
+    #
+    # However, some cmaps contain broken surrogate pairs and the ruby encoding support raises an
+    # exception when we try converting broken UTF-16 to UTF-8
+    #
     def str_to_int(str)
       return nil if str.nil? || str.size == 0
-      unpacked_string = if str.size == 1 # UTF-8
+      unpacked_string = if str.bytesize == 1 # UTF-8
         str.unpack("C*")
       else # UTF-16
          str.unpack("n*")
       end
-      if unpacked_string.size == 1
-        unpacked_string
-      elsif unpacked_string.size == 2 && unpacked_string[0] > 0xD800 && unpacked_string[0] < 0xDBFF
-        # this is a Unicode UTF-16 "Surrogate Pair" see Unicode Spec. Chapter 3.7
-        # lets convert to a UTF-32. (the high bit is between 0xD800-0xDBFF, the
-        # low bit is between 0xDC00-0xDFFF) for example: U+1D44E (U+D835 U+DC4E)
-        [(unpacked_string[0] - 0xD800) * 0x400 + (unpacked_string[1] - 0xDC00) + 0x10000]
-      else
-        # it is a bad idea to just return the first 16 bits, as this doesn't allow
-        # for ligatures for example fi (U+0066 U+0069)
-        unpacked_string
+      result = []
+      while unpacked_string.any? do
+        if unpacked_string.size >= 2 && unpacked_string[0] > 0xD800 && unpacked_string[0] < 0xDBFF
+          # this is a Unicode UTF-16 "Surrogate Pair" see Unicode Spec. Chapter 3.7
+          # lets convert to a UTF-32. (the high bit is between 0xD800-0xDBFF, the
+          # low bit is between 0xDC00-0xDFFF) for example: U+1D44E (U+D835 U+DC4E)
+          points = [unpacked_string.shift, unpacked_string.shift]
+          result << (points[0] - 0xD800) * 0x400 + (points[1] - 0xDC00) + 0x10000
+        else
+          result << unpacked_string.shift
+        end
       end
+      result
     end
 
     def process_bfchar_instructions(instructions)

data/lib/pdf/reader/encoding.rb

@@ -40,20 +40,22 @@ class PDF::Reader
       @mapping  = default_mapping # maps from character codes to Unicode codepoints
       @string_cache  = {} # maps from character codes to UTF-8 strings.
 
-      if enc.kind_of?(Hash)
-        self.differences = enc[:Differences] if enc[:Differences]
-        enc = enc[:Encoding] || enc[:BaseEncoding]
-      elsif enc != nil
-        enc = enc.to_sym
+      @enc_name = if enc.kind_of?(Hash)
+        enc[:Encoding] || enc[:BaseEncoding]
+      elsif enc && enc.respond_to?(:to_sym)
+        enc.to_sym
       else
-        enc = nil
+        :StandardEncoding
       end
 
-      @enc_name = enc
-      @unpack   = get_unpack(enc)
-      @map_file = get_mapping_file(enc)
+      @unpack   = get_unpack(@enc_name)
+      @map_file = get_mapping_file(@enc_name)
 
       load_mapping(@map_file) if @map_file
+
+      if enc.is_a?(Hash) && enc[:Differences]
+        self.differences = enc[:Differences]
+      end
     end
 
     # set the differences table for this encoding. should be an array in the following format:

data/lib/pdf/reader/filter/flate.rb

@@ -8,6 +8,9 @@ class PDF::Reader
   module Filter # :nodoc:
     # implementation of the Flate (zlib) stream filter
     class Flate
+      ZLIB_AUTO_DETECT_ZLIB_OR_GZIP = 47  # Zlib::MAX_WBITS + 32
+      ZLIB_RAW_DEFLATE              = -15 # Zlib::MAX_WBITS * -1
+
       def initialize(options = {})
         @options = options
       end
@@ -15,25 +18,34 @@ class PDF::Reader
       ################################################################################
       # Decode the specified data with the Zlib compression algorithm
       def filter(data)
-        deflated = nil
+        deflated = zlib_inflate(data) || zlib_inflate(data[0, data.bytesize-1])
+
+        if deflated.nil?
+          raise MalformedPDFError,
+            "Error while inflating a compressed stream (no suitable inflation algorithm found)"
+        end
+        Depredict.new(@options).filter(deflated)
+      end
+
+      private
+
+      def zlib_inflate(data)
         begin
-          deflated = Zlib::Inflate.new.inflate(data)
+          return Zlib::Inflate.new(ZLIB_AUTO_DETECT_ZLIB_OR_GZIP).inflate(data)
         rescue Zlib::DataError => e
           # by default, Ruby's Zlib assumes the data it's inflating
-          # is RFC1951 deflated data, wrapped in a RFC1951 zlib container.
-          # If that fails, then use an undocumented 'feature' to attempt to inflate
-          # the data as a raw RFC1951 stream.
-          #
-          # See
-          # - http://blade.nagaokaut.ac.jp/cgi-bin/scat.rb/ruby/ruby-talk/243545
-          # - http://www.gzip.org/zlib/zlib_faq.html#faq38
-          deflated = Zlib::Inflate.new(-Zlib::MAX_WBITS).inflate(data)
+          # is RFC1951 deflated data, wrapped in a RFC1950 zlib container. If that
+          # fails, swallow the exception and attempt to inflate the data as a raw
+          # RFC1951 stream.
         end
-        Depredict.new(@options).filter(deflated)
-      rescue Exception => e
-        # Oops, there was a problem inflating the stream
-        raise MalformedPDFError,
-          "Error occured while inflating a compressed stream (#{e.class.to_s}: #{e.to_s})"
+
+        begin
+          return Zlib::Inflate.new(ZLIB_RAW_DEFLATE).inflate(data)
+        rescue StandardError => e
+          # swallow this one too, so we can try some other fallback options
+        end
+
+        nil
       end
     end
   end

data/lib/pdf/reader/font.rb

@@ -97,7 +97,13 @@ class PDF::Reader
       elsif @subtype == :Type3
         PDF::Reader::WidthCalculator::TypeOneOrThree.new(self)
       elsif @subtype == :TrueType
-        PDF::Reader::WidthCalculator::TrueType.new(self)
+        if @font_descriptor
+          PDF::Reader::WidthCalculator::TrueType.new(self)
+        else
+          # A TrueType font that isn't embedded. Most readers look for a version on the
+          # local system and fallback to a substitute. For now, we go straight to a substitute
+          PDF::Reader::WidthCalculator::BuiltIn.new(self)
+        end
       elsif @subtype == :CIDFontType0 || @subtype == :CIDFontType2
         PDF::Reader::WidthCalculator::Composite.new(self)
       else
@@ -125,7 +131,9 @@ class PDF::Reader
       if obj[:ToUnicode]
         # ToUnicode is optional for Type1 and Type3
         stream = @ohash.object(obj[:ToUnicode])
-        @tounicode = PDF::Reader::CMap.new(stream.unfiltered_data)
+        if stream.is_a?(PDF::Reader::Stream)
+          @tounicode = PDF::Reader::CMap.new(stream.unfiltered_data)
+        end
       end
     end
 

data/lib/pdf/reader/object_hash.rb

@@ -78,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
@@ -254,6 +245,26 @@ 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]
+        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.

data/lib/pdf/reader/orientation_detector.rb

@@ -22,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

@@ -124,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,6 +1,8 @@
 # coding: utf-8
 # frozen_string_literal: true
 
+require 'pdf/reader/overlapping_runs_filter'
+
 class PDF::Reader
 
   # Takes a collection of TextRun objects and renders them into a single
@@ -15,13 +17,15 @@ class PDF::Reader
     def initialize(runs, mediabox)
       raise ArgumentError, "a mediabox must be provided" if mediabox.nil?
 
-      @runs    = merge_runs(runs)
+      @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
+      @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
@@ -30,7 +34,7 @@ class PDF::Reader
       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
+        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

data/lib/pdf/reader/page_state.rb

@@ -30,7 +30,15 @@ class PDF::Reader
         @xobject_stack = [page.xobjects]
         @cs_stack      = [page.color_spaces]
         @stack         = [DEFAULT_GRAPHICS_STATE.dup]
-        state[:ctm]    = identity_matrix
+        if page.rotate == 0
+          state[:ctm]  = identity_matrix
+        else
+          rotate_cos = Math.cos(page.rotate * (Math::PI/180.0)).round(2)
+          rotate_sin = Math.sin(page.rotate * (Math::PI/180.0)).round(2)
+          state[:ctm] = TransformationMatrix.new(rotate_cos, rotate_sin,
+                                                 rotate_sin * -1, rotate_cos,
+                                                 0, 0)
+        end
       end
 
       #####################################################

data/lib/pdf/reader/page_text_receiver.rb

@@ -44,10 +44,13 @@ module PDF
         @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
 
       #####################################################

data/lib/pdf/reader/text_run.rb

@@ -38,6 +38,10 @@ class PDF::Reader
       @endx ||= x + width
     end
 
+    def endy
+      @endy ||= y + font_size
+    end
+
     def mean_character_width
       @width / character_count
     end
@@ -60,8 +64,28 @@ class PDF::Reader
       "#{text} w:#{width} f:#{font_size} @#{x},#{y}"
     end
 
+    def intersect?(other_run)
+      x <= other_run.endx && endx >= other_run.x &&
+        endy >= other_run.y && y <= other_run.endy
+    end
+
+    # return what percentage of this text run is overlapped by another run
+    def intersection_area_percent(other_run)
+      return 0 unless intersect?(other_run)
+
+      dx = [endx, other_run.endx].min - [x, other_run.x].max
+      dy = [endy, other_run.endy].min - [y, other_run.y].max
+      intersection_area = dx*dy
+
+      intersection_area.to_f / area
+    end
+
     private
 
+    def area
+      (endx - x) * (endy - y)
+    end
+
     def mergable_range
       @mergable_range ||= Range.new(endx - 3, endx + font_size)
     end

data/lib/pdf/reader/width_calculator/built_in.rb

@@ -12,11 +12,20 @@ class PDF::Reader
     # see Section 9.6.2.2, PDF 32000-1:2008, pp 256
     class BuiltIn
 
+      BUILTINS = [
+        :Courier, :"Courier-Bold", :"Courier-BoldOblique", :"Courier-Oblique",
+        :Helvetica, :"Helvetica-Bold", :"Helvetica-BoldOblique", :"Helvetica-Oblique",
+        :Symbol,
+        :"Times-Roman", :"Times-Bold", :"Times-BoldItalic", :"Times-Italic",
+        :ZapfDingbats
+      ]
+
       def initialize(font)
         @font = font
         @@all_metrics ||= PDF::Reader::SynchronizedCache.new
 
-        metrics_path = File.join(File.dirname(__FILE__), "..","afm","#{font.basefont}.afm")
+        basefont = extract_basefont(font.basefont)
+        metrics_path = File.join(File.dirname(__FILE__), "..","afm","#{basefont}.afm")
 
         if File.file?(metrics_path)
           @metrics = @@all_metrics[metrics_path] ||= AFM::Font.new(metrics_path)
@@ -54,6 +63,13 @@ class PDF::Reader
         @font.encoding.int_to_name(code_point).first.to_s[/\Acontrol..\Z/]
       end
 
+      def extract_basefont(font_name)
+        if BUILTINS.include?(font_name)
+          font_name
+        else
+          "Times-Roman"
+        end
+      end
     end
   end
 end