refspec: clarify function naming and documentation

Rename `match_name_with_pattern()` to `match_refname_with_pattern()` to
better reflect its purpose and improve documentation comment clarity.
The previous function name and parameter names were inconsistent, making
it harder to understand their roles in refspec matching.

- Rename parameters:
  - `key` -> `pattern` (globbing pattern to match)
  - `name` -> `refname` (refname to check)
  - `value` -> `replacement` (replacement mapping pattern)

Signed-off-by: Meet Soni <meetsoni3017@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>

diff --git a/refspec.c b/refspec.c
index 3d6cf4dc9280e8c9e9a566fa25eba7f50de425b7..4cb80b520813d16879ab2e1d568e00e19c2d60a2 100644 (file)
--- a/refspec.c
+++ b/refspec.c
@@ -269,28 +269,28 @@ void refspec_ref_prefixes(const struct refspec *rs,
        }
 }
 
-int match_name_with_pattern(const char *key, const char *name,
-                                  const char *value, char **result)
+int match_refname_with_pattern(const char *pattern, const char *refname,
+                                  const char *replacement, char **result)
 {
-       const char *kstar = strchr(key, '*');
+       const char *kstar = strchr(pattern, '*');
        size_t klen;
        size_t ksuffixlen;
        size_t namelen;
        int ret;
        if (!kstar)
-               die(_("key '%s' of pattern had no '*'"), key);
-       klen = kstar - key;
+               die(_("pattern '%s' has no '*'"), pattern);
+       klen = kstar - pattern;
        ksuffixlen = strlen(kstar + 1);
-       namelen = strlen(name);
-       ret = !strncmp(name, key, klen) && namelen >= klen + ksuffixlen &&
-               !memcmp(name + namelen - ksuffixlen, kstar + 1, ksuffixlen);
-       if (ret && value) {
+       namelen = strlen(refname);
+       ret = !strncmp(refname, pattern, klen) && namelen >= klen + ksuffixlen &&
+               !memcmp(refname + namelen - ksuffixlen, kstar + 1, ksuffixlen);
+       if (ret && replacement) {
                struct strbuf sb = STRBUF_INIT;
-               const char *vstar = strchr(value, '*');
+               const char *vstar = strchr(replacement, '*');
                if (!vstar)
-                       die(_("value '%s' of pattern has no '*'"), value);
-               strbuf_add(&sb, value, vstar - value);
-               strbuf_add(&sb, name + klen, namelen - klen - ksuffixlen);
+                       die(_("replacement '%s' has no '*'"), replacement);
+               strbuf_add(&sb, replacement, vstar - replacement);
+               strbuf_add(&sb, refname + klen, namelen - klen - ksuffixlen);
                strbuf_addstr(&sb, vstar + 1);
                *result = strbuf_detach(&sb, NULL);
        }
@@ -301,7 +301,7 @@ static int refspec_match(const struct refspec_item *refspec,
                         const char *name)
 {
        if (refspec->pattern)
-               return match_name_with_pattern(refspec->src, name, NULL, NULL);
+               return match_refname_with_pattern(refspec->src, name, NULL, NULL);
 
        return !strcmp(refspec->src, name);
 }
@@ -352,7 +352,7 @@ static int refspec_find_negative_match(struct refspec *rs, struct refspec_item *
                        const char *key = refspec->dst ? refspec->dst : refspec->src;
                        const char *value = refspec->src;
 
-                       if (match_name_with_pattern(key, needle, value, &expn_name))
+                       if (match_refname_with_pattern(key, needle, value, &expn_name))
                                string_list_append_nodup(&reversed, expn_name);
                } else if (refspec->matching) {
                        /* For the special matching refspec, any query should match */
@@ -397,7 +397,7 @@ void refspec_find_all_matches(struct refspec *rs,
                if (!refspec->dst || refspec->negative)
                        continue;
                if (refspec->pattern) {
-                       if (match_name_with_pattern(key, needle, value, result))
+                       if (match_refname_with_pattern(key, needle, value, result))
                                string_list_append_nodup(results, *result);
                } else if (!strcmp(needle, key)) {
                        string_list_append(results, value);
@@ -426,7 +426,7 @@ int refspec_find_match(struct refspec *rs, struct refspec_item *query)
                if (!refspec->dst || refspec->negative)
                        continue;
                if (refspec->pattern) {
-                       if (match_name_with_pattern(key, needle, value, result)) {
+                       if (match_refname_with_pattern(key, needle, value, result)) {
                                query->force = refspec->force;
                                return 0;
                        }

diff --git a/refspec.h b/refspec.h
index f62f83a7ee66bd368842b93ebf0cb5e226cc913b..e2b5cc54efbdf3a652a84e4ea6173af05719702b 100644 (file)
--- a/refspec.h
+++ b/refspec.h
@@ -75,11 +75,12 @@ void refspec_ref_prefixes(const struct refspec *rs,
 int refname_matches_negative_refspec_item(const char *refname, struct refspec *rs);
 
 /*
- * Checks whether a name matches a pattern and optionally generates a result.
- * Returns 1 if the name matches the pattern, 0 otherwise.
+ * Checks if a refname matches a globbing refspec pattern.
+ * If replacement is provided, computes the corresponding mapped refname.
+ * Returns 1 if refname matches pattern, 0 otherwise.
  */
-int match_name_with_pattern(const char *key, const char *name,
-                                  const char *value, char **result);
+int match_refname_with_pattern(const char *pattern, const char *refname,
+                                  const char *replacement, char **result);
 
 /*
  * Queries a refspec for a match and updates the query item.

diff --git a/remote.c b/remote.c
index c1cf363cca7b85dade50e41a03b243dae55fdac8..c9c1384c1ddadf0f004882cc539b61841c4c789d 100644 (file)
--- a/remote.c
+++ b/remote.c
@@ -1322,9 +1322,9 @@ static char *get_ref_match(const struct refspec *rs, const struct ref *ref,
                        const char *dst_side = item->dst ? item->dst : item->src;
                        int match;
                        if (direction == FROM_SRC)
-                               match = match_name_with_pattern(item->src, ref->name, dst_side, &name);
+                               match = match_refname_with_pattern(item->src, ref->name, dst_side, &name);
                        else
-                               match = match_name_with_pattern(dst_side, ref->name, item->src, &name);
+                               match = match_refname_with_pattern(dst_side, ref->name, item->src, &name);
                        if (match) {
                                matching_refs = i;
                                break;
@@ -1942,7 +1942,7 @@ static struct ref *get_expanded_map(const struct ref *remote_refs,
 
                if (strchr(ref->name, '^'))
                        continue; /* a dereference item */
-               if (match_name_with_pattern(refspec->src, ref->name,
+               if (match_refname_with_pattern(refspec->src, ref->name,
                                            refspec->dst, &expn_name) &&
                    !ignore_symref_update(expn_name, &scratch)) {
                        struct ref *cpy = copy_ref(ref);