feat: add inc function (for basic release types) (#15)

Author: dario-piotrowicz

include/version_weaver.h

@@ -62,6 +62,27 @@ enum parse_error {
 std::expected<version, parse_error> clean(std::string_view input);
 
 std::expected<version, parse_error> parse(std::string_view version);
+
+enum release_type {
+  MAJOR,
+  MINOR,
+  PATCH,
+  // TODO: also support
+  //  - PRE_MAJOR
+  //  - PRE_MINOR
+  //  - PRE_PATCH
+  //  - PRE_RELEASE
+  //  - RELEASE
+};
+
+enum inc_error {
+  INVALID_MAJOR,
+  INVALID_MINOR,
+  INVALID_PATCH,
+  INVALID_RELEASE_TYPE,
+};
+
+std::expected<version, inc_error> inc(version version, release_type release_type);
 }  // namespace version_weaver
 
 // https://semver.org/#spec-item-11

src/version_weaver.cpp

@@ -33,6 +33,51 @@ std::optional<std::string> coerce(const std::string& version) {
 
 std::string minimum(std::string_view range) { return ""; }
 
+std::expected<version, inc_error> inc(version input, release_type release_type) {
+  switch (release_type) {
+    case MAJOR: {
+      int major_int;
+      try {
+        major_int = std::stoi(std::string(input.major));
+      } catch (...) {
+        return std::unexpected(inc_error::INVALID_MAJOR);
+      }
+      auto incremented_major_int = major_int + 1;
+      std::string_view incremented_major(std::to_string(incremented_major_int));
+      return version_weaver::version{incremented_major, "0", "0"};
+    }
+    case MINOR: {
+      int minor_int;
+      try {
+        minor_int = std::stoi(std::string(input.minor));
+      } catch (...) {
+        return std::unexpected(inc_error::INVALID_MINOR);
+      }
+      auto incremented_minor_int = minor_int + 1;
+      std::string_view incremented_minor(std::to_string(incremented_minor_int));
+      return version_weaver::version{input.major, incremented_minor, "0"};
+    }
+    case PATCH: {
+      auto dash_post = input.patch.find("-");
+      if (dash_post != std::string::npos) {
+        auto incremented_patch = input.patch.substr(0, dash_post);
+        return version_weaver::version{input.major, input.minor, incremented_patch};
+      }
+      int patch_int;
+      try {
+        patch_int = std::stoi(std::string(input.patch));
+      } catch (...) {
+        return std::unexpected(inc_error::INVALID_PATCH);
+      }
+      auto incremented_patch_int = patch_int + 1;
+      std::string_view incremented_patch(std::to_string(incremented_patch_int));
+      return version_weaver::version{input.major, input.minor, incremented_patch};
+    }
+    default:
+      return std::unexpected(inc_error::INVALID_RELEASE_TYPE);
+  }
+}
+
 constexpr inline void trim_whitespace(std::string_view* input) noexcept {
   while (!input->empty() && std::isspace(input->front())) {
     input->remove_prefix(1);

tests/basictests.cpp

@@ -184,3 +184,45 @@ TEST(basictests, coerce) {
     }
   }
 }
+
+using IncTestData = std::tuple<
+  version_weaver::version,
+  version_weaver::release_type,
+  std::expected<version_weaver::version, version_weaver::inc_error>
+>;
+
+std::vector<IncTestData> inc_values = {
+    {version_weaver::version{"1", "2", "3"}, version_weaver::release_type::MAJOR, version_weaver::version{"2", "0", "0"}},
+    {version_weaver::version{"1", "2", "3"}, version_weaver::release_type::MINOR, version_weaver::version{"1", "3", "0"}},
+    {version_weaver::version{"1", "2", "3"}, version_weaver::release_type::PATCH, version_weaver::version{"1", "2", "4"}},
+    {version_weaver::version{"1", "2", "3tag"}, version_weaver::release_type::MAJOR, version_weaver::version{"2", "0", "0"}},
+    {version_weaver::version{"1", "2", "3-tag"}, version_weaver::release_type::MAJOR, version_weaver::version{"2", "0", "0"}},
+    {version_weaver::version{"1", "2", "3"}, static_cast<version_weaver::release_type>(-1), std::unexpected(version_weaver::inc_error::INVALID_RELEASE_TYPE)},
+    {version_weaver::version{"1", "2", "0-0"}, version_weaver::release_type::PATCH, version_weaver::version{"1", "2", "0"}},
+    {version_weaver::version{"fake"}, version_weaver::release_type::MAJOR, std::unexpected(version_weaver::inc_error::INVALID_MAJOR)},
+    {version_weaver::version{"1", "2", "3-4"}, version_weaver::release_type::MAJOR, version_weaver::version{"2", "0", "0"}},
+    {version_weaver::version{"1", "2", "3-4"}, version_weaver::release_type::MINOR, version_weaver::version{"1", "3", "0"}},
+    {version_weaver::version{"1", "2", "3-4"}, version_weaver::release_type::PATCH, version_weaver::version{"1", "2", "3"}},
+    {version_weaver::version{"1", "2", "3-alpha.0.beta"}, version_weaver::release_type::MAJOR, version_weaver::version{"2", "0", "0"}},
+    {version_weaver::version{"1", "2", "3-alpha.0.beta"}, version_weaver::release_type::MINOR, version_weaver::version{"1", "3", "0"}},
+    {version_weaver::version{"1", "2", "3-alpha.0.beta"}, version_weaver::release_type::PATCH, version_weaver::version{"1", "2", "3"}},
+};
+
+TEST(basictests, inc) {
+  for (const auto& [input, release_type, expected] : inc_values) {
+    auto incremented = version_weaver::inc(input, release_type);
+
+    ASSERT_EQ(incremented.has_value(), expected.has_value());
+    if (incremented.has_value()) {
+      ASSERT_EQ(incremented->major, expected->major);
+      ASSERT_EQ(incremented->minor, expected->minor);
+      ASSERT_EQ(incremented->patch, expected->patch);
+      ASSERT_EQ(incremented->pre_release, expected->pre_release);
+      ASSERT_EQ(incremented->build, expected->build);
+    } else {
+      ASSERT_EQ(incremented.error(), expected.error());
+    }
+  }
+
+  SUCCEED();
+}