Support self-referential package: imports with Pub.

utils/pub/entrypoint.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.
 
 #library('entrypoint');
 
 #import('io.dart');
 #import('lock_file.dart');
 #import('package.dart');
 #import('root_source.dart');
@@ skipping 88 matching lines @@
 
     return future;
   }
 
   /**
    * Installs all dependencies of the [root] package to its "packages"
    * directory, respecting the [LockFile] if present. Returns a [Future] that
    * completes when all dependencies are installed.
    */
   Future installDependencies() {
-    return _loadLockFile()
+    return _validatePubspec()
+      .chain((_) => _loadLockFile())
       .chain((lockFile) => resolveVersions(cache.sources, root, lockFile))
       .chain(_installDependencies);
   }
 
   /**
    * Installs the latest available versions of all dependencies of the [root]
    * package to its "package" directory, writing a new [LockFile]. Returns a
    * [Future] that completes when all dependencies are installed.
    */
   Future updateAllDependencies() {
-    return resolveVersions(cache.sources, root, new LockFile.empty()).
-      chain(_installDependencies);
+    return _validatePubspec()
+      .chain((_) => resolveVersions(cache.sources, root, new LockFile.empty()))
+      .chain(_installDependencies);
   }
 
   /**
    * Installs the latest available versions of [dependencies], while leaving
    * other dependencies as specified by the [LockFile] if possible. Returns a
    * [Future] that completes when all dependencies are installed.
    */
   Future updateDependencies(List<String> dependencies) {
-    return _loadLockFile().chain((lockFile) {
+    return _validatePubspec().chain((_) => _loadLockFile()).chain((lockFile) {
       var versionSolver = new VersionSolver(cache.sources, root, lockFile);
       for (var dependency in dependencies) {
         versionSolver.useLatestVersion(dependency);
       }
       return versionSolver.solve();
     }).chain(_installDependencies);
   }
 
   /**
    * Installs all dependencies listed in [packageVersions] and writes a
    * [LockFile].
    */
   Future _installDependencies(List<PackageId> packageVersions) {
     return Futures.wait(packageVersions.map((id) {
       if (id.source is RootSource) return new Future.immediate(id);
       return install(id);
-    })).chain(_saveLockFile);
+    })).chain(_saveLockFile).chain(_installSelfReference);
   }
 
   /**
    * Loads the list of concrete package versions from the `pubspec.lock`, if it
    * exists. If it doesn't, this completes to an empty [LockFile].
    *
    * If there's an error reading the `pubspec.lock` file, this will print a
    * warning message and act as though the file doesn't exist.
    */
   Future<LockFile> _loadLockFile() {
     var completer = new Completer<LockFile>();
     var lockFilePath = join(root.dir, 'pubspec.lock');
     var future = readTextFile(lockFilePath);
 
     future.handleException((_) {
-      completer.complete(new LockFile.empty());
-
       // If we failed to load the lockfile but it does exist, something's
       // probably wrong and we should notify the user.
-      fileExists(lockFilePath).then((exists) {
+      fileExists(lockFilePath).transform((exists) {
         if (!exists) return;
         printError("Error reading pubspec.lock: ${future.exception}");
+      }).then((_) {
+        completer.complete(new LockFile.empty());
       });
 
       return true;
     });
 
     future.then((text) =>
         completer.complete(new LockFile.parse(text, cache.sources)));
     return completer.future;
   }
 
   /**
    * Saves a list of concrete package versions to the `pubspec.lock` file.
    */
   Future _saveLockFile(List<PackageId> packageIds) {
     var lockFile = new LockFile.empty();
     for (var id in packageIds) {
       if (id.source is! RootSource) lockFile.packages[id.name] = id;
     }
 
     return writeTextFile(join(root.dir, 'pubspec.lock'), lockFile.serialize());
   }
+
+  /**
+   * Installs a self-referential symlink in the `packages` directory that will
+   * allow a package to import its own files using `package:`.
+   */
+  Future _installSelfReference(_) {
+    var linkPath = join(path, root.name);
+    return exists(linkPath).chain((exists) {
+      if (exists) return new Future.immediate(null);
+      return ensureDir(path).chain((_) => createSymlink(root.dir, linkPath));
+    });
+  }
+
+  /**
+   * Validate that the pubspec for the entrypoint exists and specifies the name
+   * of the root package.
+   */
+  Future _validatePubspec() {
+    var future = new Future.immediate(null);;
+    if (root.pubspec.isEmpty) {
+      future = exists(join(path, "pubspec.yaml")).transform((exists) {
+        if (exists) return;
+        throw '"pubspec.yaml" not found.';

[Bob Nystrom, 2012/08/24 00:58:49]

We should do friendly error messages here. Something like "Could not find a
'pubspec.yaml' file in the directory <path>.".

Also add a TODO to mention "pub init" in the error when that's implemented.

[nweiz, 2012/08/24 01:12:12]

Done.

+      });
+    }
+
+    return future.transform((_) {
+      if (root.pubspec.name != null) return;
+      throw '"pubspec.yaml" must contain a "name" key.';

[Bob Nystrom, 2012/08/24 00:58:49]

Make this a friendly complete sentence, please.

[nweiz, 2012/08/24 01:12:12]

This one is a complete sentence. I'd be happy to rewrite it, but I'm not sure
how best to do so.

+    });
+  }
 }