Add support for iterable, nested commands

src/cascadia/TerminalApp/AppKeyBindings.cpp

@@ -53,6 +53,11 @@ namespace winrt::TerminalApp::implementation
     // - The bound keychord, if this ActionAndArgs is bound to a key, otherwise nullptr.
     KeyChord AppKeyBindings::GetKeyBindingForActionWithArgs(TerminalApp::ActionAndArgs const& actionAndArgs)
     {
+        if (actionAndArgs == nullptr)
+        {
+            return { nullptr };
+        }
+
         for (auto& kv : _keyShortcuts)
         {
             const auto action = kv.second.Action();

src/cascadia/TerminalApp/AppLogic.cpp

@@ -38,7 +38,8 @@ static const std::array<std::wstring_view, static_cast<uint32_t>(SettingsLoadWar
     USES_RESOURCE(L"AtLeastOneKeybindingWarning"),
     USES_RESOURCE(L"TooManyKeysForChord"),
     USES_RESOURCE(L"MissingRequiredParameter"),
-    USES_RESOURCE(L"LegacyGlobalsProperty")
+    USES_RESOURCE(L"LegacyGlobalsProperty"),
+    USES_RESOURCE(L"FailedToParseCommandJson")
 };
 static const std::array<std::wstring_view, static_cast<uint32_t>(SettingsLoadErrors::ERRORS_SIZE)> settingsLoadErrorsLabels {
     USES_RESOURCE(L"NoProfilesText"),

src/cascadia/TerminalApp/CascadiaSettingsSerialization.cpp

@@ -19,7 +19,6 @@
 // "Generated Files" directory.
 
 using namespace ::TerminalApp;
-using namespace winrt::Microsoft::Terminal::TerminalControl;
 using namespace winrt::TerminalApp;
 using namespace ::Microsoft::Console;
 

src/cascadia/TerminalApp/Command.cpp

@@ -11,15 +11,33 @@
 #include <LibraryResources.h>
 
 using namespace winrt::TerminalApp;
+using namespace winrt::Windows::Foundation;
 using namespace ::TerminalApp;
 
 static constexpr std::string_view NameKey{ "name" };
 static constexpr std::string_view IconPathKey{ "iconPath" };
 static constexpr std::string_view ActionKey{ "command" };
 static constexpr std::string_view ArgsKey{ "args" };
+static constexpr std::string_view IterateOnKey{ "iterateOn" };
+static constexpr std::string_view CommandsKey{ "commands" };
+
+static constexpr std::string_view IterateOnProfilesValue{ "profiles" };
+
+static constexpr std::wstring_view ProfileName{ L"${profile.name}" };
 
 namespace winrt::TerminalApp::implementation
 {
+    Command::Command()
+    {
+        _nestedCommandsView = winrt::single_threaded_vector<winrt::TerminalApp::Command>();
+        _setAction(nullptr);
+    }
+
+    Collections::IVector<winrt::TerminalApp::Command> Command::NestedCommands()
+    {
+        return _nestedCommandsView;
+    }
+
     // Function Description:
     // - attempt to get the name of this command from the provided json object.
     //   * If the "name" property is a string, return that value.
@@ -99,35 +117,81 @@ namespace winrt::TerminalApp::implementation
     {
         auto result = winrt::make_self<Command>();
 
+        bool nested = false;
+        if (const auto iterateOnJson{ json[JsonKey(IterateOnKey)] })
+        {
+            auto s = iterateOnJson.asString();
+            if (s == IterateOnProfilesValue)
+            {
+                result->_IterateOn = ExpandCommandType::Profiles;
+            }
+        }
+
+        // For iterable commands, we'll make another pass at parsing them once
+        // the json is patched. So ignore parsing sub-commands for now. Commands
+        // will only be marked iterable on the first pass.
+        if (const auto nestedCommandsJson{ json[JsonKey(CommandsKey)] })
+        {
+            auto nestedWarnings = Command::LayerJson(result->_subcommands, nestedCommandsJson);
+            // It's possible that the nested commands have some warnings
+            warnings.insert(warnings.end(), nestedWarnings.begin(), nestedWarnings.end());
+
+            nested = true;
+        }
+        else if (json.isMember(JsonKey(CommandsKey)))
+        {
+            // { "name": "foo", "commands": null } will land in this case, which
+            // should also be used for unbinding.
+            return nullptr;
+        }
+
         // TODO GH#6644: iconPath not implemented quite yet. Can't seem to get
         // the binding quite right. Additionally, do we want it to be an image,
         // or a FontIcon? I've had difficulty binding either/or.
 
-        if (const auto actionJson{ json[JsonKey(ActionKey)] })
+        // If we're a nested command, we can ignore the current action.
+        if (!nested)
         {
-            auto actionAndArgs = ActionAndArgs::FromJson(actionJson, warnings);
-
-            if (actionAndArgs)
+            if (const auto actionJson{ json[JsonKey(ActionKey)] })
             {
-                result->_setAction(*actionAndArgs);
+                auto actionAndArgs = ActionAndArgs::FromJson(actionJson, warnings);
+
+                if (actionAndArgs)
+                {
+                    result->_setAction(*actionAndArgs);
+                }
+                else
+                {
+                    // Something like
+                    //      { name: "foo", action: "unbound" }
+                    // will _remove_ the "foo" command, by returning null here.
+                    return nullptr;
+                }
+
+                // If an iterable command doesn't have a name set, we'll still just
+                // try and generate a fake name for the command give the string we
+                // currently have. It'll probably generate something like "New tab,
+                // profile: ${profile.name}". This string will only be temporarily
+                // used internally, so there's no problem.
+                result->_setName(_nameFromJsonOrAction(json, actionAndArgs));
             }
             else
             {
-                // Something like
-                //      { name: "foo", action: "unbound" }
-                // will _remove_ the "foo" command, by returning null here.
+                // { name: "foo", action: null } will land in this case, which
+                // should also be used for unbinding.
                 return nullptr;
             }
-
-            result->_setName(_nameFromJsonOrAction(json, actionAndArgs));
         }
         else
         {
-            // { name: "foo", action: null } will land in this case, which
-            // should also be used for unbinding.
-            return nullptr;
+            result->_setName(_nameFromJson(json));
         }
 
+        // Stash the original json value in this object. If the command is
+        // iterable, we'll need to re-parse it later, once we know what all the
+        // values we can iterate on are.
+        result->_originalJson = json;
+
         if (result->_Name.empty())
         {
             return nullptr;
@@ -181,4 +245,208 @@ namespace winrt::TerminalApp::implementation
         }
         return warnings;
     }
+
+    // Function Description:
+    // - Helper to escape a string as a json string. This function will also
+    //   trim off the leading and trailing double-quotes, so the output string
+    //   can be inserted directly into another json blob.
+    // Arguments:
+    // - input: the string to JSON escape.
+    // Return Value:
+    // - the input string escaped properly to be inserted into another json blob.
+    winrt::hstring _escapeForJson(const std::wstring_view input)
+    {
+        Json::Value inJson{ winrt::to_string(input) };
+        Json::StreamWriterBuilder builder;
+        builder.settings_["indentation"] = "";
+        std::string out{ Json::writeString(builder, inJson) };
+        if (out.size() >= 2)
+        {
+            // trim off the leading/trailing '"'s
+            auto ss{ out.substr(1, out.size() - 2) };
+            return winrt::to_hstring(ss);
+        }
+        return winrt::to_hstring(out);
+    }
+
+    // Function Description:
+    // - A helper to replace any occurences of `keyword` with `replaceWith` in `sourceString`
+    winrt::hstring _replaceKeyword(const winrt::hstring& sourceString,
+                                   const std::wstring_view keyword,
+                                   const std::wstring_view replaceWith)
+    {
+        std::wstring result{ sourceString };
+        size_t index = 0;
+        while (true)
+        {
+            index = result.find(keyword, index);
+            if (index == std::wstring::npos)
+            {
+                break;
+            }
+            result.replace(index, keyword.size(), replaceWith);
+            index += replaceWith.size();
+        }
+        return winrt::hstring{ result };
+    }
+
+    // Method Description:
+    // - Iterate over all the provided commands, and recursively expand any
+    //   commands with `iterateOn` set. If we successfully generated expanded
+    //   commands for them, then we'll remove the original command, and add all
+    //   the newly generated commands.
+    // - For more specific implementation details, see _expandCommand.
+    // Arguments:
+    // - commands: a map of commands to expand. Newly created commands will be
+    //   inserted into the map to replace the expandable commands.
+    // - profiles: A list of all the profiles that this command should be expanded on.
+    // - warnings: If there were any warnings during parsing, they'll be
+    //   appended to this vector.
+    // Return Value:
+    // - <none>
+    void Command::ExpandCommands(std::unordered_map<winrt::hstring, winrt::TerminalApp::Command>& commands,
+                                 gsl::span<const ::TerminalApp::Profile> profiles,
+                                 std::vector<::TerminalApp::SettingsLoadWarnings>& warnings)
+    {
+        std::vector<winrt::hstring> commandsToRemove;
+        std::vector<winrt::TerminalApp::Command> commandsToAdd;
+
+        // First, collect up all the commands that need replacing.
+        for (auto nameAndCmd : commands)
+        {
+            winrt::com_ptr<winrt::TerminalApp::implementation::Command> cmd;
+            cmd.copy_from(winrt::get_self<winrt::TerminalApp::implementation::Command>(nameAndCmd.second));
+
+            auto newCommands = _expandCommand(cmd, profiles, warnings);
+            if (newCommands.size() > 0)
+            {
+                commandsToRemove.push_back(nameAndCmd.first);
+                commandsToAdd.insert(commandsToAdd.end(), newCommands.begin(), newCommands.end());
+            }
+        }
+
+        // Second, remove all the commands that need to be removed.
+        for (auto& name : commandsToRemove)
+        {
+            commands.erase(name);
+        }
+
+        // Finally, add all the new commands.
+        for (auto& cmd : commandsToAdd)
+        {
+            commands.insert_or_assign(cmd.Name(), cmd);
+        }
+    }
+
+    // Method Description:
+    // - Initialize our ObservableVector of NestedCommands, recursively. This
+    //   will build the vector of nested Commands that XAML can access.
+    // Arguments:
+    // - <none>
+    // Return Value:
+    // - <none>
+    void Command::_createView()
+    {
+        _nestedCommandsView.Clear();
+
+        // Add all the commands we've parsed to the observable vector we
+        // have, so we can access them in XAML.
+        for (auto& nameAndCommand : _subcommands)
+        {
+            auto command = nameAndCommand.second;
+            _nestedCommandsView.Append(command);
+
+            winrt::com_ptr<winrt::TerminalApp::implementation::Command> cmd;
+            cmd.copy_from(winrt::get_self<winrt::TerminalApp::implementation::Command>(command));
+            cmd->_createView();
+        }
+    }
+
+    // Function Description:
+    // - Attempts to expand the given command into many commands, if the command
+    //   has `"iterateOn": "profiles"` set.
+    // - If it doesn't, this function will do
+    //   nothing and return an empty vector.
+    // - If it does, we're going to attempt to build a new set of commands using
+    //   the given command as a prototype. We'll attempt to create a new command
+    //   for each and every profile, to replace the original command.
+    //   * For the new commands, we'll replace any instance of "${profile.name}"
+    //     in the original json used to create this action with the name of the
+    //     given profile.
+    // - If we encounter any errors while re-parsing the json with the replaced
+    //   name, we'll just return immediately.
+    // - At the end, we'll return all the new commands we've build for the given command.
+    // Arguments:
+    // - expandable: the Command to potentially turn into more commands
+    // - profiles: A list of all the profiles that this command should be expanded on.
+    // - warnings: If there were any warnings during parsing, they'll be
+    //   appended to this vector.
+    // Return Value:
+    // - and empty vector if the command wasn't expandable, otherwise a list of
+    //   the newly-created commands.
+    std::vector<winrt::TerminalApp::Command> Command::_expandCommand(winrt::com_ptr<Command> expandable,
+                                                                     gsl::span<const ::TerminalApp::Profile> profiles,
+                                                                     std::vector<::TerminalApp::SettingsLoadWarnings>& warnings)
+    {
+        std::vector<winrt::TerminalApp::Command> newCommands;
+
+        if (!expandable->_subcommands.empty())
+        {
+            ExpandCommands(expandable->_subcommands, profiles, warnings);
+
+            expandable->_createView();
+        }
+
+        if (expandable->_IterateOn == ExpandCommandType::None)
+        {
+            return newCommands;
+        }
+
+        std::string errs; // This string will receive any error text from failing to parse.
+        std::unique_ptr<Json::CharReader> reader{ Json::CharReaderBuilder::CharReaderBuilder().newCharReader() };
+
+        // First, get a string for the original Json::Value
+        auto oldJsonString = winrt::to_hstring(expandable->_originalJson.toStyledString());
+
+        if (expandable->_IterateOn == ExpandCommandType::Profiles)
+        {
+            for (const auto& p : profiles)
+            {
+                // For each profile, create a new command. This command will have:
+                // * the icon path and keychord text of the original command
+                // * the Name will have any instances of "${profile.name}"
+                //   replaced with the profile's name
+                // * for the action, we'll take the original json, replace any
+                //   instances of "${profile.name}" with the profile's name,
+                //   then re-attempt to parse the action and args.
+
+                // Replace all the keywords in the original json, and try and parse that
+
+                // - Escape the profile name for JSON appropriately
+                auto escapedProfileName = _escapeForJson(p.GetName());
+                auto newJsonString = winrt::to_string(_replaceKeyword(oldJsonString,
+                                                                      ProfileName,
+                                                                      escapedProfileName));
+
+                // - Now, re-parse the modified value.
+                Json::Value newJsonValue;
+                const auto actualDataStart = newJsonString.data();
+                const auto actualDataEnd = newJsonString.data() + newJsonString.size();
+                if (!reader->parse(actualDataStart, actualDataEnd, &newJsonValue, &errs))
+                {
+                    warnings.push_back(::TerminalApp::SettingsLoadWarnings::FailedToParseCommandJson);
+                    // If we encounter a re-parsing error, just stop processing the rest of the commands.
+                    break;
+                }
+
+                // Pass the new json back though FromJson, to get the new expanded value.
+                if (auto newCmd{ Command::FromJson(newJsonValue, warnings) })
+                {
+                    newCommands.push_back(*newCmd);
+                }
+            }
+        }
+
+        return newCommands;
+    }
 }