advice.c

   1 #include "git-compat-util.h"
   2 #include "advice.h"
   3 #include "config.h"
   4 #include "color.h"
   5 #include "gettext.h"
   6 #include "help.h"
   7 #include "string-list.h"
   8
   9 static int advice_use_color = -1;
  10 static char advice_colors[][COLOR_MAXLEN] = {
  11         GIT_COLOR_RESET,
  12         GIT_COLOR_YELLOW,       /* HINT */
  13 };
  14
  15 enum color_advice {
  16         ADVICE_COLOR_RESET = 0,
  17         ADVICE_COLOR_HINT = 1,
  18 };
  19
  20 static int parse_advise_color_slot(const char *slot)
  21 {
  22         if (!strcasecmp(slot, "reset"))
  23                 return ADVICE_COLOR_RESET;
  24         if (!strcasecmp(slot, "hint"))
  25                 return ADVICE_COLOR_HINT;
  26         return -1;
  27 }
  28
  29 static const char *advise_get_color(enum color_advice ix)
  30 {
  31         if (want_color_stderr(advice_use_color))
  32                 return advice_colors[ix];
  33         return "";
  34 }
  35
  36 enum advice_level {
  37         ADVICE_LEVEL_NONE = 0,
  38         ADVICE_LEVEL_DISABLED,
  39         ADVICE_LEVEL_ENABLED,
  40 };
  41
  42 static struct {
  43         const char *key;
  44         enum advice_level level;
  45 } advice_setting[] = {
  46         [ADVICE_ADD_EMBEDDED_REPO]                      = { "addEmbeddedRepo" },
  47         [ADVICE_ADD_EMPTY_PATHSPEC]                     = { "addEmptyPathspec" },
  48         [ADVICE_ADD_IGNORED_FILE]                       = { "addIgnoredFile" },
  49         [ADVICE_AMBIGUOUS_FETCH_REFSPEC]                = { "ambiguousFetchRefspec" },
  50         [ADVICE_AM_WORK_DIR]                            = { "amWorkDir" },
  51         [ADVICE_CHECKOUT_AMBIGUOUS_REMOTE_BRANCH_NAME]  = { "checkoutAmbiguousRemoteBranchName" },
  52         [ADVICE_COMMIT_BEFORE_MERGE]                    = { "commitBeforeMerge" },
  53         [ADVICE_DETACHED_HEAD]                          = { "detachedHead" },
  54         [ADVICE_DIVERGING]                              = { "diverging" },
  55         [ADVICE_FETCH_SHOW_FORCED_UPDATES]              = { "fetchShowForcedUpdates" },
  56         [ADVICE_FORCE_DELETE_BRANCH]                    = { "forceDeleteBranch" },
  57         [ADVICE_GRAFT_FILE_DEPRECATED]                  = { "graftFileDeprecated" },
  58         [ADVICE_IGNORED_HOOK]                           = { "ignoredHook" },
  59         [ADVICE_IMPLICIT_IDENTITY]                      = { "implicitIdentity" },
  60         [ADVICE_MERGE_CONFLICT]                         = { "mergeConflict" },
  61         [ADVICE_NESTED_TAG]                             = { "nestedTag" },
  62         [ADVICE_OBJECT_NAME_WARNING]                    = { "objectNameWarning" },
  63         [ADVICE_PUSH_ALREADY_EXISTS]                    = { "pushAlreadyExists" },
  64         [ADVICE_PUSH_FETCH_FIRST]                       = { "pushFetchFirst" },
  65         [ADVICE_PUSH_NEEDS_FORCE]                       = { "pushNeedsForce" },
  66         [ADVICE_PUSH_NON_FF_CURRENT]                    = { "pushNonFFCurrent" },
  67         [ADVICE_PUSH_NON_FF_MATCHING]                   = { "pushNonFFMatching" },
  68         [ADVICE_PUSH_REF_NEEDS_UPDATE]                  = { "pushRefNeedsUpdate" },
  69         [ADVICE_PUSH_UNQUALIFIED_REF_NAME]              = { "pushUnqualifiedRefName" },
  70         [ADVICE_PUSH_UPDATE_REJECTED]                   = { "pushUpdateRejected" },
  71         [ADVICE_PUSH_UPDATE_REJECTED_ALIAS]             = { "pushNonFastForward" }, /* backwards compatibility */
  72         [ADVICE_REF_SYNTAX]                             = { "refSyntax" },
  73         [ADVICE_RESET_NO_REFRESH_WARNING]               = { "resetNoRefresh" },
  74         [ADVICE_RESOLVE_CONFLICT]                       = { "resolveConflict" },
  75         [ADVICE_RM_HINTS]                               = { "rmHints" },
  76         [ADVICE_SEQUENCER_IN_USE]                       = { "sequencerInUse" },
  77         [ADVICE_SET_UPSTREAM_FAILURE]                   = { "setUpstreamFailure" },
  78         [ADVICE_SKIPPED_CHERRY_PICKS]                   = { "skippedCherryPicks" },
  79         [ADVICE_STATUS_AHEAD_BEHIND_WARNING]            = { "statusAheadBehindWarning" },
  80         [ADVICE_STATUS_HINTS]                           = { "statusHints" },
  81         [ADVICE_STATUS_U_OPTION]                        = { "statusUoption" },
  82         [ADVICE_SUBMODULES_NOT_UPDATED]                 = { "submodulesNotUpdated" },
  83         [ADVICE_SUBMODULE_ALTERNATE_ERROR_STRATEGY_DIE] = { "submoduleAlternateErrorStrategyDie" },
  84         [ADVICE_SUBMODULE_MERGE_CONFLICT]               = { "submoduleMergeConflict" },
  85         [ADVICE_SUGGEST_DETACHING_HEAD]                 = { "suggestDetachingHead" },
  86         [ADVICE_UPDATE_SPARSE_PATH]                     = { "updateSparsePath" },
  87         [ADVICE_WAITING_FOR_EDITOR]                     = { "waitingForEditor" },
  88         [ADVICE_WORKTREE_ADD_ORPHAN]                    = { "worktreeAddOrphan" },
  89 };
  90
  91 static const char turn_off_instructions[] =
  92 N_("\n"
  93    "Disable this message with \"git config advice.%s false\"");
  94
  95 static void vadvise(const char *advice, int display_instructions,
  96                     const char *key, va_list params)
  97 {
  98         struct strbuf buf = STRBUF_INIT;
  99         const char *cp, *np;
 100
 101         strbuf_vaddf(&buf, advice, params);
 102
 103         if (display_instructions)
 104                 strbuf_addf(&buf, turn_off_instructions, key);
 105
 106         for (cp = buf.buf; *cp; cp = np) {
 107                 np = strchrnul(cp, '\n');
 108                 fprintf(stderr, _("%shint: %.*s%s\n"),
 109                         advise_get_color(ADVICE_COLOR_HINT),
 110                         (int)(np - cp), cp,
 111                         advise_get_color(ADVICE_COLOR_RESET));
 112                 if (*np)
 113                         np++;
 114         }
 115         strbuf_release(&buf);
 116 }
 117
 118 void advise(const char *advice, ...)
 119 {
 120         va_list params;
 121         va_start(params, advice);
 122         vadvise(advice, 0, "", params);
 123         va_end(params);
 124 }
 125
 126 int advice_enabled(enum advice_type type)
 127 {
 128         int enabled = advice_setting[type].level != ADVICE_LEVEL_DISABLED;
 129
 130         if (type == ADVICE_PUSH_UPDATE_REJECTED)
 131                 return enabled &&
 132                        advice_enabled(ADVICE_PUSH_UPDATE_REJECTED_ALIAS);
 133
 134         return enabled;
 135 }
 136
 137 void advise_if_enabled(enum advice_type type, const char *advice, ...)
 138 {
 139         va_list params;
 140
 141         if (!advice_enabled(type))
 142                 return;
 143
 144         va_start(params, advice);
 145         vadvise(advice, !advice_setting[type].level, advice_setting[type].key,
 146                 params);
 147         va_end(params);
 148 }
 149
 150 int git_default_advice_config(const char *var, const char *value)
 151 {
 152         const char *k, *slot_name;
 153         int i;
 154
 155         if (!strcmp(var, "color.advice")) {
 156                 advice_use_color = git_config_colorbool(var, value);
 157                 return 0;
 158         }
 159
 160         if (skip_prefix(var, "color.advice.", &slot_name)) {
 161                 int slot = parse_advise_color_slot(slot_name);
 162                 if (slot < 0)
 163                         return 0;
 164                 if (!value)
 165                         return config_error_nonbool(var);
 166                 return color_parse(value, advice_colors[slot]);
 167         }
 168
 169         if (!skip_prefix(var, "advice.", &k))
 170                 return 0;
 171
 172         for (i = 0; i < ARRAY_SIZE(advice_setting); i++) {
 173                 if (strcasecmp(k, advice_setting[i].key))
 174                         continue;
 175                 advice_setting[i].level = git_config_bool(var, value)
 176                                           ? ADVICE_LEVEL_ENABLED
 177                                           : ADVICE_LEVEL_DISABLED;
 178                 return 0;
 179         }
 180
 181         return 0;
 182 }
 183
 184 void list_config_advices(struct string_list *list, const char *prefix)
 185 {
 186         int i;
 187
 188         for (i = 0; i < ARRAY_SIZE(advice_setting); i++)
 189                 list_config_item(list, prefix, advice_setting[i].key);
 190 }
 191
 192 int error_resolve_conflict(const char *me)
 193 {
 194         if (!strcmp(me, "cherry-pick"))
 195                 error(_("Cherry-picking is not possible because you have unmerged files."));
 196         else if (!strcmp(me, "commit"))
 197                 error(_("Committing is not possible because you have unmerged files."));
 198         else if (!strcmp(me, "merge"))
 199                 error(_("Merging is not possible because you have unmerged files."));
 200         else if (!strcmp(me, "pull"))
 201                 error(_("Pulling is not possible because you have unmerged files."));
 202         else if (!strcmp(me, "revert"))
 203                 error(_("Reverting is not possible because you have unmerged files."));
 204         else if (!strcmp(me, "rebase"))
 205                 error(_("Rebasing is not possible because you have unmerged files."));
 206         else
 207                 BUG("Unhandled conflict reason '%s'", me);
 208
 209         if (advice_enabled(ADVICE_RESOLVE_CONFLICT))
 210                 /*
 211                  * Message used both when 'git commit' fails and when
 212                  * other commands doing a merge do.
 213                  */
 214                 advise(_("Fix them up in the work tree, and then use 'git add/rm <file>'\n"
 215                          "as appropriate to mark resolution and make a commit."));
 216         return -1;
 217 }
 218
 219 void NORETURN die_resolve_conflict(const char *me)
 220 {
 221         error_resolve_conflict(me);
 222         die(_("Exiting because of an unresolved conflict."));
 223 }
 224
 225 void NORETURN die_conclude_merge(void)
 226 {
 227         error(_("You have not concluded your merge (MERGE_HEAD exists)."));
 228         if (advice_enabled(ADVICE_RESOLVE_CONFLICT))
 229                 advise(_("Please, commit your changes before merging."));
 230         die(_("Exiting because of unfinished merge."));
 231 }
 232
 233 void NORETURN die_ff_impossible(void)
 234 {
 235         advise_if_enabled(ADVICE_DIVERGING,
 236                 _("Diverging branches can't be fast-forwarded, you need to either:\n"
 237                 "\n"
 238                 "\tgit merge --no-ff\n"
 239                 "\n"
 240                 "or:\n"
 241                 "\n"
 242                 "\tgit rebase\n"));
 243         die(_("Not possible to fast-forward, aborting."));
 244 }
 245
 246 void advise_on_updating_sparse_paths(struct string_list *pathspec_list)
 247 {
 248         struct string_list_item *item;
 249
 250         if (!pathspec_list->nr)
 251                 return;
 252
 253         fprintf(stderr, _("The following paths and/or pathspecs matched paths that exist\n"
 254                           "outside of your sparse-checkout definition, so will not be\n"
 255                           "updated in the index:\n"));
 256         for_each_string_list_item(item, pathspec_list)
 257                 fprintf(stderr, "%s\n", item->string);
 258
 259         advise_if_enabled(ADVICE_UPDATE_SPARSE_PATH,
 260                           _("If you intend to update such entries, try one of the following:\n"
 261                             "* Use the --sparse option.\n"
 262                             "* Disable or modify the sparsity rules."));
 263 }
 264
 265 void detach_advice(const char *new_name)
 266 {
 267         const char *fmt =
 268         _("Note: switching to '%s'.\n"
 269         "\n"
 270         "You are in 'detached HEAD' state. You can look around, make experimental\n"
 271         "changes and commit them, and you can discard any commits you make in this\n"
 272         "state without impacting any branches by switching back to a branch.\n"
 273         "\n"
 274         "If you want to create a new branch to retain commits you create, you may\n"
 275         "do so (now or later) by using -c with the switch command. Example:\n"
 276         "\n"
 277         "  git switch -c <new-branch-name>\n"
 278         "\n"
 279         "Or undo this operation with:\n"
 280         "\n"
 281         "  git switch -\n"
 282         "\n"
 283         "Turn off this advice by setting config variable advice.detachedHead to false\n\n");
 284
 285         fprintf(stderr, fmt, new_name);
 286 }
 287
 288 void advise_on_moving_dirty_path(struct string_list *pathspec_list)
 289 {
 290         struct string_list_item *item;
 291
 292         if (!pathspec_list->nr)
 293                 return;
 294
 295         fprintf(stderr, _("The following paths have been moved outside the\n"
 296                           "sparse-checkout definition but are not sparse due to local\n"
 297                           "modifications.\n"));
 298         for_each_string_list_item(item, pathspec_list)
 299                 fprintf(stderr, "%s\n", item->string);
 300
 301         advise_if_enabled(ADVICE_UPDATE_SPARSE_PATH,
 302                           _("To correct the sparsity of these paths, do the following:\n"
 303                             "* Use \"git add --sparse <paths>\" to update the index\n"
 304                             "* Use \"git sparse-checkout reapply\" to apply the sparsity rules"));
 305 }