BadSettingsReader.cs

Go to the documentation of this file.

using BadScript2.Common.Logging;
using BadScript2.IO;
 
using Newtonsoft.Json.Linq;
 
namespace BadScript2.Settings;
 
public class BadSettingsReader
{
    private readonly IFileSystem m_FileSystem;
 
    private readonly BadSettings m_RootSettings;
 
    private readonly string[] m_SourceFiles;
 
    public BadSettingsReader(BadSettings rootSettings, IFileSystem mFileSystem, params string[] sourceFiles)
    {
        m_SourceFiles = sourceFiles;
        m_RootSettings = rootSettings;
        m_FileSystem = mFileSystem;
    }
 
    public BadSettings ReadSettings()
    {
        List<BadSettings> settings = new List<BadSettings> { m_RootSettings };
 
        Queue<string> files = new Queue<string>(m_SourceFiles);
 
        while (files.Count != 0)
        {
            string file = files.Dequeue();
            BadLogger.Log("Reading settings from file: " + file, "SettingsReader");
            settings.Add(CreateSettings(ReadJsonFile(file), file));
        }
 
        BadSettings s = new BadSettings(string.Empty);
        s.Populate(true, settings.ToArray());
 
        BadLogger.Log("Resolving environment variables", "SettingsReader");
        BadSettings.ResolveEnvironmentVariables(s);
 
        ReadDynamicSettings(s);
 
        return s;
    }
 
    private JToken ReadJsonFile(string fileName)
    {
        string json = m_FileSystem.ReadAllText(fileName);
        JToken token = JToken.Parse(json);
 
        return token;
    }
 
    private static BadSettings CreateSettings(JToken? token, string path)
    {
        if (token is
            not { Type: JTokenType.Object })
        {
            return new BadSettings(token, path);
        }
 
        Dictionary<string, BadSettings> settings = new Dictionary<string, BadSettings>();
        JObject obj = (JObject)token;
 
        foreach (KeyValuePair<string, JToken?> keyValuePair in obj)
        {
            settings.Add(keyValuePair.Key, CreateSettings(keyValuePair.Value, path));
        }
 
        return new BadSettings(settings, path);
    }
 
 
    private void ReadDynamicSettings(BadSettings settings)
    {
        BadLogger.Log("Processing Dynamic Includes", "SettingsReader");
        BadSettings? elems = settings.FindProperty("SettingsBuilder.Include");
        string[]? includes = elems?.GetValue<string[]>();
 
        if (includes == null)
        {
            return;
        }
 
        elems?.SetValue(null);
 
        do
        {
            List<BadSettings> setting = new List<BadSettings>();
 
            foreach (string include in includes)
            {
                if (include.Contains('*'))
                {
                    bool allDirs = include.Contains("**");
 
                    string[] parts = include.Split(new[] { '*' },
                                                   StringSplitOptions.RemoveEmptyEntries
                                                  );
                    string path = parts[0];
                    string extension = parts[1];
 
                    IEnumerable<string> files = m_FileSystem.GetFiles(path,
                                                                      extension,
                                                                      allDirs
                                                                     );
 
                    setting.AddRange(files.Select(f =>
                                                  {
                                                      BadLogger.Log("Reading settings from file: " + f,
                                                                    "SettingsReader"
                                                                   );
 
                                                      return CreateSettings(ReadJsonFile(f), f);
                                                  }
                                                 )
                                    );
                }
                else
                {
                    BadLogger.Log("Reading settings from file: " + include, "SettingsReader");
                    setting.Add(CreateSettings(ReadJsonFile(include), include));
                }
            }
 
            settings.Populate(true, setting.ToArray());
 
            BadLogger.Log("Resolving environment variables", "SettingsReader");
            BadSettings.ResolveEnvironmentVariables(settings);
 
            elems = settings.FindProperty("SettingsBuilder.Include");
            includes = elems?.GetValue<string[]>();
        }
        while (includes != null);
 
        settings.RemoveProperty("SettingsBuilder");
    }
}