scalar.c

   1 /*
   2  * The Scalar command-line interface.
   3  */
   4
   5 #include "cache.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
  19 static void setup_enlistment_directory(int argc, const char **argv,
  20                                        const char * const *usagestr,
  21                                        const struct option *options,
  22                                        struct strbuf *enlistment_root)
  23 {
  24         struct strbuf path = STRBUF_INIT;
  25         int enlistment_is_repo_parent = 0;
  26         size_t len;
  27
  28         if (startup_info->have_repository)
  29                 BUG("gitdir already set up?!?");
  30
  31         if (argc > 1)
  32                 usage_with_options(usagestr, options);
  33
  34         /* find the worktree, determine its corresponding root */
  35         if (argc == 1) {
  36                 strbuf_add_absolute_path(&path, argv[0]);
  37                 if (!is_directory(path.buf))
  38                         die(_("'%s' does not exist"), path.buf);
  39                 if (chdir(path.buf) < 0)
  40                         die_errno(_("could not switch to '%s'"), path.buf);
  41         } else if (strbuf_getcwd(&path) < 0)
  42                 die(_("need a working directory"));
  43
  44         strbuf_trim_trailing_dir_sep(&path);
  45
  46         /* check if currently in enlistment root with src/ workdir */
  47         len = path.len;
  48         strbuf_addstr(&path, "/src");
  49         if (is_nonbare_repository_dir(&path)) {
  50                 enlistment_is_repo_parent = 1;
  51                 if (chdir(path.buf) < 0)
  52                         die_errno(_("could not switch to '%s'"), path.buf);
  53         }
  54         strbuf_setlen(&path, len);
  55
  56         setup_git_directory();
  57
  58         if (!the_repository->worktree)
  59                 die(_("Scalar enlistments require a worktree"));
  60
  61         if (enlistment_root) {
  62                 if (enlistment_is_repo_parent)
  63                         strbuf_addbuf(enlistment_root, &path);
  64                 else
  65                         strbuf_addstr(enlistment_root, the_repository->worktree);
  66         }
  67
  68         strbuf_release(&path);
  69 }
  70
  71 static int run_git(const char *arg, ...)
  72 {
  73         struct child_process cmd = CHILD_PROCESS_INIT;
  74         va_list args;
  75         const char *p;
  76
  77         va_start(args, arg);
  78         strvec_push(&cmd.args, arg);
  79         while ((p = va_arg(args, const char *)))
  80                 strvec_push(&cmd.args, p);
  81         va_end(args);
  82
  83         cmd.git_cmd = 1;
  84         return run_command(&cmd);
  85 }
  86
  87 struct scalar_config {
  88         const char *key;
  89         const char *value;
  90         int overwrite_on_reconfigure;
  91 };
  92
  93 static int set_scalar_config(const struct scalar_config *config, int reconfigure)
  94 {
  95         char *value = NULL;
  96         int res;
  97
  98         if ((reconfigure && config->overwrite_on_reconfigure) ||
  99             git_config_get_string(config->key, &value)) {
 100                 trace2_data_string("scalar", the_repository, config->key, "created");
 101                 res = git_config_set_gently(config->key, config->value);
 102         } else {
 103                 trace2_data_string("scalar", the_repository, config->key, "exists");
 104                 res = 0;
 105         }
 106
 107         free(value);
 108         return res;
 109 }
 110
 111 static int have_fsmonitor_support(void)
 112 {
 113         return fsmonitor_ipc__is_supported() &&
 114                fsm_settings__get_reason(the_repository) == FSMONITOR_REASON_OK;
 115 }
 116
 117 static int set_recommended_config(int reconfigure)
 118 {
 119         struct scalar_config config[] = {
 120                 /* Required */
 121                 { "am.keepCR", "true", 1 },
 122                 { "core.FSCache", "true", 1 },
 123                 { "core.multiPackIndex", "true", 1 },
 124                 { "core.preloadIndex", "true", 1 },
 125 #ifndef WIN32
 126                 { "core.untrackedCache", "true", 1 },
 127 #else
 128                 /*
 129                  * Unfortunately, Scalar's Functional Tests demonstrated
 130                  * that the untracked cache feature is unreliable on Windows
 131                  * (which is a bummer because that platform would benefit the
 132                  * most from it). For some reason, freshly created files seem
 133                  * not to update the directory's `lastModified` time
 134                  * immediately, but the untracked cache would need to rely on
 135                  * that.
 136                  *
 137                  * Therefore, with a sad heart, we disable this very useful
 138                  * feature on Windows.
 139                  */
 140                 { "core.untrackedCache", "false", 1 },
 141 #endif
 142                 { "core.logAllRefUpdates", "true", 1 },
 143                 { "credential.https://dev.azure.com.useHttpPath", "true", 1 },
 144                 { "credential.validate", "false", 1 }, /* GCM4W-only */
 145                 { "gc.auto", "0", 1 },
 146                 { "gui.GCWarning", "false", 1 },
 147                 { "index.skipHash", "false", 1 },
 148                 { "index.threads", "true", 1 },
 149                 { "index.version", "4", 1 },
 150                 { "merge.stat", "false", 1 },
 151                 { "merge.renames", "true", 1 },
 152                 { "pack.useBitmaps", "false", 1 },
 153                 { "pack.useSparse", "true", 1 },
 154                 { "receive.autoGC", "false", 1 },
 155                 { "feature.manyFiles", "false", 1 },
 156                 { "feature.experimental", "false", 1 },
 157                 { "fetch.unpackLimit", "1", 1 },
 158                 { "fetch.writeCommitGraph", "false", 1 },
 159 #ifdef WIN32
 160                 { "http.sslBackend", "schannel", 1 },
 161 #endif
 162                 /* Optional */
 163                 { "status.aheadBehind", "false" },
 164                 { "commitGraph.generationVersion", "1" },
 165                 { "core.autoCRLF", "false" },
 166                 { "core.safeCRLF", "false" },
 167                 { "fetch.showForcedUpdates", "false" },
 168                 { NULL, NULL },
 169         };
 170         int i;
 171         char *value;
 172
 173         for (i = 0; config[i].key; i++) {
 174                 if (set_scalar_config(config + i, reconfigure))
 175                         return error(_("could not configure %s=%s"),
 176                                      config[i].key, config[i].value);
 177         }
 178
 179         if (have_fsmonitor_support()) {
 180                 struct scalar_config fsmonitor = { "core.fsmonitor", "true" };
 181                 if (set_scalar_config(&fsmonitor, reconfigure))
 182                         return error(_("could not configure %s=%s"),
 183                                      fsmonitor.key, fsmonitor.value);
 184         }
 185
 186         /*
 187          * The `log.excludeDecoration` setting is special because it allows
 188          * for multiple values.
 189          */
 190         if (git_config_get_string("log.excludeDecoration", &value)) {
 191                 trace2_data_string("scalar", the_repository,
 192                                    "log.excludeDecoration", "created");
 193                 if (git_config_set_multivar_gently("log.excludeDecoration",
 194                                                    "refs/prefetch/*",
 195                                                    CONFIG_REGEX_NONE, 0))
 196                         return error(_("could not configure "
 197                                        "log.excludeDecoration"));
 198         } else {
 199                 trace2_data_string("scalar", the_repository,
 200                                    "log.excludeDecoration", "exists");
 201                 free(value);
 202         }
 203
 204         return 0;
 205 }
 206
 207 static int toggle_maintenance(int enable)
 208 {
 209         return run_git("maintenance",
 210                        enable ? "start" : "unregister",
 211                        enable ? NULL : "--force",
 212                        NULL);
 213 }
 214
 215 static int add_or_remove_enlistment(int add)
 216 {
 217         int res;
 218
 219         if (!the_repository->worktree)
 220                 die(_("Scalar enlistments require a worktree"));
 221
 222         res = run_git("config", "--global", "--get", "--fixed-value",
 223                       "scalar.repo", the_repository->worktree, NULL);
 224
 225         /*
 226          * If we want to add and the setting is already there, then do nothing.
 227          * If we want to remove and the setting is not there, then do nothing.
 228          */
 229         if ((add && !res) || (!add && res))
 230                 return 0;
 231
 232         return run_git("config", "--global", add ? "--add" : "--unset",
 233                        add ? "--no-fixed-value" : "--fixed-value",
 234                        "scalar.repo", the_repository->worktree, NULL);
 235 }
 236
 237 static int start_fsmonitor_daemon(void)
 238 {
 239         assert(have_fsmonitor_support());
 240
 241         if (fsmonitor_ipc__get_state() != IPC_STATE__LISTENING)
 242                 return run_git("fsmonitor--daemon", "start", NULL);
 243
 244         return 0;
 245 }
 246
 247 static int stop_fsmonitor_daemon(void)
 248 {
 249         assert(have_fsmonitor_support());
 250
 251         if (fsmonitor_ipc__get_state() == IPC_STATE__LISTENING)
 252                 return run_git("fsmonitor--daemon", "stop", NULL);
 253
 254         return 0;
 255 }
 256
 257 static int register_dir(void)
 258 {
 259         if (add_or_remove_enlistment(1))
 260                 return error(_("could not add enlistment"));
 261
 262         if (set_recommended_config(0))
 263                 return error(_("could not set recommended config"));
 264
 265         if (toggle_maintenance(1))
 266                 warning(_("could not turn on maintenance"));
 267
 268         if (have_fsmonitor_support() && start_fsmonitor_daemon()) {
 269                 return error(_("could not start the FSMonitor daemon"));
 270         }
 271
 272         return 0;
 273 }
 274
 275 static int unregister_dir(void)
 276 {
 277         int res = 0;
 278
 279         if (toggle_maintenance(0))
 280                 res = error(_("could not turn off maintenance"));
 281
 282         if (add_or_remove_enlistment(0))
 283                 res = error(_("could not remove enlistment"));
 284
 285         return res;
 286 }
 287
 288 /* printf-style interface, expects `<key>=<value>` argument */
 289 static int set_config(const char *fmt, ...)
 290 {
 291         struct strbuf buf = STRBUF_INIT;
 292         char *value;
 293         int res;
 294         va_list args;
 295
 296         va_start(args, fmt);
 297         strbuf_vaddf(&buf, fmt, args);
 298         va_end(args);
 299
 300         value = strchr(buf.buf, '=');
 301         if (value)
 302                 *(value++) = '\0';
 303         res = git_config_set_gently(buf.buf, value);
 304         strbuf_release(&buf);
 305
 306         return res;
 307 }
 308
 309 static char *remote_default_branch(const char *url)
 310 {
 311         struct child_process cp = CHILD_PROCESS_INIT;
 312         struct strbuf out = STRBUF_INIT;
 313
 314         cp.git_cmd = 1;
 315         strvec_pushl(&cp.args, "ls-remote", "--symref", url, "HEAD", NULL);
 316         if (!pipe_command(&cp, NULL, 0, &out, 0, NULL, 0)) {
 317                 const char *line = out.buf;
 318
 319                 while (*line) {
 320                         const char *eol = strchrnul(line, '\n'), *p;
 321                         size_t len = eol - line;
 322                         char *branch;
 323
 324                         if (!skip_prefix(line, "ref: ", &p) ||
 325                             !strip_suffix_mem(line, &len, "\tHEAD")) {
 326                                 line = eol + (*eol == '\n');
 327                                 continue;
 328                         }
 329
 330                         eol = line + len;
 331                         if (skip_prefix(p, "refs/heads/", &p)) {
 332                                 branch = xstrndup(p, eol - p);
 333                                 strbuf_release(&out);
 334                                 return branch;
 335                         }
 336
 337                         error(_("remote HEAD is not a branch: '%.*s'"),
 338                               (int)(eol - p), p);
 339                         strbuf_release(&out);
 340                         return NULL;
 341                 }
 342         }
 343         warning(_("failed to get default branch name from remote; "
 344                   "using local default"));
 345         strbuf_reset(&out);
 346
 347         child_process_init(&cp);
 348         cp.git_cmd = 1;
 349         strvec_pushl(&cp.args, "symbolic-ref", "--short", "HEAD", NULL);
 350         if (!pipe_command(&cp, NULL, 0, &out, 0, NULL, 0)) {
 351                 strbuf_trim(&out);
 352                 return strbuf_detach(&out, NULL);
 353         }
 354
 355         strbuf_release(&out);
 356         error(_("failed to get default branch name"));
 357         return NULL;
 358 }
 359
 360 static int delete_enlistment(struct strbuf *enlistment)
 361 {
 362 #ifdef WIN32
 363         struct strbuf parent = STRBUF_INIT;
 364         size_t offset;
 365         char *path_sep;
 366 #endif
 367
 368         if (unregister_dir())
 369                 return error(_("failed to unregister repository"));
 370
 371 #ifdef WIN32
 372         /*
 373          * Change the current directory to one outside of the enlistment so
 374          * that we may delete everything underneath it.
 375          */
 376         offset = offset_1st_component(enlistment->buf);
 377         path_sep = find_last_dir_sep(enlistment->buf + offset);
 378         strbuf_add(&parent, enlistment->buf,
 379                    path_sep ? path_sep - enlistment->buf : offset);
 380         if (chdir(parent.buf) < 0) {
 381                 int res = error_errno(_("could not switch to '%s'"), parent.buf);
 382                 strbuf_release(&parent);
 383                 return res;
 384         }
 385         strbuf_release(&parent);
 386 #endif
 387
 388         if (have_fsmonitor_support() && stop_fsmonitor_daemon())
 389                 return error(_("failed to stop the FSMonitor daemon"));
 390
 391         if (remove_dir_recursively(enlistment, 0))
 392                 return error(_("failed to delete enlistment directory"));
 393
 394         return 0;
 395 }
 396
 397 /*
 398  * Dummy implementation; Using `get_version_info()` would cause a link error
 399  * without this.
 400  */
 401 void load_builtin_commands(const char *prefix, struct cmdnames *cmds)
 402 {
 403         die("not implemented");
 404 }
 405
 406 static int cmd_clone(int argc, const char **argv)
 407 {
 408         const char *branch = NULL;
 409         int full_clone = 0, single_branch = 0, show_progress = isatty(2);
 410         struct option clone_options[] = {
 411                 OPT_STRING('b', "branch", &branch, N_("<branch>"),
 412                            N_("branch to checkout after clone")),
 413                 OPT_BOOL(0, "full-clone", &full_clone,
 414                          N_("when cloning, create full working directory")),
 415                 OPT_BOOL(0, "single-branch", &single_branch,
 416                          N_("only download metadata for the branch that will "
 417                             "be checked out")),
 418                 OPT_END(),
 419         };
 420         const char * const clone_usage[] = {
 421                 N_("scalar clone [<options>] [--] <repo> [<dir>]"),
 422                 NULL
 423         };
 424         const char *url;
 425         char *enlistment = NULL, *dir = NULL;
 426         struct strbuf buf = STRBUF_INIT;
 427         int res;
 428
 429         argc = parse_options(argc, argv, NULL, clone_options, clone_usage, 0);
 430
 431         if (argc == 2) {
 432                 url = argv[0];
 433                 enlistment = xstrdup(argv[1]);
 434         } else if (argc == 1) {
 435                 url = argv[0];
 436
 437                 strbuf_addstr(&buf, url);
 438                 /* Strip trailing slashes, if any */
 439                 while (buf.len > 0 && is_dir_sep(buf.buf[buf.len - 1]))
 440                         strbuf_setlen(&buf, buf.len - 1);
 441                 /* Strip suffix `.git`, if any */
 442                 strbuf_strip_suffix(&buf, ".git");
 443
 444                 enlistment = find_last_dir_sep(buf.buf);
 445                 if (!enlistment) {
 446                         die(_("cannot deduce worktree name from '%s'"), url);
 447                 }
 448                 enlistment = xstrdup(enlistment + 1);
 449         } else {
 450                 usage_msg_opt(_("You must specify a repository to clone."),
 451                               clone_usage, clone_options);
 452         }
 453
 454         if (is_directory(enlistment))
 455                 die(_("directory '%s' exists already"), enlistment);
 456
 457         dir = xstrfmt("%s/src", enlistment);
 458
 459         strbuf_reset(&buf);
 460         if (branch)
 461                 strbuf_addf(&buf, "init.defaultBranch=%s", branch);
 462         else {
 463                 char *b = repo_default_branch_name(the_repository, 1);
 464                 strbuf_addf(&buf, "init.defaultBranch=%s", b);
 465                 free(b);
 466         }
 467
 468         if ((res = run_git("-c", buf.buf, "init", "--", dir, NULL)))
 469                 goto cleanup;
 470
 471         if (chdir(dir) < 0) {
 472                 res = error_errno(_("could not switch to '%s'"), dir);
 473                 goto cleanup;
 474         }
 475
 476         setup_git_directory();
 477
 478         /* common-main already logs `argv` */
 479         trace2_def_repo(the_repository);
 480
 481         if (!branch && !(branch = remote_default_branch(url))) {
 482                 res = error(_("failed to get default branch for '%s'"), url);
 483                 goto cleanup;
 484         }
 485
 486         if (set_config("remote.origin.url=%s", url) ||
 487             set_config("remote.origin.fetch="
 488                        "+refs/heads/%s:refs/remotes/origin/%s",
 489                        single_branch ? branch : "*",
 490                        single_branch ? branch : "*") ||
 491             set_config("remote.origin.promisor=true") ||
 492             set_config("remote.origin.partialCloneFilter=blob:none")) {
 493                 res = error(_("could not configure remote in '%s'"), dir);
 494                 goto cleanup;
 495         }
 496
 497         if (!full_clone &&
 498             (res = run_git("sparse-checkout", "init", "--cone", NULL)))
 499                 goto cleanup;
 500
 501         if (set_recommended_config(0))
 502                 return error(_("could not configure '%s'"), dir);
 503
 504         if ((res = run_git("fetch", "--quiet",
 505                                 show_progress ? "--progress" : "--no-progress",
 506                                 "origin", NULL))) {
 507                 warning(_("partial clone failed; attempting full clone"));
 508
 509                 if (set_config("remote.origin.promisor") ||
 510                     set_config("remote.origin.partialCloneFilter")) {
 511                         res = error(_("could not configure for full clone"));
 512                         goto cleanup;
 513                 }
 514
 515                 if ((res = run_git("fetch", "--quiet",
 516                                         show_progress ? "--progress" : "--no-progress",
 517                                         "origin", NULL)))
 518                         goto cleanup;
 519         }
 520
 521         if ((res = set_config("branch.%s.remote=origin", branch)))
 522                 goto cleanup;
 523         if ((res = set_config("branch.%s.merge=refs/heads/%s",
 524                               branch, branch)))
 525                 goto cleanup;
 526
 527         strbuf_reset(&buf);
 528         strbuf_addf(&buf, "origin/%s", branch);
 529         res = run_git("checkout", "-f", "-t", buf.buf, NULL);
 530         if (res)
 531                 goto cleanup;
 532
 533         res = register_dir();
 534
 535 cleanup:
 536         free(enlistment);
 537         free(dir);
 538         strbuf_release(&buf);
 539         return res;
 540 }
 541
 542 static int cmd_diagnose(int argc, const char **argv)
 543 {
 544         struct option options[] = {
 545                 OPT_END(),
 546         };
 547         const char * const usage[] = {
 548                 N_("scalar diagnose [<enlistment>]"),
 549                 NULL
 550         };
 551         struct strbuf diagnostics_root = STRBUF_INIT;
 552         int res = 0;
 553
 554         argc = parse_options(argc, argv, NULL, options,
 555                              usage, 0);
 556
 557         setup_enlistment_directory(argc, argv, usage, options, &diagnostics_root);
 558         strbuf_addstr(&diagnostics_root, "/.scalarDiagnostics");
 559
 560         res = run_git("diagnose", "--mode=all", "-s", "%Y%m%d_%H%M%S",
 561                       "-o", diagnostics_root.buf, NULL);
 562
 563         strbuf_release(&diagnostics_root);
 564         return res;
 565 }
 566
 567 static int cmd_list(int argc, const char **argv)
 568 {
 569         if (argc != 1)
 570                 die(_("`scalar list` does not take arguments"));
 571
 572         if (run_git("config", "--global", "--get-all", "scalar.repo", NULL) < 0)
 573                 return -1;
 574         return 0;
 575 }
 576
 577 static int cmd_register(int argc, const char **argv)
 578 {
 579         struct option options[] = {
 580                 OPT_END(),
 581         };
 582         const char * const usage[] = {
 583                 N_("scalar register [<enlistment>]"),
 584                 NULL
 585         };
 586
 587         argc = parse_options(argc, argv, NULL, options,
 588                              usage, 0);
 589
 590         setup_enlistment_directory(argc, argv, usage, options, NULL);
 591
 592         return register_dir();
 593 }
 594
 595 static int get_scalar_repos(const char *key, const char *value, void *data)
 596 {
 597         struct string_list *list = data;
 598
 599         if (!strcmp(key, "scalar.repo"))
 600                 string_list_append(list, value);
 601
 602         return 0;
 603 }
 604
 605 static int remove_deleted_enlistment(struct strbuf *path)
 606 {
 607         int res = 0;
 608         strbuf_realpath_forgiving(path, path->buf, 1);
 609
 610         if (run_git("config", "--global",
 611                     "--unset", "--fixed-value",
 612                     "scalar.repo", path->buf, NULL) < 0)
 613                 res = -1;
 614
 615         if (run_git("config", "--global",
 616                     "--unset", "--fixed-value",
 617                     "maintenance.repo", path->buf, NULL) < 0)
 618                 res = -1;
 619
 620         return res;
 621 }
 622
 623 static int cmd_reconfigure(int argc, const char **argv)
 624 {
 625         int all = 0;
 626         struct option options[] = {
 627                 OPT_BOOL('a', "all", &all,
 628                          N_("reconfigure all registered enlistments")),
 629                 OPT_END(),
 630         };
 631         const char * const usage[] = {
 632                 N_("scalar reconfigure [--all | <enlistment>]"),
 633                 NULL
 634         };
 635         struct string_list scalar_repos = STRING_LIST_INIT_DUP;
 636         int i, res = 0;
 637         struct repository r = { NULL };
 638         struct strbuf commondir = STRBUF_INIT, gitdir = STRBUF_INIT;
 639
 640         argc = parse_options(argc, argv, NULL, options,
 641                              usage, 0);
 642
 643         if (!all) {
 644                 setup_enlistment_directory(argc, argv, usage, options, NULL);
 645
 646                 return set_recommended_config(1);
 647         }
 648
 649         if (argc > 0)
 650                 usage_msg_opt(_("--all or <enlistment>, but not both"),
 651                               usage, options);
 652
 653         git_config(get_scalar_repos, &scalar_repos);
 654
 655         for (i = 0; i < scalar_repos.nr; i++) {
 656                 const char *dir = scalar_repos.items[i].string;
 657
 658                 strbuf_reset(&commondir);
 659                 strbuf_reset(&gitdir);
 660
 661                 if (chdir(dir) < 0) {
 662                         struct strbuf buf = STRBUF_INIT;
 663
 664                         if (errno != ENOENT) {
 665                                 warning_errno(_("could not switch to '%s'"), dir);
 666                                 res = -1;
 667                                 continue;
 668                         }
 669
 670                         strbuf_addstr(&buf, dir);
 671                         if (remove_deleted_enlistment(&buf))
 672                                 res = error(_("could not remove stale "
 673                                               "scalar.repo '%s'"), dir);
 674                         else
 675                                 warning(_("removing stale scalar.repo '%s'"),
 676                                         dir);
 677                         strbuf_release(&buf);
 678                 } else if (discover_git_directory(&commondir, &gitdir) < 0) {
 679                         warning_errno(_("git repository gone in '%s'"), dir);
 680                         res = -1;
 681                 } else {
 682                         git_config_clear();
 683
 684                         the_repository = &r;
 685                         r.commondir = commondir.buf;
 686                         r.gitdir = gitdir.buf;
 687
 688                         if (set_recommended_config(1) < 0)
 689                                 res = -1;
 690                 }
 691         }
 692
 693         string_list_clear(&scalar_repos, 1);
 694         strbuf_release(&commondir);
 695         strbuf_release(&gitdir);
 696
 697         return res;
 698 }
 699
 700 static int cmd_run(int argc, const char **argv)
 701 {
 702         struct option options[] = {
 703                 OPT_END(),
 704         };
 705         struct {
 706                 const char *arg, *task;
 707         } tasks[] = {
 708                 { "config", NULL },
 709                 { "commit-graph", "commit-graph" },
 710                 { "fetch", "prefetch" },
 711                 { "loose-objects", "loose-objects" },
 712                 { "pack-files", "incremental-repack" },
 713                 { NULL, NULL }
 714         };
 715         struct strbuf buf = STRBUF_INIT;
 716         const char *usagestr[] = { NULL, NULL };
 717         int i;
 718
 719         strbuf_addstr(&buf, N_("scalar run <task> [<enlistment>]\nTasks:\n"));
 720         for (i = 0; tasks[i].arg; i++)
 721                 strbuf_addf(&buf, "\t%s\n", tasks[i].arg);
 722         usagestr[0] = buf.buf;
 723
 724         argc = parse_options(argc, argv, NULL, options,
 725                              usagestr, 0);
 726
 727         if (!argc)
 728                 usage_with_options(usagestr, options);
 729
 730         if (!strcmp("all", argv[0])) {
 731                 i = -1;
 732         } else {
 733                 for (i = 0; tasks[i].arg && strcmp(tasks[i].arg, argv[0]); i++)
 734                         ; /* keep looking for the task */
 735
 736                 if (i > 0 && !tasks[i].arg) {
 737                         error(_("no such task: '%s'"), argv[0]);
 738                         usage_with_options(usagestr, options);
 739                 }
 740         }
 741
 742         argc--;
 743         argv++;
 744         setup_enlistment_directory(argc, argv, usagestr, options, NULL);
 745         strbuf_release(&buf);
 746
 747         if (i == 0)
 748                 return register_dir();
 749
 750         if (i > 0)
 751                 return run_git("maintenance", "run",
 752                                "--task", tasks[i].task, NULL);
 753
 754         if (register_dir())
 755                 return -1;
 756         for (i = 1; tasks[i].arg; i++)
 757                 if (run_git("maintenance", "run",
 758                             "--task", tasks[i].task, NULL))
 759                         return -1;
 760         return 0;
 761 }
 762
 763 static int cmd_unregister(int argc, const char **argv)
 764 {
 765         struct option options[] = {
 766                 OPT_END(),
 767         };
 768         const char * const usage[] = {
 769                 N_("scalar unregister [<enlistment>]"),
 770                 NULL
 771         };
 772
 773         argc = parse_options(argc, argv, NULL, options,
 774                              usage, 0);
 775
 776         /*
 777          * Be forgiving when the enlistment or worktree does not even exist any
 778          * longer; This can be the case if a user deleted the worktree by
 779          * mistake and _still_ wants to unregister the thing.
 780          */
 781         if (argc == 1) {
 782                 struct strbuf src_path = STRBUF_INIT, workdir_path = STRBUF_INIT;
 783
 784                 strbuf_addf(&src_path, "%s/src/.git", argv[0]);
 785                 strbuf_addf(&workdir_path, "%s/.git", argv[0]);
 786                 if (!is_directory(src_path.buf) && !is_directory(workdir_path.buf)) {
 787                         /* remove possible matching registrations */
 788                         int res = -1;
 789
 790                         strbuf_strip_suffix(&src_path, "/.git");
 791                         res = remove_deleted_enlistment(&src_path) && res;
 792
 793                         strbuf_strip_suffix(&workdir_path, "/.git");
 794                         res = remove_deleted_enlistment(&workdir_path) && res;
 795
 796                         strbuf_release(&src_path);
 797                         strbuf_release(&workdir_path);
 798                         return res;
 799                 }
 800                 strbuf_release(&src_path);
 801                 strbuf_release(&workdir_path);
 802         }
 803
 804         setup_enlistment_directory(argc, argv, usage, options, NULL);
 805
 806         return unregister_dir();
 807 }
 808
 809 static int cmd_delete(int argc, const char **argv)
 810 {
 811         char *cwd = xgetcwd();
 812         struct option options[] = {
 813                 OPT_END(),
 814         };
 815         const char * const usage[] = {
 816                 N_("scalar delete <enlistment>"),
 817                 NULL
 818         };
 819         struct strbuf enlistment = STRBUF_INIT;
 820         int res = 0;
 821
 822         argc = parse_options(argc, argv, NULL, options,
 823                              usage, 0);
 824
 825         if (argc != 1)
 826                 usage_with_options(usage, options);
 827
 828         setup_enlistment_directory(argc, argv, usage, options, &enlistment);
 829
 830         if (dir_inside_of(cwd, enlistment.buf) >= 0)
 831                 res = error(_("refusing to delete current working directory"));
 832         else {
 833                 close_object_store(the_repository->objects);
 834                 res = delete_enlistment(&enlistment);
 835         }
 836         strbuf_release(&enlistment);
 837         free(cwd);
 838
 839         return res;
 840 }
 841
 842 static int cmd_help(int argc, const char **argv)
 843 {
 844         struct option options[] = {
 845                 OPT_END(),
 846         };
 847         const char * const usage[] = {
 848                 "scalar help",
 849                 NULL
 850         };
 851
 852         argc = parse_options(argc, argv, NULL, options,
 853                              usage, 0);
 854
 855         if (argc != 0)
 856                 usage_with_options(usage, options);
 857
 858         return run_git("help", "scalar", NULL);
 859 }
 860
 861 static int cmd_version(int argc, const char **argv)
 862 {
 863         int verbose = 0, build_options = 0;
 864         struct option options[] = {
 865                 OPT__VERBOSE(&verbose, N_("include Git version")),
 866                 OPT_BOOL(0, "build-options", &build_options,
 867                          N_("include Git's build options")),
 868                 OPT_END(),
 869         };
 870         const char * const usage[] = {
 871                 N_("scalar verbose [-v | --verbose] [--build-options]"),
 872                 NULL
 873         };
 874         struct strbuf buf = STRBUF_INIT;
 875
 876         argc = parse_options(argc, argv, NULL, options,
 877                              usage, 0);
 878
 879         if (argc != 0)
 880                 usage_with_options(usage, options);
 881
 882         get_version_info(&buf, build_options);
 883         fprintf(stderr, "%s\n", buf.buf);
 884         strbuf_release(&buf);
 885
 886         return 0;
 887 }
 888
 889 static struct {
 890         const char *name;
 891         int (*fn)(int, const char **);
 892 } builtins[] = {
 893         { "clone", cmd_clone },
 894         { "list", cmd_list },
 895         { "register", cmd_register },
 896         { "unregister", cmd_unregister },
 897         { "run", cmd_run },
 898         { "reconfigure", cmd_reconfigure },
 899         { "delete", cmd_delete },
 900         { "help", cmd_help },
 901         { "version", cmd_version },
 902         { "diagnose", cmd_diagnose },
 903         { NULL, NULL},
 904 };
 905
 906 int cmd_main(int argc, const char **argv)
 907 {
 908         struct strbuf scalar_usage = STRBUF_INIT;
 909         int i;
 910
 911         while (argc > 1 && *argv[1] == '-') {
 912                 if (!strcmp(argv[1], "-C")) {
 913                         if (argc < 3)
 914                                 die(_("-C requires a <directory>"));
 915                         if (chdir(argv[2]) < 0)
 916                                 die_errno(_("could not change to '%s'"),
 917                                           argv[2]);
 918                         argc -= 2;
 919                         argv += 2;
 920                 } else if (!strcmp(argv[1], "-c")) {
 921                         if (argc < 3)
 922                                 die(_("-c requires a <key>=<value> argument"));
 923                         git_config_push_parameter(argv[2]);
 924                         argc -= 2;
 925                         argv += 2;
 926                 } else
 927                         break;
 928         }
 929
 930         if (argc > 1) {
 931                 argv++;
 932                 argc--;
 933
 934                 for (i = 0; builtins[i].name; i++)
 935                         if (!strcmp(builtins[i].name, argv[0]))
 936                                 return !!builtins[i].fn(argc, argv);
 937         }
 938
 939         strbuf_addstr(&scalar_usage,
 940                       N_("scalar [-C <directory>] [-c <key>=<value>] "
 941                          "<command> [<options>]\n\nCommands:\n"));
 942         for (i = 0; builtins[i].name; i++)
 943                 strbuf_addf(&scalar_usage, "\t%s\n", builtins[i].name);
 944
 945         usage(scalar_usage.buf);
 946 }