dotx 3.2.0__tar.gz → 3.2.1__tar.gz

{dotx-3.2.0/src/dotx.egg-info → dotx-3.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dotx
-Version: 3.2.0
+Version: 3.2.1
 Summary: A command-line tool to install a link-farm to your dotfiles
 Author-email: Wolf <Wolf@zv.cx>
 License-Expression: MIT
@@ -58,6 +58,16 @@ purpose tool.  It's made for installing a link-farm to any kind of package from
 it for other purposes, but it's tuned for its goal.  It does the renaming task if you want it, but if your source files
 are named simply `.bashrc` it works just as well.
 
+### How to install
+
+It's an ordinary PyPI-supplied Python package providing CLI entry points, so you can install it with `pip` or any other tool you like. I think the best way to install it is this:
+
+```bash
+uv tool install dotx
+```
+
+The current version is: v3.2.0
+
 ### The user interface
 ```
 Usage: dotx [OPTIONS] COMMAND [ARGS]...

{dotx-3.2.0 → dotx-3.2.1}/README.md

@@ -30,6 +30,16 @@ purpose tool.  It's made for installing a link-farm to any kind of package from
 it for other purposes, but it's tuned for its goal.  It does the renaming task if you want it, but if your source files
 are named simply `.bashrc` it works just as well.
 
+### How to install
+
+It's an ordinary PyPI-supplied Python package providing CLI entry points, so you can install it with `pip` or any other tool you like. I think the best way to install it is this:
+
+```bash
+uv tool install dotx
+```
+
+The current version is: v3.2.0
+
 ### The user interface
 ```
 Usage: dotx [OPTIONS] COMMAND [ARGS]...

{dotx-3.2.0 → dotx-3.2.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "dotx"
-version = "3.2.0"
+version = "3.2.1"
 description = "A command-line tool to install a link-farm to your dotfiles"
 authors = [
     { name = "Wolf", email = "Wolf@zv.cx" }

{dotx-3.2.0 → dotx-3.2.1}/src/dotx/commands/install_cmd.py

@@ -10,7 +10,7 @@ from rich.console import Console
 from dotx.commands.progress import execute_plans_with_progress
 from dotx.database import InstallationDB
 from dotx.install import plan_install
-from dotx.options import is_verbose_mode
+from dotx.options import is_dry_run, is_verbose_mode
 from dotx.plan import Action, Plan, extract_plan, log_extracted_plan
 
 
@@ -92,7 +92,10 @@ def register_command(app: typer.Typer):
                     summary_parts.append(f"{total_dirs} dir(s)")
 
                 summary = " and ".join(summary_parts) if summary_parts else "nothing"
-                console.print(f"\n[green]✓ Installed {summary} from {len(sources)} package(s)[/green]")
+                if is_dry_run(ctx):
+                    console.print(f"\n[yellow][DRY RUN] Would install {summary} from {len(sources)} package(s)[/yellow]")
+                else:
+                    console.print(f"\n[green]✓ Installed {summary} from {len(sources)} package(s)[/green]")
             else:
                 console.print("[red]✗ Refusing to install - conflicts detected[/red]")
 

{dotx-3.2.0 → dotx-3.2.1}/src/dotx/commands/uninstall_cmd.py

@@ -9,7 +9,7 @@ from rich.console import Console
 
 from dotx.commands.progress import execute_plans_with_progress
 from dotx.database import InstallationDB
-from dotx.options import is_verbose_mode
+from dotx.options import is_dry_run, is_verbose_mode
 from dotx.plan import Action, Plan, extract_plan, log_extracted_plan
 from dotx.uninstall import plan_uninstall
 
@@ -67,6 +67,9 @@ def register_command(app: typer.Typer):
                 len(extract_plan(plan, {Action.UNLINK}))
                 for _, plan in plans
             )
-            console.print(f"\n[green]✓ Removed {total_removed} symlink(s) from {len(sources)} package(s)[/green]")
+            if is_dry_run(ctx):
+                console.print(f"\n[yellow][DRY RUN] Would remove {total_removed} symlink(s) from {len(sources)} package(s)[/yellow]")
+            else:
+                console.print(f"\n[green]✓ Removed {total_removed} symlink(s) from {len(sources)} package(s)[/green]")
 
         logger.info("uninstall finished")

{dotx-3.2.0 → dotx-3.2.1}/src/dotx/install.py

@@ -193,8 +193,9 @@ def plan_install(source_package_root: Path, destination_root: Path) -> Plan:
                 plan=plan,
             )
             logger.debug(f"Directory {relative_destination_root_path} matches always-create pattern, will CREATE")
-        else:
+        elif plan[relative_root_path].action != Action.CREATE:
             # Directory doesn't exist and has no rename conflicts - we can link it
+            # But only if it wasn't already marked CREATE by a descendant's mark_all_ancestors
             plan[relative_root_path].action = Action.LINK
 
         # Third pass: mark children based on what we decided for this directory

{dotx-3.2.0 → dotx-3.2.1}/src/dotx/plan.py

@@ -183,11 +183,12 @@ def execute_plan(
     # This does duplicate the loop code, but avoids thousands of repeated is_dry_run() calls
     # in installations with many files.
     if is_dry_run():
+        print("[DRY RUN] Would execute the equivalent of:")
         for step in steps:
             command = build_shell_command(step)
             if command is not None:
                 logger.info(command)
-                print(command)
+                print(f"  {command}")
     else:
         for step in steps:
             command = build_shell_command(step)

{dotx-3.2.0 → dotx-3.2.1/src/dotx.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dotx
-Version: 3.2.0
+Version: 3.2.1
 Summary: A command-line tool to install a link-farm to your dotfiles
 Author-email: Wolf <Wolf@zv.cx>
 License-Expression: MIT
@@ -58,6 +58,16 @@ purpose tool.  It's made for installing a link-farm to any kind of package from
 it for other purposes, but it's tuned for its goal.  It does the renaming task if you want it, but if your source files
 are named simply `.bashrc` it works just as well.
 
+### How to install
+
+It's an ordinary PyPI-supplied Python package providing CLI entry points, so you can install it with `pip` or any other tool you like. I think the best way to install it is this:
+
+```bash
+uv tool install dotx
+```
+
+The current version is: v3.2.0
+
 ### The user interface
 ```
 Usage: dotx [OPTIONS] COMMAND [ARGS]...

{dotx-3.2.0 → dotx-3.2.1}/tests/test_cli.py

@@ -246,3 +246,54 @@ def test_options_functions():
     result = runner.invoke(app, ["--verbose", "--debug", "--dry-run", "debug"])
 
     assert len(result.output) == 0
+
+
+def test_cli_install_dry_run_shows_indicator(tmp_path):
+    """Test install with --dry-run clearly indicates dry-run mode in output."""
+    source = tmp_path / "source"
+    source.mkdir()
+    target = tmp_path / "target"
+    target.mkdir()
+
+    # Create source file
+    (source / "file1").write_text("content1")
+
+    runner = CliRunner()
+
+    # Install with --dry-run
+    result = runner.invoke(app, [f"--target={target}", "--dry-run", "install", str(source)])
+
+    assert result.exit_code == 0
+    # Should clearly indicate dry-run mode
+    assert "[DRY RUN]" in result.output
+    assert "Would install" in result.output
+    # File should NOT actually be created
+    assert not (target / "file1").exists()
+
+
+def test_cli_uninstall_dry_run_shows_indicator(tmp_path, isolated_db):
+    """Test uninstall with --dry-run clearly indicates dry-run mode in output."""
+    source = tmp_path / "source"
+    source.mkdir()
+    target = tmp_path / "target"
+    target.mkdir()
+
+    # Create and install source file
+    (source / "file1").write_text("content1")
+
+    runner = CliRunner()
+
+    # First install for real
+    result = runner.invoke(app, [f"--target={target}", "install", str(source)])
+    assert result.exit_code == 0
+    assert (target / "file1").exists()
+
+    # Uninstall with --dry-run
+    result = runner.invoke(app, [f"--target={target}", "--dry-run", "uninstall", str(source)])
+
+    assert result.exit_code == 0
+    # Should clearly indicate dry-run mode
+    assert "[DRY RUN]" in result.output
+    assert "Would remove" in result.output
+    # File should still exist after dry-run
+    assert (target / "file1").exists()

{dotx-3.2.0 → dotx-3.2.1}/tests/test_install.py

@@ -543,3 +543,86 @@ def test_install_renamed_dir_inside_renamed_dir(tmp_path):
         Action.LINK, True, dir2_path, Path(".SIMPLE-DIR1/.SIMPLE-DIR2"), True
     )
     assert plan[file_path].action == Action.SKIP
+
+
+def test_install_deep_nesting_with_renamed_leaf(tmp_path):
+    """
+    Test that deeply nested directories with a renamed file at the leaf install correctly.
+
+    This tests the fix for a bug where:
+    - Deep directory structure: a/b/c/d/e/f/dot-deepfile
+    - The leaf file needs renaming (dot-deepfile -> .deepfile)
+    - Directory f gets marked CREATE (because child needs renaming)
+    - All parent directories should also be CREATE (via mark_all_ancestors)
+
+    Bug was: parent dirs were overwritten to LINK when processed bottom-up,
+    causing FileExistsError when we tried to CREATE f under a symlinked parent.
+
+    Fix: preserve CREATE if already set by a descendant's mark_all_ancestors.
+    """
+    source_package_root = tmp_path / "source"
+    destination_root = tmp_path / "dest"
+    source_package_root.mkdir()
+    destination_root.mkdir()
+
+    # Create deep nesting: a/b/c/d/e/f/dot-deepfile
+    deep_path = Path("a/b/c/d/e/f")
+    file_path = deep_path / "dot-deepfile"
+    (source_package_root / deep_path).mkdir(parents=True)
+    (source_package_root / file_path).write_text("deep content")
+
+    plan = plan_install(source_package_root, destination_root)
+
+    # All directories should be CREATE (to support the renamed file at the leaf)
+    for part_count in range(1, 7):  # a, b, c, d, e, f
+        parts = ["a", "b", "c", "d", "e", "f"][:part_count]
+        subdir_path = Path("/".join(parts))
+        assert plan[subdir_path].action == Action.CREATE, f"{subdir_path} should be CREATE"
+
+    # The file should be LINK with renaming
+    assert plan[file_path].action == Action.LINK
+    assert plan[file_path].requires_rename
+    assert plan[file_path].relative_destination_path == Path("a/b/c/d/e/f/.deepfile")
+
+
+def test_install_deep_nesting_execute(tmp_path, isolated_db):
+    """
+    Test that deeply nested directories with renamed leaf actually install without error.
+
+    This is an integration test that verifies the full install flow works,
+    not just the planning phase.
+    """
+    from typer.testing import CliRunner
+
+    from dotx.cli import app
+
+    source_package_root = tmp_path / "source"
+    destination_root = tmp_path / "dest"
+    source_package_root.mkdir()
+    destination_root.mkdir()
+
+    # Create deep nesting: a/b/c/d/e/f/dot-deepfile
+    deep_path = Path("a/b/c/d/e/f")
+    file_path = deep_path / "dot-deepfile"
+    (source_package_root / deep_path).mkdir(parents=True)
+    (source_package_root / file_path).write_text("deep content")
+
+    runner = CliRunner()
+
+    # Execute install via CLI - should not raise an error
+    result = runner.invoke(app, [f"--target={destination_root}", "install", str(source_package_root)])
+
+    assert result.exit_code == 0, f"Install failed: {result.output}"
+
+    # Verify: all directories should be real directories (CREATE), not symlinks
+    for part_count in range(1, 7):
+        parts = ["a", "b", "c", "d", "e", "f"][:part_count]
+        dir_path = destination_root / "/".join(parts)
+        assert dir_path.is_dir(), f"{dir_path} should be a directory"
+        assert not dir_path.is_symlink(), f"{dir_path} should NOT be a symlink"
+
+    # The file should be a symlink with the renamed name (.deepfile, not dot-deepfile)
+    deep_file_dest = destination_root / "a/b/c/d/e/f/.deepfile"
+    assert deep_file_dest.is_symlink()
+    assert deep_file_dest.exists()
+    assert deep_file_dest.read_text() == "deep content"