public Glob(string pattern, GlobOptions options = GlobOptions.None) { this.Pattern = pattern; if(options.HasFlag(GlobOptions.Compiled)) { this.Compile(); } }
/// <summary> /// Find path names matching a pattern. /// </summary> //[return: CastToFalse] public static PhpArray glob(Context ctx, string pattern, GlobOptions flags = GlobOptions.None) { var result = new PhpArray(); if (!string.IsNullOrEmpty(pattern)) { foreach (var fileName in GetMatches(ctx, pattern, flags)) { result.Add(fileName); } if (result.Count == 0 && (flags & GlobOptions.NoCheck) != 0) { result.Add(pattern); } } return(result); }
public static string[] GetIncludeFiles(string projectPath, string itemType) { var result = new List <string>(); var existingFiles = GetAllFilesRecursive(Path.GetDirectoryName(projectPath), "*.cs"); var globOptions = new GlobOptions(); globOptions.Evaluation.CaseInsensitive = false; var root = ProjectRootElement.Open(projectPath); foreach (var itemGroup in root.ItemGroups) { if (itemGroup.Condition.Length != 0) { continue; } foreach (var item in itemGroup.Items) { if (item.ItemType != itemType) { continue; } string normalizedInclude = item.Include.NormalizePath(); var glob = Glob.Parse(normalizedInclude, globOptions); // TODO Check somehow if path has no blob to avoid the following loop... foreach (var existingFile in existingFiles) { if (glob.IsMatch(existingFile)) { result.Add(existingFile); } } } } return(result.ToArray()); }
public void GlobCollection1(GlobOptions options) { using var directory = TemporaryDirectory.Create(); directory.CreateEmptyFile("d1/d2/f1.txt"); directory.CreateEmptyFile("d1/d2/f2.txt"); directory.CreateEmptyFile("d1/f3.txt"); directory.CreateEmptyFile("d3/f4.txt"); var glob = new GlobCollection( Glob.Parse("**/*.txt", options), Glob.Parse("!d1/*.txt", options)); TestEvaluate(directory, glob, new[] { "d1/d2/f1.txt", "d1/d2/f2.txt", "d3/f4.txt", }); }
private static void Command_KillAll(bool makePersistent = false, string pattern = "*") { var globOptions = new GlobOptions(); globOptions.Evaluation.CaseInsensitive = true; foreach (var ped in World.GetAllPeds()) { if (!ped.Exists() || ped.IsExplosionProof || ped.IsPlayer) { continue; } if (!Glob.Parse(pattern, globOptions).IsMatch(ped.Model.Name)) { continue; } ped.Kill(); if (makePersistent) { ped.MakePersistent(); } } }
public static PhpArray Glob(string pattern, GlobOptions flags) { if (pattern == null) { return(new PhpArray(0, 0)); } PhpArray result = new PhpArray(); foreach (var fileName in GetMatches(pattern, flags)) { result.Add(fileName); } if (result.Count == 0 && (flags & GlobOptions.NoCheck) != 0) { result.Add(pattern); } return(result); }
public Matcher(StringComparison stringComparison) { _excludePatterns = new Collection <string>(); _includePatterns = new Collection <string>(); _globOptions = new GlobOptions(); switch (stringComparison) { case StringComparison.CurrentCultureIgnoreCase: case StringComparison.InvariantCultureIgnoreCase: case StringComparison.OrdinalIgnoreCase: _globOptions.Evaluation.CaseInsensitive = true; break; default: case StringComparison.CurrentCulture: case StringComparison.InvariantCulture: case StringComparison.Ordinal: _globOptions.Evaluation.CaseInsensitive = false; break; } }
public static PhpArray glob(Context ctx, string pattern, GlobOptions flags = GlobOptions.None) { if ((flags & ~GlobOptions.SupportedMask) != 0) { PhpException.InvalidArgument(nameof(flags), string.Format(Resources.Resources.glob_invalid_flags, (flags & ~GlobOptions.SupportedMask).ToString())); return(null); // FALSE } if (string.IsNullOrEmpty(pattern)) { return(PhpArray.NewEmpty()); } var result = new PhpArray(); result.AddRange(GetMatches(ctx, pattern, flags)); if (result.Count == 0 && (flags & GlobOptions.NoCheck) != 0) { result.Add(pattern); } return(result); }
public static IEnumerable <DirectoryInfo> Directories(DirectoryInfo directory, string pattern, GlobOptions options) { throw new NotSupportedException(); }
public static IEnumerable <DirectoryInfo> GlobDirectories(this DirectoryInfo di, string pattern, GlobOptions options) { return(Glob.Directories(di, pattern, options)); }
public static IEnumerable <FileSystemInfo> GlobFileSystemInfos(this DirectoryInfo di, string pattern, GlobOptions options) { return(Glob.FilesAndDirectories(di, pattern, options)); }
/// <summary> /// Gets all files matching glob pattern. /// See: https://github.com/kthompson/glob for supported pattern expressions and use cases. /// </summary> /// <param name="context"></param> /// <param name="directory"></param> /// <param name="globPattern"></param> /// <returns></returns> public List <FileFullPath> GetFiles(GlobOptions globOptions = GlobOptions.None, params string[] globPattern) { var directoryInfo = new DirectoryInfo(_fullPath); return(globPattern.SelectMany(pattern => Glob.Files(directoryInfo, pattern, globOptions)).Select(x => new FileFullPath(x.FullName)).ToList()); }
internal static IEnumerable <string> /*!*/ GetMatches(Context ctx, string /*!*/ pattern, GlobOptions flags) { if (string.IsNullOrEmpty(pattern)) { yield break; } var noEscape = (flags & GlobOptions.NoEscape) != 0; var brace = (flags & GlobOptions.Brace) != 0; var groups = UngroupGlobs(pattern, noEscape, brace); foreach (string group in groups) { var matcher = new GlobMatcher(ctx, group, flags); foreach (string filename in matcher.DoGlob()) { yield return(CurrentPlatform.NormalizeSlashes(filename)); } } }
public static IEnumerable <string> FilesAndDirectories(string workingDirectory, string pattern, GlobOptions options) { var directoryInfo = new DirectoryInfo(workingDirectory); var truncateLength = GetTruncateLength(directoryInfo); return(FilesAndDirectories(directoryInfo, pattern, options).Select(info => info.FullName.Remove(0, truncateLength))); }
/// <summary>Returns an enumerable collection of <see cref="UsnEntry"/> entries that meet specified criteria.</summary> /// <param name="filter">The filter.</param> /// <param name="onlyFiles">If gets only the file entries.</param> public IEnumerable <UsnEntry> EnumerateUsnEntries(string filter, bool?onlyFiles) { var usnState = new USN_JOURNAL_DATA_V0(); if (QueryUsnJournal(ref usnState) != (int)UsnJournalReturnCode.USN_JOURNAL_SUCCESS) { throw new Win32Exception("Failed to query the USN journal on the volume."); } // Set up MFT_ENUM_DATA_V0 structure. var mftData = new MFT_ENUM_DATA_V0 { StartFileReferenceNumber = 0, LowUsn = 0, HighUsn = usnState.NextUsn }; var mftDataSize = Marshal.SizeOf(mftData); var mftDataBuffer = Marshal.AllocHGlobal(mftDataSize); Win32Api.ZeroMemory(mftDataBuffer, mftDataSize); Marshal.StructureToPtr(mftData, mftDataBuffer, true); // Set up the data buffer which receives the USN_RECORD data. const int pDataSize = sizeof(ulong) + 10000; var pData = Marshal.AllocHGlobal(pDataSize); Win32Api.ZeroMemory(pData, pDataSize); // Gather up volume's directories. while (Win32Api.DeviceIoControl( _usnJournalRootHandle, Win32Api.FSCTL_ENUM_USN_DATA, mftDataBuffer, mftDataSize, pData, pDataSize, out var outBytesReturned, IntPtr.Zero)) { var pUsnRecord = new IntPtr(pData.ToInt64() + sizeof(long)); // While there is at least one entry in the USN journal. while (outBytesReturned > 60) { var usnEntry = new UsnEntry(pUsnRecord); switch (onlyFiles) { case true when usnEntry.IsFolder: case false when !usnEntry.IsFolder: { pUsnRecord = new IntPtr(pUsnRecord.ToInt64() + usnEntry.RecordLength); outBytesReturned -= usnEntry.RecordLength; continue; } } if (string.IsNullOrWhiteSpace(filter)) { yield return(usnEntry); } else { var options = new GlobOptions { Evaluation = { CaseInsensitive = true } }; var glob = Glob.Parse(filter, options); if (glob.IsMatch(usnEntry.Name.AsSpan())) { yield return(usnEntry); } } pUsnRecord = new IntPtr(pUsnRecord.ToInt64() + usnEntry.RecordLength); outBytesReturned -= usnEntry.RecordLength; } Marshal.WriteInt64(mftDataBuffer, Marshal.ReadInt64(pData, 0)); } Marshal.FreeHGlobal(pData); }
public static IEnumerable <string> FilesAndDirectories(string workingDirectory, string pattern, GlobOptions options) { var directoryInfo = new DirectoryInfo(workingDirectory); var truncateLength = GetTruncateLength(directoryInfo); return(FilesAndDirectories(directoryInfo, pattern, options).Select(RemovePrefix <FileSystemInfo>(truncateLength))); }
public IEnumerable <UsnEntry> ReadUsnEntries(USN_JOURNAL_DATA_V0 previousUsnState, uint reasonMask, string filter, bool?onlyFiles) { var newUsnState = new USN_JOURNAL_DATA_V0(); var lastError = (int)UsnJournalReturnCode.VOLUME_NOT_NTFS; if (_isNtfsVolume) { if (_usnJournalRootHandle.ToInt64() != Win32Api.INVALID_HANDLE_VALUE) { // Get current USN journal state. lastError = QueryUsnJournal(ref newUsnState); if (lastError == (int)UsnJournalReturnCode.USN_JOURNAL_SUCCESS) { var bReadMore = true; // Sequentially process the USN journal looking for image file entries. const int pbDataSize = sizeof(ulong) * 16384; var pbData = Marshal.AllocHGlobal(pbDataSize); Win32Api.ZeroMemory(pbData, pbDataSize); var rujd = new READ_USN_JOURNAL_DATA_V0 { StartUsn = (ulong)previousUsnState.NextUsn, ReasonMask = reasonMask, ReturnOnlyOnClose = 0, Timeout = 0, BytesToWaitFor = 0, UsnJournalId = previousUsnState.UsnJournalID }; var sizeRujd = Marshal.SizeOf(rujd); var rujdBuffer = Marshal.AllocHGlobal(sizeRujd); Win32Api.ZeroMemory(rujdBuffer, sizeRujd); Marshal.StructureToPtr(rujd, rujdBuffer, true); // Read USN journal entries. while (bReadMore) { var bRtn = Win32Api.DeviceIoControl(_usnJournalRootHandle, Win32Api.FSCTL_READ_USN_JOURNAL, rujdBuffer, sizeRujd, pbData, pbDataSize, out var outBytesReturned, IntPtr.Zero); if (bRtn) { var pUsnRecord = new IntPtr(pbData.ToInt64() + sizeof(ulong)); // While there is at least one entry in the USN journal. while (outBytesReturned > 60) { var usnEntry = new UsnEntry(pUsnRecord); // Only read until the current usn points beyond the current state's USN. if (usnEntry.USN >= newUsnState.NextUsn) { bReadMore = false; break; } switch (onlyFiles) { case true when usnEntry.IsFolder: case false when !usnEntry.IsFolder: { pUsnRecord = new IntPtr(pUsnRecord.ToInt64() + usnEntry.RecordLength); outBytesReturned -= usnEntry.RecordLength; continue; } } if (string.IsNullOrWhiteSpace(filter)) { yield return(usnEntry); } else { var options = new GlobOptions { Evaluation = { CaseInsensitive = true } }; var glob = Glob.Parse(filter, options); if (glob.IsMatch(usnEntry.Name.AsSpan())) { yield return(usnEntry); } } pUsnRecord = new IntPtr(pUsnRecord.ToInt64() + usnEntry.RecordLength); outBytesReturned -= usnEntry.RecordLength; } } else { var lastWin32Error = Marshal.GetLastWin32Error(); if (lastWin32Error == (int)Win32Errors.ERROR_HANDLE_EOF) { lastError = (int)UsnJournalReturnCode.USN_JOURNAL_SUCCESS; } break; } var nextUsn = Marshal.ReadInt64(pbData, 0); if (nextUsn >= newUsnState.NextUsn) { break; } Marshal.WriteInt64(rujdBuffer, nextUsn); } Marshal.FreeHGlobal(rujdBuffer); Marshal.FreeHGlobal(pbData); } } else { lastError = (int)UsnJournalReturnCode.INVALID_HANDLE_VALUE; } } }
/// <summary> /// Gets all directories matching glob pattern. /// </summary> /// <param name="context"></param> /// <param name="directory"></param> /// <param name="globPattern"></param> /// <returns></returns> public static List <FullPath> GetDirectories(string directory, GlobOptions globOptions = GlobOptions.None, params string[] globPattern) { var directoryInfo = new DirectoryInfo(directory); return(globPattern.SelectMany(pattern => Glob.Directories(directoryInfo, pattern, globOptions)).Select(x => new FullPath(x.FullName)).ToList()); }
public static bool IsMatch(string input, string pattern, GlobOptions options = GlobOptions.None) => new Glob(pattern, options).IsMatch(input);
private static bool TryParse(ReadOnlySpan <char> pattern, GlobOptions options, [NotNullWhen(true)] out Glob?result, [NotNullWhen(false)] out string?errorMessage) { return(GlobParser.TryParse(pattern, options, out result, out errorMessage)); }
public static bool TryParse(ReadOnlySpan <char> pattern, GlobOptions options, [NotNullWhen(true)] out Glob?result) { return(TryParse(pattern, options, out result, out _)); }
/// <summary> /// Gets all directories matching glob pattern. /// </summary> /// <param name="context"></param> /// <param name="directory"></param> /// <param name="globPattern"></param> /// <returns></returns> public static List <FullPath> GetDirectories(this IBuildPropertiesContext context, string directory, GlobOptions globOptions = GlobOptions.None, params string[] globPattern) { return(ContextBaseExtensions.GetDirectories(directory, globOptions, globPattern)); }
internal static IEnumerable <string> /*!*/ GetMatches(Context ctx, string /*!*/ pattern, GlobOptions flags) { if (pattern.Length == 0) { yield break; } bool noEscape = ((flags & GlobOptions.NoEscape) != 0); bool brace = ((flags & GlobOptions.Brace) != 0); string[] groups = UngroupGlobs(pattern, noEscape, brace); if (groups.Length == 0) { yield break; } foreach (string group in groups) { GlobMatcher matcher = new GlobMatcher(ctx, group, flags); foreach (string filename in matcher.DoGlob()) { yield return(filename.Replace(Path.AltDirectorySeparatorChar, Path.DirectorySeparatorChar)); } } }
public static PhpArray Glob(string pattern, GlobOptions flags) { if (pattern == null) return new PhpArray(0, 0); PhpArray result = new PhpArray(); foreach (var fileName in GetMatches(pattern, flags)) { result.Add(fileName); } if (result.Count == 0 && (flags & GlobOptions.NoCheck) != 0) result.Add(pattern); return result; }
public static Glob Parse(string pattern, GlobOptions options) { return(Parse(pattern.AsSpan(), options)); }
public static void AddDirectoryFilterGlob(this FilterOptions options, string globPattern, GlobOptions globOptions = GlobOptions.None, bool negateFilter = false) { var filter = new GlobFilter(globPattern, globOptions); if (negateFilter) { filter.NegateFilter(); } options.AddDirectoryFilters(filter); }
public GlobFilter(string pattern, GlobOptions globOptions = GlobOptions.None) { _pattern = pattern; _globOptions = globOptions; }
public static bool TryParse(string pattern, GlobOptions options, [NotNullWhen(true)] out Glob?result) { return(TryParse(pattern.AsSpan(), options, out result)); }
public static IEnumerable <DirectoryInfo> Directories(DirectoryInfo workingDirectory, string pattern, GlobOptions options) => workingDirectory .Traverse(pattern, !options.HasFlag(GlobOptions.CaseInsensitive), false, true) .OfType <DirectoryInfo>();
public GlobMatcher(string/*!*/ pattern, GlobOptions flags) { _pattern = FileSystemUtils.CanonicalizePath(pattern); _flags = flags; _result = new List<string>(); _dirOnly = _pattern.LastCharacter() == '/' || (flags & GlobOptions.OnlyDir) != 0; _fnMatchFlags = NoEscapes ? FnMatchOptions.NoEscape : FnMatchOptions.None; }
public static IEnumerable <FileSystemInfo> FilesAndDirectories(DirectoryInfo workingDirectory, string pattern, GlobOptions options) => workingDirectory.Traverse(pattern, !options.HasFlag(GlobOptions.CaseInsensitive), true, true);
internal static IEnumerable<string>/*!*/ GetMatches(string/*!*/ pattern, GlobOptions flags) { if (pattern.Length == 0) { yield break; } bool noEscape = ((flags & GlobOptions.NoEscape) != 0); bool brace = ((flags & GlobOptions.Brace) != 0); string[] groups = UngroupGlobs(pattern, noEscape, brace); if (groups.Length == 0) { yield break; } foreach (string group in groups) { GlobMatcher matcher = new GlobMatcher(group, flags); foreach (string filename in matcher.DoGlob()) { yield return filename; } } }