Cleanup, first pass.

This cleanup is a significant refactoring of the original
ttfunk codebase. It removes the dependence on method_missing,
and adds explicit attribute lists. It also avoids dynamic
require statements, preferring to explicitly list the files
to load.

This cleanup also adds support for the 'loca', 'post', 'OS/2',
and 'glyf' TrueType tables.

Author: jamis

.gitignore

@@ -0,0 +1 @@
+*.swp

example.rb

@@ -2,4 +2,37 @@
 require "ttfunk"
 
 file = TTFunk::File.new("data/fonts/DejaVuSans.ttf")
-p file.directory.tables#kern#.sub_tables[0].keys.sort
+
+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 "-- CHARACTER -> GLYPH LOOKUP ---------------"
+
+character = "\xE2\x98\x9C"
+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_index = file.glyph_locations.index_of(glyph_id)
+glyph_size  = file.glyph_locations.size_of(glyph_id)
+puts "glyph index   : %d (%db)" % [glyph_index, glyph_size]
+
+glyph = file.glyph_outlines.at(glyph_index)
+puts "glyph         : (%d,%d)-(%d,%d) (%s)" % [glyph.x_min, glyph.y_min, glyph.x_max, glyph.y_max, glyph.class.name.split(/::/).last.downcase]

lib/ttfunk.rb

@@ -1,48 +1,93 @@
+require 'stringio'
+require 'ttfunk/directory'
+
 module TTFunk
   class File
-    def initialize(file)
-       @file = file
-       open_file { |fh| @directory = Table::Directory.new(fh) }
-    end
-    
-    def open_file
-      ::File.open(@file,"rb") do |fh|
-        yield(fh)
-      end
-    end
-    
-    def self.has_tables(*tables)
-      tables.each { |t| has_table(t) }
-    end
-    
-    def self.has_table(t)
-      t = t.to_s
-      
-      define_method t do
-        var = "@#{t}"
-        if ivar = instance_variable_get(var) 
-          return ivar  
-        else
-          klass = Table.const_get(t.capitalize)
-          open_file do |fh| 
-            instance_variable_set(var, 
-              klass.new(fh, self, directory_info(t)))
-          end
-        end
-      end
-    end
-    
-    def directory_info(table)
-      directory.tables[table.to_s]
-    end
-    
-    def method_missing(id,*a,&b)
-      super unless id.to_s["?"]
-      !!directory_info(id.to_s.chop)
-    end
-    
+    attr_reader :contents
     attr_reader :directory
+
+    def initialize(file)
+      @contents = StringIO.new(IO.read(file))
+      @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"
+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"
+

lib/ttfunk/directory.rb

@@ -0,0 +1,16 @@
+module TTFunk
+  class Directory
+    attr_reader :tables
+
+    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

lib/ttfunk/reader.rb

@@ -0,0 +1,28 @@
+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
+        io.pos = saved
+        return result
+      end
+  end
+end

lib/ttfunk/table.rb

@@ -1,29 +1,32 @@
-require "ttfunk/table/directory"
-
-%w[cmap head hhea hmtx name kern maxp].each do |lib|
-  require "ttfunk/table/" + lib
-  TTFunk::File.has_table lib
-end
+require 'ttfunk/reader'
 
 module TTFunk
   class Table
-    def method_missing(*args, &block)
-      var = "@#{args.first}"
-      
-      # RUBY 1.9 compatability
-      if instance_variables.map { |e| e.to_s }.include?(var)
-        instance_variable_get(var)
-      else
-        super
+    include Reader
+
+    attr_reader :file
+    attr_reader :offset
+    attr_reader :length
+
+    def initialize(file)
+      @file = file
+
+      info = file.directory_info(tag)
+
+      if info
+        @offset = info[:offset]
+        @length = info[:length]
+
+        parse_from(@offset) { parse! }
       end
     end
-    
-    private
-    
-    def to_signed(n, length=16)
-      max = 2**length-1
-      mid = 2**(length-1)
-      (n>=mid) ? -((n ^ max) + 1) : n
+
+    def exists?
+      !@offset.nil?
+    end
+
+    def tag
+      self.class.name.split(/::/).last.downcase
     end
   end
 end

lib/ttfunk/table/cmap.rb

@@ -1,94 +1,26 @@
 module TTFunk  
   class Table
     class Cmap < Table
-      def initialize(fh, font, info)
-        @file = fh
-        @file.pos = info[:offset]
-    
-        @version, @table_count = @file.read(4).unpack("n2")
-    
-        process_subtables(info[:offset])
+      attr_reader :version
+      attr_reader :tables
+
+      def unicode
+        @unicode ||= @tables.select { |table| table.unicode? }
       end
-    
+
       private
-    
-      def process_subtables(table_start)
-        @sub_tables = {}
-        @formats = {}
-        @table_count.times do
-          platform_id, encoding_id, offset = @file.read(8).unpack("n2N")
-          @sub_tables[[platform_id, encoding_id]] = offset
-        end
-    
-        @sub_tables.each do |ident, offset|
-          @file.pos = table_start + offset
-          format = @file.read(2).unpack("n").first 
-          case format
-          when 0
-            read_format0
-          when 4
-            read_format4(table_start)
-          else
-            if $DEBUG
-              warn "TTFunk: Format #{format} not implemented, skipping"
-            end
-          end
-        end 
-      end
-    
-      def read_segment
-        @file.read(@segcount_x2).unpack("n#{@segcount_x2 / 2}")
-      end
-    
-      def read_format0
-        @file.read(4) # skip length, language for now
-        glyph_ids = @file.read(256).unpack("C256")
-        @formats[0] = glyph_ids
-      end
-    
-      def read_format4(table_start)
-        @formats[4] = {}
-    
-        length, language = @file.read(4).unpack("n2")
-        @segcount_x2, search_range, entry_selector, range_shift = 
-          @file.read(8).unpack("n4")
-    
-        extract_format4_glyph_ids(table_start)
-      end
-   
-      def extract_format4_glyph_ids(table_start)
-        end_count = read_segment
-     
-        @file.read(2) # skip reserved value
-     
-        start_count = read_segment
-        id_delta = read_segment.map { |e| to_signed(e) }
-        id_range_offset = read_segment
-     
-        remaining_shorts = (@file.pos - table_start) / 2
-        glyph_ids = @file.read(remaining_shorts*2).unpack("n#{remaining_shorts}")
-       
-        start_count.each_with_index do |start, i|
-          end_i = end_count[i]
-          delta = id_delta[i]
-          range = id_range_offset[i]
-        
-          start.upto(end_i) do |char|
-            if range.zero?
-               gid = char + delta
-            else
-              gindex = range / 2 + (char - start_count[i]) - 
-                  (segcount_x2 / 2 - i)
-              gid = glyph_ids[gindex] || 0
-              gid += id_delta[i] if gid != 0   
-            end   
-            gid %= 65536 
-         
-            @formats[4][char] = gid
+
+        def parse!
+          @version, table_count = read(4, "nn")
+          @tables = []
+
+          table_count.times do
+            @tables << Cmap::Subtable.new(file, offset)
           end
         end
-      end    
     end
 
   end
-end
+end
+
+require 'ttfunk/table/cmap/subtable'

lib/ttfunk/table/cmap/format00.rb

@@ -0,0 +1,27 @@
+module TTFunk
+  class Table
+    class Cmap
+
+      module Format00
+        attr_reader :language
+        attr_reader :code_map
+
+        def [](code)
+          @code_map[code] || 0
+        end
+
+        def supported?
+          true
+        end
+
+        private
+
+          def parse_cmap!
+            length, @language = read(6, "nn")
+            @code_map = read(256, "C*")
+          end
+      end
+
+    end
+  end
+end

lib/ttfunk/table/cmap/format04.rb

@@ -0,0 +1,53 @@
+module TTFunk
+  class Table
+    class Cmap
+
+      module Format04
+        attr_reader :language
+        attr_reader :code_map
+
+        def [](code)
+          @code_map[code] || 0
+        end
+
+        def supported?
+          true
+        end
+
+        private
+
+          def parse_cmap!
+            length, @language, segcount_x2 = read(6, "nnn")
+            segcount = segcount_x2 / 2
+
+            io.read(6) # skip searching hints
+
+            end_code = read(segcount_x2, "n*")
+            io.read(2) # skip reserved value
+            start_code = read(segcount_x2, "n*")
+            id_delta = read_signed(segcount)
+            id_range_offset = read(segcount_x2, "n*")
+
+            glyph_ids = read(length - io.pos + @offset, "n*")
+
+            @code_map = {}
+
+            end_code.each_with_index do |tail, i|
+              start_code[i].upto(tail) do |code|
+                if id_range_offset[i].zero?
+                  glyph_id = code + id_delta[i]
+                else
+                  index = id_range_offset[i] / 2 + (code - start_code[i]) - (segcount - i)
+                  glyph_id = glyph_ids[index] || 0 # because some TTF fonts are broken
+                  glyph_id += id_delta[i] if glyph_id != 0
+                end
+
+                @code_map[code] = glyph_id & 0xFFFF
+              end
+            end
+          end
+      end
+
+    end
+  end
+end

lib/ttfunk/table/cmap/subtable.rb

@@ -0,0 +1,54 @@
+require 'ttfunk/reader'
+
+module TTFunk
+  class Table
+    class Cmap
+      class Subtable
+        include Reader
+
+        attr_reader :platform_id
+        attr_reader :encoding_id
+        attr_reader :format
+
+        def initialize(file, table_start)
+          @file = file
+          @platform_id, @encoding_id, @offset = read(8, "nnN")
+          @offset += table_start
+
+          saved, io.pos = io.pos, @offset
+          @format = read(2, "n").first
+
+          case @format
+            when 0 then extend(TTFunk::Table::Cmap::Format00)
+            when 4 then extend(TTFunk::Table::Cmap::Format04)
+          end
+
+          parse_cmap!
+          io.pos = saved
+        end
+
+        def unicode?
+          platform_id == 3 && encoding_id == 1 && format == 4 ||
+          platform_id == 0 && format == 4
+        end
+
+        def supported?
+          false
+        end
+
+        def [](code)
+          raise NotImplementedError, "cmap format #{@format} is not supported"
+        end
+
+        private
+
+          def parse_cmap!
+            # do nothing...
+          end
+      end
+    end
+  end
+end
+
+require 'ttfunk/table/cmap/format00'
+require 'ttfunk/table/cmap/format04'

lib/ttfunk/table/directory.rb

@@ -0,0 +1,32 @@
+require 'ttfunk/table'
+
+module TTFunk
+  class Table
+    class Glyf < Table
+      def at(glyph_offset)
+        return @cache[glyph_offset] if @cache.key?(glyph_offset)
+
+        parse_from(offset + glyph_offset) do
+          number_of_contours, x_min, y_min, x_max, y_max = read_signed(5)
+
+          @cache[glyph_offset] = if number_of_contours == -1
+              Compound.new(io, x_min, y_min, x_max, y_max)
+            else
+              Simple.new(io, number_of_contours, x_min, y_min, x_max, y_max)
+            end
+        end
+      end
+
+      private
+
+        def parse!
+          # because the glyf table is rather complex to parse, we defer
+          # the parse until we need a specific glyf, and then cache it.
+          @cache = {}
+        end
+    end
+  end
+end
+
+require 'ttfunk/table/glyf/compound'
+require 'ttfunk/table/glyf/simple'

lib/ttfunk/table/glyf.rb

@@ -0,0 +1,72 @@
+require 'ttfunk/reader'
+
+module TTFunk
+  class Table
+    class Glyf
+      class Compound
+        include Reader
+
+        ARG_1_AND_2_ARE_WORDS    = 0x0001
+        WE_HAVE_A_SCALE          = 0x0008
+        MORE_COMPONENTS          = 0x0020
+        WE_HAVE_AN_X_AND_Y_SCALE = 0x0040
+        WE_HAVE_A_TWO_BY_TWO     = 0x0080
+        WE_HAVE_INSTRUCTIONS     = 0x0100
+
+        attr_reader :x_min, :y_min, :x_max, :y_max
+        attr_reader :components
+        attr_reader :instructions
+
+        Component = Struct.new(:flags, :glyph_index, :arg1, :arg2, :transform)
+
+        def initialize(io, x_min, y_min, x_max, y_max)
+          @io = io
+          @x_min, @y_min, @x_max, @y_max = x_min, y_min, x_max, y_max
+
+          @components = []
+          instr_requests = 0
+
+          loop do
+            flags, glyph_index = read(4, "n*")
+            if flags & ARG_1_AND_2_ARE_WORDS != 0
+              arg1, arg2 = read(4, "n*")
+            else
+              arg1, arg2 = read(2, "C*")
+            end
+
+            if flags & WE_HAVE_A_TWO_BY_TWO != 0
+              transform = read(8, "n*")
+            elsif flags & WE_HAVE_AN_X_AND_Y_SCALE != 0
+              transform = read(4, "n*")
+            elsif flags & WE_HAVE_A_SCALE != 0
+              transform = read(2, "n")
+            else
+              transform = []
+            end
+
+            instr_requests += 1 if flags & WE_HAVE_INSTRUCTIONS != 0
+
+            @components << Component.new(flags, glyph_index, arg1, arg2, transform)
+            break unless flags & MORE_COMPONENTS != 0
+          end
+
+          # The docs are a bit vague on how instructions are to be parsed from
+          # a compound glyph. This seems to work for the glyphs I've tried, but...
+          @instructions = ""
+          while instr_requests > 0
+            length = read(2, "n").first
+            @instructions << io.read(length)
+            instr_requests -= 1
+          end
+        end
+
+        private
+
+          def io
+            @io
+          end
+      end
+    end
+  end
+end
+

lib/ttfunk/table/glyf/compound.rb

@@ -0,0 +1,79 @@
+require 'ttfunk/reader'
+
+module TTFunk
+  class Table
+    class Glyf
+      class Simple
+        include Reader
+
+        ON_CURVE   = 0x01
+        X_SHORT    = 0x02
+        Y_SHORT    = 0x04
+        REPEAT     = 0x08
+        X_SAME     = 0x10
+        X_POSITIVE = 0x10
+        Y_SAME     = 0x20
+        Y_POSITIVE = 0x20
+
+        attr_reader :number_of_contours
+        attr_reader :x_min, :y_min, :x_max, :y_max
+        attr_reader :end_points, :instructions, :flags
+        attr_reader :xs, :ys
+
+        def initialize(io, number_of_contours, x_min, y_min, x_max, y_max)
+          @io = io
+          @number_of_contours = number_of_contours
+          @x_min, @y_min = x_min, y_min
+          @x_max, @y_max = x_max, y_max
+
+          @end_points = read(number_of_contours * 2, "n*")
+          point_count = @end_points.last || 0
+
+          instr_len = read(2, "n").first
+          @instructions = io.read(instr_len)
+
+          @flags = []
+          while @flags.length < point_count
+            flag = read(1, "C").first
+            @flags << flag
+
+            if flag & REPEAT != 0
+              count = read(1, "C").first
+              @flags.concat([flag] * count)
+            end
+          end
+
+          @xs = []
+          read_coords(@xs, point_count, X_SHORT, X_POSITIVE, X_SAME)
+
+          @ys = []
+          read_coords(@ys, point_count, Y_SHORT, Y_POSITIVE, Y_SAME)
+        end
+
+        private
+
+          def read_coords(array, count, short_flag, positive_flag, same_flag)
+            while array.length < count
+              flag = @flags[array.length]
+
+              if flag & short_flag != 0
+                coord = read(1, "C").first
+                coord = -coord if flag & positive_flag == 0
+              elsif flag & same_flag != 0
+                coord = 0
+              else
+                coord = read_signed(1).first
+              end
+
+              array << coord
+            end
+          end
+
+          def io
+            @io
+          end
+      end
+    end
+  end
+end
+

lib/ttfunk/table/glyf/simple.rb

@@ -1,25 +1,37 @@
+require 'ttfunk/table'
+
 module TTFunk  
   class Table
     class Head < TTFunk::Table
-      def initialize(fh, font, info)
-        fh.pos = info[:offset]
-        data = fh.read(20)
-        @version, @font_revision, @check_sum_adjustment, @magic_number,
-        @flags, @units_per_em = data.unpack("N4n2")
-    
-        # skip dates
-        fh.read(16)
-    
-        data = fh.read(8)
-        @x_min, @y_min, @x_max, @y_max = data.unpack("n4").map { |e| to_signed(e) }
-    
-        data = fh.read(4)
-        @mac_style, @lowest_rec_ppem = data.unpack("n2")
-    
-        data = fh.read(6)
-        @font_direction_hint, @index_to_loc_format, @glyph_data_format =
-          data.unpack("n3")
-      end
+      attr_reader :version
+      attr_reader :font_revision
+      attr_reader :checksum_adjustment
+      attr_reader :magic_number
+      attr_reader :flags
+      attr_reader :units_per_em
+      attr_reader :created
+      attr_reader :modified
+      attr_reader :x_min
+      attr_reader :y_min
+      attr_reader :x_max
+      attr_reader :y_max
+      attr_reader :mac_style
+      attr_reader :lowest_rec_ppem
+      attr_reader :font_direction_hint
+      attr_reader :index_to_loc_format
+      attr_reader :glyph_data_format
+
+      private
+
+        def parse!
+          @version, @font_revision, @check_sum_adjustment, @magic_number,
+            @flags, @units_per_em, @created, @modified = read(36, "N4n2q2")
+      
+          @x_min, @y_min, @x_max, @y_max = read_signed(4)
+      
+          @mac_style, @lowest_rec_ppem, @font_direction_hint,
+            @index_to_loc_format, @glyph_data_format = read(10, "n*")
+        end
     end
   end
-end
+end

lib/ttfunk/table/head.rb

@@ -1,27 +1,35 @@
+require 'ttfunk/table'
+
 module TTFunk  
   class Table
     class Hhea < Table
-      def initialize(fh, font, info)
-        fh.pos = info[:offset]
-        @length = info[:length]
-        data   = fh.read(4)
-        @version = data.unpack("N")
-    
-        data = fh.read(6)
-        @ascent, @descent, @line_gap= data.unpack("n3").map {|e| to_signed(e) } 
-    
-        data = fh.read(2) 
-        @advance_width_max = data.unpack("n")
-    
-        data = fh.read(22)
-        @min_left_side_bearing, @min_right_side_bearing, @x_max_extent, 
-        @caret_slope_rise, @caret_slope_run,
-        @caret_offset, _, _, _, _, @metric_data_format =
-        data.unpack("n11").map {|e| to_signed(e) }
-    
-        data = fh.read(2)
-        @number_of_hmetrics = data.unpack("n").first
-      end
+      attr_reader :version
+      attr_reader :ascent
+      attr_reader :descent
+      attr_reader :line_gap
+      attr_reader :advance_width_max
+      attr_reader :min_left_side_bearing
+      attr_reader :min_right_side_bearing
+      attr_reader :x_max_extent
+      attr_reader :carot_slope_rise
+      attr_reader :carot_slope_run
+      attr_reader :metric_data_format
+      attr_reader :number_of_metrics
+
+      private
+
+        def parse!
+          @version = read(4, "N").first
+          @ascent, @descent, @line_gap = read_signed(3)
+          @advance_width_max = read(2, "n").first
+
+          @min_left_side_bearing, @min_right_side_bearing, @x_max_extent,
+            @carot_slope_rise, @carot_slope_run, @caret_offset,
+            reserved, reserved, reserved, reserved,
+            @metric_data_format = read_signed(11)
+
+          @number_of_metrics = read(2, "n").first
+        end
     end
   end
-end
+end

lib/ttfunk/table/hhea.rb

@@ -1,20 +1,37 @@
+require 'ttfunk/table'
+
 module TTFunk  
   class Table 
     class Hmtx < Table
-      def initialize(fh, font, info)
-        fh.pos = info[:offset]
-        @values = []
-
-        font.hhea.number_of_hmetrics.times do
-          advance = fh.read(2).unpack("n").first
-          lsb     = to_signed(fh.read(2).unpack("n").first)
-          @values << [advance,lsb]
-        end
-    
-        lsb_count = font.hhea.number_of_hmetrics - font.maxp.num_glyphs
-        pattern = "n#{lsb_count}"
-        @lsb = fh.read(2*lsb_count).unpack(pattern).map { |e| to_signed(e) }
+      attr_reader :metrics
+      attr_reader :left_side_bearings
+      attr_reader :widths
+
+      HorizontalMetric = Struct.new(:advance_width, :left_side_bearing)
+
+      def for(glyph_id)
+        @metrics[glyph_id] ||
+          HorizontalMetric.new(@metrics.last.advance_width,
+            @left_side_bearings[glyph_id - @metrics.length])
       end
+
+      private
+
+        def parse!
+          @metrics = []
+
+          file.horizontal_header.number_of_metrics.times do
+            advance = read(2, "n").first
+            lsb     = read_sshort(1).first
+            @metrics.push HorizontalMetric.new(advance, lsb)
+          end
+
+          lsb_count = file.maximum_profile.num_glyphs - file.horizontal_header.number_of_metrics
+          @left_side_bearings = read_sshort(lsb_count)
+
+          @widths = @metrics.map { |metric| metric.advance_width }
+          @widths += @left_side_bearings.length * @widths.last
+        end
     end
   end
-end
+end

lib/ttfunk/table/hmtx.rb

@@ -1,48 +1,62 @@
+require 'ttfunk/table'
+
 module TTFunk
   class Table
     class Kern < Table
-      def initialize(fh, font, info)
-        fh.pos = info[:offset]
-        data = fh.read(4)
-        @fh = fh
-        @version, @table_count = data.unpack("n2")
-        
-        @table_headers = {}
-        
-        @table_count.times do
-          version, length, coverage = fh.read(6).unpack("n3")
-          @table_headers[version] = { :length   => length, 
-                                      :coverage => coverage,
-                                      :format   => coverage >> 8 }
-        end   
-        
-        generate_subtables
-      end
-        
-      def generate_subtables
-        @sub_tables = {}
-        @table_headers.each do |version, data|
-          if data[:format].zero?
-            @sub_tables[0] = parse_subtable_format0
+      attr_reader :version
+      attr_reader :tables
+
+      private
+
+        def parse!
+          @version, num_tables = read(4, "n*")
+          @tables = []
+
+          if @version == 1 # Mac OS X fonts
+            @version = (@version << 16) + num_tables
+            num_tables = read(4, "N").first
+            parse_version_1_tables(num_tables)
           else
-            warn "TTFunk does not support kerning tables of format #{data[:format]}"
+            parse_version_0_tables(num_tables)
           end
         end
-      end
-      
-      def parse_subtable_format0
-        sub_table = {}
-        pair_count, search_range, entry_selector, range_shift = @fh.read(8).unpack("n4")
-        
-        pair_count.times do
-          left, right = @fh.read(4).unpack("n2")
-          fword = to_signed(@fh.read(2).unpack("n").first)
-          sub_table[[left,right]] = fword
+
+        def parse_version_0_tables(num_tables)
+          num_tables.times do # MS fonts
+            version, length, coverage = read(6, "n*")
+            format = coverage >> 8
+
+            add_table format, :version => version, :length => length,
+              :coverage => coverage, :data => handle.read(length-6),
+              :vertical => (coverage & 0x1 == 0),
+              :minimum => (coverage & 0x2 != 0),
+              :cross => (coverage & 0x4 != 0),
+              :override => (coverage & 0x8 != 0)
+          end
+        end
+
+        def parse_version_1_tables(num_tables)
+          num_tables.times do
+            length, coverage, tuple_index = read(8, "Nnn")
+            format = coverage & 0x0FF
+
+            add_table format, :length => length, :coverage => coverage,
+              :tuple_index => tuple_index, :data => handle.read(length-8),
+              :vertical => (coverage & 0x8000 != 0),
+              :cross => (coverage & 0x4000 != 0),
+              :variation => (coverage & 0x2000 != 0)
+          end
+        end
+
+        def add_table(format, attributes={})
+          if format == 0
+            @tables << Kern::Format0.new(attributes)
+          else
+            # silently ignore unsupported kerning tables
+          end
         end
-        
-        return sub_table
-      end
-      
     end
   end
-end
+end
+
+require 'ttfunk/table/kern/format0'

lib/ttfunk/table/kern.rb

@@ -0,0 +1,42 @@
+require 'ttfunk/reader'
+
+module TTFunk
+  class Table
+    class Kern
+      class Format0
+        include Reader
+
+        attr_reader :attributes
+        attr_reader :pairs
+
+        def initialize(attributes={})
+          @file = file
+          @attributes = attributes
+
+          num_pairs, search_range, entry_selector, range_shift, *pairs =
+            attributes.delete(:data).unpack("n*")
+
+          @pairs = {}
+          num_pairs.times do |i|
+            left = pairs[i*3]
+            right = pairs[i*3+1]
+            value = to_signed(pairs[i*3+2])
+            @pairs[[left, right]] = value
+          end
+        end
+
+        def vertical?
+          @attributes[:vertical]
+        end
+
+        def horizontal?
+          !vertical?
+        end
+
+        def cross_stream?
+          @attributes[:cross]
+        end
+      end
+    end
+  end
+end

lib/ttfunk/table/kern/format0.rb

@@ -0,0 +1,28 @@
+require 'ttfunk/table'
+
+module TTFunk
+  class Table
+    class Loca < Table
+      attr_reader :offsets
+
+      def index_of(glyph_id)
+        @offsets[glyph_id]
+      end
+
+      def size_of(glyph_id)
+        @offsets[glyph_id+1] - @offsets[glyph_id]
+      end
+
+      private
+
+        def parse!
+          type = file.header.index_to_loc_format == 0 ? "n" : "N"
+          @offsets = read(length, "#{type}*")
+
+          if file.header.index_to_loc_format == 0
+            @offsets.map! { |v| v * 2 }
+          end
+        end
+    end
+  end
+end

lib/ttfunk/table/loca.rb

@@ -1,17 +1,33 @@
+require 'ttfunk/table'
+
 module TTFunk
   class Table
     class Maxp < Table
-      def initialize(fh, font, info)
-        fh.pos = info[:offset]
-        @length = info[:length]
-        data = fh.read(@length)
-        @version, @num_glyphs, @max_points, @max_contours,
-        @max_component_points,@max_component_contours, @max_zones,
-        @max_twilight_points, @max_storage, @max_function_defs,
-        @max_instruction_defs,@max_stack_elements,
-        @max_size_of_instructions, @max_component_elements,
-        @max_component_depth = data.unpack("Nn14")
-      end
+      attr_reader :version
+      attr_reader :num_glyphs
+      attr_reader :max_points
+      attr_reader :max_contours
+      attr_reader :max_component_points
+      attr_reader :max_component_contours
+      attr_reader :max_zones
+      attr_reader :max_twilight_points
+      attr_reader :max_storage
+      attr_reader :max_function_defs
+      attr_reader :max_instruction_defs
+      attr_reader :max_stack_elements
+      attr_reader :max_size_of_instructions
+      attr_reader :max_component_elements
+      attr_reader :max_component_depth
+
+      private
+
+        def parse!
+          @version, @num_glyphs, @max_points, @max_contours, @max_component_points,
+            @max_component_contours, @max_zones, @max_twilight_points, @max_storage,
+            @max_function_defs, @max_instruction_defs, @max_stack_elements,
+            @max_size_of_instructions, @max_component_elements, @max_component_depth =
+              read(length, "Nn*")
+        end
     end
   end
-end
+end

lib/ttfunk/table/maxp.rb

@@ -1,52 +1,90 @@
+require 'ttfunk/table'
+
 module TTFunk
   class Table
     class Name < Table
-      def initialize(fh, font, info)
-        fh.pos = info[:offset]
-        data = fh.read(6)
-        @table_start = info[:offset]
-        @format, @record_count, @string_offset = data.unpack("nnn")
-        parse_name_records(fh)
-        parse_strings(fh)
-      end
-  
-      def parse_name_records(fh)
-        @records = {}
-        @record_count.times { @records.update(parse_name_record(fh)) }
-      end
-  
-      def parse_name_record(fh)
-        data = fh.read(12).unpack("n6")
-        platform, encoding, language, id, length, offset = data
-        { id => { 
-            :platform => platform, :encoding => encoding, 
-            :language => language, :length   => length,
-            :offset   => offset } }
-      end
-  
-      def parse_strings(fh)
-        @strings = @records.inject({}) do |s,v|
-          id, options = v
-      
-          fh.pos = @table_start + @string_offset + options[:offset]
-          s.merge(id => fh.read(options[:length]).delete("\000"))
+      class String < ::String
+        attr_reader :platform_id
+        attr_reader :encoding_id
+        attr_reader :language_id
+
+        def initialize(text, platform_id, encoding_id, language_id)
+          super(text)
+          @platform_id = platform_id
+          @encoding_id = encoding_id
+          @language_id = language_id
         end
       end
-  
-      def name_data 
-        [:copyright, :font_family, :font_subfamily, :unique_subfamily_id,
-         :full_name, :name_table_version, :postscript_name, :trademark_notice,
-         :manufacturer_name, :designer, :description, :vendor_url,
-         :designer_url, :license_description, :license_info_url ]
-      end
-    
-      def method_missing(*args,&block)
-        if name_data.include?(args.first)
-          @strings[name_data.index(args.first)]
-        else
-          super
+
+      attr_reader :strings
+
+      attr_reader :copyright
+      attr_reader :font_family
+      attr_reader :font_subfamily
+      attr_reader :unique_subfamily
+      attr_reader :font_name
+      attr_reader :version
+      attr_reader :postscript_name
+      attr_reader :trademark
+      attr_reader :manufacturer
+      attr_reader :designer
+      attr_reader :description
+      attr_reader :vendor_url
+      attr_reader :designer_url
+      attr_reader :license
+      attr_reader :license_url
+      attr_reader :preferred_family
+      attr_reader :preferred_subfamily
+      attr_reader :compatible_full
+      attr_reader :sample_text
+
+      private
+
+        def parse!
+          format, count, string_offset = read(6, "n*")
+
+          entries = []
+          count.times do
+            platform, encoding, language, id, length, start_offset = read(12, "n*")
+            entries << {
+              :platform_id => platform,
+              :encoding_id => encoding,
+              :language_id => language,
+              :name_id => id,
+              :length => length,
+              :offset => offset + string_offset + start_offset
+            }
+          end
+
+          @strings = Hash.new { |h,k| h[k] = [] }
+
+          count.times do |i|
+            io.pos = entries[i][:offset]
+            text = io.read(entries[i][:length])
+            @strings[entries[i][:name_id]] << Name::String.new(text,
+              entries[i][:platform_id], entries[i][:encoding_id], entries[i][:language_id])
+          end
+
+          @copyright = @strings[0]
+          @font_family = @strings[1]
+          @font_subfamily = @strings[2]
+          @unique_subfamily = @strings[3]
+          @font_name = @strings[4]
+          @version = @strings[5]
+          @postscript_name = @strings[6].first # should only be ONE postscript name
+          @trademark = @strings[7]
+          @manufacturer = @strings[8]
+          @designer = @strings[9]
+          @description = @strings[10]
+          @vendor_url = @strings[11]
+          @designer_url = @strings[12]
+          @license = @strings[13]
+          @license_url = @strings[14]
+          @preferred_family = @strings[15]
+          @preferred_subfamily = @strings[17]
+          @compatible_full = @strings[18]
+          @sample_text = @strings[19]
         end
-      end
     end
   end
-end
+end

lib/ttfunk/table/name.rb

@@ -0,0 +1,78 @@
+require 'ttfunk/table'
+
+module TTFunk
+  class Table
+    class OS2 < Table
+      attr_reader :version
+
+      attr_reader :ave_char_width
+      attr_reader :weight_class
+      attr_reader :width_class
+      attr_reader :type
+      attr_reader :y_subscript_x_size
+      attr_reader :y_subscript_y_size
+      attr_reader :y_subscript_x_offset
+      attr_reader :y_subscript_y_offset
+      attr_reader :y_superscript_x_size
+      attr_reader :y_superscript_y_size
+      attr_reader :y_superscript_x_offset
+      attr_reader :y_superscript_y_offset
+      attr_reader :y_strikeout_size
+      attr_reader :y_strikeout_position
+      attr_reader :family_class
+      attr_reader :panose
+      attr_reader :char_range
+      attr_reader :vendor_id
+      attr_reader :selection
+      attr_reader :first_char_index
+      attr_reader :last_char_index
+
+      attr_reader :ascent
+      attr_reader :descent
+      attr_reader :line_gap
+      attr_reader :win_ascent
+      attr_reader :win_descent
+      attr_reader :code_page_range
+
+      attr_reader :x_height
+      attr_reader :cap_height
+      attr_reader :default_char
+      attr_reader :break_char
+      attr_reader :max_context
+
+      def tag
+        "OS/2"
+      end
+
+      private
+
+        def parse!
+          @version = read(2, "n").first
+
+          @ave_char_width = read_signed(1)
+          @weight_class, @width_class = read(4, "nn")
+          @type, @y_subscript_x_size, @y_subscript_y_size, @y_subscript_x_offset,
+            @y_subscript_y_offset, @y_superscript_x_size, @y_superscript_y_size,
+            @y_superscript_x_offset, @y_superscript_y_offset, @y_strikeout_size,
+            @y_strikeout_position, @family_class = read_signed(12)
+          @panose = io.read(10)
+
+          @char_range = io.read(16)
+          @vendor_id = io.read(4)
+
+          @selection, @first_char_index, @last_char_index = read(6, "n*")
+
+          if @version > 0
+            @ascent, @descent, @line_gap = read_signed(3)
+            @win_ascent, @win_descent = read(4, "nn")
+            @code_page_range = io.read(8)
+
+            if @version > 1
+              @x_height, @cap_height = read_signed(2)
+              @default_char, @break_char, @max_context = read(6, "nnn")
+            end
+          end
+        end
+    end
+  end
+end

lib/ttfunk/table/os2.rb

@@ -0,0 +1,58 @@
+require 'ttfunk/table'
+
+module TTFunk  
+  class Table
+    class Post < Table
+      attr_reader :format
+      attr_reader :italic_angle
+      attr_reader :underline_position
+      attr_reader :underline_thickness
+      attr_reader :fixed_pitch
+      attr_reader :min_mem_type42
+      attr_reader :max_mem_type42
+      attr_reader :min_mem_type1
+      attr_reader :max_mem_type1
+
+      attr_reader :subtable
+
+      def fixed_pitch?
+        @fixed_pitch != 0
+      end
+
+      def glyph_for(code)
+        ".notdef"
+      end
+
+      private
+
+        def parse!
+          @format, @italic_angle, @underline_position, @underline_thickness,
+            @fixed_pitch, @min_mem_type42, @max_mem_type42, 
+            @min_mem_type1, @max_mem_type1 = read(32, "N2n2N*")
+
+          end_of_table = offset + length
+
+          @subtable = case @format
+            when 0x00010000 then extend(Post::Format10)
+            when 0x00020000 then extend(Post::Format20)
+            when 0x00025000 then extend(Post::Format25)
+            when 0x00030000 then extend(Post::Format30)
+            when 0x00040000 then extend(Post::Format40)
+            end
+
+          parse_table!
+        end
+
+        def parse_table!
+          warn "postscript table format 0x%08X is not supported" % @format
+        end
+    end
+    
+  end
+end
+
+require 'ttfunk/table/post/format10'
+require 'ttfunk/table/post/format20'
+require 'ttfunk/table/post/format25'
+require 'ttfunk/table/post/format30'
+require 'ttfunk/table/post/format40'

lib/ttfunk/table/post.rb

@@ -0,0 +1,43 @@
+module TTFunk
+  class Table
+    class Post
+      module Format10
+        POSTSCRIPT_GLYPHS = %w(
+          .notdef .null nonmarkingreturn space exclam quotedbl numbersign dollar percent
+          ampersand quotesingle parenleft parenright asterisk plus comma hyphen period slash
+          zero one two three four five six seven eight nine colon semicolon less equal greater
+          question at A B C D E F G H I J K L M N O P Q R S T U V W X Y Z
+          bracketleft backslash bracketright asciicircum underscore grave
+          a b c d e f g h i j k l m n o p q r s t u v w x y z
+          braceleft bar braceright asciitilde Adieresis Aring Ccedilla Eacute Ntilde Odieresis
+          Udieresis aacute agrave acircumflex adieresis atilde aring ccedilla eacute egrave
+          ecircumflex edieresis iacute igrave icircumflex idieresis ntilde oacute ograve
+          ocircumflex odieresis otilde uacute ugrave ucircumflex udieresis dagger degree cent
+          sterling section bullet paragraph germandbls registered copyright trademark acute
+          dieresis notequal AE Oslash infinity plusminus lessequal greaterequal yen mu
+          partialdiff summation product pi integral ordfeminine ordmasculine Omega ae oslash
+          questiondown exclamdown logicalnot radical florin approxequal Delta guillemotleft
+          guillemotright ellipsis nonbreakingspace Agrave Atilde Otilde OE oe endash emdash
+          quotedblleft quotedblright quoteleft quoteright divide lozenge ydieresis Ydieresis
+          fraction currency guilsinglleft guilsinglright fi fl daggerdbl periodcentered
+          quotesinglbase quotedblbase perthousand Acircumflex Ecircumflex Aacute Edieresis
+          Egrave Iacute Icircumflex Idieresis Igrave Oacute Ocircumflex apple Ograve Uacute
+          Ucircumflex Ugrave dotlessi circumflex tilde macron breve dotaccent ring cedilla
+          hungarumlaut ogonek caron Lslash lslash Scaron scaron Zcaron zcaron brokenbar Eth
+          eth Yacute yacute Thorn thorn minus multiply onesuperior twosuperior threesuperior
+          onehalf onequarter threequarters franc Gbreve gbreve Idotaccent Scedilla scedilla
+          Cacute cacute Ccaron ccaron dcroat)
+
+        def glyph_for(code)
+          POSTSCRIPT_GLYPHS[code] || ".notdef"
+        end
+
+        private
+
+          def parse_format!
+            # do nothing. Format 1 is easy-sauce.
+          end
+      end
+    end
+  end
+end

lib/ttfunk/table/post/format10.rb

@@ -0,0 +1,35 @@
+require 'ttfunk/table/post/format10'
+require 'stringio'
+
+module TTFunk
+  class Table
+    class Post
+      module Format20
+        include Format10
+
+        def glyph_for(code)
+          index = @glyph_name_index[code]
+          if index <= 257
+            POSTSCRIPT_GLYPHS[index]
+          else
+            @names[index - 257] || ".notdef"
+          end
+        end
+
+        private
+
+          def parse_format!
+            number_of_glyphs = read(2, 'n').first
+            @glyph_name_index = read(number_of_glyphs*2, 'n*')
+            @names = []
+
+            strings = StringIO.new(io.read(offset + length - io.pos))
+            while !strings.eof?
+              length = strings.read(1).unpack("C").first
+              @names << strings.read(length)
+            end
+          end
+      end
+    end
+  end
+end

lib/ttfunk/table/post/format20.rb

@@ -0,0 +1,23 @@
+require 'ttfunk/table/post/format10'
+require 'stringio'
+
+module TTFunk
+  class Table
+    class Post
+      module Format25
+        include Format10
+
+        def glyph_for(code)
+          POSTSCRIPT_GLYPHS[code + @offsets[code]] || ".notdef"
+        end
+
+        private
+
+          def parse_format!
+            number_of_glyphs = read(2, 'n').first
+            @offsets = read(@number_of_glyphs, "c*")
+          end
+      end
+    end
+  end
+end

lib/ttfunk/table/post/format25.rb

@@ -0,0 +1,17 @@
+module TTFunk
+  class Table
+    class Post
+      module Format30
+        def glyph_for(code)
+          ".notdef"
+        end
+
+        private
+
+          def parse_format!
+            # do nothing. Format 3 is easy-sauce.
+          end
+      end
+    end
+  end
+end

lib/ttfunk/table/post/format30.rb

@@ -0,0 +1,17 @@
+module TTFunk
+  class Table
+    class Post
+      module Format40
+        def glyph_for(code)
+          @map[code] || 0xFFFF
+        end
+
+        private
+
+          def parse_format!
+            @map = read(file.maximum_profile.num_glyphs * 2, "N*")
+          end
+      end
+    end
+  end
+end