prawn-svg 0.9.1.2 → 0.9.1.3

data/README

@@ -38,4 +38,6 @@ prawn-svg is in its infancy and does not support the full SVG specifications.  I
 
 - colors: html standard names, #xxx, #xxxxxx, rgb(1, 2, 3), rgb(1%, 2%, 3%)
 
+- measurements specified in pt, cm, dm, ft, in, m, mm, yd
+
 prawn-svg does NOT support CSS classes, named elements, anything in the defs tag, the tspan tag, gradients/patterns or markers.

data/lib/prawn-svg.rb

@@ -1,3 +1,5 @@
+require 'prawn'
 require 'prawn/svg_document'
 require 'prawn/svg/svg'
-require 'prawn/svg/svg_path'
+require 'prawn/svg/parser'
+require 'prawn/svg/path'

data/lib/prawn/svg/parser.rb

@@ -0,0 +1,352 @@
+require 'rexml/document'
+
+#
+# Prawn::Svg::Parser is responsible for parsing an SVG file and converting it into a tree of
+# prawn-compatible method calls.
+#
+# You probably do not want to use this class directly.  Instead, use Prawn::Svg to draw
+# SVG data to your Prawn::Document object.
+#
+# This class is not passed the prawn object, so knows nothing about
+# prawn specifically - this might be useful if you want to take this code and use it to convert
+# SVG to another format.
+#
+class Prawn::Svg::Parser
+  include Prawn::Measurements
+  
+  attr_reader :width, :height
+  
+  # An +Array+ of warnings that occurred while parsing the SVG data.
+  attr_reader :warnings
+
+  # The scaling factor, as determined by the :width or :height options.
+  attr_accessor :scale
+  
+  #
+  # Construct a Parser object.  
+  #
+  # The +data+ argument is SVG data.  +options+ can optionally contain
+  # the key :width or :height.  If both are specified, only :width will be used.
+  #
+  def initialize(data, options)
+    @data = data
+    @options = options
+    @warnings = []
+    
+    if data
+      parse_document
+      calculate_dimensions
+    end
+  end
+
+  #
+  # Parse the SVG data and return a call tree.  The returned +Array+ is in the format:
+  #
+  #   [
+  #     ['prawn_method_name', ['argument1', 'argument2'], []],
+  #     ['method_that_takes_a_block', ['argument1', 'argument2'], [
+  #       ['method_called_inside_block', ['argument'], []]
+  #     ]
+  #   ]
+  #
+  def parse
+    @warnings = []
+    [].tap {|calls| parse_element(@root, calls, {})}
+  end
+
+
+  private  
+  def parse_document
+    @root = REXML::Document.new(@data).root
+
+    if vb = @root.attributes['viewBox']
+      x1, y1, x2, y2 = vb.strip.split(/\s+/)
+      @x_offset, @y_offset = [x1.to_f, y1.to_f]
+      @actual_width, @actual_height = [x2.to_f - x1.to_f, y2.to_f - y1.to_f]
+    else
+      @x_offset, @y_offset = [0, 0]
+      @actual_width = @root.attributes['width'].to_f
+      @actual_height = @root.attributes['height'].to_f
+    end
+  end
+    
+  REQUIRED_ATTRIBUTES = {
+    "line"      => %w(x1 y1 x2 y2),
+    "polyline"  => %w(points),
+    "polygon"   => %w(points),
+    "circle"    => %w(r),
+    "ellipse"   => %w(rx ry),
+    "rect"      => %w(x y width height),
+    "path"      => %w(d)    
+  }
+    
+  def parse_element(element, calls, state)
+    attrs = element.attributes
+
+    if transform = attrs['transform']
+      parse_css_method_calls(transform).each do |name, arguments|
+        case name
+        when 'translate'
+          x, y = arguments
+          x, y = x.split(/\s+/) if y.nil?
+          calls << [name, [distance(x), -distance(y)], []]
+          calls = calls.last.last
+        when 'rotate'          
+          calls << [name, [-arguments.first.to_f, {:origin => [0, y('0')]}], []]
+          calls = calls.last.last
+        when 'scale'
+          calls << [name, [arguments.first.to_f], []]
+          calls = calls.last.last
+        else
+          @warnings << "Unknown transformation '#{name}'; ignoring"
+        end
+      end
+    end
+
+    calls, style_attrs, draw_type = apply_styles(attrs, calls, state)    
+
+    state[:draw_type] = draw_type if draw_type != ""
+    if state[:draw_type] && !%w(g svg).include?(element.name)
+      calls << [state[:draw_type], [], []]
+      calls = calls.last.last
+    end
+    
+    if required_attributes = REQUIRED_ATTRIBUTES[element.name]
+      return unless check_attrs_present(element, required_attributes)
+    end
+  
+    case element.name
+    when 'defs', 'desc'
+      # ignore these tags
+      
+    when 'g', 'svg'
+      element.elements.each do |child|
+        parse_element(child, calls, state.dup)
+      end
+
+    when 'text'
+      # very primitive support for fonts
+      if (font = style_attrs['font-family']) && !font.match(/[\/\\]/)
+        font = font.strip
+        if font != ""
+          calls << ['font', [font], []]
+          calls = calls.last.last
+        end
+      end
+      
+      opts = {:at => [x(attrs['x']), y(attrs['y'])]}
+      if size = style_attrs['font-size']
+        opts[:size] = size.to_f * @scale
+      end
+            
+      # This is not a prawn option but we can't work out how to render it here - it's handled by #rewrite_call
+      if anchor = style_attrs['text-anchor']
+        opts[:text_anchor] = anchor        
+      end
+      
+      calls << ['text_box', [element.text, opts], []]
+
+    when 'line'
+      calls << ['line', [x(attrs['x1']), y(attrs['y1']), x(attrs['x2']), y(attrs['y2'])], []]
+
+    when 'polyline'
+      points = attrs['points'].split(/\s+/)
+      return unless base_point = points.shift
+      x, y = base_point.split(",")
+      calls << ['move_to', [x(x), y(y)], []]
+      calls << ['stroke', [], []]
+      calls = calls.last.last
+      points.each do |point|
+        x, y = point.split(",")
+        calls << ["line_to", [x(x), y(y)], []]
+      end
+    
+    when 'polygon'
+      points = attrs['points'].split(/\s+/).collect do |point|
+        x, y = point.split(",")
+        [x(x), y(y)]
+      end
+      calls << ["polygon", points, []]      
+      
+    when 'circle'
+      calls << ["circle_at", 
+        [[x(attrs['cx'] || "0"), y(attrs['cy'] || "0")], {:radius => distance(attrs['r'])}], 
+        []]
+      
+    when 'ellipse'
+      calls << ["ellipse_at", 
+        [[x(attrs['cx'] || "0"), y(attrs['cy'] || "0")], distance(attrs['rx']), distance(attrs['ry'])],
+        []]
+      
+    when 'rect'
+      radius = distance(attrs['rx'] || attrs['ry'])
+      args = [[x(attrs['x']), y(attrs['y'])], distance(attrs['width']), distance(attrs['height'])]
+      if radius
+        # n.b. does not support both rx and ry being specified with different values
+        calls << ["rounded_rectangle", args + [radius], []]
+      else
+        calls << ["rectangle", args, []]
+      end
+      
+    when 'path'
+      @svg_path ||= Path.new
+
+      begin
+        commands = @svg_path.parse(attrs['d'])
+      rescue Prawn::Svg::Parser::Path::InvalidError => e
+        commands = []
+        @warnings << e.message
+      end
+
+      commands.each do |command, args|
+        point_to = [x(args[0]), y(args[1])]
+        if command == 'curve_to'
+          bounds = [[x(args[2]), y(args[3])], [x(args[4]), y(args[5])]]
+          calls << [command, [point_to, {:bounds => bounds}], []]
+        else
+          calls << [command, point_to, []]
+        end
+      end
+
+    else 
+      @warnings << "Unknown tag '#{element.name}'; ignoring"
+    end
+  end
+  
+  def parse_css_declarations(declarations)
+    # copied from css_parser
+    declarations.gsub!(/(^[\s]*)|([\s]*$)/, '')
+
+    {}.tap do |o|
+      declarations.split(/[\;$]+/m).each do |decs|
+        if matches = decs.match(/\s*(.[^:]*)\s*\:\s*(.[^;]*)\s*(;|\Z)/i)
+          property, value, end_of_declaration = matches.captures
+          o[property] = value
+        end
+      end
+    end
+  end
+  
+  def apply_styles(attrs, calls, state)
+    draw_types = []
+
+    decs = attrs["style"] ? parse_css_declarations(attrs["style"]) : {}
+    attrs.each {|n,v| decs[n] = v unless decs[n]}
+            
+    # Opacity:
+    # We can't do nested opacities quite like the SVG requires, but this is close enough.
+    fill_opacity = stroke_opacity = clamp(decs['opacity'].to_f, 0, 1) if decs['opacity']
+    fill_opacity = clamp(decs['fill-opacity'].to_f, 0, 1) if decs['fill-opacity']
+    stroke_opacity = clamp(decs['stroke-opacity'].to_f, 0, 1) if decs['stroke-opacity']
+    
+    if fill_opacity || stroke_opacity      
+      state[:fill_opacity] = (state[:fill_opacity] || 1) * (fill_opacity || 1)
+      state[:stroke_opacity] = (state[:stroke_opacity] || 1) * (stroke_opacity || 1)
+
+      calls << ['transparent', [state[:fill_opacity], state[:stroke_opacity]], []] 
+      calls = calls.last.last
+    end
+
+    if decs['fill'] && decs['fill'] != "none"
+      if color = color_to_hex(decs['fill'])
+        calls << ['fill_color', [color], []]
+      end
+      draw_types << 'fill'
+    end
+    
+    if decs['stroke'] && decs['stroke'] != "none"
+      if color = color_to_hex(decs['stroke'])
+        calls << ['stroke_color', [color], []]
+      end
+      draw_types << 'stroke'
+    end
+    
+    calls << ['line_width', [distance(decs['stroke-width'])], []] if decs['stroke-width']          
+        
+    [calls, decs, draw_types.join("_and_")]
+  end
+  
+  def parse_css_method_calls(string)
+    string.scan(/\s*(\w+)\(([^)]+)\)\s*/).collect do |call|
+      name, argument_string = call
+      arguments = argument_string.split(",").collect(&:strip)
+      [name, arguments]
+    end    
+  end
+
+  # TODO : use http://www.w3.org/TR/SVG11/types.html#ColorKeywords
+  HTML_COLORS = {    
+  	'black' => "000000", 'green' => "008000", 'silver' => "c0c0c0", 'lime' => "00ff00",
+  	'gray' => "808080", 'olive' => "808000", 'white' => "ffffff", 'yellow' => "ffff00",
+  	'maroon' => "800000", 'navy' => "000080", 'red' => "ff0000", 'blue' => "0000ff",
+  	'purple' => "800080", 'teal' => "008080", 'fuchsia' => "ff00ff", 'aqua' => "00ffff"
+  }.freeze
+  
+  RGB_VALUE_REGEXP = "\s*(-?[0-9.]+%?)\s*"
+  RGB_REGEXP = /\Argb\(#{RGB_VALUE_REGEXP},#{RGB_VALUE_REGEXP},#{RGB_VALUE_REGEXP}\)\z/i
+  
+  def color_to_hex(color_string)
+    color_string.scan(/([^(\s]+(\([^)]*\))?)/).detect do |color, *_|
+      if m = color.match(/\A#([0-9a-f])([0-9a-f])([0-9a-f])\z/i)
+        break "#{m[1] * 2}#{m[2] * 2}#{m[3] * 2}"
+      elsif color.match(/\A#[0-9a-f]{6}\z/i)
+        break color[1..6]
+      elsif hex = HTML_COLORS[color.downcase]
+        break hex
+      elsif m = color.match(RGB_REGEXP)
+        break (1..3).collect do |n|
+          value = m[n].to_f
+          value *= 2.55 if m[n][-1..-1] == '%'
+          "%02x" % clamp(value.round, 0, 255)
+        end.join        
+      end    
+    end
+  end
+  
+  def x(value)
+    (points(value) - @x_offset) * scale
+  end
+  
+  def y(value)
+    (@actual_height - (points(value) - @y_offset)) * scale
+  end
+  
+  def distance(value)
+    value && (points(value) * scale)
+  end
+  
+  def points(value)
+    if value.is_a?(String) && match = value.match(/\d(cm|dm|ft|in|m|mm|yd)$/)
+      send("#{match[1]}2pt", value.to_f)
+    else
+      value.to_f
+    end
+  end
+  
+  def calculate_dimensions    
+    if @options[:width]
+      @width = @options[:width]      
+      @scale = @options[:width] / @actual_width.to_f
+    elsif @options[:height]
+      @height = @options[:height]
+      @scale = @options[:height] / @actual_height.to_f
+    else
+      @scale = 1
+    end
+    
+    @width ||= @actual_width * @scale
+    @height ||= @actual_height * @scale
+  end
+  
+  def clamp(value, min_value, max_value)
+    [[value, min_value].max, max_value].min
+  end  
+  
+  def check_attrs_present(element, attrs)
+    missing_attrs = attrs - element.attributes.keys
+    if missing_attrs.any?
+      @warnings << "Must have attributes #{missing_attrs.join(", ")} on tag #{element.name}; skipping tag"
+    end
+    missing_attrs.empty?
+  end
+end

data/lib/prawn/svg/{svg_path.rb → path.rb}

@@ -1,17 +1,28 @@
-class Prawn::Svg::Path
+class Prawn::Svg::Parser::Path
+  # Raised if the SVG path cannot be parsed.
+  InvalidError = Class.new(StandardError)
+
+  #
+  # Parses an SVG path and returns a Prawn-compatible call tree.
+  #
   def parse(data)
-    cmd = values = value = nil
+    cmd = values = nil
+    value = ""
     @subpath_initial_point = @last_point = nil
     @previous_control_point = @previous_quadratic_control_point = nil
     @calls = []
 
     data.each_char do |c|
       if c >= 'A' && c <= 'Z' || c >= 'a' && c <= 'z'
+        values << value.to_f if value != ""
         run_path_command(cmd, values) if cmd
         cmd = c
         values = []
         value = ""
       elsif c >= '0' && c <= '9' || c == '.' || c == "-"
+        unless cmd
+          raise InvalidError, "Numerical value specified before character command in SVG path data"
+        end
         value << c
       elsif c == ' ' || c == "\t" || c == "\r" || c == "\n" || c == ","
         if value != ""
@@ -19,7 +30,7 @@ class Prawn::Svg::Path
           value = ""
         end
       else
-        raise "invalid character '#{c}' in path data"
+        raise InvalidError, "Invalid character '#{c}' in SVG path data"
       end
     end
     
@@ -29,6 +40,8 @@ class Prawn::Svg::Path
     @calls
   end
   
+  
+  private
   def run_path_command(command, values)
     upcase_command = command.upcase
     relative = command != upcase_command

data/lib/prawn/svg/svg.rb

@@ -1,36 +1,48 @@
-require 'rexml/document'
-require 'prawn'
-
+#
+# Prawn::Svg makes a Prawn::Svg::Parser instance, uses that object to parse the supplied
+# SVG into Prawn-compatible method calls, and then calls the Prawn methods.
+#
 class Prawn::Svg
-  include Prawn::Measurements
-  
   attr_reader :data, :prawn, :options
-  attr_accessor :scale
-
+  
+  # An +Array+ of warnings that occurred while parsing the SVG data.  If this array is non-empty,
+  # it's likely that the SVG failed to render correctly.
+  attr_reader :parser_warnings
+
+  #
+  # Creates a Prawn::Svg object.
+  #
+  # +data+ is the SVG data to convert.  +prawn+ is your Prawn::Document object.
+  #
+  # +options+ must contain the key :at, which takes a tuple of x and y co-ordinates.
+  #
+  # +options+ can optionally contain the key :width or :height.  If both are 
+  # specified, only :width will be used.
+  #
   def initialize(data, prawn, options)
     @data = data
     @prawn = prawn
     @options = options
+    
+    @options[:at] or raise "options[:at] must be specified"
+
+    @parser = Parser.new(data, options)
+    @parser_warnings = @parser.warnings
   end
 
+  #
+  # Draws the SVG to the Prawn::Document object.
+  #
   def draw
-    root = parse_document
-    calculate_dimensions
-
-    prawn.bounding_box(@options[:at], :width => @width, :height => @height) do
+    prawn.bounding_box(@options[:at], :width => @parser.width, :height => @parser.height) do
       prawn.save_graphics_state do
-        call_tree = generate_call_tree(root)
-        proc_creator(prawn, call_tree).call
+        proc_creator(prawn, @parser.parse).call
       end
     end
   end
+
   
-  def generate_call_tree(element)
-    [].tap {|calls| parse_element(element, calls, {})}
-  end
-  
-  
-  protected  
+  private  
   def proc_creator(prawn, calls)
     Proc.new {issue_prawn_command(prawn, calls)}
   end
@@ -57,271 +69,4 @@ class Prawn::Svg
       arguments.last[:at][1] += prawn.height_of(*arguments) / 3 * 2
     end
   end
-
-  def parse_document
-    REXML::Document.new(@data).root.tap do |root|    
-      if vb = root.attributes['viewBox']
-        x1, y1, x2, y2 = vb.strip.split(/\s+/)
-        @x_offset, @y_offset = [x1.to_f, y1.to_f]
-        @actual_width, @actual_height = [x2.to_f - x1.to_f, y2.to_f - y1.to_f]
-      else
-        @x_offset, @y_offset = [0, 0]
-        @actual_width = root.attributes['width'].to_f
-        @actual_height = root.attributes['height'].to_f
-      end
-    end
-  end
-    
-  def parse_element(element, calls, state)
-    attrs = element.attributes
-
-    if transform = attrs['transform']
-      parse_css_method_calls(transform).each do |name, arguments|
-        case name
-        when 'translate'
-          x, y = arguments
-          x, y = x.split(/\s+/) if y.nil?
-          calls << [name, [distance(x), -distance(y)], []]
-          calls = calls.last.last
-        when 'rotate'          
-          calls << [name, [-arguments.first.to_f, {:origin => [0, y('0')]}], []]
-          calls = calls.last.last
-        when 'scale'
-          calls << [name, [arguments.first.to_f], []]
-          calls = calls.last.last
-        else
-          #raise "unknown transformation '#{name}'"
-        end
-      end
-    end
-
-    calls, style_attrs, draw_type = apply_styles(attrs, calls, state)    
-
-    state[:draw_type] = draw_type if draw_type != ""
-    if state[:draw_type] && !%w(g svg).include?(element.name)
-      calls << [state[:draw_type], [], []]
-      calls = calls.last.last
-    end
-  
-    case element.name
-    when 'defs', 'desc'
-      # ignore these tags
-      
-    when 'g', 'svg'
-      element.elements.each do |child|
-        parse_element(child, calls, state.dup)
-      end
-
-    when 'text'
-      # very primitive support for fonts
-      if (font = style_attrs['font-family']) && !font.match(/[\/\\]/)
-        font = font.strip
-        if font != ""
-          calls << ['font', [font], []]
-          calls = calls.last.last
-        end
-      end
-      
-      opts = {:at => [x(attrs['x']), y(attrs['y'])]}
-      if size = style_attrs['font-size']
-        opts[:size] = size.to_f * @scale
-      end
-            
-      # This is not a prawn option but we can't work out how to render it here - it's handled by #rewrite_call
-      if anchor = style_attrs['text-anchor']
-        opts[:text_anchor] = anchor        
-      end
-      
-      calls << ['text_box', [element.text, opts], []]
-
-    when 'line'
-      return unless attrs['x1'] && attrs['y1'] && attrs['x2'] && attrs['y2']      
-      calls << ['line', [x(attrs['x1']), y(attrs['y1']), x(attrs['x2']), y(attrs['y2'])], []]
-
-    when 'polyline'
-      return unless attrs['points']
-      points = attrs['points'].split(/\s+/)
-      return unless base_point = points.shift
-      x, y = base_point.split(",")
-      calls << ['move_to', [x(x), y(y)], []]
-      calls << ['stroke', [], []]
-      calls = calls.last.last
-      points.each do |point|
-        x, y = point.split(",")
-        calls << ["line_to", [x(x), y(y)], []]
-      end
-    
-    when 'polygon'
-      return unless attrs['points']      
-      points = attrs['points'].split(/\s+/).collect do |point|
-        x, y = point.split(",")
-        [x(x), y(y)]
-      end
-      calls << ["polygon", points, []]      
-      
-    when 'circle'
-      return unless attrs['r']      
-      calls << ["circle_at", 
-        [[x(attrs['cx'] || "0"), y(attrs['cy'] || "0")], {:radius => distance(attrs['r'])}], 
-        []]
-      
-    when 'ellipse'
-      return unless attrs['rx'] && attrs['ry']
-      calls << ["ellipse_at", 
-        [[x(attrs['cx'] || "0"), y(attrs['cy'] || "0")], distance(attrs['rx']), distance(attrs['ry'])],
-        []]
-      
-    when 'rect'
-      return unless attrs['x'] && attrs['y'] && attrs['width'] && attrs['height']
-      radius = distance(attrs['rx'] || attrs['ry'])
-      args = [[x(attrs['x']), y(attrs['y'])], distance(attrs['width']), distance(attrs['height'])]
-      if radius
-        # n.b. does not support both rx and ry being specified with different values
-        calls << ["rounded_rectangle", args + [radius], []]
-      else
-        calls << ["rectangle", args, []]
-      end
-      
-    when 'path'
-      @svg_path ||= Path.new
-      @svg_path.parse(attrs['d']).each do |command, args|
-        point_to = [x(args[0]), y(args[1])]
-        if command == 'curve_to'
-          bounds = [[x(args[2]), y(args[3])], [x(args[4]), y(args[5])]]
-          calls << [command, [point_to, {:bounds => bounds}], []]
-        else
-          calls << [command, point_to, []]
-        end
-      end
-
-    else 
-      #raise "unknown tag #{element.name}"
-    end
-  end
-  
-  def parse_css_declarations(declarations)
-    # copied from css_parser
-    declarations.gsub!(/(^[\s]*)|([\s]*$)/, '')
-
-    {}.tap do |o|
-      declarations.split(/[\;$]+/m).each do |decs|
-        if matches = decs.match(/\s*(.[^:]*)\s*\:\s*(.[^;]*)\s*(;|\Z)/i)
-          property, value, end_of_declaration = matches.captures
-          o[property] = value
-        end
-      end
-    end
-  end
-  
-  def apply_styles(attrs, calls, state)
-    draw_types = []
-
-    decs = attrs["style"] ? parse_css_declarations(attrs["style"]) : {}
-    attrs.each {|n,v| decs[n] = v unless decs[n]}
-            
-    # Opacity:
-    # We can't do nested opacities quite like the SVG requires, but this is close enough.
-    fill_opacity = stroke_opacity = clamp(decs['opacity'].to_f, 0, 1) if decs['opacity']
-    fill_opacity = clamp(decs['fill-opacity'].to_f, 0, 1) if decs['fill-opacity']
-    stroke_opacity = clamp(decs['stroke-opacity'].to_f, 0, 1) if decs['stroke-opacity']
-    
-    if fill_opacity || stroke_opacity      
-      state[:fill_opacity] = (state[:fill_opacity] || 1) * (fill_opacity || 1)
-      state[:stroke_opacity] = (state[:stroke_opacity] || 1) * (stroke_opacity || 1)
-
-      calls << ['transparent', [state[:fill_opacity], state[:stroke_opacity]], []] 
-      calls = calls.last.last
-    end
-
-    if decs['fill'] && decs['fill'] != "none"
-      if color = color_to_hex(decs['fill'])
-        calls << ['fill_color', [color], []]
-      end
-      draw_types << 'fill'
-    end
-    
-    if decs['stroke'] && decs['stroke'] != "none"
-      if color = color_to_hex(decs['stroke'])
-        calls << ['stroke_color', [color], []]
-      end
-      draw_types << 'stroke'
-    end
-    
-    calls << ['line_width', [distance(decs['stroke-width'])], []] if decs['stroke-width']          
-        
-    [calls, decs, draw_types.join("_and_")]
-  end
-  
-  def parse_css_method_calls(string)
-    string.scan(/\s*(\w+)\(([^)]+)\)\s*/).collect do |call|
-      name, argument_string = call
-      arguments = argument_string.split(",").collect(&:strip)
-      [name, arguments]
-    end    
-  end
-
-  # TODO : use http://www.w3.org/TR/SVG11/types.html#ColorKeywords
-  HTML_COLORS = {    
-  	'black' => "000000", 'green' => "008000", 'silver' => "c0c0c0", 'lime' => "00ff00",
-  	'gray' => "808080", 'olive' => "808000", 'white' => "ffffff", 'yellow' => "ffff00",
-  	'maroon' => "800000", 'navy' => "000080", 'red' => "ff0000", 'blue' => "0000ff",
-  	'purple' => "800080", 'teal' => "008080", 'fuchsia' => "ff00ff", 'aqua' => "00ffff"
-  }.freeze
-  
-  def color_to_hex(color_string)
-    color_string.scan(/([^(\s]+(\([^)]*\))?)/).detect do |color, *_|
-      if m = color.match(/\A#([0-9a-f])([0-9a-f])([0-9a-f])\z/i)
-        break "#{m[1] * 2}#{m[2] * 2}#{m[3] * 2}"
-      elsif color.match(/\A#[0-9a-f]{6}\z/i)
-        break color[1..6]
-      elsif hex = HTML_COLORS[color.downcase]
-        break hex
-      elsif m = color.match(/\Argb\(\s*(-?[0-9.]+%?)\s*,\s*(-?[0-9.]+%?)\s*,\s*(-?[0-9.]+%?)\s*\)\z/i)
-        break (1..3).collect do |n|
-          value = m[n].to_f
-          value *= 2.55 if m[n][-1..-1] == '%'
-          "%02x" % clamp(value.round, 0, 255)
-        end.join        
-      end    
-    end
-  end
-  
-  def x(value)
-    (points(value) - @x_offset) * scale
-  end
-  
-  def y(value)
-    (@actual_height - (points(value) - @y_offset)) * scale
-  end
-  
-  def distance(value)
-    value && (points(value) * scale)
-  end
-  
-  def points(value)
-    if value.is_a?(String) && match = value.match(/\d(cm|dm|ft|in|m|mm|yd)$/)
-      send("#{match[1]}2pt", value.to_f)
-    else
-      value.to_f
-    end
-  end
-  
-  def calculate_dimensions    
-    if @options[:width]
-      @width = @options[:width]      
-      @scale = @options[:width] / @actual_width.to_f
-    elsif @options[:height]
-      @height = @options[:height]
-      @scale = @options[:height] / @actual_height.to_f
-    else
-      @scale = 1
-    end
-    
-    @width ||= @actual_width * @scale
-    @height ||= @actual_height * @scale
-  end
-  
-  def clamp(value, min_value, max_value)
-    [[value, min_value].max, max_value].min
-  end  
 end

data/lib/prawn/svg_document.rb

@@ -1,7 +1,22 @@
 module Prawn
   class Document
+    #
+    # Draws an SVG document into the PDF.
+    #
+    # +options+ must contain the key :at, which takes a tuple of x and y co-ordinates.
+    #
+    # +options+ can optionally contain the key :width or :height.  If both are 
+    # specified, only :width will be used.  If neither are specified, the resolution
+    # given in the SVG will be used.
+    #
+    # Example usage:
+    #
+    #   svg IO.read("example.svg"), :at => [100, 300], :width => 600
+    #
     def svg(data, options={})
-      Prawn::Svg.new(data, self, options).draw
+      svg = Prawn::Svg.new(data, self, options)
+      svg.draw
+      {:warnings => svg.parser_warnings}
     end
   end
 end

metadata

@@ -6,8 +6,8 @@ version: !ruby/object:Gem::Version
   - 0
   - 9
   - 1
-  - 2
-  version: 0.9.1.2
+  - 3
+  version: 0.9.1.3
 platform: ruby
 authors: 
 - Roger Nesbitt
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-03-26 00:00:00 +13:00
+date: 2010-03-27 00:00:00 +13:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -57,8 +57,9 @@ extra_rdoc_files: []
 files: 
 - README
 - LICENSE
+- lib/prawn/svg/parser.rb
+- lib/prawn/svg/path.rb
 - lib/prawn/svg/svg.rb
-- lib/prawn/svg/svg_path.rb
 - lib/prawn/svg_document.rb
 - lib/prawn-svg.rb
 has_rdoc: true