prawn 0.4.1 → 0.5.0.1

data/vendor/ttfunk/example.rb

@@ -1,45 +0,0 @@
-$LOAD_PATH << "#{File.dirname(__FILE__)}/lib"
-require "ttfunk"
-
-def character_lookup(file, character)
-  puts "character     : #{character}"
-
-  character_code = character.unpack("U*").first
-  puts "character code: #{character_code}"
-
-  glyph_id = file.cmap.unicode.first[character_code]
-  puts "glyph id      : #{glyph_id}"
-
-  glyph = file.glyph_outlines.for(glyph_id)
-  puts "glyph type    : %s" % glyph.class.name.split(/::/).last.downcase
-  puts "glyph size    : %db" % glyph.raw.length
-  puts "glyph bbox    : (%d,%d)-(%d,%d)" % [glyph.x_min, glyph.y_min, glyph.x_max, glyph.y_max]
-
-  if glyph.compound?
-    puts "components    : %d %s" % [glyph.glyph_ids.length, glyph.glyph_ids.inspect]
-  end
-end
-
-file = TTFunk::File.open(ARGV.first || "data/fonts/DejaVuSans.ttf")
-
-puts "-- FONT ------------------------------------"
-
-puts "revision  : %08x" % file.header.font_revision
-puts "name      : #{file.name.font_name.join(', ')}"
-puts "family    : #{file.name.font_family.join(', ')}"
-puts "subfamily : #{file.name.font_subfamily.join(', ')}"
-puts "postscript: #{file.name.postscript_name}"
-
-puts "-- FONT METRICS ----------------------------"
-
-puts "units/em  : #{file.header.units_per_em}"
-puts "ascent    : #{file.ascent}"
-puts "descent   : #{file.descent}"
-puts "line gap  : #{file.line_gap}"
-puts "bbox      : (%d,%d)-(%d,%d)" % file.bbox
-
-puts "-- SIMPLE CHARACTER -> GLYPH LOOKUP --------"
-character_lookup(file, "\xE2\x98\x9C")
-
-puts "-- COMPOUND CHARACTER -> GLYPH LOOKUP ------"
-character_lookup(file, "ë")

data/vendor/ttfunk/lib/ttfunk.rb

@@ -1,102 +0,0 @@
-require 'stringio'
-require 'ttfunk/directory'
-require 'ttfunk/resource_file'
-
-module TTFunk
-  class File
-    attr_reader :contents
-    attr_reader :directory
-
-    def self.open(file)
-      new(::File.open(file, "rb") { |f| f.read })
-    end
-
-    def self.from_dfont(file, which=0)
-      new(ResourceFile.open(file) { |dfont| dfont["sfnt", which] })
-    end
-
-    def initialize(contents)
-      @contents = StringIO.new(contents)
-      @directory = Directory.new(@contents)
-    end
-
-
-    def ascent
-      @ascent ||= os2.exists? && os2.ascent || horizontal_header.ascent
-    end
-
-    def descent
-      @descent ||= os2.exists? && os2.descent || horizontal_header.descent
-    end
-
-    def line_gap
-      @line_gap ||= os2.exists? && os2.line_gap || horizontal_header.line_gap
-    end
-
-    def bbox
-      [header.x_min, header.y_min, header.x_max, header.y_max]
-    end
-
-
-    def directory_info(tag)
-      directory.tables[tag.to_s]
-    end
-
-    def header
-      @header ||= TTFunk::Table::Head.new(self)
-    end
-
-    def cmap
-      @cmap ||= TTFunk::Table::Cmap.new(self)
-    end
-
-    def horizontal_header
-      @horizontal_header ||= TTFunk::Table::Hhea.new(self)
-    end
-
-    def horizontal_metrics
-      @horizontal_metrics ||= TTFunk::Table::Hmtx.new(self)
-    end
-
-    def maximum_profile
-      @maximum_profile ||= TTFunk::Table::Maxp.new(self)
-    end
-
-    def kerning
-      @kerning ||= TTFunk::Table::Kern.new(self)
-    end
-
-    def name
-      @name ||= TTFunk::Table::Name.new(self)
-    end
-
-    def os2
-      @os2 ||= TTFunk::Table::OS2.new(self)
-    end
-
-    def postscript
-      @postscript ||= TTFunk::Table::Post.new(self)
-    end
-
-    def glyph_locations
-      @glyph_locations ||= TTFunk::Table::Loca.new(self)
-    end
-
-    def glyph_outlines
-      @glyph_outlines ||= TTFunk::Table::Glyf.new(self)
-    end
-  end   
-end
-
-require "ttfunk/table/cmap"
-require "ttfunk/table/glyf"
-require "ttfunk/table/head"
-require "ttfunk/table/hhea"
-require "ttfunk/table/hmtx"
-require "ttfunk/table/kern"
-require "ttfunk/table/loca"
-require "ttfunk/table/maxp"
-require "ttfunk/table/name"
-require "ttfunk/table/os2"
-require "ttfunk/table/post"
-

data/vendor/ttfunk/lib/ttfunk/directory.rb

@@ -1,17 +0,0 @@
-module TTFunk
-  class Directory
-    attr_reader :tables
-    attr_reader :scaler_type
-
-    def initialize(io)
-      @scaler_type, table_count, search_range,
-        entry_selector, range_shift = io.read(12).unpack("Nn*")
-      
-      @tables = {}
-      table_count.times do
-        tag, checksum, offset, length = io.read(16).unpack("a4N*")
-        @tables[tag] = { :tag => tag, :checksum => checksum, :offset => offset, :length => length }
-      end
-    end
-  end
-end

data/vendor/ttfunk/lib/ttfunk/encoding/mac_roman.rb

@@ -1,88 +0,0 @@
-module TTFunk
-  module Encoding
-    class MacRoman
-      TO_UNICODE = Hash.new { |h,k| k }
-      TO_UNICODE.update(
-        0x81 => 0x00C5, 0x82 => 0x00C7, 0x83 => 0x00C9, 0x84 => 0x00D1, 0x85 => 0x00D6,
-        0x86 => 0x00DC, 0x87 => 0x00E1, 0x88 => 0x00E0, 0x89 => 0x00E2, 0x8A => 0x00E4,
-        0x8B => 0x00E3, 0x8C => 0x00E5, 0x8D => 0x00E7, 0x8E => 0x00E9, 0x8F => 0x00E8,
-        0x90 => 0x00EA, 0x91 => 0x00EB, 0x92 => 0x00ED, 0x93 => 0x00EC, 0x94 => 0x00EE,
-        0x95 => 0x00EF, 0x96 => 0x00F1, 0x97 => 0x00F3, 0x98 => 0x00F2, 0x99 => 0x00F4,
-        0x9A => 0x00F6, 0x9B => 0x00F5, 0x9C => 0x00FA, 0x9D => 0x00F9, 0x9E => 0x00FB,
-        0x9F => 0x00FC, 0xA0 => 0x2020, 0xA1 => 0x00B0, 0xA4 => 0x00A7, 0xA5 => 0x2022,
-        0xA6 => 0x00B6, 0xA7 => 0x00DF, 0xA8 => 0x00AE, 0xAA => 0x2122, 0xAB => 0x00B4,
-        0xAC => 0x00A8, 0xAD => 0x2260, 0xAE => 0x00C6, 0xAF => 0x00D8, 0xB0 => 0x221E,
-        0xB2 => 0x2264, 0xB3 => 0x2265, 0xB4 => 0x00A5, 0xB6 => 0x2202, 0xB7 => 0x2211,
-        0xB8 => 0x220F, 0xB9 => 0x03C0, 0xBA => 0x222B, 0xBB => 0x00AA, 0xBC => 0x00BA,
-        0xBD => 0x03A9, 0xBE => 0x00E6, 0xBF => 0x00F8, 0xC0 => 0x00BF, 0xC1 => 0x00A1,
-        0xC2 => 0x00AC, 0xC3 => 0x221A, 0xC4 => 0x0192, 0xC5 => 0x2248, 0xC6 => 0x2206,
-        0xC7 => 0x00AB, 0xC8 => 0x00BB, 0xC9 => 0x2026, 0xCA => 0x00A0, 0xCB => 0x00C0,
-        0xCC => 0x00C3, 0xCD => 0x00D5, 0xCE => 0x0152, 0xCF => 0x0153, 0xD0 => 0x2013,
-        0xD1 => 0x2014, 0xD2 => 0x201C, 0xD3 => 0x201D, 0xD4 => 0x2018, 0xD5 => 0x2019,
-        0xD6 => 0x00F7, 0xD7 => 0x25CA, 0xD8 => 0x00FF, 0xD9 => 0x0178, 0xDA => 0x2044,
-        0xDB => 0x20AC, 0xDC => 0x2039, 0xDD => 0x203A, 0xDE => 0xFB01, 0xDF => 0xFB02,
-        0xE0 => 0x2021, 0xE1 => 0x00B7, 0xE2 => 0x201A, 0xE3 => 0x201E, 0xE4 => 0x2030,
-        0xE5 => 0x00C2, 0xE6 => 0x00CA, 0xE7 => 0x00C1, 0xE8 => 0x00CB, 0xE9 => 0x00C8,
-        0xEA => 0x00CD, 0xEB => 0x00CE, 0xEC => 0x00CF, 0xED => 0x00CC, 0xEE => 0x00D3,
-        0xEF => 0x00D4, 0xF0 => 0xF8FF, 0xF1 => 0x00D2, 0xF2 => 0x00DA, 0xF3 => 0x00DB,
-        0xF4 => 0x00D9, 0xF5 => 0x0131, 0xF6 => 0x02C6, 0xF7 => 0x02DC, 0xF8 => 0x00AF,
-        0xF9 => 0x02D8, 0xFA => 0x02D9, 0xFB => 0x02DA, 0xFC => 0x00B8, 0xFD => 0x02DD,
-        0xFE => 0x02DB, 0xFF => 0x02C7
-      )
-
-      FROM_UNICODE = {}
-      (0..255).each { |key| FROM_UNICODE[TO_UNICODE[key]] = key }
-
-      # Maps MacRoman codes to their corresponding index in the Postscript glyph
-      # table (see TTFunk::Table::Post::Format10). If any entry in this array is a string,
-      # it is a postscript glyph that is not in the standard list, and which should be
-      # emitted specially in the TTF postscript table ('post', see format 2).
-      POSTSCRIPT_GLYPH_MAPPING = [
-          0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, # 0x0F
-          0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, # 0x1F
-          3,   4,   5,   6,   7,   8,   9,  10,  11,  12,  13,  14,  15,  16,  17,  18, # 0x2F
-         19,  20,  21,  22,  23,  24,  25,  26,  27,  28,  29,  30,  31,  32,  33,  34, # 0x3F
-         35,  36,  37,  38,  39,  40,  41,  42,  43,  44,  45,  46,  47,  48,  49,  50, # 0x4F
-         51,  52,  53,  54,  55,  56,  57,  58,  59,  60,  61,  62,  63,  64,  65,  66, # 0x5F
-         67,  68,  69,  70,  71,  72,  73,  74,  75,  76,  77,  78,  79,  80,  81,  82, # 0x6F
-         83,  84,  85,  86,  87,  88,  89,  90,  91,  92,  93,  94,  95,  96,  97,   0, # 0x7F
-         98,  99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, # 0x8F
-        114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, # 0x9F
-        130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, # 0xAF
-        146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, # 0xBF
-        162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, # 0xCF
-        178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, "Euro", 190, 191, 192, 193, # 0xDF
-        194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, # 0xEF
-        210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, 225  # 0xFF
-      ]
-
-      def self.covers?(character)
-        !FROM_UNICODE[character].nil?
-      end
-
-      def self.to_utf8(string)
-        to_unicode_codepoints(string.unpack("C*")).pack("U*")
-      end
-
-      def self.to_unicode(string)
-        to_unicode_codepoints(string.unpack("C*")).pack("n*")
-      end
-
-      def self.from_utf8(string)
-        from_unicode_codepoints(string.unpack("U*")).pack("C*")
-      end
-
-      def self.from_unicode(string)
-        from_unicode_codepoints(string.unpack("n*")).pack("C*")
-      end
-
-      def self.to_unicode_codepoints(array)
-        array.map { |code| TO_UNICODE[code] }
-      end
-
-      def self.from_unicode_codepoints(array)
-        array.map { |code| FROM_UNICODE[code] || 0 }
-      end
-    end
-  end
-end

data/vendor/ttfunk/lib/ttfunk/encoding/windows_1252.rb

@@ -1,69 +0,0 @@
-module TTFunk
-  module Encoding
-    class Windows1252
-      TO_UNICODE = Hash.new { |h,k| k }
-      TO_UNICODE.update(
-        0x80 => 0x20AC, 0x82 => 0x201A, 0x83 => 0x0192, 0x84 => 0x201E, 0x85 => 0x2026,
-        0x86 => 0x2020, 0x87 => 0x2021, 0x88 => 0x02C6, 0x89 => 0x2030, 0x8A => 0x0160,
-        0x8B => 0x2039, 0x8C => 0x0152, 0x8E => 0x017D, 0x91 => 0x2018, 0x92 => 0x2019,
-        0x93 => 0x201C, 0x94 => 0x201D, 0x95 => 0x2022, 0x96 => 0x2013, 0x97 => 0x2014,
-        0x98 => 0x02DC, 0x99 => 0x2122, 0x9A => 0x0161, 0x9B => 0x203A, 0x9C => 0x0152,
-        0x9E => 0x017E, 0x9F => 0x0178
-      )
-
-      FROM_UNICODE = {}
-      (0..255).each { |key| FROM_UNICODE[TO_UNICODE[key]] = key }
-
-      # Maps Windows-1252 codes to their corresponding index in the Postscript glyph
-      # table (see TTFunk::Table::Post::Format10). If any entry in this array is a string,
-      # it is a postscript glyph that is not in the standard list, and which should be
-      # emitted specially in the TTF postscript table ('post', see format 2).
-      POSTSCRIPT_GLYPH_MAPPING = [
-          0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-          0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-          3,   4,   5,   6,   7,   8,   9,  10,  11,  12,  13,  14,  15,  16,  17,  18,
-         19,  20,  21,  22,  23,  24,  25,  26,  27,  28,  29,  30,  31,  32,  33,  34,
-         35,  36,  37,  38,  39,  40,  41,  42,  43,  44,  45,  46,  47,  48,  49,  50,
-         51,  52,  53,  54,  55,  56,  57,  58,  59,  60,  61,  62,  63,  64,  65,  66,
-         67,  68,  69,  70,  71,  72,  73,  74,  75,  76,  77,  78,  79,  80,  81,  82,
-         83,  84,  85,  86,  87,  88,  89,  90,  91,  92,  93,  94,  95,  96,  97,   0,
-     "Euro",   0, 196, 166, 197, 171, 130, 194, 216, 198, 228, 190, 176,   0, 230,   0,
-          0, 182, 183, 180, 181, 135, 178, 179, 217, 140, 229, 191, 177,   0, 231, 186,
-          3, 163, 132, 133, 189, 150, 232, 134, 142, 139, 157, 169, 164,  16, 138, 218,
-        131, 147, 242, 243, 141, 151, 136, 195, 222, 241, 158, 170, 245, 244, 246, 162,
-        173, 201, 199, 174,  98,  99, 144, 100, 203, 101, 200, 202, 207, 204, 205, 206,
-        233, 102, 211, 208, 209, 175, 103, 240, 145, 214, 212, 213, 104, 235, 237, 137,
-        106, 105, 107, 109, 108, 110, 160, 111, 113, 112, 114, 115, 117, 116, 118, 119,
-        234, 120, 122, 121, 123, 125, 124, 184, 161, 127, 126, 128, 129, 236, 238, 186
-      ]
-
-      def self.covers?(character)
-        !FROM_UNICODE[character].nil?
-      end
-
-      def self.to_utf8(string)
-        to_unicode_codepoints(string.unpack("C*")).pack("U*")
-      end
-
-      def self.to_unicode(string)
-        to_unicode_codepoints(string.unpack("C*")).pack("n*")
-      end
-
-      def self.from_utf8(string)
-        from_unicode_codepoints(string.unpack("U*")).pack("C*")
-      end
-
-      def self.from_unicode(string)
-        from_unicode_codepoints(string.unpack("n*")).pack("C*")
-      end
-
-      def self.to_unicode_codepoints(array)
-        array.map { |code| TO_UNICODE[code] }
-      end
-
-      def self.from_unicode_codepoints(array)
-        array.map { |code| FROM_UNICODE[code] || 0 }
-      end
-    end
-  end
-end

data/vendor/ttfunk/lib/ttfunk/reader.rb

@@ -1,44 +0,0 @@
-module TTFunk
-  module Reader
-    private
-
-      def io
-        @file.contents
-      end
-
-      def read(bytes, format)
-        io.read(bytes).unpack(format)
-      end
-
-      def read_signed(count)
-        read(count*2, "n*").map { |i| to_signed(i) }
-      end
-
-      def to_signed(n)
-        (n>=0x8000) ? -((n ^ 0xFFFF) + 1) : n
-      end
-
-      def parse_from(position)
-        saved, io.pos = io.pos, position
-        result = yield position
-        io.pos = saved
-        return result
-      end
-
-      # For debugging purposes
-      def hexdump(string)
-        bytes = string.unpack("C*")
-        bytes.each_with_index do |c, i|
-          print "%02X" % c
-          if (i+1) % 16 == 0
-            puts
-          elsif (i+1) % 8 == 0
-            print "  "
-          else
-            print " "
-          end
-        end
-        puts unless bytes.length % 16 == 0
-      end
-  end
-end

data/vendor/ttfunk/lib/ttfunk/resource_file.rb

@@ -1,78 +0,0 @@
-module TTFunk
-  class ResourceFile
-    attr_reader :map
-
-    def self.open(path)
-      ::File.open(path, "rb") do |io|
-        file = new(io)
-        yield file
-      end
-    end
-
-    def initialize(io)
-      @io = io
-
-      data_offset, map_offset, data_length, map_length = @io.read(16).unpack("N*")
-
-      @map = {}
-      @io.pos = map_offset + 24 # skip header copy, next map handle, file reference, and attrs
-      type_list_offset, name_list_offset = @io.read(4).unpack("n*")
-
-      type_list_offset += map_offset
-      name_list_offset += map_offset
-
-      @io.pos = type_list_offset
-      max_index = @io.read(2).unpack("n").first
-      0.upto(max_index) do
-        type, max_type_index, ref_list_offset = @io.read(8).unpack("A4nn")
-        @map[type] = { :list => [], :named => {} }
-
-        parse_from(type_list_offset + ref_list_offset) do
-          0.upto(max_type_index) do
-            id, name_ofs, attr = @io.read(5).unpack("nnC")
-            data_ofs = @io.read(3)
-            data_ofs = data_offset + [0, data_ofs].pack("CA*").unpack("N").first
-            handle = @io.read(4).unpack("N").first
-
-            entry = { :id => id, :attributes => attr, :offset => data_ofs, :handle => handle }
-
-            if name_list_offset + name_ofs < map_offset + map_length
-              parse_from(name_ofs + name_list_offset) do
-                len = @io.read(1).unpack("C").first
-                entry[:name] = @io.read(len)
-              end
-            end
-
-            @map[type][:list] << entry
-            @map[type][:named][entry[:name]] = entry if entry[:name]
-          end
-        end
-      end
-    end
-
-    def [](type, index=0)
-      if @map[type]
-        collection = index.is_a?(Fixnum) ? :list : :named
-        if @map[type][collection][index]
-          parse_from(@map[type][collection][index][:offset]) do
-            length = @io.read(4).unpack("N").first
-            return @io.read(length)
-          end
-        end
-      end
-    end
-
-    def resources_for(type)
-      (@map[type] && @map[type][:named] || {}).keys
-    end
-
-    private
-
-      def parse_from(offset)
-        saved, @io.pos = @io.pos, offset
-        yield
-      ensure
-        @io.pos = saved
-      end
-  end
-end