From 0e01253b6262b4b583580c3be955984049df1208 Mon Sep 17 00:00:00 2001
From: Corey Oordt <coreyoordt@gmail.com>
Date: Tue, 19 Dec 2023 07:58:47 -0600
Subject: [PATCH 01/11] Fixed timezone of a test

---
 tests/test_cli.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/tests/test_cli.py b/tests/test_cli.py
index 20532f76..97a3b409 100644
--- a/tests/test_cli.py
+++ b/tests/test_cli.py
@@ -2,7 +2,7 @@
 import shutil
 import subprocess
 import traceback
-from datetime import datetime
+from datetime import datetime, timezone
 from pathlib import Path
 
 import pytest
@@ -68,7 +68,7 @@ def test_bump_nested_regex(tmp_path: Path, fixtures_path: Path, caplog):
 
     assert result.exit_code == 0
 
-    now = datetime.now().isoformat()[:10]
+    now = datetime.now(timezone.utc).isoformat()[:10]
     assert cff_path.read_text() == f"cff-version: 1.2.0\ndate-released: {now}\n"
 
 

From be87721268a6ba4cc211fb8fb3fa07c85c4eb553 Mon Sep 17 00:00:00 2001
From: Corey Oordt <coreyoordt@gmail.com>
Date: Tue, 19 Dec 2023 08:02:43 -0600
Subject: [PATCH 02/11] Refactored versioning functions and version parts

---
 bumpversion/autocast.py                       |   2 +
 bumpversion/bump.py                           |   2 +-
 bumpversion/config/files.py                   |   2 +-
 bumpversion/files.py                          |   3 +-
 bumpversion/utils.py                          |   2 +-
 bumpversion/version_part.py                   | 117 +----------------
 bumpversion/versioning/__init__.py            |   1 +
 bumpversion/{ => versioning}/functions.py     |   9 +-
 bumpversion/versioning/models.py              | 118 +++++++++++++++++
 tests/test_functions.py                       |  83 ------------
 tests/test_version_part.py                    |  58 ---------
 tests/test_versioning/__init__.py             |   0
 tests/test_versioning/test_functions.py       | 122 ++++++++++++++++++
 .../test_models_versionpart.py                |  68 ++++++++++
 14 files changed, 327 insertions(+), 260 deletions(-)
 create mode 100644 bumpversion/versioning/__init__.py
 rename bumpversion/{ => versioning}/functions.py (91%)
 create mode 100644 bumpversion/versioning/models.py
 delete mode 100644 tests/test_functions.py
 create mode 100644 tests/test_versioning/__init__.py
 create mode 100644 tests/test_versioning/test_functions.py
 create mode 100644 tests/test_versioning/test_models_versionpart.py

diff --git a/bumpversion/autocast.py b/bumpversion/autocast.py
index 06de7c98..06fd0ecb 100644
--- a/bumpversion/autocast.py
+++ b/bumpversion/autocast.py
@@ -2,6 +2,8 @@
 Automatically detect the true Python type of a string and cast it to the correct type.
 
 Based on https://github.com/cgreer/cgAutoCast/blob/master/cgAutoCast.py
+
+Only used by Legacy configuration file parser.
 """
 
 import contextlib
diff --git a/bumpversion/bump.py b/bumpversion/bump.py
index 62fe2c13..40ae459f 100644
--- a/bumpversion/bump.py
+++ b/bumpversion/bump.py
@@ -5,7 +5,7 @@
 
 if TYPE_CHECKING:  # pragma: no-coverage
     from bumpversion.files import ConfiguredFile
-    from bumpversion.version_part import Version
+    from bumpversion.versioning.models import Version
 
 from bumpversion.config import Config
 from bumpversion.config.files import update_config_file
diff --git a/bumpversion/config/files.py b/bumpversion/config/files.py
index 88d4e99e..7aa68dce 100644
--- a/bumpversion/config/files.py
+++ b/bumpversion/config/files.py
@@ -10,7 +10,7 @@
 
 if TYPE_CHECKING:  # pragma: no-coverage
     from bumpversion.config.models import Config
-    from bumpversion.version_part import Version
+    from bumpversion.versioning.models import Version
 
 logger = get_indented_logger(__name__)
 
diff --git a/bumpversion/files.py b/bumpversion/files.py
index 4bca5e87..d56ecd2d 100644
--- a/bumpversion/files.py
+++ b/bumpversion/files.py
@@ -9,7 +9,8 @@
 from bumpversion.config.models import FileChange, VersionPartConfig
 from bumpversion.exceptions import VersionNotFoundError
 from bumpversion.ui import get_indented_logger
-from bumpversion.version_part import Version, VersionConfig
+from bumpversion.version_part import VersionConfig
+from bumpversion.versioning.models import Version
 
 logger = get_indented_logger(__name__)
 
diff --git a/bumpversion/utils.py b/bumpversion/utils.py
index 5243b1a0..ffaa4f80 100644
--- a/bumpversion/utils.py
+++ b/bumpversion/utils.py
@@ -6,7 +6,7 @@
 
 if TYPE_CHECKING:  # pragma: no-coverage
     from bumpversion.config import Config
-    from bumpversion.version_part import Version
+    from bumpversion.versioning.models import Version
 
 
 def extract_regex_flags(regex_pattern: str) -> Tuple[str, str]:
diff --git a/bumpversion/version_part.py b/bumpversion/version_part.py
index 13430d35..50a2f611 100644
--- a/bumpversion/version_part.py
+++ b/bumpversion/version_part.py
@@ -2,130 +2,19 @@
 import re
 import string
 from copy import copy
-from typing import Any, Dict, List, MutableMapping, Optional, Tuple, Union
+from typing import Any, Dict, List, MutableMapping, Optional, Tuple
 
 from click import UsageError
 
 from bumpversion.config.models import VersionPartConfig
-from bumpversion.exceptions import FormattingError, InvalidVersionPartError, MissingValueError
-from bumpversion.functions import NumericFunction, PartFunction, ValuesFunction
+from bumpversion.exceptions import FormattingError, MissingValueError
 from bumpversion.ui import get_indented_logger
 from bumpversion.utils import key_val_string, labels_for_format
+from bumpversion.versioning.models import Version, VersionPart
 
 logger = get_indented_logger(__name__)
 
 
-class VersionPart:
-    """
-    Represent part of a version number.
-
-    Determines the PartFunction that rules how the part behaves when increased or reset
-    based on the configuration given.
-    """
-
-    def __init__(self, config: VersionPartConfig, value: Union[str, int, None] = None):
-        self._value = str(value) if value is not None else None
-        self.config = config
-        self.func: Optional[PartFunction] = None
-        if config.values:
-            str_values = [str(v) for v in config.values]
-            str_optional_value = str(config.optional_value) if config.optional_value is not None else None
-            str_first_value = str(config.first_value) if config.first_value is not None else None
-            self.func = ValuesFunction(str_values, str_optional_value, str_first_value)
-        else:
-            self.func = NumericFunction(config.optional_value, config.first_value or "0")
-
-    @property
-    def value(self) -> str:
-        """Return the value of the part."""
-        return self._value or self.func.optional_value
-
-    def copy(self) -> "VersionPart":
-        """Return a copy of the part."""
-        return VersionPart(self.config, self._value)
-
-    def bump(self) -> "VersionPart":
-        """Return a part with bumped value."""
-        return VersionPart(self.config, self.func.bump(self.value))
-
-    def null(self) -> "VersionPart":
-        """Return a part with first value."""
-        return VersionPart(self.config, self.func.first_value)
-
-    @property
-    def is_optional(self) -> bool:
-        """Is the part optional?"""
-        return self.value == self.func.optional_value
-
-    @property
-    def is_independent(self) -> bool:
-        """Is the part independent of the other parts?"""
-        return self.config.independent
-
-    def __format__(self, format_spec: str) -> str:
-        try:
-            val = int(self.value)
-        except ValueError:
-            return self.value
-        else:
-            return int.__format__(val, format_spec)
-
-    def __repr__(self) -> str:
-        return f"<bumpversion.VersionPart:{self.func.__class__.__name__}:{self.value}>"
-
-    def __eq__(self, other: Any) -> bool:
-        return self.value == other.value if isinstance(other, VersionPart) else False
-
-
-class Version:
-    """The specification of a version and its parts."""
-
-    def __init__(self, values: Dict[str, VersionPart], original: Optional[str] = None):
-        self.values = values
-        self.original = original
-
-    def __getitem__(self, key: str) -> VersionPart:
-        return self.values[key]
-
-    def __len__(self) -> int:
-        return len(self.values)
-
-    def __iter__(self):
-        return iter(self.values)
-
-    def __repr__(self):
-        return f"<bumpversion.Version:{key_val_string(self.values)}>"
-
-    def __eq__(self, other: Any) -> bool:
-        return (
-            all(value == other.values[key] for key, value in self.values.items())
-            if isinstance(other, Version)
-            else False
-        )
-
-    def bump(self, part_name: str, order: List[str]) -> "Version":
-        """Increase the value of the given part."""
-        bumped = False
-
-        new_values = {}
-
-        for label in order:
-            if label not in self.values:
-                continue
-            if label == part_name:
-                new_values[label] = self.values[label].bump()
-                bumped = True
-            elif bumped and not self.values[label].is_independent:
-                new_values[label] = self.values[label].null()
-            else:
-                new_values[label] = self.values[label].copy()
-
-        if not bumped:
-            raise InvalidVersionPartError(f"No part named {part_name!r}")
-
-        return Version(new_values)
-
-
 class VersionConfig:
     """
     Hold a complete representation of a version string.
diff --git a/bumpversion/versioning/__init__.py b/bumpversion/versioning/__init__.py
new file mode 100644
index 00000000..75eff716
--- /dev/null
+++ b/bumpversion/versioning/__init__.py
@@ -0,0 +1 @@
+"""Module for managing Versions and their internal parts."""
diff --git a/bumpversion/functions.py b/bumpversion/versioning/functions.py
similarity index 91%
rename from bumpversion/functions.py
rename to bumpversion/versioning/functions.py
index 798e63a2..7cc96290 100644
--- a/bumpversion/functions.py
+++ b/bumpversion/versioning/functions.py
@@ -29,7 +29,7 @@ class NumericFunction(PartFunction):
     considered (e.g. 'r3-001' --> 'r4-001').
     """
 
-    FIRST_NUMERIC = re.compile(r"(\D*)(\d+)(.*)")
+    FIRST_NUMERIC = re.compile(r"(?P<prefix>[^-0-9]*)(?P<number>-?\d+)(?P<suffix>.*)")
 
     def __init__(self, optional_value: Union[str, int, None] = None, first_value: Union[str, int, None] = None):
         if first_value is not None and not self.FIRST_NUMERIC.search(str(first_value)):
@@ -43,7 +43,14 @@ def bump(self, value: Union[str, int]) -> str:
         match = self.FIRST_NUMERIC.search(str(value))
         if not match:
             raise ValueError(f"The given value {value} does not contain any digit")
+
         part_prefix, part_numeric, part_suffix = match.groups()
+
+        if int(part_numeric) < int(self.first_value):
+            raise ValueError(
+                f"The given value {value} is lower than the first value {self.first_value} and cannot be bumped."
+            )
+
         bumped_numeric = int(part_numeric) + 1
 
         return "".join([part_prefix, str(bumped_numeric), part_suffix])
diff --git a/bumpversion/versioning/models.py b/bumpversion/versioning/models.py
new file mode 100644
index 00000000..8de38d48
--- /dev/null
+++ b/bumpversion/versioning/models.py
@@ -0,0 +1,118 @@
+"""Models for managing versioning of software projects."""
+from typing import Any, Dict, List, Optional, Union
+
+from bumpversion.config.models import VersionPartConfig
+from bumpversion.exceptions import InvalidVersionPartError
+from bumpversion.utils import key_val_string
+from bumpversion.versioning.functions import NumericFunction, PartFunction, ValuesFunction
+
+
+class VersionPart:
+    """
+    Represent part of a version number.
+
+    Determines the PartFunction that rules how the part behaves when increased or reset
+    based on the configuration given.
+    """
+
+    def __init__(self, config: VersionPartConfig, value: Union[str, int, None] = None):
+        self._value = str(value) if value is not None else None
+        self.config = config
+        self.func: Optional[PartFunction] = None
+        if config.values:
+            str_values = [str(v) for v in config.values]
+            str_optional_value = str(config.optional_value) if config.optional_value is not None else None
+            str_first_value = str(config.first_value) if config.first_value is not None else None
+            self.func = ValuesFunction(str_values, str_optional_value, str_first_value)
+        else:
+            self.func = NumericFunction(config.optional_value, config.first_value or "0")
+
+    @property
+    def value(self) -> str:
+        """Return the value of the part."""
+        return self._value or self.func.optional_value
+
+    def copy(self) -> "VersionPart":
+        """Return a copy of the part."""
+        return VersionPart(self.config, self._value)
+
+    def bump(self) -> "VersionPart":
+        """Return a part with bumped value."""
+        return VersionPart(self.config, self.func.bump(self.value))
+
+    def null(self) -> "VersionPart":
+        """Return a part with first value."""
+        return VersionPart(self.config, self.func.first_value)
+
+    @property
+    def is_optional(self) -> bool:
+        """Is the part optional?"""
+        return self.value == self.func.optional_value
+
+    @property
+    def is_independent(self) -> bool:
+        """Is the part independent of the other parts?"""
+        return self.config.independent
+
+    def __format__(self, format_spec: str) -> str:
+        try:
+            val = int(self.value)
+        except ValueError:
+            return self.value
+        else:
+            return int.__format__(val, format_spec)
+
+    def __repr__(self) -> str:
+        return f"<bumpversion.VersionPart:{self.func.__class__.__name__}:{self.value}>"
+
+    def __eq__(self, other: Any) -> bool:
+        return self.value == other.value if isinstance(other, VersionPart) else False
+
+
+class Version:
+    """The specification of a version and its parts."""
+
+    def __init__(self, values: Dict[str, VersionPart], original: Optional[str] = None):
+        self.values = values
+        self.original = original
+
+    def __getitem__(self, key: str) -> VersionPart:
+        return self.values[key]
+
+    def __len__(self) -> int:
+        return len(self.values)
+
+    def __iter__(self):
+        return iter(self.values)
+
+    def __repr__(self):
+        return f"<bumpversion.Version:{key_val_string(self.values)}>"
+
+    def __eq__(self, other: Any) -> bool:
+        return (
+            all(value == other.values[key] for key, value in self.values.items())
+            if isinstance(other, Version)
+            else False
+        )
+
+    def bump(self, part_name: str, order: List[str]) -> "Version":
+        """Increase the value of the given part."""
+        bumped = False
+
+        new_values = {}
+
+        for label in order:
+            if label not in self.values:
+                continue
+            if label == part_name:
+                new_values[label] = self.values[label].bump()
+                bumped = True
+            elif bumped and not self.values[label].is_independent:
+                new_values[label] = self.values[label].null()
+            else:
+                new_values[label] = self.values[label].copy()
+
+        if not bumped:
+            raise InvalidVersionPartError(f"No part named {part_name!r}")
+
+        return Version(new_values)
diff --git a/tests/test_functions.py b/tests/test_functions.py
deleted file mode 100644
index ecd77746..00000000
--- a/tests/test_functions.py
+++ /dev/null
@@ -1,83 +0,0 @@
-import pytest
-
-from bumpversion.functions import NumericFunction, ValuesFunction
-
-# NumericFunction
-
-
-def test_numeric_init_wo_first_value():
-    func = NumericFunction()
-    assert func.first_value == "0"
-
-
-def test_numeric_init_w_first_value():
-    func = NumericFunction(first_value="5")
-    assert func.first_value == "5"
-
-
-def test_numeric_init_non_numeric_first_value():
-    with pytest.raises(ValueError):
-        NumericFunction(first_value="a")
-
-
-def test_numeric_bump_simple_number():
-    func = NumericFunction()
-    assert func.bump("0") == "1"
-
-
-def test_numeric_bump_prefix_and_suffix():
-    func = NumericFunction()
-    assert func.bump("v0b") == "v1b"
-
-
-# ValuesFunction
-
-
-def test_values_init():
-    func = ValuesFunction(["0", "1", "2"])
-    assert func.optional_value == "0"
-    assert func.first_value == "0"
-
-
-def test_values_init_w_correct_optional_value():
-    func = ValuesFunction(["0", "1", "2"], optional_value="1")
-    assert func.optional_value == "1"
-    assert func.first_value == "0"
-
-
-def test_values_init_w_correct_first_value():
-    func = ValuesFunction(["0", "1", "2"], first_value="1")
-    assert func.optional_value == "0"
-    assert func.first_value == "1"
-
-
-def test_values_init_w_correct_optional_and_first_value():
-    func = ValuesFunction(["0", "1", "2"], optional_value="0", first_value="1")
-    assert func.optional_value == "0"
-    assert func.first_value == "1"
-
-
-def test_values_init_w_empty_values():
-    with pytest.raises(ValueError):
-        ValuesFunction([])
-
-
-def test_values_init_w_incorrect_optional_value():
-    with pytest.raises(ValueError):
-        ValuesFunction(["0", "1", "2"], optional_value="3")
-
-
-def test_values_init_w_incorrect_first_value():
-    with pytest.raises(ValueError):
-        ValuesFunction(["0", "1", "2"], first_value="3")
-
-
-def test_values_bump():
-    func = ValuesFunction(["0", "5", "10"])
-    assert func.bump("0") == "5"
-
-
-def test_values_bump_max():
-    func = ValuesFunction(["0", "5", "10"])
-    with pytest.raises(ValueError):
-        func.bump("10")
diff --git a/tests/test_version_part.py b/tests/test_version_part.py
index 4875fc05..fa9b60cd 100644
--- a/tests/test_version_part.py
+++ b/tests/test_version_part.py
@@ -5,69 +5,11 @@
 from click import UsageError
 from pytest import LogCaptureFixture, param
 
-from bumpversion.config.models import VersionPartConfig
 from bumpversion import exceptions
 from bumpversion.utils import get_context
-from bumpversion.version_part import VersionPart
 from tests.conftest import get_config_data, inside_dir
 
 
-@pytest.fixture(
-    params=[
-        None,
-        ("0", "1", "2"),
-        ("0", "3"),
-    ]
-)
-def version_part_config(request):
-    """Return a three-part and a two-part version part configuration."""
-    if request.param is None:
-        return VersionPartConfig()
-    else:
-        return VersionPartConfig(values=request.param)
-
-
-def test_version_part_init(version_part_config):
-    vp = VersionPart(version_part_config, version_part_config.first_value)
-    assert vp.value is not None
-
-
-def test_version_part_copy(version_part_config):
-    vp = VersionPart(version_part_config, version_part_config.first_value)
-    vc = vp.copy()
-    assert vp.value == vc.value
-    assert id(vp) != id(vc)
-
-
-def test_version_part_bump(version_part_config):
-    vp = VersionPart(version_part_config, version_part_config.first_value)
-    vc = vp.bump()
-    if version_part_config.values:
-        assert vc.value == str(version_part_config.values[1])
-    else:
-        assert vc.value == "1"
-
-
-def test_version_part_check_optional_false(version_part_config):
-    assert not VersionPart(version_part_config, version_part_config.first_value).bump().is_optional
-
-
-def test_version_part_check_optional_true(version_part_config):
-    assert VersionPart(version_part_config, version_part_config.first_value).is_optional
-
-
-def test_version_part_equality(version_part_config):
-    assert VersionPart(version_part_config, version_part_config.first_value) == VersionPart(
-        version_part_config, version_part_config.first_value
-    )
-
-
-def test_version_part_null(version_part_config):
-    assert VersionPart(version_part_config, version_part_config.first_value).null() == VersionPart(
-        version_part_config, version_part_config.first_value
-    )
-
-
 def test_bump_version_missing_part():
     overrides = {
         "current_version": "1.0.0",
diff --git a/tests/test_versioning/__init__.py b/tests/test_versioning/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/test_versioning/test_functions.py b/tests/test_versioning/test_functions.py
new file mode 100644
index 00000000..0f740173
--- /dev/null
+++ b/tests/test_versioning/test_functions.py
@@ -0,0 +1,122 @@
+import pytest
+from pytest import param
+
+from bumpversion.versioning.functions import NumericFunction, ValuesFunction
+
+
+# NumericFunction
+class TestNumericFunction:
+    """The numeric function manages incrementing and resetting numeric version parts."""
+
+    class TestCreation:
+        """The numeric function can be created."""
+
+        def test_without_first_value_is_zero(self):
+            func = NumericFunction()
+            assert func.first_value == "0"
+
+        def test_with_first_value_is_value(self):
+            func = NumericFunction(first_value="5")
+            assert func.first_value == "5"
+
+        def test_non_numeric_first_value_raises_value_error(self):
+            with pytest.raises(ValueError):
+                NumericFunction(first_value="a")
+
+        def test_alphanumeric_value_is_accepted(self):
+            func = NumericFunction(first_value="v10b")
+            assert func.first_value == "v10b"
+
+        def test_without_optional_value_is_first_value(self):
+            func = NumericFunction()
+            assert func.optional_value == func.first_value == "0"
+            func = NumericFunction(first_value="5")
+            assert func.optional_value == func.first_value == "5"
+
+    class TestBump:
+        """Tests for incrementing a value."""
+
+        def test_number_increments(self):
+            func = NumericFunction()
+            assert func.bump("0") == "1"
+
+        @pytest.mark.parametrize(
+            ("value", "expected"),
+            [
+                param("v10", "v11", id="alphanumeric-prefix"),
+                param("10b", "11b", id="alphanumeric-suffix"),
+                param("v10b", "v11b", id="alphanumeric-prefix-suffix"),
+                param("r3-001", "r4-001", id="alphanumeric-prefix-suffix-with-numeric-suffix"),
+            ],
+        )
+        def test_alphanumeric_increments(self, value: str, expected: str):
+            func = NumericFunction()
+            assert func.bump(value) == expected
+
+        def test_bump_before_first_value_raises_value_error(self):
+            func = NumericFunction()
+            with pytest.raises(ValueError):
+                func.bump("-1")
+
+            func = NumericFunction(first_value="5")
+            with pytest.raises(ValueError):
+                func.bump("3")
+
+        def test_bump_non_numeric_value_raises_value_error(self):
+            func = NumericFunction()
+            with pytest.raises(ValueError):
+                func.bump("a")
+
+
+# ValuesFunction
+class TestValuesFunction:
+    """The values function manages incrementing and resetting non-numeric version parts."""
+
+    class TestCreation:
+        """The values function can be created."""
+
+        def test_values_set_first_value_and_optional_value(self):
+            func = ValuesFunction(["0", "1", "2"])
+            assert func.optional_value == "0"
+            assert func.first_value == "0"
+
+        def test_optional_value_can_be_different_from_first_value(self):
+            func = ValuesFunction(["0", "1", "2"], optional_value="1")
+            assert func.optional_value == "1"
+            assert func.first_value == "0"
+
+            func = ValuesFunction(["0", "1", "2"], optional_value="0", first_value="1")
+            assert func.optional_value == "0"
+            assert func.first_value == "1"
+
+        def test_optional_value_must_be_in_values(self):
+            with pytest.raises(ValueError):
+                ValuesFunction(["0", "1", "2"], optional_value="3")
+
+        def test_first_value_doesnt_need_to_be_first_in_values(self):
+            func = ValuesFunction(["0", "1", "2"], first_value="1")
+            assert func.optional_value == "0"
+            assert func.first_value == "1"
+
+        def test_values_are_required(self):
+            with pytest.raises(ValueError):
+                ValuesFunction([])
+
+        def test_first_value_must_be_in_values(self):
+            with pytest.raises(ValueError):
+                ValuesFunction(["0", "1", "2"], first_value="3")
+
+    class TestBump:
+        def test_bump_returns_next_item(self):
+            func = ValuesFunction(["0", "5", "10"])
+            assert func.bump("0") == "5"
+
+        def test_cannot_bump_beyond_max_value(self):
+            func = ValuesFunction(["0", "5", "10"])
+            with pytest.raises(ValueError):
+                func.bump("10")
+
+        def test_bump_non_value_raises_value_error(self):
+            func = ValuesFunction(["0", "5", "10"])
+            with pytest.raises(ValueError):
+                func.bump("3")
diff --git a/tests/test_versioning/test_models_versionpart.py b/tests/test_versioning/test_models_versionpart.py
new file mode 100644
index 00000000..566b857c
--- /dev/null
+++ b/tests/test_versioning/test_models_versionpart.py
@@ -0,0 +1,68 @@
+"""Tests of the VersionPart model."""
+
+from bumpversion.versioning.models import VersionPart
+from bumpversion.config.models import VersionPartConfig
+from bumpversion.versioning.functions import ValuesFunction, NumericFunction
+import pytest
+
+
+@pytest.fixture(
+    params=[
+        None,
+        ("0", "1", "2"),
+        ("0", "3"),
+    ]
+)
+def version_part_config(request):
+    """Return a three-part and a two-part version part configuration."""
+    if request.param is None:
+        return VersionPartConfig(optional_value="0", first_value="0")
+    else:
+        return VersionPartConfig(values=request.param)
+
+
+class TestVersionPartConfig:
+    class TestCreation:
+        def test_none_value_uses_optional_value(self, version_part_config):
+            vp = VersionPart(version_part_config)
+            assert vp.value == vp.func.optional_value
+            assert vp._value is None
+
+        def test_config_with_values_selects_values_function(self):
+            values = ["0", "1", "2"]
+            vp = VersionPart(VersionPartConfig(values=values))
+            assert isinstance(vp.func, ValuesFunction)
+
+        def test_config_without_values_selects_numeric_function(self):
+            vp = VersionPart(VersionPartConfig())
+            assert isinstance(vp.func, NumericFunction)
+
+    def test_copy_returns_new_version_part(self, version_part_config):
+        vp = VersionPart(version_part_config, version_part_config.first_value)
+        vc = vp.copy()
+        assert vp.value == vc.value
+        assert id(vp) != id(vc)
+
+    def test_bump_increments_value(self, version_part_config):
+        vp = VersionPart(version_part_config, version_part_config.first_value)
+        vc = vp.bump()
+        if version_part_config.values:
+            assert vc.value == str(version_part_config.values[1])
+        else:
+            assert vc.value == "1"
+
+    def test_non_first_value_is_not_optional(self, version_part_config):
+        assert not VersionPart(version_part_config, version_part_config.first_value).bump().is_optional
+
+    def test_first_value_is_optional(self, version_part_config):
+        assert VersionPart(version_part_config, version_part_config.first_value).is_optional
+
+    def test_versionparts_with_same_settings_are_equal(self, version_part_config):
+        assert VersionPart(version_part_config, version_part_config.first_value) == VersionPart(
+            version_part_config, version_part_config.first_value
+        )
+
+    def test_null_resets_value_to_first_value(self, version_part_config):
+        assert VersionPart(version_part_config, version_part_config.first_value).null() == VersionPart(
+            version_part_config, version_part_config.first_value
+        )

From 5ed546bd20831136270cfa0264441faa042d4cd9 Mon Sep 17 00:00:00 2001
From: Corey Oordt <coreyoordt@gmail.com>
Date: Wed, 20 Dec 2023 08:06:08 -0600
Subject: [PATCH 03/11] Refactored version parsing

---
 bumpversion/version_part.py                 | 46 +++++++--------
 bumpversion/versioning/models.py            | 55 ++++++++++++++++++
 bumpversion/versioning/serialization.py     | 56 +++++++++++++++++++
 tests/test_version_part.py                  |  9 ---
 tests/test_versioning/test_serialization.py | 62 +++++++++++++++++++++
 5 files changed, 192 insertions(+), 36 deletions(-)
 create mode 100644 bumpversion/versioning/serialization.py
 create mode 100644 tests/test_versioning/test_serialization.py

diff --git a/bumpversion/version_part.py b/bumpversion/version_part.py
index 50a2f611..880f1687 100644
--- a/bumpversion/version_part.py
+++ b/bumpversion/version_part.py
@@ -9,8 +9,9 @@
 from bumpversion.config.models import VersionPartConfig
 from bumpversion.exceptions import FormattingError, MissingValueError
 from bumpversion.ui import get_indented_logger
-from bumpversion.utils import key_val_string, labels_for_format
+from bumpversion.utils import labels_for_format
 from bumpversion.versioning.models import Version, VersionPart
+from bumpversion.versioning.serialization import parse_version
 
 logger = get_indented_logger(__name__)
 
@@ -74,39 +75,17 @@ def parse(self, version_string: Optional[str] = None) -> Optional[Version]:
         Returns:
             A Version object representing the string.
         """
-        if not version_string:
-            return None
-
-        regexp_one_line = "".join([line.split("#")[0].strip() for line in self.parse_regex.pattern.splitlines()])
-
-        logger.info(
-            "Parsing version '%s' using regexp '%s'",
-            version_string,
-            regexp_one_line,
-        )
-        logger.indent()
-
-        match = self.parse_regex.search(version_string)
+        parsed = parse_version(version_string, self.parse_regex.pattern)
 
-        if not match:
-            logger.warning(
-                "Evaluating 'parse' option: '%s' does not parse current version '%s'",
-                self.parse_regex.pattern,
-                version_string,
-            )
+        if not parsed:
             return None
 
         _parsed = {
             key: VersionPart(self.part_configs[key], value)
-            for key, value in match.groupdict().items()
+            for key, value in parsed.items()
             if key in self.part_configs
         }
-        v = Version(_parsed, version_string)
-
-        logger.info("Parsed the following values: %s", key_val_string(v.values))
-        logger.dedent()
-
-        return v
+        return Version(_parsed, version_string)
 
     def _serialize(
         self, version: Version, serialize_format: str, context: MutableMapping, raise_if_incomplete: bool = False
@@ -169,6 +148,19 @@ def _serialize(
         return serialized
 
     def _choose_serialize_format(self, version: Version, context: MutableMapping) -> str:
+        """
+        Choose a serialization format for the given version and context.
+
+        Args:
+            version: The version to serialize
+            context: The context to use when serializing the version
+
+        Returns:
+            The serialized version as a string
+
+        Raises:
+            MissingValueError: if not all parts required in the format have values
+        """
         chosen = None
 
         logger.debug("Evaluating serialization formats")
diff --git a/bumpversion/versioning/models.py b/bumpversion/versioning/models.py
index 8de38d48..aa754a29 100644
--- a/bumpversion/versioning/models.py
+++ b/bumpversion/versioning/models.py
@@ -6,6 +6,61 @@
 from bumpversion.utils import key_val_string
 from bumpversion.versioning.functions import NumericFunction, PartFunction, ValuesFunction
 
+# Adapted from https://regex101.com/r/Ly7O1x/3/
+SEMVER_PATTERN = r"""
+    (?P<major>0|[1-9]\d*)\.
+    (?P<minor>0|[1-9]\d*)\.
+    (?P<patch>0|[1-9]\d*)
+    (?:
+        -                             # dash seperator for pre-release section
+        (?P<pre_l>[a-zA-Z-]+)         # pre-release label
+        (?P<pre_n>0|[1-9]\d*)         # pre-release version number
+    )?                                # pre-release section is optional
+    (?:
+        \+                            # plus seperator for build metadata section
+        (?P<buildmetadata>
+            [0-9a-zA-Z-]+
+            (?:\.[0-9a-zA-Z-]+)*
+        )
+    )?                                # build metadata section is optional
+"""
+
+# Adapted from https://packaging.python.org/en/latest/specifications/version-specifiers/
+PEP440_PATTERN = r"""
+    v?
+    (?:
+        (?:(?P<epoch>[0-9]+)!)?                           # Optional epoch
+        (?P<release>
+            (?P<major>0|[1-9]\d*)\.
+            (?P<minor>0|[1-9]\d*)\.
+            (?P<patch>0|[1-9]\d*)
+        )
+        (?P<pre>                                          # pre-release
+            [-_\.]?
+            (?P<pre_l>(a|b|c|rc|alpha|beta|pre|preview))
+            [-_\.]?
+            (?P<pre_n>[0-9]+)?
+        )?
+        (?P<post>                                         # post release
+            (?:-(?P<post_n1>[0-9]+))
+            |
+            (?:
+                [-_\.]?
+                (?P<post_l>post|rev|r)
+                [-_\.]?
+                (?P<post_n2>[0-9]+)?
+            )
+        )?
+        (?P<dev>                                          # dev release
+            [-_\.]?
+            (?P<dev_l>dev)
+            [-_\.]?
+            (?P<dev_n>[0-9]+)?
+        )?
+    )
+    (?:\+(?P<local>[a-z0-9]+(?:[-_\.][a-z0-9]+)*))?       # local version
+"""
+
 
 class VersionPart:
     """
diff --git a/bumpversion/versioning/serialization.py b/bumpversion/versioning/serialization.py
new file mode 100644
index 00000000..91bd76ab
--- /dev/null
+++ b/bumpversion/versioning/serialization.py
@@ -0,0 +1,56 @@
+"""Functions for serializing and deserializing version objects."""
+import re
+from typing import Dict
+
+from bumpversion.exceptions import BumpVersionError
+from bumpversion.ui import get_indented_logger
+from bumpversion.utils import key_val_string
+
+logger = get_indented_logger(__name__)
+
+
+def parse_version(version_string: str, parse_pattern: str) -> Dict[str, str]:
+    """
+    Parse a version string into a dictionary of the parts and values using a regular expression.
+
+    Args:
+        version_string: Version string to parse
+        parse_pattern: The regular expression pattern to use for parsing
+
+    Returns:
+        A dictionary of version part labels and their values, or an empty dictionary
+        if the version string doesn't match.
+
+    Raises:
+        BumpVersionError: If the parse_pattern is not a valid regular expression
+    """
+    if not version_string:
+        logger.debug("Version string is empty, returning empty dict")
+        return {}
+    elif not parse_pattern:
+        logger.debug("Parse pattern is empty, returning empty dict")
+        return {}
+
+    logger.debug("Parsing version '%s' using regexp '%s'", version_string, parse_pattern)
+    logger.indent()
+
+    try:
+        pattern = re.compile(parse_pattern, re.VERBOSE)
+    except re.error as e:
+        raise BumpVersionError(f"'{parse_pattern}' is not a valid regular expression.") from e
+
+    match = re.search(pattern, version_string)
+
+    if not match:
+        logger.debug(
+            "'%s' does not parse current version '%s'",
+            parse_pattern,
+            version_string,
+        )
+        return {}
+
+    parsed = match.groupdict(default="")
+    logger.debug("Parsed the following values: %s", key_val_string(parsed))
+    logger.dedent()
+
+    return parsed
diff --git a/tests/test_version_part.py b/tests/test_version_part.py
index fa9b60cd..e21766d2 100644
--- a/tests/test_version_part.py
+++ b/tests/test_version_part.py
@@ -235,15 +235,6 @@ def test_version_part_invalid_regex_exit(tmp_path: Path) -> None:
             get_config_data(overrides)
 
 
-def test_parse_doesnt_parse_current_version(tmp_path: Path, caplog: LogCaptureFixture) -> None:
-    """A warning should be output when the parse regex doesn't parse the version."""
-    overrides = {"current_version": "12", "parse": "xxx"}
-    with inside_dir(tmp_path):
-        get_config_data(overrides)
-
-    assert "    Evaluating 'parse' option: 'xxx' does not parse current version '12'" in caplog.messages
-
-
 def test_part_does_not_revert_to_zero_if_optional(tmp_path: Path) -> None:
     """A non-numeric part with the optional value should not revert to zero."""
     # From https://github.com/c4urself/bump2version/issues/248
diff --git a/tests/test_versioning/test_serialization.py b/tests/test_versioning/test_serialization.py
new file mode 100644
index 00000000..213a8ba7
--- /dev/null
+++ b/tests/test_versioning/test_serialization.py
@@ -0,0 +1,62 @@
+"""Tests for the serialization of versioned objects."""
+from bumpversion.versioning.serialization import parse_version
+from bumpversion.versioning.models import SEMVER_PATTERN
+from bumpversion.exceptions import BumpVersionError
+
+import pytest
+from pytest import param
+
+
+class TestParseVersion:
+    """Test the parse_version function."""
+
+    def test_empty_version_returns_empty_dict(self):
+        assert parse_version("", "") == {}
+        assert parse_version(None, "") == {}
+
+    def test_empty_parse_pattern_returns_empty_dict(self):
+        assert parse_version("1.2.3", "") == {}
+        assert parse_version("1.2.3", None) == {}
+
+    @pytest.mark.parametrize(
+        ["version_string", "parse_pattern", "expected"],
+        [
+            param(
+                "1.2.3",
+                SEMVER_PATTERN,
+                {"buildmetadata": "", "major": "1", "minor": "2", "patch": "3", "pre_l": "", "pre_n": ""},
+                id="parse-version",
+            ),
+            param(
+                "1.2.3-alpha1",
+                SEMVER_PATTERN,
+                {"buildmetadata": "", "major": "1", "minor": "2", "patch": "3", "pre_l": "alpha", "pre_n": "1"},
+                id="parse-prerelease",
+            ),
+            param(
+                "1.2.3+build.1",
+                SEMVER_PATTERN,
+                {"buildmetadata": "build.1", "major": "1", "minor": "2", "patch": "3", "pre_l": "", "pre_n": ""},
+                id="parse-buildmetadata",
+            ),
+            param(
+                "1.2.3-alpha1+build.1",
+                SEMVER_PATTERN,
+                {"buildmetadata": "build.1", "major": "1", "minor": "2", "patch": "3", "pre_l": "alpha", "pre_n": "1"},
+                id="parse-prerelease-buildmetadata",
+            ),
+        ],
+    )
+    def test_parses_version_and_returns_full_dict(self, version_string: str, parse_pattern: str, expected: dict):
+        """The version string should be parsed into a dictionary of the parts and values, including missing parts."""
+        results = parse_version(version_string, parse_pattern)
+        assert results == expected
+
+    def test_unmatched_pattern_returns_empty_dict(self):
+        """If the version string doesn't match the parse pattern, an empty dictionary should be returned."""
+        assert parse_version("1.2.3", r"v(?P<major>\d+)\.(?P<minor>\d+)\.(?P<patch>\d+)") == {}
+
+    def test_invalid_parse_pattern_raises_error(self):
+        """If the parse pattern is not a valid regular expression, a ValueError should be raised."""
+        with pytest.raises(BumpVersionError):
+            parse_version("1.2.3", r"v(?P<major>\d+\.(?P<minor>\d+)\.(?P<patch>\d+)")

From 7d05414ebd6deedd110f0333733a2db9cc0df6a8 Mon Sep 17 00:00:00 2001
From: Corey Oordt <coreyoordt@gmail.com>
Date: Sat, 23 Dec 2023 17:57:24 -0600
Subject: [PATCH 04/11] Refactored versioning models and tests

---
 bumpversion/bump.py                           |   6 +-
 bumpversion/config/models.py                  |  19 +-
 bumpversion/config/utils.py                   |  31 ++-
 bumpversion/files.py                          |   6 +-
 bumpversion/version_part.py                   |  25 ++-
 bumpversion/versioning/functions.py           |  19 ++
 bumpversion/versioning/models.py              | 177 ++++++++++++----
 tests/test_bump.py                            |   2 +-
 tests/test_configuredfile.py                  |  11 +
 tests/test_files.py                           |  28 +--
 tests/test_version_part.py                    |  38 ++--
 tests/test_versioning/test_models_version.py  | 114 ++++++++++
 .../test_models_versioncomponent.py           |  67 ++++++
 .../test_models_versionpart.py                |  68 ------
 .../test_models_versionspec.py                | 194 ++++++++++++++++++
 15 files changed, 623 insertions(+), 182 deletions(-)
 create mode 100644 tests/test_versioning/test_models_version.py
 create mode 100644 tests/test_versioning/test_models_versioncomponent.py
 delete mode 100644 tests/test_versioning/test_models_versionpart.py
 create mode 100644 tests/test_versioning/test_models_versionspec.py

diff --git a/bumpversion/bump.py b/bumpversion/bump.py
index 40ae459f..75aea7a5 100644
--- a/bumpversion/bump.py
+++ b/bumpversion/bump.py
@@ -42,11 +42,11 @@ def get_next_version(
     elif version_part:
         logger.info("Attempting to increment part '%s'", version_part)
         logger.indent()
-        next_version = current_version.bump(version_part, config.version_config.order)
+        next_version = current_version.bump(version_part)
     else:
         raise ConfigurationError("Unable to get the next version.")
 
-    logger.info("Values are now: %s", key_val_string(next_version.values))
+    logger.info("Values are now: %s", key_val_string(next_version.components))
     logger.dedent()
     return next_version
 
@@ -113,7 +113,7 @@ def commit_and_tag(
     dry_run: bool = False,
 ) -> None:
     """
-    Commit and tag the changes, if a tool is configured.
+    Commit and tag the changes if a tool is configured.
 
     Args:
         config: The configuration
diff --git a/bumpversion/config/models.py b/bumpversion/config/models.py
index a69ff0ef..84b8bdf5 100644
--- a/bumpversion/config/models.py
+++ b/bumpversion/config/models.py
@@ -14,20 +14,11 @@
 if TYPE_CHECKING:
     from bumpversion.scm import SCMInfo
     from bumpversion.version_part import VersionConfig
+    from bumpversion.versioning.models import VersionComponentConfig, VersionSpec
 
 logger = get_indented_logger(__name__)
 
 
-class VersionPartConfig(BaseModel):
-    """Configuration of a part of the version."""
-
-    values: Optional[list] = None  # Optional. Numeric is used if missing or no items in list
-    optional_value: Optional[str] = None  # Optional.
-    # Defaults to first value. 0 in the case of numeric. Empty string means nothing is optional.
-    first_value: Union[str, int, None] = None  # Optional. Defaults to first value in values
-    independent: bool = False
-
-
 class FileChange(BaseModel):
     """A change to make to a file."""
 
@@ -100,7 +91,7 @@ class Config(BaseSettings):
     message: str
     commit_args: Optional[str]
     scm_info: Optional["SCMInfo"]
-    parts: Dict[str, VersionPartConfig]
+    parts: Dict[str, VersionComponentConfig]
     files: List[FileChange] = Field(default_factory=list)
     included_paths: List[str] = Field(default_factory=list)
     excluded_paths: List[str] = Field(default_factory=list)
@@ -169,3 +160,9 @@ def version_config(self) -> "VersionConfig":
         from bumpversion.version_part import VersionConfig
 
         return VersionConfig(self.parse, self.serialize, self.search, self.replace, self.parts)
+
+    def version_spec(self, version: Optional[str] = None) -> "VersionSpec":
+        """Return the version specification."""
+        from bumpversion.versioning.models import VersionSpec
+
+        return VersionSpec(self.parts)
diff --git a/bumpversion/config/utils.py b/bumpversion/config/utils.py
index 61fb1b7d..bad3f3fd 100644
--- a/bumpversion/config/utils.py
+++ b/bumpversion/config/utils.py
@@ -2,11 +2,12 @@
 from __future__ import annotations
 
 import glob
-import itertools
 from typing import Dict, List
 
-from bumpversion.config.models import FileChange, VersionPartConfig
-from bumpversion.utils import labels_for_format
+from exceptions import BumpVersionError
+
+from bumpversion.config.models import FileChange
+from bumpversion.versioning.models import VersionComponentConfig
 
 
 def get_all_file_configs(config_dict: dict) -> List[FileChange]:
@@ -25,15 +26,25 @@ def get_all_file_configs(config_dict: dict) -> List[FileChange]:
     return [FileChange(**f) for f in files]
 
 
-def get_all_part_configs(config_dict: dict) -> Dict[str, VersionPartConfig]:
+def get_all_part_configs(config_dict: dict) -> Dict[str, VersionComponentConfig]:
     """Make sure all version parts are included."""
-    serialize = config_dict["serialize"]
+    import re
+
+    try:
+        parsing_groups = list(re.compile(config_dict["parse"]).groupindex.keys())
+    except re.error as e:
+        raise BumpVersionError(f"Could not parse regex '{config_dict['parse']}': {e}") from e
     parts = config_dict["parts"]
-    all_labels = set(itertools.chain.from_iterable([labels_for_format(fmt) for fmt in serialize]))
-    return {
-        label: VersionPartConfig(**parts[label]) if label in parts else VersionPartConfig()  # type: ignore[call-arg]
-        for label in all_labels
-    }
+
+    part_configs = {}
+    for label in parsing_groups:
+        is_independent = label.startswith("$")
+        part_configs[label] = (
+            VersionComponentConfig(**parts[label])
+            if label in parts
+            else VersionComponentConfig(independent=is_independent)
+        )
+    return part_configs
 
 
 def resolve_glob_files(file_cfg: FileChange) -> List[FileChange]:
diff --git a/bumpversion/files.py b/bumpversion/files.py
index d56ecd2d..c630a1f6 100644
--- a/bumpversion/files.py
+++ b/bumpversion/files.py
@@ -6,7 +6,9 @@
 from pathlib import Path
 from typing import Dict, List, MutableMapping, Optional
 
-from bumpversion.config.models import FileChange, VersionPartConfig
+from versioning.models import VersionComponentConfig
+
+from bumpversion.config.models import FileChange
 from bumpversion.exceptions import VersionNotFoundError
 from bumpversion.ui import get_indented_logger
 from bumpversion.version_part import VersionConfig
@@ -297,7 +299,7 @@ class DataFileUpdater:
     def __init__(
         self,
         file_change: FileChange,
-        version_part_configs: Dict[str, VersionPartConfig],
+        version_part_configs: Dict[str, VersionComponentConfig],
     ) -> None:
         self.file_change = file_change
         self.version_config = VersionConfig(
diff --git a/bumpversion/version_part.py b/bumpversion/version_part.py
index 880f1687..b3a4b39c 100644
--- a/bumpversion/version_part.py
+++ b/bumpversion/version_part.py
@@ -5,12 +5,12 @@
 from typing import Any, Dict, List, MutableMapping, Optional, Tuple
 
 from click import UsageError
+from versioning.models import VersionComponentConfig
 
-from bumpversion.config.models import VersionPartConfig
 from bumpversion.exceptions import FormattingError, MissingValueError
 from bumpversion.ui import get_indented_logger
 from bumpversion.utils import labels_for_format
-from bumpversion.versioning.models import Version, VersionPart
+from bumpversion.versioning.models import Version, VersionComponent, VersionSpec
 from bumpversion.versioning.serialization import parse_version
 
 logger = get_indented_logger(__name__)
@@ -27,7 +27,7 @@ def __init__(
         serialize: Tuple[str],
         search: str,
         replace: str,
-        part_configs: Optional[Dict[str, VersionPartConfig]] = None,
+        part_configs: Optional[Dict[str, VersionComponentConfig]] = None,
     ):
         try:
             self.parse_regex = re.compile(parse, re.VERBOSE)
@@ -36,6 +36,7 @@ def __init__(
 
         self.serialize_formats = serialize
         self.part_configs = part_configs or {}
+        self.version_spec = VersionSpec(self.part_configs)
         # TODO: I think these two should be removed from the config object
         self.search = search
         self.replace = replace
@@ -80,12 +81,16 @@ def parse(self, version_string: Optional[str] = None) -> Optional[Version]:
         if not parsed:
             return None
 
-        _parsed = {
-            key: VersionPart(self.part_configs[key], value)
-            for key, value in parsed.items()
-            if key in self.part_configs
-        }
-        return Version(_parsed, version_string)
+        version = self.version_spec.create_version(parsed)
+        version.original = version_string
+        return version
+
+        # _parsed = {
+        #     key: VersionComponent(self.part_configs[key], value)
+        #     for key, value in parsed.items()
+        #     if key in self.part_configs
+        # }
+        # return Version(_parsed, version_string)
 
     def _serialize(
         self, version: Version, serialize_format: str, context: MutableMapping, raise_if_incomplete: bool = False
@@ -128,7 +133,7 @@ def _serialize(
         for i, k in enumerate(keys):
             v = values[k]
 
-            if not isinstance(v, VersionPart):
+            if not isinstance(v, VersionComponent):
                 # values coming from environment variables don't need
                 # representation
                 continue
diff --git a/bumpversion/versioning/functions.py b/bumpversion/versioning/functions.py
index 7cc96290..59e4c795 100644
--- a/bumpversion/versioning/functions.py
+++ b/bumpversion/versioning/functions.py
@@ -15,6 +15,23 @@ def bump(self, value: str) -> str:
         raise NotImplementedError
 
 
+class IndependentFunction(PartFunction):
+    """
+    This is a class that provides an independent function for version parts.
+
+    It simply returns the optional value, which is equal to the first value.
+    """
+
+    def __init__(self, value: Union[str, int, None] = None):
+        self.first_value = str(value)
+        self.optional_value = str(value)
+        self.independent = True
+
+    def bump(self, value: str) -> str:
+        """Return the optional value."""
+        return self.optional_value
+
+
 class NumericFunction(PartFunction):
     """
     This is a class that provides a numeric function for version parts.
@@ -37,6 +54,7 @@ def __init__(self, optional_value: Union[str, int, None] = None, first_value: Un
 
         self.first_value = str(first_value or 0)
         self.optional_value = str(optional_value or self.first_value)
+        self.independent = False
 
     def bump(self, value: Union[str, int]) -> str:
         """Increase the first numerical value by one."""
@@ -80,6 +98,7 @@ def __init__(
             raise ValueError("Version part values cannot be empty")
 
         self._values = values
+        self.independent = False
 
         if optional_value is None:
             optional_value = values[0]
diff --git a/bumpversion/versioning/models.py b/bumpversion/versioning/models.py
index aa754a29..42d23be3 100644
--- a/bumpversion/versioning/models.py
+++ b/bumpversion/versioning/models.py
@@ -1,7 +1,11 @@
 """Models for managing versioning of software projects."""
+from __future__ import annotations
+
+from collections import defaultdict, deque
 from typing import Any, Dict, List, Optional, Union
 
-from bumpversion.config.models import VersionPartConfig
+from pydantic import BaseModel
+
 from bumpversion.exceptions import InvalidVersionPartError
 from bumpversion.utils import key_val_string
 from bumpversion.versioning.functions import NumericFunction, PartFunction, ValuesFunction
@@ -62,7 +66,7 @@
 """
 
 
-class VersionPart:
+class VersionComponent:
     """
     Represent part of a version number.
 
@@ -70,34 +74,54 @@ class VersionPart:
     based on the configuration given.
     """
 
-    def __init__(self, config: VersionPartConfig, value: Union[str, int, None] = None):
+    def __init__(
+        self,
+        values: Optional[list] = None,
+        optional_value: Optional[str] = None,
+        first_value: Union[str, int, None] = None,
+        independent: bool = False,
+        source: Optional[str] = None,
+        value: Union[str, int, None] = None,
+    ):
         self._value = str(value) if value is not None else None
-        self.config = config
         self.func: Optional[PartFunction] = None
-        if config.values:
-            str_values = [str(v) for v in config.values]
-            str_optional_value = str(config.optional_value) if config.optional_value is not None else None
-            str_first_value = str(config.first_value) if config.first_value is not None else None
+        self.independent = independent
+        self.source = source
+        if values:
+            str_values = [str(v) for v in values]
+            str_optional_value = str(optional_value) if optional_value is not None else None
+            str_first_value = str(first_value) if first_value is not None else None
             self.func = ValuesFunction(str_values, str_optional_value, str_first_value)
         else:
-            self.func = NumericFunction(config.optional_value, config.first_value or "0")
+            self.func = NumericFunction(optional_value, first_value or "0")
 
     @property
     def value(self) -> str:
         """Return the value of the part."""
         return self._value or self.func.optional_value
 
-    def copy(self) -> "VersionPart":
+    def copy(self) -> "VersionComponent":
         """Return a copy of the part."""
-        return VersionPart(self.config, self._value)
+        return VersionComponent(
+            values=getattr(self.func, "_values", None),
+            optional_value=self.func.optional_value,
+            first_value=self.func.first_value,
+            independent=self.independent,
+            source=self.source,
+            value=self._value,
+        )
 
-    def bump(self) -> "VersionPart":
+    def bump(self) -> "VersionComponent":
         """Return a part with bumped value."""
-        return VersionPart(self.config, self.func.bump(self.value))
+        new_component = self.copy()
+        new_component._value = self.func.bump(self.value)
+        return new_component
 
-    def null(self) -> "VersionPart":
+    def null(self) -> "VersionComponent":
         """Return a part with first value."""
-        return VersionPart(self.config, self.func.first_value)
+        new_component = self.copy()
+        new_component._value = self.func.first_value
+        return new_component
 
     @property
     def is_optional(self) -> bool:
@@ -107,7 +131,7 @@ def is_optional(self) -> bool:
     @property
     def is_independent(self) -> bool:
         """Is the part independent of the other parts?"""
-        return self.config.independent
+        return self.independent
 
     def __format__(self, format_spec: str) -> str:
         try:
@@ -121,53 +145,118 @@ def __repr__(self) -> str:
         return f"<bumpversion.VersionPart:{self.func.__class__.__name__}:{self.value}>"
 
     def __eq__(self, other: Any) -> bool:
-        return self.value == other.value if isinstance(other, VersionPart) else False
+        return self.value == other.value if isinstance(other, VersionComponent) else False
+
+
+class VersionComponentConfig(BaseModel):
+    """
+    Configuration of a version component.
+
+    This is used to read in the configuration from the bumpversion config file.
+    """
+
+    values: Optional[list] = None  # Optional. Numeric is used if missing or no items in list
+    optional_value: Optional[str] = None  # Optional.
+    # Defaults to first value. 0 in the case of numeric. Empty string means nothing is optional.
+    first_value: Union[str, int, None] = None  # Optional. Defaults to first value in values
+    independent: bool = False
+    # source: Optional[str] = None  # Name of environment variable or context variable to use as the source for value
+
+    def generate_component(self, value: Union[str, int, None] = None) -> VersionComponent:
+        """Generate a version component from the configuration."""
+        return VersionComponent(
+            values=self.values,
+            optional_value=self.optional_value,
+            first_value=self.first_value,
+            independent=self.independent,
+            # source=self.source,
+            value=value,
+        )
+
+
+class VersionSpec:
+    """The specification of a version's components and their relationships."""
+
+    def __init__(self, components: Dict[str, VersionComponentConfig], order: Optional[List[str]] = None):
+        if not components:
+            raise ValueError("A VersionSpec must have at least one component.")
+        if not order:
+            order = list(components.keys())
+        if len(set(order) - set(components.keys())) > 0:
+            raise ValueError("The order of components refers to items that are not in your components.")
+
+        self.component_configs = components
+        self.order = order
+        self.dependency_map = defaultdict(list)
+        previous_component = self.order[0]
+        for component in self.order[1:]:
+            if self.component_configs[component].independent:
+                continue
+            self.dependency_map[previous_component].append(component)
+            previous_component = component
+
+    def create_version(self, values: Dict[str, str]) -> "Version":
+        """Generate a version from the given values."""
+        components = {
+            key: comp_config.generate_component(value=values.get(key))
+            for key, comp_config in self.component_configs.items()
+        }
+        return Version(version_spec=self, components=components)
+
+    def get_dependents(self, component_name: str) -> List[str]:
+        """Return the parts that depend on the given part."""
+        stack = deque(self.dependency_map.get(component_name, []), maxlen=len(self.order))
+        visited = []
+
+        while stack:
+            e = stack.pop()
+            if e not in visited:
+                visited.append(e)
+                stack.extendleft(self.dependency_map[e])
+
+        return visited
 
 
 class Version:
     """The specification of a version and its parts."""
 
-    def __init__(self, values: Dict[str, VersionPart], original: Optional[str] = None):
-        self.values = values
+    def __init__(
+        self, version_spec: VersionSpec, components: Dict[str, VersionComponent], original: Optional[str] = None
+    ):
+        self.version_spec = version_spec
+        self.components = components
         self.original = original
 
-    def __getitem__(self, key: str) -> VersionPart:
-        return self.values[key]
+    def __getitem__(self, key: str) -> VersionComponent:
+        return self.components[key]
 
     def __len__(self) -> int:
-        return len(self.values)
+        return len(self.components)
 
     def __iter__(self):
-        return iter(self.values)
+        return iter(self.components)
 
     def __repr__(self):
-        return f"<bumpversion.Version:{key_val_string(self.values)}>"
+        return f"<bumpversion.Version:{key_val_string(self.components)}>"
 
     def __eq__(self, other: Any) -> bool:
         return (
-            all(value == other.values[key] for key, value in self.values.items())
+            all(value == other.components[key] for key, value in self.components.items())
             if isinstance(other, Version)
             else False
         )
 
-    def bump(self, part_name: str, order: List[str]) -> "Version":
-        """Increase the value of the given part."""
-        bumped = False
+    def bump(self, component_name: str) -> "Version":
+        """Increase the value of the specified component, reset its dependents, and return a new Version."""
+        if component_name not in self.components:
+            raise InvalidVersionPartError(f"No part named {component_name!r}")
 
-        new_values = {}
+        components_to_reset = self.version_spec.get_dependents(component_name)
 
-        for label in order:
-            if label not in self.values:
-                continue
-            if label == part_name:
-                new_values[label] = self.values[label].bump()
-                bumped = True
-            elif bumped and not self.values[label].is_independent:
-                new_values[label] = self.values[label].null()
-            else:
-                new_values[label] = self.values[label].copy()
-
-        if not bumped:
-            raise InvalidVersionPartError(f"No part named {part_name!r}")
-
-        return Version(new_values)
+        new_values = dict(self.components.items())
+        new_values[component_name] = self.components[component_name].bump()
+        for component in components_to_reset:
+            if not self.components[component].is_independent:
+                new_values[component] = self.components[component].null()
+
+        return Version(self.version_spec, new_values, self.original)
diff --git a/tests/test_bump.py b/tests/test_bump.py
index 2e4d080a..e96cfa4f 100644
--- a/tests/test_bump.py
+++ b/tests/test_bump.py
@@ -84,7 +84,7 @@ def test_do_bump_with_version_part(mock_update_config_file, mock_modify_files):
     assert mock_update_config_file.call_args[0][0] is None
     assert mock_update_config_file.call_args[0][1] == config
     assert mock_update_config_file.call_args[0][2] == current_version
-    assert mock_update_config_file.call_args[0][3] == current_version.bump(version_part, version_config.order)
+    assert mock_update_config_file.call_args[0][3] == current_version.bump(version_part)
     assert mock_update_config_file.call_args[0][5] is False
 
 
diff --git a/tests/test_configuredfile.py b/tests/test_configuredfile.py
index f1043572..258be08f 100644
--- a/tests/test_configuredfile.py
+++ b/tests/test_configuredfile.py
@@ -1,6 +1,7 @@
 """Tests for the ConfiguredFile class."""
 from bumpversion.files import ConfiguredFile, FileChange
 from bumpversion.version_part import VersionConfig
+from versioning.models import VersionComponentConfig
 
 
 class TestConfiguredFile:
@@ -25,6 +26,11 @@ def test_file_change_is_identical_to_input(self):
                 serialize=("{major}.{minor}.{patch}",),
                 search="{current_version}",
                 replace="{new_version}",
+                part_configs={
+                    "major": VersionComponentConfig(),
+                    "minor": VersionComponentConfig(),
+                    "patch": VersionComponentConfig(),
+                },
             )
             cfg_file = ConfiguredFile(change, version_config)
             assert cfg_file.file_change == change
@@ -46,6 +52,11 @@ def test_version_config_uses_file_change_attrs(self):
                 serialize=("{major}.{minor}.{patch}",),
                 search="{current_version}",
                 replace="{new_version}",
+                part_configs={
+                    "major": VersionComponentConfig(),
+                    "minor": VersionComponentConfig(),
+                    "patch": VersionComponentConfig(),
+                },
             )
             expected = VersionConfig(
                 parse=change.parse,
diff --git a/tests/test_files.py b/tests/test_files.py
index 847d2cf7..88618ded 100644
--- a/tests/test_files.py
+++ b/tests/test_files.py
@@ -47,7 +47,7 @@ def test_single_file_processed_twice(tmp_path: Path):
         ],
     }
     conf, version_config, current_version = get_config_data(overrides)
-    new_version = current_version.bump("patch", version_config.order)
+    new_version = current_version.bump("patch")
     ctx = get_context(conf)
 
     assert len(conf.files) == 2
@@ -96,7 +96,7 @@ def test_multi_file_configuration(tmp_path: Path):
         ],
     }
     conf, version_config, current_version = get_config_data(overrides)
-    major_version = current_version.bump("major", version_config.order)
+    major_version = current_version.bump("major")
 
     os.environ["BUILD_NUMBER"] = "38944"
     os.environ["USER"] = "bob"
@@ -120,7 +120,7 @@ def test_multi_file_configuration(tmp_path: Path):
     del os.environ["BUILD_NUMBER"]
     del os.environ["USER"]
     major_version = version_config.parse(conf.current_version)
-    major_patch_version = major_version.bump("patch", version_config.order)
+    major_patch_version = major_version.bump("patch")
     for file_cfg in conf.files:
         cfg_file = files.ConfiguredFile(file_cfg, version_config)
         cfg_file.make_file_change(major_version, major_patch_version, ctx)
@@ -142,7 +142,7 @@ def test_raises_correct_missing_version_string(tmp_path: Path, fixtures_path: Pa
         current_version = version_config.parse(conf.current_version)
         dst_path.joinpath("Version.csv").write_text("1;3-1;0;rc;build.1031")
 
-        major_version = current_version.bump("patch", version_config.order)
+        major_version = current_version.bump("patch")
         ctx = get_context(conf)
 
         configured_files = [files.ConfiguredFile(file_cfg, version_config) for file_cfg in conf.files]
@@ -216,7 +216,7 @@ def test_search_replace_to_avoid_updating_unconcerned_lines(tmp_path: Path, capl
     }
 
     conf, version_config, current_version = get_config_data(overrides)
-    new_version = current_version.bump("minor", version_config.order)
+    new_version = current_version.bump("minor")
 
     for file_cfg in conf.files:
         cfg_file = files.ConfiguredFile(file_cfg, version_config)
@@ -269,7 +269,7 @@ def test_non_matching_search_does_not_modify_file(tmp_path: Path):
         ],
     }
     conf, version_config, current_version = get_config_data(overrides)
-    new_version = current_version.bump("patch", version_config.order)
+    new_version = current_version.bump("patch")
     configured_files = files.resolve_file_config(conf.files, version_config)
     with pytest.raises(exceptions.VersionNotFoundError, match="Did not find 'Not-yet-released' in file:"):
         files.modify_files(configured_files, current_version, new_version, get_context(conf))
@@ -286,7 +286,7 @@ def test_simple_replacement_in_utf8_file(tmp_path: Path):
     overrides = {"current_version": "1.3.0", "files": [{"filename": str(version_path)}]}
     with inside_dir(tmp_path):
         conf, version_config, current_version = get_config_data(overrides)
-        new_version = current_version.bump("patch", version_config.order)
+        new_version = current_version.bump("patch")
 
     # Act
     for file_cfg in conf.files:
@@ -312,7 +312,7 @@ def test_multi_line_search_is_found(tmp_path: Path) -> None:
     }
     with inside_dir(tmp_path):
         conf, version_config, current_version = get_config_data(overrides)
-        new_version = current_version.bump("major", version_config.order)
+        new_version = current_version.bump("major")
 
     # Act
     for file_cfg in conf.files:
@@ -345,7 +345,7 @@ def test_ignore_missing_version(global_value: bool, file_value: bool, should_rai
     }
     with inside_dir(tmp_path):
         conf, version_config, current_version = get_config_data(overrides)
-        new_version = current_version.bump("patch", version_config.order)
+        new_version = current_version.bump("patch")
         cfg_files = [files.ConfiguredFile(file_cfg, version_config) for file_cfg in conf.files]
 
         # Act
@@ -373,7 +373,7 @@ def test_regex_search(tmp_path: Path) -> None:
         "files": [{"filename": str(version_path)}],
     }
     conf, version_config, current_version = get_config_data(overrides)
-    new_version = current_version.bump("patch", version_config.order)
+    new_version = current_version.bump("patch")
     cfg_files = [files.ConfiguredFile(file_cfg, version_config) for file_cfg in conf.files]
 
     # Act
@@ -398,7 +398,7 @@ def test_regex_search_with_escaped_chars(tmp_path: Path) -> None:
         "files": [{"filename": str(version_path)}],
     }
     conf, version_config, current_version = get_config_data(overrides)
-    new_version = current_version.bump("patch", version_config.order)
+    new_version = current_version.bump("patch")
     cfg_files = [files.ConfiguredFile(file_cfg, version_config) for file_cfg in conf.files]
 
     # Act
@@ -420,7 +420,7 @@ def test_regex_search_with_caret(tmp_path: Path, fixtures_path: Path) -> None:
     conf = config.get_configuration(config_file=config_path)
     version_config = VersionConfig(conf.parse, conf.serialize, conf.search, conf.replace, conf.parts)
     current_version = version_config.parse(conf.current_version)
-    new_version = current_version.bump("patch", version_config.order)
+    new_version = current_version.bump("patch")
 
     with inside_dir(tmp_path):
         cfg_files = [files.ConfiguredFile(file_cfg, version_config) for file_cfg in conf.files]
@@ -448,7 +448,7 @@ def test_bad_regex_search(tmp_path: Path, caplog) -> None:
         "files": [{"filename": str(version_path)}],
     }
     conf, version_config, current_version = get_config_data(overrides)
-    new_version = current_version.bump("patch", version_config.order)
+    new_version = current_version.bump("patch")
     cfg_files = [files.ConfiguredFile(file_cfg, version_config) for file_cfg in conf.files]
 
     # Act
@@ -470,7 +470,7 @@ def test_datafileupdater_replaces_key(tmp_path: Path, fixtures_path: Path) -> No
     conf = config.get_configuration(config_file=config_path, files=[{"filename": str(config_path)}])
     version_config = VersionConfig(conf.parse, conf.serialize, conf.search, conf.replace, conf.parts)
     current_version = version_config.parse(conf.current_version)
-    new_version = current_version.bump("minor", version_config.order)
+    new_version = current_version.bump("minor")
     datafile_config = FileChange(
         filename=str(config_path),
         key_path="tool.bumpversion.current_version",
diff --git a/tests/test_version_part.py b/tests/test_version_part.py
index e21766d2..21bddde6 100644
--- a/tests/test_version_part.py
+++ b/tests/test_version_part.py
@@ -16,7 +16,7 @@ def test_bump_version_missing_part():
     }
     conf, version_config, current_version = get_config_data(overrides)
     with pytest.raises(exceptions.InvalidVersionPartError, match="No part named 'bugfix'"):
-        current_version.bump("bugfix", version_config.order)
+        current_version.bump("bugfix")
 
 
 def test_build_number_configuration():
@@ -32,18 +32,18 @@ def test_build_number_configuration():
     }
     conf, version_config, current_version = get_config_data(overrides)
 
-    build_version_bump = current_version.bump("build", version_config.order)
-    assert build_version_bump.values["build"].value == "5124"
-    assert build_version_bump.values["build"].is_independent
+    build_version_bump = current_version.bump("build")
+    assert build_version_bump["build"].value == "5124"
+    assert build_version_bump["build"].is_independent
 
-    major_version_bump = build_version_bump.bump("major", version_config.order)
-    assert major_version_bump.values["build"].value == "5124"
-    assert build_version_bump.values["build"].is_independent
-    assert major_version_bump.values["major"].value == "3"
+    major_version_bump = build_version_bump.bump("major")
+    assert major_version_bump["build"].value == "5124"
+    assert build_version_bump["build"].is_independent
+    assert major_version_bump["major"].value == "3"
 
-    build_version_bump = major_version_bump.bump("build", version_config.order)
-    assert build_version_bump.values["build"].value == "5125"
-    assert build_version_bump.values["build"].is_independent
+    build_version_bump = major_version_bump.bump("build")
+    assert build_version_bump["build"].value == "5125"
+    assert build_version_bump["build"].is_independent
 
 
 def test_serialize_with_distance_to_latest_tag():
@@ -83,7 +83,7 @@ def test_serialize_with_newlines():
         "serialize": ["MAJOR={major}\nMINOR={minor}\nPATCH={patch}\n"],
     }
     conf, version_config, current_version = get_config_data(overrides)
-    new_version = current_version.bump("major", version_config.order)
+    new_version = current_version.bump("major")
     assert version_config.serialize(new_version, get_context(conf)) == "MAJOR=32\nMINOR=0\nPATCH=0\n"
 
 
@@ -103,7 +103,7 @@ def test_serialize_three_part(bump_type: str, expected: str):
     }
     conf, version_config, current_version = get_config_data(overrides)
 
-    new_version = current_version.bump(bump_type, version_config.order)
+    new_version = current_version.bump(bump_type)
     assert version_config.serialize(new_version, get_context(conf)) == expected
 
 
@@ -128,7 +128,7 @@ def test_bump_non_numeric_parts(initial: str, bump_type: str, expected: str):
     }
     conf, version_config, current_version = get_config_data(overrides)
 
-    new_version = current_version.bump(bump_type, version_config.order)
+    new_version = current_version.bump(bump_type)
     assert version_config.serialize(new_version, get_context(conf)) == expected
 
 
@@ -153,7 +153,7 @@ def test_optional_value(initial: str, bump_type: str, expected: str):
     }
     conf, version_config, current_version = get_config_data(overrides)
 
-    new_version = current_version.bump(bump_type, version_config.order)
+    new_version = current_version.bump(bump_type)
     assert version_config.serialize(new_version, get_context(conf)) == expected
 
 
@@ -198,7 +198,7 @@ def test_python_pre_release_release_post_release(initial: str, bump_type: str, e
     }
     conf, version_config, current_version = get_config_data(overrides)
 
-    new_version = current_version.bump(bump_type, version_config.order)
+    new_version = current_version.bump(bump_type)
     assert version_config.serialize(new_version, get_context(conf)) == expected
 
 
@@ -219,7 +219,7 @@ def test_part_first_value(initial: str, bump_type: str, expected: str):
     }
     conf, version_config, current_version = get_config_data(overrides)
 
-    new_version = current_version.bump(bump_type, version_config.order)
+    new_version = current_version.bump(bump_type)
     assert version_config.serialize(new_version, get_context(conf)) == expected
 
 
@@ -263,7 +263,7 @@ def test_part_does_not_revert_to_zero_if_optional(tmp_path: Path) -> None:
     with inside_dir(tmp_path):
         conf, version_config, current_version = get_config_data(overrides)
 
-    new_version = current_version.bump("build", version_config.order)
+    new_version = current_version.bump("build")
     assert version_config.serialize(new_version, get_context(conf)) == "0.3.1g1"
 
 
@@ -292,7 +292,7 @@ def test_order_of_serialization(tmp_path: Path, caplog: LogCaptureFixture) -> No
     with inside_dir(tmp_path):
         conf, version_config, current_version = get_config_data(overrides)
 
-    new_version = current_version.bump("release", version_config.order)
+    new_version = current_version.bump("release")
     new_version_str = version_config.serialize(new_version, get_context(conf))
     for msg in caplog.messages:
         print(msg)
diff --git a/tests/test_versioning/test_models_version.py b/tests/test_versioning/test_models_version.py
new file mode 100644
index 00000000..7a7fcf67
--- /dev/null
+++ b/tests/test_versioning/test_models_version.py
@@ -0,0 +1,114 @@
+"""Tests for the Version class."""
+
+from versioning.models import VersionComponentConfig
+from bumpversion.versioning.models import VersionSpec, Version, VersionComponent
+import pytest
+
+
+@pytest.fixture
+def version_spec():
+    """Return a version spec."""
+    config = {
+        "major": VersionComponentConfig(),
+        "minor": VersionComponentConfig(),
+        "patch": VersionComponentConfig(),
+        "build": VersionComponentConfig(optional_value="0", independent=True),
+    }
+
+    return VersionSpec(config)
+
+
+class TestVersion:
+    """Test how the Version model should behave."""
+
+    def test_version_acts_like_a_dict(self, version_spec: VersionSpec):
+        """You can get version components by name."""
+        # Arrange
+        version = version_spec.create_version({"major": "1", "minor": "2", "patch": "3"})
+
+        # Assert
+        assert version["major"].value == "1"
+        assert version["minor"].value == "2"
+        assert version["patch"].value == "3"
+        assert version["build"].value == "0"
+
+        with pytest.raises(KeyError):
+            version["invalid"]
+
+    def test_version_has_a_length(self, version_spec: VersionSpec):
+        # Arrange
+        version = version_spec.create_version({"major": "1"})
+
+        # Assert
+        assert len(version) == 4
+
+    def test_version_is_iterable(self, version_spec: VersionSpec):
+        # Arrange
+        version = version_spec.create_version({"major": "1"})
+
+        # Assert
+        assert list(version) == ["major", "minor", "patch", "build"]
+
+    def test_version_has_a_string_representation(self, version_spec: VersionSpec):
+        # Arrange
+        version = version_spec.create_version({"major": "1", "minor": "2", "patch": "3"})
+
+        # Assert
+        assert repr(version) == "<bumpversion.Version:build=0, major=1, minor=2, patch=3>"
+
+    def test_version_has_an_equality_comparison(self, version_spec: VersionSpec):
+        # Arrange
+        version1 = version_spec.create_version({"major": "1", "minor": "2", "patch": "3"})
+        version2 = version_spec.create_version({"major": "1", "minor": "2", "patch": "3"})
+        version3 = version_spec.create_version({"major": "1", "minor": "2", "patch": "4"})
+
+        # Assert
+        assert version1 == version2
+        assert version1 != version3
+
+    class TestBump:
+        """Tests of the bump method."""
+
+        def test_bump_does_not_change_original_version(self, version_spec: VersionSpec):
+            """Bumping a version does not change the original version."""
+            # Arrange
+            version1 = version_spec.create_version({"major": "1", "minor": "2", "patch": "3"})
+
+            # Act
+            version2 = version1.bump("patch")
+
+            # Assert
+            assert version1["patch"].value == "3"
+            assert version2["patch"].value == "4"
+
+        def test_bump_returns_a_new_version(self, version_spec: VersionSpec):
+            """Bumping a version returns a new version."""
+            # Arrange
+            version1 = version_spec.create_version({"major": "1", "minor": "2", "patch": "3"})
+
+            # Act
+            version2 = version1.bump("patch")
+
+            # Assert
+            assert version1 is not version2
+
+        def test_bump_changes_component_and_dependents(self, version_spec: VersionSpec):
+            """Bumping a version bumps the specified component and changes its dependents."""
+            # Arrange
+            version1 = version_spec.create_version({"major": "1", "minor": "2", "patch": "3", "build": "4"})
+
+            # Act
+            patch_version = version1.bump("patch")
+            minor_version = version1.bump("minor")
+            major_version = version1.bump("major")
+            build_version = version1.bump("build")
+
+            # Assert
+            patch_version_str = ".".join([item.value for item in patch_version.components.values()])
+            minor_version_str = ".".join([item.value for item in minor_version.components.values()])
+            major_version_str = ".".join([item.value for item in major_version.components.values()])
+            build_version_str = ".".join([item.value for item in build_version.components.values()])
+            assert patch_version_str == "1.2.4.4"
+            assert minor_version_str == "1.3.0.4"
+            assert major_version_str == "2.0.0.4"
+            assert build_version_str == "1.2.3.5"
diff --git a/tests/test_versioning/test_models_versioncomponent.py b/tests/test_versioning/test_models_versioncomponent.py
new file mode 100644
index 00000000..3d7498f8
--- /dev/null
+++ b/tests/test_versioning/test_models_versioncomponent.py
@@ -0,0 +1,67 @@
+"""Tests of the VersionPart model."""
+
+from versioning.models import VersionComponentConfig
+from bumpversion.versioning.functions import ValuesFunction, NumericFunction
+import pytest
+
+
+@pytest.fixture(
+    params=[
+        None,
+        ("0", "1", "2"),
+        ("0", "3"),
+    ]
+)
+def version_component_config(request):
+    """Return a three-part and a two-part version part configuration."""
+    if request.param is None:
+        return VersionComponentConfig(optional_value="0", first_value="0")
+    else:
+        return VersionComponentConfig(values=request.param)
+
+
+class TestVersionComponent:
+    class TestCreation:
+        def test_none_value_uses_optional_value(self, version_component_config):
+            vp = version_component_config.generate_component()
+            assert vp.value == vp.func.optional_value
+            assert vp._value is None
+
+        def test_config_with_values_selects_values_function(self):
+            values = ["0", "1", "2"]
+            vp = VersionComponentConfig(values=values).generate_component()
+            assert isinstance(vp.func, ValuesFunction)
+
+        def test_config_without_values_selects_numeric_function(self):
+            vp = VersionComponentConfig().generate_component()
+            assert isinstance(vp.func, NumericFunction)
+
+    def test_copy_returns_new_version_part(self, version_component_config):
+        vp = version_component_config.generate_component(version_component_config.first_value)
+        vc = vp.copy()
+        assert vp.value == vc.value
+        assert id(vp) != id(vc)
+
+    def test_bump_increments_value(self, version_component_config):
+        vp = version_component_config.generate_component(version_component_config.first_value)
+        vc = vp.bump()
+        if version_component_config.values:
+            assert vc.value == str(version_component_config.values[1])
+        else:
+            assert vc.value == "1"
+
+    def test_non_first_value_is_not_optional(self, version_component_config):
+        assert not version_component_config.generate_component(version_component_config.first_value).bump().is_optional
+
+    def test_first_value_is_optional(self, version_component_config):
+        assert version_component_config.generate_component(version_component_config.first_value).is_optional
+
+    def test_versionparts_with_same_settings_are_equal(self, version_component_config):
+        version1 = version_component_config.generate_component(version_component_config.first_value)
+        version2 = version_component_config.generate_component(version_component_config.first_value)
+        assert version1 == version2
+
+    def test_null_resets_value_to_first_value(self, version_component_config):
+        version1 = version_component_config.generate_component(version_component_config.first_value)
+        version2 = version1.bump().null()
+        assert version2 == version1
diff --git a/tests/test_versioning/test_models_versionpart.py b/tests/test_versioning/test_models_versionpart.py
deleted file mode 100644
index 566b857c..00000000
--- a/tests/test_versioning/test_models_versionpart.py
+++ /dev/null
@@ -1,68 +0,0 @@
-"""Tests of the VersionPart model."""
-
-from bumpversion.versioning.models import VersionPart
-from bumpversion.config.models import VersionPartConfig
-from bumpversion.versioning.functions import ValuesFunction, NumericFunction
-import pytest
-
-
-@pytest.fixture(
-    params=[
-        None,
-        ("0", "1", "2"),
-        ("0", "3"),
-    ]
-)
-def version_part_config(request):
-    """Return a three-part and a two-part version part configuration."""
-    if request.param is None:
-        return VersionPartConfig(optional_value="0", first_value="0")
-    else:
-        return VersionPartConfig(values=request.param)
-
-
-class TestVersionPartConfig:
-    class TestCreation:
-        def test_none_value_uses_optional_value(self, version_part_config):
-            vp = VersionPart(version_part_config)
-            assert vp.value == vp.func.optional_value
-            assert vp._value is None
-
-        def test_config_with_values_selects_values_function(self):
-            values = ["0", "1", "2"]
-            vp = VersionPart(VersionPartConfig(values=values))
-            assert isinstance(vp.func, ValuesFunction)
-
-        def test_config_without_values_selects_numeric_function(self):
-            vp = VersionPart(VersionPartConfig())
-            assert isinstance(vp.func, NumericFunction)
-
-    def test_copy_returns_new_version_part(self, version_part_config):
-        vp = VersionPart(version_part_config, version_part_config.first_value)
-        vc = vp.copy()
-        assert vp.value == vc.value
-        assert id(vp) != id(vc)
-
-    def test_bump_increments_value(self, version_part_config):
-        vp = VersionPart(version_part_config, version_part_config.first_value)
-        vc = vp.bump()
-        if version_part_config.values:
-            assert vc.value == str(version_part_config.values[1])
-        else:
-            assert vc.value == "1"
-
-    def test_non_first_value_is_not_optional(self, version_part_config):
-        assert not VersionPart(version_part_config, version_part_config.first_value).bump().is_optional
-
-    def test_first_value_is_optional(self, version_part_config):
-        assert VersionPart(version_part_config, version_part_config.first_value).is_optional
-
-    def test_versionparts_with_same_settings_are_equal(self, version_part_config):
-        assert VersionPart(version_part_config, version_part_config.first_value) == VersionPart(
-            version_part_config, version_part_config.first_value
-        )
-
-    def test_null_resets_value_to_first_value(self, version_part_config):
-        assert VersionPart(version_part_config, version_part_config.first_value).null() == VersionPart(
-            version_part_config, version_part_config.first_value
-        )
diff --git a/tests/test_versioning/test_models_versionspec.py b/tests/test_versioning/test_models_versionspec.py
new file mode 100644
index 00000000..ea4de90f
--- /dev/null
+++ b/tests/test_versioning/test_models_versionspec.py
@@ -0,0 +1,194 @@
+"""Tests of the VersionSpec model."""
+
+import pytest
+from bumpversion.versioning.models import VersionSpec
+from versioning.models import VersionComponentConfig
+
+
+class TestVersionSpec:
+    """Tests for the version spec."""
+
+    class TestCreation:
+        """Tests for creating a version spec."""
+
+        def test_empty_components_raises_error(self):
+            """An empty components dict raises an error."""
+            with pytest.raises(ValueError):
+                VersionSpec({}, [])
+
+        class TestComponentOrder:
+            def test_empty_order_uses_order_of_components(self):
+                """If the order is empty, it uses the component order."""
+                # Arrange
+                config = {
+                    "major": VersionComponentConfig(),
+                    "minor": VersionComponentConfig(),
+                    "patch": VersionComponentConfig(),
+                }
+
+                # Act
+                version_spec = VersionSpec(config, [])
+
+                # Assert
+                assert version_spec.order == ["major", "minor", "patch"]
+
+            def test_extra_items_raises_error(self):
+                """If the order contains component names that do not exist, it raises and error."""
+                # Arrange
+                config = {
+                    "major": VersionComponentConfig(),
+                    "minor": VersionComponentConfig(),
+                    "patch": VersionComponentConfig(),
+                }
+
+                # Act
+                with pytest.raises(ValueError):
+                    VersionSpec(config, ["major", "minor", "patch", "build"])
+
+            def test_subset_of_items_works_fine(self):
+                """An order containing a subset of component names works fine."""
+                # Arrange
+                config = {
+                    "major": VersionComponentConfig(),
+                    "minor": VersionComponentConfig(),
+                    "patch": VersionComponentConfig(),
+                }
+
+                # Act
+                version_spec = VersionSpec(config, ["major", "patch"])
+
+                # Assert
+                assert dict(version_spec.dependency_map) == {"major": ["patch"]}
+
+        def test_dependency_map_follows_order(self):
+            """The order of components correctly creates the dependency map."""
+            # Arrange
+            config = {
+                "major": VersionComponentConfig(),
+                "minor": VersionComponentConfig(),
+                "patch": VersionComponentConfig(),
+            }
+
+            # Act
+            version_spec = VersionSpec(config, ["major", "minor", "patch"])
+            version_spec2 = VersionSpec(config, ["patch", "minor", "major"])
+
+            # Assert
+            assert dict(version_spec.dependency_map) == {"major": ["minor"], "minor": ["patch"]}
+            assert dict(version_spec2.dependency_map) == {"patch": ["minor"], "minor": ["major"]}
+
+        def test_dependency_map_skips_independent_components(self):
+            """Independent components are not in the dependency map."""
+            # Arrange
+            config = {
+                "major": VersionComponentConfig(),
+                "minor": VersionComponentConfig(independent=True),
+                "patch": VersionComponentConfig(),
+            }
+
+            # Act
+            version_spec = VersionSpec(config, ["major", "minor", "patch"])
+
+            # Assert
+            assert dict(version_spec.dependency_map) == {"major": ["patch"]}
+
+    class TestGenerateVersion:
+        """Tests of the generate_version method."""
+
+        def test_empty_values_creates_default_version(self):
+            """An empty values dict raises an error."""
+            # Arrange
+            config = {
+                "major": VersionComponentConfig(),
+                "minor": VersionComponentConfig(),
+                "patch": VersionComponentConfig(),
+                "build": VersionComponentConfig(independent=True),
+            }
+            version_spec = VersionSpec(config)
+
+            # Act
+            version = version_spec.create_version({})
+
+            # Assert
+            assert version["major"].value == "0"
+            assert version["minor"].value == "0"
+            assert version["patch"].value == "0"
+            assert version["build"].value == "0"
+
+        def test_missing_values_uses_component_first_value(self):
+            """A missing value raises an error."""
+            # Arrange
+            config = {
+                "major": VersionComponentConfig(),
+                "minor": VersionComponentConfig(),
+                "patch": VersionComponentConfig(),
+                "build": VersionComponentConfig(independent=True),
+            }
+            version_spec = VersionSpec(config)
+
+            # Act
+            version = version_spec.create_version({"major": "1", "minor": "2"})
+
+            # Assert
+            assert version["major"].value == "1"
+            assert version["minor"].value == "2"
+            assert version["patch"].value == "0"
+            assert version["build"].value == "0"
+
+        def test_extra_values_ignored(self):
+            """Extra values are ignored."""
+            # Arrange
+            config = {
+                "major": VersionComponentConfig(),
+                "minor": VersionComponentConfig(),
+                "patch": VersionComponentConfig(),
+            }
+            version_spec = VersionSpec(config)
+
+            # Act
+            version = version_spec.create_version({"major": "1", "minor": "2", "patch": "3", "build": "4"})
+
+            # Assert
+            assert version["major"].value == "1"
+            assert version["minor"].value == "2"
+            assert version["patch"].value == "3"
+            assert "build" not in version
+
+    class TestGetDependents:
+        """Tests of the get_dependents method."""
+
+        def test_bad_component_name_returns_empty_list(self):
+            """Getting the dependents of a non-existing component returns an empty list."""
+            # Arrange
+            config = {
+                "major": VersionComponentConfig(),
+                "minor": VersionComponentConfig(),
+                "patch": VersionComponentConfig(),
+            }
+            version_spec = VersionSpec(config)
+
+            # Act
+            dependents = version_spec.get_dependents("invalid")
+
+            # Assert
+            assert dependents == []
+
+        def test_extra_values_ignored(self):
+            """Extra values are ignored."""
+            # Arrange
+            config = {
+                "major": VersionComponentConfig(),
+                "minor": VersionComponentConfig(),
+                "patch": VersionComponentConfig(),
+            }
+            version_spec = VersionSpec(config)
+
+            # Act
+            patch_dependents = version_spec.get_dependents("patch")
+            minor_dependents = version_spec.get_dependents("minor")
+            major_dependents = version_spec.get_dependents("major")
+
+            # Assert
+            assert patch_dependents == []
+            assert minor_dependents == ["patch"]
+            assert major_dependents == ["minor", "patch"]

From 5c86d512916b665f164de08b6c488aa6c3d2ee1e Mon Sep 17 00:00:00 2001
From: Corey Oordt <coreyoordt@gmail.com>
Date: Tue, 26 Dec 2023 17:03:26 -0600
Subject: [PATCH 05/11] Fixed bad imports

---
 bumpversion/config/models.py | 3 ++-
 bumpversion/config/utils.py  | 3 +--
 bumpversion/files.py         | 4 +---
 tests/test_configuredfile.py | 2 +-
 4 files changed, 5 insertions(+), 7 deletions(-)

diff --git a/bumpversion/config/models.py b/bumpversion/config/models.py
index 84b8bdf5..8bbdac3c 100644
--- a/bumpversion/config/models.py
+++ b/bumpversion/config/models.py
@@ -10,11 +10,12 @@
 from pydantic_settings import BaseSettings, SettingsConfigDict
 
 from bumpversion.ui import get_indented_logger
+from bumpversion.versioning.models import VersionComponentConfig  # NOQA: TCH001
 
 if TYPE_CHECKING:
     from bumpversion.scm import SCMInfo
     from bumpversion.version_part import VersionConfig
-    from bumpversion.versioning.models import VersionComponentConfig, VersionSpec
+    from bumpversion.versioning.models import VersionSpec
 
 logger = get_indented_logger(__name__)
 
diff --git a/bumpversion/config/utils.py b/bumpversion/config/utils.py
index bad3f3fd..08667770 100644
--- a/bumpversion/config/utils.py
+++ b/bumpversion/config/utils.py
@@ -4,9 +4,8 @@
 import glob
 from typing import Dict, List
 
-from exceptions import BumpVersionError
-
 from bumpversion.config.models import FileChange
+from bumpversion.exceptions import BumpVersionError
 from bumpversion.versioning.models import VersionComponentConfig
 
 
diff --git a/bumpversion/files.py b/bumpversion/files.py
index c630a1f6..5af8f4ed 100644
--- a/bumpversion/files.py
+++ b/bumpversion/files.py
@@ -6,13 +6,11 @@
 from pathlib import Path
 from typing import Dict, List, MutableMapping, Optional
 
-from versioning.models import VersionComponentConfig
-
 from bumpversion.config.models import FileChange
 from bumpversion.exceptions import VersionNotFoundError
 from bumpversion.ui import get_indented_logger
 from bumpversion.version_part import VersionConfig
-from bumpversion.versioning.models import Version
+from bumpversion.versioning.models import Version, VersionComponentConfig
 
 logger = get_indented_logger(__name__)
 
diff --git a/tests/test_configuredfile.py b/tests/test_configuredfile.py
index 258be08f..8eae6ead 100644
--- a/tests/test_configuredfile.py
+++ b/tests/test_configuredfile.py
@@ -1,7 +1,7 @@
 """Tests for the ConfiguredFile class."""
 from bumpversion.files import ConfiguredFile, FileChange
 from bumpversion.version_part import VersionConfig
-from versioning.models import VersionComponentConfig
+from bumpversion.versioning.models import VersionComponentConfig
 
 
 class TestConfiguredFile:

From f8c4d05d1b4d8df25335b84823a00888a43349f0 Mon Sep 17 00:00:00 2001
From: Corey Oordt <coreyoordt@gmail.com>
Date: Tue, 26 Dec 2023 17:05:36 -0600
Subject: [PATCH 06/11] Fixed None as value for a function

- Turns None into an empty string
---
 bumpversion/versioning/functions.py | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/bumpversion/versioning/functions.py b/bumpversion/versioning/functions.py
index 59e4c795..3d4c5a8c 100644
--- a/bumpversion/versioning/functions.py
+++ b/bumpversion/versioning/functions.py
@@ -23,13 +23,15 @@ class IndependentFunction(PartFunction):
     """
 
     def __init__(self, value: Union[str, int, None] = None):
+        if value is None:
+            value = ""
         self.first_value = str(value)
         self.optional_value = str(value)
         self.independent = True
 
-    def bump(self, value: str) -> str:
+    def bump(self, value: Optional[str] = None) -> str:
         """Return the optional value."""
-        return self.optional_value
+        return value or self.optional_value
 
 
 class NumericFunction(PartFunction):

From 88e7f71e200ba0a7ef6f121205d634820a68c150 Mon Sep 17 00:00:00 2001
From: Corey Oordt <coreyoordt@gmail.com>
Date: Tue, 26 Dec 2023 17:11:03 -0600
Subject: [PATCH 07/11] Refactored verioning models

- created a "conventions" module for future release
- added an optional `depends_on` version component configuration
- The `depends_on` is required for PEP440 versioning
---
 bumpversion/versioning/conventions.py         | 109 ++++
 bumpversion/versioning/models.py              |  69 +--
 tests/fixtures/basic_cfg_expected.txt         |  12 +-
 tests/fixtures/basic_cfg_expected.yaml        |   4 +
 tests/fixtures/basic_cfg_expected_full.json   |   4 +
 tests/test_versioning/test_conventions.py     | 502 ++++++++++++++++++
 tests/test_versioning/test_functions.py       |  27 +-
 tests/test_versioning/test_models_version.py  |  32 +-
 .../test_models_versioncomponent.py           |   2 +-
 .../test_models_versionspec.py                |   2 +-
 10 files changed, 698 insertions(+), 65 deletions(-)
 create mode 100644 bumpversion/versioning/conventions.py
 create mode 100644 tests/test_versioning/test_conventions.py

diff --git a/bumpversion/versioning/conventions.py b/bumpversion/versioning/conventions.py
new file mode 100644
index 00000000..e40617c1
--- /dev/null
+++ b/bumpversion/versioning/conventions.py
@@ -0,0 +1,109 @@
+"""Standard version conventions."""
+from bumpversion.versioning.models import VersionComponentConfig, VersionSpec
+
+# Adapted from https://packaging.python.org/en/latest/specifications/version-specifiers/
+PEP440_PATTERN = r"""
+    v?
+    (?:
+        (?P<major>0|[1-9]\d*)\.
+        (?P<minor>0|[1-9]\d*)\.
+        (?P<patch>0|[1-9]\d*)
+        (?:                                          # pre-release
+            [-_\.]?
+            (?P<pre>
+                (?P<pre_l>a|b|c|rc|alpha|beta|pre|preview)
+                [-_\.]?
+                (?P<pre_n>[0-9]+)?
+            )
+        )?
+        (?:                                          # post release
+            [-_\.]?
+            (?P<post>
+                post
+                [-_\.]?
+                [0-9]+
+            )
+        )?
+        (?:                                          # dev release
+            [-_\.]?
+            (?P<dev>
+                dev
+                [-_\.]?
+                [0-9]+
+            )
+        )?
+    )
+    (?:\+(?P<local>[a-z0-9]+(?:[-_\.][a-z0-9]+)*))?   # local version
+"""
+PEP440_SERIALIZE_PATTERNS = [
+    "{major}.{minor}.{patch}{pre_l}{pre_n}.{post}.{dev}+{local}",
+    "{major}.{minor}.{patch}{pre_l}{pre_n}.{post}.{dev}",
+    "{major}.{minor}.{patch}{pre_l}{pre_n}.{post}+{local}",
+    "{major}.{minor}.{patch}{pre_l}{pre_n}.{dev}+{local}",
+    "{major}.{minor}.{patch}.{post}.{dev}+{local}",
+    "{major}.{minor}.{patch}{pre_l}{pre_n}.{post}",
+    "{major}.{minor}.{patch}{pre_l}{pre_n}.{dev}",
+    "{major}.{minor}.{patch}{pre_l}{pre_n}+{local}",
+    "{major}.{minor}.{patch}.{post}.{dev}",
+    "{major}.{minor}.{patch}.{post}+{local}",
+    "{major}.{minor}.{patch}.{dev}+{local}",
+    "{major}.{minor}.{patch}.{pre_l}{pre_n}",
+    "{major}.{minor}.{patch}.{post}",
+    "{major}.{minor}.{patch}.{dev}",
+    "{major}.{minor}.{patch}+{local}",
+    "{major}.{minor}.{patch}",
+]
+PEP440_COMPONENT_CONFIGS = {
+    "major": VersionComponentConfig(),
+    "minor": VersionComponentConfig(),
+    "patch": VersionComponentConfig(),
+    "pre_l": VersionComponentConfig(values=["", "a", "b", "rc"]),
+    "pre_n": VersionComponentConfig(),
+    "post": VersionComponentConfig(depends_on="patch"),
+    "dev": VersionComponentConfig(depends_on="patch"),
+    "local": VersionComponentConfig(depends_on="patch", optional_value=""),
+}
+
+
+def pep440_version_spec() -> VersionSpec:
+    """Return a VersionSpec for PEP 440."""
+    return VersionSpec(components=PEP440_COMPONENT_CONFIGS)
+
+
+# Adapted from https://regex101.com/r/Ly7O1x/3/
+SEMVER_PATTERN = r"""
+    (?P<major>0|[1-9]\d*)\.
+    (?P<minor>0|[1-9]\d*)\.
+    (?P<patch>0|[1-9]\d*)
+    (?:
+        -                             # dash seperator for pre-release section
+        (?P<pre_l>[a-zA-Z-]+)         # pre-release label
+        (?P<pre_n>0|[1-9]\d*)         # pre-release version number
+    )?                                # pre-release section is optional
+    (?:
+        \+                            # plus seperator for build metadata section
+        (?P<buildmetadata>
+            [0-9a-zA-Z-]+
+            (?:\.[0-9a-zA-Z-]+)*
+        )
+    )?                                # build metadata section is optional
+"""
+SEMVER_SERIALIZE_PATTERNS = [
+    "{major}.{minor}.{patch}-{pre_l}{pre_n}+{buildmetadata}",
+    "{major}.{minor}.{patch}-{pre_l}{pre_n}",
+    "{major}.{minor}.{patch}+{buildmetadata}",
+    "{major}.{minor}.{patch}",
+]
+SEMVER_COMPONENT_CONFIGS = {
+    "major": VersionComponentConfig(),
+    "minor": VersionComponentConfig(),
+    "patch": VersionComponentConfig(),
+    "pre_l": VersionComponentConfig(values=["", "a", "b", "rc"]),
+    "pre_n": VersionComponentConfig(),
+    "buildmetadata": VersionComponentConfig(independent=True),
+}
+
+
+def semver_spec() -> VersionSpec:
+    """Return a VersionSpec for SEMVER."""
+    return VersionSpec(components=SEMVER_COMPONENT_CONFIGS)
diff --git a/bumpversion/versioning/models.py b/bumpversion/versioning/models.py
index 42d23be3..967a3627 100644
--- a/bumpversion/versioning/models.py
+++ b/bumpversion/versioning/models.py
@@ -10,61 +10,6 @@
 from bumpversion.utils import key_val_string
 from bumpversion.versioning.functions import NumericFunction, PartFunction, ValuesFunction
 
-# Adapted from https://regex101.com/r/Ly7O1x/3/
-SEMVER_PATTERN = r"""
-    (?P<major>0|[1-9]\d*)\.
-    (?P<minor>0|[1-9]\d*)\.
-    (?P<patch>0|[1-9]\d*)
-    (?:
-        -                             # dash seperator for pre-release section
-        (?P<pre_l>[a-zA-Z-]+)         # pre-release label
-        (?P<pre_n>0|[1-9]\d*)         # pre-release version number
-    )?                                # pre-release section is optional
-    (?:
-        \+                            # plus seperator for build metadata section
-        (?P<buildmetadata>
-            [0-9a-zA-Z-]+
-            (?:\.[0-9a-zA-Z-]+)*
-        )
-    )?                                # build metadata section is optional
-"""
-
-# Adapted from https://packaging.python.org/en/latest/specifications/version-specifiers/
-PEP440_PATTERN = r"""
-    v?
-    (?:
-        (?:(?P<epoch>[0-9]+)!)?                           # Optional epoch
-        (?P<release>
-            (?P<major>0|[1-9]\d*)\.
-            (?P<minor>0|[1-9]\d*)\.
-            (?P<patch>0|[1-9]\d*)
-        )
-        (?P<pre>                                          # pre-release
-            [-_\.]?
-            (?P<pre_l>(a|b|c|rc|alpha|beta|pre|preview))
-            [-_\.]?
-            (?P<pre_n>[0-9]+)?
-        )?
-        (?P<post>                                         # post release
-            (?:-(?P<post_n1>[0-9]+))
-            |
-            (?:
-                [-_\.]?
-                (?P<post_l>post|rev|r)
-                [-_\.]?
-                (?P<post_n2>[0-9]+)?
-            )
-        )?
-        (?P<dev>                                          # dev release
-            [-_\.]?
-            (?P<dev_l>dev)
-            [-_\.]?
-            (?P<dev_n>[0-9]+)?
-        )?
-    )
-    (?:\+(?P<local>[a-z0-9]+(?:[-_\.][a-z0-9]+)*))?       # local version
-"""
-
 
 class VersionComponent:
     """
@@ -161,6 +106,7 @@ class VersionComponentConfig(BaseModel):
     first_value: Union[str, int, None] = None  # Optional. Defaults to first value in values
     independent: bool = False
     # source: Optional[str] = None  # Name of environment variable or context variable to use as the source for value
+    depends_on: Optional[str] = None  # The name of the component this component depends on
 
     def generate_component(self, value: Union[str, int, None] = None) -> VersionComponent:
         """Generate a version component from the configuration."""
@@ -192,7 +138,10 @@ def __init__(self, components: Dict[str, VersionComponentConfig], order: Optiona
         for component in self.order[1:]:
             if self.component_configs[component].independent:
                 continue
-            self.dependency_map[previous_component].append(component)
+            elif self.component_configs[component].depends_on:
+                self.dependency_map[self.component_configs[component].depends_on].append(component)
+            else:
+                self.dependency_map[previous_component].append(component)
             previous_component = component
 
     def create_version(self, values: Dict[str, str]) -> "Version":
@@ -227,6 +176,10 @@ def __init__(
         self.components = components
         self.original = original
 
+    def values(self) -> Dict[str, str]:
+        """Return the values of the parts."""
+        return {key: value.value for key, value in self.components.items()}
+
     def __getitem__(self, key: str) -> VersionComponent:
         return self.components[key]
 
@@ -246,6 +199,10 @@ def __eq__(self, other: Any) -> bool:
             else False
         )
 
+    def required_components(self) -> List[str]:
+        """Return the names of the parts that are required."""
+        return [key for key, value in self.components.items() if value.value != value.func.optional_value]
+
     def bump(self, component_name: str) -> "Version":
         """Increase the value of the specified component, reset its dependents, and return a new Version."""
         if component_name not in self.components:
diff --git a/tests/fixtures/basic_cfg_expected.txt b/tests/fixtures/basic_cfg_expected.txt
index b1d24f9d..470930a0 100644
--- a/tests/fixtures/basic_cfg_expected.txt
+++ b/tests/fixtures/basic_cfg_expected.txt
@@ -37,19 +37,23 @@
  'included_paths': [],
  'message': 'Bump version: {current_version} → {new_version}',
  'parse': '(?P<major>\\d+)\\.(?P<minor>\\d+)\\.(?P<patch>\\d+)(\\-(?P<release>[a-z]+))?',
- 'parts': {'major': {'first_value': None,
+ 'parts': {'major': {'depends_on': None,
+                     'first_value': None,
                      'independent': False,
                      'optional_value': None,
                      'values': None},
-           'minor': {'first_value': None,
+           'minor': {'depends_on': None,
+                     'first_value': None,
                      'independent': False,
                      'optional_value': None,
                      'values': None},
-           'patch': {'first_value': None,
+           'patch': {'depends_on': None,
+                     'first_value': None,
                      'independent': False,
                      'optional_value': None,
                      'values': None},
-           'release': {'first_value': None,
+           'release': {'depends_on': None,
+                       'first_value': None,
                        'independent': False,
                        'optional_value': 'gamma',
                        'values': ['dev', 'gamma']}},
diff --git a/tests/fixtures/basic_cfg_expected.yaml b/tests/fixtures/basic_cfg_expected.yaml
index 28e53dbe..51784937 100644
--- a/tests/fixtures/basic_cfg_expected.yaml
+++ b/tests/fixtures/basic_cfg_expected.yaml
@@ -45,21 +45,25 @@ message: "Bump version: {current_version} → {new_version}"
 parse: "(?P<major>\\d+)\\.(?P<minor>\\d+)\\.(?P<patch>\\d+)(\\-(?P<release>[a-z]+))?"
 parts:
   major:
+    depends_on: null
     first_value: null
     independent: false
     optional_value: null
     values: null
   minor:
+    depends_on: null
     first_value: null
     independent: false
     optional_value: null
     values: null
   patch:
+    depends_on: null
     first_value: null
     independent: false
     optional_value: null
     values: null
   release:
+    depends_on: null
     first_value: null
     independent: false
     optional_value: "gamma"
diff --git a/tests/fixtures/basic_cfg_expected_full.json b/tests/fixtures/basic_cfg_expected_full.json
index b7baefe3..7f5f0695 100644
--- a/tests/fixtures/basic_cfg_expected_full.json
+++ b/tests/fixtures/basic_cfg_expected_full.json
@@ -54,24 +54,28 @@
   "parse": "(?P<major>\\d+)\\.(?P<minor>\\d+)\\.(?P<patch>\\d+)(\\-(?P<release>[a-z]+))?",
   "parts": {
     "major": {
+      "depends_on": null,
       "first_value": null,
       "independent": false,
       "optional_value": null,
       "values": null
     },
     "minor": {
+      "depends_on": null,
       "first_value": null,
       "independent": false,
       "optional_value": null,
       "values": null
     },
     "patch": {
+      "depends_on": null,
       "first_value": null,
       "independent": false,
       "optional_value": null,
       "values": null
     },
     "release": {
+      "depends_on": null,
       "first_value": null,
       "independent": false,
       "optional_value": "gamma",
diff --git a/tests/test_versioning/test_conventions.py b/tests/test_versioning/test_conventions.py
new file mode 100644
index 00000000..66ba8eb1
--- /dev/null
+++ b/tests/test_versioning/test_conventions.py
@@ -0,0 +1,502 @@
+"""Test the versioning conventions."""
+
+from bumpversion.versioning.conventions import (
+    PEP440_COMPONENT_CONFIGS,
+    PEP440_PATTERN,
+    PEP440_SERIALIZE_PATTERNS,
+)
+import re
+
+import pytest
+from pytest import param
+
+
+@pytest.mark.parametrize(
+    ["version", "expected"],
+    [
+        param(
+            "1.2.3a123.post123.dev123+local.123",
+            {
+                "dev": "dev123",
+                "local": "local.123",
+                "major": "1",
+                "minor": "2",
+                "patch": "3",
+                "post": "post123",
+                "pre": "a123",
+                "pre_l": "a",
+                "pre_n": "123",
+            },
+            id="alpha-post-dev-local",
+        ),
+        param(
+            "1.2.3b123.post123.dev123+local.123",
+            {
+                "dev": "dev123",
+                "local": "local.123",
+                "major": "1",
+                "minor": "2",
+                "patch": "3",
+                "post": "post123",
+                "pre": "b123",
+                "pre_l": "b",
+                "pre_n": "123",
+            },
+            id="beta-post-dev-local",
+        ),
+        param(
+            "1.2.3rc123.post123.dev123+local.123",
+            {
+                "dev": "dev123",
+                "local": "local.123",
+                "major": "1",
+                "minor": "2",
+                "patch": "3",
+                "post": "post123",
+                "pre": "rc123",
+                "pre_l": "rc",
+                "pre_n": "123",
+            },
+            id="rc-post-dev-local",
+        ),
+        param(
+            "1.2.3a123.post123.dev123",
+            {
+                "dev": "dev123",
+                "local": None,
+                "major": "1",
+                "minor": "2",
+                "patch": "3",
+                "post": "post123",
+                "pre": "a123",
+                "pre_l": "a",
+                "pre_n": "123",
+            },
+            id="alpha-post-dev",
+        ),
+        param(
+            "1.2.3b123.post123.dev123",
+            {
+                "dev": "dev123",
+                "local": None,
+                "major": "1",
+                "minor": "2",
+                "patch": "3",
+                "post": "post123",
+                "pre": "b123",
+                "pre_l": "b",
+                "pre_n": "123",
+            },
+            id="beta-post-dev",
+        ),
+        param(
+            "1.2.3rc123.post123.dev123",
+            {
+                "dev": "dev123",
+                "local": None,
+                "major": "1",
+                "minor": "2",
+                "patch": "3",
+                "post": "post123",
+                "pre": "rc123",
+                "pre_l": "rc",
+                "pre_n": "123",
+            },
+            id="rc-post-dev",
+        ),
+        param(
+            "1.2.3a123.post123+local.123",
+            {
+                "dev": None,
+                "local": "local.123",
+                "major": "1",
+                "minor": "2",
+                "patch": "3",
+                "post": "post123",
+                "pre": "a123",
+                "pre_l": "a",
+                "pre_n": "123",
+            },
+            id="alpha-post-local",
+        ),
+        param(
+            "1.2.3b123.post123+local.123",
+            {
+                "dev": None,
+                "local": "local.123",
+                "major": "1",
+                "minor": "2",
+                "patch": "3",
+                "post": "post123",
+                "pre": "b123",
+                "pre_l": "b",
+                "pre_n": "123",
+            },
+            id="beta-post-local",
+        ),
+        param(
+            "1.2.3rc123.post123+local.123",
+            {
+                "dev": None,
+                "local": "local.123",
+                "major": "1",
+                "minor": "2",
+                "patch": "3",
+                "post": "post123",
+                "pre": "rc123",
+                "pre_l": "rc",
+                "pre_n": "123",
+            },
+            id="rc-post-local",
+        ),
+        param(
+            "1.2.3a123.dev123+local.123",
+            {
+                "dev": "dev123",
+                "local": "local.123",
+                "major": "1",
+                "minor": "2",
+                "patch": "3",
+                "post": None,
+                "pre": "a123",
+                "pre_l": "a",
+                "pre_n": "123",
+            },
+            id="alpha-dev-local",
+        ),
+        param(
+            "1.2.3b123.dev123+local.123",
+            {
+                "dev": "dev123",
+                "local": "local.123",
+                "major": "1",
+                "minor": "2",
+                "patch": "3",
+                "post": None,
+                "pre": "b123",
+                "pre_l": "b",
+                "pre_n": "123",
+            },
+            id="beta-dev-local",
+        ),
+        param(
+            "1.2.3rc123.dev123+local.123",
+            {
+                "dev": "dev123",
+                "local": "local.123",
+                "major": "1",
+                "minor": "2",
+                "patch": "3",
+                "post": None,
+                "pre": "rc123",
+                "pre_l": "rc",
+                "pre_n": "123",
+            },
+            id="rc-dev-local",
+        ),
+        param(
+            "1.2.3.post123.dev123+local.123",
+            {
+                "dev": "dev123",
+                "local": "local.123",
+                "major": "1",
+                "minor": "2",
+                "patch": "3",
+                "post": "post123",
+                "pre": None,
+                "pre_l": None,
+                "pre_n": None,
+            },
+            id="post-dev-local",
+        ),
+        param(
+            "1.2.3a123.post123",
+            {
+                "dev": None,
+                "local": None,
+                "major": "1",
+                "minor": "2",
+                "patch": "3",
+                "post": "post123",
+                "pre": "a123",
+                "pre_l": "a",
+                "pre_n": "123",
+            },
+            id="alpha-post",
+        ),
+        param(
+            "1.2.3b123.post123",
+            {
+                "dev": None,
+                "local": None,
+                "major": "1",
+                "minor": "2",
+                "patch": "3",
+                "post": "post123",
+                "pre": "b123",
+                "pre_l": "b",
+                "pre_n": "123",
+            },
+            id="beta-post",
+        ),
+        param(
+            "1.2.3rc123.post123",
+            {
+                "dev": None,
+                "local": None,
+                "major": "1",
+                "minor": "2",
+                "patch": "3",
+                "post": "post123",
+                "pre": "rc123",
+                "pre_l": "rc",
+                "pre_n": "123",
+            },
+            id="rc-post",
+        ),
+        param(
+            "1.2.3a123.dev123",
+            {
+                "dev": "dev123",
+                "local": None,
+                "major": "1",
+                "minor": "2",
+                "patch": "3",
+                "post": None,
+                "pre": "a123",
+                "pre_l": "a",
+                "pre_n": "123",
+            },
+            id="alpha-dev",
+        ),
+        param(
+            "1.2.3b123.dev123",
+            {
+                "dev": "dev123",
+                "local": None,
+                "major": "1",
+                "minor": "2",
+                "patch": "3",
+                "post": None,
+                "pre": "b123",
+                "pre_l": "b",
+                "pre_n": "123",
+            },
+            id="beta-dev",
+        ),
+        param(
+            "1.2.3rc123.dev123",
+            {
+                "dev": "dev123",
+                "local": None,
+                "major": "1",
+                "minor": "2",
+                "patch": "3",
+                "post": None,
+                "pre": "rc123",
+                "pre_l": "rc",
+                "pre_n": "123",
+            },
+            id="rc-dev",
+        ),
+        param(
+            "1.2.3a123+local.123",
+            {
+                "dev": None,
+                "local": "local.123",
+                "major": "1",
+                "minor": "2",
+                "patch": "3",
+                "post": None,
+                "pre": "a123",
+                "pre_l": "a",
+                "pre_n": "123",
+            },
+            id="alpha-local",
+        ),
+        param(
+            "1.2.3b123+local.123",
+            {
+                "dev": None,
+                "local": "local.123",
+                "major": "1",
+                "minor": "2",
+                "patch": "3",
+                "post": None,
+                "pre": "b123",
+                "pre_l": "b",
+                "pre_n": "123",
+            },
+            id="beta-local",
+        ),
+        param(
+            "1.2.3rc123+local.123",
+            {
+                "dev": None,
+                "local": "local.123",
+                "major": "1",
+                "minor": "2",
+                "patch": "3",
+                "post": None,
+                "pre": "rc123",
+                "pre_l": "rc",
+                "pre_n": "123",
+            },
+            id="rc-local",
+        ),
+        param(
+            "1.2.3.post123.dev123",
+            {
+                "dev": "dev123",
+                "local": None,
+                "major": "1",
+                "minor": "2",
+                "patch": "3",
+                "post": "post123",
+                "pre": None,
+                "pre_l": None,
+                "pre_n": None,
+            },
+            id="post-dev",
+        ),
+        param(
+            "1.2.3.post123+local.123",
+            {
+                "dev": None,
+                "local": "local.123",
+                "major": "1",
+                "minor": "2",
+                "patch": "3",
+                "post": "post123",
+                "pre": None,
+                "pre_l": None,
+                "pre_n": None,
+            },
+            id="post-local",
+        ),
+        param(
+            "1.2.3.dev123+local.123",
+            {
+                "dev": "dev123",
+                "local": "local.123",
+                "major": "1",
+                "minor": "2",
+                "patch": "3",
+                "post": None,
+                "pre": None,
+                "pre_l": None,
+                "pre_n": None,
+            },
+            id="dev-local",
+        ),
+        param(
+            "1.2.3a123",
+            {
+                "dev": None,
+                "local": None,
+                "major": "1",
+                "minor": "2",
+                "patch": "3",
+                "post": None,
+                "pre": "a123",
+                "pre_l": "a",
+                "pre_n": "123",
+            },
+            id="alpha",
+        ),
+        param(
+            "1.2.3b123",
+            {
+                "dev": None,
+                "local": None,
+                "major": "1",
+                "minor": "2",
+                "patch": "3",
+                "post": None,
+                "pre": "b123",
+                "pre_l": "b",
+                "pre_n": "123",
+            },
+            id="beta",
+        ),
+        param(
+            "1.2.3rc123",
+            {
+                "dev": None,
+                "local": None,
+                "major": "1",
+                "minor": "2",
+                "patch": "3",
+                "post": None,
+                "pre": "rc123",
+                "pre_l": "rc",
+                "pre_n": "123",
+            },
+            id="rc",
+        ),
+        param(
+            "1.2.3.post123",
+            {
+                "dev": None,
+                "local": None,
+                "major": "1",
+                "minor": "2",
+                "patch": "3",
+                "post": "post123",
+                "pre": None,
+                "pre_l": None,
+                "pre_n": None,
+            },
+            id="post",
+        ),
+        param(
+            "1.2.3.dev123",
+            {
+                "dev": "dev123",
+                "local": None,
+                "major": "1",
+                "minor": "2",
+                "patch": "3",
+                "post": None,
+                "pre": None,
+                "pre_l": None,
+                "pre_n": None,
+            },
+            id="dev",
+        ),
+        param(
+            "1.2.3+local.123",
+            {
+                "dev": None,
+                "local": "local.123",
+                "major": "1",
+                "minor": "2",
+                "patch": "3",
+                "post": None,
+                "pre": None,
+                "pre_l": None,
+                "pre_n": None,
+            },
+            id="local",
+        ),
+        param(
+            "1.2.3",
+            {
+                "dev": None,
+                "local": None,
+                "major": "1",
+                "minor": "2",
+                "patch": "3",
+                "post": None,
+                "pre": None,
+                "pre_l": None,
+                "pre_n": None,
+            },
+            id="release",
+        ),
+    ],
+)
+def test_pep440_pattern(version: str, expected: dict):
+    """The PEP440 pattern should match the version string and return the expected dictionary."""
+    match = re.search(PEP440_PATTERN, version, re.VERBOSE)
+    assert match.groupdict() == expected
diff --git a/tests/test_versioning/test_functions.py b/tests/test_versioning/test_functions.py
index 0f740173..d561d49c 100644
--- a/tests/test_versioning/test_functions.py
+++ b/tests/test_versioning/test_functions.py
@@ -1,7 +1,7 @@
 import pytest
 from pytest import param
 
-from bumpversion.versioning.functions import NumericFunction, ValuesFunction
+from bumpversion.versioning.functions import NumericFunction, ValuesFunction, IndependentFunction
 
 
 # NumericFunction
@@ -120,3 +120,28 @@ def test_bump_non_value_raises_value_error(self):
             func = ValuesFunction(["0", "5", "10"])
             with pytest.raises(ValueError):
                 func.bump("3")
+
+
+class TestIndependentFunction:
+    """The independent function manages incrementing and resetting version parts."""
+
+    class TestCreation:
+        """The independent function can be created."""
+
+        def test_value_sets_first_value_and_optional_value(self):
+            func = IndependentFunction("value")
+            assert func.optional_value == "value"
+            assert func.first_value == "value"
+
+        def test_value_is_not_required(self):
+            assert IndependentFunction().optional_value == ""
+            assert IndependentFunction("").optional_value == ""
+
+    class TestBump:
+        def test_bump_with_value_returns_value(self):
+            func = IndependentFunction("1")
+            assert func.bump("5") == "5"
+
+        def test_bump_with_no_value_returns_initial_value(self):
+            func = IndependentFunction("1")
+            assert func.bump() == "1"
diff --git a/tests/test_versioning/test_models_version.py b/tests/test_versioning/test_models_version.py
index 7a7fcf67..19e73e1b 100644
--- a/tests/test_versioning/test_models_version.py
+++ b/tests/test_versioning/test_models_version.py
@@ -1,8 +1,9 @@
 """Tests for the Version class."""
 
-from versioning.models import VersionComponentConfig
-from bumpversion.versioning.models import VersionSpec, Version, VersionComponent
+from bumpversion.versioning.models import VersionComponentConfig
+from bumpversion.versioning.models import VersionSpec
 import pytest
+from pytest import param
 
 
 @pytest.fixture
@@ -112,3 +113,30 @@ def test_bump_changes_component_and_dependents(self, version_spec: VersionSpec):
             assert minor_version_str == "1.3.0.4"
             assert major_version_str == "2.0.0.4"
             assert build_version_str == "1.2.3.5"
+
+    class TestRequiredComponents:
+        """Tests of the required_keys function."""
+
+        @pytest.mark.parametrize(
+            ["values", "expected"],
+            [
+                param({"major": "1", "minor": "2", "patch": "3"}, ["major", "minor", "patch"], id="major-minor-patch"),
+                param(
+                    {"major": "0", "minor": "2", "patch": "3", "build": "4"},
+                    ["minor", "patch", "build"],
+                    id="minor-patch-build",
+                ),
+                param({"major": "1", "minor": "0", "patch": "3", "build": ""}, ["major", "patch"], id="major-patch"),
+                param({"major": "0", "minor": "0", "patch": "3", "build": ""}, ["patch"], id="patch"),
+            ],
+        )
+        def test_returns_required_component_names(self, version_spec: VersionSpec, values: dict, expected: list):
+            """The required_keys function returns all required keys."""
+            # Arrange
+            version = version_spec.create_version(values)
+
+            # Act
+            required_components = version.required_components()
+
+            # Assert
+            assert required_components == expected
diff --git a/tests/test_versioning/test_models_versioncomponent.py b/tests/test_versioning/test_models_versioncomponent.py
index 3d7498f8..18e9e911 100644
--- a/tests/test_versioning/test_models_versioncomponent.py
+++ b/tests/test_versioning/test_models_versioncomponent.py
@@ -1,6 +1,6 @@
 """Tests of the VersionPart model."""
 
-from versioning.models import VersionComponentConfig
+from bumpversion.versioning.models import VersionComponentConfig
 from bumpversion.versioning.functions import ValuesFunction, NumericFunction
 import pytest
 
diff --git a/tests/test_versioning/test_models_versionspec.py b/tests/test_versioning/test_models_versionspec.py
index ea4de90f..62bf8c8a 100644
--- a/tests/test_versioning/test_models_versionspec.py
+++ b/tests/test_versioning/test_models_versionspec.py
@@ -2,7 +2,7 @@
 
 import pytest
 from bumpversion.versioning.models import VersionSpec
-from versioning.models import VersionComponentConfig
+from bumpversion.versioning.models import VersionComponentConfig
 
 
 class TestVersionSpec:

From 384fd994f67df1fe1a1d56c94e568a00d2c7176b Mon Sep 17 00:00:00 2001
From: Corey Oordt <coreyoordt@gmail.com>
Date: Tue, 26 Dec 2023 17:36:44 -0600
Subject: [PATCH 08/11] Fixed extra capture group in PEP440 parser

---
 tests/fixtures/pep440.toml | 12 +++++-------
 1 file changed, 5 insertions(+), 7 deletions(-)

diff --git a/tests/fixtures/pep440.toml b/tests/fixtures/pep440.toml
index 214faa64..1deb17ff 100644
--- a/tests/fixtures/pep440.toml
+++ b/tests/fixtures/pep440.toml
@@ -10,15 +10,13 @@ tag_message = "Bump version: {current_version} → {new_version}"
 current_version = "1.0.0"
 parse = """(?x)
 (?:
-    (?P<release>
-        (?P<major>[0-9]+)
+    (?P<major>[0-9]+)
+    (?:
+        \\.(?P<minor>[0-9]+)
         (?:
-            \\.(?P<minor>[0-9]+)
-            (?:
-                \\.(?P<patch>[0-9]+)
-            )?
+            \\.(?P<patch>[0-9]+)
         )?
-    )
+    )?
     (?P<prerelease>
         [-_\\.]?
         (?P<pre_label>a|b|rc)

From 0ac2cd80925c352b72840c1d5707bb61a18248eb Mon Sep 17 00:00:00 2001
From: Corey Oordt <coreyoordt@gmail.com>
Date: Tue, 26 Dec 2023 17:45:42 -0600
Subject: [PATCH 09/11] Refactored serialization

- Moved serialization from VersionConfig to version.serialization
---
 bumpversion/version_part.py                 | 126 +-------------------
 bumpversion/versioning/serialization.py     |  87 +++++++++++++-
 tests/test_versioning/test_serialization.py |  72 ++++++++++-
 3 files changed, 156 insertions(+), 129 deletions(-)

diff --git a/bumpversion/version_part.py b/bumpversion/version_part.py
index b3a4b39c..5f1352a6 100644
--- a/bumpversion/version_part.py
+++ b/bumpversion/version_part.py
@@ -1,17 +1,13 @@
 """Module for managing Versions and their internal parts."""
 import re
-import string
-from copy import copy
 from typing import Any, Dict, List, MutableMapping, Optional, Tuple
 
 from click import UsageError
-from versioning.models import VersionComponentConfig
 
-from bumpversion.exceptions import FormattingError, MissingValueError
 from bumpversion.ui import get_indented_logger
 from bumpversion.utils import labels_for_format
-from bumpversion.versioning.models import Version, VersionComponent, VersionSpec
-from bumpversion.versioning.serialization import parse_version
+from bumpversion.versioning.models import Version, VersionComponentConfig, VersionSpec
+from bumpversion.versioning.serialization import parse_version, serialize
 
 logger = get_indented_logger(__name__)
 
@@ -85,117 +81,6 @@ def parse(self, version_string: Optional[str] = None) -> Optional[Version]:
         version.original = version_string
         return version
 
-        # _parsed = {
-        #     key: VersionComponent(self.part_configs[key], value)
-        #     for key, value in parsed.items()
-        #     if key in self.part_configs
-        # }
-        # return Version(_parsed, version_string)
-
-    def _serialize(
-        self, version: Version, serialize_format: str, context: MutableMapping, raise_if_incomplete: bool = False
-    ) -> str:
-        """
-        Attempts to serialize a version with the given serialization format.
-
-        Args:
-            version: The version to serialize
-            serialize_format: The serialization format to use, using Python's format string syntax
-            context: The context to use when serializing the version
-            raise_if_incomplete: Whether to raise an error if the version is incomplete
-
-        Raises:
-            FormattingError: if not serializable
-            MissingValueError: if not all parts required in the format have values
-
-        Returns:
-            The serialized version as a string
-        """
-        values = copy(context)
-        for k in version:
-            values[k] = version[k]
-
-        # TODO dump complete context on debug level
-
-        try:
-            # test whether all parts required in the format have values
-            serialized = serialize_format.format(**values)
-
-        except KeyError as e:
-            missing_key = getattr(e, "message", e.args[0])
-            raise MissingValueError(
-                f"Did not find key {missing_key!r} in {version!r} when serializing version number"
-            ) from e
-
-        keys_needing_representation = set()
-
-        keys = list(self.order)
-        for i, k in enumerate(keys):
-            v = values[k]
-
-            if not isinstance(v, VersionComponent):
-                # values coming from environment variables don't need
-                # representation
-                continue
-
-            if not v.is_optional:
-                keys_needing_representation = set(keys[: i + 1])
-
-        required_by_format = set(labels_for_format(serialize_format))
-
-        # try whether all parsed keys are represented
-        if raise_if_incomplete and not keys_needing_representation <= required_by_format:
-            missing_keys = keys_needing_representation ^ required_by_format
-            raise FormattingError(
-                f"""Could not represent '{"', '".join(missing_keys)}' in format '{serialize_format}'"""
-            )
-
-        return serialized
-
-    def _choose_serialize_format(self, version: Version, context: MutableMapping) -> str:
-        """
-        Choose a serialization format for the given version and context.
-
-        Args:
-            version: The version to serialize
-            context: The context to use when serializing the version
-
-        Returns:
-            The serialized version as a string
-
-        Raises:
-            MissingValueError: if not all parts required in the format have values
-        """
-        chosen = None
-
-        logger.debug("Evaluating serialization formats")
-        logger.indent()
-        for serialize_format in self.serialize_formats:
-            try:
-                self._serialize(version, serialize_format, context, raise_if_incomplete=True)
-                # Prefer shorter or first search expression.
-                chosen_part_count = len(list(string.Formatter().parse(chosen))) if chosen else None
-                serialize_part_count = len(list(string.Formatter().parse(serialize_format)))
-                if not chosen or chosen_part_count > serialize_part_count:
-                    chosen = serialize_format
-                    logger.debug("Found '%s' to be a usable serialization format", chosen)
-                else:
-                    logger.debug("Found '%s' usable serialization format, but it's longer", serialize_format)
-            except FormattingError:
-                # If chosen, prefer shorter
-                if not chosen:
-                    chosen = serialize_format
-            except MissingValueError as e:
-                logger.info(e.message)
-                raise e
-
-        if not chosen:
-            raise KeyError("Did not find suitable serialization format")
-        logger.dedent()
-        logger.debug("Selected serialization format '%s'", chosen)
-
-        return chosen
-
     def serialize(self, version: Version, context: MutableMapping) -> str:
         """
         Serialize a version to a string.
@@ -207,9 +92,4 @@ def serialize(self, version: Version, context: MutableMapping) -> str:
         Returns:
             The serialized version as a string
         """
-        logger.debug("Serializing version '%s'", version)
-        logger.indent()
-        serialized = self._serialize(version, self._choose_serialize_format(version, context), context)
-        logger.debug("Serialized to '%s'", serialized)
-        logger.dedent()
-        return serialized
+        return serialize(version, list(self.serialize_formats), context)
diff --git a/bumpversion/versioning/serialization.py b/bumpversion/versioning/serialization.py
index 91bd76ab..926266b2 100644
--- a/bumpversion/versioning/serialization.py
+++ b/bumpversion/versioning/serialization.py
@@ -1,10 +1,13 @@
 """Functions for serializing and deserializing version objects."""
 import re
-from typing import Dict
+from copy import copy
+from operator import itemgetter
+from typing import Dict, List, MutableMapping
 
-from bumpversion.exceptions import BumpVersionError
+from bumpversion.exceptions import BumpVersionError, FormattingError
 from bumpversion.ui import get_indented_logger
-from bumpversion.utils import key_val_string
+from bumpversion.utils import key_val_string, labels_for_format
+from bumpversion.versioning.models import Version
 
 logger = get_indented_logger(__name__)
 
@@ -54,3 +57,81 @@ def parse_version(version_string: str, parse_pattern: str) -> Dict[str, str]:
     logger.dedent()
 
     return parsed
+
+
+def multisort(xs: list, specs: tuple) -> list:
+    """
+    Sort a list of dictionaries by multiple keys.
+
+    From https://docs.python.org/3/howto/sorting.html#sort-stability-and-complex-sorts
+
+    Args:
+        xs: The list of dictionaries to sort
+        specs: A tuple of (key, reverse) pairs
+
+    Returns:
+        The sorted list
+    """
+    for key, reverse in reversed(specs):
+        xs.sort(key=itemgetter(key), reverse=reverse)
+    return xs
+
+
+def serialize(version: Version, serialize_patterns: List[str], context: MutableMapping) -> str:
+    """
+    Attempts to serialize a version with the given serialization format.
+
+    - valid serialization patterns are those that are renderable with the given context
+    - formats that contain all required components are preferred
+    - the shortest valid serialization pattern is used
+    - if two patterns are equally short, the first one is used
+    - if no valid serialization pattern is found, an error is raised
+
+    Args:
+        version: The version to serialize
+        serialize_patterns: The serialization format to use, using Python's format string syntax
+        context: The context to use when serializing the version
+
+    Raises:
+        FormattingError: if a serialization pattern
+
+    Returns:
+        The serialized version as a string
+    """
+    logger.debug("Serializing version '%s'", version)
+    logger.indent()
+
+    local_context = copy(context)
+    local_context.update(version.values())
+    local_context_keys = set(local_context.keys())
+    required_component_labels = set(version.required_components())
+
+    patterns = []
+    for index, pattern in enumerate(serialize_patterns):
+        labels = set(labels_for_format(pattern))
+        patterns.append(
+            {
+                "pattern": pattern,
+                "labels": labels,
+                "order": index,
+                "num_labels": len(labels),
+                "renderable": local_context_keys >= labels,
+                "has_required_components": required_component_labels <= labels,
+            }
+        )
+
+    valid_patterns = filter(itemgetter("renderable"), patterns)
+    sorted_patterns = multisort(
+        list(valid_patterns), (("has_required_components", True), ("num_labels", False), ("order", False))
+    )
+
+    if not sorted_patterns:
+        raise FormattingError(f"Could not find a valid serialization format in {serialize_patterns!r} for {version!r}")
+
+    chosen_pattern = sorted_patterns[0]["pattern"]
+    logger.debug("Using serialization format '%s'", chosen_pattern)
+    serialized = chosen_pattern.format(**local_context)
+    logger.debug("Serialized to '%s'", serialized)
+    logger.dedent()
+
+    return serialized
diff --git a/tests/test_versioning/test_serialization.py b/tests/test_versioning/test_serialization.py
index 213a8ba7..55475ed9 100644
--- a/tests/test_versioning/test_serialization.py
+++ b/tests/test_versioning/test_serialization.py
@@ -1,7 +1,8 @@
 """Tests for the serialization of versioned objects."""
-from bumpversion.versioning.serialization import parse_version
-from bumpversion.versioning.models import SEMVER_PATTERN
-from bumpversion.exceptions import BumpVersionError
+from bumpversion.versioning.serialization import parse_version, serialize
+from bumpversion.versioning.conventions import semver_spec, SEMVER_PATTERN
+from bumpversion.versioning.models import Version
+from bumpversion.exceptions import BumpVersionError, FormattingError, MissingValueError
 
 import pytest
 from pytest import param
@@ -60,3 +61,68 @@ def test_invalid_parse_pattern_raises_error(self):
         """If the parse pattern is not a valid regular expression, a ValueError should be raised."""
         with pytest.raises(BumpVersionError):
             parse_version("1.2.3", r"v(?P<major>\d+\.(?P<minor>\d+)\.(?P<patch>\d+)")
+
+    def test_parse_pattern_with_newlines(self):
+        """A parse pattern with newlines should be parsed correctly."""
+        pattern = r"MAJOR=(?P<major>\d+)\nMINOR=(?P<minor>\d+)\nPATCH=(?P<patch>\d+)\n"
+        assert parse_version("MAJOR=31\nMINOR=0\nPATCH=3\n", pattern) == {"major": "31", "minor": "0", "patch": "3"}
+
+
+class TestSerialize:
+    """Test the serialize function."""
+
+    @pytest.mark.parametrize(
+        ["version", "expected"],
+        [
+            param(
+                semver_spec().create_version({"major": "1", "minor": "2", "patch": "3"}),
+                "1.2.3",
+                id="major-minor-patch",
+            ),
+            param(
+                semver_spec().create_version({"major": "1", "minor": "2", "patch": "0"}),
+                "1.2",
+                id="major-minor-patch-zero",
+            ),
+            param(
+                semver_spec().create_version({"major": "1", "minor": "0", "patch": "0"}),
+                "1",
+                id="major-minor-zero-patch-zero",
+            ),
+        ],
+    )
+    def test_picks_string_with_least_labels(self, version: Version, expected: str):
+        patterns = ["{major}.{minor}.{patch}", "{major}.{minor}", "{major}"]
+        assert serialize(version, serialize_patterns=patterns, context=version.values()) == expected
+
+    def test_renders_a_format_with_newlines(self):
+        """A serialization format with newlines should be rendered correctly."""
+        version = semver_spec().create_version({"major": "31", "minor": "0", "patch": "3"})
+        assert (
+            serialize(
+                version, serialize_patterns=["MAJOR={major}\nMINOR={minor}\nPATCH={patch}\n"], context=version.values()
+            )
+            == "MAJOR=31\nMINOR=0\nPATCH=3\n"
+        )
+
+    def test_renders_a_format_with_additional_context(self):
+        """A serialization format with additional context should be rendered correctly."""
+        version = semver_spec().create_version({"major": "1", "minor": "2", "patch": "3"})
+        assert (
+            serialize(
+                version,
+                serialize_patterns=["{major}.{minor}.{patch}+{$BUILDMETADATA}"],
+                context={"$BUILDMETADATA": "build.1", "major": "1", "minor": "2", "patch": "3"},
+            )
+            == "1.2.3+build.1"
+        )
+
+    def test_raises_error_if_context_is_missing_values(self):
+        """An error is raised if not all parts required in the format have values."""
+        version = semver_spec().create_version({"major": "1", "minor": "2"})
+        with pytest.raises(FormattingError):
+            serialize(
+                version,
+                serialize_patterns=["{major}.{minor}.{patch}+{$BUILDMETADATA}"],
+                context={"major": "1", "minor": "2", "patch": "0"},
+            )

From 593a4ee376cac57cf6bd26e704f0f6c2a841b99a Mon Sep 17 00:00:00 2001
From: Corey Oordt <coreyoordt@gmail.com>
Date: Sat, 6 Jan 2024 08:16:48 -0600
Subject: [PATCH 10/11] Fixed some tests

---
 bumpversion/versioning/models.py              |   4 +-
 tests/test_version_part.py                    | 213 ------------------
 .../test_models_versioncomponent.py           |  34 ++-
 tests/test_versioning/test_serialization.py   | 171 +++++++++-----
 4 files changed, 137 insertions(+), 285 deletions(-)

diff --git a/bumpversion/versioning/models.py b/bumpversion/versioning/models.py
index 967a3627..9953c934 100644
--- a/bumpversion/versioning/models.py
+++ b/bumpversion/versioning/models.py
@@ -108,7 +108,7 @@ class VersionComponentConfig(BaseModel):
     # source: Optional[str] = None  # Name of environment variable or context variable to use as the source for value
     depends_on: Optional[str] = None  # The name of the component this component depends on
 
-    def generate_component(self, value: Union[str, int, None] = None) -> VersionComponent:
+    def create_component(self, value: Union[str, int, None] = None) -> VersionComponent:
         """Generate a version component from the configuration."""
         return VersionComponent(
             values=self.values,
@@ -147,7 +147,7 @@ def __init__(self, components: Dict[str, VersionComponentConfig], order: Optiona
     def create_version(self, values: Dict[str, str]) -> "Version":
         """Generate a version from the given values."""
         components = {
-            key: comp_config.generate_component(value=values.get(key))
+            key: comp_config.create_component(value=values.get(key))
             for key, comp_config in self.component_configs.items()
         }
         return Version(version_spec=self, components=components)
diff --git a/tests/test_version_part.py b/tests/test_version_part.py
index 21bddde6..8234d6a1 100644
--- a/tests/test_version_part.py
+++ b/tests/test_version_part.py
@@ -1,9 +1,7 @@
-import logging
 from pathlib import Path
 
 import pytest
 from click import UsageError
-from pytest import LogCaptureFixture, param
 
 from bumpversion import exceptions
 from bumpversion.utils import get_context
@@ -76,153 +74,6 @@ def test_serialize_with_environment_var():
     del os.environ["BUILD_NUMBER"]
 
 
-def test_serialize_with_newlines():
-    overrides = {
-        "current_version": "MAJOR=31\nMINOR=0\nPATCH=3\n",
-        "parse": r"MAJOR=(?P<major>\d+)\nMINOR=(?P<minor>\d+)\nPATCH=(?P<patch>\d+)\n",
-        "serialize": ["MAJOR={major}\nMINOR={minor}\nPATCH={patch}\n"],
-    }
-    conf, version_config, current_version = get_config_data(overrides)
-    new_version = current_version.bump("major")
-    assert version_config.serialize(new_version, get_context(conf)) == "MAJOR=32\nMINOR=0\nPATCH=0\n"
-
-
-@pytest.mark.parametrize(
-    ["bump_type", "expected"],
-    [
-        param("patch", "0.9.1", id="patch"),
-        param("minor", "0.10", id="minor"),
-        param("major", "1", id="major"),
-    ],
-)
-def test_serialize_three_part(bump_type: str, expected: str):
-    overrides = {
-        "current_version": "0.9",
-        "parse": r"(?P<major>\d+)(\.(?P<minor>\d+)(\.(?P<patch>\d+))?)?",
-        "serialize": ["{major}.{minor}.{patch}", "{major}.{minor}", "{major}"],
-    }
-    conf, version_config, current_version = get_config_data(overrides)
-
-    new_version = current_version.bump(bump_type)
-    assert version_config.serialize(new_version, get_context(conf)) == expected
-
-
-@pytest.mark.parametrize(
-    ["initial", "bump_type", "expected"],
-    [
-        param("1.5.dev", "release", "1.5", id="release"),
-        param("1.5", "minor", "1.6.dev", id="minor"),
-    ],
-)
-def test_bump_non_numeric_parts(initial: str, bump_type: str, expected: str):
-    overrides = {
-        "current_version": initial,
-        "parse": r"(?P<major>\d+)\.(?P<minor>\d+)(\.(?P<release>[a-z]+))?",
-        "serialize": ["{major}.{minor}.{release}", "{major}.{minor}"],
-        "parts": {
-            "release": {
-                "optional_value": "gamma",
-                "values": ["dev", "gamma"],
-            },
-        },
-    }
-    conf, version_config, current_version = get_config_data(overrides)
-
-    new_version = current_version.bump(bump_type)
-    assert version_config.serialize(new_version, get_context(conf)) == expected
-
-
-@pytest.mark.parametrize(
-    ["initial", "bump_type", "expected"],
-    [
-        param("1.alpha", "release", "1.beta", id="alpha-to-beta-release"),
-        param("1.beta", "release", "1", id="beta-to-release"),
-    ],
-)
-def test_optional_value(initial: str, bump_type: str, expected: str):
-    overrides = {
-        "current_version": initial,
-        "parse": r"(?P<num>\d+)(\.(?P<release>.*))?(\.)?",
-        "serialize": ["{num}.{release}", "{num}"],
-        "parts": {
-            "release": {
-                "optional_value": "gamma",
-                "values": ["alpha", "beta", "gamma"],
-            },
-        },
-    }
-    conf, version_config, current_version = get_config_data(overrides)
-
-    new_version = current_version.bump(bump_type)
-    assert version_config.serialize(new_version, get_context(conf)) == expected
-
-
-@pytest.mark.parametrize(
-    ["initial", "bump_type", "expected"],
-    [
-        param("1.0a", "prerel", "1.0b", id="a-to-b-release"),
-        param("1.0b", "prerelversion", "1.0b1", id="prerelease-version"),
-        param("1.0b1", "prerelversion", "1.0b2", id="prerelease-version2"),
-        param("1.0b2", "prerel", "1.0c", id="b2-to-c-release"),
-        param("1.0c", "prerel", "1.0rc", id="c-to-rc-release"),
-        param("1.0rc", "prerel", "1.0", id="rc-to-d-release"),
-        param("1.0", "minor", "1.1dev", id="minor-release"),
-        param("1.1dev", "prerel", "1.1a", id="dev-to-a-release"),
-    ],
-)
-def test_python_pre_release_release_post_release(initial: str, bump_type: str, expected: str):
-    # adapted from http://legacy.python.org/dev/peps/pep-0386/#the-new-versioning-algorithm
-    overrides = {
-        "current_version": initial,
-        "parse": r"""^
-            (?P<major>\d+)\.(?P<minor>\d+)   # minimum 'N.N'
-            (?:
-                (?P<prerel>[abc]|rc|dev)     # 'a' = alpha, 'b' = beta
-                                             # 'c' or 'rc' = release candidate
-                (?:
-                    (?P<prerelversion>\d+(?:\.\d+)*)
-                )?
-            )?
-            (?P<postdev>(\.post(?P<post>\d+))?(\.dev(?P<dev>\d+))?)?""",
-        "serialize": [
-            "{major}.{minor}{prerel}{prerelversion}",
-            "{major}.{minor}{prerel}",
-            "{major}.{minor}",
-        ],
-        "parts": {
-            "prerel": {
-                "optional_value": "d",
-                "values": ["dev", "a", "b", "c", "rc", "d"],
-            },
-        },
-    }
-    conf, version_config, current_version = get_config_data(overrides)
-
-    new_version = current_version.bump(bump_type)
-    assert version_config.serialize(new_version, get_context(conf)) == expected
-
-
-@pytest.mark.parametrize(
-    ["initial", "bump_type", "expected"],
-    [
-        param("0.9.4", "major", "1.1.0", id="first-value-1"),
-    ],
-)
-def test_part_first_value(initial: str, bump_type: str, expected: str):
-    overrides = {
-        "current_version": initial,
-        "parts": {
-            "minor": {
-                "first_value": "1",
-            },
-        },
-    }
-    conf, version_config, current_version = get_config_data(overrides)
-
-    new_version = current_version.bump(bump_type)
-    assert version_config.serialize(new_version, get_context(conf)) == expected
-
-
 def test_version_part_invalid_regex_exit(tmp_path: Path) -> None:
     """A version part with an invalid regex should raise an exception."""
     # Arrange
@@ -233,67 +84,3 @@ def test_version_part_invalid_regex_exit(tmp_path: Path) -> None:
     with inside_dir(tmp_path):
         with pytest.raises(UsageError):
             get_config_data(overrides)
-
-
-def test_part_does_not_revert_to_zero_if_optional(tmp_path: Path) -> None:
-    """A non-numeric part with the optional value should not revert to zero."""
-    # From https://github.com/c4urself/bump2version/issues/248
-    # Arrange
-    overrides = {
-        "current_version": "0.3.1",
-        "parse": r"(?P<major>\d+)\.(?P<minor>\d+)\.(?P<patch>\d+)((?P<release>\D+)(?P<build>\d*))?",
-        "serialize": [
-            "{major}.{minor}.{patch}{release}{build}",
-            "{major}.{minor}.{patch}{release}",
-            "{major}.{minor}.{patch}",
-        ],
-        "parts": {
-            "release": {
-                "optional_value": "g",
-                "first_value": "g",
-                "values": [
-                    "dev",
-                    "a",
-                    "b",
-                    "g",
-                ],
-            },
-        },
-    }
-    with inside_dir(tmp_path):
-        conf, version_config, current_version = get_config_data(overrides)
-
-    new_version = current_version.bump("build")
-    assert version_config.serialize(new_version, get_context(conf)) == "0.3.1g1"
-
-
-def test_order_of_serialization(tmp_path: Path, caplog: LogCaptureFixture) -> None:
-    """The order of serialization should be as specified in the config."""
-    caplog.set_level(logging.DEBUG)
-    overrides = {
-        "current_version": "3.16.dev1",
-        "parse": r"(?P<major>\d+)\.(?P<minor>\d+)\.(?P<release>[a-z]+)?(?P<patch>\d+)?",
-        "serialize": [
-            "{major}.{minor}.{release}{patch}",
-            "{major}.{minor}.{release}",
-            "{major}.{minor}.{patch}",
-        ],
-        "parts": {
-            "release": {
-                "optional_value": "prod",
-                "first_value": "dev",
-                "values": [
-                    "dev",
-                    "prod",
-                ],
-            },
-        },
-    }
-    with inside_dir(tmp_path):
-        conf, version_config, current_version = get_config_data(overrides)
-
-    new_version = current_version.bump("release")
-    new_version_str = version_config.serialize(new_version, get_context(conf))
-    for msg in caplog.messages:
-        print(msg)
-    assert new_version_str == "3.16.prod"
diff --git a/tests/test_versioning/test_models_versioncomponent.py b/tests/test_versioning/test_models_versioncomponent.py
index 18e9e911..e0f82605 100644
--- a/tests/test_versioning/test_models_versioncomponent.py
+++ b/tests/test_versioning/test_models_versioncomponent.py
@@ -7,61 +7,59 @@
 
 @pytest.fixture(
     params=[
-        None,
-        ("0", "1", "2"),
-        ("0", "3"),
+        {"optional_value": "0", "first_value": "0"},
+        {"first_value": "1"},
+        {"values": ["alpha", "beta", "gamma"]},
+        {"values": ["alpha", "gamma"]},
     ]
 )
 def version_component_config(request):
     """Return a three-part and a two-part version part configuration."""
-    if request.param is None:
-        return VersionComponentConfig(optional_value="0", first_value="0")
-    else:
-        return VersionComponentConfig(values=request.param)
+    return VersionComponentConfig(**request.param)
 
 
 class TestVersionComponent:
     class TestCreation:
         def test_none_value_uses_optional_value(self, version_component_config):
-            vp = version_component_config.generate_component()
+            vp = version_component_config.create_component()
             assert vp.value == vp.func.optional_value
             assert vp._value is None
 
         def test_config_with_values_selects_values_function(self):
             values = ["0", "1", "2"]
-            vp = VersionComponentConfig(values=values).generate_component()
+            vp = VersionComponentConfig(values=values).create_component()
             assert isinstance(vp.func, ValuesFunction)
 
         def test_config_without_values_selects_numeric_function(self):
-            vp = VersionComponentConfig().generate_component()
+            vp = VersionComponentConfig().create_component()
             assert isinstance(vp.func, NumericFunction)
 
     def test_copy_returns_new_version_part(self, version_component_config):
-        vp = version_component_config.generate_component(version_component_config.first_value)
+        vp = version_component_config.create_component(version_component_config.first_value)
         vc = vp.copy()
         assert vp.value == vc.value
         assert id(vp) != id(vc)
 
     def test_bump_increments_value(self, version_component_config):
-        vp = version_component_config.generate_component(version_component_config.first_value)
+        vp = version_component_config.create_component(version_component_config.first_value)
         vc = vp.bump()
         if version_component_config.values:
             assert vc.value == str(version_component_config.values[1])
         else:
-            assert vc.value == "1"
+            assert vc.value == str(int(version_component_config.first_value) + 1)
 
     def test_non_first_value_is_not_optional(self, version_component_config):
-        assert not version_component_config.generate_component(version_component_config.first_value).bump().is_optional
+        assert not version_component_config.create_component(version_component_config.first_value).bump().is_optional
 
     def test_first_value_is_optional(self, version_component_config):
-        assert version_component_config.generate_component(version_component_config.first_value).is_optional
+        assert version_component_config.create_component(version_component_config.first_value).is_optional
 
     def test_versionparts_with_same_settings_are_equal(self, version_component_config):
-        version1 = version_component_config.generate_component(version_component_config.first_value)
-        version2 = version_component_config.generate_component(version_component_config.first_value)
+        version1 = version_component_config.create_component(version_component_config.first_value)
+        version2 = version_component_config.create_component(version_component_config.first_value)
         assert version1 == version2
 
     def test_null_resets_value_to_first_value(self, version_component_config):
-        version1 = version_component_config.generate_component(version_component_config.first_value)
+        version1 = version_component_config.create_component(version_component_config.first_value)
         version2 = version1.bump().null()
         assert version2 == version1
diff --git a/tests/test_versioning/test_serialization.py b/tests/test_versioning/test_serialization.py
index 55475ed9..4d9c6ff5 100644
--- a/tests/test_versioning/test_serialization.py
+++ b/tests/test_versioning/test_serialization.py
@@ -1,8 +1,8 @@
 """Tests for the serialization of versioned objects."""
 from bumpversion.versioning.serialization import parse_version, serialize
 from bumpversion.versioning.conventions import semver_spec, SEMVER_PATTERN
-from bumpversion.versioning.models import Version
-from bumpversion.exceptions import BumpVersionError, FormattingError, MissingValueError
+from bumpversion.versioning.models import Version, VersionSpec, VersionComponentConfig
+from bumpversion.exceptions import BumpVersionError, FormattingError
 
 import pytest
 from pytest import param
@@ -71,58 +71,125 @@ def test_parse_pattern_with_newlines(self):
 class TestSerialize:
     """Test the serialize function."""
 
-    @pytest.mark.parametrize(
-        ["version", "expected"],
-        [
-            param(
-                semver_spec().create_version({"major": "1", "minor": "2", "patch": "3"}),
-                "1.2.3",
-                id="major-minor-patch",
-            ),
-            param(
-                semver_spec().create_version({"major": "1", "minor": "2", "patch": "0"}),
-                "1.2",
-                id="major-minor-patch-zero",
-            ),
-            param(
-                semver_spec().create_version({"major": "1", "minor": "0", "patch": "0"}),
-                "1",
-                id="major-minor-zero-patch-zero",
-            ),
-        ],
-    )
-    def test_picks_string_with_least_labels(self, version: Version, expected: str):
-        patterns = ["{major}.{minor}.{patch}", "{major}.{minor}", "{major}"]
-        assert serialize(version, serialize_patterns=patterns, context=version.values()) == expected
-
-    def test_renders_a_format_with_newlines(self):
-        """A serialization format with newlines should be rendered correctly."""
-        version = semver_spec().create_version({"major": "31", "minor": "0", "patch": "3"})
-        assert (
-            serialize(
-                version, serialize_patterns=["MAJOR={major}\nMINOR={minor}\nPATCH={patch}\n"], context=version.values()
-            )
-            == "MAJOR=31\nMINOR=0\nPATCH=3\n"
+    class TestFormatSelection:
+        @pytest.mark.parametrize(
+            ["version", "expected"],
+            [
+                param(
+                    semver_spec().create_version({"major": "1", "minor": "2", "patch": "3"}),
+                    "1.2.3",
+                    id="major-minor-patch",
+                ),
+                param(
+                    semver_spec().create_version({"major": "1", "minor": "2", "patch": "0"}),
+                    "1.2",
+                    id="major-minor-patch-zero",
+                ),
+                param(
+                    semver_spec().create_version({"major": "1", "minor": "0", "patch": "0"}),
+                    "1",
+                    id="major-minor-zero-patch-zero",
+                ),
+            ],
         )
+        def test_is_string_with_fewest_required_labels(self, version: Version, expected: str):
+            """The smallest pattern with all the required values should be picked."""
+            patterns = ["{major}.{minor}.{patch}", "{major}.{minor}", "{major}"]
+            assert serialize(version, serialize_patterns=patterns, context={}) == expected
 
-    def test_renders_a_format_with_additional_context(self):
-        """A serialization format with additional context should be rendered correctly."""
-        version = semver_spec().create_version({"major": "1", "minor": "2", "patch": "3"})
-        assert (
-            serialize(
-                version,
-                serialize_patterns=["{major}.{minor}.{patch}+{$BUILDMETADATA}"],
-                context={"$BUILDMETADATA": "build.1", "major": "1", "minor": "2", "patch": "3"},
+        def test_is_renderable_pattern_with_fewest_labels(self):
+            """The smallest renderable pattern should be picked if no pattern has all the required values."""
+            version = semver_spec().create_version(
+                {"major": "1", "minor": "2", "patch": "3", "pre_l": "a", "buildmetadata": "build.1"}
+            )
+            # None of the patterns have all the required values, so the smallest renderable pattern should be picked
+            assert (
+                serialize(
+                    version,
+                    serialize_patterns=["{major}.{minor}.{patch}+{buildmetadata}", "{major}.{minor}.{patch}"],
+                    context={},
+                )
+                == "1.2.3"
+            )
+
+        def test_is_first_pattern_with_fewest_labels(self):
+            """The first pattern with the fewest labels should be picked if multiple have the same number of labels."""
+            version = semver_spec().create_version(
+                {"major": "1", "minor": "2", "patch": "3", "buildmetadata": "build.1"}
+            )
+            assert (
+                serialize(
+                    version,
+                    serialize_patterns=["{major}.{minor}.{buildmetadata}", "{major}.{minor}.{patch}"],
+                    context={},
+                )
+                == "1.2.build.1"
+            )
+
+        def test_includes_optional_component_when_dependent_is_not_optional(self):
+            """A format with an optional component should render when the dependent component is not optional."""
+            version_spec = VersionSpec(
+                components={
+                    "major": VersionComponentConfig(),
+                    "minor": VersionComponentConfig(),
+                    "patch": VersionComponentConfig(),
+                    "release": VersionComponentConfig(
+                        optional_value="g",
+                        first_value="g",
+                        values=[
+                            "dev",
+                            "a",
+                            "b",
+                            "g",
+                        ],
+                    ),
+                    "build": VersionComponentConfig(),
+                },
+            )
+            serialize_patterns = [
+                "{major}.{minor}.{patch}{release}{build}",
+                "{major}.{minor}.{patch}{release}",
+                "{major}.{minor}.{patch}",
+            ]
+
+            version = version_spec.create_version({"major": "0", "minor": "3", "patch": "1", "build": "1"})
+            assert (
+                serialize(
+                    version,
+                    serialize_patterns=serialize_patterns,
+                    context={},
+                )
+                == "0.3.1g1"
             )
-            == "1.2.3+build.1"
-        )
 
-    def test_raises_error_if_context_is_missing_values(self):
-        """An error is raised if not all parts required in the format have values."""
-        version = semver_spec().create_version({"major": "1", "minor": "2"})
-        with pytest.raises(FormattingError):
-            serialize(
-                version,
-                serialize_patterns=["{major}.{minor}.{patch}+{$BUILDMETADATA}"],
-                context={"major": "1", "minor": "2", "patch": "0"},
+    class TestRendersFormat:
+        def test_with_newlines(self):
+            """A serialization format with newlines should be rendered correctly."""
+            version = semver_spec().create_version({"major": "31", "minor": "0", "patch": "3"})
+            assert (
+                serialize(version, serialize_patterns=["MAJOR={major}\nMINOR={minor}\nPATCH={patch}\n"], context={})
+                == "MAJOR=31\nMINOR=0\nPATCH=3\n"
             )
+
+        def test_with_additional_context(self):
+            """A serialization format with additional context should be rendered correctly."""
+            version = semver_spec().create_version({"major": "1", "minor": "2", "patch": "3"})
+            assert (
+                serialize(
+                    version,
+                    serialize_patterns=["{major}.{minor}.{patch}+{$BUILDMETADATA}"],
+                    context={"$BUILDMETADATA": "build.1"},
+                )
+                == "1.2.3+build.1"
+            )
+
+    class TestRaisesError:
+        def test_if_context_is_missing_values(self):
+            """An error is raised if not all parts required in the format have values."""
+            version = semver_spec().create_version({"major": "1", "minor": "2"})
+            with pytest.raises(FormattingError):
+                serialize(
+                    version,
+                    serialize_patterns=["{major}.{minor}.{patch}+{$BUILDMETADATA}"],
+                    context={},
+                )

From 8bfa5d9a7f696cec2a492fcb29a05e802d57e40b Mon Sep 17 00:00:00 2001
From: Corey Oordt <coreyoordt@gmail.com>
Date: Sat, 27 Jan 2024 08:53:56 -0600
Subject: [PATCH 11/11] Fixed some tests !minor

---
 tests/test_cli.py   |  0
 tests/test_files.py |  2 +-
 tests/test_utils.py | 52 +++++++++++++++++++++++++++++++++++++++++++++
 3 files changed, 53 insertions(+), 1 deletion(-)
 delete mode 100644 tests/test_cli.py

diff --git a/tests/test_cli.py b/tests/test_cli.py
deleted file mode 100644
index e69de29b..00000000
diff --git a/tests/test_files.py b/tests/test_files.py
index 5f9b7662..e90a7cba 100644
--- a/tests/test_files.py
+++ b/tests/test_files.py
@@ -470,7 +470,7 @@ def test_update_file_does_not_modify_non_toml_files(self, tmp_path: Path) -> Non
 
         overrides = {"current_version": "1.2.3", "files": [{"filename": str(version_path)}]}
         conf, version_config, current_version = get_config_data(overrides)
-        new_version = current_version.bump("patch", version_config.order)
+        new_version = current_version.bump("patch")
         datafile_config = FileChange(
             filename=str(version_path),
             key_path="",
diff --git a/tests/test_utils.py b/tests/test_utils.py
index b0ffe63d..0142a553 100644
--- a/tests/test_utils.py
+++ b/tests/test_utils.py
@@ -1,4 +1,6 @@
 """Tests for the utils module."""
+from itertools import combinations
+
 import pytest
 from bumpversion import utils
 
@@ -78,3 +80,53 @@ def test_non_dict_element_raises_valueerror(self):
         # Act/Assert
         with pytest.raises(ValueError):
             utils.set_nested_value(d, value, path)
+
+
+def pytest_generate_tests(metafunc):
+    if "flag_permutation" in metafunc.fixturenames:
+        flags = [
+            "a",
+            "i",
+            "L",
+            "m",
+            "s",
+            "u",
+            "x",
+        ]
+        permutes = flags[:]
+        permutes.extend(["".join(p) for p in combinations(flags, 2)])
+        permutes.extend(["".join(p) for p in combinations(flags, 3)])
+        permutes.extend(["".join(p) for p in combinations(flags, 4)])
+        permutes.extend(["".join(p) for p in combinations(flags, 5)])
+        permutes.extend(["".join(p) for p in combinations(flags, 6)])
+        permutes.extend(["".join(p) for p in combinations(flags, 7)])
+        metafunc.parametrize(
+            "flag_permutation",
+            permutes,
+        )
+
+
+class TestExtractRegexFlags:
+    def test_returns_flags_when_available(self, flag_permutation):
+        """It should return the flags when available."""
+        # Arrange
+        regex = f"(?{flag_permutation})abc"
+        expected = ("abc", f"(?{flag_permutation})")
+
+        # Act
+        actual_flags = utils.extract_regex_flags(regex)
+
+        # Assert
+        assert actual_flags == expected
+
+    def test_returns_empty_string_when_no_flags(self):
+        """It should return an empty string when no flags are present."""
+        # Arrange
+        regex = "abc"
+        expected = ("abc", "")
+
+        # Act
+        actual_flags = utils.extract_regex_flags(regex)
+
+        # Assert
+        assert actual_flags == expected