git-rflow

#!/usr/bin/env bash

#  https://github.com/thewoolleyman/gitrflow
#  Copyright (c) 2014 Chad Woolley - The MIT License

###
### Bash setup
###

# http://www.gnu.org/software/bash/manual/html_node/The-Set-Builtin.html

function handle_gitrflow_bash_xtrace() {
  gitrflow_bash_xtrace=${GITRFLOW_BASH_XTRACE:-false}
  if [[ ${gitrflow_bash_xtrace} == 'true' ]]; then
    export PS4="+(\${BASH_SOURCE}:\${LINENO}): \${FUNCNAME[0]:+\${FUNCNAME[0]}(): }"
    set -o xtrace
  fi
}
handle_gitrflow_bash_xtrace

gitrflow_bash_verbose=${GITRFLOW_BASH_VERBOSE:-false}
if [[ ${gitrflow_bash_verbose} == 'true' ]]; then
  set -o verbose
fi

set -o errexit # AKA -e - exit immediately on errors (http://mywiki.wooledge.org/BashFAQ/105)
set -o errtrace # AKA -E - any trap on ERR is inherited by subshell
set -o noclobber # AKA -C - disallow '>' to overwrite file (see http://mywiki.wooledge.org/NoClobber)
set -o nounset # AKA -u - guard against unused variables (see http://mywiki.wooledge.org/BashFAQ/035)
set -o pipefail # fail when pipelines contain an error (see http://www.gnu.org/software/bash/manual/html_node/Pipelines.html)

_log_prefix="[gitrflow] ${BASH_SOURCE}:"

function onexit() {
  local exit_status=${1:-$?}
  if [[ ${exit_status} != 0 ]]; then
    _error_line="error trapped."
  else
    _error_line=''
  fi
  if [[ $(type -t onexit_hook) = 'function' ]]; then
    onexit_hook
  fi
  echo "$_log_prefix $_error_line Exiting $0 with exit status $exit_status"
  exit "${exit_status}"
}

function disable_error_checking() {
  trap - ERR
  set +o errexit
}

function enable_error_checking() {
  trap onexit ERR
  set -o errexit
}

trap onexit HUP INT QUIT TERM ERR

###
### Git Processing
###

function exec_git() {
  unset git_output # reset output from any previous git command

  git_command="${*}"

  git_output=$(${git_command} 2>&1)
  git_command_exit_status=$?
  if ${print_git_commands}; then
    echo "${git_command}"
  fi

  if [[ -n ${git_output} && ${print_git_output} == true ]]; then
    echo "${git_output}" # print git output if option is set
    git_output_to_print=true
  fi

  if [[ ! ${git_command_exit_status} == 0 ]]; then
    return "${git_command_exit_status}"
  fi
}

###
### Common Utility Functions
###

function fail_unless_local_repo_is_clean_and_unmodified() {
  fail_unless_repo_clean

  fail_if_repo_gone

  exec_git "git rev-parse --abbrev-ref HEAD"
  starting_branch=${git_output}
  current_branch=${starting_branch}
  fetch_current_branch

  exec_git 'git status --porcelain --branch'
  git_status_output=${git_output}

  fail_if_unpushed_changes
}

function fail_unless_repo_clean() {
  exec_git 'git status --porcelain'
  if [[ -n ${git_output} ]]; then
    print_error_and_exit 'ERROR: Local repo is not clean. Please fix and retry.'
  fi
}

function fail_if_repo_gone() {
  exec_git 'git status --porcelain --branch'
  if [[ ${git_output} == *'[gone]'* ]]; then
    print_error_and_exit 'ERROR: Local repo is "gone". Please fix and retry.'
  fi
}

function fetch_current_branch() {
  exec_git "git fetch -q ${remote} ${current_branch}"
}

function fail_if_unpushed_changes() {
  if [[ ${git_status_output} =~ \[(ahead) ]]; then
    print_error_and_exit 'ERROR: Local repo has unpushed changes. Please fix and retry.'
  fi
}

function fail_if_unpulled_changes() {
  if [[ ${git_status_output} =~ \[(behind) ]]; then
    print_error_and_exit "ERROR: Local repo is behind remote. Please run 'git rflow update' to pull remote updates, then retry."
  fi
}

###
### Command Processing
###

function run_command() {
  local current_branch
  local starting_branch
  local git_command
  local git_output
  local git_status_output

  if ${do_update}; then
    run_update_command
  else
    run_branch_command
  fi

}

###
### Update Command Processing
###

function run_update_command() {
  fail_unless_local_repo_is_clean_and_unmodified

  if [[ ${git_status_output} =~ \[(behind) ]]; then
    printf "Rebasing local branch '%s' onto remote branch '%s/%s'...\n" "${current_branch}" "${remote}" "${current_branch}"
    exec_git "git rebase ${remote}/${current_branch}"
    printf "Rebase complete!  Local branch '%s' is now up-to-date.\n" "${current_branch}"
  else
    printf "Up to date! No changes to pull from remote branch '%s/%s'.\n" "${remote}" "${current_branch}"
  fi
}

###
### Branch Command Processing
###

function run_branch_command() {
  # declare variables with local scope to this function and all subfunctions
  local prefixed_branch_name

  fail_unless_local_repo_is_clean_and_unmodified
  fail_if_unpulled_changes

  prefix="${branch_type}_prefix" # e.g. 'feature_prefix
  # bash indirect parameter expansion: http://www.gnu.org/software/bash/manual/html_node/Shell-Parameter-Expansion.html
  prefixed_branch_name="${!prefix}${branch_name}" # e.g. 'feat/mybranch'
  "${branch_type}_${branch_command}" # Invoke function, e.g. 'feature_start'
}

###
### Feature Branch Command Processing
###

function feature_start() {
  if [[ ! ${current_branch} == 'master' ]]; then
    print_error_and_exit 'ERROR: Local branch is not master.  Currently, git-rflow only supports feature branches created directly off of master.'
  fi

  exec_git "git checkout -b ${prefixed_branch_name}"
  exec_git "git push ${remote} ${prefixed_branch_name}"

  if ${git_output_to_print}; then
    printf "\n"
  fi
  printf "Summary of actions:\n"
  printf "%s A new Feature branch '%s' was created, based on 'master'\n" \
    '-' "${prefixed_branch_name}"
  printf "%s It is pushed to the remote '%s', with a tracking branch of 'origin/%s'\n" \
    '-' "${remote}" "${prefixed_branch_name}"
  printf "%s You are now on branch '%s'\n\n" '-' "${prefixed_branch_name}"
  printf "Now, start committing on your feature. When done, use:\n\n"
  printf "     git flow feature finish %s\n" "${branch_name}"
}

###
### Config handling
###

function load_config_or_fail() {
  local config_loaded='true'
  load_config
  if [[ ! ${config_loaded} == 'true' ]]; then
    print_error_and_exit \
      'ERROR: Not a gitrflow-enabled repo yet. Please run "git rflow init [--defaults]" first.'
  fi
}

function load_config() {
	load_prefixes
}

function load_prefixes() {
  # Note: disable shellcheck SC2034 unused variable warning, because the [branch_type]_prefix
  # variables are used in run_branch_command() via bash indirect parameter expansion
	if ! exec_git 'git config --get gitrflow.prefix.feature'; then
    config_loaded='false'
  else
    # shellcheck disable=SC2034
    feature_prefix="${git_output}"
  fi
}

###
### Init handling
###

function run_init_command() {
  prefix='feat/'
  if ${do_init_use_defaults}; then
    printf "Using default branch prefixes:\n"
    printf "  Feature branches: '%s'\n" ${prefix}
  else
    printf "What prefix will you use for feature branches? [%s]\n" ${prefix}
	  read input
    if [[ ! ${input} == '' ]]; then
      prefix=${input}
    fi
	fi
  exec_git "git config gitrflow.prefix.feature ${prefix}"
}

###
### Option handling
###

function print_version() {
  echo 'git-rflow, version 0.0.1'
}

function print_usage_and_exit() {
  printf "Usage:\n"
  printf "  gitrflow [global options] init [--defaults]\n"
  printf "  gitrflow [global options] update\n"
  printf "  gitrflow [global options] <branch type> <command> [command options]\n"
  printf "\n"
  printf "'init' command options:\n"
  printf "    --defaults                  Use defaults for init config without prompting\n"
  printf "\n"
  printf "Branch Types:\n"
  printf "    feature\n"
  printf "\n"
  printf "'feature' branch type commands and options:\n"
  printf "    feature start <branch_name>\n"
  printf "\n"
  printf "Global options:\n"
  printf "    -c, --print-git-commands    Print git [c]ommands as they are run\n"
  printf "    -d, --debug                 Debug git-rflow script with bash xtrace\n"
  printf "    -h, --help                  Display this [h]elp\n"
  printf "    -o, --print-git-output      Print [o]utput from git commands\n"
  printf "    -V, --version               Display the program [v]ersion\n"
  printf "    --                          Ignore all following options\n"
  printf "\nSee https://github.com/thewoolleyman/gitrflow for more information.\n"
  exit 1
}

function print_error_and_exit() {
  echo "${1}" >&2
  printf "'git-rflow --help' for usage.\n"
  exit 1
}

function parse_options() {
  set +o nounset

  # see http://stackoverflow.com/a/13864829/25192
  if [[ -z "${1+x}" ]]; then
    print_usage_and_exit
  fi

  if [[ "${1}" == '--' ]]; then
    print_usage_and_exit
  fi

  # flags
  local do_init=false
  local do_init_use_defaults=false
  local do_update=false
  local git_output_to_print=false
  local print_git_commands=false
  local print_git_output=false
  local remote='origin'

  # config
  local feature_prefix

  # from http://mywiki.wooledge.org/BashFAQ/035
  while :; do
    case ${1} in
      init)
        do_init=true
        shift
        if [[ "${1}" == '--defaults' ]]; then
          do_init_use_defaults=true
          shift
        fi
        continue
        ;;
      update)
        do_update=true
        shift
        continue
        ;;
      feature) # Takes an option arguments, ensuring they have been specified.
        local branch_type=${1}
        if [[ "${2}" ]]; then
          local branch_command=$2
          if [[ "${3}" ]]; then
            local branch_name=$3
            shift 3
            continue
          else
            print_error_and_exit 'ERROR: The feature branch name is required.'
          fi
        else
          print_error_and_exit 'ERROR: The feature branch command is required.'
        fi
        ;;
      -c|--print-git-commands)
        print_git_commands=true
        ;;
      -d|--debug)
        GITRFLOW_BASH_XTRACE='true'
        handle_gitrflow_bash_xtrace
        ;;
      -h|--help)
        print_usage_and_exit
        ;;
      -o|--print-git-output)
        print_git_output=true
        ;;
      -V|--version)
        print_version
        exit 0
        ;;
      --) # ignore all following options
        shift
        break
        ;;
      *)
        # see http://stackoverflow.com/a/13864829/25192
        if [[ -z "${1+x}" ]]; then
          break
        else
          print_error_and_exit "ERROR: Unrecognized parameter '${1}'"
        fi
    esac

    shift
  done

  set -o nounset

  if ${do_init}; then
    run_init_command
    exit 0
  fi

  load_config_or_fail

  run_command
}

function invoke() {
  set +o nounset
  parse_options "${@}"
  set -o nounset
}

###
### invoke script
###

set +o nounset
invoke "${@}"
set -o nounset