internal PatternGroup(IEnumerable <string> includePatterns) { IncludeLiterals = Enumerable.Empty <string>(); IncludePatterns = includePatterns; ExcludePatterns = Enumerable.Empty <string>(); _matcher.AddIncludePatterns(IncludePatterns); }
private static IEnumerable <FilePatternMatch> GetIncludeFilesCore( string sourceBasePath, List <string> includePatterns, List <string> excludePatterns, List <string> includeFiles, List <string> builtInsInclude, List <string> builtInsExclude) { var literalIncludedFiles = new List <string>(); if (includeFiles != null) { // literal included files are added at the last, but the search happens early // so as to make the process fail early in case there is missing file. fail early // helps to avoid unnecessary globing for performance optimization foreach (var literalRelativePath in includeFiles) { var fullPath = Path.GetFullPath(Path.Combine(sourceBasePath, literalRelativePath)); if (!File.Exists(fullPath)) { throw new InvalidOperationException(string.Format("Can't find file {0}", literalRelativePath)); } literalIncludedFiles.Add(fullPath); } } // Globbing var matcher = new Matcher(); if (builtInsInclude != null) { matcher.AddIncludePatterns(builtInsInclude); } if (includePatterns != null) { matcher.AddIncludePatterns(includePatterns); } if (builtInsExclude != null) { matcher.AddExcludePatterns(builtInsExclude); } if (excludePatterns != null) { matcher.AddExcludePatterns(excludePatterns); } return(matcher.Execute(new DirectoryInfoWrapper(new DirectoryInfo(sourceBasePath))).Files); }
private Task LoadDirectoryFiles() { string rootDir = null; if (_initParams.rootUri != null) { rootDir = _initParams.rootUri.ToAbsolutePath(); } else if (!string.IsNullOrEmpty(_initParams.rootPath)) { rootDir = PathUtils.NormalizePath(_initParams.rootPath); } if (string.IsNullOrEmpty(rootDir)) { return(Task.CompletedTask); } var matcher = new Matcher(); var included = _initParams.initializationOptions.includeFiles; matcher.AddIncludePatterns(included != null && included.Length > 0 ? included : new[] { "**/*" }); matcher.AddExcludePatterns(_initParams.initializationOptions.excludeFiles ?? Enumerable.Empty <string>()); var dib = new DirectoryInfoWrapper(new DirectoryInfo(rootDir)); var matchResult = matcher.Execute(dib); _server.LogMessage(MessageType.Log, $"Loading files from {rootDir}"); return(LoadFromDirectoryAsync(rootDir, matchResult)); }
private bool ProcessGlob() { this.Log.AddInfo(string.Format(Util.CLEANUP_Processing, this.Version.ToString(3))); try { if (this._glob.Contains("..")) { this.Log.AddWarning(Util.EXCEPTION + " - " + Util.EXCEPTION_GlobDotDotNotSupportedInCleanup); } else { var globs = new Matcher(StringComparison.InvariantCultureIgnoreCase); globs.AddIncludePatterns(this._glob.Split(';')); var files = globs.GetResultsInFullPath(Globals.ApplicationMapPath).ToArray(); FileSystemUtils.DeleteFiles(files); } } catch (Exception ex) { this.Log.AddWarning(string.Format(Util.CLEANUP_ProcessError, ex.Message)); } this.Log.AddInfo(string.Format(Util.CLEANUP_ProcessComplete, this.Version.ToString(3))); return(true); }
private static IEnumerable <string> GetCompileFullPaths(XElement compile, string includeOrRemovePattern, string csProjRoot) { if (string.IsNullOrEmpty(csProjRoot)) { csProjRoot = "./"; } // solve macro includeOrRemovePattern = includeOrRemovePattern.Replace("$(ProjectDir)", csProjRoot).Replace("$(MSBuildProjectDirectory)", csProjRoot); var matcher = new Matcher(StringComparison.OrdinalIgnoreCase); matcher.AddIncludePatterns(includeOrRemovePattern.Split(';')); var exclude = compile?.Attribute("Exclude")?.Value; if (exclude != null) { matcher.AddExcludePatterns(exclude.Split(';')); } foreach (var path in matcher.GetResultsInFullPath(csProjRoot)) { yield return(path); } }
private static void ProcessInputDirectory(AppContext appContext) { var patterns = appContext.SearchPatterns.Split(new char[] { ';' }, StringSplitOptions.RemoveEmptyEntries); var matcher = new Matcher(); matcher.AddIncludePatterns(patterns); var files = matcher.GetResultsInFullPath(appContext.InputDirectory); foreach (var file in files) { try { using (Log.Logger.BeginTimedOperation("Process file", file)) { var fileContext = new FileContext(appContext, file); fileContext.ProcessFile(); } } catch (Exception exception) { Log.Error(exception, "Failed to process {Path}", file); } } }
public async Task <bool> TryHandleCommandAsync(IImmutableSet <IProjectTree> nodes, long commandId, bool focused, long commandExecuteOptions, IntPtr variantArgIn, IntPtr variantArgOut) { _appShell.AssertIsOnMainThread(); if (commandId != RPackageCommandId.icmdSendToRemote) { return(false); } var properties = _configuredProject.Services.ExportProvider.GetExportedValue <ProjectProperties>(); string projectDir = Path.GetDirectoryName(_configuredProject.UnconfiguredProject.FullPath); string fileFilterString = await properties.GetFileFilterAsync(); Matcher matcher = new Matcher(StringComparison.OrdinalIgnoreCase); matcher.AddIncludePatterns(fileFilterString.Split(new string[] { ";" }, StringSplitOptions.RemoveEmptyEntries)); List <string> filteredFiles = new List <string>(); filteredFiles.AddRange(matcher.GetMatchedFiles(nodes.GetAllFolderPaths(_configuredProject.UnconfiguredProject))); // Add any file that user specifically selected. This can contain a file ignored by the filter. filteredFiles.AddRange(nodes.Where(n => n.IsFile()).Select(n => n.FilePath)); string projectName = properties.GetProjectName(); string remotePath = await properties.GetRemoteProjectPathAsync(); if (filteredFiles.Count > 0) { await SendToRemoteAsync(filteredFiles.Distinct(), projectDir, projectName, remotePath); } return(true); }
private async Task SendProjectAsync(EnvDTE.Project project, string remotePath, string filterString) { ProgressOutputWriter.WriteLine("Preparing to transfer project."); var projectDir = Path.GetDirectoryName(project.FullName); var projectName = Path.GetFileNameWithoutExtension(project.FullName); string[] filterSplitter = { ";" }; Matcher matcher = new Matcher(StringComparison.InvariantCultureIgnoreCase); matcher.AddIncludePatterns(filterString.Split(filterSplitter, StringSplitOptions.RemoveEmptyEntries)); ProgressOutputWriter.WriteLine($"Remote destination: {remotePath}"); ProgressOutputWriter.WriteLine($"File filter applied: {filterString}"); ProgressOutputWriter.WriteLine("Compressing project files for transfer: "); var compressedFilePath = FileSystem.CompressDirectory(projectDir, matcher, new Progress <string>((p) => { ProgressOutputWriter.WriteLine($"Compressing: {p}"); }), CancellationToken.None); using (var fts = new FileTransferSession(Session, FileSystem)) { ProgressOutputWriter.Write("Transferring project to remote host..."); var remoteFile = await fts.SendFileAsync(compressedFilePath); await Session.EvaluateAsync <string>($"rtvs:::save_to_project_folder({remoteFile.Id}, {projectName.ToRStringLiteral()}, '{remotePath.ToRPath()}')", REvaluationKind.Normal); } ProgressOutputWriter.WriteLine(" done."); }
public void Run(string path, string include, string exclude, Action <string> action) { var matcher = new Matcher(StringComparison.OrdinalIgnoreCase); if (string.IsNullOrEmpty(include)) { matcher.AddInclude("**/*"); } else { var tmp = include.Split(new char[] { ';' }, StringSplitOptions.RemoveEmptyEntries); matcher.AddIncludePatterns(tmp); } if (string.IsNullOrEmpty(exclude) == false) { var tmp = exclude.Split(new char[] { ';' }, StringSplitOptions.RemoveEmptyEntries); matcher.AddExcludePatterns(tmp); } var files = matcher.GetResultsInFullPath(path) .ToList(); if (files.Any()) { foreach (var file in files) { action?.Invoke(file); } } }
private static string CreateUnityPackage(IPackage meta, IPackageVariation variation) { var matcher = new Matcher(); matcher.AddIncludePatterns(variation.UnityPackage.Includes); matcher.AddExclude("**/*.meta"); if (variation.UnityPackage.Excludes != null) { matcher.AddExcludePatterns(variation.UnityPackage.Excludes); } var rootDirectory = new DirectoryInfoWrapper(new DirectoryInfo(Application.dataPath)); var assets = matcher.Execute(rootDirectory).Files.Select(w => $"Assets/{w.Path}"); var destDirectory = Path.Combine(Application.dataPath, meta.Describe.Output); if (!Directory.Exists(destDirectory)) { Directory.CreateDirectory(destDirectory); } var destName = string.IsNullOrWhiteSpace(variation.UnityPackage.Name) ? $"{meta.Name}.unitypackage" : $"{variation.UnityPackage.Name}.unitypackage"; var publishTo = Path.Combine(destDirectory, destName); if (File.Exists(publishTo)) { File.Delete(publishTo); } AssetDatabase.ExportPackage(assets.ToArray(), publishTo, ExportPackageOptions.Default); return(publishTo); }
private async Task SendProjectAsync(EnvDTE.Project project, string remotePath, string filterString, CancellationToken cancellationToken) { Console.WriteLine(Resources.Info_PreparingProjectForTransfer); var projectDir = Path.GetDirectoryName(project.FullName); var projectName = Path.GetFileNameWithoutExtension(project.FullName); string[] filterSplitter = { ";" }; Matcher matcher = new Matcher(StringComparison.InvariantCultureIgnoreCase); matcher.AddIncludePatterns(filterString.Split(filterSplitter, StringSplitOptions.RemoveEmptyEntries)); Console.WriteLine(Resources.Info_RemoteDestination.FormatInvariant(remotePath)); Console.WriteLine(Resources.Info_FileTransferFilter.FormatInvariant(filterString)); Console.WriteLine(Resources.Info_CompressingFiles); var compressedFilePath = FileSystem.CompressDirectory(projectDir, matcher, new Progress <string>((p) => { Console.WriteLine(Resources.Info_LocalFilePath.FormatInvariant(p)); string dest = p.MakeRelativePath(projectDir).ProjectRelativePathToRemoteProjectPath(remotePath, projectName); Console.WriteLine(Resources.Info_RemoteFilePath.FormatInvariant(dest)); }), CancellationToken.None); using (var fts = new DataTransferSession(Session, FileSystem)) { Console.WriteLine(Resources.Info_TransferringFiles); var remoteFile = await fts.SendFileAsync(compressedFilePath, true, null, cancellationToken); await Session.EvaluateAsync <string>($"rtvs:::save_to_project_folder({remoteFile.Id}, {projectName.ToRStringLiteral()}, '{remotePath.ToRPath()}')", REvaluationKind.Normal, cancellationToken); } Console.WriteLine(Resources.Info_TransferringFilesDone); }
static string[] GetFilePathsFromGlobPatterns(string rootPath, string[] globPatterns) { var matcher = new Matcher(StringComparison.CurrentCultureIgnoreCase); matcher.AddExcludePatterns(globPatterns.Where(globPattern => globPattern.StartsWith(GLOB_EXCLUDE_CHAR.ToString())).Select(globPattern => globPattern.TrimStart(GLOB_EXCLUDE_CHAR))); matcher.AddIncludePatterns(globPatterns.Where(globPattern => !globPattern.StartsWith(GLOB_EXCLUDE_CHAR.ToString()))); return(matcher.GetResultsInFullPath(rootPath).ToArray()); }
public ICollection <MigrationInfo> Load(ICollection <IFileProvider> fileProviders, string pattern) { var matcher = new Matcher(StringComparison.OrdinalIgnoreCase); matcher.AddIncludePatterns(new[] { pattern }); return(fileProviders.SelectMany(x => LoadDirectory(x, matcher)).ToArray()); }
public static Matcher CreateMatcher(IEnumerable <string> include, IEnumerable <string> exclude) { var fileMatcher = new Matcher(StringComparison.OrdinalIgnoreCase); fileMatcher.AddIncludePatterns(include.Any() ? include : AllFilesList); fileMatcher.AddExcludePatterns(exclude); return(fileMatcher); }
private SourceFileMatcher(string[] include, string[] exclude) { Include = include.ToImmutableArray(); Exclude = exclude.ToImmutableArray(); _matcher = new Matcher(StringComparison.OrdinalIgnoreCase); _matcher.AddIncludePatterns(Include); _matcher.AddExcludePatterns(Exclude); }
public GlobMatcher(IEnumerable <string> includes, IEnumerable <string> excludes) { var matcher = new Matcher(); matcher.AddIncludePatterns(includes); matcher.AddExcludePatterns(excludes); _matcher = matcher; }
public virtual IEnumerable <string> Find(string directoryPath, IEnumerable <string> excludePatterns, IEnumerable <string> includePatterns) { var matcher = new Matcher(); matcher.AddExcludePatterns(excludePatterns ?? Enumerable.Empty <string>()); matcher.AddIncludePatterns(includePatterns ?? Enumerable.Empty <string>()); return(matcher.Execute(new DirectoryInfoWrapper(new DirectoryInfo(directoryPath))).Files.Select(file => file.Path)); }
private int Execute(IReadOnlyList <string> include, bool preprocess) { var matcher = new Matcher(); if (include.Count == 0) { matcher.AddInclude(@"**\*.tt"); } else { matcher.AddIncludePatterns(include); } var engine = new Engine(); var templates = matcher.GetResultsInFullPath(_appEnv.ApplicationBasePath); foreach (var template in templates) { Console.WriteLine("Processing '{0}'...", template); var host = new CommandLineEngineHost(); var fileName = Path.GetFileNameWithoutExtension(template); var content = File.ReadAllText(template); string transformedText; if (preprocess) { var relativeDir = Path.GetDirectoryName(template).Substring(_appEnv.ApplicationBasePath.Length); var classNamespace = _appEnv.ApplicationName; if (relativeDir.Length != 0) { classNamespace += '.' + relativeDir.Replace(Path.DirectorySeparatorChar, '.'); } string language; string[] references; transformedText = engine.PreprocessTemplate( content, host, fileName, classNamespace, out language, out references); } else { transformedText = engine.ProcessTemplate(content, host); } var output = Path.ChangeExtension(template, host.FileExtension); Console.WriteLine("Writing '{0}'...", output); File.WriteAllText(output, transformedText); } return(0); }
public static Matcher AddIncludePatterns(this Matcher result, string includes) { if (string.IsNullOrWhiteSpace(includes) == false) { var patterns = includes.Split(';', StringSplitOptions.RemoveEmptyEntries); result.AddIncludePatterns(patterns); } return(result); }
//----------------------------------------------------------- static void Main(string[] args) { var opts = ParseArgs(args); var matcher = new Matcher(StringComparison.InvariantCultureIgnoreCase); matcher.AddIncludePatterns(new string[] { opts.InputPattern }); var matches = matcher.Execute(new DirectoryInfoWrapper(opts.WorkingDir)) .Files .Select(f => Path.GetFullPath(f.Path, opts.WorkingDir.FullName)) .ToArray(); // These are probably already returned sorted Array.Sort(matches); foreach (var f in matches) { Console.WriteLine(f); } var images = matches .Select(f => new Image(ImageDataFactory.Create(f))) .ToArray(); if (images.Length < 1) { ErrorExit("No images found for include pattern."); } var writer = new PdfWriter(opts.OutPath); var pdf = new PdfDocument(writer); var doc = new Document(pdf); doc.SetMargins(0, 0, 0, 0); // Take size of first image as the page size float imgWidth = images[0].GetImageWidth(); float imgHeight = images[0].GetImageHeight(); pdf.SetDefaultPageSize(new(new(0, 0, imgWidth, imgHeight) ) ); foreach (var img in images) { img.SetMargins(0, 0, 0, 0); img.SetPadding(0); img.SetWidth(pdf.GetDefaultPageSize().GetWidth()); img.SetAutoScaleHeight(true); doc.Add(img); } pdf.Close(); }
private static Matcher GetMatcher(string[] includePatterns, string[] excludePatterns) { Matcher matcher = new Matcher(); matcher.AddIncludePatterns(includePatterns.IsNullOrEmpty() ? new[] { "**/*" } : includePatterns); if (!excludePatterns.IsNullOrEmpty()) { matcher.AddExcludePatterns(excludePatterns); } return(matcher); }
/// <summary> /// Returns a list of files matching the specified globbing patterns. Patterns starting with /// `!` are interpreted as exclude patterns. /// </summary> public IEnumerable <FileInfoBase> Files(IEnumerable <string> globs) { var matcher = new Matcher(); var includePatterns = globs.Where(s => s.Length > 0 && s[0] != '!'); var excludePatterns = globs.Where(s => s.Length > 0 && s[0] == '!').Select(s => s.Substring(1)); matcher.AddIncludePatterns(includePatterns); matcher.AddExcludePatterns(excludePatterns); var results = matcher.Execute(Root); return(results.Files.Select(f => File(f.Path))); }
private void OnDebug() { var matcher = new Matcher(); matcher.AddExclude("**/*.meta"); matcher.AddIncludePatterns(_includes); matcher.AddExcludePatterns(_excludes); var rootDirectory = new DirectoryInfoWrapper(new DirectoryInfo(Application.dataPath)); _matches.Clear(); _matches.AddRange(matcher.Execute(rootDirectory).Files.Select(w => $"Assets/{w.Path}")); }
private SourceFileMatcher(string[] include, string[] exclude) { _shouldMatchAll = include.Length == 0 && exclude.Length == 0; Include = include.Length > 0 ? include.ToImmutableArray() : AllFilesList.ToImmutableArray(); Exclude = exclude.ToImmutableArray(); _matcher = new Matcher(StringComparison.OrdinalIgnoreCase); _matcher.AddIncludePatterns(Include); _matcher.AddExcludePatterns(Exclude); }
public ExitCode Run() { _logger.LogDebug("Identifying file to process in {Count} directories. {CountInclude} includes, {CountExclude} excludes were provided", _settings.Directories.Length, _settings.Includes?.Length ?? 0, _settings.Excludes?.Length ?? 0); Matcher globber = new Matcher(StringComparison.OrdinalIgnoreCase); if (_settings.Includes != null) { globber.AddIncludePatterns(_settings.Includes); } if (_settings.Excludes != null) { globber.AddExcludePatterns(_settings.Excludes); } if (!_settings.NoDefaultExcludes) { globber.AddExclude("**/obj/**.targets"); globber.AddExclude("**/bin/**.targets"); } foreach (string directory in _settings.Directories) { using (_logger.BeginScope(new Dictionary <string, object> { { "Directory", directory } })) { _logger.LogDebug("Searching for files in {Directory}", directory); if (Directory.Exists(directory)) { IEnumerable <string> files = globber.GetResultsInFullPath(directory); foreach (string file in files) { HandleFile(_formatter, file); ProcessedFiles++; } } else { _logger.LogWarning("{Directory} was not found", directory); } } } return(ExitCode.Ok); }
public static Matcher AddIncludePatterns(this Matcher result, string patterns, char separator, string defaultValue) { if (string.IsNullOrEmpty(patterns)) { result.AddInclude(defaultValue); } else { var items = patterns.Split(new char[] { separator }, StringSplitOptions.RemoveEmptyEntries); result.AddIncludePatterns(items); } return(result); }
private static void CreateZipPackage(IPackage meta, IPackageVariation variation, string publishedTo) { var matcher = new Matcher(); if (variation.Archive?.Includes != null) { matcher.AddIncludePatterns(variation.Archive.Includes); } if (variation.Archive?.Excludes != null) { matcher.AddExcludePatterns(variation.Archive.Excludes); } var rootDirectory = new DirectoryInfoWrapper(new DirectoryInfo(Application.dataPath)); var assets = matcher.Execute(rootDirectory).Files.Select(w => $"Assets/{w.Path}"); var sb = new List <string>(); sb.Add(string.IsNullOrWhiteSpace(variation.Archive?.Name) ? meta.Name : variation.Archive.Name); if (!string.IsNullOrWhiteSpace(variation.Name)) { sb.Add(variation.Name); } sb.Add(meta.Version); var archiveName = string.Join("-", sb); var destDirectory = Path.Combine(Application.dataPath, meta.Describe.Output, archiveName); if (!Directory.Exists(destDirectory)) { Directory.CreateDirectory(destDirectory); } foreach (var asset in assets) { var baseDir = string.IsNullOrWhiteSpace(variation.Archive?.BaseDir) ? "" : $"Assets/{variation.Archive.BaseDir}"; var destTo = $"{destDirectory}/{(string.IsNullOrWhiteSpace(baseDir) ? asset : asset.Replace(baseDir, ""))}"; if (!Directory.Exists(Path.GetDirectoryName(destTo))) { Directory.CreateDirectory(Path.GetDirectoryName(destTo) ?? string.Empty); } File.Copy(asset, destTo, true); } File.Copy(publishedTo, $"{destDirectory}/{Path.GetFileName(publishedTo)}", true); ZipFile.CreateFromDirectory(destDirectory, $"{destDirectory}.zip", CompressionLevel.Optimal, true); Directory.Delete(destDirectory, true); }
public int OnExecute() { try { if (Targets == null || Targets.Length == 0) { _Console.Error.WriteLine("one or more files must be specified"); return(1); } var basedir = !string.IsNullOrEmpty(BaseDirectory) ? BaseDirectory : Directory.GetCurrentDirectory(); var fromenc = TextConverter.GetEncodingFromString(FromEncoding); var toenc = TextConverter.GetEncodingFromString(ToEncoding); var matcher = new Matcher(StringComparison.CurrentCultureIgnoreCase); matcher.AddIncludePatterns(Targets); if (Exclude != null && Exclude.Length != 0) { matcher.AddExcludePatterns(Exclude); } var baseDirInfo = new DirectoryInfoWrapper(new DirectoryInfo(basedir)); var result = matcher.Execute(baseDirInfo); if (!result.HasMatches) { _Console.Error.WriteLine("no file was matched"); return(3); } _Logger.LogDebug("converting {0} to {1}, newline = {2}, no preamble = {3}", fromenc.WebName, toenc.WebName, Newline, NoPreamble); foreach (var fpath in result.Files.Select(x => x.Path)) { if (DryRun) { Console.WriteLine($"replacing file(dryrun): {fpath}"); continue; } else { Console.WriteLine($"replacing file: {fpath}"); } DoEncoding(Path.Combine(baseDirInfo.FullName, fpath), fromenc, toenc); } return(0); } catch (Exception e) { _Console.Error.WriteLine("converting file error:{0}", e); return(2); } }
private static IEnumerable <string> GetCompileFullPaths(XElement compile, string includeOrRemovePattern, string csProjRoot) { var matcher = new Matcher(StringComparison.OrdinalIgnoreCase); matcher.AddIncludePatterns(includeOrRemovePattern.Split(';')); var exclude = compile?.Attribute("Exclude")?.Value; if (exclude != null) { matcher.AddExcludePatterns(exclude.Split(';')); } foreach (var path in matcher.GetResultsInFullPath(csProjRoot)) { yield return(path); } }
/// <summary> /// Based on the CLI args, find the matching files. Return just a distinct set in case there are duplicates matches /// </summary> private IEnumerable <string> GetFileList(IEnumerable <FileInfo> files, DirectoryInfo baseDir, IEnumerable <string> patterns) { var filePaths = files?.Select(x => x.FullName) ?? Array.Empty <string>(); if (baseDir != null && patterns != null) { var matcher = new Matcher(); matcher.AddIncludePatterns(patterns); var matchedFiles = matcher.GetResultsInFullPath(baseDir.FullName); // Union() removes duplicates from the return set, so we don't need to 'Distinct()' the collection ourselves. filePaths = filePaths.Union(matchedFiles); } // We still need to sort it though // (still need to Distinct, since user can pass in duplicate files via the '--file' arg) return(filePaths.Distinct().OrderBy(x => x)); }