Flow.Launcher/Plugins/Flow.Launcher.Plugin.Explorer/Search/EnvironmentVariables.cs

using System;
using System.Collections;
using System.Collections.Generic;
using System.IO;
using System.Text;

namespace Flow.Launcher.Plugin.Explorer.Search
{
    public static class EnvironmentVariables
    {
        private static Dictionary<string, string> _envStringPaths = null;
        private static Dictionary<string, string> EnvStringPaths
        {
            get
            {
                if (_envStringPaths == null)
                {
                    _envStringPaths = LoadEnvironmentStringPaths();
                }
                return _envStringPaths;
            }
        }

        internal static bool IsEnvironmentVariableSearch(string search)
        {
            return search.StartsWith("%")
                    && search != "%%"
                    && !search.Contains('\\')
                    && EnvStringPaths.Count > 0;
        }

        internal static bool BeginsWithEnvironmentVar(string search)
        {
            return search[0] == '%' && search[1..].Contains("%\\");
        }

        internal static Dictionary<string, string> LoadEnvironmentStringPaths()
        {
            var envStringPaths = new Dictionary<string, string>(StringComparer.InvariantCultureIgnoreCase);

            foreach (DictionaryEntry special in Environment.GetEnvironmentVariables())
            {
                var path = special.Value.ToString();
                if (Directory.Exists(path))
                {
                    // we add a trailing slash to the path to make sure drive paths become valid absolute paths.
                    // for example, if %systemdrive% is C: we turn it to C:\
                    path = path.TrimEnd(Path.DirectorySeparatorChar) + Path.DirectorySeparatorChar;

                    // if we don't have an absolute path, we use Path.GetFullPath to get one.
                    // for example, if %homepath% is \Users\John we turn it to C:\Users\John
                    path = Path.IsPathFullyQualified(path) ? path : Path.GetFullPath(path);

                    // Variables are returned with a mixture of all upper/lower case. 
                    // Call ToLower() to make the results look consistent
                    envStringPaths.Add(special.Key.ToString().ToLower(), path);
                }
            }

            return envStringPaths;
        }

        internal static string TranslateEnvironmentVariablePath(string environmentVariablePath)
        {
            return Environment.ExpandEnvironmentVariables(environmentVariablePath);
        }

        internal static List<Result> GetEnvironmentStringPathSuggestions(string querySearch, Query query, PluginInitContext context)
        {
            var results = new List<Result>();

            var search = querySearch;

            if (querySearch.EndsWith("%") && search.Length > 1)
            {
                // query starts and ends with a %, find an exact match from env-string paths
                search = querySearch.Substring(1, search.Length - 2);

                if (EnvStringPaths.ContainsKey(search))
                {
                    var expandedPath = EnvStringPaths[search];

                    results.Add(ResultManager.CreateFolderResult($"%{search}%", expandedPath, expandedPath, query));

                    return results;
                }
            }

            if (querySearch == "%")
            {
                search = ""; // Get all paths
            }
            else
            {
                search = search.Substring(1);
            }

            foreach (var p in EnvStringPaths)
            {
                if (p.Key.StartsWith(search, StringComparison.InvariantCultureIgnoreCase))
                {
                    results.Add(ResultManager.CreateFolderResult($"%{p.Key}%", p.Value, p.Value, query));
                }
            }

            return results;
        }
    }
}