Add Version class for Semantic Versioning 2.0.0 parsing and comparison.

Also add unit tests for the new class.

oscar/oscar.pro

@@ -501,13 +501,15 @@ test {
     SOURCES += \
         tests/prs1tests.cpp \
         tests/resmedtests.cpp \
-        tests/sessiontests.cpp
+        tests/sessiontests.cpp \
+        tests/versiontests.cpp
 
     HEADERS += \
         tests/AutoTest.h \
         tests/prs1tests.h \
         tests/resmedtests.h \
-        tests/sessiontests.h
+        tests/sessiontests.h \
+        tests/versiontests.h
 }
 
 macx {

oscar/tests/versiontests.cpp

@@ -0,0 +1,44 @@
+/* Version Unit Tests
+ *
+ * Copyright (c) 2020 The OSCAR Team
+ *
+ * This file is subject to the terms and conditions of the GNU General Public
+ * License. See the file COPYING in the main directory of the source code
+ * for more details. */
+
+#include "versiontests.h"
+#include "version.h"
+
+void VersionTests::testCurrentVersion()
+{
+    qDebug() << getVersion();
+
+    // If this fails, it means that the defined VERSION isn't valid and needs fixing!
+    Q_ASSERT(getVersion().IsValid());
+}
+
+void VersionTests::testPrecedence()
+{
+    // This is the list of precedence examples from the Semantic Version documentation:
+    Q_ASSERT(Version("1.0.0-alpha") < Version("1.0.0-alpha.1"));
+    Q_ASSERT(Version("1.0.0-alpha.1") < Version("1.0.0-alpha.beta"));
+    Q_ASSERT(Version("1.0.0-alpha.beta") < Version("1.0.0-beta"));
+    Q_ASSERT(Version("1.0.0-beta") < Version("1.0.0-beta.2"));
+    Q_ASSERT(Version("1.0.0-beta.2") < Version("1.0.0-beta.11"));
+    Q_ASSERT(Version("1.0.0-beta.11") < Version("1.0.0-rc.1"));
+    Q_ASSERT(Version("1.0.0-rc.1") < Version("1.0.0"));
+    
+    Q_ASSERT(Version("1.0.0-alpha+001") == Version("1.0.0-alpha+002"));
+    Q_ASSERT(Version("1.0.0+20130313144700") == Version("1.0.0+20200313144700"));
+    Q_ASSERT(Version("1.0.0-beta+exp.sha.5114f85") == Version("1.0.0-beta+exp.sha.00000000"));
+
+    // This is the list of precedence that we expect to work correctly as of 1.1.0:
+    Q_ASSERT(Version("1.0.1-r1") < Version("1.1.0-testing-1"));
+    Q_ASSERT(Version("1.1.0-testing-1") < Version("1.1.0-testing-4"));
+    Q_ASSERT(Version("1.1.0-testing-4") < Version("1.1.0-beta-1"));
+    Q_ASSERT(Version("1.1.0-beta-1") < Version("1.1.0-beta-2"));
+    Q_ASSERT(Version("1.1.0-beta-2") < Version("1.1.0-rc.1"));
+    Q_ASSERT(Version("1.1.0-rc.1") < Version("1.1.0-rc.2"));
+    Q_ASSERT(Version("1.1.0-rc.2") < Version("1.1.0"));
+    Q_ASSERT(Version("1.1.0-rc.2") < Version("1.2.0"));
+}

oscar/tests/versiontests.h

@@ -0,0 +1,18 @@
+/* Version Unit Tests
+ *
+ * Copyright (c) 2020 The OSCAR Team
+ *
+ * This file is subject to the terms and conditions of the GNU General Public
+ * License. See the file COPYING in the main directory of the source code
+ * for more details. */
+
+#include "tests/AutoTest.h"
+
+class VersionTests : public QObject
+{
+    Q_OBJECT
+private slots:
+    void testCurrentVersion();
+    void testPrecedence();
+};
+DECLARE_TEST(VersionTests)

oscar/version.cpp

@@ -10,12 +10,16 @@
 #include "git_info.h"
 #include "SleepLib/common.h"
 
+#include <QRegularExpression>
+
 const int major_version = 1;   // incompatible API changes
 const int minor_version = 1;   // new features that don't break things
 const int revision_number = 0; // bugfixes, revisions
 const QString ReleaseStatus = "beta"; // testing/nightly/unstable, beta/untamed, rc/almost, r/stable
 #include "build_number.h"
 
+#define VERSION "1.1.0-beta-1"
+
 const QString VersionString = QString("%1.%2.%3-%4-%5").arg(major_version).arg(minor_version).arg(revision_number).arg(ReleaseStatus).arg(build_number);
 const QString ShortVersionString = QString("%1.%2.%3").arg(major_version).arg(minor_version).arg(revision_number);
 
@@ -224,3 +228,122 @@ bool isReleaseVersion()
 {
     return (ReleaseStatus == "r");
 }
+
+
+static const Version s_Version(VERSION);
+const Version & getVersion()
+{
+    return s_Version;
+}
+
+Version::Version(const QString & version_string) : mString(version_string), mIsValid(false)
+{
+    ParseSemanticVersion();
+    FixLegacyVersions();
+}
+
+Version::operator const QString &() const
+{
+    return mString;
+}
+
+// Parse a version string as specified by Semantic Versioning 2.0.0, see https://semver.org/spec/v2.0.0.html
+void Version::ParseSemanticVersion()
+{
+    // Use a C++11 raw string literal to keep the regular expression (mostly) legible.
+    static const QRegularExpression re(R"(^(?P<major>0|[1-9]\d*)\.(?P<minor>0|[1-9]\d*)\.(?P<patch>0|[1-9]\d*)(?:-(?P<prerelease>(?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*)(?:\.(?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*))*))?(?:\+(?P<buildmetadata>[0-9a-zA-Z-]+(?:\.[0-9a-zA-Z-]+)*))?$)");
+    QRegularExpressionMatch match = re.match(mString);
+    while (match.hasMatch()) {
+        bool ok;
+
+        mMajor = match.captured("major").toInt(&ok);
+        if (!ok) break;
+        mMinor = match.captured("minor").toInt(&ok);
+        if (!ok) break;
+        mPatch = match.captured("patch").toInt(&ok);
+        if (!ok) break;
+        mPrerelease = match.captured("prerelease");
+        mBuild = match.captured("buildmetadata");
+        mIsValid = true;
+        break;
+    }
+}
+
+// Deal with non-Semantic-Versioning numbers used before 1.1.0-beta-2 to make sure they
+// will have proper (lower) precedence compared to later versions.
+//
+// TODO: THIS CAN PROBABLY BE REMOVED AFTER THE RELEASE OF 1.1.0, since the release
+// version will take precedence over all 1.1.0 prereleases, as well as 1.0.1 of any
+// release status.
+//
+// Right now we just need to make sure that 1.1.0-beta versions take precedence over
+// 1.1.0-testing.
+void Version::FixLegacyVersions()
+{
+    if (mIsValid) {
+        // Replace prerelease "testing" with "alpha" for backwards compatibility with 1.1.0-testing-*
+        // versions: otherwise "testing" would take precedence over "beta".
+        mPrerelease.replace("testing", "alpha");
+
+        // Technically the use of "r1" in "1.0.1-r1" could also be corrected, as the code
+        // will incorrectly consider that release version to be a prerelease, but it doesn't
+        // matter because 1.1.0 and later will take precedence either way.
+    }
+}
+
+// Compare two version instances in accordance with Semantic Versionin 2.0.0 precedence rules.
+int Version::Compare(const Version & a, const Version & b)
+{
+    int diff;
+    
+    diff = a.mMajor - b.mMajor;
+    if (diff) return diff;
+
+    diff = a.mMinor - b.mMinor;
+    if (diff) return diff;
+
+    diff = a.mPatch - b.mPatch;
+    if (diff) return diff;
+
+    // Version numbers are equal, now check prerelease status:
+
+    if (a.IsReleaseVersion() && b.IsReleaseVersion()) return 0;
+
+    // A pre-release version has lower prededence than a release version.
+    diff = a.IsReleaseVersion() - b.IsReleaseVersion();
+    if (diff) return diff;
+
+    // Both are prerelease versions, compare them:
+
+    // The prerelease version may contain a series of dot-separated identifiers,
+    // each of which is compared.
+    QStringList ap = a.mPrerelease.split(".");
+    QStringList bp = b.mPrerelease.split(".");
+    int max = qMin(ap.size(), bp.size());
+    for (int i = 0; i < max; i++) {
+        bool a_is_num, b_is_num;
+        int ai = ap[i].toInt(&a_is_num);
+        int bi = bp[i].toInt(&b_is_num);
+
+        // Numeric identifiers always have lower precedence than non-numeric.
+        diff = b_is_num - a_is_num;
+        if (diff) return diff;
+        
+        if (a_is_num) {
+            // Numeric identifiers are compared numerically.
+            diff = ai - bi;
+            if (diff) return diff;
+        } else {
+            // Non-numeric identifiers are compared lexically.
+            diff = ap[i].compare(bp[i]);
+            if (diff) return diff;
+        }
+    }
+
+    // A larger set of pre-release fields has higher precedence (if the above were equal).
+    diff = ap.size() - bp.size();
+
+    // We ignore build metadata in comparing semantic versions.
+
+    return diff;
+}

oscar/version.h

@@ -12,6 +12,34 @@
 
 #include <QString>
 
+class Version
+{
+    friend class VersionTests;
+public:
+    Version(const QString & version_string);
+    operator const QString &() const;
+    bool IsReleaseVersion() const { return mPrerelease.isEmpty(); }
+    bool IsValid() const { return mIsValid; }
+    bool operator==(const Version & b) const { return Compare(*this, b) == 0; }
+    bool operator<(const Version & b) const { return Compare(*this, b) < 0; }
+    bool operator>(const Version & b) const { return Compare(*this, b) > 0; }
+
+protected:
+    const QString mString;
+    bool mIsValid;
+    
+    int mMajor, mMinor, mPatch;
+    QString mPrerelease, mBuild;
+    
+    void ParseSemanticVersion();
+    void FixLegacyVersions();
+    static int Compare(const Version & a, const Version & b);
+};
+
+//!brief Get the current version of the application
+const Version & getVersion();
+
+
 extern const QString VersionString;
 
 int compareVersion(const QString & version);