zoxide/templates/xonsh.txt

{%- let section = "# =============================================================================\n#" -%}
{%- let not_configured = "# -- not configured --" -%}

# pylint: disable=missing-module-docstring

import builtins  # pylint: disable=unused-import
import os
import os.path
import subprocess
import sys
from typing import AnyStr, List, Optional

import xonsh.dirstack  # type: ignore # pylint: disable=import-error
import xonsh.environ  # type: ignore # pylint: disable=import-error

{{ section }}
# Utility functions for zoxide.
#


def __zoxide_bin() -> str:
    """Finds and returns the location of the zoxide binary."""
    zoxide = xonsh.environ.locate_binary("zoxide")
    if zoxide is None:
        zoxide = "zoxide"
    return zoxide


def __zoxide_pwd() -> str:
    """pwd based on the value of _ZO_RESOLVE_SYMLINKS."""
{%- if resolve_symlinks %}
    pwd = os.getcwd()
{%- else %}
    pwd = builtins.__xonsh__.env.get("PWD")  # type: ignore  # pylint:disable=no-member
    if pwd is None:
        raise Exception("$PWD not found")
{%- endif %}
    return pwd


def __zoxide_cd(path: Optional[AnyStr] = None):
    """cd + custom logic based on the value of _ZO_ECHO."""
    if path is None:
        args = []
    elif isinstance(path, bytes):
        args = [path.decode("utf-8")]
    elif isinstance(path, str):
        args = [path]
    _, exc, _ = xonsh.dirstack.cd(args)
    if exc is not None:
        raise Exception(exc)
{%- if echo %}
    print(__zoxide_pwd())
{%- endif %}


class ZoxideSilentException(Exception):
    """Exit without complaining."""


def __zoxide_errhandler(func):
    """Print exception and exit with error code 1."""

    def wrapper(args: List[str]):
        try:
            func(args)
            return 0
        except ZoxideSilentException:
            return 1
        except Exception as exc:  # pylint: disable=broad-except
            print(f"zoxide: {exc}", file=sys.stderr)
            return 1

    return wrapper


{{ section }}
# Hook configuration for zoxide.
#

# Initialize hook to add new entries to the database.
if globals().get("__zoxide_hooked") is not True:
    globals()["__zoxide_hooked"] = True
{% match hook -%}
{%- when InitHook::None %}
    {{ not_configured }}
{%- when InitHook::Prompt %}
    @builtins.events.on_post_prompt  # type: ignore  # pylint:disable=no-member
{%- when InitHook::Pwd %}
    @builtins.events.on_chdir  # type: ignore  # pylint:disable=no-member
{%- endmatch %}
    def __zoxide_hook(**_kwargs):
        """Hook to add new entries to the database."""
        pwd = __zoxide_pwd()
        zoxide = __zoxide_bin()
        subprocess.run([zoxide, "add", "--", pwd], check=False)


{{ section }}
# When using zoxide with --no-aliases, alias these internal functions as
# desired.
#


@__zoxide_errhandler
def __zoxide_z(args: List[str]):
    """Jump to a directory using only keywords."""
    if args == []:
        __zoxide_cd()
    elif args == ["-"]:
        __zoxide_cd("-")
    elif len(args) == 1 and os.path.isdir(args[0]):
        __zoxide_cd(args[0])
    else:
        try:
            zoxide = __zoxide_bin()
            __zoxide_cmd = subprocess.run(
                [zoxide, "query", "--exclude", __zoxide_pwd(), "--"] + args,
                check=True,
                stdout=subprocess.PIPE,
            )
        except subprocess.CalledProcessError as exc:
            raise ZoxideSilentException() from exc

        __zoxide_result = __zoxide_cmd.stdout[:-1]
        __zoxide_cd(__zoxide_result)


def __zoxide_zi(args: List[str]):
    """Jump to a directory using interactive search."""
    try:
        zoxide = __zoxide_bin()
        __zoxide_cmd = subprocess.run(
            [zoxide, "query", "-i", "--"] + args, check=True, stdout=subprocess.PIPE
        )
    except subprocess.CalledProcessError as exc:
        raise ZoxideSilentException() from exc

    __zoxide_result = __zoxide_cmd.stdout[:-1]
    __zoxide_cd(__zoxide_result)


{{ section }}
# Convenient aliases for zoxide. Disable these using --no-aliases.
#

{%- match cmd %}
{%- when Some with (cmd) %}

builtins.aliases["{{cmd}}"] = __zoxide_z  # type: ignore  # pylint:disable=no-member
builtins.aliases["{{cmd}}i"] = __zoxide_zi  # type: ignore  # pylint:disable=no-member

{%- when None %}

{{ not_configured }}

{%- endmatch %}

{{ section }}
# To initialize zoxide, add this to your configuration (usually ~/.xonshrc):
#
# execx($(zoxide init xonsh), 'exec', __xonsh__.ctx, filename='zoxide')