pdf-reader 1.4.1 → 2.5.0

data/lib/pdf/reader/cmap.rb

@@ -1,4 +1,5 @@
 # coding: utf-8
+# frozen_string_literal: true
 
 ################################################################################
 #
@@ -31,6 +32,17 @@ class PDF::Reader
   # extracting various useful information.
   #
   class CMap # :nodoc:
+    CMAP_KEYWORDS = {
+      "begincodespacerange" => 1,
+      "endcodespacerange" => 1,
+      "beginbfchar" => 1,
+      "endbfchar" => 1,
+      "beginbfrange" => 1,
+      "endbfrange" => 1,
+      "begin" => 1,
+      "begincmap" => 1,
+      "def" => 1
+    }
 
     attr_reader :map
 
@@ -40,24 +52,25 @@ class PDF::Reader
     end
 
     def process_data(data)
+      parser = build_parser(data)
       mode = nil
-      instructions = ""
+      instructions = []
 
-      data.each_line do |l|
-        if l.include?("beginbfchar")
+      while token = parser.parse_token(CMAP_KEYWORDS)
+        if token == "beginbfchar"
           mode = :char
-        elsif l.include?("endbfchar")
+        elsif token == "endbfchar"
           process_bfchar_instructions(instructions)
-          instructions = ""
+          instructions = []
           mode = nil
-        elsif l.include?("beginbfrange")
+        elsif token == "beginbfrange"
           mode = :range
-        elsif l.include?("endbfrange")
+        elsif token == "endbfrange"
           process_bfrange_instructions(instructions)
-          instructions = ""
+          instructions = []
           mode = nil
         elsif mode == :char || mode == :range
-          instructions << l
+          instructions << token
         end
       end
     end
@@ -83,44 +96,46 @@ 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)
-      parser  = build_parser(instructions)
-      find    = str_to_int(parser.parse_token)
-      replace = str_to_int(parser.parse_token)
-      while find && replace
-        @map[find[0]] = replace
-        find       = str_to_int(parser.parse_token)
-        replace    = str_to_int(parser.parse_token)
+      instructions.each_slice(2) do |one, two|
+        find    = str_to_int(one)
+        replace = str_to_int(two)
+        @map[find.first] = replace
       end
     end
 
     def process_bfrange_instructions(instructions)
-      parser  = build_parser(instructions)
-      start   = parser.parse_token
-      finish  = parser.parse_token
-      to      = parser.parse_token
-      while start && finish && to
+      instructions.each_slice(3) do |start, finish, to|
         if start.kind_of?(String) && finish.kind_of?(String) && to.kind_of?(String)
           bfrange_type_one(start, finish, to)
         elsif start.kind_of?(String) && finish.kind_of?(String) && to.kind_of?(Array)
@@ -128,9 +143,6 @@ class PDF::Reader
         else
           raise "invalid bfrange section"
         end
-        start   = parser.parse_token
-        finish  = parser.parse_token
-        to      = parser.parse_token
       end
     end
 

data/lib/pdf/reader/encoding.rb

@@ -1,4 +1,5 @@
 # coding: utf-8
+# frozen_string_literal: true
 
 ################################################################################
 #
@@ -39,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:
@@ -147,7 +150,7 @@ class PDF::Reader
       ret = [
         @mapping[glyph_code.to_i] || glyph_code.to_i
       ].pack("U*")
-      ret.force_encoding("UTF-8") if ret.respond_to?(:force_encoding)
+      ret.force_encoding("UTF-8")
       ret
     end
 
@@ -158,13 +161,13 @@ class PDF::Reader
     def little_boxes(times)
       codepoints = [ PDF::Reader::Encoding::UNKNOWN_CHAR ] * times
       ret = codepoints.pack("U*")
-      ret.force_encoding("UTF-8") if ret.respond_to?(:force_encoding)
+      ret.force_encoding("UTF-8")
       ret
     end
 
     def convert_to_utf8(str)
       ret = str.unpack(unpack).map! { |c| @mapping[c] || c }.pack("U*")
-      ret.force_encoding("UTF-8") if ret.respond_to?(:force_encoding)
+      ret.force_encoding("UTF-8")
       ret
     end
 
@@ -198,17 +201,12 @@ class PDF::Reader
       end
     end
 
-    def has_mapping?
-      @mapping.size > 0
-    end
-
     def glyphlist
       @glyphlist ||= PDF::Reader::GlyphHash.new
     end
 
     def load_mapping(file)
-      RUBY_VERSION >= "1.9" ? mode = "r:BINARY" : mode = "r"
-      File.open(file, mode) do |f|
+      File.open(file, "r:BINARY") do |f|
         f.each do |l|
           _m, single_byte, unicode = *l.match(/([0-9A-Za-z]+);([0-9A-F]{4})/)
           @mapping["0x#{single_byte}".hex] = "0x#{unicode}".hex if single_byte

data/lib/pdf/reader/error.rb

@@ -1,4 +1,5 @@
 # coding: utf-8
+# frozen_string_literal: true
 
 ################################################################################
 #
@@ -52,6 +53,10 @@ class PDF::Reader
   # the PDF spec and cannot be recovered
   class MalformedPDFError < RuntimeError; end
 
+  ################################################################################
+  # an exception that is raised when an invalid page number is used
+  class InvalidPageError < ArgumentError; end
+
   ################################################################################
   # an exception that is raised when a PDF object appears to be invalid
   class InvalidObjectError < MalformedPDFError; end

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

@@ -1,4 +1,5 @@
 # coding: utf-8
+# frozen_string_literal: true
 
 require 'ascii85'
 

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

@@ -1,4 +1,6 @@
 # coding: utf-8
+# frozen_string_literal: true
+
 #
 class PDF::Reader
   module Filter # :nodoc:

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

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

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

@@ -1,4 +1,5 @@
 # coding: utf-8
+# frozen_string_literal: true
 
 
 require 'zlib'
@@ -7,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
@@ -14,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)
-        rescue Zlib::DataError => e
+          return Zlib::Inflate.new(ZLIB_AUTO_DETECT_ZLIB_OR_GZIP).inflate(data)
+        rescue Zlib::DataError
           # 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
+          # swallow this one too, so we can try some other fallback options
+        end
+
+        nil
       end
     end
   end

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

@@ -1,4 +1,6 @@
 # coding: utf-8
+# frozen_string_literal: true
+
 #
 class PDF::Reader
   module Filter # :nodoc:

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

@@ -1,4 +1,6 @@
 # coding: utf-8
+# frozen_string_literal: true
+
 #
 class PDF::Reader
   module Filter # :nodoc:

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

@@ -1,4 +1,6 @@
 # coding: utf-8
+# frozen_string_literal: true
+
 #
 class PDF::Reader # :nodoc:
   module Filter # :nodoc:
@@ -12,14 +14,10 @@ class PDF::Reader # :nodoc:
       # Decode the specified data with the RunLengthDecode compression algorithm
       def filter(data)
         pos = 0
-        out = ""
+        out = "".dup
 
         while pos < data.length
-          if data.respond_to?(:getbyte)
-            length = data.getbyte(pos)
-          else
-            length = data[pos]
-          end
+          length = data.getbyte(pos)
           pos += 1
 
           case

data/lib/pdf/reader/filter.rb

@@ -1,4 +1,5 @@
 # coding: utf-8
+# frozen_string_literal: true
 
 ################################################################################
 #
@@ -46,6 +47,7 @@ class PDF::Reader
       when :CCITTFaxDecode  then PDF::Reader::Filter::Null.new(options)
       when :DCTDecode       then PDF::Reader::Filter::Null.new(options)
       when :FlateDecode     then PDF::Reader::Filter::Flate.new(options)
+      when :Fl              then PDF::Reader::Filter::Flate.new(options)
       when :JBIG2Decode     then PDF::Reader::Filter::Null.new(options)
       when :JPXDecode       then PDF::Reader::Filter::Null.new(options)
       when :LZWDecode       then PDF::Reader::Filter::Lzw.new(options)

data/lib/pdf/reader/font.rb

@@ -1,4 +1,5 @@
 # coding: utf-8
+# frozen_string_literal: true
 
 ################################################################################
 #
@@ -36,11 +37,7 @@ class PDF::Reader
     attr_reader :widths, :first_char, :last_char, :basefont, :font_descriptor,
                 :cid_widths, :cid_default_width
 
-    def initialize(ohash = nil, obj = nil)
-      if ohash.nil? || obj.nil?
-        $stderr.puts "DEPREACTION WARNING - PDF::Reader::Font.new should be called with 2 args"
-        return
-      end
+    def initialize(ohash, obj)
       @ohash = ohash
       @tounicode = nil
 
@@ -52,12 +49,6 @@ class PDF::Reader
       @encoding ||= PDF::Reader::Encoding.new(:StandardEncoding)
     end
 
-    def basefont=(font)
-      $stderr.puts "Font#basefont= is deprecated and will be removed in the 2.0 release"
-      @encoding ||= default_encoding(font)
-      @basefont = font
-    end
-
     def to_utf8(params)
       if @tounicode
         to_utf8_via_cmap(params)
@@ -106,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
@@ -134,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/font_descriptor.rb

@@ -1,4 +1,5 @@
 # coding: utf-8
+# frozen_string_literal: true
 
 require 'ttfunk'
 

data/lib/pdf/reader/form_xobject.rb

@@ -1,4 +1,5 @@
 # coding: utf-8
+# frozen_string_literal: true
 
 require 'digest/md5'
 

data/lib/pdf/reader/glyph_hash.rb

@@ -1,4 +1,5 @@
 # coding: utf-8
+# frozen_string_literal: true
 
 ################################################################################
 #
@@ -48,6 +49,9 @@ class PDF::Reader
     #   h.name_to_unicode(:Euro)
     #   => 8364
     #
+    #   h.name_to_unicode(:X4A)
+    #   => 74
+    #
     #   h.name_to_unicode(:G30)
     #   => 48
     #
@@ -62,6 +66,8 @@ class PDF::Reader
 
       if @by_name.has_key?(name)
         @by_name[name]
+      elsif str.match(/\AX[0-9a-fA-F]{2,4}\Z/)
+        "0x#{str[1,4]}".hex
       elsif str.match(/\Auni[A-F\d]{4}\Z/)
         "0x#{str[3,4]}".hex
       elsif str.match(/\Au[A-F\d]{4,6}\Z/)
@@ -102,8 +108,7 @@ class PDF::Reader
       keyed_by_name      = {}
       keyed_by_codepoint = {}
 
-      RUBY_VERSION >= "1.9" ? mode = "r:BINARY" : mode = "r"
-      File.open(File.dirname(__FILE__) + "/glyphlist.txt", mode) do |f|
+      File.open(File.dirname(__FILE__) + "/glyphlist.txt", "r:BINARY") do |f|
         f.each do |l|
           _m, name, code = *l.match(/([0-9A-Za-z]+);([0-9A-F]{4})/)
           if name && code

data/lib/pdf/reader/lzw.rb

@@ -1,4 +1,5 @@
 # coding: utf-8
+# frozen_string_literal: true
 
 module PDF
 
@@ -22,7 +23,7 @@ module PDF
 
         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
@@ -82,7 +83,7 @@ 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)
@@ -116,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,4 +1,5 @@
 # coding: utf-8
+# frozen_string_literal: true
 
 require 'hashery/lru_hash'