ebump 0.2.0__tar.gz → 0.2.2__tar.gz

{ebump-0.2.0/src/ebump.egg-info → ebump-0.2.2}/PKG-INFO

@@ -1,10 +1,10 @@
 Metadata-Version: 2.4
 Name: ebump
-Version: 0.2.0
+Version: 0.2.2
 Summary: Easy version bumping
 Author-email: Jorge Morgado Vega <jorge.morgadov@gmail.com>
 License: MIT
-Requires-Python: >=3.13
+Requires-Python: >=3.11
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Dynamic: license-file

{ebump-0.2.0 → ebump-0.2.2}/pyproject.toml

@@ -1,9 +1,9 @@
 [project]
 name = "ebump"
-version = "0.2.0"
+version = "0.2.2"
 description = "Easy version bumping"
 readme = "README.md"
-requires-python = ">= 3.13"
+requires-python = ">= 3.11"
 authors = [{ name = "Jorge Morgado Vega", email = "jorge.morgadov@gmail.com" }]
 license = { text = "MIT" }
 
@@ -37,7 +37,7 @@ ebump = "ebump.main:main"
 [tool.ruff]
 line-length = 88
 indent-width = 4
-target-version = "py313"
+target-version = "py311"
 
 [tool.ruff.format]
 quote-style = "double"
@@ -78,7 +78,7 @@ unfixable = []
 
 
 [tool.mypy]
-python_version = "3.13"
+python_version = "3.11"
 files = ["src", "tests"]
 warn_unused_configs = true
 warn_redundant_casts = true

ebump-0.2.2/src/ebump/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.2.2"

{ebump-0.2.0 → ebump-0.2.2}/src/ebump/bump.py

@@ -12,7 +12,10 @@ def bump(curr_ver: Version, part: PartType, tag: TagType | None = None) -> Versi
         )
 
     assert part == PartType.TAG, "Invalid part type for bumping"
+    return _bump_tag(curr_ver, tag)
 
+
+def _bump_tag(curr_ver: Version, tag: TagType | None) -> Version:
     if curr_ver.tag == TagType.FINAL:
         if tag is not None and tag != TagType.FINAL:
             raise ValueError(f"Cannot bump to tag {tag._value_} on a final version.")

{ebump-0.2.0 → ebump-0.2.2}/src/ebump/config.py

@@ -10,11 +10,11 @@ from ebump.version import VERSION_RE, TagType, Version
 class Config:
     root: Path
     current_version: Version
-    re_patterns: dict[Path, list[re.Pattern]]
+    re_patterns: dict[Path, list[re.Pattern[str]]]
 
 
 def _ensure_pyproject_pattern(
-    pyproject_path: Path, re_patterns: dict[Path, list[re.Pattern]]
+    pyproject_path: Path, re_patterns: dict[Path, list[re.Pattern[str]]]
 ) -> None:
     pyproject_pattern = re.compile(
         r"^version\s*=\s*\"" + VERSION_RE.pattern + r"\"\s*$"
@@ -52,7 +52,7 @@ def parse_config(root: Path) -> Config:
     config_patterns = (
         pyproject_dict.get("tool", {}).get("ebump", {}).get("patterns", {})
     )
-    re_patterns: dict[Path, list[re.Pattern]] = {}
+    re_patterns: dict[Path, list[re.Pattern[str]]] = {}
 
     for str_path, patterns in config_patterns.items():
         path = (root / Path(str_path)).absolute()
@@ -60,7 +60,7 @@ def parse_config(root: Path) -> Config:
             raise FileNotFoundError(
                 f"File {path} specified in pyproject.toml does not exist in project root {root.absolute()!s}"
             )
-        path_re_patterns: list[re.Pattern] = []
+        path_re_patterns: list[re.Pattern[str]] = []
         for pattern in patterns:
             if "{version}" not in pattern:
                 raise ValueError(

{ebump-0.2.0 → ebump-0.2.2}/src/ebump/main.py

@@ -24,8 +24,8 @@ TAG_OPTS = {"alpha", "beta", "dev", "rc", "post", "final"}
 def _show_diff(old_lines: list[str], new_lines: list[str]) -> None:
     for old_line, new_line in zip(old_lines, new_lines, strict=False):
         if old_line != new_line:
-            sys.stdout.write(f"- {old_line}\n")
-            sys.stdout.write(f"+ {new_line}\n")
+            sys.stdout.write(f"- {old_line}")
+            sys.stdout.write(f"+ {new_line}")
 
 
 def set_version(cfg: Config, new_version: Version, dry_run: bool) -> None:
@@ -76,11 +76,14 @@ Bad examples:
         formatter_class=argparse.RawDescriptionHelpFormatter,
     )
 
+    bump_opts = list(PART_OPTS) + list(TAG_OPTS)
+    # Checked after parsing: before Python 3.12, argparse rejects an empty
+    # nargs="*" positional when it declares choices.
     parser.add_argument(
         "bump",
         nargs="*",
         default=None,
-        choices=list(PART_OPTS) + list(TAG_OPTS),
+        metavar="{" + ",".join(bump_opts) + "}",
         help=f"Version part to bump {PART_OPTS}, and/or specific pre-release tag {TAG_OPTS}",
     )
 
@@ -105,6 +108,12 @@ Bad examples:
     )
 
     args = parser.parse_args()
+    invalid_opts = [opt for opt in args.bump if opt not in bump_opts]
+    if invalid_opts:
+        parser.error(
+            f"argument bump: invalid choice: {invalid_opts[0]!r} "
+            f"(choose from {', '.join(map(repr, bump_opts))})"
+        )
     bump_args = args.bump
     dry_run = args.dry_run
 

{ebump-0.2.0 → ebump-0.2.2}/src/ebump/rewrite.py

@@ -11,20 +11,21 @@ RewriteData = NamedTuple(
         ("path", Path),
         ("old_lines", list[str]),
         ("new_lines", list[str]),
-        ("line_sep", str),
     ],
 )
 
 
 def rewrite_lines(
-    old_lines: list[str], new_version: str, patterns: list[re.Pattern]
+    old_lines: list[str], new_version: str, patterns: list[re.Pattern[str]]
 ) -> list[str]:
     used_patterns = set()
     new_lines = old_lines[:]
     for i, line in enumerate(old_lines):
+        stripped = line.rstrip("\r\n")
+        ending = line[len(stripped) :]
         new_line = line
         for patt_idx, pattern in enumerate(patterns):
-            match = pattern.match(line)
+            match = pattern.match(stripped)
             if match is None:
                 continue
 
@@ -38,13 +39,14 @@ def rewrite_lines(
                 start_idx = match.start(group_idx)
                 end_idx = match.end(group_idx)
                 if last_idx < start_idx:
-                    new_line += line[last_idx:start_idx]
+                    new_line += stripped[last_idx:start_idx]
 
                 new_line += new_version
                 last_idx = end_idx
 
-            if last_idx < len(line):
-                new_line += line[last_idx:]
+            if last_idx < len(stripped):
+                new_line += stripped[last_idx:]
+            new_line += ending
             break
 
         new_lines[i] = new_line
@@ -60,25 +62,14 @@ def rewrite_lines(
     return new_lines
 
 
-def detect_line_sep(content: str) -> str:
-    """Parse line separator from content."""
-    if "\r\n" in content:
-        return "\r\n"
-    if "\r" in content:
-        return "\r"
-    return "\n"
-
-
 def rewrite_file(
-    path: Path, new_version: str, patterns: list[re.Pattern]
+    path: Path, new_version: str, patterns: list[re.Pattern[str]]
 ) -> RewriteData:
-    content = path.read_text(newline="")
-    line_sep = detect_line_sep(content)
-    old_lines = content.split(line_sep)
+    with path.open(newline="") as file:
+        content = file.read()
+    old_lines = content.splitlines(keepends=True)
     new_lines = rewrite_lines(old_lines, new_version, patterns)
-    return RewriteData(
-        path=path, old_lines=old_lines, new_lines=new_lines, line_sep=line_sep
-    )
+    return RewriteData(path=path, old_lines=old_lines, new_lines=new_lines)
 
 
 def rewrite_files(config: Config, new_version: str) -> list[RewriteData]:
@@ -90,5 +81,5 @@ def rewrite_files(config: Config, new_version: str) -> list[RewriteData]:
 
 def perform_rewrites(rewrite_data_list: list[RewriteData]) -> None:
     for rewrite_data in rewrite_data_list:
-        new_content = rewrite_data.line_sep.join(rewrite_data.new_lines)
-        rewrite_data.path.write_text(new_content)
+        new_content = "".join(rewrite_data.new_lines)
+        rewrite_data.path.write_text(new_content, newline="")

{ebump-0.2.0 → ebump-0.2.2}/src/ebump/version.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 
 import enum
 import re
-from typing import NamedTuple, cast
+from typing import NamedTuple
 
 
 class PartType(enum.Enum):
@@ -22,9 +22,7 @@ class TagType(enum.Enum):
 
 TAGS_ORDER = {tag: i for i, tag in enumerate(TagType)}
 
-
 VERSION_RE = re.compile(r"(\d+\.\d+\.\d+(?:-(alpha|beta|dev|rc|post)\d*)?)")
-
 VERSION_GROUPS_RE = re.compile(
     r"(?P<major>\d+)"
     r"\."
@@ -61,7 +59,7 @@ class Version(NamedTuple):
         tag = TagType(match.group("tag") or "final")
         tag_num = int(match.group("tag_num") or 0)
 
-        return Version(major, minor, patch, cast(TagType, tag), tag_num)
+        return Version(major, minor, patch, tag, tag_num)
 
     def __eq__(self, other: object) -> bool:
         return self._compare(other) == 0

{ebump-0.2.0 → ebump-0.2.2/src/ebump.egg-info}/PKG-INFO

@@ -1,10 +1,10 @@
 Metadata-Version: 2.4
 Name: ebump
-Version: 0.2.0
+Version: 0.2.2
 Summary: Easy version bumping
 Author-email: Jorge Morgado Vega <jorge.morgadov@gmail.com>
 License: MIT
-Requires-Python: >=3.13
+Requires-Python: >=3.11
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Dynamic: license-file

{ebump-0.2.0 → ebump-0.2.2}/src/ebump.egg-info/SOURCES.txt

@@ -17,4 +17,5 @@ src/ebump.egg-info/top_level.txt
 tests/test_cli.py
 tests/test_config.py
 tests/test_patterns.py
+tests/test_rewrite.py
 tests/test_version.py

{ebump-0.2.0 → ebump-0.2.2}/tests/test_cli.py

@@ -2,6 +2,8 @@
 Tests for ebump CLI.
 """
 
+from pathlib import Path
+
 from conftest import make_pyproject, read_version, run_ebump
 
 # ---------------------------------------------------------------------------
@@ -10,12 +12,12 @@ from conftest import make_pyproject, read_version, run_ebump
 
 
 class TestShowVersion:
-    def test_shows_current_version(self, project):
+    def test_shows_current_version(self, project: Path) -> None:
         result = run_ebump([], project)
         assert result.returncode == 0
         assert "1.0.0" in result.stdout
 
-    def test_shows_pre_release_version(self, project):
+    def test_shows_pre_release_version(self, project: Path) -> None:
         make_pyproject("2.3.0-beta1", project)
         result = run_ebump([], project)
         assert result.returncode == 0
@@ -28,42 +30,42 @@ class TestShowVersion:
 
 
 class TestBumpPatch:
-    def test_patch_increments_patch(self, project):
+    def test_patch_increments_patch(self, project: Path) -> None:
         run_ebump(["patch"], project)
         assert read_version(project) == "1.0.1"
 
-    def test_patch_resets_prerelease_tag(self, project):
+    def test_patch_resets_prerelease_tag(self, project: Path) -> None:
         make_pyproject("1.0.0-beta2", project)
         run_ebump(["patch"], project)
         assert read_version(project) == "1.0.1"
 
-    def test_patch_dry_run_does_not_change(self, project):
+    def test_patch_dry_run_does_not_change(self, project: Path) -> None:
         run_ebump(["patch", "--dry-run"], project)
         assert read_version(project) == "1.0.0"
 
 
 class TestBumpMinor:
-    def test_minor_increments_minor_resets_patch(self, project):
+    def test_minor_increments_minor_resets_patch(self, project: Path) -> None:
         make_pyproject("1.2.3", project)
         run_ebump(["minor"], project)
         assert read_version(project) == "1.3.0"
 
-    def test_minor_with_beta_tag(self, project):
+    def test_minor_with_beta_tag(self, project: Path) -> None:
         run_ebump(["minor", "beta"], project)
         assert read_version(project) == "1.1.0-beta0"
 
-    def test_minor_dry_run(self, project):
+    def test_minor_dry_run(self, project: Path) -> None:
         run_ebump(["minor", "--dry-run"], project)
         assert read_version(project) == "1.0.0"
 
 
 class TestBumpMajor:
-    def test_major_increments_major_resets_rest(self, project):
+    def test_major_increments_major_resets_rest(self, project: Path) -> None:
         make_pyproject("1.5.4", project)
         run_ebump(["major"], project)
         assert read_version(project) == "2.0.0"
 
-    def test_major_with_alpha_tag(self, project):
+    def test_major_with_alpha_tag(self, project: Path) -> None:
         run_ebump(["major", "alpha"], project)
         assert read_version(project) == "2.0.0-alpha0"
 
@@ -74,45 +76,45 @@ class TestBumpMajor:
 
 
 class TestBumpTag:
-    def test_tag_increments_existing_tag_number(self, project):
+    def test_tag_increments_existing_tag_number(self, project: Path) -> None:
         make_pyproject("1.0.0-beta1", project)
         run_ebump(["tag"], project)
         assert read_version(project) == "1.0.0-beta2"
 
-    def test_tag_with_no_tag_exits_error(self, project):
+    def test_tag_with_no_tag_exits_error(self, project: Path) -> None:
         assert read_version(project) == "1.0.0"
         result = run_ebump(["tag"], project)
         assert result.returncode != 0
         assert "Cannot bump tag number on a final version" in result.stderr
 
-    def test_tag_beta_when_at_alpha_promotes_to_beta(self, project):
+    def test_tag_beta_when_at_alpha_promotes_to_beta(self, project: Path) -> None:
         make_pyproject("1.0.0-alpha3", project)
         run_ebump(["tag", "beta"], project)
         assert read_version(project) == "1.0.0-beta0"
 
-    def test_tag_beta_when_at_beta_increments(self, project):
+    def test_tag_beta_when_at_beta_increments(self, project: Path) -> None:
         make_pyproject("1.0.0-beta0", project)
         run_ebump(["tag", "beta"], project)
         assert read_version(project) == "1.0.0-beta1"
 
 
 class TestTagShorthand:
-    def test_alpha_when_already_alpha_increments(self, project):
+    def test_alpha_when_already_alpha_increments(self, project: Path) -> None:
         make_pyproject("1.0.0-alpha4", project)
         run_ebump(["alpha"], project)
         assert read_version(project) == "1.0.0-alpha5"
 
-    def test_beta_when_at_alpha_promotes(self, project):
+    def test_beta_when_at_alpha_promotes(self, project: Path) -> None:
         make_pyproject("1.0.0-alpha5", project)
         run_ebump(["beta"], project)
         assert read_version(project) == "1.0.0-beta0"
 
-    def test_final_from_rc_removes_tag(self, project):
+    def test_final_from_rc_removes_tag(self, project: Path) -> None:
         make_pyproject("1.0.0-rc2", project)
         run_ebump(["final"], project)
         assert read_version(project) == "1.0.0"
 
-    def test_final_when_already_final_is_noop(self, project):
+    def test_final_when_already_final_is_noop(self, project: Path) -> None:
         result = run_ebump(["final"], project)
         assert result.returncode == 0
         assert read_version(project) == "1.0.0"
@@ -125,84 +127,61 @@ class TestTagShorthand:
 
 
 class TestErrorCases:
-    def test_bump_to_tag_on_final_is_error(self, project):
+    def test_bump_to_tag_on_final_is_error(self, project: Path) -> None:
         make_pyproject("1.0.0", project)
         result = run_ebump(["beta"], project)
         assert result.returncode != 0
         assert "Cannot bump to tag beta on a final version" in result.stderr
 
-    def test_two_parts_is_an_error(self, project):
+    def test_two_parts_is_an_error(self, project: Path) -> None:
         result = run_ebump(["patch", "minor"], project)
         assert result.returncode != 0
 
-    def test_two_tags_is_an_error(self, project):
+    def test_two_tags_is_an_error(self, project: Path) -> None:
         result = run_ebump(["alpha", "beta"], project)
         assert result.returncode != 0
 
-    def test_three_args_is_an_error(self, project):
+    def test_three_args_is_an_error(self, project: Path) -> None:
         result = run_ebump(["minor", "alpha", "beta"], project)
         assert result.returncode != 0
 
-    def test_missing_config_exits_with_error(self, tmp_path):
+    def test_missing_config_exits_with_error(self, tmp_path: Path) -> None:
         # A directory with no pyproject.toml at all
         result = run_ebump([], tmp_path)
         assert result.returncode != 0
 
-    def test_invalid_bumping_exits_with_error(self, project):
+    def test_invalid_bumping_exits_with_error(self, project: Path) -> None:
         make_pyproject("1.0.0-beta2", project)
         result = run_ebump(["alpha"], project)
         assert result.returncode != 0
 
 
-class TestRewritePatterns:
-    def test_pattern_rewrite_same_line_endings(self, project):
-        make_pyproject(
-            "1.0.0",
-            project,
-            custom_pyproject_content='[project]\r\nname = "test_project"\r\nversion = "1.0.0"\r\n',
-        )
-        run_ebump(["patch"], project)
-        assert (project / "pyproject.toml").read_text(
-            newline=""
-        ) == '[project]\r\nname = "test_project"\r\nversion = "1.0.1"\r\n'
-
-        make_pyproject(
-            "1.0.0",
-            project,
-            custom_pyproject_content='[project]\rname = "test_project"\rversion = "1.0.0"\r',
-        )
-        run_ebump(["patch"], project)
-        assert (project / "pyproject.toml").read_text(
-            newline=""
-        ) == '[project]\rname = "test_project"\rversion = "1.0.1"\r'
-
-
 class TestVersionSet:
-    def test_version_set(self, project):
+    def test_version_set(self, project: Path) -> None:
         make_pyproject("1.0.0", project)
         result = run_ebump(["--set", "1.0.1-alpha1"], project)
         assert result.returncode == 0
         assert read_version(project) == "1.0.1-alpha1"
 
-    def test_version_set_dry_run(self, project):
+    def test_version_set_dry_run(self, project: Path) -> None:
         make_pyproject("1.0.0", project)
         result = run_ebump(["--set", "1.0.1-alpha1", "--dry-run"], project)
         assert result.returncode == 0
         assert read_version(project) == "1.0.0"
 
-    def test_version_set_invalid_version(self, project):
+    def test_version_set_invalid_version(self, project: Path) -> None:
         make_pyproject("1.0.0", project)
         result = run_ebump(["--set", "not_a_version"], project)
         assert result.returncode != 0
         assert "Invalid version string: not_a_version" in result.stderr
 
-    def test_version_set_forcedly_overwrite(self, project):
+    def test_version_set_forcedly_overwrite(self, project: Path) -> None:
         make_pyproject("3.0.0", project)
         result = run_ebump(["--set", "2.0.0", "--force"], project)
         assert result.returncode == 0
         assert read_version(project) == "2.0.0"
 
-    def test_versino_set_invalid_no_force(self, project):
+    def test_versino_set_invalid_no_force(self, project: Path) -> None:
         make_pyproject("3.0.0", project)
         result = run_ebump(["--set", "2.0.0"], project)
         assert result.returncode != 0

{ebump-0.2.0 → ebump-0.2.2}/tests/test_config.py

@@ -1,4 +1,5 @@
 import textwrap
+from pathlib import Path
 
 import pytest
 from conftest import make_pyproject
@@ -8,12 +9,12 @@ from ebump.version import VERSION_RE
 
 
 class TestConfig:
-    def test_config_no_patterns(self, project):
+    def test_config_no_patterns(self, project: Path) -> None:
         make_pyproject("1.0.0", project)
         cfg = parse_config(project)
         assert cfg.current_version == "1.0.0"
 
-    def test_config_with_patterns(self, project):
+    def test_config_with_patterns(self, project: Path) -> None:
         make_pyproject(
             "2.3.0-beta1",
             project,
@@ -28,7 +29,7 @@ class TestConfig:
         assert len(patterns) == 1
         assert patterns[0].pattern == r"^version = " + VERSION_RE.pattern + "$"
 
-    def test_config_no_pyproject_version(self, project):
+    def test_config_no_pyproject_version(self, project: Path) -> None:
         make_pyproject(
             "",
             project,
@@ -40,7 +41,7 @@ class TestConfig:
         with pytest.raises(ValueError, match=r"No version found in pyproject.toml.*"):
             parse_config(project)
 
-    def test_config_invalid_pyproject_version(self, project):
+    def test_config_invalid_pyproject_version(self, project: Path) -> None:
         make_pyproject(
             "not_a_version",
             project,
@@ -55,7 +56,7 @@ class TestConfig:
         ):
             parse_config(project)
 
-    def test_config_pattern_invalid_file(self, project):
+    def test_config_pattern_invalid_file(self, project: Path) -> None:
         make_pyproject(
             "1.0.0",
             project,

{ebump-0.2.0 → ebump-0.2.2}/tests/test_patterns.py

@@ -1,8 +1,10 @@
+from pathlib import Path
+
 from conftest import make_pyproject, run_ebump
 
 
 class TestPatterns:
-    def test_pattern_simple(self, project):
+    def test_pattern_simple(self, project: Path) -> None:
         make_pyproject(
             "1.0.0",
             project,
@@ -12,7 +14,7 @@ class TestPatterns:
         run_ebump(["patch"], project)
         assert (project / "custom_file.md").read_text() == "version = 1.0.1"
 
-    def test_pattern_multiple_on_same_line(self, project):
+    def test_pattern_multiple_on_same_line(self, project: Path) -> None:
         make_pyproject(
             "1.0.0",
             project,
@@ -22,7 +24,7 @@ class TestPatterns:
         run_ebump(["patch"], project)
         assert (project / "custom_file.md").read_text() == "version = 1.0.1 and 1.0.1"
 
-    def test_multiple_but_only_change_one(self, project):
+    def test_multiple_but_only_change_one(self, project: Path) -> None:
         make_pyproject(
             "1.0.0",
             project,
@@ -34,7 +36,7 @@ class TestPatterns:
             project / "custom_file.md"
         ).read_text() == "version = 1.0.1 version = 1.0.0"
 
-    def test_pattern_not_found(self, project):
+    def test_pattern_not_found(self, project: Path) -> None:
         make_pyproject(
             "1.0.0",
             project,
@@ -45,7 +47,7 @@ class TestPatterns:
         assert result.returncode != 0
         assert "Some patterns were not found" in result.stderr
 
-    def test_pattern_does_not_contain_placeholder(self, project):
+    def test_pattern_does_not_contain_placeholder(self, project: Path) -> None:
         make_pyproject(
             "1.0.0",
             project,

ebump-0.2.2/tests/test_rewrite.py

@@ -0,0 +1,95 @@
+from pathlib import Path
+
+from conftest import make_pyproject, read_raw_text, run_ebump
+
+
+class TestRewritePatterns:
+    def test_pattern_rewrite_same_line_endings(self, project: Path) -> None:
+        make_pyproject(
+            "1.0.0",
+            project,
+            custom_pyproject_content='[project]\r\nname = "test_project"\r\nversion = "1.0.0"\r\n',
+        )
+        run_ebump(["patch"], project)
+        assert (
+            read_raw_text(project / "pyproject.toml")
+            == '[project]\r\nname = "test_project"\r\nversion = "1.0.1"\r\n'
+        )
+
+        make_pyproject(
+            "1.0.0",
+            project,
+            custom_pyproject_content='[project]\rname = "test_project"\rversion = "1.0.0"\r',
+        )
+        run_ebump(["patch"], project)
+        assert (
+            read_raw_text(project / "pyproject.toml")
+            == '[project]\rname = "test_project"\rversion = "1.0.1"\r'
+        )
+
+    def test_mixed_line_endings_preserved(self, project: Path) -> None:
+        content = '[project]\r\nname = "test_project"\nversion = "1.0.0"\r\n'
+        make_pyproject("1.0.0", project, custom_pyproject_content=content)
+
+        run_ebump(["patch"], project)
+
+        assert read_raw_text(project / "pyproject.toml") == (
+            '[project]\r\nname = "test_project"\nversion = "1.0.1"\r\n'
+        )
+
+    def test_no_trailing_newline(self, project: Path) -> None:
+        content = '[project]\nname = "test_project"\nversion = "1.0.0"'
+        make_pyproject("1.0.0", project, custom_pyproject_content=content)
+
+        run_ebump(["patch"], project)
+
+        # should NOT add a newline
+        assert read_raw_text(project / "pyproject.toml") == (
+            '[project]\nname = "test_project"\nversion = "1.0.1"'
+        )
+
+    def test_preserve_multiple_trailing_newlines(self, project: Path) -> None:
+        content = '[project]\nname = "test_project"\nversion = "1.0.0"\n\n'
+        make_pyproject("1.0.0", project, custom_pyproject_content=content)
+
+        run_ebump(["patch"], project)
+
+        assert read_raw_text(project / "pyproject.toml") == (
+            '[project]\nname = "test_project"\nversion = "1.0.1"\n\n'
+        )
+
+    def test_preserve_blank_lines_between(self, project: Path) -> None:
+        content = '[project]\n\nname = "test_project"\n\nversion = "1.0.0"\n'
+        make_pyproject("1.0.0", project, custom_pyproject_content=content)
+
+        run_ebump(["patch"], project)
+
+        assert read_raw_text(project / "pyproject.toml") == (
+            '[project]\n\nname = "test_project"\n\nversion = "1.0.1"\n'
+        )
+
+    def test_crlf_not_doubled(self, project: Path) -> None:
+        # regression test for Windows double-spacing bug
+        content = '[project]\r\nname = "test_project"\r\nversion = "1.0.0"\r\n'
+        make_pyproject("1.0.0", project, custom_pyproject_content=content)
+
+        run_ebump(["patch"], project)
+
+        result = read_raw_text(project / "pyproject.toml")
+
+        # ensure no accidental \r\r\n sequences
+        assert "\r\r\n" not in result
+        assert result == '[project]\r\nname = "test_project"\r\nversion = "1.0.1"\r\n'
+
+    def test_multiple_version_occurrences_same_line(self, project: Path) -> None:
+        content = '[project]\nversion = "1.0.0"\n# here 1.0.0 also 1.0.0 here\n\n[tool.ebump.patterns]\n"pyproject.toml" = ["^# here {version} also {version} here$"]\n'
+        make_pyproject("1.0.0", project, custom_pyproject_content=content)
+
+        result = run_ebump(["patch"], project)
+
+        assert result.returncode == 0, (
+            "ebump failed with output:\n" + result.stdout + "\n" + result.stderr
+        )
+        assert read_raw_text(project / "pyproject.toml") == (
+            '[project]\nversion = "1.0.1"\n# here 1.0.1 also 1.0.1 here\n\n[tool.ebump.patterns]\n"pyproject.toml" = ["^# here {version} also {version} here$"]\n'
+        )

{ebump-0.2.0 → ebump-0.2.2}/tests/test_version.py

@@ -4,7 +4,7 @@ from ebump.version import TagType, Version
 
 
 class TestVersion:
-    def test_version_creation(self):
+    def test_version_creation(self) -> None:
         version = Version(1, 2, 3, TagType.BETA, 4)
         assert version.major == 1
         assert version.minor == 2
@@ -12,7 +12,7 @@ class TestVersion:
         assert version.tag == TagType.BETA
         assert version.tag_num == 4
 
-    def test_version_parsing(self):
+    def test_version_parsing(self) -> None:
         version_str = "1.2.3-beta4"
         version = Version.parse(version_str)
         assert version.major == 1
@@ -21,7 +21,7 @@ class TestVersion:
         assert version.tag == TagType.BETA
         assert version.tag_num == 4
 
-    def test_version_comparison(self):
+    def test_version_comparison(self) -> None:
         v0 = Version.parse("0.0.1-alpha0")
         v1 = Version.parse("0.0.1-beta0")
         v2 = Version.parse("0.0.1-beta1")
@@ -39,15 +39,15 @@ class TestVersion:
         assert v2 > v0
         assert Version.parse("0.0.2") > v3
 
-    def test_version_parsing_error(self):
+    def test_version_parsing_error(self) -> None:
         with pytest.raises(ValueError, match=r"Invalid version string: not_a_version"):
             Version.parse("not_a_version")
 
-    def test_version_comp_with_string(self):
+    def test_version_comp_with_string(self) -> None:
         v = Version.parse("1.0.0")
         assert v == "1.0.0"
 
-    def test_version_comp_with_non_version(self):
+    def test_version_comp_with_non_version(self) -> None:
         v = Version.parse("1.0.0")
         with pytest.raises(TypeError):
             _ = v == 123

ebump-0.2.0/src/ebump/__init__.py

@@ -1 +0,0 @@
-__version__ = "0.2.0"