File f-apps/f-ciwoco.c from the latest check-in

/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ 
/* vim: set ts=2 et sw=2 tw=80: */
  Copyright 2013-2021 The Libfossil Authors, see LICENSES/BSD-2-Clause.txt

  SPDX-License-Identifier: BSD-2-Clause-FreeBSD
  SPDX-FileCopyrightText: 2021 The Libfossil Authors
  SPDX-ArtifactOfProjectName: Libfossil
  SPDX-FileType: Code
   f-ciwoco is a libfossil app to create checkins in a repository without
   requiring a checkout. ciwoco = CheckIn WithOut CheckOut.
#ifdef NDEBUG
/* Force assert() to always be in effect. */
#undef NDEBUG
#include "libfossil.h"
#include <string.h>

// Only for testing/debugging..
#define MARKER(pfexp)                                               \
  do{ printf("MARKER: %s:%d:%s():\t",__FILE__,__LINE__,__func__);   \
    printf pfexp;                                                   \
  } while(0)

// Global app state.
struct App_ {
  char const * sym;
  char const * branch;
  char const * comment;
  char const * commentFile;
  char const * stripPrefix;
  fsl_size_t nStripPrefix;
  bool addRCard;
  bool dryRun;
  bool checkIgnoreGlobs;
  bool noChangesNoCry;
} App = {
.sym = "trunk",
.branch = NULL,
.comment = NULL,
.commentFile = NULL,
.stripPrefix = NULL,
.nStripPrefix = 0,
.addRCard = true,
.dryRun = false,
.checkIgnoreGlobs = true,
.noChangesNoCry = false

   Takes a filename in the form NAME[:REPO-NAME] and dissects it into
   two parts:

   *localName is the NAME part.

   *repoName is the REPO-NAME part, if set, else the NAME part.

   The returned strings are owned by fcli and survive until app
static void parse_fn(char const *full, char const ** localName,
                    char const ** repoName){
  char * z = fcli_fax( fsl_strdup(full) );
  *localName = *repoName = z;
  if('.'==z[0] && '/'==z[1]){
    /* For usability convenience, e.g. passing along input from:

       find . -type f

       Strip any leading ./ on the reponame part.
    *repoName = z;
  while( *z && *z!=':' ) ++z;
    *z++ = 0;
    *repoName = z;
    if(0==fsl_strncmp(App.stripPrefix, *repoName, App.nStripPrefix)){
      *repoName += App.nStripPrefix;

   Checks whether d has changes compared to its parent (if any).
   Returns 0 on succcess (any error is considered fatal). Sets *rv to
   true if there are changes, else *rv to false.
static int deck_check_changes(fsl_deck * const d, bool * rv){
  int rc = 0;
  fsl_cx * const f = d->f;
  fsl_deck p = fsl_deck_empty;
  *rv = false;
    /* New root deck. */
    *rv = true;
    return 0;
  rc = fsl_deck_load_sym(f, &p, (char const *)d->P.list[0], d->type);
  if(rc) goto end;
  if(p.F.used != d->F.used
     /* ^^^ that isn't necessarily a correct heuristic if the parent
        is a delta manifest. */
     || (p.R && d->R && fsl_strcmp(p.R,d->R))){
    goto change;
  for(fsl_size_t i = 0; i < p.F.used; ++i ){
    fsl_card_F const * const fL = &p.F.list[i];
    fsl_card_F const * const fR = &d->F.list[i];
       || fsl_strcmp(fL->name, fR->name)
       || fsl_strcmp(fL->uuid, fR->uuid)
       || fL->perm != fR->perm){
      goto change;
  return rc;
  *rv = true;
  goto end;

   Does... everything. Returns 0 on success (or non-error).
static int do_everything(void){
  int rc = 0;
  fsl_cx * const f = fcli_cx();
  fsl_deck d = fsl_deck_empty;
  char const *fname = 0;
  fsl_buffer fcontent = fsl_buffer_empty;
  int const verbose = fcli_is_verbose();
  bool isNewRoot = false;
  char * dBranch = NULL;
  rc = fsl_cx_transaction_begin(f);
  if(rc) return rc;

  if(0==fsl_strcmp("-", App.sym)){
    isNewRoot = true;
    fsl_deck_init(f, &d, FSL_SATYPE_CHECKIN);
    if(!App.branch || !*App.branch){
      // We "need" a default branch, so...
      App.branch = "ciwoco";
    rc = fsl_deck_load_sym(f, &d, App.sym, FSL_SATYPE_CHECKIN);
    if(rc) goto end;
    f_out("Deriving from checkin [%s] (RID %"FSL_ID_T_PFMT")\n",
          App.sym, d.rid);
    rc = fsl_deck_derive(&d);
    if(rc) goto end;
      rc = fsl_branch_of_rid(f, d.rid, true, &dBranch);
      if(rc) goto end;
    if(isNewRoot || 0!=fsl_strcmp(dBranch, App.branch)){
      /* Only set the branch if it would really be a change. In that case,
         we need to cancel the previous branch's tag. */
      rc = fsl_deck_branch_set(&d, App.branch);
      if(!rc && dBranch){
        dBranch = fsl_mprintf("sym-%z", dBranch);
        rc = fsl_deck_T_add(&d, FSL_TAGTYPE_CANCEL, NULL, dBranch,
                            "Cancelled by branch.");
      if(rc) goto end;
    rc = fsl_buffer_fill_from_filename(&fcontent, App.commentFile);
      rc = fcli_err_set(rc, "Cannot read comment file: %s", App.commentFile);
      goto end;
    char * c = fsl_buffer_take(&fcontent);
    App.comment = c;
    rc = fcli_err_set(FSL_RC_MISUSE, "Missing required checkin comment.");
    goto end;

  rc = fsl_deck_C_set(&d, App.comment, -1);
    char const * u = fsl_cx_user_get(f);
      rc = fcli_err_set(FSL_RC_MISUSE,
                        "Cannot determine user name. "
                        "Try using --user NAME.");
      rc = fsl_deck_U_set(&d, u);
  if(rc) goto end;

     Look for args in the form:


     Where FILENAME is the local filesystem name and REPO-NAME is the
     name of that file within the repository, defaulting to FILENAME.

     Potential TODOs:

     - If FILENAME is a directory, process it recursively. If so, possibly
     offer a flag which tells it to only process files which already exist.
  while((fname = fcli_next_arg(true))){
    /* Handle input files... */
    char const * nameLocal = 0;
    char const * nameRepo = 0;
    fsl_fstat fst = fsl_fstat_empty;
    parse_fn(fname, &nameLocal, &nameRepo);
    if(!*nameLocal || !*nameRepo){
      rc = fcli_err_set(FSL_RC_MISUSE,
                        "Only Chuck Norris may use empty filenames.");
      goto end;
    rc = fsl_stat(nameLocal, &fst, false);
      rc = fcli_err_set(rc, "Error stat()'ing file: %s", nameLocal);
      goto end;
      case FSL_FSTAT_TYPE_DIR:
        rc = fcli_err_set(FSL_RC_TYPE,
                          "Cannot currently CiWoCo a whole directory: %s",
        rc = fcli_err_set(FSL_RC_TYPE,
                          "Symlinks are currently unsupported: %s",
        rc = fcli_err_set(FSL_RC_TYPE, "Unknown file type: %s", nameLocal);
      case FSL_FSTAT_TYPE_FILE: break;
    if(rc) goto end;
    rc = fsl_buffer_fill_from_filename(&fcontent, nameLocal);
      rc = fcli_err_set(rc, "Error reading file: %s", nameLocal);
      goto end;
      if(fsl_cx_glob_matches(f, FSL_GLOBS_IGNORE, nameRepo)){
          f_out("Skipping due to ignore-glob: %s\n", nameLocal);
    fsl_card_F const * fc = fsl_deck_F_search(&d, nameRepo);
      /* New file: make sure its name is not reserved. If it's reserved
         but already in the repo then the damage is already done and
         we won't enforce it retroactively. */
      rc = fsl_reserved_fn_check(f, nameRepo, -1, false);
      f_out("reserved name check: %s %s\n", fsl_rc_cstr(rc), nameRepo);
      if(rc) goto end;
      char const * const action = fc ? "Updating" : "Adding";
        f_out("%s [%s] as [%s]\n", action,nameLocal, nameRepo);
        f_out("%s [%s]\n", action, nameLocal);
    rc = fsl_deck_F_set_content(&d, nameRepo, &fcontent,
                                ? FSL_FILE_PERM_EXE
                                : FSL_FILE_PERM_REGULAR,
    if(rc) goto end;
  }/*next-arg loop*/

  if(App.addRCard || (isNewRoot && !d.F.used)
     /* A checkin artifact with no P/F/Q/R-cards cannot be unambiguously
        recognized as a checkin, so we'll add an R-card if someone
        creates an empty root-level checkin. */
    if(verbose) f_out("Calculating R-card... ");
    rc = fsl_deck_R_calc(&d);
    if(verbose) f_out("\n");
    if(rc) goto end;

    f_out("Creating new root entry.\n");
    bool gotChanges = false;
    rc = deck_check_changes(&d, &gotChanges);
    if(rc) goto end;
    else if(!gotChanges){
        f_out("No changes were made. Exiting without an error.\n");
        goto end;
        rc = fcli_err_set(FSL_RC_NOOP,
                          "No file changes were made from "
                          "the parent version. Use --no-change-no-error "
                          "to permit a checkin anyway.");
        goto end;

  double const julian = true
    ? fsl_db_julian_now(fsl_cx_db_repo(f))
    /* ^^^^ ms precision */
    : fsl_julian_now() /* seconds precision */;
  rc = fsl_deck_D_set(&d, julian);
  if(rc) goto end;

  rc = fsl_deck_save(&d, false);
  if(rc) goto end;
  f_out("Saved checkin %z (RID %"FSL_ID_T_PFMT")\n",
        fsl_rid_to_uuid(d.f, d.rid), d.rid);
    f_out("Dry-run mode. Rolling back.\n");
      rc = fsl_deck_output(&d, NULL, NULL);
      if(rc) goto end;
    f_out("ACHTUNG: current checkouts of this repo will not "
          "automatically know about this commit: they'll need "
          "to 'update' to see the changes.\n");

  rc = fsl_cx_transaction_end(f, App.dryRun);
    fsl_cx_transaction_end(f, true);
  return rc;

static void ciwoco_help(void){
  f_out("Each non-flag argument is expected to be a file name "
        "in the form LOCALNAME:REPONAME, e.g. '/etc/hosts:foo/hosts'. "
        "The REPONAME part must be a repository-friendly name, e.g. no "
        "leading slashes nor stray ./ components. The default value "
        "for the REPONAME part is the LOCALNAME part, but that will "
        "only be useful in limited cases. ");
  f_out("As a special case, any leading './' on the REPONAME part "
        "is elided\n");

int main(int argc, const char * const * argv ){
  const fcli_cliflag FCliFlags[] = {
    FCLI_FLAG("v", "version", "version", &App.sym,
              "Version to derive from (default='trunk'). "
              "Use the value '-' to create a new checkin "
              "without a parent checkin. In that case, the "
              "--branch flag is strongly recommended."),
    FCLI_FLAG("b", "branch", "branch-name", &App.branch,
              "Create a new branch for the new checkin."),
    FCLI_FLAG("m", "comment", "string", &App.comment,
              "Checkin comment."),
    FCLI_FLAG("M", "comment-file", "filename", &App.commentFile,
              "Checkin comment from a file (trumps -m)."),
    FCLI_FLAG("p", "strip-prefix", "string", &App.stripPrefix,
              "Any repository-side filenames which start with the "
              "given prefix get that prefix stripped from them."),
    FCLI_FLAG_BOOL("e","no-change-no-error", &App.noChangesNoCry,
                   "If no changes were made from the previous "
                   "version, exit without an error. New root entries "
                   "are always considered to be changes."),
    FCLI_FLAG_BOOL("n", "dry-run", &App.dryRun,
                   "Dry-run mode. If verbose mode is active, "
                   "the resuling manifest is sent to stdout."),
    FCLI_FLAG_BOOL_INVERT("i", "no-ignore-glob", &App.checkIgnoreGlobs,
                          "If set, do not honor the repo-level 'ignore-glob' "
                          "config setting to determine whether to skip a given "
    FCLI_FLAG_BOOL_INVERT(NULL, "no-r-card", &App.addRCard,
                          "If set, do not add an R-card to commits. "
                          "Even with this flag, an R-card is always "
                          "added for cases where not having one may "
                          "produce an ambiguous artifact."),
    fcli_cliflag_empty_m // list MUST end with this (or equivalent)
  const fcli_help_info FCliHelp = {
    "Creates a checkin into a fossil repository without an "
    "intermediary checkout.",
    "file1:file1-repo-name ... fileN:file-N-repo-name",
    // ^^^ very brief usage text, e.g. "file1 [...fileN]"
    ciwoco_help // optional callback which outputs app-specific help
  fsl_cx * f = NULL;
  fcli.clientFlags.checkoutDir = NULL; // same effect as global --no-checkout flag.
  int rc = fcli_setup_v2(argc, argv, FCliFlags, &FCliHelp);
  if(rc) goto end;
  else if((rc=fcli_has_unused_flags(false))) goto end;
  f = fcli_cx();
    rc = FSL_RC_NOT_A_REPO;
    goto end;
  fsl_cx_flag_set(f, FSL_CX_F_CALC_R_CARD, App.addRCard);
  if(App.stripPrefix) App.nStripPrefix = fsl_strlen(App.stripPrefix);
  rc = do_everything();
  return fcli_end_of_main(rc);