static void Main(string[] args) { Target(Clean, ForEach("**/bin", "**/obj"), dir => { IEnumerable <string> GetDirectories(string d) { return(Glob.Directories(".", d)); } void RemoveDirectory(string d) { if (Directory.Exists(d)) { Console.WriteLine(d); Directory.Delete(d, true); } } foreach (var d in GetDirectories(dir)) { RemoveDirectory(d); } }); Target(Build, ForEach("net46", "netstandard2.0", "netstandard2.1"), framework => { if (!RuntimeInformation.IsOSPlatform(OSPlatform.Windows) && framework == "net46") { return; } Run("dotnet", "build src/SharpCompress/SharpCompress.csproj -c Release"); }); Target(Test, DependsOn(Build), ForEach("netcoreapp3.1"), framework => { IEnumerable <string> GetFiles(string d) { return(Glob.Files(".", d)); } foreach (var file in GetFiles("**/*.Test.csproj")) { Run("dotnet", $"test {file} -c Release -f {framework} --no-restore --no-build"); } }); Target(Publish, DependsOn(Test), () => { Run("dotnet", "pack src/SharpCompress/SharpCompress.csproj -c Release -o artifacts/"); }); Target("default", DependsOn(Publish), () => Console.WriteLine("Done!")); RunTargetsAndExit(args); }
public void StarStarFiles() { Action <string> AssertEqual(string expected) => actual => Assert.Equal(expected, actual); var testRoot = Path.Combine(Path.GetTempPath(), "Glob", "PathTraverserTests", "StarStarFiles"); try { CreateFiles(testRoot, "ab/bin/a.cs ab/bin/sub/a.cs a/taco.cs b/taco.cs b/ab/a/hat.taco"); // Verify files exist before Assert.True(File.Exists(Path.Combine(testRoot, "a/taco.cs"))); Assert.True(File.Exists(Path.Combine(testRoot, "ab/bin/a.cs"))); Assert.True(File.Exists(Path.Combine(testRoot, "ab/bin/sub/a.cs"))); Assert.True(File.Exists(Path.Combine(testRoot, "b/ab/a/hat.taco"))); Assert.True(File.Exists(Path.Combine(testRoot, "b/taco.cs"))); Assert.Collection(Glob.Files(testRoot, "**").OrderBy(x => x), AssertEqual(Path.Combine("a", "taco.cs")), AssertEqual(Path.Combine("ab", "bin", "a.cs")), AssertEqual(Path.Combine("ab", "bin", "sub", "a.cs")), AssertEqual(Path.Combine("b", "ab", "a", "hat.taco")), AssertEqual(Path.Combine("b", "taco.cs")) ); } finally { // Cleanup test Directory.Delete(testRoot, true); } }
/// <summary> /// Copies the files matching the specified globs from one directory to another, creating subdirectories as needed. /// </summary> /// <param name="fromDirectory">The source directory.</param> /// <param name="toDirectory">The target directory.</param> /// <param name="globs">The globs to match. Use <c>"**"</c> to copy all files and directories.</param> public static void CopyFiles(string fromDirectory, string toDirectory, params string[] globs) { if (fromDirectory == null) { throw new ArgumentNullException(nameof(fromDirectory)); } if (toDirectory == null) { throw new ArgumentNullException(nameof(toDirectory)); } if (globs == null) { throw new ArgumentNullException(nameof(globs)); } foreach (var filePath in globs.SelectMany(glob => Glob.Files(fromDirectory, glob, GlobOptions.CaseInsensitive)).Distinct()) { if (Path.GetDirectoryName(filePath) is string directoryName) { Directory.CreateDirectory(Path.Combine(toDirectory, directoryName)); } File.Copy(Path.Combine(fromDirectory, filePath), Path.Combine(toDirectory, filePath)); } }
public void Issue59MultipleEnumerationsReturnSameResults() { var testRoot = Path.Combine(Path.GetTempPath(), "Glob", "PathTraverserTests", "Issue59MultipleEnumerationsReturnSameResults"); try { CreateFiles(testRoot, "b/a taco.txt a/b"); var allFiles = Glob.Files(testRoot, "**").OrderBy(x => x); var enumerator1 = allFiles.GetEnumerator(); AssertEnumerator(enumerator1, Path.Combine("a", "b")); AssertEnumerator(enumerator1, Path.Combine("b", "a")); AssertEnumerator(enumerator1, "taco.txt"); Assert.False(enumerator1.MoveNext()); // second enumeration should emit same results var enumerator2 = allFiles.GetEnumerator(); AssertEnumerator(enumerator2, Path.Combine("a", "b")); AssertEnumerator(enumerator2, Path.Combine("b", "a")); AssertEnumerator(enumerator2, "taco.txt"); Assert.False(enumerator2.MoveNext()); } finally { // Cleanup test Directory.Delete(testRoot, true); } }
public static void Restore() { LOG.Debug("Restoring Settings"); var currentSettingsFile = ConfigurationManager.OpenExeConfiguration(ConfigurationUserLevel.PerUserRoamingAndLocal).FilePath; LOG.Debug($"Current Settings File: {currentSettingsFile}"); var localAppData = new DirectoryInfo(Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData)); var settingsFile = Glob.Files(localAppData, "Tabbed*TortoiseGit/Tabbed*TortoiseGit*/*/user.config") .Where((f) => f.FullName != currentSettingsFile) .OrderBy((f) => f.LastWriteTime) .LastOrDefault(); LOG.Debug($"Previous Settings File: {settingsFile?.FullName}"); if (settingsFile != null) { LOG.Debug("Copying previous settings file to current settings file"); Directory.CreateDirectory(Path.GetDirectoryName(currentSettingsFile) !); settingsFile.CopyTo(currentSettingsFile, true); LOG.Debug("Reloading settings"); Settings.Default.Reload(); } }
// Start is called before the first frame update void Start() { musicFolderPath = musicFolderPath.Replace('\\', '/'); matchingFiles = Glob.Files($"{musicFolderPath}", "*.wav").ToArray(); foreach (string path in matchingFiles) { StartCoroutine(LoadAudio(musicFolderPath + "/" + path)); } }
public void CanMatchFilesInDirectoriesWithTrailingSlash() { var globPattern = @"**/*Gl*.Te*"; var root = new DirectoryInfo(SourceRoot + Path.DirectorySeparatorChar).FullName; var result = Glob.Files(root, globPattern).ToList(); Assert.NotNull(result); Assert.All(result, path => Assert.StartsWith("test", path)); Assert.True(result.Any(), $"There should be some directories that match glob: {globPattern} in '{root}'"); }
protected override void ConfigureBuildProperties(IBuildPropertiesContext context) { context.Properties.Set(BuildProps.ProductId, "CAP"); context.Properties.Set(BuildProps.SolutionFileName, "CAP.sln"); context.Properties.Set(BuildProps.BuildConfiguration, string.IsNullOrEmpty(Configuration) ? "Release" : Configuration); //// todo remove casting when new version of flubu is available BuildVersion = FetchBuildVersion(context as ITaskContext); Console.WriteLine(BuildVersion.Version()); TestProjectFiles = Glob.Files("./test", "*/*.csproj", GlobOptions.MatchFullPath).Select(x => $"./test/{x}").ToList(); ProjectFiles = Glob.Files("./src", "*/*.csproj").Select(x => $"./src/{x}").ToList(); }
static void Main(string[] args) { Target(Clean, ForEach("publish", "**/bin", "**/obj"), dir => { IEnumerable <string> GetDirectories(string d) { return(Glob.Directories(".", d)); } void RemoveDirectory(string d) { if (Directory.Exists(d)) { Console.WriteLine($"Cleaning {d}"); Directory.Delete(d, true); } } foreach (var d in GetDirectories(dir)) { RemoveDirectory(d); } }); Target(Build, () => Run("dotnet", "build . -c Release")); Target(Test, DependsOn(Build), () => { IEnumerable <string> GetFiles(string d) { return(Glob.Files(".", d)); } foreach (var file in GetFiles("tests/**/*.csproj")) { Run("dotnet", $"test {file} -c Release --no-restore --no-build --verbosity=normal"); } }); Target(Publish, DependsOn(Test), ForEach("src/Conduit"), project => { Run("dotnet", $"publish {project} -c Release -f netcoreapp3.1 -o ./publish --no-restore --no-build --verbosity=normal"); }); Target("default", DependsOn(Publish), () => Console.WriteLine("Done!")); RunTargetsAndExit(args); }
/// <summary> /// Finds the files matching the specified globs. /// </summary> /// <param name="directory">The starting directory.</param> /// <param name="globs">The globs to match.</param> /// <returns>The paths of the matching files.</returns> public static IReadOnlyList <string> FindFilesFrom(string directory, params string[] globs) { if (directory == null) { throw new ArgumentNullException(nameof(directory)); } if (globs == null) { throw new ArgumentNullException(nameof(globs)); } return(globs.SelectMany(glob => Glob.Files(directory, glob, GlobOptions.CaseInsensitive)).Distinct().Select(path => Path.Combine(directory, path)).ToList()); }
private int OnExecute() { // var project = new Project(); // project.groups = new List<ProjectGroup>(); // project.groups.Add(new ProjectGroup() { name = "Render", }) if (!File.Exists(manifest)) { Console.WriteLine($"Could not find manifest file [{manifest}]."); return(-1); } using (var fs = File.OpenRead(manifest)) { var dir = Path.GetDirectoryName(manifest); var m = Utf8Json.JsonSerializer.Deserialize <Manifest>(fs); foreach (var g in m.groups) { if (Path.IsPathRooted(g.path) || g.path.Contains("..")) { Console.WriteLine("Path must be relative and a subdirectory."); return(-1); } Console.WriteLine(g.name); var workingDir = Path.Combine(dir, g.path); foreach (var file in Glob.Files(workingDir, "*.json", GlobOptions.CaseInsensitive)) { if (ProcessFile(m, g, Path.Combine(workingDir, file)) != 0) { return(-1); } Console.WriteLine(" " + file); } } } // foreach (var file in Glob.Files(workingDir, search, GlobOptions.CaseInsensitive)) // { // if (ProcessFile(file) != 0) // return -1; // //WriteLine(file); // } return(0); }
/// <summary> /// Copies the files matching the specified globs from one directory to another, creating subdirectories as needed. /// </summary> /// <param name="fromDirectory">The source directory.</param> /// <param name="toDirectory">The target directory.</param> /// <param name="globs">The globs to match. Use <c>"**"</c> to copy all files and directories.</param> public static void CopyFiles(string fromDirectory, string toDirectory, params string[] globs) { if (fromDirectory == null) { throw new ArgumentNullException(nameof(fromDirectory)); } if (toDirectory == null) { throw new ArgumentNullException(nameof(toDirectory)); } if (globs == null) { throw new ArgumentNullException(nameof(globs)); } CopyFilesCore(fromDirectory, toDirectory, globs.SelectMany(glob => Glob.Files(fromDirectory, glob, GlobOptions.CaseInsensitive)).Distinct()); }
/// <summary> /// Creates a new plugin loader /// </summary> /// <param name="root">root folder, default is relative to executing assemlby</param> /// <param name="patterns"></param> public PluginLoader(ILogger logger = null, string rootDir = ".", IEnumerable <string> patterns = null) { logger.LogDebug("Getting files from {relpath}", rootDir); var files = new List <string>(); if (patterns == null) { files.AddRange(Glob.Files(rootDir, "**/*.dll")); } else { foreach (var pattern in patterns) { files.AddRange(Glob.Files(rootDir, Regex.Replace(pattern, @"^\./", ""))); } } logger.LogDebug("Found {fct} files:\n {@files}", files.Count, files); var builder = new ReflectionMetadataBuilder(); foreach (var file in files) { try { builder.AddAssembly(Path.Combine(rootDir, file)); } catch (Exception) { } } builder.AddReferenceOnlyAssemblyByType <object>(); // adds the corlib try { metaData = builder.Build(true); } catch (AggregateException aex) { throw; } catch (Exception ex) { } }
private static bool VerifyReportFileAndExpandGlobPatterns(string path, out IEnumerable <string> expanded) { expanded = null; if (string.IsNullOrWhiteSpace(path)) { Log.Warning("Invalid report path."); return(false); } if (path.Contains('*') || path.Contains('?') || path.Contains('!') || path.Contains(',')) { string directory; string pattern; if (Path.IsPathRooted(path)) { directory = Path.GetPathRoot(path); pattern = path.Substring(directory.Length); } else { directory = Environment.CurrentDirectory; pattern = path; } expanded = Glob.Files(directory, pattern, GlobOptions.Compiled | GlobOptions.CaseInsensitive) .Select(x => Path.Combine(directory, x)) .Distinct(); return(true); } else if (!File.Exists(path)) { Log.Warning("The file {path} does not exist.", path); return(false); } expanded = new[] { path }; return(true); }
private static bool VerifyReportFileAndExpandGlobPatterns(string path, out IEnumerable <string> expandedPath) { var expanded = new HashSet <string> { path }; expandedPath = expanded; if (string.IsNullOrWhiteSpace(path)) { Logger.Log.Warning("Invalid report path."); return(false); } if (path.Contains('*') || path.Contains('?') || path.Contains('!') || path.Contains(',')) { // Logger.Log.Information($"Using wildcard path {path}"); var matches = Glob.Files(Environment.CurrentDirectory, path, GlobOptions.Compiled | GlobOptions.CaseInsensitive)?.ToList(); if (matches?.Any() != true) { // Logger.Log.Warning($"There are no files that match the wildcard {path}."); return(false); } expanded.Clear(); matches.ForEach(_ => // Logger.Log.Information($"Adding file {_} that matches wildcard path {path}"); expanded.Add(_)); return(true); } else if (!File.Exists(path)) { Logger.Log.Warning($"The file {path} does not exist."); return(false); } return(true); }
void RunWithSingleEntry(string inputPath) { if (Directory.Exists(inputPath)) { foreach (var fileName in Directory.EnumerateFiles(inputPath)) { RunWithSingleFileSafe(Path.Combine(inputPath, fileName)); } } else if (File.Exists(inputPath)) { RunWithSingleFileSafe(inputPath); } else { var specialCharPos = inputPath.IndexOfAny("*?[{".ToCharArray()); if (specialCharPos < 0) { throw new BinariexException("finding source file", "Input file not found.").AddInputPath(inputPath); } var sepCharPos = inputPath.LastIndexOf(Path.DirectorySeparatorChar, specialCharPos); if (sepCharPos < 0) { throw new BinariexException("finding source file", "Need directory path before wildcard.").AddInputPath(inputPath); } var rootDirPath = inputPath.Substring(0, sepCharPos); if (!Directory.Exists(rootDirPath)) { throw new BinariexException("finding source file", "Input file not found.").AddInputPath(inputPath); } foreach (var file in Glob.Files(new DirectoryInfo(rootDirPath), inputPath.Substring(sepCharPos + 1))) { RunWithSingleFileSafe(file.FullName); } } }
public void Issue59MissingFiles() { Action <string> AssertEqual(string expected) => actual => Assert.Equal(expected, actual); var testRoot = Path.Combine(Path.GetTempPath(), "Glob", "PathTraverserTests", "Issue59MissingFiles"); try { CreateFiles(testRoot, "test1.txt deep/test2.txt"); var allFiles = Glob.Files(testRoot, "**/*.txt").OrderBy(x => x).ToList(); Assert.Collection(allFiles, AssertEqual(Path.Combine("deep", "test2.txt")), AssertEqual("test1.txt") ); } finally { // Cleanup test Directory.Delete(testRoot, true); } }
public void StarStarFilesIssue52() { Action <string> AssertEqual(string expected) => actual => Assert.Equal(expected, actual); var testRoot = Path.Combine(Path.GetTempPath(), "Glob", "PathTraverserTests", "StarStarFilesIssue52"); try { CreateFiles(testRoot, "a/a/a/a/b.txt"); // Verify files exist before Assert.True(File.Exists(Path.Combine(testRoot, "a/a/a/a/b.txt"))); Assert.Collection(Glob.Files(testRoot, "**/a/**/b.txt").OrderBy(x => x), AssertEqual(Path.Combine("a", "a", "a", "a", "b.txt")) ); } finally { // Cleanup test Directory.Delete(testRoot, true); } }
public void Configure(IApophysisNative apophysis) { foreach (var glob in Plugin ?? new string[0]) { var dir = Path.IsPathRooted(glob) ? Regex.Replace(glob, "^(.+?)\\*.*$", "$1") : Environment.CurrentDirectory; var pattern = Path.IsPathRooted(glob) ? glob.Substring(dir.Length) : glob; foreach (var file in Glob.Files(dir, pattern, GlobOptions.MatchFullPath)) { _outputManager.Log($"Loading plugin: {file}"); apophysis.InitializePlugin(Path.Combine(dir, file)); } } using (var sr = new StreamReader(OpenInputStream())) { apophysis.Parameters = sr.ReadToEnd(); } apophysis.ImageFormat = ImageFormat; apophysis.ImageSize = ImageSize; apophysis.SamplesPerPixel = Quality; apophysis.ThreadingLevel = Threads; }
private static void Run(ArgsReader args) { var workingDirectory = args.ReadOption("w") ?? Environment.CurrentDirectory; var arguments = args.ReadArguments().ToList(); var globIndex = arguments.FindIndex(x => x.IndexOfAny(new[] { '*', '?', '[', '{' }) != -1); void LaunchFile(string filePath) { var processArgs = arguments.Take(globIndex).Append(filePath).Concat(arguments.Skip(globIndex + 1)).ToList(); var processStartInfo = new ProcessStartInfo { FileName = processArgs[0], WorkingDirectory = workingDirectory, UseShellExecute = true, }; foreach (var processArg in processArgs.Skip(1)) { processStartInfo.ArgumentList.Add(processArg); } Process.Start(processStartInfo); } if (arguments.Count == 0) { ShowMessageBox( "Usage: LaunchGlob <args...> [options] [-- <args...>]", "", "One argument must be a glob (e.g. *.sln). If there is one match,", "it will be launched immediately; otherwise, choose from the prompt.", "", "Options:", " -w <working-directory>"); } else if (globIndex == -1) { ShowMessageBox("Error: glob not found in arguments."); } else { var glob = arguments[globIndex]; var filePaths = Glob.Files(workingDirectory, glob, GlobOptions.CaseInsensitive).ToList(); if (filePaths.Count == 0) { ShowMessageBox( "File not found!", "", $"Glob: {glob}", $"Directory: {workingDirectory}"); } else if (filePaths.Count == 1) { LaunchFile(filePaths[0]); } else { var listBox = new ListBox { Anchor = AnchorStyles.Top | AnchorStyles.Bottom | AnchorStyles.Left | AnchorStyles.Right, ItemHeight = 15, Location = new Point(12, 12), Size = new Size(460, 94), TabIndex = 0, }; var launchButton = new Button { Anchor = AnchorStyles.Bottom | AnchorStyles.Right, Location = new Point(397, 116), Size = new Size(75, 23), TabIndex = 1, Text = "Launch", }; var form = new Form { AcceptButton = launchButton, AutoScaleDimensions = new SizeF(7F, 15F), AutoScaleMode = AutoScaleMode.Font, ClientSize = new Size(484, 151), Controls = { listBox, launchButton }, KeyPreview = true, MinimumSize = new Size(300, 150), ShowIcon = false, StartPosition = FormStartPosition.CenterScreen, Text = c_appCaption, }; foreach (var filePath in filePaths) { listBox.Items.Add(filePath); } listBox.SelectedIndex = 0; listBox.MouseDoubleClick += (s, e) => LaunchSelectedFile(); launchButton.Click += (s, e) => LaunchSelectedFile(); form.KeyDown += (s, e) => { if (e.KeyCode == Keys.Escape) { form.Close(); } }; Application.Run(form); void LaunchSelectedFile() { #pragma warning disable 8602 // https://github.com/dotnet/roslyn/issues/40821 LaunchFile(filePaths[listBox.SelectedIndex]); form.Close(); #pragma warning restore 8602 } } } }
static void AutoGen() { var root = typeof(Program).Assembly.GetModules()[0].FullyQualifiedName; while (!File.Exists(Path.Combine(root, "NWayland.sln"))) { root = Path.GetFullPath(Path.Combine(root, "..")); if (Path.GetPathRoot(root) == root) { throw new InvalidOperationException("Unable to find base directory"); } } string GetPath(params string[] elements) => Path.Combine(elements.Prepend(root).ToArray()); IEnumerable <string> GlobPath(params string[] elements) { var subRoot = GetPath(elements.SkipLast(1).ToArray()); var glob = Glob.Files(subRoot, elements.Last()); return(glob.Select(x => Path.Combine(subRoot, x))); } var coreProtocols = new List <string>(); var kdeProtocols = new List <string>(); coreProtocols.Add(GetPath("external", "wayland", "protocol", "wayland.xml")); coreProtocols.AddRange(GlobPath("external", "wayland-protocols", "**/*.xml")); var hints = ProtocolHintsConfiguration.GetGeneratorHints(); WaylandProtocolGroup Group(string assembly, string ns, IEnumerable <string> paths) => new WaylandProtocolGroup(assembly, ns) { Protocols = paths.Select(path => (WaylandProtocol) new XmlSerializer(typeof(WaylandProtocol)).Deserialize( new StringReader(File.ReadAllText(path)))) .Where(p => !hints.ProtocolBlacklist.Contains(p.Name)).ToList() }; var groups = new[] { Group("NWayland", "NWayland.Protocols", coreProtocols), Group("NWayland.Protocols.KWayland", "NWayland.Protocols.KWayland", GlobPath("external", "kwayland", "src", "client", "protocols", "**/*.xml")), Group("NWayland.Protocols.Wlr", "NWayland.Protocols.Wlr", GlobPath("external", "wlr-protocols", "**/*.xml")) }; var gen = new WaylandProtocolGenerator(groups, hints); foreach (var g in groups) { var generatedDir = GetPath("src", g.Assembly, "Generated"); if (Directory.Exists(generatedDir)) { Directory.Delete(generatedDir, true); } Directory.CreateDirectory(generatedDir); foreach (var protocol in g.Protocols) { var generated = gen.Generate(protocol); File.WriteAllText(Path.Combine(generatedDir, protocol.Name + ".generated.cs"), generated); } } }
/// <summary> /// Loads source sprites referenced in declaration input and packs sprites into a sprite sheet. /// </summary> /// <param name="declaration">Sprite sheet delcaration input.</param> /// <param name="context">Context of the process routine.</param> /// <returns>Sprite sheet content.</returns> public override SpriteSheetContent Process(SpriteSheetDeclaration declaration, ContentProcessorContext context) { if (declaration == null) { throw new ArgumentNullException(nameof(declaration)); } if (context == null) { throw new ArgumentNullException(nameof(context)); } // Collect all texture file paths. // var texturePaths = new HashSet <string>(); foreach (string pathPattern in declaration.PathPatterns) { foreach (string filePath in Glob.Files(Directory.GetCurrentDirectory(), pathPattern)) { texturePaths.Add(filePath); } } // Limit the packed texture based on the target graphics profile. // int maximumDimension = context.TargetProfile == GraphicsProfile.HiDef ? 4096 : 2048; PackedTexture packedTexture = SpritePacker.Pack( configuration: new PackConfiguration(maximumDimension, maximumDimension, this.IsPowerOfTwo, this.IsSquare, this.Padding), spritePaths: texturePaths.ToArray()); // Ensure our output directory exists. // if (!Directory.Exists(context.OutputDirectory)) { Directory.CreateDirectory(context.OutputDirectory); } // Write the packed texture to the output location. // string outputPath = Path.Combine(context.OutputDirectory, $"{declaration.Name}.png"); using (var stream = new FileStream(outputPath, FileMode.Create)) { packedTexture.Texture.Save(stream, ImageFormat.Png); } context.AddOutputFile(outputPath); // Finalize the content to serialize from this processor. // return(new SpriteSheetContent { Name = declaration.Name, SpriteNamesToIndexMapping = packedTexture.SpriteNamesToIndexMapping, SpriteRectangles = packedTexture.SpriteRectangles, Texture = this.BuildTexture($"{declaration.Name}Texture", outputPath, context), }); }
private static IEnumerable <string> GetDirectoryFileList(string path) { return(Glob.Files(path, "**/*")); }
/// <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()); }
/// <summary> /// Finds the files matching the specified globs. /// </summary> /// <param name="directory">The starting directory.</param> /// <param name="globs">The globs to match.</param> /// <returns>The paths of the matching files.</returns> public static IReadOnlyList <string> FindFilesFrom(string directory, params string[] globs) => globs.SelectMany(glob => Glob.Files(directory, glob, GlobOptions.CaseInsensitive)).Distinct().Select(path => Path.Combine(directory, path)).ToList();
public void CreateGraphs(string path) { Console.WriteLine("Generating graphs..."); // hour of day var f = new StreamWriter(path + "\\hour_of_day.plot"); f.Write(GnuplotCommon); f.Write($@" set output 'hour_of_day.{ImageType}' unset key set xrange [0.5:24.5] set xtics 4 set grid y set ylabel ""Commits"" plot 'hour_of_day.dat' using 1:2:(0.5) w boxes fs solid "); f.Close(); // day of week f = new StreamWriter(path + "\\day_of_week.plot"); f.Write(GnuplotCommon); f.Write($@" set output 'day_of_week.{ImageType}' unset key set xrange [0.5:7.5] set xtics 1 set grid y set ylabel ""Commits"" plot 'day_of_week.dat' using 1:2:(0.5) w boxes fs solid "); f.Close(); // Domains f = new StreamWriter(path + "\\domains.plot"); f.Write(GnuplotCommon); f.Write($@" set output 'domains.{ImageType}' unset key unset xtics set grid y set ylabel ""Commits"" plot 'domains.dat' using 2:3:(0.5) with boxes fs solid, '' using 2:3:1 with labels rotate by 45 offset 0,1 "); f.Close(); // Month of Year f = new StreamWriter(path + "\\month_of_year.plot"); f.Write(GnuplotCommon); f.Write($@" set output 'month_of_year.{ImageType}' unset key set xrange [0.5:12.5] set xtics 1 set grid y set ylabel ""Commits"" plot 'month_of_year.dat' using 1:2:(0.5) w boxes fs solid "); f.Close(); // commits_by_year_month f = new StreamWriter(path + "\\commits_by_year_month.plot"); f.Write(GnuplotCommon); f.Write($@" set output 'commits_by_year_month.{ImageType}' unset key set xdata time set timefmt ""%Y-%m"" set format x ""%Y-%m"" set xtics rotate by 90 15768000 set bmargin 5 set grid y set ylabel ""Commits"" plot 'commits_by_year_month.dat' using 1:2:(0.5) w boxes fs solid "); f.Close(); // commits_by_year f = new StreamWriter(path + "\\commits_by_year.plot"); f.Write(GnuplotCommon); f.Write($@" set output 'commits_by_year.{ImageType}' unset key set xtics 1 rotate by 90 set grid y set ylabel ""Commits"" set yrange [0:] plot 'commits_by_year.dat' using 1:2:(0.5) w boxes fs solid "); f.Close(); // Files by date f = new StreamWriter(path + "\\files_by_date.plot"); f.Write(GnuplotCommon); f.Write($@" set output 'files_by_date.{ImageType}' unset key set xdata time set timefmt ""%Y-%m-%d"" set format x ""%Y-%m-%d"" set grid y set ylabel ""Files"" set xtics rotate by 90 set ytics autofreq set bmargin 6 plot 'files_by_date.dat' using 1:2 w steps "); f.Close(); // Lines of Code f = new StreamWriter(path + "\\lines_of_code.plot"); f.Write(GnuplotCommon); f.Write($@" set output 'lines_of_code.{ImageType}' unset key set xdata time set timefmt ""%s"" set format x ""%Y-%m-%d"" set grid y set ylabel ""Lines"" set xtics rotate by 90 set bmargin 6 plot 'lines_of_code.dat' using 1:2 w lines "); f.Close(); Directory.SetCurrentDirectory(path); var matchingFiles = Glob.Files(path, "*.plot").ToArray(); foreach (var file in matchingFiles) { var output = GitStats.GetPipeOutput(new[] { Program.GnuPlotCmd + $" \"{file}\"" }); if (output.Length > 0) { Console.WriteLine(output); } } }
public void PathTraversal() { var SourceRoot = Path.Combine("..", "..", "..", "..", ".."); var results = Glob.Files(SourceRoot, "test/*Tests/**/*.cs").ToList(); }
public static IReadOnlyCollection <string> GlobFiles(string directory, params string[] patterns) { var directoryInfo = new DirectoryInfo(directory); return(patterns.SelectMany(x => Glob.Files(directoryInfo, x, GlobOptions)).Select(x => x.FullName).ToList()); }