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