fireinc-pdf-reader 0.11.0.alpha

data/lib/pdf/reader/cmap.rb

@@ -0,0 +1,138 @@
+################################################################################
+#
+# Copyright (C) 2008 James Healy (jimmy@deefa.com)
+#
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# 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
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+# 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
+  class CMap # :nodoc:
+
+    def initialize(data)
+      @map = {}
+      process_data(data)
+    end
+
+    def process_data(data)
+      mode = nil
+      instructions = ""
+
+      data.each_line do |l|
+        if l.include?("beginbfchar")
+          mode = :char
+        elsif l.include?("endbfchar")
+          process_bfchar_instructions(instructions)
+          instructions = ""
+          mode = nil
+        elsif l.include?("beginbfrange")
+          mode = :range
+        elsif l.include?("endbfrange")
+          process_bfrange_instructions(instructions)
+          instructions = ""
+          mode = nil
+        elsif mode == :char || mode == :range
+          instructions << l
+        end
+      end
+    end
+
+    def size
+      @map.size
+    end
+
+    def decode(c)
+      # TODO: implement the conversion
+      return c unless c.class == Fixnum
+      @map[c]
+    end
+
+    private
+
+    def build_parser(instructions)
+      buffer = Buffer.new(StringIO.new(instructions))
+      Parser.new(buffer)
+    end
+
+    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]
+      end
+    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)
+      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
+        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)
+          bfrange_type_two(start, finish, to)
+        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)
+      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
+      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)
+      from_range = (start_code..end_code)
+
+      # add all values in the range to our mapping
+      from_range.each_with_index do |val, idx|
+        @map[val] = str_to_int(dst[idx])
+      end
+    end
+  end
+end

data/lib/pdf/reader/encoding.rb

@@ -0,0 +1,190 @@
+################################################################################
+#
+# Copyright (C) 2008 James Healy (jimmy@deefa.com)
+#
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# 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
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+# 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
+  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]
+    UNKNOWN_CHAR = 0x25AF # ▯
+
+    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
+      else
+        enc = nil
+      end
+
+      @to_unicode_required = unicode_required?(enc)
+      @unpack   = get_unpack(enc)
+      @map_file = get_mapping_file(enc)
+      load_mapping(@map_file) if @map_file
+    end
+
+    def to_unicode_required?
+      @to_unicode_required
+    end
+
+    # set the differences table for this encoding. should be an array in the following format:
+    #
+    #   [25, :A, 26, :B]
+    #
+    # The array alternates between a decimal byte number and a glyph name to map to that byte
+    #
+    # To save space the following array is also valid and equivalent to the previous one
+    #
+    #   [25, :A, :B]
+    def differences=(diff)
+      raise ArgumentError, "diff must be an array" unless diff.kind_of?(Array)
+
+      @differences = {}
+      byte = 0
+      diff.each do |val|
+        if val.kind_of?(Numeric)
+          byte = val.to_i
+        else
+          @differences[byte] = val
+          byte += 1
+        end
+      end
+      @differences
+    end
+
+    def differences
+      @differences ||= {}
+    end
+
+    # convert the specified string to utf8
+    #
+    # * unpack raw bytes into codepoints
+    # * replace any that have entries in the differences table with a glyph name
+    # * convert codepoints from source encoding to Unicode codepoints
+    # * convert any glyph names to Unicode codepoints
+    # * replace characters that didn't convert to Unicode nicely with something
+    #   valid
+    # * pack the final array of Unicode codepoints into a utf-8 string
+    # * mark the string as utf-8 if we're running on a M17N aware VM
+    #
+    def to_utf8(str, tounicode = nil)
+      ret = str.unpack(unpack).map { |c|
+        differences[c] || c
+      }.map { |num|
+        original_codepoint_to_unicode(num, tounicode)
+      }.map { |c|
+        glyphnames[c] || c
+      }.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
+    end
+
+    private
+
+    def original_codepoint_to_unicode(cp, tounicode = nil)
+      if tounicode && (code = tounicode.decode(cp))
+        code
+      elsif to_unicode_required? && (tounicode.nil? || tounicode.decode(cp).nil?)
+        PDF::Reader::Encoding::UNKNOWN_CHAR
+      elsif mapping[cp]
+        mapping[cp]
+      elsif PDF::Reader::Encoding::CONTROL_CHARS.include?(cp)
+        PDF::Reader::Encoding::UNKNOWN_CHAR
+      else
+        cp
+      end
+    end
+
+    def get_unpack(enc)
+      case enc
+      when :"Identity-H", :"Identity-V", :UTF16Encoding
+        "n*"
+      else
+        "C*"
+      end
+    end
+
+    def get_mapping_file(enc)
+      return File.dirname(__FILE__) + "/encodings/standard.txt" if enc.nil?
+      files = {
+        :"Identity-H"      => nil,
+        :"Identity-V"      => nil,
+        :MacRomanEncoding  => File.dirname(__FILE__) + "/encodings/mac_roman.txt",
+        :MacExpertEncoding => File.dirname(__FILE__) + "/encodings/mac_expert.txt",
+        :PDFDocEncoding    => File.dirname(__FILE__) + "/encodings/pdf_doc.txt",
+        :StandardEncoding  => File.dirname(__FILE__) + "/encodings/standard.txt",
+        :SymbolEncoding    => File.dirname(__FILE__) + "/encodings/symbol.txt",
+        :UTF16Encoding     => nil,
+        :WinAnsiEncoding   => File.dirname(__FILE__) + "/encodings/win_ansi.txt",
+        :ZapfDingbatsEncoding => File.dirname(__FILE__) + "/encodings/zapf_dingbats.txt"
+      }
+
+      if files.has_key?(enc)
+        files[enc]
+      else
+        raise UnsupportedFeatureError, "#{enc} is not currently a supported encoding"
+      end
+    end
+
+    def unicode_required?(enc)
+      enc == :"Identity-H" or enc == :"Identity-V"
+    end
+
+    def mapping
+      @mapping ||= {}
+    end
+
+    def has_mapping?
+      mapping.size > 0
+    end
+
+    def glyphnames
+      @glyphnames ||= PDF::Reader::Font.glyphnames
+    end
+
+    def load_mapping(file)
+      return if has_mapping?
+
+      RUBY_VERSION >= "1.9" ? mode = "r:BINARY" : mode = "r"
+      File.open(file, mode) 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
+        end
+      end
+    end
+
+  end
+end

data/lib/pdf/reader/encodings/mac_expert.txt

@@ -0,0 +1,159 @@
+21;F721
+22;F6F8 # Hungarumlautsmall
+23;F7A2
+24;F724
+25;F6E4
+26;F726
+27;F7B4
+28;207D
+29;F07E
+2A;2025
+2B;2024
+2F;2044
+30;F730
+31;F731
+32;F732
+33;F733
+34;F734
+35;F735
+36;F736
+37;F737
+38;F738
+39;F739
+3D;F6DE
+3F;F73F
+44;F7F0
+47;00BC
+48;00BD
+49;00BE
+4A;215B
+4B;215C
+4C;215D
+4D;215E
+4E;2153
+4F;2154
+56;FB00
+57;FB01
+58;FB02
+59;FB03
+5A;FB04
+5B;208D
+5D;208E
+5E;F6F6
+5F;F6E5
+60;F760
+61;F761
+62;F762
+63;F763
+64;F764
+65;F765
+66;F766
+67;F767
+68;F768
+69;F769
+6A;F76A
+6B;F76B
+6C;F76C
+6D;F76D
+6E;F76E
+6F;F76F
+70;F770
+71;F771
+72;F772
+73;F773
+74;F774
+75;F775
+76;F776
+77;F777
+78;F778
+79;F779
+7A;F77A
+7B;20A1
+7C;F6DC
+7D;F6DD
+7E;F6FE
+81;F6E9
+82;F6E0
+87;F7E1 # Acircumflexsmall
+88;F7E0
+89;F7E2 # Acutesmall
+8A;F7E4
+8B;F7E3
+8C;F7E5
+8D;F7E7
+8E;F7E9
+8F;F7E8
+90;F7E4
+91;F7EB
+92;F7ED
+93;F7EC
+94;F7EE
+95;F7EF
+96;F7F1
+97;F7F3
+98;F7F2
+99;F7F4
+9A;F7F6
+9B;F7F5
+9C;F7FA
+9D;F7F9
+9E;F7FB
+9F;F7FC
+A1;2078
+A2;2084
+A3;2083
+A4;2086
+A5;2088
+A6;2087
+A7;F6FD
+A9;F6DF
+AA;2082
+AC;F7A8
+AE;F6F5
+AF;F6F0
+B0;2085
+B2;F6E1
+B3;F6E7
+B4;F7FD
+B6;F6E3
+B9;F7FE
+BB;2089
+BC;2080
+BD;F6FF
+BE;F7E6 # AEsmall
+BF;F7F8
+C0;F7BF
+C1;2081
+C2;F6F9
+C9;F7B8
+CF;F6FA
+D0;2012
+D1;F6E6
+D6;F7A1
+D8;F7FF
+DA;00B9
+DB;00B2
+DC;00B3
+DD;2074
+DE;2075
+DF;2076
+E0;2077
+E1;2079
+E2;2070
+E4;F6EC
+E5;F6F1
+E6;F6F3
+E9;F6ED
+EA;F6F2
+EB;F6EB
+F1;F6EE
+F2;F6FB
+F3;F6F4
+F4;F7AF
+F5;F6EF
+F6;207F
+F7;F6EF
+F8;F6E2
+F9;F6E8
+FA;F6F7
+FB;F6FC

data/lib/pdf/reader/encodings/mac_roman.txt

@@ -0,0 +1,128 @@
+80;00C4
+81;00C5
+82;00C7
+83;00C9
+84;00D1
+85;00D6
+86;00DC
+87;00E1
+88;00E0
+89;00E2
+8A;00E4
+8B;00E3
+8C;00E5
+8D;00E7
+8E;00E9
+8F;00E8
+90;00EA
+91;00EB
+92;00ED
+93;00EC
+94;00EE
+95;00EF
+96;00F1
+97;00F3
+98;00F2
+99;00F4
+9A;00F6
+9B;00F5
+9C;00FA
+9D;00F9
+9E;00FB
+9F;00FC
+A0;2020
+A1;00B0
+A2;00A2
+A3;00A3
+A4;00A7
+A5;2022
+A6;00B6
+A7;00DF
+A8;00AE
+A9;00A9
+AA;2122
+AB;00B4
+AC;00A8
+AD;2260
+AE;00C6
+AF;00D8
+B0;221E
+B1;00B1
+B2;2264
+B3;2265
+B4;00A5
+B5;00B5
+B6;2202
+B7;2211
+B8;220F
+B9;03C0
+BA;222B
+BB;00AA
+BC;00BA
+BD;03A9
+BE;00E6
+BF;00F8
+C0;00BF
+C1;00A1
+C2;00AC
+C3;221A
+C4;0192
+C5;2248
+C6;2206
+C7;00AB
+C8;00BB
+C9;2026
+CA;00A0
+CB;00C0
+CC;00C3
+CD;00D5
+CE;0152
+CF;0153
+D0;2013
+D1;2014
+D2;201C
+D3;201D
+D4;2018
+D5;2019
+D6;00F7
+D7;25CA
+D8;00FF
+D9;0178
+DA;2044
+DB;20AC
+DC;2039
+DD;203A
+DE;FB01
+DF;FB02
+E0;2021
+E1;00B7
+E2;201A
+E3;201E
+E4;2030
+E5;00C2
+E6;00CA
+E7;00C1
+E8;00CB
+E9;00C8
+EA;00CD
+EB;00CE
+EC;00CF
+ED;00CC
+EE;00D3
+EF;00D4
+F0;F8FF
+F1;00D2
+F2;00DA
+F3;00D8
+F4;00D9
+F5;0131
+F6;02C6
+F7;02DC
+F8;00AF
+F9;02D8
+FA;02D9
+FB;02DA
+FC;00B8
+FD;02DD
+FE;02DB
+FF;02C7

data/lib/pdf/reader/encodings/pdf_doc.txt

@@ -0,0 +1,40 @@
+18;02D8
+19;02C7
+1A;02C6
+1B;02D9
+1C;02DD
+1D;02DB
+1E;02DA
+1F;02DC
+80;2022
+81;2020
+82;2021
+83;2026
+84;2014
+85;2013
+86;0192
+87;2044
+88;2039
+89;203A
+8A;2212
+8B;2030
+8C;201E
+8D;201C
+8E;201D
+8F;2018
+90;2019
+91;201A
+92;2122
+93;FB01
+94;FB02
+95;0141
+96;0152
+97;0160
+98;0178
+99;017D
+9A;0131
+9B;0142
+9C;0153
+9D;0161
+9E;017E
+A0;20AC

data/lib/pdf/reader/encodings/standard.txt

@@ -0,0 +1,47 @@
+27;2019
+60;2018
+A4;2044
+A6;0192
+A8;00A4
+A9;0027
+AA;201C
+AC;2039
+AD;203A
+AE;FB01
+AF;FB02
+B1;2013
+B2;2020
+B3;2021
+B4;00B7
+B7;2022
+B8;201A
+B9;201E
+BA;201D
+BC;2026
+BD;2030
+C1;0060
+C2;00B4
+C3;02C6
+C4;02DC
+C5;00AF
+C6;02D8
+C7;02D9
+C8;00A8
+CA;02DA
+CB;00B8
+CD;02DD
+CE;02DB
+CF;02C7
+D0;2014
+E1;00C6
+E3;00AA
+E8;0141
+E9;00D8
+EA;0152
+EB;00BA
+F1;00E6
+F5;0131
+F8;0142
+F9;00F8
+FA;0153
+FB;00DF