guilt

   1 #!/bin/bash
   2 #
   3 # Copyright (c) Josef "Jeff" Sipek, 2006, 2007
   4 #
   5
   6 GUILT_VERSION="0.19-rc1"
   7 GUILT_NAME="Two Step"
   8
   9 if [ `basename $0` = "guilt" ]; then
  10         # being run as standalone
  11
  12         # by default, we shouldn't fail
  13         fail=0
  14
  15         if [ $# -ne 0 ]; then
  16                 # take first arg, and try to execute it
  17
  18                 cmd="$1"
  19                 dir=`dirname $0`
  20
  21                 if [ ! -x "$dir/guilt-$cmd" ]; then
  22                         echo "Command $cmd not found" >&2
  23                         echo "" >&2
  24                         fail=1
  25                 else
  26                         shift
  27                         exec "$dir/guilt-$cmd" "$@"
  28
  29                         # this is not reached because of the exec
  30                         echo "Exec failed! Something is terribly wrong!" >&2
  31                         exit 1
  32                 fi
  33         fi
  34
  35         # no args passed or invalid command entered, just output help summary
  36
  37         echo "Guilt v$GUILT_VERSION"
  38         echo ""
  39         echo "Pick a command:"
  40         for x in `dirname $0`/guilt-*; do
  41                 [ -x $x ] && echo -e "\t`basename $x`"
  42         done
  43
  44         echo ""
  45         echo "Example:"
  46         echo -e "\tguilt-push"
  47         echo "or"
  48         echo -e "\tguilt push"
  49
  50         # now, let's exit
  51         exit $fail
  52 fi
  53
  54 ########
  55
  56 #
  57 # Library goodies
  58 #
  59
  60 function print_usage
  61 {
  62         echo "$USAGE" >&2
  63 }
  64
  65 function find_git_dir
  66 {
  67         local d=`git-rev-parse --git-dir`
  68
  69         if [ $? -ne 0 -o -z "$d" ]; then
  70                 echo "Not a git repository" >&2
  71                 return 1
  72         fi
  73
  74         echo "$d"
  75 }
  76
  77 function get_branch
  78 {
  79         git-symbolic-ref HEAD | sed -e 's,^refs/heads/,,'
  80 }
  81
  82 function verify_branch
  83 {
  84         local b=$branch
  85
  86         [ ! -d "$GIT_DIR/patches" ] &&
  87                 echo "Patches directory doesn't exist, try guilt-init" >&2 &&
  88                 return 1
  89         [ ! -d "$GIT_DIR/patches/$b" ] &&
  90                 echo "Branch $b is not initialized, try guilt-init" >&2 &&
  91                 return 1
  92         [ ! -f "$GIT_DIR/patches/$b/series" ] &&
  93                 echo "Branch $b does not have a series file" >&2 &&
  94                 return 1
  95         [ ! -f "$GIT_DIR/patches/$b/status" ] &&
  96                 echo "Branch $b does not have a status file" >&2 &&
  97                 return 1
  98         [ -f "$GIT_DIR/patches/$b/applied" ] &&
  99                 echo "Warning: Branch $b has 'applied' file - guilt is not compatible with stgit" >&2 &&
 100                 return 1
 101
 102         return 0
 103 }
 104
 105 function get_top
 106 {
 107         tail -1 $GUILT_DIR/$branch/status | cut -d: -f 2-
 108 }
 109
 110 function get_prev
 111 {
 112         local n=`wc -l < $GUILT_DIR/$branch/status`
 113         local n=`expr $n - 1`
 114
 115         local idx=0
 116         for p in `cat $GUILT_DIR/$branch/status`; do
 117                 idx=`expr $idx + 1`
 118                 [ $idx -lt $n ] && continue
 119                 [ $idx -gt $n ] && break
 120
 121                 echo $p
 122         done
 123 }
 124
 125 function get_series
 126 {
 127         # ignore all lines matching:
 128         #       - empty lines
 129         #       - whitespace only
 130         #       - optional whitespace followed by '#' followed by more
 131         #         optional whitespace
 132         grep -ve '^[[:space:]]*\(#.*\)*$' < $series
 133 }
 134
 135 # usage: do_get_header patchfile
 136 function do_get_header
 137 {
 138         # The complexity arises from the fact that we want to ignore the
 139         # From line and the empty line after it if it exists
 140
 141         # 2nd line skips the From line
 142         # 3rd line skips the empty line right after a From line
 143         do_get_full_header $1 | awk '
 144 BEGIN{skip=0}
 145 /^From:/{skip=1; next}
 146 /^[ \t\f\n\r\v]*$/ && (skip==1){skip=0; next}
 147 {print $0}
 148 END{}
 149 '
 150 }
 151
 152 # usage: do_get_full_header patchfile
 153 function do_get_full_header
 154 {
 155         # 2nd line checks for the begining of a patch
 156         # 3rd line outputs the line if it didn't get pruned by the above rules
 157         cat $1 | awk '
 158 BEGIN{ok=1}
 159 /^(diff|---)/{ok=0}
 160 (ok==1){print $0}
 161 END{}
 162 '
 163 }
 164
 165 # usage: assert_head_check
 166 function assert_head_check
 167 {
 168         # make sure we're not doing funky things to commits that don't
 169         # belong to us
 170         local ch=`cat $GIT_DIR/refs/heads/$branch`
 171         local eh=`tail -1 < $applied | cut -d: -f 1`
 172
 173         # if there are no patches pushed, there can be no mis-matches
 174         [ -z "$eh" ] && return 0
 175
 176         if [ "$ch" != "$eh" ]; then
 177                 echo "Expected HEAD commit $eh" >&2
 178                 echo "                 got $ch" >&2
 179                 echo "aborting..." >&2
 180                 exit 1
 181         fi
 182 }
 183
 184 # usage: pop_patch
 185 function pop_patch
 186 {
 187         pop_many_patches HEAD^ 1
 188 }
 189
 190 # usage: pop_many_patches <commitish> <number of patches>
 191 function pop_many_patches
 192 {
 193         assert_head_check
 194
 195         cd $TOP_DIR
 196
 197         git-reset --hard $1 > /dev/null
 198         head -n -$2 < $applied > $applied.tmp
 199         mv $applied{.tmp,}
 200
 201         cd - 2>&1 >/dev/null
 202 }
 203
 204 # usage: push_patch patchname
 205 function push_patch
 206 {
 207         local p="$GUILT_DIR/$branch/$1"
 208         local pname="$1"
 209
 210         local bail=0
 211
 212         assert_head_check
 213
 214         cd $TOP_DIR
 215
 216         # apply the patch if and only if there is something to apply
 217         if [ `git-apply --numstat $p | wc -l` -gt 0 ]; then
 218                 git-apply -C$guilt_push_diff_context \
 219                         --reject $p > /dev/null 2> /tmp/guilt.log.$$
 220                 bail=$?
 221
 222                 [ $bail -ne 0 ] && cat /tmp/guilt.log.$$ >&2
 223
 224                 # FIXME: Path munging is being done, we need to convince
 225                 # git-apply to just give us list of files with \0 as a
 226                 # delimiter, and pass -z to git-update-index
 227                 git-apply --numstat $p | cut -f 3- | git-update-index --add --remove --stdin
 228         fi
 229
 230         # grab a commit message out of the patch
 231         do_get_header $p > /tmp/guilt.msg.$$
 232
 233         # make a default commit message if patch doesn't contain one
 234         [ ! -s /tmp/guilt.msg.$$ ] && echo "patch $pname" > /tmp/guilt.msg.$$
 235
 236         # extract a From line from the patch header, and set
 237         # GIT_AUTHOR_{NAME,EMAIL}
 238         local author_str=`cat $p | grep -e '^From: ' | sed -e 's/^From: //'`
 239         if [ ! -z "$author_str" ]; then
 240                 local backup_author_name="$GIT_AUTHOR_NAME"
 241                 local backup_author_email="$GIT_AUTHOR_EMAIL"
 242                 GIT_AUTHOR_NAME=`echo $author_str | sed -e 's/ *<.*$//'`
 243                 GIT_AUTHOR_EMAIL=`echo $author_str | sed -e 's/[^<]*//'`
 244
 245                 if [ -z "$GIT_AUTHOR_NAME" ]; then
 246                         GIT_AUTHOR_NAME=" "
 247                 fi
 248
 249                 export GIT_AUTHOR_NAME GIT_AUTHOR_EMAIL
 250         fi
 251
 252         # commit
 253         local treeish=`git-write-tree`
 254         local commitish=`git-commit-tree $treeish -p HEAD < /tmp/guilt.msg.$$`
 255         echo $commitish > $GIT_DIR/`git-symbolic-ref HEAD`
 256
 257         # mark patch as applied
 258         echo "$commitish:$pname" >> $applied
 259
 260         # restore original GIT_AUTHOR_{NAME,EMAIL}
 261         if [ ! -z "$author_str" ]; then
 262                 if [ ! -z "$backup_author_name" ]; then
 263                         export GIT_AUTHOR_NAME="$backup_author_name"
 264                 else
 265                         unset GIT_AUTHOR_NAME
 266                 fi
 267
 268                 if [ ! -z "$backup_author_name" ]; then
 269                         export GIT_AUTHOR_EMAIL="$backup_author_email"
 270                 else
 271                         unset GIT_AUTHOR_EMAIL
 272                 fi
 273         fi
 274
 275         rm -f /tmp/guilt.msg.$$ /tmp/guilt.log.$$
 276
 277         cd - 2>&1 >/dev/null
 278
 279         return $bail
 280 }
 281
 282 # usage: must_commit_first
 283 function must_commit_first
 284 {
 285         [ `git-diff-files | wc -l` -eq 0 ]
 286         return $?
 287 }
 288
 289 # usage: refresh_patch patchname
 290 function refresh_patch
 291 {
 292         local p="$GUILT_DIR/$branch/$1"
 293
 294         assert_head_check
 295
 296         cd $TOP_DIR
 297
 298         git-diff-files --name-only | (while read n; do git-update-index $n ; done)
 299
 300         # get the patch header
 301         do_get_full_header $p > /tmp/guilt.diff.$$
 302
 303         # get the new patch
 304         git-diff HEAD^ >> /tmp/guilt.diff.$$
 305
 306         # move the new patch in
 307         mv $p $p.prev
 308         mv /tmp/guilt.diff.$$ $p
 309
 310         cd - 2>&1 >/dev/null
 311
 312         # drop the currently applied patch, pop_patch does it's own cd
 313         # $TOP_DIR
 314         pop_patch
 315
 316         # push_patch does it's own cd $TOP_DIR
 317         push_patch $1
 318 }
 319
 320 # Some constants
 321
 322 # used for: git-apply -C <val>
 323 guilt_push_diff_context=1
 324
 325 #
 326 # The following gets run every time this file is source'd
 327 #
 328
 329 GIT_DIR=`find_git_dir`
 330 [ $? -ne 0 ] && exit 1
 331
 332 TOP_DIR=`git-rev-parse --show-cdup`
 333 if [ -z "$TOP_DIR" ]; then
 334         TOP_DIR="./"
 335 fi
 336
 337 GUILT_DIR="$GIT_DIR/patches"
 338
 339 branch=`get_branch`
 340
 341 # most of the time we want to verify that the repo's branch has been
 342 # initialized, but every once in a blue moon (e.g., we want to run guilt-init),
 343 # we must avoid the checks
 344 if [ -z "$DO_NOT_CHECK_BRANCH_EXISTENCE" ]; then
 345         verify_branch || exit 1
 346 fi
 347
 348 # very useful files
 349 series="$GUILT_DIR/$branch/series"
 350 applied="$GUILT_DIR/$branch/status"
 351
 352 USAGE="Usage: `basename $0`"
 353