git

1
/*
2
 * The Scalar command-line interface.
3
 */
4

5
#define USE_THE_REPOSITORY_VARIABLE
6

7
#include "git-compat-util.h"
8
#include "abspath.h"
9
#include "gettext.h"
10
#include "parse-options.h"
11
#include "config.h"
12
#include "run-command.h"
13
#include "simple-ipc.h"
14
#include "fsmonitor-ipc.h"
15
#include "fsmonitor-settings.h"
16
#include "refs.h"
17
#include "dir.h"
18
#include "packfile.h"
19
#include "help.h"
20
#include "setup.h"
21
#include "trace2.h"
22

23
static void setup_enlistment_directory(int argc, const char **argv,
24
				       const char * const *usagestr,
25
				       const struct option *options,
26
				       struct strbuf *enlistment_root)
27
{
28
	struct strbuf path = STRBUF_INIT;
29
	int enlistment_is_repo_parent = 0;
30
	size_t len;
31

32
	if (startup_info->have_repository)
33
		BUG("gitdir already set up?!?");
34

35
	if (argc > 1)
36
		usage_with_options(usagestr, options);
37

38
	/* find the worktree, determine its corresponding root */
39
	if (argc == 1) {
40
		strbuf_add_absolute_path(&path, argv[0]);
41
		if (!is_directory(path.buf))
42
			die(_("'%s' does not exist"), path.buf);
43
		if (chdir(path.buf) < 0)
44
			die_errno(_("could not switch to '%s'"), path.buf);
45
	} else if (strbuf_getcwd(&path) < 0)
46
		die(_("need a working directory"));
47

48
	strbuf_trim_trailing_dir_sep(&path);
49

50
	/* check if currently in enlistment root with src/ workdir */
51
	len = path.len;
52
	strbuf_addstr(&path, "/src");
53
	if (is_nonbare_repository_dir(&path)) {
54
		enlistment_is_repo_parent = 1;
55
		if (chdir(path.buf) < 0)
56
			die_errno(_("could not switch to '%s'"), path.buf);
57
	}
58
	strbuf_setlen(&path, len);
59

60
	setup_git_directory();
61

62
	if (!the_repository->worktree)
63
		die(_("Scalar enlistments require a worktree"));
64

65
	if (enlistment_root) {
66
		if (enlistment_is_repo_parent)
67
			strbuf_addbuf(enlistment_root, &path);
68
		else
69
			strbuf_addstr(enlistment_root, the_repository->worktree);
70
	}
71

72
	strbuf_release(&path);
73
}
74

75
LAST_ARG_MUST_BE_NULL
76
static int run_git(const char *arg, ...)
77
{
78
	struct child_process cmd = CHILD_PROCESS_INIT;
79
	va_list args;
80
	const char *p;
81

82
	va_start(args, arg);
83
	strvec_push(&cmd.args, arg);
84
	while ((p = va_arg(args, const char *)))
85
		strvec_push(&cmd.args, p);
86
	va_end(args);
87

88
	cmd.git_cmd = 1;
89
	return run_command(&cmd);
90
}
91

92
struct scalar_config {
93
	const char *key;
94
	const char *value;
95
	int overwrite_on_reconfigure;
96
};
97

98
static int set_scalar_config(const struct scalar_config *config, int reconfigure)
99
{
100
	char *value = NULL;
101
	int res;
102

103
	if ((reconfigure && config->overwrite_on_reconfigure) ||
104
	    git_config_get_string(config->key, &value)) {
105
		trace2_data_string("scalar", the_repository, config->key, "created");
106
		res = git_config_set_gently(config->key, config->value);
107
	} else {
108
		trace2_data_string("scalar", the_repository, config->key, "exists");
109
		res = 0;
110
	}
111

112
	free(value);
113
	return res;
114
}
115

116
static int have_fsmonitor_support(void)
117
{
118
	return fsmonitor_ipc__is_supported() &&
119
	       fsm_settings__get_reason(the_repository) == FSMONITOR_REASON_OK;
120
}
121

122
static int set_recommended_config(int reconfigure)
123
{
124
	struct scalar_config config[] = {
125
		/* Required */
126
		{ "am.keepCR", "true", 1 },
127
		{ "core.FSCache", "true", 1 },
128
		{ "core.multiPackIndex", "true", 1 },
129
		{ "core.preloadIndex", "true", 1 },
130
#ifndef WIN32
131
		{ "core.untrackedCache", "true", 1 },
132
#else
133
		/*
134
		 * Unfortunately, Scalar's Functional Tests demonstrated
135
		 * that the untracked cache feature is unreliable on Windows
136
		 * (which is a bummer because that platform would benefit the
137
		 * most from it). For some reason, freshly created files seem
138
		 * not to update the directory's `lastModified` time
139
		 * immediately, but the untracked cache would need to rely on
140
		 * that.
141
		 *
142
		 * Therefore, with a sad heart, we disable this very useful
143
		 * feature on Windows.
144
		 */
145
		{ "core.untrackedCache", "false", 1 },
146
#endif
147
		{ "core.logAllRefUpdates", "true", 1 },
148
		{ "credential.https://dev.azure.com.useHttpPath", "true", 1 },
149
		{ "credential.validate", "false", 1 }, /* GCM4W-only */
150
		{ "gc.auto", "0", 1 },
151
		{ "gui.GCWarning", "false", 1 },
152
		{ "index.skipHash", "false", 1 },
153
		{ "index.threads", "true", 1 },
154
		{ "index.version", "4", 1 },
155
		{ "merge.stat", "false", 1 },
156
		{ "merge.renames", "true", 1 },
157
		{ "pack.useBitmaps", "false", 1 },
158
		{ "pack.useSparse", "true", 1 },
159
		{ "receive.autoGC", "false", 1 },
160
		{ "feature.manyFiles", "false", 1 },
161
		{ "feature.experimental", "false", 1 },
162
		{ "fetch.unpackLimit", "1", 1 },
163
		{ "fetch.writeCommitGraph", "false", 1 },
164
#ifdef WIN32
165
		{ "http.sslBackend", "schannel", 1 },
166
#endif
167
		/* Optional */
168
		{ "status.aheadBehind", "false" },
169
		{ "commitGraph.generationVersion", "1" },
170
		{ "core.autoCRLF", "false" },
171
		{ "core.safeCRLF", "false" },
172
		{ "fetch.showForcedUpdates", "false" },
173
		{ NULL, NULL },
174
	};
175
	int i;
176
	char *value;
177

178
	for (i = 0; config[i].key; i++) {
179
		if (set_scalar_config(config + i, reconfigure))
180
			return error(_("could not configure %s=%s"),
181
				     config[i].key, config[i].value);
182
	}
183

184
	if (have_fsmonitor_support()) {
185
		struct scalar_config fsmonitor = { "core.fsmonitor", "true" };
186
		if (set_scalar_config(&fsmonitor, reconfigure))
187
			return error(_("could not configure %s=%s"),
188
				     fsmonitor.key, fsmonitor.value);
189
	}
190

191
	/*
192
	 * The `log.excludeDecoration` setting is special because it allows
193
	 * for multiple values.
194
	 */
195
	if (git_config_get_string("log.excludeDecoration", &value)) {
196
		trace2_data_string("scalar", the_repository,
197
				   "log.excludeDecoration", "created");
198
		if (git_config_set_multivar_gently("log.excludeDecoration",
199
						   "refs/prefetch/*",
200
						   CONFIG_REGEX_NONE, 0))
201
			return error(_("could not configure "
202
				       "log.excludeDecoration"));
203
	} else {
204
		trace2_data_string("scalar", the_repository,
205
				   "log.excludeDecoration", "exists");
206
		free(value);
207
	}
208

209
	return 0;
210
}
211

212
static int toggle_maintenance(int enable)
213
{
214
	return run_git("maintenance",
215
		       enable ? "start" : "unregister",
216
		       enable ? NULL : "--force",
217
		       NULL);
218
}
219

220
static int add_or_remove_enlistment(int add)
221
{
222
	int res;
223

224
	if (!the_repository->worktree)
225
		die(_("Scalar enlistments require a worktree"));
226

227
	res = run_git("config", "--global", "--get", "--fixed-value",
228
		      "scalar.repo", the_repository->worktree, NULL);
229

230
	/*
231
	 * If we want to add and the setting is already there, then do nothing.
232
	 * If we want to remove and the setting is not there, then do nothing.
233
	 */
234
	if ((add && !res) || (!add && res))
235
		return 0;
236

237
	return run_git("config", "--global", add ? "--add" : "--unset",
238
		       add ? "--no-fixed-value" : "--fixed-value",
239
		       "scalar.repo", the_repository->worktree, NULL);
240
}
241

242
static int start_fsmonitor_daemon(void)
243
{
244
	assert(have_fsmonitor_support());
245

246
	if (fsmonitor_ipc__get_state() != IPC_STATE__LISTENING)
247
		return run_git("fsmonitor--daemon", "start", NULL);
248

249
	return 0;
250
}
251

252
static int stop_fsmonitor_daemon(void)
253
{
254
	assert(have_fsmonitor_support());
255

256
	if (fsmonitor_ipc__get_state() == IPC_STATE__LISTENING)
257
		return run_git("fsmonitor--daemon", "stop", NULL);
258

259
	return 0;
260
}
261

262
static int register_dir(void)
263
{
264
	if (add_or_remove_enlistment(1))
265
		return error(_("could not add enlistment"));
266

267
	if (set_recommended_config(0))
268
		return error(_("could not set recommended config"));
269

270
	if (toggle_maintenance(1))
271
		warning(_("could not turn on maintenance"));
272

273
	if (have_fsmonitor_support() && start_fsmonitor_daemon()) {
274
		return error(_("could not start the FSMonitor daemon"));
275
	}
276

277
	return 0;
278
}
279

280
static int unregister_dir(void)
281
{
282
	int res = 0;
283

284
	if (toggle_maintenance(0))
285
		res = error(_("could not turn off maintenance"));
286

287
	if (add_or_remove_enlistment(0))
288
		res = error(_("could not remove enlistment"));
289

290
	return res;
291
}
292

293
/* printf-style interface, expects `<key>=<value>` argument */
294
__attribute__((format (printf, 1, 2)))
295
static int set_config(const char *fmt, ...)
296
{
297
	struct strbuf buf = STRBUF_INIT;
298
	char *value;
299
	int res;
300
	va_list args;
301

302
	va_start(args, fmt);
303
	strbuf_vaddf(&buf, fmt, args);
304
	va_end(args);
305

306
	value = strchr(buf.buf, '=');
307
	if (value)
308
		*(value++) = '\0';
309
	res = git_config_set_gently(buf.buf, value);
310
	strbuf_release(&buf);
311

312
	return res;
313
}
314

315
static char *remote_default_branch(const char *url)
316
{
317
	struct child_process cp = CHILD_PROCESS_INIT;
318
	struct strbuf out = STRBUF_INIT;
319

320
	cp.git_cmd = 1;
321
	strvec_pushl(&cp.args, "ls-remote", "--symref", url, "HEAD", NULL);
322
	if (!pipe_command(&cp, NULL, 0, &out, 0, NULL, 0)) {
323
		const char *line = out.buf;
324

325
		while (*line) {
326
			const char *eol = strchrnul(line, '\n'), *p;
327
			size_t len = eol - line;
328
			char *branch;
329

330
			if (!skip_prefix(line, "ref: ", &p) ||
331
			    !strip_suffix_mem(line, &len, "\tHEAD")) {
332
				line = eol + (*eol == '\n');
333
				continue;
334
			}
335

336
			eol = line + len;
337
			if (skip_prefix(p, "refs/heads/", &p)) {
338
				branch = xstrndup(p, eol - p);
339
				strbuf_release(&out);
340
				return branch;
341
			}
342

343
			error(_("remote HEAD is not a branch: '%.*s'"),
344
			      (int)(eol - p), p);
345
			strbuf_release(&out);
346
			return NULL;
347
		}
348
	}
349
	warning(_("failed to get default branch name from remote; "
350
		  "using local default"));
351
	strbuf_reset(&out);
352

353
	child_process_init(&cp);
354
	cp.git_cmd = 1;
355
	strvec_pushl(&cp.args, "symbolic-ref", "--short", "HEAD", NULL);
356
	if (!pipe_command(&cp, NULL, 0, &out, 0, NULL, 0)) {
357
		strbuf_trim(&out);
358
		return strbuf_detach(&out, NULL);
359
	}
360

361
	strbuf_release(&out);
362
	error(_("failed to get default branch name"));
363
	return NULL;
364
}
365

366
static int delete_enlistment(struct strbuf *enlistment)
367
{
368
	struct strbuf parent = STRBUF_INIT;
369
	size_t offset;
370
	char *path_sep;
371

372
	if (unregister_dir())
373
		return error(_("failed to unregister repository"));
374

375
	/*
376
	 * Change the current directory to one outside of the enlistment so
377
	 * that we may delete everything underneath it.
378
	 */
379
	offset = offset_1st_component(enlistment->buf);
380
	path_sep = find_last_dir_sep(enlistment->buf + offset);
381
	strbuf_add(&parent, enlistment->buf,
382
		   path_sep ? path_sep - enlistment->buf : offset);
383
	if (chdir(parent.buf) < 0) {
384
		int res = error_errno(_("could not switch to '%s'"), parent.buf);
385
		strbuf_release(&parent);
386
		return res;
387
	}
388
	strbuf_release(&parent);
389

390
	if (have_fsmonitor_support() && stop_fsmonitor_daemon())
391
		return error(_("failed to stop the FSMonitor daemon"));
392

393
	if (remove_dir_recursively(enlistment, 0))
394
		return error(_("failed to delete enlistment directory"));
395

396
	return 0;
397
}
398

399
/*
400
 * Dummy implementation; Using `get_version_info()` would cause a link error
401
 * without this.
402
 */
403
void load_builtin_commands(const char *prefix UNUSED,
404
			   struct cmdnames *cmds UNUSED)
405
{
406
	die("not implemented");
407
}
408

409
static int cmd_clone(int argc, const char **argv)
410
{
411
	const char *branch = NULL;
412
	int full_clone = 0, single_branch = 0, show_progress = isatty(2);
413
	int src = 1;
414
	struct option clone_options[] = {
415
		OPT_STRING('b', "branch", &branch, N_("<branch>"),
416
			   N_("branch to checkout after clone")),
417
		OPT_BOOL(0, "full-clone", &full_clone,
418
			 N_("when cloning, create full working directory")),
419
		OPT_BOOL(0, "single-branch", &single_branch,
420
			 N_("only download metadata for the branch that will "
421
			    "be checked out")),
422
		OPT_BOOL(0, "src", &src,
423
			 N_("create repository within 'src' directory")),
424
		OPT_END(),
425
	};
426
	const char * const clone_usage[] = {
427
		N_("scalar clone [--single-branch] [--branch <main-branch>] [--full-clone]\n"
428
		   "\t[--[no-]src] <url> [<enlistment>]"),
429
		NULL
430
	};
431
	const char *url;
432
	char *enlistment = NULL, *dir = NULL;
433
	struct strbuf buf = STRBUF_INIT;
434
	int res;
435

436
	argc = parse_options(argc, argv, NULL, clone_options, clone_usage, 0);
437

438
	if (argc == 2) {
439
		url = argv[0];
440
		enlistment = xstrdup(argv[1]);
441
	} else if (argc == 1) {
442
		url = argv[0];
443

444
		strbuf_addstr(&buf, url);
445
		/* Strip trailing slashes, if any */
446
		while (buf.len > 0 && is_dir_sep(buf.buf[buf.len - 1]))
447
			strbuf_setlen(&buf, buf.len - 1);
448
		/* Strip suffix `.git`, if any */
449
		strbuf_strip_suffix(&buf, ".git");
450

451
		enlistment = find_last_dir_sep(buf.buf);
452
		if (!enlistment) {
453
			die(_("cannot deduce worktree name from '%s'"), url);
454
		}
455
		enlistment = xstrdup(enlistment + 1);
456
	} else {
457
		usage_msg_opt(_("You must specify a repository to clone."),
458
			      clone_usage, clone_options);
459
	}
460

461
	if (is_directory(enlistment))
462
		die(_("directory '%s' exists already"), enlistment);
463

464
	if (src)
465
		dir = xstrfmt("%s/src", enlistment);
466
	else
467
		dir = xstrdup(enlistment);
468

469
	strbuf_reset(&buf);
470
	if (branch)
471
		strbuf_addf(&buf, "init.defaultBranch=%s", branch);
472
	else {
473
		char *b = repo_default_branch_name(the_repository, 1);
474
		strbuf_addf(&buf, "init.defaultBranch=%s", b);
475
		free(b);
476
	}
477

478
	if ((res = run_git("-c", buf.buf, "init", "--", dir, NULL)))
479
		goto cleanup;
480

481
	if (chdir(dir) < 0) {
482
		res = error_errno(_("could not switch to '%s'"), dir);
483
		goto cleanup;
484
	}
485

486
	setup_git_directory();
487

488
	/* common-main already logs `argv` */
489
	trace2_def_repo(the_repository);
490

491
	if (!branch && !(branch = remote_default_branch(url))) {
492
		res = error(_("failed to get default branch for '%s'"), url);
493
		goto cleanup;
494
	}
495

496
	if (set_config("remote.origin.url=%s", url) ||
497
	    set_config("remote.origin.fetch="
498
		       "+refs/heads/%s:refs/remotes/origin/%s",
499
		       single_branch ? branch : "*",
500
		       single_branch ? branch : "*") ||
501
	    set_config("remote.origin.promisor=true") ||
502
	    set_config("remote.origin.partialCloneFilter=blob:none")) {
503
		res = error(_("could not configure remote in '%s'"), dir);
504
		goto cleanup;
505
	}
506

507
	if (!full_clone &&
508
	    (res = run_git("sparse-checkout", "init", "--cone", NULL)))
509
		goto cleanup;
510

511
	if (set_recommended_config(0))
512
		return error(_("could not configure '%s'"), dir);
513

514
	if ((res = run_git("fetch", "--quiet",
515
				show_progress ? "--progress" : "--no-progress",
516
				"origin", NULL))) {
517
		warning(_("partial clone failed; attempting full clone"));
518

519
		if (set_config("remote.origin.promisor") ||
520
		    set_config("remote.origin.partialCloneFilter")) {
521
			res = error(_("could not configure for full clone"));
522
			goto cleanup;
523
		}
524

525
		if ((res = run_git("fetch", "--quiet",
526
					show_progress ? "--progress" : "--no-progress",
527
					"origin", NULL)))
528
			goto cleanup;
529
	}
530

531
	if ((res = set_config("branch.%s.remote=origin", branch)))
532
		goto cleanup;
533
	if ((res = set_config("branch.%s.merge=refs/heads/%s",
534
			      branch, branch)))
535
		goto cleanup;
536

537
	strbuf_reset(&buf);
538
	strbuf_addf(&buf, "origin/%s", branch);
539
	res = run_git("checkout", "-f", "-t", buf.buf, NULL);
540
	if (res)
541
		goto cleanup;
542

543
	res = register_dir();
544

545
cleanup:
546
	free(enlistment);
547
	free(dir);
548
	strbuf_release(&buf);
549
	return res;
550
}
551

552
static int cmd_diagnose(int argc, const char **argv)
553
{
554
	struct option options[] = {
555
		OPT_END(),
556
	};
557
	const char * const usage[] = {
558
		N_("scalar diagnose [<enlistment>]"),
559
		NULL
560
	};
561
	struct strbuf diagnostics_root = STRBUF_INIT;
562
	int res = 0;
563

564
	argc = parse_options(argc, argv, NULL, options,
565
			     usage, 0);
566

567
	setup_enlistment_directory(argc, argv, usage, options, &diagnostics_root);
568
	strbuf_addstr(&diagnostics_root, "/.scalarDiagnostics");
569

570
	res = run_git("diagnose", "--mode=all", "-s", "%Y%m%d_%H%M%S",
571
		      "-o", diagnostics_root.buf, NULL);
572

573
	strbuf_release(&diagnostics_root);
574
	return res;
575
}
576

577
static int cmd_list(int argc, const char **argv UNUSED)
578
{
579
	if (argc != 1)
580
		die(_("`scalar list` does not take arguments"));
581

582
	if (run_git("config", "--global", "--get-all", "scalar.repo", NULL) < 0)
583
		return -1;
584
	return 0;
585
}
586

587
static int cmd_register(int argc, const char **argv)
588
{
589
	struct option options[] = {
590
		OPT_END(),
591
	};
592
	const char * const usage[] = {
593
		N_("scalar register [<enlistment>]"),
594
		NULL
595
	};
596

597
	argc = parse_options(argc, argv, NULL, options,
598
			     usage, 0);
599

600
	setup_enlistment_directory(argc, argv, usage, options, NULL);
601

602
	return register_dir();
603
}
604

605
static int get_scalar_repos(const char *key, const char *value,
606
			    const struct config_context *ctx UNUSED,
607
			    void *data)
608
{
609
	struct string_list *list = data;
610

611
	if (!strcmp(key, "scalar.repo"))
612
		string_list_append(list, value);
613

614
	return 0;
615
}
616

617
static int remove_deleted_enlistment(struct strbuf *path)
618
{
619
	int res = 0;
620
	strbuf_realpath_forgiving(path, path->buf, 1);
621

622
	if (run_git("config", "--global",
623
		    "--unset", "--fixed-value",
624
		    "scalar.repo", path->buf, NULL) < 0)
625
		res = -1;
626

627
	if (run_git("config", "--global",
628
		    "--unset", "--fixed-value",
629
		    "maintenance.repo", path->buf, NULL) < 0)
630
		res = -1;
631

632
	return res;
633
}
634

635
static int cmd_reconfigure(int argc, const char **argv)
636
{
637
	int all = 0;
638
	struct option options[] = {
639
		OPT_BOOL('a', "all", &all,
640
			 N_("reconfigure all registered enlistments")),
641
		OPT_END(),
642
	};
643
	const char * const usage[] = {
644
		N_("scalar reconfigure [--all | <enlistment>]"),
645
		NULL
646
	};
647
	struct string_list scalar_repos = STRING_LIST_INIT_DUP;
648
	int i, res = 0;
649
	struct strbuf commondir = STRBUF_INIT, gitdir = STRBUF_INIT;
650

651
	argc = parse_options(argc, argv, NULL, options,
652
			     usage, 0);
653

654
	if (!all) {
655
		setup_enlistment_directory(argc, argv, usage, options, NULL);
656

657
		return set_recommended_config(1);
658
	}
659

660
	if (argc > 0)
661
		usage_msg_opt(_("--all or <enlistment>, but not both"),
662
			      usage, options);
663

664
	git_config(get_scalar_repos, &scalar_repos);
665

666
	for (i = 0; i < scalar_repos.nr; i++) {
667
		int succeeded = 0;
668
		struct repository *old_repo, r = { NULL };
669
		const char *dir = scalar_repos.items[i].string;
670

671
		strbuf_reset(&commondir);
672
		strbuf_reset(&gitdir);
673

674
		if (chdir(dir) < 0) {
675
			struct strbuf buf = STRBUF_INIT;
676

677
			if (errno != ENOENT) {
678
				warning_errno(_("could not switch to '%s'"), dir);
679
				goto loop_end;
680
			}
681

682
			strbuf_addstr(&buf, dir);
683
			if (remove_deleted_enlistment(&buf))
684
				error(_("could not remove stale "
685
					"scalar.repo '%s'"), dir);
686
			else {
687
				warning(_("removed stale scalar.repo '%s'"),
688
					dir);
689
				succeeded = 1;
690
			}
691
			strbuf_release(&buf);
692
			goto loop_end;
693
		}
694

695
		switch (discover_git_directory_reason(&commondir, &gitdir)) {
696
		case GIT_DIR_INVALID_OWNERSHIP:
697
			warning(_("repository at '%s' has different owner"), dir);
698
			goto loop_end;
699

700
		case GIT_DIR_INVALID_GITFILE:
701
		case GIT_DIR_INVALID_FORMAT:
702
			warning(_("repository at '%s' has a format issue"), dir);
703
			goto loop_end;
704

705
		case GIT_DIR_DISCOVERED:
706
			succeeded = 1;
707
			break;
708

709
		default:
710
			warning(_("repository not found in '%s'"), dir);
711
			break;
712
		}
713

714
		git_config_clear();
715

716
		if (repo_init(&r, gitdir.buf, commondir.buf))
717
			goto loop_end;
718

719
		old_repo = the_repository;
720
		the_repository = &r;
721

722
		if (set_recommended_config(1) >= 0)
723
			succeeded = 1;
724

725
		the_repository = old_repo;
726

727
loop_end:
728
		if (!succeeded) {
729
			res = -1;
730
			warning(_("to unregister this repository from Scalar, run\n"
731
				  "\tgit config --global --unset --fixed-value scalar.repo \"%s\""),
732
				dir);
733
		}
734
	}
735

736
	string_list_clear(&scalar_repos, 1);
737
	strbuf_release(&commondir);
738
	strbuf_release(&gitdir);
739

740
	return res;
741
}
742

743
static int cmd_run(int argc, const char **argv)
744
{
745
	struct option options[] = {
746
		OPT_END(),
747
	};
748
	struct {
749
		const char *arg, *task;
750
	} tasks[] = {
751
		{ "config", NULL },
752
		{ "commit-graph", "commit-graph" },
753
		{ "fetch", "prefetch" },
754
		{ "loose-objects", "loose-objects" },
755
		{ "pack-files", "incremental-repack" },
756
		{ NULL, NULL }
757
	};
758
	struct strbuf buf = STRBUF_INIT;
759
	const char *usagestr[] = { NULL, NULL };
760
	int i;
761

762
	strbuf_addstr(&buf, N_("scalar run <task> [<enlistment>]\nTasks:\n"));
763
	for (i = 0; tasks[i].arg; i++)
764
		strbuf_addf(&buf, "\t%s\n", tasks[i].arg);
765
	usagestr[0] = buf.buf;
766

767
	argc = parse_options(argc, argv, NULL, options,
768
			     usagestr, 0);
769

770
	if (!argc)
771
		usage_with_options(usagestr, options);
772

773
	if (!strcmp("all", argv[0])) {
774
		i = -1;
775
	} else {
776
		for (i = 0; tasks[i].arg && strcmp(tasks[i].arg, argv[0]); i++)
777
			; /* keep looking for the task */
778

779
		if (i > 0 && !tasks[i].arg) {
780
			error(_("no such task: '%s'"), argv[0]);
781
			usage_with_options(usagestr, options);
782
		}
783
	}
784

785
	argc--;
786
	argv++;
787
	setup_enlistment_directory(argc, argv, usagestr, options, NULL);
788
	strbuf_release(&buf);
789

790
	if (i == 0)
791
		return register_dir();
792

793
	if (i > 0)
794
		return run_git("maintenance", "run",
795
			       "--task", tasks[i].task, NULL);
796

797
	if (register_dir())
798
		return -1;
799
	for (i = 1; tasks[i].arg; i++)
800
		if (run_git("maintenance", "run",
801
			    "--task", tasks[i].task, NULL))
802
			return -1;
803
	return 0;
804
}
805

806
static int cmd_unregister(int argc, const char **argv)
807
{
808
	struct option options[] = {
809
		OPT_END(),
810
	};
811
	const char * const usage[] = {
812
		N_("scalar unregister [<enlistment>]"),
813
		NULL
814
	};
815

816
	argc = parse_options(argc, argv, NULL, options,
817
			     usage, 0);
818

819
	/*
820
	 * Be forgiving when the enlistment or worktree does not even exist any
821
	 * longer; This can be the case if a user deleted the worktree by
822
	 * mistake and _still_ wants to unregister the thing.
823
	 */
824
	if (argc == 1) {
825
		struct strbuf src_path = STRBUF_INIT, workdir_path = STRBUF_INIT;
826

827
		strbuf_addf(&src_path, "%s/src/.git", argv[0]);
828
		strbuf_addf(&workdir_path, "%s/.git", argv[0]);
829
		if (!is_directory(src_path.buf) && !is_directory(workdir_path.buf)) {
830
			/* remove possible matching registrations */
831
			int res = -1;
832

833
			strbuf_strip_suffix(&src_path, "/.git");
834
			res = remove_deleted_enlistment(&src_path) && res;
835

836
			strbuf_strip_suffix(&workdir_path, "/.git");
837
			res = remove_deleted_enlistment(&workdir_path) && res;
838

839
			strbuf_release(&src_path);
840
			strbuf_release(&workdir_path);
841
			return res;
842
		}
843
		strbuf_release(&src_path);
844
		strbuf_release(&workdir_path);
845
	}
846

847
	setup_enlistment_directory(argc, argv, usage, options, NULL);
848

849
	return unregister_dir();
850
}
851

852
static int cmd_delete(int argc, const char **argv)
853
{
854
	char *cwd = xgetcwd();
855
	struct option options[] = {
856
		OPT_END(),
857
	};
858
	const char * const usage[] = {
859
		N_("scalar delete <enlistment>"),
860
		NULL
861
	};
862
	struct strbuf enlistment = STRBUF_INIT;
863
	int res = 0;
864

865
	argc = parse_options(argc, argv, NULL, options,
866
			     usage, 0);
867

868
	if (argc != 1)
869
		usage_with_options(usage, options);
870

871
	setup_enlistment_directory(argc, argv, usage, options, &enlistment);
872

873
	if (dir_inside_of(cwd, enlistment.buf) >= 0)
874
		res = error(_("refusing to delete current working directory"));
875
	else {
876
		close_object_store(the_repository->objects);
877
		res = delete_enlistment(&enlistment);
878
	}
879
	strbuf_release(&enlistment);
880
	free(cwd);
881

882
	return res;
883
}
884

885
static int cmd_help(int argc, const char **argv)
886
{
887
	struct option options[] = {
888
		OPT_END(),
889
	};
890
	const char * const usage[] = {
891
		"scalar help",
892
		NULL
893
	};
894

895
	argc = parse_options(argc, argv, NULL, options,
896
			     usage, 0);
897

898
	if (argc != 0)
899
		usage_with_options(usage, options);
900

901
	return run_git("help", "scalar", NULL);
902
}
903

904
static int cmd_version(int argc, const char **argv)
905
{
906
	int verbose = 0, build_options = 0;
907
	struct option options[] = {
908
		OPT__VERBOSE(&verbose, N_("include Git version")),
909
		OPT_BOOL(0, "build-options", &build_options,
910
			 N_("include Git's build options")),
911
		OPT_END(),
912
	};
913
	const char * const usage[] = {
914
		N_("scalar verbose [-v | --verbose] [--build-options]"),
915
		NULL
916
	};
917
	struct strbuf buf = STRBUF_INIT;
918

919
	argc = parse_options(argc, argv, NULL, options,
920
			     usage, 0);
921

922
	if (argc != 0)
923
		usage_with_options(usage, options);
924

925
	get_version_info(&buf, build_options);
926
	fprintf(stderr, "%s\n", buf.buf);
927
	strbuf_release(&buf);
928

929
	return 0;
930
}
931

932
static struct {
933
	const char *name;
934
	int (*fn)(int, const char **);
935
} builtins[] = {
936
	{ "clone", cmd_clone },
937
	{ "list", cmd_list },
938
	{ "register", cmd_register },
939
	{ "unregister", cmd_unregister },
940
	{ "run", cmd_run },
941
	{ "reconfigure", cmd_reconfigure },
942
	{ "delete", cmd_delete },
943
	{ "help", cmd_help },
944
	{ "version", cmd_version },
945
	{ "diagnose", cmd_diagnose },
946
	{ NULL, NULL},
947
};
948

949
int cmd_main(int argc, const char **argv)
950
{
951
	struct strbuf scalar_usage = STRBUF_INIT;
952
	int i;
953

954
	while (argc > 1 && *argv[1] == '-') {
955
		if (!strcmp(argv[1], "-C")) {
956
			if (argc < 3)
957
				die(_("-C requires a <directory>"));
958
			if (chdir(argv[2]) < 0)
959
				die_errno(_("could not change to '%s'"),
960
					  argv[2]);
961
			argc -= 2;
962
			argv += 2;
963
		} else if (!strcmp(argv[1], "-c")) {
964
			if (argc < 3)
965
				die(_("-c requires a <key>=<value> argument"));
966
			git_config_push_parameter(argv[2]);
967
			argc -= 2;
968
			argv += 2;
969
		} else
970
			break;
971
	}
972

973
	if (argc > 1) {
974
		argv++;
975
		argc--;
976

977
		for (i = 0; builtins[i].name; i++)
978
			if (!strcmp(builtins[i].name, argv[0]))
979
				return !!builtins[i].fn(argc, argv);
980
	}
981

982
	strbuf_addstr(&scalar_usage,
983
		      N_("scalar [-C <directory>] [-c <key>=<value>] "
984
			 "<command> [<options>]\n\nCommands:\n"));
985
	for (i = 0; builtins[i].name; i++)
986
		strbuf_addf(&scalar_usage, "\t%s\n", builtins[i].name);
987

988
	usage(scalar_usage.buf);
989
}
990