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