Fix for #89 and #92, Object fields containing objects may not return the proper object value in certain circumstances. (#93)

Author: Arkatufus

src/Hocon.Tests/ArrayAndObjectConcatenation.cs

@@ -191,6 +191,33 @@ public void CanConcatenateObjectsWhenMerged()
             Assert.Equal(2, config.GetInt("a.c"));
         }
 
+        [Fact]
+        public void CanConcatenateObjectsWhenMerged_Issue89()
+        {
+            var hocon = @"
+a {
+  aa: 1
+  bb: ""2""
+        }
+
+        a {
+            cc: 3.3
+        }
+";
+            var config = Parser.Parse(hocon);
+            Assert.Equal(1, config.GetInt("a.aa"));
+            Assert.Equal("2", config.GetString("a.bb"));
+            Assert.Equal(3.3, config.GetDouble("a.cc"));
+            _output.WriteLine(config.PrettyPrint(2));
+            Assert.Equal(@"{
+  a : {
+    aa : 1,
+    bb : ""2"",
+    cc : 3.3
+  }
+}", config.PrettyPrint(2));
+        }
+
         // Undefined behavior in spec.
         // In this implementation, mixed value types in an array will throw an exception.
         [Theory]

src/Hocon.Tests/DuplicateKeysAndObjectMerging.cs

@@ -11,11 +11,19 @@
 using System.Text;
 using System.Threading.Tasks;
 using Xunit;
+using Xunit.Abstractions;
 
 namespace Hocon.Tests
 {
     public class DuplicateKeysAndObjectMerging
     {
+        private readonly ITestOutputHelper _output;
+
+        public DuplicateKeysAndObjectMerging(ITestOutputHelper output)
+        {
+            _output = output;
+        }
+
         /*
          * FACT:
          * duplicate keys that appear later override those that appear earlier, unless both values are objects
@@ -138,5 +146,39 @@ public void ObjectCanMixBraceAndDotSyntax()
             Assert.Equal(2, config.GetInt("foo.y"));
             Assert.Equal(32, config.GetInt("foo.z"));
         }
+
+        [Fact]
+        public void CanMixObjectMergeAndSubstitutions_Issue92()
+        {
+            var hocon = 
+@"x={ q : 10 }
+y=5
+
+a=1
+a.q.r.s=${b}
+a=${y}
+a=${x}
+a={ c : 3 }
+
+b=${x}
+b=${y}
+
+// nesting ConfigDelayed inside another one
+c=${x}
+c={ d : 600, e : ${a}, f : ${b} }";
+
+            var config = Parser.Parse(hocon);
+            _output.WriteLine(config.PrettyPrint(2));
+            Assert.Equal(3, config.GetInt("a.c"));
+            Assert.Equal(10, config.GetInt("a.q"));
+            Assert.Equal(5, config.GetInt("b"));
+            Assert.Equal(600, config.GetInt("c.d"));
+            Assert.Equal(3, config.GetInt("c.e.c"));
+            Assert.Equal(10, config.GetInt("c.e.q"));
+            Assert.Equal(5, config.GetInt("c.f"));
+            Assert.Equal(10, config.GetInt("c.q"));
+            Assert.Equal(10, config.GetInt("x.q"));
+            Assert.Equal(5, config.GetInt("y"));
+        }
     }
 }

src/Hocon/Impl/HoconField.cs

@@ -57,8 +57,44 @@ internal HoconField ParentField
 
         public HoconValue Value
         {
-            get => _internalValues.Count > 0 ? _internalValues.Last() : HoconValue.Undefined;
-            //set => _internalValues.Add(value);
+            get
+            {
+                switch (_internalValues.Count)
+                {
+                    case 0:
+                        return HoconValue.Undefined;
+                    case 1:
+                        return _internalValues[0];
+                    default:
+                        var lastValue = _internalValues.Last();
+                        if (lastValue.Type != HoconType.Object)
+                            return lastValue;
+
+                        var objects = new List<HoconObject>();
+                        foreach (var val in _internalValues)
+                        {
+                            if (val.Type != HoconType.Object)
+                                objects.Clear();
+                            else
+                                objects.Add(val.GetObject());
+                        }
+
+                        var value = new HoconValue(this);
+                        switch (objects.Count)
+                        {
+                            case 0:
+                                throw new HoconException("Should never reach this line.");
+                            case 1:
+                                value.Add(objects[0]);
+                                break;
+                            default:
+                                var resultObject = new HoconMergedObject(value, objects);
+                                value.Add(resultObject);
+                                break;
+                        }
+                        return value;
+                }
+            }
         }
 
         public HoconField(HoconPath path, HoconObject parent)
@@ -84,19 +120,39 @@ internal void EnsureFieldIsObject()
         internal List<HoconSubstitution> SetValue(HoconValue value)
         {
             var removedSubs = new List<HoconSubstitution>();
-            if (value.Type == HoconType.Array || value.Type == HoconType.Literal)
+
+            if (_internalValues.Count == 0)
             {
-                var subs = value.GetSubstitutions();
-                if (subs.All(sub => sub.Path != Path))
-                {
-                    foreach (var item in _internalValues)
+                _internalValues.Add(value);
+                return removedSubs;
+            }
+
+            switch (value.Type)
+            {
+                case HoconType.Array:
+                case HoconType.Literal:
+                    var subs = value.GetSubstitutions();
+                    if (subs.All(sub => sub.Path != Path))
                     {
-                        removedSubs.AddRange(item.GetSubstitutions());
+                        foreach (var item in _internalValues)
+                        {
+                            removedSubs.AddRange(item.GetSubstitutions());
+                        }
+                        _internalValues.Clear();
                     }
-                    _internalValues.Clear();
-                }
+                    _internalValues.Add(value);
+                    break;
+                case HoconType.Object:
+                    var lastValue = _internalValues.Last();
+                    if (lastValue.Type != HoconType.Object)
+                        _internalValues.Add(value);
+                    else
+                        lastValue.GetObject().Merge(value.GetObject());
+                    break;
+                default:
+                    _internalValues.Add(value);
+                    break;
             }
-            _internalValues.Add(value);
             return removedSubs;
         }
 

src/Hocon/Impl/HoconSubstitution.cs

@@ -99,10 +99,10 @@ internal HoconSubstitution(IHoconElement parent, HoconPath path, IHoconLineInfo
         public string Raw => ResolvedValue?.Raw;
 
         /// <inheritdoc />
-        public List<HoconValue> GetArray() => ResolvedValue?.GetArray() ?? new List<HoconValue>();
+        public List<HoconValue> GetArray() => ResolvedValue?.GetArray();
 
         /// <inheritdoc />
-        public HoconObject GetObject() => ResolvedValue?.GetObject() ?? new HoconObject(Parent);
+        public HoconObject GetObject() => ResolvedValue?.GetObject();
 
         /// <summary>
         /// Returns the string representation of this element.