From d7fade5f4c0e0c2021e68f8628e8efce3f4b6892 Mon Sep 17 00:00:00 2001 From: sawinglogz <3787776-sawinglogz@users.noreply.gitlab.com> Date: Wed, 15 Jan 2020 17:00:21 -0500 Subject: [PATCH] Add Version class for Semantic Versioning 2.0.0 parsing and comparison. Also add unit tests for the new class. --- oscar/oscar.pro | 6 +- oscar/tests/versiontests.cpp | 44 +++++++++++++ oscar/tests/versiontests.h | 18 +++++ oscar/version.cpp | 123 +++++++++++++++++++++++++++++++++++ oscar/version.h | 28 ++++++++ 5 files changed, 217 insertions(+), 2 deletions(-) create mode 100644 oscar/tests/versiontests.cpp create mode 100644 oscar/tests/versiontests.h diff --git a/oscar/oscar.pro b/oscar/oscar.pro index 55c3aaf8..39cddc0d 100644 --- a/oscar/oscar.pro +++ b/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 { diff --git a/oscar/tests/versiontests.cpp b/oscar/tests/versiontests.cpp new file mode 100644 index 00000000..228e2cfc --- /dev/null +++ b/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")); +} diff --git a/oscar/tests/versiontests.h b/oscar/tests/versiontests.h new file mode 100644 index 00000000..fb230083 --- /dev/null +++ b/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) diff --git a/oscar/version.cpp b/oscar/version.cpp index 979a318f..933188b5 100644 --- a/oscar/version.cpp +++ b/oscar/version.cpp @@ -10,12 +10,16 @@ #include "git_info.h" #include "SleepLib/common.h" +#include + 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"(^(?P0|[1-9]\d*)\.(?P0|[1-9]\d*)\.(?P0|[1-9]\d*)(?:-(?P(?: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[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; +} diff --git a/oscar/version.h b/oscar/version.h index 354c1b9b..8f4fb929 100644 --- a/oscar/version.h +++ b/oscar/version.h @@ -12,6 +12,34 @@ #include +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);