Make pub's binstubs resilient to changes in snapshot format.

sdk/lib/_internal/pub_generated/lib/src/global_packages.dart

 // Copyright (c) 2014, 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 pub.global_packages;
 
 import 'dart:async';
 import 'dart:io';
 
 import 'package:path/path.dart' as p;
 import 'package:barback/barback.dart';
 import 'package:pub_semver/pub_semver.dart';
 
 import 'barback/asset_environment.dart';
 import 'entrypoint.dart';
+import 'exceptions.dart';
 import 'executable.dart' as exe;
 import 'io.dart';
 import 'lock_file.dart';
 import 'log.dart' as log;
 import 'package.dart';
 import 'pubspec.dart';
 import 'sdk.dart' as sdk;
 import 'solver/version_solver.dart';
 import 'source/cached.dart';
 import 'source/git.dart';
 import 'source/path.dart';
 import 'system_cache.dart';
 import 'utils.dart';
 
-/// Matches the package name that a binstub was created for inside the contents
-/// of the shell script.
-final _binStubPackagePattern = new RegExp(r"Package: ([a-zA-Z0-9_-]+)");
-
 /// Maintains the set of packages that have been globally activated.
 ///
 /// These have been hand-chosen by the user to make their executables in bin/
 /// available to the entire system. This lets them access them even when the
 /// current working directory is not inside another entrypoint package.
 ///
 /// Only one version of a given package name can be globally activated at a
 /// time. Activating a different version of a package will deactivate the
 /// previous one.
 ///
@@ skipping 476 matching lines @@
 
   /// Gets the path to the lock file for an activated cached package with
   /// [name].
   String _getLockFilePath(String name) =>
       p.join(_directory, name, "pubspec.lock");
 
   /// Shows to the user formatted list of globally activated packages.
   void listActivePackages() {
     if (!dirExists(_directory)) return;
 
-    // Loads lock [file] and returns [PackageId] of the activated package.
-    loadPackageId(file, name) {
-      var lockFile = new LockFile.load(p.join(_directory, file), cache.sources);
-      return lockFile.packages[name];
+    return listDir(_directory).map(_loadPackageId).toList()
+        ..sort((id1, id2) => id1.name.compareTo(id2.name))
+        ..forEach((id) => log.message(_formatPackage(id)));
+  }
+
+  void _loadPackageId(String path) {
+    var name = p.basenameWithoutExtension(path);
+    if (!fileExists(path)) path = p.join(path, 'pubspec.lock');
+
+    var id =
+        new LockFile.load(p.join(_directory, path), cache.sources).packages[name];
+
+    if (id == null) {
+      throw new FormatException(
+          "Pubspec for activated package $name didn't " "contain an entry for itself.");
     }
 
-    var packages = listDir(_directory).map((entry) {
-      if (fileExists(entry)) {
-        return loadPackageId(entry, p.basenameWithoutExtension(entry));
-      } else {
-        return loadPackageId(p.join(entry, 'pubspec.lock'), p.basename(entry));
-      }
-    }).toList();
-
-    packages
-        ..sort((id1, id2) => id1.name.compareTo(id2.name))
-        ..forEach((id) => log.message(_formatPackage(id)));
+    return id;
   }
 
   /// Returns formatted string representing the package [id].
   String _formatPackage(PackageId id) {
     if (id.source == 'git') {
       var url = GitSource.urlFromDescription(id.description);
       return '${log.bold(id.name)} ${id.version} from Git repository "$url"';
     } else if (id.source == 'path') {
       var path = PathSource.pathFromDescription(id.description);
       return '${log.bold(id.name)} ${id.version} at path "$path"';
     } else {
       return '${log.bold(id.name)} ${id.version}';
     }
   }
 
+  Future<Pair<int, int>> repairActivatedPackages() {
+    final completer0 = new Completer();
+    scheduleMicrotask(() {
+      try {
+        var executables = {};
+        join0() {
+          var successes = 0;
+          var failures = 0;
+          join1() {
+            join2() {
+              completer0.complete(new Pair(successes, failures));
+            }
+            if (executables.isNotEmpty) {
+              var packages = pluralize("package", executables.length);
+              var message =
+                  new StringBuffer("Binstubs exist for non-activated " "packages:\n");
+              executables.forEach(((package, executableNames) {
+                message.writeln(
+                    "  From ${log.bold(package)}: " "${toSentence(executableNames)}");
+              }));
+              log.error(message);
+              join2();
+            } else {
+              join2();
+            }
+          }
+          if (dirExists(_directory)) {
+            Future.wait(listDir(_directory).map(((entry) {
+              final completer0 = new Completer();
+              scheduleMicrotask(() {
+                try {
+                  var id;
+                  join0() {
+                    completer0.complete();
+                  }
+                  catch0(error, stackTrace) {
+                    try {
+                      var message =
+                          "Failed to reactivate " "${log.bold(p.basenameWithoutExtension(entry))}";
+                      join1() {
+                        log.error(message, error, stackTrace);
+                        failures++;
+                        join0();
+                      }
+                      if (id != null) {
+                        message += " ${id.version}";
+                        join2() {
+                          join1();
+                        }
+                        if (id.source != "hosted") {
+                          message += " from ${id.source}";
+                          join2();
+                        } else {
+                          join2();
+                        }
+                      } else {
+                        join1();
+                      }
+                    } catch (error, stackTrace) {
+                      completer0.completeError(error, stackTrace);
+                    }
+                  }
+                  try {
+                    id = _loadPackageId(entry);
+                    log.message(
+                        "Reactivating ${log.bold(id.name)} ${id.version}...");
+                    find(id.name).then((x0) {
+                      try {
+                        var entrypoint = x0;
+                        entrypoint.loadPackageGraph().then((x1) {
+                          try {
+                            var graph = x1;
+                            _precompileExecutables(
+                                entrypoint,
+                                id.name).then((x2) {
+                              try {
+                                var snapshots = x2;
+                                var packageExecutables =
+                                    executables.remove(id.name);
+                                join3() {
+                                  _updateBinStubs(
+                                      graph.packages[id.name],
+                                      packageExecutables,
+                                      overwriteBinStubs: true,
+                                      snapshots: snapshots,
+                                      pathSuggestion: false);
+                                  successes++;
+                                  join0();
+                                }
+                                if (packageExecutables == null) {
+                                  packageExecutables = [];
+                                  join3();
+                                } else {
+                                  join3();
+                                }
+                              } catch (e0, s0) {
+                                catch0(e0, s0);
+                              }
+                            }, onError: catch0);
+                          } catch (e1, s1) {
+                            catch0(e1, s1);
+                          }
+                        }, onError: catch0);
+                      } catch (e2, s2) {
+                        catch0(e2, s2);
+                      }
+                    }, onError: catch0);
+                  } catch (e3, s3) {
+                    catch0(e3, s3);
+                  }
+                } catch (e, s) {
+                  completer0.completeError(e, s);
+                }
+              });
+              return completer0.future;
+            }))).then((x0) {
+              try {
+                x0;
+                join1();
+              } catch (e0, s0) {
+                completer0.completeError(e0, s0);
+              }
+            }, onError: completer0.completeError);
+          } else {
+            join1();
+          }
+        }
+        if (dirExists(_binStubDir)) {
+          var it0 = listDir(_binStubDir).iterator;
+          break0() {
+            join0();
+          }
+          var trampoline0;
+          continue0() {
+            trampoline0 = null;
+            if (it0.moveNext()) {
+              var entry = it0.current;
+              join3() {
+                trampoline0 = continue0;
+              }
+              catch0(error, stackTrace) {
+                try {
+                  log.error(
+                      "Error reading binstub for " "\"${p.basenameWithoutExtension(entry)}\"",
+                      error,
+                      stackTrace);
+                  join3();
+                } catch (error, stackTrace) {
+                  completer0.completeError(error, stackTrace);
+                }
+              }
+              try {
+                var binstub = readTextFile(entry);
+                var package = _binStubProperty(binstub, "Package");
+                join4() {
+                  var executable = _binStubProperty(binstub, "Executable");
+                  join5() {
+                    executables.putIfAbsent(package, (() {
+                      return [];
+                    })).add(executable);
+                    join3();
+                  }
+                  if (executable == null) {
+                    throw new ApplicationException("No 'Executable' property.");
+                    join5();
+                  } else {
+                    join5();
+                  }
+                }
+                if (package == null) {
+                  throw new ApplicationException("No 'Package' property.");
+                  join4();
+                } else {
+                  join4();
+                }
+              } catch (e1, s1) {
+                catch0(e1, s1);
+              }
+            } else {
+              break0();
+            }
+          }
+          trampoline0 = continue0;
+          do trampoline0(); while (trampoline0 != null);
+        } else {
+          join0();
+        }
+      } catch (e, s) {
+        completer0.completeError(e, s);
+      }
+    });
+    return completer0.future;
+  }
+
   /// Updates the binstubs for [package].
   ///
   /// A binstub is a little shell script in `PUB_CACHE/bin` that runs an
   /// executable from a globally activated package. This removes any old
   /// binstubs from the previously activated version of the package and
   /// (optionally) creates new ones for the executables listed in the package's
   /// pubspec.
   ///
   /// [executables] is the names of the executables that should have binstubs.
   /// If `null`, all executables in the package will get binstubs. If empty, no
   /// binstubs will be created.
   ///
   /// If [overwriteBinStubs] is `true`, any binstubs that collide with
   /// existing binstubs in other packages will be overwritten by this one's.
   /// Otherwise, the previous ones will be preserved.
   ///
   /// If [snapshots] is given, it is a map of the names of executables whose
-  /// snapshots that were precompiled to their paths. Binstubs for those will
-  /// run the snapshot directly and skip pub entirely.
+  /// snapshots were precompiled to the paths of those snapshots. Binstubs for
+  /// those will run the snapshot directly and skip pub entirely.
+  ///
+  /// If [pathSuggestion] is `true` (the default), this will warn the user if
+  /// the bin directory isn't on their path.
   void _updateBinStubs(Package package, List<String> executables,
-      {bool overwriteBinStubs, Map<String, String> snapshots}) {
+      {bool overwriteBinStubs, Map<String, String> snapshots, bool pathSuggestion:
+      true}) {
     if (snapshots == null) snapshots = const {};
 
     // Remove any previously activated binstubs for this package, in case the
     // list of executables has changed.
     _deleteBinStubs(package.name);
 
     if ((executables != null && executables.isEmpty) ||
         package.pubspec.executables.isEmpty) {
       return;
     }
@@ skipping 67 matching lines @@
     for (var executable in installed) {
       var script = package.pubspec.executables[executable];
       var scriptPath = p.join("bin", "$script.dart");
       if (!binFiles.contains(scriptPath)) {
         log.warning(
             'Warning: Executable "$executable" runs "$scriptPath", '
                 'which was not found in ${log.bold(package.name)}.');
       }
     }
 
-    if (installed.isNotEmpty) _suggestIfNotOnPath(installed);
+    if (pathSuggestion && installed.isNotEmpty) {
+      _suggestIfNotOnPath(installed.first);
+    }
   }
 
   /// Creates a binstub named [executable] that runs [script] from [package].
   ///
   /// If [overwrite] is `true`, this will replace an existing binstub with that
   /// name for another package.
   ///
   /// If [snapshot] is non-null, it is a path to a snapshot file. The binstub
   /// will invoke that directly. Otherwise, it will run `pub global run`.
   ///
   /// If a collision occurs, returns the name of the package that owns the
   /// existing binstub. Otherwise returns `null`.
   String _createBinStub(Package package, String executable, String script,
       {bool overwrite, String snapshot}) {
     var binStubPath = p.join(_binStubDir, executable);
 
     if (Platform.operatingSystem == "windows") binStubPath += ".bat";
 
     // See if the binstub already exists. If so, it's for another package
     // since we already deleted all of this package's binstubs.
     var previousPackage;
     if (fileExists(binStubPath)) {
       var contents = readTextFile(binStubPath);
-      var match = _binStubPackagePattern.firstMatch(contents);
-      if (match != null) {
-        previousPackage = match[1];
-        if (!overwrite) return previousPackage;
-      } else {
+      previousPackage = _binStubProperty(contents, "Package");
+      if (previousPackage == null) {
         log.fine("Could not parse binstub $binStubPath:\n$contents");
+      } else if (!overwrite) {
+        return previousPackage;
       }
     }
 
     // If the script was precompiled to a snapshot, just invoke that directly
     // and skip pub global run entirely.
     var invocation;
+    var pubGlobalInvocation = "pub global run ${package.name}:$script";
     if (snapshot != null) {
       // We expect absolute paths from the precompiler since relative ones
       // won't be relative to the right directory when the user runs this.
       assert(p.isAbsolute(snapshot));
       invocation = 'dart "$snapshot"';
     } else {
-      invocation = "pub global run ${package.name}:$script";
+      invocation = pubGlobalInvocation;
     }
 
     if (Platform.operatingSystem == "windows") {
       var batch = """
 @echo off
 rem This file was created by pub v${sdk.version}.
 rem Package: ${package.name}
 rem Version: ${package.version}
 rem Executable: ${executable}
 rem Script: ${script}
 $invocation %*
 """;
+
+      if (snapshot != null) {
+        batch += """
+
+if errorlevel 255 (
+  exit /b %errorlevel%
+)
+
+$pubGlobalInvocation
+""";
+      }
+
       writeTextFile(binStubPath, batch);
     } else {
       var bash = """
 #!/usr/bin/env sh
 # This file was created by pub v${sdk.version}.
 # Package: ${package.name}
 # Version: ${package.version}
 # Executable: ${executable}
 # Script: ${script}
 $invocation "\$@"
 """;
+
+      if (snapshot != null) {
+        bash += """
+
+exit_code=\$?
+if [[ \$exit_code != 255 ]]; then
+  exit \$exit_code
+fi
+
+rm "$snapshot"
+$pubGlobalInvocation
+""";
+      }
+
       writeTextFile(binStubPath, bash);
 
       // Make it executable.
       var result = Process.runSync('chmod', ['+x', binStubPath]);
       if (result.exitCode != 0) {
         // Couldn't make it executable so don't leave it laying around.
         try {
           deleteEntry(binStubPath);
         } on IOException catch (err) {
           // Do nothing. We're going to fail below anyway.
           log.fine("Could not delete binstub:\n$err");
         }
 
         fail(
             'Could not make "$binStubPath" executable (exit code '
                 '${result.exitCode}):\n${result.stderr}');
       }
     }
 
     return previousPackage;
   }
 
   /// Deletes all existing binstubs for [package].
   void _deleteBinStubs(String package) {
     if (!dirExists(_binStubDir)) return;
 
     for (var file in listDir(_binStubDir, includeDirs: false)) {
       var contents = readTextFile(file);
-      var match = _binStubPackagePattern.firstMatch(contents);
-      if (match == null) {
+      var binStubPackage = _binStubProperty(contents, "Package");
+      if (binStubPackage == null) {
         log.fine("Could not parse binstub $file:\n$contents");
         continue;
       }
 
-      if (match[1] == package) {
+      if (binStubPackage == package) {
         log.fine("Deleting old binstub $file");
         deleteEntry(file);
       }
     }
   }
 
   /// Checks to see if the binstubs are on the user's PATH and, if not, suggests
   /// that the user add the directory to their PATH.
-  void _suggestIfNotOnPath(List<String> installed) {
+  ///
+  /// [installed] should be the name of an installed executable that can be used
+  /// to test whether accessing it on the path works.
+  void _suggestIfNotOnPath(String installed) {
     if (Platform.operatingSystem == "windows") {
       // See if the shell can find one of the binstubs.
       // "\q" means return exit code 0 if found or 1 if not.
-      var result = runProcessSync("where", [r"\q", installed.first + ".bat"]);
+      var result = runProcessSync("where", [r"\q", installed + ".bat"]);
       if (result.exitCode == 0) return;
 
       log.warning(
           "${log.yellow('Warning:')} Pub installs executables into "
               "${log.bold(_binStubDir)}, which is not on your path.\n"
               "You can fix that by adding that directory to your system's "
               '"Path" environment variable.\n'
               'A web search for "configure windows path" will show you how.');
     } else {
       // See if the shell can find one of the binstubs.
-      var result = runProcessSync("which", [installed.first]);
+      var result = runProcessSync("which", [installed]);
       if (result.exitCode == 0) return;
 
       var binDir = _binStubDir;
       if (binDir.startsWith(Platform.environment['HOME'])) {
         binDir =
             p.join("~", p.relative(binDir, from: Platform.environment['HOME']));
       }
 
       log.warning(
           "${log.yellow('Warning:')} Pub installs executables into "
               "${log.bold(binDir)}, which is not on your path.\n"
               "You can fix that by adding this to your shell's config file "
               "(.bashrc, .bash_profile, etc.):\n" "\n"
               "  ${log.bold('export PATH="\$PATH":"$binDir"')}\n" "\n");
     }
   }
+
+  String _binStubProperty(String source, String name) {
+    var pattern = new RegExp(quoteRegExp(name) + r": ([a-zA-Z0-9_-]+)");
+    var match = pattern.firstMatch(source);
+    return match == null ? null : match[1];
+  }
 }