Address PR comments II. Apply SOLI>>D<< to ValueFormatter.

9swampy · 9swampy · commit 65a39f50bc64 · 2025-07-19T23:19:01.000+01:00
diff --git a/src/GitVersion.Core.Tests/Formatting/DateFormatterTests.cs b/src/GitVersion.Core.Tests/Formatting/DateFormatterTests.cs
@@ -17,8 +17,8 @@ public void TryFormat_NullValue_ReturnsFalse()
         formatted.ShouldBeEmpty();
     }
 
-    [TestCase("2021-01-01", "date:yyyy-MM-dd", "2021-01-01")]
-    [TestCase("2021-01-01T12:00:00Z", "date:yyyy-MM-ddTHH:mm:ssZ", "2021-01-01T12:00:00Z")]
+    [TestCase("2021-01-01", "yyyy-MM-dd", "2021-01-01")]
+    [TestCase("2021-01-01T12:00:00Z", "yyyy-MM-ddTHH:mm:ssZ", "2021-01-01T12:00:00Z")]
     public void TryFormat_ValidDateFormats_ReturnsExpectedResult(string input, string format, string expected)
     {
         var date = DateTime.Parse(input);
@@ -27,13 +27,4 @@ public void TryFormat_ValidDateFormats_ReturnsExpectedResult(string input, strin
         result.ShouldBeTrue();
         formatted.ShouldBe(expected);
     }
-
-    [Test]
-    public void TryFormat_UnsupportedFormat_ReturnsFalse()
-    {
-        var sut = new DateFormatter();
-        var result = sut.TryFormat(DateTime.Now, "unsupported", out var formatted);
-        result.ShouldBeFalse();
-        formatted.ShouldBeEmpty();
-    }
 }
diff --git a/src/GitVersion.Core.Tests/Formatting/FormattableFormatterTests.cs b/src/GitVersion.Core.Tests/Formatting/FormattableFormatterTests.cs
@@ -1,4 +1,5 @@
-﻿using GitVersion.Formatting;
+﻿using System.Globalization;
+using GitVersion.Formatting;
 
 namespace GitVersion.Core.Tests.Formatting;
 
@@ -12,13 +13,16 @@ public class FormattableFormatterTests
     public void TryFormat_NullValue_ReturnsFalse()
     {
         var sut = new FormattableFormatter();
-        var result = sut.TryFormat(null, "G", out var formatted);
+        var result = sut.TryFormat(null, "G", CultureInfo.InvariantCulture, out var formatted);
         result.ShouldBeFalse();
         formatted.ShouldBeEmpty();
     }
 
     [TestCase(123.456, "F2", "123.46")]
     [TestCase(1234.456, "F2", "1234.46")]
+    [TestCase(123.456, "C", "¤123.46")]
+    [TestCase(123.456, "P", "12,345.60 %")]
+    [TestCase(1234567890, "N0", "1,234,567,890")]
     public void TryFormat_ValidFormats_ReturnsExpectedResult(object input, string format, string expected)
     {
         var sut = new FormattableFormatter();
@@ -27,9 +31,6 @@ public void TryFormat_ValidFormats_ReturnsExpectedResult(object input, string fo
         formatted.ShouldBe(expected);
     }
 
-    [TestCase(123.456, "C", "Format 'C' is not supported in FormattableFormatter")]
-    [TestCase(123.456, "P", "Format 'P' is not supported in FormattableFormatter")]
-    [TestCase(1234567890, "N0", "Format 'N0' is not supported in FormattableFormatter")]
     [TestCase(1234567890, "Z", "Format 'Z' is not supported in FormattableFormatter")]
     public void TryFormat_UnsupportedFormat_ReturnsFalse(object input, string format, string expected)
     {
diff --git a/src/GitVersion.Core.Tests/Formatting/ValueFormatterTests.cs b/src/GitVersion.Core.Tests/Formatting/ValueFormatterTests.cs
@@ -0,0 +1,121 @@
+using GitVersion.Formatting;
+
+namespace GitVersion.Core.Tests.Formatting;
+
+[TestFixture]
+public class ValueFormatterTests
+{
+    [Test]
+    public void TryFormat_NullValue_ReturnsFalse()
+    {
+        var result = ValueFormatter.Default.TryFormat(null, "any", out var formatted);
+        result.ShouldBeFalse();
+        formatted.ShouldBeEmpty();
+    }
+
+    [Test]
+    public void TryFormat_String_UsesStringFormatter()
+    {
+        var result = ValueFormatter.Default.TryFormat("hello", "u", out var formatted);
+        result.ShouldBeTrue();
+        formatted.ShouldBe("HELLO");
+    }
+
+    [Test]
+    public void TryFormat_Number_UsesNumericFormatter()
+    {
+        var result = ValueFormatter.Default.TryFormat(1234.5678, "n", out var formatted);
+        result.ShouldBeTrue();
+        formatted.ShouldBe("1,234.57");
+    }
+
+    [Test]
+    public void TryFormat_Date_UsesDateFormatter()
+    {
+        var date = new DateTime(2023, 12, 25);
+        var result = ValueFormatter.Default.TryFormat(date, "yyyy-MM-dd", out var formatted);
+        result.ShouldBeTrue();
+        formatted.ShouldBe("2023-12-25");
+    }
+
+    [Test]
+    public void TryFormat_FormattableObject_UsesFormattableFormatter()
+    {
+        var value = 123.456m;
+        var result = ValueFormatter.Default.TryFormat(value, "C", out var formatted);
+        result.ShouldBeTrue();
+        formatted.ShouldBe("�123.46");
+    }
+
+    [Test]
+    public void TryFormat_InvalidFormat_ReturnsFalse()
+    {
+        var result = ValueFormatter.Default.TryFormat("test", "invalidformat", out var formatted);
+        result.ShouldBeFalse();
+        formatted.ShouldBeEmpty();
+    }
+
+    [Test]
+    public void RegisterFormatter_AddsNewFormatter()
+    {
+        var customFormatter = new TestFormatter { Priority = 0 };
+        IValueFormatterCombiner sut = new ValueFormatter();
+        sut.RegisterFormatter(customFormatter);
+        var result = sut.TryFormat("test", "custom", out var formatted);
+        result.ShouldBeTrue();
+        formatted.ShouldBe("CUSTOM:test");
+    }
+
+    [Test]
+    public void RemoveFormatter_RemovesExistingFormatter()
+    {
+        IValueFormatterCombiner sut = new ValueFormatter();
+        // First verify numeric formatting works
+        sut.TryFormat(123.45, "n", out var before);
+        before.ShouldBe("123.45");
+
+        // Remove the numeric formatter
+        sut.RemoveFormatter<NumericFormatter>();
+
+        // Now numeric formatting should fail
+        var result = sut.TryFormat(123.45, "n", out var after);
+        result.ShouldBeFalse();
+        after.ShouldBeEmpty();
+    }
+
+    [Test]
+    public void Formatters_ExecuteInPriorityOrder()
+    {
+        IValueFormatterCombiner sut = new ValueFormatter();
+        var highPriorityFormatter = new TestFormatter { Priority = 0 };
+        var lowPriorityFormatter = new TestFormatter { Priority = 99 };
+
+        sut.RegisterFormatter(lowPriorityFormatter);
+        sut.RegisterFormatter(highPriorityFormatter);
+        var result = sut.TryFormat("test", "custom", out var formatted);
+        result.ShouldBeTrue();
+
+        // Should use the high priority formatter first
+        formatted.ShouldBe("CUSTOM:test");
+    }
+
+    private class TestFormatter : IValueFormatter
+    {
+        public int Priority { get; init; }
+
+        public bool TryFormat(object? value, string format, out string result)
+        {
+            if (format == "custom" && value is string str)
+            {
+                result = $"CUSTOM:{str}";
+                return true;
+            }
+
+            result = string.Empty;
+            return false;
+        }
+
+        public bool TryFormat(object? value, string format, System.Globalization.CultureInfo cultureInfo, out string result)
+            => TryFormat(value, format, out result);
+    }
+}
diff --git a/src/GitVersion.Core/Extensions/StringExtensions.cs b/src/GitVersion.Core/Extensions/StringExtensions.cs
@@ -1,4 +1,5 @@
 using System.Diagnostics.CodeAnalysis;
+using System.Globalization;
 using GitVersion.Core;
 
 namespace GitVersion.Extensions;
@@ -31,7 +32,7 @@ public static bool IsEquivalentTo(this string self, string? other) =>
     public static string WithPrefixIfNotNullOrEmpty(this string value, string prefix)
         => string.IsNullOrEmpty(value) ? value : prefix + value;
 
-    internal static string PascalCase(this string input)
+    internal static string PascalCase(this string input, CultureInfo cultureInfo)
     {
         var sb = new StringBuilder(input.Length);
         var capitalizeNext = true;
@@ -44,7 +45,7 @@ internal static string PascalCase(this string input)
                 continue;
             }
 
-            sb.Append(capitalizeNext ? char.ToUpperInvariant(c) : char.ToLowerInvariant(c));
+            sb.Append(capitalizeNext ? cultureInfo.TextInfo.ToUpper(c) : cultureInfo.TextInfo.ToLower(c));
             capitalizeNext = false;
         }
 
diff --git a/src/GitVersion.Core/Formatting/DateFormatter.cs b/src/GitVersion.Core/Formatting/DateFormatter.cs
@@ -2,30 +2,26 @@
 
 namespace GitVersion.Formatting;
 
-internal class DateFormatter : IValueFormatter
+internal class DateFormatter : InvariantFormatter, IValueFormatter
 {
     public int Priority => 2;
 
-    public bool TryFormat(object? value, string format, out string result)
+    public override bool TryFormat(object? value, string format, CultureInfo cultureInfo, out string result)
     {
         result = string.Empty;
 
-        if (value is DateTime dt && format.StartsWith("date:"))
+        if (value is DateTime dt)
         {
-            var dateFormat = RemoveDatePrefix(format);
-            result = dt.ToString(dateFormat, CultureInfo.InvariantCulture);
+            result = dt.ToString(format, cultureInfo);
             return true;
         }
 
-        if (value is string dateStr && DateTime.TryParse(dateStr, out var parsedDate) && format.StartsWith("date:"))
+        if (value is string dateStr && DateTime.TryParse(dateStr, out var parsedDate))
         {
-            var dateFormat = format.Substring(5);
-            result = parsedDate.ToString(dateFormat, CultureInfo.InvariantCulture);
+            result = parsedDate.ToString(format, cultureInfo);
             return true;
         }
 
         return false;
     }
-
-    private static string RemoveDatePrefix(string format) => format.Substring(5);
 }
diff --git a/src/GitVersion.Core/Formatting/ExpressionCompiler.cs b/src/GitVersion.Core/Formatting/ExpressionCompiler.cs
@@ -1,6 +1,6 @@
 using System.Linq.Expressions;
 
-namespace GitVersion.Helpers;
+namespace GitVersion.Formatting;
 
 internal class ExpressionCompiler : IExpressionCompiler
 {
diff --git a/src/GitVersion.Core/Formatting/FormattableFormatter.cs b/src/GitVersion.Core/Formatting/FormattableFormatter.cs
@@ -7,23 +7,20 @@ internal class FormattableFormatter : IValueFormatter
     public int Priority => 2;
 
     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 (string.IsNullOrWhiteSpace(format))
             return false;
 
-        if (IsBlockedFormat(format))
-        {
-            result = $"Format '{format}' is not supported in {nameof(FormattableFormatter)}";
-            return false;
-        }
-
         if (value is IFormattable formattable)
         {
             try
             {
-                result = formattable.ToString(format, CultureInfo.InvariantCulture);
+                result = formattable.ToString(format, cultureInfo);
                 return true;
             }
             catch (FormatException)
@@ -35,9 +32,4 @@ public bool TryFormat(object? value, string format, out string result)
 
         return false;
     }
-
-    private static bool IsBlockedFormat(string format) =>
-        format.Equals("C", StringComparison.OrdinalIgnoreCase) ||
-        format.Equals("P", StringComparison.OrdinalIgnoreCase) ||
-        format.StartsWith("N", StringComparison.OrdinalIgnoreCase);
 }
diff --git a/src/GitVersion.Core/Formatting/IExpressionCompiler.cs b/src/GitVersion.Core/Formatting/IExpressionCompiler.cs
@@ -1,4 +1,4 @@
-﻿namespace GitVersion.Helpers
+﻿namespace GitVersion.Formatting
 {
     internal interface IExpressionCompiler
     {
diff --git a/src/GitVersion.Core/Formatting/IMemberResolver.cs b/src/GitVersion.Core/Formatting/IMemberResolver.cs
@@ -1,4 +1,4 @@
-namespace GitVersion.Helpers;
+namespace GitVersion.Formatting;
 
 internal interface IMemberResolver
 {
diff --git a/src/GitVersion.Core/Formatting/IValueFormatter.cs b/src/GitVersion.Core/Formatting/IValueFormatter.cs
@@ -1,9 +1,13 @@
+using System.Globalization;
+
 namespace GitVersion.Formatting;
 
 internal interface IValueFormatter
 {
     bool TryFormat(object? value, string format, out string result);
 
+    bool TryFormat(object? value, string format, CultureInfo cultureInfo, out string result);
+
     /// <summary>
     ///   Lower number = higher priority
     /// </summary>
diff --git a/src/GitVersion.Core/Formatting/IValueFormatterCombiner.cs b/src/GitVersion.Core/Formatting/IValueFormatterCombiner.cs
@@ -0,0 +1,8 @@
+namespace GitVersion.Formatting;
+
+internal interface IValueFormatterCombiner : IValueFormatter
+{
+    void RegisterFormatter(IValueFormatter formatter);
+
+    void RemoveFormatter<T>() where T : IValueFormatter;
+}
diff --git a/src/GitVersion.Core/Formatting/InvariantFormatter.cs b/src/GitVersion.Core/Formatting/InvariantFormatter.cs
@@ -0,0 +1,11 @@
+using System.Globalization;
+
+namespace GitVersion.Formatting;
+
+internal abstract class InvariantFormatter
+{
+    public bool TryFormat(object? value, string format, out string result)
+        => TryFormat(value, format, CultureInfo.InvariantCulture, out result);
+
+    public abstract bool TryFormat(object? value, string format, CultureInfo cultureInfo, out string result);
+}
diff --git a/src/GitVersion.Core/Formatting/MemberResolver.cs b/src/GitVersion.Core/Formatting/MemberResolver.cs
@@ -1,4 +1,4 @@
-namespace GitVersion.Helpers;
+namespace GitVersion.Formatting;
 
 internal class MemberResolver : IMemberResolver
 {
@@ -29,15 +29,11 @@ public MemberInfo[] ResolveMemberPath(Type type, string memberExpression)
     public static List<MemberInfo>? FindMemberRecursive(Type type, string memberName, HashSet<Type> visited)
     {
         if (!visited.Add(type))
-        {
             return null;
-        }
 
         var member = FindDirectMember(type, memberName);
         if (member != null)
-        {
             return [member];
-        }
 
         foreach (var prop in type.GetProperties())
         {
diff --git a/src/GitVersion.Core/Formatting/NumericFormatter.cs b/src/GitVersion.Core/Formatting/NumericFormatter.cs
diff --git a/src/GitVersion.Core/Formatting/StringFormatter.cs b/src/GitVersion.Core/Formatting/StringFormatter.cs
diff --git a/src/GitVersion.Core/Formatting/ValueFormatter.cs b/src/GitVersion.Core/Formatting/ValueFormatter.cs
diff --git a/src/GitVersion.Core/Helpers/StringFormatWith.cs b/src/GitVersion.Core/Helpers/StringFormatWith.cs

Original file line number	Diff line number	Diff line change
`@@ -17,8 +17,8 @@ public void TryFormat_NullValue_ReturnsFalse()`
`17`	`17`	`formatted.ShouldBeEmpty();`
`18`	`18`	`}`
`19`	`19`
`20`		`- [TestCase("2021-01-01", "date:yyyy-MM-dd", "2021-01-01")]`
`21`		`- [TestCase("2021-01-01T12:00:00Z", "date:yyyy-MM-ddTHH:mm:ssZ", "2021-01-01T12:00:00Z")]`
	`20`	`+ [TestCase("2021-01-01", "yyyy-MM-dd", "2021-01-01")]`
	`21`	`+ [TestCase("2021-01-01T12:00:00Z", "yyyy-MM-ddTHH:mm:ssZ", "2021-01-01T12:00:00Z")]`
`22`	`22`	`public void TryFormat_ValidDateFormats_ReturnsExpectedResult(string input, string format, string expected)`
`23`	`23`	`{`
`24`	`24`	`var date = DateTime.Parse(input);`
`@@ -27,13 +27,4 @@ public void TryFormat_ValidDateFormats_ReturnsExpectedResult(string input, strin`
`27`	`27`	`result.ShouldBeTrue();`
`28`	`28`	`formatted.ShouldBe(expected);`
`29`	`29`	`}`
`30`		`-`
`31`		`- [Test]`
`32`		`- public void TryFormat_UnsupportedFormat_ReturnsFalse()`
`33`		`- {`
`34`		`- var sut = new DateFormatter();`
`35`		`- var result = sut.TryFormat(DateTime.Now, "unsupported", out var formatted);`
`36`		`- result.ShouldBeFalse();`
`37`		`- formatted.ShouldBeEmpty();`
`38`		`- }`
`39`	`30`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1,4 +1,5 @@`
`1`		`-using GitVersion.Formatting;`
	`1`	`+using System.Globalization;`
	`2`	`+using GitVersion.Formatting;`
`2`	`3`
`3`	`4`	`namespace GitVersion.Core.Tests.Formatting;`
`4`	`5`
`@@ -12,13 +13,16 @@ public class FormattableFormatterTests`
`12`	`13`	`public void TryFormat_NullValue_ReturnsFalse()`
`13`	`14`	`{`
`14`	`15`	`var sut = new FormattableFormatter();`
`15`		`- var result = sut.TryFormat(null, "G", out var formatted);`
	`16`	`+ var result = sut.TryFormat(null, "G", CultureInfo.InvariantCulture, out var formatted);`
`16`	`17`	`result.ShouldBeFalse();`
`17`	`18`	`formatted.ShouldBeEmpty();`
`18`	`19`	`}`
`19`	`20`
`20`	`21`	`[TestCase(123.456, "F2", "123.46")]`
`21`	`22`	`[TestCase(1234.456, "F2", "1234.46")]`
	`23`	`+ [TestCase(123.456, "C", "¤123.46")]`
	`24`	`+ [TestCase(123.456, "P", "12,345.60 %")]`
	`25`	`+ [TestCase(1234567890, "N0", "1,234,567,890")]`
`22`	`26`	`public void TryFormat_ValidFormats_ReturnsExpectedResult(object input, string format, string expected)`
`23`	`27`	`{`
`24`	`28`	`var sut = new FormattableFormatter();`
`@@ -27,9 +31,6 @@ public void TryFormat_ValidFormats_ReturnsExpectedResult(object input, string fo`
`27`	`31`	`formatted.ShouldBe(expected);`
`28`	`32`	`}`
`29`	`33`
`30`		`- [TestCase(123.456, "C", "Format 'C' is not supported in FormattableFormatter")]`
`31`		`- [TestCase(123.456, "P", "Format 'P' is not supported in FormattableFormatter")]`
`32`		`- [TestCase(1234567890, "N0", "Format 'N0' is not supported in FormattableFormatter")]`
`33`	`34`	`[TestCase(1234567890, "Z", "Format 'Z' is not supported in FormattableFormatter")]`
`34`	`35`	`public void TryFormat_UnsupportedFormat_ReturnsFalse(object input, string format, string expected)`
`35`	`36`	`{`
Original file line number	Diff line number	Diff line change
`@@ -1,4 +1,5 @@`
`1`	`1`	`using System.Diagnostics.CodeAnalysis;`
	`2`	`+using System.Globalization;`
`2`	`3`	`using GitVersion.Core;`
`3`	`4`
`4`	`5`	`namespace GitVersion.Extensions;`
`@@ -31,7 +32,7 @@ public static bool IsEquivalentTo(this string self, string? other) =>`
`31`	`32`	`public static string WithPrefixIfNotNullOrEmpty(this string value, string prefix)`
`32`	`33`	`=> string.IsNullOrEmpty(value) ? value : prefix + value;`
`33`	`34`
`34`		`- internal static string PascalCase(this string input)`
	`35`	`+ internal static string PascalCase(this string input, CultureInfo cultureInfo)`
`35`	`36`	`{`
`36`	`37`	`var sb = new StringBuilder(input.Length);`
`37`	`38`	`var capitalizeNext = true;`
`@@ -44,7 +45,7 @@ internal static string PascalCase(this string input)`
`44`	`45`	`continue;`
`45`	`46`	`}`
`46`	`47`
`47`		`- sb.Append(capitalizeNext ? char.ToUpperInvariant(c) : char.ToLowerInvariant(c));`
	`48`	`+ sb.Append(capitalizeNext ? cultureInfo.TextInfo.ToUpper(c) : cultureInfo.TextInfo.ToLower(c));`
`48`	`49`	`capitalizeNext = false;`
`49`	`50`	`}`
`50`	`51`
Original file line number	Diff line number	Diff line change
`@@ -2,30 +2,26 @@`
`2`	`2`
`3`	`3`	`namespace GitVersion.Formatting;`
`4`	`4`
`5`		`-internal class DateFormatter : IValueFormatter`
	`5`	`+internal class DateFormatter : InvariantFormatter, IValueFormatter`
`6`	`6`	`{`
`7`	`7`	`public int Priority => 2;`
`8`	`8`
`9`		`- public bool TryFormat(object? value, string format, out string result)`
	`9`	`+ public override bool TryFormat(object? value, string format, CultureInfo cultureInfo, out string result)`
`10`	`10`	`{`
`11`	`11`	`result = string.Empty;`
`12`	`12`
`13`		`- if (value is DateTime dt && format.StartsWith("date:"))`
	`13`	`+ if (value is DateTime dt)`
`14`	`14`	`{`
`15`		`- var dateFormat = RemoveDatePrefix(format);`
`16`		`- result = dt.ToString(dateFormat, CultureInfo.InvariantCulture);`
	`15`	`+ result = dt.ToString(format, cultureInfo);`
`17`	`16`	`return true;`
`18`	`17`	`}`
`19`	`18`
`20`		`- if (value is string dateStr && DateTime.TryParse(dateStr, out var parsedDate) && format.StartsWith("date:"))`
	`19`	`+ if (value is string dateStr && DateTime.TryParse(dateStr, out var parsedDate))`
`21`	`20`	`{`
`22`		`- var dateFormat = format.Substring(5);`
`23`		`- result = parsedDate.ToString(dateFormat, CultureInfo.InvariantCulture);`
	`21`	`+ result = parsedDate.ToString(format, cultureInfo);`
`24`	`22`	`return true;`
`25`	`23`	`}`
`26`	`24`
`27`	`25`	`return false;`
`28`	`26`	`}`
`29`		`-`
`30`		`- private static string RemoveDatePrefix(string format) => format.Substring(5);`
`31`	`27`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1,6 +1,6 @@`
`1`	`1`	`using System.Linq.Expressions;`
`2`	`2`
`3`		`-namespace GitVersion.Helpers;`
	`3`	`+namespace GitVersion.Formatting;`
`4`	`4`
`5`	`5`	`internal class ExpressionCompiler : IExpressionCompiler`
`6`	`6`	`{`
Original file line number	Diff line number	Diff line change
`@@ -7,23 +7,20 @@ internal class FormattableFormatter : IValueFormatter`
`7`	`7`	`public int Priority => 2;`
`8`	`8`
`9`	`9`	`public bool TryFormat(object? value, string format, out string result)`
	`10`	`+ => TryFormat(value, format, CultureInfo.InvariantCulture, out result);`
	`11`	`+`
	`12`	`+ public bool TryFormat(object? value, string format, CultureInfo cultureInfo, out string result)`
`10`	`13`	`{`
`11`	`14`	`result = string.Empty;`
`12`	`15`
`13`	`16`	`if (string.IsNullOrWhiteSpace(format))`
`14`	`17`	`return false;`
`15`	`18`
`16`		`- if (IsBlockedFormat(format))`
`17`		`- {`
`18`		`- result = $"Format '{format}' is not supported in {nameof(FormattableFormatter)}";`
`19`		`- return false;`
`20`		`- }`
`21`		`-`
`22`	`19`	`if (value is IFormattable formattable)`
`23`	`20`	`{`
`24`	`21`	`try`
`25`	`22`	`{`
`26`		`- result = formattable.ToString(format, CultureInfo.InvariantCulture);`
	`23`	`+ result = formattable.ToString(format, cultureInfo);`
`27`	`24`	`return true;`
`28`	`25`	`}`
`29`	`26`	`catch (FormatException)`
`@@ -35,9 +32,4 @@ public bool TryFormat(object? value, string format, out string result)`
`35`	`32`
`36`	`33`	`return false;`
`37`	`34`	`}`
`38`		`-`
`39`		`- private static bool IsBlockedFormat(string format) =>`
`40`		`- format.Equals("C", StringComparison.OrdinalIgnoreCase) \|\|`
`41`		`- format.Equals("P", StringComparison.OrdinalIgnoreCase) \|\|`
`42`		`- format.StartsWith("N", StringComparison.OrdinalIgnoreCase);`
`43`	`35`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1,4 +1,4 @@`
`1`		`-namespace GitVersion.Helpers`
	`1`	`+namespace GitVersion.Formatting`
`2`	`2`	`{`
`3`	`3`	`internal interface IExpressionCompiler`
`4`	`4`	`{`