diff options
Diffstat (limited to 'libbutl')
| -rw-r--r-- | libbutl/.gitignore | 1 | ||||
| -rw-r--r-- | libbutl/buildfile | 7 | ||||
| -rw-r--r-- | libbutl/standard-version.bash.in | 46 | ||||
| -rw-r--r-- | libbutl/standard-version.cxx | 127 |
4 files changed, 180 insertions, 1 deletions
diff --git a/libbutl/.gitignore b/libbutl/.gitignore index 6b2eb75..02399ae 100644 --- a/libbutl/.gitignore +++ b/libbutl/.gitignore @@ -1 +1,2 @@ manifest +standard-version diff --git a/libbutl/buildfile b/libbutl/buildfile index 8039035..135733c 100644 --- a/libbutl/buildfile +++ b/libbutl/buildfile @@ -9,7 +9,12 @@ bash{utility}: in{utility} bash{manifest-parser}: in{manifest-parser} bash{utility} exe{manifest} bash{manifest-serializer}: in{manifest-serializer} bash{utility} exe{manifest} -exe{manifest}: cxx{manifest} $libs +bash{standard-version}: in{standard-version} \ + bash{utility} \ + exe{standard-version} + +exe{manifest}: cxx{manifest} $libs +exe{standard-version}: cxx{standard-version} $libs # Install our binding support executables next to the modules. # diff --git a/libbutl/standard-version.bash.in b/libbutl/standard-version.bash.in new file mode 100644 index 0000000..20215d9 --- /dev/null +++ b/libbutl/standard-version.bash.in @@ -0,0 +1,46 @@ +# file : libbutl/standard-version.bash.in +# license : MIT; see accompanying LICENSE file + +if [ "$butl_standard_version" ]; then + return 0 +else + butl_standard_version=true +fi + +@import libbutl/utility@ + +# Check that the specified predicates are true for a standard version. +# +# Parse the standard version and exit with code 0 if all the specified +# predicates are true and code 1 otherwise. If the specified argument is not a +# valid standard version, then print the error description to stderr, unless +# --is-version option is specified, and exit with code 2. For other errors +# (usage, etc), issue diagnostics and exit with code 3. +# +# Options in the --is-[not-]<predicate> form enable the standard version +# predicate checks. The recognized predicates are: +# +# snapshot +# latest-snapshot +# alpha +# beta +# pre-release +# release +# final +# stub +# earliest +# +# Note that specifying opposite predicates (for example, --is-beta and +# --is-not-beta) is not a usage error and results in exit code 1. See +# libbutl/standard-version.mxx for the predicates semantics. +# +# Other options: +# +# --is-version +# +# Don't issue diagnostics if the argument is not a valid standard version. +# +function butl_standard_version () # [<options>] <standard-version> +{ + "$(butl_path)/standard-version" "$@" +} diff --git a/libbutl/standard-version.cxx b/libbutl/standard-version.cxx new file mode 100644 index 0000000..36e79fb --- /dev/null +++ b/libbutl/standard-version.cxx @@ -0,0 +1,127 @@ +// file : libbutl/standard-version.cxx +// license : MIT; see accompanying LICENSE file + +#include <string> +#include <cstddef> // size_t +#include <iostream> +#include <stdexcept> // invalid_argument + +#include <libbutl/utility.mxx> // operator<<(ostream,exception) +#include <libbutl/optional.mxx> +#include <libbutl/standard-version.mxx> + +using namespace std; +using namespace butl; + +// Usage: argv[0] [<options>] <standard-version> +// +// Check that the specified predicates are true for a standard version. +// +// See standard-version.bash.in for the functionality and options description. +// +int +main (int argc, char* argv[]) +{ + using butl::optional; + + // We could probably try to parse the last argument as a version first and + // then evaluate the predicates while parsing the options. This, however + // would worsen the diagnostics (think about the `standard-version --beta` + // command) and would complicate things a bit, since at the time of the + // version parsing we wouldn't know if to print the diagnostics for an + // invalid version. Thus, we will parse the arguments in the direct order. + // + optional<bool> snapshot; + optional<bool> latest_sn; + optional<bool> alpha; + optional<bool> beta; + optional<bool> pre_release; + optional<bool> release; + optional<bool> final; + optional<bool> stub; + optional<bool> earliest; + + bool valid (false); // --is-version is specified. + bool opposite (false); // Opposite predicates are specified simultaneously + // (i.e. --is-beta and --is-not-beta). + + int i (1); + for (; i != argc; ++i) + { + string op (argv[i]); + + bool is; + size_t n; + + if (op.compare (0, (n = 9), "--is-not-") == 0) is = false; + else if (op.compare (0, (n = 5), "--is-") == 0) is = true; + else break; + + string p (op, n); + + // Set the predicate expected value. If the opposite value have already + // been specified, then save this information to exit with code 1 later + // (note that we still need to validate the rest of the arguments). + // + auto set = [is, &opposite] (optional<bool>& v) + { + if (!v) + v = is; + else if (*v != is) + opposite = true; + }; + + if (p == "snapshot") set (snapshot); + else if (p == "latest-snapshot") set (latest_sn); + else if (p == "alpha") set (alpha); + else if (p == "beta") set (beta); + else if (p == "pre-release") set (pre_release); + else if (p == "release") set (release); + else if (p == "final") set (final); + else if (p == "stub") set (stub); + else if (p == "earliest") set (earliest); + else if (p == "version" && is) valid = true; + else break; + } + + if (i == argc) + { + cerr << "error: missing version" << endl; + return 3; + } + + string a (argv[i++]); + + if (i != argc) + { + cerr << "error: unexpected argument '" << argv[i] << "'" << endl; + return 3; + } + + try + { + standard_version v (a, + (standard_version::allow_earliest | + standard_version::allow_stub)); + + return !opposite && + (!snapshot || *snapshot == v.snapshot()) && + (!latest_sn || *latest_sn == v.latest_snapshot ()) && + (!alpha || *alpha == v.alpha ().has_value ()) && + (!beta || *beta == v.beta ().has_value ()) && + (!pre_release || *pre_release == v.pre_release ().has_value ()) && + (!release || *release == v.release ()) && + (!final || *final == v.final ()) && + (!stub || *stub == v.stub ()) && + (!earliest || *earliest == v.earliest ()) + ? 0 + : 1; + } + catch (const invalid_argument& e) + { + if (!valid) + cerr << "error: " << e << endl; + + return 2; + } +} |