diff mbox series

[GSoC,v2] refspec: clarify function naming and documentation

Message ID 20250215084539.73799-1-meetsoni3017@gmail.com (mailing list archive)
State Accepted
Commit 044b6f04f23d6c7e3c3750c9829db96b71470874
Headers show
Series [GSoC,v2] refspec: clarify function naming and documentation | expand

Commit Message

Meet Soni Feb. 15, 2025, 8:45 a.m. UTC 
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>
---
changes in v2:
    - updated parameter names as per review. Namely:
        - `src_pattern` -> `pattern`
        - `dst_pattern` -> `replacement`
    - updated comment and commit message.

Range-diff against v1:
1:  8bd849b7c2 ! 1:  aa47431720 refspec: clarify function naming and documentation
    @@ Commit message
         it harder to understand their roles in refspec matching.
     
         - Rename parameters:
    -      - `key` -> `src_pattern` (source globbing pattern)
    +      - `key` -> `pattern` (globbing pattern to match)
           - `name` -> `refname` (refname to check)
    -      - `value` -> `dst_pattern` (destination mapping pattern)
    +      - `value` -> `replacement` (replacement mapping pattern)
     
         Signed-off-by: Meet Soni <meetsoni3017@gmail.com>
     
    @@ refspec.c: 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 *src_pattern, const char *refname,
    -+				   const char *dst_pattern, 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(src_pattern, '*');
    ++	const char *kstar = strchr(pattern, '*');
      	size_t klen;
      	size_t ksuffixlen;
      	size_t namelen;
    @@ refspec.c: void refspec_ref_prefixes(const struct refspec *rs,
      	if (!kstar)
     -		die(_("key '%s' of pattern had no '*'"), key);
     -	klen = kstar - key;
    -+		die(_("source pattern '%s' has no '*'"), src_pattern);
    -+	klen = kstar - src_pattern;
    ++		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, src_pattern, klen) && namelen >= klen + ksuffixlen &&
    ++	ret = !strncmp(refname, pattern, klen) && namelen >= klen + ksuffixlen &&
     +		!memcmp(refname + namelen - ksuffixlen, kstar + 1, ksuffixlen);
    -+	if (ret && dst_pattern) {
    ++	if (ret && replacement) {
      		struct strbuf sb = STRBUF_INIT;
     -		const char *vstar = strchr(value, '*');
    -+		const char *vstar = strchr(dst_pattern, '*');
    ++		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(_("destination pattern '%s' has no '*'"), dst_pattern);
    -+		strbuf_add(&sb, dst_pattern, vstar - dst_pattern);
    ++			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);
    @@ refspec.h: void refspec_ref_prefixes(const 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 dst_pattern is provided, computes the mapped destination refname.
    -+ * Returns 1 if refname matches src_pattern, 0 otherwise.
    ++ * 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 *src_pattern, const char *refname,
    -+				   const char *dst_pattern, 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.

 refspec.c | 34 +++++++++++++++++-----------------
 refspec.h |  9 +++++----
 remote.c  |  6 +++---
 3 files changed, 25 insertions(+), 24 deletions(-)
diff mbox series

Patch

diff --git a/refspec.c b/refspec.c
index 3d6cf4dc92..4cb80b5208 100644
--- 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 f62f83a7ee..e2b5cc54ef 100644
--- 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 5574b6a00f..5d3d1773dc 100644
--- 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);