Initial pass at loadExternalActionSource command

Author: pappleby

CHANGELOG.md

@@ -11,6 +11,7 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).
 - Added support for variadic functions.
 - Added support for cancelling compilation.
   - To enable cancelling a compilation, supply a `CancellationToken` to your `CompilationJob` object. You can request that the compilation be cancelled by cancelling the token. For more information, see [Task Cancellation](https://learn.microsoft.com/en-us/dotnet/standard/parallel-programming/task-cancellation).
+- Added a new language server command `yarnspinner.loadExternalActionSource` which can be used to programatically load command / function definitions from an external source (eg. a vscode extension that parses yarn commands/functions from a non-C# language).
 
 ### Changed
 

YarnSpinner.LanguageServer/src/Server/Commands/Commands.cs

@@ -73,4 +73,11 @@ public static class Commands
     /// The command to get all projects in the current workspace.
     /// </summary>
     public const string ListProjects = "yarnspinner.listProjects";
+
+    /// <summary>
+    /// The command to import function and command definitions from external sources.
+    /// </summary>
+    /// <param name="sourceKey">The unique key identifying the external action source.</param>
+    /// <param name="sourceContent">A string containing JSON with the same schema as the .ysls.json file.</param>
+    public const string LoadExternalActionSource = "yarnspinner.loadExternalActionSource";
 }

YarnSpinner.LanguageServer/src/Server/Workspace/Workspace.cs

@@ -59,6 +59,11 @@ internal IEnumerable<Project> GetProjectsForUri(DocumentUri uri)
         /// </summary>
         private HashSet<Action> workspaceActions = new HashSet<Action>();
 
+        /// <summary>
+        /// The collection of actions loaded using the loadExternalActionSource command.
+        /// </summary>
+        private Dictionary<string, HashSet<Action>> externalActions = new Dictionary<string, HashSet<Action>>();
+
         Configuration IConfigurationSource.Configuration => this.Configuration;
 
         internal void ReloadWorkspace(CancellationToken cancellationToken)
@@ -73,6 +78,15 @@ internal void ReloadWorkspace(CancellationToken cancellationToken)
                 this.workspaceActions = new HashSet<Action>();
             }
 
+            // Merge in the actions from external sources
+            foreach (var externalSource in this.externalActions)
+            {
+                foreach (var action in externalSource.Value)
+                {
+                    this.workspaceActions.Add(action);
+                }
+            }
+
             // Find all actions built in to this DLL
             try
             {
@@ -229,6 +243,21 @@ internal static IEnumerable<Action> GetPredefinedActions()
             return predefinedActions;
         }
 
+        /// <summary>
+        ///  Imports an external action source into the workspace.
+        ///  </summary>
+        /// <remarks>
+        ///  Existing actions with the same source key will be deleted / replaced.
+        ///  This will not automatically relaod the workspace,
+        ///  so it is up to the caller to call <see cref="ReloadWorkspace(CancellationToken)"/> after importing
+        ///  the external actions to ensure that the workspace is up to date with the new actions.
+        /// </remarks>
+        internal void ImportExternalActionSource(string sourceKey, HashSet<Action> actionsSet)
+        {
+            this.externalActions.Remove(sourceKey);
+            this.externalActions.Add(sourceKey, actionsSet);
+        }
+
         private IEnumerable<Action> FindWorkspaceActions(string root)
         {
             var csharpWorkspaceFiles = System.IO.Directory.EnumerateFiles(root, "*.cs", System.IO.SearchOption.AllDirectories);

YarnSpinner.LanguageServer/src/Server/YarnLanguageServer.cs

@@ -6,12 +6,14 @@
 using System.Threading.Tasks;
 using Google.Protobuf;
 using Microsoft.Extensions.DependencyInjection;
+using Newtonsoft.Json;
 using Newtonsoft.Json.Linq;
 using OmniSharp.Extensions.LanguageServer.Protocol.Models;
 using OmniSharp.Extensions.LanguageServer.Protocol.Server;
 using OmniSharp.Extensions.LanguageServer.Protocol.Window;
 using OmniSharp.Extensions.LanguageServer.Protocol.Workspace;
 using OmniSharp.Extensions.LanguageServer.Server;
+using static YarnLanguageServer.JsonConfigFile;
 
 [assembly: System.Runtime.CompilerServices.InternalsVisibleTo("YarnLanguageServer.Tests")]
 
@@ -182,6 +184,15 @@ public static LanguageServerOptions ConfigureOptions(LanguageServerOptions optio
                 }
             );
 
+            // Register Load External Action Source command
+            options.OnExecuteCommand<bool>(
+                (commandParams, cancellationToken) => LoadExternalActionSourceAsync(workspace, commandParams, cancellationToken),
+                (_, _) => new ExecuteCommandRegistrationOptions
+                {
+                    Commands = new[] { Commands.LoadExternalActionSource },
+                }
+            );
+
             return options;
         }
 
@@ -829,5 +840,51 @@ private static Task<Container<ProjectInfo>> ListProjectsAsync(Workspace workspac
             });
             return Task.FromResult(Container.From(info));
         }
+
+        private static Task<bool> LoadExternalActionSourceAsync(Workspace workspace, ExecuteCommandParams<bool> commandParams, CancellationToken cancellationToken)
+        {
+            if (commandParams.Arguments == null || commandParams.Arguments.Count < 2)
+            {
+                workspace.ShowMessage($"{Commands.LoadExternalActionSource} expects at least two arguments: a source key and a json of actions (same format as ysls.json)", MessageType.Error);
+                return Task.FromResult(false);
+            }
+
+            var externalActionSourceName = commandParams.Arguments[0].ToString();
+            var externalActionContent = commandParams.Arguments[1].ToString();
+
+            var parsedActions = JsonConvert.DeserializeObject<JsonConfigFormat>(externalActionContent);
+            if (parsedActions == null)
+            {
+                workspace.ShowMessage($"Failed to parse external action source JSON for {externalActionSourceName}", MessageType.Error);
+                return Task.FromResult(false);
+            }
+
+            var actionsToImport = new HashSet<Action>();
+            foreach (var definition in parsedActions.Functions)
+            {
+                Action action = definition.ToAction();
+                action.IsBuiltIn = false;
+                action.Type = ActionType.Function;
+                if (!actionsToImport.Add(action)) {
+                    workspace.ShowMessage($"Duplicate action found for function: {externalActionSourceName}", MessageType.Error);
+                    return Task.FromResult(false);
+                }
+            }
+
+            foreach (var definition in parsedActions.Commands)
+            {
+                Action action = definition.ToAction();
+                action.IsBuiltIn = false;
+                action.Type = ActionType.Command;
+                if (!actionsToImport.Add(action)) {
+                    workspace.ShowMessage($"Duplicate action found for command: {externalActionSourceName}", MessageType.Error);
+                    return Task.FromResult(false);
+                }
+            }
+
+            workspace.ImportExternalActionSource(externalActionSourceName, actionsToImport);
+            workspace.ReloadWorkspace(cancellationToken);
+            return Task.FromResult(true);
+        }
     }
 }