diff options
author | Karen Arutyunov <karen@codesynthesis.com> | 2020-06-24 22:12:01 +0300 |
---|---|---|
committer | Karen Arutyunov <karen@codesynthesis.com> | 2020-06-26 15:29:44 +0300 |
commit | 58357d79110a925dcb3cdc734d812f17b6465c17 (patch) | |
tree | 2b5f4714e038f1b0cefcca64b427e6ae9772833f /bpkg/package.hxx | |
parent | 86700536f5ca500c4a837d03626f672dcfdbb97d (diff) |
Fix build order for test and main packages
Diffstat (limited to 'bpkg/package.hxx')
-rw-r--r-- | bpkg/package.hxx | 132 |
1 files changed, 124 insertions, 8 deletions
diff --git a/bpkg/package.hxx b/bpkg/package.hxx index 8987069..f10e670 100644 --- a/bpkg/package.hxx +++ b/bpkg/package.hxx @@ -27,7 +27,7 @@ // #define DB_SCHEMA_VERSION_BASE 5 -#pragma db model version(DB_SCHEMA_VERSION_BASE, 6, closed) +#pragma db model version(DB_SCHEMA_VERSION_BASE, 7, closed) namespace bpkg { @@ -446,7 +446,61 @@ namespace bpkg #pragma db member(dependency::constraint) column("") #pragma db value(dependency_alternatives) definition - using dependencies = vector<dependency_alternatives>; + // Extend dependency_alternatives to also represent the special test + // dependencies of the test packages to the main packages, produced by + // inverting the main packages external test dependencies (specified with + // the tests, etc., manifest values). + // + #pragma db value + class dependency_alternatives_ex: public dependency_alternatives + { + public: + optional<test_dependency_type> type; + + dependency_alternatives_ex () = default; + + // Create the regular dependency alternatives object. + // + dependency_alternatives_ex (dependency_alternatives da) + : dependency_alternatives (move (da)) {} + + // Create the special test dependencies object (built incrementally). + // + dependency_alternatives_ex (test_dependency_type t) + : dependency_alternatives (false /* conditional */, + false /* buildtime */, + "" /* comment */), + type (t) {} + }; + + using dependencies = vector<dependency_alternatives_ex>; + + // Convert the regular dependency alternatives list (normally comes from a + // package manifest) to the extended version of it (see above). + // + inline dependencies + convert (vector<dependency_alternatives>&& das) + { + return dependencies (make_move_iterator (das.begin ()), + make_move_iterator (das.end ())); + } + + // tests + // + #pragma db value(test_dependency) definition + + using optional_test_dependency_type = optional<test_dependency_type>; + + #pragma db map type(test_dependency_type) as(string) \ + to(to_string (?)) \ + from(bpkg::to_test_dependency_type (?)) + + #pragma db map type(optional_test_dependency_type) \ + as(bpkg::optional_string) \ + to((?) ? to_string (*(?)) : bpkg::optional_string ()) \ + from((?) \ + ? bpkg::to_test_dependency_type (*(?)) \ + : bpkg::optional_test_dependency_type ()) // Wildcard version. Satisfies any version constraint and is represented as // 0+0 (which is also the "stub version"; since a real version is always @@ -498,12 +552,17 @@ namespace bpkg // small_vector<package_location, 1> locations; - // Package manifest data. + // Package manifest data and, potentially, the special test dependencies. + // + // Note that there can be only one special test dependencies entry in the + // list and it's always the last one, if present. // using dependencies_type = bpkg::dependencies; dependencies_type dependencies; + small_vector<test_dependency, 1> tests; + // Present for non-transient objects only (and only for certain repository // types). // @@ -519,7 +578,8 @@ namespace bpkg available_package (package_manifest&& m) : id (move (m.name), m.version), version (move (m.version)), - dependencies (move (m.dependencies)), + dependencies (convert (move (m.dependencies))), + tests (move (m.tests)), sha256sum (move (m.sha256sum)) {} // Create available stub package. @@ -596,8 +656,8 @@ namespace bpkg // dependencies // - using _dependency_key = odb::nested_key<dependency_alternatives>; - using _dependency_alternatives_type = + using _dependency_key = odb::nested_key<dependency_alternatives_ex>; + using _dependency_alternatives_ex_type = std::map<_dependency_key, dependency>; #pragma db value(_dependency_key) @@ -605,13 +665,18 @@ namespace bpkg #pragma db member(_dependency_key::inner) column("index") #pragma db member(dependencies) id_column("") value_column("") - #pragma db member(dependency_alternatives) \ - virtual(_dependency_alternatives_type) \ + #pragma db member(dependency_alternatives_ex) \ + table("available_package_dependency_alternatives") \ + virtual(_dependency_alternatives_ex_type) \ after(dependencies) \ get(odb::nested_get (this.dependencies)) \ set(odb::nested_set (this.dependencies, std::move (?))) \ id_column("") key_column("") value_column("dep_") + // tests + // + #pragma db member(tests) id_column("") value_column("test_") + private: friend class odb::access; available_package () = default; @@ -626,6 +691,57 @@ namespace bpkg operator size_t () const {return result;} }; + // Return the list of available test packages, that is, that are referred to + // as external tests by some main package(s). + // + // Note that there can be only one test dependency row per package, so the + // DISTINCT clause is not required. + // + #pragma db view object(available_package = package) \ + table("available_package_dependencies" = "pd" inner: \ + "pd.type IN ('tests', 'examples', 'benchmarks') AND " \ + "pd.name = " + package::id.name + "AND" + \ + "pd.version_epoch = " + package::id.version.epoch + "AND" + \ + "pd.version_canonical_upstream = " + \ + package::id.version.canonical_upstream + "AND" + \ + "pd.version_canonical_release = " + \ + package::id.version.canonical_release + "AND" + \ + "pd.version_revision = " + package::id.version.revision + "AND" + \ + "pd.version_iteration = " + package::id.version.iteration) + struct available_test + { + shared_ptr<available_package> package; + }; + + // Return the list of available main packages, that is, that refer to some + // external test packages. + // + #pragma db view object(available_package = package) \ + table("available_package_tests" = "pt" inner: \ + "pt.name = " + package::id.name + "AND" + \ + "pt.version_epoch = " + package::id.version.epoch + "AND" + \ + "pt.version_canonical_upstream = " + \ + package::id.version.canonical_upstream + "AND" + \ + "pt.version_canonical_release = " + \ + package::id.version.canonical_release + "AND" + \ + "pt.version_revision = " + package::id.version.revision + "AND" + \ + "pt.version_iteration = " + package::id.version.iteration) \ + query(distinct) + struct available_main + { + shared_ptr<available_package> package; + }; + + // Query the available packages that optionally satisfy the specified + // version constraint and return them in the version descending order, by + // default. Note that a stub satisfies any constraint. + // + odb::result<available_package> + query_available (database&, + const package_name&, + const optional<version_constraint>&, + bool order = true); + // Only return packages that are in the specified repository fragments, their // complements or prerequisites (if prereq is true), recursively. While you // could maybe come up with a (barely comprehensible) view/query to achieve |