prawn 0.15.0 → 1.0.0.rc1

data/lib/prawn/document/page_geometry.rb

@@ -0,0 +1,136 @@
+# encoding: utf-8
+
+# page_geometry.rb : Describes PDF page geometries
+#
+# Copyright April 2008, Gregory Brown.  All Rights Reserved.
+#
+# This is free software. Please see the LICENSE and COPYING files for details.
+
+module Prawn
+  class Document
+    
+    # Dimensions pulled from PDF::Writer, rubyforge.org/projects/ruby-pdf
+    # 
+    # All of these dimensions are in PDF Points, see Prawn::Measurements for
+    # conversion utilities.
+    # 
+    # Additionally, if the size you are after is not listed below, you can always
+    # specify your size by passing an array of width and height to Prawn::Document.new
+    # like:
+    # 
+    #  Prawn::Document.new(:page_size => [1000, 20000])
+    #
+    # The sizes below can be used by passing the appropriate string to :size:
+    # 
+    #  Prawn::Document.new(:page_size => '2A0')
+    # 
+    # ===Inbuilt Sizes:
+    # 
+    # 
+    # 4A0:: => 4767.87 x 6740.79
+    # 2A0:: => 3370.39 x 4767.87
+    # A0:: => 2383.94 x 3370.39
+    # A1:: => 1683.78 x 2383.94
+    # A2:: => 1190.55 x 1683.78
+    # A3:: => 841.89 x 1190.55
+    # A4:: => 595.28 x 841.89
+    # A5:: => 419.53 x 595.28
+    # A6:: => 297.64 x 419.53
+    # A7:: => 209.76 x 297.64
+    # A8:: => 147.40 x 209.76
+    # A9:: => 104.88 x 147.40
+    # A10:: => 73.70 x 104.88
+    # B0:: => 2834.65 x 4008.19
+    # B1:: => 2004.09 x 2834.65
+    # B2:: => 1417.32 x 2004.09
+    # B3:: => 1000.63 x 1417.32
+    # B4:: => 708.66 x 1000.63
+    # B5:: => 498.90 x 708.66
+    # B6:: => 354.33 x 498.90
+    # B7:: => 249.45 x 354.33
+    # B8:: => 175.75 x 249.45
+    # B9:: => 124.72 x 175.75
+    # B10:: => 87.87 x 124.72
+    # C0:: => 2599.37 x 3676.54
+    # C1:: => 1836.85 x 2599.37
+    # C2:: => 1298.27 x 1836.85
+    # C3:: => 918.43 x 1298.27
+    # C4:: => 649.13 x 918.43
+    # C5:: => 459.21 x 649.13
+    # C6:: => 323.15 x 459.21
+    # C7:: => 229.61 x 323.15
+    # C8:: => 161.57 x 229.61
+    # C9:: => 113.39 x 161.57
+    # C10:: => 79.37 x 113.39
+    # RA0:: => 2437.80 x 3458.27
+    # RA1:: => 1729.13 x 2437.80
+    # RA2:: => 1218.90 x 1729.13
+    # RA3:: => 864.57 x 1218.90
+    # RA4:: => 609.45 x 864.57
+    # SRA0:: => 2551.18 x 3628.35
+    # SRA1:: => 1814.17 x 2551.18
+    # SRA2:: => 1275.59 x 1814.17
+    # SRA3:: => 907.09 x 1275.59
+    # SRA4:: => 637.80 x 907.09
+    # EXECUTIVE:: => 521.86 x 756.00
+    # FOLIO:: => 612.00 x 936.00
+    # LEGAL:: => 612.00 x 1008.00
+    # LETTER:: => 612.00 x 792.00
+    # TABLOID:: => 792.00 x 1224.00 
+    #
+    module PageGeometry
+
+      SIZES = { "4A0" => [4767.87, 6740.79],
+                "2A0" => [3370.39, 4767.87],
+                 "A0" => [2383.94, 3370.39],
+                 "A1" => [1683.78, 2383.94],
+                 "A2" => [1190.55, 1683.78],
+                 "A3" => [841.89, 1190.55],
+                 "A4" => [595.28, 841.89],
+                 "A5" => [419.53, 595.28],
+                 "A6" => [297.64, 419.53],
+                 "A7" => [209.76, 297.64],
+                 "A8" => [147.40, 209.76],
+                 "A9" => [104.88, 147.40],
+                "A10" => [73.70, 104.88],
+                 "B0" => [2834.65, 4008.19],
+                 "B1" => [2004.09, 2834.65],
+                 "B2" => [1417.32, 2004.09],
+                 "B3" => [1000.63, 1417.32],
+                 "B4" => [708.66, 1000.63],
+                 "B5" => [498.90, 708.66],
+                 "B6" => [354.33, 498.90],
+                 "B7" => [249.45, 354.33],
+                 "B8" => [175.75, 249.45],
+                 "B9" => [124.72, 175.75],
+                "B10" => [87.87, 124.72],
+                 "C0" => [2599.37, 3676.54],
+                 "C1" => [1836.85, 2599.37],
+                 "C2" => [1298.27, 1836.85],
+                 "C3" => [918.43, 1298.27],
+                 "C4" => [649.13, 918.43],
+                 "C5" => [459.21, 649.13],
+                 "C6" => [323.15, 459.21],
+                 "C7" => [229.61, 323.15],
+                 "C8" => [161.57, 229.61],
+                 "C9" => [113.39, 161.57],
+                "C10" => [79.37, 113.39],
+                "RA0" => [2437.80, 3458.27],
+                "RA1" => [1729.13, 2437.80],
+                "RA2" => [1218.90, 1729.13],
+                "RA3" => [864.57, 1218.90],
+                "RA4" => [609.45, 864.57],
+               "SRA0" => [2551.18, 3628.35],
+               "SRA1" => [1814.17, 2551.18],
+               "SRA2" => [1275.59, 1814.17],
+               "SRA3" => [907.09, 1275.59],
+               "SRA4" => [637.80, 907.09],
+          "EXECUTIVE" => [521.86, 756.00],
+              "FOLIO" => [612.00, 936.00],
+              "LEGAL" => [612.00, 1008.00],
+             "LETTER" => [612.00, 792.00],
+            "TABLOID" => [792.00, 1224.00] }
+
+   end
+  end
+end

data/lib/prawn/document/snapshot.rb

@@ -10,9 +10,8 @@ require 'delegate'
 
 module Prawn
   class Document
-    # @private
-    
     module Snapshot
+
       RollbackTransaction = Class.new(StandardError)
 
       # Call this within a +transaction+ block to roll back the transaction and
@@ -28,7 +27,7 @@ module Prawn
       # +rollback+ is called or a RollbackTransaction exception is raised
       # inside the block, all actions taken inside the block will be rolled
       # back (with the exception of y-position, which you must restore
-      # yourself).
+      # yourself). 
       #
       # Returns true on success, or false if the transaction was rolled back.
       #
@@ -42,7 +41,7 @@ module Prawn
       end
 
       private
-
+      
       # Takes a current snapshot of the document's state, sufficient to
       # reconstruct it after it was amended.
       #
@@ -51,10 +50,10 @@ module Prawn
         # monotonically as data is added to the document, so we share that
         # between the old and new copies.
         {:page_content    => state.page.content.deep_copy,
-         :current_page    => state.page.dictionary.deep_copy([:Parent]),
+         :current_page    => state.page.dictionary.deep_copy(share=[:Parent]),
          :bounds          => bounds.deep_copy,
          :page_number     => page_number,
-         :page_kids       => state.store.pages.data[:Kids].compact.map{|kid| kid.identifier},
+         :page_kids       => state.store.pages.data[:Kids].map{|kid| kid.identifier},
          :dests           => names? && names.data[:Dests].deep_copy}
       end
 
@@ -81,7 +80,7 @@ module Prawn
         self.bounds = BoundingBox.restore_deep_copy(shot[:bounds], self)
 
         if shot[:dests]
-          names.data[:Dests] = shot[:dests]
+          names.data[:Dests] = shot[:dests] 
         end
       end
 

data/lib/prawn/document/span.rb

@@ -8,10 +8,8 @@
 
 module Prawn
   class Document
-    # @group Stable API
-
-    # A span is a special purpose bounding box that allows a column of
-    # elements to be positioned relative to the margin_box.
+    # A span is a special purpose bounding box that allows a column of 
+    # elements to be positioned relative to the margin_box.  
     #
     # Arguments:
     # +width+:: The width of the column in PDF points
@@ -19,23 +17,23 @@ module Prawn
     # Options:
     # <tt>:position</tt>:: One of :left, :center, :right or an x offset
     #
-    # This method is typically used for flowing a column of text from one
+    # This method is typically used for flowing a column of text from one 
     # page to the next.
     #
     #  span(350, :position => :center) do
     #    text "Here's some centered text in a 350 point column. " * 100
     #  end
-    #
+    #  
     def span(width, options={})
       Prawn.verify_options [:position], options
-      original_position = self.y
-
+      original_position = self.y      
+     
       # FIXME: Any way to move this upstream?
       left_boundary = case(options[:position] || :left)
       when :left
         margin_box.absolute_left
       when :center
-        margin_box.absolute_left + margin_box.width / 2.0 - width / 2.0
+        margin_box.absolute_left + margin_box.width / 2.0 - width /2.0
       when :right
         margin_box.absolute_right - width
       when Numeric
@@ -43,15 +41,15 @@ module Prawn
       else
         raise ArgumentError, "Invalid option for :position"
       end
-
+      
       # we need to bust out of whatever nested bounding boxes we're in.
       canvas do
-        bounding_box([left_boundary,
+        bounding_box([left_boundary, 
                       margin_box.absolute_top], :width => width) do
           self.y = original_position
           yield
         end
-      end
+      end          
     end
   end
 end

data/lib/prawn/encoding.rb

@@ -5,7 +5,7 @@
 # This is free software. Please see the LICENSE and COPYING files for details.
 #
 module Prawn
-  module Encoding # @private
+  module Encoding
     # Map between unicode and WinAnsiEnoding
     #
     class WinAnsi #:nodoc:
@@ -18,7 +18,7 @@ module Prawn
         .notdef       .notdef        .notdef        .notdef
         .notdef       .notdef        .notdef        .notdef
         .notdef       .notdef        .notdef        .notdef
-
+        
         space         exclam         quotedbl       numbersign
         dollar        percent        ampersand      quotesingle
         parenleft     parenright     asterisk       plus
@@ -54,7 +54,7 @@ module Prawn
         quotedblright bullet         endash         emdash
         tilde         trademark      scaron         guilsinglright
         oe            .notdef        zcaron         ydieresis
-
+       
         space         exclamdown     cent           sterling
         currency      yen            brokenbar      section
         dieresis      copyright      ordfeminine    guillemotleft
@@ -81,10 +81,10 @@ module Prawn
         ocircumflex   otilde         odieresis      divide
         oslash        ugrave         uacute         ucircumflex
         udieresis     yacute         thorn          ydieresis
-      ]
-
+      ]    
+      
       def initialize
-        @mapping_file = "#{Prawn::DATADIR}/encodings/win_ansi.txt"
+        @mapping_file = "#{Prawn::BASEDIR}/data/encodings/win_ansi.txt"
         load_mapping if self.class.mapping.empty?
       end
 
@@ -100,7 +100,7 @@ module Prawn
         # Replace anything else with an underscore
         self.class.mapping[codepoint] || 95
       end
-
+      
       def self.mapping
         @mapping ||= {}
       end
@@ -108,9 +108,10 @@ module Prawn
       private
 
       def load_mapping
-        File.open(@mapping_file, "r:BINARY") do |f|
+        RUBY_VERSION >= "1.9" ? mode = "r:BINARY" : mode = "r"
+        File.open(@mapping_file, mode) do |f|
           f.each do |l|
-            _, single_byte, unicode = *l.match(/([0-9A-Za-z]+);([0-9A-F]{4})/)
+            m, single_byte, unicode = *l.match(/([0-9A-Za-z]+);([0-9A-F]{4})/)
             self.class.mapping["0x#{unicode}".hex] = "0x#{single_byte}".hex if single_byte
           end
         end

data/lib/prawn/errors.rb

@@ -8,18 +8,25 @@
 #
 module Prawn
   module Errors
-     # Raised when a table is spanned in an impossible way.
+     
+     # This error is raised when Prawn::PdfObject() encounters a Ruby object it
+     # cannot convert to PDF
      #
-     InvalidTableSpan = Class.new(StandardError)
-
-     # This error is raised when a method requiring a current page is called
+     FailedObjectConversion = Class.new(StandardError)
+     
+     # This error is raised when Document#page_layout is set to anything
+     # other than :portrait or :landscape            
+     #
+     InvalidPageLayout = Class.new(StandardError)       
+     
+     # This error is raised when a method requiring a current page is called 
      # without being on a page.
      #
      NotOnPage = Class.new(StandardError)
-
-     # This error is raised when Prawn cannot find a specified font
+     
+     # This error is raised when Prawn cannot find a specified font   
      #
-     UnknownFont = Class.new(StandardError)
+     UnknownFont = Class.new(StandardError)   
 
      # Raised when Prawn is asked to draw something into a too-small box
      #
@@ -28,18 +35,18 @@ module Prawn
      # Raised if group() is called with a block that is too big to be
      # rendered in the current context.
      #
-     CannotGroup = Class.new(StandardError)
+     CannotGroup = Class.new(StandardError) 
 
      # This error is raised when Prawn is being used on a M17N aware VM,
      # and the user attempts to add text that isn't compatible with UTF-8
      # to their document
      #
      IncompatibleStringEncoding = Class.new(StandardError)
-
+     
      # This error is raised when Prawn encounters an unknown key in functions
      # that accept an options hash.  This usually means there is a typo in your
      # code or that the option you are trying to use has a different name than
-     # what you have specified.
+     # what you have specified. 
      #
      UnknownOption = Class.new(StandardError)
 
@@ -59,22 +66,30 @@ module Prawn
     # This error is raised when an object is attempted to be
     # referenced by name, but no such name is associated with an object
     UndefinedObjectName = Class.new(StandardError)
-
+    
     # This error is raised when a required option has not been set
     RequiredOption = Class.new(StandardError)
-
+    
     # This error is raised when a requested outline item with a given title does not exist
     UnknownOutlineTitle = Class.new(StandardError)
 
     # This error is raised when a block is required, but not provided
     BlockRequired = Class.new(StandardError)
-
+    
     # This error is rased when a graphics method is called with improper arguments
     InvalidGraphicsPath = Class.new(StandardError)
+    
+    # This error is raised when Prawn fails to load a template file
+    #
+    TemplateError = Class.new(StandardError)
+    
+    # This error is raise when trying to restore a graphic state that 
+    #
+    EmptyGraphicStateStack = Class.new(StandardError)
 
     # Raised when unrecognized content is provided for a table cell.
     #
     UnrecognizedTableContent = Class.new(StandardError)
-
+    
   end
-end
+end   

data/lib/prawn/font.rb

@@ -6,16 +6,13 @@
 #
 # This is free software. Please see the LICENSE and COPYING files for details.
 #
-require_relative "font/afm"
-require_relative "font/ttf"
-require_relative "font/dfont"
-require_relative "font_metric_cache"
+require "prawn/font/afm"
+require "prawn/font/ttf"
+require "prawn/font/dfont"
 
 module Prawn
 
   class Document
-    # @group Stable API
-
     # Without arguments, this returns the currently selected font. Otherwise,
     # it sets the current font. When a block is used, the font is applied
     # transactionally and is rolled back when the block exits.
@@ -41,7 +38,7 @@ module Prawn
     #
     # If a ttf font is specified, the glyphs necessary to render your document
     # will be embedded in the rendered PDF. This should be your preferred option
-    # in most cases. It will increase the size of the resulting file, but also
+    # in most cases. It will increase the size of the resulting file, but also 
     # make it more portable.
     #
     # The options parameter is an optional hash providing size and style. To use
@@ -52,9 +49,9 @@ module Prawn
       return((defined?(@font) && @font) || font("Helvetica")) if name.nil?
 
       if state.pages.empty? && !state.page.in_stamp_stream?
-        raise Prawn::Errors::NotOnPage
+        raise Prawn::Errors::NotOnPage 
       end
-
+      
       new_font = find_font(name.to_s, options)
 
       if block_given?
@@ -69,10 +66,7 @@ module Prawn
       @font
     end
 
-    # @method font_size(points=nil)
-    #
     # When called with no argument, returns the current font size.
-    #
     # When called with a single argument but no block, sets the current font
     # size.  When a block is used, the font size is applied transactionally and
     # is rolled back when the block exits.  You may still change the font size
@@ -103,44 +97,59 @@ module Prawn
       @font_size = size_before_yield
     end
 
-    # Sets the font size
-    def font_size=(size)
-      font_size(size)
+    # Sets the font directly, given an actual Font object
+    # and size.
+    #
+    def set_font(font, size=nil) # :nodoc:
+      @font = font
+      @font_size = size if size
     end
 
-    # Returns the width of the given string using the given font. If :size is not
-    # specified as one of the options, the string is measured using the current
-    # font size. You can also pass :kerning as an option to indicate whether
-    # kerning should be used when measuring the width (defaults to +false+).
-    #
-    # Note that the string _must_ be encoded properly for the font being used.
-    # For AFM fonts, this is WinAnsi. For TTF, make sure the font is encoded as
-    # UTF-8. You can use the Font#normalize_encoding method to make sure strings
-    # are in an encoding appropriate for the current font.
-    #--
-    # For the record, this method used to be a method of Font (and still delegates
-    # to width computations on Font). However, having the primary interface for
-    # calculating string widths exist on Font made it tricky to write extensions
-    # for Prawn in which widths are computed differently (e.g., taking formatting
-    # tags into account, or the like).
+    # Saves the current font, and then yields. When the block
+    # finishes, the original font is restored.
     #
-    # By putting width_of here, on Document itself, extensions may easily override
-    # it and redefine the width calculation behavior.
-    #++
-    def width_of(string, options={})
-      if p = options[:inline_format]
-        p = [] unless p.is_a?(Array)
+    def save_font
+      @font ||= find_font("Helvetica")
+      original_font = @font
+      original_size = @font_size
 
-        # Build up an Arranger with the entire string on one line, finalize it,
-        # and find its width.
-        arranger = Prawn::Text::Formatted::Arranger.new(self, options)
-        arranger.consumed = self.text_formatter.format(string, *p)
-        arranger.finalize_line
+      yield
+    ensure
+      set_font(original_font, original_size) if original_font
+    end
 
-        arranger.line_width
-      else
-        width_of_string(string, options)
-      end
+    # Looks up the given font using the given criteria. Once a font has been
+    # found by that matches the criteria, it will be cached to subsequent lookups
+    # for that font will return the same object.
+    #--
+    # Challenges involved: the name alone is not sufficient to uniquely identify
+    # a font (think dfont suitcases that can hold multiple different fonts in a
+    # single file). Thus, the :name key is included in the cache key.
+    #
+    # It is further complicated, however, since fonts in some formats (like the
+    # dfont suitcases) can be identified either by numeric index, OR by their
+    # name within the suitcase, and both should hash to the same font object
+    # (to avoid the font being embedded multiple times). This is not yet implemented,
+    # which means if someone selects a font both by name, and by index, the
+    # font will be embedded twice. Since we do font subsetting, this double
+    # embedding won't be catastrophic, just annoying.
+    # ++
+    def find_font(name, options={}) #:nodoc: 
+      if font_families.key?(name) 
+        family, name = name, font_families[name][options[:style] || :normal] 
+        if name.is_a?(Hash) 
+          options = options.merge(name) 
+          name = options[:file] 
+        end 
+      end 
+      key = "#{name}:#{options[:font] || 0}" 
+      font_registry[key] ||= Font.load(self, name, options.merge(:family => family)) 
+    end 
+    
+    # Hash of Font objects keyed by names
+    #
+    def font_registry #:nodoc:
+      @font_registry ||= {}
     end
 
     # Hash that maps font family names to their styled individual font names.
@@ -164,12 +173,13 @@ module Prawn
     # wish to support.
     #
     # By default the styles :bold, :italic, :bold_italic, and :normal are
-    # defined for fonts "Courier", "Times-Roman" and "Helvetica". When
-    # defining your own font families, you can map any or all of these
-    # styles to whatever font files you'd like.
+    # defined for fonts "Courier", "Times-Roman" and "Helvetica".
+    #
+    # You probably want to provide those four styles, but are free to define
+    # custom ones, like :thin, and use them in font calls.
     #
     def font_families
-      @font_families ||= {}.merge!(
+      @font_families ||= Hash.new.merge!(
         { "Courier"     => { :bold        => "Courier-Bold",
                              :italic      => "Courier-Oblique",
                              :bold_italic => "Courier-BoldOblique",
@@ -187,79 +197,45 @@ module Prawn
         })
     end
 
-    # @group Experimental API
-
-    # Sets the font directly, given an actual Font object
-    # and size.
-    #
-    def set_font(font, size=nil) # :nodoc:
-      @font = font
-      @font_size = size if size
-    end
-
-    # Saves the current font, and then yields. When the block
-    # finishes, the original font is restored.
+    # Returns the width of the given string using the given font. If :size is not
+    # specified as one of the options, the string is measured using the current
+    # font size. You can also pass :kerning as an option to indicate whether
+    # kerning should be used when measuring the width (defaults to +false+).
     #
-    def save_font
-      @font ||= find_font("Helvetica")
-      original_font = @font
-      original_size = @font_size
-
-      yield
-    ensure
-      set_font(original_font, original_size) if original_font
-    end
-
-    # Looks up the given font using the given criteria. Once a font has been
-    # found by that matches the criteria, it will be cached to subsequent lookups
-    # for that font will return the same object.
+    # Note that the string _must_ be encoded properly for the font being used.
+    # For AFM fonts, this is WinAnsi. For TTF, make sure the font is encoded as
+    # UTF-8. You can use the Font#normalize_encoding method to make sure strings
+    # are in an encoding appropriate for the current font.
     #--
-    # Challenges involved: the name alone is not sufficient to uniquely identify
-    # a font (think dfont suitcases that can hold multiple different fonts in a
-    # single file). Thus, the :name key is included in the cache key.
-    #
-    # It is further complicated, however, since fonts in some formats (like the
-    # dfont suitcases) can be identified either by numeric index, OR by their
-    # name within the suitcase, and both should hash to the same font object
-    # (to avoid the font being embedded multiple times). This is not yet implemented,
-    # which means if someone selects a font both by name, and by index, the
-    # font will be embedded twice. Since we do font subsetting, this double
-    # embedding won't be catastrophic, just annoying.
-    # ++
-    #
-    # @private
-    def find_font(name, options={}) #:nodoc:
-      if font_families.key?(name)
-        family, name = name, font_families[name][options[:style] || :normal]
-        if name.is_a?(::Hash)
-          options = options.merge(name)
-          name = options[:file]
-        end
-      end
-      key = "#{name}:#{options[:font] || 0}"
-      font_registry[key] ||= Font.load(self, name, options.merge(:family => family))
-    end
-
-    # Hash of Font objects keyed by names
+    # For the record, this method used to be a method of Font (and still delegates
+    # to width computations on Font). However, having the primary interface for
+    # calculating string widths exist on Font made it tricky to write extensions
+    # for Prawn in which widths are computed differently (e.g., taking formatting
+    # tags into account, or the like).
     #
-    def font_registry #:nodoc:
-      @font_registry ||= {}
-    end
-
-    private
-
-    def width_of_inline_formatted_string(string, options={})
-      # Build up an Arranger with the entire string on one line, finalize it,
-      # and find its width.
-      arranger = Prawn::Text::Formatted::Arranger.new(self, options)
-      arranger.consumed = Text::Formatted::Parser.format(string)
-      arranger.finalize_line
-
-      arranger.line_width
-    end
+    # By putting width_of here, on Document itself, extensions may easily override
+    # it and redefine the width calculation behavior.
+    #++
+    def width_of(string, options={})
+      if options[:inline_format]
+        # Build up an Arranger with the entire string on one line, finalize it,
+        # and find its width.
+        arranger = Core::Text::Formatted::Arranger.new(self, options)
+        arranger.consumed = Text::Formatted::Parser.to_array(string)
+        arranger.finalize_line
 
-    def width_of_string(string, options={})
-      font_metric_cache.width_of( string, options )
+        arranger.line_width
+      else
+        f = if options[:style]
+              # override style with :style => :bold
+              find_font(@font ? @font.name : 'Helvetica',
+                        :style => options[:style])
+            else
+              font
+            end
+        f.compute_width_of(string, options) +
+          (character_spacing * font.character_count(string))
+      end
     end
   end
 
@@ -281,7 +257,7 @@ module Prawn
     # will be passed through to Font::AFM.new()
     #
     def self.load(document,name,options={})
-      case name.to_s
+      case name
       when /\.ttf$/i   then TTF.new(document, name, options)
       when /\.dfont$/i then DFont.new(document, name, options)
       when /\.afm$/i   then AFM.new(document, name, options)
@@ -301,7 +277,7 @@ module Prawn
       @references = {}
     end
 
-    # The size of the font ascender in PDF points
+    # The size of the font ascender in PDF points 
     #
     def ascender
       @ascender / 1000.0 * size
@@ -319,6 +295,14 @@ module Prawn
       @line_gap / 1000.0 * size
     end
 
+    def identifier_for(subset)
+      "#{@identifier}.#{subset}".to_sym
+    end
+
+    def inspect
+      "#{self.class.name}< #{name}: #{size} >"
+    end
+
     # Normalizes the encoding of the string to an encoding supported by the
     # font. The string is expected to be UTF-8 going in. It will be re-encoded
     # and the new string will be returned. For an in-place (destructive)
@@ -364,22 +348,6 @@ module Prawn
       "#{self.class.name}< #{name}: #{size} >"
     end
 
-    # Return a hash (as in Object#hash) for the font based on the output of
-    # #inspect. This is required since font objects are used as keys in hashes
-    # that cache certain values (See
-    # Prawn::Table::Text#styled_with_of_single_character)
-    #
-    def hash #:nodoc:
-      [ self.class, self.name, self.family, size ].hash
-    end
-
-    # Compliments the #hash implementation above
-    #
-    def eql?( other ) #:nodoc:
-      self.class == other.class && self.name == other.name &&
-        self.family == other.family && size == other.send(:size)
-    end
-
     private
 
     # generate a font identifier that hasn't been used on the curretn page yet