Plugin manifest parsing.

pkg/analyzer/lib/src/plugin/plugin_configuration.dart

 // Copyright (c) 2015, 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 analyzer.src.plugin.plugin_configuration;
 
 import 'package:analyzer/plugin/options.dart';
 import 'package:yaml/yaml.dart';
 
 const _analyzerOptionScope = 'analyzer';
 
 const _pluginOptionScope = 'plugins';
 
+/// Parse the given string into a plugin manifest.
+PluginManifest parsePluginManifestString(String manifestSource) {
+  var yaml = loadYaml(manifestSource);
+  _verifyMap(yaml, 'plugin manifest');
+  PluginInfo analyzerPlugin = _parsePlugin(yaml['analyzer-plugin']);

[Brian Wilkerson, 2015/09/24 19:22:57]

I'm confused. I thought we were going to (a) have a one-to-one relationship
between plugins and packages and (b) have a one-to-one relationship between
plugin manifest files and packages. If those are both true, then a single plugin
manifest file should describe a single plugin.

[pquitslund, 2015/09/24 19:32:36]

I guess I didn't want to completely rule out the possibility that we might allow
folks to declare an analyzer and server plugin *pair* in one package.  If that's
categorically inadvisable, maybe we shouldn't support it though?

Not a huge deal either way.

+  PluginInfo serverPlugin = _parsePlugin(yaml['server-plugin']);
+  return new PluginManifest(
+      analyzerPlugin: analyzerPlugin, serverPlugin: serverPlugin);
+}
+
+String _asString(var yaml) {
+  if (yaml != null && yaml is! String) {
+    throw new PluginConfigFormatException(
+        'Unable to parse pugin manifest, '
+        'expected `String`, got `${yaml.runtimeType}`',
+        yaml);
+  }
+  return yaml;
+}
+
+PluginInfo _parsePlugin(dynamic yaml) {
+  if (yaml != null) {
+    _verifyMap(yaml, 'plugin manifest');
+    return new PluginInfo._fromYaml(details: yaml);
+  }
+  return null;
+}
+
 PluginInfo _processPluginMapping(dynamic name, dynamic details) {
   if (name is String) {
     if (details is String) {
       return new PluginInfo(name: name, version: details);
     }
     if (details is YamlMap) {
-      return new PluginInfo(
-          name: name,
-          version: details['version'],
-          className: details['class_name'],
-          libraryUri: details['library_uri'],
-          packageName: details['package_name'],
-          path: details['path']);
+      return new PluginInfo._fromYaml(name: name, details: details);
     }
   }
 
   return null;
 }
 
+_verifyMap(dynamic yaml, String context) {
+  if (yaml is! YamlMap) {
+    throw new PluginConfigFormatException(
+        'Unable to parse $context, '
+        'expected `YamlMap`, got `${yaml.runtimeType}`',
+        yaml);
+  }
+}
+
 /// A callback for error handling.
 typedef ErrorHandler(Exception e);
 
 /// Describes plugin configuration information as extracted from an
-/// analysis options map.
+/// analysis options map or plugin manifest.
 class PluginConfig {
   final Iterable<PluginInfo> plugins;
   PluginConfig(this.plugins);
 
   /// Create a plugin configuration from an options map.
   factory PluginConfig.fromOptions(Map<String, YamlNode> options) {
     List<PluginInfo> plugins = [];
     var analyzerOptions = options[_analyzerOptionScope];
     if (analyzerOptions != null) {
       if (analyzerOptions is YamlMap) {
         var pluginConfig = analyzerOptions[_pluginOptionScope];
         if (pluginConfig is YamlMap) {
           pluginConfig.forEach((name, details) {
             var plugin = _processPluginMapping(name, details);
             if (plugin != null) {
               plugins.add(plugin);
             }
           });
         } else {
           // Anything but an empty list of plugins is treated as a format error.
           if (pluginConfig != null) {
             throw new PluginConfigFormatException(
-                'Unrecognized plugin config format (expected `YamlMap`, got `${pluginConfig.runtimeType}`)',
+                'Unrecognized plugin config format, expected `YamlMap`, got `${pluginConfig.runtimeType}`',
                 pluginConfig);
           }
         }
       }
     }
 
     return new PluginConfig(plugins);
   }
 }
 
@@ skipping 39 matching lines @@
   final String libraryUri;
   final String packageName;
   final String path;
   PluginInfo(
       {this.name,
       this.version,
       this.className,
       this.libraryUri,
       this.packageName,
       this.path});
+
+  factory PluginInfo._fromYaml({String name, YamlMap details}) =>
+      new PluginInfo(
+          name: name,
+          version: _asString(details['version']),
+          className: _asString(details['class_name']),
+          libraryUri: _asString(details['library_uri']),
+          packageName: _asString(details['package_name']),
+          path: _asString(details['path']));
 }
+
+/// Plugin manifests accompany plugin packages, providing
+/// configuration information for published plugins.
+///
+/// Provisionally, plugin manifests live in a file `plugin.yaml`
+/// at the root of the plugin package.
+///
+///     my_plugin/
+///       bin/
+///       lib/
+///       plugin.yaml
+///       pubspec.yaml
+///
+/// Provisional manifest file format:
+///
+///     analyzer-plugin:
+///       class_name: MyAnalyzerPlugin
+///       library_uri: 'my_plugin/my_analyzer_plugin.dart'
+///     server-plugin:
+///       class_name: MyServerPlugin
+///       library_uri: 'my_plugin/my_server_plugin.dart'
+///
+class PluginManifest {
+  PluginInfo analyzerPlugin;
+  PluginInfo serverPlugin;
+  PluginManifest({this.analyzerPlugin, this.serverPlugin});
+}