Don't lose case in Greedy substitutions. (#91)

Author: StephenMolloy

README.md

@@ -298,6 +298,7 @@ public class MySpecialSectionHandler : SectionHandler<MySpecialSection>
 {
     // T ConfigSection;
     // public override void Initialize(string name, NameValueCollection config) {}
+	// public override string TryGetOriginalCase(string requestedKey) {}
 
     public override IEnumerator<KeyValuePair<string, object>> GetEnumerator() {}
 
@@ -306,7 +307,7 @@ public class MySpecialSectionHandler : SectionHandler<MySpecialSection>
 ```
 Keep in mind when implementing a section handler, that `InsertOrUpdate()` will be called while iterating over the enumerator
 supplied by `GetEnumerator()`. So the two methods must work in cooperation to make sure that the enumerator does not get confused
-while iterating.
+while iterating. Ie, don't tamper with the collection that the enumerator is iterating over.
 
 A section handler is free to interpret the structure of a `ConfigurationSection` in any way it sees fit, so long it can be exposed as an
 enumerable list of key/value things. The 'value' side of that pair doesn't even have to be a string. Consider the implementation of
@@ -318,6 +319,12 @@ New section handlers can be introduced to the config system... via config. Secti
 provider model introduced in .Net 2.0, so they require `name` and `type` attributes, but can additionally support any other
 attribute needed by passing them in a `NameValueCollection` to the `Initialize(name, config)` method.
 
+Section handlers also have an optional override method `TryGetOriginalCase` that attempts to preserve casing in config files
+when executing in `Greedy` mode. When operating in `Strict` mode, config builders in this repo always preserved the case of the
+key when updating the value. This was easy because the original key was already at hand during lookup and replacement. In `Greedy`
+mode however, the original key from the config file was not used since it was not needed for a one-item lookup. Thus any greedy substitutions
+had their keys replaced with the keys from the external config source. Functionally they should be the same, since key/value config
+is supposed to be case-insensitive. But aesthetically, being a good citizen and not replacing the original key case is good.
 
 The `AppSettingsSectionHandler` and `ConnectionStringsSectionHandler`
 are implicitly added at the root level config, but they can be clear/removed just like any other item in an add/remove/clear configuration

samples/SampleWebApp/Web.config

@@ -94,7 +94,7 @@
 
   <appConfigTest configBuilders="appconfig1,appconfig2,appconfig3">
     <add key="acTest" value="Will be replaced by appconfig1. Should be 'test1'"/>
-    <add key="acTEST2" value="Should be case-insensitive replaced by appconfig1, and again by appconfig2. Should be 'test2b'"/>
+    <add key="acTEST2" value="Should be case-insensitive-and-preserve replaced by appconfig1, and again by appconfig2. Should be 'test2b'"/>
     <!-- <add key="acTest3" value="Will be added by appconfig2. Should be 'test3b'" /> -->
     <!-- <add key="acTest4" value="Will not exist." /> -->
     <add key="acLMTest" value="Will be replaced by appconfig3. Should be 'oldest'"/>

src/Base/KeyValueConfigBuilder.cs

@@ -251,8 +251,9 @@ public override ConfigurationSection ProcessConfigurationSection(ConfigurationSe
             {
                 foreach (var configItem in handler)
                 {
-                    string newValue = GetValueInternal(configItem.Key);
+                    // Presumably, UpdateKey will preserve casing appropriately, so newKey is cased as expected.
                     string newKey = UpdateKey(configItem.Key);
+                    string newValue = GetValueInternal(configItem.Key);
 
                     if (newValue != null)
                         handler.InsertOrUpdate(newKey, newValue, configItem.Key, configItem.Value);
@@ -267,8 +268,9 @@ public override ConfigurationSection ProcessConfigurationSection(ConfigurationSe
                 {
                     if (kvp.Value != null)
                     {
+                        // Here, kvp.Key is not from the config file, so it might not be correctly cased. Get the correct casing for UpdateKey.
                         string oldKey = TrimPrefix(kvp.Key);
-                        string newKey = UpdateKey(oldKey);
+                        string newKey = UpdateKey(handler.TryGetOriginalCase(oldKey));
                         handler.InsertOrUpdate(newKey, kvp.Value, oldKey);
                     }
                 }

src/Base/SectionHandler.cs

@@ -6,6 +6,7 @@
 using System.Configuration.Provider;
 using System.Collections.Specialized;
 using System;
+using System.Linq.Expressions;
 
 namespace Microsoft.Configuration.ConfigurationBuilders
 {
@@ -14,6 +15,7 @@ internal interface ISectionHandler
     {
         void InsertOrUpdate(string newKey, string newValue, string oldKey = null, object oldItem = null);
         IEnumerator<KeyValuePair<string, object>> GetEnumerator();
+        string TryGetOriginalCase(string requestedKey);
     }
 
     /// <summary>
@@ -45,6 +47,17 @@ public abstract class SectionHandler<T> : ProviderBase, ISectionHandler where T
         /// <param name="oldItem">A reference to the old key/value pair obtained by <see cref="GetEnumerator"/>, or null.</param>
         public abstract void InsertOrUpdate(string newKey, string newValue, string oldKey = null, object oldItem = null);
 
+        /// <summary>
+        /// Attempt to lookup the original key casing so it can be preserved during greedy updates which would otherwise lose
+        /// the original casing in favor of the casing used in the config source.
+        /// </summary>
+        /// <param name="requestedKey">The key to find original casing for.</param>
+        /// <returns>Unless overridden, returns the string passed in.</returns>
+        public virtual string TryGetOriginalCase(string requestedKey)
+        {
+            return requestedKey;
+        }
+
         private void Initialize(string name, T configSection, NameValueCollection config)
         {
             ConfigSection = configSection;
@@ -88,6 +101,25 @@ public override IEnumerator<KeyValuePair<string, object>> GetEnumerator()
             foreach (string key in keys)
                 yield return new KeyValuePair<string, object>(key, key);
         }
+
+        /// <summary>
+        /// Attempt to lookup the original key casing so it can be preserved during greedy updates which would otherwise lose
+        /// the original casing in favor of the casing used in the config source.
+        /// </summary>
+        /// <param name="requestedKey">The key to find original casing for.</param>
+        /// <returns>A string containing the key with original casing from the config section, or the key as passed in if no match
+        /// can be found.</returns>
+        public override string TryGetOriginalCase(string requestedKey)
+        {
+            if (!String.IsNullOrWhiteSpace(requestedKey))
+            {
+                var keyval = ConfigSection.Settings[requestedKey];
+                if (keyval != null)
+                    return keyval.Key;
+            }
+
+            return base.TryGetOriginalCase(requestedKey);
+        }
     }
 
     /// <summary>
@@ -136,5 +168,24 @@ public override IEnumerator<KeyValuePair<string, object>> GetEnumerator()
             foreach (ConnectionStringSettings cs in connStrs)
                 yield return new KeyValuePair<string, object>(cs.Name, cs);
         }
+
+        /// <summary>
+        /// Attempt to lookup the original key casing so it can be preserved during greedy updates which would otherwise lose
+        /// the original casing in favor of the casing used in the config source.
+        /// </summary>
+        /// <param name="requestedKey">The key to find original casing for.</param>
+        /// <returns>A string containing the key with original casing from the config section, or the key as passed in if no match
+        /// can be found.</returns>
+        public override string TryGetOriginalCase(string requestedKey)
+        {
+            if (!String.IsNullOrWhiteSpace(requestedKey))
+            {
+                var connStr = ConfigSection.ConnectionStrings[requestedKey];
+                if (connStr != null)
+                    return connStr.Name;
+            }
+
+            return base.TryGetOriginalCase(requestedKey);
+        }
     }
 }