Merge branch 'ab/ci-use-macos-12'
[git/debian.git] / scalar.c
blob6c52243cdf1f68bb3716891bfabbdf85fe26fcd4
1 /*
2 * The Scalar command-line interface.
3 */
5 #include "cache.h"
6 #include "gettext.h"
7 #include "parse-options.h"
8 #include "config.h"
9 #include "run-command.h"
10 #include "simple-ipc.h"
11 #include "fsmonitor-ipc.h"
12 #include "fsmonitor-settings.h"
13 #include "refs.h"
14 #include "dir.h"
15 #include "packfile.h"
16 #include "help.h"
18 static void setup_enlistment_directory(int argc, const char **argv,
19 const char * const *usagestr,
20 const struct option *options,
21 struct strbuf *enlistment_root)
23 struct strbuf path = STRBUF_INIT;
24 int enlistment_is_repo_parent = 0;
25 size_t len;
27 if (startup_info->have_repository)
28 BUG("gitdir already set up?!?");
30 if (argc > 1)
31 usage_with_options(usagestr, options);
33 /* find the worktree, determine its corresponding root */
34 if (argc == 1) {
35 strbuf_add_absolute_path(&path, argv[0]);
36 if (!is_directory(path.buf))
37 die(_("'%s' does not exist"), path.buf);
38 if (chdir(path.buf) < 0)
39 die_errno(_("could not switch to '%s'"), path.buf);
40 } else if (strbuf_getcwd(&path) < 0)
41 die(_("need a working directory"));
43 strbuf_trim_trailing_dir_sep(&path);
45 /* check if currently in enlistment root with src/ workdir */
46 len = path.len;
47 strbuf_addstr(&path, "/src");
48 if (is_nonbare_repository_dir(&path)) {
49 enlistment_is_repo_parent = 1;
50 if (chdir(path.buf) < 0)
51 die_errno(_("could not switch to '%s'"), path.buf);
53 strbuf_setlen(&path, len);
55 setup_git_directory();
57 if (!the_repository->worktree)
58 die(_("Scalar enlistments require a worktree"));
60 if (enlistment_root) {
61 if (enlistment_is_repo_parent)
62 strbuf_addbuf(enlistment_root, &path);
63 else
64 strbuf_addstr(enlistment_root, the_repository->worktree);
67 strbuf_release(&path);
70 static int run_git(const char *arg, ...)
72 struct child_process cmd = CHILD_PROCESS_INIT;
73 va_list args;
74 const char *p;
76 va_start(args, arg);
77 strvec_push(&cmd.args, arg);
78 while ((p = va_arg(args, const char *)))
79 strvec_push(&cmd.args, p);
80 va_end(args);
82 cmd.git_cmd = 1;
83 return run_command(&cmd);
86 struct scalar_config {
87 const char *key;
88 const char *value;
89 int overwrite_on_reconfigure;
92 static int set_scalar_config(const struct scalar_config *config, int reconfigure)
94 char *value = NULL;
95 int res;
97 if ((reconfigure && config->overwrite_on_reconfigure) ||
98 git_config_get_string(config->key, &value)) {
99 trace2_data_string("scalar", the_repository, config->key, "created");
100 res = git_config_set_gently(config->key, config->value);
101 } else {
102 trace2_data_string("scalar", the_repository, config->key, "exists");
103 res = 0;
106 free(value);
107 return res;
110 static int have_fsmonitor_support(void)
112 return fsmonitor_ipc__is_supported() &&
113 fsm_settings__get_reason(the_repository) == FSMONITOR_REASON_OK;
116 static int set_recommended_config(int reconfigure)
118 struct scalar_config config[] = {
119 /* Required */
120 { "am.keepCR", "true", 1 },
121 { "core.FSCache", "true", 1 },
122 { "core.multiPackIndex", "true", 1 },
123 { "core.preloadIndex", "true", 1 },
124 #ifndef WIN32
125 { "core.untrackedCache", "true", 1 },
126 #else
128 * Unfortunately, Scalar's Functional Tests demonstrated
129 * that the untracked cache feature is unreliable on Windows
130 * (which is a bummer because that platform would benefit the
131 * most from it). For some reason, freshly created files seem
132 * not to update the directory's `lastModified` time
133 * immediately, but the untracked cache would need to rely on
134 * that.
136 * Therefore, with a sad heart, we disable this very useful
137 * feature on Windows.
139 { "core.untrackedCache", "false", 1 },
140 #endif
141 { "core.logAllRefUpdates", "true", 1 },
142 { "credential.https://dev.azure.com.useHttpPath", "true", 1 },
143 { "credential.validate", "false", 1 }, /* GCM4W-only */
144 { "gc.auto", "0", 1 },
145 { "gui.GCWarning", "false", 1 },
146 { "index.threads", "true", 1 },
147 { "index.version", "4", 1 },
148 { "merge.stat", "false", 1 },
149 { "merge.renames", "true", 1 },
150 { "pack.useBitmaps", "false", 1 },
151 { "pack.useSparse", "true", 1 },
152 { "receive.autoGC", "false", 1 },
153 { "feature.manyFiles", "false", 1 },
154 { "feature.experimental", "false", 1 },
155 { "fetch.unpackLimit", "1", 1 },
156 { "fetch.writeCommitGraph", "false", 1 },
157 #ifdef WIN32
158 { "http.sslBackend", "schannel", 1 },
159 #endif
160 /* Optional */
161 { "status.aheadBehind", "false" },
162 { "commitGraph.generationVersion", "1" },
163 { "core.autoCRLF", "false" },
164 { "core.safeCRLF", "false" },
165 { "fetch.showForcedUpdates", "false" },
166 { NULL, NULL },
168 int i;
169 char *value;
171 for (i = 0; config[i].key; i++) {
172 if (set_scalar_config(config + i, reconfigure))
173 return error(_("could not configure %s=%s"),
174 config[i].key, config[i].value);
177 if (have_fsmonitor_support()) {
178 struct scalar_config fsmonitor = { "core.fsmonitor", "true" };
179 if (set_scalar_config(&fsmonitor, reconfigure))
180 return error(_("could not configure %s=%s"),
181 fsmonitor.key, fsmonitor.value);
185 * The `log.excludeDecoration` setting is special because it allows
186 * for multiple values.
188 if (git_config_get_string("log.excludeDecoration", &value)) {
189 trace2_data_string("scalar", the_repository,
190 "log.excludeDecoration", "created");
191 if (git_config_set_multivar_gently("log.excludeDecoration",
192 "refs/prefetch/*",
193 CONFIG_REGEX_NONE, 0))
194 return error(_("could not configure "
195 "log.excludeDecoration"));
196 } else {
197 trace2_data_string("scalar", the_repository,
198 "log.excludeDecoration", "exists");
199 free(value);
202 return 0;
205 static int toggle_maintenance(int enable)
207 return run_git("maintenance",
208 enable ? "start" : "unregister",
209 enable ? NULL : "--force",
210 NULL);
213 static int add_or_remove_enlistment(int add)
215 int res;
217 if (!the_repository->worktree)
218 die(_("Scalar enlistments require a worktree"));
220 res = run_git("config", "--global", "--get", "--fixed-value",
221 "scalar.repo", the_repository->worktree, NULL);
224 * If we want to add and the setting is already there, then do nothing.
225 * If we want to remove and the setting is not there, then do nothing.
227 if ((add && !res) || (!add && res))
228 return 0;
230 return run_git("config", "--global", add ? "--add" : "--unset",
231 add ? "--no-fixed-value" : "--fixed-value",
232 "scalar.repo", the_repository->worktree, NULL);
235 static int start_fsmonitor_daemon(void)
237 assert(have_fsmonitor_support());
239 if (fsmonitor_ipc__get_state() != IPC_STATE__LISTENING)
240 return run_git("fsmonitor--daemon", "start", NULL);
242 return 0;
245 static int stop_fsmonitor_daemon(void)
247 assert(have_fsmonitor_support());
249 if (fsmonitor_ipc__get_state() == IPC_STATE__LISTENING)
250 return run_git("fsmonitor--daemon", "stop", NULL);
252 return 0;
255 static int register_dir(void)
257 if (add_or_remove_enlistment(1))
258 return error(_("could not add enlistment"));
260 if (set_recommended_config(0))
261 return error(_("could not set recommended config"));
263 if (toggle_maintenance(1))
264 return error(_("could not turn on maintenance"));
266 if (have_fsmonitor_support() && start_fsmonitor_daemon()) {
267 return error(_("could not start the FSMonitor daemon"));
270 return 0;
273 static int unregister_dir(void)
275 int res = 0;
277 if (toggle_maintenance(0))
278 res = error(_("could not turn off maintenance"));
280 if (add_or_remove_enlistment(0))
281 res = error(_("could not remove enlistment"));
283 return res;
286 /* printf-style interface, expects `<key>=<value>` argument */
287 static int set_config(const char *fmt, ...)
289 struct strbuf buf = STRBUF_INIT;
290 char *value;
291 int res;
292 va_list args;
294 va_start(args, fmt);
295 strbuf_vaddf(&buf, fmt, args);
296 va_end(args);
298 value = strchr(buf.buf, '=');
299 if (value)
300 *(value++) = '\0';
301 res = git_config_set_gently(buf.buf, value);
302 strbuf_release(&buf);
304 return res;
307 static char *remote_default_branch(const char *url)
309 struct child_process cp = CHILD_PROCESS_INIT;
310 struct strbuf out = STRBUF_INIT;
312 cp.git_cmd = 1;
313 strvec_pushl(&cp.args, "ls-remote", "--symref", url, "HEAD", NULL);
314 if (!pipe_command(&cp, NULL, 0, &out, 0, NULL, 0)) {
315 const char *line = out.buf;
317 while (*line) {
318 const char *eol = strchrnul(line, '\n'), *p;
319 size_t len = eol - line;
320 char *branch;
322 if (!skip_prefix(line, "ref: ", &p) ||
323 !strip_suffix_mem(line, &len, "\tHEAD")) {
324 line = eol + (*eol == '\n');
325 continue;
328 eol = line + len;
329 if (skip_prefix(p, "refs/heads/", &p)) {
330 branch = xstrndup(p, eol - p);
331 strbuf_release(&out);
332 return branch;
335 error(_("remote HEAD is not a branch: '%.*s'"),
336 (int)(eol - p), p);
337 strbuf_release(&out);
338 return NULL;
341 warning(_("failed to get default branch name from remote; "
342 "using local default"));
343 strbuf_reset(&out);
345 child_process_init(&cp);
346 cp.git_cmd = 1;
347 strvec_pushl(&cp.args, "symbolic-ref", "--short", "HEAD", NULL);
348 if (!pipe_command(&cp, NULL, 0, &out, 0, NULL, 0)) {
349 strbuf_trim(&out);
350 return strbuf_detach(&out, NULL);
353 strbuf_release(&out);
354 error(_("failed to get default branch name"));
355 return NULL;
358 static int delete_enlistment(struct strbuf *enlistment)
360 #ifdef WIN32
361 struct strbuf parent = STRBUF_INIT;
362 size_t offset;
363 char *path_sep;
364 #endif
366 if (unregister_dir())
367 return error(_("failed to unregister repository"));
369 #ifdef WIN32
371 * Change the current directory to one outside of the enlistment so
372 * that we may delete everything underneath it.
374 offset = offset_1st_component(enlistment->buf);
375 path_sep = find_last_dir_sep(enlistment->buf + offset);
376 strbuf_add(&parent, enlistment->buf,
377 path_sep ? path_sep - enlistment->buf : offset);
378 if (chdir(parent.buf) < 0) {
379 int res = error_errno(_("could not switch to '%s'"), parent.buf);
380 strbuf_release(&parent);
381 return res;
383 strbuf_release(&parent);
384 #endif
386 if (have_fsmonitor_support() && stop_fsmonitor_daemon())
387 return error(_("failed to stop the FSMonitor daemon"));
389 if (remove_dir_recursively(enlistment, 0))
390 return error(_("failed to delete enlistment directory"));
392 return 0;
396 * Dummy implementation; Using `get_version_info()` would cause a link error
397 * without this.
399 void load_builtin_commands(const char *prefix, struct cmdnames *cmds)
401 die("not implemented");
404 static int cmd_clone(int argc, const char **argv)
406 const char *branch = NULL;
407 int full_clone = 0, single_branch = 0;
408 struct option clone_options[] = {
409 OPT_STRING('b', "branch", &branch, N_("<branch>"),
410 N_("branch to checkout after clone")),
411 OPT_BOOL(0, "full-clone", &full_clone,
412 N_("when cloning, create full working directory")),
413 OPT_BOOL(0, "single-branch", &single_branch,
414 N_("only download metadata for the branch that will "
415 "be checked out")),
416 OPT_END(),
418 const char * const clone_usage[] = {
419 N_("scalar clone [<options>] [--] <repo> [<dir>]"),
420 NULL
422 const char *url;
423 char *enlistment = NULL, *dir = NULL;
424 struct strbuf buf = STRBUF_INIT;
425 int res;
427 argc = parse_options(argc, argv, NULL, clone_options, clone_usage, 0);
429 if (argc == 2) {
430 url = argv[0];
431 enlistment = xstrdup(argv[1]);
432 } else if (argc == 1) {
433 url = argv[0];
435 strbuf_addstr(&buf, url);
436 /* Strip trailing slashes, if any */
437 while (buf.len > 0 && is_dir_sep(buf.buf[buf.len - 1]))
438 strbuf_setlen(&buf, buf.len - 1);
439 /* Strip suffix `.git`, if any */
440 strbuf_strip_suffix(&buf, ".git");
442 enlistment = find_last_dir_sep(buf.buf);
443 if (!enlistment) {
444 die(_("cannot deduce worktree name from '%s'"), url);
446 enlistment = xstrdup(enlistment + 1);
447 } else {
448 usage_msg_opt(_("You must specify a repository to clone."),
449 clone_usage, clone_options);
452 if (is_directory(enlistment))
453 die(_("directory '%s' exists already"), enlistment);
455 dir = xstrfmt("%s/src", enlistment);
457 strbuf_reset(&buf);
458 if (branch)
459 strbuf_addf(&buf, "init.defaultBranch=%s", branch);
460 else {
461 char *b = repo_default_branch_name(the_repository, 1);
462 strbuf_addf(&buf, "init.defaultBranch=%s", b);
463 free(b);
466 if ((res = run_git("-c", buf.buf, "init", "--", dir, NULL)))
467 goto cleanup;
469 if (chdir(dir) < 0) {
470 res = error_errno(_("could not switch to '%s'"), dir);
471 goto cleanup;
474 setup_git_directory();
476 /* common-main already logs `argv` */
477 trace2_def_repo(the_repository);
479 if (!branch && !(branch = remote_default_branch(url))) {
480 res = error(_("failed to get default branch for '%s'"), url);
481 goto cleanup;
484 if (set_config("remote.origin.url=%s", url) ||
485 set_config("remote.origin.fetch="
486 "+refs/heads/%s:refs/remotes/origin/%s",
487 single_branch ? branch : "*",
488 single_branch ? branch : "*") ||
489 set_config("remote.origin.promisor=true") ||
490 set_config("remote.origin.partialCloneFilter=blob:none")) {
491 res = error(_("could not configure remote in '%s'"), dir);
492 goto cleanup;
495 if (!full_clone &&
496 (res = run_git("sparse-checkout", "init", "--cone", NULL)))
497 goto cleanup;
499 if (set_recommended_config(0))
500 return error(_("could not configure '%s'"), dir);
502 if ((res = run_git("fetch", "--quiet", "origin", NULL))) {
503 warning(_("partial clone failed; attempting full clone"));
505 if (set_config("remote.origin.promisor") ||
506 set_config("remote.origin.partialCloneFilter")) {
507 res = error(_("could not configure for full clone"));
508 goto cleanup;
511 if ((res = run_git("fetch", "--quiet", "origin", NULL)))
512 goto cleanup;
515 if ((res = set_config("branch.%s.remote=origin", branch)))
516 goto cleanup;
517 if ((res = set_config("branch.%s.merge=refs/heads/%s",
518 branch, branch)))
519 goto cleanup;
521 strbuf_reset(&buf);
522 strbuf_addf(&buf, "origin/%s", branch);
523 res = run_git("checkout", "-f", "-t", buf.buf, NULL);
524 if (res)
525 goto cleanup;
527 res = register_dir();
529 cleanup:
530 free(enlistment);
531 free(dir);
532 strbuf_release(&buf);
533 return res;
536 static int cmd_diagnose(int argc, const char **argv)
538 struct option options[] = {
539 OPT_END(),
541 const char * const usage[] = {
542 N_("scalar diagnose [<enlistment>]"),
543 NULL
545 struct strbuf diagnostics_root = STRBUF_INIT;
546 int res = 0;
548 argc = parse_options(argc, argv, NULL, options,
549 usage, 0);
551 setup_enlistment_directory(argc, argv, usage, options, &diagnostics_root);
552 strbuf_addstr(&diagnostics_root, "/.scalarDiagnostics");
554 res = run_git("diagnose", "--mode=all", "-s", "%Y%m%d_%H%M%S",
555 "-o", diagnostics_root.buf, NULL);
557 strbuf_release(&diagnostics_root);
558 return res;
561 static int cmd_list(int argc, const char **argv)
563 if (argc != 1)
564 die(_("`scalar list` does not take arguments"));
566 if (run_git("config", "--global", "--get-all", "scalar.repo", NULL) < 0)
567 return -1;
568 return 0;
571 static int cmd_register(int argc, const char **argv)
573 struct option options[] = {
574 OPT_END(),
576 const char * const usage[] = {
577 N_("scalar register [<enlistment>]"),
578 NULL
581 argc = parse_options(argc, argv, NULL, options,
582 usage, 0);
584 setup_enlistment_directory(argc, argv, usage, options, NULL);
586 return register_dir();
589 static int get_scalar_repos(const char *key, const char *value, void *data)
591 struct string_list *list = data;
593 if (!strcmp(key, "scalar.repo"))
594 string_list_append(list, value);
596 return 0;
599 static int remove_deleted_enlistment(struct strbuf *path)
601 int res = 0;
602 strbuf_realpath_forgiving(path, path->buf, 1);
604 if (run_git("config", "--global",
605 "--unset", "--fixed-value",
606 "scalar.repo", path->buf, NULL) < 0)
607 res = -1;
609 if (run_git("config", "--global",
610 "--unset", "--fixed-value",
611 "maintenance.repo", path->buf, NULL) < 0)
612 res = -1;
614 return res;
617 static int cmd_reconfigure(int argc, const char **argv)
619 int all = 0;
620 struct option options[] = {
621 OPT_BOOL('a', "all", &all,
622 N_("reconfigure all registered enlistments")),
623 OPT_END(),
625 const char * const usage[] = {
626 N_("scalar reconfigure [--all | <enlistment>]"),
627 NULL
629 struct string_list scalar_repos = STRING_LIST_INIT_DUP;
630 int i, res = 0;
631 struct repository r = { NULL };
632 struct strbuf commondir = STRBUF_INIT, gitdir = STRBUF_INIT;
634 argc = parse_options(argc, argv, NULL, options,
635 usage, 0);
637 if (!all) {
638 setup_enlistment_directory(argc, argv, usage, options, NULL);
640 return set_recommended_config(1);
643 if (argc > 0)
644 usage_msg_opt(_("--all or <enlistment>, but not both"),
645 usage, options);
647 git_config(get_scalar_repos, &scalar_repos);
649 for (i = 0; i < scalar_repos.nr; i++) {
650 const char *dir = scalar_repos.items[i].string;
652 strbuf_reset(&commondir);
653 strbuf_reset(&gitdir);
655 if (chdir(dir) < 0) {
656 struct strbuf buf = STRBUF_INIT;
658 if (errno != ENOENT) {
659 warning_errno(_("could not switch to '%s'"), dir);
660 res = -1;
661 continue;
664 strbuf_addstr(&buf, dir);
665 if (remove_deleted_enlistment(&buf))
666 res = error(_("could not remove stale "
667 "scalar.repo '%s'"), dir);
668 else
669 warning(_("removing stale scalar.repo '%s'"),
670 dir);
671 strbuf_release(&buf);
672 } else if (discover_git_directory(&commondir, &gitdir) < 0) {
673 warning_errno(_("git repository gone in '%s'"), dir);
674 res = -1;
675 } else {
676 git_config_clear();
678 the_repository = &r;
679 r.commondir = commondir.buf;
680 r.gitdir = gitdir.buf;
682 if (set_recommended_config(1) < 0)
683 res = -1;
687 string_list_clear(&scalar_repos, 1);
688 strbuf_release(&commondir);
689 strbuf_release(&gitdir);
691 return res;
694 static int cmd_run(int argc, const char **argv)
696 struct option options[] = {
697 OPT_END(),
699 struct {
700 const char *arg, *task;
701 } tasks[] = {
702 { "config", NULL },
703 { "commit-graph", "commit-graph" },
704 { "fetch", "prefetch" },
705 { "loose-objects", "loose-objects" },
706 { "pack-files", "incremental-repack" },
707 { NULL, NULL }
709 struct strbuf buf = STRBUF_INIT;
710 const char *usagestr[] = { NULL, NULL };
711 int i;
713 strbuf_addstr(&buf, N_("scalar run <task> [<enlistment>]\nTasks:\n"));
714 for (i = 0; tasks[i].arg; i++)
715 strbuf_addf(&buf, "\t%s\n", tasks[i].arg);
716 usagestr[0] = buf.buf;
718 argc = parse_options(argc, argv, NULL, options,
719 usagestr, 0);
721 if (!argc)
722 usage_with_options(usagestr, options);
724 if (!strcmp("all", argv[0])) {
725 i = -1;
726 } else {
727 for (i = 0; tasks[i].arg && strcmp(tasks[i].arg, argv[0]); i++)
728 ; /* keep looking for the task */
730 if (i > 0 && !tasks[i].arg) {
731 error(_("no such task: '%s'"), argv[0]);
732 usage_with_options(usagestr, options);
736 argc--;
737 argv++;
738 setup_enlistment_directory(argc, argv, usagestr, options, NULL);
739 strbuf_release(&buf);
741 if (i == 0)
742 return register_dir();
744 if (i > 0)
745 return run_git("maintenance", "run",
746 "--task", tasks[i].task, NULL);
748 if (register_dir())
749 return -1;
750 for (i = 1; tasks[i].arg; i++)
751 if (run_git("maintenance", "run",
752 "--task", tasks[i].task, NULL))
753 return -1;
754 return 0;
757 static int cmd_unregister(int argc, const char **argv)
759 struct option options[] = {
760 OPT_END(),
762 const char * const usage[] = {
763 N_("scalar unregister [<enlistment>]"),
764 NULL
767 argc = parse_options(argc, argv, NULL, options,
768 usage, 0);
771 * Be forgiving when the enlistment or worktree does not even exist any
772 * longer; This can be the case if a user deleted the worktree by
773 * mistake and _still_ wants to unregister the thing.
775 if (argc == 1) {
776 struct strbuf src_path = STRBUF_INIT, workdir_path = STRBUF_INIT;
778 strbuf_addf(&src_path, "%s/src/.git", argv[0]);
779 strbuf_addf(&workdir_path, "%s/.git", argv[0]);
780 if (!is_directory(src_path.buf) && !is_directory(workdir_path.buf)) {
781 /* remove possible matching registrations */
782 int res = -1;
784 strbuf_strip_suffix(&src_path, "/.git");
785 res = remove_deleted_enlistment(&src_path) && res;
787 strbuf_strip_suffix(&workdir_path, "/.git");
788 res = remove_deleted_enlistment(&workdir_path) && res;
790 strbuf_release(&src_path);
791 strbuf_release(&workdir_path);
792 return res;
794 strbuf_release(&src_path);
795 strbuf_release(&workdir_path);
798 setup_enlistment_directory(argc, argv, usage, options, NULL);
800 return unregister_dir();
803 static int cmd_delete(int argc, const char **argv)
805 char *cwd = xgetcwd();
806 struct option options[] = {
807 OPT_END(),
809 const char * const usage[] = {
810 N_("scalar delete <enlistment>"),
811 NULL
813 struct strbuf enlistment = STRBUF_INIT;
814 int res = 0;
816 argc = parse_options(argc, argv, NULL, options,
817 usage, 0);
819 if (argc != 1)
820 usage_with_options(usage, options);
822 setup_enlistment_directory(argc, argv, usage, options, &enlistment);
824 if (dir_inside_of(cwd, enlistment.buf) >= 0)
825 res = error(_("refusing to delete current working directory"));
826 else {
827 close_object_store(the_repository->objects);
828 res = delete_enlistment(&enlistment);
830 strbuf_release(&enlistment);
831 free(cwd);
833 return res;
836 static int cmd_help(int argc, const char **argv)
838 struct option options[] = {
839 OPT_END(),
841 const char * const usage[] = {
842 "scalar help",
843 NULL
846 argc = parse_options(argc, argv, NULL, options,
847 usage, 0);
849 if (argc != 0)
850 usage_with_options(usage, options);
852 return run_git("help", "scalar", NULL);
855 static int cmd_version(int argc, const char **argv)
857 int verbose = 0, build_options = 0;
858 struct option options[] = {
859 OPT__VERBOSE(&verbose, N_("include Git version")),
860 OPT_BOOL(0, "build-options", &build_options,
861 N_("include Git's build options")),
862 OPT_END(),
864 const char * const usage[] = {
865 N_("scalar verbose [-v | --verbose] [--build-options]"),
866 NULL
868 struct strbuf buf = STRBUF_INIT;
870 argc = parse_options(argc, argv, NULL, options,
871 usage, 0);
873 if (argc != 0)
874 usage_with_options(usage, options);
876 get_version_info(&buf, build_options);
877 fprintf(stderr, "%s\n", buf.buf);
878 strbuf_release(&buf);
880 return 0;
883 static struct {
884 const char *name;
885 int (*fn)(int, const char **);
886 } builtins[] = {
887 { "clone", cmd_clone },
888 { "list", cmd_list },
889 { "register", cmd_register },
890 { "unregister", cmd_unregister },
891 { "run", cmd_run },
892 { "reconfigure", cmd_reconfigure },
893 { "delete", cmd_delete },
894 { "help", cmd_help },
895 { "version", cmd_version },
896 { "diagnose", cmd_diagnose },
897 { NULL, NULL},
900 int cmd_main(int argc, const char **argv)
902 struct strbuf scalar_usage = STRBUF_INIT;
903 int i;
905 while (argc > 1 && *argv[1] == '-') {
906 if (!strcmp(argv[1], "-C")) {
907 if (argc < 3)
908 die(_("-C requires a <directory>"));
909 if (chdir(argv[2]) < 0)
910 die_errno(_("could not change to '%s'"),
911 argv[2]);
912 argc -= 2;
913 argv += 2;
914 } else if (!strcmp(argv[1], "-c")) {
915 if (argc < 3)
916 die(_("-c requires a <key>=<value> argument"));
917 git_config_push_parameter(argv[2]);
918 argc -= 2;
919 argv += 2;
920 } else
921 break;
924 if (argc > 1) {
925 argv++;
926 argc--;
928 for (i = 0; builtins[i].name; i++)
929 if (!strcmp(builtins[i].name, argv[0]))
930 return !!builtins[i].fn(argc, argv);
933 strbuf_addstr(&scalar_usage,
934 N_("scalar [-C <directory>] [-c <key>=<value>] "
935 "<command> [<options>]\n\nCommands:\n"));
936 for (i = 0; builtins[i].name; i++)
937 strbuf_addf(&scalar_usage, "\t%s\n", builtins[i].name);
939 usage(scalar_usage.buf);