savage-transform 1.3.0

data/spec/savage/directions/vertical_to_spec.rb

@@ -0,0 +1,10 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+
+include Savage::Directions
+
+describe VerticalTo do
+  def dir_class; VerticalTo; end
+  def create_relative; VerticalTo.new(100,false); end
+  def command_code; 'v'; end
+  it_behaves_like 'CoordinateTarget'
+end

data/spec/savage/parser_spec.rb

@@ -0,0 +1,250 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+include Savage
+
+describe Parser do
+  it 'should have a parse method' do
+    Parser.respond_to?(:parse).should == true
+  end
+  describe '.parse' do
+    it 'should accept a single string as argument' do
+      lambda { Parser.parse }.should raise_error
+      lambda { Parser.parse("M100 200") }.should_not raise_error
+      lambda { Parser.parse(2) }.should raise_error
+    end
+
+    it 'should return a path object with one subpath containing one move_to when the string is only a move_to command' do
+      path = Parser.parse("M100 200")
+      path.class.should == Path
+      path.subpaths.length.should == 1
+      path.subpaths.last.directions.length.should == 1
+      path.subpaths.last.directions.last.class.should == Directions::MoveTo
+    end
+
+    it 'should return a path object with one subpath containing an absolute move_to even when the string starts with a relative move_to command' do
+      path = Parser.parse("m100 200")
+      path.class.should == Path
+      path.subpaths.length.should == 1
+      path.subpaths.last.directions.length.should == 1
+      path.subpaths.last.directions.last.class.should == Directions::MoveTo
+      path.subpaths.last.directions.last.should be_absolute
+    end
+
+    it 'should handle comma separated coordinates' do
+      path = Parser.parse("M100,200")
+      path.class.should == Path
+      path.subpaths.length.should == 1
+      path.subpaths.last.directions.length.should == 1
+      path.subpaths.last.directions.last.class.should == Directions::MoveTo
+    end
+
+    it 'should return a path object with one subpath containing a move_to and a line_to when the string is a move_to command followed by a line_to command' do
+      path = Parser.parse("M100 200l-342.65 21")
+      path.class.should == Path
+      path.subpaths.length.should == 1
+      path.subpaths.last.directions.length.should == 2
+      path.subpaths.last.directions[0].class.should == Directions::MoveTo
+      path.subpaths.last.directions[1].should_not be_absolute
+      path.subpaths.last.directions[1].class.should == Directions::LineTo
+    end
+
+    it 'should return a path object with one subpath containing a move_to and a horizontal_to when the string is a move_to command followed by a horizontal_to command' do
+      path = Parser.parse("M100 200H-342.65")
+      path.class.should == Path
+      path.subpaths.length.should == 1
+      path.subpaths.last.directions.length.should == 2
+      path.subpaths.last.directions[0].class.should == Directions::MoveTo
+      path.subpaths.last.directions[1].class.should == Directions::HorizontalTo
+    end
+
+    it 'should return a path object with one subpath containing a move_to and a vertical_to when the string is a move_to command followed by a vertical_to command' do
+      path = Parser.parse("M100 200V-342.65")
+      path.class.should == Path
+      path.subpaths.length.should == 1
+      path.subpaths.last.directions.length.should == 2
+      path.subpaths.last.directions[0].class.should == Directions::MoveTo
+      path.subpaths.last.directions[1].class.should == Directions::VerticalTo
+    end
+
+    it 'should return a path object with one subpath containing a move_to and a full cubic_curve_to when the string is a move_to command followed by a full cubic_curve_to command' do
+      path = Parser.parse("M100 200C-342.65-32 1.233-34 255 12")
+      path.class.should == Path
+      path.subpaths.length.should == 1
+      path.subpaths.last.directions.length.should == 2
+      path.subpaths.last.directions[0].class.should == Directions::MoveTo
+      path.subpaths.last.directions[1].class.should == Directions::CubicCurveTo
+      path.subpaths.last.directions[1].command_code.should == 'C'
+    end
+
+    it 'should return a path object with one subpath containing a move_to and a short cubic_curve_to when the string is a move_to command followed by a short cubic_curve_to command' do
+      path = Parser.parse("M100 200S1.233-34 255 12")
+      path.class.should == Path
+      path.subpaths.length.should == 1
+      path.subpaths.last.directions.length.should == 2
+      path.subpaths.last.directions[0].class.should == Directions::MoveTo
+      path.subpaths.last.directions[1].class.should == Directions::CubicCurveTo
+      path.subpaths.last.directions[1].command_code.should == 'S'
+    end
+
+    it 'should return a path object with one subpath containing a move_to and a full quadratic_curve_to when the string is a move_to command followed by a full quadratic_curve_to command' do
+      path = Parser.parse("M100 200Q1.233-34 255 12")
+      path.class.should == Path
+      path.subpaths.length.should == 1
+      path.subpaths.last.directions.length.should == 2
+      path.subpaths.last.directions[0].class.should == Directions::MoveTo
+      path.subpaths.last.directions[1].class.should == Directions::QuadraticCurveTo
+      path.subpaths.last.directions[1].command_code.should == 'Q'
+    end
+
+    it 'should return a path object with one subpath containing a move_to and a short quadratic_curve_to when the string is a move_to command followed by a short quadratic_curve_to command' do
+      path = Parser.parse("M100 200T255 12")
+      path.class.should == Path
+      path.subpaths.length.should == 1
+      path.subpaths.last.directions.length.should == 2
+      path.subpaths.last.directions[0].class.should == Directions::MoveTo
+      path.subpaths.last.directions[1].class.should == Directions::QuadraticCurveTo
+      path.subpaths.last.directions[1].command_code.should == 'T'
+    end
+    it 'should return a path object with one subpath containing a move_to and an arc_to when the string is a move_to command followed by an arc_to command' do
+      path = Parser.parse("M100 200A255 12-123 1 0 23-93.4")
+      path.class.should == Path
+      path.subpaths.length.should == 1
+      path.subpaths.last.directions.length.should == 2
+      path.subpaths.last.directions[0].class.should == Directions::MoveTo
+      path.subpaths.last.directions[1].class.should == Directions::ArcTo
+      path.subpaths.last.directions[1].command_code.should == 'A'
+    end
+
+    it 'should return a path object with one subpath containing a move_to, a line_to, and a close_path command when the string is a move_to command followed by a line_to followed by a close_path command' do
+      path = Parser.parse("M100 200l-342.65 21Z")
+      path.class.should == Path
+      path.subpaths.length.should == 1
+      path.subpaths.last.directions.length.should == 3
+      path.subpaths.last.directions[0].class.should == Directions::MoveTo
+      path.subpaths.last.directions[1].class.should == Directions::LineTo
+      path.subpaths.last.directions[2].class.should == Directions::ClosePath
+      path.subpaths.last.closed?.should == true
+    end
+
+    it 'should return a path object with one subpath containing two line_to directions when the string is a line_to command followed by implicit coordinates' do
+      path = Parser.parse("L100 200 300 400")
+      path.class.should == Path
+      path.subpaths.length.should == 1
+      path.subpaths.last.directions.length.should == 2
+      path.subpaths.last.directions[0].class.should == Directions::LineTo
+      path.subpaths.last.directions[0].target.x.should == 100
+      path.subpaths.last.directions[0].target.y.should == 200
+      path.subpaths.last.directions[1].class.should == Directions::LineTo
+      path.subpaths.last.directions[1].target.x.should == 300
+      path.subpaths.last.directions[1].target.y.should == 400
+    end
+
+    it 'should return a path object with one subpath containing two line_to directions when the string is a line_to command followed by implicit coordinates' do
+      path = Parser.parse("L100 200 300 400")
+      path.class.should == Path
+      path.subpaths.length.should == 1
+      path.subpaths.last.directions.length.should == 2
+      path.subpaths.last.directions[0].class.should == Directions::LineTo
+      path.subpaths.last.directions[0].target.x.should == 100
+      path.subpaths.last.directions[0].target.y.should == 200
+      path.subpaths.last.directions[1].class.should == Directions::LineTo
+      path.subpaths.last.directions[1].target.x.should == 300
+      path.subpaths.last.directions[1].target.y.should == 400
+    end
+
+    it 'should return a path object with one subpath containing a move_to and a line_to direction when the string is a move_to command followed by implicit coordinates' do
+      path = Parser.parse("M100 200 300 400")
+      path.class.should == Path
+      path.subpaths.length.should == 1
+      path.subpaths.last.directions.length.should == 2
+      path.subpaths.last.directions[0].class.should == Directions::MoveTo
+      path.subpaths.last.directions[0].target.x.should == 100
+      path.subpaths.last.directions[0].target.y.should == 200
+      path.subpaths.last.directions[1].class.should == Directions::LineTo
+      path.subpaths.last.directions[1].target.x.should == 300
+      path.subpaths.last.directions[1].target.y.should == 400
+    end
+
+    it 'should return a path object with one subpath containing an absolute move_to and two absolute line_to directions when the string is an absolute move_to command followed by more than one set of implicit coordinates' do
+      path = Parser.parse("M100 200 300 400 500 600 ")
+      path.class.should == Path
+      path.subpaths.length.should == 1
+      path.subpaths.last.directions.length.should == 3
+      path.subpaths.last.directions[0].class.should == Directions::MoveTo
+      path.subpaths.last.directions[0].should be_absolute
+      path.subpaths.last.directions[0].target.x.should == 100
+      path.subpaths.last.directions[0].target.y.should == 200
+      path.subpaths.last.directions[1].class.should == Directions::LineTo
+      path.subpaths.last.directions[1].should be_absolute
+      path.subpaths.last.directions[1].target.x.should == 300
+      path.subpaths.last.directions[1].target.y.should == 400
+      path.subpaths.last.directions[2].class.should == Directions::LineTo
+      path.subpaths.last.directions[2].should be_absolute
+      path.subpaths.last.directions[2].target.x.should == 500
+      path.subpaths.last.directions[2].target.y.should == 600
+    end
+
+    it 'should return a path object with one subpath containing an absolute move_to and two relative line_to directions when the string is a relative move_to command followed by more than one set of implicit coordinates' do
+      path = Parser.parse("m100 200 300 400 500 600 ")
+      path.class.should == Path
+      path.subpaths.length.should == 1
+      path.subpaths.last.directions.length.should == 3
+      path.subpaths.last.directions[0].class.should == Directions::MoveTo
+      path.subpaths.last.directions[0].should be_absolute
+      path.subpaths.last.directions[0].target.x.should == 100
+      path.subpaths.last.directions[0].target.y.should == 200
+      path.subpaths.last.directions[1].class.should == Directions::LineTo
+      path.subpaths.last.directions[1].should_not be_absolute
+      path.subpaths.last.directions[1].target.x.should == 300
+      path.subpaths.last.directions[1].target.y.should == 400
+      path.subpaths.last.directions[2].class.should == Directions::LineTo
+      path.subpaths.last.directions[2].should_not be_absolute
+      path.subpaths.last.directions[2].target.x.should == 500
+      path.subpaths.last.directions[2].target.y.should == 600
+    end
+
+    it 'should return a path object with two subpaths containing one line_to directions each when the string is two move_to commands each followed by a line_to command' do
+      path = Parser.parse("M100 200 332 -12.3m594 230-423 11.1")
+      path.class.should == Path
+      path.subpaths.length.should == 2
+      path.subpaths[0].directions.length.should == 2
+      path.subpaths[0].directions[0].class.should == Directions::MoveTo
+      path.subpaths[0].directions[0].should be_absolute
+      path.subpaths[0].directions[0].target.x.should == 100
+      path.subpaths[0].directions[0].target.y.should == 200
+      path.subpaths[0].directions[1].class.should == Directions::LineTo
+      path.subpaths[0].directions[1].should be_absolute
+      path.subpaths[0].directions[1].target.x.should == 332
+      path.subpaths[0].directions[1].target.y.should == -12.3
+      path.subpaths[1].directions[0].class.should == Directions::MoveTo
+      path.subpaths[1].directions[0].should_not be_absolute
+      path.subpaths[1].directions[0].target.x.should == 594
+      path.subpaths[1].directions[0].target.y.should == 230
+      path.subpaths[1].directions[1].class.should == Directions::LineTo
+      path.subpaths[1].directions[1].should_not be_absolute
+      path.subpaths[1].directions[1].target.x.should == -423
+      path.subpaths[1].directions[1].target.y.should == 11.1
+    end
+
+    it 'should generate the same string given to it (assuming float values are used), if not changed in the interim' do
+      path_string = "M100 200A255 12-123 1 0 23-93.4L100 200 300 400Q1.233-34 255 12T255 12H-342.65Z"
+      path = Parser.parse(path_string)
+      path.to_command.should == path_string
+    end
+
+    it "should be able to parse complex paths" do
+      path = Parser.parse("M74.89,146.249c042,0.552,0.376,0.685,0.744,0.293m50.543-9.1323c15.445-16.43,32.782-32.859,49.793-49.289    c-6.298,001-12.595,001-18.893,0c-10.813,10.37-21.759,20.737-32.275,31.107C74.249,134.323,74.424,140.285,74.89,146.249z")
+      path.class.should == Path
+      path.subpaths.length.should == 2
+      path.subpaths[0].directions.length.should == 2
+      path.subpaths[1].directions.length.should == 6
+    end
+
+    it "should support scientific notation in paths (eg. 2e-5)" do
+      # this is a 100x100 square
+      path = Parser.parse "M 0,0 L 1e2,0 100,1000e-1 L 0,10e+1"
+      points = path.directions.map{|d| [d.target.x, d.target.y] }
+      points.should == [[0, 0], [100, 0], [100, 100], [0, 100]]
+    end
+  end
+end

data/spec/savage/path_spec.rb

@@ -0,0 +1,105 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+include Savage
+
+describe Path do
+  it 'should accept no parameters in a constructor for a new, empty path' do
+    lambda{ Path.new }.should_not raise_error
+  end
+  it 'should be able to be constructed with a starting point (absolute move to)' do
+    path = Path.new(100,200)
+    path.subpaths.length.should == 1
+    path.subpaths.last.directions.length.should == 1
+    path.subpaths.last.directions.last.class.should == Directions::MoveTo
+  end
+  it 'should be able to build itself in a block' do
+    path = Path.new(100,200) do |p|
+      p.line_to 300, 400
+      p.cubic_curve_to 500,600,700,800,900,1000
+      p.arc_to 100,200,123,1,1,300,400
+    end
+    path.subpaths.last.directions[0].class.should == Directions::MoveTo
+    path.subpaths.last.directions[1].class.should == Directions::LineTo
+    path.subpaths.last.directions[2].class.should == Directions::CubicCurveTo
+    path.subpaths.last.directions[3].class.should == Directions::ArcTo
+
+    path2 = Path.new do |p|
+      p.line_to 300, 400
+      p.cubic_curve_to 500,600,700,800,900,1000
+      p.arc_to 100,200,123,1,1,300,400
+    end
+    path2.subpaths.last.directions[0].class.should == Directions::LineTo
+    path2.subpaths.last.directions[1].class.should == Directions::CubicCurveTo
+    path2.subpaths.last.directions[2].class.should == Directions::ArcTo
+  end
+  it 'should have a directions list' do
+    Path.new.respond_to?(:directions).should == true
+  end
+  it 'should have a move_to method' do
+    Path.new.respond_to?(:move_to).should == true
+  end
+  it 'should have a line_to method' do
+    Path.new.respond_to?(:line_to).should == true
+  end
+  it 'should have a horizontal_to method' do
+    Path.new.respond_to?(:horizontal_to).should == true
+  end
+  it 'should have a vertical_to method' do
+    Path.new.respond_to?(:vertical_to).should == true
+  end
+  it 'should have a quadratic_curve_to method' do
+    Path.new.respond_to?(:quadratic_curve_to).should == true
+  end
+  it 'should have a cubic_curve_to method' do
+    Path.new.respond_to?(:cubic_curve_to).should == true
+  end
+  it 'should have a arc_to method' do
+    Path.new.respond_to?(:arc_to).should == true
+  end
+  it 'should have a close_path method' do
+    Path.new.respond_to?(:close_path).should == true
+  end
+  it 'should have a closed? method' do
+    Path.new.respond_to?(:closed?).should == true
+  end
+  it 'should have subpaths' do
+    Path.new.respond_to?(:subpaths).should == true
+  end
+  it 'should have a to_command method' do
+    Path.new.respond_to?(:to_command).should == true
+  end
+  describe '#move_to' do
+    it 'should create a new subpath with that movement therein if there is already a populated subpath' do
+      path = Path.new(200,300) do |p|
+        p.line_to(123,456)
+        p.close_path
+      end
+      path.move_to(200,300)
+      path.subpaths.length.should == 2
+      path.subpaths.last.directions.length.should == 1
+      path.subpaths.last.directions.last.class.should == Directions::MoveTo
+    end
+    it 'should create append the movement if the last subpath is empty a populated subpath' do
+      path = Path.new
+      path.move_to(200,300)
+      path.subpaths.length.should == 1
+      path.subpaths.last.directions.length.should == 1
+      path.subpaths.last.directions.last.class.should == Directions::MoveTo
+    end
+  end
+  describe '#to_command' do
+    it 'should concatenate all its subpaths command strings' do
+      path = Path.new(100,200) do |p|
+        p.line_to 300, 400
+        p.cubic_curve_to 500,600,700,800,900,1000
+        p.arc_to 100,200,123,1,1,300,400
+        p.close_path
+        p.move_to 499, 232
+        p.line_to 2433.4, -231
+        p.line_to -233, 122
+      end
+      concatenated = path.subpaths.collect { |subpath| subpath.to_command }.join
+      path.to_command.should == concatenated
+    end
+  end
+end

data/spec/savage/sub_path_spec.rb

@@ -0,0 +1,195 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+include Savage
+
+describe SubPath do
+  it 'should have a directions list' do
+    SubPath.new.respond_to?(:directions).should == true
+  end
+  it 'should have a move_to method' do
+    SubPath.new.respond_to?(:move_to).should == true
+  end
+  it 'should have a line_to method' do
+    SubPath.new.respond_to?(:line_to).should == true
+  end
+  it 'should have a horizontal_to method' do
+    SubPath.new.respond_to?(:horizontal_to).should == true
+  end
+  it 'should have a vertical_to method' do
+    SubPath.new.respond_to?(:vertical_to).should == true
+  end
+  it 'should have a quadratic_curve_to method' do
+    SubPath.new.respond_to?(:quadratic_curve_to).should == true
+  end
+  it 'should have a cubic_curve_to method' do
+    SubPath.new.respond_to?(:cubic_curve_to).should == true
+  end
+  it 'should have a arc_to method' do
+    SubPath.new.respond_to?(:arc_to).should == true
+  end
+  it 'should have a close_path method' do
+    SubPath.new.respond_to?(:close_path).should == true
+  end
+  it 'should have a closed? method' do
+    SubPath.new.respond_to?(:closed?).should == true
+  end
+  it 'should have a to_command method' do
+    SubPath.new.respond_to?(:to_command).should == true
+  end
+  it 'should be able to be constructed empty' do
+    lambda { SubPath.new }.should_not raise_error
+  end
+  it 'should be able to be constructed with a starting point (absolute move to)' do
+    path = SubPath.new(100,200)
+    path.directions.length.should == 1
+    path.directions.last.class.should == Directions::MoveTo
+  end
+  it 'should be able to build itself in a block' do
+    path = SubPath.new(100,200) do |p|
+      p.line_to 300, 400
+      p.cubic_curve_to 500,600,700,800,900,1000
+      p.arc_to 100,200,123,1,1,300,400
+    end
+    path.directions[0].class.should == Directions::MoveTo
+    path.directions[1].class.should == Directions::LineTo
+    path.directions[2].class.should == Directions::CubicCurveTo
+    path.directions[3].class.should == Directions::ArcTo
+    
+    path2 = SubPath.new do |p|
+      p.line_to 300, 400
+      p.cubic_curve_to 500,600,700,800,900,1000
+      p.arc_to 100,200,123,1,1,300,400
+    end
+    path2.directions[0].class.should == Directions::LineTo
+    path2.directions[1].class.should == Directions::CubicCurveTo
+    path2.directions[2].class.should == Directions::ArcTo
+  end
+  describe '#quadratic_curve_to' do
+    it 'should raise an error if in short format and the previous command is of any type by QuadraticCurveTo' do
+      path = SubPath.new
+      lambda { path.quadratic_curve_to 500, 600 }.should raise_error
+      path = SubPath.new
+      path.move_to 233, 123
+      lambda { path.quadratic_curve_to 500, 600 }.should raise_error
+      path = SubPath.new
+      path.line_to 443, 265
+      lambda { path.quadratic_curve_to 500, 600 }.should raise_error
+      path = SubPath.new
+      path.cubic_curve_to 100,200,300,400,500,600
+      lambda { path.quadratic_curve_to 500, 600 }.should raise_error
+    end
+    it 'should not raise an error if in short format and the previous command is of type QuadraticCurveTo' do
+      path = SubPath.new
+      path.quadratic_curve_to 100,200,300,400
+      lambda { path.quadratic_curve_to 500, 600 }.should_not raise_error
+    end
+  end
+  describe '#cubic_curve_to' do
+    it 'should raise an error if in short format and the previous command is of any type by CubicCurveTo' do
+      path = SubPath.new
+      lambda { path.cubic_curve_to 500, 600, 700, 800 }.should raise_error
+      path = SubPath.new
+      path.move_to 233, 123
+      lambda { path.cubic_curve_to 500, 600, 700, 800 }.should raise_error
+      path = SubPath.new
+      path.line_to 443, 265
+      lambda { path.cubic_curve_to 500, 600, 700, 800 }.should raise_error
+      path = SubPath.new
+      path.quadratic_curve_to 100,200,300,400
+      lambda { path.cubic_curve_to 500, 600, 700, 800 }.should raise_error
+    end
+    it 'should not raise an error if in short format and the previous command is of type CubicCurveTo' do
+      path = SubPath.new
+      path.cubic_curve_to 100,200,300,400,500,600
+      lambda { path.cubic_curve_to 500, 600, 700, 800 }.should_not raise_error
+    end
+  end
+  describe '#closed?' do
+    it 'should be true if the last direction in the directions list is of type ClosePath' do
+      path = SubPath.new
+      path.move_to 100, 300
+      path.line_to 243, 21
+      path.close_path
+      path.closed?.should == true
+    end
+    it 'should be false if the last direction in the directions list is of any other type or absent' do
+      path = SubPath.new
+      path.move_to 100, 300
+      path.line_to 234, 21
+      path.closed?.should == false
+      path2 = SubPath.new
+      path2.closed?.should == false
+    end
+  end
+  describe '#to_command' do
+    before :each do
+      @path = SubPath.new
+      @dir_1 = @path.move_to 100, 200
+    end
+    it 'should output the concatenation of all the subdirections if no two are the same in sequence' do
+      dir_2 = @path.horizontal_to -200
+      dir_3 = @path.quadratic_curve_to 342, -341.23, 405, 223
+      dir_4 = @path.line_to -342.002, 231.42
+      dir_5 = @path.close_path
+      @path.to_command.should == @dir_1.to_command << dir_2.to_command << dir_3.to_command << dir_4.to_command << dir_5.to_command
+    end
+    it 'should strip the command code if the previous code was the same as the present' do
+      dir_2 = @path.horizontal_to -200
+      dir_3 = @path.line_to -342.002, 231.42
+      dir_4 = @path.line_to -234, 502
+      @path.to_command.should == @dir_1.to_command << dir_2.to_command << dir_3.to_command << dir_4.to_command[1..-1]
+    end
+    it 'should not strip the command code if the previous code was the same as the present, but of different absoluteness' do
+      dir_2 = @path.horizontal_to -200
+      dir_3 = @path.line_to -342.002, 231.42
+      dir_4 = @path.line_to -234, 502, false
+      @path.to_command.should == @dir_1.to_command << dir_2.to_command << dir_3.to_command << dir_4.to_command
+    end
+    it 'should strip the command code if the previous code was a MoveTo and the current code is an absolute LineTo' do
+      dir_2 = @path.line_to -342.002, 231.42
+      dir_3 = @path.line_to -234, 502
+      @path.to_command.should == @dir_1.to_command << dir_2.to_command[1..-1] << dir_3.to_command[1..-1]
+    end
+    it 'should not strip the command code if the previous code was a MoveTo and the current code is a relative LineTo' do
+      dir_2 = @path.line_to -342.002, 231.42, false
+      dir_3 = @path.line_to -234, 502
+      @path.to_command.should == @dir_1.to_command << dir_2.to_command << dir_3.to_command
+    end
+    it 'should add leading whitespace if the first coordinate of the code-stripped direction is not negative' do
+      dir_2 = @path.horizontal_to -200
+      dir_3 = @path.line_to -342.002, 231.42
+      dir_4 = @path.line_to 234, 502
+      @path.to_command.should == @dir_1.to_command << dir_2.to_command << dir_3.to_command << dir_4.to_command[1..-1].insert(0,' ')
+    end
+  end
+  describe '#move_to' do
+    before :each do
+      @path = SubPath.new
+    end
+    context 'when the command list is empty' do
+      it 'should add a MoveTo command on to the directions list' do
+        this_move = @path.move_to(100,200)
+        @path.directions.should == [this_move]
+      end
+      it 'should return the newly created MoveTo command' do
+        @path.move_to(100,200).class.should == Directions::MoveTo
+      end
+    end
+    context 'when the command list is not empty' do
+      it 'does something' do
+        first_move = @path.move_to(200,400)
+        @path.move_to(100,200)
+        @path.directions.should == [first_move]
+      end
+      it 'should return nil' do
+        @path.move_to(200,400)
+        @path.move_to(100,200).nil?.should == true
+      end
+    end
+  end
+  describe '#directions' do
+    it 'should be able to access items via the bracket operator' do
+      SubPath.new.directions.respond_to?(:[]).should == true
+    end
+  end
+end