git-flow-feature

#
# ITM Gitflow script package -- A collection of Git extensions to provide
# high-level repository operations for Vincent Driessen's branching model.
#
# A blog post by Vincent Driessen presenting this model is found at:
#    http://nvie.com/posts/a-successful-git-branching-model/
#
# Feel free to contribute to this project at:
#    https://github.com/fspreng/ITM_gitflow
#
# Copyright (c) 2012-2015 Fabian Spreng. All rights reserved.
#
# Original author:
# Copyright 2010 Vincent Driessen. All rights reserved.
# 
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions are met:
# 
#    1. Redistributions of source code must retain the above copyright notice,
#       this list of conditions and the following disclaimer.
# 
#    2. Redistributions in binary form must reproduce the above copyright
#       notice, this list of conditions and the following disclaimer in the
#       documentation and/or other materials provided with the distribution.
# 
# THIS SOFTWARE IS PROVIDED BY VINCENT DRIESSEN ``AS IS'' AND ANY EXPRESS OR
# IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
# MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
# EVENT SHALL VINCENT DRIESSEN OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
# INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
# BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
# OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
# NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
# EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
# 
# The views and conclusions contained in the software and documentation are
# those of the authors and should not be interpreted as representing official
# policies, either expressed or implied, of Vincent Driessen.
#

init() {
  require_git_repo
  require_gitflow_initialized
  gitflow_load_settings
  PREFIX=$(git config --get gitflow.prefix.feature)
  REMOTE_PREFIX=$ORIGIN/$PREFIX
}

usage() {
	echo "usage: $GITFLOW_COMMAND feature [list] [-v]"
	echo "       $GITFLOW_COMMAND feature start [-F] <name> [<base>]"
	echo "       $GITFLOW_COMMAND feature finish [-rFkDS] <name|nameprefix>"
	echo "       $GITFLOW_COMMAND feature delete [-l] <name>"
	echo "       $GITFLOW_COMMAND feature publish <name>"
	echo "       $GITFLOW_COMMAND feature track <name>"
	echo "       $GITFLOW_COMMAND feature diff [<name|nameprefix>]"
	echo "       $GITFLOW_COMMAND feature rebase [-i] [<name|nameprefix>]"
	echo "       $GITFLOW_COMMAND feature checkout [<name|nameprefix>]"
	echo "       $GITFLOW_COMMAND feature pull [-r] <remote> [<name>]"
	echo "       $GITFLOW_COMMAND feature update <name> [<base>]"
}

cmd_default() {
	cmd_list "$@"
}

cmd_list() {
	DEFINE_boolean verbose false 'verbose (more) output' v
	parse_args "$@"

	local feature_branches
	local current_branch
	local short_names
	feature_branches=$(echo "$(git_local_branches)" | grep "^$PREFIX")
	echo "Executing Git command 'git remote update'"
	git_do remote update >/dev/null 2>&1 || \
	  die "Could not update remote branches from $ORIGIN."
	echo "Executing Git command 'git remote prune origin'"
	git_do remote prune origin >/dev/null 2>&1
	local remote_feature_branches
	remote_feature_branches=$(echo "$(git_remote_branches)" | grep "^$REMOTE_PREFIX")
	if [ -z "$feature_branches" ] && [ -z "$remote_feature_branches" ]; then
		warn "No feature branches exist."
		warn ""
		warn "You can start a new feature branch:"
		warn ""
		warn "    $GITFLOW_COMMAND feature start <name> [<base>]"
		warn ""
		exit 0
	fi
	current_branch=$(git branch --no-color | grep '^\* ' | grep -v 'no branch' | sed 's/^* //g')
	short_names=$(echo "$feature_branches" | sed "s ^$PREFIX  g")

	# determine column width first
	local width=0
	local branch
	for branch in $short_names; do
		local len=${#branch}
		width=$(max $width $len)
	done
	for branch in $remote_feature_branches; do
		local len=${#branch}
		width=$(max $width $len)
	done
	width=$(($width+3))

	if [ "$feature_branches" ]; then
		printf "Local feature branches:"
		echo
		local branch
		for branch in $short_names; do
			local fullname=$PREFIX$branch
			local base=$(git merge-base "$fullname" "$DEVELOP_BRANCH")
			local develop_sha=$(git rev-parse "$DEVELOP_BRANCH")
			local branch_sha=$(git rev-parse "$fullname")
			if [ "$fullname" = "$current_branch" ]; then
				printf "* "
			else
				printf "  "
			fi
			if flag verbose; then
				printf "%-${width}s" "$PREFIX$branch"
				if [ "$branch_sha" = "$develop_sha" ]; then
					printf "(no commits yet)"
				elif [ "$base" = "$branch_sha" ]; then
					printf "(is behind develop, may ff)"
				elif [ "$base" = "$develop_sha" ]; then
					printf "(based on latest develop)"
				else
					printf "(may be rebased)"
				fi
			else
				printf "%s" "$PREFIX$branch"
			fi
			echo
		done
	fi
	if [ "$remote_feature_branches" ]; then
		printf "Remote feature branches:"
		echo
		for branch in $remote_feature_branches; do
			printf "  "
			printf "%s" "remotes/$branch"
			echo
		done
	fi
}

cmd_help() {
	usage
	exit 0
}

require_name_arg() {
	if [ "$NAME" = "" ]; then
		warn "Missing argument <name>"
		usage
		exit 1
	fi
}

expand_nameprefix_arg() {
	require_name_arg

	local expanded_name
	local exitcode
	expanded_name=$(gitflow_resolve_nameprefix "$NAME" "$PREFIX")
	exitcode=$?
	case $exitcode in
		0) NAME=$expanded_name
		   BRANCH=$PREFIX$NAME
		   ;;
		*) exit 1 ;;
	esac
}

use_current_feature_branch_name() {
	local current_branch=$(git_current_branch)
	if startswith "$current_branch" "$PREFIX"; then
		BRANCH=$current_branch
		NAME=${BRANCH#$PREFIX}
	else
		warn "The current HEAD is no feature branch."
		warn "Please specify a <name> argument."
		exit 1
	fi
}

expand_nameprefix_arg_or_current() {
	if [ "$NAME" != "" ]; then
		expand_nameprefix_arg
		require_branch "$PREFIX$NAME"
	else
		use_current_feature_branch_name
	fi
}

name_or_current() {
	if [ -z "$NAME" ]; then
		use_current_feature_branch_name
	fi
}

parse_args() {
	# parse options
	FLAGS "$@" || exit $?
	eval set -- "${FLAGS_ARGV}"

	# process possible trailing arguments
	length_old=0
	for k in "${@:2}"
	do
		length_old=$[$length_old+1]
	done
	if [ "$length_old" -gt "0" ]; then
		FLAGS "${@:2}" || exit $?
		length_new=0
		for l in ${FLAGS_ARGV[@]}
		do
			length_new=$[$length_new+1]
		done
		if [ "$length_new" -gt "0" ] && [ "$length_new" != "$length_old" ]; then
			die "Putting flags between the two main arguments is not a good idea! Process aborted."
		fi
		if [ "$length_new" == "$length_old" ]; then
			FLAGS "${@:3}" || exit $?
			length_newnew=0
			for l in ${FLAGS_ARGV[@]}
			do
				length_newnew=$[$length_newnew+1]
			done
			if [ "$length_newnew" == "$length_old" ]; then
				die "Too many arguments have been found!"
			fi
		fi
	fi

	# read arguments into global variables
	NAME=$1
	# check whether the user has already added the branch prefix or not
	if { echo "$NAME" | grep -q "^$PREFIX"; } then
		local len=${#PREFIX}
		NAME=${NAME:$len}
	fi
	BRANCH=$PREFIX$NAME
}

parse_remote_name() {
	# parse options
	FLAGS "$@" || exit $?
	eval set -- "${FLAGS_ARGV}"

	# process possible trailing arguments
	length_old=0
	for k in "${@:2}"
	do
		length_old=$[$length_old+1]
	done
	if [ "$length_old" -gt "0" ]; then
		FLAGS "${@:2}" || exit $?
		length_new=0
		for l in ${FLAGS_ARGV[@]}
		do
			length_new=$[$length_new+1]
		done
		if [ "$length_new" -gt "0" ] && [ "$length_new" != "$length_old" ]; then
			die "Putting flags between the two main arguments is not a good idea! Process aborted."
		fi
		if [ "$length_new" == "$length_old" ]; then
			FLAGS "${@:3}" || exit $?
			length_newnew=0
			for l in ${FLAGS_ARGV[@]}
			do
				length_newnew=$[$length_newnew+1]
			done
			if [ "$length_newnew" == "$length_old" ]; then
				die "Too many arguments have been found!"
			fi
		fi
	fi

	# read arguments into global variables
	REMOTE=$1
	NAME=$2
	BRANCH=$PREFIX$NAME
}

cmd_start() {
	DEFINE_boolean fetch true 'fetch from $ORIGIN before performing local operation' F
	parse_args "$@"
	BASE=${2:-$DEVELOP_BRANCH}
	require_name_arg

	# sanity checks
	require_clean_working_tree
	require_branch_absent "$BRANCH"
	echo "Executing Git command 'git remote update'"
	git_do remote update >/dev/null 2>&1 || \
	  die "Could not update remote branches from $ORIGIN."
	echo "Executing Git command 'git remote prune origin'"
	git_do remote prune origin >/dev/null 2>&1
	require_branch_absent "$ORIGIN/$BRANCH"

	# temporarily changing to root directory of git repository
	echo "Changing to root directory of Git repository"
	cd "$(git rev-parse --show-cdup)"

	# update the local repo with remote changes, if asked
	if flag fetch; then
		echo "Executing Git command 'git checkout $BASE'"
		git_do checkout "$BASE" >/dev/null 2>&1 || \
		  die "Could not check out $BASE."
		echo "Executing Git command 'git fetch -q $ORIGIN $BASE:refs/remotes/$ORIGIN/$BASE'"
		git_do fetch -q "$ORIGIN" "$BASE":refs/remotes/"$ORIGIN"/"$BASE" >/dev/null 2>&1 || \
		  die "Could not fetch $BASE from $ORIGIN."
		echo "Executing Git command 'git merge --no-commit $ORIGIN/$BASE'"
		git_do merge --no-commit "$ORIGIN/$BASE" >/dev/null 2>&1  || {
		  echo "*******************************************************************************"
		  # return to previous working directory if available
		  if assert_dir_existence_and_access "$OLDPWD" >/dev/null 2>&1; then
		  	echo "Returning to previous working directory"
		  	cd "$OLDPWD"
		  else
		  	echo "Previous working directory no longer available, staying in root directory of Git repository"
		  fi
		  die "WARNING: There were merge conflicts on $BASE. Resolve them using git mergetool."
		}
		echo "Executing Git command 'git push origin $BASE'"
		git_do push origin "$BASE" >/dev/null 2>&1 || \
		  die "Could not push to $BASE from $ORIGIN."
	fi

	# if the origin branch counterpart exists, assert that the local branch
	# isn't behind it (to avoid unnecessary rebasing)
	if git_branch_exists "$ORIGIN/$BASE"; then
		require_branches_equal "$BASE" "$ORIGIN/$BASE"
	fi

	# create the local branch and the corresponding remote branch
	echo "Executing Git command 'git checkout -b $BRANCH $BASE'"
	if ! git_do checkout -b "$BRANCH" "$BASE" >/dev/null 2>&1; then
		die "Could not create feature branch '$BRANCH'."
	else
		echo "Executing Git command 'git push -u origin $BRANCH'"
		git_do push -u origin "$BRANCH" >/dev/null 2>&1 || \
		  die "Could not push to $BRANCH from $ORIGIN."
	fi

	# return to previous working directory if available
	if assert_dir_existence_and_access "$OLDPWD" >/dev/null 2>&1; then
		echo "Returning to previous working directory"
		cd "$OLDPWD"
	else
		echo "Previous working directory no longer available, staying in root directory of Git repository"
	fi

	echo
	echo "Summary of actions:"
	echo "- A new local branch '$BRANCH' was created, based on '$BASE'"
	echo "- A new remote branch '$BRANCH' was created, based on the local one"
	echo "- You are now on branch '$BRANCH'"
	echo ""
	echo "Now, start committing on your feature. When done, use:"
	echo ""
	echo "     $GITFLOW_COMMAND feature finish $NAME"
	echo
}

cmd_finish() {
	DEFINE_boolean fetch true "fetch from remote branches before performing finish" F
	DEFINE_boolean rebase false "rebase instead of merge (remote branch will be deleted!)" r
	DEFINE_boolean keep false "keep branch after performing finish" k
	DEFINE_boolean force_delete false "force delete feature branch after finish" D
	DEFINE_boolean squash false "squash feature during merge" S
	parse_args "$@"
	require_name_arg
	expand_nameprefix_arg_or_current

	# sanity checks
	require_clean_working_tree
	require_branch "$BRANCH"
	
	# temporarily changing to root directory of git repository
	echo "Changing to root directory of Git repository"
	cd "$(git rev-parse --show-cdup)"
	
	echo "Executing Git command 'git checkout $BRANCH'"
	git_do checkout "$BRANCH" >/dev/null 2>&1 || \
	  die "Could not check out $BRANCH."
	echo "Executing Git command 'git fetch -q $ORIGIN $BRANCH:refs/remotes/$ORIGIN/$BRANCH'"
	git_do fetch -q "$ORIGIN" "$BRANCH":refs/remotes/"$ORIGIN"/"$BRANCH" >/dev/null 2>&1 || \
	  die "Could not fetch $BRANCH from $ORIGIN."
	echo "Executing Git command 'git remote prune origin'"
	git_do remote prune origin >/dev/null 2>&1
	require_branch "$ORIGIN/$BRANCH"
	echo "Executing Git command 'git merge --no-commit $ORIGIN/$BRANCH'"
	git_do merge --no-commit "$ORIGIN/$BRANCH" >/dev/null 2>&1 || {
	  echo "*********************************************************************************"
	  # return to previous working directory if available
	  if assert_dir_existence_and_access "$OLDPWD" >/dev/null 2>&1; then
	  	echo "Returning to previous working directory"
	  	cd "$OLDPWD"
	  else
	  	echo "Previous working directory no longer available, staying in root directory of Git repository"
	  fi
	  die "WARNING: There were merge conflicts on $BRANCH. Resolve them using git mergetool."
	}
	echo "Executing Git command 'git push origin $BRANCH'"
	git_do push origin "$BRANCH" >/dev/null 2>&1 || \
	  die "Could not push to $BRANCH from $ORIGIN."

	# detect if we're restoring from a merge conflict
	if [ -f "$DOT_GIT_DIR/.gitflow/MERGE_BASE" ]; then
		#
		# TODO: detect that we're working on the correct branch here!
		# The user need not necessarily have given the same $NAME twice here
		# (although he/she should).
		# 

		# TODO: git_is_clean_working_tree() should provide an alternative
		# exit code for "unmerged changes in working tree", which we should
		# actually be testing for here
		if git_is_clean_working_tree; then
			FINISH_BASE=$(cat "$DOT_GIT_DIR/.gitflow/MERGE_BASE")

			# Since the working tree is now clean, either the user did a
			# succesfull merge manually, or the merge was cancelled.
			# We detect this using git_is_branch_merged_into()
			if git_is_branch_merged_into "$BRANCH" "$FINISH_BASE"; then
				rm -f "$DOT_GIT_DIR/.gitflow/MERGE_BASE"
				helper_finish_cleanup
				# return to previous working directory if available
				if assert_dir_existence_and_access "$OLDPWD" >/dev/null 2>&1; then
					echo "Returning to previous working directory"
					cd "$OLDPWD"
				else
					echo "Previous working directory no longer available, staying in root directory of Git repository"
				fi
				exit 0
			else
				# If the user cancelled the merge and decided to wait until later,
				# that's fine. But we have to acknowledge this by removing the
				# MERGE_BASE file and continuing normal execution of the finish
				rm -f "$DOT_GIT_DIR/.gitflow/MERGE_BASE"
			fi
		else
			# return to previous working directory if available
			if assert_dir_existence_and_access "$OLDPWD" >/dev/null 2>&1; then
				echo "Returning to previous working directory"
				cd "$OLDPWD"
			else
				echo "Previous working directory no longer available, staying in root directory of Git repository"
			fi

			echo
			echo "Merge conflicts not resolved yet, use:"
			echo "    git mergetool"
			echo "    $GITFLOW_COMMAND commit"
			echo 
			echo "You can then complete the finish by running it again:"
			echo "    $GITFLOW_COMMAND feature finish $NAME"
			echo
			exit 1
		fi
	fi

	# sanity checks
	require_clean_working_tree

	# update local repo with remote changes first, if asked
	# branch $ORIGIN/$BRANCH should be existent, but check it anyway...
	if has "$ORIGIN/$BRANCH" $(git_remote_branches); then
		if flag fetch; then
#			echo "Executing Git command 'git fetch -q $ORIGIN $BRANCH:refs/remotes/$ORIGIN/$BRANCH'"
#			git_do fetch -q "$ORIGIN" "$BRANCH":refs/remotes/"$ORIGIN"/"$BRANCH" >/dev/null 2>&1
			echo "Executing Git command 'git checkout $DEVELOP_BRANCH'"
			git_do checkout "$DEVELOP_BRANCH" >/dev/null 2>&1 || \
			  die "Could not check out $DEVELOP_BRANCH."
			# Basically, the additional fetch is not necessary, but can be useful when the
			# subsequent pull fails
			echo "Executing Git command 'git fetch -q $ORIGIN $DEVELOP_BRANCH:refs/remotes/$ORIGIN/$DEVELOP_BRANCH'"
			git_do fetch -q "$ORIGIN" "$DEVELOP_BRANCH":refs/remotes/"$ORIGIN"/"$DEVELOP_BRANCH" >/dev/null 2>&1 || \
			  die "Could not fetch $DEVELOP_BRANCH from $ORIGIN."
			echo "Executing Git command 'git pull -q --no-commit $ORIGIN $DEVELOP_BRANCH:refs/remotes/$ORIGIN/$DEVELOP_BRANCH'"
			git_do pull -q --no-commit "$ORIGIN" "$DEVELOP_BRANCH":refs/remotes/"$ORIGIN"/"$DEVELOP_BRANCH" >/dev/null 2>&1 || {
			  echo "*****************************************************************************************"
			  # return to previous working directory if available
			  if assert_dir_existence_and_access "$OLDPWD" >/dev/null 2>&1; then
			  	echo "Returning to previous working directory"
			  	cd "$OLDPWD"
			  else
			  	echo "Previous working directory no longer available, staying in root directory of Git repository"
			  fi
			  die "WARNING: There were merge conflicts on $DEVELOP_BRANCH. Resolve them using git mergetool."
			}
#			echo "Executing Git command 'git merge --no-commit $ORIGIN/$DEVELOP_BRANCH'"
#			git_do merge --no-commit "$ORIGIN/$DEVELOP_BRANCH" >/dev/null 2>&1 || {
#			  echo "*****************************************************************************************"
#			  # return to previous working directory if available
#			  if assert_dir_existence_and_access "$OLDPWD" >/dev/null 2>&1; then
#			  	echo "Returning to previous working directory"
#			  	cd "$OLDPWD"
#			  else
#			  	echo "Previous working directory no longer available, staying in root directory of Git repository"
#			  fi
#			  die "WARNING: There were merge conflicts on $DEVELOP_BRANCH. Resolve them using git mergetool."
#			}
			echo "Executing Git command 'git push origin $DEVELOP_BRANCH'"
			git_do push origin "$DEVELOP_BRANCH" >/dev/null 2>&1 || \
			  die "Could not push to $DEVELOP_BRANCH from $ORIGIN."
		fi
	fi

	if has "$ORIGIN/$BRANCH" $(git_remote_branches); then
		require_branches_equal "$BRANCH" "$ORIGIN/$BRANCH"
	fi
	if has "$ORIGIN/$DEVELOP_BRANCH" $(git_remote_branches); then
		require_branches_equal "$DEVELOP_BRANCH" "$ORIGIN/$DEVELOP_BRANCH"
	fi

	# if the user wants to rebase, do that first
	if flag rebase; then
		if ! git-flow feature rebase "$NAME" "$DEVELOP_BRANCH"; then
			# return to previous working directory if available
			if assert_dir_existence_and_access "$OLDPWD" >/dev/null 2>&1; then
				echo "Returning to previous working directory"
				cd "$OLDPWD"
			else
				echo "Previous working directory no longer available, staying in root directory of Git repository"
			fi

			warn "Finish was aborted due to conflicts during rebase."
			warn "Please finish the rebase manually now."
			warn "When finished, re-run:"
			warn "    $GITFLOW_COMMAND feature finish $NAME $DEVELOP_BRANCH"
			exit 1
		fi
	fi

	# merge into BASE
	# we should be already on the develop branch, but try checkout anyway...
	echo "Executing Git command 'git checkout $DEVELOP_BRANCH'"
	git_do checkout "$DEVELOP_BRANCH" >/dev/null 2>&1 || \
	  die "Could not check out $DEVELOP_BRANCH."
	if [ "$(git rev-list -n2 "$DEVELOP_BRANCH..$BRANCH" | wc -l)" -eq 1 ]; then
		echo "Executing Git command 'git merge --ff $BRANCH'"
		git_do merge --ff "$BRANCH" >/dev/null 2>&1
	else
		if noflag squash; then
		    echo "Executing Git command 'git merge --no-ff $BRANCH'"
		    git_do merge --no-ff "$BRANCH" >/dev/null 2>&1
		else
			echo "Executing Git command 'git merge --squash $BRANCH'"
			git_do merge --squash "$BRANCH" >/dev/null 2>&1
			echo "Executing Git command 'git commit --quiet'"
			git_do commit --quiet
			echo "Executing Git command 'git merge $BRANCH'"
			git_do merge "$BRANCH" >/dev/null 2>&1
		fi
	fi

	if [ $? -ne 0 ]; then
		# return to previous working directory if available
		if assert_dir_existence_and_access "$OLDPWD" >/dev/null 2>&1; then
			echo "Returning to previous working directory"
			cd "$OLDPWD"
		else
			echo "Previous working directory no longer available, staying in root directory of Git repository"
		fi

		# oops.. we have a merge conflict!
		# write the given $DEVELOP_BRANCH to a temporary file (we need it later)
		mkdir -p "$DOT_GIT_DIR/.gitflow"
		echo "$DEVELOP_BRANCH" > "$DOT_GIT_DIR/.gitflow/MERGE_BASE"
		echo
		echo "************************************************************************"
		echo "There were merge conflicts. To resolve the merge conflict manually, use:"
		echo "    git mergetool"
		echo "    $GITFLOW_COMMAND commit"
		echo 
		echo "You can then complete the finish by running it again:"
		echo "    $GITFLOW_COMMAND feature finish $NAME"
		echo "************************************************************************"
		echo
		exit 1
	fi

	# when no merge conflict is detected, just clean up the feature branch
	helper_finish_cleanup
}

helper_finish_cleanup() {
	# sanity checks
	require_branch "$BRANCH"
	require_clean_working_tree

	# push branches to origin
	if flag fetch; then
		echo "Executing Git command 'git push $ORIGIN $BRANCH'"
		git_do push "$ORIGIN" "$BRANCH" >/dev/null 2>&1 || \
		  die "Could not push to $BRANCH from $ORIGIN."
		echo "Executing Git command 'git push $ORIGIN $DEVELOP_BRANCH'"
		git_do push "$ORIGIN" "$DEVELOP_BRANCH" >/dev/null 2>&1 || \
		  die "Could not push to $DEVELOP_BRANCH from $ORIGIN."
	fi
	
	# delete branch
	if noflag keep; then
		echo "Executing Git command 'git push origin :$BRANCH'"
		git_do push origin ":$BRANCH" >/dev/null 2>&1 || \
		  die "Could not delete the remote $BRANCH in $ORIGIN."
		if flag force_delete; then
			echo "Executing Git command 'git branch -D $BRANCH'"
			git_do branch -D "$BRANCH" >/dev/null 2>&1
		else
			echo "Executing Git command 'git branch -d $BRANCH'"
			git_do branch -d "$BRANCH" >/dev/null 2>&1
		fi
	fi

	# return to previous working directory if available
	if assert_dir_existence_and_access "$OLDPWD" >/dev/null 2>&1; then
		echo "Returning to previous working directory"
		cd "$OLDPWD"
	else
		echo "Previous working directory no longer available, staying in root directory of Git repository"
	fi

	echo
	echo "Summary of actions:"
	echo "- The feature branch '$BRANCH' was merged into '$DEVELOP_BRANCH'"
	#echo "- Merge conflicts were resolved"		# TODO: Add this line when it's supported
	if flag keep; then
		echo "- Feature branch '$BRANCH' (local and remote) is still available"
	else
		echo "- Feature branch '$BRANCH' (local and remote) has been removed"
	fi
	echo "- You are now on branch '$DEVELOP_BRANCH'"
	echo
}

cmd_delete() {
	DEFINE_boolean local false "only delete the local branch" l
	parse_args "$@"

	# sanity checks
#	require_branch "$BRANCH"
	require_clean_working_tree

	# temporarily changing to root directory of git repository
	echo "Changing to root directory of Git repository"
	cd "$(git rev-parse --show-cdup)"

	# change to branch develop
	echo "Executing Git command 'git checkout $DEVELOP_BRANCH'"
	git_do checkout "$DEVELOP_BRANCH" >/dev/null 2>&1 || \
	  die "Could not check out $DEVELOP_BRANCH."

	# delete local branch
	echo "Executing Git command 'git branch -D $BRANCH'"
	git_do branch -D "$BRANCH" >/dev/null 2>&1

	if ! flag local; then
		# make sure that the remote branch should be deleted as well
		read -p "Are you sure that you want to delete the remote branch as well (Y/N)? " answer
		if [ "$answer" == "y" ] || [ "$answer" == "Y" ] || [ "$answer" == "yes" ] || [ "$answer" == "Yes" ] || [ "$answer" == "YES" ]; then
			# delete remote branch
#			echo "Executing Git command 'git remote prune origin'"
#			git_do remote prune origin >/dev/null 2>&1
			echo "Executing Git command 'git push $ORIGIN :refs/heads/$BRANCH'"
			git_do push "$ORIGIN" ":refs/heads/$BRANCH" >/dev/null 2>&1
		else
			answer="false"
		fi
	fi

	# return to previous working directory if available
	if assert_dir_existence_and_access "$OLDPWD" >/dev/null 2>&1; then
		echo "Returning to previous working directory"
		cd "$OLDPWD"
	else
		echo "Previous working directory no longer available, staying in root directory of Git repository"
	fi

	echo
	echo "Summary of actions:"
	echo "- The local branch '$BRANCH' has been deleted"
	if ! flag local; then
		if [ "$answer" != "false" ]; then
			echo "- The remote branch '$ORIGIN/$BRANCH' has been deleted"
		fi
	fi
	echo "- You are now on branch '$DEVELOP_BRANCH'"
	echo
}

cmd_publish() {
	parse_args "$@"
	expand_nameprefix_arg

	# sanity checks
	require_clean_working_tree
	require_branch "$BRANCH"

	echo "Executing Git command 'git fetch -q $ORIGIN'"
	git_do fetch -q "$ORIGIN" >/dev/null 2>&1 || \
	  die "Could not fetch from $ORIGIN."
	echo "Executing Git command 'git remote prune origin'"
	git_do remote prune origin >/dev/null 2>&1
	require_branch_absent "$ORIGIN/$BRANCH"

	# create remote branch
	echo "Executing Git command 'git push $ORIGIN $BRANCH:refs/heads/$BRANCH'"
	git_do push "$ORIGIN" "$BRANCH:refs/heads/$BRANCH" >/dev/null 2>&1
	echo "Executing Git command 'git fetch -q $ORIGIN'"
	git_do fetch -q "$ORIGIN" >/dev/null 2>&1 || \
	  die "Could not fetch from $ORIGIN."

	# temporarily changing to root directory of git repository
	echo "Changing to root directory of Git repository"
	cd "$(git rev-parse --show-cdup)"

	# configure remote tracking
	echo "Executing Git command 'git config branch.$BRANCH.remote $ORIGIN'"
	git_do config "branch.$BRANCH.remote" "$ORIGIN" >/dev/null 2>&1
	echo "Executing Git command 'git config branch.$BRANCH.merge refs/heads/$BRANCH'"
	git_do config "branch.$BRANCH.merge" "refs/heads/$BRANCH" >/dev/null 2>&1
	echo "Executing Git command 'git checkout $BRANCH'"
	git_do checkout "$BRANCH" >/dev/null 2>&1

	# return to previous working directory if available
	if assert_dir_existence_and_access "$OLDPWD" >/dev/null 2>&1; then
		echo "Returning to previous working directory"
		cd "$OLDPWD"
	else
		echo "Previous working directory no longer available, staying in root directory of Git repository"
	fi

	echo
	echo "Summary of actions:"
	echo "- A new remote branch '$BRANCH' was created"
	echo "- The local branch '$BRANCH' was configured to track the remote branch"
	echo "- The old remote branch '$BRANCH' has to be deleted manually"
	echo "- You are now on branch '$BRANCH'"
	echo
}

cmd_track() {
	parse_args "$@"
	require_name_arg

	# sanity checks
	require_clean_working_tree
	require_branch_absent "$BRANCH"
	echo "Executing Git command 'git fetch -q $ORIGIN'"
	git_do fetch -q "$ORIGIN" >/dev/null 2>&1 || \
	  die "Could not fetch from $ORIGIN."
	echo "Executing Git command 'git remote prune origin'"
	git_do remote prune origin >/dev/null 2>&1
	require_branch "$ORIGIN/$BRANCH"

	# temporarily changing to root directory of git repository
	echo "Changing to root directory of Git repository"
	cd "$(git rev-parse --show-cdup)"

	# create tracking branch
	echo "Executing Git command 'git checkout -b $BRANCH $ORIGIN/$BRANCH'"
	git_do checkout -b "$BRANCH" "$ORIGIN/$BRANCH" >/dev/null 2>&1

	# return to previous working directory if available
	if assert_dir_existence_and_access "$OLDPWD" >/dev/null 2>&1; then
		echo "Returning to previous working directory"
		cd "$OLDPWD"
	else
		echo "Previous working directory no longer available, staying in root directory of Git repository"
	fi

	echo
	echo "Summary of actions:"
	echo "- A new local tracking branch '$BRANCH' was created"
	echo "- You are now on branch '$BRANCH'"
	echo
}

cmd_diff() {
	parse_args "$@"

	if [ "$NAME" != "" ]; then
		expand_nameprefix_arg
		BASE=$(git merge-base "$DEVELOP_BRANCH" "$BRANCH")
		git diff "$BASE..$BRANCH"
	else
		if ! git_current_branch | grep -q "^$PREFIX"; then
			die "Not on a feature branch. Name one explicitly."
		fi

		BASE=$(git merge-base "$DEVELOP_BRANCH" HEAD)
		git diff "$BASE"
	fi
}

cmd_checkout() {
	parse_args "$@"

	if [ "$NAME" != "" ]; then
		expand_nameprefix_arg
		
		# temporarily changing to root directory of git repository
		echo "Changing to root directory of Git repository"
		cd "$(git rev-parse --show-cdup)"

		echo "Executing Git command 'git checkout $BRANCH'"
		git_do checkout "$BRANCH"

		# return to previous working directory if available
		if assert_dir_existence_and_access "$OLDPWD" >/dev/null 2>&1; then
			echo "Returning to previous working directory"
			cd "$OLDPWD"
		else
			echo "Previous working directory no longer available, staying in root directory of Git repository"
		fi
	else
		die "Name a feature branch explicitly."
	fi
}

cmd_co() {
	# Alias for checkout
	cmd_checkout "$@"
}

cmd_rebase() {
	DEFINE_boolean interactive false 'do an interactive rebase' i
	parse_args "$@"
	expand_nameprefix_arg_or_current
	warn "Will try to rebase '$NAME'..."
	require_clean_working_tree
	echo "Executing Git command 'git fetch -q $ORIGIN'"
	git_do fetch -q "$ORIGIN"  >/dev/null 2>&1 || \
	  die "Could not fetch from $ORIGIN."
	require_branch "$BRANCH"

	# temporarily changing to root directory of git repository
	echo "Changing to root directory of Git repository"
	cd "$(git rev-parse --show-cdup)"

	echo "Executing Git command 'git checkout -q $BRANCH'"
	git_do checkout -q "$BRANCH"
	local OPTS=
	if flag interactive; then
		OPTS="$OPTS -i"
	fi
	echo "Executing Git command 'git rebase $OPTS $DEVELOP_BRANCH'"
	git_do rebase $OPTS "$DEVELOP_BRANCH"

	# return to previous working directory if available
	if assert_dir_existence_and_access "$OLDPWD" >/dev/null 2>&1; then
		echo "Returning to previous working directory"
		cd "$OLDPWD"
	else
		echo "Previous working directory no longer available, staying in root directory of Git repository"
	fi
}

avoid_accidental_cross_branch_action() {
	local current_branch=$(git_current_branch)
	if [ "$BRANCH" != "$current_branch" ]; then
		warn "Trying to pull from '$BRANCH' while currently on branch '$current_branch'."
		warn "To avoid unintended merges, ITM Gitflow aborted."
		return 1
	fi
	return 0
}

cmd_pull() {
	#DEFINE_string prefix false 'alternative remote feature branch name prefix' p
	DEFINE_boolean rebase false "pull with rebase" r
	parse_remote_name "$@"

	if [ -z "$REMOTE" ]; then
		die "Name a remote explicitly."
	fi
	name_or_current

	# To avoid accidentally merging different feature branches into each other,
	# die if the current feature branch differs from the requested $NAME
	# argument.
	local current_branch=$(git_current_branch)
	if startswith "$current_branch" "$PREFIX"; then
		# we are on a local feature branch already, so $BRANCH must be equal to
		# the current branch
		avoid_accidental_cross_branch_action || die
	fi

	require_clean_working_tree

	if git_branch_exists "$BRANCH"; then
		# Again, avoid accidental merges
		avoid_accidental_cross_branch_action || die

		# we already have a local branch called like this, so simply pull the
		# remote changes in
		if flag rebase; then
			echo "Executing Git command 'git pull --rebase -q $REMOTE $BRANCH'"
			if ! git_do pull --rebase -q "$REMOTE" "$BRANCH"; then
				warn "Pull was aborted. There might be conflicts during rebase or '$REMOTE' might be inaccessible."
				exit 1
			fi
		else
			echo "Executing Git command 'git pull -q $REMOTE $BRANCH'"
			git_do pull -q "$REMOTE" "$BRANCH" || die "Failed to pull from remote '$REMOTE'."
		fi

		echo "Pulled $REMOTE's changes into $BRANCH."
	else
		# set up the local branch clone for the first time
		echo "Executing Git command 'git fetch -q $REMOTE $BRANCH'"
		git_do fetch -q "$REMOTE" "$BRANCH" || die "Fetch failed."     # stores in FETCH_HEAD
		echo "Executing Git command 'git branch --no-track $BRANCH FETCH_HEAD'"
		git_do branch --no-track "$BRANCH" FETCH_HEAD || die "Branch failed."

		# temporarily changing to root directory of git repository
		echo "Changing to root directory of Git repository"
		cd "$(git rev-parse --show-cdup)"

		echo "Executing Git command 'git checkout -q $BRANCH'"
		git_do checkout -q "$BRANCH" || die "Checking out new local branch failed."
		echo "Created local branch $BRANCH based on $REMOTE's $BRANCH."

		# return to previous working directory if available
		if assert_dir_existence_and_access "$OLDPWD" >/dev/null 2>&1; then
			echo "Returning to previous working directory"
			cd "$OLDPWD"
		else
			echo "Previous working directory no longer available, staying in root directory of Git repository"
		fi
	fi
}

cmd_update() {
	parse_args "$@"
	require_name_arg

	# sanity checks
	require_clean_working_tree
	if [ "$2" = "" ]; then
		base="$DEVELOP_BRANCH"
	else
		base="$2"
	fi

	# temporarily changing to root directory of git repository
	echo "Changing to root directory of Git repository"
	cd "$(git rev-parse --show-cdup)"

	echo "Executing Git command 'git checkout $base'"
	git_do checkout "$base" >/dev/null 2>&1 || \
	  die "Could not check out $base."
	echo "Executing Git command 'git remote prune origin'"
	git_do remote prune origin >/dev/null 2>&1
	echo "Executing Git command 'git fetch -q $ORIGIN $base:refs/remotes/$ORIGIN/$base'"
	git_do fetch -q "$ORIGIN" "$base":refs/remotes/"$ORIGIN"/"$base" >/dev/null 2>&1 || \
	  die "Could not fetch $base from $ORIGIN."
	echo "Executing Git command 'git merge --no-commit $ORIGIN/$base'"
	git_do merge --no-commit "$ORIGIN/$base" >/dev/null 2>&1  || {
	  echo "*******************************************************************************"
	  # return to previous working directory if available
	  if assert_dir_existence_and_access "$OLDPWD" >/dev/null 2>&1; then
	  	echo "Returning to previous working directory"
	  	cd "$OLDPWD"
	  else
	  	echo "Previous working directory no longer available, staying in root directory of Git repository"
	  fi
	  die "WARNING: There were merge conflicts on $base. Resolve them using git mergetool."
	}
	echo "Executing Git command 'git push origin $base'"
	git_do push origin "$base" >/dev/null 2>&1 || \
	  die "Could not push to $base from $ORIGIN."
	require_branches_equal "$base" "$ORIGIN/$base"
	echo "Executing Git command 'git checkout $BRANCH'"
	git_do checkout "$BRANCH" >/dev/null 2>&1 || \
	  die "Could not check out $BRANCH."
	echo "Executing Git command 'git fetch -q $ORIGIN $BRANCH:refs/remotes/$ORIGIN/$BRANCH'"
	git_do fetch -q "$ORIGIN" "$BRANCH":refs/remotes/"$ORIGIN"/"$BRANCH" >/dev/null 2>&1 || \
	  die "Could not fetch $BRANCH from $ORIGIN."
	echo "Executing Git command 'git merge --no-commit $ORIGIN/$BRANCH'"
	git_do merge --no-commit "$ORIGIN/$BRANCH" >/dev/null 2>&1  || {
	  echo "*********************************************************************************"
	  # return to previous working directory if available
	  if assert_dir_existence_and_access "$OLDPWD" >/dev/null 2>&1; then
	  	echo "Returning to previous working directory"
	  	cd "$OLDPWD"
	  else
	  	echo "Previous working directory no longer available, staying in root directory of Git repository"
	  fi
	  die "WARNING: There were merge conflicts on $BRANCH. Resolve them using git mergetool."
	}
	require_branches_equal "$BRANCH" "$ORIGIN/$BRANCH"
	if ! git_is_branch_merged_into "$BRANCH" "$base"; then
		echo "Executing Git command 'git merge --no-ff $base'"
		git_do merge --no-ff "$base" >/dev/null 2>&1 || {
		  echo "*********************************************************************************"
		  # return to previous working directory if available
		  if assert_dir_existence_and_access "$OLDPWD" >/dev/null 2>&1; then
		  	echo "Returning to previous working directory"
		  	cd "$OLDPWD"
		  else
		  	echo "Previous working directory no longer available, staying in root directory of Git repository"
		  fi
		  die "WARNING: There were merge conflicts on $BRANCH. Resolve them using git mergetool."
		}
		  # TODO: What do we do now?
		echo "Executing Git command 'git push origin $BRANCH'"
		git_do push origin "$BRANCH" >/dev/null 2>&1 || \
		  die "Could not push to $BRANCH from $ORIGIN."
	fi

	# return to previous working directory if available
	if assert_dir_existence_and_access "$OLDPWD" >/dev/null 2>&1; then
		echo "Returning to previous working directory"
		cd "$OLDPWD"
	else
		echo "Previous working directory no longer available, staying in root directory of Git repository"
	fi

	echo
	echo "Summary of actions:"
	echo "- The latest version of branch '$base' was merged into '$BRANCH'"
	echo "- You are now on branch '$BRANCH'"
	echo
}