zshrc: bash-style reverse incremental search on ^R

[dotfiles.git] / etc / zsh / .zshenv

### functions
## cleanup
# XXX: only call after relevant vars have been set up, defined early so that
#      below code can utilize it after they do so
function _sev_zcleanup {
    local x p y

    # gpg forwarding
    if [[ -d $_sev_gpg_forward_dir && ( -z $1 || $1 == 'gpg-forward' ) ]] {
        # clean up forward dirs if its session is dead or we ask for it
        find $_sev_gpg_forward_dir -mindepth 1 -maxdepth 1 -type d |
          while {read -r x} {
            # NOTE: the only way we can get here is if we have not been
            #       forwarded before, if the user asks for it, or during
            #       logout. if our own pid already has a dir, it is most likely
            #       stale, the user wants it removed, or something is very
            #       broken—in all 3 of these cases the best choice is remove it.
            p=$(basename $x)
            if {[[ -v _sev_gpg_forward_clean || $$ == $p ]] ||
                    ! kill -0 $p 2>/dev/null} {
                find $x -mindepth 1 -maxdepth 1 | while {read -r y} {
                    # XXX: real dirs will stop unlink, consider it a feature
                    unlink $y
                }
                # don't force in case something important is still there
                rmdir $x
            }
        }
        # reset GNUPGHOME if we removed our own dir
        if [[ $GNUPGHOME =~ '/.ssh_forward/\d+/*$' && ! -d $GNUPGHOME ]]
            GNUPGHOME=${GNUPGHOME%$MATCH}
    }

    # custom tmp
    # NOTE: _sev_tmp is not unset so session dirs will not be recreated if
    #       called during runtime; unset _sev_tmp and re-source to fix
    # NOTE: XDG dirs that use our tmp are not unset here, they are in zlogout
    #       after this function is called
    if [[ -d $_sev_tmp && ( -z $1 || $1 == 'tmp' ) ]] {
        # clean up tmp dirs if its session is dead or we ask for it
        find $_sev_tmp -mindepth 1 -maxdepth 1 -name '.session.*' -type d |
          while {read -r x} {
            # NOTE: same rationale as above
            p=${$(basename $x)#.session.}
            if {[[ -v _sev_tmp_clean || $$ == $p ]] ||
                    ! kill -0 $p 2>/dev/null} {
                rm -rf $x
            }
        }
    }
}

function _sev_setpath {
    # add as many generic paths as possible to keep the order we want
    # NOTE: tied arrays path and fpath already exist, but are not unique (-U);
    #       we utilize the fact that unique arrays keep the first occurrence
    #       and remove any further occurrences to check for elements from the
    #       old PATH that we did not anticipate and shift them to the front,
    #       since they are probably important to the system
    typeset -gU path fpath
    local -a syspath=("$path[@]")
    # NOTE: /usr/{pkg,games} are unix/bsdisms
    # NOTE: some systems (esp. research machines) may have multiple versions of
    #       packages installed in /opt/[pkg]/[ver]/bin or other dirs, managed
    #       with something like Environment Modules. this code does not account
    #       for this type of usage and will add all valid paths. any undesired
    #       paths can be removed using .zshenv.local.
    # NOTE: fun non-conformant systems like Android may have fun dirs that
    #       contain binaries intended solely for the base system, and their use
    #       by other users/subsystems may cause problems. for example,
    #       /system/bin/bc on Android may be a different version of or
    #       completely different codebase compared to the Termux-installed bc.
    #       modern Termux does not add these such systems to PATH by default,
    #       but older versions/configurations might.
    # XXX: PREFIX not validated, non-POSIX but Termux uses it, maybe others
    # XXX: XDG specifies ~/.local/bin as the only user-writable dir for
    #      executables, but we specify more; technically this is against spec
    path=({{${_sev_home:-~},~}{/.local,},{$PREFIX,}{,/usr{,/local,/pkg},/opt{,/*{/*,}}}}/{s,}bin(N)
          {$PREFIX,}/usr/{X11R{7,6}/bin,games}
          # emulate Arch Linux flatpak-bindir.sh for use on other systems
          {${XDG_DATA_HOME:-~/.local/share},{$PREFIX,}/var/lib}/flatpak/exports/bin)
    local -i i len=$#path
    path+=("$syspath[@]")
    # remove bad paths... after having combined the arrays to remove duplicates
    for (( i = 1; i <= $#path; i++ )) {
        if [[ ! -d $path[$i] ]] {
            path[$i]=()
            ((i <= len)) && ((len--))
            ((i--))
            continue
        }
    }
    # shift valid system paths to the front if there are any left
    ((len > 0 && len < $#path)) && path=("${(@)path[len + 1, -1]}" "${(@)path[1, len]}")
    # include our zsh dir in fpath. unlike above, we always prefer our paths
    fpath=({${ZDOTDIR:-{${_sev_home:-~},~}/.zsh},{${_sev_home:-~},~}/.zsh}/functions/**/*(/N) "$fpath[@]")
    # remove bad paths
    for (( i = 1; i <= $#fpath; i++ )) {
        if [[ ! -d $fpath[$i] ]] {
            fpath[$i]=()
            ((i--))
            continue
        }
    }
    # FPATH is not exported by default
    export FPATH
    # un-unique system arrays for consistency
    typeset +U path fpath
}

### common exports
export CHARSET=${CHARSET:-UTF-8}
export LANG=${LANG:-en_US.UTF-8}

## alternative home for pulling in bin & config, used for zsu
[[ -v _sev_home ]] || export _sev_home=$HOME

## fix broken term
# NOTE: we do this here instead of .zshrc since we might print stuff
if [[ -t 1 ]] { # only if stdout is tty
    [[ ! -v TERM ]] && export TERM=xterm-256color >/dev/null 2>&1
    if [[ $#terminfo -eq 0 ]] {
        _oldterm=$TERM
        export TERM=xterm >/dev/null 2>&1
        [[ -o interactive ]] &&
          print -P "%F{red}!!! Can't find terminfo for $_oldterm, using $TERM%f"
        unset _oldterm
    }
}

## path
if [[ ! -v _sev_setup_path || -o login ]] {
    _sev_setpath
    # NOTE: do not set _sev_setup_path, it is set in zprofile
}

### home dir setup & additional exports
# XXX: traditionally, zshenv should just contain exports, and not touch the
#      filesystem. however, our TMPDIR and XDG vars rely on mutable user paths
#      that may not exist, and as such need to be set up before the rest of the
#      system can use them. this is important as some environments include code
#      in the global zprofile, or source scripts of other shells in the global
#      zprofile, that may rely on our desired dir structure and vars pointing
#      to it. for example, `flatpak-bindir.sh` in the Arch Linux flatpak
#      package references $XDG_DATA_HOME with no fallback. since we do special
#      handling for these vars before we export them, we're forced to do it all
#      here instead of at the top of the zprofile.

## xdg local dir
# NOTE: need this for tmp, so confirm it exists.
# XXX: perms are not specified for XDG dirs except runtime. 760 makes the most
#      sense, but we need to be a bit more permissive for zsu.
[[ -e ~/.local ]] && chmod 755 ~/.local || mkdir -pm766 ~/.local

## tmp
# NOTE: specs say that POSIX tmp and XDG runtime directories should exist
#       until the last session is logged out (POSIX can exist for longer).
#       since we can't reliably keep track of sessions in a cross-platform
#       manner, the current implementation should use a separate directory per
#       toplevel session (i.e. SHLVL=1). this should placate most applications,
#       though it is not expressly spec compliant. this may also cause problems
#       with disowned applications that still try to use the directories after
#       the toplevel shell has already logged out and the dirs removed, but the
#       chances of that are slim. this also needs to be adjusted for usermode
#       Xorg, as it requires $PREFIX/tmp/.X11-unix on most installs.
if [[ ! -v _sev_tmp ]] {
    _sev_tmp=~/.local/tmp
    # create personal TMPDIR under system tmp
    # NOTE: under proot with uid remapping and shared /tmp, we can reuse old
    #       dir, without worrying about permission issues; intended for termux.
    _t=${TMPDIR:-${TEMPDIR:-${TEMP:-${TMP:-${${TMPPREFIX%/zsh}:-/tmp}}}}}/.home-${_sev_proot_real_user:-$LOGNAME}
    [[ -e $_t ]] || mkdir -m700 $_t 2>/dev/null
    if [[ ! -d $_t ]] {
        # fallback TMPDIR to bare local directory or existing softlink
        [[ -o interactive ]] &&
          print -P "%F{orange}*** Can't create tmp dir $_t, using $_sev_tmp%f"
        [[ -h $_sev_tmp && ! -d _sev_tmp ]] && unlink $_sev_tmp 2>/dev/null
        [[ ! -e $_sev_tmp ]] && mkdir -m700 $_sev_tmp 2>/dev/null
        if [[ ! -d $_sev_tmp ]] {
            _sev_tmp=${$(mktemp 2>/dev/null):-/tmp}
            [[ -o interactive ]] &&
              print -P "%F{red}!!! Can't create tmp dir, using $_sev_tmp%f"
        }
    } elif [[ -e $_sev_tmp && ! -h $_sev_tmp ]] {
        # non-softlink node is on our local dir
        [[ -o interactive ]] &&
          print -P "%F{orange}*** $_sev_tmp exists, can't link to tmp dir $_t, ignoring it%f"
        _sev_tmp=$_t
    } else {
        if [[ ! -v $_sev_tmp_keep_link && -h $_sev_tmp && $_sev_tmp:P != $_t:P ]] {
            [[ -o interactive ]] &&
              print -P "%F{orange}*** $_sev_tmp links to ${_sev_tmp:P} and not ${t:P}, unlinking it%f"
            # NOTE: ln -f doesn't seem to work reliably with softlink
            #       directories, so explicitly remove the target if it exists
            # XXX: potential race condition
            # TODO: handle cleanup of old dir if it doesn't match?
            unlink $_sev_tmp 2>/dev/null
        }
        if [[ ! -e $_sev_tmp ]] {
            # link local dir to tmp dir
            ln -s $_t $_sev_tmp 2>/dev/null
        }
    }
    # ensure dir is clean
    _sev_zcleanup tmp
    # finally create our subdir for this session
    _t=$_sev_tmp/.session.$$
    if ! mkdir -m700 $_t 2>/dev/null; then
        [[ -o interactive ]] &&
          print -P "%F{red}!!! Can't create session tmp subdir $_t, using $_sev_tmp%f"
        _t=$_sev_tmp
    fi
    export _sev_tmp TMPDIR=$_t TEMPDIR=$_t TEMP=$_t TMP=$_t TMPPREFIX=$_t/zsh
    unset _t
}

## xdg
if [[ ! -v _sev_setup_xdg ]] {
    ## merge with any existing dirs and remove duplicates using unique arrays
    # NOTE: we are accepting whatever value might be set for CONFIG and DATA;
    #       if it wasn't set, we just use default and leave it unset
    # NOTE: include and then remove CONFIG_HOME and DATA_HOME to ensure they
    #       are not present in the array if it was added before we got to it

    # source user dirs before other vars; technically it is against spec to
    # include any of the below dirs there, but you never know what crazy shit
    # people will do. I rather handle them sanely with our own code than let
    # them override after the fact.
    [[ -f $XDG_CONFIG_HOME/user-dirs.dirs ]] &&
      emulate sh -c "source $XDG_CONFIG_HOME/user-dirs.dirs"

    typeset -UT XDG_DATA_DIRS xdg_data_dirs
    [[ -v XDG_DATA_HOME ]] && export XDG_DATA_HOME
    [[ -e ${XDG_DATA_HOME:-~/.local/share} ]] ||
      mkdir -m760 ${XDG_DATA_HOME:-~/.local/share}
    xdg_data_dirs=($XDG_DATA_HOME ${XDG_DATA_DIRS:+${xdg_data_dirs%%/}}
      /{usr{,/local,/pkg},opt{,/*{/*,}}}/share(N))
    xdg_data_dirs=($xdg_data_dirs(/N))
    export XDG_DATA_DIRS

    typeset -UT XDG_CONFIG_DIRS xdg_config_dirs
    [[ -v XDG_CONFIG_HOME ]] && export XDG_CONFIG_HOME
    [[ -e ${XDG_CONFIG_HOME:-~/.config} ]] ||
      mkdir -m760 ${XDG_CONFIG_HOME:-~/.config}
    # I am of the belief .local should follow FHS /usr/local...
    [[ -e ~/.local/etc ]] || ln -s ${XDG_CONFIG_HOME:-~/.config} ~/.local/etc
    xdg_config_dirs=($XDG_CONFIG_HOME ${XDG_CONFIG_DIRS:+${xdg_config_dirs%%/}}
      {,/usr{,/local,/pkg},opt{,/*{/*,}}}/etc/xdg(N))
    xdg_config_dirs=($xdg_config_dirs(/N))
    export XDG_CONFIG_DIRS

    [[ -v XDG_STATE_HOME ]] && export XDG_STATE_HOME
    [[ -e ${XDG_STATE_HOME:-~/.local/state} ]] ||
      mkdir -m760 ${XDG_STATE_HOME:-~/.local/state}

    if [[ -v XDG_CACHE_HOME ]] {
        export XDG_CACHE_HOME
    } else {
        export XDG_CACHE_HOME=$_sev_tmp/.xdg.cache
    }
    [[ -e ${XDG_CACHE_HOME:-~/.cache} ]] ||
      mkdir -m700 ${XDG_CACHE_HOME:-~/.cache}

    # NOTE: this can be set by systemd or other pre-shell supervisor, and if
    #       any services were started such as pipewire, we need to use the
    #       existing runtime dir to preserve runtime state
    if [[ -v XDG_RUNTIME_DIR ]] {
        export XDG_RUNTIME_DIR
    } else {
        # make runtime dir in our session-specific tmpdir
        export XDG_RUNTIME_DIR=$TMPDIR/.xdg.runtime
        # same as in tmpdir creation, ensure dir doesn't exist
        if [[ -h $XDG_RUNTIME_DIR ]] {
            unlink $XDG_RUNTIME_DIR 2>/dev/null
        } elif [[ -e $XDG_RUNTIME_DIR ]] {
            rm -rf $XDG_RUNTIME_DIR 2>/dev/null
        }
    }
    [[ ! -e $XDG_RUNTIME_DIR ]] &&
      mkdir -m700 $XDG_RUNTIME_DIR 2>/dev/null

    export _sev_setup_xdg=
}

### app setup & exports
# NOTE: we set these up here since some scripts might need them
## gpg home
if [[ ! -v GNUPGHOME ]] {
    export GNUPGHOME=${XDG_CONFIG_HOME:-~/.config}/gnupg
    # move existing gnupg dir to our new home
    if [[ -d ~/.gnupg && ! -d $GNUPGHOME ]] {
        mv ~/.gnupg $GNUPGHOME
    }
}

## perl local lib
if [[ ! -v PERL_LOCAL_LIB_ROOT && -v commands[perl] ]] {
    _p5=${XDG_DATA_HOME:-~/.local/share}/perl5
    [[ -d $_p5 ]] || mkdir -p $_p5
    if [[ -f $_p5/lib/perl5/local/lib.pm ]] {
        eval $(perl -I$_p5/lib/perl5 -Mlocal::lib=$_p5 2>/dev/null)
    } else {
        # emulate local::lib if not installed
        path=($_p5/bin "${path[@]}")
        export \
          PERL_MB_OPT="--install_base '$_p5'" \
          PERL_MM_OPT=INSTALL_BASE=$_p5 \
          PERL5LIB=$_p5/lib/perl5 \
          PERL_LOCAL_LIB_ROOT=$_p5${$PERL_LOCAL_LIB_ROOT:+:$PERL_LOCAL_LIB_ROOT}
    }
    unset _p5
}
## go
if [[ -v commands[go] ]] {
    [[ ! -v GOPATH ]] && export GOPATH=${XDG_DATA_HOME:-~/.local/share}/go:~/go
    [[ ! -v GOBIN  ]] && export GOBIN=~/.local/bin
}

### load zshenv site-specific
autoload -Uz load-site-dotfile
load-site-dotfile zshenv

### source .zprofile early for non-login shells that should be
if [[ ! -v _sev_first_display && ( -v DISPLAY || -v WAYLAND_DISPLAY ) ]] {
    # most graphical login/session managers will spawn the user's shell as a
    # parent of all child processes for that session. however, if the parent
    # shell isn't a login shell for some reason, our .zprofile won't be run,
    # and the environment won't be configured for child processes.
    #
    # XXX: .zprofile will be sourced by every new child shell if zsh is not
    #      used to start the graphical session and the _sev_first_display var
    #      isn't exported; for example, this previously happened when using
    #      sway without a display manager in front of it to run a login shell.
    #
    #      this issue is not mitigated by .zprofile only loading what has not
    #      already been loaded if the env vars preventing the load are not set;
    #      in that case, every shell will think it is a fresh login shell.

    # update gpgagent to use graphical pinentry
    # XXX: will steal display from any other logged in graphical sessions, but
    #      I consider this to be an unlikely scenario
    _sev_refresh_gpgagent=

    export _sev_first_display=
    [[ ! -o login ]] && source ${ZDOTDIR:-~}/.zprofile
} elif [[ ${+TERMUX_VERSION} -eq 0 && ! -o login && $SHLVL -eq 1 ]] {
    # Termux first process isn't login shell, so source early
    source ${ZDOTDIR:-~}/.zprofile
}