refactor: re-use original structure & method signatures

GerkinDev · GerkinDev · commit 6495d3ce2a2c · 2022-01-06T08:43:47.000+01:00
diff --git a/src/Serilog.Sinks.BrowserConsole/Sinks/BrowserConsole/Output/ConsoleArgBuilder.cs b/src/Serilog.Sinks.BrowserConsole/Sinks/BrowserConsole/Output/ConsoleArgBuilder.cs
diff --git a/src/Serilog.Sinks.BrowserConsole/Sinks/BrowserConsole/Output/EventPropertyTokenRenderer.cs b/src/Serilog.Sinks.BrowserConsole/Sinks/BrowserConsole/Output/EventPropertyTokenRenderer.cs
@@ -13,7 +13,6 @@
 // limitations under the License.
 
 using System;
-using System.Collections.Generic;
 using System.IO;
 using Serilog.Events;
 using Serilog.Parsing;
@@ -32,16 +31,14 @@ public EventPropertyTokenRenderer(PropertyToken token, IFormatProvider formatPro
             _formatProvider = formatProvider;
         }
 
-        public override IEnumerable<ConsoleArgBuilder> ConsoleArgs(LogEvent logEvent)
+        public override void Render(LogEvent logEvent, TokenEmitter emitToken)
         {
             // If a property is missing, don't render anything (message templates render the raw token here).
             if (!logEvent.Properties.TryGetValue(_token.PropertyName, out var propertyValue))
             {
                 if (_token.Alignment is not null)
-                {
-                    yield return ConsoleArgBuilder.Template(Padding.Apply(string.Empty, _token.Alignment));
-                }
-                yield break;
+                    emitToken(SConsoleToken.String(Padding.Apply(string.Empty, _token.Alignment)));
+                return;
             }
 
             var writer = new StringWriter();
@@ -60,9 +57,9 @@ public override IEnumerable<ConsoleArgBuilder> ConsoleArgs(LogEvent logEvent)
 
             var str = writer.ToString();
             if (_token.Alignment is not null)
-                yield return ConsoleArgBuilder.String(Padding.Apply(str, _token.Alignment));
+                emitToken(SConsoleToken.String(Padding.Apply(str, _token.Alignment)));
             else
-                yield return ConsoleArgBuilder.String(str);
+                emitToken(SConsoleToken.String(str));
         }
     }
 }
diff --git a/src/Serilog.Sinks.BrowserConsole/Sinks/BrowserConsole/Output/ExceptionTokenRenderer.cs b/src/Serilog.Sinks.BrowserConsole/Sinks/BrowserConsole/Output/ExceptionTokenRenderer.cs
@@ -20,10 +20,10 @@ namespace Serilog.Sinks.BrowserConsole.Output
 {
     class ExceptionTokenRenderer : OutputTemplateTokenRenderer
     {
-        public override IEnumerable<ConsoleArgBuilder> ConsoleArgs(LogEvent logEvent)
+        public override void Render(LogEvent logEvent, TokenEmitter emitToken)
         {
             if (logEvent.Exception is not null)
-                yield return ConsoleArgBuilder.String(logEvent.Exception.ToString());
+                emitToken(SConsoleToken.String(logEvent.Exception.ToString()));
         }
     }
 }
diff --git a/src/Serilog.Sinks.BrowserConsole/Sinks/BrowserConsole/Output/LevelTokenRenderer.cs b/src/Serilog.Sinks.BrowserConsole/Sinks/BrowserConsole/Output/LevelTokenRenderer.cs
@@ -15,7 +15,6 @@
 using Serilog.Events;
 using Serilog.Parsing;
 using Serilog.Sinks.BrowserConsole.Rendering;
-using System.Collections.Generic;
 
 namespace Serilog.Sinks.BrowserConsole.Output
 {
@@ -28,11 +27,11 @@ public LevelTokenRenderer(PropertyToken levelToken)
             _levelToken = levelToken;
         }
 
-        public override IEnumerable<ConsoleArgBuilder> ConsoleArgs(LogEvent logEvent)
+        public override void Render(LogEvent logEvent, TokenEmitter emitToken)
         {
             var moniker = LevelOutputFormat.GetLevelMoniker(logEvent.Level, _levelToken.Format);
             var alignedOutput = Padding.Apply(moniker, _levelToken.Alignment);
-            yield return ConsoleArgBuilder.String(alignedOutput);
+            emitToken(SConsoleToken.String(alignedOutput));
         }
     }
 }
diff --git a/src/Serilog.Sinks.BrowserConsole/Sinks/BrowserConsole/Output/MessageTemplateOutputTokenRenderer.cs b/src/Serilog.Sinks.BrowserConsole/Sinks/BrowserConsole/Output/MessageTemplateOutputTokenRenderer.cs
@@ -13,30 +13,25 @@
 // limitations under the License.
 
 using System;
-using System.Collections.Generic;
 using Serilog.Events;
 using Serilog.Parsing;
 
 namespace Serilog.Sinks.BrowserConsole.Output
 {
     class MessageTemplateOutputTokenRenderer : OutputTemplateTokenRenderer
     {
-        public override IEnumerable<ConsoleArgBuilder> ConsoleArgs(LogEvent logEvent)
+        public override void Render(LogEvent logEvent, TokenEmitter emitToken)
         {
             foreach (var token in logEvent.MessageTemplate.Tokens)
             {
                 switch (token)
                 {
                     case TextToken tt:
-                        foreach(var argBuilder in new TextTokenRenderer(tt.Text).ConsoleArgs(logEvent)){
-                            yield return argBuilder;
-                        }
+                        new TextTokenRenderer(tt.Text).Render(logEvent, emitToken);
                         break;
                     case PropertyToken pt:
                         if (logEvent.Properties.TryGetValue(pt.PropertyName, out var propertyValue))
-                        {
-                            yield return ConsoleArgBuilder.Object(propertyValue);
-                        }
+                            emitToken(SConsoleToken.Object(propertyValue));
                         break;
                     default:
                         throw new InvalidOperationException();
diff --git a/src/Serilog.Sinks.BrowserConsole/Sinks/BrowserConsole/Output/NewLineTokenRenderer.cs b/src/Serilog.Sinks.BrowserConsole/Sinks/BrowserConsole/Output/NewLineTokenRenderer.cs
@@ -13,7 +13,6 @@
 // limitations under the License.
 
 using System;
-using System.Collections.Generic;
 using Serilog.Events;
 using Serilog.Parsing;
 using Serilog.Sinks.BrowserConsole.Rendering;
@@ -29,12 +28,12 @@ public NewLineTokenRenderer(Alignment? alignment)
             _alignment = alignment;
         }
 
-        public override IEnumerable<ConsoleArgBuilder> ConsoleArgs(LogEvent logEvent)
+        public override void Render(LogEvent logEvent, TokenEmitter emitToken)
         {
             if (_alignment is not null)
-                yield return ConsoleArgBuilder.Template(Padding.Apply(Environment.NewLine, _alignment.Value.Widen(Environment.NewLine.Length)));
+                emitToken(SConsoleToken.Template(Padding.Apply(Environment.NewLine, _alignment.Value.Widen(Environment.NewLine.Length))));
             else
-                yield return ConsoleArgBuilder.Template(Environment.NewLine);
+                emitToken(SConsoleToken.Template(Environment.NewLine));
         }
     }
 }
diff --git a/src/Serilog.Sinks.BrowserConsole/Sinks/BrowserConsole/Output/OutputTemplateRenderer.cs b/src/Serilog.Sinks.BrowserConsole/Sinks/BrowserConsole/Output/OutputTemplateRenderer.cs
@@ -21,52 +21,54 @@ public OutputTemplateRenderer(string outputTemplate, IFormatProvider formatProvi
                 .SelectMany(token => token switch
                 {
                     TextToken tt => new[] { new TextTokenRenderer(tt.Text) },
-                    PropertyToken pt => WrapStyle(pt, tokenStyles, pt.PropertyName switch
-                    {
-                        OutputProperties.LevelPropertyName => new LevelTokenRenderer(pt),
-                        OutputProperties.NewLinePropertyName => new NewLineTokenRenderer(pt.Alignment),
-                        OutputProperties.ExceptionPropertyName => new ExceptionTokenRenderer(),
-                        OutputProperties.MessagePropertyName => new MessageTemplateOutputTokenRenderer(),
-                        OutputProperties.TimestampPropertyName => new TimestampTokenRenderer(pt, formatProvider),
-                        OutputProperties.PropertiesPropertyName => new PropertiesTokenRenderer(pt, template),
-                        _ => new EventPropertyTokenRenderer(pt, formatProvider)
-                    }),
+                    PropertyToken pt => WrapTokenStyle(
+                        tokenStyles.GetValueOrDefault(pt.PropertyName),
+                        pt.PropertyName switch
+                        {
+                            OutputProperties.LevelPropertyName => new LevelTokenRenderer(pt),
+                            OutputProperties.NewLinePropertyName => new NewLineTokenRenderer(pt.Alignment),
+                            OutputProperties.ExceptionPropertyName => new ExceptionTokenRenderer(),
+                            OutputProperties.MessagePropertyName => new MessageTemplateOutputTokenRenderer(),
+                            OutputProperties.TimestampPropertyName => new TimestampTokenRenderer(pt, formatProvider),
+                            OutputProperties.PropertiesPropertyName => new PropertiesTokenRenderer(pt, template),
+                            _ => new EventPropertyTokenRenderer(pt, formatProvider)
+                        }),
                     _ => throw new InvalidOperationException()
                 })
                 .ToArray();
         }
 
-        private IEnumerable<OutputTemplateTokenRenderer> WrapStyle(PropertyToken token, IReadOnlyDictionary<string, string> tokenStyles, OutputTemplateTokenRenderer renderer)
-        {
-            if (tokenStyles?.TryGetValue(token.PropertyName, out var style) ?? false)
-            {
-                return new[]
+        private static IEnumerable<OutputTemplateTokenRenderer> WrapTokenStyle(string style, OutputTemplateTokenRenderer renderer) =>
+            style != null ?
+                new[]
                 {
-                    new TextTokenRenderer($"<<{style}>>"),
-                    renderer,
-                    new TextTokenRenderer("<<_>>")
-                };
-            }
-            else
-            {
-                return new[] { renderer };
-            }
-        }
+                        new StyleTokenRenderer(style),
+                        renderer,
+                        new StyleTokenRenderer("")
+                } :
+                new[] { renderer };
 
         public object[] Format(LogEvent logEvent)
         {
             if (logEvent is null) throw new ArgumentNullException(nameof(logEvent));
 
-            var templateBuilder = new StringBuilder();
-            var buffer = new List<object>(_renderers.Length * 2);
+            var buffer = new List<SConsoleToken>(_renderers.Length * 2);
             foreach (var renderer in _renderers)
             {
-                foreach (var consoleToken in renderer.ConsoleArgs(logEvent))
+                renderer.Render(logEvent, buffer.Add);
+            }
+
+            var templateBuilder = new StringBuilder();
+            var argsList = new List<object>(buffer.Count);
+            foreach (var token in buffer)
+            {
+                templateBuilder.Append(token.TemplateStr);
+                if (token.Arg is not null)
                 {
-                    consoleToken.Render(templateBuilder, buffer.Add);
+                    argsList.Add(token.Arg.Value);
                 }
             }
-            return buffer.Prepend(templateBuilder.ToString()).ToArray();
+            return new object[] { templateBuilder.ToString() }.Concat(argsList).ToArray();
         }
     }
 }
diff --git a/src/Serilog.Sinks.BrowserConsole/Sinks/BrowserConsole/Output/OutputTemplateTokenRenderer.cs b/src/Serilog.Sinks.BrowserConsole/Sinks/BrowserConsole/Output/OutputTemplateTokenRenderer.cs
@@ -13,14 +13,13 @@
 // limitations under the License.
 
 using Serilog.Events;
-using System.Collections.Generic;
 
 namespace Serilog.Sinks.BrowserConsole.Output
 {
-    delegate void TokenEmitter(object token);
+    delegate void TokenEmitter(SConsoleToken token);
     
     abstract class OutputTemplateTokenRenderer
     {
-        public abstract IEnumerable<ConsoleArgBuilder> ConsoleArgs(LogEvent logEvent);
+        public abstract void Render(LogEvent logEvent, TokenEmitter emitToken);
     }
 }
diff --git a/src/Serilog.Sinks.BrowserConsole/Sinks/BrowserConsole/Output/PropertiesTokenRenderer.cs b/src/Serilog.Sinks.BrowserConsole/Sinks/BrowserConsole/Output/PropertiesTokenRenderer.cs
@@ -12,7 +12,6 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-using System.Collections.Generic;
 using System.Linq;
 using Serilog.Events;
 using Serilog.Parsing;
@@ -29,7 +28,7 @@ public PropertiesTokenRenderer(PropertyToken token, MessageTemplate outputTempla
             _token = token;
         }
 
-        public override IEnumerable<ConsoleArgBuilder> ConsoleArgs(LogEvent logEvent)
+        public override void Render(LogEvent logEvent, TokenEmitter emitToken)
         {
             var included = logEvent.Properties
                 .Where(p => !TemplateContainsPropertyName(logEvent.MessageTemplate, p.Key) &&
@@ -38,7 +37,7 @@ public override IEnumerable<ConsoleArgBuilder> ConsoleArgs(LogEvent logEvent)
 
             foreach (var property in included)
             {
-                yield return ConsoleArgBuilder.Object(property.Value, _token.Format);
+                emitToken(SConsoleToken.Object(property.Value, _token.Format));
             }
         }
 
diff --git a/src/Serilog.Sinks.BrowserConsole/Sinks/BrowserConsole/Output/SConsoleToken.cs b/src/Serilog.Sinks.BrowserConsole/Sinks/BrowserConsole/Output/SConsoleToken.cs
@@ -0,0 +1,23 @@
+﻿using Serilog.Events;
+
+namespace Serilog.Sinks.BrowserConsole.Output
+{
+    /// <summary>
+    /// Used to generate `console.log` arguments.
+    /// </summary>
+    internal struct SConsoleToken
+    {
+        public SConsoleToken(string templateStr, ScalarValue arg = null)
+        {
+            TemplateStr = templateStr;
+            Arg = arg;
+        }
+        public string TemplateStr { get; init; }
+        public ScalarValue Arg { get; init; }
+
+        public static SConsoleToken Style(string style) => new("%c", new ScalarValue(style));
+        public static SConsoleToken Template(string rawText) => new(rawText.Replace("%", "%%"));
+        public static SConsoleToken String(string @string) => new("%s", new ScalarValue(@string));
+        public static SConsoleToken Object(LogEventPropertyValue value, string format = default) => new("%o", new ScalarValue(ObjectModelInterop.ToInteropValue(value, format)));
+    }
+}
diff --git a/src/Serilog.Sinks.BrowserConsole/Sinks/BrowserConsole/Output/StyleTokenRenderer .cs b/src/Serilog.Sinks.BrowserConsole/Sinks/BrowserConsole/Output/StyleTokenRenderer .cs
diff --git a/src/Serilog.Sinks.BrowserConsole/Sinks/BrowserConsole/Output/TextTokenRenderer.cs b/src/Serilog.Sinks.BrowserConsole/Sinks/BrowserConsole/Output/TextTokenRenderer.cs
diff --git a/src/Serilog.Sinks.BrowserConsole/Sinks/BrowserConsole/Output/TimestampTokenRenderer.cs b/src/Serilog.Sinks.BrowserConsole/Sinks/BrowserConsole/Output/TimestampTokenRenderer.cs

Original file line number	Diff line number	Diff line change
`@@ -13,7 +13,6 @@`
`13`	`13`	`// limitations under the License.`
`14`	`14`
`15`	`15`	`using System;`
`16`		`-using System.Collections.Generic;`
`17`	`16`	`using System.IO;`
`18`	`17`	`using Serilog.Events;`
`19`	`18`	`using Serilog.Parsing;`
`@@ -32,16 +31,14 @@ public EventPropertyTokenRenderer(PropertyToken token, IFormatProvider formatPro`
`32`	`31`	`_formatProvider = formatProvider;`
`33`	`32`	`}`
`34`	`33`
`35`		`- public override IEnumerable<ConsoleArgBuilder> ConsoleArgs(LogEvent logEvent)`
	`34`	`+ public override void Render(LogEvent logEvent, TokenEmitter emitToken)`
`36`	`35`	`{`
`37`	`36`	`// If a property is missing, don't render anything (message templates render the raw token here).`
`38`	`37`	`if (!logEvent.Properties.TryGetValue(_token.PropertyName, out var propertyValue))`
`39`	`38`	`{`
`40`	`39`	`if (_token.Alignment is not null)`
`41`		`- {`
`42`		`- yield return ConsoleArgBuilder.Template(Padding.Apply(string.Empty, _token.Alignment));`
`43`		`- }`
`44`		`- yield break;`
	`40`	`+ emitToken(SConsoleToken.String(Padding.Apply(string.Empty, _token.Alignment)));`
	`41`	`+ return;`
`45`	`42`	`}`
`46`	`43`
`47`	`44`	`var writer = new StringWriter();`
`@@ -60,9 +57,9 @@ public override IEnumerable<ConsoleArgBuilder> ConsoleArgs(LogEvent logEvent)`
`60`	`57`
`61`	`58`	`var str = writer.ToString();`
`62`	`59`	`if (_token.Alignment is not null)`
`63`		`- yield return ConsoleArgBuilder.String(Padding.Apply(str, _token.Alignment));`
	`60`	`+ emitToken(SConsoleToken.String(Padding.Apply(str, _token.Alignment)));`
`64`	`61`	`else`
`65`		`- yield return ConsoleArgBuilder.String(str);`
	`62`	`+ emitToken(SConsoleToken.String(str));`
`66`	`63`	`}`
`67`	`64`	`}`
`68`	`65`	`}`
Original file line number	Diff line number	Diff line change
`@@ -20,10 +20,10 @@ namespace Serilog.Sinks.BrowserConsole.Output`
`20`	`20`	`{`
`21`	`21`	`class ExceptionTokenRenderer : OutputTemplateTokenRenderer`
`22`	`22`	`{`
`23`		`- public override IEnumerable<ConsoleArgBuilder> ConsoleArgs(LogEvent logEvent)`
	`23`	`+ public override void Render(LogEvent logEvent, TokenEmitter emitToken)`
`24`	`24`	`{`
`25`	`25`	`if (logEvent.Exception is not null)`
`26`		`- yield return ConsoleArgBuilder.String(logEvent.Exception.ToString());`
	`26`	`+ emitToken(SConsoleToken.String(logEvent.Exception.ToString()));`
`27`	`27`	`}`
`28`	`28`	`}`
`29`	`29`	`}`
Original file line number	Diff line number	Diff line change
`@@ -15,7 +15,6 @@`
`15`	`15`	`using Serilog.Events;`
`16`	`16`	`using Serilog.Parsing;`
`17`	`17`	`using Serilog.Sinks.BrowserConsole.Rendering;`
`18`		`-using System.Collections.Generic;`
`19`	`18`
`20`	`19`	`namespace Serilog.Sinks.BrowserConsole.Output`
`21`	`20`	`{`
`@@ -28,11 +27,11 @@ public LevelTokenRenderer(PropertyToken levelToken)`
`28`	`27`	`_levelToken = levelToken;`
`29`	`28`	`}`
`30`	`29`
`31`		`- public override IEnumerable<ConsoleArgBuilder> ConsoleArgs(LogEvent logEvent)`
	`30`	`+ public override void Render(LogEvent logEvent, TokenEmitter emitToken)`
`32`	`31`	`{`
`33`	`32`	`var moniker = LevelOutputFormat.GetLevelMoniker(logEvent.Level, _levelToken.Format);`
`34`	`33`	`var alignedOutput = Padding.Apply(moniker, _levelToken.Alignment);`
`35`		`- yield return ConsoleArgBuilder.String(alignedOutput);`
	`34`	`+ emitToken(SConsoleToken.String(alignedOutput));`
`36`	`35`	`}`
`37`	`36`	`}`
`38`	`37`	`}`
Original file line number	Diff line number	Diff line change
`@@ -13,14 +13,13 @@`
`13`	`13`	`// limitations under the License.`
`14`	`14`
`15`	`15`	`using Serilog.Events;`
`16`		`-using System.Collections.Generic;`
`17`	`16`
`18`	`17`	`namespace Serilog.Sinks.BrowserConsole.Output`
`19`	`18`	`{`
`20`		`- delegate void TokenEmitter(object token);`
	`19`	`+ delegate void TokenEmitter(SConsoleToken token);`
`21`	`20`
`22`	`21`	`abstract class OutputTemplateTokenRenderer`
`23`	`22`	`{`
`24`		`- public abstract IEnumerable<ConsoleArgBuilder> ConsoleArgs(LogEvent logEvent);`
	`23`	`+ public abstract void Render(LogEvent logEvent, TokenEmitter emitToken);`
`25`	`24`	`}`
`26`	`25`	`}`
Original file line number	Diff line number	Diff line change
`@@ -12,7 +12,6 @@`
`12`	`12`	`// See the License for the specific language governing permissions and`
`13`	`13`	`// limitations under the License.`
`14`	`14`
`15`		`-using System.Collections.Generic;`
`16`	`15`	`using System.Linq;`
`17`	`16`	`using Serilog.Events;`
`18`	`17`	`using Serilog.Parsing;`
`@@ -29,7 +28,7 @@ public PropertiesTokenRenderer(PropertyToken token, MessageTemplate outputTempla`
`29`	`28`	`_token = token;`
`30`	`29`	`}`
`31`	`30`
`32`		`- public override IEnumerable<ConsoleArgBuilder> ConsoleArgs(LogEvent logEvent)`
	`31`	`+ public override void Render(LogEvent logEvent, TokenEmitter emitToken)`
`33`	`32`	`{`
`34`	`33`	`var included = logEvent.Properties`
`35`	`34`	`.Where(p => !TemplateContainsPropertyName(logEvent.MessageTemplate, p.Key) &&`
`@@ -38,7 +37,7 @@ public override IEnumerable<ConsoleArgBuilder> ConsoleArgs(LogEvent logEvent)`
`38`	`37`
`39`	`38`	`foreach (var property in included)`
`40`	`39`	`{`
`41`		`- yield return ConsoleArgBuilder.Object(property.Value, _token.Format);`
	`40`	`+ emitToken(SConsoleToken.Object(property.Value, _token.Format));`
`42`	`41`	`}`
`43`	`42`	`}`
`44`	`43`