text2path 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 26be4b45234941e24e0d27d2f836eac4de6b05ba
+  data.tar.gz: a6f2ad6421d8f76d39d82724c89b48ce711d8e6e
+SHA512:
+  metadata.gz: b4ec9fff758cc8f14284a0e1da00441895361d3008cb5c09adff07694ea588a34a611e4d9525b5b92e6b6cd60daefc7ebc96ee5bc4c767bf3f368766a1fac58e
+  data.tar.gz: ce6910fa7f327ea147f3b1ad93665e502d72110d2a10734a00b2436769c032a5576880bf3f5a0a9244c74cb63fc35988376742c29bdc2c726b5bc709a53ab6b5

data/Gemfile

@@ -0,0 +1,4 @@
+source 'http://ruby.taobao.org'
+
+gem 'nokogiri'
+gem 'htmlentities'

data/Gemfile.lock

@@ -0,0 +1,14 @@
+GEM
+  remote: http://ruby.taobao.org/
+  specs:
+    htmlentities (4.3.1)
+    mini_portile (0.5.1)
+    nokogiri (1.6.0)
+      mini_portile (~> 0.5.0)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  htmlentities
+  nokogiri

data/README.md

@@ -0,0 +1,40 @@
+# Text2Path
+
+This library convert text into svg paths. For example:
+
+~~~ruby
+require 'text2path'
+
+# load font from pre-built svg font file
+# You can make svg font from .ttf or other formats with Batik tools
+font = Text2Path::SvgFont.load 'assets/fonts/arial.svg'
+
+# Code below converts text to svg output that can be displayed in browsers:
+Text2Path.convert( 'Hello, world!', font, font_size: 20 ).to_svg
+
+# <?xml version="1.0" standalone="no"?>
+# <!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">
+# <svg xmlns="http://www.w3.org/2000/svg" version="1.1">
+#   <g>
+#     <path d="M4.296875 34..." />
+#     <path d="M4.296875 34..." />
+#     <path d="M4.296875 34..." />
+#     <path d="M4.296875 34..." />
+#   </g>
+# </svg>
+
+# This convert text to an array containing a list of Savage::Path instance
+Text2Path.convert( 'Hello, world!', font, font_size: 20 ).to_paths
+
+~~~
+
+## helpful infomation
+[generating svg font file](http://xmlgraphics.apache.org/batik/tools/font-converter.html)
+
+## TODO
+This project is at its very beginning, features missing:
+
+1. support right-to-left text directions
+2. support vertical orientation
+3. support more options like font-weight, font-style, kerning.. etc.
+4. helper to create svg fonts

data/lib/ext/savage/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2010 Jeremy Holland
+
+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/lib/ext/savage/README.rdoc

@@ -0,0 +1,108 @@
+= Savage
+
+A little gem for extracting and manipulating SVG vector path data, Savage will make your life easier when it comes time to dynamically draw new and manipulate existing SVG paths. No more wacky regex to capture those cryptic path data strings; just pass the whole "d" attribute into Savage's parser, et voilá: You'll be given an instance of Savage::Path, replete with an array of subpaths split on the "move to" commands (to better help with those pesky winding issues). In turn, each subpath contains its own array of directions that can be swapped around, reconfigured, and otherwise manipulated to your heart's content in a truly human-readable way.
+
+== Latest Update
+
+Version 1.2.0 includes a new array abstraction (see below) and optimized implementation of Direction#to_command, courtesy of {bdon}[https://github.com/bdon]!
+
+== Usage
+
+<b>Parsing existing data</b>
+
+Easy-peasy Japanesey. Just take a look at the below:
+
+  path = Savage::Parser.parse my_path_data_string
+  path.subpaths # [subpath_1, subpath_2, ... subpath_n]
+  path.subpaths.last.directions # [direction_1, direction_2, ... direction_n]
+
+Once extracted, you can manipulate, add, and remove the subpaths and directions as you see fit. See below for instructions on using the various direction types
+
+<b>Creating from scratch</b>
+
+What if you want to roll your own from the get-go? No problem:
+
+  path = Savage::Path.new do |p|
+    p.move_to 100, 200
+    p.line_to 300, 400
+    p.horizontal_to 500
+    p.close_path
+  end
+
+We'll learn more about the actual drawing methods here shortly, but suffice it to say they are provided both as methods on the constructor block parameter for the sake of your visual organization, and the path itself after instantiation, as below:
+
+  path = Savage::Path.new
+  path.move_to 100, 200
+  path.line_to 300, 400
+  path.horizontal_to 500
+  path.close_path
+
+<b>Drawing with Savage</b>
+
+So what are the different directions we can give our virtual pen? Here I'll refer you first to the SVG 1.1 specification by our friends down at the W3C, as they can describe all the specifics much better than I: http://www.w3.org/TR/SVG/paths.html#PathData. Each "command" listed in that section has an analog method on the Savage::SubPath class as well as the Savage::Path class (calling one of the methods on an instance of the Savage::Path class actually just delegates the call to the last SubPath in that path's selection of subpaths). Every parameter of these methods is expected to be a Numeric except where noted otherwise.  The methods are as follows:
+
+* <b>path.move_to(target_x, target_y)</b> - Move the 'pen' to the specified coordinates on the 'canvas' without drawing anything. Note that you can only call this method on a subpath if it's otherwise empty. Most of the time, just call this on an instance of the Path class, which will actually create a new subpath for you to continue drawing into
+* <b>path.close_path()</b> - Draw a straight line from the current position to the coordinates of the start of the current subpath
+* <b>path.line_to(target_x, target_y)</b> - Draw a straight line from the current position to the specified coordinates
+* <b>path.horizontal_to(target_x)</b> - Draw a straight horizontal line to the provided x coordinate
+* <b>path.vertical_to(target_y)</b> - Draw a straight vertical line to the provided y coordinate
+* <b>path.cubic_curve_to(control_1_x, control_1_y, control_2_x, control_2_y, target_x, target_y)</b> - Draw a cubic Bézier curve from the current position to the target coordinates (target_x/y) using the control points specified - see the SVG specification referred to above for more info
+* <b>path.cubic_curve_to(control_2_x, control_2_y, target_x, target_y)</b> - Shorthand cubic Bézier curve; assumes continuation of previous curve. See SVG specification
+* <b>path.quadratic_curve_to(control_x, control_y, target_x, target_y)</b> - Draw a quadratic Bézier curve from the current position to the target coordinates (target_x/y) using the control point specified - see the SVG specification referred to above for more info
+* <b>path.quadratic_curve_to(target_x, target_y)</b> - Shorthand quadratic Bézier curve; assumes continuation of previous curve. See SVG specification
+* <b>path.arc_to(radius_x,radius_y,rotation,large_arc_flag,sweep_flag,target_x,target_y)</b> - This is a doozy and complicated as sin to explain, so we'll let the W3C do it for us - see the spec. Otherwise, be aware that the large_arc_flag and sweep_flag arguments are expected to be boolean values, not Numeric.
+
+There you have it, pretty much right out of the book. One thing to keep in mind is that all of these methods use ABSOLUTE coordinates by default; if you want to use relative coordinates (based on the current position of the 'pen'), just pass false as the final argument to any of them:
+
+  path.line_to 100, 200, false
+
+Each of these commands just creates a new instance of the appropriate subclass of the Savage::Direction class and pushes it onto the end of the directions list in question. Don't necessarily want to draw onto the end? Just create your own instance using the standard constructor and insert it wherever it butters your biscuit so to do:
+
+  direction = Savage::Directions::LineTo.new(100,200)
+  subpath.directions.insert(3,direction)
+
+Did you mess up before and need to change a directions coordinates after you drew it (or, more likely, after you parsed it out of some pre-existing data)? No problem:
+
+  direction = Savage::Directions::LineTo.new(100,200)
+  direction.target.x = 234
+
+As you may have guessed, Savage::Path#subpaths and Savage::SubPath#directions are both just good old-fashioned arrays, so you can fiddle with them using all your favorite Enumerable tricks as always.
+
+<b>Abstracting it to an array (new in v1.2.0!)</b>
+
+Bang!:
+
+  path.to_a # => ["M", 100, 200, ...]
+
+<b>Turning it back into a path data string</b>
+
+Bang!:
+
+  path.to_command # => 'M100 200-342 43.5Q-34.88 123.9 13-532' or whatever...
+
+Note that the #to_command method exists on Savage::Path, Savage::SubPath, and each subclass of Savage::Direction, so you can be as fine-grained with it as needed.
+
+== Issues / Feature Requests
+
+I have no doubt that will be some problems with this thing, as well as features missing that some of you fine folks might want. Please, please, please check Github's issue-tracking system to see if a ticket for the problem has already been submitted, or create a new one if not. I'll check the issues listed therein regularly, but you email me directly at your own risk (and by risk, I mean risk of not receiving a reply). :)
+
+== Note on Patches/Pull Requests
+
+* Fork the project.
+* Make your feature addition or bug fix. I very much prefer feature-specific branches.
+* Add specs for it. This is important so I don't break it in a future version unintentionally, which I can guarantee I will do.
+* Commit. Do not mess with rakefile, version, or history, please.
+* Send me a pull request - again, bonus points for topic branches.
+
+== Contributors
+
+* Jeremy Holland (jeremy@jeremypholland.com, github:{awebneck}[https://github.com/awebneck]) -- author
+* Christoffer Klang (toffeklang@yahoo.se, github:{christoffer}[https://github.com/christoffer]) -- regexp improvements
+* Bartosz Dz (github:{MatmaRex}[https://github.com/matmarex]) -- parser improvements, scientific notation support, bug fixes
+* Brandon Liu (github:{bdon}[https://github.com/bdon]) -- spec improvements, array abstraction
+
+== Copyright
+
+Copyright (c) 2010 Jeremy Holland. See LICENSE for details.
+
+

data/lib/ext/savage/Rakefile

@@ -0,0 +1,39 @@
+require 'rubygems'
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "savage"
+    gem.summary = %Q{A little library to manipulate SVG path data}
+    gem.description = %Q{A little gem for extracting and manipulating SVG vector path data.}
+    gem.email = "jeremy@jeremypholland.com"
+    gem.homepage = "http://github.com/awebneck/savage"
+    gem.authors = ["Jeremy Holland"]
+    gem.add_development_dependency "rspec", ">= 2.3.0"
+    # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
+  end
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: gem install jeweler"
+end
+
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec)
+RSpec::Core::RakeTask.new(:rcov) do |spec|
+  spec.rcov = true
+end
+
+task :spec => :check_dependencies
+
+task :default => :spec
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "savage #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/lib/ext/savage/VERSION

@@ -0,0 +1 @@
+1.2.0

data/lib/ext/savage/lib/savage/direction.rb

@@ -0,0 +1,42 @@
+module Savage
+  module Directions
+    Point = Struct.new :x, :y
+  end
+
+  class Direction
+
+    include Utils
+    include Transformable
+
+    def initialize(absolute)
+      @absolute = absolute
+    end
+
+    def absolute?
+      @absolute
+    end
+
+    def relative?
+      !absolute?
+    end
+
+    def to_command
+      arr = to_a
+      arr.map! do |x|
+        x.to_i == x ? x.to_i : x
+      end
+      arr[0] + arr[1..-1].join(' ').gsub(/ -/,'-')
+    end
+  end
+end
+
+require File.dirname(__FILE__) + "/directions/close_path"
+require File.dirname(__FILE__) + "/directions/coordinate_target"
+require File.dirname(__FILE__) + "/directions/horizontal_to"
+require File.dirname(__FILE__) + "/directions/vertical_to"
+require File.dirname(__FILE__) + "/directions/point_target"
+require File.dirname(__FILE__) + "/directions/move_to"
+require File.dirname(__FILE__) + "/directions/line_to"
+require File.dirname(__FILE__) + "/directions/quadratic_curve_to"
+require File.dirname(__FILE__) + "/directions/cubic_curve_to"
+require File.dirname(__FILE__) + "/directions/arc_to"

data/lib/ext/savage/lib/savage/direction_proxy.rb

@@ -0,0 +1,19 @@
+module Savage
+  module DirectionProxy
+    def self.included(klass)
+      klass.extend ClassMethods
+    end
+
+    module ClassMethods
+      def define_proxies(&block)
+        Directions.constants.each do |constant_sym|
+          constant = (constant_sym.is_a?(Symbol)) ? constant_sym.to_s : constant_sym
+          unless %w[PointTarget CoordinateTarget Point MoveTo].include? constant
+            sym = constant.to_s.gsub(/[A-Z]/) { |p| '_' + p.downcase }[1..-1].to_sym
+            block.call(sym,constant)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ext/savage/lib/savage/directions/arc_to.rb

@@ -0,0 +1,29 @@
+module Savage
+  module Directions
+    class ArcTo < PointTarget
+      attr_accessor :radius, :rotation, :large_arc, :sweep
+
+      def initialize(radius_x, radius_y, rotation, large_arc, sweep, target_x, target_y, absolute=true)
+        super(target_x, target_y, absolute)
+        @radius = Point.new(radius_x, radius_y)
+        @rotation = rotation
+        @large_arc = large_arc.is_a?(Numeric) ? large_arc > 0 : large_arc
+        @sweep = sweep.is_a?(Numeric) ? sweep > 0 : sweep
+      end
+
+      def to_a
+        [command_code, @radius.x, @radius.y, @rotation, bool_to_int(@large_arc), bool_to_int(@sweep), target.x, target.y]
+      end
+
+      def command_code
+        (absolute?) ? 'A' : 'a'
+      end
+
+      def transform(scale_x, skew_x, skew_y, scale_y, tx, ty)
+        # relative arc_to dont't need to be tranlated
+        tx = ty = 0 if relative?
+        transform_dot( target,  scale_x, skew_x, skew_y, scale_y, tx, ty)
+      end
+    end
+  end
+end

data/lib/ext/savage/lib/savage/directions/close_path.rb

@@ -0,0 +1,18 @@
+module Savage
+  module Directions
+    class ClosePath < Direction
+
+      def initialize(absolute=true)
+        super(absolute)
+      end
+
+      def to_a
+        [command_code]
+      end
+
+      def command_code
+        (absolute?) ? 'Z' : 'z'
+      end
+    end
+  end
+end

data/lib/ext/savage/lib/savage/directions/coordinate_target.rb

@@ -0,0 +1,17 @@
+module Savage
+  module Directions
+    class CoordinateTarget < Direction
+
+      attr_accessor :target
+
+      def initialize(target, absolute=true)
+        @target = target
+        super(absolute)
+      end
+
+      def to_a
+        [command_code, @target]
+      end
+    end
+  end
+end

data/lib/ext/savage/lib/savage/directions/cubic_curve_to.rb

@@ -0,0 +1,40 @@
+module Savage
+  module Directions
+    class CubicCurveTo < QuadraticCurveTo
+      attr_accessor :control_1
+
+      def initialize(*args)
+        raise ArgumentError if args.length < 4
+        case args.length
+        when 4
+          super(args[0],args[1],args[2],args[3],true)
+        when 5
+          raise ArgumentError if args[4].kind_of?(Numeric)
+          super(args[0],args[1],args[2],args[3],args[4])
+        when 6
+          @control_1 = Point.new(args[0],args[1])
+          super(args[2],args[3],args[4],args[5],true)
+        when 7
+          @control_1 = Point.new(args[0],args[1])
+          super(args[2],args[3],args[4],args[5],args[6])
+        end
+      end
+
+      def to_a
+        if @control_1
+          [command_code, @control_1.x, @control_1.y, @control.x, @control.y, @target.x, @target.y]
+        else
+          [command_code, @control.x, @control.y, @target.x, @target.y]
+        end
+      end
+
+      def control_2; @control; end
+      def control_2=(value); @control = value; end
+
+      def command_code
+        return (absolute?) ? 'C' : 'c' if @control_1
+        (absolute?) ? 'S' : 's'
+      end
+    end
+  end
+end

data/lib/ext/savage/lib/savage/directions/horizontal_to.rb

@@ -0,0 +1,19 @@
+module Savage
+  module Directions
+    class HorizontalTo < CoordinateTarget
+      def command_code
+        (absolute?) ? 'H' : 'h'
+      end
+
+      def transform(scale_x, skew_x, skew_y, scale_y, tx, ty)
+
+        unless skew_y.zero?
+          raise 'rotating or skewing (in Y axis) an "horizontal_to" direction is not supported yet.'
+        end
+        
+        self.target *= scale_x
+        self.target += tx if absolute?
+      end
+    end
+  end
+end

data/lib/ext/savage/lib/savage/directions/line_to.rb

@@ -0,0 +1,15 @@
+module Savage
+  module Directions
+    class LineTo < PointTarget
+      def command_code
+        (absolute?) ? 'L' : 'l'
+      end
+
+      def transform(scale_x, skew_x, skew_y, scale_y, tx, ty)
+        # relative line_to dont't need to be tranlated
+        tx = ty = 0 if relative?
+        transform_dot( target, scale_x, skew_x, skew_y, scale_y, tx, ty)
+      end
+    end
+  end
+end

data/lib/ext/savage/lib/savage/directions/move_to.rb

@@ -0,0 +1,15 @@
+module Savage
+  module Directions
+    class MoveTo < PointTarget
+      def command_code
+        (absolute?) ? 'M' : 'm'
+      end
+
+      def transform(scale_x, skew_x, skew_y, scale_y, tx, ty)
+        # relative move_to dont't need to be tranlated
+        tx = ty = 0 if relative?
+        transform_dot( target, scale_x, skew_x, skew_y, scale_y, tx, ty )
+      end
+    end
+  end
+end

data/lib/ext/savage/lib/savage/directions/point_target.rb

@@ -0,0 +1,17 @@
+module Savage
+  module Directions
+    class PointTarget < Direction
+
+      attr_accessor :target
+
+      def initialize(x, y, absolute=true)
+        @target = Point.new(x,y)
+        super(absolute)
+      end
+
+      def to_a
+        [command_code, @target.x, @target.y]
+      end
+    end
+  end
+end

data/lib/ext/savage/lib/savage/directions/quadratic_curve_to.rb

@@ -0,0 +1,44 @@
+module Savage
+  module Directions
+    class QuadraticCurveTo < PointTarget
+      attr_accessor :control
+
+      def initialize(*args)
+        raise ArgumentError if args.length < 2
+        case args.length
+        when 2
+          super(args[0],args[1],true)
+        when 3
+          raise ArgumentError if args[2].kind_of?(Numeric)
+          super(args[0],args[1],args[2])
+        when 4
+          @control = Point.new(args[0],args[1])
+          super(args[2],args[3],true)
+        when 5
+          @control = Point.new(args[0],args[1])
+          super(args[2],args[3],args[4])
+        end
+      end
+
+      def to_a
+        if @control
+          [command_code, @control.x, @control.y, @target.x, @target.y]
+        else
+          [command_code, @target.x, @target.y]
+        end
+      end
+
+      def command_code
+        return (absolute?) ? 'Q' : 'q' if @control
+        (absolute?) ? 'T' : 't'
+      end
+
+      def transform(scale_x, skew_x, skew_y, scale_y, tx, ty)
+        # relative line_to dont't need to be tranlated
+        tx = ty = 0 if relative?
+        transform_dot( target,  scale_x, skew_x, skew_y, scale_y, tx, ty)
+        transform_dot( control, scale_x, skew_x, skew_y, scale_y, tx, ty)
+      end
+    end
+  end
+end

data/lib/ext/savage/lib/savage/directions/vertical_to.rb

@@ -0,0 +1,19 @@
+module Savage
+  module Directions
+    class VerticalTo < CoordinateTarget
+      def command_code
+        (absolute?) ? 'V' : 'v'
+      end
+
+      def transform(scale_x, skew_x, skew_y, scale_y, tx, ty)
+
+        unless skew_x.zero?
+          raise 'rotating or skewing (in X axis) an "vertical_to" direction is not supported yet.'
+        end
+        
+        self.target *= scale_y
+        self.target += ty if absolute?
+      end
+    end
+  end
+end

data/lib/ext/savage/lib/savage/parser.rb

@@ -0,0 +1,108 @@
+module Savage
+  class Parser
+    DIRECTIONS = {
+      :m => {:class => Directions::MoveTo,
+             :args => 2},
+      :l => {:class => Directions::LineTo,
+             :args => 2},
+      :h => {:class => Directions::HorizontalTo,
+             :args => 1},
+      :v => {:class => Directions::VerticalTo,
+             :args => 1},
+      :c => {:class => Directions::CubicCurveTo,
+             :args => 6},
+      :s => {:class => Directions::CubicCurveTo,
+             :args => 4},
+      :q => {:class => Directions::QuadraticCurveTo,
+             :args => 4},
+      :t => {:class => Directions::QuadraticCurveTo,
+             :args => 2},
+      :a => {:class => Directions::ArcTo,
+             :args => 7}
+    }
+
+    class << self
+      def parse(parsable)
+        raise TypeError if parsable.class != String
+        subpaths = extract_subpaths parsable
+        raise TypeError if (subpaths.empty?)
+        path = Path.new
+        path.subpaths = []
+        subpaths.each_with_index do |subpath, i|
+          path.subpaths << parse_subpath(subpath, i == 0)
+        end
+        path
+      end
+      
+      private
+        def extract_subpaths(parsable)
+          subpaths = []
+          if move_index = parsable.index(/[Mm]/)
+            subpaths << parsable[0...move_index] if move_index > 0
+            parsable.scan(/[Mm](?:\d|[eE.,+-]|[LlHhVvQqCcTtSsAaZz]|\W)+/m) do |match_group|
+              subpaths << $&
+            end
+          else
+            subpaths << parsable
+          end
+          subpaths
+        end
+        
+        def parse_subpath(parsable, force_absolute=false)
+          subpath = SubPath.new
+          subpath.directions = extract_directions parsable, force_absolute
+          subpath
+        end
+        
+        def extract_directions(parsable, force_absolute=false)
+          directions = []
+          i = 0
+          parsable.scan(/[MmLlHhVvQqCcTtSsAaZz](?:\d|[eE.,+-]|\W)*/m) do |match_group|
+            direction = build_direction $&, force_absolute && i == 0
+            if direction.kind_of?(Array)
+              directions.concat direction
+            else
+              directions << direction
+            end
+            i += 1
+          end
+          directions
+        end
+        
+        def build_direction(parsable, force_absolute=false)
+          directions = []
+          @coordinates = extract_coordinates parsable
+          recurse_code = parsable[0,1]
+          first_absolute = force_absolute
+          
+          # we need to handle this separately, since ClosePath doesn't take any coordinates
+          if @coordinates.empty? && recurse_code =~ /[Zz]/
+            directions << Directions::ClosePath.new(parsable[0,1] == parsable[0,1].upcase)
+          end
+          
+          until @coordinates.empty?
+            absolute = (first_absolute || parsable[0,1] == parsable[0,1].upcase)
+            directions << construct_direction(recurse_code.strip[0].downcase.intern, absolute)
+            recurse_code = 'L' if recurse_code.downcase =~ /m/
+            first_absolute = false
+          end
+          
+          directions
+        end
+
+        def construct_direction(recurse_code, absolute)
+          args = @coordinates.shift DIRECTIONS[recurse_code][:args]
+          raise TypeError if args.any?(&:nil?)
+          DIRECTIONS[recurse_code][:class].new(*args, absolute)
+        end
+        
+        def extract_coordinates(command_string)
+          coordinates = []
+          command_string.scan(/-?\d+(\.\d+)?([eE][+-]?\d+)?/) do |match_group|
+            coordinates << $&.to_f
+          end
+          coordinates
+        end
+    end
+  end
+end