[vcpkg-upgrade] Accept list of packages to specifically upgrade.

1 files changed, 97 insertions, 11 deletions

diff --git a/toolsrc/src/commands.upgrade.cpp b/toolsrc/src/commands.upgrade.cpp
index 7a3210042..2ce04faa9 100644
--- a/toolsrc/src/commands.upgrade.cpp
+++ b/toolsrc/src/commands.upgrade.cpp
@@ -1,8 +1,10 @@
 #include "pch.h"
 
+#include <vcpkg/base/util.h>
 #include <vcpkg/commands.h>
 #include <vcpkg/dependencies.h>
 #include <vcpkg/help.h>
+#include <vcpkg/input.h>
 #include <vcpkg/install.h>
 #include <vcpkg/statusparagraphs.h>
 #include <vcpkg/update.h>
@@ -24,37 +26,121 @@ namespace vcpkg::Commands::Upgrade
     const CommandStructure COMMAND_STRUCTURE = {
         Help::create_example_string("upgrade --no-dry-run"),
         0,
-        0,
+        SIZE_MAX,
         {INSTALL_SWITCHES, {}},
         nullptr,
     };
 
-    void perform_and_exit(const VcpkgCmdArguments& args, const VcpkgPaths& paths, const Triplet&)
+    void perform_and_exit(const VcpkgCmdArguments& args, const VcpkgPaths& paths, const Triplet& default_triplet)
     {
-        // input sanitization
         const ParsedArguments options = args.parse_arguments(COMMAND_STRUCTURE);
 
         const bool no_dry_run = Util::Sets::contains(options.switches, OPTION_NO_DRY_RUN);
         const KeepGoing keep_going = to_keep_going(Util::Sets::contains(options.switches, OPTION_KEEP_GOING));
 
-        // create the plan
         StatusParagraphs status_db = database_load_check(paths);
 
         Dependencies::PathsPortFileProvider provider(paths);
         Dependencies::PackageGraph graph(provider, status_db);
 
-        auto outdated_packages = Update::find_outdated_packages(provider, status_db);
-        for (auto&& outdated_package : outdated_packages)
-            graph.upgrade(outdated_package.spec);
+        // input sanitization
+        const std::vector<PackageSpec> specs = Util::fmap(args.command_arguments, [&](auto&& arg) {
+            return Input::check_and_get_package_spec(arg, default_triplet, COMMAND_STRUCTURE.example_text);
+        });
 
-        auto plan = graph.serialize();
+        for (auto&& spec : specs)
+        {
+            Input::check_triplet(spec.triplet(), paths);
+        }
 
-        if (plan.empty())
+        if (specs.empty())
         {
-            System::println("All packages are up-to-date.");
-            Checks::exit_success(VCPKG_LINE_INFO);
+            // If no packages specified, upgrade all outdated packages.
+            auto outdated_packages = Update::find_outdated_packages(provider, status_db);
+
+            if (outdated_packages.empty())
+            {
+                System::println("All installed packages are up-to-date with the local portfiles.");
+                Checks::exit_success(VCPKG_LINE_INFO);
+            }
+
+            for (auto&& outdated_package : outdated_packages)
+                graph.upgrade(outdated_package.spec);
+        }
+        else
+        {
+            std::vector<PackageSpec> not_installed;
+            std::vector<PackageSpec> no_portfile;
+            std::vector<PackageSpec> to_upgrade;
+            std::vector<PackageSpec> up_to_date;
+
+            for (auto&& spec : specs)
+            {
+                auto it = status_db.find_installed(spec);
+                if (it == status_db.end())
+                {
+                    not_installed.push_back(spec);
+                }
+
+                auto maybe_scf = provider.get_control_file(spec.name());
+                if (auto p_scf = maybe_scf.get())
+                {
+                    if (it != status_db.end())
+                    {
+                        if (p_scf->core_paragraph->version != (*it)->package.version)
+                        {
+                            to_upgrade.push_back(spec);
+                        }
+                        else
+                        {
+                            up_to_date.push_back(spec);
+                        }
+                    }
+                }
+                else
+                {
+                    no_portfile.push_back(spec);
+                }
+            }
+
+            Util::sort(not_installed);
+            Util::sort(no_portfile);
+            Util::sort(up_to_date);
+            Util::sort(to_upgrade);
+
+            if (!up_to_date.empty())
+            {
+                System::println(System::Color::success, "The following packages are up-to-date:");
+                System::println(Strings::join(
+                    "", up_to_date, [](const PackageSpec& spec) { return "    " + spec.to_string() + "\n"; }));
+            }
+
+            if (!not_installed.empty())
+            {
+                System::println(System::Color::error, "The following packages are not installed:");
+                System::println(Strings::join(
+                    "", not_installed, [](const PackageSpec& spec) { return "    " + spec.to_string() + "\n"; }));
+            }
+
+            if (!no_portfile.empty())
+            {
+                System::println(System::Color::error, "The following packages do not have a valid portfile:");
+                System::println(Strings::join(
+                    "", no_portfile, [](const PackageSpec& spec) { return "    " + spec.to_string() + "\n"; }));
+            }
+
+            Checks::check_exit(VCPKG_LINE_INFO, not_installed.empty() && no_portfile.empty());
+
+            if (to_upgrade.empty()) Checks::exit_success(VCPKG_LINE_INFO);
+
+            for (auto&& spec : to_upgrade)
+                graph.upgrade(spec);
         }
 
+        auto plan = graph.serialize();
+
+        Checks::check_exit(VCPKG_LINE_INFO, !plan.empty());
+
         Dependencies::print_plan(plan, true);
 
         if (!no_dry_run)