Fix legacy composite format syntax handling (Issue #4654)

This commit fixes the bug where legacy .NET composite format syntax
like {CommitsSinceVersionSource:0000;;''} was not working correctly.

The issue was that the formatter would output literal text instead of
properly formatted values. For example, it would output:
  "6.13.54-gv6-CommitsSinceVersionSource-0000-----"
instead of:
  "6.13.54-gv60002"

Changes:
1. Updated RegexPatterns.cs to allow semicolons and quotes in format
   strings by changing the format pattern from [A-Za-z0-9\.\-,]+ to
   [A-Za-z0-9\.\-,;'"]+

2. Added LegacyCompositeFormatter.cs to properly handle the three-section
   composite format syntax (positive;negative;zero) with support for:
   - Zero-suppression using empty string ('')
   - Proper handling of negative values (no double negative)
   - Numeric formatting in all sections

3. Updated ValueFormatter.cs to register LegacyCompositeFormatter with
   priority 1 and allow null values to be processed by formatters

4. Updated StringFormatWithExtension.cs to not return early for null
   values when legacy syntax is detected

5. Added Issue4654Tests.cs to verify the fix works correctly

The fix ensures backward compatibility with legacy .NET composite format
syntax while maintaining support for modern format strings.

Author: claude

src/GitVersion.Core.Tests/Issues/Issue4654Tests.cs

@@ -0,0 +1,101 @@
+using System.Globalization;
+using GitVersion.Core.Tests.Helpers;
+using GitVersion.Formatting;
+
+namespace GitVersion.Core.Tests.Issues;
+
+[TestFixture]
+public class Issue4654Tests
+{
+    private const string TestVersion = "6.13.54";
+    private const string TestVersionWithPreRelease = "6.13.54-gv60002";
+    private const string TestPreReleaseLabel = "gv6";
+    private const string TestPreReleaseLabelWithDash = "-gv6";
+
+    [Test]
+    [Category("Issue4654")]
+    public void Issue4654_ExactReproduction_ShouldFormatCorrectly()
+    {
+        var semanticVersion = new SemanticVersion
+        {
+            Major = 6,
+            Minor = 13,
+            Patch = 54,
+            PreReleaseTag = new SemanticVersionPreReleaseTag(TestPreReleaseLabel, 1, true),
+            BuildMetaData = new SemanticVersionBuildMetaData()
+            {
+                Branch = "feature/gv6",
+                VersionSourceSha = "21d7e26e6ff58374abd3daf2177be4b7a9c49040",
+                Sha = "489a0c0ab425214def918e36399f3cc3c9a9c42d",
+                ShortSha = "489a0c0",
+                CommitsSinceVersionSource = 2,
+                CommitDate = DateTimeOffset.Parse("2025-08-12", CultureInfo.InvariantCulture),
+                UncommittedChanges = 0
+            }
+        };
+
+        var extendedVersion = new
+        {
+            semanticVersion.Major,
+            semanticVersion.Minor,
+            semanticVersion.Patch,
+            semanticVersion.BuildMetaData.CommitsSinceVersionSource,
+            MajorMinorPatch = $"{semanticVersion.Major}.{semanticVersion.Minor}.{semanticVersion.Patch}",
+            PreReleaseLabel = semanticVersion.PreReleaseTag.Name,
+            PreReleaseLabelWithDash = string.IsNullOrEmpty(semanticVersion.PreReleaseTag.Name)
+                ? ""
+                : $"-{semanticVersion.PreReleaseTag.Name}",
+            AssemblySemFileVer = TestVersion + ".0",
+            AssemblySemVer = TestVersion + ".0",
+            BranchName = "feature/gv6",
+            EscapedBranchName = "feature-gv6",
+            FullSemVer = "6.13.54-gv6.1+2",
+            SemVer = "6.13.54-gv6.1"
+        };
+
+        const string template = "{MajorMinorPatch}{PreReleaseLabelWithDash}{CommitsSinceVersionSource:0000;;''}";
+        const string expected = TestVersionWithPreRelease;
+
+        var actual = template.FormatWith(extendedVersion, new TestEnvironment());
+
+        actual.ShouldBe(expected, "The legacy ;;'' syntax should format CommitsSinceVersionSource as 0002, not as literal text");
+    }
+
+    [Test]
+    [Category("Issue4654")]
+    public void Issue4654_WithoutLegacySyntax_ShouldStillWork()
+    {
+        var testData = new
+        {
+            MajorMinorPatch = TestVersion,
+            PreReleaseLabelWithDash = TestPreReleaseLabelWithDash,
+            CommitsSinceVersionSource = 2
+        };
+
+        const string template = "{MajorMinorPatch}{PreReleaseLabelWithDash}{CommitsSinceVersionSource:0000}";
+        const string expected = TestVersionWithPreRelease;
+
+        var actual = template.FormatWith(testData, new TestEnvironment());
+
+        actual.ShouldBe(expected, "New format syntax should work correctly");
+    }
+
+    [Test]
+    [Category("Issue4654")]
+    public void Issue4654_ZeroValueWithLegacySyntax_ShouldUseEmptyFallback()
+    {
+        var mainBranchData = new
+        {
+            MajorMinorPatch = TestVersion,
+            PreReleaseLabelWithDash = "",
+            CommitsSinceVersionSource = 0
+        };
+
+        const string template = "{MajorMinorPatch}{PreReleaseLabelWithDash}{CommitsSinceVersionSource:0000;;''}";
+        const string expected = TestVersion;
+
+        var actual = template.FormatWith(mainBranchData, new TestEnvironment());
+
+        actual.ShouldBe(expected, "Zero values should use the third section (empty string) in legacy ;;'' syntax");
+    }
+}

src/GitVersion.Core/Core/RegexPatterns.cs

@@ -93,7 +93,7 @@ internal static partial class Common
                     |                                                   # OR
                     (?<member>[A-Za-z_][A-Za-z0-9_]*)                   # member/property name
                     (?:                                                 # Optional format specifier
-                        :(?<format>[A-Za-z0-9\.\-,]+)                   # Colon followed by format string (no spaces, ?, or }), format cannot contain colon
+                        :(?<format>[A-Za-z0-9\.\-,;'"]+)                # Colon followed by format string (including semicolons and quotes for legacy composite format)
                     )?                                                  # Format is optional
                 )                                                       # End group for env or member
                 (?:                                                     # Optional fallback group

src/GitVersion.Core/Formatting/LegacyCompositeFormatter.cs

@@ -0,0 +1,164 @@
+using System.Globalization;
+
+namespace GitVersion.Formatting;
+
+internal class LegacyCompositeFormatter : IValueFormatter
+{
+    public int Priority => 1;
+
+    public bool TryFormat(object? value, string format, out string result) =>
+        TryFormat(value, format, CultureInfo.InvariantCulture, out result);
+
+    public bool TryFormat(object? value, string format, CultureInfo cultureInfo, out string result)
+    {
+        result = string.Empty;
+
+        if (!HasLegacySyntax(format))
+            return false;
+
+        var sections = ParseSections(format);
+        var index = GetSectionIndex(value, sections.Length);
+
+        if (index >= sections.Length)
+            return true;
+
+        var section = sections[index];
+
+        // Use absolute value for negative numbers to prevent double negatives
+        var valueToFormat = (index == 1 && value != null && IsNumeric(value) && Convert.ToDouble(value) < 0)
+            ? Math.Abs(Convert.ToDouble(value))
+            : value;
+
+        result = IsQuotedLiteral(section)
+            ? UnquoteString(section)
+            : FormatWithSection(valueToFormat, section, cultureInfo, sections, index);
+
+        return true;
+    }
+
+    private static bool HasLegacySyntax(string format) =>
+        !string.IsNullOrEmpty(format) && format.Contains(';') && !format.Contains("??");
+
+    private static string[] ParseSections(string format)
+    {
+        var sections = new List<string>();
+        var current = new StringBuilder();
+        var inQuotes = false;
+        var quoteChar = '\0';
+
+        foreach (var c in format)
+        {
+            if (!inQuotes && (c == '\'' || c == '"'))
+            {
+                inQuotes = true;
+                quoteChar = c;
+            }
+            else if (inQuotes && c == quoteChar)
+            {
+                inQuotes = false;
+            }
+            else if (!inQuotes && c == ';')
+            {
+                sections.Add(current.ToString());
+                current.Clear();
+                continue;
+            }
+
+            current.Append(c);
+        }
+
+        sections.Add(current.ToString());
+        return [.. sections];
+    }
+
+    private static int GetSectionIndex(object? value, int sectionCount)
+    {
+        if (sectionCount == 1) return 0;
+        if (value == null) return sectionCount >= 3 ? 2 : 0;
+
+        if (!IsNumeric(value)) return 0;
+
+        var num = Convert.ToDouble(value);
+        return num switch
+        {
+            > 0 => 0,
+            < 0 when sectionCount >= 2 => 1,
+            0 when sectionCount >= 3 => 2,
+            _ => 0
+        };
+    }
+
+    private static bool IsNumeric(object value) =>
+        value is byte or sbyte or short or ushort or int or uint or long or ulong or float or double or decimal;
+
+    private static bool IsQuotedLiteral(string section)
+    {
+        if (string.IsNullOrEmpty(section)) return true;
+        var trimmed = section.Trim();
+        return (trimmed.StartsWith('\'') && trimmed.EndsWith('\'')) ||
+               (trimmed.StartsWith('"') && trimmed.EndsWith('"'));
+    }
+
+    private static string UnquoteString(string section)
+    {
+        if (string.IsNullOrEmpty(section)) return string.Empty;
+        var trimmed = section.Trim();
+
+        // Handle empty quoted strings like '' and ""
+        if (trimmed == "''" || trimmed == "\"\"")
+            return string.Empty;
+
+        return IsQuoted(trimmed) && trimmed.Length > 2
+            ? trimmed[1..^1]
+            : trimmed;
+
+        static bool IsQuoted(string s) =>
+            (s.StartsWith('\'') && s.EndsWith('\'')) || (s.StartsWith('"') && s.EndsWith('"'));
+    }
+
+    private static string FormatWithSection(object? value, string section, IFormatProvider formatProvider, string[]? sections = null, int index = 0)
+    {
+        if (string.IsNullOrEmpty(section)) return string.Empty;
+        if (IsQuotedLiteral(section)) return UnquoteString(section);
+
+        try
+        {
+            return value switch
+            {
+                IFormattable formattable => formattable.ToString(section, formatProvider),
+                not null when IsValidFormatString(section) =>
+                    string.Format(formatProvider, "{0:" + section + "}", value),
+                not null when index > 0 && sections != null && sections.Length > 0 && IsValidFormatString(sections[0]) =>
+                    // For invalid formats in non-first sections, use first section format
+                    string.Format(formatProvider, "{0:" + sections[0] + "}", value),
+                not null => value.ToString() ?? string.Empty,
+                _ => section  // Only for null values without valid format
+            };
+        }
+        catch (FormatException)
+        {
+            // On format exception, try first section format or return value string
+            if (index > 0 && sections != null && sections.Length > 0 && IsValidFormatString(sections[0]))
+            {
+                try
+                {
+                    return string.Format(formatProvider, "{0:" + sections[0] + "}", value);
+                }
+                catch
+                {
+                    return value?.ToString() ?? section;
+                }
+            }
+            return value?.ToString() ?? section;
+        }
+    }
+
+    private static bool IsValidFormatString(string format)
+    {
+        if (string.IsNullOrEmpty(format)) return false;
+
+        var firstChar = char.ToUpperInvariant(format[0]);
+        return "CDEFGNPXR".Contains(firstChar) ||
+               format.All(c => "0123456789.,#".Contains(c));
+    }
+}

src/GitVersion.Core/Formatting/StringFormatWithExtension.cs

@@ -84,7 +84,8 @@ private static string EvaluateMember<T>(T source, string member, string? format,
         var getter = ExpressionCompiler.CompileGetter(source.GetType(), memberPath);
         var value = getter(source);
 
-        if (value is null)
+        // Only return early for null if format doesn't use legacy syntax
+        if (value is null && !HasLegacySyntax(format))
             return fallback ?? string.Empty;
 
         if (format is not null && ValueFormatter.Default.TryFormat(
@@ -95,6 +96,9 @@ private static string EvaluateMember<T>(T source, string member, string? format,
             return formatted;
         }
 
-        return value.ToString() ?? fallback ?? string.Empty;
+        return value?.ToString() ?? fallback ?? string.Empty;
     }
+
+    private static bool HasLegacySyntax(string? format) =>
+        !string.IsNullOrEmpty(format) && format.Contains(';') && !format.Contains("??");
 }

src/GitVersion.Core/Formatting/ValueFormatter.cs

@@ -13,6 +13,7 @@ internal class ValueFormatter : InvariantFormatter, IValueFormatterCombiner
     internal ValueFormatter()
         => formatters =
         [
+            new LegacyCompositeFormatter(),
             new StringFormatter(),
             new FormattableFormatter(),
             new NumericFormatter(),
@@ -22,17 +23,20 @@ internal ValueFormatter()
     public override bool TryFormat(object? value, string format, CultureInfo cultureInfo, out string result)
     {
         result = string.Empty;
-        if (value is null)
-        {
-            return false;
-        }
 
+        // Allow formatters to handle null values (e.g., legacy composite formatter for zero sections)
         foreach (var formatter in formatters.OrderBy(f => f.Priority))
         {
             if (formatter.TryFormat(value, format, out result))
                 return true;
         }
 
+        // Only return false if no formatter could handle it
+        if (value is null)
+        {
+            return false;
+        }
+
         return false;
     }