Add standard-version utility

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;
+  }
+}