From: "John Cai via GitGitGadget" <gitgitgadget@gmail.com>
To: git@vger.kernel.org
Cc: "René Scharfe" <l.s.r@web.de>, "John Cai" <johncai86@gmail.com>
Subject: [PATCH v2 0/2] reflog.c: switch to use parse-options API
Date: Mon, 03 Jan 2022 15:20:20 +0000 [thread overview]
Message-ID: <pull.1175.v2.git.git.1641223223.gitgitgadget@gmail.com> (raw)
In-Reply-To: <pull.1175.git.git.1640932151.gitgitgadget@gmail.com>
Switch out manual argv parsing for the reflog expire subcommand to use the
parse-options API. This reduces code redundancy by consolidating option
parsing logic.
changes since v1:
* add helper parse_opt_expiry_date so we can use this shared logic to parse
the expire date option.
* place explicit_expiry inside of cmd_reflog_expire_cb to make it easier to
use a callback to set both the value of the timestamp and the
explicit_expiry flag.
John Cai (2):
parse-options.h: add parse_opt_expiry_date helper
builtin/reflog.c: switch to use parse-options API for delete
subcommand
builtin/reflog.c | 168 +++++++++++++++++++++++----------------------
parse-options-cb.c | 7 +-
parse-options.h | 1 +
3 files changed, 94 insertions(+), 82 deletions(-)
base-commit: 55b058a8bbcc54bd93c733035c995abc7967e539
Published-As: https://github.com/gitgitgadget/git/releases/tag/pr-git-1175%2Fjohn-cai%2Fjc%2Freflog-switch-to-option-parse-v2
Fetch-It-Via: git fetch https://github.com/gitgitgadget/git pr-git-1175/john-cai/jc/reflog-switch-to-option-parse-v2
Pull-Request: https://github.com/git/git/pull/1175
Range-diff vs v1:
1: 9bd3c6672c4 < -: ----------- builtin/reflog.c: use parse-options for expire subcommand
-: ----------- > 1: bcd74559c24 parse-options.h: add parse_opt_expiry_date helper
2: fffea298642 ! 2: f9de21e0f26 builtin/reflog.c: switch to use parse-options API for delete subcommand
@@ Commit message
Address NEEDSWORK by switching out manual arg parsing for the
parse-options API for the delete subcommand.
+ Moves explicit_expiry flag into cmd_reflog_expire_cb struct so a
+ callback can set both the value of the expiration as well as the
+ explicit_expiry flag.
+
Signed-off-by: "John Cai" <johncai86@gmail.com>
## builtin/reflog.c ##
@@
- #include "revision.h"
#include "reachable.h"
#include "worktree.h"
--#include "parse-options.h"
+-/* NEEDSWORK: switch to using parse_options */
+-static const char reflog_expire_usage[] =
+-N_("git reflog expire [--expire=<time>] "
+- "[--expire-unreachable=<time>] "
+- "[--rewrite] [--updateref] [--stale-fix] [--dry-run | -n] "
+- "[--verbose] [--all] <refs>...");
-static const char reflog_delete_usage[] =
-N_("git reflog delete [--rewrite] [--updateref] "
- "[--dry-run | -n] [--verbose] <refs>...");
static const char reflog_exists_usage[] =
N_("git reflog exists <ref>");
+@@ builtin/reflog.c: static timestamp_t default_reflog_expire_unreachable;
+ struct cmd_reflog_expire_cb {
+ struct rev_info revs;
+ int stalefix;
++ int explicit_expiry;
+ timestamp_t expire_total;
+ timestamp_t expire_unreachable;
+ int recno;
+@@ builtin/reflog.c: static int reflog_expire_config(const char *var, const char *value, void *cb)
+ return 0;
+ }
+
+-static void set_reflog_expiry_param(struct cmd_reflog_expire_cb *cb, int slot, const char *ref)
++static void set_reflog_expiry_param(struct cmd_reflog_expire_cb *cb, const char *ref)
+ {
+ struct reflog_expire_cfg *ent;
+-
+- if (slot == (EXPIRE_TOTAL|EXPIRE_UNREACH))
++ if (cb->explicit_expiry == (EXPIRE_TOTAL|EXPIRE_UNREACH))
+ return; /* both given explicitly -- nothing to tweak */
+
+ for (ent = reflog_expire_cfg; ent; ent = ent->next) {
+ if (!wildmatch(ent->pattern, ref, 0)) {
+- if (!(slot & EXPIRE_TOTAL))
++ if (!(cb->explicit_expiry & EXPIRE_TOTAL))
+ cb->expire_total = ent->expire_total;
+- if (!(slot & EXPIRE_UNREACH))
++ if (!(cb->explicit_expiry & EXPIRE_UNREACH))
+ cb->expire_unreachable = ent->expire_unreachable;
+ return;
+ }
+@@ builtin/reflog.c: static void set_reflog_expiry_param(struct cmd_reflog_expire_cb *cb, int slot, c
+ * If unconfigured, make stash never expire
+ */
+ if (!strcmp(ref, "refs/stash")) {
+- if (!(slot & EXPIRE_TOTAL))
++ if (!(cb->explicit_expiry & EXPIRE_TOTAL))
+ cb->expire_total = 0;
+- if (!(slot & EXPIRE_UNREACH))
++ if (!(cb->explicit_expiry & EXPIRE_UNREACH))
+ cb->expire_unreachable = 0;
+ return;
+ }
+
+ /* Nothing matched -- use the default value */
+- if (!(slot & EXPIRE_TOTAL))
++ if (!(cb->explicit_expiry & EXPIRE_TOTAL))
+ cb->expire_total = default_reflog_expire;
+- if (!(slot & EXPIRE_UNREACH))
++ if (!(cb->explicit_expiry & EXPIRE_UNREACH))
+ cb->expire_unreachable = default_reflog_expire_unreachable;
+ }
+
++static const char * reflog_expire_usage[] = {
++ N_("git reflog expire [--expire=<time>] "
++ "[--expire-unreachable=<time>] "
++ "[--rewrite] [--updateref] [--stale-fix] [--dry-run | -n] "
++ "[--verbose] [--all] <refs>..."),
++ NULL
++};
++
++static int expire_unreachable_callback(const struct option *opt,
++ const char *arg,
++ int unset)
++{
++ struct cmd_reflog_expire_cb *cmd = opt->value;
++ cmd->explicit_expiry |= EXPIRE_UNREACH;
++ return parse_opt_expiry_date(&cmd->expire_unreachable, arg, unset);
++}
++
++static int expire_total_callback(const struct option *opt,
++ const char *arg,
++ int unset)
++{
++ struct cmd_reflog_expire_cb *cmd = opt->value;
++ cmd->explicit_expiry |= EXPIRE_TOTAL;
++ return parse_opt_expiry_date(&cmd->expire_total, arg, unset);
++}
++
+ static int cmd_reflog_expire(int argc, const char **argv, const char *prefix)
+ {
+ struct expire_reflog_policy_cb cb;
+ timestamp_t now = time(NULL);
+ int i, status, do_all, all_worktrees = 1;
+- int explicit_expiry = 0;
+ unsigned int flags = 0;
++ const struct option options[] = {
++ OPT_BIT(0, "dry-run", &flags, N_("do not actually prune any entries"),
++ EXPIRE_REFLOGS_DRY_RUN),
++ OPT_BIT(0, "rewrite", &flags,
++ N_("rewrite the old SHA1 with the new SHA1 of the entry that now precedes it"),
++ EXPIRE_REFLOGS_REWRITE),
++ OPT_BIT(0, "updateref", &flags,
++ N_("update the reference to the value of the top reflog entry"),
++ EXPIRE_REFLOGS_UPDATE_REF),
++ OPT_BIT(0, "verbose", &flags, N_("print extra information on screen."),
++ EXPIRE_REFLOGS_VERBOSE),
++ OPT_CALLBACK(0, "expire", &cb.cmd, N_("timestamp"),
++ N_("prune entries older than the specified time"), expire_total_callback),
++ OPT_CALLBACK(0, "expire-unreachable", &cb.cmd, N_("timestamp"),
++ N_("prune entries older than <time> that are not reachable from the current tip of the branch"),
++ expire_unreachable_callback),
++ OPT_BOOL(0, "stale-fix", &cb.cmd.stalefix,
++ N_("prune any reflog entries that point to broken commits")),
++ OPT_BOOL(0, "all", &do_all, N_("process the reflogs of all references")),
++ OPT_BOOL(1, "single-worktree", &all_worktrees,
++ N_("limits processing to reflogs from the current worktree only.")),
++ OPT_END()
++ };
+
+ default_reflog_expire_unreachable = now - 30 * 24 * 3600;
+ default_reflog_expire = now - 90 * 24 * 3600;
+@@ builtin/reflog.c: static int cmd_reflog_expire(int argc, const char **argv, const char *prefix)
+ do_all = status = 0;
+ memset(&cb, 0, sizeof(cb));
+
++ cb.cmd.explicit_expiry = 0;
+ cb.cmd.expire_total = default_reflog_expire;
+ cb.cmd.expire_unreachable = default_reflog_expire_unreachable;
+
+- for (i = 1; i < argc; i++) {
+- const char *arg = argv[i];
+-
+- if (!strcmp(arg, "--dry-run") || !strcmp(arg, "-n"))
+- flags |= EXPIRE_REFLOGS_DRY_RUN;
+- else if (skip_prefix(arg, "--expire=", &arg)) {
+- if (parse_expiry_date(arg, &cb.cmd.expire_total))
+- die(_("'%s' is not a valid timestamp"), arg);
+- explicit_expiry |= EXPIRE_TOTAL;
+- }
+- else if (skip_prefix(arg, "--expire-unreachable=", &arg)) {
+- if (parse_expiry_date(arg, &cb.cmd.expire_unreachable))
+- die(_("'%s' is not a valid timestamp"), arg);
+- explicit_expiry |= EXPIRE_UNREACH;
+- }
+- else if (!strcmp(arg, "--stale-fix"))
+- cb.cmd.stalefix = 1;
+- else if (!strcmp(arg, "--rewrite"))
+- flags |= EXPIRE_REFLOGS_REWRITE;
+- else if (!strcmp(arg, "--updateref"))
+- flags |= EXPIRE_REFLOGS_UPDATE_REF;
+- else if (!strcmp(arg, "--all"))
+- do_all = 1;
+- else if (!strcmp(arg, "--single-worktree"))
+- all_worktrees = 0;
+- else if (!strcmp(arg, "--verbose"))
+- flags |= EXPIRE_REFLOGS_VERBOSE;
+- else if (!strcmp(arg, "--")) {
+- i++;
+- break;
+- }
+- else if (arg[0] == '-')
+- usage(_(reflog_expire_usage));
+- else
+- break;
+- }
+-
++ argc = parse_options(argc, argv, prefix, options, reflog_expire_usage, 0);
+ /*
+ * We can trust the commits and objects reachable from refs
+ * even in older repository. We cannot trust what's reachable
+@@ builtin/reflog.c: static int cmd_reflog_expire(int argc, const char **argv, const char *prefix)
+ for (i = 0; i < collected.nr; i++) {
+ struct collected_reflog *e = collected.e[i];
+
+- set_reflog_expiry_param(&cb.cmd, explicit_expiry, e->reflog);
++ set_reflog_expiry_param(&cb.cmd, e->reflog);
+ status |= reflog_expire(e->reflog, flags,
+ reflog_expiry_prepare,
+ should_expire_reflog_ent,
@@ builtin/reflog.c: static int cmd_reflog_expire(int argc, const char **argv, const char *prefix)
free(collected.e);
}
@@ builtin/reflog.c: static int cmd_reflog_expire(int argc, const char **argv, cons
char *ref;
if (!dwim_log(argv[i], strlen(argv[i]), NULL, &ref)) {
status |= error(_("%s points nowhere!"), argv[i]);
+ continue;
+ }
+- set_reflog_expiry_param(&cb.cmd, explicit_expiry, ref);
++ set_reflog_expiry_param(&cb.cmd, ref);
+ status |= reflog_expire(ref, flags,
+ reflog_expiry_prepare,
+ should_expire_reflog_ent,
@@ builtin/reflog.c: static int count_reflog_ent(struct object_id *ooid, struct object_id *noid,
return 0;
}
--
gitgitgadget
next prev parent reply other threads:[~2022-01-03 15:20 UTC|newest]
Thread overview: 19+ messages / expand[flat|nested] mbox.gz Atom feed top
2021-12-31 6:29 [PATCH 0/2] reflog.c: switch to use parse-options API John Cai via GitGitGadget
2021-12-31 6:29 ` [PATCH 1/2] builtin/reflog.c: use parse-options for expire subcommand John Cai via GitGitGadget
2022-01-01 2:06 ` John Cai
2022-01-01 11:16 ` René Scharfe
2022-01-01 19:09 ` John Cai
2022-01-02 9:00 ` René Scharfe
2021-12-31 6:29 ` [PATCH 2/2] builtin/reflog.c: switch to use parse-options API for delete subcommand John Cai via GitGitGadget
2022-01-03 15:20 ` John Cai via GitGitGadget [this message]
2022-01-03 15:20 ` [PATCH v2 1/2] parse-options.h: add parse_opt_expiry_date helper John Cai via GitGitGadget
2022-01-04 2:26 ` Junio C Hamano
2022-01-03 15:20 ` [PATCH v2 2/2] builtin/reflog.c: switch to use parse-options API for delete subcommand John Cai via GitGitGadget
2022-01-04 2:36 ` Junio C Hamano
2022-01-04 17:41 ` [PATCH v3] builtin/reflog.c: use parse-options api for expire, delete subcommands John Cai via GitGitGadget
2022-01-04 22:04 ` Junio C Hamano
2022-01-05 4:06 ` [PATCH v4] " John Cai via GitGitGadget
2022-01-05 20:34 ` Junio C Hamano
2022-01-06 19:06 ` [PATCH v5] " John Cai via GitGitGadget
2022-01-06 21:09 ` Junio C Hamano
2022-01-06 21:32 ` John Cai
Reply instructions:
You may reply publicly to this message via plain-text email
using any one of the following methods:
* Save the following mbox file, import it into your mail client,
and reply-to-all from there: mbox
Avoid top-posting and favor interleaved quoting:
https://en.wikipedia.org/wiki/Posting_style#Interleaved_style
* Reply using the --to, --cc, and --in-reply-to
switches of git-send-email(1):
git send-email \
--in-reply-to=pull.1175.v2.git.git.1641223223.gitgitgadget@gmail.com \
--to=gitgitgadget@gmail.com \
--cc=git@vger.kernel.org \
--cc=johncai86@gmail.com \
--cc=l.s.r@web.de \
/path/to/YOUR_REPLY
https://kernel.org/pub/software/scm/git/docs/git-send-email.html
* If your mail client supports setting the In-Reply-To header
via mailto: links, try the mailto: link
Be sure your reply has a Subject: header at the top and a blank line
before the message body.
This is an external index of several public inboxes,
see mirroring instructions on how to clone and mirror
all data and code used by this external index.