Feature/Unicode escape support

src/SmartFormat.Tests/Core/LiteralTextTests.cs

@@ -18,31 +18,31 @@ public class LiteralTextTests
         public void FormatCharacterLiteralsAsString()
         {
             const string formatWithFileBehavior = @"No carriage return\r, no line feed\n";
-            const string formatWithCodeBahavior = "With carriage return\r, and with line feed\n";
+            const string formatWithCodeBehavior = "With carriage return\r, and with line feed\n";
 
             var formatter = Smart.CreateDefaultSmartFormat();
             formatter.Settings.ConvertCharacterStringLiterals = false;
 
             var result = formatter.Format(formatWithFileBehavior);
             Assert.AreEqual(string.Format(formatWithFileBehavior), result);
 
-            result = formatter.Format(formatWithCodeBahavior);
-            Assert.AreEqual(string.Format(formatWithCodeBahavior), result);
+            result = formatter.Format(formatWithCodeBehavior);
+            Assert.AreEqual(string.Format(formatWithCodeBehavior), result);
         }
 
         [Test]
         public void AllSupportedCharacterLiteralsAsUnicode()
         {
             var data = new Dictionary<string, string> { { "key", "value" } };
 
-            const string formatWithFileBehavior = @"All supported literal characters: \' \"" \\ \a \b \f \n \r \t \v {key}\0!";
-            const string formatWithCodeBahavior = "All supported literal characters: \' \" \\ \a \b \f \n \r \t \v {key}\0!";
+            const string formatWithFileBehavior = @"All supported literal characters: \' \"" \\ \a \b \f \n \r \t \v \u2022 {key}\0!";
+            const string formatWithCodeBehavior = "All supported literal characters: \' \" \\ \a \b \f \n \r \t \v \u2022 {key}\0!";
 
             var formatter = Smart.CreateDefaultSmartFormat();
             formatter.Settings.ConvertCharacterStringLiterals = true;
 
             var result = formatter.Format(formatWithFileBehavior, data);
-            Assert.AreEqual(string.Format(formatWithCodeBahavior.Replace("{"+ data.First().Key +"}", data.First().Value)), result);
+            Assert.AreEqual(string.Format(formatWithCodeBehavior.Replace("{"+ data.First().Key +"}", data.First().Value)), result);
         }
 
         [Test]
@@ -63,15 +63,15 @@ public void IllegalEscapeSequenceThrowsException()
             Smart.Default.Settings.ConvertCharacterStringLiterals = true;
 
             Assert.Throws<ArgumentException>(() => {
-                Smart.Default.Format(@"Illegal excape sequence at end of line = \z");
+                Smart.Default.Format(@"Illegal escape sequence at end of line = \z");
             });
 
             Assert.Throws<ArgumentException>(() => {
-                Smart.Default.Format(@"Illegal excape sequence \z somewhere in text");
+                Smart.Default.Format(@"Illegal escape sequence \z somewhere in text");
             });
 
             Assert.Throws<ArgumentException>(() => {
-                Smart.Default.Format(@"Illegal excape sequences at end of line = \");
+                Smart.Default.Format(@"Illegal escape sequences at end of line = \");
             });
 
             Smart.Default.Settings.ConvertCharacterStringLiterals = false;

src/SmartFormat/Core/Parsing/LiteralText.cs

@@ -4,6 +4,7 @@
 //
 
 using System;
+using System.Globalization;
 using SmartFormat.Core.Settings;
 
 namespace SmartFormat.Core.Parsing
@@ -39,7 +40,7 @@ private string ConvertCharacterLiteralsToUnicode()
             if (source[0] != Parser.CharLiteralEscapeChar)
                 return source;
 
-            // The string length should be 2: espace character \ and literal character
+            // The string length should be 2: escape character \ and literal character
             if (source.Length < 2) throw new ArgumentException($"Missing escape sequence in literal: \"{source}\"");
 
             char c;
@@ -78,6 +79,11 @@ private string ConvertCharacterLiteralsToUnicode()
                 case 'v':
                     c = '\v';
                     break;
+                case 'u':
+                    if (!int.TryParse(source.Substring(2, source.Length - 2), NumberStyles.HexNumber, null, out var result))
+                        throw new ArgumentException($"Failed to parse unicode escape sequence in literal: \"{source}\"");
+                    c = (char) result;
+                    break;
                 default:
                     throw new ArgumentException($"Unrecognized escape sequence in literal: \"{source}\"");
             }

src/SmartFormat/Core/Parsing/Parser.cs

@@ -280,7 +280,13 @@ public Format ParseFormat(string format, string[] formatterExtensionNames)
 
                             // Finish the last text item:
                             if (i != lastI) current.Items.Add(new LiteralText(Settings, current, lastI) {endIndex = i});
-                            lastI = i + 2;
+
+                            // Is this a unicode escape sequence?
+                            if (i + 1 < format.Length && format[i + 1] == 'u')
+                                lastI = i + 6; // \u0000 format
+                            else
+                                lastI = i + 2;
+
                             if (lastI > length) lastI = length;
 
                             // Next add the character literal INCLUDING the escape character, which LiteralText will expect