git-bpf-feature

#!/bin/sh
#
# git-bpt -- A collection of Git extensions to provide high-level
# repository operations for Git Branch Per Feature (BPF) workflow.
#
# This project is an implementation of the Git BPF workflow
# described by Adam Dymitruk:
# 	http://dymitruk.com/blog/2012/02/05/branch-per-feature/
# And its source code is wildly inspired by gitflow tools source code:
#    https://github.com/nvie/gitflow
# 
# Feel free to contribute to this project at:
#    https://github.com/cdue/gitbpf
#
# Copyright (c) 2015 Cédric Dué
#
# Permission is hereby granted, free of charge, to any person obtaining a copy
# of this software and associated documentation files (the "Software"), to deal
# in the Software without restriction, including without limitation the rights
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
# copies of the Software, and to permit persons to whom the Software is
# furnished to do so, subject to the following conditions:
# 
# The above copyright notice and this permission notice shall be included in all
# copies or substantial portions of the Software.
# 
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
# SOFTWARE
#

init() {
  require_git_repo
  require_gitbpf_initialized
  gitbpf_load_settings
  PREFIX=$(git config --get gitbpf.prefix.feature)
}

usage() {
	echo "usage: git bpf feature [list] [-v]"
	echo "       git bpf feature start [-F] <name> [<base>]"
	echo "       git bpf feature finish [-rFkDS] [<name|nameprefix>]"
	echo "       git bpf feature publish <name>"
	echo "       git bpf feature integrate <name>"
	# echo "       git bpf feature track <name>"
	# echo "       git bpf feature diff [<name|nameprefix>]"
	echo "       git bpf feature rebase [-i] [<name|nameprefix>]"
	echo "       git bpf feature checkout [<name|nameprefix>]"
	echo "       git bpf feature pull [-r] <remote> [<name>]"
}

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")
	if [ -z "$feature_branches" ]; then
		warn "No feature branches exist."
		warn ""
		warn "You can start a new feature branch:"
		warn ""
		warn "    git bpf 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
	width=$(($width+3))

	local branch
	for branch in $short_names; do
		local fullname=$PREFIX$branch
		local base=$(git merge-base "$fullname" "$MASTER_BRANCH")
		local develop_sha=$(git rev-parse "$MASTER_BRANCH")
		local branch_sha=$(git rev-parse "$fullname")
		if [ "$fullname" = "$current_branch" ]; then
			printf "* "
		else
			printf "  "
		fi
		if flag verbose; then
			printf "%-${width}s" "$branch"
			if [ "$branch_sha" = "$master_sha" ]; then
				printf "(no commits yet)"
			elif [ "$base" = "$branch_sha" ]; then
				printf "(is behind master, may ff)"
			elif [ "$base" = "$develop_sha" ]; then
				printf "(based on latest master)"
			else
				printf "(may be rebased)"
			fi
		else
			printf "%s" "$branch"
		fi
		echo
	done
}

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=$(gitbpf_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}"

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

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

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

cmd_start() {
	#DEFINE_boolean fetch false 'fetch from origin before performing local operation' F
	parse_args "$@"
	BASE=${2:-$MASTER_BRANCH}
	require_name_arg

	# sanity checks
	require_branch_absent "$BRANCH"

	# update the local repo with remote changes, if asked
	# if flag fetch; then
	#	git_do fetch -q "$ORIGIN" "$MASTER_BRANCH"
	# fi

	# With BPF, we always need to fetch tags before starting a new feature
	local remote_url=$(git_remote_url)

	if [ ! -z $remote_url ]; then
		git_do fetch -q --all --tags
	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/$MASTER_BRANCH"; then
	#	require_branches_equal "$MASTER_BRANCH" "$ORIGIN/$MASTER_BRANCH"
	#fi
	# Never mind if local master isn't equal to remote because we are creating the feature branch from origin

	# create branch
	if [ ! -z $remote_url ]; then
		local branch_origin="$ORIGIN/$BASE"
	fi
	if ! git_do checkout -b "$BRANCH" $branch_origin; then
		die "Could not create feature branch '$BRANCH'"
	fi

	echo
	echo "Summary of actions:"
	echo "- A new branch '$BRANCH' was created, based on '$BASE'"
	echo "- You are now on branch '$BRANCH'"
	echo ""
	echo "Now, start committing on your feature, and share your code using:"
	echo "> git bpf feature publish $NAME"
	echo ""
	echo "Don't forget to integrate your code from time to time (every 2-3 commits) using:"
	echo "> git bpf feature integrate $NAME"
	echo "This will allow you to resolve and automatically share integration conflicts resolutions."
	echo "/!\ this is very important!"
	echo
}

cmd_finish() {
	echo "TODO: merge on QA..."
	die

	DEFINE_boolean fetch false "fetch from $ORIGIN before performing finish" F
	DEFINE_boolean rebase false "rebase instead of merge" 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 "$@"
	expand_nameprefix_arg_or_current

	# sanity checks
	require_branch "$BRANCH"

	# detect if we're restoring from a merge conflict
	if [ -f "$DOT_GIT_DIR/.gitbpf/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/.gitbpf/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/.gitbpf/MERGE_BASE"
				helper_finish_cleanup
				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/.gitbpf/MERGE_BASE"
			fi
		else
			echo
			echo "Merge conflicts not resolved yet, use:"
			echo "    git mergetool"
			echo "    git commit"
			echo 
			echo "You can then complete the finish by running it again:"
			echo "    git bpf feature finish $NAME"
			echo
			exit 1
		fi
	fi

	# sanity checks
	require_clean_working_tree

	# update local repo with remote changes first, if asked
	if has "$ORIGIN/$BRANCH" $(git_remote_branches); then
		if flag fetch; then
			git_do fetch -q "$ORIGIN" "$BRANCH"
			git_do fetch -q "$ORIGIN" "$DEVELOP_BRANCH"
		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 bpf feature rebase "$NAME" "$DEVELOP_BRANCH"; then
			warn "Finish was aborted due to conflicts during rebase."
			warn "Please finish the rebase manually now."
			warn "When finished, re-run:"
			warn "    git bpf feature finish '$NAME' '$DEVELOP_BRANCH'"
			exit 1
		fi
	fi

	# merge into BASE
	git_do checkout "$DEVELOP_BRANCH"
	if [ "$(git rev-list -n2 "$DEVELOP_BRANCH..$BRANCH" | wc -l)" -eq 1 ]; then
		git_do merge --ff "$BRANCH"
	else
		if noflag squash; then
		    git_do merge --no-ff "$BRANCH"
		else
			git_do merge --squash "$BRANCH"
			git_do commit
			git_do merge "$BRANCH"
		fi
	fi

	if [ $? -ne 0 ]; then
		# oops.. we have a merge conflict!
		# write the given $DEVELOP_BRANCH to a temporary file (we need it later)
		mkdir -p "$DOT_GIT_DIR/.gitbpf"
		echo "$DEVELOP_BRANCH" > "$DOT_GIT_DIR/.gitbpf/MERGE_BASE"
		echo
		echo "There were merge conflicts. To resolve the merge conflict manually, use:"
		echo "    git mergetool"
		echo "    git commit"
		echo 
		echo "You can then complete the finish by running it again:"
		echo "    git bpf feature finish $NAME"
		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

	# delete branch
	if flag fetch; then
		git_do push "$ORIGIN" ":refs/heads/$BRANCH"
	fi
	
	
	if noflag keep; then
		if flag force_delete; then
			git_do branch -D "$BRANCH"
		else
			git_do branch -d "$BRANCH"
		fi
	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' is still available"
	else
		echo "- Feature branch '$BRANCH' has been removed"
	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"
	git_do fetch -q "$ORIGIN"
	# require_branch_absent "$ORIGIN/$BRANCH"
	local remote_branch_exists=0
	if git_remote_branch_exists "$ORIGIN/$BRANCH"; then
		$remote_branch_exists=1
	fi

	# create remote branch
	git_do push "$ORIGIN" "$BRANCH:refs/heads/$BRANCH"
	git_do fetch -q "$ORIGIN"

	# configure remote tracking if remote was just created
	if [ $remote_branch_exists -eq 0 ]; then
		git_do config "branch.$BRANCH.remote" "$ORIGIN"
		git_do config "branch.$BRANCH.merge" "refs/heads/$BRANCH"
	fi

	git_do checkout "$BRANCH"

	echo
	echo "Summary of actions:"
	if [ $remote_branch_exists -eq 0 ]; then
		echo "- A new remote branch '$BRANCH' was created"
		echo "- The local branch '$BRANCH' was configured to track the remote branch"
	fi
	echo "- Your code has been pushed to '$ORIGIN/$BRANCH'"
	echo
}

# cmd_track() {
# 	parse_args "$@"
# 	require_name_arg
# 
# 	# sanity checks
# 	require_clean_working_tree
# 	require_branch_absent "$BRANCH"
# 	git_do fetch -q "$ORIGIN"
# 	require_branch "$ORIGIN/$BRANCH"
# 
# 	# create tracking branch
# 	git_do checkout -b "$BRANCH" "$ORIGIN/$BRANCH"
# 
# 	echo
# 	echo "Summary of actions:"
# 	echo "- A new remote 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
		git_do checkout "$BRANCH"
	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
	require_branch "$BRANCH"

	git_do checkout -q "$BRANCH"
	local OPTS=
	if flag interactive; then
		OPTS="$OPTS -i"
	fi
	git_do rebase $OPTS "$MASTER_BRANCH"
}

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, git-bpf 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
			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
			git_do pull -q "$REMOTE" "$BRANCH" || die "Failed to pull from remote '$REMOTE'."
		fi

		echo "Pulled $REMOTE's changes into $BRANCH."
	else
		# setup the local branch clone for the first time
		git_do fetch -q "$REMOTE" "$BRANCH" || die "Fetch failed."     # stores in FETCH_HEAD
		git_do branch --no-track "$BRANCH" FETCH_HEAD || die "Branch failed."
		git_do checkout -q "$BRANCH" || die "Checking out new local branch failed."
		echo "Created local branch $BRANCH based on $REMOTE's $BRANCH."
	fi
}

cmd_integrate() {
	echo "TODO: "
	echo "git checkout develop"
	echo "git merge $BRANCH [--no-edit]"
	echo "(resolve conflits if any)"
	echo "git push $ORIGIN $BRANCH"
	echo "git checkout $BRANCH"
}