dotx 3.2.1__tar.gz → 3.2.2__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dotx
-Version: 3.2.1
+Version: 3.2.2
 Summary: A command-line tool to install a link-farm to your dotfiles
 Author-email: Wolf <Wolf@zv.cx>
 License-Expression: MIT

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

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

{dotx-3.2.1 → dotx-3.2.2}/src/dotx/commands/database.py

@@ -152,9 +152,13 @@ def register_commands(app: typer.Typer):
                 if issues:
                     console.print(f"\n[bold cyan]{pkg_name}:[/bold cyan]")
                     for issue in issues:
-                        console.print(f"  [red]✗[/red] {issue["target_path"]}")
-                        console.print(f"    [dim]Issue: {issue["issue"]}[/dim]")
-                        console.print(f"    [dim]Expected: {issue["link_type"]}[/dim]")
+                        console.print(f"  [red]✗[/red] {issue['target_path']}")
+                        console.print(f"    [dim]Issue: {issue['issue']}[/dim]")
+                        console.print(f"    [dim]Expected type: {issue['link_type']}[/dim]")
+                        if "expected" in issue:
+                            console.print(f"    [dim]Expected source: {issue['expected']}[/dim]")
+                        if "actual" in issue:
+                            console.print(f"    [dim]Actual target: {issue['actual']}[/dim]")
                     total_issues += len(issues)
 
             if total_issues == 0:
@@ -409,6 +413,7 @@ def register_commands(app: typer.Typer):
                 with InstallationDB() as db:
                     all_packages = db.get_all_packages()
                     total_would_clean = 0
+                    total_dangling_symlinks = 0
 
                     for pkg_info in all_packages:
                         pkg_root = Path(pkg_info["package_root"])
@@ -416,10 +421,16 @@ def register_commands(app: typer.Typer):
                         orphaned = db.get_orphaned_entries(pkg_root, pkg_name)
                         if orphaned:
                             total_would_clean += len(orphaned)
+                            # Count dangling symlinks that would be removed
+                            dangling = [e for e in orphaned if Path(e["target_path"]).is_symlink()]
+                            total_dangling_symlinks += len(dangling)
                             console.print(f"  {pkg_name}: {len(orphaned)} orphaned entry(ies)")
+                            if dangling and verbose:
+                                for entry in dangling:
+                                    console.print(f"    [dim]Would remove: {entry['target_path']}[/dim]")
 
                     if total_would_clean > 0:
-                        console.print(f"[yellow]Would remove {total_would_clean} orphaned entry(ies).[/yellow]")
+                        console.print(f"[yellow]Would remove {total_would_clean} orphaned DB entry(ies) and {total_dangling_symlinks} dangling symlink(s).[/yellow]")
                     else:
                         console.print("[green]No orphaned entries to clean.[/green]")
 
@@ -462,18 +473,37 @@ def register_commands(app: typer.Typer):
                 console.print("\n[cyan]Cleaning orphaned entries...[/cyan]")
                 all_packages = db.get_all_packages()
                 total_cleaned = 0
+                total_symlinks_removed = 0
 
                 for pkg_info in all_packages:
                     pkg_root = Path(pkg_info["package_root"])
                     pkg_name = pkg_info["package_name"]
+
+                    # Get orphaned entries before cleaning to remove dangling symlinks
+                    orphaned = db.get_orphaned_entries(pkg_root, pkg_name)
+
+                    # Remove dangling symlinks from filesystem
+                    for entry in orphaned:
+                        target_path = Path(entry["target_path"])
+                        if target_path.is_symlink():
+                            try:
+                                target_path.unlink()
+                                total_symlinks_removed += 1
+                                logger.info(f"Removed dangling symlink: {target_path}")
+                                if verbose:
+                                    console.print(f"  [dim]Removed: {target_path}[/dim]")
+                            except OSError as e:
+                                logger.warning(f"Failed to remove symlink {target_path}: {e}")
+
+                    # Clean database entries
                     cleaned = db.clean_orphaned_entries(pkg_root, pkg_name)
                     if cleaned > 0:
                         total_cleaned += cleaned
                         if verbose:
                             console.print(f"  Cleaned {cleaned} orphaned entry(ies) from {pkg_name}")
 
-                if total_cleaned > 0:
-                    console.print(f"[green]✓ Removed {total_cleaned} orphaned entry(ies).[/green]")
+                if total_cleaned > 0 or total_symlinks_removed > 0:
+                    console.print(f"[green]✓ Removed {total_cleaned} orphaned DB entry(ies) and {total_symlinks_removed} dangling symlink(s).[/green]")
                 else:
                     console.print("[green]✓ No orphaned entries found.[/green]")
 

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

@@ -56,10 +56,18 @@ def register_command(app: typer.Typer):
                 if failures:
                     can_install = False
                     console.print(
-                        f"[red]✗ Error: can't install {source_package.name} - would overwrite:[/red]"
+                        f"[red]✗ Error: can't install {source_package.name} - conflicts detected:[/red]"
                     )
                     for plan_node in failures:
-                        console.print(f"  {target_path / plan_node.relative_destination_path}")
+                        dest_path = target_path / plan_node.relative_destination_path
+                        if dest_path.is_symlink():
+                            try:
+                                link_target = dest_path.readlink()
+                                console.print(f"  {dest_path} [dim](symlink → {link_target})[/dim]")
+                            except OSError:
+                                console.print(f"  {dest_path} [dim](broken symlink)[/dim]")
+                        else:
+                            console.print(f"  {dest_path} [dim](existing file)[/dim]")
                     console.print()
 
             if can_install:

{dotx-3.2.1 → dotx-3.2.2}/src/dotx/database.py

@@ -315,12 +315,43 @@ class InstallationDB:
 
         return [dict(row) for row in cursor.fetchall()]
 
+    def _verify_symlink(self, target: Path, source_package_root: Path) -> dict | None:
+        """
+        Verify a symlink points to the correct source.
+
+        Returns an issue dict if there's a problem, None if symlink is correct.
+        """
+        try:
+            link_target = target.readlink()
+            actual_target = target.resolve()
+
+            # Check if it's a broken symlink (target doesn't exist)
+            if not actual_target.exists():
+                return {
+                    "issue": "Broken symlink (target missing)",
+                    "actual": str(link_target),
+                }
+
+            # Check if symlink points under source_package_root
+            try:
+                actual_target.relative_to(source_package_root)
+                return None  # Symlink is correct
+            except ValueError:
+                return {
+                    "issue": "Symlink points to wrong target",
+                    "expected": str(source_package_root),
+                    "actual": str(link_target),
+                }
+        except OSError:
+            return {"issue": "Cannot read symlink target"}
+
     def verify_installations(self, package_root: Path, package_name: str) -> list[dict]:
         """
         Verify installations for a package against filesystem.
 
         Checks if database records match actual filesystem state. Each issue
-        is a dict with keys: target_path, issue (description), and link_type.
+        is a dict with keys: target_path, issue (description), link_type, and
+        optionally expected/actual for symlink target mismatches.
         """
         if not self.conn:
             raise RuntimeError("Database not connected")
@@ -331,29 +362,37 @@ class InstallationDB:
         for install in installations:
             target = Path(install["target_path"])
             link_type = install["link_type"]
+            source_package_root = Path(install["source_package_root"])
 
-            # Check if file exists
-            if not target.exists():
-                issues.append({
-                    "target_path": str(target),
-                    "issue": "File missing (in DB but not on filesystem)",
-                    "link_type": link_type,
-                })
-                continue
-
-            # Check if it's a symlink (for file and directory types)
             if link_type in ("file", "directory"):
                 if not target.is_symlink():
+                    if target.exists():
+                        issue = "Not a symlink (regular file/dir exists instead)"
+                    else:
+                        issue = "Missing (not on filesystem)"
                     issues.append({
                         "target_path": str(target),
-                        "issue": "Not a symlink (should be symlink)",
+                        "issue": issue,
                         "link_type": link_type,
                     })
+                else:
+                    symlink_issue = self._verify_symlink(target, source_package_root)
+                    if symlink_issue:
+                        symlink_issue["target_path"] = str(target)
+                        symlink_issue["link_type"] = link_type
+                        issues.append(symlink_issue)
+
             elif link_type == "created_dir":
-                if not target.is_dir() or target.is_symlink():
+                if not target.exists():
+                    issue = "Missing (not on filesystem)"
+                elif not target.is_dir() or target.is_symlink():
+                    issue = "Not a regular directory (should be created dir)"
+                else:
+                    issue = None
+                if issue:
                     issues.append({
                         "target_path": str(target),
-                        "issue": "Not a regular directory (should be created dir)",
+                        "issue": issue,
                         "link_type": link_type,
                     })
 

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

@@ -147,12 +147,27 @@ def plan_install(source_package_root: Path, destination_root: Path) -> Plan:
             # we can't link the whole directory - must CREATE it instead
             if plan[child_relative_source_path].requires_rename:
                 found_children_to_rename = True
-            # Fail if we would overwrite an existing regular file
+            # Fail if we would overwrite an existing file or symlink pointing elsewhere
             destination_path = (
                 destination_root
                 / plan[child_relative_source_path].relative_destination_path
             )
-            if destination_path.exists() and destination_path.is_file():
+            if destination_path.is_symlink():
+                # Symlink exists - only OK if it already points to our source
+                expected_source = (
+                    source_package_root / plan[child_relative_source_path].relative_source_path
+                ).resolve()
+                try:
+                    actual_target = destination_path.resolve()
+                except OSError:
+                    # Broken symlink - treat as conflict
+                    actual_target = None
+                if actual_target == expected_source:
+                    # Already installed correctly - skip it
+                    plan[child_relative_source_path].action = Action.SKIP
+                else:
+                    plan[child_relative_source_path].action = Action.FAIL
+            elif destination_path.exists() and destination_path.is_file():
                 plan[child_relative_source_path].action = Action.FAIL
 
         # Second pass: decide action for current directory based on children and destination state

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dotx
-Version: 3.2.1
+Version: 3.2.2
 Summary: A command-line tool to install a link-farm to your dotfiles
 Author-email: Wolf <Wolf@zv.cx>
 License-Expression: MIT

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

@@ -42,9 +42,9 @@ def test_cli_install_conflict_detection(tmp_path):
 
     assert result.exit_code == 0  # CLI doesn't return error code, just refuses
     assert "can't install" in result.output.lower()
-    assert "would overwrite" in result.output.lower()
+    assert "conflicts detected" in result.output.lower()
+    assert "existing file" in result.output.lower()
     assert "Refusing to install" in result.output
-    assert "conflicts detected" in result.output
 
 
 def test_cli_install_with_verbose(tmp_path, isolated_db):
@@ -295,5 +295,7 @@ def test_cli_uninstall_dry_run_shows_indicator(tmp_path, isolated_db):
     # Should clearly indicate dry-run mode
     assert "[DRY RUN]" in result.output
     assert "Would remove" in result.output
+    # Should show the rm command that would be executed
+    assert "rm" in result.output
     # File should still exist after dry-run
     assert (target / "file1").exists()

{dotx-3.2.1 → dotx-3.2.2}/tests/test_cli_database.py

@@ -117,6 +117,52 @@ def test_verify_not_symlink(tmp_path):
         assert "not a symlink" in issues[0]["issue"].lower()
 
 
+def test_verify_wrong_symlink_target(tmp_path):
+    """Test 'dotx verify' detects symlinks pointing to wrong target."""
+    db_path = tmp_path / "test.db"
+    package = tmp_path / "package"
+    package.mkdir()
+    (package / "dot-bashrc").write_text("# correct source")
+
+    target_file = tmp_path / ".bashrc"
+    # Create symlink pointing to wrong location
+    wrong_target = tmp_path / "wrong-file"
+    wrong_target.write_text("# wrong target")
+    target_file.symlink_to(wrong_target)
+
+    # Record as if it were pointing to package
+    with InstallationDB(db_path) as db:
+        db.record_installation(tmp_path, "package", package, target_file, "file")
+
+    # Verify - should detect wrong target
+    with InstallationDB(db_path) as db:
+        issues = db.verify_installations(tmp_path, "package")
+        assert len(issues) == 1
+        assert "wrong target" in issues[0]["issue"].lower()
+        assert "actual" in issues[0]
+
+
+def test_verify_broken_symlink(tmp_path):
+    """Test 'dotx verify' detects broken symlinks."""
+    db_path = tmp_path / "test.db"
+    package = tmp_path / "package"
+    package.mkdir()
+
+    target_file = tmp_path / ".bashrc"
+    # Create symlink pointing to nonexistent file
+    target_file.symlink_to("/nonexistent/path")
+
+    # Record installation
+    with InstallationDB(db_path) as db:
+        db.record_installation(tmp_path, "package", package, target_file, "file")
+
+    # Verify - should detect broken symlink
+    with InstallationDB(db_path) as db:
+        issues = db.verify_installations(tmp_path, "package")
+        assert len(issues) == 1
+        assert "broken" in issues[0]["issue"].lower()
+
+
 def test_show_package(tmp_path):
     """Test 'dotx show' displays package installation details."""
     db_path = tmp_path / "test.db"
@@ -557,7 +603,7 @@ def test_cli_sync_clean_dry_run(tmp_path, monkeypatch):
 
     assert result.exit_code == 0
     assert "Would clean orphaned entries" in result.output
-    assert "Would remove 1 orphaned entry(ies)" in result.output
+    assert "Would remove 1 orphaned DB entry(ies)" in result.output
     assert "Dry run" in result.output
 
 
@@ -604,7 +650,7 @@ def test_cli_sync_clean(tmp_path, monkeypatch):
 
     assert result.exit_code == 0
     assert "Cleaning orphaned entries" in result.output
-    assert "Removed 1 orphaned entry(ies)" in result.output
+    assert "Removed 1 orphaned DB entry(ies)" in result.output
 
     # Check database now has only 1 entry
     with InstallationDB() as db:

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

@@ -289,6 +289,59 @@ def test_install_normal_file_fail(tmp_path):
     )
 
 
+def test_install_symlink_to_wrong_target_fails(tmp_path):
+    """Test that existing symlink pointing to wrong target is marked FAIL."""
+    source_package_root = tmp_path / "source"
+    destination_root = tmp_path / "dest"
+    source_package_root.mkdir()
+    destination_root.mkdir()
+    file_path = Path("file1")
+    (source_package_root / file_path).write_text("content")
+
+    # Create a symlink pointing to a different location
+    wrong_target = tmp_path / "wrong_target"
+    wrong_target.write_text("wrong content")
+    (destination_root / file_path).symlink_to(wrong_target)
+
+    plan = plan_install(source_package_root, destination_root)
+
+    assert plan[file_path].action == Action.FAIL
+
+
+def test_install_broken_symlink_fails(tmp_path):
+    """Test that existing broken symlink is marked FAIL."""
+    source_package_root = tmp_path / "source"
+    destination_root = tmp_path / "dest"
+    source_package_root.mkdir()
+    destination_root.mkdir()
+    file_path = Path("file1")
+    (source_package_root / file_path).write_text("content")
+
+    # Create a broken symlink (target doesn't exist)
+    (destination_root / file_path).symlink_to("/nonexistent/path")
+
+    plan = plan_install(source_package_root, destination_root)
+
+    assert plan[file_path].action == Action.FAIL
+
+
+def test_install_symlink_to_our_source_skips(tmp_path):
+    """Test that existing symlink pointing to our source is marked SKIP."""
+    source_package_root = tmp_path / "source"
+    destination_root = tmp_path / "dest"
+    source_package_root.mkdir()
+    destination_root.mkdir()
+    file_path = Path("file1")
+    (source_package_root / file_path).write_text("content")
+
+    # Create a symlink pointing to our source (already installed)
+    (destination_root / file_path).symlink_to(source_package_root / file_path)
+
+    plan = plan_install(source_package_root, destination_root)
+
+    assert plan[file_path].action == Action.SKIP
+
+
 def test_install_hidden_file(tmp_path):
     source_package_root = tmp_path / "source"
     destination_root = tmp_path / "dest"