OutputTemplate -> ExpressionTemplate

Author: nblumhardt

README.md

@@ -12,7 +12,7 @@ dotnet add package Serilog.Expressions
 ```
 
 The package adds extension methods to Serilog's `Filter`, `WriteTo`, and 
-`Enrich` configuration objects, along with an `OutputTemplate`
+`Enrich` configuration objects, along with an `ExpressionTemplate`
 type that's compatible with Serilog sinks accepting an
 `ITextFormatter`.
 
@@ -81,12 +81,12 @@ _Serilog.Expressions_ adds a number of expression-based overloads and helper met
 
 ## Formatting
 
-_Serilog.Expressions_ includes the `OutputTemplate` class for text formatting. `OutputTemplate` implements `ITextFormatter`, so
+_Serilog.Expressions_ includes the `ExpressionTemplate` class for text formatting. `ExpressionTemplate` implements `ITextFormatter`, so
 it works with any text-based Serilog sink:
 
 ```csharp
 Log.Logger = new LoggerConfiguration()
-    .WriteTo.Console(new OutputTemplate(
+    .WriteTo.Console(new ExpressionTemplate(
         "[{@t:HH:mm:ss} {@l:u3} ({SourceContext})] {@m} (first item is {Items[0]})\n{@x}"))
     .CreateLogger();
 ```

example/Sample/Program.cs

@@ -19,7 +19,7 @@ public static void Main()
                 .Filter.ByIncludingOnly("@l = 'Information' and AppId is not null and Items[?] like 'C%'")
                 .WriteTo.Console(outputTemplate:
                     "[{Timestamp:HH:mm:ss} {Level:u3} ({SourceContext})] {Message:lj} (first item is {FirstItem}){NewLine}{Exception}")
-                .WriteTo.Console(new OutputTemplate(
+                .WriteTo.Console(new ExpressionTemplate(
                     "[{@t:HH:mm:ss} {@l:u3} ({SourceContext})] {@m} (first item is {Items[0]})\n{@x}"))
                     .CreateLogger();
 

src/Serilog.Expressions/Templates/OutputTemplate.cs renamed to src/Serilog.Expressions/Templates/ExpressionTemplate.cs

@@ -14,29 +14,29 @@ namespace Serilog.Templates
     /// <summary>
     /// Formats <see cref="LogEvent"/>s into text using embedded expressions.
     /// </summary>
-    public class OutputTemplate : ITextFormatter
+    public class ExpressionTemplate : ITextFormatter
     {
         readonly IFormatProvider? _formatProvider;
         readonly CompiledTemplate _compiled;
 
         /// <summary>
-        /// Construct an <see cref="OutputTemplate"/>.
+        /// Construct an <see cref="ExpressionTemplate"/>.
         /// </summary>
         /// <param name="template">The template text.</param>
         /// <param name="result">The parsed template, if successful.</param>
         /// <param name="error">A description of the error, if unsuccessful.</param>
         /// <returns><c langword="true">true</c> if the template was well-formed.</returns>
         public static bool TryParse(
             string template,
-            [MaybeNullWhen(false)] out OutputTemplate result,
+            [MaybeNullWhen(false)] out ExpressionTemplate result,
             [MaybeNullWhen(true)] out string error)
         {
             if (template == null) throw new ArgumentNullException(nameof(template));
             return TryParse(template, null, null, out result, out error);
         }
 
         /// <summary>
-        /// Construct an <see cref="OutputTemplate"/>.
+        /// Construct an <see cref="ExpressionTemplate"/>.
         /// </summary>
         /// <param name="template">The template text.</param>
         /// <param name="formatProvider">Optionally, an <see cref="IFormatProvider"/> to use when formatting
@@ -50,7 +50,7 @@ public static bool TryParse(
             string template,
             IFormatProvider? formatProvider,
             IEnumerable<NameResolver>? orderedResolvers,
-            [MaybeNullWhen(false)] out OutputTemplate result,
+            [MaybeNullWhen(false)] out ExpressionTemplate result,
             [MaybeNullWhen(true)] out string error)
         {
             if (template == null) throw new ArgumentNullException(nameof(template));
@@ -61,25 +61,25 @@ public static bool TryParse(
                 return false;
             }
 
-            result = new OutputTemplate(TemplateCompiler.Compile(parsed, DefaultFunctionNameResolver.Build(orderedResolvers)), formatProvider);
+            result = new ExpressionTemplate(TemplateCompiler.Compile(parsed, DefaultFunctionNameResolver.Build(orderedResolvers)), formatProvider);
             return true;
         }
 
-        OutputTemplate(CompiledTemplate compiled, IFormatProvider? formatProvider)
+        ExpressionTemplate(CompiledTemplate compiled, IFormatProvider? formatProvider)
         {
             _compiled = compiled;
             _formatProvider = formatProvider;
         }
 
         /// <summary>
-        /// Construct an <see cref="OutputTemplate"/>.
+        /// Construct an <see cref="ExpressionTemplate"/>.
         /// </summary>
         /// <param name="template">The template text.</param>
         /// <param name="formatProvider">Optionally, an <see cref="IFormatProvider"/> to use when formatting
         /// embedded values.</param>
         /// <param name="orderedResolvers">Optionally, an ordered list of <see cref="NameResolver"/>s
         /// from which to resolve function names that appear in the template.</param>
-        public OutputTemplate(
+        public ExpressionTemplate(
             string template,
             IFormatProvider? formatProvider = null,
             IEnumerable<NameResolver>? orderedResolvers = null)

test/Serilog.Expressions.Tests/TemplateEvaluationTests.cs

@@ -30,7 +30,7 @@ static IEnumerable<object[]> ReadCases(string filename)
         public void TemplatesAreCorrectlyEvaluated(string template, string expected)
         {
             var evt = Some.InformationEvent("Hello, {Name}!", "nblumhardt");
-            var compiled = new OutputTemplate(template);
+            var compiled = new ExpressionTemplate(template);
             var output = new StringWriter();
             compiled.Format(evt, output);
             var actual = output.ToString();

test/Serilog.Expressions.Tests/TemplateParserTests.cs

@@ -14,7 +14,7 @@ public class TemplateParserTests
         [InlineData("Syntax {1 + 2 and}or", "Invalid expression, unexpected `}`, expected expression.")]
         public void ErrorsAreReported(string input, string error)
         {
-            Assert.False(OutputTemplate.TryParse(input, null, null, out _, out var actual));
+            Assert.False(ExpressionTemplate.TryParse(input, null, null, out _, out var actual));
             Assert.Equal(error, actual);
         }
     }