Adds a new parameter to block producing extensions to allow specifying if a newline is produced or not. (#10)

resolves #8
fixes #9

* Added string extension to `Ubiquity.NET.Extensions`
    * Extension method HasLineEndings() determines if a string has any line endings.
* Added WriteCommentLine(s) methods to C# extensions for `IndentedTextWriter`
* Added parameter to indicate if blocks are closed with a newline.
    * default is not for compat.
        - Next major rev can shift to using newline as default. [BREAKING CHANGE]

Author: smaillet

BuildVersion.xml

@@ -15,5 +15,6 @@ PreReleaseFix
 <BuildVersionData
     BuildMajor = "20"
     BuildMinor = "1"
-    BuildPatch = "8"
+    BuildPatch = "9"
+    PreReleaseName = "alpha"
 />

src/Ubiquity.NET.Extensions.UT/StringExtensionTests.cs

@@ -0,0 +1,33 @@
+// Copyright (c) Ubiquity.NET Contributors. All rights reserved.
+// Licensed under the Apache-2.0 WITH LLVM-exception license. See the LICENSE.md file in the project root for full license information.
+
+namespace Ubiquity.NET.Extensions.UT
+{
+    [TestClass]
+    public class StringExtensionTests
+    {
+        [TestMethod]
+        public void HasLineEndings_with_null_throws( )
+        {
+#pragma warning disable CS8604 // Possible null reference argument.
+            // nullability guarantees is the point of this test
+            string? test = null;
+            var ex = Assert.ThrowsExactly<ArgumentNullException>(()=>StringExtensions.HasLineEndings( test ));
+            Assert.AreEqual("self", ex.ParamName);
+#pragma warning restore CS8604 // Possible null reference argument.
+        }
+
+        [TestMethod]
+        public void HasLineEndings_detects_all_line_endings( )
+        {
+            // valid Unicode line endings are "(\r\n|\r|\n|\f|\u0085|\u2028|\u2029)"
+            Assert.IsFalse("This is a test".HasLineEndings());
+            Assert.IsTrue("This\r is a test".HasLineEndings());
+            Assert.IsTrue("This\n is a test".HasLineEndings());
+            Assert.IsTrue("This\f is a test".HasLineEndings());
+            Assert.IsTrue("This\u0085 is a test".HasLineEndings());
+            Assert.IsTrue("This\u2028 is a test".HasLineEndings());
+            Assert.IsTrue("This\u2029 is a test".HasLineEndings());
+        }
+    }
+}

src/Ubiquity.NET.Extensions.UT/StringNormalizerTests.cs

@@ -44,7 +44,7 @@ public void Normalize_with_default_endings_does_nothing( )
         [TestMethod]
         public void Normalize_with_alternate_endings_produces_new_string( )
         {
-            string testInput = "This is a line"+ Environment.NewLine + "And so is this"; // Platform specific
+            string testInput = "This is a line" + Environment.NewLine + "And so is this"; // Platform specific
             const string expectedOutput = "This is a line\rAnd so is this";
 
             // CR Only is not the default for any currently supported runtime for .NET so this

src/Ubiquity.NET.Extensions/GlobalNamespaceImports.cs

@@ -26,10 +26,9 @@ set of namespaces that is NOT consistent or controlled by the developer. THAT is
 global using System.Diagnostics.CodeAnalysis;
 global using System.Globalization;
 global using System.IO;
-global using System.Linq;
 global using System.Reflection;
 global using System.Runtime.CompilerServices;
-global using System.Text;
+global using System.Text.RegularExpressions;
 global using System.Threading;
 
 global using Ubiquity.NET.Extensions.Properties;

src/Ubiquity.NET.Extensions/StringExtensions.cs

@@ -0,0 +1,74 @@
+// Copyright (c) Ubiquity.NET Contributors. All rights reserved.
+// Licensed under the Apache-2.0 WITH LLVM-exception license. See the LICENSE.md file in the project root for full license information.
+
+namespace Ubiquity.NET.Extensions
+{
+    /// <summary>Utility class to provide extensions for <see cref="string"/></summary>
+    public static partial class StringExtensions
+    {
+        /// <summary>Tests if a string contains any line endings</summary>
+        /// <param name="self">String to test</param>
+        /// <param name="skipUnicodeLineEndigs">Indicates whether additional Unicode line endings are considered [default: false]</param>
+        /// <returns><see langword="true"/> if the string contains any line endings</returns>
+        public static bool HasLineEndings( this string self, bool skipUnicodeLineEndigs = false )
+        {
+#if NETSTANDARD2_0
+            PolyFillExceptionValidators.ThrowIfNull(self);
+            return skipUnicodeLineEndigs
+                 ? PolyFillStringExtensions.SystemNewLinesRegex.IsMatch(self)
+                 : PolyFillStringExtensions.UnicodeNewLinesRegex.IsMatch(self);
+#else
+            ArgumentNullException.ThrowIfNull(self);
+            return skipUnicodeLineEndigs
+                 ? SystemNewLinesRegex.IsMatch(self)
+                 : UnicodeNewLinesRegex.IsMatch(self);
+#endif
+        }
+
+        // Since the poly fills are only applied for .NET Standard 2.0 this has to
+        // replicate the new line Regular expressions.
+#if !NETSTANDARD2_0
+        // The Unicode Standard, Sec. 5.8, Recommendation R4 and Table 5-2 state that the CR, LF,
+        // CRLF, NEL, LS, FF, and PS sequences are considered newline functions. That section
+        // also specifically excludes VT from the list of newline functions, so we do not include
+        // it in the regular expression match.
+
+        // language=regex
+        private const string UnicodeNewLinesRegExPattern = @"(\r\n|\r|\n|\f|\u0085|\u2028|\u2029)";
+
+        // language=regex
+        private const string SystemNewLinesRegExPattern = @"(\r\n|\r|\n)";
+
+    #if NET9_0_OR_GREATER
+            // Source generator for .NET 9+ understands properties directly
+            [GeneratedRegex( UnicodeNewLinesRegExPattern )]
+            internal static partial Regex UnicodeNewLinesRegEx { get; }
+
+            // Source generator for .NET 9+ understands properties directly
+            [GeneratedRegex( SystemNewLinesRegExPattern )]
+            internal static partial Regex SystemNewLinesRegEx { get; }
+    #else
+        // The generated method uses a static instance already, so
+        // this syntactic sugar should be aggressively inlined to
+        // avoid even tail-call overhead.
+        internal static Regex UnicodeNewLinesRegex
+        {
+            [MethodImpl( MethodImplOptions.AggressiveInlining )]
+            get => GetUnicodeNewLinesRegex();
+        }
+
+        [GeneratedRegex( UnicodeNewLinesRegExPattern )]
+        private static partial Regex GetUnicodeNewLinesRegex();
+
+        internal static Regex SystemNewLinesRegex
+        {
+            [MethodImpl( MethodImplOptions.AggressiveInlining )]
+            get => GetSystemNewLinesRegex();
+        }
+
+        [GeneratedRegex( SystemNewLinesRegExPattern )]
+        private static partial Regex GetSystemNewLinesRegex();
+    #endif
+#endif
+    }
+}

src/Ubiquity.NET.InteropHelpers/LazyEncodedString.cs

@@ -1,7 +1,5 @@
 // Copyright (c) Ubiquity.NET Contributors. All rights reserved.
 // Licensed under the Apache-2.0 WITH LLVM-exception license. See the LICENSE.md file in the project root for full license information.
-using System.Text;
-
 namespace Ubiquity.NET.InteropHelpers
 {
     /// <summary>Lazily encoded string with implicit casting to a read only span of bytes or a normal managed string</summary>

src/Ubiquity.NET.PollyFill.SharedSources/PolyFillOperatingSystem.cs

@@ -29,7 +29,7 @@ PlatformID.Win32NT or
         }
 
         // other forms of Is* are more difficult to poly fill as Linux, macOS, iOS, and android, are all apparently reported as PlatformId.Unix
-        // So they need to rely on additional native interop APIs for unix AND type name searches
+        // So they need to rely on additional native interop APIs for Unix AND type name searches
         // see: https://github.com/ryancheung/PlatformUtil/blob/master/PlatformUtil/PlatformInfo.cs
 #endif
     }

src/Ubiquity.NET.PollyFill.SharedSources/PolyFillStringExtensions.cs

@@ -67,7 +67,7 @@ public static string ReplaceLineEndings( this string self, string replacementTex
             global::System.PolyFillExceptionValidators.ThrowIfNull( self );
             global::System.PolyFillExceptionValidators.ThrowIfNull( replacementText );
 
-            string retVal = UnicodeNewLinesRegEx.Replace(self, replacementText);
+            string retVal = UnicodeNewLinesRegex.Replace(self, replacementText);
 
             // if the result of replacement is the same, just return the original
             // This is wasted overhead, but at least matches the behavior
@@ -82,11 +82,30 @@ public static string ReplaceLineEndings( this string self, string replacementTex
         // language=regex
         private const string UnicodeNewLinesRegExPattern = @"(\r\n|\r|\n|\f|\u0085|\u2028|\u2029)";
 
-        // NOTE: can't use source generated RegEx here as there's no way to declare the dependency on
+        // language=regex
+        private const string SystemNewLinesRegExPattern = @"(\r\n|\r|\n)";
+
+        // NOTE: can't use source generated Regex here as there's no way to declare the dependency on
         // the output of one generator as the input for another. They all see the same input, therefore
         // the partial implementation would never be filled in and produces a compilation error instead.
-        private static global::System.Text.RegularExpressions.Regex UnicodeNewLinesRegEx { get; }
-            = new global::System.Text.RegularExpressions.Regex( UnicodeNewLinesRegExPattern );
+        // Thus these use a lazy pattern to take the cost only once.
+        internal static global::System.Text.RegularExpressions.Regex UnicodeNewLinesRegex
+        {
+            [global::System.Runtime.CompilerServices.MethodImpl( global::System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining )]
+            get => LazyUnicodeNewLinesRegex.Value;
+        }
+
+        internal static global::System.Text.RegularExpressions.Regex SystemNewLinesRegex
+        {
+            [global::System.Runtime.CompilerServices.MethodImpl( global::System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining )]
+            get => LazySystemNewLinesRegex.Value;
+        }
+
+        private static global::System.Lazy<global::System.Text.RegularExpressions.Regex> LazyUnicodeNewLinesRegex
+            = new(() => new global::System.Text.RegularExpressions.Regex( UnicodeNewLinesRegExPattern ));
+
+        internal static global::System.Lazy<global::System.Text.RegularExpressions.Regex> LazySystemNewLinesRegex
+            = new(() => new global::System.Text.RegularExpressions.Regex( SystemNewLinesRegExPattern ));
 #endif
     }
 }