WIP - Add Report() method to Settings

Fig.Core/CompositeSettingsDictionary.cs

@@ -1,3 +1,4 @@
+using System.Linq;
 using System;
 using System.Collections.Generic;
 using System.Text.RegularExpressions;
@@ -17,7 +18,10 @@ public CompositeSettingsDictionary()
             _dictionaries = new List<SettingsDictionary>();
         }
 
-        public void Add(SettingsDictionary settingsDictionary) 
+        public IEnumerable<string> Keys
+            => _dictionaries.Cast<IDictionary<string, string>>().SelectMany(d => d.Keys);
+
+        public void Add(SettingsDictionary settingsDictionary)
             => _dictionaries.Add(settingsDictionary);
 
         public bool TryGetValue(string key, string env, out string value)
@@ -37,7 +41,7 @@ public bool TryGetValue(string key, string env, out string value)
         }
 
         /// <summary>
-        /// Look for ${key} and replace with values from the dictionary 
+        /// Look for ${key} and replace with values from the dictionary
         /// </summary>
         /// <param name="template">The string to expand</param>
         /// <param name="configuration">A specific configuration to use if key is unqualified</param>
@@ -48,13 +52,15 @@ public string ExpandVariables(string template, string configuration = null)
             var regex = new Regex(pattern, RegexOptions.IgnoreCase | RegexOptions.CultureInvariant);
             return regex.Replace(template, m => GetCurrentEnvironment(m, configuration));
         }
+
         private string GetCurrentEnvironment(Match m, string configuration)
         {
-            var key = m.Groups["key"]. Value;
+            var key = m.Groups["key"].Value;
             var env = m.Groups["env"].Success ? m.Groups["env"].Value : configuration;
             TryGetValue(key, env, out var result);
             return result;
         }
+
         private bool ConcatIndices(SettingsDictionary sd, string key, out string value)
         {
             var indices = new List<string>();

Fig.Core/Fig.Core.csproj

@@ -17,4 +17,7 @@
   <ItemGroup>
     <None Remove="appsettings.json" />
   </ItemGroup>
+  <ItemGroup>
+    <PackageReference Include="ConsoleTables" Version="2.3.0" />
+  </ItemGroup>
 </Project>

Fig.Core/Settings.cs

@@ -1,9 +1,11 @@
+using System.Text;
 using System;
 using System.Collections.Generic;
 using System.ComponentModel;
 using System.Linq;
 using System.Reflection;
 using System.Runtime.CompilerServices;
+using ConsoleTables;
 
 namespace Fig
 {
@@ -105,6 +107,59 @@ public Settings(string bindingPath = null, IStringConverter converter = null)
             Environment = "";
         }
 
+        /// <summary>
+        /// Diagnostic report as string representation of current configuration and source for each property.
+        /// </summary>
+        public string Report()
+        {
+            var reportBuilder = new StringBuilder(
+                $"[{this.GetType().Name} Diagnostic Report]{System.Environment.NewLine}{System.Environment.NewLine}");
+            var keyTrackingValues = new Dictionary<string, (string, string)>();
+            var defaultKeyValuePair = new KeyValuePair<string, (string, string)>();
+
+            foreach (var k in SettingsDictionary.Keys)
+            {
+                var keyEnvironment = k.Contains(":")
+                    ? k.Split(':').Skip(1).LastOrDefault() ?? String.Empty
+                    : String.Empty;
+                var key = (keyEnvironment == String.Empty)
+                    ? k
+                    : k.Substring(0, k.Length - keyEnvironment.Length - 1);
+
+                if (SettingsDictionary.TryGetValue(key, Environment, out var value))
+                {
+                    var environment = (keyEnvironment == Environment) ? keyEnvironment : String.Empty;
+                    var foundKvp = keyTrackingValues.FirstOrDefault((_k) => _k.Key.ToUpper() == key.ToUpper());
+
+                    if (!foundKvp.Equals(defaultKeyValuePair))
+                    {
+                        var (trackedEnviroment, trackedValue) = foundKvp.Value;
+
+                        if (trackedEnviroment == String.Empty && environment != String.Empty)
+                        {
+                            keyTrackingValues[foundKvp.Key] = (environment, trackedValue);
+                        }
+
+                        continue;
+                    }
+
+                    keyTrackingValues.Add(key, (environment, value));
+                }
+            }
+
+            var table = new ConsoleTable("Key", "Value", "Enviroment");
+
+            foreach (var kvp in keyTrackingValues)
+            {
+                var (environment, value) = kvp.Value;
+                table.AddRow(kvp.Key, value, environment);
+            }
+
+            reportBuilder.Append(table.ToString());
+
+            return reportBuilder.ToString();
+        }
+
         private string GetBindingPath()
         {
             //Untyped Settings class should bind to the root of the tree

Fig.Tests/UntypedSettingsTests.cs

@@ -1,3 +1,5 @@
+using System.Linq;
+using System.Diagnostics;
 using System;
 using System.Collections.Generic;
 using NUnit.Framework;
@@ -75,5 +77,38 @@ public void DefaultKicksInWhenSettingsIsMissing()
             var actual = _settings.Get("missing", () => expected);
             Assert.AreEqual(actual, expected);
         }
+
+        [Test]
+        public void WhenReportReturnsValue()
+        {
+            var report = this._settings.Report();
+            var hasValue = !String.IsNullOrWhiteSpace(report);
+
+            Assert.IsTrue(hasValue);
+        }
+
+        [Test]
+        public void WhenEnvironmentAndReportReturnsValue()
+        {
+            _settings.SetEnvironment("test");
+            var report = this._settings.Report();
+            var hasValue = report
+                .Split(System.Environment.NewLine)
+                .Any(l => l.Contains("| a.b                  | a.b:test | test       |"));
+
+            Assert.IsTrue(hasValue);
+        }
+
+        [Test]
+        public void WhenNoEnvironmentAndReportReturnsValue()
+        {
+            var report = this._settings.Report();
+            var hasValue = report
+                .Split(System.Environment.NewLine)
+                .Any(l => l.Contains("| a.b                  | a.b      |            |"));
+
+            Assert.IsTrue(hasValue);
+        }
+
     }
 }