public Task Invoke(IDictionary <string, object> environment) { if (!environment.ContainsKey("owin.RequestPath")) { throw new ApplicationException("Invalid OWIN request. Expected owin.RequestPath, but not present."); } var path = Uri.UnescapeDataString((string)environment["owin.RequestPath"]); if (statelessAuthOptions != null) { foreach (var ignorePath in statelessAuthOptions.IgnorePaths) { var mm = new Minimatcher(ignorePath, new Options() { IgnoreCase = true }); if (mm.IsMatch(path)) { return(nextFunc(environment)); } } } var requestHeaders = (IDictionary <string, string[]>)environment["owin.RequestHeaders"]; if (!requestHeaders.ContainsKey("Authorization")) { SetResponseStatusCodeAndHeader(environment); return(ReturnCompletedTask()); } var token = requestHeaders["Authorization"].FirstOrDefault(); if (string.IsNullOrWhiteSpace(token)) { SetResponseStatusCodeAndHeader(environment); return(ReturnCompletedTask()); } var validatedUser = tokenValidator.ValidateUser(token); if (validatedUser == null) { SetResponseStatusCodeAndHeader(environment); return(ReturnCompletedTask()); } if (environment.ContainsKey(ServerUser)) { environment[ServerUser] = validatedUser; } else { environment.Add(ServerUser, validatedUser); } return(nextFunc(environment)); }
private static bool IsSourceFile(JObject obj, string cwd, string fileName) { IEnumerable <string> files = obj["files"]?.Values <string>() ?? Enumerable.Empty <string>(); IEnumerable <string> includes = obj["include"]?.Values <string>() ?? Enumerable.Empty <string>(); var options = new Options { AllowWindowsPaths = true }; string relative = fileName.Substring(cwd.Length).Trim('\\'); foreach (string file in files) { bool isMatch = Minimatcher.Check(relative, file, options); if (isMatch) { return(true); } } foreach (string pattern in includes) { bool isMatch = Minimatcher.Check(relative, pattern, options); if (isMatch) { return(true); } } return(false); }
private bool IsImageOnProbingPath(string file, out Optimization optimization) { optimization = null; foreach (var opti in _config.Optimizations) { optimization = opti; bool isIncluded = opti.Includes.Any(pattern => Minimatcher.Check(file, pattern, _matcherOptions)); if (!isIncluded) { continue; } bool isExcluded = opti.Excludes.Any(pattern => Minimatcher.Check(file, pattern, _matcherOptions)); if (isExcluded) { continue; } return(true); } return(false); }
private IReadOnlyCollection <IProject> GetNotExcludedProjects(IReadOnlyCollection <string> exclusionPatterns) { if (exclusionPatterns == null || exclusionPatterns.Count < 1) { return(_projects); } var notExcludedProjects = new List <IProject>(); foreach (var project in _projects) { var excluded = false; foreach (var excludedProject in exclusionPatterns) { if (Minimatcher.Check(project.FilePath, excludedProject, new Options { AllowWindowsPaths = true, NoCase = true })) { _logger.LogDebug($"Ignoring project '{project.FilePath}' as it matches the exclusion pattern {excludedProject}"); excluded = true; break; } } if (excluded) { continue; } notExcludedProjects.Add(project); } return(notExcludedProjects); }
public string GetSchemaFor(string fileLocation) { foreach (string url in _schemas.Keys) { try { if (_schemas[url] == null) { continue; } foreach (string file in _schemas[url]) { var pattern = "**/" + file.TrimStart('*', '/'); var matche = new Minimatcher(pattern, _options); if (matche.IsMatch(fileLocation)) { return(url); } } } catch { Logger.Log("JSON Schema: Couldn't parse " + _schemas[url] + " as a valid regex."); } } return(null); }
public static Boolean IsSetVariableAllowed(this TaskRestrictions restrictions, String variable) { ArgUtil.NotNull(variable, nameof(variable)); var allowedList = restrictions.SettableVariables?.Allowed; if (allowedList == null) { return(true); } var opts = new Options() { IgnoreCase = true }; foreach (String pattern in allowedList) { if (Minimatcher.Check(variable, pattern, opts)) { return(true); } } return(false); }
/// <summary> /// Expands braces in patterns if they are exist /// </summary> /// <param name="pattern">String of pattern</param> /// <param name="matchOptions">Download parameters from minimatcherFuncs</param> /// <returns></returns> private string[] ExpandBraces(string pattern, Options matchOptions) { // Convert slashes on Windows before calling braceExpand(). Unfortunately this means braces cannot // be escaped on Windows, this limitation is consistent with current limitations of minimatch (3.0.3). tracer.Info($"Expanding braces."); string convertedPattern = pattern.Replace("\\", "/"); return(Minimatcher.BraceExpand(convertedPattern, matchOptions).ToArray()); }
private IEnumerable <DbvItemBase> FilterDeleted(IEnumerable <DbvItemBase> source, string itemMask) { var matcher = new Minimatcher(string.IsNullOrEmpty(itemMask) ? "**" : itemMask, new Options { IgnoreCase = true, MatchBase = true }); // code duplication with the above return(source.Where(item => matcher.IsMatch(item.Name)) .Where(item => !IsDeleted(item))); }
public IEnumerable <DbvItemBase> History(string itemMask) { var matcher = new Minimatcher(string.IsNullOrEmpty(itemMask) ? "**" : itemMask, new Options { IgnoreCase = true, MatchBase = true }); return(_revisionStore.List(0) .Where(item => matcher.IsMatch(item.Name)) .OrderBy(k => k.Revision)); }
public static bool CheckGlobbing(string path, string pattern) { string p = pattern?.TrimEnd('/'); if (!string.IsNullOrWhiteSpace(p)) { return(Minimatcher.Check(path, p, _options)); } return(false); }
public void VerifyMinimatcherSearchPatternMatch() { var matcher = new Minimatcher("/test/*", new Minimatch.Options { IgnoreCase = true }); Assert.IsTrue(matcher.IsMatch("/test/dummy.csv")); Assert.IsTrue(matcher.IsMatch("/TEST/dummy.csv")); Assert.IsFalse(matcher.IsMatch("/second/dummy.csv")); }
internal static Func <string, bool> CreateMinimatchFilter(AgentTaskPluginExecutionContext context, string rule, bool invert) { Func <string, bool> filter = Minimatcher.CreateFilter(rule, minimatchOptions); Func <string, bool> tracedFilter = (path) => { bool filterResult = filter(path); context.Verbose($"Path `{path}` is {(filterResult ? "" : "not ")}{(invert ? "excluded" : "included")} because of pattern `{(invert ? "!" : "")}{rule}`."); return(invert ^ filterResult); }; return(tracedFilter); }
///<summary>Filters a list of inputs against a single pattern.</summary> ///<remarks>This function reparses this input on each invocation. For performance, avoid this function and reuse a Minimatcher instance instead.</remarks> public static IEnumerable <string> Filter(IEnumerable <string> list, string pattern, Options options = null) { var mm = new Minimatcher(pattern, options); list = list.Where(mm.IsMatch); if (options != null && options.NoNull) { list = list.DefaultIfEmpty(pattern); } return(list); }
public void TestIssue3() { var filterOptions = new Options { AllowWindowsPaths = true, IgnoreCase = true }; var minimatcher = new Minimatcher("**/Thumbs.db", filterOptions); Assert.IsFalse(minimatcher.IsMatch(@"NewFolder\")); }
static void TestCase(string pattern, IList <string> expected, Options options = null, IEnumerable <string> input = null) { input ??= files; Assert.Equal( string.Join(Environment.NewLine, expected.OrderBy(s => s)), string.Join(Environment.NewLine, Minimatcher.Filter(input, pattern, options).OrderBy(s => s)) ); var regex = Minimatcher.CreateRegex(pattern, options); actualRegexes.Add(Tuple.Create(pattern, regex == null ? "false" : "/" + regex.ToString() + "/" + (regex.Options == RegexOptions.IgnoreCase ? "i" : ""))); }
public void IncrementAndUpdateAll() { b.Verbose.Log("IncrementAndUpdateAll called"); ValidateForUpdate(); LoadVersioningComponent(); b.Verbose.Log("Versioning Loaded "); ver.Increment(); b.Verbose.Log("Saving"); SaveVersioningComponent(); b.Verbose.Log($"Searching {BaseSearchDir} there are {pendingUpdates.Count} pends."); var enumer = Directory.EnumerateFiles(BaseSearchDir, "*.*", SearchOption.AllDirectories).GetEnumerator(); bool shouldContinue = true; while (shouldContinue) { try { shouldContinue = enumer.MoveNext(); if (shouldContinue) { var v = enumer.Current; // Check every file that we have returned. foreach (var chk in pendingUpdates.Keys) { var mm = new Minimatcher(chk, new Options { AllowWindowsPaths = true, IgnoreCase = true }); b.Verbose.Log($"Checking {chk} against {v}"); if (mm.IsMatch(v)) { b.Info.Log("Match..."); // TODO Cache this and make it less loopey VersionFileUpdater sut = new VersionFileUpdater(ver); foreach (var updateType in pendingUpdates[chk]) { b.Verbose.Log($"Perform update {v}"); sut.PerformUpdate(v, updateType); } } } } } catch (System.UnauthorizedAccessException) { // If you run through all the filles in a directory you can hit areas of the filesystem // that you dont have access to - this skips those files and then continues. b.Verbose.Log("Unauthorised area of the filesystem, skipping"); } } VersionString = ver.GetVersionString(); }
private static void CheckTheseMatches(List <Tuple <string, bool> > mtchs, string againstThis) { var mm = new Minimatcher(againstThis, new Options { AllowWindowsPaths = true, IgnoreCase = true }); int i = 0; foreach (var v in mtchs) { i++; bool isMatch = mm.IsMatch(v.Item1); Assert.Equal(v.Item2, isMatch); //, "Mismatch " + i.ToString()); } }
public Vehicle[] Search(SearchCtx ctx) { Minimatcher mm = GetMinimatcher(ctx); var vehicles = JoinVehicles(); var typesById = TypesById(); var found = vehicles .Where(a => ctx.SelectedType == "1" || a.Typename == typesById[ctx.SelectedType]) .Where(a => !ctx.OnlyToday || DateTime.Now.Day == a.checkInDate.Day) .Where(a => mm == null || (a.RegNr != null && mm.IsMatch(a.RegNr)) || (a.OwnerName != null && mm.IsMatch(a.OwnerName))); return(found.ToArray()); }
///<summary>Creates a filter function that tests input against a pattern.</summary> public static Func <string, bool> CreateFilter(string pattern, Options options = null) { if (pattern == null) { throw new ArgumentNullException("pattern"); } // "" only matches "" if (String.IsNullOrWhiteSpace(pattern)) { return(String.IsNullOrEmpty); } var m = new Minimatcher(pattern, options); return(m.IsMatch); }
public void MiniMatchSyntax_FindAssemblyInfo() { var mtchs = new List <Tuple <string, bool> >(); mtchs.Add(new Tuple <string, bool>(@"C:\temp\te st\properties\assemblyinfo.cs", true)); mtchs.Add(new Tuple <string, bool>(@"C:\te mp\test\assemblyinfo.cs", false)); mtchs.Add(new Tuple <string, bool>(@"C:\te mp\t e s t\properties\notassemblyinfo.cs", false)); mtchs.Add(new Tuple <string, bool>(@"C:\temp\test\properties\assemblyinfo.cs.txt", false)); mtchs.Add(new Tuple <string, bool>(@"C:\a\1\s\PliskyLibrary\PliskyLib\Properties\AssemblyInfo.cs", true)); string againstThis = @"**\properties\assemblyinfo.cs"; CheckTheseMatches(mtchs, againstThis); var mm2 = new Minimatcher(@"C:\temp\test\testfile.tst", new Options { AllowWindowsPaths = true }); Assert.True(mm2.IsMatch(@"C:\temp\test\testfile.tst"), "Cant match on full filename"); }
private bool CheckAndUpdate(string fl, Minimatcher assemblyMM, string versionValue, Action <string, string> p) { b.Assert.True(p != null, "The action used cant be null"); b.Verbose.Log("Checking file :" + fl); bool result = assemblyMM.IsMatch(fl); if ((result) && (File.Exists(fl))) { b.Info.Log($"Updating VersioningFile File ({fl}) to ({versionValue})"); hook?.PreUpdateFileAction(fl); // PreUpdateAllAction?.Invoke(fl); //PreUpdateAction?.Invoke(fl); p(fl, versionValue); hook?.PostUpdateFileAction(fl); } return(result); }
public string[] ListTestAssemblyPaths(string directory, string[] minimatchPatterns) { var files = ListAllAccessibleFilesInDirectory(directory); var matchingFilesToBeIncluded = new List <string>(); foreach (var minimatchPattern in minimatchPatterns.Where(minimatchPattern => !minimatchPattern.StartsWith("!"))) { var mm = new Minimatcher(minimatchPattern, new Minimatch.Options() { AllowWindowsPaths = true, IgnoreCase = true }); matchingFilesToBeIncluded.AddRange(mm.Filter(files)); } var noMatchingFilesFound = matchingFilesToBeIncluded.Count == 0; if (noMatchingFilesFound) { return(null); } var matchingFilesToBeExcluded = new List <string>(); foreach (var minimatchPattern in minimatchPatterns.Where(minimatchPattern => minimatchPattern.StartsWith("!"))) { var actualMinimatchPattern = minimatchPattern.TrimStart('!'); var mm = new Minimatcher(actualMinimatchPattern, new Minimatch.Options() { AllowWindowsPaths = true, IgnoreCase = true }); matchingFilesToBeExcluded.AddRange(mm.Filter(files)); } matchingFilesToBeIncluded.RemoveAll(x => matchingFilesToBeExcluded.Contains(x)); return(matchingFilesToBeIncluded.ToArray()); }
/// <inheritdoc/> public override async Task<FtpResponse> Process(FtpCommand command, CancellationToken cancellationToken) { if (string.IsNullOrEmpty(command.Argument)) { var taskStates = Server.GetBackgroundTaskStates(); var statusMessage = new StringBuilder(); statusMessage.AppendFormat("Server functional, {0} open connections", Server.Statistics.ActiveConnections); if (taskStates.Count != 0) statusMessage.AppendFormat(", {0} active background transfers", taskStates.Count); return new FtpResponse(211, statusMessage.ToString()); } var mask = command.Argument; if (!mask.EndsWith("*")) mask += "*"; var mmOptions = new Options() { IgnoreCase = Data.FileSystem.FileSystemEntryComparer.Equals("a", "A"), NoGlobStar = true, Dot = true, }; var mm = new Minimatcher(mask, mmOptions); var formatter = new LongListFormatter(); await Connection.WriteAsync($"211-STAT {command.Argument}", cancellationToken); foreach (var entry in (await Data.FileSystem.GetEntriesAsync(Data.CurrentDirectory, cancellationToken)).Where(x => mm.IsMatch(x.Name))) { var line = formatter.Format(entry, entry.Name); Connection.Log?.Debug(line); await Connection.WriteAsync($" {line}", cancellationToken); } return new FtpResponse(211, "STAT"); }
public void IncrementAndUpdateAll() { Bilge.VerboseLog("IncrementAndUpdateAll called"); ValidateForUpdate(); LoadVersioningComponent(); Bilge.VerboseLog("Versioning Loaded Ver at " + ver.ToString()); ver.PerformIncrement(); Bilge.VerboseLog("Saving Ver At " + ver.ToString()); SaveVersioningComponent(); Bilge.VerboseLog($"Searching {BaseSearchDir} there are {pendingUpdates.Count} pends."); foreach (var v in Directory.EnumerateFiles(BaseSearchDir, "*.*", SearchOption.AllDirectories)) { // Check every file that we have returned. foreach (var chk in pendingUpdates.Keys) { var mm = new Minimatcher(chk, new Options { AllowWindowsPaths = true, IgnoreCase = true }); // Dump out every file considered. Bilge.VerboseLog($"Checking {chk} against {v}"); if (mm.IsMatch(v)) { Bilge.Log($"Match...{chk}", v); // TODO Cache this and make it less loopey VersionFileUpdater vfu = new VersionFileUpdater(ver); foreach (var updateType in pendingUpdates[chk]) { Bilge.VerboseLog($"Perform update {v} using {updateType.ToString()} as {(int)updateType}"); vfu.PerformUpdate(v, updateType); } } } } }
public void Start() { var filesMinimatched = new List <string>(); var baseFolderLength = Arguments.BaseFolder.Length; var relativeFiles = Directory.EnumerateFiles(Arguments.BaseFolder, "*.*", SearchOption.AllDirectories) .Select(f => f.Substring(baseFolderLength)); // Search files matching the Pattern foreach (string file in relativeFiles) { if (Minimatcher.IsMatch(file)) { filesMinimatched.Add(file); } } // Read and replace foreach (var relativeFile in filesMinimatched) { var filename = Arguments.BaseFolder + relativeFile; var file = new File(filename); string newContent = Regex.Replace(file.Content, Arguments.Find, Arguments.Replace, RegexOptions.IgnoreCase); if (newContent != file.Content) { if (!Arguments.IsDemoMode) { file.WriteAllText(newContent); } this.FilesMatched.Add(relativeFile); Logger?.Invoke(relativeFile, newContent); } } }
public static IEnumerable <string> ExpandFileGlobs(IEnumerable <string> potentialGlobs, IEnumerable <string> libraryFiles) { var finalSetOfFiles = new HashSet <string>(); var negatedOptions = new Minimatch.Options { FlipNegate = true }; foreach (string potentialGlob in potentialGlobs) { // only process globs where we find them, otherwise it can get expensive if (potentialGlob.StartsWith("!", StringComparison.Ordinal)) { // Remove matches from the files list var filesToRemove = finalSetOfFiles.Where(f => Minimatcher.Check(f, potentialGlob, negatedOptions)).ToList(); foreach (string file in filesToRemove) { finalSetOfFiles.Remove(file); } } else if (potentialGlob.IndexOfAny(GlobIndicatorCharacters) >= 0) { IEnumerable <string> filterResult = libraryFiles.Where(f => Minimatcher.Check(f, potentialGlob)); if (filterResult.Any()) { finalSetOfFiles.UnionWith(filterResult); } } else { // not a glob pattern, so just include the file literally finalSetOfFiles.Add(potentialGlob); } } return(finalSetOfFiles); }
internal List <string> GetAbsoluteInputFiles() { List <string> files = new List <string>(); string folder = new DirectoryInfo(Path.GetDirectoryName(FileName)).FullName; string ext = Path.GetExtension(InputFiles.First()); Options options = new Options { AllowWindowsPaths = true }; foreach (string inputFile in InputFiles.Where(f => !f.StartsWith("!", StringComparison.Ordinal))) { int globIndex = inputFile.IndexOf('*'); if (globIndex > -1) { string relative = string.Empty; int last = inputFile.LastIndexOf('/', globIndex); if (last > -1) { relative = inputFile.Substring(0, last + 1); } var output = GetAbsoluteOutputFile(); var outputMin = BundleFileProcessor.GetMinFileName(output); string searchDir = new FileInfo(Path.Combine(folder, relative).Replace("/", "\\")).FullName; var allFiles = Directory.EnumerateFiles(searchDir, "*" + ext, SearchOption.AllDirectories).Select(f => f.Replace(folder + "\\", "")); var matches = Minimatcher.Filter(allFiles, inputFile, options).Select(f => Path.Combine(folder, f)); matches = matches.Where(match => match != output && match != outputMin); files.AddRange(matches.Where(f => !files.Contains(f))); } else { string fullPath = Path.Combine(folder, inputFile).Replace("/", "\\"); if (Directory.Exists(fullPath)) { DirectoryInfo dir = new DirectoryInfo(fullPath); SearchOption search = SearchOption.TopDirectoryOnly; var dirFiles = dir.GetFiles("*" + Path.GetExtension(OutputFileName), search); files.AddRange(dirFiles.Select(f => f.FullName).Where(f => !files.Contains(f))); } else { files.Add(fullPath); } } } // Remove files starting with a ! foreach (string inputFile in InputFiles) { int globIndex = inputFile.IndexOf('!'); if (globIndex == 0) { var allFiles = files.Select(f => f.Replace(folder + "\\", "")); var matches = Minimatcher.Filter(allFiles, inputFile, options).Select(f => Path.Combine(folder, f)); files = matches.ToList(); } } return(files); }
/// <summary> /// Returns a list of absolute file paths of all matching input files. /// </summary> /// <param name="notifyOnPatternMiss">Writes to the Console if any input file is missing on disk.</param> public List <string> GetAbsoluteInputFiles(bool notifyOnPatternMiss = false) { List <string> files = new List <string>(); if (!InputFiles.Any()) { return(files); } string folder = new DirectoryInfo(Path.GetDirectoryName(FileName)).FullName; string ext = Path.GetExtension(InputFiles.First()); Options options = new Options { AllowWindowsPaths = true }; foreach (string inputFile in InputFiles.Where(f => !f.StartsWith("!", StringComparison.Ordinal))) { int globIndex = inputFile.IndexOf('*'); if (globIndex > -1) { string relative = string.Empty; int last = inputFile.LastIndexOf('/', globIndex); if (last > -1) { relative = inputFile.Substring(0, last + 1); } var output = GetAbsoluteOutputFile(); var outputMin = BundleMinifier.GetMinFileName(output); string searchDir = new FileInfo(Path.Combine(folder, relative).NormalizePath()).FullName; var allFiles = Directory.EnumerateFiles(searchDir, "*" + ext, SearchOption.AllDirectories).Select(f => f.Replace(folder + FileHelpers.PathSeparatorChar, "")); var matches = Minimatcher.Filter(allFiles, inputFile, options).Select(f => Path.Combine(folder, f)); matches = matches.Where(match => match != output && match != outputMin).ToList(); if (notifyOnPatternMiss && !matches.Any()) { Console.WriteLine($" No files matched the pattern {inputFile}".Orange().Bright()); } files.AddRange(matches.Where(f => !files.Contains(f))); } else { string fullPath = Path.Combine(folder, inputFile.NormalizePath()); if (Directory.Exists(fullPath)) { DirectoryInfo dir = new DirectoryInfo(fullPath); SearchOption search = SearchOption.TopDirectoryOnly; var dirFiles = dir.GetFiles("*" + Path.GetExtension(OutputFileName), search); var collected = dirFiles.Select(f => f.FullName).Where(f => !files.Contains(f)).ToList(); if (notifyOnPatternMiss && collected.Count == 0) { Console.WriteLine($" No files were found in {inputFile}".Orange().Bright()); } files.AddRange(collected); } else { files.Add(fullPath); if (notifyOnPatternMiss && !File.Exists(fullPath)) { Console.WriteLine($" {inputFile} was not found".Orange().Bright()); } } } } // Remove files starting with a ! foreach (string inputFile in InputFiles) { int globIndex = inputFile.IndexOf('!'); if (globIndex == 0) { var allFiles = files.Select(f => f.Replace(folder + FileHelpers.PathSeparatorChar, "")); var matches = Minimatcher.Filter(allFiles, inputFile, options).Select(f => Path.Combine(folder, f)); files = matches.ToList(); } } return(files); }
///<summary>Filters a list of inputs against a single pattern.</summary> ///<remarks>This function reparses this input on each invocation. For performance, avoid this function and reuse a Minimatcher instance instead.</remarks> public static IEnumerable<string> Filter(IEnumerable<string> list, string pattern, Options options = null) { var mm = new Minimatcher(pattern, options); list = list.Where(mm.IsMatch); if (options != null && options.NoNull) list = list.DefaultIfEmpty(pattern); return list; }
///<summary>Creates a filter function that tests input against a pattern.</summary> public static Func<string, bool> CreateFilter(string pattern, Options options = null) { if (pattern == null) throw new ArgumentNullException("pattern"); // "" only matches "" if (String.IsNullOrWhiteSpace(pattern)) return String.IsNullOrEmpty; var m = new Minimatcher(pattern, options); return m.IsMatch; }
public static List <string> GetProjectFiles(this ICollection <string> patterns, bool recursive = false) { var result = new List <string>(); foreach (var p in patterns) { var pattern = p ?? ""; if (recursive) { pattern = pattern.NativeToUnix().Trailing('/') + "**"; } if (pattern.IsValidPath() && ( File.Exists(pattern) || Directory.Exists(pattern) )) { result.Add(GetProjectFile(pattern)); continue; } if (pattern.IndexOf('*') == -1) { throw new FileNotFoundException("No such file or directory: " + pattern); } if (pattern.IndexOf("..", StringComparison.Ordinal) != -1) { throw new Exception("'..' is not supported in glob pattern: " + p); } while (pattern.StartsWith("./") || pattern.StartsWith(".\\")) { pattern = pattern.Substring(2); } var glob = new Minimatcher(pattern, new Options { IgnoreCase = true, AllowWindowsPaths = true }); var root = Directory.GetCurrentDirectory(); foreach (var e in Directory.EnumerateFiles( root, "*.unoproj", pattern.Contains("**") ? SearchOption.AllDirectories : SearchOption.TopDirectoryOnly)) { if (glob.IsMatch(e.Substring(root.Length + 1))) { result.Add(e); } } } if (result.Count == 0) { throw new FileNotFoundException("No project".Plural(patterns) + " matching: " + string.Join(", ", patterns)); } return(result); }
public GlobbingPattern(string pattern) { _matcher = new Minimatcher(pattern); }
/// <inheritdoc/> public override async Task <FtpResponse> Process(FtpCommand command, CancellationToken cancellationToken) { await Connection.WriteAsync(new FtpResponse(150, "Opening data connection."), cancellationToken); ITcpSocketClient responseSocket; try { responseSocket = await Connection.CreateResponseSocket(); } catch (Exception) { return(new FtpResponse(425, "Can't open data connection.")); } try { // Parse arguments in a way that's compatible with broken FTP clients var argument = new ListArguments(command.Argument); var showHidden = argument.All; // Instantiate the formatter IListFormatter formatter; if (string.Equals(command.Name, "NLST", StringComparison.OrdinalIgnoreCase)) { formatter = new ShortListFormatter(); } else if (string.Equals(command.Name, "LS", StringComparison.OrdinalIgnoreCase)) { formatter = new LongListFormatter(); } else { formatter = new LongListFormatter(); } // Parse the given path to determine the mask (e.g. when information about a file was requested) var directoriesToProcess = new Queue <DirectoryQueueItem>(); // Use braces to avoid the definition of mask and path in the following parts // of this function. { var mask = "*"; var path = Data.Path.Clone(); if (!string.IsNullOrEmpty(argument.Path)) { var foundEntry = await Data.FileSystem.SearchEntryAsync(path, argument.Path, cancellationToken); if (foundEntry?.Directory == null) { return(new FtpResponse(550, "File system entry not found.")); } var dirEntry = foundEntry.Entry as IUnixDirectoryEntry; if (dirEntry == null) { mask = foundEntry.FileName; } else if (!dirEntry.IsRoot) { path.Push(dirEntry); } } directoriesToProcess.Enqueue(new DirectoryQueueItem(path, mask)); } var encoding = Data.NlstEncoding ?? Connection.Encoding; using (var stream = await Connection.CreateEncryptedStream(responseSocket.WriteStream)) { using (var writer = new StreamWriter(stream, encoding, 4096, true) { NewLine = "\r\n", }) { while (directoriesToProcess.Count != 0) { var queueItem = directoriesToProcess.Dequeue(); var currentPath = queueItem.Path; var mask = queueItem.Mask; var currentDirEntry = currentPath.Count != 0 ? currentPath.Peek() : Data.FileSystem.Root; if (argument.Recursive) { var line = currentPath.ToDisplayString() + ":"; Connection.Log?.Debug(line); await writer.WriteLineAsync(line); } var mmOptions = new Options() { IgnoreCase = Data.FileSystem.FileSystemEntryComparer.Equals("a", "A"), NoGlobStar = true, Dot = true, }; var mm = new Minimatcher(mask, mmOptions); var entries = await Data.FileSystem.GetEntriesAsync(currentDirEntry, cancellationToken); var enumerator = new DirectoryListingEnumerator(entries, Data.FileSystem, currentPath, true); while (enumerator.MoveNext()) { var name = enumerator.Name; if (!enumerator.IsDotEntry) { if (!mm.IsMatch(name)) { continue; } if (name.StartsWith(".") && !showHidden) { continue; } } var entry = enumerator.Entry; if (argument.Recursive && !enumerator.IsDotEntry) { var dirEntry = entry as IUnixDirectoryEntry; if (dirEntry != null) { var subDirPath = currentPath.Clone(); subDirPath.Push(dirEntry); directoriesToProcess.Enqueue(new DirectoryQueueItem(subDirPath, "*")); } } var line = formatter.Format(entry, name); Connection.Log?.Debug(line); await writer.WriteLineAsync(line); } } } } } finally { responseSocket.Dispose(); } // Use 250 when the connection stays open. return(new FtpResponse(250, "Closing data connection.")); }
public void VerifyMinimatcherSearchPatternMatch() { var matcher = new Minimatcher("/test/*", new Minimatch.Options {IgnoreCase = true}); Assert.IsTrue(matcher.IsMatch("/test/dummy.csv")); Assert.IsTrue(matcher.IsMatch("/TEST/dummy.csv")); Assert.IsFalse(matcher.IsMatch("/second/dummy.csv")); }