Public Git Hosting - git/mingw.git/blob

1 #!/bin/bash

3 # git-subtree.sh: split/join git repositories in subdirectories of this one

if [ $# -eq 0 ]; then

8 set -- -h

9 fi

10 OPTS_SPEC="\

11 git subtree add --prefix=<prefix> <commit>

12 git subtree split [options...] --prefix=<prefix> <commit...>

13 git subtree merge --prefix=<prefix> <commit>

14 git subtree pull --prefix=<prefix> <repository> <refspec...>

15 --

16 h,help show the help

17 q quiet

18 d show debug messages

19 prefix= the name of the subdir to split out

20 options for 'split'

21 annotate= add a prefix to commit message of new commits

22 b,branch= create a new branch from the split subtree

23 ignore-joins ignore prior --rejoin commits

24 onto= try connecting new tree to an existing one

25 rejoin merge the new branch back into HEAD

26 "

eval $(echo "$OPTS_SPEC" | git rev-parse --parseopt -- "$@" || echo exit $?)

28 . git-sh-setup

29 require_work_tree

31 quiet=

32 branch=

33 debug=

34 command=

35 onto=

36 rejoin=

37 ignore_joins=

38 annotate=

40 debug()

41 {

        if [ -n "$debug" ]; then

43 echo "$@" >&2

44 fi

45 }

47 say()

48 {

        if [ -z "$quiet" ]; then

50 echo "$@" >&2

51 fi

52 }

54 assert()

55 {

56 if "$@"; then

57 :

58 else

59 die "assertion failed: " "$@"

60 fi

61 }

64 #echo "Options: $*"

while [ $# -gt 0 ]; do

67 opt="$1"

68 shift

        case "$opt" in

                -q) quiet=1 ;;

                -d) debug=1 ;;

                --annotate) annotate="$1"; shift ;;

73 --no-annotate) annotate= ;;

                -b) branch="$1"; shift ;;

                --prefix) prefix="$1"; shift ;;

76 --no-prefix) prefix= ;;

                --onto) onto="$1"; shift ;;

78 --no-onto) onto= ;;

                --rejoin) rejoin=1 ;;

80 --no-rejoin) rejoin= ;;

                --ignore-joins) ignore_joins=1 ;;

82 --no-ignore-joins) ignore_joins= ;;

83 --) break ;;

                *) die "Unexpected option: $opt" ;;

85 esac

86 done

command="$1"

89 shift

case "$command" in

91 add|merge|pull) default= ;;

        split) default="--default HEAD" ;;

        *) die "Unknown command '$command'" ;;

94 esac

if [ -z "$prefix" ]; then

97 die "You must provide the --prefix option."

98 fi

99 dir="$prefix"

100

if [ "$command" != "pull" ]; then

        revs=$(git rev-parse $default --revs-only "$@") || exit $?

        dirs="$(git rev-parse --no-revs --no-flags "$@")" || exit $?

        if [ -n "$dirs" ]; then

105 die "Error: Use --prefix instead of bare filenames."

106 fi

107 fi

108

109 debug "command: {$command}"

110 debug "quiet: {$quiet}"

111 debug "revs: {$revs}"

112 debug "dir: {$dir}"

113 debug "opts: {$*}"

114 debug

115

116 cache_setup()

117 {

118 cachedir="$GIT_DIR/subtree-cache/$$"

        rm -rf "$cachedir" || die "Can't delete old cachedir: $cachedir"

        mkdir -p "$cachedir" || die "Can't create new cachedir: $cachedir"

        debug "Using cachedir: $cachedir" >&2

122 }

123

124 cache_get()

125 {

126 for oldrev in $*; do

                if [ -r "$cachedir/$oldrev" ]; then

                        read newrev <"$cachedir/$oldrev"

129 echo $newrev

130 fi

131 done

132 }

133

134 cache_set()

135 {

136 oldrev="$1"

137 newrev="$2"

        if [ "$oldrev" != "latest_old" \

             -a "$oldrev" != "latest_new" \

             -a -e "$cachedir/$oldrev" ]; then

141 die "cache for $oldrev already exists!"

142 fi

        echo "$newrev" >"$cachedir/$oldrev"

144 }

145

146 rev_exists()

147 {

        if git rev-parse "$1" >/dev/null 2>&1; then

149 return 0

150 else

151 return 1

152 fi

153 }

154

155 # if a commit doesn't have a parent, this might not work. But we only want

156 # to remove the parent from the rev-list, and since it doesn't exist, it won't

157 # be there anyway, so do nothing in that case.

158 try_remove_previous()

159 {

        if rev_exists "$1^"; then

161 echo "^$1^"

162 fi

163 }

164

165 find_existing_splits()

166 {

167 debug "Looking for prior splits..."

168 dir="$1"

169 revs="$2"

        git log --grep="^git-subtree-dir: $dir\$" \

                --pretty=format:'%s%n%n%b%nEND' $revs |

172 while read a b junk; do

                case "$a" in

                        git-subtree-mainline:) main="$b" ;;

                        git-subtree-split:) sub="$b" ;;

176 *)

                                if [ -n "$main" -a -n "$sub" ]; then

                                        debug "  Prior: $main -> $sub"

179 cache_set $main $sub

180 try_remove_previous "$main"

181 try_remove_previous "$sub"

182 main=

183 sub=

184 fi

185 ;;

186 esac

187 done

188 }

189

190 copy_commit()

191 {

192 # We're going to set some environment vars here, so

193 # do it in a subshell to get rid of them safely later

        debug copy_commit "{$1}" "{$2}" "{$3}"

        git log -1 --pretty=format:'%an%n%ae%n%ad%n%cn%n%ce%n%cd%n%s%n%n%b' "$1" |

196 (

197 read GIT_AUTHOR_NAME

198 read GIT_AUTHOR_EMAIL

199 read GIT_AUTHOR_DATE

200 read GIT_COMMITTER_NAME

201 read GIT_COMMITTER_EMAIL

202 read GIT_COMMITTER_DATE

203 export GIT_AUTHOR_NAME \

204 GIT_AUTHOR_EMAIL \

205 GIT_AUTHOR_DATE \

206 GIT_COMMITTER_NAME \

207 GIT_COMMITTER_EMAIL \

208 GIT_COMMITTER_DATE

                (echo -n "$annotate"; cat ) |

                git commit-tree "$2" $3  # reads the rest of stdin

211 ) || die "Can't copy commit $1"

212 }

213

214 add_msg()

215 {

216 dir="$1"

217 latest_old="$2"

218 latest_new="$3"

219 cat <<-EOF

                Add '$dir/' from commit '$latest_new'

221

222 git-subtree-dir: $dir

223 git-subtree-mainline: $latest_old

224 git-subtree-split: $latest_new

225 EOF

226 }

227

228 merge_msg()

229 {

230 dir="$1"

231 latest_old="$2"

232 latest_new="$3"

233 cat <<-EOF

                Split '$dir/' into commit '$latest_new'

235

236 git-subtree-dir: $dir

237 git-subtree-mainline: $latest_old

238 git-subtree-split: $latest_new

239 EOF

240 }

241

242 toptree_for_commit()

243 {

244 commit="$1"

        git log -1 --pretty=format:'%T' "$commit" -- || exit $?

246 }

247

248 subtree_for_commit()

249 {

250 commit="$1"

251 dir="$2"

        git ls-tree "$commit" -- "$dir" |

        while read mode type tree name; do

                assert [ "$name" = "$dir" ]

255 echo $tree

256 break

257 done

258 }

259

260 tree_changed()

261 {

262 tree=$1

263 shift

        if [ $# -ne 1 ]; then

265 return 0 # weird parents, consider it changed

266 else

267 ptree=$(toptree_for_commit $1)

                if [ "$ptree" != "$tree" ]; then

269 return 0 # changed

270 else

271 return 1 # not changed

272 fi

273 fi

274 }

275

276 copy_or_skip()

277 {

        rev="$1"

279 tree="$2"

280 newparents="$3"

        assert [ -n "$tree" ]

282

283 identical=

284 nonidentical=

285 p=

286 gotparents=

        for parent in $newparents; do

                ptree=$(toptree_for_commit $parent) || exit $?

                [ -z "$ptree" ] && continue

                if [ "$ptree" = "$tree" ]; then

291 # an identical parent could be used in place of this rev.

292 identical="$parent"

293 else

294 nonidentical="$parent"

295 fi

296

297 # sometimes both old parents map to the same newparent;

298 # eliminate duplicates

299 is_new=1

                for gp in $gotparents; do

                        if [ "$gp" = "$parent" ]; then

302 is_new=

303 break

304 fi

305 done

                if [ -n "$is_new" ]; then

                        gotparents="$gotparents $parent"

                        p="$p -p $parent"

309 fi

310 done

311

        if [ -n "$identical" ]; then

313 echo $identical

314 else

                copy_commit $rev $tree "$p" || exit $?

316 fi

317 }

318

319 ensure_clean()

320 {

        if ! git diff-index HEAD --exit-code --quiet; then

322 die "Working tree has modifications. Cannot add."

323 fi

        if ! git diff-index --cached HEAD --exit-code --quiet; then

325 die "Index has modifications. Cannot add."

326 fi

327 }

328

329 cmd_add()

330 {

        if [ -e "$dir" ]; then

332 die "'$dir' already exists. Cannot add."

333 fi

334 ensure_clean

335

336 set -- $revs

        if [ $# -ne 1 ]; then

338 die "You must provide exactly one revision. Got: '$revs'"

339 fi

        rev="$1"

341

        debug "Adding $dir as '$rev'..."

        git read-tree --prefix="$dir" $rev || exit $?

344 git checkout "$dir" || exit $?

345 tree=$(git write-tree) || exit $?

346

347 headrev=$(git rev-parse HEAD) || exit $?

        if [ -n "$headrev" -a "$headrev" != "$rev" ]; then

349 headp="-p $headrev"

350 else

351 headp=

352 fi

        commit=$(add_msg "$dir" "$headrev" "$rev" |

                 git commit-tree $tree $headp -p "$rev") || exit $?

        git reset "$commit" || exit $?

356 }

357

358 cmd_split()

359 {

        if [ -n "$branch" ] && rev_exists "refs/heads/$branch"; then

361 die "Branch '$branch' already exists."

362 fi

363

364 debug "Splitting $dir..."

365 cache_setup || exit $?

366

        if [ -n "$onto" ]; then

368 debug "Reading history for --onto=$onto..."

369 git rev-list $onto |

                while read rev; do

371 # the 'onto' history is already just the subdir, so

372 # any parent we find there can be used verbatim

373 debug " cache: $rev"

374 cache_set $rev $rev

375 done

376 fi

377

        if [ -n "$ignore_joins" ]; then

379 unrevs=

380 else

                unrevs="$(find_existing_splits "$dir" "$revs")"

382 fi

383

384 # We can't restrict rev-list to only $dir here, because some of our

385 # parents have the $dir contents the root, and those won't match.

386 # (and rev-list --follow doesn't seem to solve this)

        grl='git rev-list --reverse --parents $revs $unrevs'

        revmax=$(eval "$grl" | wc -l)

389 revcount=0

390 createcount=0

391 eval "$grl" |

        while read rev parents; do

                revcount=$(($revcount + 1))

                say -n "$revcount/$revmax ($createcount)
"

395 debug "Processing commit: $rev"

396 exists=$(cache_get $rev)

                if [ -n "$exists" ]; then

398 debug " prior: $exists"

399 continue

400 fi

                createcount=$(($createcount + 1))

402 debug " parents: $parents"

403 newparents=$(cache_get $parents)

404 debug " newparents: $newparents"

405

                tree=$(subtree_for_commit $rev "$dir")

407 debug " tree is: $tree"

                [ -z $tree ] && continue

409

                newrev=$(copy_or_skip "$rev" "$tree" "$newparents") || exit $?

411 debug " newrev is: $newrev"

412 cache_set $rev $newrev

413 cache_set latest_new $newrev

414 cache_set latest_old $rev

415 done || exit $?

416 latest_new=$(cache_get latest_new)

        if [ -z "$latest_new" ]; then

418 die "No new revisions were found"

419 fi

420

        if [ -n "$rejoin" ]; then

422 debug "Merging split branch into HEAD..."

423 latest_old=$(cache_get latest_old)

424 git merge -s ours \

                        -m "$(merge_msg $dir $latest_old $latest_new)" \

426 $latest_new >&2 || exit $?

427 fi

        if [ -n "$branch" ]; then

                git update-ref -m 'subtree split' "refs/heads/$branch" \

430 $latest_new "" || exit $?

431 say "Created branch '$branch'"

432 fi

433 echo $latest_new

434 exit 0

435 }

436

437 cmd_merge()

438 {

439 ensure_clean

440

441 set -- $revs

        if [ $# -ne 1 ]; then

443 die "You must provide exactly one revision. Got: '$revs'"

444 fi

        rev="$1"

446

447 git merge -s subtree $rev

448 }

449

450 cmd_pull()

451 {

452 ensure_clean

453 set -x

454 git pull -s subtree "$@"

455 }

456

457 "cmd_$command" "$@"