aboutsummaryrefslogtreecommitdiff
path: root/git-applypatch.sh
blob: 4c577eb835b877dd0766edbc5a603ee4e3db049a (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
#!/bin/sh
##
## applypatch takes four file arguments, and uses those to
## apply the unpacked patch (surprise surprise) that they
## represent to the current tree.
##
## The arguments are:
##	$1 - file with commit message
##	$2 - file with the actual patch
##	$3 - "info" file with Author, email and subject
##	$4 - optional file containing signoff to add
##
. git-sh-setup

final=.dotest/final-commit
##
## If this file exists, we ask before applying
##
query_apply=.dotest/.query_apply

## We do not munge the first line of the commit message too much
## if this file exists.
keep_subject=.dotest/.keep_subject

## We do not attempt the 3-way merge fallback unless this file exists.
fall_back_3way=.dotest/.3way

MSGFILE=$1
PATCHFILE=$2
INFO=$3
SIGNOFF=$4
EDIT=${VISUAL:-${EDITOR:-vi}}

export GIT_AUTHOR_NAME="$(sed -n '/^Author/ s/Author: //p' "$INFO")"
export GIT_AUTHOR_EMAIL="$(sed -n '/^Email/ s/Email: //p' "$INFO")"
export GIT_AUTHOR_DATE="$(sed -n '/^Date/ s/Date: //p' "$INFO")"
export SUBJECT="$(sed -n '/^Subject/ s/Subject: //p' "$INFO")"

if test '' != "$SIGNOFF"
then
	if test -f "$SIGNOFF"
	then
		SIGNOFF=`cat "$SIGNOFF"` || exit
	elif case "$SIGNOFF" in yes | true | me | please) : ;; *) false ;; esac
	then
		SIGNOFF=`git-var GIT_COMMITTER_IDENT | sed -e '
				s/>.*/>/
				s/^/Signed-off-by: /'
		`
	else
		SIGNOFF=
	fi
	if test '' != "$SIGNOFF"
	then
		LAST_SIGNED_OFF_BY=`
			sed -ne '/^Signed-off-by: /p' "$MSGFILE" |
			tail -n 1
		`
		test "$LAST_SIGNED_OFF_BY" = "$SIGNOFF" || {
		    test '' = "$LAST_SIGNED_OFF_BY" && echo
		    echo "$SIGNOFF"
		} >>"$MSGFILE"
	fi
fi

patch_header=
test -f "$keep_subject" || patch_header='[PATCH] '

{
	echo "$patch_header$SUBJECT"
	if test -s "$MSGFILE"
	then
		echo
		cat "$MSGFILE"
	fi
} >"$final"

interactive=yes
test -f "$query_apply" || interactive=no

while [ "$interactive" = yes ]; do
	echo "Commit Body is:"
	echo "--------------------------"
	cat "$final"
	echo "--------------------------"
	echo -n "Apply? [y]es/[n]o/[e]dit/[a]ccept all "
	read reply
	case "$reply" in
		y|Y) interactive=no;;
		n|N) exit 2;;	# special value to tell dotest to keep going
		e|E) "$EDIT" "$final";;
		a|A) rm -f "$query_apply"
		     interactive=no ;;
	esac
done

if test -x "$GIT_DIR"/hooks/applypatch-msg
then
	"$GIT_DIR"/hooks/applypatch-msg "$final" || exit
fi

echo
echo Applying "'$SUBJECT'"
echo

git-apply --index "$PATCHFILE" || {

	# git-apply exits with status 1 when the patch does not apply,
	# but it die()s with other failures, most notably upon corrupt
	# patch.  In the latter case, there is no point to try applying
	# it to another tree and do 3-way merge.
	test $? = 1 || exit 1

	test -f "$fall_back_3way" || exit 1

	# Here if we know which revision the patch applies to,
	# we create a temporary working tree and index, apply the
	# patch, and attempt 3-way merge with the resulting tree.

	O_OBJECT=`cd "$GIT_OBJECT_DIRECTORY" && pwd`
	rm -fr .patch-merge-*

	if git-apply -z --index-info "$PATCHFILE" \
		>.patch-merge-index-info 2>/dev/null &&
		GIT_INDEX_FILE=.patch-merge-tmp-index \
		git-update-index -z --index-info <.patch-merge-index-info &&
		GIT_INDEX_FILE=.patch-merge-tmp-index \
		git-write-tree >.patch-merge-tmp-base &&
		(
			mkdir .patch-merge-tmp-dir &&
			cd .patch-merge-tmp-dir &&
			GIT_INDEX_FILE="../.patch-merge-tmp-index" \
			GIT_OBJECT_DIRECTORY="$O_OBJECT" \
			git-apply $binary --index
		) <"$PATCHFILE"
	then
		echo Using index info to reconstruct a base tree...
		mv .patch-merge-tmp-base .patch-merge-base
		mv .patch-merge-tmp-index .patch-merge-index
	else
	(
		N=10

		# Otherwise, try nearby trees that can be used to apply the
		# patch.
		git-rev-list --max-count=$N HEAD

		# or hoping the patch is against known tags...
		git-ls-remote --tags .
	) |
	    while read base junk
	    do
		# Try it if we have it as a tree.
		git-cat-file tree "$base" >/dev/null 2>&1 || continue

		rm -fr .patch-merge-tmp-* &&
		mkdir .patch-merge-tmp-dir || break
		(
			cd .patch-merge-tmp-dir &&
			GIT_INDEX_FILE=../.patch-merge-tmp-index &&
			GIT_OBJECT_DIRECTORY="$O_OBJECT" &&
			export GIT_INDEX_FILE GIT_OBJECT_DIRECTORY &&
			git-read-tree "$base" &&
			git-apply --index &&
			mv ../.patch-merge-tmp-index ../.patch-merge-index &&
			echo "$base" >../.patch-merge-base
		) <"$PATCHFILE"  2>/dev/null && break
	    done
	fi

	test -f .patch-merge-index &&
	his_tree=$(GIT_INDEX_FILE=.patch-merge-index git-write-tree) &&
	orig_tree=$(cat .patch-merge-base) &&
	rm -fr .patch-merge-* || exit 1

	echo Falling back to patching base and 3-way merge using $orig_tree...

	# This is not so wrong.  Depending on which base we picked,
	# orig_tree may be wildly different from ours, but his_tree
	# has the same set of wildly different changes in parts the
	# patch did not touch, so resolve ends up cancelling them,
	# saying that we reverted all those changes.

	if git-merge-resolve $orig_tree -- HEAD $his_tree
	then
		echo Done.
	else
		echo Failed to merge in the changes.
		exit 1
	fi
}

if test -x "$GIT_DIR"/hooks/pre-applypatch
then
	"$GIT_DIR"/hooks/pre-applypatch || exit
fi

tree=$(git-write-tree) || exit 1
echo Wrote tree $tree
parent=$(git-rev-parse --verify HEAD) &&
commit=$(git-commit-tree $tree -p $parent <"$final") || exit 1
echo Committed: $commit
git-update-ref HEAD $commit $parent || exit

if test -x "$GIT_DIR"/hooks/post-applypatch
then
	"$GIT_DIR"/hooks/post-applypatch
fi