guilt

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