Config.Root should contain fallback values (#181)

* Fixed fallbacks handling

* Refactored Config class to reuse Root property

* Added configuration spec for complex objects with fallback

Co-authored-by: Aaron Stannard <[email protected]>

Author: IgorFedchenko

src/Hocon.Configuration.Test/ConfigurationSpec.cs

@@ -395,6 +395,47 @@ public void Config_Empty_is_Empty()
             ConfigurationFactory.Empty.IsEmpty.Should().BeTrue();
         }
 
+        [Fact]
+        public void HoconValue_GetObject_should_use_fallback_values()
+        {
+            var config1 = ConfigurationFactory.ParseString("a = 5");
+            var config2 = ConfigurationFactory.ParseString("b = 3");
+            var config = config1.WithFallback(config2);
+            var rootObject = config.Root.GetObject();
+            rootObject.ContainsKey("a").Should().BeTrue();
+            rootObject["a"].Raw.Should().Be("5");
+            rootObject.ContainsKey("b").Should().BeTrue();
+            rootObject["b"].Raw.Should().Be("3");
+        }
+        
+        [Fact]
+        public void HoconValue_GetObject_should_use_fallback_values_with_complex_objects()
+        {
+            var config1 = ConfigurationFactory.ParseString(@"
+	            akka.actor.deployment {
+		            /worker1 {
+			            router = round-robin-group1
+			            routees.paths = [""/user/testroutes/1""]
+		            }
+	            }");
+            var config2 = ConfigurationFactory.ParseString(@"
+	            akka.actor.deployment {
+		            /worker2 {
+			            router = round-robin-group2
+			            routees.paths = [""/user/testroutes/2""]
+		            }
+	            }");
+            var configWithFallback = config1.WithFallback(config2);
+            
+            var config = configWithFallback.GetConfig("akka.actor.deployment");
+            var rootObj = config.Root.GetObject();
+            rootObj.Unwrapped.Should().ContainKeys("/worker1", "/worker2");
+            rootObj["/worker1.router"].Raw.Should().Be("round-robin-group1");
+            rootObj["/worker1.router"].Raw.Should().Be("round-robin-group1");
+            rootObj["/worker1.routees.paths"].Value[0].GetArray()[0].Raw.Should().Be(@"""/user/testroutes/1""");
+            rootObj["/worker2.routees.paths"].Value[0].GetArray()[0].Raw.Should().Be(@"""/user/testroutes/2""");
+        }
+
 
 #if !NETCORE
         [Fact]
@@ -427,9 +468,15 @@ public void ShouldSerializeFallbackValues()
             }");
 
             var c = a.WithFallback(b);
+            
             c.GetInt("akka.other-key").Should().Be(42, "Fallback value should exist as data");
             c.ToString().Should().NotContain("other-key", "Fallback values are ignored by default");
             c.ToString(true).Should().Contain("other-key", "Fallback values should be displayed when requested");
+            
+            c.GetString("akka.some-key").Should().Be("value", "Original value should remain");
+            c.ToString().Should().Contain("some-key", "Original values are shown by default");
+            c.ToString(true).Should().Contain("some-key", "Original values should be displayed always");
+
         }
 
         /// <summary>

src/Hocon.Configuration/Config.cs

@@ -59,7 +59,29 @@ public Config(HoconRoot source, Config fallback) : base(source?.Value,
         /// <summary>
         ///     The root node of this configuration section
         /// </summary>
-        public virtual HoconValue Root => Value;
+        public virtual HoconValue Root
+        {
+            get
+            {
+                var elements = Value.ToList();
+                var config = this;
+                while (config.Fallback != null)
+                {
+                    config = config.Fallback;
+                    if (config.Value != null)
+                        elements.AddRange(config.Value);
+                }
+
+                var aggregated = new HoconValue(null);
+                elements.Reverse();
+                foreach (var element in elements)
+                {
+                    aggregated.Add(element);
+                }
+
+                return aggregated;
+            }
+        }
 
         /// <summary>
         ///     Returns string representation of <see cref="Config" />, allowing to include fallback values
@@ -69,12 +91,8 @@ public string ToString(bool useFallbackValues)
         {
             if (!useFallbackValues)
                 return base.ToString();
-
-            var config = this;
-            while (config.Fallback != null)
-                config = config.Fallback;
-
-            return config.ToString();
+            
+            return Root.ToString();
         }
 
         /// <summary>
@@ -93,20 +111,17 @@ protected Config Copy()
 
         protected override HoconValue GetNode(HoconPath path, bool throwIfNotFound = false)
         {
-            HoconValue result;
             try
             {
-                result = Root.GetObject().GetValue(path);
+                return Root.GetObject().GetValue(path);
             }
             catch
             {
                 if (throwIfNotFound)
                     throw;
 
-                result = Fallback?.GetNode(path);
+                return null;
             }
-
-            return result;
         }
 
         /// <summary>
@@ -123,12 +138,6 @@ public virtual Config GetConfig(string path)
         public virtual Config GetConfig(HoconPath path)
         {
             var value = GetNode(path);
-            if (Fallback != null)
-            {
-                var f = Fallback.GetConfig(path);
-                return value == null ? f : new Config(new HoconRoot(value)).WithFallback(f);
-            }
-
             return value == null ? null : new Config(new HoconRoot(value));
         }
 
@@ -188,19 +197,13 @@ public static implicit operator Config(string str)
         public override IEnumerable<KeyValuePair<string, HoconField>> AsEnumerable()
         {
             var used = new HashSet<string>();
-            var current = this;
-            while (current != null)
+            foreach (var kvp in Root.GetObject())
             {
-                foreach (var kvp in current.Root.GetObject())
-                {
-                    if (used.Contains(kvp.Key))
-                        continue;
-
-                    yield return kvp;
-                    used.Add(kvp.Key);
-                }
+                if (used.Contains(kvp.Key))
+                    continue;
 
-                current = current.Fallback;
+                yield return kvp;
+                used.Add(kvp.Key);
             }
         }
     }