Refactor the XmlPersistanceService to use PersistancePathProvider

Author: bclothier

Rubberduck.SettingsProvider/IPersistanceService.cs

@@ -2,8 +2,8 @@
 {
     public interface IPersistanceService<T> where T : new()
     {
-        void Save(T settings);
-        T Load(T settings);
+        void Save(T settings, string nonDefaultFilePath = null);
+        T Load(T settings, string nonDefaultFilePath = null);
     }
 
     public interface IFilePersistanceService<T> : IPersistanceService<T> where T : new()

Rubberduck.SettingsProvider/PersistancePathProvider.cs

@@ -12,6 +12,9 @@ static PersistancePathProvider()
             LazyInstance = new Lazy<IPersistancePathProvider>(() => new PersistancePathProvider());
         }
 
+        // Disallow instancing of the class except via static method
+        private PersistancePathProvider() { }
+
         public string DataRootPath => Path.Combine(
             Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData),
             "Rubberduck");

Rubberduck.SettingsProvider/XmlContractPersistanceService.cs

@@ -15,23 +15,26 @@ namespace Rubberduck.SettingsProvider
             RootNamespace = XmlDictionaryString.Empty            
         };
 
+        public XmlContractPersistanceService(IPersistancePathProvider pathProvider) : base(pathProvider) { }
+
         private string _filePath;
         public override string FilePath
         {
             get => _filePath ?? Path.Combine(RootPath, DefaultConfigFile);
             set => _filePath = value;
         }
 
-        public override T Load(T toDeserialize)
+        public override T Load(T toDeserialize, string nonDefaultFilePath = null)
         {
-            if (!File.Exists(FilePath))
+            var filePath = string.IsNullOrWhiteSpace(nonDefaultFilePath) ? FilePath : nonDefaultFilePath;
+            if (!File.Exists(filePath))
             {
                 return Cached;
             }
 
             try
             {
-                using (var stream = new FileStream(FilePath, FileMode.Open, FileAccess.Read))
+                using (var stream = new FileStream(filePath, FileMode.Open, FileAccess.Read))
                 using (var reader = XmlReader.Create(stream))
                 {
                     var serializer = new DataContractSerializer(typeof(T));
@@ -44,11 +47,12 @@ public override T Load(T toDeserialize)
             }
         }
 
-        public override void Save(T toSerialize)
+        public override void Save(T toSerialize, string nonDefaultFilePath = null)
         {
-            EnsurePathExists();
+            var filePath = string.IsNullOrWhiteSpace(nonDefaultFilePath) ? FilePath : nonDefaultFilePath;
+            EnsurePathExists(filePath);
 
-            using (var stream = new FileStream(FilePath, FileMode.Create, FileAccess.Write))
+            using (var stream = new FileStream(filePath, FileMode.Create, FileAccess.Write))
             using (var writer = XmlWriter.Create(stream, OutputXmlSettings))
             {
                 var serializer = new DataContractSerializer(typeof(T), SerializerSettings);

Rubberduck.SettingsProvider/XmlPersistanceService.cs

@@ -10,9 +10,12 @@ namespace Rubberduck.SettingsProvider
     public class XmlPersistanceService<T> : XmlPersistanceServiceBase<T> 
         where T : class, IEquatable<T>, new()
     {
-        public override T Load(T toDeserialize)
+        public XmlPersistanceService(IPersistancePathProvider pathProvider) : base(pathProvider) { }
+
+        public override T Load(T toDeserialize, string nonDefaultFilePath = null)
         {
-            var doc = GetConfigurationDoc(FilePath);
+            var filePath = string.IsNullOrWhiteSpace(nonDefaultFilePath) ? FilePath : nonDefaultFilePath;
+            var doc = GetConfigurationDoc(filePath);
             var node = GetNodeByName(doc, typeof(T).Name);
             if (node == null)
             {
@@ -35,9 +38,10 @@ public override T Load(T toDeserialize)
         }
 
         [SuppressMessage("Microsoft.Usage", "CA2202:Do not dispose objects multiple times")] //This is fine. StreamWriter disposes the MemoryStream, but calling twice is a NOP.
-        public override void Save(T toSerialize)
+        public override void Save(T toSerialize, string nonDefaultFilePath = null)
         {
-            var doc = GetConfigurationDoc(FilePath);
+            var filePath = string.IsNullOrWhiteSpace(nonDefaultFilePath) ? FilePath : nonDefaultFilePath;
+            var doc = GetConfigurationDoc(filePath);
             var node = GetNodeByName(doc, typeof(T).Name);
 
             using (var stream = new MemoryStream())

Rubberduck.SettingsProvider/XmlPersistanceServiceBase.cs

@@ -28,9 +28,8 @@ namespace Rubberduck.SettingsProvider
 
         protected T Cached { get; set; }
 
-        protected XmlPersistanceServiceBase()
+        protected XmlPersistanceServiceBase(IPersistancePathProvider pathProvider)
         {
-            var pathProvider = PersistancePathProvider.Instance;
             RootPath = pathProvider.DataRootPath;
         }
 
@@ -41,9 +40,9 @@ public virtual string FilePath
             set => _filePath = value;
         }
 
-        public abstract T Load(T toDeserialize);
+        public abstract T Load(T toDeserialize, string nonDefaultFilePath = null);
 
-        public abstract void Save(T toSerialize);
+        public abstract void Save(T toSerialize, string nonDefaultFilePath = null);
 
         protected static T FailedLoadReturnValue()
         {
@@ -81,9 +80,10 @@ protected static XElement GetNodeByName(XContainer doc, string name)
             return doc.Descendants().FirstOrDefault(e => e.Name.LocalName.Equals(name));
         }
 
-        protected void EnsurePathExists()
+        protected void EnsurePathExists(string nonDefaultFilePath = null)
         {
-            var folder = Path.GetDirectoryName(FilePath);
+            var filePath = string.IsNullOrWhiteSpace(nonDefaultFilePath) ? FilePath : nonDefaultFilePath;
+            var folder = Path.GetDirectoryName(filePath);
             if (folder != null && !Directory.Exists(folder))
             {
                 Directory.CreateDirectory(folder);