Refactor SCM info retrieval and config file update checks

Replaced ChainMap with MutableMapping in function signatures and types. Enhanced SCM info handling by splitting code into dedicated methods for commit and revision info retrieval. Added logic to prevent config file updates when the file is outside the repo and implemented corresponding test.

Author: coordt

bumpversion/bump.py

@@ -2,7 +2,7 @@
 
 import shlex
 from pathlib import Path
-from typing import TYPE_CHECKING, ChainMap, List, Optional
+from typing import TYPE_CHECKING, List, MutableMapping, Optional
 
 if TYPE_CHECKING:  # pragma: no-coverage
     from bumpversion.files import ConfiguredFile
@@ -117,7 +117,7 @@ def commit_and_tag(
     config: Config,
     config_file: Optional[Path],
     configured_files: List["ConfiguredFile"],
-    ctx: ChainMap,
+    ctx: MutableMapping,
     dry_run: bool = False,
 ) -> None:
     """

bumpversion/config/files.py

@@ -129,6 +129,11 @@ def update_config_file(
         logger.info("\n%sProcessing config file: %s", logger.indent_str, config_file)
     logger.indent()
     config_path = Path(config_file)
+
+    if config.scm_info.tool and not config.scm_info.path_in_repo(config_path):
+        logger.info("\n%sConfiguration file is outside of the repo. Not going to change.", logger.indent_str)
+        return
+
     if config_path.suffix != ".toml":
         logger.info("You must have a `.toml` suffix to update the config file: %s.", config_path)
         return

bumpversion/scm.py

@@ -6,7 +6,7 @@
 from dataclasses import dataclass
 from pathlib import Path
 from tempfile import NamedTemporaryFile
-from typing import TYPE_CHECKING, ClassVar, List, MutableMapping, Optional, Type, Union
+from typing import TYPE_CHECKING, Any, ClassVar, Dict, List, MutableMapping, Optional, Type, Union
 
 from bumpversion.ui import get_indented_logger
 from bumpversion.utils import extract_regex_flags, run_command
@@ -51,7 +51,7 @@ def __repr__(self):
     def path_in_repo(self, path: Union[Path, str]) -> bool:
         """Return whether a path is inside this repository."""
         if self.repository_root is None:
-            return False
+            return True
 
         return Path(path).is_relative_to(self.repository_root)
 
@@ -263,15 +263,36 @@ def latest_tag_info(cls, tag_name: str, parse_pattern: str) -> SCMInfo:
         if not cls.is_usable():
             return SCMInfo()
 
-        info = SCMInfo(tool=cls)
+        info: Dict[str, Any] = {"tool": cls}
 
         try:
             # git-describe doesn't update the git-index, so we do that
             run_command(["git", "update-index", "--refresh", "-q"])
         except subprocess.CalledProcessError as e:
             logger.debug("Error when running git update-index: %s", e.stderr)
 
+        commit_info = cls._commit_info(parse_pattern, tag_name)
+        rev_info = cls._revision_info()
+        info |= commit_info
+        info |= rev_info
+
+        return SCMInfo(**info)
+
+    @classmethod
+    def _commit_info(cls, parse_pattern: str, tag_name: str) -> dict:
+        """
+        Get the commit info for the repo.
+
+        Args:
+            parse_pattern: The regular expression pattern used to parse the version from the tag.
+            tag_name: The tag name format used to locate the latest tag.
+
+        Returns:
+            A dictionary containing information about the latest commit.
+        """
         tag_pattern = tag_name.replace("{new_version}", "*")
+        info = dict.fromkeys(["dirty", "commit_sha", "distance_to_latest_tag", "current_version"])
+        info["distance_to_latest_tag"] = 0
         try:
             # get info about the latest tag in git
             git_cmd = [
@@ -286,28 +307,45 @@ def latest_tag_info(cls, tag_name: str, parse_pattern: str) -> SCMInfo:
             result = run_command(git_cmd)
             describe_out = result.stdout.strip().split("-")
             if describe_out[-1].strip() == "dirty":
-                info.dirty = True
+                info["dirty"] = True
                 describe_out.pop()
             else:
-                info.dirty = False
+                info["dirty"] = False
 
-            info.commit_sha = describe_out.pop().lstrip("g")
-            info.distance_to_latest_tag = int(describe_out.pop())
+            info["commit_sha"] = describe_out.pop().lstrip("g")
+            info["distance_to_latest_tag"] = int(describe_out.pop())
             version = cls.get_version_from_tag("-".join(describe_out), tag_name, parse_pattern)
-            info.current_version = version or "-".join(describe_out).lstrip("v")
+            info["current_version"] = version or "-".join(describe_out).lstrip("v")
         except subprocess.CalledProcessError as e:
             logger.debug("Error when running git describe: %s", e.stderr)
 
+        return info
+
+    @classmethod
+    def _revision_info(cls) -> dict:
+        """
+        Returns a dictionary containing revision information.
+
+        If an error occurs while running the git command, the dictionary values will be set to None.
+
+        Returns:
+            A dictionary with the following keys:
+                - branch_name: The name of the current branch.
+                - short_branch_name: A 20 lowercase characters of the branch name with special characters removed.
+                - repository_root: The root directory of the Git repository.
+        """
+        info = dict.fromkeys(["branch_name", "short_branch_name", "repository_root"])
+
         try:
             git_cmd = ["git", "rev-parse", "--show-toplevel", "--abbrev-ref", "HEAD"]
             result = run_command(git_cmd)
             lines = [line.strip() for line in result.stdout.split("\n")]
             repository_root = Path(lines[0])
             branch_name = lines[1]
             short_branch_name = re.sub(r"([^a-zA-Z0-9]*)", "", branch_name).lower()[:20]
-            info.branch_name = branch_name
-            info.short_branch_name = short_branch_name
-            info.repository_root = repository_root
+            info["branch_name"] = branch_name
+            info["short_branch_name"] = short_branch_name
+            info["repository_root"] = repository_root
         except subprocess.CalledProcessError as e:
             logger.debug("Error when running git rev-parse: %s", e.stderr)
 
@@ -316,7 +354,9 @@ def latest_tag_info(cls, tag_name: str, parse_pattern: str) -> SCMInfo:
     @classmethod
     def add_path(cls, path: Union[str, Path]) -> None:
         """Add a path to the VCS."""
-        run_command(["git", "add", "--update", str(path)])
+        info = SCMInfo(**cls._revision_info())
+        if info.path_in_repo(path):
+            run_command(["git", "add", "--update", str(path)])
 
     @classmethod
     def tag(cls, name: str, sign: bool = False, message: Optional[str] = None) -> None:

tests/test_cli/test_bump.py

@@ -346,3 +346,40 @@ def test_current_version_not_required_in_config(tmp_path, fixtures_path, runner)
 
     assert result.exit_code == 0
     assert config_file.read_text() == config_contents
+
+
+def test_remote_config_doesnt_update(tmp_path, git_repo, runner):
+    """The current version is not required in the configuration."""
+
+    config_file = tmp_path / ".bumpversion.toml"
+    config_contents = '[tool.bumpversion]\nallow_dirty = true\n\n[[tool.bumpversion.files]]\nfilename = "readme.md"\n'
+    config_file.write_text(
+        config_contents,
+        encoding="utf-8",
+    )
+    myfile = git_repo / "readme.md"
+    myfile.write_text("version = 1.0.0\n", encoding="utf-8")
+
+    # Act
+    with inside_dir(git_repo):
+        result: Result = runner.invoke(
+            cli.cli,
+            [
+                "bump",
+                "-vv",
+                "--current-version",
+                "1.0.0",
+                f"--config-file={config_file}",
+                "minor",
+            ],
+        )
+
+    # Assert
+    if result.exit_code != 0:
+        print("Here is the output:")
+        print(result.output)
+        print(traceback.print_exception(result.exc_info[1]))
+
+    assert result.exit_code == 0
+    assert config_file.read_text() == config_contents
+    assert myfile.read_text() == "version = 1.1.0\n"