Replace obsolete version parsing logic

* Update version.py to only parse the Python-style version strings

* Update tests

* Add more edge cases, including mutual exclusivity between dev previews and release candidates

Author: pushfoo

arcade/version.py

@@ -13,43 +13,16 @@
        # Using file=sys.stderr prints to the error stream (usually prints red)
        print("This game requires Arcade 3.0.0+ to run!", file=sys.stderr)
 
+The ``VERSION`` constant in this module will be loaded from a file in the
+same directory. It will contain the following:
 
-Arcade contributors will benefit from understanding how and why
-this file loads and converts the contents of the ``VERSION`` file.
+#. major
+#. minor
+#. point
+#. (Optional) one and _only_ one of:
 
-After a release build succeeds, GitHub's CI is configured to do
-the following:
-
-#. Push the package files to PyPI
-#. Call the ``remorses/bump-version@js`` action to auto-increment
-   Arcade's version on the development branch
-
-This is where an edge case arises:
-
-#. Our CI expects ``3.1.0-dev.1`` for dev preview builds
-#. Python expects ``3.1.0.dev1`` for dev preview builds
-
-The ``VERSION`` file in this file's directory stores the version
-in the form the GH Action prefers. This allows it to auto-increment
-the version number on the ``development`` branch after we make an
-Arcade release to PyPI.
-
-The auto-bump action is configured by the following file:
-https://github.com/pythonarcade/arcade/blob/development/.github/workflows/bump_version.yml
-
-As an example, the GH action would auto-increment a dev preview's
-version after releasing the 5th dev preview of ``3.1.0`` by updating
-the ``VERSION`` file from this:
-
-.. code-block::
-
-   3.1.0-dev.5
-
-...to this:
-
-.. code-block::
-
-   3.1.0-dev.6
+   * .dev{DEV_PREVIEW_NUMBER}
+   * rc{RC_NUMBER}
 
 """
 
@@ -63,72 +36,83 @@
 _HERE = Path(__file__).parent
 
 # Grab version numbers + optional dev point preview
-# Assumes $MAJOR.$MINOR.$POINT format with optional -dev$DEV_PREVIEW
+# Assumes:
+# {MAJOR}.{MINOR}.{POINT} format
+# optional: one and ONLY one of:
+# 1. dev{DEV_PREVIEW}
+# 2. rc{RC_NUMBER}
 # Q: Why did you use regex?!
 # A: If the dev_preview field is invalid, the whole match fails instantly
-_VERSION_REGEX = re.compile(
+_VERSION_REGEX: Final[re.Pattern] = re.compile(
     r"""
     # First three version number fields
       (?P<major>[0-9]+)
-    \.(?P<minor>[0-9]+)
-    \.(?P<point>[0-9]+)
-    # Optional dev preview suffix
+    \.(?P<minor>0|[1-9][0-9]*)
+    \.(?P<point>0|[1-9][0-9]*)
+    # Optional and mutually exclusive: dev preview or rc number
     (?:
-        -dev                    # Dev prefix as a literal
-        \.                      # Point
-        (?P<dev_preview>[0-9]+) # Dev preview number
+        \.(?P<dev_preview>dev(?:0|[1-9][0-9]*))
+        |  # XOR: can't be both a preview and an rc
+        (?P<rc_number>rc(?:0|[1-9][0-9]*))
     )?
     """,
     re.X,
 )
 
 
-def _parse_python_friendly_version(version_for_github_actions: str) -> str:
-    """Convert a GitHub CI version string to a Python-friendly one.
+def _parse_python_friendly_version(
+        raw_version: str,
+        pattern: re.Pattern[str] = _VERSION_REGEX
+) -> str:
+    """Read a GitHub CI version string to a Python-friendly one.
 
     For example, ``3.1.0-dev.1`` would become ``3.1.0.dev1``.
 
     Args:
-        version_for_github_actions:
+        raw_version:
             A raw GitHub CI version string, as read from a file.
     Returns:
         A Python-friendly version string.
     """
     # Quick preflight check: we don't support tuple format here!
-    if not isinstance(version_for_github_actions, str):
-        raise TypeError(
-            f"Expected a string of the format MAJOR.MINOR.POINT"
-            f"or MAJOR.MINOR.POINT-dev.DEV_PREVIEW,"
-            f"not {version_for_github_actions!r}"
-        )
+    problem = None
+    if not isinstance(raw_version, str):
+        problem = TypeError
+    elif (match := pattern.fullmatch(raw_version)) is None:
+        problem = ValueError
+    if problem:
+        raise problem(
+            f"{raw_version=!r} not a str of the format MAJOR.MINOR"
+            f"POINT with at most one of dev{{DEV_PREVIEW}} or"
+            f"rc{{RC_NUMBER}},")
+  
+    # Build final output, including a dev preview version if present
+    group_dict: dict[str, str | None] = match.groupdict()  # type: ignore
+    parts: list[str] = [group_dict[k] for k in ('major', 'minor', 'point')] # type: ignore
+    dev_preview, rc_number = (group_dict[k] for k in ('dev_preview', 'rc_number'))
 
-    # Attempt to extract our raw data
-    match = _VERSION_REGEX.fullmatch(version_for_github_actions.strip())
-    if match is None:
-        raise ValueError(
-            f"String does not appear to be a version number: {version_for_github_actions!r}"
-        )
+    if dev_preview and rc_number:
+        raise ValueError(f"Can't have both {dev_preview=!r} and {rc_number=!r}")
+    elif dev_preview:
+        parts.append(dev_preview)
 
-    # Build final output, including a dev preview version if present
-    group_dict = match.groupdict()
-    major, minor, point, dev_preview = group_dict.values()
-    parts = [major, minor, point]
-    if dev_preview is not None:
-        parts.append(f"dev{dev_preview}")
     joined = ".".join(parts)
+    if rc_number:
+        joined += rc_number
 
     return joined
 
 
-def _parse_py_version_from_github_ci_file(
+def _parse_py_version_from_file(
     version_path: str | Path = _HERE / "VERSION", write_errors_to=sys.stderr
 ) -> str:
-    """Parse a Python-friendly version from a ``bump-version``-compatible file.
+    """Read & validate the VERSION file as from a limited subset.
 
     On failure, it will:
 
     #. Print an error to stderr
     #. Return "0.0.0"
+    #. (Indirectly) cause any PyPI uploads to fail
 
     Args:
         version_path:
@@ -152,7 +136,7 @@ def _parse_py_version_from_github_ci_file(
     return data
 
 
-VERSION: Final[str] = _parse_py_version_from_github_ci_file()
+VERSION: Final[str] = _parse_py_version_from_file()
 """A Python-friendly version string.
 
 This value is converted from the GitHub-style ``VERSION`` file at the

tests/unit/test_version.py

@@ -5,32 +5,33 @@
 import pytest
 from arcade.version import (
     _parse_python_friendly_version,
-    _parse_py_version_from_github_ci_file
+    _parse_py_version_from_file
 )
 
 
 @pytest.mark.parametrize("value, expected", [
-    ("3.0.0-dev.1", "3.0.0.dev1"),
+    ("3.0.0.dev1", "3.0.0.dev1"),
     ("3.0.0", "3.0.0"),
     # Edge cases
-    ("11.22.333-dev.4444", "11.22.333.dev4444"),
+    ("11.22.333.dev4444", "11.22.333.dev4444"),
     ("11.22.333", "11.22.333"),
+    ("111.2222.3333rc0", "111.2222.3333rc0")
 ])
 class TestParsingWellFormedData:
     def test_parse_python_friendly_version(
             self, value, expected
     ):
         assert _parse_python_friendly_version(value) == expected
 
-    def test_parse_py_version_from_github_ci_file(
+    def test_parse_py_version_from_file(
             self, value, expected
     ):
 
         with tempfile.NamedTemporaryFile("w", delete=False) as f:
             f.write(value)
             f.close()
 
-            assert _parse_py_version_from_github_ci_file(
+            assert _parse_py_version_from_file(
                 f.name
             ) == expected
 
@@ -47,12 +48,15 @@ def test_parse_py_version_from_github_ci_file(
         "3.1.2.",
         "3.1.0.dev",
         "3.1.0-dev."
+        "3.1.0-dev.4"  # No longer valid input
         # Hex is not valid in version numbers
         "A",
         "3.A.",
         "3.1.A",
         "3.1.0.A",
-        "3.1.0-dev.A"
+        "3.1.0-dev.A",
+        # Can't be both a release candidate and a dev preview
+        "3.1.0.dev4rc1"
     )
 )
 def test_parse_python_friendly_version_raises_value_errors(bad_value):
@@ -72,8 +76,8 @@ def test_parse_python_friendly_version_raises_typeerror_on_bad_values(bad_type):
         _parse_python_friendly_version(bad_type)  # type: ignore  # Type mistmatch is the point
 
 
-def test_parse_py_version_from_github_ci_file_returns_zeroes_on_errors():
+def test_parse_py_version_from_file_returns_zeroes_on_errors():
     fake_stderr = mock.MagicMock(sys.stderr)
-    assert _parse_py_version_from_github_ci_file(
+    assert _parse_py_version_from_file(
         "FILEDOESNOTEXIST", write_errors_to=fake_stderr
     ) == "0.0.0"