feat: support prerelease inc operations (but only on int prerelease values)

Author: dario-piotrowicz

include/version_weaver.h

@@ -81,6 +81,7 @@ enum parse_error {
   INVALID_MAJOR,
   INVALID_MINOR,
   INVALID_PATCH,
+  INVALID_PRERELEASE,
   INVALID_RELEASE_TYPE,
 };
 
@@ -99,8 +100,7 @@ enum release_type {
   PRE_MINOR,
   PRE_PATCH,
   RELEASE,
-  // TODO: also support
-  //  - PRE_RELEASE
+  PRE_RELEASE,
 };
 
 // Increment the version according to the provided release type.

src/version_weaver.cpp

@@ -37,6 +37,7 @@ std::string minimum(std::string_view range) { return ""; }
 std::expected<std::string, parse_error> inc(version input,
                                             release_type release_type) {
   version_weaver::version result;
+  std::string incremented;
   switch (release_type) {
     case MAJOR:
     case PRE_MAJOR: {
@@ -48,8 +49,8 @@ std::expected<std::string, parse_error> inc(version input,
         return std::unexpected(parse_error::INVALID_MAJOR);
       }
       auto incremented_major_int = major_int + 1;
-      auto major = std::to_string(incremented_major_int);
-      result = version_weaver::version{major, "0", "0"};
+      incremented = std::to_string(incremented_major_int);
+      result = version_weaver::version{incremented, "0", "0"};
       break;
     }
     case MINOR:
@@ -62,15 +63,34 @@ std::expected<std::string, parse_error> inc(version input,
         return std::unexpected(parse_error::INVALID_MINOR);
       }
       auto incremented_minor_int = minor_int + 1;
-      result = version_weaver::version{
-          input.major, std::to_string(incremented_minor_int), "0"};
+      incremented = std::to_string(incremented_minor_int);
+      result = version_weaver::version{input.major, incremented, "0"};
       break;
     }
     case PATCH:
-    case PRE_PATCH: {
-      if (input.pre_release && release_type != PRE_PATCH) {
+    case PRE_PATCH:
+    case PRE_RELEASE: {
+      if (input.pre_release.has_value() && release_type == PATCH) {
         return version_weaver::version{input.major, input.minor, input.patch};
       }
+      if (release_type == PRE_RELEASE && input.pre_release.has_value()) {
+        // TODO: support non-int pre_releases as well
+        //       (see:
+        //       https://github.com/npm/node-semver/blob/d17aebf8/test/fixtures/increments.js#L22-L36)
+        auto pre_release_value = input.pre_release.value();
+        int prerelease_int;
+        auto [ptr, ec] =
+            std::from_chars(pre_release_value.data(),
+                            pre_release_value.data() + pre_release_value.size(),
+                            prerelease_int);
+        if (ec != std::errc()) {
+          return std::unexpected(parse_error::INVALID_PRERELEASE);
+        }
+        auto incremented_prerelease_int = prerelease_int + 1;
+        incremented = std::to_string(incremented_prerelease_int);
+        return version_weaver::version{input.major, input.minor, input.patch,
+                                       incremented};
+      }
       int patch_int;
       auto [ptr, ec] =
           std::from_chars(input.patch.data(),
@@ -79,8 +99,8 @@ std::expected<std::string, parse_error> inc(version input,
         return std::unexpected(parse_error::INVALID_PATCH);
       }
       auto incremented_patch_int = patch_int + 1;
-      result = version_weaver::version{input.major, input.minor,
-                                       std::to_string(incremented_patch_int)};
+      incremented = std::to_string(incremented_patch_int);
+      result = version_weaver::version{input.major, input.minor, incremented};
       break;
     }
     case RELEASE: {
@@ -94,7 +114,7 @@ std::expected<std::string, parse_error> inc(version input,
   }
 
   if (release_type == PRE_MAJOR || release_type == PRE_MINOR ||
-      release_type == PRE_PATCH) {
+      release_type == PRE_PATCH || release_type == PRE_RELEASE) {
     result.pre_release = "0";
   }
 

tests/basictests.cpp

@@ -256,6 +256,12 @@ std::vector<IncTestData> inc_values = {
     {version_weaver::version{"1", "2", "3"}, "1.2.3",
      version_weaver::release_type::RELEASE, "1.2.3",
      std::unexpected(version_weaver::parse_error::INVALID_INPUT)},
+    {version_weaver::version{"1", "2", "4"}, "1.2.4",
+     version_weaver::release_type::PRE_RELEASE, "1.2.5-0",
+     version_weaver::version{"1", "2", "5", "0"}},
+    {version_weaver::version{"1", "2", "3", "0"}, "1.2.3-0",
+     version_weaver::release_type::PRE_RELEASE, "1.2.3-1",
+     version_weaver::version{"1", "2", "3", "1"}},
 };
 
 TEST(basictests, inc) {