Add support for creating a .packages file when the plugin is in a Bazel workspace

pkg/analysis_server/lib/src/plugin/plugin_manager.dart

 // Copyright (c) 2017, 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.
 
 import 'dart:async';
 import 'dart:collection';
 import 'dart:convert';
 import 'dart:io' show Platform, Process, ProcessResult;
 
 import 'package:analysis_server/src/plugin/notification_manager.dart';
 import 'package:analyzer/context/context_root.dart' as analyzer;
 import 'package:analyzer/file_system/file_system.dart';
 import 'package:analyzer/instrumentation/instrumentation.dart';
 import 'package:analyzer/src/generated/bazel.dart';
 import 'package:analyzer/src/generated/gn.dart';
+import 'package:analyzer/src/generated/source.dart';
+import 'package:analyzer/src/generated/workspace.dart';
 import 'package:analyzer/src/util/glob.dart';
 import 'package:analyzer_plugin/channel/channel.dart';
 import 'package:analyzer_plugin/protocol/protocol.dart';
 import 'package:analyzer_plugin/protocol/protocol_common.dart';
 import 'package:analyzer_plugin/protocol/protocol_constants.dart';
 import 'package:analyzer_plugin/protocol/protocol_generated.dart';
 import 'package:analyzer_plugin/src/channel/isolate_channel.dart';
 import 'package:analyzer_plugin/src/protocol/protocol_internal.dart';
 import 'package:convert/convert.dart';
 import 'package:crypto/crypto.dart';
 import 'package:meta/meta.dart';
 import 'package:path/path.dart' as path;
 import 'package:watcher/watcher.dart' as watcher;
+import 'package:yaml/yaml.dart';
 
 /**
  * Information about a plugin that is built-in.
  */
 class BuiltInPluginInfo extends PluginInfo {
   /**
    * The entry point function that will be executed in the plugin's isolate.
    */
   final EntryPoint entryPoint;
 
@@ skipping 290 matching lines @@
    * yet been started, then it will be started by this method.
    */
   Future<Null> addPluginToContextRoot(
       analyzer.ContextRoot contextRoot, String path) async {
     if (!_isWhitelisted(path)) {
       return;
     }
     PluginInfo plugin = _pluginMap[path];
     bool isNew = plugin == null;
     if (isNew) {
-      List<String> pluginPaths = _pathsFor(path);
-      if (pluginPaths == null || pluginPaths[1] == null) {
+      List<String> pluginPaths = pathsFor(path);
+      if (pluginPaths == null) {
         return;
       }
       plugin = new DiscoveredPluginInfo(path, pluginPaths[0], pluginPaths[1],
           notificationManager, instrumentationService);
       _pluginMap[path] = plugin;
       if (pluginPaths[0] != null) {
         PluginSession session = await plugin.start(byteStorePath, sdkPath);
         session?.onDone?.then((_) {
           _pluginMap.remove(path);
         });
@@ skipping 57 matching lines @@
         event ??= _convertWatchEvent(watchEvent);
         AnalysisHandleWatchEventsParams params =
             new AnalysisHandleWatchEventsParams([event]);
         responses.add(session.sendRequest(params));
       }
     }
     return responses;
   }
 
   /**
+   * Return the execution path and .packages path associated with the plugin at
+   * the given [path], or `null` if there is a problem that prevents us from
+   * executing the plugin.
+   */
+  @visibleForTesting
+  List<String> pathsFor(String pluginPath) {
+    Folder pluginFolder = resourceProvider.getFolder(pluginPath);
+    File pubspecFile = pluginFolder.getChildAssumingFile('pubspec.yaml');
+    if (!pubspecFile.exists) {
+      // If there's no pubspec file, then we don't need to copy the package
+      // because we won't be running pub.

[mfairhurst, 2017/07/24 18:00:07]

This will prevent the bazel support from working without a pubspec file, no?

Edit: I see, looks like bazel support requires pubspec files?

Any change we could do like, bazel queries instead?

+      return _computePaths(pluginFolder);
+    }
+    Workspace workspace =
+        BazelWorkspace.find(resourceProvider, pluginFolder.path) ??
+            GnWorkspace.find(resourceProvider, pluginFolder.path);
+    if (workspace != null) {
+      // Similarly, we won't be running pub if we're in a workspace because
+      // there is exactly one version of each package.
+      return _computePaths(pluginFolder, workspace: workspace);
+    }
+    //
+    // Copy the plugin directory to a unique subdirectory of the plugin
+    // manager's state location. The subdirectory's name is selected such that
+    // it will be invariant across sessions, reducing the number of times the
+    // plugin will need to be copied and pub will need to be run.
+    //
+    Folder stateFolder = resourceProvider.getStateLocation('.plugin_manager');
+    String stateName = _uniqueDirectoryName(pluginPath);
+    Folder parentFolder = stateFolder.getChildAssumingFolder(stateName);
+    if (parentFolder.exists) {
+      Folder executionFolder =
+          parentFolder.getChildAssumingFolder(pluginFolder.shortName);
+      return _computePaths(executionFolder);
+    }
+    Folder executionFolder = pluginFolder.copyTo(parentFolder);
+    return _computePaths(executionFolder, runPub: true);
+  }
+
+  /**
    * Return a list of all of the plugins that are currently associated with the
    * given [contextRoot].
    */
   @visibleForTesting
   List<PluginInfo> pluginsForContextRoot(analyzer.ContextRoot contextRoot) {
     if (contextRoot == null) {
       return _pluginMap.values.toList();
     }
     List<PluginInfo> plugins = <PluginInfo>[];
     for (PluginInfo plugin in _pluginMap.values) {
@@ skipping 83 matching lines @@
   /**
    * Whitelist all plugins.
    */
   @visibleForTesting
   void whitelistEverything() {
     _whitelistGlobs = <Glob>[
       new Glob(resourceProvider.pathContext.separator, '**/*')
     ];
   }
 
+  /**
+   * Compute the paths to be returned by the enclosing method given that the
+   * plugin should exist in the given [pluginFolder].
+   */
+  List<String> _computePaths(Folder pluginFolder,
+      {bool runPub: false, Workspace workspace}) {
+    File pluginFile = pluginFolder
+        .getChildAssumingFolder('bin')
+        .getChildAssumingFile('plugin.dart');
+    if (!pluginFile.exists) {
+      return null;
+    }
+    File packagesFile = pluginFolder.getChildAssumingFile('.packages');
+    if (!packagesFile.exists) {
+      if (runPub) {
+        String vmPath = Platform.executable;
+        String pubPath = path.join(path.dirname(vmPath), 'pub');
+        ProcessResult result = Process.runSync(pubPath, <String>['get'],
+            stderrEncoding: UTF8,
+            stdoutEncoding: UTF8,
+            workingDirectory: pluginFolder.path);
+        if (result.exitCode != 0) {
+          StringBuffer buffer = new StringBuffer();
+          buffer.writeln('Failed to run pub get');
+          buffer.writeln('  pluginFolder = ${pluginFolder.path}');
+          buffer.writeln('  exitCode = ${result.exitCode}');
+          buffer.writeln('  stdout = ${result.stdout}');
+          buffer.writeln('  stderr = ${result.stderr}');
+          instrumentationService.logError(buffer.toString());
+        }
+        if (!packagesFile.exists) {
+          packagesFile = null;
+        }
+      } else if (workspace != null) {
+        packagesFile =
+            _createPackagesFile(pluginFolder, workspace.packageUriResolver);
+      } else {
+        packagesFile = null;
+      }
+    }
+    if (packagesFile == null) {
+      return null;
+    }
+    return <String>[pluginFile.path, packagesFile.path];
+  }
+
   WatchEventType _convertChangeType(watcher.ChangeType type) {
     switch (type) {
       case watcher.ChangeType.ADD:
         return WatchEventType.ADD;
       case watcher.ChangeType.MODIFY:
         return WatchEventType.MODIFY;
       case watcher.ChangeType.REMOVE:
         return WatchEventType.REMOVE;
       default:
         throw new StateError('Unknown change type: $type');
     }
   }
 
   WatchEvent _convertWatchEvent(watcher.WatchEvent watchEvent) {
     return new WatchEvent(_convertChangeType(watchEvent.type), watchEvent.path);
   }
 
   /**
+   * Return a temporary `.packages` file that is appropriate for the plugin in
+   * the given [pluginFolder]. The [packageUriResolver] is used to determine the
+   * location of the packages that need to be included in the packages file.
+   */
+  File _createPackagesFile(
+      Folder pluginFolder, UriResolver packageUriResolver) {
+    String pluginPath = pluginFolder.path;
+    Folder stateFolder = resourceProvider.getStateLocation('.plugin_manager');
+    String stateName = _uniqueDirectoryName(pluginPath) + '.packages';
+    File packagesFile = stateFolder.getChildAssumingFile(stateName);
+    if (!packagesFile.exists) {
+      File pluginPubspec = pluginFolder.getChildAssumingFile('pubspec.yaml');
+      if (!pluginPubspec.exists) {
+        return null;
+      }
+
+      try {
+        Map<String, String> visitedPackages = <String, String>{};
+        path.Context context = resourceProvider.pathContext;
+        visitedPackages[context.basename(pluginPath)] =
+            context.join(pluginFolder.path, 'lib');
+        List<File> pubspecFiles = <File>[];
+        pubspecFiles.add(pluginPubspec);
+        while (pubspecFiles.isNotEmpty) {
+          File pubspecFile = pubspecFiles.removeLast();
+          for (String packageName in _readDependecies(pubspecFile)) {
+            if (!visitedPackages.containsKey(packageName)) {
+              Uri uri = Uri.parse('package:$packageName/$packageName.dart');
+              Source packageSource = packageUriResolver.resolveAbsolute(uri);
+              String libDirPath = context.dirname(packageSource.fullName);
+              visitedPackages[packageName] = libDirPath;
+              String pubspecPath =
+                  context.join(context.dirname(libDirPath), 'pubspec.yaml');
+              pubspecFiles.add(resourceProvider.getFile(pubspecPath));
+            }
+          }
+        }
+
+        StringBuffer buffer = new StringBuffer();
+        visitedPackages.forEach((String name, String path) {
+          buffer.write(name);
+          buffer.write(':');
+          buffer.writeln(new Uri.file(path));
+        });
+        packagesFile.writeAsStringSync(buffer.toString());
+      } catch (exception) {
+        // If we are not able to produce a .packages file, return null so that
+        // callers will not try to load the plugin.
+        return null;

[mfairhurst, 2017/07/24 18:00:06]

should log the exception too though

+      }
+    }
+    return packagesFile;
+  }
+
+  /**
    * Return `true` if the plugin with the given [path] has been whitelisted.
    */
   bool _isWhitelisted(String path) {
     for (Glob glob in _whitelistGlobs) {
       if (glob.matches(path)) {
         return true;
       }
     }
     return false;
   }
 
   /**
-   * Return the execution path and .packages path associated with the plugin at
-   * the given [path], or `null` if there is a problem that prevents us from
-   * executing the plugin.
+   * Return the names of packages that are listed as dependencies in the given
+   * [pubspecFile].
    */
-  List<String> _pathsFor(String pluginPath) {
-    /**
-     * Return `true` if the plugin in the give [folder] needs to be copied to a
-     * temporary location so that 'pub' can be run to resolve dependencies. We
-     * need to run `pub` if the plugin contains a `pubspec.yaml` file and is not
-     * in a workspace.
-     */
-    bool needToCopy(Folder folder) {
-      File pubspecFile = folder.getChildAssumingFile('pubspec.yaml');
-      if (!pubspecFile.exists) {
-        return false;
+  Iterable<String> _readDependecies(File pubspecFile) {
+    YamlDocument document = loadYamlDocument(pubspecFile.readAsStringSync(),
+        sourceUrl: pubspecFile.toUri());
+    YamlNode contents = document.contents;
+    if (contents is YamlMap) {
+      YamlNode dependencies = contents['dependencies'];

[mfairhurst, 2017/07/24 18:00:06]

Is there any way we can get this info by running pub? This skips
dev_dependencies; would be nice if pub could encaspulate that behavior so it
doesn't have to be perfectly recreated here.

+      if (dependencies is YamlMap) {
+        return dependencies.keys;
       }
-      return BazelWorkspace.find(resourceProvider, folder.path) == null &&
-          GnWorkspace.find(resourceProvider, folder.path) == null;
     }
-
-    /**
-     * Compute the paths to be returned by the enclosing method given that the
-     * plugin should exist in the given [pluginFolder].
-     */
-    List<String> computePaths(Folder pluginFolder, {bool runPub: false}) {
-      File pluginFile = pluginFolder
-          .getChildAssumingFolder('bin')
-          .getChildAssumingFile('plugin.dart');
-      if (!pluginFile.exists) {
-        return null;
-      }
-      File packagesFile = pluginFolder.getChildAssumingFile('.packages');
-      if (!packagesFile.exists) {
-        if (runPub) {
-          String vmPath = Platform.executable;
-          String pubPath = path.join(path.dirname(vmPath), 'pub');
-          ProcessResult result = Process.runSync(pubPath, <String>['get'],
-              stderrEncoding: UTF8,
-              stdoutEncoding: UTF8,
-              workingDirectory: pluginFolder.path);
-          if (result.exitCode != 0) {
-            StringBuffer buffer = new StringBuffer();
-            buffer.writeln('Failed to run pub get');
-            buffer.writeln('  pluginFolder = ${pluginFolder.path}');
-            buffer.writeln('  exitCode = ${result.exitCode}');
-            buffer.writeln('  stdout = ${result.stdout}');
-            buffer.writeln('  stderr = ${result.stderr}');
-            instrumentationService.logError(buffer.toString());
-          }
-          if (!packagesFile.exists) {
-            packagesFile = null;
-          }
-        } else {
-          packagesFile = null;
-        }
-      }
-      return <String>[pluginFile.path, packagesFile?.path];
-    }
-
-    Folder pluginFolder = resourceProvider.getFolder(pluginPath);
-    if (!needToCopy(pluginFolder)) {
-      return computePaths(pluginFolder);
-    }
-    //
-    // Copy the plugin directory to a unique subdirectory of the plugin
-    // manager's state location. The subdirectory's name is selected such that
-    // it will be invariant across sessions, reducing the number of times the
-    // plugin will need to be copied and pub will need to be run.
-    //
-    Folder stateFolder = resourceProvider.getStateLocation('.plugin_manager');
-    String stateName = _uniqueDirectoryName(pluginPath);
-    Folder parentFolder = stateFolder.getChildAssumingFolder(stateName);
-    if (parentFolder.exists) {
-      Folder executionFolder =
-          parentFolder.getChildAssumingFolder(pluginFolder.shortName);
-      return computePaths(executionFolder);
-    }
-    Folder executionFolder = pluginFolder.copyTo(parentFolder);
-    return computePaths(executionFolder, runPub: true);
+    return const <String>[];
   }
 
   /**
    * Return a hex-encoded MD5 signature of the given file [path].
    */
   String _uniqueDirectoryName(String path) {
     List<int> bytes = md5.convert(path.codeUnits).bytes;
     return hex.encode(bytes);
   }
 
@@ skipping 258 matching lines @@
    * The completer that will be used to complete the future when the response is
    * received from the plugin.
    */
   final Completer<Response> completer;
 
   /**
    * Initialize a pending request.
    */
   _PendingRequest(this.method, this.requestTime, this.completer);
 }