Add support for immutable settings

Author: InfinityGhost

TabletBot.Common/AppData.cs

@@ -0,0 +1,55 @@
+using System;
+using System.IO;
+
+namespace TabletBot.Common
+{
+    public static class AppData
+    {
+        private const string SETTINGS_FILENAME = "settings.json";
+        private const string STATE_FILENAME = "state.json";
+
+        public static Settings Settings => ImmutableSettings ?? MutableSettings ?? new Settings();
+        public static Settings? ImmutableSettings => ImmutableSettingsFile == null ? null : Read<Settings>(ImmutableSettingsFile);
+        public static Settings? MutableSettings => Read<Settings>(UserSettingsFile);
+        public static State State => Read<State>(StateFile) ?? new State();
+
+        public static FileInfo SettingsFile => ImmutableSettingsFile ?? UserSettingsFile;
+        private static FileInfo? ImmutableSettingsFile => string.IsNullOrEmpty(ImmutableSettingsPath) ? null : new FileInfo(ImmutableSettingsPath);
+        private static FileInfo UserSettingsFile => new FileInfo(MutableSettingsPath);
+        public static FileInfo StateFile => new FileInfo(StatePath);
+
+        private static string? ImmutableSettingsPath => Environment.GetEnvironmentVariable("TABLETBOT_SETTINGS");
+        private static string MutableSettingsPath => Path.Join(GetLocalAppdata(), SETTINGS_FILENAME);
+        private static string StatePath => Path.Join(GetLocalAppdata(), STATE_FILENAME);
+
+        private static string GetLocalAppdata()
+        {
+            if (Environment.GetEnvironmentVariable("TABLETBOT_DATA") is string appdata)
+            {
+                return appdata;
+            }
+            if (OperatingSystem.IsWindows())
+            {
+                var localappdata = Environment.GetEnvironmentVariable("LOCALAPPDATA");
+                return Path.Join(localappdata, "TabletBot");
+            }
+            if (OperatingSystem.IsLinux())
+            {
+                var home = Environment.GetEnvironmentVariable("HOME");
+                return Path.Join(home, ".config", "TabletBot");
+            }
+            if (OperatingSystem.IsMacOS())
+            {
+                var macHome = Environment.GetEnvironmentVariable("HOME");
+                return Path.Join(macHome, "Library", "Application Support", "TabletBot");
+            }
+
+            throw new PlatformNotSupportedException("This platform is unsupported.");
+        }
+
+        private static T? Read<T>(FileInfo file)
+        {
+            return file.Exists ? Serialization.Deserialize<T>(file) : default;
+        }
+    }
+}

TabletBot.Common/GuildSettings.cs

@@ -0,0 +1,7 @@
+namespace TabletBot.Common
+{
+    public sealed class GuildSettings
+    {
+
+    }
+}

TabletBot.Common/Log.cs

@@ -1,11 +1,10 @@
 using System;
-using System.Threading.Tasks;
 
 namespace TabletBot.Common
 {
     public static class Log
     {
-        public static event Action<LogMessage> Output;
+        public static event Action<LogMessage>? Output;
 
         public static void Write(string group, string text, LogLevel level = LogLevel.Info)
         {

TabletBot.Common/Platform.cs

@@ -0,0 +1,52 @@
+using System.IO;
+using JetBrains.Annotations;
+using Newtonsoft.Json;
+
+namespace TabletBot.Common
+{
+    [UsedImplicitly(ImplicitUseTargetFlags.WithInheritors | ImplicitUseTargetFlags.WithMembers)]
+    public abstract class Serializable
+    {
+        [JsonIgnore]
+        public abstract FileInfo File { get; }
+
+        [JsonIgnore]
+        public bool Mutable
+        {
+            get
+            {
+                if (File.Exists)
+                    return (File.Attributes & FileAttributes.ReadOnly) == 0;
+
+                var dir = File.Directory;
+                while (dir is { Exists: false })
+                    dir = dir.Parent;
+
+                if (dir == null)
+                    return false;
+
+                return (dir.Attributes & FileAttributes.ReadOnly) == 0;
+            }
+        }
+
+        public void Write()
+        {
+            if (!Mutable)
+            {
+                Log.Write("IO", $"Unable to write to '{File.FullName}'.", LogLevel.Error);
+                return;
+            }
+
+            if (File.Directory is { Exists: false })
+                File.Directory.Create();
+
+            using (var fs = File.Create())
+                Serialization.Serialize(fs, this);
+        }
+
+        public override string ToString()
+        {
+            return JsonConvert.SerializeObject(this, Formatting.Indented);
+        }
+    }
+}

TabletBot.Common/Reflection/Extensions.cs

@@ -0,0 +1,54 @@
+using System.IO;
+using JetBrains.Annotations;
+using Newtonsoft.Json;
+
+namespace TabletBot.Common
+{
+    [UsedImplicitly(ImplicitUseTargetFlags.Members)]
+    public class Serialization
+    {
+        private static readonly JsonSerializer Serializer = new JsonSerializer
+        {
+            Formatting = Formatting.Indented
+        };
+
+        public static T Deserialize<T>(FileInfo file)
+        {
+            using (var fs = file.OpenRead())
+                return Deserialize<T>(fs);
+        }
+
+        public static T Deserialize<T>(Stream stream)
+        {
+            using (var sr = new StreamReader(stream))
+            using (var jr = new JsonTextReader(sr))
+                return Deserialize<T>(jr);
+        }
+
+        public static T Deserialize<T>(JsonTextReader textReader)
+        {
+            return Serializer.Deserialize<T>(textReader)!;
+        }
+
+        public static void Serialize(FileInfo file, object value)
+        {
+            if (file.Exists)
+                file.Delete();
+
+            using (var fs = file.Create())
+                Serialize(fs, value);
+        }
+
+        public static void Serialize(Stream stream, object value)
+        {
+            using (var sw = new StreamWriter(stream))
+            using (var jw = new JsonTextWriter(sw))
+                Serialize(jw, value);
+        }
+
+        public static void Serialize(JsonTextWriter textWriter, object value)
+        {
+            Serializer.Serialize(textWriter, value);
+        }
+    }
+}

TabletBot.Common/Serializable.cs

@@ -1,13 +1,8 @@
-using System.Collections.ObjectModel;
 using System.IO;
-using System.Text.Json;
-using System.Text.Json.Serialization;
-using System.Threading.Tasks;
-using TabletBot.Common.Store;
 
 namespace TabletBot.Common
 {
-    public sealed class Settings
+    public sealed class Settings : Serializable
     {
         private const ulong MAIN_GUILD_ID = 615607687467761684;
         private const ulong LOG_MESSAGE_CHANNEL_ID = 715344685853442198;
@@ -26,47 +21,6 @@ public sealed class Settings
 
         public LogLevel LogLevel { set; get; } = LogLevel.Debug;
 
-        public Collection<RoleManagementMessageStore> ReactiveRoles { set; get; } = new Collection<RoleManagementMessageStore>();
-        public Collection<SnippetStore> Snippets { set; get; } = new Collection<SnippetStore>();
-
-        [JsonIgnore]
-        public bool RunAsUnit { set; get; } = false;
-
-        private static readonly JsonSerializerOptions SerializerOptions = new JsonSerializerOptions
-        {
-            WriteIndented = true
-        };
-
-        public async Task Write(FileInfo file)
-        {
-            if (file.Directory is { Exists: false })
-                file.Directory.Create();
-            await using (var fs = file.Create())
-                await JsonSerializer.SerializeAsync(fs, this, SerializerOptions);
-        }
-
-        public static async Task<Settings> Read(FileInfo file)
-        {
-            await using (var fs = file.OpenRead())
-                return await JsonSerializer.DeserializeAsync<Settings>(fs);
-        }
-
-        public async Task<string> ExportAsync()
-        {
-            await using (var ms = new MemoryStream())
-            {
-                await JsonSerializer.SerializeAsync(ms, this, SerializerOptions);
-                ms.Position = 0;
-                using (var sr = new StreamReader(ms))
-                    return await sr.ReadToEndAsync();
-            }
-        }
-
-        public async Task Overwrite()
-        {
-            Platform.SettingsFile.Refresh();
-            if (Platform.SettingsFile.Exists)
-                await Write(Platform.SettingsFile);
-        }
+        public override FileInfo File { get; } = AppData.SettingsFile;
     }
 }

TabletBot.Common/Serialization.cs

@@ -0,0 +1,18 @@
+using System.Collections.ObjectModel;
+using System.IO;
+using Newtonsoft.Json;
+using TabletBot.Common.Store;
+
+namespace TabletBot.Common
+{
+    public sealed class State : Serializable
+    {
+        public Collection<RoleManagementMessage> ReactiveRoles { set; get; } = new Collection<RoleManagementMessage>();
+        public Collection<Snippet> Snippets { set; get; } = new Collection<Snippet>();
+
+        [JsonIgnore]
+        public bool RunAsUnit { set; get; }
+
+        public override FileInfo File { get; } = AppData.StateFile;
+    }
+}

TabletBot.Common/Settings.cs

@@ -1,12 +1,11 @@
+using JetBrains.Annotations;
+
 namespace TabletBot.Common.Store
 {
-    public class RoleManagementMessageStore
+    [UsedImplicitly(ImplicitUseTargetFlags.Members)]
+    public class RoleManagementMessage
     { 
-        public RoleManagementMessageStore()
-        {
-        }
-
-        public RoleManagementMessageStore(ulong messageId, ulong targetRole, string emote)
+        public RoleManagementMessage(ulong messageId, ulong targetRole, string emote)
         {
             MessageId = messageId;
             RoleId = targetRole;