gows

#  -*- mode: unix-shell-script; -*-

_gows_help() {
    echo "Go workspace manager"
    echo
    echo "Usage:"
    echo "    gows command [arguments]"
    echo
    echo "The commands are:"
    echo "    add        add path to front of workspace GOPATH (default current)"
    echo "    cd         switch to directory of package path (default \$GOPATH/src)"
    echo "    edit       open package path in VISUAL editor (default \$GOPATH/src)"
    echo "    init       initialize workspace (default working directory)"
    echo "    install    install default Go packages"
    echo "    list       list all workspace paths"
    echo "    reset      reset to empty workspace"
    echo "    run        detects go path and runs command in that environment"
    echo "    switch     switch workspace to path (default to working directory)"
    echo "    which      show workspace for path (default to working directory)"
    echo
    echo "gows manages the workspace by setting the GOPATH environment variable"
    echo "When setting or adding a workspace, gows will search up the path"
    echo "to find the parent with the required GOPATH entries of bin, pkg, and src"
    echo "Workspaces are added to the front of an existing GOPATH."
    echo
    echo "gows init will install all packages listed in the following:"
    echo "    /usr/etc/goenvrc"
    echo "    /usr/local/etc/goenvrc"
    echo "    ~/.goenvrc"
    echo "    .goenvrc"
}

_gows_commands() {
	for c in add cd edit init install list reset run switch which; do
		echo $c
	done
}

_gows_complete() {
	case "$1" in
		cd | edit )
			# Use current workspace only
			(
				# go list std doesn't include cmd/internal/rsc.io/* so filter manually
				GOPATH=`_gows_find_ws_path`
				comm -3 <(go list all) <(go list std) | grep -v "cmd/internal/*"
			)
			;;
		*)
			;;
	esac
}

_gows_config() {
	rcfiles=(/usr/etc/goenvrc /usr/local/etc/goenvrc ~/.goenvrc ./.goenvrc)
	packages=()
	
	for rc in ${rcfiles[*]}; do
		if [ -e $rc ]; then
			while read line; do
				packages=("${packages[@]}" $line)
			done <$rc
		fi
	done
}

_gows_exec() {
    case "$1" in
    add)
        if [ -z "$2" ]; then
            _gows_add `_gows_find_ws_path`
        else
            _gows_add `_gows_fullpath $2`
        fi
        ;;
    cd)
    	_gows_cd $2
    	;;
    edit)
        _gows_edit $2
        ;;
    init)
        if [ -z "$2" ]; then
            _gows_init $(pwd)
        else
            _gows_init `_gows_fullpath $2`
        fi
        ;;
    install)
    	_gows_install
    	;;
    switch)
        if [ -z "$2" ]; then
            _gows_switch `_gows_find_ws_path`
        else
            _gows_switch `_gows_fullpath $2`
        fi
        ;;
    *)
        echo "Invalid command"
    esac
}

_gows_find_ws_path() {
    local WSPATH=${1:-$(pwd)}
    if [ -d "${WSPATH}" ]; then
		while [[ "${WSPATH}" != "" ]] && ! [[ -d "${WSPATH}/bin" && -d "${WSPATH}/pkg" && -d "${WSPATH}/src" ]]; do
			WSPATH=${WSPATH%/*}
		done
		echo `_gows_fullpath "${WSPATH}"`
	fi
}

_gows_fullpath() {
  case "$1" in
    /*)
        echo "$1"
        ;;
    *)
        echo "$PWD/$1"
        ;;
  esac
}

_gows_split() {
    OLDIFS="$IFS"
    IFS=$2
    items=(`echo $1`)
    IFS="$OLDIFS"
    echo $items
}

# Subcommands

_gows_add() {
    if [[ -n "$1" && -d "$1" ]]; then
		# Verify target is a Go workspace
		if [[ -d "$1/bin" && -d "$1/pkg" && -d "$1/src" ]]; then
			if [ -z "$_GOWS_OLD_PATH" ]; then
				# Workspace has not been set yet
				_gows_switch $1
			elif [[ ! "$GOPATH" =~  (^|:)"$1"(:|$) ]]; then
				# Add workspace
				if [ -n "$GOPATH" ]; then
					GOPATH=${1}:${GOPATH}
				else
					GOPATH=${1}
				fi
				export GOPATH
			
				PATH=${1}/bin:${PATH}
				export PATH
			else
				echo "Workspace already set"
			fi
		else
			echo "Not a Go workspace"
		fi
    else
        echo "Go workspace missing"
    fi
}

_gows_cd() {
	# Determine if relative or full path or package name
	case "$1" in
		/*)
			cd `_gows_fullpath $1`
			;;
		.*)
			cd "$1"
			;;
		*)
			cd `_gows_find_ws_path`/src/$1
			;;
	esac
	
	_gows_add `_gows_find_ws_path`
}

_gows_edit() {
    if [[ -n "$GOPATH" ]]; then
		if [ -z "$VISUAL" ]; then
			echo "VISUAL editor is not set"
			return
		fi
		"$VISUAL" "`_gows_find_ws_path`/src/$1"
	else
		echo "Go workspace not set"
	fi
}

_gows_init() {
    if [ -n "$1" ]; then
    	# Verify that directory is not already a Go workspace
    	if [[ -n "$(_gows_find_ws_path "${1}")" ]]; then
    		echo "${1} is already in a workspace"
    		return
    	fi
    
        mkdir -p $1/bin $1/pkg $1/src
        _gows_add $1
        
        # Install default packages
        _gows_install
    else
        echo "Path does not exist"
    fi
}

_gows_install() {
	if [[ -n "${GOPATH}" ]]; then
        # Read configuration
        _gows_config
        
		# go get default packages
		for pkg in ${packages[*]}; do
			echo "go get ${pkg}"
			go get -u "${pkg}"
		done
	else
		echo "Go workspace not set"
	fi
}

_gows_list() {    
    if [[ -n "$GOPATH" ]]; then
        items=(`_gows_split $GOPATH ":"`)
        for item in "${items[@]}"; do
          echo "$item"
        done
    else
        echo "Go workspace not set"
    fi
}

_gows_reset() {
    if [ -n "$GOPATH" ]; then
        if [ -n "$_GOWS_OLD_PATH" ]; then
            PATH=$_GOWS_OLD_PATH
            export PATH
            unset _GOWS_OLD_PATH
        fi
        if [ -n "$_GOWS_OLD_GOPATH" ]; then
        	GOPATH=$_GOWS_OLD_GOPATH
        	export GOPATH
	        unset _GOWS_OLD_GOPATH
	    else
	    	unset GOPATH
	    fi
    else
        echo "Go workspace not set"
    fi
}

_gows_switch() {
	# Reset workspace if already set
	if [ -n "$_GOWS_OLD_PATH" ]; then
		_gows_reset
	fi
	
	# Cache original values before switching to allow reset
    if [[ -n "$1" && -d "$1" ]]; then
        _GOWS_OLD_PATH=$PATH
        export _GOWS_OLD_PATH
        
        if [ -n "$GOPATH" ]; then    
			_GOWS_OLD_GOPATH=$GOPATH
			export _GOWS_OLD_GOPATH
        fi
        
        _gows_add $1
    else
        echo "Go workspace missing"
    fi
}

_gows_which() {
    echo `_gows_find_ws_path "${1}"`
}

# Command handler

gows() {
    cmd=$1
    
    case "$cmd" in
    cd | edit | install | switch)
    	_gows_exec $@
        ;;
	# Commands for list
    add | init)
    	shift
    	if [ $# -gt 0 ]; then
    		while (($#)); do
    			_gows_exec $cmd $1
    			shift
    		done
    	else
    		_gows_exec $cmd
    	fi
    	;;
    run)
    	shift
    	(
    		_gows_exec "switch"
    		if [ 0 -eq $? ]; then
    			$@
    		fi
    	)
    	;;
    reset     ) _gows_reset;;
    list      ) _gows_list;;
    which     )
    	shift
    	_gows_which $@
    	;;
    --commands) _gows_commands;;
    --complete)
    	shift
    	if [ $# -gt 0 ]; then
    		_gows_complete $*
    	fi
    	;;
    help | *) _gows_help;;
    esac
}

# Setup completion
if [ -n "$BASH_VERSION" ]; then
	source "$(dirname "${BASH_SOURCE[0]}")/gows.bash"
elif [ -n "$ZSH_VERSION" ]; then
	source "$(dirname "$0")/gows.zsh"
fi