Mac 的设置和软件 2018岁末版（2020.3更新）

# =============================================================================
# ZSH CONFIGURATION
# Description: Optimized Zsh configuration for development environment
# File: ~/.zshrc
# =============================================================================

# Skip loading if not interactive shell
[[ $- != *i* ]] && return

# Disable slow security checks for faster startup
export ZSH_DISABLE_COMPFIX=true

# Homebrew environment (dynamic detection)
if [[ -x "/opt/homebrew/bin/brew" ]]; then
    # Apple Silicon Mac
    eval "$(/opt/homebrew/bin/brew shellenv)"
elif [[ -x "/usr/local/bin/brew" ]]; then
    # Intel Mac
    eval "$(/usr/local/bin/brew shellenv)"
fi

### ----------
### Zsh plugin
### ----------

# zsh-autosuggestions (load with fallback)
if [[ -f "/opt/homebrew/share/zsh-autosuggestions/zsh-autosuggestions.zsh" ]]; then
    source /opt/homebrew/share/zsh-autosuggestions/zsh-autosuggestions.zsh
elif [[ -f "/usr/local/share/zsh-autosuggestions/zsh-autosuggestions.zsh" ]]; then
    source /usr/local/share/zsh-autosuggestions/zsh-autosuggestions.zsh
fi

# zsh-syntax-highlighting (load with fallback)
if [[ -f "/opt/homebrew/share/zsh-syntax-highlighting/zsh-syntax-highlighting.zsh" ]]; then
    source /opt/homebrew/share/zsh-syntax-highlighting/zsh-syntax-highlighting.zsh
elif [[ -f "/usr/local/share/zsh-syntax-highlighting/zsh-syntax-highlighting.zsh" ]]; then
    source /usr/local/share/zsh-syntax-highlighting/zsh-syntax-highlighting.zsh
fi

# zsh-history-substring-search (load with fallback)
if [[ -f "/opt/homebrew/share/zsh-history-substring-search/zsh-history-substring-search.zsh" ]]; then
    source /opt/homebrew/share/zsh-history-substring-search/zsh-history-substring-search.zsh
elif [[ -f "/usr/local/share/zsh-history-substring-search/zsh-history-substring-search.zsh" ]]; then
    source /usr/local/share/zsh-history-substring-search/zsh-history-substring-search.zsh
fi

### -------
### Options
### -------

set ZSH_ALIAS_FINDER_AUTOMATIC=true

# History & Completion
HISTDUP=erase
export HISTORY_IGNORE="(ls|pwd|cd|exit|clear|history)*"
HISTSIZE=10000
SAVEHIST=10000
export HSTR_CONFIG=hicolor  # get more colors

# History Options
setopt ALWAYS_TO_END        # move cursor to end if word had one match
setopt APPEND_HISTORY       # allow multiple terminal sessions to all append to one zsh command history
setopt AUTO_CD              # cd by typing directory name if it's not a command
setopt AUTO_LIST            # automatically list choices on ambiguous completion
setopt AUTO_MENU            # automatically use menu completion
setopt COMPLETE_IN_WORD     # needed for prefix completer
setopt CORRECT_ALL          # autocorrect commands
setopt EXTENDED_HISTORY     # include more information about when the command was executed, etc
setopt HIST_IGNORE_ALL_DUPS # delete an old recorded event if a new event is a duplicate.
setopt HIST_IGNORE_DUPS     # do not record an event that was just recorded again.
setopt HIST_NO_STORE        # don't store history commands
setopt HIST_REDUCE_BLANKS   # remove extra blanks from each command line being added to history
setopt HIST_SAVE_NO_DUPS    # do not write a duplicate event to the history file.
setopt histignorespace      # skip cmds w/ leading space from history
setopt INC_APPEND_HISTORY   # add comamnds as they are typed, don't wait until shell exit
setopt SHARE_HISTORY        # share history between all sessions.

# Correction and completion
setopt CORRECT                  # Autocorrect commands (not CORRECT_ALL to avoid aggressive correction)
setopt NO_CASE_GLOB             # Case insensitive globbing
setopt NUMERIC_GLOB_SORT        # Sort numeric filenames numerically

# Job control
setopt AUTO_RESUME              # Resume jobs with their name
setopt LONG_LIST_JOBS           # List jobs in long format
setopt NOTIFY                   # Report status of background jobs immediately


### -----------------
### COMPLETION SYSTEM
### -----------------

# Initialize completion system
autoload -Uz compinit
# Check if compinit needs to be regenerated (once per day)
if [[ -n ${ZDOTDIR:-$HOME}/.zcompdump(#qN.mh+24) ]]; then
    compinit
else
    compinit -C  # Skip security check for faster startup
fi

# Completion styles
zstyle ':completion:*' menu select                                    # Select completions with arrow keys
zstyle ':completion:*' group-name ''                                  # Group results by category
zstyle ':completion:*' list-colors ${(s.:.)LS_COLORS}                # Use LS_COLORS for completion
zstyle ':completion:*:descriptions' format '%F{yellow}-- %d --%f'     # Format group descriptions
zstyle ':completion:*:warnings' format '%F{red}-- No matches found --%f'
zstyle ':completion:*' completer _expand _complete _ignored _approximate
zstyle ':completion:*' matcher-list 'm:{a-zA-Z}={A-Za-z}'            # Case insensitive matching
zstyle ':completion:*' rehash true                                    # Automatically find new executables in path


### -------
### bindkey
### -------

# History search
bindkey '^R' history-incremental-search-backward
bindkey '^[[A' history-substring-search-up      # Up arrow
bindkey '^[[B' history-substring-search-down    # Down arrow

# HSTR integration
if command -v hstr >/dev/null 2>&1; then
    bindkey -s "\C-r" "\C-a hstr -- \C-j"       # Bind hstr to Ctrl-r
fi

# Line editing
bindkey '^A' beginning-of-line                   # Ctrl+A
bindkey '^E' end-of-line                         # Ctrl+E
bindkey '^K' kill-line                           # Ctrl+K
bindkey '^U' backward-kill-line                  # Ctrl+U
bindkey '^W' backward-kill-word                  # Ctrl+W

# Enable Vi mode (uncomment if preferred)
# bindkey -v

# User configuration

### ---------------------
### ENVIRONMENT VARIABLES
### ---------------------

# export MANPATH="/usr/local/man:$MANPATH"

# You may need to manually set your language environment
export LANG=en_US.UTF-8
export LC_ALL=en_US.UTF-8

# Editor configuration
if [[ -n $SSH_CONNECTION ]]; then
    export EDITOR='vim'
    export VISUAL='vim'
else
    export EDITOR='code --wait'
    export VISUAL='code --wait'
fi

# Pager
export PAGER='less'
export LESS='-R -F -X -M'

# Development environment
export DEVELOPMENT_MODE=true

# Compilation flags
# export ARCHFLAGS="-arch x86_64"
# export LDFLAGS="-L/usr/local/opt/luajit-openresty/lib"
# export CPPFLAGS="-I/usr/local/opt/luajit-openresty/include"

### -----
### Path
### -----

# Function to safely add to PATH
add_to_path() {
    local dir="$1"
    if [[ -d "$dir" && ":$PATH:" != *":$dir:"* ]]; then
        export PATH="$dir:$PATH"
    fi
}

# Add development tools to PATH
add_to_path "/usr/local/opt/icu4c/bin"
add_to_path "/usr/local/opt/icu4c/sbin"
add_to_path "/usr/local/opt/ruby/bin"
add_to_path "$HOME/.local/bin"
add_to_path "$HOME/bin"

### -----
### Conda
### -----

# Lazy loading conda for faster shell startup
lazy_load_conda() {
    __conda_setup="$('/Users/zhonglun/anaconda3/bin/conda' 'shell.zsh' 'hook' 2> /dev/null)"
    if [ $? -eq 0 ]; then
        eval "$__conda_setup"
        echo "🐍 Conda environment loaded"
        return 0
    fi
    echo "❌ Conda not found in common locations"
    return 1
}

conda_status() {
    if command -v conda >/dev/null 2>&1; then
        echo "🐍 Conda: Loaded and ready"
        return 0
    else
        echo "❌ Conda: Not available"
        echo "💡 Use 'conda0' to initialize"
        return 1
    fi
}

# Enhanced conda aliases
alias conda0=lazy_load_conda
alias condaenvs="conda env list"
alias condainfo="conda_status && conda info"
alias condaclr="conda clean --all"
alias condals="conda list"
alias condasearch="conda search"
alias condaupd="conda update conda && conda update anaconda && conda update --all && conda clean --all"


### -----
### Tools
### -----

# Autojump (with fallback paths)
if [[ -f "/opt/homebrew/etc/profile.d/autojump.sh" ]]; then
    source /opt/homebrew/etc/profile.d/autojump.sh
elif [[ -f "/usr/local/etc/profile.d/autojump.sh" ]]; then
    source /usr/local/etc/profile.d/autojump.sh
fi

# iTerm2 integration
if [[ -f "${HOME}/.iterm2_shell_integration.zsh" ]]; then
    source "${HOME}/.iterm2_shell_integration.zsh"
fi

# Starship prompt (with fallback)
if command -v starship >/dev/null 2>&1; then
    eval "$(starship init zsh)"
else
    # Simple fallback prompt
    PS1='%F{cyan}%n@%m%f:%F{yellow}%~%f$ '
fi


### -----
### Alias
### -----

# Source homebrew aliases: b
[ -f ~/.aliases/homebrew.sh ] && source ~/.aliases/homebrew.sh

# Source common tools aliases: Cat, Echo, List, Find, Ssh, q/x, Zsh, History, etc.
[ -f ~/.aliases/common.sh ] && source ~/.aliases/common.sh

# Source tools aliases
[ -f ~/.aliases/tools.sh ] && source ~/.aliases/tools.sh

# Source git aliases: g
[ -f ~/.aliases/git.sh ] && source ~/.aliases/git.sh

# Source java and jvm aliases: jv
[ -f ~/.aliases/java.sh ] && source ~/.aliases/java.sh

# Source javascript aliases: n - npm
[ -f ~/.aliases/js.sh ] && source ~/.aliases/js.sh

# Source python aliases: py
[ -f ~/.aliases/python.sh ] && source ~/.aliases/python.sh

# Source go aliases: go
[ -f ~/.aliases/go.sh ] && source ~/.aliases/go.sh

# Source rust aliases: rust
[ -f ~/.aliases/rust.sh ] && source ~/.aliases/rust.sh

# Source ruby aliases: rb
[ -f ~/.aliases/ruby.sh ] && source ~/.aliases/ruby.sh

# Source lua aliases: lua
[ -f ~/.aliases/lua.sh ] && source ~/.aliases/lua.sh

# Source projects aliases
[ -f ~/.aliases/projects.sh ] && source ~/.aliases/projects.sh



# Function to display development environment info for different languages
f_devinfo() {
    local language="$1"
    YELLOW='\033[1;33m'
    NC='\033[0m' # No Color

    if [[ -z "$language" ]]; then
        echo "🔧 DEVELOPMENT ENVIRONMENTS"
        echo "============================"
        echo
        echo "Available info commands:"
        echo -e "  ${YELLOW}devinfo${NC}     → Show all environments"
        echo -e "  ${YELLOW}devgo    ${NC}   → Go environment info"
        echo -e "  ${YELLOW}devjava  ${NC}   → Java, Maven, Gradle info"
        echo -e "  ${YELLOW}devjs    ${NC}   → Node.js and npm info"
        echo -e "  ${YELLOW}devkotlin${NC}   → Kotlin environment info"
        echo -e "  ${YELLOW}devlua   ${NC}   → Lua environment info"
        echo -e "  ${YELLOW}devpython${NC}   → Python environment info"
        echo -e "  ${YELLOW}devruby  ${NC}   → Ruby and gems info"
        echo -e "  ${YELLOW}devrust  ${NC}   → Rust and Cargo info"
        echo -e "  ${YELLOW}devscala ${NC}   → Scala and SBT info"
        echo
        return
    fi

    case "$language" in
        "java")
            if command -v javainfo >/dev/null 2>&1; then
                javainfo
            else
                echo "❌ javainfo function not available"
            fi
            ;;
        "kotlin")
            if command -v kotlininfo >/dev/null 2>&1; then
                kotlininfo
            else
                echo "❌ kotlininfo function not available"
            fi
            ;;
        "scala")
            if command -v scalainfo >/dev/null 2>&1; then
                scalainfo
            else
                echo "❌ scalainfo function not available"
            fi
            ;;
        "python"|"py")
            if command -v pyinfo >/dev/null 2>&1; then
                pyinfo
            else
                echo "❌ pyinfo function not available"
            fi
            ;;
        "rust")
            if command -v rustinfo >/dev/null 2>&1; then
                rustinfo
            else
                echo "❌ rustinfo function not available"
            fi
            ;;
        "go")
            if command -v goinfo >/dev/null 2>&1; then
                goinfo
            else
                echo "❌ goinfo function not available"
            fi
            ;;
        "js"|"javascript"|"node")
            if command -v jsinfo >/dev/null 2>&1; then
                jsinfo
            elif command -v nodeinfo >/dev/null 2>&1; then
                nodeinfo
            else
                echo "❌ jsinfo/nodeinfo function not available"
            fi
            ;;
        "ruby"|"rb")
            if command -v rubyinfo >/dev/null 2>&1; then
                rubyinfo
            else
                echo "❌ rubyinfo function not available"
            fi
            ;;
        "lua")
            if command -v luainfo >/dev/null 2>&1; then
                luainfo
            else
                echo "❌ luainfo function not available"
            fi
            ;;
        "all")
            echo "🌍 ALL DEVELOPMENT ENVIRONMENTS"
            echo "==============================="
            echo

            for lang in java kotlin scala python rust go js ruby lua; do
                f_devinfo "$lang"
                echo
            done
            ;;
        *)
            echo "❌ Unknown language: $language"
            echo
            echo "Available: java, kotlin, scala, python, rust, go, js, ruby, lua, all"  | lolcat
            ;;
    esac
}

# Function to display available aks* and dev* shortcuts
f_aliases_help() {
    local category="$1"
    YELLOW='\033[1;33m'
    NC='\033[0m' # No Color

    case "$category" in
        "aks")
            echo "📋 ALIAS SHORTCUTS (aks*)"
            echo "========================="
            echo
            echo "General:"
            echo -e "  ${YELLOW}aksls  ${NC}    → Show all aliases"
            echo -e "  ${YELLOW}aksfind${NC}    → Search for aliases"
            echo
            echo "Language-specific aliases:"
            echo -e "  ${YELLOW}aksbrew  ${NC}  → Homebrew aliases"
            echo -e "  ${YELLOW}akscommon${NC}  → Common tools aliases"
            echo -e "  ${YELLOW}aksdevops${NC}  → Devops tools aliases"
            echo -e "  ${YELLOW}aksgit   ${NC}  → Git aliases"
            echo -e "  ${YELLOW}aksjava  ${NC}  → Java/Maven/Gradle aliases"
            echo -e "  ${YELLOW}aksjs    ${NC}  → JavaScript/Node aliases"
            echo -e "  ${YELLOW}akspy    ${NC}  → Python aliases"
            echo -e "  ${YELLOW}aksrust  ${NC}  → Rust/Cargo aliases"
            echo -e "  ${YELLOW}aksgo    ${NC}  → Go aliases"
            echo -e "  ${YELLOW}aksruby  ${NC}  → Ruby/Gem aliases"
            echo -e "  ${YELLOW}akslua   ${NC}  → Lua aliases"
            echo -e "  ${YELLOW}akstools ${NC}  → Development tools aliases"
            echo -e "  ${YELLOW}aksproj  ${NC}  → Project-specific aliases"
            ;;
        "dev")
            echo "🔧 DEVELOPMENT INFO SHORTCUTS (dev*)"
            echo "====================================="
            echo
            echo "Individual environments:"
            echo -e "  ${YELLOW}devjava  ${NC}  → Java/Maven/Gradle info"
            echo -e "  ${YELLOW}devkotlin${NC}  → Kotlin environment info"
            echo -e "  ${YELLOW}devscala ${NC}  → Scala/SBT info"
            echo -e "  ${YELLOW}devpython${NC}  → Python environment info"
            echo -e "  ${YELLOW}devrust  ${NC}  → Rust/Cargo info"
            echo -e "  ${YELLOW}devgo    ${NC}  → Go environment info"
            echo -e "  ${YELLOW}devjs    ${NC}  → Node.js/npm info"
            echo -e "  ${YELLOW}devruby  ${NC}  → Ruby/Gem info"
            echo -e "  ${YELLOW}devlua   ${NC}  → Lua environment info"
            echo
            echo "Special commands:"
            echo -e "  ${YELLOW}devinfo${NC}     → Show ALL environments"
            ;;
        "")
            echo "🚀 DEVELOPMENT SHORTCUTS REFERENCE"
            echo "=================================="
            echo
            f_shortcuts_help "aks"
            echo
            f_shortcuts_help "dev"
            echo
            echo "💡 Usage Tips:"
            echo "  • Use 'aksfind <term>' to search for specific aliases" | lolcat
            echo "  • Use 'devinfo' to see all development environments at once"  | lolcat
            ;;
        *)
            echo "❌ Unknown category: $category"
            echo
            echo "Available categories:"
            echo "  aks    → Show aks alias shortcuts"  | lolcat
            echo "  dev    → Show development info shortcuts"  | lolcat
            ;;
    esac
}


# Function to display aliases from specific files or all files
f_aliases_show() {
    local category="$1"
    local aliases_dir="$HOME/.aliases"

    # Color codes for better readability
    local BLUE='\033[0;34m'
    local GREEN='\033[0;32m'
    local YELLOW='\033[1;33m'
    local RED='\033[0;31m'
    local NC='\033[0m' # No Color

    # Function to extract and display aliases from a file
    show_file_aliases() {
        local file="$1"
        local filename=$(basename "$file" .sh)

        if [[ -f "$file" ]]; then
            echo
            echo -e "${BLUE}=== $(echo ${filename} | tr '[:lower:]' '[:upper:]') ALIASES ===${NC}"

            # Extract aliases and functions, skip comments and empty lines
            grep -E "^(alias |function |.*\(\))" "$file" | \
            grep -v "^#" | \
            while IFS= read -r line; do
                if [[ "$line" =~ ^alias ]]; then
                    # Extract alias name and command
                    local alias_part="${line#alias }"
                    local alias_name="${alias_part%%=*}"
                    local alias_cmd="${alias_part#*=}"
                    # Remove quotes from command
                    alias_cmd="${alias_cmd%\"}"
                    alias_cmd="${alias_cmd#\"}"
                    alias_cmd="${alias_cmd%\'}"
                    alias_cmd="${alias_cmd#\'}"

                    echo -e "  ${GREEN}${alias_name}${NC} → ${YELLOW}${alias_cmd}${NC}"
                elif [[ "$line" =~ \(\) ]] || [[ "$line" =~ ^function ]]; then
                    # Extract function name
                    local func_name
                    if [[ "$line" =~ ^function ]]; then
                        func_name="${line#function }"
                        func_name="${func_name%%\(*}"
                    else
                        func_name="${line%%\(*}"
                    fi
                    echo -e "  ${GREEN}${func_name}${NC} → ${RED}[function]${NC}"
                fi
            done
            echo
        else
            echo -e "${RED}File not found: $file${NC}"
            echo
        fi
    }

    if [[ -z "$category" ]]; then
        # Show all aliases if no category specified
        echo
        echo -e "${YELLOW}📋 ALL ALIASES AND FUNCTIONS${NC}"
        echo "================================"
        echo

        # List all .sh files in aliases directory
        for file in "$aliases_dir"/*.sh; do
            if [[ -f "$file" ]]; then
                show_file_aliases "$file"
            fi
        done
    else
        # Show specific category
        local file="$aliases_dir/${category}.sh"
        echo
        show_file_aliases "$file"
    fi
}

# Function to search for aliases across all files
f_aliases_find() {
    local search_term="$1"
    local aliases_dir="$HOME/.aliases"

    if [[ -z "$search_term" ]]; then
        echo "Usage: f_aliases_find <search_term>"
        echo "Example: f_aliases_find git"
        return 1
    fi

    echo
    echo "🔍 SEARCHING FOR: $search_term"
    echo "================================"
    echo

    local found=false

    # Search in all .sh files in aliases directory
    for file in "$aliases_dir"/*.sh; do
        if [[ -f "$file" ]]; then
            local filename=$(basename "$file" .sh)

            # Search for aliases and functions containing the search term
            local matches=$(grep -n -E "^(alias |function |.*\(\))" "$file" 2>/dev/null | grep -i "$search_term" 2>/dev/null)

            if [[ -n "$matches" ]]; then
                found=true
                echo "📁 Found in ${filename}.sh:"

                while IFS= read -r match; do
                    if [[ -n "$match" ]]; then
                        local line_num="${match%%:*}"
                        local line_content="${match#*:}"

                        if [[ "$line_content" =~ ^alias ]]; then
                            # Parse alias
                            local alias_part="${line_content#alias }"
                            local alias_name="${alias_part%%=*}"
                            local alias_cmd="${alias_part#*=}"
                            # Remove quotes
                            alias_cmd="${alias_cmd%\"}"
                            alias_cmd="${alias_cmd#\"}"
                            alias_cmd="${alias_cmd%\'}"
                            alias_cmd="${alias_cmd#\'}"

                            echo "  $alias_name → $alias_cmd (line $line_num)"
                        elif [[ "$line_content" =~ \(\) ]] || [[ "$line_content" =~ ^function ]]; then
                            # Parse function
                            local func_name
                            if [[ "$line_content" =~ ^function ]]; then
                                func_name="${line_content#function }"
                                func_name="${func_name%%\(*}"
                            else
                                func_name="${line_content%%\(*}"
                            fi

                            echo "  $func_name → [function] (line $line_num)"
                        fi
                    fi
                done <<< "$matches"
                echo
            fi
        fi
    done

    if [[ "$found" == false ]]; then
        echo "❌ No aliases or functions found matching: $search_term"
        echo
        echo "💡 Tip: Try a partial match or different spelling"  | lolcat
    fi
}

# Alias display shortcuts
alias aks="f_aliases_help aks"
alias akshelp="f_aliases_help aks"
alias aksls="f_aliases_show"
alias aksfind="f_aliases_find"
alias akscommon="f_aliases_show common"
alias aksgit="f_aliases_show git"
alias aksgo="f_aliases_show go"
alias aksbrew="f_aliases_show homebrew"
alias aksjava="f_aliases_show java"
alias aksjs="f_aliases_show js"
alias akslua="f_aliases_show lua"
alias aksproj="f_aliases_show projects"
alias akspy="f_aliases_show python"
alias aksruby="f_aliases_show ruby"
alias aksrust="f_aliases_show rust"
alias akstools="f_aliases_show tools"


alias dev="f_aliases_help dev"
alias devhelp="f_aliases_help dev"
alias devinfo="f_devinfo all"
alias devgo="f_devinfo go"
alias devjava="f_devinfo java"
alias devjs="f_devinfo js"
alias devkotlin="f_devinfo kotlin"
alias devlua="f_devinfo lua"
alias devpython="f_devinfo python"
alias devruby="f_devinfo ruby"
alias devrust="f_devinfo rust"
alias devscala="f_devinfo scala"