kernel
/
git
mirror of https://git.kernel.org/pub/scm/git/git.git
1
0
Fork 0
Code Releases Activity
Browse Source

apply: refactor `git apply` option parsing 

Parsing `git apply` options can be useful to other commands that
want to call the libified apply functionality, because this way
they can easily pass some options from their own command line to
the libified apply functionality.

This will be used by `git am` in a following patch.

To make this possible, let's refactor the `git apply` option
parsing code into a new libified apply_parse_options() function.

Doing that makes it possible to remove some functions definitions
from "apply.h" and make them static in "apply.c".

Helped-by: Ramsay Jones <ramsay@ramsayjones.plus.com>
Signed-off-by: Christian Couder <chriscool@tuxfamily.org>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
maint
Christian Couder 8 years ago committed by Junio C Hamano
parent
45b78d8ba3
commit
7e1bad24e3
3 changed files with 97 additions and 98 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 103
      apply.c
  2. 18
      apply.h
  3. 74
      builtin/apply.c

103
apply.c
Unescape View File

@ -4730,16 +4730,16 @@ end:
return res; return res;
} }


int apply_option_parse_exclude(const struct option *opt, static int apply_option_parse_exclude(const struct option *opt,
const char *arg, int unset) const char *arg, int unset)
{ {
struct apply_state *state = opt->value; struct apply_state *state = opt->value;
add_name_limit(state, arg, 1); add_name_limit(state, arg, 1);
return 0; return 0;
} }


int apply_option_parse_include(const struct option *opt, static int apply_option_parse_include(const struct option *opt,
const char *arg, int unset) const char *arg, int unset)
{ {
struct apply_state *state = opt->value; struct apply_state *state = opt->value;
add_name_limit(state, arg, 0); add_name_limit(state, arg, 0);
@ -4747,9 +4747,9 @@ int apply_option_parse_include(const struct option *opt,
return 0; return 0;
} }


int apply_option_parse_p(const struct option *opt, static int apply_option_parse_p(const struct option *opt,
const char *arg, const char *arg,
int unset) int unset)
{ {
struct apply_state *state = opt->value; struct apply_state *state = opt->value;
state->p_value = atoi(arg); state->p_value = atoi(arg);
@ -4757,8 +4757,8 @@ int apply_option_parse_p(const struct option *opt,
return 0; return 0;
} }


int apply_option_parse_space_change(const struct option *opt, static int apply_option_parse_space_change(const struct option *opt,
const char *arg, int unset) const char *arg, int unset)
{ {
struct apply_state *state = opt->value; struct apply_state *state = opt->value;
if (unset) if (unset)
@ -4768,8 +4768,8 @@ int apply_option_parse_space_change(const struct option *opt,
return 0; return 0;
} }


int apply_option_parse_whitespace(const struct option *opt, static int apply_option_parse_whitespace(const struct option *opt,
const char *arg, int unset) const char *arg, int unset)
{ {
struct apply_state *state = opt->value; struct apply_state *state = opt->value;
state->whitespace_option = arg; state->whitespace_option = arg;
@ -4778,8 +4778,8 @@ int apply_option_parse_whitespace(const struct option *opt,
return 0; return 0;
} }


int apply_option_parse_directory(const struct option *opt, static int apply_option_parse_directory(const struct option *opt,
const char *arg, int unset) const char *arg, int unset)
{ {
struct apply_state *state = opt->value; struct apply_state *state = opt->value;
strbuf_reset(&state->root); strbuf_reset(&state->root);
@ -4893,3 +4893,80 @@ end:
return res; return res;
return (res == -1 ? 1 : 128); return (res == -1 ? 1 : 128);
} }

int apply_parse_options(int argc, const char **argv,
struct apply_state *state,
int *force_apply, int *options,
const char * const *apply_usage)
{
struct option builtin_apply_options[] = {
{ OPTION_CALLBACK, 0, "exclude", state, N_("path"),
N_("don't apply changes matching the given path"),
0, apply_option_parse_exclude },
{ OPTION_CALLBACK, 0, "include", state, N_("path"),
N_("apply changes matching the given path"),
0, apply_option_parse_include },
{ OPTION_CALLBACK, 'p', NULL, state, N_("num"),
N_("remove <num> leading slashes from traditional diff paths"),
0, apply_option_parse_p },
OPT_BOOL(0, "no-add", &state->no_add,
N_("ignore additions made by the patch")),
OPT_BOOL(0, "stat", &state->diffstat,
N_("instead of applying the patch, output diffstat for the input")),
OPT_NOOP_NOARG(0, "allow-binary-replacement"),
OPT_NOOP_NOARG(0, "binary"),
OPT_BOOL(0, "numstat", &state->numstat,
N_("show number of added and deleted lines in decimal notation")),
OPT_BOOL(0, "summary", &state->summary,
N_("instead of applying the patch, output a summary for the input")),
OPT_BOOL(0, "check", &state->check,
N_("instead of applying the patch, see if the patch is applicable")),
OPT_BOOL(0, "index", &state->check_index,
N_("make sure the patch is applicable to the current index")),
OPT_BOOL(0, "cached", &state->cached,
N_("apply a patch without touching the working tree")),
OPT_BOOL(0, "unsafe-paths", &state->unsafe_paths,
N_("accept a patch that touches outside the working area")),
OPT_BOOL(0, "apply", force_apply,
N_("also apply the patch (use with --stat/--summary/--check)")),
OPT_BOOL('3', "3way", &state->threeway,
N_( "attempt three-way merge if a patch does not apply")),
OPT_FILENAME(0, "build-fake-ancestor", &state->fake_ancestor,
N_("build a temporary index based on embedded index information")),
/* Think twice before adding "--nul" synonym to this */
OPT_SET_INT('z', NULL, &state->line_termination,
N_("paths are separated with NUL character"), '\0'),
OPT_INTEGER('C', NULL, &state->p_context,
N_("ensure at least <n> lines of context match")),
{ OPTION_CALLBACK, 0, "whitespace", state, N_("action"),
N_("detect new or modified lines that have whitespace errors"),
0, apply_option_parse_whitespace },
{ OPTION_CALLBACK, 0, "ignore-space-change", state, NULL,
N_("ignore changes in whitespace when finding context"),
PARSE_OPT_NOARG, apply_option_parse_space_change },
{ OPTION_CALLBACK, 0, "ignore-whitespace", state, NULL,
N_("ignore changes in whitespace when finding context"),
PARSE_OPT_NOARG, apply_option_parse_space_change },
OPT_BOOL('R', "reverse", &state->apply_in_reverse,
N_("apply the patch in reverse")),
OPT_BOOL(0, "unidiff-zero", &state->unidiff_zero,
N_("don't expect at least one line of context")),
OPT_BOOL(0, "reject", &state->apply_with_reject,
N_("leave the rejected hunks in corresponding *.rej files")),
OPT_BOOL(0, "allow-overlap", &state->allow_overlap,
N_("allow overlapping hunks")),
OPT__VERBOSE(&state->apply_verbosity, N_("be verbose")),
OPT_BIT(0, "inaccurate-eof", options,
N_("tolerate incorrectly detected missing new-line at the end of file"),
APPLY_OPT_INACCURATE_EOF),
OPT_BIT(0, "recount", options,
N_("do not trust the line counts in the hunk headers"),
APPLY_OPT_RECOUNT),
{ OPTION_CALLBACK, 0, "directory", state, N_("root"),
N_("prepend <root> to all filenames"),
0, apply_option_parse_directory },
OPT_END()
};

return parse_options(argc, argv, state->prefix, builtin_apply_options, apply_usage, 0);
}

18
apply.h
Unescape View File

@ -111,20 +111,10 @@ struct apply_state {
int applied_after_fixing_ws; int applied_after_fixing_ws;
}; };


extern int apply_option_parse_exclude(const struct option *opt, extern int apply_parse_options(int argc, const char **argv,
const char *arg, int unset); struct apply_state *state,
extern int apply_option_parse_include(const struct option *opt, int *force_apply, int *options,
const char *arg, int unset); const char * const *apply_usage);
extern int apply_option_parse_p(const struct option *opt,
const char *arg,
int unset);
extern int apply_option_parse_whitespace(const struct option *opt,
const char *arg, int unset);
extern int apply_option_parse_directory(const struct option *opt,
const char *arg, int unset);
extern int apply_option_parse_space_change(const struct option *opt,
const char *arg, int unset);

extern int init_apply_state(struct apply_state *state, extern int init_apply_state(struct apply_state *state,
const char *prefix, const char *prefix,
struct lock_file *lock_file); struct lock_file *lock_file);

74
builtin/apply.c
Unescape View File

@ -18,80 +18,12 @@ int cmd_apply(int argc, const char **argv, const char *prefix)
int ret; int ret;
struct apply_state state; struct apply_state state;


struct option builtin_apply_options[] = {
{ OPTION_CALLBACK, 0, "exclude", &state, N_("path"),
N_("don't apply changes matching the given path"),
0, apply_option_parse_exclude },
{ OPTION_CALLBACK, 0, "include", &state, N_("path"),
N_("apply changes matching the given path"),
0, apply_option_parse_include },
{ OPTION_CALLBACK, 'p', NULL, &state, N_("num"),
N_("remove <num> leading slashes from traditional diff paths"),
0, apply_option_parse_p },
OPT_BOOL(0, "no-add", &state.no_add,
N_("ignore additions made by the patch")),
OPT_BOOL(0, "stat", &state.diffstat,
N_("instead of applying the patch, output diffstat for the input")),
OPT_NOOP_NOARG(0, "allow-binary-replacement"),
OPT_NOOP_NOARG(0, "binary"),
OPT_BOOL(0, "numstat", &state.numstat,
N_("show number of added and deleted lines in decimal notation")),
OPT_BOOL(0, "summary", &state.summary,
N_("instead of applying the patch, output a summary for the input")),
OPT_BOOL(0, "check", &state.check,
N_("instead of applying the patch, see if the patch is applicable")),
OPT_BOOL(0, "index", &state.check_index,
N_("make sure the patch is applicable to the current index")),
OPT_BOOL(0, "cached", &state.cached,
N_("apply a patch without touching the working tree")),
OPT_BOOL(0, "unsafe-paths", &state.unsafe_paths,
N_("accept a patch that touches outside the working area")),
OPT_BOOL(0, "apply", &force_apply,
N_("also apply the patch (use with --stat/--summary/--check)")),
OPT_BOOL('3', "3way", &state.threeway,
N_( "attempt three-way merge if a patch does not apply")),
OPT_FILENAME(0, "build-fake-ancestor", &state.fake_ancestor,
N_("build a temporary index based on embedded index information")),
/* Think twice before adding "--nul" synonym to this */
OPT_SET_INT('z', NULL, &state.line_termination,
N_("paths are separated with NUL character"), '\0'),
OPT_INTEGER('C', NULL, &state.p_context,
N_("ensure at least <n> lines of context match")),
{ OPTION_CALLBACK, 0, "whitespace", &state, N_("action"),
N_("detect new or modified lines that have whitespace errors"),
0, apply_option_parse_whitespace },
{ OPTION_CALLBACK, 0, "ignore-space-change", &state, NULL,
N_("ignore changes in whitespace when finding context"),
PARSE_OPT_NOARG, apply_option_parse_space_change },
{ OPTION_CALLBACK, 0, "ignore-whitespace", &state, NULL,
N_("ignore changes in whitespace when finding context"),
PARSE_OPT_NOARG, apply_option_parse_space_change },
OPT_BOOL('R', "reverse", &state.apply_in_reverse,
N_("apply the patch in reverse")),
OPT_BOOL(0, "unidiff-zero", &state.unidiff_zero,
N_("don't expect at least one line of context")),
OPT_BOOL(0, "reject", &state.apply_with_reject,
N_("leave the rejected hunks in corresponding *.rej files")),
OPT_BOOL(0, "allow-overlap", &state.allow_overlap,
N_("allow overlapping hunks")),
OPT__VERBOSE(&state.apply_verbosity, N_("be verbose")),
OPT_BIT(0, "inaccurate-eof", &options,
N_("tolerate incorrectly detected missing new-line at the end of file"),
APPLY_OPT_INACCURATE_EOF),
OPT_BIT(0, "recount", &options,
N_("do not trust the line counts in the hunk headers"),
APPLY_OPT_RECOUNT),
{ OPTION_CALLBACK, 0, "directory", &state, N_("root"),
N_("prepend <root> to all filenames"),
0, apply_option_parse_directory },
OPT_END()
};

if (init_apply_state(&state, prefix, &lock_file)) if (init_apply_state(&state, prefix, &lock_file))
exit(128); exit(128);


argc = parse_options(argc, argv, state.prefix, builtin_apply_options, argc = apply_parse_options(argc, argv,
apply_usage, 0); &state, &force_apply, &options,
apply_usage);


if (check_apply_state(&state, force_apply)) if (check_apply_state(&state, force_apply))
exit(128); exit(128);

Write Preview
Loading…
Cancel
Save