pdf-reader 1.2.0 → 1.3.0

data/lib/pdf/reader/pages_strategy.rb

@@ -1,3 +1,5 @@
+# coding: utf-8
+
 ################################################################################
 #
 # Copyright (C) 2006 Peter J Jones (pjones@pmade.com)
@@ -56,9 +58,10 @@ class PDF::Reader
   # == Text Callbacks
   #
   # All text passed into these callbacks will be encoded as UTF-8. Depending on where (and when) the
-  # PDF was generated, there's a good chance the text is NOT stored as UTF-8 internally so be careful
-  # when doing a comparison on strings returned from PDF::Reader (when doing unit tests for example). The
-  # string may not be byte-by-byte identical with the string that was originally written to the PDF.
+  # PDF was generated, there's a good chance the text is NOT stored as UTF-8 internally so be
+  # careful when doing a comparison on strings returned from PDF::Reader (when doing unit tests for
+  # example). The string may not be byte-by-byte identical with the string that was originally
+  # written to the PDF.
   #
   # - end_text_object
   # - move_to_start_of_next_line
@@ -267,6 +270,16 @@ class PDF::Reader
     end
     private
     ################################################################################
+    def params_to_utf8(params, font)
+      if params.is_a?(String)
+        font.to_utf8(params)
+      elsif params.is_a?(Array)
+        params.map { |i| params_to_utf8(i, font)}
+      else
+        params
+      end
+    end
+    ################################################################################
     # Walk over all pages in the PDF file, calling the appropriate callbacks for each page and all
     # its content
     def walk_pages (page)
@@ -363,7 +376,7 @@ class PDF::Reader
             if options[:raw_text]
               callback("#{OPERATORS[token]}_raw".to_sym, params)
             end
-            params = fonts[current_font].to_utf8(params)
+            params = params_to_utf8(params, fonts[current_font])
           elsif token == "ID"
             # inline image data, first convert the current params into a more familiar hash
             map = {}

data/lib/pdf/reader/parser.rb

@@ -1,3 +1,5 @@
+# coding: utf-8
+
 ################################################################################
 #
 # Copyright (C) 2006 Peter J Jones (pjones@pmade.com)
@@ -74,8 +76,6 @@ class PDF::Reader
         STRATEGIES[token].call(self, token)
       elsif token.is_a? PDF::Reader::Reference
         token
-      elsif token.is_a? Token
-        token
       elsif operators.has_key? token
         Token.new(token)
       elsif token.respond_to?(:to_token)
@@ -100,6 +100,7 @@ class PDF::Reader
 
       obj = parse_token
       post_obj = parse_token
+
       if post_obj == "stream"
         stream(obj)
       else
@@ -171,58 +172,30 @@ class PDF::Reader
       return "" if str == ")"
       Error.assert_equal(parse_token, ")")
 
-      ret = ""
-      idx = 0
-
-      while idx < str.size
-        chr = str[idx,1]
-        jump = 1
-
-        if chr == "\\"
-          jump = 2
-          case str[idx+1, 1]
-          when "" then jump = 1
-          when "n"  then chr = "\n"
-          when "r"  then chr = "\r"
-          when "t"  then chr = "\t"
-          when "b"  then chr = "\b"
-          when "f"  then chr = "\f"
-          when "("  then chr = "("
-          when ")"  then chr = ")"
-          when "\\" then chr = "\\"
-          when "\n" then
-            chr = ""
-            jump = 2
-          else
-            if str[idx+1,3].match(/\d{3}/)
-              jump = 4
-              chr = str[idx+1,3].oct.chr
-            elsif str[idx+1,2].match(/\d{2}/)
-              jump = 3
-              chr = ("0"+str[idx+1,2]).oct.chr
-            elsif str[idx+1,1].match(/\d/)
-              jump = 2
-              chr = ("00"+str[idx+1,1]).oct.chr
-            else
-              jump = 1
-              chr = ""
-            end
-
-          end
-        elsif chr == "\r" && str[idx+1,1] == "\n"
-          chr = "\n"
-          jump = 2
-        elsif chr == "\n" && str[idx+1,1] == "\r"
-          chr = "\n"
-          jump = 2
-        elsif chr == "\r"
-          chr = "\n"
-        end
-        ret << chr
-        idx += jump
+      str.gsub!(/\\([nrtbf()\\\n]|\d{1,3})?|\r\n?|\n\r/m) do |match|
+        MAPPING[match] || ""
       end
-      ret
+      str
     end
+
+    MAPPING = {
+      "\r"   => "\n",
+      "\n\r" => "\n",
+      "\r\n" => "\n",
+      "\\n"  => "\n",
+      "\\r"  => "\r",
+      "\\t"  => "\t",
+      "\\b"  => "\b",
+      "\\f"  => "\f",
+      "\\("  => "(",
+      "\\)"  => ")",
+      "\\\\" => "\\",
+      "\\\n" => "",
+    }
+    0.upto(9)   { |n| MAPPING["\\00"+n.to_s] = ("00"+n.to_s).oct.chr }
+    0.upto(99)  { |n| MAPPING["\\0"+n.to_s]  = ("0"+n.to_s).oct.chr }
+    0.upto(377) { |n| MAPPING["\\"+n.to_s]   = n.to_s.oct.chr }
+
     ################################################################################
     # Decodes the contents of a PDF Stream and returns it as a Ruby String.
     def stream (dict)

data/lib/pdf/reader/print_receiver.rb

@@ -1,4 +1,9 @@
+# coding: utf-8
+
 class PDF::Reader
+  # A simple receiver that prints all operaters and parameters in the content
+  # stream of a single page.
+  #
   class PrintReceiver
 
     attr_accessor :callbacks

data/lib/pdf/reader/reference.rb

@@ -1,3 +1,5 @@
+# coding: utf-8
+
 ################################################################################
 #
 # Copyright (C) 2006 Peter J Jones (pjones@pmade.com)

data/lib/pdf/reader/register_receiver.rb

@@ -85,7 +85,7 @@ class PDF::Reader
         match = idx and break if count == 0
       end
 
-      if match 
+      if match
         return callbacks[match, methods.size]
       else
         return nil

data/lib/pdf/reader/standard_security_handler.rb

@@ -1,3 +1,5 @@
+# coding: utf-8
+
 ################################################################################
 #
 # Copyright (C) 2011 Evan J Brunner (ejbrun@appittome.com)

data/lib/pdf/reader/stream.rb

@@ -1,3 +1,5 @@
+# coding: utf-8
+
 ################################################################################
 #
 # Copyright (C) 2006 Peter J Jones (pjones@pmade.com)

data/lib/pdf/reader/synchronized_cache.rb

@@ -0,0 +1,32 @@
+# encoding: utf-8
+
+# utilities.rb : General-purpose utility classes which don't fit anywhere else
+#
+# Copyright August 2012, Alex Dowad. All Rights Reserved.
+#
+# This is free software. Please see the LICENSE and COPYING files for details.
+#
+# This was originally written for the prawn gem.
+
+require 'thread'
+
+class PDF::Reader
+
+  # Throughout the pdf-reader codebase, repeated calculations which can benefit
+  # from caching are made In some cases, caching and reusing results can not
+  # only save CPU cycles but also greatly reduce memory requirements But at the
+  # same time, we don't want to throw away thread safety We have two
+  # interchangeable thread-safe cache implementations:
+  class SynchronizedCache
+    def initialize
+      @cache = {}
+      @mutex = Mutex.new
+    end
+    def [](key)
+      @mutex.synchronize { @cache[key] }
+    end
+    def []=(key,value)
+      @mutex.synchronize { @cache[key] = value }
+    end
+  end
+end

data/lib/pdf/reader/text_receiver.rb

@@ -1,3 +1,5 @@
+# coding: utf-8
+
 ################################################################################
 #
 # Copyright (C) 2006 Peter J Jones (pjones@pmade.com)
@@ -9,10 +11,10 @@
 # distribute, sublicense, and/or sell copies of the Software, and to
 # permit persons to whom the Software is furnished to do so, subject to
 # the following conditions:
-# 
+#
 # The above copyright notice and this permission notice shall be
 # included in all copies or substantial portions of the Software.
-# 
+#
 # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 # EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 # MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
@@ -161,7 +163,7 @@ class PDF::Reader
 
       x = (@tm[2,0]/TS_UNITS_PER_H_CHAR).to_i
       y = (ury - (@tm[2,1]/TS_UNITS_PER_V_CHAR)).to_i
-      
+
       #puts "rendering '#{string}' to #{x}x#{y}"
 
       place = (@output[y] ||= (" " * urx.to_i))
@@ -255,7 +257,6 @@ class PDF::Reader
       @smallest_y_loc = key if key < @smallest_y_loc
       @location = key
       @line = @displacement[key]
-      #puts "calculate_line_and_location: @location=#@location @line=#@line smallest_y_loc=#@smallest_y_loc"
     end
     ################################################################################
   end

data/lib/pdf/reader/text_run.rb

@@ -0,0 +1,80 @@
+# coding: utf-8
+
+class PDF::Reader
+  # A value object that represents one or more consecutive characters on a page.
+  class TextRun
+    include Comparable
+
+    attr_reader :x, :y, :width, :font_size, :text
+
+    alias :to_s :text
+
+    def initialize(x, y, width, font_size, text)
+      @x = x
+      @y = y
+      @width = width
+      @font_size = font_size.floor
+      @text = text
+    end
+
+    # Allows collections of TextRun objects to be sorted. They will be sorted
+    # in order of their position on a cartesian plain - Top Left to Bottom Right
+    def <=>(other)
+      if x == other.x && y == other.y
+        0
+      elsif y < other.y
+        1
+      elsif y > other.y
+        -1
+      elsif x < other.x
+        -1
+      elsif x > other.x
+        1
+      end
+    end
+
+    def endx
+      @endx ||= x + width
+    end
+
+    def mean_character_width
+      @width / character_count
+    end
+
+    def mergable?(other)
+      y.to_i == other.y.to_i && font_size == other.font_size && mergable_range.include?(other.x)
+    end
+
+    def +(other)
+      raise ArgumentError, "#{other} cannot be merged with this run" unless mergable?(other)
+
+      if (other.x - endx) <( font_size * 0.2)
+        TextRun.new(x, y, other.endx - x, font_size, text + other.text)
+      else
+        TextRun.new(x, y, other.endx - x, font_size, "#{text} #{other.text}")
+      end
+    end
+
+    def inspect
+      "#{text} w:#{width} f:#{font_size} @#{x},#{y}"
+    end
+
+    private
+
+    def mergable_range
+      @mergable_range ||= Range.new(endx - 3, endx + font_size)
+    end
+
+    def character_count
+      if @text.size == 1
+        1.0
+      elsif @text.respond_to?(:bytesize)
+        # M17N aware VM
+        # so we can trust String#size to return a character count
+        @text.size.to_f
+      else
+        text.unpack("U*").size.to_f
+      end
+    end
+  end
+end

data/lib/pdf/reader/token.rb

@@ -1,3 +1,5 @@
+# coding: utf-8
+
 ################################################################################
 #
 # Copyright (C) 2006 Peter J Jones (pjones@pmade.com)

data/lib/pdf/reader/transformation_matrix.rb

@@ -0,0 +1,194 @@
+# coding: utf-8
+
+class PDF::Reader
+  # co-ordinate systems in PDF files are specified using a 3x3 matrix that looks
+  # something like this:
+  #
+  #   [ a b 0 ]
+  #   [ c d 0 ]
+  #   [ e f 1 ]
+  #
+  # Because the final column never changes, we can represent each matrix using
+  # only 6 numbers. This is important to save CPU time, memory and GC pressure
+  # caused by allocating too many unnecessary objects.
+  class TransformationMatrix
+    attr_reader :a, :b, :c, :d, :e, :f
+
+    def initialize(a, b, c, d, e, f)
+      @a, @b, @c, @d, @e, @f = a, b, c, d, e, f
+    end
+
+    def inspect
+      "#{a}, #{b}, 0,\n#{c}, #{d}, #{0},\n#{e}, #{f}, 1"
+    end
+
+    def to_a
+      [@a,@b,0,
+       @c,@d,0,
+       @e,@f,1]
+    end
+
+    # multiply this matrix with another.
+    #
+    # the second matrix is represented by the 6 scalar values that are changeable
+    # in a PDF transformation matrix.
+    #
+    # WARNING: This mutates the current matrix to avoid allocating memory when
+    #          we don't need too. Matrices are multiplied ALL THE FREAKING TIME
+    #          so this is a worthwhile optimisation
+    #
+    # NOTE: When multiplying matrices, ordering matters. Double check
+    #       the PDF spec to ensure you're multiplying things correctly.
+    #
+    # NOTE: see Section 8.3.3, PDF 32000-1:2008, pp 119
+    #
+    # NOTE: The if statements in this method are ordered to prefer optimisations
+    #       that allocate fewer objects
+    #
+    # TODO: it might be worth adding an optimised path for vertical
+    #       displacement to speed up processing documents that use vertical
+    #       writing systems
+    #
+    def multiply!(a,b=nil,c=nil, d=nil,e=nil,f=nil)
+      if a == 1 && b == 0 && c == 0 && d == 1 && e == 0 && f == 0
+        # the identity matrix, no effect
+        self
+      elsif @a == 1 && @b == 0 && @c == 0 && @d == 1 && @e == 0 && @f == 0
+        # I'm the identity matrix, so just copy values across
+        @a = a
+        @b = b
+        @c = c
+        @d = d
+        @e = e
+        @f = f
+      elsif a == 1 && b == 0 && c == 0 && d == 1 && f == 0
+        # the other matrix is a horizontal displacement
+        horizontal_displacement_multiply!(e)
+      elsif @a == 1 && @b == 0 && @c == 0 && @d == 1 && @f == 0
+        # I'm a horizontal displacement
+        horizontal_displacement_multiply_reversed!(a,b,c,d,e,f)
+      elsif @a != 1 && @b == 0 && @c == 0 && @d != 1 && @e == 0 && @f == 0
+        # I'm a xy scale
+        xy_scaling_multiply_reversed!(a,b,c,d,e,f)
+      elsif a != 1 && b == 0 && c == 0 && d != 1 && e == 0 && f == 0
+        # the other matrix is an xy scale
+        xy_scaling_multiply!(a,b,c,d,e,f)
+      else
+        faster_multiply!(a,b,c, d,e,f)
+      end
+      self
+    end
+
+    # Optimised method for when the second matrix in the calculation is
+    # a simple horizontal displacement.
+    #
+    # Like this:
+    #
+    #   [ 1 2 0 ]   [ 1  0 0 ]
+    #   [ 3 4 0 ] x [ 0  1 0 ]
+    #   [ 5 6 1 ]   [ e2 0 1 ]
+    #
+    def horizontal_displacement_multiply!(e2)
+      @e = @e + e2
+    end
+
+    private
+
+    # Optimised method for when the first matrix in the calculation is
+    # a simple horizontal displacement.
+    #
+    # Like this:
+    #
+    #   [ 1 0 0 ]   [ 1 2 0 ]
+    #   [ 0 1 0 ] x [ 3 4 0 ]
+    #   [ 5 0 1 ]   [ 5 6 1 ]
+    #
+    def horizontal_displacement_multiply_reversed!(a2,b2,c2,d2,e2,f2)
+      newa = a2
+      newb = b2
+      newc = c2
+      newd = d2
+      newe = (@e * a2) + e2
+      newf = (@e * b2) + f2
+      @a, @b, @c, @d, @e, @f = newa, newb, newc, newd, newe, newf
+    end
+
+    # Optimised method for when the second matrix in the calculation is
+    # an X and Y scale
+    #
+    # Like this:
+    #
+    #   [ 1 2 0 ]   [ 5 0 0 ]
+    #   [ 3 4 0 ] x [ 0 5 0 ]
+    #   [ 5 6 1 ]   [ 0 0 1 ]
+    #
+    def xy_scaling_multiply!(a2,b2,c2,d2,e2,f2)
+      newa = @a * a2
+      newb = @b * d2
+      newc = @c * a2
+      newd = @d * d2
+      newe = @e * a2
+      newf = @f * d2
+      @a, @b, @c, @d, @e, @f = newa, newb, newc, newd, newe, newf
+    end
+
+    # Optimised method for when the first matrix in the calculation is
+    # an X and Y scale
+    #
+    # Like this:
+    #
+    #   [ 5 0 0 ]   [ 1 2 0 ]
+    #   [ 0 5 0 ] x [ 3 4 0 ]
+    #   [ 0 0 1 ]   [ 5 6 1 ]
+    #
+    def xy_scaling_multiply_reversed!(a2,b2,c2,d2,e2,f2)
+      newa = @a * a2
+      newb = @a * b2
+      newc = @d * c2
+      newd = @d * d2
+      newe = e2
+      newf = f2
+      @a, @b, @c, @d, @e, @f = newa, newb, newc, newd, newe, newf
+    end
+
+    # A general solution to multiplying two 3x3 matrixes. This is correct in all cases,
+    # but slower due to excessive object allocations. It's not actually used in any
+    # active code paths, but is here for reference. Use faster_multiply instead.
+    #
+    # Like this:
+    #
+    #   [ a b 0 ]   [ a b 0 ]
+    #   [ c d 0 ] x [ c d 0 ]
+    #   [ e f 1 ]   [ e f 1 ]
+    #
+    def regular_multiply!(a2,b2,c2,d2,e2,f2)
+      newa = (@a * a2) + (@b * c2) + (0 * e2)
+      newb = (@a * b2) + (@b * d2) + (0 * f2)
+      newc = (@c * a2) + (@d * c2) + (0 * e2)
+      newd = (@c * b2) + (@d * d2) + (0 * f2)
+      newe = (@e * a2) + (@f * c2) + (1 * e2)
+      newf = (@e * b2) + (@f * d2) + (1 * f2)
+      @a, @b, @c, @d, @e, @f = newa, newb, newc, newd, newe, newf
+    end
+
+    # A general solution for multiplying two matrices when we know all values
+    # in the final column are fixed. This is the fallback method for when none
+    # of the optimised methods are applicable.
+    #
+    # Like this:
+    #
+    #   [ a b 0 ]   [ a b 0 ]
+    #   [ c d 0 ] x [ c d 0 ]
+    #   [ e f 1 ]   [ e f 1 ]
+    #
+    def faster_multiply!(a2,b2,c2, d2,e2,f2)
+      newa = (@a * a2) + (@b * c2)
+      newb = (@a * b2) + (@b * d2)
+      newc = (@c * a2) + (@d * c2)
+      newd = (@c * b2) + (@d * d2)
+      newe = (@e * a2) + (@f * c2) + e2
+      newf = (@e * b2) + (@f * d2) + f2
+      @a, @b, @c, @d, @e, @f = newa, newb, newc, newd, newe, newf
+    end
+  end
+end