activate

#!/bin/sh
# 4.2.0

BRO_COMMANDS="create remove list takeover update start goto"

bro_sed () {
	if command -v gsed > /dev/null ; then
    gsed $@
		return 0
	fi

	sed $@
}

bro_expand () {
	echo `sh -c "echo $1"`
}

bro_error () {
	printf "Bro! $1.\n"
}

bro_usage () {
	echo "Project management: bro <subcommand>"
	echo "Available subcommands are:"
	echo "  create     Create a new project."
	echo "  start      Work on a project."
	echo "  list       List available projects to work on."
	echo "  remove     Delete an existing project."
	echo "  takeover   Let bro handle existing project."
}


bro_goto_usage () {
	echo "Usage: bro goto <project>"
	echo "  project     Name of a project."
}

bro_create_usage () {
	echo "Usage: bro create [-t template -p path] <project>"
	echo "  project     Name of the project to be created."
	echo "  template    Path to a template. It could be local directory or remote repo."
	echo "  path        Absolute/relative path where the project directory is to be created."
}


bro_remove_usage () {
	echo "Usage: bro remove <project>"
	echo "  project     Name of the project to be removed."
}

bro_start_usage () {
	echo "Usage: bro start <project>"
	echo "  project     Name of the project to work on."
}

bro_takeover_usage () {
	echo "Usage: bro takeover <path> <project>"
	echo "  path      Path to existing project."
	echo "  project   Name of the project."
}

bro_update () {
	cwd=$(pwd)
	cd $BRO_STATION
	git pull origin master
	cd $cwd
}

# setup a project
# like installing dependencies, git, preparing project structure etc
bro_setup () {
  project=$1
  bro_task setup $project
	bro_init $project
}

bro_init () {
  structure () {
    tmux new -d -s $1
  }

  window () {
    tmux new-window -n $1
  }

  run () {
    tmux send "$@" ENTER
  }

  vsplit () {
    tmux split-window -h -b
  }

  hsplit () {
    tmux split-window -b
  }

  pane () {
    case $1 in
      up)
        tmux select-pane -U
        ;;
      right)
        tmux select-pane -R
        ;;
      down)
        tmux select-pane -D
        ;;
      left)
        tmux select-pane -L
        ;;
    esac
  }

  focus () {
    if [[ $# = 2 ]]; then
      tmux select-window -t $1
      tmux select-pane -t $2
    elif [[ $# = 1 ]]; then
      tmux select-window -t $1
    fi
  }

  connect () {
    tmux kill-window -t 0
    tmux a -t $1
  }

  bro_task init $@

  unset -f structure
  unset -f window
  unset -f run
  unset -f vsplit
  unset -f hsplit
  unset -f pane
  unset -f focus
  unset -f connect
}

bro_task () {
  local task_file
  task=$1
	project=$2
	project_reference=`bro_expand "$BRO_STATION/projects/$project"`

	# check if the project exists
	if [ ! -e "$project_reference" ]; then
		bro_error "the project \"$project\" does not exist.\n Create it with $ bro create $1"
		return 1
	fi

  cd $(cat $project_reference)

  task_directory='./tasks'
  if [ -d $task_directory ] ; then
    case $task in
      setup)
        task_file=$(find $task_directory -type f -name 'setup' -o -name 'setup.*')
        ;;
      init)
        task_file=$(find $task_directory -type f -name 'init' -o -name 'init.*')
        ;;
      exit)
        task_file=$(find $task_directory -type f -name 'exit' -o -name 'exit.*')
        ;;
    esac
  fi

  if [ ! -z $task_file ] ; then
    chmod +x $task_file
    first_line=$(bro_sed -n '1p' $task_file)

    # remove task name and project name
    shift

    case $first_line in
      '#!/bin/sh'|'#!/bin/bash'|'#!/bin/ksh'|'#!/bin/dash')
        source $task_file $@
        ;;
      *)
        $task_file $@
        ;;
    esac
  fi
}

bro_start () {
  possible_project=$1

  if [ -z $possible_project ] ; then
    bro_start_usage
  fi
	project_reference=`bro_expand "$BRO_STATION/projects/$possible_project"`

  # if a tmux session already exists reconnect it
  if [[ $(tmux ls 2>/dev/null | bro_sed -n "/$possible_project:/p") ]] ; then
    tmux new-session -A -s $possible_project
  fi

  if [[ -f "$project_reference" ]] ; then
    bro_init $@
  else
    bro_error "The project $possible_project does not exist."
	fi 
}

# creates a project
bro_create () {
	local OPTIND template path opt project_path project_reference template_path

	while getopts :t:p: opt; do
		case  $opt in
			t) template=$OPTARG;;
			p) path=$OPTARG;;
			*) echo "Invalid option: -" $OPTARG;;
		esac
	done

	## get project name
	shift $(($OPTIND-1))
	project=$@

  if [ "$project" = "" ] && [ ! -z "$(echo $template | bro_sed '/.*\.git/p')" ] ; then
    project="$(echo $template | bro_sed 's/.*\/\(.*\)\.git/\1/')"
  fi

	if [ "$project" = "" ] ; then
		bro_error "you missed the project name"
		bro_create_usage
		return 1
	fi

	## set project path
	if [ "$path" = "" ] ; then
		project_path=`bro_expand "$WORKSTATION/$project"`
	else
		if [ "$(echo $path | bro_sed -n "/[~\/]/p")" = "" ] ; then
			mkdir -p `bro_expand "$WORKSTATION/$path"`
			project_path=`bro_expand "$WORKSTATION/$path/$project"`
		else
			project_path=`bro_expand "$path/$project"`
		fi
	fi
	## set project reference path
	project_reference=`bro_expand "$BRO_STATION/projects/$project"`

	### check if the project already exists
	if [ -e $project_reference ] ; then
		bro_error "the project \"$project\" already exists"
		return 1
	fi

	## set template
	case $template in
		"")
			template_path=""
			;;
		# templates/name or name
		git@*|http:*|https:*|/*|~*)
			template_path=$template
			;;
		*)
			template_path=`bro_expand "$WORKSTATION/$template"`
			;;
	esac

	## create project directory at specified path
	case $template_path in
		# http or git
		git@*|http:*|https:*)
			git clone $template_path $project_path

			if [ ! -e $project_path ] ; then
				bro_error "it seems template at \"$template_path\" does not exist.\nPlease check the url or the internet connection."
				return
			fi
			;;
		# local path
		*)
			if [ ! -e $template_path ] ; then
				bro_error "the bro template \"$template\" does not exist. Please create one at $WORKSTATION"
				return
			fi

			mkdir -p $project_path

			## copy files from template to project directory
      if [ ! -z "$template_path" ] ; then
			  cp -a $template_path/. $project_path/
      fi
			;;
	esac

	## create project reference file
	touch $project_reference
	echo "$project_path" > $project_reference

	## setup project
	bro_setup $project
}

# remove a project
bro_remove () {
	if [[ "$1" = "" ]] ; then
		bro_remove_usage
		return 1
	fi

	project=$1
	project_reference=`bro_expand "$BRO_STATION/projects/$project"`

	# check if the project already exists
	if [ ! -e "$project_reference" ]; then
		bro_error "the project \"$project\" does not exist"
		return 1
	fi

	rm -f $project_reference
}


# list available projects
bro_list () {
	ls $BRO_STATION/projects/
}


# takeover existing projects
bro_takeover () {
	if [ $# = 0 ] ; then
		bro_takeover_usage
		return
	fi

	project_name=$(basename $1)
	project_reference=$BRO_STATION/projects/$project_name
	project_path=`cd $1 && pwd`

	if [ -f $project_reference ] ; then
		echo "Project already exists."
		return
	fi

	if [ ! -d $project_path ] ; then
		echo "$project_path does not exist."
		return
	fi

	## create project reference file
	touch $project_reference
	echo $project_path > $project_reference

	cd $project_path
	bro_init $project_name
}


bro_exit () {
  project=$(basename "`pwd`")

	if [[ $(tmux ls 2>/dev/null | bro_sed -n "/$project:/p") ]]
	then
		tmux kill-session -t $project
		return 0
	fi
	bro_task exit $project
}

bro_goto () {
  possible_project=$1

  if [ -z $possible_project ] ; then
    bro_goto_usage
  fi
	project_reference=`bro_expand "$BRO_STATION/projects/$possible_project"`

  if [[ -f "$project_reference" ]] ; then
    cd $(cat $project_reference)
  else
    bro_error "The project $possible_project does not exist."
  fi 
}

bro () {
	if [ "$#" = "0" ] ; then
		bro_usage
		return 1
	fi

	cmd=$1
	project=$2

	# local OPTIND
	case $cmd in
		goto)
			shift
			bro_goto $@
			;;
		create)
			shift
			bro_create $@
			;;
		remove)
			bro_remove $project
			;;
		list)
			bro_list
			;;
		takeover)
			shift
			bro_takeover $@
			;;
    exit)
      bro_exit
      ;;
		update)
			bro_update
			;;
    exit)
      bro_exit
      ;;
    start)
			shift
			bro_start $@
      ;;
		*)
      bro_usage
			;;
	esac
}

# autocomplete
_bro () {
	local cur prev

	cur=${COMP_WORDS[COMP_CWORD]}
	prev=${COMP_WORDS[COMP_CWORD-1]}

	projects=$(ls $BRO_STATION/projects)

	# $ bro
	if (( $COMP_CWORD <= 1 )); then
    COMPREPLY=( $(compgen -W '$BRO_COMMANDS' -- $cur) )
		return 0
	fi

	if [[ "$prev" = "start" ]]; then
    COMPREPLY=( $(compgen -W '$projects' -- $cur) )
		return 0
	fi

	if [[ "$prev" = "goto" ]]; then
    COMPREPLY=( $(compgen -W '$projects' -- $cur) )
    return 0
	fi

    # if prev == <one of the projects>, look into the init.sh task if exists and display the functions
    if [[ $(echo $projects | grep $prev) ]]; then
        project_path=$(cat $BRO_STATION/projects/$prev)
        init_path=$project_path/tasks/init.sh
        if [[ -f $init_path ]]; then
            # look for lines matching '<function name> ()' and omit the '()'
            output=$(cat $init_path | grep -oE '^([a-z-]+) *\( *\)' | grep -Eo '[a-z][a-z-]+[a-z]')
            COMPREPLY=( $(compgen -W '$output' -- $cur) )
        fi
        return 0
    fi

	# autocomplete options for create command
	if [[ "$prev" = "create" ]]; then
		COMPREPLY=( $(compgen -W '-p -t' -- $cur) )
		return 0
	fi

	# autocomplete project names for remove command
	if [[ "$prev" = "remove" ]]; then
		COMPREPLY=( $(compgen -W '$projects' -- $cur) )
		return 0
	fi

	if [[ "$prev" = "takeover" ]]; then
		COMPREPLY=( $(compgen -f -- $cur) )
		return 0
	fi

	# no auto completion for list command
	if [[ "$prev" = "list" ]]; then
		return 0
	fi
}

complete -F _bro bro