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 merge --prefix=<prefix> <commit>

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

14 git subtree split --prefix=<prefix> <commit...>

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 options for 'add', 'merge', and 'pull'

27 squash merge subtree changes as a single commit

28 "

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

PATH=$(git --exec-path):$PATH

31 . git-sh-setup

32 require_work_tree

34 quiet=

35 branch=

36 debug=

37 command=

38 onto=

39 rejoin=

40 ignore_joins=

41 annotate=

42 squash=

44 debug()

45 {

        if [ -n "$debug" ]; then

47 echo "$@" >&2

48 fi

49 }

51 say()

52 {

        if [ -z "$quiet" ]; then

54 echo "$@" >&2

55 fi

56 }

58 assert()

59 {

60 if "$@"; then

61 :

62 else

63 die "assertion failed: " "$@"

64 fi

65 }

68 #echo "Options: $*"

while [ $# -gt 0 ]; do

71 opt="$1"

72 shift

        case "$opt" in

                -q) quiet=1 ;;

                -d) debug=1 ;;

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

77 --no-annotate) annotate= ;;

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

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

80 --no-prefix) prefix= ;;

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

82 --no-onto) onto= ;;

                --rejoin) rejoin=1 ;;

84 --no-rejoin) rejoin= ;;

                --ignore-joins) ignore_joins=1 ;;

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

                --squash) squash=1 ;;

88 --no-squash) squash= ;;

89 --) break ;;

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

91 esac

92 done

command="$1"

95 shift

case "$command" in

97 add|merge|pull) default= ;;

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

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

100 esac

101

if [ -z "$prefix" ]; then

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

104 fi

dir="$(dirname "$prefix/.")"

106

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

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

112 fi

113 fi

114

115 debug "command: {$command}"

116 debug "quiet: {$quiet}"

117 debug "revs: {$revs}"

118 debug "dir: {$dir}"

119 debug "opts: {$*}"

120 debug

121

122 cache_setup()

123 {

124 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

128 }

129

130 cache_get()

131 {

132 for oldrev in $*; do

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

                        read newrev <"$cachedir/$oldrev"

135 echo $newrev

136 fi

137 done

138 }

139

140 cache_set()

141 {

142 oldrev="$1"

143 newrev="$2"

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

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

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

147 die "cache for $oldrev already exists!"

148 fi

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

150 }

151

152 rev_exists()

153 {

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

155 return 0

156 else

157 return 1

158 fi

159 }

160

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

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

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

164 try_remove_previous()

165 {

        if rev_exists "$1^"; then

167 echo "^$1^"

168 fi

169 }

170

171 find_latest_squash()

172 {

173 debug "Looking for latest squash ($dir)..."

174 dir="$1"

175 sq=

176 main=

177 sub=

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

179 --pretty=format:'START %H%n%s%n%n%b%nEND%n' HEAD |

180 while read a b junk; do

                debug "$a $b $junk"

                debug "{{$sq/$main/$sub}}"

                case "$a" in

                        START) sq="$b" ;;

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

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

187 END)

                                if [ -n "$sub" ]; then

                                        if [ -n "$main" ]; then

190 # a rejoin commit?

191 # Pretend its sub was a squash.

                                                sq="$sub"

193 fi

                                        debug "Squash found: $sq $sub"

                                        echo "$sq" "$sub"

196 break

197 fi

198 sq=

199 main=

200 sub=

201 ;;

202 esac

203 done

204 }

205

206 find_existing_splits()

207 {

208 debug "Looking for prior splits..."

209 dir="$1"

210 revs="$2"

211 main=

212 sub=

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

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

215 while read a b junk; do

                case "$a" in

                        START) sq="$b" ;;

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

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

220 END)

221 debug " Main is: '$main'"

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

223 # squash commits refer to a subtree

                                        debug "  Squash: $sq from $sub"

                                        cache_set "$sq" "$sub"

226 fi

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

                                        debug "  Prior: $main -> $sub"

229 cache_set $main $sub

230 try_remove_previous "$main"

231 try_remove_previous "$sub"

232 fi

233 main=

234 sub=

235 ;;

236 esac

237 done

238 }

239

240 copy_commit()

241 {

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

243 # 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" |

246 (

247 read GIT_AUTHOR_NAME

248 read GIT_AUTHOR_EMAIL

249 read GIT_AUTHOR_DATE

250 read GIT_COMMITTER_NAME

251 read GIT_COMMITTER_EMAIL

252 read GIT_COMMITTER_DATE

253 export GIT_AUTHOR_NAME \

254 GIT_AUTHOR_EMAIL \

255 GIT_AUTHOR_DATE \

256 GIT_COMMITTER_NAME \

257 GIT_COMMITTER_EMAIL \

258 GIT_COMMITTER_DATE

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

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

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

262 }

263

264 add_msg()

265 {

266 dir="$1"

267 latest_old="$2"

268 latest_new="$3"

269 cat <<-EOF

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

271

272 git-subtree-dir: $dir

273 git-subtree-mainline: $latest_old

274 git-subtree-split: $latest_new

275 EOF

276 }

277

278 rejoin_msg()

279 {

280 dir="$1"

281 latest_old="$2"

282 latest_new="$3"

283 cat <<-EOF

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

285

286 git-subtree-dir: $dir

287 git-subtree-mainline: $latest_old

288 git-subtree-split: $latest_new

289 EOF

290 }

291

292 squash_msg()

293 {

294 dir="$1"

295 oldsub="$2"

296 newsub="$3"

        newsub_short=$(git rev-parse --short "$newsub")

298

        if [ -n "$oldsub" ]; then

                oldsub_short=$(git rev-parse --short "$oldsub")

                echo "Squashed '$dir/' changes from $oldsub_short..$newsub_short"

302 echo

                git log --pretty=tformat:'%h %s' "$oldsub..$newsub"

                git log --pretty=tformat:'REVERT: %h %s' "$newsub..$oldsub"

305 else

                echo "Squashed '$dir/' content from commit $newsub_short"

307 fi

308

309 echo

310 echo "git-subtree-dir: $dir"

311 echo "git-subtree-split: $newsub"

312 }

313

314 toptree_for_commit()

315 {

316 commit="$1"

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

318 }

319

320 subtree_for_commit()

321 {

322 commit="$1"

323 dir="$2"

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

        while read mode type tree name; do

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

                assert [ "$type" = "tree" ]

328 echo $tree

329 break

330 done

331 }

332

333 tree_changed()

334 {

335 tree=$1

336 shift

        if [ $# -ne 1 ]; then

338 return 0 # weird parents, consider it changed

339 else

340 ptree=$(toptree_for_commit $1)

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

342 return 0 # changed

343 else

344 return 1 # not changed

345 fi

346 fi

347 }

348

349 new_squash_commit()

350 {

351 old="$1"

352 oldsub="$2"

353 newsub="$3"

        tree=$(toptree_for_commit $newsub) || exit $?

        if [ -n "$old" ]; then

                squash_msg "$dir" "$oldsub" "$newsub" | 

                        git commit-tree "$tree" -p "$old" || exit $?

358 else

                squash_msg "$dir" "" "$newsub" |

360 git commit-tree "$tree" || exit $?

361 fi

362 }

363

364 copy_or_skip()

365 {

        rev="$1"

367 tree="$2"

368 newparents="$3"

        assert [ -n "$tree" ]

370

371 identical=

372 nonidentical=

373 p=

374 gotparents=

        for parent in $newparents; do

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

                [ -z "$ptree" ] && continue

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

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

380 identical="$parent"

381 else

382 nonidentical="$parent"

383 fi

384

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

386 # eliminate duplicates

387 is_new=1

                for gp in $gotparents; do

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

390 is_new=

391 break

392 fi

393 done

                if [ -n "$is_new" ]; then

                        gotparents="$gotparents $parent"

                        p="$p -p $parent"

397 fi

398 done

399

        if [ -n "$identical" ]; then

401 echo $identical

402 else

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

404 fi

405 }

406

407 ensure_clean()

408 {

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

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

411 fi

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

413 die "Index has modifications. Cannot add."

414 fi

415 }

416

417 cmd_add()

418 {

        if [ -e "$dir" ]; then

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

421 fi

422 ensure_clean

423

424 set -- $revs

        if [ $# -ne 1 ]; then

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

427 fi

        rev="$1"

429

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

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

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

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

434

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

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

437 headp="-p $headrev"

438 else

439 headp=

440 fi

441

        if [ -n "$squash" ]; then

                rev=$(new_squash_commit "" "" "$rev") || exit $?

                commit=$(echo "Merge commit '$rev' as '$dir'" |

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

446 else

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

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

449 fi

        git reset "$commit" || exit $?

451

452 say "Added dir '$dir'"

453 }

454

455 cmd_split()

456 {

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

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

459 fi

460

461 debug "Splitting $dir..."

462 cache_setup || exit $?

463

        if [ -n "$onto" ]; then

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

466 git rev-list $onto |

                while read rev; do

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

469 # any parent we find there can be used verbatim

470 debug " cache: $rev"

471 cache_set $rev $rev

472 done

473 fi

474

        if [ -n "$ignore_joins" ]; then

476 unrevs=

477 else

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

479 fi

480

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

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

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

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

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

486 revcount=0

487 createcount=0

488 eval "$grl" |

        while read rev parents; do

                revcount=$(($revcount + 1))

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

492 debug "Processing commit: $rev"

493 exists=$(cache_get $rev)

                if [ -n "$exists" ]; then

495 debug " prior: $exists"

496 continue

497 fi

                createcount=$(($createcount + 1))

499 debug " parents: $parents"

500 newparents=$(cache_get $parents)

501 debug " newparents: $newparents"

502

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

504 debug " tree is: $tree"

505

506 # ugly. is there no better way to tell if this is a subtree

507 # vs. a mainline commit? Does it matter?

                [ -z $tree ] && continue

509

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

511 debug " newrev is: $newrev"

512 cache_set $rev $newrev

513 cache_set latest_new $newrev

514 cache_set latest_old $rev

515 done || exit $?

516 latest_new=$(cache_get latest_new)

        if [ -z "$latest_new" ]; then

518 die "No new revisions were found"

519 fi

520

        if [ -n "$rejoin" ]; then

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

523 latest_old=$(cache_get latest_old)

524 git merge -s ours \

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

526 $latest_new >&2 || exit $?

527 fi

        if [ -n "$branch" ]; then

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

530 $latest_new "" || exit $?

531 say "Created branch '$branch'"

532 fi

533 echo $latest_new

534 exit 0

535 }

536

537 cmd_merge()

538 {

539 ensure_clean

540

541 set -- $revs

        if [ $# -ne 1 ]; then

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

544 fi

        rev="$1"

546

        if [ -n "$squash" ]; then

548 first_split="$(find_latest_squash "$dir")"

                if [ -z "$first_split" ]; then

550 die "Can't squash-merge: '$dir' was never added."

551 fi

552 set $first_split

553 old=$1

554 sub=$2

                if [ "$sub" = "$rev" ]; then

556 say "Subtree is already at commit $rev."

557 exit 0

558 fi

                new=$(new_squash_commit "$old" "$sub" "$rev") || exit $?

560 debug "New squash commit: $new"

                rev="$new"

562 fi

563

564 git merge -s subtree $rev

565 }

566

567 cmd_pull()

568 {

569 ensure_clean

570 git fetch "$@" || exit $?

571 revs=FETCH_HEAD

572 cmd_merge

573 }

574

575 "cmd_$command" "$@"