prawn 1.0.0.rc2 → 1.0.0

data/lib/prawn/font/afm.rb

@@ -6,11 +6,13 @@
 #
 # This is free software. Please see the LICENSE and COPYING files for details.
 
-require 'prawn/encoding'
-require 'afm'
+require_relative '../../prawn/encoding'
 
 module Prawn
   class Font
+
+    # @private
+
     class AFM < Font
       BUILT_INS = %w[ Courier Helvetica Times-Roman Symbol ZapfDingbats
                       Courier-Bold Courier-Oblique Courier-BoldOblique
@@ -49,21 +51,23 @@ module Prawn
         file_name << ".afm" unless file_name =~ /\.afm$/
         file_name = file_name[0] == ?/ ? file_name : find_font(file_name)
 
-        font_data = @@font_data[file_name] ||= ::AFM::Font.new(file_name)
-        @glyph_table     = build_glyph_table(font_data)
-        @kern_pairs      = font_data.kern_pairs
-        @kern_pair_table = build_kern_pair_table(@kern_pairs)
-        @attributes      = font_data.metadata
+        font_data = @@font_data[file_name] ||= parse_afm(file_name)
+        @glyph_widths    = font_data[:glyph_widths]
+        @glyph_table     = font_data[:glyph_table]
+        @bounding_boxes  = font_data[:bounding_boxes]
+        @kern_pairs      = font_data[:kern_pairs]
+        @kern_pair_table = font_data[:kern_pair_table]
+        @attributes      = font_data[:attributes]
 
-        @ascender  = @attributes["Ascender"].to_i
-        @descender = @attributes["Descender"].to_i
+        @ascender  = @attributes["ascender"].to_i
+        @descender = @attributes["descender"].to_i
         @line_gap  = Float(bbox[3] - bbox[1]) - (@ascender - @descender)
       end
 
       # The font bbox, as an array of integers
       #
       def bbox
-        @bbox ||= @attributes['FontBBox'].split(/\s+/).map { |e| Integer(e) }
+        @bbox ||= @attributes['fontbbox'].split(/\s+/).map { |e| Integer(e) }
       end
 
       # NOTE: String *must* be encoded as WinAnsi
@@ -89,7 +93,7 @@ module Prawn
       # string. Changes the encoding in-place, so the argument itself
       # is replaced with a string in WinAnsi encoding.
       #
-      def normalize_encoding(text) 
+      def normalize_encoding(text)
         enc = @@winansi
         text.unpack("U*").collect { |i| enc[i] }.pack("C*")
       rescue ArgumentError
@@ -141,7 +145,7 @@ module Prawn
       end
 
       def symbolic?
-        attributes["CharacterSet"] == "Special"
+        attributes["characterset"] == "Special"
       end
 
       def find_font(file)
@@ -152,6 +156,61 @@ module Prawn
            self.class.metrics_path.join("\n")
       end
 
+      def parse_afm(file_name)
+        data    = {:glyph_widths => {}, :bounding_boxes => {}, :kern_pairs => {}, :attributes => {}}         
+        section = []
+
+        File.foreach(file_name) do |line|
+          case line
+          when /^Start(\w+)/
+            section.push $1
+            next
+          when /^End(\w+)/
+            section.pop
+            next
+          end
+
+          case section
+          when ["FontMetrics", "CharMetrics"]
+            next unless line =~ /^CH?\s/
+
+            name                        = line[/\bN\s+(\.?\w+)\s*;/, 1]
+            data[:glyph_widths][name]   = line[/\bWX\s+(\d+)\s*;/, 1].to_i
+            data[:bounding_boxes][name] = line[/\bB\s+([^;]+);/, 1].to_s.rstrip
+          when ["FontMetrics", "KernData", "KernPairs"]
+            next unless line =~ /^KPX\s+(\.?\w+)\s+(\.?\w+)\s+(-?\d+)/
+            data[:kern_pairs][[$1, $2]] = $3.to_i
+          when ["FontMetrics", "KernData", "TrackKern"],
+            ["FontMetrics", "Composites"]
+            next
+          else
+            parse_generic_afm_attribute(line, data)
+          end
+        end
+        
+        # process data parsed from AFM file to build tables which
+        #   will be used when measuring and kerning text
+        data[:glyph_table] = (0..255).map do |i|
+          data[:glyph_widths][Encoding::WinAnsi::CHARACTERS[i]].to_i
+        end
+
+        character_hash = Hash[Encoding::WinAnsi::CHARACTERS.zip((0..Encoding::WinAnsi::CHARACTERS.size).to_a)]
+        data[:kern_pair_table] = data[:kern_pairs].inject({}) do |h,p|
+          h[p[0].map { |n| character_hash[n] }] = p[1]
+          h
+        end
+
+        data.each_value { |hash| hash.freeze }
+        data.freeze
+      end
+
+      def parse_generic_afm_attribute(line, hash)
+        line =~ /(^\w+)\s+(.*)/
+        key, value = $1.to_s.downcase, $2
+
+        hash[:attributes][key] = hash[:attributes][key] ? Array(hash[:attributes][key]) << value : value
+      end
+
       # converts a string into an array with spacing offsets
       # bewteen characters that need to be kerned
       #
@@ -161,37 +220,22 @@ module Prawn
         kerned = [[]]
         last_byte = nil
 
-        string.bytes do |byte|
+        string.each_byte do |byte|
           if k = last_byte && @kern_pair_table[[last_byte, byte]]
             kerned << -k << [byte]
           else
             kerned.last << byte
-          end         
+          end
           last_byte = byte
         end
 
-        kerned.map { |e| 
+        kerned.map { |e|
           e = (Array === e ? e.pack("C*") : e)
-          e.respond_to?(:force_encoding) ? e.force_encoding("Windows-1252") : e  
+          e.respond_to?(:force_encoding) ? e.force_encoding(::Encoding::Windows_1252) : e
         }
       end
       
-      def build_kern_pair_table(kern_pairs)
-        character_hash = Hash[Encoding::WinAnsi::CHARACTERS.zip((0..Encoding::WinAnsi::CHARACTERS.size).to_a)]
-        kern_pairs.inject({}) do |h,p|
-          h[
-            [character_hash[p[0]], character_hash[p[1]]]
-          ] = p[2]
-          h
-        end
-      end
-
-      def build_glyph_table(font_data)
-        (0..255).map do |char|
-          metrics = font_data.metrics_for(char)
-          metrics ? metrics[:wx] : 0
-        end
-      end
+      private
       
       def unscaled_width_of(string)
         string.bytes.inject(0) do |s,r|

data/lib/prawn/font/dfont.rb

@@ -6,12 +6,13 @@
 #
 # This is free software. Please see the LICENSE and COPYING files for details.
 #
-require 'prawn/font/ttf'
+require_relative 'ttf'
 
 module Prawn
   class Font
+    # @private
     class DFont < TTF
-      
+
       # Returns a list of the names of all named fonts in the given dfont file.
       # Note that fonts are not required to be named in a dfont file, so the
       # list may be empty even if the file does contain fonts. Also, note that
@@ -32,7 +33,7 @@ module Prawn
         end
       end
 
-      private 
+      private
 
       def read_ttf_file
         TTFunk::File.from_dfont(@name, @options[:font] || 0)

data/lib/prawn/font/ttf.rb

@@ -2,7 +2,7 @@
 
 # prawn/font/ttf.rb : Implements AFM font support for Prawn
 #
-# Copyright May 2008, Gregory Brown / James Healy / Jamis Buck  
+# Copyright May 2008, Gregory Brown / James Healy / Jamis Buck
 # All Rights Reserved.
 #
 # This is free software. Please see the LICENSE and COPYING files for details.
@@ -12,13 +12,15 @@ require 'ttfunk/subset_collection'
 
 module Prawn
   class Font
+
+    # @private
     class TTF < Font
       attr_reader :ttf, :subsets
 
       def unicode?
         true
       end
-      
+
       def initialize(document, name, options={})
         super
 
@@ -26,8 +28,8 @@ module Prawn
         @subsets          = TTFunk::SubsetCollection.new(@ttf)
 
         @attributes       = {}
-        @bounding_boxes   = {} 
-        @char_widths      = {}   
+        @bounding_boxes   = {}
+        @char_widths      = {}
         @has_kerning_data = @ttf.kerning.exists? && @ttf.kerning.tables.any?
 
         @ascender         = Integer(@ttf.ascent * scale_factor)
@@ -42,7 +44,7 @@ module Prawn
           kern(string).inject(0) do |s,r|
             if r.is_a?(Numeric)
               s - r
-            else 
+            else
               r.inject(s) { |s2, u| s2 + character_width_by_code(u) }
             end
           end * scale
@@ -51,17 +53,17 @@ module Prawn
             s + character_width_by_code(r)
           end * scale
         end
-      end   
-     
+      end
+
       # The font bbox, as an array of integers
-      # 
+      #
       def bbox
         @bbox ||= @ttf.bbox.map { |i| Integer(i * scale_factor) }
       end
 
       # Returns true if the font has kerning data, false otherwise
       def has_kerning_data?
-        @has_kerning_data 
+        @has_kerning_data
       end
 
       # Perform any changes to the string that need to happen
@@ -77,7 +79,7 @@ module Prawn
 
         if options[:kerning]
           last_subset = nil
-          kern(text).inject([]) do |result, element| 
+          kern(text).inject([]) do |result, element|
             if element.is_a?(Numeric)
               result.last[1] = [result.last[1]] unless result.last[1].is_a?(Array)
               result.last[1] << element
@@ -102,7 +104,7 @@ module Prawn
           @subsets.encode(text.unpack("U*"))
         end
       end
-      
+
       def basename
         @basename ||= @ttf.name.postscript_name
       end
@@ -160,7 +162,15 @@ module Prawn
       end
 
       def normalize_encoding(text)
-        text.normalize_to_utf8
+        begin
+          text.encode(::Encoding::UTF_8)
+        rescue => e
+          puts e
+          raise Prawn::Errors::IncompatibleStringEncoding, "Encoding " +
+            "#{text.encoding} can not be transparently converted to UTF-8. " +
+            "Please ensure the encoding of the string you are attempting " +
+            "to use is set correctly"
+        end
       end
 
       def glyph_present?(char)
@@ -171,7 +181,7 @@ module Prawn
       # Returns the number of characters in +str+ (a UTF-8-encoded string).
       #
       def character_count(str)
-        str.unicode_length
+        str.length
       end
 
       private
@@ -179,7 +189,7 @@ module Prawn
       def cmap
         @cmap ||= @ttf.cmap.unicode.first or raise("no unicode cmap for font")
       end
-      
+
       # +string+ must be UTF8-encoded.
       #
       # Returns an array. If an element is a numeric, it represents the
@@ -188,7 +198,7 @@ module Prawn
       def kern(string)
         a = []
 
-        string.codepoints do |r|
+        string.each_codepoint do |r|
           if a.empty?
             a << [r]
           elsif (kern = kern_pairs_table[[cmap[a.last.last], cmap[r]]])
@@ -215,7 +225,7 @@ module Prawn
         @hmtx ||= @ttf.horizontal_metrics
       end
 
-      def character_width_by_code(code)    
+      def character_width_by_code(code)
         return 0 unless cmap[code]
 
         # Some TTF fonts have nonzero widths for \n (UTF-8 / ASCII code: 10).
@@ -223,7 +233,7 @@ module Prawn
         return 0.0 if code == 10
 
         @char_widths[code] ||= Integer(hmtx.widths[cmap[code]] * scale_factor)
-      end                   
+      end
 
       def scale_factor
         @scale ||= 1000.0 / @ttf.header.units_per_em
@@ -233,7 +243,7 @@ module Prawn
         temp_name = @ttf.name.postscript_name.gsub("\0","").to_sym
         ref = @document.ref!(:Type => :Font, :BaseFont => temp_name)
 
-        # Embed the font metrics in the document after everything has been 
+        # Embed the font metrics in the document after everything has been
         # drawn, just before the document is emitted.
         @document.before_render { |doc| embed(ref, subset) }
 
@@ -254,11 +264,9 @@ module Prawn
 
         raise "Can't detect a postscript name for #{file}" if basename.nil?
 
-        compressed_font = Zlib::Deflate.deflate(font_content)
-
-        fontfile = @document.ref!(:Length1 => font_content.size,
-                                 :Filter => :FlateDecode )
-        fontfile << compressed_font
+        fontfile = @document.ref!(:Length1 => font_content.size)
+        fontfile.stream << font_content
+        fontfile.stream.compress!
 
         descriptor = @document.ref!(:Type        => :FontDescriptor,
                                    :FontName    => basename.to_sym,
@@ -289,7 +297,7 @@ module Prawn
         map = @subsets[subset].to_unicode_map
 
         ranges = [[]]
-        lines = map.keys.sort.inject("") do |s, code|
+        map.keys.sort.inject("") do |s, code|
           ranges << [] if ranges.last.length >= 100
           unicode = map[code]
           ranges.last << "<%02x><%04x>" % [code, unicode]
@@ -303,7 +311,7 @@ module Prawn
 
         cmap = @document.ref!({})
         cmap << to_unicode_cmap
-        cmap.compress_stream
+        cmap.stream.compress!
 
         reference.data.update(:Subtype => :TrueType,
                               :BaseFont => basename.to_sym,

data/lib/prawn/font_metric_cache.rb

@@ -0,0 +1,47 @@
+# encoding: utf-8
+#
+# font_metric_cache.rb : The Prawn font class
+#
+# Copyright Dec 2012, Kenneth Kalmer. All Rights Reserved.
+#
+# This is free software. Please see the LICENSE and COPYING files for details.
+#
+
+module Prawn
+
+  # Cache used internally by Prawn::Document instances to calculate the width
+  # of various strings for layout purposes.
+  #
+  # @private
+  class FontMetricCache 
+
+    CacheEntry = Struct.new( :font, :options, :string )
+
+    def initialize( document )
+      @document = document
+
+      @cache = {}
+    end
+
+    def width_of( string, options )
+      f = if options[:style]
+            # override style with :style => :bold
+            @document.find_font(@document.font ? @document.font.name : 'Helvetica',
+                      :style => options[:style])
+          else
+            @document.font
+          end
+
+      key = CacheEntry.new( f, options, string )
+
+      unless length = @cache[ key ]
+        length = @cache[ key ] = f.compute_width_of(string, options)
+      end
+
+      length +
+        (@document.character_spacing * @document.font.character_count(string))
+    end
+
+  end
+
+end

data/lib/prawn/graphics.rb

@@ -6,13 +6,14 @@
 #
 # This is free software. Please see the LICENSE and COPYING files for details.
 
-require "prawn/graphics/color"
-require "prawn/graphics/dash"
-require "prawn/graphics/cap_style"
-require "prawn/graphics/join_style"
-require "prawn/graphics/transparency"
-require "prawn/graphics/transformation"
-require "prawn/graphics/patterns"
+
+require_relative "graphics/color"
+require_relative "graphics/dash"
+require_relative "graphics/cap_style"
+require_relative "graphics/join_style"
+require_relative "graphics/transparency"
+require_relative "graphics/transformation"
+require_relative "graphics/patterns"
 
 module Prawn
 
@@ -32,6 +33,8 @@ module Prawn
     include Transformation
     include Patterns
 
+    # @group Stable API
+
     #######################################################################
     # Low level drawing operations must map the point to absolute coords! #
     #######################################################################
@@ -82,9 +85,9 @@ module Prawn
       x,y = map_to_absolute(point)
       add_content("%.3f %.3f %.3f %.3f re" % [ x, y - height, width, height ])
     end
-    
+
     # Draws a rounded rectangle given <tt>point</tt>, <tt>width</tt> and
-    # <tt>height</tt> and <tt>radius</tt> for the rounded corner. The rectangle 
+    # <tt>height</tt> and <tt>radius</tt> for the rounded corner. The rectangle
     # is bounded by its upper-left corner.
     #
     #    pdf.rounded_rectangle [300,300], 100, 200, 10
@@ -93,7 +96,7 @@ module Prawn
       x, y = point
       rounded_polygon(radius, point, [x + width, y], [x + width, y - height], [x, y - height])
     end
-    
+
 
     ###########################################################
     #  Higher level functions: May use relative coords        #
@@ -138,7 +141,7 @@ module Prawn
     # current <tt>y</tt> position, or the position specified by the :at option.
     #
     #  # draw a line from [25, 75] to [100, 75]
-    #  horizontal_line 25, 100, :at => 75  
+    #  horizontal_line 25, 100, :at => 75
     #
     def horizontal_line(x1,x2,options={})
       if options[:at]
@@ -146,7 +149,7 @@ module Prawn
       else
         y1 = y - bounds.absolute_bottom
       end
-      
+
       line(x1,y1,x2,y1)
     end
 
@@ -181,13 +184,6 @@ module Prawn
     #
     KAPPA = 4.0 * ((Math.sqrt(2) - 1.0) / 3.0)
 
-    # <b>DEPRECATED:</b> Please use <tt>circle</tt> instead.
-    def circle_at(point, options)
-      warn "[DEPRECATION] 'circle_at' is deprecated in favor of 'circle'. " +
-           "'circle_at' will be removed in release 1.1"
-      circle(point, options[:radius])
-    end
-
     # Draws a circle of radius <tt>radius</tt> with the centre-point at <tt>point</tt>
     # as a complete subpath. The drawing point will be moved to the
     # centre-point upon completion of the drawing the circle.
@@ -198,13 +194,6 @@ module Prawn
       ellipse(center, radius, radius)
     end
 
-    # <b>DEPRECATED:</b> Please use <tt>ellipse</tt> instead.
-    def ellipse_at(point, r1, r2=r1)
-      warn "[DEPRECATION] 'ellipse_at' is deprecated in favor of 'ellipse'. " +
-           "'ellipse_at' will be removed in release 1.1"
-      ellipse(point, r1, r2)
-    end
-
     # Draws an ellipse of +x+ radius <tt>r1</tt> and +y+ radius <tt>r2</tt>
     # with the centre-point at <tt>point</tt> as a complete subpath. The
     # drawing point will be moved to the centre-point upon completion of the
@@ -252,7 +241,7 @@ module Prawn
       # close the path
       add_content "h"
     end
-    
+
     # Draws a rounded polygon from specified points using the radius to define bezier curves
     #
     #  # draws a rounded filled in polygon
@@ -268,20 +257,19 @@ module Prawn
       # close the path
       add_content "h"
     end
-    
-    
+
+
     # Creates a rounded vertex for a line segment used for building a rounded polygon
     # requires a radius to define bezier curve and three points. The first two points define
     # the line segment and the third point helps define the curve for the vertex.
     def rounded_vertex(radius, *points)
-      x0,y0,x1,y1,x2,y2 = points.flatten
       radial_point_1 = point_on_line(radius, points[0], points[1])
       bezier_point_1 = point_on_line((radius - radius*KAPPA), points[0], points[1] )
       radial_point_2 = point_on_line(radius, points[2], points[1])
       bezier_point_2 = point_on_line((radius - radius*KAPPA), points[2], points[1])
       line_to(radial_point_1)
       curve_to(radial_point_2, :bounds => [bezier_point_1, bezier_point_2])
-    end      
+    end
 
     # Strokes the current path. If a block is provided, yields to the block
     # before closing the path. See Graphics::Color for color details.
@@ -298,13 +286,75 @@ module Prawn
       yield if block_given?
       add_content "s"
     end
-    
+
     # Draws and strokes a rectangle represented by the current bounding box
     #
     def stroke_bounds
       stroke_rectangle bounds.top_left, bounds.width, bounds.height
     end
 
+    # Draws and strokes X and Y axes rulers beginning at the current bounding
+    # box origin (or at a custom location).
+    #
+    # == Options
+    #
+    # +:at+::
+    #   Origin of the X and Y axes (default: [0, 0] = origin of the bounding
+    #   box)
+    #
+    # +:width+::
+    #   Length of the X axis (default: width of the bounding box)
+    #
+    # +:height+::
+    #   Length of the Y axis (default: height of the bounding box)
+    #
+    # +:step_length+::
+    #   Length of the step between markers (default: 100)
+    #
+    # +:negative_axes_length+::
+    #   Length of the negative parts of the axes (default: 20)
+    #
+    # +:color+:
+    #   The color of the axes and the text.
+    #
+    def stroke_axis(options = {})
+      options = {
+        :at => [0,0],
+        :height => bounds.height.to_i - (options[:at] || [0,0])[1],
+        :width => bounds.width.to_i - (options[:at] || [0,0])[0],
+        :step_length => 100,
+        :negative_axes_length => 20,
+        :color => "000000",
+      }.merge(options)
+
+      Prawn.verify_options([:at, :width, :height, :step_length,
+                            :negative_axes_length, :color], options)
+
+      save_graphics_state do
+        fill_color(options[:color])
+        stroke_color(options[:color])
+
+        dash(1, :space => 4)
+        stroke_horizontal_line(options[:at][0] - options[:negative_axes_length],
+                               options[:at][0] + options[:width], :at => options[:at][1])
+        stroke_vertical_line(options[:at][1] - options[:negative_axes_length],
+                             options[:at][1] + options[:height], :at => options[:at][0])
+        undash
+
+        fill_circle(options[:at], 1)
+
+        (options[:step_length]..options[:width]).step(options[:step_length]) do |point|
+          fill_circle([options[:at][0] + point, options[:at][1]], 1)
+          draw_text(point, :at => [options[:at][0] + point - 5, options[:at][1] - 10], :size => 7)
+        end
+
+        (options[:step_length]..options[:height]).step(options[:step_length]) do |point|
+          fill_circle([options[:at][0], options[:at][1] + point], 1)
+          draw_text(point, :at => [options[:at][0] - 17, options[:at][1] + point - 2], :size => 7)
+        end
+      end
+    end
+
     # Closes and fills the current path. See Graphics::Color for color details.
     #
     # If the option :fill_rule => :even_odd is specified, Prawn will use the
@@ -339,140 +389,210 @@ module Prawn
 
     ##
     # :method: stroke_rectangle
-    # Draws and strokes a rectangle given +point+, +width+ and +height+. The rectangle is bounded by its upper-left corner.
+    #
+    # Draws and strokes a rectangle given +point+, +width+ and +height+. The
+    # rectangle is bounded by its upper-left corner.
+    #
     # :call-seq:
     #   stroke_rectangle(point,width,height)
 
     ##
     # :method: fill_rectangle
-    # Draws and fills ills a rectangle given +point+, +width+ and +height+. The rectangle is bounded by its upper-left corner.
+    #
+    # Draws and fills ills a rectangle given +point+, +width+ and +height+. The
+    # rectangle is bounded by its upper-left corner.
+    #
     # :call-seq:
     #   fill_rectangle(point,width,height)
 
     ##
     # :method: fill_and_stroke_rectangle
-    # Draws, fills, and strokes a rectangle given +point+, +width+ and +height+. The rectangle is bounded by its upper-left corner.
+    #
+    # Draws, fills, and strokes a rectangle given +point+, +width+ and +height+.
+    # The rectangle is bounded by its upper-left corner.
+    #
     # :call-seq:
     #   fill_and_stroke_rectangle(point,width,height)
 
     ##
     # :method: stroke_rounded_rectangle
-    # Draws and strokes a rounded rectangle given +point+, +width+ and +height+ and +radius+ for the rounded corner. The rectangle is bounded by its upper-left corner.
+    #
+    # Draws and strokes a rounded rectangle given +point+, +width+ and +height+
+    # and +radius+ for the rounded corner. The rectangle is bounded by its
+    # upper-left corner.
+    #
     # :call-seq:
     #   stroke_rounded_rectangle(point,width,height,radius)
 
     ##
     # :method: fill_rounded_rectangle
-    # Draws and fills a rounded rectangle given +point+, +width+ and +height+ and +radius+ for the rounded corner. The rectangle is bounded by its upper-left corner.
+    #
+    # Draws and fills a rounded rectangle given +point+, +width+ and +height+
+    # and +radius+ for the rounded corner. The rectangle is bounded by its
+    # upper-left corner.
+    #
     # :call-seq:
     #   fill_rounded_rectangle(point,width,height,radius)
 
     ##
     # :method: stroke_and_fill_rounded_rectangle
-    # Draws, fills, and strokes a rounded rectangle given +point+, +width+ and +height+ and +radius+ for the rounded corner. The rectangle is bounded by its upper-left corner.
+    #
+    # Draws, fills, and strokes a rounded rectangle given +point+, +width+ and
+    # +height+ and +radius+ for the rounded corner. The rectangle is bounded by
+    # its upper-left corner.
+    #
     # :call-seq:
     #   stroke_and_fill_rounded_rectangle(point,width,height,radius)
 
     ##
     # :method: stroke_line
-    # Strokes a line from one point to another. Points may be specified as tuples or flattened argument list.
+    #
+    # Strokes a line from one point to another. Points may be specified as
+    # tuples or flattened argument list.
+    #
     # :call-seq:
     #   stroke_line(*points)
 
     ##
     # :method: stroke_horizontal_line
-    # Strokes a horizontal line from +x1+ to +x2+ at the current y position, or the position specified by the :at option.
+    #
+    # Strokes a horizontal line from +x1+ to +x2+ at the current y position, or
+    # the position specified by the :at option.
+    #
     # :call-seq:
     #   stroke_horizontal_line(x1,x2,options={})
 
     ##
     # :method: stroke_horizontal_rule
-    # Strokes a horizontal line from the left border to the right border of the bounding box at the current y position.
+    #
+    # Strokes a horizontal line from the left border to the right border of the
+    # bounding box at the current y position.
+    #
+    # :call-seq:
+    #   stroke_horizontal_rule
 
     ##
     # :method: stroke_vertical_line
+    #
     # Strokes a vertical line at the x coordinate given by :at from y1 to y2.
+    #
     # :call-seq:
     #   stroke_vertical_line(y1,y2,params)
 
     ##
     # :method: stroke_curve
-    # Strokes a Bezier curve between two points, bounded by two additional points. 
+    #
+    # Strokes a Bezier curve between two points, bounded by two additional
+    # points.
+    #
     # :call-seq:
     #   stroke_curve(origin,dest,options={})
 
     ##
     # :method: stroke_circle
-    # Draws and strokes a circle of radius +radius+ with the centre-point at +point+.
+    #
+    # Draws and strokes a circle of radius +radius+ with the centre-point at
+    # +point+.
+    #
     # :call-seq:
     #   stroke_circle(center,radius)
 
     ##
     # :method: fill_circle
-    # Draws and fills a circle of radius +radius+ with the centre-point at +point+.
+    #
+    # Draws and fills a circle of radius +radius+ with the centre-point at
+    # +point+.
+    #
     # :call-seq:
     #   fill_circle(center,radius)
 
     ##
     # :method: fill_and_stroke_circle
-    # Draws, strokes, and fills a circle of radius +radius+ with the centre-point at +point+.
+    #
+    # Draws, strokes, and fills a circle of radius +radius+ with the
+    # centre-point at +point+.
+    #
     # :call-seq:
     #   fill_and_stroke_circle(center,radius)
 
     ##
     # :method: stroke_ellipse
-    # Draws and strokes an ellipse of x radius +r1+ and y radius +r2+ with the centre-point at +point+.
+    #
+    # Draws and strokes an ellipse of x radius +r1+ and y radius +r2+ with the
+    # centre-point at +point+.
+    #
     # :call-seq:
     #   stroke_ellipse(point, r1, r2 = r1)
 
     ##
     # :method: fill_ellipse
-    # Draws and fills an ellipse of x radius +r1+ and y radius +r2+ with the centre-point at +point+.
+    #
+    # Draws and fills an ellipse of x radius +r1+ and y radius +r2+ with the
+    # centre-point at +point+.
+    #
     # :call-seq:
     #   fill_ellipse(point, r1, r2 = r1)
 
     ##
     # :method: fill_and_stroke_ellipse
-    # Draws, strokes, and fills an ellipse of x radius +r1+ and y radius +r2+ with the centre-point at +point+.
+    #
+    # Draws, strokes, and fills an ellipse of x radius +r1+ and y radius +r2+
+    # with the centre-point at +point+.
+    #
     # :call-seq:
     #   fill_and_stroke_ellipse(point, r1, r2 = r1)
 
     ##
     # :method: stroke_polygon
+    #
     # Draws and strokes a polygon from the specified points.
+    #
     # :call-seq:
     #   stroke_polygon(*points)
 
     ##
     # :method: fill_polygon
+    #
     # Draws and fills a polygon from the specified points.
+    #
     # :call-seq:
     #   fill_polygon(*points)
 
     ##
     # :method: fill_and_stroke_polygon
+    #
     # Draws, strokes, and fills a polygon from the specified points.
+    #
     # :call-seq:
     #   fill_and_stroke_polygon(*points)
 
     ##
     # :method: stroke_rounded_polygon
-    # Draws and strokes a rounded polygon from specified points, using +radius+ to define Bezier curves.
+    #
+    # Draws and strokes a rounded polygon from specified points, using +radius+
+    # to define Bezier curves.
+    #
     # :call-seq:
     #   stroke_rounded_polygon(radius, *points)
 
     ##
     # :method: fill_rounded_polygon
-    # Draws and fills a rounded polygon from specified points, using +radius+ to define Bezier curves.
+    #
+    # Draws and fills a rounded polygon from specified points, using +radius+ to
+    # define Bezier curves.
+    #
     # :call-seq:
     #   fill_rounded_polygon(radius, *points)
 
     ##
     # :method: fill_and_stroke_rounded_polygon
-    # Draws, strokes, and fills a rounded polygon from specified points, using +radius+ to define Bezier curves.
+    #
+    # Draws, strokes, and fills a rounded polygon from specified points, using
+    # +radius+ to define Bezier curves.
+    #
     # :call-seq:
     #   fill_and_stroke_rounded_polygon(radius, *points)
-    
+
     ops    = %w{fill stroke fill_and_stroke}
     shapes = %w{line_to curve_to rectangle rounded_rectangle line horizontal_line horizontal_rule vertical_line
                 curve circle_at circle ellipse_at ellipse polygon rounded_polygon rounded_vertex}
@@ -482,15 +602,15 @@ module Prawn
     end
 
     private
-    
+
     def current_line_width
       graphic_state.line_width
     end
-    
+
     def current_line_width=(width)
       graphic_state.line_width = width
     end
-    
+
     def write_line_width
       add_content("#{current_line_width} w")
     end
@@ -507,7 +627,7 @@ module Prawn
     def degree_to_rad(angle)
        angle * Math::PI / 180
     end
-    
+
     # Returns the coordinates for a point on a line that is a given distance away from the second
     # point defining the line segement
     def point_on_line(distance_from_end, *points)
@@ -518,6 +638,6 @@ module Prawn
       yr = y0 + p*(y1 - y0)
       [xr, yr]
     end
-    
+
   end
 end