(#140) Refactor

Author: colinangusmackay

src/Stravaig.Extensions.Logging.Diagnostics.Verify/LogEntryConverter.cs

@@ -16,55 +16,100 @@ public LogEntryConverter(Settings settings)
     {
         _settings = settings;
     }
-    
+
+    private class Context
+    {
+        internal Settings Settings { get; }
+        internal VerifyJsonWriter Writer { get; }
+        private int _sequence;
+        internal int CadenceOffset { get; set; }
+        
+        internal bool IsWritingSequence => Using(Settings.Sequence);
+        internal bool IsWritingLogLevel => Using(Settings.LogLevel);
+        internal bool IsWritingCategoryName => Using(Settings.CategoryName);
+        internal bool IsWritingFormattedMessage => Using(Settings.FormattedMessage);
+
+        internal int CurrentSequence(LogEntry logEntry) =>
+            Using(Settings.KeepSequenceCadence)
+                ? logEntry.Sequence - CadenceOffset
+                : _sequence; 
+
+        public Context(VerifyJsonWriter writer, Settings settings)
+        {
+            _sequence = 0;
+            Settings = settings;
+            Writer = writer;
+        }
+
+        internal void MoveToNextLogEntry()
+        {
+            _sequence++;
+        }
+        
+        private bool Using(Settings setting) => (Settings & setting) != 0;
+        
+    }
 
     public override void Write(VerifyJsonWriter writer, IEnumerable<LogEntry> logEntries)
     {
-        int sequence = 0;
-        int cadenceOffset = 0;
+        var ctx = new Context(writer, _settings);
         bool isFirst = true;
         writer.WriteStartArray();
         foreach (var logEntry in logEntries)
         {
             if (isFirst)
             {
-                cadenceOffset = logEntry.Sequence;
+                ctx.CadenceOffset = logEntry.Sequence;
                 isFirst = false;
             }
 
             writer.WriteStartObject();
 
-            if (_settings.WriteSequence())
-            {
-                writer.WritePropertyName(nameof(logEntry.Sequence));
-                if (_settings.Use(Settings.KeepSequenceCadence))
-                    writer.WriteValue(logEntry.Sequence - cadenceOffset);
-                else
-                    writer.WriteValue(sequence);
-            }
-
-            if (_settings.WriteLogLevel())
-            {
-                writer.WritePropertyName(nameof(logEntry.LogLevel));
-                writer.WriteValue(logEntry.LogLevel.ToString());
-            }
-
-            if (_settings.WriteCategoryName())
-            {
-                writer.WritePropertyName(nameof(logEntry.CategoryName));
-                writer.WriteValue(logEntry.CategoryName);
-            }
-
-            if (_settings.WriteFormattedMessage())
-            {
-                writer.WritePropertyName(nameof(logEntry.FormattedMessage));
-                writer.WriteValue(logEntry.FormattedMessage);
-            }
+            WriteSequence(ctx, logEntry);
+            WriteLogLevel(ctx, logEntry);
+            WriteCategoryName(ctx, logEntry);
+            WriteFormattedMessage(ctx, logEntry);
 
             writer.WriteEndObject();
-            sequence++;
+            ctx.MoveToNextLogEntry();
         }
 
         writer.WriteEndArray();
     }
+
+    private static void WriteFormattedMessage(Context ctx, LogEntry logEntry)
+    {
+        if (ctx.IsWritingFormattedMessage)
+        {
+            ctx.Writer.WritePropertyName(nameof(logEntry.FormattedMessage));
+            ctx.Writer.WriteValue(logEntry.FormattedMessage);
+        }
+    }
+
+    private static void WriteCategoryName(Context ctx, LogEntry logEntry)
+    {
+        if (ctx.IsWritingCategoryName)
+        {
+            ctx.Writer.WritePropertyName(nameof(logEntry.CategoryName));
+            ctx.Writer.WriteValue(logEntry.CategoryName);
+        }
+    }
+
+    private static void WriteLogLevel(Context ctx, LogEntry logEntry)
+    {
+        if (ctx.IsWritingLogLevel)
+        {
+            ctx.Writer.WritePropertyName(nameof(logEntry.LogLevel));
+            ctx.Writer.WriteValue(logEntry.LogLevel.ToString());
+        }
+    }
+
+    private static void WriteSequence(Context ctx, LogEntry logEntry)
+    {
+        if (ctx.IsWritingSequence)
+        {
+            ctx.Writer.WritePropertyName(nameof(logEntry.Sequence));
+            ctx.Writer.WriteValue(ctx.CurrentSequence(logEntry));
+        }
+    }
 }

src/Stravaig.Extensions.Logging.Diagnostics.Verify/Settings.cs

@@ -49,10 +49,5 @@ public enum Settings
 
 internal static class SettingsExtensions
 {
-    internal static bool Use(this Settings settings, Settings setting) => (settings & setting) != 0;
-
-    internal static bool WriteSequence(this Settings settings) => settings.Use(Settings.Sequence);
-    internal static bool WriteLogLevel(this Settings settings) => settings.Use(Settings.LogLevel);
-    internal static bool WriteCategoryName(this Settings settings) => settings.Use(Settings.CategoryName);
-    internal static bool WriteFormattedMessage(this Settings settings) => settings.Use(Settings.FormattedMessage);
+   
 }