Mirrors/PowerToys
1
0
Fork 0
mirror of https://github.com/microsoft/PowerToys.git synced 2026-04-07 19:57:07 +02:00
Code Issues Packages Projects Releases Wiki Activity

Made Plugin Folder Unit tests & Expanding enviroment search (#6600)

Browse Source 
* Made Plugin Folder Unit tests. Fixes '>' not recursive searching (with max). Added that paths with an UnauthorizedAccessException are ignored. Added expanding enviroment search.

* Fixed some merging errors

* Added feedback from review

* Made the change that  ryanbodrug-microsoft suggested

* Stupid merge request... fixed

Co-authored-by: p-storm <paul.de.man@gmail.com>
This commit is contained in:
P-Storm
2020-10-01 05:37:46 +02:00
committed by GitHub
parent b2c00b1e1a
commit 5c84de5400
31 changed files with 1264 additions and 296 deletions
Download Patch File Download Diff File Expand all files Collapse all files

16
src/modules/launcher/Plugins/Microsoft.Plugin.Folder/IFolderProcessor.cs Normal file
View File

@@ -0,0 +1,16 @@
// Copyright (c) Microsoft Corporation
// The Microsoft Corporation licenses this file to you under the MIT license.
// See the LICENSE file in the project root for more information.
using System.Collections.Generic;
using Microsoft.Plugin.Folder.Sources;
using Microsoft.Plugin.Folder.Sources.Result;
using Wox.Plugin;
namespace Microsoft.Plugin.Folder
{
internal interface IFolderProcessor
{
IEnumerable<IItemResult> Results(string actionKeyword, string search);
}
}

34
src/modules/launcher/Plugins/Microsoft.Plugin.Folder/InternalDirectoryProcessor.cs Normal file
View File

@@ -0,0 +1,34 @@
// Copyright (c) Microsoft Corporation
// The Microsoft Corporation licenses this file to you under the MIT license.
// See the LICENSE file in the project root for more information.
using System.Collections.Generic;
using System.Linq;
using Microsoft.Plugin.Folder.Sources;
using Microsoft.Plugin.Folder.Sources.Result;
using Wox.Plugin;
namespace Microsoft.Plugin.Folder
{
public class InternalDirectoryProcessor : IFolderProcessor
{
private readonly IFolderHelper _folderHelper;
private readonly IQueryInternalDirectory _internalDirectory;
public InternalDirectoryProcessor(IFolderHelper folderHelper, IQueryInternalDirectory internalDirectory)
{
_folderHelper = folderHelper;
_internalDirectory = internalDirectory;
}
public IEnumerable<IItemResult> Results(string actionKeyword, string search)
{
if (!_folderHelper.IsDriveOrSharedFolder(search))
{
return Enumerable.Empty<IItemResult>();
}
return _internalDirectory.Query(search);
}
}
}

329
src/modules/launcher/Plugins/Microsoft.Plugin.Folder/Main.cs
View File

@@ -4,20 +4,10 @@
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Text.RegularExpressions;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Media;
using Microsoft.Plugin.Folder.Sources;
using Microsoft.PowerToys.Settings.UI.Lib;
using Microsoft.VisualBasic;
using Newtonsoft.Json;
using Wox.Infrastructure;
using Wox.Infrastructure.Logger;
using Wox.Infrastructure.Storage;
using Wox.Plugin;
@@ -30,13 +20,19 @@ namespace Microsoft.Plugin.Folder
public const string DeleteFileFolderImagePath = "Images\\delete.dark.png";
public const string CopyImagePath = "Images\\copy.dark.png";
private const string _fileExplorerProgramName = "explorer";
private static readonly PluginJsonStorage<FolderSettings> _storage = new PluginJsonStorage<FolderSettings>();
private static readonly FolderSettings _settings = _storage.Load();
private static List<string> _driverNames;
private static readonly IQueryInternalDirectory _internalDirectory = new QueryInternalDirectory(_settings, new QueryFileSystemInfo());
private static readonly FolderHelper _folderHelper = new FolderHelper(new DriveInformation(), new FolderLinksSettings(_settings));
private static readonly ICollection<IFolderProcessor> _processors = new IFolderProcessor[]
{
new UserFolderProcessor(_folderHelper),
new InternalDirectoryProcessor(_folderHelper, _internalDirectory),
};
private static PluginInitContext _context;
private IContextMenu _contextMenuLoader;
private static string warningIconPath;
private bool _disposed;
public void Save()
@@ -49,35 +45,6 @@ namespace Microsoft.Plugin.Folder
throw new NotImplementedException();
}
public void Init(PluginInitContext context)
{
_context = context ?? throw new ArgumentNullException(nameof(context));
_contextMenuLoader = new ContextMenuLoader(context);
InitialDriverList();
_context.API.ThemeChanged += OnThemeChanged;
UpdateIconPath(_context.API.GetCurrentTheme());
}
private static void UpdateIconPath(Theme theme)
{
if (theme == Theme.Light || theme == Theme.HighContrastWhite)
{
warningIconPath = "Images/Warning.light.png";
}
else
{
warningIconPath = "Images/Warning.dark.png";
}
}
[System.Diagnostics.CodeAnalysis.SuppressMessage("StyleCop.CSharp.NamingRules", "SA1313:Parameter names should begin with lower-case letter", Justification = "The parameter is unused")]
private void OnThemeChanged(Theme _, Theme newTheme)
{
UpdateIconPath(newTheme);
}
[System.Diagnostics.CodeAnalysis.SuppressMessage("Globalization", "CA1308:Normalize strings to uppercase", Justification = "Do not want to change the behavior of the application, but want to enforce static analysis")]
public List<Result> Query(Query query)
{
if (query == null)
@@ -85,283 +52,55 @@ namespace Microsoft.Plugin.Folder
throw new ArgumentNullException(paramName: nameof(query));
}
var results = GetFolderPluginResults(query);
var expandedName = FolderHelper.Expand(query.Search);
// todo why was this hack here?
foreach (var result in results)
{
result.Score += 10;
}
return results;
return _processors.SelectMany(processor => processor.Results(query.ActionKeyword, expandedName))
.Select(res => res.Create(_context.API))
.Select(AddScore)
.ToList();
}
[System.Diagnostics.CodeAnalysis.SuppressMessage("Globalization", "CA1308:Normalize strings to uppercase", Justification = "Do not want to change the behavior of the application, but want to enforce static analysis")]
public static List<Result> GetFolderPluginResults(Query query)
public void Init(PluginInitContext context)
{
var results = GetUserFolderResults(query);
string search = query.Search.ToLower(CultureInfo.InvariantCulture);
_context = context ?? throw new ArgumentNullException(nameof(context));
_contextMenuLoader = new ContextMenuLoader(context);
if (!IsDriveOrSharedFolder(search))
{
return results;
}
results.AddRange(QueryInternalDirectoryExists(query));
return results;
_context.API.ThemeChanged += OnThemeChanged;
UpdateIconPath(_context.API.GetCurrentTheme());
}
[System.Diagnostics.CodeAnalysis.SuppressMessage("Design", "CA1031:Do not catch general exception types", Justification = "We want to keep the process alive and instead inform the user of the error")]
private static bool OpenFileOrFolder(string program, string path)
{
try
{
Process.Start(program, path);
}
catch (Exception e)
{
string messageBoxTitle = string.Format(CultureInfo.InvariantCulture, "{0} {1}", Properties.Resources.wox_plugin_folder_select_folder_OpenFileOrFolder_error_message, path);
Log.Exception($"Failed to open {path} in explorer, {e.Message}", e, MethodBase.GetCurrentMethod().DeclaringType);
_context.API.ShowMsg(messageBoxTitle, e.Message);
}
return true;
}
private static bool IsDriveOrSharedFolder(string search)
{
if (search == null)
{
throw new ArgumentNullException(nameof(search));
}
if (search.StartsWith(@"\\", StringComparison.InvariantCulture))
{ // share folder
return true;
}
if (_driverNames != null && _driverNames.Any(search.StartsWith))
{ // normal drive letter
return true;
}
if (_driverNames == null && search.Length > 2 && char.IsLetter(search[0]) && search[1] == ':')
{ // when we don't have the drive letters we can try...
return true; // we don't know so let's give it the possibility
}
return false;
}
private static Result CreateFolderResult(string title, string subtitle, string path, Query query)
{
return new Result
{
Title = title,
IcoPath = path,
SubTitle = string.Format(CultureInfo.InvariantCulture, "{0}: {1}", Properties.Resources.wox_plugin_folder_plugin_name, subtitle),
QueryTextDisplay = path,
TitleHighlightData = StringMatcher.FuzzySearch(query.Search, title).MatchData,
ContextData = new SearchResult { Type = ResultType.Folder, FullPath = path },
Action = c =>
{
return OpenFileOrFolder(_fileExplorerProgramName, path);
},
};
}
[System.Diagnostics.CodeAnalysis.SuppressMessage("Globalization", "CA1308:Normalize strings to uppercase", Justification = "Do not want to change the behavior of the application, but want to enforce static analysis")]
private static List<Result> GetUserFolderResults(Query query)
public static IEnumerable<Result> GetFolderPluginResults(Query query)
{
if (query == null)
{
throw new ArgumentNullException(paramName: nameof(query));
}
string search = query.Search.ToLower(CultureInfo.InvariantCulture);
var userFolderLinks = _settings.FolderLinks.Where(
x => x.Nickname.StartsWith(search, StringComparison.OrdinalIgnoreCase));
var results = userFolderLinks.Select(item =>
CreateFolderResult(item.Nickname, item.Path, item.Path, query)).ToList();
return results;
var expandedName = FolderHelper.Expand(query.Search);
return _processors.SelectMany(processor => processor.Results(query.ActionKeyword, expandedName))
.Select(res => res.Create(_context.API))
.Select(AddScore);
}
[System.Diagnostics.CodeAnalysis.SuppressMessage("Globalization", "CA1308:Normalize strings to uppercase", Justification = "Do not want to change the behavior of the application, but want to enforce static analysis")]
private static void InitialDriverList()
private static void UpdateIconPath(Theme theme)
{
if (_driverNames == null)
{
_driverNames = new List<string>();
var allDrives = DriveInfo.GetDrives();
foreach (DriveInfo driver in allDrives)
{
_driverNames.Add(driver.Name.ToLower(CultureInfo.InvariantCulture).TrimEnd('\\'));
}
}
QueryInternalDirectory.SetWarningIcon(theme);
}
private static readonly char[] _specialSearchChars = new char[]
[System.Diagnostics.CodeAnalysis.SuppressMessage("StyleCop.CSharp.NamingRules", "SA1313:Parameter names should begin with lower-case letter", Justification = "The parameter is unused")]
private static void OnThemeChanged(Theme _, Theme newTheme)
{
'?', '*', '>',
};
[System.Diagnostics.CodeAnalysis.SuppressMessage("Globalization", "CA1308:Normalize strings to uppercase", Justification = "Do not want to change the behavior of the application, but want to enforce static analysis")]
private static List<Result> QueryInternalDirectoryExists(Query query)
{
var search = query.Search;
var results = new List<Result>();
var hasSpecial = search.IndexOfAny(_specialSearchChars) >= 0;
string incompleteName = string.Empty;
if (hasSpecial || !Directory.Exists(search + "\\"))
{
// if folder doesn't exist, we want to take the last part and use it afterwards to help the user
// find the right folder.
int index = search.LastIndexOf('\\');
if (index > 0 && index < (search.Length - 1))
{
incompleteName = search.Substring(index + 1).ToLower(CultureInfo.InvariantCulture);
search = search.Substring(0, index + 1);
if (!Directory.Exists(search))
{
return results;
}
}
else
{
return results;
}
}
else
{
// folder exist, add \ at the end of doesn't exist
if (!search.EndsWith("\\", StringComparison.InvariantCulture))
{
search += "\\";
}
}
results.Add(CreateOpenCurrentFolderResult(search));
var searchOption = SearchOption.TopDirectoryOnly;
incompleteName += "*";
// give the ability to search all folder when starting with >
if (incompleteName.StartsWith(">", StringComparison.InvariantCulture))
{
searchOption = SearchOption.AllDirectories;
// match everything before and after search term using supported wildcard '*', ie. *searchterm*
incompleteName = "*" + incompleteName.Substring(1);
}
var folderList = new List<Result>();
var fileList = new List<Result>();
try
{
// search folder and add results
var directoryInfo = new DirectoryInfo(search);
var fileSystemInfos = directoryInfo.GetFileSystemInfos(incompleteName, searchOption);
foreach (var fileSystemInfo in fileSystemInfos)
{
if ((fileSystemInfo.Attributes & FileAttributes.Hidden) == FileAttributes.Hidden)
{
continue;
}
if (fileSystemInfo is DirectoryInfo)
{
var folderSubtitleString = fileSystemInfo.FullName;
folderList.Add(CreateFolderResult(fileSystemInfo.Name, folderSubtitleString, fileSystemInfo.FullName, query));
}
else
{
fileList.Add(CreateFileResult(fileSystemInfo.FullName, query));
}
}
}
catch (Exception e)
{
if (e is UnauthorizedAccessException || e is ArgumentException)
{
results.Add(new Result { Title = e.Message, Score = 501 });
return results;
}
throw;
}
results = results.Concat(folderList.OrderBy(x => x.Title).Take(_settings.MaxFolderResults)).Concat(fileList.OrderBy(x => x.Title).Take(_settings.MaxFileResults)).ToList();
// Show warning message if result has been truncated
if (folderList.Count > _settings.MaxFolderResults || fileList.Count > _settings.MaxFileResults)
{
var preTruncationCount = folderList.Count + fileList.Count;
var postTruncationCount = Math.Min(folderList.Count, _settings.MaxFolderResults) + Math.Min(fileList.Count, _settings.MaxFileResults);
results.Add(CreateTruncatedItemsResult(search, preTruncationCount, postTruncationCount));
}
return results.ToList();
UpdateIconPath(newTheme);
}
private static Result CreateTruncatedItemsResult(string search, int preTruncationCount, int postTruncationCount)
// todo why was this hack here?
private static Result AddScore(Result result)
{
return new Result
{
Title = Properties.Resources.Microsoft_plugin_folder_truncation_warning_title,
QueryTextDisplay = search,
SubTitle = string.Format(CultureInfo.InvariantCulture, Properties.Resources.Microsoft_plugin_folder_truncation_warning_subtitle, postTruncationCount, preTruncationCount),
IcoPath = warningIconPath,
};
}
private static Result CreateFileResult(string filePath, Query query)
{
var result = new Result
{
Title = Path.GetFileName(filePath),
SubTitle = string.Format(CultureInfo.InvariantCulture, "{0}: {1}", Properties.Resources.wox_plugin_folder_plugin_name, filePath),
IcoPath = filePath,
ContextData = new SearchResult { Type = ResultType.File, FullPath = filePath },
TitleHighlightData = StringMatcher.FuzzySearch(query.Search, Path.GetFileName(filePath)).MatchData,
Action = c =>
{
return OpenFileOrFolder(_fileExplorerProgramName, filePath);
},
};
result.Score += 10;
return result;
}
private static Result CreateOpenCurrentFolderResult(string search)
{
var firstResult = string.Format(CultureInfo.InvariantCulture, "{0} {1}", Properties.Resources.wox_plugin_folder_select_folder_first_result_title, search);
var folderName = search.TrimEnd('\\').Split(new[] { Path.DirectorySeparatorChar }, StringSplitOptions.None).Last();
var sanitizedPath = Regex.Replace(search, @"[\/\\]+", "\\");
// A network path must start with \\
if (sanitizedPath.StartsWith("\\", StringComparison.InvariantCulture))
{
sanitizedPath = sanitizedPath.Insert(0, "\\");
}
return new Result
{
Title = firstResult,
QueryTextDisplay = search,
SubTitle = string.Format(CultureInfo.InvariantCulture, "{0}: {1}", Properties.Resources.wox_plugin_folder_plugin_name, Properties.Resources.wox_plugin_folder_select_folder_first_result_subtitle),
IcoPath = search,
Score = 500,
ContextData = new SearchResult { Type = ResultType.Folder, FullPath = search },
Action = c =>
{
return OpenFileOrFolder(_fileExplorerProgramName, search);
},
};
}
public string GetTranslatedPluginTitle()
{
return Properties.Resources.wox_plugin_folder_plugin_name;

70
src/modules/launcher/Plugins/Microsoft.Plugin.Folder/Sources/ExplorerAction.cs Normal file
View File

@@ -0,0 +1,70 @@
// Copyright (c) Microsoft Corporation
// The Microsoft Corporation licenses this file to you under the MIT license.
// See the LICENSE file in the project root for more information.
using System;
using System.Diagnostics;
using System.Globalization;
using System.Reflection;
using System.Text.RegularExpressions;
using System.Windows;
using Wox.Infrastructure.Logger;
using Wox.Plugin;
namespace Microsoft.Plugin.Folder.Sources
{
public class ExplorerAction : IExplorerAction
{
private const string FileExplorerProgramName = "explorer";
public bool Execute(string path, IPublicAPI contextApi)
{
if (contextApi == null)
{
throw new ArgumentNullException(nameof(contextApi));
}
return OpenFileOrFolder(FileExplorerProgramName, path, contextApi);
}
public bool ExecuteSanitized(string search, IPublicAPI contextApi)
{
if (contextApi == null)
{
throw new ArgumentNullException(nameof(contextApi));
}
return Execute(SanitizedPath(search), contextApi);
}
private static string SanitizedPath(string search)
{
var sanitizedPath = Regex.Replace(search, @"[\/\\]+", "\\");
// A network path must start with \\
if (!sanitizedPath.StartsWith("\\", StringComparison.InvariantCulture))
{
return sanitizedPath;
}
return sanitizedPath.Insert(0, "\\");
}
[System.Diagnostics.CodeAnalysis.SuppressMessage("Design", "CA1031:Do not catch general exception types", Justification = "We want to keep the process alive and instead inform the user of the error")]
private static bool OpenFileOrFolder(string program, string path, IPublicAPI contextApi)
{
try
{
Process.Start(program, path);
}
catch (Exception e)
{
string messageBoxTitle = string.Format(CultureInfo.InvariantCulture, "{0} {1}", Properties.Resources.wox_plugin_folder_select_folder_OpenFileOrFolder_error_message, path);
Log.Exception($"Failed to open {path} in {FileExplorerProgramName}, {e.Message}", e, MethodBase.GetCurrentMethod().DeclaringType);
contextApi.ShowMsg(messageBoxTitle, e.Message);
}
return true;
}
}
}

24
src/modules/launcher/Plugins/Microsoft.Plugin.Folder/Sources/FolderLinksSettings.cs Normal file
View File

@@ -0,0 +1,24 @@
// Copyright (c) Microsoft Corporation
// The Microsoft Corporation licenses this file to you under the MIT license.
// See the LICENSE file in the project root for more information.
using System.Collections.Generic;
using Wox.Infrastructure.Storage;
namespace Microsoft.Plugin.Folder.Sources
{
internal class FolderLinksSettings : IFolderLinks
{
private readonly FolderSettings _settings;
public FolderLinksSettings(FolderSettings settings)
{
_settings = settings;
}
public IEnumerable<FolderLink> FolderLinks()
{
return _settings.FolderLinks;
}
}
}

15
src/modules/launcher/Plugins/Microsoft.Plugin.Folder/Sources/IExplorerAction.cs Normal file
View File

@@ -0,0 +1,15 @@
// Copyright (c) Microsoft Corporation
// The Microsoft Corporation licenses this file to you under the MIT license.
// See the LICENSE file in the project root for more information.
using Wox.Plugin;
namespace Microsoft.Plugin.Folder.Sources
{
public interface IExplorerAction
{
bool Execute(string sanitizedPath, IPublicAPI contextApi);
bool ExecuteSanitized(string search, IPublicAPI contextApi);
}
}

13
src/modules/launcher/Plugins/Microsoft.Plugin.Folder/Sources/IFolderLinks.cs Normal file
View File

@@ -0,0 +1,13 @@
// Copyright (c) Microsoft Corporation
// The Microsoft Corporation licenses this file to you under the MIT license.
// See the LICENSE file in the project root for more information.
using System.Collections.Generic;
namespace Microsoft.Plugin.Folder.Sources
{
public interface IFolderLinks
{
IEnumerable<FolderLink> FolderLinks();
}
}

15
src/modules/launcher/Plugins/Microsoft.Plugin.Folder/Sources/IQueryFileSystemInfo.cs Normal file
View File

@@ -0,0 +1,15 @@
// Copyright (c) Microsoft Corporation
// The Microsoft Corporation licenses this file to you under the MIT license.
// See the LICENSE file in the project root for more information.
using System.Collections.Generic;
using System.IO;
using Wox.Infrastructure.FileSystemHelper;
namespace Microsoft.Plugin.Folder.Sources
{
public interface IQueryFileSystemInfo : IDirectoryWrapper
{
IEnumerable<DisplayFileInfo> MatchFileSystemInfo(string search, string incompleteName, SearchOption searchOption);
}
}

14
src/modules/launcher/Plugins/Microsoft.Plugin.Folder/Sources/IQueryInternalDirectory.cs Normal file
View File

@@ -0,0 +1,14 @@
// Copyright (c) Microsoft Corporation
// The Microsoft Corporation licenses this file to you under the MIT license.
// See the LICENSE file in the project root for more information.
using System.Collections.Generic;
using Microsoft.Plugin.Folder.Sources.Result;
namespace Microsoft.Plugin.Folder.Sources
{
public interface IQueryInternalDirectory
{
IEnumerable<IItemResult> Query(string search);
}
}

42
src/modules/launcher/Plugins/Microsoft.Plugin.Folder/Sources/Path/DisplayFileInfo.cs Normal file
View File

@@ -0,0 +1,42 @@
// Copyright (c) Microsoft Corporation
// The Microsoft Corporation licenses this file to you under the MIT license.
// See the LICENSE file in the project root for more information.
using System;
namespace Microsoft.Plugin.Folder.Sources
{
public struct DisplayFileInfo : IEquatable<DisplayFileInfo>
{
public string Name { get; set; }
public string FullName { get; set; }
public DisplayType Type { get; set; }
public override bool Equals(object obj)
{
return obj is DisplayFileInfo other && Equals(other);
}
public override int GetHashCode()
{
return HashCode.Combine(Name, FullName, (int)Type);
}
public bool Equals(DisplayFileInfo other)
{
return Name == other.Name && FullName == other.FullName && Type == other.Type;
}
public static bool operator ==(DisplayFileInfo a, DisplayFileInfo b)
{
return a.Equals(b);
}
public static bool operator !=(DisplayFileInfo a, DisplayFileInfo b)
{
return !(a == b);
}
}
}

12
src/modules/launcher/Plugins/Microsoft.Plugin.Folder/Sources/Path/DisplayType.cs Normal file
View File

@@ -0,0 +1,12 @@
// Copyright (c) Microsoft Corporation
// The Microsoft Corporation licenses this file to you under the MIT license.
// See the LICENSE file in the project root for more information.
namespace Microsoft.Plugin.Folder.Sources
{
public enum DisplayType
{
Directory,
File,
}
}

26
src/modules/launcher/Plugins/Microsoft.Plugin.Folder/Sources/Path/DriveInformation.cs Normal file
View File

@@ -0,0 +1,26 @@
// Copyright (c) Microsoft Corporation
// The Microsoft Corporation licenses this file to you under the MIT license.
// See the LICENSE file in the project root for more information.
using System.Collections.Generic;
using System.Globalization;
using System.IO;
using System.Linq;
namespace Microsoft.Plugin.Folder.Sources
{
internal class DriveInformation : IDriveInformation
{
private static readonly List<string> DriverNames = InitialDriverList().ToList();
[System.Diagnostics.CodeAnalysis.SuppressMessage("Globalization", "CA1308:Normalize strings to uppercase", Justification = "Do not want to change the behavior of the application, but want to enforce static analysis")]
private static IEnumerable<string> InitialDriverList()
{
var directorySeparatorChar = System.IO.Path.DirectorySeparatorChar;
return DriveInfo.GetDrives()
.Select(driver => driver.Name.ToLower(CultureInfo.InvariantCulture).TrimEnd(directorySeparatorChar));
}
public IEnumerable<string> GetDriveNames() => DriverNames;
}
}

81
src/modules/launcher/Plugins/Microsoft.Plugin.Folder/Sources/Path/FolderHelper.cs Normal file
View File

@@ -0,0 +1,81 @@
// Copyright (c) Microsoft Corporation
// The Microsoft Corporation licenses this file to you under the MIT license.
// See the LICENSE file in the project root for more information.
using System;
using System.Collections.Generic;
using System.Collections.Immutable;
using System.Linq;
namespace Microsoft.Plugin.Folder.Sources
{
public class FolderHelper : IFolderHelper
{
private readonly IDriveInformation _driveInformation;
private readonly IFolderLinks _folderLinks;
public FolderHelper(IDriveInformation driveInformation, IFolderLinks folderLinks)
{
_driveInformation = driveInformation;
_folderLinks = folderLinks;
}
public IEnumerable<FolderLink> GetUserFolderResults(string query)
{
if (query == null)
{
throw new ArgumentNullException(paramName: nameof(query));
}
return _folderLinks.FolderLinks()
.Where(x => x.Nickname.StartsWith(query, StringComparison.OrdinalIgnoreCase));
}
public bool IsDriveOrSharedFolder(string search)
{
if (search == null)
{
throw new ArgumentNullException(nameof(search));
}
if (search.StartsWith(@"\\", StringComparison.InvariantCulture))
{ // share folder
return true;
}
var driverNames = _driveInformation.GetDriveNames()
.ToImmutableArray();
if (driverNames.Any())
{
if (driverNames.Any(dn => search.StartsWith(dn, StringComparison.InvariantCultureIgnoreCase)))
{
// normal drive letter
return true;
}
}
else
{
if (search.Length > 2 && ValidDriveLetter(search[0]) && search[1] == ':')
{ // when we don't have the drive letters we can try...
return true; // we don't know so let's give it the possibility
}
}
return false;
}
/// <summary>
/// This check is needed because char.IsLetter accepts more than [A-z]
/// </summary>
public static bool ValidDriveLetter(char c)
{
return c <= 122 && char.IsLetter(c);
}
public static string Expand(string search)
{
return Environment.ExpandEnvironmentVariables(search);
}
}
}

12
src/modules/launcher/Plugins/Microsoft.Plugin.Folder/Sources/Path/IDriveInformation.cs Normal file
View File

@@ -0,0 +1,12 @@
// Copyright (c) Microsoft Corporation
// The Microsoft Corporation licenses this file to you under the MIT license.
// See the LICENSE file in the project root for more information.
using System.Collections.Generic;
namespace Microsoft.Plugin.Folder.Sources
{
public interface IDriveInformation
{
IEnumerable<string> GetDriveNames();
}
}

11
src/modules/launcher/Plugins/Microsoft.Plugin.Folder/Sources/Path/IFolderHelper.cs Normal file
View File

@@ -0,0 +1,11 @@
// Copyright (c) Microsoft Corporation
// The Microsoft Corporation licenses this file to you under the MIT license.
// See the LICENSE file in the project root for more information.
namespace Microsoft.Plugin.Folder.Sources
{
public interface IFolderHelper
{
bool IsDriveOrSharedFolder(string search);
}
}

74
src/modules/launcher/Plugins/Microsoft.Plugin.Folder/Sources/QueryFileSystemInfo.cs Normal file
View File

@@ -0,0 +1,74 @@
// Copyright (c) Microsoft Corporation
// The Microsoft Corporation licenses this file to you under the MIT license.
// See the LICENSE file in the project root for more information.
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using Wox.Infrastructure.FileSystemHelper;
namespace Microsoft.Plugin.Folder.Sources
{
public class QueryFileSystemInfo : DirectoryWrapper, IQueryFileSystemInfo
{
public IEnumerable<DisplayFileInfo> MatchFileSystemInfo(string search, string incompleteName, SearchOption searchOption)
{
// search folder and add results
var directoryInfo = new DirectoryInfo(search);
var fileSystemInfos = directoryInfo.EnumerateFileSystemInfos(incompleteName, searchOption);
return SafeEnumerateFileSystemInfos(fileSystemInfos)
.Where(fileSystemInfo => (fileSystemInfo.Attributes & FileAttributes.Hidden) != FileAttributes.Hidden)
.Select(CreateDisplayFileInfo);
}
private static IEnumerable<FileSystemInfo> SafeEnumerateFileSystemInfos(IEnumerable<FileSystemInfo> fileSystemInfos)
{
using (var enumerator = fileSystemInfos.GetEnumerator())
{
while (true)
{
FileSystemInfo currentFileSystemInfo;
try
{
if (!enumerator.MoveNext())
{
break;
}
currentFileSystemInfo = enumerator.Current;
}
catch (UnauthorizedAccessException)
{
continue;
}
yield return currentFileSystemInfo;
}
}
}
private static DisplayFileInfo CreateDisplayFileInfo(FileSystemInfo fileSystemInfo)
{
return new DisplayFileInfo()
{
Name = fileSystemInfo.Name,
FullName = fileSystemInfo.FullName,
Type = GetDisplayType(fileSystemInfo),
};
}
private static DisplayType GetDisplayType(FileSystemInfo fileSystemInfo)
{
if (fileSystemInfo is DirectoryInfo)
{
return DisplayType.Directory;
}
else
{
return DisplayType.File;
}
}
}
}

188
src/modules/launcher/Plugins/Microsoft.Plugin.Folder/Sources/QueryInternalDirectory.cs Normal file
View File

@@ -0,0 +1,188 @@
// Copyright (c) Microsoft Corporation
// The Microsoft Corporation licenses this file to you under the MIT license.
// See the LICENSE file in the project root for more information.
using System;
using System.Collections.Generic;
using System.Collections.Immutable;
using System.Globalization;
using System.IO;
using System.Linq;
using Microsoft.Plugin.Folder.Sources.Result;
using Wox.Plugin;
namespace Microsoft.Plugin.Folder.Sources
{
public class QueryInternalDirectory : IQueryInternalDirectory
{
private readonly FolderSettings _settings;
private readonly IQueryFileSystemInfo _queryFileSystemInfo;
private static readonly HashSet<char> SpecialSearchChars = new HashSet<char>
{
'?', '*', '>',
};
private static string _warningIconPath;
public QueryInternalDirectory(FolderSettings folderSettings, IQueryFileSystemInfo queryFileSystemInfo)
{
_settings = folderSettings;
_queryFileSystemInfo = queryFileSystemInfo;
}
private static bool HasSpecialChars(string search)
{
return search.Any(c => SpecialSearchChars.Contains(c));
}
public static SearchOption GetSearchOptions(string query)
{
// give the ability to search all folder when it contains a >
if (query.Any(c => c.Equals('>')))
{
return SearchOption.AllDirectories;
}
return SearchOption.TopDirectoryOnly;
}
[System.Diagnostics.CodeAnalysis.SuppressMessage("Globalization", "CA1308:Normalize strings to uppercase", Justification = "Do not want to change the behavior of the application, but want to enforce static analysis")]
private (string search, string incompleteName) Process(string search)
{
string incompleteName = string.Empty;
if (HasSpecialChars(search) || !_queryFileSystemInfo.Exists($@"{search}\"))
{
// if folder doesn't exist, we want to take the last part and use it afterwards to help the user
// find the right folder.
int index = search.LastIndexOf('\\');
// No slashes found, so probably not a folder
if (index <= 0 || index >= search.Length - 1)
{
return default;
}
// Remove everything after the last \ and add *
incompleteName = search.Substring(index + 1)
.ToLower(CultureInfo.InvariantCulture) + "*";
search = search.Substring(0, index + 1);
if (!_queryFileSystemInfo.Exists(search))
{
return default;
}
}
else
{
// folder exist, add \ at the end of doesn't exist
if (!search.EndsWith(@"\", StringComparison.InvariantCulture))
{
search += @"\";
}
}
return (search, incompleteName);
}
public IEnumerable<IItemResult> Query(string querySearch)
{
if (querySearch == null)
{
throw new ArgumentNullException(nameof(querySearch));
}
var processed = Process(querySearch);
if (processed == default)
{
yield break;
}
var (search, incompleteName) = processed;
var searchOption = GetSearchOptions(incompleteName);
if (searchOption == SearchOption.AllDirectories)
{
// match everything before and after search term using supported wildcard '*', ie. *searchterm*
if (string.IsNullOrEmpty(incompleteName))
{
incompleteName = "*";
}
else
{
incompleteName = "*" + incompleteName.Substring(1);
}
}
yield return new CreateOpenCurrentFolderResult(search);
// Note: Take 1000 is so that you don't search the whole system before you discard
var lookup = _queryFileSystemInfo.MatchFileSystemInfo(search, incompleteName, searchOption)
.Take(1000)
.ToLookup(r => r.Type);
var folderList = lookup[DisplayType.Directory].ToImmutableArray();
var fileList = lookup[DisplayType.File].ToImmutableArray();
var fileSystemResult = GenerateFolderResults(search, folderList)
.Concat<IItemResult>(GenerateFileResults(search, fileList))
.ToImmutableArray();
foreach (var result in fileSystemResult)
{
yield return result;
}
// Show warning message if result has been truncated
if (folderList.Length > _settings.MaxFolderResults || fileList.Length > _settings.MaxFileResults)
{
yield return GenerateTruncatedItemResult(folderList.Length + fileList.Length, fileSystemResult.Length);
}
}
private IEnumerable<FileItemResult> GenerateFileResults(string search, IEnumerable<DisplayFileInfo> fileList)
{
return fileList
.Select(fileSystemInfo => new FileItemResult()
{
FilePath = fileSystemInfo.FullName,
Search = search,
})
.OrderBy(x => x.Title)
.Take(_settings.MaxFileResults);
}
private IEnumerable<FolderItemResult> GenerateFolderResults(string search, IEnumerable<DisplayFileInfo> folderList)
{
return folderList
.Select(fileSystemInfo => new FolderItemResult(fileSystemInfo)
{
Search = search,
})
.OrderBy(x => x.Title)
.Take(_settings.MaxFolderResults);
}
private static TruncatedItemResult GenerateTruncatedItemResult(int preTruncationCount, int postTruncationCount)
{
return new TruncatedItemResult()
{
PreTruncationCount = preTruncationCount,
PostTruncationCount = postTruncationCount,
WarningIconPath = _warningIconPath,
};
}
public static void SetWarningIcon(Theme theme)
{
if (theme == Theme.Light || theme == Theme.HighContrastWhite)
{
_warningIconPath = "Images/Warning.light.png";
}
else
{
_warningIconPath = "Images/Warning.dark.png";
}
}
}
}

39
src/modules/launcher/Plugins/Microsoft.Plugin.Folder/Sources/Result/CreateOpenCurrentFolderResult.cs Normal file
View File

@@ -0,0 +1,39 @@
// Copyright (c) Microsoft Corporation
// The Microsoft Corporation licenses this file to you under the MIT license.
// See the LICENSE file in the project root for more information.
using Wox.Plugin;
namespace Microsoft.Plugin.Folder.Sources.Result
{
public class CreateOpenCurrentFolderResult : IItemResult
{
private readonly IExplorerAction _explorerAction;
public string Search { get; set; }
public CreateOpenCurrentFolderResult(string search)
: this(search, new ExplorerAction())
{
}
public CreateOpenCurrentFolderResult(string search, IExplorerAction explorerAction)
{
Search = search;
_explorerAction = explorerAction;
}
public Wox.Plugin.Result Create(IPublicAPI contextApi)
{
return new Wox.Plugin.Result
{
Title = $"Open {Search}",
QueryTextDisplay = Search,
SubTitle = $"Folder: Use > to search within the directory. Use * to search for file extensions. Or use both >*.",
IcoPath = Search,
Score = 500,
Action = c => _explorerAction.ExecuteSanitized(Search, contextApi),
};
}
}
}

35
src/modules/launcher/Plugins/Microsoft.Plugin.Folder/Sources/Result/FileItemResult.cs Normal file
View File

@@ -0,0 +1,35 @@
// Copyright (c) Microsoft Corporation
// The Microsoft Corporation licenses this file to you under the MIT license.
// See the LICENSE file in the project root for more information.
using System.IO;
using Wox.Infrastructure;
using Wox.Plugin;
namespace Microsoft.Plugin.Folder.Sources.Result
{
public class FileItemResult : IItemResult
{
private static readonly IExplorerAction ExplorerAction = new ExplorerAction();
public string FilePath { get; set; }
public string Title => Path.GetFileName(FilePath);
public string Search { get; set; }
public Wox.Plugin.Result Create(IPublicAPI contextApi)
{
var result = new Wox.Plugin.Result
{
Title = Title,
SubTitle = "Folder: " + FilePath,
IcoPath = FilePath,
TitleHighlightData = StringMatcher.FuzzySearch(Search, Path.GetFileName(FilePath)).MatchData,
Action = c => ExplorerAction.Execute(FilePath, contextApi),
ContextData = new SearchResult { Type = ResultType.File, FullPath = FilePath },
};
return result;
}
}
}

36
src/modules/launcher/Plugins/Microsoft.Plugin.Folder/Sources/Result/FileSystemResult.cs Normal file
View File

@@ -0,0 +1,36 @@
// Copyright (c) Microsoft Corporation
// The Microsoft Corporation licenses this file to you under the MIT license.
// See the LICENSE file in the project root for more information.
using System;
using System.Collections.Generic;
using JetBrains.Annotations;
namespace Microsoft.Plugin.Folder.Sources.Result
{
public class FileSystemResult : List<DisplayFileInfo>
{
public FileSystemResult()
{
}
public FileSystemResult([NotNull] IEnumerable<DisplayFileInfo> collection)
: base(collection)
{
}
public FileSystemResult(int capacity)
: base(capacity)
{
}
public static FileSystemResult Error(Exception exception)
{
return new FileSystemResult { Exception = exception };
}
public Exception Exception { get; private set; }
public bool HasException() => Exception != null;
}
}

47
src/modules/launcher/Plugins/Microsoft.Plugin.Folder/Sources/Result/FolderItemResult.cs Normal file
View File

@@ -0,0 +1,47 @@
// Copyright (c) Microsoft Corporation
// The Microsoft Corporation licenses this file to you under the MIT license.
// See the LICENSE file in the project root for more information.
using Wox.Infrastructure;
using Wox.Plugin;
namespace Microsoft.Plugin.Folder.Sources.Result
{
public class FolderItemResult : IItemResult
{
private static readonly IExplorerAction ExplorerAction = new ExplorerAction();
public FolderItemResult()
{
}
public FolderItemResult(DisplayFileInfo fileSystemInfo)
{
Title = fileSystemInfo.Name;
Subtitle = fileSystemInfo.FullName;
Path = fileSystemInfo.FullName;
}
public string Title { get; set; }
public string Subtitle { get; set; }
public string Path { get; set; }
public string Search { get; set; }
public Wox.Plugin.Result Create(IPublicAPI contextApi)
{
return new Wox.Plugin.Result
{
Title = Title,
IcoPath = Path,
SubTitle = "Folder: " + Subtitle,
QueryTextDisplay = Path,
TitleHighlightData = StringMatcher.FuzzySearch(Search, Title).MatchData,
ContextData = new SearchResult { Type = ResultType.Folder, FullPath = Path },
Action = c => ExplorerAction.Execute(Path, contextApi),
};
}
}
}

15
src/modules/launcher/Plugins/Microsoft.Plugin.Folder/Sources/Result/IItemResult.cs Normal file
View File

@@ -0,0 +1,15 @@
// Copyright (c) Microsoft Corporation
// The Microsoft Corporation licenses this file to you under the MIT license.
// See the LICENSE file in the project root for more information.
using Wox.Plugin;
namespace Microsoft.Plugin.Folder.Sources.Result
{
public interface IItemResult
{
string Search { get; set; }
Wox.Plugin.Result Create(IPublicAPI contextApi);
}
}

31
src/modules/launcher/Plugins/Microsoft.Plugin.Folder/Sources/Result/TruncatedItemResult.cs Normal file
View File

@@ -0,0 +1,31 @@
// Copyright (c) Microsoft Corporation
// The Microsoft Corporation licenses this file to you under the MIT license.
// See the LICENSE file in the project root for more information.
using System.Globalization;
using Wox.Plugin;
namespace Microsoft.Plugin.Folder.Sources.Result
{
public class TruncatedItemResult : IItemResult
{
public int PreTruncationCount { get; set; }
public int PostTruncationCount { get; set; }
public string WarningIconPath { get; set; }
public string Search { get; set; }
public Wox.Plugin.Result Create(IPublicAPI contextApi)
{
return new Wox.Plugin.Result
{
Title = Properties.Resources.Microsoft_plugin_folder_truncation_warning_title,
QueryTextDisplay = Search,
SubTitle = string.Format(CultureInfo.InvariantCulture, Properties.Resources.Microsoft_plugin_folder_truncation_warning_subtitle, PostTruncationCount, PreTruncationCount),
IcoPath = WarningIconPath,
};
}
}
}

38
src/modules/launcher/Plugins/Microsoft.Plugin.Folder/UserFolderProcessor.cs Normal file
View File

@@ -0,0 +1,38 @@
// Copyright (c) Microsoft Corporation
// The Microsoft Corporation licenses this file to you under the MIT license.
// See the LICENSE file in the project root for more information.
using System.Collections.Generic;
using System.Linq;
using Microsoft.Plugin.Folder.Sources;
using Microsoft.Plugin.Folder.Sources.Result;
namespace Microsoft.Plugin.Folder
{
internal class UserFolderProcessor : IFolderProcessor
{
private readonly FolderHelper _folderHelper;
public UserFolderProcessor(FolderHelper folderHelper)
{
_folderHelper = folderHelper;
}
public IEnumerable<IItemResult> Results(string actionKeyword, string search)
{
return _folderHelper.GetUserFolderResults(search)
.Select(item => CreateFolderResult(item.Nickname, item.Path, item.Path, search));
}
private static IItemResult CreateFolderResult(string title, string subtitle, string path, string search)
{
return new UserFolderResult
{
Search = search,
Title = title,
Subtitle = subtitle,
Path = path,
};
}
}
}

38
src/modules/launcher/Plugins/Microsoft.Plugin.Folder/UserFolderResult.cs Normal file
View File

@@ -0,0 +1,38 @@
// Copyright (c) Microsoft Corporation
// The Microsoft Corporation licenses this file to you under the MIT license.
// See the LICENSE file in the project root for more information.
using Microsoft.Plugin.Folder.Sources;
using Microsoft.Plugin.Folder.Sources.Result;
using Wox.Infrastructure;
using Wox.Plugin;
namespace Microsoft.Plugin.Folder
{
public class UserFolderResult : IItemResult
{
private readonly IExplorerAction _explorerAction = new ExplorerAction();
public string Search { get; set; }
public string Title { get; set; }
public string Path { get; set; }
public string Subtitle { get; set; }
public Result Create(IPublicAPI contextApi)
{
return new Result
{
Title = Title,
IcoPath = Path,
SubTitle = $"Folder: {Subtitle}",
QueryTextDisplay = Path,
TitleHighlightData = StringMatcher.FuzzySearch(Search, Title).MatchData,
ContextData = new SearchResult { Type = ResultType.Folder, FullPath = Path },
Action = c => _explorerAction.Execute(Path, contextApi),
};
}
}
}