text2path 0.0.2 → 0.0.4

data/lib/ext/savage/spec/savage/directions/vertical_to_spec.rb

@@ -1,10 +0,0 @@
-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/lib/ext/savage/spec/savage/parser_spec.rb

@@ -1,250 +0,0 @@
-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/lib/ext/savage/spec/savage/path_spec.rb

@@ -1,105 +0,0 @@
-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/lib/ext/savage/spec/savage/sub_path_spec.rb

@@ -1,195 +0,0 @@
-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