Extract ActionAndArgs::FromJson into its own class (#6351)

## Summary of the Pull Request

Pulls the `ActionAndArgs` deserializing into its own class, separate from `AppKeyBindings`. Some 2.0 features are going to need to re-use these actions in their json, so we'll want one unified way of deserializing them.

## References

* Done primarily as part of the work on #2046/#5400/#5674 
* Also related: #1571/#5888 
* Will aggressively conflict with any open PRs that introduced keybindings (looking at #6299)

## PR Checklist
* [x] Closes nothing, this is code refactoring
* [x] I work here
* [x] Current tests passed
* [n/a] Requires documentation to be updated

src/cascadia/TerminalApp/ActionAndArgs.cpp

@@ -1,11 +1,212 @@
 #include "pch.h"
+#include "ActionArgs.h"
 #include "ActionAndArgs.h"
 #include "ActionAndArgs.g.cpp"
 
-// We define everything necessary for the ActionAndArgs class in the header, but
-// we still need this file to compile the ActionAndArgs.g.cpp file, and we can't
-// just include that file in the header.
+static constexpr std::string_view ActionKey{ "action" };
+
+// This key is reserved to remove a keybinding, instead of mapping it to an action.
+static constexpr std::string_view UnboundKey{ "unbound" };
+
+static constexpr std::string_view CopyTextKey{ "copy" };
+static constexpr std::string_view PasteTextKey{ "paste" };
+static constexpr std::string_view OpenNewTabDropdownKey{ "openNewTabDropdown" };
+static constexpr std::string_view DuplicateTabKey{ "duplicateTab" };
+static constexpr std::string_view NewTabKey{ "newTab" };
+static constexpr std::string_view NewWindowKey{ "newWindow" };
+static constexpr std::string_view CloseWindowKey{ "closeWindow" };
+static constexpr std::string_view CloseTabKey{ "closeTab" };
+static constexpr std::string_view ClosePaneKey{ "closePane" };
+static constexpr std::string_view SwitchtoTabKey{ "switchToTab" };
+static constexpr std::string_view NextTabKey{ "nextTab" };
+static constexpr std::string_view PrevTabKey{ "prevTab" };
+static constexpr std::string_view AdjustFontSizeKey{ "adjustFontSize" };
+static constexpr std::string_view ResetFontSizeKey{ "resetFontSize" };
+static constexpr std::string_view ScrollupKey{ "scrollUp" };
+static constexpr std::string_view ScrolldownKey{ "scrollDown" };
+static constexpr std::string_view ScrolluppageKey{ "scrollUpPage" };
+static constexpr std::string_view ScrolldownpageKey{ "scrollDownPage" };
+static constexpr std::string_view SwitchToTabKey{ "switchToTab" };
+static constexpr std::string_view OpenSettingsKey{ "openSettings" }; // TODO GH#2557: Add args for OpenSettings
+static constexpr std::string_view SplitPaneKey{ "splitPane" };
+static constexpr std::string_view ResizePaneKey{ "resizePane" };
+static constexpr std::string_view MoveFocusKey{ "moveFocus" };
+static constexpr std::string_view FindKey{ "find" };
+static constexpr std::string_view ToggleFullscreenKey{ "toggleFullscreen" };
 
 namespace winrt::TerminalApp::implementation
 {
+    // Specifically use a map here over an unordered_map. We want to be able to
+    // iterate over these entries in-order when we're serializing the keybindings.
+    // HERE BE DRAGONS:
+    // These are string_views that are being used as keys. These string_views are
+    // just pointers to other strings. This could be dangerous, if the map outlived
+    // the actual strings being pointed to. However, since both these strings and
+    // the map are all const for the lifetime of the app, we have nothing to worry
+    // about here.
+    const std::map<std::string_view, ShortcutAction, std::less<>> ActionAndArgs::ActionNamesMap{
+        { CopyTextKey, ShortcutAction::CopyText },
+        { PasteTextKey, ShortcutAction::PasteText },
+        { OpenNewTabDropdownKey, ShortcutAction::OpenNewTabDropdown },
+        { DuplicateTabKey, ShortcutAction::DuplicateTab },
+        { NewTabKey, ShortcutAction::NewTab },
+        { NewWindowKey, ShortcutAction::NewWindow },
+        { CloseWindowKey, ShortcutAction::CloseWindow },
+        { CloseTabKey, ShortcutAction::CloseTab },
+        { ClosePaneKey, ShortcutAction::ClosePane },
+        { NextTabKey, ShortcutAction::NextTab },
+        { PrevTabKey, ShortcutAction::PrevTab },
+        { AdjustFontSizeKey, ShortcutAction::AdjustFontSize },
+        { ResetFontSizeKey, ShortcutAction::ResetFontSize },
+        { ScrollupKey, ShortcutAction::ScrollUp },
+        { ScrolldownKey, ShortcutAction::ScrollDown },
+        { ScrolluppageKey, ShortcutAction::ScrollUpPage },
+        { ScrolldownpageKey, ShortcutAction::ScrollDownPage },
+        { SwitchToTabKey, ShortcutAction::SwitchToTab },
+        { ResizePaneKey, ShortcutAction::ResizePane },
+        { MoveFocusKey, ShortcutAction::MoveFocus },
+        { OpenSettingsKey, ShortcutAction::OpenSettings },
+        { ToggleFullscreenKey, ShortcutAction::ToggleFullscreen },
+        { SplitPaneKey, ShortcutAction::SplitPane },
+        { UnboundKey, ShortcutAction::Invalid },
+        { FindKey, ShortcutAction::Find }
+    };
+
+    using ParseResult = std::tuple<IActionArgs, std::vector<::TerminalApp::SettingsLoadWarnings>>;
+    using ParseActionFunction = std::function<ParseResult(const Json::Value&)>;
+
+    // This is a map of ShortcutAction->function<IActionArgs(Json::Value)>. It holds
+    // a set of deserializer functions that can be used to deserialize a IActionArgs
+    // from json. Each type of IActionArgs that can accept arbitrary args should be
+    // placed into this map, with the corresponding deserializer function as the
+    // value.
+    static const std::map<ShortcutAction, ParseActionFunction, std::less<>> argParsers{
+        { ShortcutAction::CopyText, winrt::TerminalApp::implementation::CopyTextArgs::FromJson },
+
+        { ShortcutAction::NewTab, winrt::TerminalApp::implementation::NewTabArgs::FromJson },
+
+        { ShortcutAction::SwitchToTab, winrt::TerminalApp::implementation::SwitchToTabArgs::FromJson },
+
+        { ShortcutAction::ResizePane, winrt::TerminalApp::implementation::ResizePaneArgs::FromJson },
+
+        { ShortcutAction::MoveFocus, winrt::TerminalApp::implementation::MoveFocusArgs::FromJson },
+
+        { ShortcutAction::AdjustFontSize, winrt::TerminalApp::implementation::AdjustFontSizeArgs::FromJson },
+
+        { ShortcutAction::SplitPane, winrt::TerminalApp::implementation::SplitPaneArgs::FromJson },
+
+        { ShortcutAction::OpenSettings, winrt::TerminalApp::implementation::OpenSettingsArgs::FromJson },
+
+        { ShortcutAction::Invalid, nullptr },
+    };
+
+    // Function Description:
+    // - Attempts to match a string to a ShortcutAction. If there's no match, then
+    //   returns ShortcutAction::Invalid
+    // Arguments:
+    // - actionString: the string to match to a ShortcutAction
+    // Return Value:
+    // - The ShortcutAction corresponding to the given string, if a match exists.
+    static ShortcutAction GetActionFromString(const std::string_view actionString)
+    {
+        // Try matching the command to one we have. If we can't find the
+        // action name in our list of names, let's just unbind that key.
+        const auto found = ActionAndArgs::ActionNamesMap.find(actionString);
+        return found != ActionAndArgs::ActionNamesMap.end() ? found->second : ShortcutAction::Invalid;
+    }
+
+    // Method Description:
+    // - Deserialize an ActionAndArgs from the provided json object or string `json`.
+    //   * If json is a string, we'll attempt to treat it as an action name,
+    //     without arguments.
+    //   * If json is an object, we'll attempt to retrieve the action name from
+    //     its "action" property, and we'll use that name to fine a deserializer
+    //     to precess the rest of the arguments in the json object.
+    // - If the action name is null or "unbound", or we don't understand the
+    //   action name, or we failed to parse the arguments to this action, we'll
+    //   return null. This should indicate to the caller that the action should
+    //   be unbound.
+    // - If there were any warnings while parsing arguments for the action,
+    //   they'll be appended to the warnings parameter.
+    // Arguments:
+    // - json: The Json::Value to attempt to parse as an ActionAndArgs
+    // - warnings: If there were any warnings during parsing, they'll be
+    //   appended to this vector.
+    // Return Value:
+    // - a deserialized ActionAndArgs corresponding to the values in json, or
+    //   null if we failed to deserialize an action.
+    winrt::com_ptr<ActionAndArgs> ActionAndArgs::FromJson(const Json::Value& json,
+                                                          std::vector<::TerminalApp::SettingsLoadWarnings>& warnings)
+    {
+        // Invalid is our placeholder that the action was not parsed.
+        ShortcutAction action = ShortcutAction::Invalid;
+
+        // Actions can be serialized in two styles:
+        //   "action": "switchToTab0",
+        //   "action": { "action": "switchToTab", "index": 0 },
+        // NOTE: For keybindings, the "action" param is actually "command"
+
+        // 1. In the first case, the json is a string, that's the
+        //    action name. There are no provided args, so we'll pass
+        //    Json::Value::null to the parse function.
+        // 2. In the second case, the json is an object. We'll use the
+        //    "action" in that object as the action name. We'll then pass
+        //    the json object to the arg parser, for further parsing.
+
+        auto argsVal = Json::Value::null;
+
+        // Only try to parse the action if it's actually a string value.
+        // `null` will not pass this check.
+        if (json.isString())
+        {
+            auto commandString = json.asString();
+            action = GetActionFromString(commandString);
+        }
+        else if (json.isObject())
+        {
+            const auto actionVal = json[JsonKey(ActionKey)];
+            if (actionVal.isString())
+            {
+                auto actionString = actionVal.asString();
+                action = GetActionFromString(actionString);
+                argsVal = json;
+            }
+        }
+
+        // Some keybindings can accept other arbitrary arguments. If it
+        // does, we'll try to deserialize any "args" that were provided with
+        // the binding.
+        IActionArgs args{ nullptr };
+        std::vector<::TerminalApp::SettingsLoadWarnings> parseWarnings;
+        const auto deserializersIter = argParsers.find(action);
+        if (deserializersIter != argParsers.end())
+        {
+            auto pfn = deserializersIter->second;
+            if (pfn)
+            {
+                std::tie(args, parseWarnings) = pfn(argsVal);
+            }
+            warnings.insert(warnings.end(), parseWarnings.begin(), parseWarnings.end());
+
+            // if an arg parser was registered, but failed, bail
+            if (pfn && args == nullptr)
+            {
+                return nullptr;
+            }
+        }
+
+        if (action != ShortcutAction::Invalid)
+        {
+            auto actionAndArgs = winrt::make_self<ActionAndArgs>();
+            actionAndArgs->Action(action);
+            actionAndArgs->Args(args);
+
+            return actionAndArgs;
+        }
+        else
+        {
+            return nullptr;
+        }
+    }
+
 }

src/cascadia/TerminalApp/ActionAndArgs.h

@@ -1,11 +1,16 @@
 #pragma once
 #include "ActionAndArgs.g.h"
+#include "TerminalWarnings.h"
 #include "..\inc\cppwinrt_utils.h"
 
 namespace winrt::TerminalApp::implementation
 {
     struct ActionAndArgs : public ActionAndArgsT<ActionAndArgs>
     {
+        static const std::map<std::string_view, ShortcutAction, std::less<>> ActionNamesMap;
+        static winrt::com_ptr<ActionAndArgs> FromJson(const Json::Value& json,
+                                                      std::vector<::TerminalApp::SettingsLoadWarnings>& warnings);
+
         ActionAndArgs() = default;
         GETSET_PROPERTY(TerminalApp::ShortcutAction, Action, TerminalApp::ShortcutAction::Invalid);
         GETSET_PROPERTY(IActionArgs, Args, nullptr);