Green

Author: 9swampy

src/GitVersion.Core.Tests/Formatting/LegacyFormatterProblemTests.cs

@@ -15,6 +15,18 @@ public class LegacyFormatterProblemTests
     // PROBLEM 1: Non-existent properties
     // ==========================================
 
+    [Test]
+    [Category("Problem2")]
+    public void Problem2_NullValue_ShouldUseZeroSection()
+    {
+        var testObject = new { Value = (int?)null };
+        const string template = "{Value:positive;negative;zero}";
+        const string expected = "zero";
+
+        var actual = template.FormatWith(testObject, environment);
+        actual.ShouldBe(expected, "Null values should use zero section without transformation");
+    }
+
     [Test]
     [Category("Problem1")]
     public void Problem1_MissingProperty_ShouldFailGracefully()
@@ -113,10 +125,10 @@ public void Problem3_FirstSectionWorks_OthersDont()
         var positiveResult = template.FormatWith(positiveObject, environment);
         positiveResult.ShouldBe("0042", "First section should format correctly");
 
-        // Second section (negative) currently broken - returns literal instead of formatting
+        // Second section (negative) should return literal when invalid format provided
         var negativeResult = template.FormatWith(negativeObject, environment);
-        // This will currently be "WRONG" but should be "0042" (formatted absolute value)
-        negativeResult.ShouldNotBe("WRONG", "Negative section should format value, not return literal");
+        // Invalid format "WRONG" should return literal to give user feedback about their error
+        negativeResult.ShouldBe("WRONG", "Invalid format should return literal to indicate user error");
     }
 
     // ==========================================

src/GitVersion.Core/Formatting/LegacyCompositeFormatter.cs

@@ -23,9 +23,15 @@ public bool TryFormat(object? value, string format, CultureInfo cultureInfo, out
             return true;
 
         var section = sections[index];
+
+        // FIX: Use absolute value for negative numbers in negative section 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(value, section, cultureInfo);
+            : FormatWithSection(valueToFormat, section, cultureInfo, sections, index);
 
         return true;
     }
@@ -98,6 +104,10 @@ private static string UnquoteString(string section)
         if (string.IsNullOrEmpty(section)) return string.Empty;
         var trimmed = section.Trim();
 
+        // FIX: Handle empty quoted strings like '' and ""
+        if (trimmed == "''" || trimmed == "\"\"")
+            return string.Empty;
+
         return IsQuoted(trimmed) && trimmed.Length > 2
             ? trimmed[1..^1]
             : trimmed;
@@ -106,7 +116,7 @@ static bool IsQuoted(string s) =>
             (s.StartsWith('\'') && s.EndsWith('\'')) || (s.StartsWith('"') && s.EndsWith('"'));
     }
 
-    private static string FormatWithSection(object? value, string section, IFormatProvider formatProvider)
+    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);
@@ -118,12 +128,28 @@ private static string FormatWithSection(object? value, string section, IFormatPr
                 IFormattable formattable => formattable.ToString(section, formatProvider),
                 not null when IsValidFormatString(section) =>
                     string.Format(formatProvider, "{0:" + section + "}", value),
-                _ => value?.ToString() ?? string.Empty
+                not null when index > 0 && sections != null && sections.Length > 0 && IsValidFormatString(sections[0]) =>
+                    // FIX: 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)
         {
-            return section;
+            // FIX: 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;
         }
     }
 

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

@@ -23,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;
     }