dotx 3.2.2__tar.gz → 3.3.0__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dotx
-Version: 3.2.2
+Version: 3.3.0
 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.2 → dotx-3.3.0}/pyproject.toml

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

{dotx-3.2.2 → dotx-3.3.0}/src/dotx/cli.py

@@ -68,13 +68,20 @@ def main(
     target: Annotated[
         Path | None,
         typer.Option(
-            help="Where to install (defaults to $HOME)",
+            help="Where to install (defaults to $HOME). Mutually exclusive with --xdg.",
             exists=True,
             file_okay=False,
             dir_okay=True,
             writable=True,
         ),
     ] = None,
+    xdg: Annotated[
+        bool,
+        typer.Option(
+            "--xdg/--no-xdg",
+            help="Use XDG Base Directory paths (.config→$XDG_CONFIG_HOME, etc). Mutually exclusive with --target.",
+        ),
+    ] = False,
     dry_run: Annotated[
         bool,
         typer.Option("--dry-run/--no-dry-run", help="Just echo; don't actually (un)install"),
@@ -91,6 +98,10 @@ def main(
     """
     configure_logging(debug, verbose, log)
 
+    # Check mutual exclusivity
+    if xdg and target is not None:
+        raise typer.BadParameter("--xdg and --target are mutually exclusive")
+
     # Store options in context for commands to access
     ctx.ensure_object(dict)
     if target:
@@ -101,6 +112,7 @@ def main(
     set_option("DEBUG", debug, ctx)
     set_option("VERBOSE", verbose, ctx)
     set_option("DRYRUN", dry_run, ctx)
+    set_option("XDG", xdg, ctx)
 
     if log:
         set_option("LOG", log, ctx)

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

@@ -23,6 +23,7 @@ from loguru import logger
 
 from dotx.hierarchy import HierarchicalPatternMatcher
 from dotx.ignore import IgnoreRules
+from dotx.options import is_xdg_mode
 from dotx.plan import (
     Action,
     Plan,
@@ -30,6 +31,7 @@ from dotx.plan import (
     log_extracted_plan,
     mark_all_ancestors,
     mark_immediate_children,
+    resolve_destination,
 )
 
 
@@ -99,9 +101,13 @@ def plan_install(source_package_root: Path, destination_root: Path) -> Plan:
     already exists at the destination, which must be created, renamed, linked, or already exist in a way that causes
     a failure.
 
+    Respects XDG mode: when enabled, .config/*, .local/share/*, .cache/* are resolved to their
+    respective XDG Base Directory paths when checking for existing files.
+
     Returns: a `Plan` with all the information needed to complete an install, or to fail
     """
     plan: Plan = plan_install_paths(source_package_root)
+    xdg_mode = is_xdg_mode()
 
     # Load always-create patterns to determine which directories must be real (never symlinked)
     always_create_matcher = HierarchicalPatternMatcher(".always-create")
@@ -148,9 +154,10 @@ def plan_install(source_package_root: Path, destination_root: Path) -> Plan:
             if plan[child_relative_source_path].requires_rename:
                 found_children_to_rename = True
             # Fail if we would overwrite an existing file or symlink pointing elsewhere
-            destination_path = (
-                destination_root
-                / plan[child_relative_source_path].relative_destination_path
+            destination_path = resolve_destination(
+                plan[child_relative_source_path].relative_destination_path,
+                destination_root,
+                xdg_mode,
             )
             if destination_path.is_symlink():
                 # Symlink exists - only OK if it already points to our source
@@ -174,7 +181,7 @@ def plan_install(source_package_root: Path, destination_root: Path) -> Plan:
         if current_root_path == source_package_root:
             # Package root always EXISTS (it's the target directory)
             plan[relative_root_path].action = Action.EXISTS
-        elif (destination_root / relative_destination_root_path).exists():
+        elif resolve_destination(relative_destination_root_path, destination_root, xdg_mode).exists():
             # Directory already exists at destination - merge into it
             # This takes precedence over always-create because we can't create what exists
             plan[relative_root_path].action = Action.EXISTS

{dotx-3.2.2 → dotx-3.3.0}/src/dotx/options.py

@@ -4,6 +4,7 @@ This module provides convenience functions for accessing user-data on the associ
 Note: typer is built on click, so we use click.Context for type annotations.
 """
 
+from pathlib import Path
 from typing import Any
 
 import click
@@ -36,7 +37,8 @@ def get_option(option: str, default_for_option: Any = None, ctx: click.Context |
     """
     if ctx is None:
         # Typer uses click under the hood, so we can use click's get_current_context
-        ctx = click.get_current_context()
+        # Use silent=True to return None instead of raising when no context exists
+        ctx = click.get_current_context(silent=True)
     if ctx is not None and ctx.obj is not None and option in ctx.obj:
         return ctx.obj[option]
     return default_for_option
@@ -55,3 +57,28 @@ def is_debug_mode(ctx: click.Context | None = None) -> bool:
 def is_dry_run(ctx: click.Context | None = None) -> bool:
     """Check if dry-run mode is enabled."""
     return get_option("DRYRUN", False, ctx)
+
+
+def is_xdg_mode(ctx: click.Context | None = None) -> bool:
+    """Check if XDG mode is enabled."""
+    return get_option("XDG", False, ctx)
+
+
+def get_xdg_paths() -> dict[str, Path]:
+    """
+    Get XDG Base Directory paths with defaults.
+
+    Returns a dict mapping destination prefixes to their XDG paths:
+    - ".config" → $XDG_CONFIG_HOME (default ~/.config)
+    - ".local/share" → $XDG_DATA_HOME (default ~/.local/share)
+    - ".cache" → $XDG_CACHE_HOME (default ~/.cache)
+    """
+    import os
+
+    home = Path.home()
+
+    return {
+        ".config": Path(os.environ.get("XDG_CONFIG_HOME", home / ".config")),
+        ".local/share": Path(os.environ.get("XDG_DATA_HOME", home / ".local/share")),
+        ".cache": Path(os.environ.get("XDG_CACHE_HOME", home / ".cache")),
+    }

{dotx-3.2.2 → dotx-3.3.0}/src/dotx/plan.py

@@ -34,7 +34,7 @@ from typing import TYPE_CHECKING
 from loguru import logger
 
 from dotx.database import NoOpDB
-from dotx.options import is_dry_run
+from dotx.options import is_dry_run, is_xdg_mode, get_xdg_paths
 
 if TYPE_CHECKING:
     from dotx.database import InstallationDB
@@ -91,6 +91,33 @@ class PlanNode:
 Plan = dict[Path, PlanNode]
 
 
+def resolve_destination(relative_path: Path, default_root: Path, xdg_mode: bool = False) -> Path:
+    """
+    Resolve the absolute destination path, respecting XDG mode.
+
+    In normal mode: default_root / relative_path
+    In XDG mode: redirects .config/*, .local/share/*, .cache/* to XDG directories
+    """
+    if not xdg_mode:
+        return default_root / relative_path
+
+    path_str = str(relative_path)
+    xdg_paths = get_xdg_paths()
+
+    # Check XDG prefixes in order of specificity (longer first)
+    for prefix in sorted(xdg_paths.keys(), key=len, reverse=True):
+        if path_str == prefix:
+            # Exact match - return the XDG dir itself
+            return xdg_paths[prefix]
+        if path_str.startswith(prefix + "/"):
+            # Path under XDG dir - remap it
+            suffix = path_str[len(prefix) + 1:]
+            return xdg_paths[prefix] / suffix
+
+    # No XDG prefix match - use default (HOME)
+    return default_root / relative_path
+
+
 def execute_plan(
     source_package_root: Path,
     destination_root: Path,
@@ -104,18 +131,28 @@ def execute_plan(
     links, or unlinks files using pathlib native functions.
 
     If a database is provided, records installations (CREATE, LINK) and removals (UNLINK).
+
+    Respects XDG mode: when enabled, .config/*, .local/share/*, .cache/* are redirected
+    to their respective XDG Base Directory paths.
     """
     # Use NoOpDB if no database provided
     working_db = db if db is not None else NoOpDB()
 
+    # Check XDG mode
+    xdg_mode = is_xdg_mode()
+
     # Extract package info for database tracking
     package_root = source_package_root.parent
     package_name = source_package_root.name
 
+    def get_destination(step: PlanNode) -> Path:
+        """Get the absolute destination path, respecting XDG mode."""
+        return resolve_destination(step.relative_destination_path, destination_root, xdg_mode)
+
     def build_shell_command(step: PlanNode):
         """Print the shell command corresponding to exactly one `PlanNode`"""
         command = None
-        destination = destination_root / step.relative_destination_path
+        destination = get_destination(step)
         source = (source_package_root / step.relative_source_path).resolve()
         try:
             source = source.relative_to(destination.parent)
@@ -147,7 +184,7 @@ def execute_plan(
 
         Records installations and removals in database.
         """
-        destination = destination_root / step.relative_destination_path
+        destination = get_destination(step)
         source = (source_package_root / step.relative_source_path).resolve()
         try:
             source = source.relative_to(destination.parent)

{dotx-3.2.2 → dotx-3.3.0}/src/dotx/uninstall.py

@@ -11,7 +11,8 @@ Exported functions:
 import os
 from pathlib import Path
 
-from dotx.plan import Action, Plan, mark_all_descendents
+from dotx.options import is_xdg_mode
+from dotx.plan import Action, Plan, mark_all_descendents, resolve_destination
 from dotx.install import plan_install_paths
 
 
@@ -19,9 +20,13 @@ def plan_uninstall(source_package_root: Path, destination_root: Path) -> Plan:
     """
     Create a plan to uninstall files from destination_root that link to source_package_root.
 
+    Respects XDG mode: when enabled, .config/*, .local/share/*, .cache/* are resolved to their
+    respective XDG Base Directory paths when checking for symlinks to remove.
+
     Returns: a `Plan` with actions set to UNLINK for symlinks pointing to the source package
     """
     plan: Plan = plan_install_paths(source_package_root)
+    xdg_mode = is_xdg_mode()
 
     for current_root, _, child_files in os.walk(source_package_root):
         current_root_path = Path(current_root)
@@ -36,15 +41,18 @@ def plan_uninstall(source_package_root: Path, destination_root: Path) -> Plan:
             child_relative_source_path = relative_root_path / child
             if child_relative_source_path not in plan:
                 continue
-            destination_path = (
-                destination_root
-                / plan[child_relative_source_path].relative_destination_path
+            destination_path = resolve_destination(
+                plan[child_relative_source_path].relative_destination_path,
+                destination_root,
+                xdg_mode,
             )
             if destination_path.is_symlink():
                 plan[child_relative_source_path].action = Action.UNLINK
 
-        destination_path = (
-            destination_root / plan[relative_root_path].relative_destination_path
+        destination_path = resolve_destination(
+            plan[relative_root_path].relative_destination_path,
+            destination_root,
+            xdg_mode,
         )
         action = None
         if not destination_path.exists():

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dotx
-Version: 3.2.2
+Version: 3.3.0
 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.2 → dotx-3.3.0}/tests/test_cli.py

@@ -299,3 +299,93 @@ def test_cli_uninstall_dry_run_shows_indicator(tmp_path, isolated_db):
     assert "rm" in result.output
     # File should still exist after dry-run
     assert (target / "file1").exists()
+
+
+def test_cli_xdg_and_target_mutually_exclusive(tmp_path, isolated_db):
+    """Test that --xdg and --target cannot be used together."""
+    source = tmp_path / "source"
+    source.mkdir()
+    (source / "file1").write_text("content")
+
+    runner = CliRunner()
+
+    # Try to use both --xdg and --target
+    result = runner.invoke(app, ["--xdg", f"--target={tmp_path}", "install", str(source)])
+
+    assert result.exit_code != 0
+    assert "mutually exclusive" in result.output.lower()
+
+
+def _has_symlink_ancestor(path: Path) -> bool:
+    """Check if any ancestor of path is a symlink."""
+    for parent in path.parents:
+        if parent.is_symlink():
+            return True
+    return path.is_symlink()
+
+
+def test_cli_xdg_mode_install_to_xdg_paths(tmp_path, monkeypatch, isolated_db):
+    """Test that --xdg mode installs .config files to XDG_CONFIG_HOME."""
+    source = tmp_path / "source"
+    source.mkdir()
+
+    # Create .config/app directory with config file
+    config_dir = source / "dot-config" / "myapp"
+    config_dir.mkdir(parents=True)
+    (config_dir / "config.toml").write_text("setting = true")
+
+    # Set custom XDG_CONFIG_HOME
+    custom_config = tmp_path / "custom-config"
+    custom_config.mkdir()
+    monkeypatch.setenv("XDG_CONFIG_HOME", str(custom_config))
+
+    runner = CliRunner()
+
+    # Install with --xdg mode
+    result = runner.invoke(app, ["--xdg", "install", str(source)])
+
+    assert result.exit_code == 0, f"Install failed: {result.output}"
+
+    # File should be accessible at XDG path
+    config_file = custom_config / "myapp" / "config.toml"
+    assert config_file.exists(), "config.toml should be accessible at XDG path"
+
+    # File should be connected to source via symlink (either directly or via ancestor)
+    assert _has_symlink_ancestor(config_file), "File or ancestor should be a symlink"
+
+    # Content should match source
+    assert config_file.read_text() == "setting = true"
+
+
+def test_cli_xdg_mode_install_and_uninstall_roundtrip(tmp_path, monkeypatch, isolated_db):
+    """Test that --xdg mode works for both install and uninstall."""
+    source = tmp_path / "source"
+    source.mkdir()
+
+    # Create .config/app directory with config file
+    config_dir = source / "dot-config" / "myapp"
+    config_dir.mkdir(parents=True)
+    (config_dir / "config.toml").write_text("setting = true")
+
+    # Set custom XDG_CONFIG_HOME
+    custom_config = tmp_path / "custom-config"
+    custom_config.mkdir()
+    monkeypatch.setenv("XDG_CONFIG_HOME", str(custom_config))
+
+    runner = CliRunner()
+
+    # Install with --xdg mode
+    result = runner.invoke(app, ["--xdg", "install", str(source)])
+    assert result.exit_code == 0, f"Install failed: {result.output}"
+
+    # Verify file is installed and accessible
+    config_file = custom_config / "myapp" / "config.toml"
+    assert config_file.exists(), "File should be accessible at XDG path"
+    assert _has_symlink_ancestor(config_file), "File or ancestor should be a symlink"
+
+    # Uninstall with --xdg mode
+    result = runner.invoke(app, ["--xdg", "uninstall", str(source)])
+    assert result.exit_code == 0, f"Uninstall failed: {result.output}"
+
+    # File should be removed (not accessible anymore)
+    assert not config_file.exists(), "File should be removed after uninstall"

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

@@ -679,3 +679,91 @@ def test_install_deep_nesting_execute(tmp_path, isolated_db):
     assert deep_file_dest.is_symlink()
     assert deep_file_dest.exists()
     assert deep_file_dest.read_text() == "deep content"
+
+
+# --- XDG Mode Tests ---
+
+
+def test_resolve_destination_no_xdg():
+    """Test that resolve_destination without XDG mode just joins paths."""
+    from dotx.plan import resolve_destination
+
+    default_root = Path("/home/user")
+    relative_path = Path(".config/app/config.toml")
+
+    result = resolve_destination(relative_path, default_root, xdg_mode=False)
+
+    assert result == Path("/home/user/.config/app/config.toml")
+
+
+def test_resolve_destination_xdg_config(monkeypatch):
+    """Test that resolve_destination with XDG mode redirects .config paths."""
+    from dotx.plan import resolve_destination
+
+    # Set custom XDG_CONFIG_HOME
+    monkeypatch.setenv("XDG_CONFIG_HOME", "/custom/config")
+
+    default_root = Path("/home/user")
+    relative_path = Path(".config/app/config.toml")
+
+    result = resolve_destination(relative_path, default_root, xdg_mode=True)
+
+    assert result == Path("/custom/config/app/config.toml")
+
+
+def test_resolve_destination_xdg_data(monkeypatch):
+    """Test that resolve_destination with XDG mode redirects .local/share paths."""
+    from dotx.plan import resolve_destination
+
+    # Set custom XDG_DATA_HOME
+    monkeypatch.setenv("XDG_DATA_HOME", "/custom/data")
+
+    default_root = Path("/home/user")
+    relative_path = Path(".local/share/app/data.db")
+
+    result = resolve_destination(relative_path, default_root, xdg_mode=True)
+
+    assert result == Path("/custom/data/app/data.db")
+
+
+def test_resolve_destination_xdg_cache(monkeypatch):
+    """Test that resolve_destination with XDG mode redirects .cache paths."""
+    from dotx.plan import resolve_destination
+
+    # Set custom XDG_CACHE_HOME
+    monkeypatch.setenv("XDG_CACHE_HOME", "/custom/cache")
+
+    default_root = Path("/home/user")
+    relative_path = Path(".cache/app/cache.db")
+
+    result = resolve_destination(relative_path, default_root, xdg_mode=True)
+
+    assert result == Path("/custom/cache/app/cache.db")
+
+
+def test_resolve_destination_xdg_non_xdg_path(monkeypatch):
+    """Test that paths not matching XDG prefixes still use default_root in XDG mode."""
+    from dotx.plan import resolve_destination
+
+    monkeypatch.setenv("XDG_CONFIG_HOME", "/custom/config")
+
+    default_root = Path("/home/user")
+    relative_path = Path(".bashrc")
+
+    result = resolve_destination(relative_path, default_root, xdg_mode=True)
+
+    assert result == Path("/home/user/.bashrc")
+
+
+def test_resolve_destination_xdg_exact_match(monkeypatch):
+    """Test that exact XDG prefix paths resolve to XDG directory itself."""
+    from dotx.plan import resolve_destination
+
+    monkeypatch.setenv("XDG_CONFIG_HOME", "/custom/config")
+
+    default_root = Path("/home/user")
+    relative_path = Path(".config")
+
+    result = resolve_destination(relative_path, default_root, xdg_mode=True)
+
+    assert result == Path("/custom/config")