history: add squash subcommand to fold a range
Folding a series of commits into one required either an interactive rebase where each commit after the first was hand-edited to "fixup", or a "git reset --soft" to the merge base followed by "git commit --amend". Add "git history squash <revision-range>" to do this directly. It folds every commit in the range into the oldest one, keeping that commit's authorship and taking the tree of the newest commit, then replays the commits above the range on top. The squashed message comes from the oldest commit by default, or from the body of the last amend! commit targeting it. An editor opens with the selected message when --reedit-message is given. A fixup!, squash! or amend! commit is refused unless the commit it targets is also in the range, so the fold does not silently absorb a marker meant for a commit outside it. The check runs the range through todo_list_rearrange_squash(), which leaves such a marker as a plain pick. Markers whose target is in the range fold in as usual. As an exception, a range made up entirely of markers for one target is combined anyway, taking its message from the last amend! if there is one, so a batch of fixups for the same commit can be collapsed. The range is read like the arguments to "git rev-list", so several revisions such as "HEAD~3..HEAD ^topic" may be given, and rev-list options are accepted too. As "git replay" does, the walk options the fold relies on are forced after setup_revisions() and a warning is printed if an option changed them, so the first commit returned is the range's oldest and its parent is the base regardless of what the user passed (including after a "--"). A merge inside the range is folded when its other parent is reachable from the base, otherwise the range has more than one base and is rejected. By default the command also refuses when a ref points at a commit that the fold would discard. Use --update-refs=head to rewrite only the current branch instead. Inspired-by: Sergey Chernov <serega.morph@gmail.com> Signed-off-by: Harald Nordgren <haraldnordgren@gmail.com> Signed-off-by: Junio C Hamano <gitster@pobox.com>
Harald Nordgren committed
Jul 20, 2026 at 08:27 UTC
e439185efdcbe94d923ad0bacedc4e529c96ef75
7 files changed
+992
-3
Documentation/config/advice.adoc
+4
@@ -59,6 +59,10 @@ all advice messages.
59
forceDeleteBranch::
60
Shown when the user tries to delete a not fully merged
61
branch without the force option set.
62
+ historyUpdateRefs::
63
+ Shown when `git history squash` refuses because a ref points
64
+ into the range being folded, to tell the user about
65
+ `--update-refs=head`.
66
ignoredHook::
67
Shown when a hook is ignored because the hook is not
68
set as executable.
Documentation/git-history.adoc
+42
-3
@@ -12,6 +12,7 @@ git history drop <commit> [--dry-run] [--update-refs=(branches|head)] [--empty=(
12
git history fixup <commit> [--dry-run] [--update-refs=(branches|head)] [--reedit-message] [--empty=(drop|keep|abort)]
13
git history reword <commit> [--dry-run] [--update-refs=(branches|head)]
14
git history split <commit> [--dry-run] [--update-refs=(branches|head)] [--] [<pathspec>...]
15
+git history squash [--dry-run] [--update-refs=(branches|head)] [--reedit-message] <revision-range>
16
17
DESCRIPTION
18
-----------
@@ -43,8 +44,11 @@ at once.
44
LIMITATIONS
45
-----------
46
46
-This command does not (yet) work with histories that contain merges. You
47
-should use linkgit:git-rebase[1] with the `--rebase-merges` flag instead.
47
+This command does not (yet) replay merge commits onto the rewritten
48
+history: if a commit that would be replayed is a merge, the operation is
49
+rejected, and you should use linkgit:git-rebase[1] with the
50
+`--rebase-merges` flag instead. The `squash` subcommand can still fold a
51
+merge that lies inside the range, as long as the range has a single base.
52
53
Furthermore, the command does not support operations that can result in merge
54
conflicts. This limitation is by design as history rewrites are not intended to
@@ -113,6 +117,41 @@ linkgit:gitglossary[7].
117
It is invalid to select either all or no hunks, as that would lead to
118
one of the commits becoming empty.
119
120
+`squash <revision-range>`::
121
+ Fold all commits in _<revision-range>_ into the oldest commit of that
122
+ range. The resulting commit keeps the oldest commit's authorship and
123
+ takes the tree of the range's newest commit, so the whole range
124
+ collapses into a single commit. Commits above the range are replayed
125
+ on top of the result.
126
++
127
+The range is given in the usual `<base>..<tip>` form, where _<base>_ is
128
+the commit just below the oldest commit to squash. For example, `git
129
+history squash HEAD~3..HEAD` folds the three most recent commits into
130
+one, and `git history squash HEAD~5..HEAD~2` squashes an interior range
131
+while leaving the two newest commits in place. Several revisions may be
132
+given, for example `HEAD~3..HEAD ^topic` to additionally exclude what is
133
+already on `topic`. Rev-list options may also be given, but any that would
134
+change how the range is walked are overridden with a warning.
135
++
136
+The oldest commit's message is preserved by default, except that an `amend!`
137
+commit targeting it replaces its message. Specify `--reedit-message` to edit
138
+the resulting message. A merge commit inside the range is folded like any
139
+other, but the range must have a single base, so a range that reaches more
140
+than one entry point (for example a side branch that forked before the range
141
+and was later merged into it) is rejected.
142
++
143
+A `fixup!`, `squash!`, or `amend!` commit is refused unless the commit it
144
+targets is also in the range, so the fold does not silently absorb a
145
+marker meant for a commit outside it. As an exception, a range made up entirely
146
+of markers for one target is combined into a single commit, keeping the last
147
+`amend!` message if there is one.
148
++
149
+A branch or tag that points at a commit inside the range would be left
150
+dangling once those commits are folded away, so with the default
151
+`--update-refs=branches` the command refuses. Rerun with
152
+`--update-refs=head` to rewrite only the current branch and leave such
153
+refs pointing at the old commits.
154
+
155
OPTIONS
156
-------
157
@@ -123,7 +162,7 @@ OPTIONS
162
ref updates is generally safe.
163
164
`--reedit-message`::
126
- Open an editor to modify the target commit's message.
165
+ Open an editor to modify the rewritten commit's message.
166
167
`--empty=(drop|keep|abort)`::
168
Control what happens when a commit becomes empty as a result of the
advice.c
+1
@@ -58,6 +58,7 @@ static struct {
58
[ADVICE_FETCH_SHOW_FORCED_UPDATES] = { "fetchShowForcedUpdates" },
59
[ADVICE_FORCE_DELETE_BRANCH] = { "forceDeleteBranch" },
60
[ADVICE_GRAFT_FILE_DEPRECATED] = { "graftFileDeprecated" },
61
+ [ADVICE_HISTORY_UPDATE_REFS] = { "historyUpdateRefs" },
62
[ADVICE_IGNORED_HOOK] = { "ignoredHook" },
63
[ADVICE_IMPLICIT_IDENTITY] = { "implicitIdentity" },
64
[ADVICE_MERGE_CONFLICT] = { "mergeConflict" },
advice.h
+1
@@ -25,6 +25,7 @@ enum advice_type {
25
ADVICE_FETCH_SHOW_FORCED_UPDATES,
26
ADVICE_FORCE_DELETE_BRANCH,
27
ADVICE_GRAFT_FILE_DEPRECATED,
28
+ ADVICE_HISTORY_UPDATE_REFS,
29
ADVICE_IGNORED_HOOK,
30
ADVICE_IMPLICIT_IDENTITY,
31
ADVICE_MERGE_CONFLICT,
builtin/history.c
+374
@@ -1,6 +1,7 @@
1
#define USE_THE_REPOSITORY_VARIABLE
2
3
#include "builtin.h"
4
+#include "advice.h"
5
#include "cache-tree.h"
6
#include "commit.h"
7
#include "commit-reach.h"
@@ -34,6 +35,8 @@
35
N_("git history reword <commit> [--dry-run] [--update-refs=(branches|head)]")
36
#define GIT_HISTORY_SPLIT_USAGE \
37
N_("git history split <commit> [--dry-run] [--update-refs=(branches|head)] [--] [<pathspec>...]")
38
+#define GIT_HISTORY_SQUASH_USAGE \
39
+ N_("git history squash [--dry-run] [--update-refs=(branches|head)] [--reedit-message] <revision-range>")
40
41
static void change_data_free(void *util, const char *str UNUSED)
42
{
@@ -1004,6 +1007,375 @@ out:
1007
return ret;
1008
}
1009
1010
+/*
1011
+ * Resolve a "<base>..<tip>" revision range into the base commit just outside
1012
+ * the range (which becomes the parent of the squashed commit), the oldest
1013
+ * commit contained in the range (whose message the squash reuses), and the
1014
+ * range tip (whose tree becomes the result). A merge inside the range is fine,
1015
+ * but the range must have a single base and must not reach a root commit.
1016
+ */
1017
+static int resolve_squash_range(struct repository *repo,
1018
+ const char **argv,
1019
+ struct commit **base_out,
1020
+ struct commit **oldest_out,
1021
+ struct commit **tip_out,
1022
+ struct oidset *interior_out)
1023
+{
1024
+ struct rev_info revs;
1025
+ struct commit *commit, *base = NULL, *oldest = NULL, *tip = NULL;
1026
+ struct commit_list *boundaries = NULL, *b;
1027
+ struct strvec args = STRVEC_INIT;
1028
+ size_t i;
1029
+ int ret;
1030
+
1031
+ repo_init_revisions(repo, &revs, NULL);
1032
+ revs.reverse = 1;
1033
+ revs.topo_order = 1;
1034
+ revs.sort_order = REV_SORT_IN_GRAPH_ORDER;
1035
+ revs.simplify_history = 0;
1036
+ revs.boundary = 1;
1037
+
1038
+ strvec_push(&args, "ignored");
1039
+ strvec_push(&args, "--ancestry-path");
1040
+ strvec_pushv(&args, argv);
1041
+ setup_revisions_from_strvec(&args, &revs, NULL);
1042
+ if (args.nr != 1) {
1043
+ ret = error(_("unrecognized argument: %s"), args.v[1]);
1044
+ goto out;
1045
+ }
1046
+
1047
+ if (revs.reverse != 1 || revs.topo_order != 1 ||
1048
+ revs.sort_order != REV_SORT_IN_GRAPH_ORDER ||
1049
+ revs.simplify_history != 0 || revs.boundary != 1) {
1050
+ warning(_("ignoring rev-list options that would change how the "
1051
+ "range is walked"));
1052
+ revs.reverse = 1;
1053
+ revs.topo_order = 1;
1054
+ revs.sort_order = REV_SORT_IN_GRAPH_ORDER;
1055
+ revs.simplify_history = 0;
1056
+ revs.boundary = 1;
1057
+ }
1058
+
1059
+ /*
1060
+ * A squash needs a base to reparent onto, so the range has to exclude
1061
+ * something, as in "<base>..<tip>". A revision range with no such
1062
+ * bottom commit cannot be squashed.
1063
+ */
1064
+ for (i = 0; i < revs.cmdline.nr; i++)
1065
+ if (revs.cmdline.rev[i].flags & UNINTERESTING)
1066
+ break;
1067
+ if (i == revs.cmdline.nr) {
1068
+ ret = error(_("not a '<base>..<tip>' revision range"));
1069
+ goto out;
1070
+ }
1071
+
1072
+ if (prepare_revision_walk(&revs) < 0) {
1073
+ ret = error(_("error preparing revisions"));
1074
+ goto out;
1075
+ }
1076
+
1077
+ /*
1078
+ * Set boundary commits aside for the base check below, and put every
1079
+ * in-range commit but the tip into the interior set. A ref pointing
1080
+ * at an interior commit would dangle once the range is folded away.
1081
+ */
1082
+ while ((commit = get_revision(&revs))) {
1083
+ if (commit->object.flags & BOUNDARY) {
1084
+ commit_list_insert(commit, &boundaries);
1085
+ continue;
1086
+ }
1087
+ if (!oldest)
1088
+ oldest = commit;
1089
+ if (tip)
1090
+ oidset_insert(interior_out, &tip->object.oid);
1091
+ tip = commit;
1092
+ }
1093
+
1094
+ if (!oldest) {
1095
+ ret = error(_("the revision range is empty"));
1096
+ goto out;
1097
+ } else if (oldest == tip) {
1098
+ ret = error(_("the revision range holds a single commit; "
1099
+ "nothing to squash"));
1100
+ goto out;
1101
+ } else if (!oldest->parents) {
1102
+ BUG("an in-range commit must have a parent");
1103
+ }
1104
+ base = oldest->parents->item;
1105
+
1106
+ /*
1107
+ * A boundary other than the base is an in-range commit reaching a
1108
+ * commit outside the range, so the range has more than one base.
1109
+ */
1110
+ for (b = boundaries; b; b = b->next) {
1111
+ if (b->item != base) {
1112
+ ret = error(_("the revision range has more than one base; "
1113
+ "cannot squash"));
1114
+ goto out;
1115
+ }
1116
+ }
1117
+
1118
+ *base_out = base;
1119
+ *oldest_out = oldest;
1120
+ *tip_out = tip;
1121
+ ret = 0;
1122
+
1123
+out:
1124
+ commit_list_free(boundaries);
1125
+ reset_revision_walk();
1126
+ release_revisions(&revs);
1127
+ strvec_clear(&args);
1128
+ return ret;
1129
+}
1130
+
1131
+static const char *autosquash_target(const char *subject)
1132
+{
1133
+ const char *rest;
1134
+
1135
+ while (skip_prefix(subject, "fixup! ", &rest) ||
1136
+ skip_prefix(subject, "squash! ", &rest) ||
1137
+ skip_prefix(subject, "amend! ", &rest))
1138
+ subject = rest;
1139
+ return subject;
1140
+}
1141
+
1142
+static int reject_dangling_fixups(struct repository *repo,
1143
+ struct commit *base,
1144
+ struct commit *tip,
1145
+ struct commit *oldest,
1146
+ struct commit **msg_source,
1147
+ struct commit **amend_source)
1148
+{
1149
+ struct todo_list todo = TODO_LIST_INIT;
1150
+ struct replay_opts opts = REPLAY_OPTS_INIT;
1151
+ struct rev_info revs;
1152
+ struct commit *commit, *last_amend = NULL;
1153
+ struct strvec args = STRVEC_INIT;
1154
+ char *dangling_subject = NULL, *dangling_target = NULL;
1155
+ bool mixed_target = false, all_fixups_one_target;
1156
+ bool past_oldest_group = false;
1157
+ int i, ret, nr_dangling = 0;
1158
+
1159
+ *msg_source = oldest;
1160
+ *amend_source = NULL;
1161
+
1162
+ repo_init_revisions(repo, &revs, NULL);
1163
+ strvec_push(&args, "ignored");
1164
+ strvec_push(&args, "--reverse");
1165
+ strvec_push(&args, "--topo-order");
1166
+ strvec_pushf(&args, "%s..%s", oid_to_hex(&base->object.oid),
1167
+ oid_to_hex(&tip->object.oid));
1168
+ setup_revisions_from_strvec(&args, &revs, NULL);
1169
+
1170
+ if (prepare_revision_walk(&revs) < 0) {
1171
+ ret = error(_("error preparing revisions"));
1172
+ goto out;
1173
+ }
1174
+ while ((commit = get_revision(&revs)))
1175
+ strbuf_addf(&todo.buf, "pick %s\n",
1176
+ oid_to_hex(&commit->object.oid));
1177
+
1178
+ if (todo_list_parse_insn_buffer(repo, &opts, todo.buf.buf, &todo) < 0 ||
1179
+ todo_list_rearrange_squash(&todo) < 0) {
1180
+ ret = error(_("could not check the range for fixups"));
1181
+ goto out;
1182
+ }
1183
+
1184
+ for (i = 0; i < todo.nr; i++) {
1185
+ const char *message, *subject_start, *target;
1186
+ char *subject;
1187
+ size_t sublen;
1188
+
1189
+ message = repo_logmsg_reencode(repo, todo.items[i].commit,
1190
+ NULL, NULL);
1191
+ sublen = find_commit_subject(message, &subject_start);
1192
+
1193
+ if (todo.items[i].command != TODO_PICK) {
1194
+ if (!past_oldest_group &&
1195
+ starts_with(subject_start, "amend! "))
1196
+ *amend_source = todo.items[i].commit;
1197
+ repo_unuse_commit_buffer(repo, todo.items[i].commit, message);
1198
+ continue;
1199
+ }
1200
+ if (i)
1201
+ past_oldest_group = true;
1202
+
1203
+ subject = xmemdupz(subject_start, sublen);
1204
+ target = autosquash_target(subject);
1205
+ if (target != subject) {
1206
+ nr_dangling++;
1207
+ if (!dangling_target) {
1208
+ dangling_target = xstrdup(target);
1209
+ dangling_subject = xstrdup(subject);
1210
+ } else if (strcmp(dangling_target, target)) {
1211
+ mixed_target = true;
1212
+ }
1213
+ if (starts_with(subject, "amend! "))
1214
+ last_amend = todo.items[i].commit;
1215
+ }
1216
+ free(subject);
1217
+ repo_unuse_commit_buffer(repo, todo.items[i].commit, message);
1218
+ }
1219
+
1220
+ all_fixups_one_target = nr_dangling == todo.nr && !mixed_target;
1221
+ if (nr_dangling && !all_fixups_one_target) {
1222
+ ret = error(_("cannot squash '%s': its target is not in the "
1223
+ "range"), dangling_subject);
1224
+ } else {
1225
+ if (last_amend)
1226
+ *msg_source = last_amend;
1227
+ ret = 0;
1228
+ }
1229
+
1230
+out:
1231
+ free(dangling_subject);
1232
+ free(dangling_target);
1233
+ todo_list_release(&todo);
1234
+ replay_opts_release(&opts);
1235
+ reset_revision_walk();
1236
+ release_revisions(&revs);
1237
+ strvec_clear(&args);
1238
+ return ret;
1239
+}
1240
+
1241
+struct interior_ref_cb {
1242
+ const struct oidset *interior;
1243
+ const char *name;
1244
+};
1245
+
1246
+static int find_interior_ref(const struct reference *ref, void *cb_data)
1247
+{
1248
+ struct interior_ref_cb *data = cb_data;
1249
+
1250
+ if (oidset_contains(data->interior, ref->oid)) {
1251
+ data->name = xstrdup(ref->name);
1252
+ return 1;
1253
+ }
1254
+
1255
+ return 0;
1256
+}
1257
+
1258
+static int cmd_history_squash(int argc,
1259
+ const char **argv,
1260
+ const char *prefix,
1261
+ struct repository *repo)
1262
+{
1263
+ const char * const usage[] = {
1264
+ GIT_HISTORY_SQUASH_USAGE,
1265
+ NULL,
1266
+ };
1267
+ enum ref_action action = REF_ACTION_DEFAULT;
1268
+ enum commit_tree_flags flags = 0;
1269
+ int dry_run = 0;
1270
+ struct option options[] = {
1271
+ OPT_CALLBACK_F(0, "update-refs", &action, "(branches|head)",
1272
+ N_("control which refs should be updated"),
1273
+ PARSE_OPT_NONEG, parse_ref_action),
1274
+ OPT_BOOL('n', "dry-run", &dry_run,
1275
+ N_("perform a dry-run without updating any refs")),
1276
+ OPT_BIT(0, "reedit-message", &flags,
1277
+ N_("open an editor to modify the commit message"),
1278
+ COMMIT_TREE_EDIT_MESSAGE),
1279
+ OPT_END(),
1280
+ };
1281
+ struct strbuf reflog_msg = STRBUF_INIT;
1282
+ struct strbuf message = STRBUF_INIT;
1283
+ struct oidset interior = OIDSET_INIT;
1284
+ struct commit *base, *oldest, *tip, *rewritten, *msg_source,
1285
+ *amend_source;
1286
+ const struct object_id *base_tree_oid, *tip_tree_oid;
1287
+ const char *message_template = NULL;
1288
+ struct commit_list *parents = NULL;
1289
+ struct rev_info revs = { 0 };
1290
+ int ret;
1291
+
1292
+ argc = parse_options(argc, argv, prefix, options, usage,
1293
+ PARSE_OPT_KEEP_UNKNOWN_OPT);
1294
+ if (!argc) {
1295
+ ret = error(_("command expects a revision range"));
1296
+ goto out;
1297
+ }
1298
+ repo_config(repo, git_default_config, NULL);
1299
+
1300
+ if (action == REF_ACTION_DEFAULT)
1301
+ action = REF_ACTION_BRANCHES;
1302
+
1303
+ ret = resolve_squash_range(repo, argv, &base, &oldest, &tip,
1304
+ &interior);
1305
+ if (ret < 0)
1306
+ goto out;
1307
+
1308
+ ret = reject_dangling_fixups(repo, base, tip, oldest, &msg_source,
1309
+ &amend_source);
1310
+ if (ret < 0)
1311
+ goto out;
1312
+ if (amend_source) {
1313
+ const char *amend_message, *body;
1314
+
1315
+ amend_message = repo_logmsg_reencode(repo, amend_source,
1316
+ NULL, NULL);
1317
+ find_commit_subject(amend_message, &body);
1318
+ body = skip_blank_lines(body + commit_subject_length(body));
1319
+ strbuf_addstr(&message, body);
1320
+ message_template = message.buf;
1321
+ repo_unuse_commit_buffer(repo, amend_source, amend_message);
1322
+ }
1323
+
1324
+ if (action == REF_ACTION_BRANCHES) {
1325
+ struct interior_ref_cb cb = { .interior = &interior };
1326
+
1327
+ refs_for_each_ref(get_main_ref_store(repo),
1328
+ find_interior_ref, &cb);
1329
+ if (cb.name) {
1330
+ ret = error(_("'%s' points into the squashed range"),
1331
+ cb.name);
1332
+ advise_if_enabled(ADVICE_HISTORY_UPDATE_REFS,
1333
+ _("Use --update-refs=head to rewrite only "
1334
+ "the current branch and leave such refs "
1335
+ "untouched."));
1336
+ free((char *)cb.name);
1337
+ goto out;
1338
+ }
1339
+ }
1340
+
1341
+ ret = setup_revwalk(repo, action, tip, &revs);
1342
+ if (ret < 0)
1343
+ goto out;
1344
+
1345
+ base_tree_oid = &repo_get_commit_tree(repo, base)->object.oid;
1346
+ tip_tree_oid = &repo_get_commit_tree(repo, tip)->object.oid;
1347
+ commit_list_append(base, &parents);
1348
+
1349
+ ret = commit_tree_ext(repo, "squash", msg_source, message_template,
1350
+ parents,
1351
+ base_tree_oid, tip_tree_oid, &rewritten, flags);
1352
+ if (ret < 0) {
1353
+ ret = error(_("failed writing squashed commit"));
1354
+ goto out;
1355
+ }
1356
+
1357
+ strbuf_addstr(&reflog_msg, "squash: updating ");
1358
+ strbuf_join_argv(&reflog_msg, argc, argv, ' ');
1359
+
1360
+ ret = handle_reference_updates(&revs, action, tip, rewritten,
1361
+ reflog_msg.buf, dry_run,
1362
+ REPLAY_EMPTY_COMMIT_ABORT);
1363
+ if (ret < 0) {
1364
+ ret = error(_("failed replaying descendants"));
1365
+ goto out;
1366
+ }
1367
+
1368
+ ret = 0;
1369
+
1370
+out:
1371
+ strbuf_release(&reflog_msg);
1372
+ strbuf_release(&message);
1373
+ oidset_clear(&interior);
1374
+ commit_list_free(parents);
1375
+ release_revisions(&revs);
1376
+ return ret;
1377
+}
1378
+
1379
static int update_worktree(struct repository *repo,
1380
const struct commit *old_head,
1381
const struct commit *new_head,
@@ -1192,6 +1564,7 @@ int cmd_history(int argc,
1564
GIT_HISTORY_FIXUP_USAGE,
1565
GIT_HISTORY_REWORD_USAGE,
1566
GIT_HISTORY_SPLIT_USAGE,
1567
+ GIT_HISTORY_SQUASH_USAGE,
1568
NULL,
1569
};
1570
parse_opt_subcommand_fn *fn = NULL;
@@ -1200,6 +1573,7 @@ int cmd_history(int argc,
1573
OPT_SUBCOMMAND("fixup", &fn, cmd_history_fixup),
1574
OPT_SUBCOMMAND("reword", &fn, cmd_history_reword),
1575
OPT_SUBCOMMAND("split", &fn, cmd_history_split),
1576
+ OPT_SUBCOMMAND("squash", &fn, cmd_history_squash),
1577
OPT_END(),
1578
};
1579
t/meson.build
+1
@@ -405,6 +405,7 @@ integration_tests = [
405
't3452-history-split.sh',
406
't3453-history-fixup.sh',
407
't3454-history-drop.sh',
408
+ 't3455-history-squash.sh',
409
't3500-cherry.sh',
410
't3501-revert-cherry-pick.sh',
411
't3502-cherry-pick-merge.sh',
t/t3455-history-squash.sh
new
+569
@@ -0,0 +1,569 @@
1
+#!/bin/sh
2
+
3
+test_description='tests for git-history squash subcommand'
4
+
5
+. ./test-lib.sh
6
+
7
+stage_file () {
8
+ printf "%s\n" "$1" >file &&
9
+ git add file
10
+}
11
+
12
+commit_with_message () {
13
+ printf "%b" "$1" >msg &&
14
+ git commit --allow-empty -qF msg
15
+}
16
+
17
+check_commit_count () {
18
+ git rev-list --count "$1" >actual &&
19
+ echo "$2" >expect &&
20
+ test_cmp expect actual
21
+}
22
+
23
+check_log_subjects () {
24
+ git log --format="%s" "$1" >actual &&
25
+ cat >expect &&
26
+ test_cmp expect actual
27
+}
28
+
29
+check_log_messages () {
30
+ git log --format="%B" "$1" >actual &&
31
+ cat >expect &&
32
+ test_cmp expect actual
33
+}
34
+
35
+test_expect_success 'setup linear history touching two files' '
36
+ test_commit base file a &&
37
+ git tag start &&
38
+ test_commit --no-tag one other x &&
39
+ test_commit --no-tag two file c &&
40
+ test_commit three file d
41
+'
42
+
43
+test_expect_success 'errors on missing range argument' '
44
+ test_must_fail git history squash 2>err &&
45
+ test_grep "expects a revision range" err
46
+'
47
+
48
+test_expect_success 'errors on an empty range' '
49
+ test_must_fail git history squash HEAD..HEAD 2>err &&
50
+ test_grep "the revision range is empty" err
51
+'
52
+
53
+test_expect_success 'errors on a single revision that is not a range' '
54
+ test_must_fail git history squash HEAD 2>err &&
55
+ test_grep "not a .*range" err &&
56
+ test_must_fail git history squash HEAD~1 2>err &&
57
+ test_grep "not a .*range" err
58
+'
59
+
60
+test_expect_success 'errors on a range holding a single commit' '
61
+ git reset --hard three &&
62
+ head_before=$(git rev-parse HEAD) &&
63
+
64
+ test_must_fail git history squash "HEAD^!" 2>err &&
65
+ test_grep "single commit; nothing to squash" err &&
66
+ test_cmp_rev "$head_before" HEAD
67
+'
68
+
69
+test_expect_success 'accepts multiple revision arguments with an exclusion' '
70
+ git reset --hard three &&
71
+ git branch -f keep HEAD~2 &&
72
+ tip_tree=$(git rev-parse HEAD^{tree}) &&
73
+
74
+ git history squash start..HEAD ^keep &&
75
+
76
+ git reflog -1 --format=%gs >actual &&
77
+ echo "squash: updating start..HEAD ^keep" >expect &&
78
+ test_cmp expect actual &&
79
+
80
+ check_log_subjects start..HEAD <<-\EOF &&
81
+ two
82
+ one
83
+ EOF
84
+ test_cmp_rev keep HEAD~1 &&
85
+ test "$tip_tree" = "$(git rev-parse HEAD^{tree})" &&
86
+
87
+ git branch -D keep
88
+'
89
+
90
+test_expect_success 'squashes a branch the current branch is not on' '
91
+ git reset --hard three &&
92
+ main=$(git symbolic-ref --short HEAD) &&
93
+ head_before=$(git rev-parse HEAD) &&
94
+ git checkout -b off-history start &&
95
+ test_commit --no-tag off-one off a &&
96
+ test_commit --no-tag off-two off b &&
97
+ git checkout "$main" &&
98
+
99
+ git history squash start..off-history &&
100
+
101
+ check_commit_count start..off-history 1 &&
102
+ test_cmp_rev "$head_before" HEAD &&
103
+
104
+ git branch -D off-history
105
+'
106
+
107
+test_expect_success 'squashes a range into a single commit without changing the tree' '
108
+ git reset --hard three &&
109
+ head_before=$(git rev-parse HEAD) &&
110
+ tip_tree=$(git rev-parse HEAD^{tree}) &&
111
+
112
+ git history squash --dry-run start.. >out &&
113
+ predicted=$(awk "/^update refs\/heads\// {print \$3}" out) &&
114
+ test_cmp_rev "$head_before" HEAD &&
115
+
116
+ git history squash start.. &&
117
+
118
+ test "$predicted" = "$(git rev-parse HEAD)" &&
119
+ check_commit_count start..HEAD 1 &&
120
+ test_cmp_rev start HEAD^ &&
121
+ test "$tip_tree" = "$(git rev-parse HEAD^{tree})" &&
122
+ check_log_subjects -1 <<-\EOF &&
123
+ one
124
+ EOF
125
+ git reflog >reflog &&
126
+ test_grep "squash: updating" reflog
127
+'
128
+
129
+test_expect_success 'sanitizes rev-list walk options, before and after --' '
130
+ git reset --hard three &&
131
+ tip_tree=$(git rev-parse HEAD^{tree}) &&
132
+
133
+ git history squash --date-order start.. 2>err &&
134
+ test_grep "ignoring rev-list options" err &&
135
+ test_cmp_rev start HEAD^ &&
136
+ test "$tip_tree" = "$(git rev-parse HEAD^{tree})" &&
137
+
138
+ git reset --hard three &&
139
+ git history squash -- --reverse start.. 2>err &&
140
+ test_grep "ignoring rev-list options" err &&
141
+ test_cmp_rev start HEAD^ &&
142
+ test "$tip_tree" = "$(git rev-parse HEAD^{tree})"
143
+'
144
+
145
+test_expect_success 'squashes an interior range and replays descendants verbatim' '
146
+ git reset --hard three &&
147
+ final_tree=$(git rev-parse HEAD^{tree}) &&
148
+
149
+ git history squash start..@~1 &&
150
+
151
+ check_log_subjects start..HEAD <<-\EOF &&
152
+ three
153
+ one
154
+ EOF
155
+
156
+ test_cmp_rev start HEAD~2 &&
157
+ test "$final_tree" = "$(git rev-parse HEAD^{tree})"
158
+'
159
+
160
+test_expect_success 'squashes when the base is the root commit' '
161
+ git reset --hard three &&
162
+ root=$(git rev-list --max-parents=0 HEAD) &&
163
+ tip_tree=$(git rev-parse HEAD^{tree}) &&
164
+
165
+ git history squash "$root.." &&
166
+
167
+ check_commit_count "$root..HEAD" 1 &&
168
+ test_cmp_rev "$root" HEAD^ &&
169
+ test "$tip_tree" = "$(git rev-parse HEAD^{tree})"
170
+'
171
+
172
+
173
+test_expect_success 'folds fixups whose target is in the range' '
174
+ git reset --hard start &&
175
+ test_commit --no-tag target file b &&
176
+ git commit --allow-empty -m "fixup! target" &&
177
+ git commit --allow-empty -m "fixup! target" &&
178
+ test_commit --no-tag later file c &&
179
+
180
+ git history squash start.. &&
181
+
182
+ check_commit_count start..HEAD 1 &&
183
+ check_log_subjects -1 <<-\EOF
184
+ target
185
+ EOF
186
+'
187
+
188
+test_expect_success 'refuses a below-range fixup! after an in-range commit' '
189
+ git reset --hard start &&
190
+ test_commit --no-tag inside file b &&
191
+ test_commit --no-tag "fixup! outside" file c &&
192
+ head_before=$(git rev-parse HEAD) &&
193
+
194
+ test_must_fail git history squash start.. 2>err &&
195
+ test_grep "target is not in the range" err &&
196
+ test_cmp_rev "$head_before" HEAD
197
+'
198
+
199
+test_expect_success 'combines a run of fixups for one commit below the range' '
200
+ git reset --hard start &&
201
+ stage_file b && git commit -m "fixup! base" &&
202
+ stage_file c && git commit -m "fixup! base" &&
203
+
204
+ git history squash start.. &&
205
+
206
+ check_commit_count start..HEAD 1 &&
207
+ check_log_subjects -1 <<-\EOF
208
+ fixup! base
209
+ EOF
210
+'
211
+
212
+test_expect_success 'combining below-range fixups keeps the last amend! message' '
213
+ git reset --hard start &&
214
+ stage_file b && git commit -m "fixup! base" &&
215
+ stage_file c &&
216
+ commit_with_message "amend! base\n\namended body\n" &&
217
+
218
+ git history squash start.. &&
219
+
220
+ check_commit_count start..HEAD 1 &&
221
+ check_log_messages -1 <<-\EOF
222
+ amend! base
223
+
224
+ amended body
225
+
226
+ EOF
227
+'
228
+
229
+test_expect_success 'refuses fixups for two different commits below the range' '
230
+ git reset --hard start &&
231
+ stage_file b && git commit -m "fixup! aaa" &&
232
+ stage_file c && git commit -m "fixup! bbb" &&
233
+ head_before=$(git rev-parse HEAD) &&
234
+
235
+ test_must_fail git history squash start.. 2>err &&
236
+ test_grep "target is not in the range" err &&
237
+ test_cmp_rev "$head_before" HEAD
238
+'
239
+
240
+test_expect_success 'the last amend! for the oldest commit replaces its message' '
241
+ git reset --hard start &&
242
+ test_commit --no-tag marker-oldest file b &&
243
+ git commit --allow-empty -m "squash! marker-oldest" &&
244
+ commit_with_message "amend! marker-oldest\n\nearlier message\n" &&
245
+ commit_with_message \
246
+ "amend! marker-oldest\n\namended subject\n\namended body\n" &&
247
+ test_commit --no-tag marker-later file c &&
248
+ commit_with_message "amend! marker-later\n\nwrong message\n" &&
249
+
250
+ git history squash start.. &&
251
+
252
+ check_commit_count start..HEAD 1 &&
253
+ check_log_messages -1 <<-\EOF
254
+ amended subject
255
+
256
+ amended body
257
+
258
+ EOF
259
+'
260
+
261
+test_expect_success 'preserves authorship of the oldest commit' '
262
+ git reset --hard start &&
263
+ GIT_AUTHOR_NAME=Squasher GIT_AUTHOR_EMAIL=squash@example.com \
264
+ test_commit --no-tag oldest file b &&
265
+ test_commit newest file c &&
266
+
267
+ git history squash start.. &&
268
+
269
+ git log -1 --format="%an <%ae>" >actual &&
270
+ echo "Squasher <squash@example.com>" >expect &&
271
+ test_cmp expect actual
272
+'
273
+
274
+test_expect_success '--update-refs=head only moves HEAD' '
275
+ git reset --hard three &&
276
+ git branch -f other HEAD &&
277
+ other_before=$(git rev-parse other) &&
278
+
279
+ git history squash --update-refs=head start.. &&
280
+
281
+ check_commit_count start..HEAD 1 &&
282
+ test_cmp_rev "$other_before" other
283
+'
284
+
285
+test_expect_success 'refuses to fold a range a ref points into' '
286
+ git reset --hard three &&
287
+ git branch -f mid HEAD~1 &&
288
+ head_before=$(git rev-parse HEAD) &&
289
+
290
+ test_must_fail git history squash start.. 2>err &&
291
+ test_grep "error: .* points into the squashed range" err &&
292
+ test_grep "hint: .*--update-refs=head" err &&
293
+ test_cmp_rev "$head_before" HEAD &&
294
+
295
+ git branch -D mid
296
+'
297
+
298
+test_expect_success 'advice.historyUpdateRefs silences the hint' '
299
+ git reset --hard three &&
300
+ git branch -f mid HEAD~1 &&
301
+ head_before=$(git rev-parse HEAD) &&
302
+
303
+ test_must_fail git -c advice.historyUpdateRefs=false \
304
+ history squash start.. 2>err &&
305
+ test_grep "points into the squashed range" err &&
306
+ test_grep ! "hint:" err &&
307
+ test_cmp_rev "$head_before" HEAD &&
308
+
309
+ git branch -D mid
310
+'
311
+
312
+test_expect_success '--update-refs=head folds past a ref pointing into the range' '
313
+ git reset --hard three &&
314
+ git branch -f mid HEAD~1 &&
315
+ mid_before=$(git rev-parse mid) &&
316
+
317
+ git history squash --update-refs=head start.. &&
318
+
319
+ check_commit_count start..HEAD 1 &&
320
+ test_cmp_rev "$mid_before" mid &&
321
+
322
+ git branch -D mid
323
+'
324
+
325
+test_expect_success 'refuses to fold a range a tag points into' '
326
+ git reset --hard three &&
327
+ git tag -f mark HEAD~1 &&
328
+ head_before=$(git rev-parse HEAD) &&
329
+
330
+ test_must_fail git history squash start.. 2>err &&
331
+ test_grep "refs/tags/mark" err &&
332
+ test_grep "points into the squashed range" err &&
333
+ test_cmp_rev "$head_before" HEAD &&
334
+
335
+ git tag -d mark
336
+'
337
+
338
+test_expect_success 'squashes a range whose internal merge has a single base' '
339
+ git reset --hard start &&
340
+ main=$(git symbolic-ref --short HEAD) &&
341
+ test_commit --no-tag before-side file b &&
342
+ git checkout -b inner-side &&
343
+ test_commit --no-tag on-inner-side inner x &&
344
+ git checkout "$main" &&
345
+ test_commit --no-tag after-side file c &&
346
+ git merge --no-ff -m merge inner-side &&
347
+ git branch -D inner-side &&
348
+ test_commit --no-tag after-merge file d &&
349
+ tip_tree=$(git rev-parse HEAD^{tree}) &&
350
+
351
+ git history squash start.. &&
352
+
353
+ check_commit_count start..HEAD 1 &&
354
+ check_log_subjects -1 <<-\EOF &&
355
+ before-side
356
+ EOF
357
+ test "$tip_tree" = "$(git rev-parse HEAD^{tree})" &&
358
+ test_path_is_file inner
359
+'
360
+
361
+test_expect_success 'folds a merge of a branch that forked at the base' '
362
+ git reset --hard start &&
363
+ main=$(git symbolic-ref --short HEAD) &&
364
+ git checkout -b base-fork-side &&
365
+ test_commit --no-tag base-fork-side side x &&
366
+ git checkout "$main" &&
367
+ test_commit --no-tag base-fork-main file b &&
368
+ git merge --no-ff -m "merge base-fork-side" base-fork-side &&
369
+ git branch -D base-fork-side &&
370
+ test_commit --no-tag base-fork-tail file c &&
371
+ tip_tree=$(git rev-parse HEAD^{tree}) &&
372
+
373
+ git history squash start.. &&
374
+
375
+ check_commit_count start..HEAD 1 &&
376
+ test_cmp_rev start HEAD^ &&
377
+ test "$tip_tree" = "$(git rev-parse HEAD^{tree})" &&
378
+ test_path_is_file side
379
+'
380
+
381
+test_expect_success 'refuses a merge whose other parent is outside the range' '
382
+ git reset --hard start &&
383
+ main=$(git symbolic-ref --short HEAD) &&
384
+ git checkout -b outside-parent &&
385
+ test_commit --no-tag outside-parent outside x &&
386
+ git checkout "$main" &&
387
+ test_commit --no-tag outside-main file b &&
388
+ base=$(git rev-parse HEAD) &&
389
+ test_commit --no-tag outside-mid file c &&
390
+ git merge --no-ff -m "merge outside-parent" outside-parent &&
391
+ git branch -D outside-parent &&
392
+ merged=$(git rev-parse HEAD) &&
393
+
394
+ test_must_fail git history squash "$base.." 2>err &&
395
+ test_grep "more than one base" err &&
396
+ test_cmp_rev "$merged" HEAD
397
+'
398
+
399
+test_expect_success 'folds a range whose tip is a merge commit' '
400
+ git reset --hard start &&
401
+ main=$(git symbolic-ref --short HEAD) &&
402
+ test_commit --no-tag tipmerge-base file b &&
403
+ git checkout -b tipmerge-side &&
404
+ test_commit --no-tag tipmerge-side side x &&
405
+ git checkout "$main" &&
406
+ test_commit --no-tag tipmerge-main file c &&
407
+ git merge --no-ff -m "merge tipmerge-side" tipmerge-side &&
408
+ git branch -D tipmerge-side &&
409
+ tip_tree=$(git rev-parse HEAD^{tree}) &&
410
+
411
+ git history squash start.. &&
412
+
413
+ check_commit_count start..HEAD 1 &&
414
+ test "$tip_tree" = "$(git rev-parse HEAD^{tree})" &&
415
+ test_path_is_file side
416
+'
417
+
418
+test_expect_success 'folds a range whose base is a merge commit' '
419
+ git reset --hard start &&
420
+ main=$(git symbolic-ref --short HEAD) &&
421
+ git checkout -b basemerge-side &&
422
+ test_commit --no-tag basemerge-side side x &&
423
+ git checkout "$main" &&
424
+ test_commit --no-tag basemerge-main file b &&
425
+ git merge --no-ff -m "merge basemerge-side" basemerge-side &&
426
+ git branch -D basemerge-side &&
427
+ base=$(git rev-parse HEAD) &&
428
+ test_commit --no-tag basemerge-one file c &&
429
+ test_commit --no-tag basemerge-two file d &&
430
+ tip_tree=$(git rev-parse HEAD^{tree}) &&
431
+
432
+ git history squash "$base.." &&
433
+
434
+ check_commit_count "$base..HEAD" 1 &&
435
+ test_cmp_rev "$base" HEAD^ &&
436
+ test "$tip_tree" = "$(git rev-parse HEAD^{tree})"
437
+'
438
+
439
+test_expect_success 'folds a range with two interior merges' '
440
+ git reset --hard start &&
441
+ main=$(git symbolic-ref --short HEAD) &&
442
+ test_commit --no-tag two-merge-a file a1 &&
443
+ git checkout -b two-merge-s1 &&
444
+ test_commit --no-tag two-merge-s1 s1 x &&
445
+ git checkout "$main" &&
446
+ git merge --no-ff -m "merge s1" two-merge-s1 &&
447
+ test_commit --no-tag two-merge-b file b1 &&
448
+ git checkout -b two-merge-s2 &&
449
+ test_commit --no-tag two-merge-s2 s2 y &&
450
+ git checkout "$main" &&
451
+ git merge --no-ff -m "merge s2" two-merge-s2 &&
452
+ git branch -D two-merge-s1 two-merge-s2 &&
453
+ tip_tree=$(git rev-parse HEAD^{tree}) &&
454
+
455
+ git history squash start.. &&
456
+
457
+ check_commit_count start..HEAD 1 &&
458
+ test "$tip_tree" = "$(git rev-parse HEAD^{tree})" &&
459
+ test_path_is_file s1 &&
460
+ test_path_is_file s2
461
+'
462
+
463
+test_expect_success 'folds a range with a nested merge' '
464
+ git reset --hard start &&
465
+ main=$(git symbolic-ref --short HEAD) &&
466
+ git checkout -b nested-outer &&
467
+ test_commit --no-tag nested-outer outer x &&
468
+ git checkout -b nested-inner &&
469
+ test_commit --no-tag nested-inner inner y &&
470
+ git checkout nested-outer &&
471
+ git merge --no-ff -m "merge inner" nested-inner &&
472
+ git checkout "$main" &&
473
+ test_commit --no-tag nested-main file b1 &&
474
+ git merge --no-ff -m "merge outer" nested-outer &&
475
+ git branch -D nested-outer nested-inner &&
476
+ tip_tree=$(git rev-parse HEAD^{tree}) &&
477
+
478
+ git history squash start.. &&
479
+
480
+ check_commit_count start..HEAD 1 &&
481
+ test "$tip_tree" = "$(git rev-parse HEAD^{tree})" &&
482
+ test_path_is_file outer &&
483
+ test_path_is_file inner
484
+'
485
+
486
+test_expect_success 'folds a range with an octopus merge' '
487
+ git reset --hard start &&
488
+ main=$(git symbolic-ref --short HEAD) &&
489
+ test_commit --no-tag octo-base file a1 &&
490
+ git checkout -b octo-1 &&
491
+ test_commit --no-tag octo-1 o1 x &&
492
+ git checkout "$main" &&
493
+ git checkout -b octo-2 &&
494
+ test_commit --no-tag octo-2 o2 y &&
495
+ git checkout "$main" &&
496
+ git merge --no-ff -m octopus octo-1 octo-2 &&
497
+ git branch -D octo-1 octo-2 &&
498
+ tip_tree=$(git rev-parse HEAD^{tree}) &&
499
+
500
+ git history squash start.. &&
501
+
502
+ check_commit_count start..HEAD 1 &&
503
+ test "$tip_tree" = "$(git rev-parse HEAD^{tree})" &&
504
+ test_path_is_file o1 &&
505
+ test_path_is_file o2
506
+'
507
+
508
+test_expect_success 'refuses an octopus merge with an arm forked before the base' '
509
+ git reset --hard start &&
510
+ main=$(git symbolic-ref --short HEAD) &&
511
+ git checkout -b octo-pre &&
512
+ test_commit octo-pre-side pside x &&
513
+ git checkout "$main" &&
514
+ test_commit octo-pre-main file b1 &&
515
+ octo_base=$(git rev-parse HEAD) &&
516
+ git checkout -b octo-within &&
517
+ test_commit --no-tag octo-within wside y &&
518
+ git checkout "$main" &&
519
+ git merge --no-ff -m octopus octo-pre octo-within &&
520
+ merged=$(git rev-parse HEAD) &&
521
+ git branch -D octo-pre octo-within &&
522
+
523
+ test_must_fail git history squash "$octo_base.." 2>err &&
524
+ test_grep "more than one base" err &&
525
+ test_cmp_rev "$merged" HEAD
526
+'
527
+
528
+test_expect_success 'refuses when a descendant above the range is a merge' '
529
+ git reset --hard start &&
530
+ main=$(git symbolic-ref --short HEAD) &&
531
+ test_commit --no-tag desc-one file b &&
532
+ test_commit --no-tag desc-two file c &&
533
+ git tag desc-tip &&
534
+ git checkout -b desc-above &&
535
+ test_commit --no-tag desc-above above x &&
536
+ git checkout "$main" &&
537
+ test_commit --no-tag desc-main file d &&
538
+ git merge --no-ff -m "merge desc-above" desc-above &&
539
+ git branch -D desc-above &&
540
+ head_before=$(git rev-parse HEAD) &&
541
+
542
+ test_must_fail git history squash start..desc-tip 2>err &&
543
+ test_grep "merge commits is not supported" err &&
544
+ test_cmp_rev "$head_before" HEAD
545
+'
546
+
547
+test_expect_success 'refuses to fold a range a ref points into at a merge' '
548
+ git reset --hard start &&
549
+ main=$(git symbolic-ref --short HEAD) &&
550
+ test_commit --no-tag refmerge-base file b &&
551
+ git checkout -b refmerge-side &&
552
+ test_commit --no-tag refmerge-side side x &&
553
+ git checkout "$main" &&
554
+ test_commit --no-tag refmerge-main file c &&
555
+ git merge --no-ff -m "interior merge" refmerge-side &&
556
+ git branch -D refmerge-side &&
557
+ git branch at-merge HEAD &&
558
+ test_commit --no-tag refmerge-tail file d &&
559
+ head_before=$(git rev-parse HEAD) &&
560
+
561
+ test_must_fail git history squash start.. 2>err &&
562
+ test_grep "at-merge" err &&
563
+ test_grep "points into the squashed range" err &&
564
+ test_cmp_rev "$head_before" HEAD &&
565
+
566
+ git branch -D at-merge
567
+'
568
+
569
+test_done