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_REBASE_TODO_ERROR]                      = { "rebaseTodoError" },
  73         [ADVICE_REF_SYNTAX]                             = { "refSyntax" },
  74         [ADVICE_RESET_NO_REFRESH_WARNING]               = { "resetNoRefresh" },
  75         [ADVICE_RESOLVE_CONFLICT]                       = { "resolveConflict" },
  76         [ADVICE_RM_HINTS]                               = { "rmHints" },
  77         [ADVICE_SEQUENCER_IN_USE]                       = { "sequencerInUse" },
  78         [ADVICE_SET_UPSTREAM_FAILURE]                   = { "setUpstreamFailure" },
  79         [ADVICE_SKIPPED_CHERRY_PICKS]                   = { "skippedCherryPicks" },
  80         [ADVICE_STATUS_AHEAD_BEHIND_WARNING]            = { "statusAheadBehindWarning" },
  81         [ADVICE_STATUS_HINTS]                           = { "statusHints" },
  82         [ADVICE_STATUS_U_OPTION]                        = { "statusUoption" },
  83         [ADVICE_SUBMODULES_NOT_UPDATED]                 = { "submodulesNotUpdated" },
  84         [ADVICE_SUBMODULE_ALTERNATE_ERROR_STRATEGY_DIE] = { "submoduleAlternateErrorStrategyDie" },
  85         [ADVICE_SUBMODULE_MERGE_CONFLICT]               = { "submoduleMergeConflict" },
  86         [ADVICE_SUGGEST_DETACHING_HEAD]                 = { "suggestDetachingHead" },
  87         [ADVICE_UPDATE_SPARSE_PATH]                     = { "updateSparsePath" },
  88         [ADVICE_WAITING_FOR_EDITOR]                     = { "waitingForEditor" },
  89         [ADVICE_WORKTREE_ADD_ORPHAN]                    = { "worktreeAddOrphan" },
  90 };
  91
  92 static const char turn_off_instructions[] =
  93 N_("\n"
  94    "Disable this message with \"git config advice.%s false\"");
  95
  96 static void vadvise(const char *advice, int display_instructions,
  97                     const char *key, va_list params)
  98 {
  99         struct strbuf buf = STRBUF_INIT;
 100         const char *cp, *np;
 101
 102         strbuf_vaddf(&buf, advice, params);
 103
 104         if (display_instructions)
 105                 strbuf_addf(&buf, turn_off_instructions, key);
 106
 107         for (cp = buf.buf; *cp; cp = np) {
 108                 np = strchrnul(cp, '\n');
 109                 fprintf(stderr, _("%shint:%s%.*s%s\n"),
 110                         advise_get_color(ADVICE_COLOR_HINT),
 111                         (np == cp) ? "" : " ",
 112                         (int)(np - cp), cp,
 113                         advise_get_color(ADVICE_COLOR_RESET));
 114                 if (*np)
 115                         np++;
 116         }
 117         strbuf_release(&buf);
 118 }
 119
 120 void advise(const char *advice, ...)
 121 {
 122         va_list params;
 123         va_start(params, advice);
 124         vadvise(advice, 0, "", params);
 125         va_end(params);
 126 }
 127
 128 int advice_enabled(enum advice_type type)
 129 {
 130         int enabled = advice_setting[type].level != ADVICE_LEVEL_DISABLED;
 131
 132         if (type == ADVICE_PUSH_UPDATE_REJECTED)
 133                 return enabled &&
 134                        advice_enabled(ADVICE_PUSH_UPDATE_REJECTED_ALIAS);
 135
 136         return enabled;
 137 }
 138
 139 void advise_if_enabled(enum advice_type type, const char *advice, ...)
 140 {
 141         va_list params;
 142
 143         if (!advice_enabled(type))
 144                 return;
 145
 146         va_start(params, advice);
 147         vadvise(advice, !advice_setting[type].level, advice_setting[type].key,
 148                 params);
 149         va_end(params);
 150 }
 151
 152 int git_default_advice_config(const char *var, const char *value)
 153 {
 154         const char *k, *slot_name;
 155         int i;
 156
 157         if (!strcmp(var, "color.advice")) {
 158                 advice_use_color = git_config_colorbool(var, value);
 159                 return 0;
 160         }
 161
 162         if (skip_prefix(var, "color.advice.", &slot_name)) {
 163                 int slot = parse_advise_color_slot(slot_name);
 164                 if (slot < 0)
 165                         return 0;
 166                 if (!value)
 167                         return config_error_nonbool(var);
 168                 return color_parse(value, advice_colors[slot]);
 169         }
 170
 171         if (!skip_prefix(var, "advice.", &k))
 172                 return 0;
 173
 174         for (i = 0; i < ARRAY_SIZE(advice_setting); i++) {
 175                 if (strcasecmp(k, advice_setting[i].key))
 176                         continue;
 177                 advice_setting[i].level = git_config_bool(var, value)
 178                                           ? ADVICE_LEVEL_ENABLED
 179                                           : ADVICE_LEVEL_DISABLED;
 180                 return 0;
 181         }
 182
 183         return 0;
 184 }
 185
 186 void list_config_advices(struct string_list *list, const char *prefix)
 187 {
 188         int i;
 189
 190         for (i = 0; i < ARRAY_SIZE(advice_setting); i++)
 191                 list_config_item(list, prefix, advice_setting[i].key);
 192 }
 193
 194 int error_resolve_conflict(const char *me)
 195 {
 196         if (!strcmp(me, "cherry-pick"))
 197                 error(_("Cherry-picking is not possible because you have unmerged files."));
 198         else if (!strcmp(me, "commit"))
 199                 error(_("Committing is not possible because you have unmerged files."));
 200         else if (!strcmp(me, "merge"))
 201                 error(_("Merging is not possible because you have unmerged files."));
 202         else if (!strcmp(me, "pull"))
 203                 error(_("Pulling is not possible because you have unmerged files."));
 204         else if (!strcmp(me, "revert"))
 205                 error(_("Reverting is not possible because you have unmerged files."));
 206         else if (!strcmp(me, "rebase"))
 207                 error(_("Rebasing is not possible because you have unmerged files."));
 208         else
 209                 BUG("Unhandled conflict reason '%s'", me);
 210
 211         if (advice_enabled(ADVICE_RESOLVE_CONFLICT))
 212                 /*
 213                  * Message used both when 'git commit' fails and when
 214                  * other commands doing a merge do.
 215                  */
 216                 advise(_("Fix them up in the work tree, and then use 'git add/rm <file>'\n"
 217                          "as appropriate to mark resolution and make a commit."));
 218         return -1;
 219 }
 220
 221 void NORETURN die_resolve_conflict(const char *me)
 222 {
 223         error_resolve_conflict(me);
 224         die(_("Exiting because of an unresolved conflict."));
 225 }
 226
 227 void NORETURN die_conclude_merge(void)
 228 {
 229         error(_("You have not concluded your merge (MERGE_HEAD exists)."));
 230         if (advice_enabled(ADVICE_RESOLVE_CONFLICT))
 231                 advise(_("Please, commit your changes before merging."));
 232         die(_("Exiting because of unfinished merge."));
 233 }
 234
 235 void NORETURN die_ff_impossible(void)
 236 {
 237         advise_if_enabled(ADVICE_DIVERGING,
 238                 _("Diverging branches can't be fast-forwarded, you need to either:\n"
 239                 "\n"
 240                 "\tgit merge --no-ff\n"
 241                 "\n"
 242                 "or:\n"
 243                 "\n"
 244                 "\tgit rebase\n"));
 245         die(_("Not possible to fast-forward, aborting."));
 246 }
 247
 248 void advise_on_updating_sparse_paths(struct string_list *pathspec_list)
 249 {
 250         struct string_list_item *item;
 251
 252         if (!pathspec_list->nr)
 253                 return;
 254
 255         fprintf(stderr, _("The following paths and/or pathspecs matched paths that exist\n"
 256                           "outside of your sparse-checkout definition, so will not be\n"
 257                           "updated in the index:\n"));
 258         for_each_string_list_item(item, pathspec_list)
 259                 fprintf(stderr, "%s\n", item->string);
 260
 261         advise_if_enabled(ADVICE_UPDATE_SPARSE_PATH,
 262                           _("If you intend to update such entries, try one of the following:\n"
 263                             "* Use the --sparse option.\n"
 264                             "* Disable or modify the sparsity rules."));
 265 }
 266
 267 void detach_advice(const char *new_name)
 268 {
 269         const char *fmt =
 270         _("Note: switching to '%s'.\n"
 271         "\n"
 272         "You are in 'detached HEAD' state. You can look around, make experimental\n"
 273         "changes and commit them, and you can discard any commits you make in this\n"
 274         "state without impacting any branches by switching back to a branch.\n"
 275         "\n"
 276         "If you want to create a new branch to retain commits you create, you may\n"
 277         "do so (now or later) by using -c with the switch command. Example:\n"
 278         "\n"
 279         "  git switch -c <new-branch-name>\n"
 280         "\n"
 281         "Or undo this operation with:\n"
 282         "\n"
 283         "  git switch -\n"
 284         "\n"
 285         "Turn off this advice by setting config variable advice.detachedHead to false\n\n");
 286
 287         fprintf(stderr, fmt, new_name);
 288 }
 289
 290 void advise_on_moving_dirty_path(struct string_list *pathspec_list)
 291 {
 292         struct string_list_item *item;
 293
 294         if (!pathspec_list->nr)
 295                 return;
 296
 297         fprintf(stderr, _("The following paths have been moved outside the\n"
 298                           "sparse-checkout definition but are not sparse due to local\n"
 299                           "modifications.\n"));
 300         for_each_string_list_item(item, pathspec_list)
 301                 fprintf(stderr, "%s\n", item->string);
 302
 303         advise_if_enabled(ADVICE_UPDATE_SPARSE_PATH,
 304                           _("To correct the sparsity of these paths, do the following:\n"
 305                             "* Use \"git add --sparse <paths>\" to update the index\n"
 306                             "* Use \"git sparse-checkout reapply\" to apply the sparsity rules"));
 307 }