Allow Directory.create to create all missing path components.

tests/standalone/io/directory_test.dart

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 //
 // Directory listing test.
 
 #import("dart:io");
 #import("dart:isolate");
 
 class DirectoryTest {
@@ skipping 22 matching lines @@
       listedFile = true;
       Expect.isTrue(f.contains(directory.path));
       Expect.isTrue(f.contains('subdir'));
       Expect.isTrue(f.contains('file.txt'));
     };
 
     lister.onDone = (completed) {
       Expect.isTrue(completed, "directory listing did not complete");
       Expect.isTrue(listedDir, "directory not found");
       Expect.isTrue(listedFile, "file not found");
-      directory.deleteRecursively().then((ignore) {
+      directory.delete(recursive: true).then((ignore) {
         f.exists().then((exists) => Expect.isFalse(exists));
         directory.exists().then((exists) => Expect.isFalse(exists));
         subDirectory.exists().then((exists) => Expect.isFalse(exists));
       });
     };
 
     // Listing is asynchronous, so nothing should be listed at this
     // point.
     Expect.isFalse(listedDir);
     Expect.isFalse(listedFile);
@@ skipping 23 matching lines @@
     });
   }
 
   static void testListTooLongName() {
     new Directory("").createTemp().then((d) {
       var errors = 0;
       setupListHandlers(DirectoryLister lister) {
         lister.onError = (e) {
           Expect.isTrue(e is DirectoryIOException);
           if (++errors == 2) {
-            d.deleteRecursively();
+            d.delete(recursive: true);
           }
         };
         lister.onFile = (file) {
           Expect.fail("Listing of non-existing directory should fail");
         };
         lister.onDir = (dir) {
           Expect.fail("Listing of non-existing directory should fail");
         };
         lister.onDone = (success) {
           Expect.isFalse(success);
@@ skipping 24 matching lines @@
         return true;
       });
       future.then((ignore) {
         Expect.fail("Deletion of non-existing directory should fail");
       });
     }
 
     new Directory("").createTemp().then((d) {
       d.delete().then((ignore) {
         setupFutureHandlers(d.delete());
-        setupFutureHandlers(d.deleteRecursively());
+        setupFutureHandlers(d.delete(recursive: true));
       });
     });
   }
 
   static void testDeleteTooLongName() {
     var port = new ReceivePort();
     new Directory("").createTemp().then((d) {
       var subDirName = 'subdir';
       var subDir = new Directory("${d.path}/$subDirName");
       subDir.create().then((ignore) {
           // Construct a long string of the form
           // 'tempdir/subdir/../subdir/../subdir'.
           var buffer = new StringBuffer();
           buffer.add(subDir.path);
           for (var i = 0; i < 1000; i++) {
             buffer.add("/../${subDirName}");
           }
           var long = new Directory("${buffer.toString()}");
           var errors = 0;
           onError(e) {
             Expect.isTrue(e is DirectoryIOException);
             if (++errors == 2) {
-              d.deleteRecursively().then((ignore) => port.close());
+              d.delete(recursive: true).then((ignore) => port.close());
             }
             return true;
           }
           long.delete().handleException(onError);
-          long.deleteRecursively().handleException(onError);
+          long.delete(recursive: true).handleException(onError);
         });
     });
   }
 
   static void testDeleteNonExistentSync() {
     Directory d = new Directory("").createTempSync();
     d.deleteSync();
     Expect.throws(d.deleteSync);
-    Expect.throws(() => d.deleteRecursivelySync());
+    Expect.throws(() => d.deleteSync(recursive: true));
   }
 
   static void testDeleteTooLongNameSync() {
     Directory d = new Directory("").createTempSync();
     var subDirName = 'subdir';
     var subDir = new Directory("${d.path}/$subDirName");
     subDir.createSync();
     // Construct a long string of the form
     // 'tempdir/subdir/../subdir/../subdir'.
     var buffer = new StringBuffer();
     buffer.add(subDir.path);
     for (var i = 0; i < 1000; i++) {
       buffer.add("/../${subDirName}");
     }
     var long = new Directory("${buffer.toString()}");
     Expect.throws(long.deleteSync);
-    Expect.throws(() => long.deleteRecursivelySync());
-    d.deleteRecursivelySync();
+    Expect.throws(() => long.deleteSync(recursive: true));
+    d.deleteSync(recursive: true);
   }
 
   static void testDeleteSymlink() {
     // temp/
     //   a/
     //     file.txt
     //   b/
     //     a_link -> a
     var d = new Directory("").createTempSync();
     var a = new Directory("${d.path}/a");
@@ skipping 11 matching lines @@
     var cmd = "ln";
     var args = ['-s', "${d.path}/b/a_link", "${d.path}/a"];
 
     if (Platform.operatingSystem == "windows") {
       cmd = "cmd";
       args = ["/c", "mklink", "/j", "${d.path}\\b\\a_link", "${d.path}\\a"];
     }
 
     Process.run(cmd, args).then((_) {
       // Delete the directory containing the junction.
-      b.deleteRecursivelySync();
+      b.deleteSync(recursive: true);
 
       // We should not have recursed through a_link into a.
       Expect.isTrue(f.existsSync());
 
       // Clean up after ourselves.
-      d.deleteRecursivelySync();
+      d.deleteSync(recursive: true);
     });
   }
 
   static void testExistsCreateDelete() {
     new Directory("").createTemp().then((d) {
       d.exists().then((bool exists) {
         Expect.isTrue(exists);
         Directory created = new Directory("${d.path}/subdir");
         created.create().then((ignore) {
           created.exists().then((bool exists) {
@@ skipping 227 matching lines @@
 testCreateExistingSync() {
   // Test that creating an existing directory succeeds.
   var d = new Directory('');
   var temp = d.createTempSync();
   var subDir = new Directory('${temp.path}/flaf');
   Expect.isFalse(subDir.existsSync());
   subDir.createSync();
   Expect.isTrue(subDir.existsSync());
   subDir.createSync();
   Expect.isTrue(subDir.existsSync());
-  temp.deleteRecursivelySync();
+  temp.deleteSync(recursive: true);
 }
 
 
 testCreateExisting() {
   // Test that creating an existing directory succeeds.
   var port = new ReceivePort();
   var d = new Directory('');
   d.createTemp().then((temp) {
     var subDir = new Directory('${temp.path}/flaf');
     subDir.exists().then((dirExists) {
       Expect.isFalse(dirExists);
       subDir.create().then((_) {
         subDir.exists().then((dirExists) {
           Expect.isTrue(dirExists);
           subDir.create().then((_) {
             subDir.exists().then((dirExists) {
               Expect.isTrue(dirExists);
-              temp.deleteRecursively().then((_) {
+              temp.delete(recursive: true).then((_) {
                 port.close();
               });
             });
           });
         });
       });
     });
   });
 }
 
 
 testCreateDirExistingFileSync() {
   // Test that creating an existing directory succeeds.
   var d = new Directory('');
   var temp = d.createTempSync();
   var path = '${temp.path}/flaf';
   var file = new File(path);
   file.createSync();
   Expect.isTrue(file.existsSync());
   Expect.throws(new Directory(path).createSync,
                 (e) => e is DirectoryIOException);
-  temp.deleteRecursivelySync();
+  temp.deleteSync(recursive: true);
 }
 
 
 testCreateDirExistingFile() {
   // Test that creating an existing directory succeeds.
   var port = new ReceivePort();
   var d = new Directory('');
   d.createTemp().then((temp) {
     var path = '${temp.path}/flaf';
     var file = new File(path);
     var subDir = new Directory(path);
     file.create().then((_) {
       subDir.create()
         ..then((_) { Expect.fail("dir create should fail on existing file"); })
         ..handleException((e) {
             Expect.isTrue(e is DirectoryIOException);
-            temp.deleteRecursively().then((_) {
+            temp.delete(recursive: true).then((_) {
               port.close();
             });
             return true;
           });
     });
   });
 }
 
 
+testCreateRecursiveSync() {
+  var temp = new Directory('').createTempSync();
+  var d = new Directory('${temp.path}/a/b/c');
+  d.createSync(recursive: true);
+  Expect.isTrue(new Directory('${temp.path}/a').existsSync());
+  Expect.isTrue(new Directory('${temp.path}/a/b').existsSync());
+  Expect.isTrue(new Directory('${temp.path}/a/b/c').existsSync());
+  temp.deleteSync(recursive: true);
+}
+
+
+testCreateRecursive() {
+  var port = new ReceivePort();
+  new Directory('').createTemp().then((temp) {
+    var d = new Directory('${temp.path}/a/b/c');
+    d.create(recursive: true).then((_) {
+      Expect.isTrue(new Directory('${temp.path}/a').existsSync());
+      Expect.isTrue(new Directory('${temp.path}/a/b').existsSync());
+      Expect.isTrue(new Directory('${temp.path}/a/b/c').existsSync());
+      temp.deleteSync(recursive: true);
+      port.close();
+    });
+  });
+}
+
+
 testRename() {
   var d = new Directory('');
   var temp1 = d.createTempSync();
   var temp2 = d.createTempSync();
   var temp3 = temp1.renameSync(temp2.path);
   Expect.isFalse(temp1.existsSync());
   Expect.isTrue(temp2.existsSync());
   Expect.equals(temp3.path, temp2.path);
 
   temp2.rename(temp1.path).then((temp4) {
     Expect.isFalse(temp3.existsSync());
     Expect.isFalse(temp2.existsSync());
     Expect.isTrue(temp1.existsSync());
     Expect.isTrue(temp4.existsSync());
     Expect.equals(temp1.path, temp4.path);
-    temp1.deleteRecursivelySync();
+    temp1.deleteSync(recursive: true);
   });
 }
 
 main() {
   DirectoryTest.testMain();
   NestedTempDirectoryTest.testMain();
   testCreateTempErrorSync();
   testCreateTempError();
   testCreateExistingSync();
   testCreateExisting();
   testCreateDirExistingFileSync();
   testCreateDirExistingFile();
+  testCreateRecursive();
+  testCreateRecursiveSync();
   testRename();
 }