feat(workspace): complete other commands support

qqiangwu · qqiangwu · commit 82b1c1213161 · 2025-04-05T00:38:04.000+08:00
diff --git a/CMakeLists.txt b/CMakeLists.txt
@@ -1,5 +1,5 @@
 cmake_minimum_required(VERSION 3.17)
-project(cppship VERSION 0.8.0)
+project(cppship VERSION 0.8.1)
 
 # cpp std
 set(CMAKE_CXX_STANDARD 20)
diff --git a/cppship.toml b/cppship.toml
@@ -1,6 +1,6 @@
 [package]
 name = "cppship"
-version = "0.8.0"
+version = "0.8.1"
 authors = []
 std = 20
 
diff --git a/include/cppship/cmd/bench.h b/include/cppship/cmd/bench.h
@@ -10,8 +10,9 @@ namespace cppship::cmd {
 struct BenchOptions {
     Profile profile = Profile::release;
     std::optional<std::string> target;
+    std::optional<std::string> package;
 };
 
 int run_bench(const BenchOptions& options);
 
-}
+}
diff --git a/include/cppship/cmd/build.h b/include/cppship/cmd/build.h
@@ -26,7 +26,7 @@ struct BuildOptions {
     Profile profile = Profile::debug;
     bool dry_run = false;
     std::optional<std::string> package;
-    std::optional<std::string> target;
+    std::optional<std::string> cmake_target;
     std::set<BuildGroup> groups;
 };
 
diff --git a/include/cppship/cmd/run.h b/include/cppship/cmd/run.h
@@ -10,10 +10,11 @@ namespace cppship::cmd {
 struct RunOptions {
     Profile profile = Profile::debug;
     std::string args;
+    std::optional<std::string> package;
     std::optional<std::string> bin;
     std::optional<std::string> example;
 };
 
 int run_run(const RunOptions& options);
 
-}
+}
diff --git a/include/cppship/cmd/test.h b/include/cppship/cmd/test.h
@@ -10,10 +10,11 @@ namespace cppship::cmd {
 struct TestOptions {
     Profile profile = Profile::debug;
     std::optional<std::string> target;
+    std::optional<std::string> package;
     std::optional<std::string> name_regex;
     bool rerun_failed = false;
 };
 
 int run_test(const TestOptions& options);
 
-}
+}
diff --git a/include/cppship/core/workspace.h b/include/cppship/core/workspace.h
@@ -1,5 +1,7 @@
 #pragma once
 
+#include <range/v3/view/map.hpp>
+
 #include "cppship/core/layout.h"
 #include "cppship/core/manifest.h"
 
@@ -25,6 +27,8 @@ class Workspace {
 
     auto end() const { return packages_.end(); }
 
+    auto layouts() const { return ranges::views::values(packages_); }
+
 private:
     fs::path root_;
 
diff --git a/include/cppship/cppship.h b/include/cppship/cppship.h
@@ -1,12 +1,12 @@
 #pragma once
 
-#include "cppship/cmd/bench.h"
-#include "cppship/cmd/build.h"
-#include "cppship/cmd/clean.h"
-#include "cppship/cmd/cmake.h"
-#include "cppship/cmd/fmt.h"
-#include "cppship/cmd/init.h"
-#include "cppship/cmd/install.h"
-#include "cppship/cmd/lint.h"
-#include "cppship/cmd/run.h"
-#include "cppship/cmd/test.h"
+#include "cppship/cmd/bench.h" // IWYU pragma: export
+#include "cppship/cmd/build.h" // IWYU pragma: export
+#include "cppship/cmd/clean.h" // IWYU pragma: export
+#include "cppship/cmd/cmake.h" // IWYU pragma: export
+#include "cppship/cmd/fmt.h" // IWYU pragma: export
+#include "cppship/cmd/init.h" // IWYU pragma: export
+#include "cppship/cmd/install.h" // IWYU pragma: export
+#include "cppship/cmd/lint.h" // IWYU pragma: export
+#include "cppship/cmd/run.h" // IWYU pragma: export
+#include "cppship/cmd/test.h" // IWYU pragma: export
diff --git a/lib/cmake/generator.cpp b/lib/cmake/generator.cpp
@@ -324,6 +324,7 @@ find_package(GTest REQUIRED)
         }
 
         mOut << fmt::format("add_test({} {})\n", target, target);
+        mOut << fmt::format("set_tests_properties({} PROPERTIES LABELS {})\n", target, mName);
 
         mTestTargets.emplace(target);
     }
diff --git a/lib/cmd/bench.cpp b/lib/cmd/bench.cpp
@@ -4,14 +4,14 @@
 
 #include <boost/process/system.hpp>
 #include <gsl/narrow>
+#include <range/v3/algorithm/all_of.hpp>
 #include <range/v3/range/conversion.hpp>
 #include <range/v3/view.hpp>
 #include <spdlog/spdlog.h>
 
 #include "cppship/cmake/msvc.h"
 #include "cppship/cmake/naming.h"
 #include "cppship/cmd/build.h"
-#include "cppship/core/manifest.h"
 #include "cppship/core/workspace.h"
 #include "cppship/util/fs.h"
 #include "cppship/util/log.h"
@@ -34,20 +34,19 @@ int run_one_bench(const cmd::BuildContext& ctx, const std::string_view bench)
 
 int cmd::run_bench(const BenchOptions& options)
 {
-    BuildContext ctx(options.profile);
-    Manifest manifest(ctx.metafile);
-
-    const auto& layout = enforce_default_package(ctx.workspace);
-
     NameTargetMapper mapper;
+
+    BuildContext ctx(options.profile);
     BuildOptions build_options { .profile = options.profile };
     if (options.target) {
-        if (!layout.bench(*options.target)) {
+        if (ranges::all_of(
+                ctx.workspace.layouts(), [&](const auto& layout) { return !layout.bench(*options.target); })) {
             throw Error { fmt::format("bench `{}` not found", *options.target) };
         }
 
-        build_options.target = mapper.bench(*options.target);
+        build_options.cmake_target = mapper.bench(*options.target);
     } else {
+        build_options.package = options.package;
         build_options.groups.insert(BuildGroup::benches);
     }
 
@@ -56,14 +55,16 @@ int cmd::run_bench(const BenchOptions& options)
         return EXIT_FAILURE;
     }
 
-    if (build_options.target) {
-        return run_one_bench(ctx, *build_options.target);
+    if (build_options.cmake_target) {
+        return run_one_bench(ctx, *build_options.cmake_target);
     }
 
-    for (const auto& bench : layout.benches()) {
-        const int res = run_one_bench(ctx, mapper.bench(bench.name));
-        if (res != 0) {
-            result = res;
+    for (const auto& layout : ctx.workspace.layouts()) {
+        for (const auto& bench : layout.benches()) {
+            const int res = run_one_bench(ctx, mapper.bench(bench.name));
+            if (res != 0) {
+                result = res;
+            }
         }
     }
 
diff --git a/lib/cmd/build.cpp b/lib/cmd/build.cpp
@@ -432,8 +432,8 @@ int cmd::cmake_build(const BuildContext& ctx, const BuildOptions& options, const
         ctx.profile_dir.string(),
         options.max_concurrency,
         to_string(options.profile));
-    if (options.target) {
-        cmd += fmt::format(" --target {}", *options.target);
+    if (options.cmake_target) {
+        cmd += fmt::format(" --target {}", *options.cmake_target);
     } else if (options.groups.empty()) {
         cmd += fmt::format(" --target {}", to_cmake_group(BuildGroup::binaries, ctx, options));
     } else {
diff --git a/lib/cmd/run.cpp b/lib/cmd/run.cpp
@@ -4,13 +4,15 @@
 
 #include <boost/process/system.hpp>
 #include <gsl/narrow>
+#include <range/v3/algorithm/none_of.hpp>
 #include <spdlog/spdlog.h>
 
 #include "cppship/cmake/msvc.h"
 #include "cppship/cmake/naming.h"
 #include "cppship/cmd/build.h"
 #include "cppship/core/layout.h"
 #include "cppship/core/manifest.h"
+#include "cppship/core/workspace.h"
 #include "cppship/util/cmd.h"
 #include "cppship/util/fs.h"
 #include "cppship/util/log.h"
@@ -20,59 +22,71 @@ using namespace cppship;
 
 namespace {
 
-void validate_options(const cmd::RunOptions& options)
+void validate_options(const cmd::BuildContext& ctx, const cmd::RunOptions& options)
 {
     if (options.bin && options.example) {
         throw Error { "should not specify --bin and --example in the same time" };
     }
+    if (options.package) {
+        if (ctx.manifest.get(*options.package) == nullptr) {
+            throw InvalidCmdOption("package", "invalid package specified by --package");
+        }
+    }
 }
 
-void validate_target(const Layout& layout, const cmd::RunOptions& opt)
+void validate_target(const Workspace& workspace, const cmd::RunOptions& opt)
 {
+    const auto layouts = workspace.layouts();
     if (const auto& bin = opt.bin) {
-        if (!layout.binary(*bin)) {
+        if (ranges::none_of(layouts, [&](const Layout& layout) { return layout.binary(*bin).has_value(); })) {
             throw Error { fmt::format("binary `{}` not found", *bin) };
         }
     } else if (const auto& example = opt.example) {
-        if (!layout.example(*example)) {
+        if (ranges::none_of(layouts, [&](const Layout& layout) { return layout.example(*example).has_value(); })) {
             throw Error { fmt::format("example `{}` not found", *example) };
         }
     }
 }
 
-std::string choose_binary(const cmd::RunOptions& options, const PackageManifest& manifest)
+std::optional<std::string> choose_binary(const cmd::RunOptions& options, const PackageManifest* manifest)
 {
     if (options.example) {
-        return *options.example;
+        return options.example;
     }
     if (options.bin) {
-        return *options.bin;
+        return options.bin;
+    }
+    if (options.package) {
+        return options.package;
+    }
+    if (manifest != nullptr) {
+        return std::make_optional<std::string>(manifest->name());
     }
 
-    return fmt::format("{}", manifest.name());
+    return std::nullopt;
 }
-
 }
 
 int cmd::run_run(const RunOptions& options)
 {
-    validate_options(options);
-
     BuildContext ctx(options.profile);
-    Manifest manifest(ctx.metafile);
-
-    const auto& layout = enforce_default_package(ctx.workspace);
-    validate_target(layout, options);
+    validate_options(ctx, options);
+    validate_target(ctx.workspace, options);
 
     cmake::NameTargetMapper mapper;
-    const auto bin = choose_binary(options, *manifest.get_if_package());
-    const auto target = options.example ? mapper.example(bin) : bin;
-    const int result = run_build({ .profile = options.profile, .target = target });
+    const auto bin = choose_binary(options, ctx.manifest.get_if_package());
+    if (!bin) {
+        warn("no target selected");
+        return EXIT_SUCCESS;
+    }
+
+    const auto target = options.example ? mapper.example(*bin) : *bin;
+    const int result = run_build({ .profile = options.profile, .cmake_target = target });
     if (result != 0) {
         return EXIT_FAILURE;
     }
 
-    const fs::path fixed_bin = msvc::fix_bin_path(ctx, bin);
+    const fs::path fixed_bin = msvc::fix_bin_path(ctx, *bin);
     const auto bin_file = options.example ? ctx.profile_dir / kExamplesPath / fixed_bin : ctx.profile_dir / fixed_bin;
     if (!has_cmd(bin_file.string())) {
         error("no binary to run: {}", bin_file.string());
diff --git a/lib/cmd/test.cpp b/lib/cmd/test.cpp
@@ -4,6 +4,7 @@
 
 #include <boost/process/system.hpp>
 #include <gsl/narrow>
+#include <range/v3/algorithm/all_of.hpp>
 #include <spdlog/spdlog.h>
 
 #include "cppship/cmake/naming.h"
@@ -14,20 +15,34 @@
 
 using namespace cppship;
 
+namespace {
+
+void valid_options(const cmd::TestOptions& options)
+{
+    if (options.target && options.name_regex) {
+        throw Error { "testname and -R should not be specified both" };
+    }
+}
+
+}
+
 int cmd::run_test(const TestOptions& options)
 {
+    valid_options(options);
+
     cmake::NameTargetMapper mapper;
-    BuildContext ctx(options.profile);
-    const auto& layout = enforce_default_package(ctx.workspace);
 
+    BuildContext ctx(options.profile);
     BuildOptions build_opts { .profile = options.profile };
     if (options.target && !options.rerun_failed) {
-        if (!layout.test(*options.target)) {
+        if (ranges::all_of(
+                ctx.workspace.layouts(), [&](const auto& layout) { return !layout.test(*options.target); })) {
             throw Error { fmt::format("test `{}` not found", *options.target) };
         }
 
-        build_opts.target = mapper.test(*options.target);
+        build_opts.cmake_target = mapper.test(*options.target);
     } else {
+        build_opts.package = options.package;
         build_opts.groups.insert(BuildGroup::tests);
     }
 
@@ -41,10 +56,15 @@ int cmd::run_test(const TestOptions& options)
     auto cmd = fmt::format("ctest --output-on-failure");
     if (options.rerun_failed) {
         cmd += " --rerun-failed";
-    } else if (build_opts.target) {
-        cmd += fmt::format(" -R '^{}$'", *build_opts.target);
+    } else if (build_opts.cmake_target) {
+        cmd += fmt::format(" -R '^{}$'", *build_opts.cmake_target);
     } else if (options.name_regex) {
         cmd += fmt::format(" -R {}", *options.name_regex);
+        if (options.package) {
+            cmd += fmt::format(" -L '^{}$'", *options.package);
+        }
+    } else if (options.package) {
+        cmd += fmt::format(" -L '^{}$'", *options.package);
     }
 
     status("test", "{}", cmd);
diff --git a/src/main.cpp b/src/main.cpp
@@ -149,7 +149,7 @@ std::list<SubCommand> build_commands(const ArgumentParser& common)
         .help("dry-run, generate compile_commands.json")
         .default_value(false)
         .implicit_value(true);
-    build.parser.add_argument("--package").help("package to build");
+    build.parser.add_argument("-p", "--package").help("package to build");
     build.parser.add_argument("--profile").help("build with specific profile").default_value(kProfileDebug);
     build.parser.add_argument("--examples").help("build all examples").default_value(false).implicit_value(true);
     build.parser.add_argument("--tests").help("build all tests").default_value(false).implicit_value(true);
@@ -200,6 +200,7 @@ std::list<SubCommand> build_commands(const ArgumentParser& common)
         return cmd::run_test({
             .profile = get_profile(cmd),
             .target = cmd.present("testname"),
+            .package = cmd.present("package"),
             .name_regex = cmd.present("-R"),
             .rerun_failed = cmd.get<bool>("--rerun-failed"),
         });
@@ -208,6 +209,7 @@ std::list<SubCommand> build_commands(const ArgumentParser& common)
     test.parser.add_description("run tests");
     test.parser.add_argument("-r").help("build in release mode").default_value(false).implicit_value(true);
     test.parser.add_argument("-R").help("run tests with name matches the regex").metavar("testregex");
+    test.parser.add_argument("-p", "--package").help("package to test");
     test.parser.add_argument("--profile")
         .help("build with specific profile")
         .metavar("profile")
@@ -223,10 +225,12 @@ std::list<SubCommand> build_commands(const ArgumentParser& common)
         return cmd::run_bench({
             .profile = parse_profile(cmd.get("--profile")),
             .target = cmd.present("benchname"),
+            .package = cmd.present("package"),
         });
     });
 
     bench.parser.add_description("run benches");
+    bench.parser.add_argument("-p", "--package").help("package to bench");
     bench.parser.add_argument("--profile")
         .help("build with specific profile")
         .metavar("profile")
diff --git a/tests/cmd/build.cpp b/tests/cmd/build.cpp

Original file line number	Diff line number	Diff line change
`@@ -324,6 +324,7 @@ find_package(GTest REQUIRED)`
`324`	`324`	`}`
`325`	`325`
`326`	`326`	`mOut << fmt::format("add_test({} {})\n", target, target);`
	`327`	`+ mOut << fmt::format("set_tests_properties({} PROPERTIES LABELS {})\n", target, mName);`
`327`	`328`
`328`	`329`	`mTestTargets.emplace(target);`
`329`	`330`	`}`