ini: add basic INI file deserialiser

Add a basic INI file deserialiser

Author: mjcheetham

src/shared/Core.Tests/IniFileTests.cs

@@ -0,0 +1,135 @@
+using System.Collections.Generic;
+using System.Text;
+using GitCredentialManager.Tests.Objects;
+using Xunit;
+
+namespace GitCredentialManager.Tests
+{
+    public class IniFileTests
+    {
+        [Fact]
+        public void IniSectionName_Equality()
+        {
+            var a1 = new IniSectionName("foo");
+            var b1 = new IniSectionName("foo");
+            Assert.Equal(a1,b1);
+            Assert.Equal(a1.GetHashCode(),b1.GetHashCode());
+
+            var a2 = new IniSectionName("foo");
+            var b2 = new IniSectionName("FOO");
+            Assert.Equal(a2,b2);
+            Assert.Equal(a2.GetHashCode(),b2.GetHashCode());
+
+            var a3 = new IniSectionName("foo", "bar");
+            var b3 = new IniSectionName("foo", "BAR");
+            Assert.NotEqual(a3,b3);
+            Assert.NotEqual(a3.GetHashCode(),b3.GetHashCode());
+
+            var a4 = new IniSectionName("foo", "bar");
+            var b4 = new IniSectionName("FOO", "bar");
+            Assert.Equal(a4,b4);
+            Assert.Equal(a4.GetHashCode(),b4.GetHashCode());
+        }
+
+        [Fact]
+        public void IniSerializer_Deserialize()
+        {
+            const string path = "/tmp/test.ini";
+            string iniText = @"
+[one]
+    foo = 123
+  [two]
+    foo   =   abc
+# comment
+[two ""subsection name""] # comment [section]
+    foo = this is different # comment prop = val
+
+#[notasection]
+
+    [
+[bad #section]
+recovery tests]
+[]
+    ]
+
+    [three]
+    bar = a
+    bar = b
+    # comment
+    bar = c
+    empty =
+[TWO]
+    foo = hello
+    widget = ""Hello, World!""
+[four]
+[five]
+    prop1 = ""this hash # is inside quotes""
+    prop2 = ""this hash # is inside quotes"" # this line has two hashes
+    prop3 = ""   this dquoted string has three spaces around   ""
+    #prop4 = this property has been commented-out
+";
+
+            var fs = new TestFileSystem
+            {
+                Files = { [path] = Encoding.UTF8.GetBytes(iniText) }
+            };
+
+            IniFile ini = IniSerializer.Deserialize(fs, path);
+
+            Assert.Equal(6, ini.Sections.Count);
+
+            AssertSection(ini, "one", out IniSection one);
+            Assert.Equal(1, one.Properties.Count);
+            AssertProperty(one, "foo", "123");
+
+            AssertSection(ini, "two", out IniSection twoA);
+            Assert.Equal(3, twoA.Properties.Count);
+            AssertProperty(twoA, "foo", "hello");
+            AssertProperty(twoA, "widget", "Hello, World!");
+
+            AssertSection(ini, "two", "subsection name", out IniSection twoB);
+            Assert.Equal(1, twoB.Properties.Count);
+            AssertProperty(twoB, "foo", "this is different");
+
+            AssertSection(ini, "three", out IniSection three);
+            Assert.Equal(4, three.Properties.Count);
+            AssertMultiProperty(three, "bar", "a", "b", "c");
+            AssertProperty(three, "empty", "");
+
+            AssertSection(ini, "four", out IniSection four);
+            Assert.Equal(0, four.Properties.Count);
+
+            AssertSection(ini, "five", out IniSection five);
+            Assert.Equal(3, five.Properties.Count);
+            AssertProperty(five, "prop1", "this hash # is inside quotes");
+            AssertProperty(five, "prop2", "this hash # is inside quotes");
+            AssertProperty(five, "prop3", "   this dquoted string has three spaces around   ");
+        }
+
+        private static void AssertSection(IniFile file, string name, out IniSection section)
+        {
+            Assert.True(file.TryGetSection(name, out section));
+            Assert.Equal(name, section.Name.Name);
+            Assert.Null(section.Name.SubName);
+        }
+
+        private static void AssertSection(IniFile file, string name, string subName, out IniSection section)
+        {
+            Assert.True(file.TryGetSection(name, subName, out section));
+            Assert.Equal(name, section.Name.Name);
+            Assert.Equal(subName, section.Name.SubName);
+        }
+
+        private static void AssertProperty(IniSection section, string name, string value)
+        {
+            Assert.True(section.TryGetProperty(name, out var actualValue));
+            Assert.Equal(value, actualValue);
+        }
+
+        private static void AssertMultiProperty(IniSection section, string name, params string[] values)
+        {
+            Assert.True(section.TryGetMultiProperty(name, out IEnumerable<string> actualValues));
+            Assert.Equal(values, actualValues);
+        }
+    }
+}

src/shared/Core/IniFile.cs

@@ -0,0 +1,207 @@
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Linq;
+using System.Text.RegularExpressions;
+
+namespace GitCredentialManager
+{
+    public class IniFile
+    {
+        public IniFile()
+        {
+            Sections = new Dictionary<IniSectionName, IniSection>();
+        }
+
+        public IDictionary<IniSectionName, IniSection> Sections { get; }
+
+        public bool TryGetSection(string name, string subName, out IniSection section)
+        {
+            return Sections.TryGetValue(new IniSectionName(name, subName), out section);
+        }
+
+        public bool TryGetSection(string name, out IniSection section)
+        {
+            return Sections.TryGetValue(new IniSectionName(name), out section);
+        }
+    }
+
+    [DebuggerDisplay("{DebuggerDisplay}")]
+    public readonly struct IniSectionName : IEquatable<IniSectionName>
+    {
+        public IniSectionName(string name, string subName = null)
+        {
+            Name = name;
+            SubName = string.IsNullOrEmpty(subName) ? null : subName;
+        }
+
+        public string Name { get; }
+
+        public string SubName { get; }
+
+        public bool Equals(IniSectionName other)
+        {
+            // Main section name is case-insensitive, but subsection name IS case-sensitive!
+            return StringComparer.OrdinalIgnoreCase.Equals(Name, other.Name) &&
+                   StringComparer.Ordinal.Equals(SubName, other.SubName);
+        }
+
+        public override bool Equals(object obj)
+        {
+            return obj is IniSectionName other && Equals(other);
+        }
+
+        public override int GetHashCode()
+        {
+            unchecked
+            {
+                return ((Name != null ? Name.ToLowerInvariant().GetHashCode() : 0) * 397) ^
+                       (SubName != null ? SubName.GetHashCode() : 0);
+            }
+        }
+
+        private string DebuggerDisplay => SubName is null ? Name : $"{Name} \"{SubName}\"";
+    }
+
+    [DebuggerDisplay("{DebuggerDisplay}")]
+    public class IniSection
+    {
+        public IniSection(IniSectionName name)
+        {
+            Name = name;
+            Properties = new List<IniProperty>();
+        }
+
+        public IniSectionName Name { get; }
+
+        public IList<IniProperty> Properties { get; }
+
+        public bool TryGetProperty(string name, out string value)
+        {
+            if (TryGetMultiProperty(name, out IEnumerable<string> values))
+            {
+                value = values.Last();
+                return true;
+            }
+
+            value = null;
+            return false;
+        }
+
+        public bool TryGetMultiProperty(string name, out IEnumerable<string> values)
+        {
+            IniProperty[] props = Properties
+                .Where(x => StringComparer.OrdinalIgnoreCase.Equals(x.Name, name))
+                .ToArray();
+
+            if (props.Length == 0)
+            {
+                values = Array.Empty<string>();
+                return false;
+            }
+
+            values = props.Select(x => x.Value);
+            return true;
+        }
+
+        private string DebuggerDisplay => Name.SubName is null
+            ? $"{Name.Name} [Properties: {Properties.Count}]"
+            : $"{Name.Name} \"{Name.SubName}\" [Properties: {Properties.Count}]";
+    }
+
+    [DebuggerDisplay("{DebuggerDisplay}")]
+    public class IniProperty
+    {
+        public IniProperty(string name, string value)
+        {
+            Name = name;
+            Value = value;
+        }
+
+        public string Name { get; }
+        public string Value { get; }
+
+        private string DebuggerDisplay => $"{Name}={Value}";
+    }
+
+    public static class IniSerializer
+    {
+        private static readonly Regex SectionRegex =
+            new Regex(@"^\[[^\S#]*(?'name'[^\s#\]]*?)(?:\s+""(?'sub'.+)"")?\s*\]", RegexOptions.Compiled);
+
+        private static readonly Regex PropertyRegex =
+            new Regex(@"^[^\S#]*?(?'name'[^\s#]+)\s*=(?'value'.*)?$", RegexOptions.Compiled);
+
+        public static IniFile Deserialize(IFileSystem fs, string path)
+        {
+            IEnumerable<string> lines = fs.ReadAllLines(path).Select(x => x.Trim());
+
+            var iniFile = new IniFile();
+            IniSection section = null;
+
+            foreach (string line in lines)
+            {
+                Match match = SectionRegex.Match(line);
+                if (match.Success)
+                {
+                    string mainName = match.Groups["name"].Value;
+                    string subName = match.Groups["sub"].Value;
+
+                    // Skip empty-named sections
+                    if (string.IsNullOrWhiteSpace(mainName))
+                    {
+                        continue;
+                    }
+
+                    if (!iniFile.TryGetSection(mainName, subName, out section))
+                    {
+                        var sectionName = new IniSectionName(mainName, subName);
+                        section = new IniSection(sectionName);
+                        iniFile.Sections[sectionName] = section;
+                    }
+
+                    continue;
+                }
+
+                match = PropertyRegex.Match(line);
+                if (match.Success)
+                {
+                    if (section is null)
+                    {
+                        throw new Exception("Missing section header");
+                    }
+
+                    string propName = match.Groups["name"].Value;
+                    string propValue = match.Groups["value"].Value.Trim();
+
+                    // Trim trailing comments
+                    int firstDQuote = propValue.IndexOf('"');
+                    int lastDQuote = propValue.LastIndexOf('"');
+                    int commentIdx = propValue.LastIndexOf('#');
+                    if (commentIdx > -1)
+                    {
+                        bool insideDQuotes = firstDQuote > -1 && lastDQuote > -1 &&
+                                             (firstDQuote < commentIdx && commentIdx < lastDQuote);
+
+                        if (!insideDQuotes)
+                        {
+                            propValue = propValue.Substring(0, commentIdx).Trim();
+                        }
+                    }
+
+                    // Trim book-ending double quotes: "foo" => foo
+                    if (propValue.Length > 1 && propValue[0] == '"' &&
+                        propValue[propValue.Length - 1] == '"')
+                    {
+                        propValue = propValue.Substring(1, propValue.Length - 2);
+                    }
+
+                    var property = new IniProperty(propName, propValue);
+                    section.Properties.Add(property);
+                }
+            }
+
+            return iniFile;
+        }
+    }
+}