removed need for nesting in public api

Author: Erwinvandervalk

README.md

@@ -26,18 +26,21 @@ Another example is when accessing an URL from code, where the URL is usually com
 
     using TemplatedConfiguration;
 
-    /* ... */
+    /* snip ... */
 
         var config = new ConfigurationBuilder()
-            .WithRecursiveTemplateSupport(
+                // First set up defaults, for example using in memory
+                .AddInMemoryCollection(Global.DefaultSettings)
+
+                // Then set up the 'overrides'. 
+                .AddIniFile("Config.ini")
+                .AddCommandLine(args)
+                .AddEnvironmentVariables()
+
                 // Wrap the configuration providers with the provider that supports templating
-                builder => builder
-                    // First set up defaults
-                    // Then set up the 'overrides'. 
-                    .AddIniFile("Config.ini")
-                    .AddCommandLine(args)
-                    .AddEnvironmentVariables()
-                )
+                .WithRecursiveTemplateSupport()
+
+                // Any provider added after this will NOT partake in the templating. 
             .Build();
 ```
 

src/TemplatedConfiguration.Example/Program.cs

@@ -9,20 +9,19 @@ class Program
         static void Main(string[] args)
         {
             var config = new ConfigurationBuilder()
-                .WithRecursiveTemplateSupport(
+                // First set up defaults
+                .AddInMemoryCollection(Global.DefaultSettings)
+                .AddInMemoryCollection(ComponentA.DefaultSettings)
+                .AddInMemoryCollection(ComponentB.DefaultSettings)
 
-                    // Wrap the configuration providers with the provider that supports templating
-                    builder => builder
-                        // First set up defaults
-                        .AddInMemoryCollection(Global.DefaultSettings)
-                        .AddInMemoryCollection(ComponentA.DefaultSettings)
-                        .AddInMemoryCollection(ComponentB.DefaultSettings)
+                // Then set up the 'overrides'. 
+                .AddIniFile("Config.ini")
+                .AddCommandLine(args)
+                .AddEnvironmentVariables()
+
+                // Wrap the configuration providers with the provider that supports templating
+                .WithRecursiveTemplateSupport()
 
-                        // Then set up the 'overrides'. 
-                        .AddIniFile("Config.ini")
-                        .AddCommandLine(args)
-                        .AddEnvironmentVariables()
-                    )
                 .Build();
 
             Console.WriteLine("Component A: Connection String: " +config.GetValue<string>("ComponentA.ConnectionString"));

src/TemplatedConfiguration.Tests/TemplatedConfigurationSourceTests.cs

@@ -6,11 +6,27 @@ namespace TemplatedConfiguration.Tests
 {
     public class TemplatedConfigurationSourceTests
     {
-        private readonly IConfigurationRoot _configurationRoot;
 
         public TemplatedConfigurationSourceTests()
         {
-            _configurationRoot = new ConfigurationBuilder()
+
+        }
+
+        [Theory]
+        [InlineData("SettingWithoutTemplate")] // Correctly cased
+        [InlineData("settingwithouttemplate")] // Proves Case Insensititivity
+        public void Can_get_value_without_template(string key)
+        {
+            var configurationRoot = BuildConfigurationRootWithoutRebuilding();
+
+            var result = configurationRoot.GetValue<string>(key);
+
+            Assert.Equal("normal value", result);
+        }
+
+        private static IConfigurationRoot BuildConfigurationRootWithoutRebuilding()
+        {
+            var configurationRoot = new ConfigurationBuilder()
                 .WithRecursiveTemplateSupport(
                     builder => builder
                         .AddInMemoryCollection(new Dictionary<string, string>
@@ -25,37 +41,81 @@ public TemplatedConfigurationSourceTests()
                             {"Recursive", "this is {Recursive}"},
                         })
                 ).Build();
+            return configurationRoot;
         }
 
 
         [Theory]
-        [InlineData("SettingWithoutTemplate")] // Correctly cased
-        [InlineData("settingwithouttemplate")] // Proves Case Insensititivity
-        public void Can_get_value_without_template(string key)
+        [InlineData("TemplatedSetting")] // Correctly cased
+        [InlineData("templatedsetting")] // Proves Case Insensititivity on root template name
+        [InlineData("CaseInsensitiveSetting")] // Proves Case Insensititivity on recursive template
+        public void Can_get_templated_default_value(string key)
         {
-            var result = _configurationRoot.GetValue<string>(key);
+            var configurationRoot = BuildConfigurationRootWithoutRebuilding();
+            var result = configurationRoot.GetValue<string>(key);
 
-            Assert.Equal("normal value", result);
+            Assert.Equal("this comes from the default setting: '[default value]'", result);
         }
 
+        [Fact]
+        public void Can_handle_loops_in_recursion()
+        {
+            var configurationRoot = BuildConfigurationRootWithoutRebuilding();
+            var result = configurationRoot.GetValue<string>("Recursive");
+
+            Assert.Equal("this is {Recursive}", result);
+        }
 
         [Theory]
         [InlineData("TemplatedSetting")] // Correctly cased
         [InlineData("templatedsetting")] // Proves Case Insensititivity on root template name
         [InlineData("CaseInsensitiveSetting")] // Proves Case Insensititivity on recursive template
-        public void Can_get_templated_default_value(string key)
+        public void Can_add_templated_configuration_without_subbuilder(string key)
         {
-            var result = _configurationRoot.GetValue<string>(key);
+            var configurationRoot = new ConfigurationBuilder()
+                .AddInMemoryCollection(new Dictionary<string, string>
+                {
+                    {"SettingWithoutTemplate", "normal value"},
+                    {"DefaultSetting", "[default value]"},
+                })
+                .AddInMemoryCollection(new Dictionary<string, string>
+                {
+                    {"TemplatedSetting", "this comes from the default setting: '{DefaultSetting}'"},
+                    {"CaseInsensitiveSetting", "this comes from the default setting: '{defaultsetting}'"},
+                    {"Recursive", "this is {Recursive}"},
+                })
+                .WithRecursiveTemplateSupport()
+                .Build();
+
+            var result = configurationRoot.GetValue<string>(key);
 
             Assert.Equal("this comes from the default setting: '[default value]'", result);
+
         }
 
         [Fact]
-        public void Can_handle_loops_in_recursion()
+        public void Build_is_only_called_once_on_source()
         {
-            var result = _configurationRoot.GetValue<string>("Recursive");
+            var fakeConfigSource = new FakeConfigSource();
+            var configurationRoot = new ConfigurationBuilder()
+                .Add(fakeConfigSource)
+                .WithRecursiveTemplateSupport()
+                .Build();
 
-            Assert.Equal("this is {Recursive}", result);
+            Assert.Equal(1, fakeConfigSource.BuildCount);
+
+        }
+
+        private class FakeConfigSource : IConfigurationSource
+        {
+            public int BuildCount = 0;
+
+            public IConfigurationProvider Build(IConfigurationBuilder builder)
+            {
+                BuildCount++;
+                return new FakeConfigurationProvider();
+            }
         }
+        private class FakeConfigurationProvider : ConfigurationProvider { }
     }
 }

src/TemplatedConfiguration/IConfigurationBuidlerExtensions.cs

@@ -10,5 +10,11 @@ public static IConfigurationBuilder WithRecursiveTemplateSupport(this IConfigura
             builder.Add(new TemplatedConfigurationSource(configurer));
             return builder;
         }
+
+        public static IConfigurationBuilder WithRecursiveTemplateSupport(this IConfigurationBuilder builder)
+        {
+            builder.Add(new TemplatedConfigurationSource(builder));
+            return builder;
+        }
     }
 }

src/TemplatedConfiguration/TemplatedConfiguration.csproj

@@ -2,6 +2,7 @@
 
   <PropertyGroup>
     <TargetFramework>netstandard2.0</TargetFramework>
+    <Version>0.1.0</Version>
   </PropertyGroup>
 
   <ItemGroup>

src/TemplatedConfiguration/TemplatedConfigurationProvider.cs

@@ -34,15 +34,15 @@ public static string Replace(this string str, string oldValue, string newValue,
     public class TemplatedConfigurationProvider : IConfigurationProvider
     {
         private static readonly Regex _regex = new Regex(@"(\{[\w,\-,\.]*\})", RegexOptions.Compiled);
-        private readonly IConfigurationRoot _source;
+        public readonly IConfigurationRoot InnerConfiguration;
 
         /// <summary>Initialize a new instance from the source.</summary>
-        /// <param name="source">The source settings.</param>
-        public TemplatedConfigurationProvider(IConfigurationRoot source)
+        /// <param name="innerConfiguration">The source settings.</param>
+        public TemplatedConfigurationProvider(IConfigurationRoot innerConfiguration)
         {
-            if (source == null)
-                throw new ArgumentNullException(nameof(source));
-            _source = source;
+            if (innerConfiguration == null)
+                throw new ArgumentNullException(nameof(innerConfiguration));
+            InnerConfiguration = innerConfiguration;
         }
 
         public bool TryGet(string key, out string value)
@@ -52,7 +52,7 @@ public bool TryGet(string key, out string value)
 
         private bool TryGetInternal(TemplatedSettingKey key, HashSet<TemplatedSettingKey> visited, out string value)
         {
-            value = _source[key.Name];
+            value = InnerConfiguration[key.Name];
             if (value == null)
                 return false;
 
@@ -82,22 +82,22 @@ private bool TryGetInternal(TemplatedSettingKey key, HashSet<TemplatedSettingKey
 
         public void Set(string key, string value)
         {
-            _source[key] = value;
+            InnerConfiguration[key] = value;
         }
 
         public IChangeToken GetReloadToken()
         {
-            return _source.GetReloadToken();
+            return InnerConfiguration.GetReloadToken();
         }
 
         public void Load()
         {
-            _source.Reload();
+            InnerConfiguration.Reload();
         }
 
         public IEnumerable<string> GetChildKeys(IEnumerable<string> earlierKeys, string path)
         {
-            return _source.Providers.Aggregate(Enumerable.Empty<string>(),
+            return InnerConfiguration.Providers.Aggregate(Enumerable.Empty<string>(),
                 (seed, source) =>
                     source.GetChildKeys(seed, path)).Distinct().Select(
                 key =>

src/TemplatedConfiguration/TemplatedConfigurationSource.cs

@@ -1,32 +1,65 @@
 using System;
+using System.Collections.Generic;
+using System.Linq;
 using Microsoft.Extensions.Configuration;
 
 namespace TemplatedConfiguration
 {
     public class TemplatedConfigurationSource : IConfigurationSource
     {
-        private readonly IConfigurationRoot _config;
+        private readonly ConfigurationBuilder _innerConfigurationBuilder;
 
-        public TemplatedConfigurationSource(Action<IConfigurationBuilder> configurer) : this(BuildConfigurationRoot(configurer))
+        public TemplatedConfigurationSource(IConfigurationBuilder builder)
         {
+            _innerConfigurationBuilder = new ConfigurationBuilder();
+            for (int i = 0; i < builder.Sources.Count; i++)
+            {
+                var source = builder.Sources[i];
+                if (source == this)
+                {
+                    // We only care about providers before this provider. So stop looking after we've found it. 
+                    break;
+                }
+                
+                // We wrap the providerSource into a proxied provider source, that caches the built output, so that we don't build 'twice'. 
+                var proxiedSource = new ProxiedProviderSource(source);
+                builder.Sources[i] = proxiedSource;
+                _innerConfigurationBuilder.Add(proxiedSource);
+            }
+        }
 
+        public TemplatedConfigurationSource(Action<IConfigurationBuilder> configurer)
+        {
+            _innerConfigurationBuilder = new ConfigurationBuilder();
+            configurer(_innerConfigurationBuilder);
         }
 
-        private static IConfigurationRoot BuildConfigurationRoot(Action<IConfigurationBuilder> configurerer)
+
+        public IConfigurationProvider Build(IConfigurationBuilder builder)
         {
-            var builder = new ConfigurationBuilder();
-            configurerer(builder);
-            return builder.Build();
+             return new TemplatedConfigurationProvider(_innerConfigurationBuilder.Build());
         }
+    }
 
-        public TemplatedConfigurationSource(IConfigurationRoot config)
+    internal class ProxiedProviderSource : IConfigurationSource
+    {
+        private readonly IConfigurationSource _source;
+
+        private IConfigurationProvider _provider;
+
+        public ProxiedProviderSource(IConfigurationSource source)
         {
-            _config = config;
+            _source = source;
         }
 
         public IConfigurationProvider Build(IConfigurationBuilder builder)
         {
-            return new TemplatedConfigurationProvider(_config);
+            if (_provider != null)
+                return _provider;
+
+            return _provider = _source.Build(builder);
         }
     }
+
+
 }