strvec: drop unnecessary include of hex.h
[alt-git.git] / scalar.c
blobdf7358f481cc2d6fd307a27f0bfc5bd070daefd5
1 /*
2 * The Scalar command-line interface.
3 */
5 #include "git-compat-util.h"
6 #include "abspath.h"
7 #include "gettext.h"
8 #include "parse-options.h"
9 #include "config.h"
10 #include "run-command.h"
11 #include "simple-ipc.h"
12 #include "fsmonitor-ipc.h"
13 #include "fsmonitor-settings.h"
14 #include "refs.h"
15 #include "dir.h"
16 #include "packfile.h"
17 #include "help.h"
18 #include "setup.h"
19 #include "trace2.h"
21 static void setup_enlistment_directory(int argc, const char **argv,
22 const char * const *usagestr,
23 const struct option *options,
24 struct strbuf *enlistment_root)
26 struct strbuf path = STRBUF_INIT;
27 int enlistment_is_repo_parent = 0;
28 size_t len;
30 if (startup_info->have_repository)
31 BUG("gitdir already set up?!?");
33 if (argc > 1)
34 usage_with_options(usagestr, options);
36 /* find the worktree, determine its corresponding root */
37 if (argc == 1) {
38 strbuf_add_absolute_path(&path, argv[0]);
39 if (!is_directory(path.buf))
40 die(_("'%s' does not exist"), path.buf);
41 if (chdir(path.buf) < 0)
42 die_errno(_("could not switch to '%s'"), path.buf);
43 } else if (strbuf_getcwd(&path) < 0)
44 die(_("need a working directory"));
46 strbuf_trim_trailing_dir_sep(&path);
48 /* check if currently in enlistment root with src/ workdir */
49 len = path.len;
50 strbuf_addstr(&path, "/src");
51 if (is_nonbare_repository_dir(&path)) {
52 enlistment_is_repo_parent = 1;
53 if (chdir(path.buf) < 0)
54 die_errno(_("could not switch to '%s'"), path.buf);
56 strbuf_setlen(&path, len);
58 setup_git_directory();
60 if (!the_repository->worktree)
61 die(_("Scalar enlistments require a worktree"));
63 if (enlistment_root) {
64 if (enlistment_is_repo_parent)
65 strbuf_addbuf(enlistment_root, &path);
66 else
67 strbuf_addstr(enlistment_root, the_repository->worktree);
70 strbuf_release(&path);
73 static int run_git(const char *arg, ...)
75 struct child_process cmd = CHILD_PROCESS_INIT;
76 va_list args;
77 const char *p;
79 va_start(args, arg);
80 strvec_push(&cmd.args, arg);
81 while ((p = va_arg(args, const char *)))
82 strvec_push(&cmd.args, p);
83 va_end(args);
85 cmd.git_cmd = 1;
86 return run_command(&cmd);
89 struct scalar_config {
90 const char *key;
91 const char *value;
92 int overwrite_on_reconfigure;
95 static int set_scalar_config(const struct scalar_config *config, int reconfigure)
97 char *value = NULL;
98 int res;
100 if ((reconfigure && config->overwrite_on_reconfigure) ||
101 git_config_get_string(config->key, &value)) {
102 trace2_data_string("scalar", the_repository, config->key, "created");
103 res = git_config_set_gently(config->key, config->value);
104 } else {
105 trace2_data_string("scalar", the_repository, config->key, "exists");
106 res = 0;
109 free(value);
110 return res;
113 static int have_fsmonitor_support(void)
115 return fsmonitor_ipc__is_supported() &&
116 fsm_settings__get_reason(the_repository) == FSMONITOR_REASON_OK;
119 static int set_recommended_config(int reconfigure)
121 struct scalar_config config[] = {
122 /* Required */
123 { "am.keepCR", "true", 1 },
124 { "core.FSCache", "true", 1 },
125 { "core.multiPackIndex", "true", 1 },
126 { "core.preloadIndex", "true", 1 },
127 #ifndef WIN32
128 { "core.untrackedCache", "true", 1 },
129 #else
131 * Unfortunately, Scalar's Functional Tests demonstrated
132 * that the untracked cache feature is unreliable on Windows
133 * (which is a bummer because that platform would benefit the
134 * most from it). For some reason, freshly created files seem
135 * not to update the directory's `lastModified` time
136 * immediately, but the untracked cache would need to rely on
137 * that.
139 * Therefore, with a sad heart, we disable this very useful
140 * feature on Windows.
142 { "core.untrackedCache", "false", 1 },
143 #endif
144 { "core.logAllRefUpdates", "true", 1 },
145 { "credential.https://dev.azure.com.useHttpPath", "true", 1 },
146 { "credential.validate", "false", 1 }, /* GCM4W-only */
147 { "gc.auto", "0", 1 },
148 { "gui.GCWarning", "false", 1 },
149 { "index.skipHash", "false", 1 },
150 { "index.threads", "true", 1 },
151 { "index.version", "4", 1 },
152 { "merge.stat", "false", 1 },
153 { "merge.renames", "true", 1 },
154 { "pack.useBitmaps", "false", 1 },
155 { "pack.useSparse", "true", 1 },
156 { "receive.autoGC", "false", 1 },
157 { "feature.manyFiles", "false", 1 },
158 { "feature.experimental", "false", 1 },
159 { "fetch.unpackLimit", "1", 1 },
160 { "fetch.writeCommitGraph", "false", 1 },
161 #ifdef WIN32
162 { "http.sslBackend", "schannel", 1 },
163 #endif
164 /* Optional */
165 { "status.aheadBehind", "false" },
166 { "commitGraph.generationVersion", "1" },
167 { "core.autoCRLF", "false" },
168 { "core.safeCRLF", "false" },
169 { "fetch.showForcedUpdates", "false" },
170 { NULL, NULL },
172 int i;
173 char *value;
175 for (i = 0; config[i].key; i++) {
176 if (set_scalar_config(config + i, reconfigure))
177 return error(_("could not configure %s=%s"),
178 config[i].key, config[i].value);
181 if (have_fsmonitor_support()) {
182 struct scalar_config fsmonitor = { "core.fsmonitor", "true" };
183 if (set_scalar_config(&fsmonitor, reconfigure))
184 return error(_("could not configure %s=%s"),
185 fsmonitor.key, fsmonitor.value);
189 * The `log.excludeDecoration` setting is special because it allows
190 * for multiple values.
192 if (git_config_get_string("log.excludeDecoration", &value)) {
193 trace2_data_string("scalar", the_repository,
194 "log.excludeDecoration", "created");
195 if (git_config_set_multivar_gently("log.excludeDecoration",
196 "refs/prefetch/*",
197 CONFIG_REGEX_NONE, 0))
198 return error(_("could not configure "
199 "log.excludeDecoration"));
200 } else {
201 trace2_data_string("scalar", the_repository,
202 "log.excludeDecoration", "exists");
203 free(value);
206 return 0;
209 static int toggle_maintenance(int enable)
211 return run_git("maintenance",
212 enable ? "start" : "unregister",
213 enable ? NULL : "--force",
214 NULL);
217 static int add_or_remove_enlistment(int add)
219 int res;
221 if (!the_repository->worktree)
222 die(_("Scalar enlistments require a worktree"));
224 res = run_git("config", "--global", "--get", "--fixed-value",
225 "scalar.repo", the_repository->worktree, NULL);
228 * If we want to add and the setting is already there, then do nothing.
229 * If we want to remove and the setting is not there, then do nothing.
231 if ((add && !res) || (!add && res))
232 return 0;
234 return run_git("config", "--global", add ? "--add" : "--unset",
235 add ? "--no-fixed-value" : "--fixed-value",
236 "scalar.repo", the_repository->worktree, NULL);
239 static int start_fsmonitor_daemon(void)
241 assert(have_fsmonitor_support());
243 if (fsmonitor_ipc__get_state() != IPC_STATE__LISTENING)
244 return run_git("fsmonitor--daemon", "start", NULL);
246 return 0;
249 static int stop_fsmonitor_daemon(void)
251 assert(have_fsmonitor_support());
253 if (fsmonitor_ipc__get_state() == IPC_STATE__LISTENING)
254 return run_git("fsmonitor--daemon", "stop", NULL);
256 return 0;
259 static int register_dir(void)
261 if (add_or_remove_enlistment(1))
262 return error(_("could not add enlistment"));
264 if (set_recommended_config(0))
265 return error(_("could not set recommended config"));
267 if (toggle_maintenance(1))
268 warning(_("could not turn on maintenance"));
270 if (have_fsmonitor_support() && start_fsmonitor_daemon()) {
271 return error(_("could not start the FSMonitor daemon"));
274 return 0;
277 static int unregister_dir(void)
279 int res = 0;
281 if (toggle_maintenance(0))
282 res = error(_("could not turn off maintenance"));
284 if (add_or_remove_enlistment(0))
285 res = error(_("could not remove enlistment"));
287 return res;
290 /* printf-style interface, expects `<key>=<value>` argument */
291 static int set_config(const char *fmt, ...)
293 struct strbuf buf = STRBUF_INIT;
294 char *value;
295 int res;
296 va_list args;
298 va_start(args, fmt);
299 strbuf_vaddf(&buf, fmt, args);
300 va_end(args);
302 value = strchr(buf.buf, '=');
303 if (value)
304 *(value++) = '\0';
305 res = git_config_set_gently(buf.buf, value);
306 strbuf_release(&buf);
308 return res;
311 static char *remote_default_branch(const char *url)
313 struct child_process cp = CHILD_PROCESS_INIT;
314 struct strbuf out = STRBUF_INIT;
316 cp.git_cmd = 1;
317 strvec_pushl(&cp.args, "ls-remote", "--symref", url, "HEAD", NULL);
318 if (!pipe_command(&cp, NULL, 0, &out, 0, NULL, 0)) {
319 const char *line = out.buf;
321 while (*line) {
322 const char *eol = strchrnul(line, '\n'), *p;
323 size_t len = eol - line;
324 char *branch;
326 if (!skip_prefix(line, "ref: ", &p) ||
327 !strip_suffix_mem(line, &len, "\tHEAD")) {
328 line = eol + (*eol == '\n');
329 continue;
332 eol = line + len;
333 if (skip_prefix(p, "refs/heads/", &p)) {
334 branch = xstrndup(p, eol - p);
335 strbuf_release(&out);
336 return branch;
339 error(_("remote HEAD is not a branch: '%.*s'"),
340 (int)(eol - p), p);
341 strbuf_release(&out);
342 return NULL;
345 warning(_("failed to get default branch name from remote; "
346 "using local default"));
347 strbuf_reset(&out);
349 child_process_init(&cp);
350 cp.git_cmd = 1;
351 strvec_pushl(&cp.args, "symbolic-ref", "--short", "HEAD", NULL);
352 if (!pipe_command(&cp, NULL, 0, &out, 0, NULL, 0)) {
353 strbuf_trim(&out);
354 return strbuf_detach(&out, NULL);
357 strbuf_release(&out);
358 error(_("failed to get default branch name"));
359 return NULL;
362 static int delete_enlistment(struct strbuf *enlistment)
364 #ifdef WIN32
365 struct strbuf parent = STRBUF_INIT;
366 size_t offset;
367 char *path_sep;
368 #endif
370 if (unregister_dir())
371 return error(_("failed to unregister repository"));
373 #ifdef WIN32
375 * Change the current directory to one outside of the enlistment so
376 * that we may delete everything underneath it.
378 offset = offset_1st_component(enlistment->buf);
379 path_sep = find_last_dir_sep(enlistment->buf + offset);
380 strbuf_add(&parent, enlistment->buf,
381 path_sep ? path_sep - enlistment->buf : offset);
382 if (chdir(parent.buf) < 0) {
383 int res = error_errno(_("could not switch to '%s'"), parent.buf);
384 strbuf_release(&parent);
385 return res;
387 strbuf_release(&parent);
388 #endif
390 if (have_fsmonitor_support() && stop_fsmonitor_daemon())
391 return error(_("failed to stop the FSMonitor daemon"));
393 if (remove_dir_recursively(enlistment, 0))
394 return error(_("failed to delete enlistment directory"));
396 return 0;
400 * Dummy implementation; Using `get_version_info()` would cause a link error
401 * without this.
403 void load_builtin_commands(const char *prefix, struct cmdnames *cmds)
405 die("not implemented");
408 static int cmd_clone(int argc, const char **argv)
410 const char *branch = NULL;
411 int full_clone = 0, single_branch = 0, show_progress = isatty(2);
412 struct option clone_options[] = {
413 OPT_STRING('b', "branch", &branch, N_("<branch>"),
414 N_("branch to checkout after clone")),
415 OPT_BOOL(0, "full-clone", &full_clone,
416 N_("when cloning, create full working directory")),
417 OPT_BOOL(0, "single-branch", &single_branch,
418 N_("only download metadata for the branch that will "
419 "be checked out")),
420 OPT_END(),
422 const char * const clone_usage[] = {
423 N_("scalar clone [<options>] [--] <repo> [<dir>]"),
424 NULL
426 const char *url;
427 char *enlistment = NULL, *dir = NULL;
428 struct strbuf buf = STRBUF_INIT;
429 int res;
431 argc = parse_options(argc, argv, NULL, clone_options, clone_usage, 0);
433 if (argc == 2) {
434 url = argv[0];
435 enlistment = xstrdup(argv[1]);
436 } else if (argc == 1) {
437 url = argv[0];
439 strbuf_addstr(&buf, url);
440 /* Strip trailing slashes, if any */
441 while (buf.len > 0 && is_dir_sep(buf.buf[buf.len - 1]))
442 strbuf_setlen(&buf, buf.len - 1);
443 /* Strip suffix `.git`, if any */
444 strbuf_strip_suffix(&buf, ".git");
446 enlistment = find_last_dir_sep(buf.buf);
447 if (!enlistment) {
448 die(_("cannot deduce worktree name from '%s'"), url);
450 enlistment = xstrdup(enlistment + 1);
451 } else {
452 usage_msg_opt(_("You must specify a repository to clone."),
453 clone_usage, clone_options);
456 if (is_directory(enlistment))
457 die(_("directory '%s' exists already"), enlistment);
459 dir = xstrfmt("%s/src", enlistment);
461 strbuf_reset(&buf);
462 if (branch)
463 strbuf_addf(&buf, "init.defaultBranch=%s", branch);
464 else {
465 char *b = repo_default_branch_name(the_repository, 1);
466 strbuf_addf(&buf, "init.defaultBranch=%s", b);
467 free(b);
470 if ((res = run_git("-c", buf.buf, "init", "--", dir, NULL)))
471 goto cleanup;
473 if (chdir(dir) < 0) {
474 res = error_errno(_("could not switch to '%s'"), dir);
475 goto cleanup;
478 setup_git_directory();
480 /* common-main already logs `argv` */
481 trace2_def_repo(the_repository);
483 if (!branch && !(branch = remote_default_branch(url))) {
484 res = error(_("failed to get default branch for '%s'"), url);
485 goto cleanup;
488 if (set_config("remote.origin.url=%s", url) ||
489 set_config("remote.origin.fetch="
490 "+refs/heads/%s:refs/remotes/origin/%s",
491 single_branch ? branch : "*",
492 single_branch ? branch : "*") ||
493 set_config("remote.origin.promisor=true") ||
494 set_config("remote.origin.partialCloneFilter=blob:none")) {
495 res = error(_("could not configure remote in '%s'"), dir);
496 goto cleanup;
499 if (!full_clone &&
500 (res = run_git("sparse-checkout", "init", "--cone", NULL)))
501 goto cleanup;
503 if (set_recommended_config(0))
504 return error(_("could not configure '%s'"), dir);
506 if ((res = run_git("fetch", "--quiet",
507 show_progress ? "--progress" : "--no-progress",
508 "origin", NULL))) {
509 warning(_("partial clone failed; attempting full clone"));
511 if (set_config("remote.origin.promisor") ||
512 set_config("remote.origin.partialCloneFilter")) {
513 res = error(_("could not configure for full clone"));
514 goto cleanup;
517 if ((res = run_git("fetch", "--quiet",
518 show_progress ? "--progress" : "--no-progress",
519 "origin", NULL)))
520 goto cleanup;
523 if ((res = set_config("branch.%s.remote=origin", branch)))
524 goto cleanup;
525 if ((res = set_config("branch.%s.merge=refs/heads/%s",
526 branch, branch)))
527 goto cleanup;
529 strbuf_reset(&buf);
530 strbuf_addf(&buf, "origin/%s", branch);
531 res = run_git("checkout", "-f", "-t", buf.buf, NULL);
532 if (res)
533 goto cleanup;
535 res = register_dir();
537 cleanup:
538 free(enlistment);
539 free(dir);
540 strbuf_release(&buf);
541 return res;
544 static int cmd_diagnose(int argc, const char **argv)
546 struct option options[] = {
547 OPT_END(),
549 const char * const usage[] = {
550 N_("scalar diagnose [<enlistment>]"),
551 NULL
553 struct strbuf diagnostics_root = STRBUF_INIT;
554 int res = 0;
556 argc = parse_options(argc, argv, NULL, options,
557 usage, 0);
559 setup_enlistment_directory(argc, argv, usage, options, &diagnostics_root);
560 strbuf_addstr(&diagnostics_root, "/.scalarDiagnostics");
562 res = run_git("diagnose", "--mode=all", "-s", "%Y%m%d_%H%M%S",
563 "-o", diagnostics_root.buf, NULL);
565 strbuf_release(&diagnostics_root);
566 return res;
569 static int cmd_list(int argc, const char **argv UNUSED)
571 if (argc != 1)
572 die(_("`scalar list` does not take arguments"));
574 if (run_git("config", "--global", "--get-all", "scalar.repo", NULL) < 0)
575 return -1;
576 return 0;
579 static int cmd_register(int argc, const char **argv)
581 struct option options[] = {
582 OPT_END(),
584 const char * const usage[] = {
585 N_("scalar register [<enlistment>]"),
586 NULL
589 argc = parse_options(argc, argv, NULL, options,
590 usage, 0);
592 setup_enlistment_directory(argc, argv, usage, options, NULL);
594 return register_dir();
597 static int get_scalar_repos(const char *key, const char *value,
598 const struct config_context *ctx UNUSED,
599 void *data)
601 struct string_list *list = data;
603 if (!strcmp(key, "scalar.repo"))
604 string_list_append(list, value);
606 return 0;
609 static int remove_deleted_enlistment(struct strbuf *path)
611 int res = 0;
612 strbuf_realpath_forgiving(path, path->buf, 1);
614 if (run_git("config", "--global",
615 "--unset", "--fixed-value",
616 "scalar.repo", path->buf, NULL) < 0)
617 res = -1;
619 if (run_git("config", "--global",
620 "--unset", "--fixed-value",
621 "maintenance.repo", path->buf, NULL) < 0)
622 res = -1;
624 return res;
627 static int cmd_reconfigure(int argc, const char **argv)
629 int all = 0;
630 struct option options[] = {
631 OPT_BOOL('a', "all", &all,
632 N_("reconfigure all registered enlistments")),
633 OPT_END(),
635 const char * const usage[] = {
636 N_("scalar reconfigure [--all | <enlistment>]"),
637 NULL
639 struct string_list scalar_repos = STRING_LIST_INIT_DUP;
640 int i, res = 0;
641 struct repository r = { NULL };
642 struct strbuf commondir = STRBUF_INIT, gitdir = STRBUF_INIT;
644 argc = parse_options(argc, argv, NULL, options,
645 usage, 0);
647 if (!all) {
648 setup_enlistment_directory(argc, argv, usage, options, NULL);
650 return set_recommended_config(1);
653 if (argc > 0)
654 usage_msg_opt(_("--all or <enlistment>, but not both"),
655 usage, options);
657 git_config(get_scalar_repos, &scalar_repos);
659 for (i = 0; i < scalar_repos.nr; i++) {
660 const char *dir = scalar_repos.items[i].string;
662 strbuf_reset(&commondir);
663 strbuf_reset(&gitdir);
665 if (chdir(dir) < 0) {
666 struct strbuf buf = STRBUF_INIT;
668 if (errno != ENOENT) {
669 warning_errno(_("could not switch to '%s'"), dir);
670 res = -1;
671 continue;
674 strbuf_addstr(&buf, dir);
675 if (remove_deleted_enlistment(&buf))
676 res = error(_("could not remove stale "
677 "scalar.repo '%s'"), dir);
678 else
679 warning(_("removing stale scalar.repo '%s'"),
680 dir);
681 strbuf_release(&buf);
682 } else if (discover_git_directory(&commondir, &gitdir) < 0) {
683 warning_errno(_("git repository gone in '%s'"), dir);
684 res = -1;
685 } else {
686 git_config_clear();
688 the_repository = &r;
689 r.commondir = commondir.buf;
690 r.gitdir = gitdir.buf;
692 if (set_recommended_config(1) < 0)
693 res = -1;
697 string_list_clear(&scalar_repos, 1);
698 strbuf_release(&commondir);
699 strbuf_release(&gitdir);
701 return res;
704 static int cmd_run(int argc, const char **argv)
706 struct option options[] = {
707 OPT_END(),
709 struct {
710 const char *arg, *task;
711 } tasks[] = {
712 { "config", NULL },
713 { "commit-graph", "commit-graph" },
714 { "fetch", "prefetch" },
715 { "loose-objects", "loose-objects" },
716 { "pack-files", "incremental-repack" },
717 { NULL, NULL }
719 struct strbuf buf = STRBUF_INIT;
720 const char *usagestr[] = { NULL, NULL };
721 int i;
723 strbuf_addstr(&buf, N_("scalar run <task> [<enlistment>]\nTasks:\n"));
724 for (i = 0; tasks[i].arg; i++)
725 strbuf_addf(&buf, "\t%s\n", tasks[i].arg);
726 usagestr[0] = buf.buf;
728 argc = parse_options(argc, argv, NULL, options,
729 usagestr, 0);
731 if (!argc)
732 usage_with_options(usagestr, options);
734 if (!strcmp("all", argv[0])) {
735 i = -1;
736 } else {
737 for (i = 0; tasks[i].arg && strcmp(tasks[i].arg, argv[0]); i++)
738 ; /* keep looking for the task */
740 if (i > 0 && !tasks[i].arg) {
741 error(_("no such task: '%s'"), argv[0]);
742 usage_with_options(usagestr, options);
746 argc--;
747 argv++;
748 setup_enlistment_directory(argc, argv, usagestr, options, NULL);
749 strbuf_release(&buf);
751 if (i == 0)
752 return register_dir();
754 if (i > 0)
755 return run_git("maintenance", "run",
756 "--task", tasks[i].task, NULL);
758 if (register_dir())
759 return -1;
760 for (i = 1; tasks[i].arg; i++)
761 if (run_git("maintenance", "run",
762 "--task", tasks[i].task, NULL))
763 return -1;
764 return 0;
767 static int cmd_unregister(int argc, const char **argv)
769 struct option options[] = {
770 OPT_END(),
772 const char * const usage[] = {
773 N_("scalar unregister [<enlistment>]"),
774 NULL
777 argc = parse_options(argc, argv, NULL, options,
778 usage, 0);
781 * Be forgiving when the enlistment or worktree does not even exist any
782 * longer; This can be the case if a user deleted the worktree by
783 * mistake and _still_ wants to unregister the thing.
785 if (argc == 1) {
786 struct strbuf src_path = STRBUF_INIT, workdir_path = STRBUF_INIT;
788 strbuf_addf(&src_path, "%s/src/.git", argv[0]);
789 strbuf_addf(&workdir_path, "%s/.git", argv[0]);
790 if (!is_directory(src_path.buf) && !is_directory(workdir_path.buf)) {
791 /* remove possible matching registrations */
792 int res = -1;
794 strbuf_strip_suffix(&src_path, "/.git");
795 res = remove_deleted_enlistment(&src_path) && res;
797 strbuf_strip_suffix(&workdir_path, "/.git");
798 res = remove_deleted_enlistment(&workdir_path) && res;
800 strbuf_release(&src_path);
801 strbuf_release(&workdir_path);
802 return res;
804 strbuf_release(&src_path);
805 strbuf_release(&workdir_path);
808 setup_enlistment_directory(argc, argv, usage, options, NULL);
810 return unregister_dir();
813 static int cmd_delete(int argc, const char **argv)
815 char *cwd = xgetcwd();
816 struct option options[] = {
817 OPT_END(),
819 const char * const usage[] = {
820 N_("scalar delete <enlistment>"),
821 NULL
823 struct strbuf enlistment = STRBUF_INIT;
824 int res = 0;
826 argc = parse_options(argc, argv, NULL, options,
827 usage, 0);
829 if (argc != 1)
830 usage_with_options(usage, options);
832 setup_enlistment_directory(argc, argv, usage, options, &enlistment);
834 if (dir_inside_of(cwd, enlistment.buf) >= 0)
835 res = error(_("refusing to delete current working directory"));
836 else {
837 close_object_store(the_repository->objects);
838 res = delete_enlistment(&enlistment);
840 strbuf_release(&enlistment);
841 free(cwd);
843 return res;
846 static int cmd_help(int argc, const char **argv)
848 struct option options[] = {
849 OPT_END(),
851 const char * const usage[] = {
852 "scalar help",
853 NULL
856 argc = parse_options(argc, argv, NULL, options,
857 usage, 0);
859 if (argc != 0)
860 usage_with_options(usage, options);
862 return run_git("help", "scalar", NULL);
865 static int cmd_version(int argc, const char **argv)
867 int verbose = 0, build_options = 0;
868 struct option options[] = {
869 OPT__VERBOSE(&verbose, N_("include Git version")),
870 OPT_BOOL(0, "build-options", &build_options,
871 N_("include Git's build options")),
872 OPT_END(),
874 const char * const usage[] = {
875 N_("scalar verbose [-v | --verbose] [--build-options]"),
876 NULL
878 struct strbuf buf = STRBUF_INIT;
880 argc = parse_options(argc, argv, NULL, options,
881 usage, 0);
883 if (argc != 0)
884 usage_with_options(usage, options);
886 get_version_info(&buf, build_options);
887 fprintf(stderr, "%s\n", buf.buf);
888 strbuf_release(&buf);
890 return 0;
893 static struct {
894 const char *name;
895 int (*fn)(int, const char **);
896 } builtins[] = {
897 { "clone", cmd_clone },
898 { "list", cmd_list },
899 { "register", cmd_register },
900 { "unregister", cmd_unregister },
901 { "run", cmd_run },
902 { "reconfigure", cmd_reconfigure },
903 { "delete", cmd_delete },
904 { "help", cmd_help },
905 { "version", cmd_version },
906 { "diagnose", cmd_diagnose },
907 { NULL, NULL},
910 int cmd_main(int argc, const char **argv)
912 struct strbuf scalar_usage = STRBUF_INIT;
913 int i;
915 while (argc > 1 && *argv[1] == '-') {
916 if (!strcmp(argv[1], "-C")) {
917 if (argc < 3)
918 die(_("-C requires a <directory>"));
919 if (chdir(argv[2]) < 0)
920 die_errno(_("could not change to '%s'"),
921 argv[2]);
922 argc -= 2;
923 argv += 2;
924 } else if (!strcmp(argv[1], "-c")) {
925 if (argc < 3)
926 die(_("-c requires a <key>=<value> argument"));
927 git_config_push_parameter(argv[2]);
928 argc -= 2;
929 argv += 2;
930 } else
931 break;
934 if (argc > 1) {
935 argv++;
936 argc--;
938 for (i = 0; builtins[i].name; i++)
939 if (!strcmp(builtins[i].name, argv[0]))
940 return !!builtins[i].fn(argc, argv);
943 strbuf_addstr(&scalar_usage,
944 N_("scalar [-C <directory>] [-c <key>=<value>] "
945 "<command> [<options>]\n\nCommands:\n"));
946 for (i = 0; builtins[i].name; i++)
947 strbuf_addf(&scalar_usage, "\t%s\n", builtins[i].name);
949 usage(scalar_usage.buf);