XD/XD.c

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>

#if defined(ERR) || defined(EXPLAIN)
#include <stdarg.h>
#endif

#ifdef GIT
#include <sys/stat.h>
#include <dirent.h>
#include <git2.h>
#endif

#define P(X) fwrite(X, 1, 1, stdout)

#if defined(ERR) || defined(EXPLAIN)
void
l(const char *fmt, ...)
{
  va_list ap;

  va_start(ap, fmt);
  vfprintf(stderr, fmt, ap);
  va_end(ap);

  if (fmt[0] && fmt[strlen(fmt) - 1] == ':') {
    fputc(' ', stderr);
    perror(NULL);
  } else {
    fputc('\n', stderr);
  }
}
#endif

#ifdef ERR
#define L(...) l(__VA_ARGS__)
#else
#define L(...)
#endif

#ifdef EXPLAIN
static int explain = 0;
#define E(...) if (explain) {    \
                 l(__VA_ARGS__); \
               } else
#else
#define E(...)
#endif

#ifdef GIT
/**
 * @brief search all parent directories for a git repo
 *
 * @return absolute path to git repo
 */
char
*find_git_repo()
{
  char path[PATH_MAX] = ".", *rpath;
  struct stat s;
  int i, c;


  /* find the number of jumps to the root of the fs */
  rpath = realpath(path, NULL);
  for (i = c = 0; i < strlen(rpath); i++) {
    if (rpath[i] == '/') {
      c++;
    }
  }
  free(rpath);

  /* start searching */
  for (i = c; i > 0; i--) {
    strcat(path, "/.git");

    /* if there seems to be a git directory return the directory it was found in */
    if (stat(path, &s) == 0 && S_ISDIR(s.st_mode)) {
      return realpath(path, NULL);
    }

    /* reset contents of gpath, and go up a directory */
    memset(&path[strlen(path) - 4], '.', 2);
    memset(&path[strlen(path) - 2], 0, 2);
  }

  return NULL;
}

/**
 * @brief open git repo if one is available at the current path
 *
 * @return a pointer to the git repo object
 */
git_repository
*init_git()
{
  char *buf;
  git_repository *repo;

  /* check for a repo before loading libgit2 */
  if ((buf = find_git_repo()) == NULL) {
    return NULL;
  }

  /* disable a bunch of git options to hopefully speed things up */
  git_libgit2_opts(GIT_OPT_ENABLE_CACHING, 0);

  git_libgit2_opts(GIT_OPT_SET_SEARCH_PATH, GIT_CONFIG_LEVEL_GLOBAL, "");
  git_libgit2_opts(GIT_OPT_SET_SEARCH_PATH, GIT_CONFIG_LEVEL_XDG, "");
  git_libgit2_opts(GIT_OPT_SET_SEARCH_PATH, GIT_CONFIG_LEVEL_SYSTEM, "");
  git_libgit2_opts(GIT_OPT_SET_TEMPLATE_PATH, "");

  git_libgit2_opts(GIT_OPT_DISABLE_PACK_KEEP_FILE_CHECKS, 1);

  /* initialize the git library and repository */
  if (git_libgit2_init() < 0) {
    L("Failed to initalize libgit2, proceeding without git functionality enabled.");
    return NULL;
  }

  if (git_repository_open(&repo, buf) < 0) {
    L("Failed to open git repo: %s", git_error_last()->message);
    free(buf);
    return NULL;
  }

  /* get rid of object containing git repo path and return the repo */
  free(buf);
  return repo;
}

/**
 * @brief check for any existing stashes in the provided git repo
 *
 * @param repo git repo to check for existing stashes
 * @return 1 if stashes found 0 otherwise
 */
int
has_stashes(git_repository *repo)
{
	git_reference *stash = NULL;
  int e;

  e = git_reference_lookup(&stash, repo, "refs/stash");
  if (e == GIT_ENOTFOUND) {
    return 0;
  } else if (e < 0) {
    L("Error looking up stash reference: %s", git_error_last()->message);
    return 0;
  } else {
    e = 1;
  }

  git_reference_free(stash);
  return e;
}

/**
 * @brief check for any untracked changes in the current git repo
 *
 * @param repo git repository object
 * @return 1 if any untracked changes have been found 0 otherwise
 */
int
has_untracked(git_repository *repo)
{
  git_status_options opts = GIT_STATUS_OPTIONS_INIT;
  git_status_list *list = NULL;
  int r = 0;

  opts.show = GIT_STATUS_SHOW_INDEX_AND_WORKDIR;
  opts.flags = GIT_STATUS_OPT_INCLUDE_UNTRACKED |
    GIT_STATUS_OPT_RENAMES_HEAD_TO_INDEX;

  if (git_status_list_new(&list, repo, &opts) < 0) {
    L("Error checking for untracked changes: %s", git_error_last()->message);
    return 0;
  }

  /* if any changes are found return 1 */
  if (git_status_list_entrycount(list) > 0) {
    r = 1;
  }

  git_status_list_free(list);
  return r;
}

/**
 * @brief check for staged changes
 *
 * @param repo git repository object
 * @return 1 if any staged changes found 0 otherwise
 */
int
has_staged(git_repository *repo)
{
  git_status_entry entry;
  git_status_list *list = NULL;
  git_status_options opts = GIT_STATUS_OPTIONS_INIT;
  int i, c, r = 0;

  opts.show = GIT_STATUS_SHOW_INDEX_ONLY;
  opts.flags = GIT_STATUS_INDEX_NEW;

  if (git_status_list_new(&list, repo, &opts) < 0) {
    L("Error checking for staged changes: %s", git_error_last()->message);
    return 0;
  }

  /* if any staged changes are found return 1 */
  if ((c = git_status_list_entrycount(list)) > 0) {
    for (i = 0; i < c; i++) {
      entry = *git_status_byindex(list, i);

      if (entry.status & (GIT_STATUS_INDEX_NEW
        | GIT_STATUS_INDEX_DELETED
        | GIT_STATUS_INDEX_MODIFIED)) {
        r = 1;
        break;
      }
    }
  }

  git_status_list_free(list);
  return r;
}
#endif

inline unsigned
numcat(unsigned x, unsigned y)
{
  unsigned pow = 10;
  while(y >= pow) {
    pow *= 10;
  }

  return (x * pow) + y;
}

int
str_to_int(char *str)
{
  int res = -1;
  char *c;

  for (c = str; (*c != '\0') && isdigit(*c); c++) {
    if (res == -1) {
      res = *c - '0';
    } else {
      res = numcat(res, *c - '0');
    }
  }

  return res;
}

int
main(int argc, char *argv[])
{
  int code = -1;

  /* print version information */
  if (argc > 1 && strcmp(argv[1], "-v") == 0) {
    printf("XD [number] v%s\n", VERSION);
    return 0;
  #ifdef EXPLAIN
  } else if (argc > 1 && strcmp(argv[1], "-e") == 0) {
    explain = 1;
  #endif
  }

  #ifdef GIT
  git_repository *repo;

  if ((repo = init_git())) {
    /* change the eyes depending on the current git repo's status */
    if (has_stashes(repo)) {
      E("The current git repo has stashed changes.")
      P("8"); /* goggle eyes if we have some stashed changes */
    } else if (git_repository_is_empty(repo)) {
      E("This is a new git repo.")
      P("B"); /* sunglasses if we're in a new repo with no HEAD */
    } else {
      E("In a git repository.")
      P(";"); /* wink when we're in a git repo */
    }

    /* change the nose depending on the current git repo's status */
    if (has_staged(repo)) {
      E("They're staged changes.")
      P("*"); /* change to broken nose for staged changes */
    } else if (has_untracked(repo)) {
      E("There are untracked changes in the repository.")
      P("^"); /* add a little nose when there are untracked changes in the repo */
    } else if (git_repository_head_detached(repo)) {
      E("The HEAD is detached.")
      P("-"); /* add a minus nose when the HEAD is detached */
    }
    git_repository_free(repo);
    git_libgit2_shutdown();
  } else
  #endif
  if (1) {
    E("Not in a git repository.")
    P(":");
  }

  /* get exit code from user args */
  if (argc > 1 && argv[argc - 1]) {
    code = str_to_int(argv[argc - 1]);
    if (code < 0) {
      L("Return code, %d, not valid", code);
      exit(1);
    }
  }

  /* change mouth based on exit code */
  if (code >= 0) {
    switch (code) {
      case 0: /* all good */
        E("Return code of %d, no errors.", code)
        P(")");
        break;
      case 130: /* Ctrl-c pressed (SIGTERM) */
        E("Return code of %d, ctrl-c was pressed, or SIGTERM sent.", code)
        P("O");
        break;
      case 126: /* permission denied */
        E("Return code of %d, permission denied.", code)
        P("P");
        break;
      case 127: /* command not found */
        E("Return code of %d, command not found.", code)
        P("/");
        break;
      default: /* all other codes (usually the program saying it has failed) */
        E("Return code of %d, probably an error with the program.", code)
        P("(");
        break;
    }
  } else {
    E("No code information passed in.")
    P("|"); /* no code info */
  }

  return code;
}