pdf-reader 1.1.1 → 2.5.0

data/lib/pdf/reader/cid_widths.rb

@@ -0,0 +1,63 @@
+# coding: utf-8
+# frozen_string_literal: true
+
+#
+
+require 'forwardable'
+
+class PDF::Reader
+  # A Hash-like object that wraps the array of glyph widths in a CID font
+  # and gives us a nice way to query it for specific widths.
+  #
+  # there are two ways to calculate a cidfont_glyph_width, that are defined
+  # in Section 9.7.4.3 PDF 32000-1:2008 pp 271, the differences are remarked
+  # on below. because of these difference that may be contained within the
+  # same array, it is a bit difficult to parse this array.
+  class CidWidths
+    extend Forwardable
+
+    # Graphics State Operators
+    def_delegators :@widths, :[], :fetch
+
+    def initialize(default, array)
+      @widths = parse_array(default, array.dup)
+    end
+
+    private
+
+    def parse_array(default, array)
+      widths  = Hash.new(default)
+      params = []
+      while array.size > 0
+        params << array.shift
+
+        if params.size == 2 && params.last.is_a?(Array)
+          widths.merge! parse_first_form(params.first, params.last)
+          params = []
+        elsif params.size == 3
+          widths.merge! parse_second_form(params[0], params[1], params[2])
+          params = []
+        end
+      end
+      widths
+    end
+
+    # this is the form 10 [234 63 234 346 47 234] where width of index 10 is
+    # 234, index 11 is 63, etc
+    def parse_first_form(first, widths)
+      widths.inject({}) { |accum, glyph_width|
+        accum[first + accum.size] = glyph_width
+        accum
+      }
+    end
+
+    # this is the form 10 20 123 where all index between 10 and 20 have width 123
+    def parse_second_form(first, final, width)
+      (first..final).inject({}) { |accum, index|
+        accum[index] = width
+        accum
+      }
+    end
+
+  end
+end

data/lib/pdf/reader/cmap.rb

@@ -1,3 +1,6 @@
+# coding: utf-8
+# frozen_string_literal: true
+
 ################################################################################
 #
 # Copyright (C) 2008 James Healy (jimmy@deefa.com)
@@ -24,7 +27,22 @@
 ################################################################################
 
 class PDF::Reader
+
+  # wraps a string containing a PDF CMap and provides convenience methods for
+  # 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
 
@@ -34,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
@@ -60,9 +79,13 @@ class PDF::Reader
       @map.size
     end
 
+    # Convert a glyph code into one or more Codepoints.
+    #
+    # Returns an array of Integers.
+    #
     def decode(c)
       # TODO: implement the conversion
-      return c unless c.class == Fixnum
+      return c unless Integer === c
       @map[c]
     end
 
@@ -73,33 +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 || str.size >= 3
-
-      if str.size == 1
-        str.unpack("C*")[0]
-      else
-        str.unpack("n*")[0]
+      return nil if str.nil? || str.size == 0
+      unpacked_string = if str.bytesize == 1 # UTF-8
+        str.unpack("C*")
+      else # UTF-16
+         str.unpack("n*")
+      end
+      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] = 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)
@@ -107,28 +143,23 @@ class PDF::Reader
         else
           raise "invalid bfrange section"
         end
-        start   = parser.parse_token
-        finish  = parser.parse_token
-        to      = parser.parse_token
       end
     end
 
     def bfrange_type_one(start_code, end_code, dst)
-      start_code = str_to_int(start_code)
-      end_code   = str_to_int(end_code)
+      start_code = str_to_int(start_code)[0]
+      end_code   = str_to_int(end_code)[0]
       dst        = str_to_int(dst)
 
       # add all values in the range to our mapping
       (start_code..end_code).each_with_index do |val, idx|
-        @map[val] = dst + idx
-        # ensure a single range does not exceed 255 chars
-        raise PDF::Reader::MalformedPDFError, "a CMap bfrange cann't exceed 255 chars" if idx > 255
+        @map[val] = dst.length == 1 ? [dst[0] + idx] : [dst[0], dst[1] + 1]
       end
     end
 
     def bfrange_type_two(start_code, end_code, dst)
-      start_code = str_to_int(start_code)
-      end_code   = str_to_int(end_code)
+      start_code = str_to_int(start_code)[0]
+      end_code   = str_to_int(end_code)[0]
       from_range = (start_code..end_code)
 
       # add all values in the range to our mapping

data/lib/pdf/reader/encoding.rb

@@ -1,3 +1,6 @@
+# coding: utf-8
+# frozen_string_literal: true
+
 ################################################################################
 #
 # Copyright (C) 2008 James Healy (jimmy@deefa.com)
@@ -24,6 +27,8 @@
 ################################################################################
 
 class PDF::Reader
+  # Util class for working with string encodings in PDF files. Mostly used to
+  # convert strings of various PDF-dialect encodings into UTF-8.
   class Encoding # :nodoc:
     CONTROL_CHARS = [0,1,2,3,4,5,6,7,8,11,12,14,15,16,17,18,19,20,21,22,23,
                      24,25,26,27,28,29,30,31]
@@ -32,19 +37,25 @@ class PDF::Reader
     attr_reader :unpack
 
     def initialize(enc)
-      if enc.kind_of?(Hash)
-        self.differences = enc[:Differences] if enc[:Differences]
-        enc = enc[:Encoding] || enc[:BaseEncoding]
-      elsif enc != nil
-        enc = enc.to_sym
+      @mapping  = default_mapping # maps from character codes to Unicode codepoints
+      @string_cache  = {} # maps from character codes to UTF-8 strings.
+
+      @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:
@@ -66,6 +77,7 @@ class PDF::Reader
           byte = val.to_i
         else
           @differences[byte] = val
+          @mapping[byte] = glyphlist.name_to_unicode(val)
           byte += 1
         end
       end
@@ -73,6 +85,7 @@ class PDF::Reader
     end
 
     def differences
+      # this method is only used by the spec tests
       @differences ||= {}
     end
 
@@ -95,8 +108,52 @@ class PDF::Reader
       end
     end
 
+    def int_to_utf8_string(glyph_code)
+      @string_cache[glyph_code] ||= internal_int_to_utf8_string(glyph_code)
+    end
+
+    # convert an integer glyph code into an Adobe glyph name.
+    #
+    #     int_to_name(65)
+    #     => [:A]
+    #
+    def int_to_name(glyph_code)
+      if @enc_name == "Identity-H" || @enc_name == "Identity-V"
+        []
+      elsif differences[glyph_code]
+        [differences[glyph_code]]
+      elsif @mapping[glyph_code]
+        glyphlist.unicode_to_name(@mapping[glyph_code])
+      else
+        []
+      end
+    end
+
     private
 
+    # returns a hash that:
+    # - maps control chars and nil to the unicode "unknown character"
+    # - leaves all other bytes <= 255 unchaged
+    #
+    # Each specific encoding will change this default as required for their glyphs
+    def default_mapping
+      all_bytes = (0..255).to_a
+      tuples = all_bytes.map {|i|
+        CONTROL_CHARS.include?(i) ? [i, UNKNOWN_CHAR] : [i,i]
+      }
+      mapping = Hash[tuples]
+      mapping[nil] = UNKNOWN_CHAR
+      mapping
+    end
+
+    def internal_int_to_utf8_string(glyph_code)
+      ret = [
+        @mapping[glyph_code.to_i] || glyph_code.to_i
+      ].pack("U*")
+      ret.force_encoding("UTF-8")
+      ret
+    end
+
     def utf8_conversion_impossible?
       @enc_name == :"Identity-H" || @enc_name == :"Identity-V"
     end
@@ -104,33 +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|
-        differences[c] || c
-      }.map { |c|
-        mapping[c] || c
-      }.map { |c|
-        names_to_unicode[c] || c
-      }.map { |c|
-        if PDF::Reader::Encoding::CONTROL_CHARS.include?(c)
-          PDF::Reader::Encoding::UNKNOWN_CHAR
-        else
-          c
-        end
-      }.map { |c|
-        if c.nil? || !c.is_a?(Fixnum)
-          PDF::Reader::Encoding::UNKNOWN_CHAR
-        else
-          c
-        end
-      }.pack("U*")
-
-      ret.force_encoding("UTF-8") if ret.respond_to?(:force_encoding)
-
+      ret = str.unpack(unpack).map! { |c| @mapping[c] || c }.pack("U*")
+      ret.force_encoding("UTF-8")
       ret
     end
 
@@ -164,26 +201,15 @@ class PDF::Reader
       end
     end
 
-    def mapping
-      @mapping ||= {}
-    end
-
-    def has_mapping?
-      mapping.size > 0
-    end
-
-    def names_to_unicode
-      @names_to_unicode ||= PDF::Reader::GlyphHash.new
+    def glyphlist
+      @glyphlist ||= PDF::Reader::GlyphHash.new
     end
 
     def load_mapping(file)
-      return if has_mapping?
-
-      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
+          _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
         end
       end
     end

data/lib/pdf/reader/error.rb

@@ -1,3 +1,6 @@
+# coding: utf-8
+# frozen_string_literal: true
+
 ################################################################################
 #
 # Copyright (C) 2006 Peter J Jones (pjones@pmade.com)
@@ -21,34 +24,51 @@
 # OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
 # WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 #
-
 class PDF::Reader
   ################################################################################
   # An internal PDF::Reader class that helps to verify various parts of the PDF file
   # are valid
   class Error # :nodoc:
     ################################################################################
-    def self.str_assert (lvalue, rvalue, chars=nil)
+    def self.str_assert(lvalue, rvalue, chars=nil)
       raise MalformedPDFError, "PDF malformed, expected string but found #{lvalue.class} instead" if chars and !lvalue.kind_of?(String)
       lvalue = lvalue[0,chars] if chars
       raise MalformedPDFError, "PDF malformed, expected '#{rvalue}' but found #{lvalue} instead"  if lvalue != rvalue
     end
     ################################################################################
-    def self.str_assert_not (lvalue, rvalue, chars=nil)
+    def self.str_assert_not(lvalue, rvalue, chars=nil)
       raise MalformedPDFError, "PDF malformed, expected string but found #{lvalue.class} instead" if chars and !lvalue.kind_of?(String)
       lvalue = lvalue[0,chars] if chars
       raise MalformedPDFError, "PDF malformed, expected '#{rvalue}' but found #{lvalue} instead"  if lvalue == rvalue
     end
     ################################################################################
-    def self.assert_equal (lvalue, rvalue)
+    def self.assert_equal(lvalue, rvalue)
       raise MalformedPDFError, "PDF malformed, expected #{rvalue} but found #{lvalue} instead" if lvalue != rvalue
     end
     ################################################################################
   end
+
   ################################################################################
+  # an exception that is raised when we believe the current PDF is not following
+  # 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
+
+  ################################################################################
+  # an exception that is raised when a PDF follows the specs but uses a feature
+  # that we don't support just yet
   class UnsupportedFeatureError < RuntimeError; end
+
+  ################################################################################
+  # an exception that is raised when a PDF is encrypted and we don't have the
+  # necessary data to decrypt it
   class EncryptedPDFError < UnsupportedFeatureError; end
 end
 ################################################################################