Versioning: use MAJOR.YYYYMMDD.PATCH.

Author: agarny

CMakeLists.txt

@@ -24,12 +24,12 @@ endforeach()
 
 # Project details.
 
-string(TIMESTAMP CURRENT_YEAR "%Y")
-string(TIMESTAMP CURRENT_MONTH "%m")
-string(TIMESTAMP CURRENT_DAY "%d")
+string(TIMESTAMP YEAR "%Y")
+string(TIMESTAMP MONTH "%m")
+string(TIMESTAMP DAY "%d")
 
 project(libOpenCOR
-        VERSION "${CURRENT_YEAR}.${CURRENT_MONTH}.${CURRENT_DAY}")
+        VERSION "0.${YEAR}${MONTH}${DAY}.0")
 
 string(TOLOWER "${CMAKE_PROJECT_NAME}" CMAKE_PROJECT_NAME_LC)
 

cmake/packaging/CMakeLists.txt

@@ -81,7 +81,7 @@ if(WIN32)
     endif()
 endif()
 
-set(CPACK_PACKAGE_FILE_NAME ${CPACK_PACKAGE_NAME}-${PROJECT_VERSION_MAJOR}.${PROJECT_VERSION_MINOR}.${PROJECT_VERSION_PATCH}${CPACK_SYSTEM_NAME}${LIBRARY_ARCHITECTURE}${LIBRARY_TYPE}${LIBRARY_MODE})
+set(CPACK_PACKAGE_FILE_NAME ${CPACK_PACKAGE_NAME}-${PROJECT_VERSION}${CPACK_SYSTEM_NAME}${LIBRARY_ARCHITECTURE}${LIBRARY_TYPE}${LIBRARY_MODE})
 
 # Package libOpenCOR.
 

setup.py

@@ -23,7 +23,7 @@
 
 setup(
     name="libopencor",
-    version=f"{year}.{month:02}.{day:02}",
+    version=f"0.{year}{month:02}{day:02}.0",
     description="libOpenCOR is the backend library to OpenCOR, a cross-platform modelling environment, which can be used to organise, edit, simulate and analyse CellML files.",
     author="libOpenCOR contributors",
     url="https://opencor.ws/libopencor/",

src/CMakeLists.txt

@@ -59,7 +59,15 @@ endif()
 
 # Configure the version file.
 
-set(LIBOPENCOR_VERSION 0x${PROJECT_VERSION_MAJOR}${PROJECT_VERSION_MINOR}${PROJECT_VERSION_PATCH})
+foreach(VERSION_PART PROJECT_VERSION_MAJOR PROJECT_VERSION_PATCH)
+    string(LENGTH ${${VERSION_PART}} VERSION_PART_LENGTH)
+
+    if(VERSION_PART_LENGTH EQUAL 1)
+        set(${VERSION_PART}_PAD 0)
+    endif()
+endforeach()
+
+set(LIBOPENCOR_VERSION 0x${PROJECT_VERSION_MAJOR_PAD}${PROJECT_VERSION_MAJOR}${PROJECT_VERSION_MINOR}${PROJECT_VERSION_PATCH_PAD}${PROJECT_VERSION_PATCH})
 set(LIBOPENCOR_VERSION_STRING ${PROJECT_VERSION})
 
 set(VERSION_HEADER_FILE_IN ${CMAKE_CURRENT_SOURCE_DIR}/version.h.in)
@@ -291,7 +299,7 @@ if(EMSCRIPTEN)
 
     # Create a .tgz file for our generated .js file that can be used to distribute our JavaScript bindings.
 
-    set(TGZ_FILE ${CMAKE_BINARY_DIR}/../../../../${REAL_CMAKE_PROJECT_NAME}-${PROJECT_VERSION_MAJOR}.${PROJECT_VERSION_MINOR}.${PROJECT_VERSION_PATCH}.tgz)
+    set(TGZ_FILE ${CMAKE_BINARY_DIR}/../../../../${REAL_CMAKE_PROJECT_NAME}-${PROJECT_VERSION}.tgz)
 
     add_custom_command(TARGET ${CMAKE_PROJECT_NAME} POST_BUILD
                        COMMAND ${CMAKE_COMMAND} -E make_directory package
@@ -377,7 +385,6 @@ else()
                           CXX_VISIBILITY_PRESET hidden
                           DEBUG_POSTFIX d
                           PREFIX ""
-                          VERSION ${PROJECT_VERSION}
                           VISIBILITY_INLINES_HIDDEN ON)
 endif()
 

src/api/libopencor/version.h

@@ -30,7 +30,7 @@ namespace libOpenCOR {
  * @return A number that represents the version of libOpenCOR.
  */
 
-unsigned int LIBOPENCOR_EXPORT version();
+uint64_t LIBOPENCOR_EXPORT version();
 
 /**
  * Return the version of libOpenCOR as a string. The version string is in the format x.y.z, where the "."s are literal,

src/version.cpp

@@ -74,7 +74,7 @@ unsigned int secondDigit(unsigned int pTwoDigitNumber)
     return pTwoDigitNumber % TEN;
 }
 
-unsigned int version()
+uint64_t version()
 {
     return LIBOPENCOR_VERSION;
 }

src/version.h.in

@@ -19,7 +19,7 @@ limitations under the License.
 namespace libOpenCOR {
 
 // clang-format off
-static constexpr unsigned int LIBOPENCOR_VERSION = @LIBOPENCOR_VERSION@;
+static constexpr auto LIBOPENCOR_VERSION = @LIBOPENCOR_VERSION@;
 // clang-format on
 static constexpr auto LIBOPENCOR_VERSION_STRING = "@LIBOPENCOR_VERSION_STRING@";
 

tests/api/version/tests.cpp

@@ -22,41 +22,51 @@ limitations under the License.
 
 TEST(VersionTest, libOpenCOR)
 {
-    static const int NINETEEN_HUNDRED = 1900;
-    static const int ONE = 1;
+    static const auto VERSION_MAJOR = 0;
+    static const auto VERSION_PATCH = 0;
 
-    auto now = std::chrono::system_clock::now();
-    auto now_time_t = std::chrono::system_clock::to_time_t(now);
-    std::tm local_tm {};
+    auto now = std::chrono::system_clock::to_time_t(std::chrono::system_clock::now());
+    std::tm tm {};
 
 #ifdef BUILDING_ON_WINDOWS
-    localtime_s(&local_tm, &now_time_t); // NOLINT
+    localtime_s(&tm, &now); // NOLINT
 #else
-    localtime_r(&now_time_t, &local_tm); // NOLINT
+    localtime_r(&now, &tm); // NOLINT
 #endif
 
-    auto year = NINETEEN_HUNDRED + local_tm.tm_year;
-    auto month = ONE + local_tm.tm_mon;
-    auto day = local_tm.tm_mday;
+    static const auto NINETEEN_HUNDRED = 1900;
+    static const auto ONE = 1;
 
-    static const int TEN_THOUSAND = 10000;
-    static const int HUNDRED = 100;
-    static const int TEN = 10;
+    const auto year = NINETEEN_HUNDRED + tm.tm_year;
+    const auto month = ONE + tm.tm_mon;
+    const auto day = tm.tm_mday;
 
-    int version = 0;
-    int number = TEN_THOUSAND * year + HUNDRED * month + day;
+    static const uint64_t TEN_BILLION = 10000000000;
+    static const uint64_t TEN_THOUSAND = 10000;
+    static const uint64_t HUNDRED = 100;
+    static const uint64_t TEN = 10;
+
+    uint64_t version = 0;
+    auto number = TEN_BILLION * VERSION_MAJOR + HUNDRED * (TEN_THOUSAND * static_cast<uint64_t>(year) + HUNDRED * static_cast<uint64_t>(month) + static_cast<uint64_t>(day)) + VERSION_PATCH;
 
     for (int i = 0; number != 0; i += 4) {
         version |= (number % TEN) << i; // NOLINT
         number /= TEN;
     }
 
-    static const size_t VERSION_STRING_SIZE = 11;
+    static const size_t VERSION_STRING_SIZE = 15;
 
     std::array<char, VERSION_STRING_SIZE> versionString {};
 
-    EXPECT_EQ(std::snprintf(versionString.data(), VERSION_STRING_SIZE, "%d.%02d.%02d", year, month, day), VERSION_STRING_SIZE - 1); // NOLINT
+#ifdef BUILDING_USING_GNU
+#    pragma GCC diagnostic push
+#    pragma GCC diagnostic ignored "-Wformat-truncation"
+#endif
+    std::snprintf(versionString.data(), VERSION_STRING_SIZE, "%d.%d%02d%02d.%d", VERSION_MAJOR, year, month, day, VERSION_PATCH); // NOLINT
     // Note: ideally, we would be using std::format(), but it is not available on some of the CI systems we are using.
+#ifdef BUILDING_USING_GNU
+#    pragma GCC diagnostic pop
+#endif
 
     EXPECT_EQ(version, libOpenCOR::version());
     EXPECT_EQ(versionString.data(), libOpenCOR::versionString());

tests/bindings/javascript/version.test.js

@@ -20,24 +20,34 @@ const libopencor = await libOpenCOR();
 
 describe("Version tests", () => {
   test("libOpenCOR", () => {
+    const version_major = 0;
+    const version_patch = 0;
+
     const now = new Date();
     const year = now.getFullYear();
     const month = now.getMonth() + 1;
     const day = now.getDate();
 
-    let version = 0;
-    let number = 10000 * year + 100 * month + day;
-    let i = 0;
+    let version = BigInt(0);
+    let number = BigInt(
+      10000000000 * version_major +
+        100 * (10000 * year + 100 * month + day) +
+        version_patch,
+    );
+    let i = BigInt(0);
+
+    const ten = BigInt(10);
+    const four = BigInt(4);
 
     while (number != 0) {
-      version |= number % 10 << i;
-      number = Math.floor(number / 10);
-      i += 4;
+      version |= number % ten << i;
+      number /= ten;
+      i += four;
     }
 
     expect(libopencor.version()).toBe(version);
     expect(libopencor.versionString()).toBe(
-      `${year}.${String(month).padStart(2, "0")}.${String(day).padStart(2, "0")}`,
+      `${version_major}.${year}${String(month).padStart(2, "0")}${String(day).padStart(2, "0")}.${version_patch}`,
     );
   });
 

tests/bindings/python/test_version.py

@@ -17,12 +17,22 @@
 import libopencor as oc
 
 
+version_major = 0
+version_patch = 0
+
 now = datetime.datetime.now()
+year = now.year
+month = now.month
+day = now.day
 
 
 def test_version():
     version = 0
-    number = 10000 * now.year + 100 * now.month + now.day
+    number = (
+        10000000000 * version_major
+        + 100 * (10000 * year + 100 * month + day)
+        + version_patch
+    )
     i = 0
 
     while number != 0:
@@ -35,7 +45,7 @@ def test_version():
 
 
 def test_version_string():
-    version = f"{now.year}.{now.month:02}.{now.day:02}"
+    version = f"{version_major}.{year}{month:02}{day:02}.{version_patch}"
 
     assert oc.__version__ == version