fix: add tests (#5)

Author: lemire

.github/workflows/ubuntu.yml

@@ -1,4 +1,4 @@
-name: Ubuntu 22.04 CI
+name: Ubuntu 24.04 CI
 
 on:
   pull_request:
@@ -22,17 +22,17 @@ concurrency:
 
 jobs:
   ubuntu-build:
-    runs-on: ubuntu-22.04
+    runs-on: ubuntu-24.04
     strategy:
       matrix:
         shared: [ON, OFF]
-        cxx: [g++-12, clang++-14]
+        cxx: [g++-14]
     steps:
       - uses: actions/checkout@0ad4b8fadaa221de15dcec353f45205ec38ea70b # v4.1.4
       - name: Setup Ninja
         run: sudo apt-get install ninja-build
       - name: Prepare
-        run: cmake -D ADA_BENCHMARKS=ON -DBUILD_SHARED_LIBS=${{matrix.shared}} -G Ninja -B build
+        run: cmake -DBUILD_SHARED_LIBS=${{matrix.shared}} -G Ninja -B build
         env:
           CXX: ${{matrix.cxx}}
       - name: Build

CMakeLists.txt

@@ -1,7 +1,7 @@
 cmake_minimum_required(VERSION 3.10)
 project(version_weaver)
 
-set(CMAKE_CXX_STANDARD 17)
+set(CMAKE_CXX_STANDARD 23)
 set(CMAKE_CXX_STANDARD_REQUIRED True)
 if (NOT CMAKE_BUILD_TYPE)
     message(STATUS "No build type selected, default to Release")

include/version_weaver.h

@@ -3,7 +3,7 @@
 #include <optional>
 #include <string>
 #include <string_view>
-#include <variant>
+#include <expected>
 
 namespace version_weaver {
 
@@ -58,7 +58,25 @@ enum ParseError {
   INVALID_INPUT,
 };
 
-std::variant<Version, ParseError> parse(std::string_view version);
+std::expected<Version, ParseError> parse(std::string_view version);
 }  // namespace version_weaver
 
+inline bool operator!=(const version_weaver::Version& first,
+                       const version_weaver::Version& second) {
+  if (first.major != second.major) return first.major != second.major;
+  if (first.minor != second.minor) return first.minor != second.minor;
+  return first.patch != second.patch;
+}
+inline bool operator==(const version_weaver::Version& first,
+                       const version_weaver::Version& second) {
+  if (first.major != second.major) return first.major == second.major;
+  if (first.minor != second.minor) return first.minor == second.minor;
+  return first.patch == second.patch;
+}
+/*
+inline auto operator<=>(const version_weaver::Version& first, const
+version_weaver::Version& second) { if (first.major != second.major) return
+first.major <=> second.major; if (first.minor != second.minor) return
+first.minor <=> second.minor; return first.patch <=> second.patch;
+}*/
 #endif  // VERSION_WEAVER_H

src/version_weaver.cpp

@@ -1,8 +1,8 @@
 #include "version_weaver.h"
+#include <algorithm>
+#include <cctype>
 namespace version_weaver {
-bool validate(std::string_view version) {
-  return std::holds_alternative<Version>(parse(version));
-}
+bool validate(std::string_view version) { return bool(parse(version)); }
 
 bool gt(std::string_view version1, std::string_view version2) { return true; }
 bool lt(std::string_view version1, std::string_view version2) { return true; }
@@ -13,66 +13,81 @@ std::string coerce(std::string_view version) { return ""; }
 std::string minimum(std::string_view range) { return ""; }
 std::string clean(std::string_view range) { return ""; }
 
-std::variant<Version, ParseError> parse(std::string_view input) {
+inline std::string_view trim_whitespace(std::string_view input) noexcept {
+  while (!input.empty() && std::isspace(input.front())) {
+    input.remove_prefix(1);
+  }
+  while (!input.empty() && std::isspace(input.back())) {
+    input.remove_suffix(1);
+  }
+  return input;
+}
+
+std::expected<Version, ParseError> parse(std::string_view input) {
   if (input.size() > MAX_VERSION_LENGTH) {
-    return ParseError::VERSION_LARGER_THAN_MAX_LENGTH;
+    return std::unexpected(ParseError::VERSION_LARGER_THAN_MAX_LENGTH);
   }
 
-  std::string_view input_copy = input;
-  // TODO: Trim leading and trailing whitespace
+  std::string_view input_copy = trim_whitespace(input);
 
   auto dot_iterator = input_copy.find('.');
   if (dot_iterator == std::string_view::npos) {
     // Only major exists. No minor or patch.
-    return ParseError::INVALID_INPUT;
+    return std::unexpected(ParseError::INVALID_INPUT);
   }
   Version version;
   auto major = input_copy.substr(0, dot_iterator);
 
   if (major.empty() || major.front() == '0') {
     // Version components can not have leading zeroes.
-    return ParseError::INVALID_INPUT;
+    return std::unexpected(ParseError::INVALID_INPUT);
   }
   version.major = major;
   input_copy = input_copy.substr(dot_iterator + 1);
   dot_iterator = input_copy.find('.');
   if (dot_iterator == std::string_view::npos) {
     // Only major and minor exists. No patch.
-    return ParseError::INVALID_INPUT;
+    return std::unexpected(ParseError::INVALID_INPUT);
   }
 
   auto minor = input_copy.substr(0, dot_iterator);
-  if (minor.empty() || minor.front() == '0') {
+  if (minor.empty() || (minor.front() == '0' && minor.size() > 1)) {
     // Version components can not have leading zeroes.
-    return ParseError::INVALID_INPUT;
+    return std::unexpected(ParseError::INVALID_INPUT);
   }
   version.minor = minor;
   input_copy = input_copy.substr(dot_iterator + 1);
-  dot_iterator = input_copy.find('.');
-  if (dot_iterator == std::string_view::npos) {
-    // Only major, minor and patch exists.
-    return ParseError::INVALID_INPUT;
-  }
-
-  auto patch = input_copy.substr(0, dot_iterator);
-  if (patch.empty() || patch.front() == '0') {
-    // Version components can not have leading zeroes.
-    return ParseError::INVALID_INPUT;
+  dot_iterator = input_copy.find_first_of("-+");
+  auto patch = (dot_iterator == std::string_view::npos)
+                   ? input_copy
+                   : input_copy.substr(0, dot_iterator);
+  if (patch.empty() || (patch.front() == '0' && patch.size() > 1)) {
+    return std::unexpected(ParseError::INVALID_INPUT);
   }
   version.patch = patch;
+  if (dot_iterator == std::string_view::npos) {
+    return version;
+  }
+  bool is_pre_release = input_copy[dot_iterator] == '-';
   input_copy = input_copy.substr(dot_iterator + 1);
-
-  auto pre_release_iterator = input_copy.find('-');
-  if (pre_release_iterator != std::string_view::npos) {
-    version.pre_release = input_copy.substr(0, pre_release_iterator);
-    input_copy = input_copy.substr(pre_release_iterator + 1);
-    if (input_copy.find('.') != std::string_view::npos) {
-      // Build metadata exists.
-      auto build_iterator = input_copy.find('.');
-      version.build = input_copy.substr(0, build_iterator);
+  if (is_pre_release) {
+    dot_iterator = input_copy.find('+');
+    auto prerelease = (dot_iterator == std::string_view::npos)
+                          ? input_copy
+                          : input_copy.substr(0, dot_iterator);
+    if (prerelease.empty()) {
+      return std::unexpected(ParseError::INVALID_INPUT);
+    }
+    version.pre_release = prerelease;
+    if (dot_iterator == std::string_view::npos) {
+      return version;
     }
+    input_copy = input_copy.substr(dot_iterator + 1);
   }
-
+  if (input_copy.empty()) {
+    return std::unexpected(ParseError::INVALID_INPUT);
+  }
+  version.build = input_copy;
   return version;
 }
 }  // namespace version_weaver

tests/basictests.cpp

@@ -1,3 +1,49 @@
 #include "version_weaver.h"
 #include <cstdlib>
-int main() { return EXIT_SUCCESS; }
+#include <vector>
+#include <format>
+
+std::vector<std::pair<std::string, std::expected<version_weaver::Version,
+                                                 version_weaver::ParseError>>>
+    test_values = {
+        {"1.0.0", version_weaver::Version{"1", "0", "0"}},
+        {"1.0.0-alpha", version_weaver::Version{"1", "0", "0", "alpha"}},
+        {"1.0.0-alpha.1", version_weaver::Version{"1", "0", "0", "alpha.1"}},
+        {"1.0.0-0.3.7", version_weaver::Version{"1", "0", "0", "0.3.7"}},
+        {"1.0.0-x.7.z.92", version_weaver::Version{"1", "0", "0", "x.7.z.92"}},
+        {"1.0.0-x-y-z.--", version_weaver::Version{"1", "0", "0", "x-y-z.--"}},
+        {"1.0.0-alpha+001",
+         version_weaver::Version{"1", "0", "0", "alpha", "001"}},
+        {"1.0.0+20130313144700",
+         version_weaver::Version{"1", "0", "0", "", "20130313144700"}},
+        {"1.0.0-beta+exp.sha.5114f85",
+         version_weaver::Version{"1", "0", "0", "beta", "exp.sha.5114f85"}},
+        {"1.0.0+21AF26D3----117B344092BD",
+         version_weaver::Version{"1", "0", "0", "",
+                                 "21AF26D3----117B344092BD"}},
+};
+
+bool test_parse() {
+  for (const auto& [input, expected] : test_values) {
+    auto result = version_weaver::parse(input);
+    if (bool(result) != bool(expected)) {
+      std::printf("Expected %d, got %d\n", bool(expected), bool(result));
+      return false;
+    }
+    if (bool(result)) {
+      if (result.value() != expected.value()) {
+        std::printf("Expected \n");
+        return false;
+      }
+    }
+  }
+  return true;
+}
+int main() {
+  if (!test_parse()) {
+    std::printf("Test failed\n");
+    return EXIT_FAILURE;
+  }
+  std::printf("Tests succeeded!\n");
+  return EXIT_SUCCESS;
+}