- Support for JSON arrays

- Use the json.net parser instead of manually parsing the json
- Simplified some test code

src/Microsoft.Framework.ConfigurationModel.Json/JsonConfigurationFileParser.cs

@@ -0,0 +1,113 @@
+// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved.
+// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
+
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using Newtonsoft.Json;
+using Newtonsoft.Json.Linq;
+
+namespace Microsoft.Framework.ConfigurationModel.Json
+{
+    internal class JsonConfigurationFileParser
+    {
+        private readonly IDictionary<string, string> _data = new SortedDictionary<string, string>(StringComparer.OrdinalIgnoreCase);
+        private readonly Stack<string> _context = new Stack<string>();
+        private string _currentPath;
+
+        private JsonTextReader _reader;
+
+        public IDictionary<string, string> Parse(Stream input)
+        {
+            _data.Clear();
+            _reader = new JsonTextReader(new StreamReader(input));
+            _reader.DateParseHandling = DateParseHandling.None;
+
+            var jsonConfig = JObject.Load(_reader);
+
+            VisitJObject(jsonConfig);
+
+            return _data;
+        }
+
+        private void VisitJObject(JObject jObject)
+        {
+            foreach (var property in jObject.Properties())
+            {
+                EnterContext(property.Name);
+                VisitProperty(property);
+                ExitContext();
+            }
+        }
+
+        private void VisitProperty(JProperty property)
+        {
+            VisitToken(property.Value);
+        }
+
+        private void VisitToken(JToken token)
+        {
+            switch (token.Type)
+            {
+                case JTokenType.Object:
+                    VisitJObject(token.Value<JObject>());
+                    break;
+
+                case JTokenType.Array:
+                    VisitArray(token.Value<JArray>());
+                    break;
+
+                case JTokenType.Integer:
+                case JTokenType.Float:
+                case JTokenType.String:
+                case JTokenType.Boolean:
+                case JTokenType.Bytes:
+                case JTokenType.Raw:
+                case JTokenType.Null:
+                    VisitPrimitive(token);
+                    break;
+
+                default:
+                    throw new FormatException(Resources.FormatError_UnsupportedJSONToken(
+                        _reader.TokenType,
+                        _reader.Path,
+                        _reader.LineNumber,
+                        _reader.LinePosition));
+            }
+        }
+
+        private void VisitArray(JArray array)
+        {
+            for (int index = 0; index < array.Count; index++)
+            {
+                EnterContext(index.ToString());
+                VisitToken(array[index]);
+                ExitContext();
+            }
+        }
+
+        private void VisitPrimitive(JToken data)
+        {
+            var key = _currentPath;
+
+            if (_data.ContainsKey(key))
+            {
+                throw new FormatException(Resources.FormatError_KeyIsDuplicated(key));
+            }
+            _data[key] = data.ToString();
+        }
+
+        private void EnterContext(string context)
+        {
+            _context.Push(context);
+            _currentPath = string.Join(":", _context.Reverse());
+        }
+
+        private void ExitContext()
+        {
+            _context.Pop();
+            _currentPath = string.Join(":", _context.Reverse());
+        }
+    }
+}

src/Microsoft.Framework.ConfigurationModel.Json/JsonConfigurationSource.cs

@@ -5,7 +5,6 @@
 using System.Collections.Generic;
 using System.IO;
 using Microsoft.Framework.ConfigurationModel.Json;
-using Newtonsoft.Json;
 
 namespace Microsoft.Framework.ConfigurationModel
 {
@@ -78,129 +77,8 @@ public override void Load()
 
         internal void Load(Stream stream)
         {
-            var data = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
-
-            using (var reader = new JsonTextReader(new StreamReader(stream)))
-            {
-                var startObjectCount = 0;
-
-                // Dates are parsed as strings
-                reader.DateParseHandling = DateParseHandling.None;
-
-                // Move to the first token
-                reader.Read();
-
-                SkipComments(reader);
-
-                if (reader.TokenType != JsonToken.StartObject)
-                {
-                    throw new FormatException(Resources.FormatError_RootMustBeAnObject(reader.Path,
-                        reader.LineNumber, reader.LinePosition));
-                }
-
-                do
-                {
-                    SkipComments(reader);
-
-                    switch (reader.TokenType)
-                    {
-                        case JsonToken.StartObject:
-                            startObjectCount++;
-                            break;
-
-                        case JsonToken.EndObject:
-                            startObjectCount--;
-                            break;
-
-                        // Keys in key-value pairs
-                        case JsonToken.PropertyName:
-                            break;
-
-                        // Values in key-value pairs
-                        case JsonToken.Integer:
-                        case JsonToken.Float:
-                        case JsonToken.String:
-                        case JsonToken.Boolean:
-                        case JsonToken.Bytes:
-                        case JsonToken.Raw:
-                        case JsonToken.Null:
-                            var key = GetKey(reader.Path);
-
-                            if (data.ContainsKey(key))
-                            {
-                                throw new FormatException(Resources.FormatError_KeyIsDuplicated(key));
-                            }
-                            data[key] = reader.Value.ToString();
-                            break;
-
-                        // End of file
-                        case JsonToken.None:
-                            {
-                                throw new FormatException(Resources.FormatError_UnexpectedEnd(reader.Path,
-                                    reader.LineNumber, reader.LinePosition));
-                            }
-
-                        default:
-                            {
-                                // Unsupported elements: Array, Constructor, Undefined
-                                throw new FormatException(Resources.FormatError_UnsupportedJSONToken(
-                                    reader.TokenType, reader.Path, reader.LineNumber, reader.LinePosition));
-                            }
-                    }
-
-                    reader.Read();
-
-                } while (startObjectCount > 0);
-            }
-
-            Data = data;
-        }
-
-        private string GetKey(string jsonPath)
-        {
-            var pathSegments = new List<string>();
-            var index = 0;
-
-            while (index < jsonPath.Length)
-            {
-                // If the JSON element contains '.' in its name, JSON.net escapes that element as ['element']
-                // while getting its Path. So before replacing '.' => ':' to represent JSON hierarchy, here 
-                // we skip a '.' => ':' conversion if the element is not enclosed with in ['..'].
-                var start = jsonPath.IndexOf("['", index);
-
-                if (start < 0)
-                {
-                    // No more ['. Skip till end of string.
-                    pathSegments.Add(jsonPath.
-                        Substring(index).
-                        Replace('.', ':'));
-                    break;
-                }
-                else
-                {
-                    if (start > index)
-                    {
-                        pathSegments.Add(
-                            jsonPath
-                            .Substring(index, start - index) // Anything between the previous [' and '].
-                            .Replace('.', ':'));
-                    }
-
-                    var endIndex = jsonPath.IndexOf("']", start);
-                    pathSegments.Add(jsonPath.Substring(start + 2, endIndex - start - 2));
-                    index = endIndex + 2;
-                }
-            }
-
-            return string.Join(string.Empty, pathSegments);
-        }
-
-        private void SkipComments(JsonReader reader)
-        {
-            while (reader.TokenType == JsonToken.Comment)
-            {
-                reader.Read();
-            }
+            JsonConfigurationFileParser parser = new JsonConfigurationFileParser();
+            Data = parser.Parse(stream);
         }
     }
 }

src/Microsoft.Framework.ConfigurationModel.Json/Resources.resx

@@ -132,12 +132,6 @@
   <data name="Error_KeyIsDuplicated" xml:space="preserve">
     <value>A duplicate key '{0}' was found.</value>
   </data>
-  <data name="Error_RootMustBeAnObject" xml:space="preserve">
-    <value>Only an object can be the root. Path '{0}', line {1} position {2}.</value>
-  </data>
-  <data name="Error_UnexpectedEnd" xml:space="preserve">
-    <value>Unexpected end when parsing JSON. Path '{0}', line {1} position {2}.</value>
-  </data>
   <data name="Error_UnsupportedJSONToken" xml:space="preserve">
     <value>Unsupported JSON token '{0}' was found. Path '{1}', line {2} position {3}.</value>
   </data>

src/Microsoft.Framework.ConfigurationModel.Json/project.json

@@ -9,6 +9,10 @@
     "frameworks": {
         "net45": { },
         "dnx451": { },
-        "dnxcore50": { }
+        "dnxcore50": {
+            "dependencies": {
+                "System.Dynamic.Runtime": "4.0.10-*"
+            }
+        }
     }
 }

src/Microsoft.Framework.ConfigurationModel/ConfigurationKeyComparer.cs

@@ -0,0 +1,62 @@
+// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved.
+// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
+
+using System;
+using System.Collections.Generic;
+
+namespace Microsoft.Framework.ConfigurationModel
+{
+    public class ConfigurationKeyComparer : IComparer<string>
+    {
+        private const char Separator = ':';
+
+        public static ConfigurationKeyComparer Instance { get; } = new ConfigurationKeyComparer();
+
+        public int Compare(string x, string y)
+        {
+            var xParts = x?.Split(Separator) ?? new string[0];
+            var yParts = y?.Split(Separator) ?? new string[0];
+
+            // Compare each part until we get two parts that are not equal
+            for (int i = 0; i < Math.Min(xParts.Length, yParts.Length); i++)
+            {
+                x = xParts[i];
+                y = yParts[i];
+
+                var value1 = 0;
+                var value2 = 0;
+
+                var xIsInt = x != null && int.TryParse(x, out value1);
+                var yIsInt = y != null && int.TryParse(y, out value2);
+
+                int result = 0;
+
+                if (!xIsInt && !yIsInt)
+                {
+                    // Both are strings
+                    result = string.Compare(x, y, StringComparison.OrdinalIgnoreCase);
+                }
+                else if (xIsInt && yIsInt)
+                {
+                    // Both are int 
+                    result = value1 - value2;
+                }
+                else
+                {
+                    // Only one of them is int
+                    result = xIsInt ? -1 : 1;
+                }
+
+                if (result != 0)
+                {
+                    // One of them is different
+                    return result;
+                }
+            }
+
+            // If we get here, the common parts are equal.
+            // If they are of the same length, then they are totally identical
+            return xParts.Length - yParts.Length;
+        }
+    }
+}

src/Microsoft.Framework.ConfigurationModel/Properties/AssemblyInfo.cs

@@ -39,5 +39,6 @@
 [assembly: AssemblyVersion("1.0.0.0")]
 [assembly: AssemblyFileVersion("1.0.0.0")]
 [assembly: InternalsVisibleTo("Microsoft.Framework.ConfigurationModel.Test")]
+[assembly: InternalsVisibleTo("Microsoft.Framework.ConfigurationModel.Json.Test")]
 [assembly: NeutralResourcesLanguage("en-US")]
 [assembly: AssemblyMetadata("Serviceable", "True")]

src/Microsoft.Framework.ConfigurationModel/Sources/ConfigurationSource.cs

@@ -35,7 +35,8 @@ public virtual IEnumerable<string> ProduceSubKeys(IEnumerable<string> earlierKey
             return Data
                 .Where(kv => kv.Key.StartsWith(prefix, StringComparison.OrdinalIgnoreCase))
                 .Select(kv => Segment(kv.Key, prefix, delimiter))
-                .Concat(earlierKeys);
+                .Concat(earlierKeys)
+                .OrderBy(k => k, ConfigurationKeyComparer.Instance);
         }
 
         private static string Segment(string key, string prefix, string delimiter)