implemented AutoCompleteSettings

Author: retailcoder

Rubberduck.Core/AutoComplete/AutoCompleteProvider.cs

@@ -0,0 +1,30 @@
+using System.Collections.Generic;
+using System.Linq;
+using Rubberduck.Settings;
+
+namespace Rubberduck.AutoComplete
+{
+    public interface IAutoCompleteProvider
+    {
+        IEnumerable<IAutoComplete> AutoCompletes { get; }
+    }
+
+    public class AutoCompleteProvider : IAutoCompleteProvider
+    {
+        public AutoCompleteProvider(IEnumerable<IAutoComplete> autoCompletes)
+        {
+            var defaults = new DefaultSettings<AutoCompleteSettings>().Default;
+            var defaultKeys = defaults.Settings.Select(x => x.Key);
+            var defaultAutoCompletes = autoCompletes.Where(autoComplete => defaultKeys.Contains(autoComplete.GetType().Name));
+
+            foreach (var autoComplete in defaultAutoCompletes)
+            {
+                autoComplete.IsEnabled = defaults.Settings.First(setting => setting.Key == autoComplete.GetType().Name).IsEnabled;
+            }
+
+            AutoCompletes = autoCompletes;
+        }
+
+        public IEnumerable<IAutoComplete> AutoCompletes { get; }
+    }
+}

Rubberduck.Core/AutoComplete/IAutoComplete.cs

@@ -7,6 +7,6 @@ public interface IAutoComplete
         string InputToken { get; }
         string OutputToken { get; }
         bool Execute(AutoCompleteEventArgs e);
-        bool IsEnabled { get; }
+        bool IsEnabled { get; set; }
     }
 }

Rubberduck.Core/Properties/Settings.Designer.cs

@@ -257,5 +257,11 @@
   <RunInspectionsOnSuccessfulParse>true</RunInspectionsOnSuccessfulParse>
 &lt;/CodeInspectionSettings&gt;</Value>
     </Setting>
+    <Setting Name="AutoCompleteSettings" Type="Rubberduck.Settings.AutoCompleteSettings" Scope="Application">
+      <Value Profile="(Default)">&lt;?xml version="1.0" encoding="utf-16"?&gt;
+&lt;AutoCompleteSettings xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema"&gt;
+  &lt;Settings /&gt;
+&lt;/AutoCompleteSettings&gt;</Value>
+    </Setting>
   </Settings>
 </SettingsFile>

Rubberduck.Core/Properties/Settings.settings

@@ -332,6 +332,7 @@
     <Compile Include="Common\WinAPI\WindowLongFlags.cs" />
     <Compile Include="Common\WindowsOperatingSystem.cs" />
     <Compile Include="Common\UndocumentedAttribute.cs" />
+    <Compile Include="AutoComplete\AutoCompleteProvider.cs" />
     <Compile Include="Inspections\IInspectionProvider.cs" />
     <Compile Include="Inspections\InspectionProvider.cs" />
     <Compile Include="Navigation\CodeExplorer\ICodeExplorerDeclarationViewModel.cs" />
@@ -363,6 +364,9 @@
     <Compile Include="Refactorings\ExtractMethod\IExtractMethodProc.cs" />
     <Compile Include="Refactorings\ExtractMethod\IExtractMethodRule.cs" />
     <Compile Include="Refactorings\ExtractMethod\IExtractMethodSelectionValidation.cs" />
+    <Compile Include="Settings\AutoCompleteConfigProvider.cs" />
+    <Compile Include="Settings\AutoCompleteSetting.cs" />
+    <Compile Include="Settings\AutoCompleteSettings.cs" />
     <Compile Include="Settings\CodeInspectionConfigProvider.cs" />
     <Compile Include="Settings\ExperimentalFeatures.cs" />
     <Compile Include="Settings\DefaultSettings.cs" />

Rubberduck.Core/Rubberduck.Core.csproj

@@ -0,0 +1,48 @@
+using System.Collections.Generic;
+using System.Linq;
+using Rubberduck.AutoComplete;
+using Rubberduck.Parsing.VBA;
+using Rubberduck.SettingsProvider;
+
+namespace Rubberduck.Settings
+{
+    public class AutoCompleteConfigProvider : IConfigProvider<AutoCompleteSettings>
+    {
+        private readonly IPersistanceService<AutoCompleteSettings> _persister;
+        private readonly AutoCompleteSettings _defaultSettings;
+        private readonly HashSet<string> _foundAutoCompleteKeys;
+
+        public AutoCompleteConfigProvider(IPersistanceService<AutoCompleteSettings> persister, IAutoCompleteProvider provider)
+        {
+            _persister = persister;
+            _foundAutoCompleteKeys = provider.AutoCompletes.Select(e => e.GetType().Name).ToHashSet();
+            _defaultSettings = new DefaultSettings<AutoCompleteSettings>().Default;
+            _defaultSettings.Settings = _defaultSettings.Settings.Where(setting => _foundAutoCompleteKeys.Contains(setting.Key)).ToHashSet();
+
+        }
+
+        public AutoCompleteSettings Create()
+        {
+            var prototype = new AutoCompleteSettings(_defaultSettings.Settings);
+
+            // Loaded settings don't contain defaults, so we need to use the `Settings` property to combine user settings with defaults.
+            var loaded = _persister.Load(prototype);
+            if (loaded != null)
+            {
+                prototype.Settings = loaded.Settings;
+            }
+
+            return prototype;
+        }
+
+        public AutoCompleteSettings CreateDefaults()
+        {
+            return new AutoCompleteSettings(_defaultSettings.Settings);
+        }
+
+        public void Save(AutoCompleteSettings settings)
+        {
+            _persister.Save(settings);
+        }
+    }
+}

Rubberduck.Core/Settings/AutoCompleteConfigProvider.cs

@@ -0,0 +1,24 @@
+using System.Xml.Serialization;
+using System.Configuration;
+using Rubberduck.AutoComplete;
+
+namespace Rubberduck.Settings
+{
+    [SettingsSerializeAs(SettingsSerializeAs.Xml)]
+    public class AutoCompleteSetting
+    {
+        public AutoCompleteSetting() { /* default ctor required for XML serialization */ }
+
+        public AutoCompleteSetting(IAutoComplete autoComplete)
+        {
+            Key = autoComplete.GetType().Name;
+            IsEnabled = autoComplete.IsEnabled;
+        }
+
+        public string Key { get; set; }
+        public bool IsEnabled { get; set; }
+
+        [XmlIgnore]
+        public string Description => Resources.Settings.SettingsUI.ResourceManager.GetString(Key + "Description");
+    }
+}

Rubberduck.Core/Settings/AutoCompleteSetting.cs

@@ -0,0 +1,113 @@
+using Rubberduck.AutoComplete;
+using Rubberduck.Parsing.VBA;
+using System;
+using System.Collections.Generic;
+using System.Configuration;
+using System.Linq;
+using System.Xml.Serialization;
+
+namespace Rubberduck.Settings
+{
+    public interface IAutoCompleteSettings
+    {
+        HashSet<AutoCompleteSetting> Settings { get; set; }
+    }
+
+    [SettingsSerializeAs(SettingsSerializeAs.Xml)]
+    [XmlType(AnonymousType = true)]
+    public class AutoCompleteSettings : IAutoCompleteSettings
+    {
+        private readonly IEnumerable<AutoCompleteSetting> _defaultSettings;
+        private HashSet<AutoCompleteSetting> _settings = new HashSet<AutoCompleteSetting>();
+
+        public AutoCompleteSettings() { /* default constructor required for XML serialization */ }
+
+        public AutoCompleteSettings(IEnumerable<AutoCompleteSetting> defaultSettings)
+        {
+            _defaultSettings = defaultSettings;
+            _settings = defaultSettings.ToHashSet();
+        }
+
+        [XmlArrayItem("AutoComplete", IsNullable = false)]
+        public HashSet<AutoCompleteSetting> Settings
+        {
+            get => _settings;
+            set
+            {
+                // Enable loading user settings during deserialization
+                if (_defaultSettings == null)
+                {
+                    if (value != null)
+                    {
+                        AddUnique(value);
+                    }
+
+                    return;
+                }
+
+                var defaults = _defaultSettings.ToArray();
+
+                if (value == null || value.Count == 0)
+                {
+                    _settings = new HashSet<AutoCompleteSetting>(defaults);
+                    return;
+                }
+
+                _settings = new HashSet<AutoCompleteSetting>();
+
+                var incoming = value;
+                AddUnique(incoming);
+
+                //Merge any hotkeys that weren't found in the input.
+                foreach (var setting in defaults.Where(setting => _settings.FirstOrDefault(s => s.Key.Equals(setting.Key)) == null))
+                {
+                    setting.IsEnabled &= !IsDuplicate(setting);
+                    _settings.Add(setting);
+                }
+            }
+
+        }
+
+        private void AddUnique(IEnumerable<AutoCompleteSetting> settings)
+        {
+            //Only take the first setting if multiple definitions are found.
+            foreach (var setting in settings.GroupBy(s => s.Key).Select(autocomplete => autocomplete.First()))
+            {
+                //Only allow one hotkey to be enabled with the same key combination.
+                setting.IsEnabled &= !IsDuplicate(setting);
+                _settings.Add(setting);
+            }
+        }
+
+        private bool IsDuplicate(AutoCompleteSetting setting)
+        {
+            return _settings.FirstOrDefault(s => s.Key == setting.Key) != null;
+        }
+
+        public AutoCompleteSetting GetSetting<TAutoComplete>() where TAutoComplete : IAutoComplete
+        {
+            return Settings.FirstOrDefault(s => typeof(TAutoComplete).Name.Equals(s.Key))
+                ?? GetSetting(typeof(TAutoComplete));
+        }
+
+        public AutoCompleteSetting GetSetting(Type autoCompleteType)
+        {
+            try
+            {
+                var existing = Settings.FirstOrDefault(s => autoCompleteType.Name.Equals(s.Key));
+                if (existing != null)
+                {
+                    return existing;
+                }
+                var proto = Convert.ChangeType(Activator.CreateInstance(autoCompleteType, new object[] { null }), autoCompleteType);
+                var setting = new AutoCompleteSetting(proto as IAutoComplete);
+                Settings.Add(setting);
+                return setting;
+            }
+            catch (Exception)
+            {
+                return null;
+            }
+        }
+    }
+}