mirror of
https://github.com/git/git
synced 2024-08-27 19:49:21 +00:00
![SZEDER Gábor](/assets/img/avatar_default.png)
The 'versionsort.prereleaseSuffix' configuration variable, as its name suggests, is supposed to only deal with tagnames with prerelease suffixes, and allows sorting those prerelease tags in a user-defined order before the suffixless main release tag, instead of sorting them simply lexicographically. However, the previous changes in this series resulted in an interesting and useful property of version sort: - The empty string as a configured suffix matches all tagnames, including tagnames without any suffix, but - tagnames containing a "real" configured suffix are still ordered according to that real suffix, because any longer suffix takes precedence over the empty string. Exploiting this property we can easily generalize suffix reordering and specify the order of tags with given suffixes not only before but even after a main release tag by using the empty suffix to denote the position of the main release tag, without any algorithm changes: $ git -c versionsort.prereleaseSuffix=-alpha \ -c versionsort.prereleaseSuffix=-beta \ -c versionsort.prereleaseSuffix="" \ -c versionsort.prereleaseSuffix=-gamma \ -c versionsort.prereleaseSuffix=-delta \ tag -l --sort=version:refname 'v3.0*' v3.0-alpha1 v3.0-beta1 v3.0 v3.0-gamma1 v3.0-delta1 Since 'versionsort.prereleaseSuffix' is not a fitting name for a configuration variable to control this more general suffix reordering, introduce the new variable 'versionsort.suffix'. Still keep the old configuration variable name as a deprecated alias, though, to avoid suddenly breaking setups already using it. Ignore the old variable if both old and new configuration variables are set, but emit a warning so users will be aware of it and can fix their configuration. Extend the documentation to describe and add a test to check this more general behavior. Note: since the empty suffix matches all tagnames, tagnames with suffixes not included in the configuration are listed together with the suffixless main release tag, ordered lexicographically right after that, i.e. before tags with suffixes listed in the configuration following the empty suffix. Signed-off-by: SZEDER Gábor <szeder.dev@gmail.com> Signed-off-by: Junio C Hamano <gitster@pobox.com>
193 lines
5.2 KiB
C
193 lines
5.2 KiB
C
#include "cache.h"
|
|
#include "string-list.h"
|
|
|
|
/*
|
|
* versioncmp(): copied from string/strverscmp.c in glibc commit
|
|
* ee9247c38a8def24a59eb5cfb7196a98bef8cfdc, reformatted to Git coding
|
|
* style. The implementation is under LGPL-2.1 and Git relicenses it
|
|
* to GPLv2.
|
|
*/
|
|
|
|
/*
|
|
* states: S_N: normal, S_I: comparing integral part, S_F: comparing
|
|
* fractionnal parts, S_Z: idem but with leading Zeroes only
|
|
*/
|
|
#define S_N 0x0
|
|
#define S_I 0x3
|
|
#define S_F 0x6
|
|
#define S_Z 0x9
|
|
|
|
/* result_type: CMP: return diff; LEN: compare using len_diff/diff */
|
|
#define CMP 2
|
|
#define LEN 3
|
|
|
|
static const struct string_list *prereleases;
|
|
static int initialized;
|
|
|
|
struct suffix_match {
|
|
int conf_pos;
|
|
int start;
|
|
int len;
|
|
};
|
|
|
|
static void find_better_matching_suffix(const char *tagname, const char *suffix,
|
|
int suffix_len, int start, int conf_pos,
|
|
struct suffix_match *match)
|
|
{
|
|
/*
|
|
* A better match either starts earlier or starts at the same offset
|
|
* but is longer.
|
|
*/
|
|
int end = match->len < suffix_len ? match->start : match->start-1;
|
|
int i;
|
|
for (i = start; i <= end; i++)
|
|
if (starts_with(tagname + i, suffix)) {
|
|
match->conf_pos = conf_pos;
|
|
match->start = i;
|
|
match->len = suffix_len;
|
|
break;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* off is the offset of the first different character in the two strings
|
|
* s1 and s2. If either s1 or s2 contains a prerelease suffix containing
|
|
* that offset or a suffix ends right before that offset, then that
|
|
* string will be forced to be on top.
|
|
*
|
|
* If both s1 and s2 contain a (different) suffix around that position,
|
|
* their order is determined by the order of those two suffixes in the
|
|
* configuration.
|
|
* If any of the strings contains more than one different suffixes around
|
|
* that position, then that string is sorted according to the contained
|
|
* suffix which starts at the earliest offset in that string.
|
|
* If more than one different contained suffixes start at that earliest
|
|
* offset, then that string is sorted according to the longest of those
|
|
* suffixes.
|
|
*
|
|
* Return non-zero if *diff contains the return value for versioncmp()
|
|
*/
|
|
static int swap_prereleases(const char *s1,
|
|
const char *s2,
|
|
int off,
|
|
int *diff)
|
|
{
|
|
int i;
|
|
struct suffix_match match1 = { -1, off, -1 };
|
|
struct suffix_match match2 = { -1, off, -1 };
|
|
|
|
for (i = 0; i < prereleases->nr; i++) {
|
|
const char *suffix = prereleases->items[i].string;
|
|
int start, suffix_len = strlen(suffix);
|
|
if (suffix_len < off)
|
|
start = off - suffix_len;
|
|
else
|
|
start = 0;
|
|
find_better_matching_suffix(s1, suffix, suffix_len, start,
|
|
i, &match1);
|
|
find_better_matching_suffix(s2, suffix, suffix_len, start,
|
|
i, &match2);
|
|
}
|
|
if (match1.conf_pos == -1 && match2.conf_pos == -1)
|
|
return 0;
|
|
if (match1.conf_pos == match2.conf_pos)
|
|
/* Found the same suffix in both, e.g. "-rc" in "v1.0-rcX"
|
|
* and "v1.0-rcY": the caller should decide based on "X"
|
|
* and "Y". */
|
|
return 0;
|
|
|
|
if (match1.conf_pos >= 0 && match2.conf_pos >= 0)
|
|
*diff = match1.conf_pos - match2.conf_pos;
|
|
else if (match1.conf_pos >= 0)
|
|
*diff = -1;
|
|
else /* if (match2.conf_pos >= 0) */
|
|
*diff = 1;
|
|
return 1;
|
|
}
|
|
|
|
/*
|
|
* Compare S1 and S2 as strings holding indices/version numbers,
|
|
* returning less than, equal to or greater than zero if S1 is less
|
|
* than, equal to or greater than S2 (for more info, see the texinfo
|
|
* doc).
|
|
*/
|
|
|
|
int versioncmp(const char *s1, const char *s2)
|
|
{
|
|
const unsigned char *p1 = (const unsigned char *) s1;
|
|
const unsigned char *p2 = (const unsigned char *) s2;
|
|
unsigned char c1, c2;
|
|
int state, diff;
|
|
|
|
/*
|
|
* Symbol(s) 0 [1-9] others
|
|
* Transition (10) 0 (01) d (00) x
|
|
*/
|
|
static const uint8_t next_state[] = {
|
|
/* state x d 0 */
|
|
/* S_N */ S_N, S_I, S_Z,
|
|
/* S_I */ S_N, S_I, S_I,
|
|
/* S_F */ S_N, S_F, S_F,
|
|
/* S_Z */ S_N, S_F, S_Z
|
|
};
|
|
|
|
static const int8_t result_type[] = {
|
|
/* state x/x x/d x/0 d/x d/d d/0 0/x 0/d 0/0 */
|
|
|
|
/* S_N */ CMP, CMP, CMP, CMP, LEN, CMP, CMP, CMP, CMP,
|
|
/* S_I */ CMP, -1, -1, +1, LEN, LEN, +1, LEN, LEN,
|
|
/* S_F */ CMP, CMP, CMP, CMP, CMP, CMP, CMP, CMP, CMP,
|
|
/* S_Z */ CMP, +1, +1, -1, CMP, CMP, -1, CMP, CMP
|
|
};
|
|
|
|
if (p1 == p2)
|
|
return 0;
|
|
|
|
c1 = *p1++;
|
|
c2 = *p2++;
|
|
/* Hint: '0' is a digit too. */
|
|
state = S_N + ((c1 == '0') + (isdigit (c1) != 0));
|
|
|
|
while ((diff = c1 - c2) == 0) {
|
|
if (c1 == '\0')
|
|
return diff;
|
|
|
|
state = next_state[state];
|
|
c1 = *p1++;
|
|
c2 = *p2++;
|
|
state += (c1 == '0') + (isdigit (c1) != 0);
|
|
}
|
|
|
|
if (!initialized) {
|
|
const struct string_list *deprecated_prereleases;
|
|
initialized = 1;
|
|
prereleases = git_config_get_value_multi("versionsort.suffix");
|
|
deprecated_prereleases = git_config_get_value_multi("versionsort.prereleasesuffix");
|
|
if (prereleases) {
|
|
if (deprecated_prereleases)
|
|
warning("ignoring versionsort.prereleasesuffix because versionsort.suffix is set");
|
|
} else
|
|
prereleases = deprecated_prereleases;
|
|
}
|
|
if (prereleases && swap_prereleases(s1, s2, (const char *) p1 - s1 - 1,
|
|
&diff))
|
|
return diff;
|
|
|
|
state = result_type[state * 3 + (((c2 == '0') + (isdigit (c2) != 0)))];
|
|
|
|
switch (state) {
|
|
case CMP:
|
|
return diff;
|
|
|
|
case LEN:
|
|
while (isdigit (*p1++))
|
|
if (!isdigit (*p2++))
|
|
return 1;
|
|
|
|
return isdigit (*p2) ? -1 : diff;
|
|
|
|
default:
|
|
return state;
|
|
}
|
|
}
|