calkit-python 0.35.3__tar.gz → 0.35.4__tar.gz

{calkit_python-0.35.3 → calkit_python-0.35.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: calkit-python
-Version: 0.35.3
+Version: 0.35.4
 Summary: Reproducibility simplified.
 Project-URL: Homepage, https://calkit.org
 Project-URL: Issues, https://github.com/calkit/calkit/issues

{calkit_python-0.35.3 → calkit_python-0.35.4}/calkit/git.py

@@ -150,10 +150,48 @@ def ensure_path_is_not_ignored(
         gitignore_txt = f.read()
     lines = gitignore_txt.splitlines()
     no_ignore_line = f"!{target_path}"
-    if target_path in lines:
-        lines.remove(target_path)
-    elif no_ignore_line not in lines:
-        lines.append(no_ignore_line)
+    path_parts = Path(target_path).parts
+    if len(path_parts) == 1:
+        # Simple (non-nested) path: remove the direct ignore rule, or add a
+        # negation if the ignore comes from a glob or other pattern.
+        if target_path in lines:
+            lines.remove(target_path)
+        elif no_ignore_line not in lines:
+            lines.append(no_ignore_line)
+    else:
+        # Nested path: Git will not traverse into a directory excluded by a
+        # "dir/" pattern, so a bare "!dir/sub/file" negation has no effect.
+        # We need to:
+        #   1. Convert any "ancestor/" (or "ancestor") exclude to "ancestor/*"
+        #      so that git traverses the directory while still ignoring its
+        #      direct children by default.
+        #   2. Add "!ancestor/" un-ignore rules for each intermediate directory
+        #      so git recurses into them.
+        #   3. Add "ancestor/*" re-ignore rules so that only explicitly
+        #      un-ignored files within each intermediate directory are tracked.
+        #   4. Add the final "!target_path" negation for the specific file.
+        if target_path in lines:
+            lines.remove(target_path)
+        for i in range(1, len(path_parts)):
+            ancestor = "/".join(path_parts[:i])
+            reignore_glob = f"{ancestor}/*"
+            # Convert a directory-exclude pattern to a glob so git traverses it
+            if f"{ancestor}/" in lines:
+                idx = lines.index(f"{ancestor}/")
+                lines[idx] = reignore_glob
+            elif ancestor in lines:
+                idx = lines.index(ancestor)
+                lines[idx] = reignore_glob
+            # Un-ignore this intermediate directory so git recurses into it
+            no_ignore_dir = f"!{ancestor}/"
+            if no_ignore_dir not in lines:
+                lines.append(no_ignore_dir)
+            # Re-ignore everything inside this intermediate directory so that
+            # only explicitly un-ignored entries are tracked
+            if reignore_glob not in lines:
+                lines.append(reignore_glob)
+        if no_ignore_line not in lines:
+            lines.append(no_ignore_line)
     with open(gitignore_path, "w") as f:
         f.write(os.linesep.join(lines))
     return True

{calkit_python-0.35.3 → calkit_python-0.35.4}/calkit/releases.py

@@ -129,7 +129,7 @@ def create_citation_cff(
 def ls_files() -> list[str]:
     """List all files to be released."""
     repo = git.Repo()
-    git_files = repo.git.ls_files(".").strip().split("\n")
+    git_files = repo.git.ls_files(".", recurse_submodules=True).splitlines()
     dvc_files = calkit.dvc.list_paths(recursive=True)
     return git_files + dvc_files
 

{calkit_python-0.35.3 → calkit_python-0.35.4}/calkit/tests/test_git.py

@@ -1,5 +1,6 @@
 """Tests for ``calkit.git``."""
 
+import os
 from pathlib import Path
 
 import git
@@ -97,3 +98,53 @@ def test_ensure_path_is_not_ignored(tmp_dir):
         gi_sub = f.read().splitlines()
     assert "test.txt" not in gi_sub
     assert "!test.txt" not in gi_sub
+
+
+def test_ensure_path_is_not_ignored_nested(tmp_dir):
+    """Test that nested paths in ignored directories are correctly un-ignored.
+
+    When a parent directory is excluded with a trailing slash (e.g.,
+    ``results/``), git will not traverse into it, so a simple negation like
+    ``!results/StageName/end.json`` has no effect.  The fix converts the
+    directory exclude to a glob pattern and adds intermediate un-ignore rules.
+    """
+    repo = git.Repo.init()
+    # Ignore the entire results/ directory
+    with open(".gitignore", "w") as f:
+        f.write("results/\n")
+    # Create the nested target file so git can evaluate ignore status
+    os.makedirs("results/StageName", exist_ok=True)
+    with open("results/StageName/end.json", "w") as f:
+        f.write("{}")
+    # The file must be ignored before we try to un-ignore it
+    assert repo.ignored("results/StageName/end.json")
+    result = calkit.git.ensure_path_is_not_ignored(
+        repo, path="results/StageName/end.json"
+    )
+    assert result is True
+    with open(".gitignore") as f:
+        lines = f.read().splitlines()
+    # The plain directory exclude should be replaced with a glob
+    assert "results/" not in lines
+    assert "results/*" in lines
+    # Intermediate directory must be un-ignored so git traverses into it
+    assert "!results/StageName/" in lines
+    # The intermediate directory's other contents must be re-ignored
+    assert "results/StageName/*" in lines
+    # The specific file must be explicitly un-ignored
+    assert "!results/StageName/end.json" in lines
+    # Verify git no longer considers the target file as ignored
+    assert not repo.ignored("results/StageName/end.json")
+    # Other files in results/ must still be ignored
+    with open("results/other.txt", "w") as f:
+        f.write("other")
+    assert repo.ignored("results/other.txt")
+    # Other files in the intermediate directory must still be ignored
+    with open("results/StageName/other.json", "w") as f:
+        f.write("{}")
+    assert repo.ignored("results/StageName/other.json")
+    # Calling again should be a no-op (path is no longer ignored)
+    result2 = calkit.git.ensure_path_is_not_ignored(
+        repo, path="results/StageName/end.json"
+    )
+    assert result2 is None

calkit_python-0.35.4/calkit/tests/test_releases.py

@@ -0,0 +1,44 @@
+"""Tests for the ``releases`` module."""
+
+import subprocess
+
+import git
+
+from calkit.releases import ls_files
+
+
+def test_ls_files(tmp_dir):
+    subprocess.run(["calkit", "init"], check=True)
+    # Create some files and add them to git and dvc
+    (tmp_dir / "file1.txt").write_text("This is file 1.")
+    (tmp_dir / "file2.txt").write_text("This is file 2.")
+    subprocess.run(["git", "add", "file1.txt"], check=True)
+    subprocess.run(["git", "commit", "-m", "Add file1.txt"], check=True)
+    subprocess.run(["calkit", "dvc", "add", "file2.txt"], check=True)
+    # Get the list of files to be released
+    files = ls_files()
+    assert "file1.txt" in files
+    assert "file2.txt" in files
+    # Now add some files in a git submodule and ensure they are included
+    submodule_source = tmp_dir / "submodule-source"
+    submodule_repo = git.Repo.init(submodule_source)
+    (submodule_source / "submodule-file.txt").write_text(
+        "This file lives in the submodule."
+    )
+    submodule_repo.git.add("submodule-file.txt")
+    submodule_repo.index.commit("Add submodule file")
+    subprocess.run(
+        [
+            "git",
+            "-c",
+            "protocol.file.allow=always",
+            "submodule",
+            "add",
+            str(submodule_source),
+            "submodule",
+        ],
+        check=True,
+    )
+    subprocess.run(["git", "commit", "-m", "Add submodule"], check=True)
+    files = ls_files()
+    assert "submodule/submodule-file.txt" in files