savage 0.1.0 → 0.2.0

data/spec/savage/directions/cubic_curve_to_spec.rb

@@ -17,13 +17,9 @@ describe CubicCurveTo do
     @dir.respond_to?(:target).should == true
     @dir.target.class.should == Point
   end
-  it 'should have a first control point' do
-    @dir.respond_to?(:control_1).should == true
-    @dir.control_1.class.should == Point
-  end
-  it 'should have a first control point' do
-    @dir.respond_to?(:control_2).should == true
-    @dir.control_2.class.should == Point
+  it 'should have a control point' do
+    @dir.respond_to?(:control).should == true
+    @dir.control.class.should == Point
   end
   it 'should have an accessible target x, based on the constructor argument' do
     @dir.target.x.should == 500
@@ -31,55 +27,60 @@ describe CubicCurveTo do
   it 'should have an accessible target y, based on the constructor argument' do
     @dir.target.y.should == 600
   end
-  it 'should have an accessible first control x, based on the constructor argument' do
-    @dir.control_1.x.should == 100
-  end
-  it 'should have an accessible first control y, based on the constructor argument' do
-    @dir.control_1.y.should == 200
-  end
   it 'should have an accessible second control x, based on the constructor argument' do
     @dir.control_2.x.should == 300
   end
   it 'should have an accessible second control y, based on the constructor argument' do
     @dir.control_2.y.should == 400
   end
-  it 'should be constructed with at least target x and y, a control 1 x and y, and a control 2 x and y parameters' do
-    lambda { dir_class.new }.should raise_error
-    lambda { dir_class.new 45 }.should raise_error
-    lambda { dir_class.new 45, 50 }.should raise_error
-    lambda { dir_class.new 45, 50, 60 }.should raise_error
-    lambda { dir_class.new 45, 50, 60, 70 }.should raise_error
-    lambda { dir_class.new 45, 50, 60, 70, 80 }.should raise_error
-    lambda { dir_class.new 45, 50, 60, 70, 80, 90 }.should_not raise_error
-    lambda { dir_class.new 45, 50, 60, 70, 80, 90, true }.should_not raise_error
-  end
-  it 'should be relative if constructed with a true seventh parameter' do
-    direction = dir_class.new 45, 50, 60, 70, 80, 90, false
-    direction.absolute?.should == false
-  end
-  it 'should be absolute if constructed with a false seventh parameter' do
-    direction = dir_class.new 45, 50, 60, 70, 80, 90, true
-    direction.absolute?.should == true
-  end
-  it 'should be absolute if constructed with only six parameters' do
-    direction = dir_class.new 45, 50, 60, 70, 80, 90
-    direction.absolute?.should == true
-  end
-  describe '#to_command' do
-    context 'when not asked to be continuous' do
+  context 'when in verbose format' do
+    it 'should be constructed with at least target x and y, control 1 x and y, and control 2 x and y parameters' do
+      lambda { dir_class.new }.should raise_error
+      lambda { dir_class.new 45 }.should raise_error
+      lambda { dir_class.new 45, 50 }.should raise_error
+      lambda { dir_class.new 45, 50, 60 }.should raise_error
+      lambda { dir_class.new 45, 50, 60, 70, 80 }.should raise_error
+      lambda { dir_class.new 45, 50, 60, 70, 80, 90 }.should_not raise_error
+      lambda { dir_class.new 45, 50, 60, 70, 80, 90, true }.should_not raise_error
+    end
+    it 'should be relative if constructed with a false seventh parameter' do
+      direction = dir_class.new 45, 50, 60, 70, 80, 90, false
+      direction.absolute?.should == false
+    end
+    it 'should be absolute if constructed with a true seventh parameter' do
+      direction = dir_class.new 45, 50, 60, 70, 80, 90, true
+      direction.absolute?.should == true
+    end
+    it 'should be absolute if constructed with only six parameters' do
+      direction = dir_class.new 45, 50, 60, 70, 80, 90
+      direction.absolute?.should == true
+    end
+    it 'should have an accessible first control x, based on the constructor argument' do
+      @dir.control_1.x.should == 100
+    end
+    it 'should have an accessible first control y, based on the constructor argument' do
+      @dir.control_1.y.should == 200
+    end
+    describe '#to_command' do
+      it 'should start with a lower-case c when not absolute' do
+        extract_command(CubicCurveTo.new(100,200,300,400,500,600,false).to_command).should == 'c'
+      end
+      it 'should start with a capital C when absolute' do
+        extract_command(@dir.to_command).should == 'C'
+      end
       it 'should have exactly 6 numerical parameters' do
         extract_coordinates(@dir.to_command).length.should == 6
       end
-      it 'should show the provided control 1 X value as the first parameter' do
+      it 'should show the provided first control X value as the first parameter' do
         extract_coordinates(@dir.to_command)[0].should == 100
       end
-      it 'should show the provided control 1 Y value as the second parameter' do
+      it 'should show the provided first control Y value as the second parameter' do
         extract_coordinates(@dir.to_command)[1].should == 200
       end
-      it 'should show the provided control 2 X value as the third parameter' do
+      it 'should show the provided second control X value as the third parameter' do
         extract_coordinates(@dir.to_command)[2].should == 300
       end
-      it 'should show the provided control 2 Y value as the fourth parameter' do
+      it 'should show the provided second control Y value as the fourth parameter' do
         extract_coordinates(@dir.to_command)[3].should == 400
       end
       it 'should show the provided target X value as the fifth parameter' do
@@ -89,28 +90,55 @@ describe CubicCurveTo do
         extract_coordinates(@dir.to_command)[5].should == 600
       end
     end
-    context 'when asked to be continuous' do
+  end
+  context 'when in shorthand format' do
+    before :each do
+      @dir = CubicCurveTo.new(100,200,300,400)
+    end
+    it 'should be constructed with at least target x and y parameters' do
+      lambda { dir_class.new }.should raise_error
+      lambda { dir_class.new 45 }.should raise_error
+      lambda { dir_class.new 45, 50 }.should raise_error
+      lambda { dir_class.new 45, 50, 60 }.should raise_error
+      lambda { dir_class.new 45, 50, 60, 70 }.should_not raise_error
+      lambda { dir_class.new 45, 50, 60, 70, true }.should_not raise_error
+    end
+    it 'should be relative if constructed with a false third parameter' do
+      direction = dir_class.new 45, 50, 60, 70, false
+      direction.absolute?.should == false
+    end
+    it 'should be absolute if constructed with a true third parameter' do
+      direction = dir_class.new 45, 50, 60, 70, true
+      direction.absolute?.should == true
+    end
+    it 'should be absolute if constructed with only two parameters' do
+      direction = dir_class.new 45, 50, 60, 70
+      direction.absolute?.should == true
+    end
+    it 'should have an nil first control, based on the constructor argument' do
+      @dir.control_1.should == nil
+    end
+    describe '#to_command' do
       it 'should start with a lower-case s when not absolute' do
-        rel_dir = create_relative
-        extract_command(rel_dir.to_command(true)).should == 's'
+        extract_command(CubicCurveTo.new(100,200,300,400,false).to_command).should == 's'
       end
       it 'should start with a capital S when absolute' do
-        extract_command(@dir.to_command(true)).should == 'S'
+        extract_command(@dir.to_command).should == 'S'
       end
-      it 'should have exactly 4 numerical parameters' do
-        extract_coordinates(@dir.to_command(true)).length.should == 4
+      it 'should have exactly 2 numerical parameters' do
+        extract_coordinates(@dir.to_command).length.should == 4
       end
-      it 'should show the provided control 2 X value as the first parameter' do
-        extract_coordinates(@dir.to_command(true))[0].should == 300
+      it 'should show the provided second control X value as the first parameter' do
+        extract_coordinates(@dir.to_command)[0].should == 100
       end
-      it 'should show the provided control 2 Y value as the second parameter' do
-        extract_coordinates(@dir.to_command(true))[1].should == 400
+      it 'should show the provided second control Y value as the second parameter' do
+        extract_coordinates(@dir.to_command)[1].should == 200
       end
       it 'should show the provided target X value as the third parameter' do
-        extract_coordinates(@dir.to_command(true))[2].should == 500
+        extract_coordinates(@dir.to_command)[2].should == 300
       end
       it 'should show the provided target Y value as the fourth parameter' do
-        extract_coordinates(@dir.to_command(true))[3].should == 600
+        extract_coordinates(@dir.to_command)[3].should == 400
       end
     end
   end

data/spec/savage/directions/quadratic_curve_spec.rb

@@ -27,54 +27,96 @@ describe QuadraticCurveTo do
   it 'should have an accessible target y, based on the constructor argument' do
     @dir.target.y.should == 400
   end
-  it 'should have an accessible first control x, based on the constructor argument' do
-    @dir.control.x.should == 100
-  end
-  it 'should have an accessible first control y, based on the constructor argument' do
-    @dir.control.y.should == 200
-  end
-  it 'should be constructed with at least target x and y, a control 1 x and y, and a control 2 x and y parameters' do
-    lambda { dir_class.new }.should raise_error
-    lambda { dir_class.new 45 }.should raise_error
-    lambda { dir_class.new 45, 50 }.should raise_error
-    lambda { dir_class.new 45, 50, 60 }.should raise_error
-    lambda { dir_class.new 45, 50, 60, 70 }.should_not raise_error
-    lambda { dir_class.new 45, 50, 60, 70, true }.should_not raise_error
-  end
-  it 'should be relative if constructed with a false fifth parameter' do
-    direction = dir_class.new 45, 50, 60, 70, false
-    direction.absolute?.should == false
-  end
-  it 'should be absolute if constructed with a true fifth parameter' do
-    direction = dir_class.new 45, 50, 60, 70, true
-    direction.absolute?.should == true
-  end
-  it 'should be absolute if constructed with only four parameters' do
-    direction = dir_class.new 45, 50, 60, 70
-    direction.absolute?.should == true
+  context 'when in verbose format' do
+    it 'should be constructed with at least target x and y and control x and y parameters' do
+      lambda { dir_class.new }.should raise_error
+      lambda { dir_class.new 45 }.should raise_error
+      lambda { dir_class.new 45, 50, 60 }.should raise_error
+      lambda { dir_class.new 45, 50, 60, 70 }.should_not raise_error
+      lambda { dir_class.new 45, 50, 60, 70, true }.should_not raise_error
+    end
+    it 'should be relative if constructed with a false fifth parameter' do
+      direction = dir_class.new 45, 50, 60, 70, false
+      direction.absolute?.should == false
+    end
+    it 'should be absolute if constructed with a true fifth parameter' do
+      direction = dir_class.new 45, 50, 60, 70, true
+      direction.absolute?.should == true
+    end
+    it 'should be absolute if constructed with only four parameters' do
+      direction = dir_class.new 45, 50, 60, 70
+      direction.absolute?.should == true
+    end
+    it 'should have an accessible first control x, based on the constructor argument' do
+      @dir.control.x.should == 100
+    end
+    it 'should have an accessible first control y, based on the constructor argument' do
+      @dir.control.y.should == 200
+    end
+    describe '#to_command' do
+      it 'should start with a lower-case q when not absolute' do
+        extract_command(QuadraticCurveTo.new(100,200,300,400,false).to_command).should == 'q'
+      end
+      it 'should start with a capital Q when absolute' do
+        extract_command(@dir.to_command).should == 'Q'
+      end
+      it 'should have exactly 4 numerical parameters' do
+        extract_coordinates(@dir.to_command).length.should == 4
+      end
+      it 'should show the provided control X value as the first parameter' do
+        extract_coordinates(@dir.to_command)[0].should == 100
+      end
+      it 'should show the provided control Y value as the second parameter' do
+        extract_coordinates(@dir.to_command)[1].should == 200
+      end
+      it 'should show the provided target X value as the third parameter' do
+        extract_coordinates(@dir.to_command)[2].should == 300
+      end
+      it 'should show the provided target Y value as the fourth parameter' do
+        extract_coordinates(@dir.to_command)[3].should == 400
+      end
+    end
   end
-  describe '#to_command' do
-    it 'should start with a capital T when not absolute' do
-      rel_dir = create_relative
-      extract_command(rel_dir.to_command(true)).should == 't'
+  context 'when in shorthand format' do
+    before :each do
+      @dir = QuadraticCurveTo.new(100,200)
     end
-    it 'should start with a lower-case t when absolute' do
-      extract_command(@dir.to_command(true)).should == 'T'
+    it 'should be constructed with at least target x and y parameters' do
+      lambda { dir_class.new }.should raise_error
+      lambda { dir_class.new 45 }.should raise_error
+      lambda { dir_class.new 45, 50 }.should_not raise_error
     end
-    it 'should have exactly 4 numerical parameters' do
-      extract_coordinates(@dir.to_command).length.should == 4
+    it 'should be relative if constructed with a false third parameter' do
+      direction = dir_class.new 45, 50, false
+      direction.absolute?.should == false
     end
-    it 'should show the provided control X value as the first parameter' do
-      extract_coordinates(@dir.to_command)[0].should == 100
+    it 'should be absolute if constructed with a true third parameter' do
+      direction = dir_class.new 45, 50, true
+      direction.absolute?.should == true
     end
-    it 'should show the provided control Y value as the second parameter' do
-      extract_coordinates(@dir.to_command)[1].should == 200
+    it 'should be absolute if constructed with only two parameters' do
+      direction = dir_class.new 45, 50
+      direction.absolute?.should == true
     end
-    it 'should show the provided target X value as the third parameter' do
-      extract_coordinates(@dir.to_command)[2].should == 300
+    it 'should have an nil control, based on the constructor argument' do
+      @dir.control.should == nil
     end
-    it 'should show the provided target Y value as the fourth parameter' do
-      extract_coordinates(@dir.to_command)[3].should == 400
+    describe '#to_command' do
+      it 'should start with a lower-case t when not absolute' do
+        extract_command(QuadraticCurveTo.new(100,200,false).to_command).should == 't'
+      end
+      it 'should start with a capital T when absolute' do
+        extract_command(@dir.to_command).should == 'T'
+      end
+      it 'should have exactly 2 numerical parameters' do
+        extract_coordinates(@dir.to_command).length.should == 2
+      end
+      it 'should show the provided target X value as the first parameter' do
+        extract_coordinates(@dir.to_command)[0].should == 100
+      end
+      it 'should show the provided target Y value as the second parameter' do
+        extract_coordinates(@dir.to_command)[1].should == 200
+      end
     end
   end
 end

data/spec/savage/parser_spec.rb

@@ -0,0 +1,174 @@
+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 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 a move_to and two line_to directions when the string is a 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].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
+      path.subpaths.last.directions[2].class.should == Directions::LineTo
+      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].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].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].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].target.x.should == -423
+      path.subpaths[1].directions[1].target.y.should == 11.1
+    end
+  end
+end

data/spec/savage/path_spec.rb

@@ -6,14 +6,61 @@ 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 accept a string parameter to build a path based on existing path data' do
-    lambda{ Path.new("M100 200") }.should_not raise_error
+  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 raise an error if anything besides a string is passed to the constructor' do
-    lambda{ Path.new([]) }.should raise_error
-    lambda{ Path.new({}) }.should raise_error
-    lambda{ Path.new(56) }.should raise_error
-    lambda{ Path.new(Object.new) }.should raise_error
+  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
@@ -21,4 +68,38 @@ describe Path do
   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