dot_zshrc.tmpl

# xdg
[[ -z "$XDG_CONFIG_HOME" ]] && export XDG_CONFIG_HOME="$HOME/.config"
[[ -z "$XDG_CACHE_HOME" ]] && export XDG_CACHE_HOME="$HOME/.cache"
[[ -z "$XDG_DATA_HOME" ]] && export XDG_DATA_HOME="$HOME/.local/share"
[[ -z "$XDG_STATE_HOME" ]] && export XDG_STATE_HOME="$HOME/.local/state"

# zinit
if [[ ! -f $XDG_DATA_HOME/zinit/zinit.git/zinit.zsh ]]; then
  print -P "%F{33} %F{220}Installing %F{33}ZDHARMA-CONTINUUM%F{220} Initiative Plugin Manager (%F{33}zdharma-continuum/zinit%F{220})…%f"
  command mkdir -p "$XDG_DATA_HOME/zinit" && command chmod g-rwX "$XDG_DATA_HOME/zinit"
  command git clone https://github.com/zdharma-continuum/zinit "$XDG_DATA_HOME/zinit/zinit.git" && \
    print -P "%F{33} %F{34}Installation successful.%f%b" || \
    print -P "%F{160} The clone has failed.%f%b"
fi

source "$XDG_DATA_HOME/zinit/zinit.git/zinit.zsh"
autoload -Uz _zinit
(( ${+_comps} )) && _comps[zinit]=_zinit

zinit ice pick"async.zsh" src"pure.zsh"
zinit light sindresorhus/pure

zinit light-mode for \
  PZTM::environment \
  PZTM::spectrum \
  PZTM::editor \

zinit wait lucid blockf light-mode for \
  zsh-users/zsh-completions \
  zsh-users/zsh-autosuggestions \
  zdharma-continuum/fast-syntax-highlighting \
  zdharma-continuum/history-search-multi-word \
  CyberShadow/per-directory-history \
  azu/ni.zsh

### zsh ###
setopt INTERACTIVE_COMMENTS

# history
setopt HIST_IGNORE_ALL_DUPS
setopt HIST_ALLOW_CLOBBER
setopt HIST_IGNORE_SPACE
setopt HIST_NO_FUNCTIONS
setopt HIST_NO_STORE
setopt HIST_REDUCE_BLANKS
setopt HIST_VERIFY
setopt INC_APPEND_HISTORY
setopt SHARE_HISTORY
## per-directory-history
PER_DIRECTORY_HISTORY_TOGGLE='^G'

# directory
setopt AUTO_CD
setopt AUTO_PUSHD
setopt PUSHD_IGNORE_DUPS
setopt PUSHD_SILENT
setopt PUSHD_TO_HOME
setopt CDABLE_VARS
setopt MULTIOS
setopt EXTENDED_GLOB
unsetopt CLOBBER

# correct
setopt CORRECT
alias cd='nocorrect cd'
alias cp='nocorrect cp'
alias grep='nocorrect grep'
alias ln='nocorrect ln'
alias man='nocorrect man'
alias mkdir='nocorrect mkdir -p'
alias mv='nocorrect mv'
alias rm='nocorrect rm'
alias sudo='nocorrect sudo'

# ls
alias ls='ls -G'
alias l='ls -A'
alias ll='ls -lh'
alias la='ll -A'
alias sl='ls'

# network
alias ipen0='ipconfig getifaddr en0'

# homebrew
if [[ $(arch) == "i386" ]]; then
  # x86_64
  [ -s "/usr/local/bin/brew" ] && eval "$(/usr/local/bin/brew shellenv)"
else
  # arm64
  [ -s "/opt/homebrew/bin/brew" ] && eval "$(/opt/homebrew/bin/brew shellenv)"
fi

if type brew &>/dev/null; then
  if [[ $(arch) == "arm64" ]]; then
    # asdf
    type asdf &>/dev/null && . $(brew --prefix asdf)/libexec/asdf.sh

    # mise
    type mise &>/dev/null && eval "$(mise activate zsh)"

    # gcloud
    if type gloud &>/dev/null;  then
      source "$(brew --prefix)/share/google-cloud-sdk/path.zsh.inc"
      source "$(brew --prefix)/share/google-cloud-sdk/completion.zsh.inc"
    fi

    # mysql-client
    [[ -d "$(brew --prefix)/opt/mysql-client@8.4" ]] && export PATH="$(brew --prefix)/opt/mysql-client@8.4/bin:$PATH"
  fi

  FPATH="$(brew --prefix)/share/zsh/site-functions:${FPATH}"
fi

# git
alias gr='cd $(git rev-parse --show-superproject-working-tree --show-toplevel | head -1)'

# gh
if type gh &>/dev/null; then
  function gh-pr-worktree() {
    git rev-parse 2>/dev/null || {
      echo "Not a git repository"
      return 1
    }
    type peco &>/dev/null || {
      echo "peco is not installed"
      return 1
    }

    local num branch
    IFS=$'\t' read -r num branch <<< "$(gh pr list | peco | cut -f1,3)"
    local dir=$(git rev-parse --show-toplevel)
    [ ! -z $num ] && git worktree add -B "$branch" "$dir.pr/$num" "origin/$branch"
  }

  function gh-defaultbranch() {
    git rev-parse 2>/dev/null || {
      echo "Not a git repository"
      return 1
    }
    defaultbranch=$(gh repo view --json defaultBranchRef --jq '.defaultBranchRef.name')
    [ -z $defaultbranch ] && return 0
    git config --local init.defaultBranch $defaultbranch
    echo $defaultbranch
  }
fi

# ghq
if type ghq &>/dev/null && type peco &>/dev/null; then
  function g() {
    local dir="$(ghq list | peco)"
    [ ! -z $dir ] && cd "$(ghq root)/$dir"
  }
fi

# code
if type code &>/dev/null; then
  function c() {
    local localwsfile="local.code-workspace"
    if [ -f "$localwsfile" ]; then
      code -n "$localwsfile"
      return 0
    fi
    local wsfile=$(find . -maxdepth 1 -type f -name "*.code-workspace" | head -n 1)
    if [ ! -z "$wsfile" ]; then
      code -n "$wsfile"
    else
      code -n .
    fi
  }
fi

# direnv
type direnv &>/dev/null && eval "$(direnv hook zsh)"

# tre
alias tree='tre'

{{ if eq .chezmoi.os "darwin" -}}
# pbcopy
alias clip='pbcopy'

# tailscale
alias tailscale='/Applications/Tailscale.app/Contents/MacOS/Tailscale'
[[ -f "${fpath[1]}/_tailscale" ]] || tailscale completion zsh > "${fpath[1]}/_tailscale"

# xcode
alias xcode='xed'
alias xcodeclean='rm -rf ~/Library/Developer/Xcode/DerivedData'
{{- end }}

# fvm
[[ -f "$XDG_CONFIG_HOME/.dart-cli-completion/zsh-config.zsh" ]] && . "$XDG_CONFIG_HOME/.dart-cli-completion/zsh-config.zsh" || true
function check-fvm() {
  if [[ -d ".fvm" ]]; then
    echo "fvm is available"
    alias flutter='fvm flutter'
    alias dart='fvm dart'
  fi
}
check-fvm

# chezmoi
alias cz='chezmoi'
alias czc='code -n $(cz source-path)'

# rust
[[ -d "$HOME/.cargo" ]] && source "$HOME/.cargo/env"
if type rustup &>/dev/null && [[ ! -f $HOME/.zfunc/_rustup ]]; then
  command mkdir "$HOME/.zfunc"
  rustup completions zsh > "$HOME/.zfunc/_rustup"
  rustup completions zsh cargo > "$HOME/.zfunc/_cargo"
fi

# rye
if type rye &>/dev/null && [[ -d "$HOME/.rye" ]]; then
  source "$HOME/.rye/shims"
fi

# tabtab source for packages
# uninstall by removing these lines
[[ -f $XDG_CONFIG_HOME/tabtab/zsh/__tabtab.zsh ]] && . $XDG_CONFIG_HOME/tabtab/zsh/__tabtab.zsh || true

# chpwd hook
autoload -Uz add-zsh-hook
add-zsh-hook chpwd check-fvm

# autocompletion
fpath+=$HOME/.zfunc
autoload -Uz compinit && compinit
autoload -U +X bashcompinit && bashcompinit

# ni
compdef _ni ni

# 1password cli
if type op &>/dev/null; then
  [[ -f "$XDG_CONFIG_HOME/op/plugins.sh" ]] && source "$XDG_CONFIG_HOME/op/plugins.sh"
  eval "$(op completion zsh)"
  compdef _op op
fi

# buf
type buf &>/dev/null && eval "$(buf completion zsh)"

# terraform
type terraform &>/dev/null && complete -o nospace -C terraform terraform

# terragrunt
type terragrunt &>/dev/null && complete -o nospace -C terragrunt terragrunt

# jujutsu
type jj &>/dev/null && source <(jj util completion zsh)

# sdkman
export SDKMAN_DIR="$HOME/.sdkman"
[[ -s "$HOME/.sdkman/bin/sdkman-init.sh" ]] && source "$HOME/.sdkman/bin/sdkman-init.sh"