prawn-svg 0.9.1

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License
+
+Copyright 2010 Roger Nesbitt
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README

@@ -0,0 +1,17 @@
+The very start of an SVG renderer for Prawn.
+
+This will take an SVG file as input and render it into your PDF.  Find out more about the Prawn PDF library at:
+
+  http://wiki.github.com/sandal/prawn/
+
+Using prawn-svg:
+
+  Prawn::Document.generate("svg.pdf") do
+    svg svg_data, :at => [x, y], :width => w
+  end
+  
+:at must be specified.  :width, :height, or neither may be specified; if neither is present,
+the resolution specified in the SVG will be used.
+
+Note that only a very small subset of SVG is currently supported.  It's just enough so that
+it renders a simple graph made by Scruffy.

data/lib/prawn-svg.rb

@@ -0,0 +1,3 @@
+require 'prawn/svg_document'
+require 'prawn/svg/svg'
+require 'prawn/svg/svg_path'

data/lib/prawn/svg/svg.rb

@@ -0,0 +1,320 @@
+require 'rexml/document'
+require 'prawn'
+
+class Prawn::Svg
+  include Prawn::Measurements
+  
+  attr_reader :data, :prawn, :options
+  attr_accessor :scale
+
+  def initialize(data, prawn, options)
+    @data = data
+    @prawn = prawn
+    @options = options
+  end
+
+  def draw
+    root = parse_document
+    calculate_dimensions
+
+    prawn.bounding_box(@options[:at], :width => @width, :height => @height) do
+      prawn.save_graphics_state do
+        call_tree = generate_call_tree(root)
+        proc_creator(prawn, call_tree).call
+      end
+    end
+  end
+  
+  def generate_call_tree(element)
+    [].tap {|calls| parse_element(element, calls, {})}
+  end
+  
+  
+  protected  
+  def proc_creator(prawn, calls)
+    Proc.new {issue_prawn_command(prawn, calls)}
+  end
+  
+  def issue_prawn_command(prawn, calls)
+    calls.each do |call, arguments, children|
+      if children.empty?
+        rewrite_call_arguments(prawn, call, arguments)
+        prawn.send(call, *arguments)
+      else
+        prawn.send(call, *arguments, &proc_creator(prawn, children))
+      end
+    end
+  end
+  
+  def rewrite_call_arguments(prawn, call, arguments)
+    if call == 'text_box'
+      if (anchor = arguments.last.delete(:text_anchor)) && %w(middle end).include?(anchor)
+        width = prawn.width_of(*arguments)
+        width /= 2 if anchor == 'middle'
+        arguments.last[:at][0] -= width
+      end
+      
+      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'
+      calls << ['line', [x(attrs['x1']), y(attrs['y1']), x(attrs['x2']), y(attrs['y2'])], []]
+
+    when 'polyline'
+      points = attrs['points'].split(/\s+/)
+      x, y = points.shift.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
+      @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)
+    (pixels(value) - @x_offset) * scale
+  end
+  
+  def y(value)
+    (@actual_height - (pixels(value) - @y_offset)) * scale
+  end
+  
+  def distance(value)
+    value && (pixels(value) * scale)
+  end
+  
+  def pixels(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/svg_path.rb

@@ -0,0 +1,167 @@
+class Prawn::Svg::Path
+  def parse(data)
+    cmd = values = value = nil
+    @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'
+        run_path_command(cmd, values) if cmd
+        cmd = c
+        values = []
+        value = ""
+      elsif c >= '0' && c <= '9' || c == '.' || c == "-"
+        value << c
+      elsif c == ' ' || c == "\t" || c == "\r" || c == "\n" || c == ","
+        if value != ""
+          values << value.to_f
+          value = ""
+        end
+      else
+        raise "invalid character '#{c}' in path data"
+      end
+    end
+    
+    values << value.to_f if value != ""
+    run_path_command(cmd, values) if cmd
+    
+    @calls
+  end
+  
+  def run_path_command(command, values)
+    upcase_command = command.upcase
+    relative = command != upcase_command
+    
+    case upcase_command
+    when 'M' # moveto
+      x = values.shift
+      y = values.shift
+
+      if relative && @last_point
+        x += @last_point.first
+        y += @last_point.last
+      end
+      
+      @last_point = @subpath_initial_point = [x, y]
+      @calls << ["move_to", @last_point]
+      
+      return run_path_command('L', values) if values.any?
+      
+    when 'Z' # closepath
+      if @subpath_initial_point
+        @calls << ["line_to", @subpath_initial_point]
+        @last_point = @subpath_initial_point
+      end
+    
+    when 'L' # lineto
+      while values.any?
+        x = values.shift
+        y = values.shift
+        if relative && @last_point
+          x += @last_point.first
+          y += @last_point.last
+        end
+        @last_point = [x, y]
+        @calls << ["line_to", @last_point]
+      end
+      
+    when 'H' # horizontal lineto
+      while values.any?
+        x = values.shift
+        x += @last_point.first if relative && @last_point
+        @last_point = [x, @last_point.last]
+        @calls << ["line_to", @last_point]
+      end
+
+    when 'V' # vertical lineto
+      while values.any?
+        y = values.shift
+        y += @last_point.last if relative && @last_point
+        @last_point = [@last_point.first, y]
+        @calls << ["line_to", @last_point]
+      end
+    
+    when 'C' # curveto
+      while values.any?
+        x1, y1, x2, y2, x, y = (1..6).collect {values.shift}
+        if relative && @last_point
+          x += @last_point.first
+          x1 += @last_point.first
+          x2 += @last_point.first                    
+          y += @last_point.last 
+          y1 += @last_point.last 
+          y2 += @last_point.last 
+        end
+        
+        @last_point = [x, y]
+        @previous_control_point = [x2, y2]
+        @calls << ["curve_to", [x, y, x1, y1, x2, y2]]
+      end      
+
+    when 'S' # shorthand/smooth curveto
+      while values.any?
+        x2, y2, x, y = (1..4).collect {values.shift}
+        if relative && @last_point
+          x += @last_point.first
+          x2 += @last_point.first                    
+          y += @last_point.last 
+          y2 += @last_point.last 
+        end
+        
+        if @previous_control_point
+          x1 = 2 * @last_point.first - @previous_control_point.first
+          y1 = 2 * @last_point.last - @previous_control_point.last
+        else
+          x1, y1 = @last_point
+        end
+        
+        @last_point = [x, y]
+        @previous_control_point = [x2, y2]        
+        @calls << ["curve_to", [x, y, x1, y1, x2, y2]]
+      end
+      
+    when 'Q', 'T' # quadratic curveto
+      while values.any?
+        if shorthand = upcase_command == 'T'
+          x, y = (1..2).collect {values.shift}          
+        else        
+          x1, y1, x, y = (1..4).collect {values.shift}
+        end
+        
+        if relative && @last_point
+          x += @last_point.first
+          x1 += @last_point.first if x1
+          y += @last_point.last 
+          y1 += @last_point.last if y1
+        end
+        
+        if shorthand 
+          if @previous_quadratic_control_point
+            x1 = 2 * @last_point.first - @previous_quadratic_control_point.first
+            y1 = 2 * @last_point.last - @previous_quadratic_control_point.last
+          else
+            x1, y1 = @last_point
+          end
+        end                
+        
+        # convert from quadratic to cubic
+        cx1 = @last_point.first + (x1 - @last_point.first) * 2 / 3.0
+        cy1 = @last_point.last + (y1 - @last_point.last) * 2 / 3.0
+        cx2 = cx1 + (x - @last_point.first) / 3.0
+        cy2 = cy1 + (y - @last_point.last) / 3.0        
+
+        @last_point = [x, y]
+        @previous_quadratic_control_point = [x1, y1]
+                
+        @calls << ["curve_to", [x, y, cx1, cy1, cx2, cy2]]
+      end      
+      
+    when 'A'
+      # unsupported      
+    end
+    
+    @previous_control_point = nil unless %w(C S).include?(upcase_command)
+    @previous_quadratic_control_point = nil unless %w(Q T).include?(upcase_command)
+  end  
+end

data/lib/prawn/svg_document.rb

@@ -0,0 +1,7 @@
+module Prawn
+  class Document
+    def svg(data, options={})
+      Prawn::Svg.new(data, self, options).draw
+    end
+  end
+end

metadata

@@ -0,0 +1,67 @@
+--- !ruby/object:Gem::Specification 
+name: prawn-svg
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 9
+  - 1
+  version: 0.9.1
+platform: ruby
+authors: 
+- Roger Nesbitt
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-03-26 00:00:00 +13:00
+default_executable: 
+dependencies: []
+
+description: SVG renderer for Prawn PDF library
+email: roger@seriousorange.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- README
+- LICENSE
+- lib/prawn/svg/svg.rb
+- lib/prawn/svg/svg_path.rb
+- lib/prawn/svg_document.rb
+- lib/prawn-svg.rb
+has_rdoc: true
+homepage: 
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.6
+signing_key: 
+specification_version: 3
+summary: SVG renderer for Prawn PDF library
+test_files: []
+