public void ValidateTest() { // Make a valid one first. FilesingConfig uut = new FilesingConfig(); uut.PatternConfigs.Add(new PatternConfig(new Regex("Hello"))); uut.SearchDirectoryLocation = "./"; Assert.DoesNotThrow(() => uut.Validate()); // Start making things not valid. // Directory can not be null, empty, whitespace. uut.SearchDirectoryLocation = null; Assert.Throws <ValidationException>(() => uut.Validate()); uut.SearchDirectoryLocation = string.Empty; Assert.Throws <ValidationException>(() => uut.Validate()); uut.SearchDirectoryLocation = " "; Assert.Throws <ValidationException>(() => uut.Validate()); // Directory must exist. uut.SearchDirectoryLocation = "./lol"; Assert.Throws <ValidationException>(() => uut.Validate()); uut.SearchDirectoryLocation = "./"; // Number of threads can not be negative. uut.NumberOfThreads = -1; Assert.Throws <ValidationException>(() => uut.Validate()); // Patterns can not be empty. uut.PatternConfigs.Clear(); Assert.Throws <ValidationException>(() => uut.Validate()); }
private static FilesingConfig GenerateConfig(Regex regex, string searchDir, GenericLogger log, string inFile) { FilesingConfig config; if (regex == null) { log.WriteLine( FilesingConstants.LightVerbosity, "- Using regexes from config file '{0}'", inFile ); config = XmlLoader.LoadConfigFromXml(inFile, searchDir); } else { log.WriteLine( FilesingConstants.LightVerbosity, "- Regex specified on command line. Using regex '" + regex.ToString() + "'" ); if (string.IsNullOrWhiteSpace(inFile)) { log.WriteLine( FilesingConstants.LightVerbosity, "- No config file specified, not ignoring any files or directories." ); config = new FilesingConfig(); } else { log.WriteLine( FilesingConstants.LightVerbosity, "- Config file '{0}' specified. Using config file's global ignores and requires. Ignoring file's patterns since 'regex' was specified on CLI.", inFile ); config = XmlLoader.LoadConfigFromXml(inFile, searchDir); } config.PatternConfigs.Clear(); PatternConfig patternConfig = new PatternConfig(regex); config.PatternConfigs.Add(patternConfig); } config.SearchDirectoryLocation = searchDir; return(config); }
static int Main(string[] args) { GenericLogger log = new GenericLogger(); // Generic Logger's WriteLine adds a new line. So, // For Console, only call Write, as if we call WriteLine, // we'll get 2 new lines... one from GenericLogger, one from // Console.WriteLine. log.OnWriteLine += Console.Write; log.OnWarningWriteLine += Log_OnWarningWriteLine; log.OnErrorWriteLine += Log_OnErrorWriteLine; try { bool showHelp = false; bool showVersion = false; bool showLicense = false; string inFile = string.Empty; string searchDir = string.Empty; int numThreads = 1; int verbosity = 0; int foundExitCode = 0; Regex regex = null; OptionSet options = new OptionSet { { "h|help", "Shows this message and exits.", h => showHelp = (h != null) }, { "version", "Shows the version and exits.", v => showVersion = (v != null) }, { "license", "Shows the license information and exits.", l => showLicense = (l != null) }, { "f|configfile=", "The input file to determine which patterns to search for. Required if regex is not specified.", f => inFile = Path.GetFullPath(f) }, { "d|searchdir=", "The directory to search for files that match the patterns. Required.", d => searchDir = Path.GetFullPath(d) }, { "j|numthreads=", "The number of threads to use. 0 for the processor count. Defaulted to 1.", j => { if (int.TryParse(j, out numThreads) == false) { throw new ArgumentException( "Number of threads must be an integer, got: '" + j + "'" ); } } }, { "v|verbosity=", "How verbose the output should be. Levels are 0, 1, 2, and 3. 0 (the default) or less prints the least, 3 or more prints the most.", v => { if (int.TryParse(v, out verbosity) == false) { throw new ArgumentException( "Verbosity must be an integer, got: '" + v + "'" ); } } }, { "e|exit_code_on_find=", "If ANY matches are found, what the exit code should be. Defaulted to 0.", e => { if (int.TryParse(e, out foundExitCode) == false) { throw new ArgumentException( "exit_code_on_find must be an integer, got: '" + e + "'" ); } } }, { "r|regex=", "Searches the diretory for this regex. If a config file is specified as well, the global " + "ignore/require settings in the config file are applied when searching for this regex." + " Optional (uses regexes in config file if not specified).", r => { regex = new Regex(r, RegexOptions.Compiled); } } }; options.Parse(args); // Help will take precedence, followed by version, then // license. if (showHelp) { options.WriteOptionDescriptions(Console.Out); } else if (showVersion) { ShowVersion(); } else if (showLicense) { ShowLicense(); } else { log.Verbosity = verbosity; FilesingConfig config = GenerateConfig(regex, searchDir, log, inFile); config.NumberOfThreads = numThreads; log.WriteLine( FilesingConstants.LightVerbosity, "- Search directory specified: '" + searchDir + "'" ); IReadOnlyList <MatchResult> results = null; Stopwatch stopWatch = new Stopwatch(); try { stopWatch.Start(); using (FilesingRunner runner = new FilesingRunner(config, log)) { runner.Start(); results = runner.Join(); } } finally { stopWatch.Stop(); } log.WriteLine(FilesingConstants.LightVerbosity, "Operation took: " + stopWatch.Elapsed.TotalSeconds + "s"); if (results.Count == 0) { log.WriteLine("No Matches Found!"); } else { log.WriteLine("Matches Found:"); foreach (MatchResult result in results) { log.WriteLine(result.ToString()); } return(foundExitCode); } } } catch (OptionException e) { log.WriteLine(e.Message); return(-1); } catch (Exception e) { log.ErrorWriteLine("FATAL ERROR: " + e.Message); return(-2); } return(0); }
public void XmlLoadTest() { string fileName = Path.Combine(testFilesDir, "TestConfig.xml"); FilesingConfig config = XmlLoader.LoadConfigFromXml(fileName, TestDirManager.TestDir); // Check global ignore config { Assert.AreEqual(1, config.GlobalIgnoreConfigs.Count); IgnoreConfig globalIgnoreConfig = config.GlobalIgnoreConfigs[0]; // Should only contain 1 file: Assert.AreEqual(1, globalIgnoreConfig.IgnoredFiles.Count); PathExistsInCollection(globalIgnoreConfig.IgnoredFiles, TestDirManager.RootFile1); // Should only contain 1 dir: Assert.AreEqual(1, globalIgnoreConfig.IgnoredDirectories.Count); PathExistsInCollection(globalIgnoreConfig.IgnoredDirectories, TestDirManager.Dir2_MyDir); // Should only contain 1 file with regex: Assert.AreEqual(1, globalIgnoreConfig.IgnoredFilesWithRegex.Count); FileRegexExistsInCollection(globalIgnoreConfig.IgnoredFilesWithRegex, "myFile.+", false); // Should only contain 1 dir with regex: Assert.AreEqual(1, globalIgnoreConfig.IgnoredDirectoriesWithRegex.Count); DirRegexExistsInCollection(globalIgnoreConfig.IgnoredDirectoriesWithRegex, "dir3", true); // Should contain 2 extensions to ignore. Assert.AreEqual(2, globalIgnoreConfig.IgnoredFileExtensions.Count); FileRegexExistsInCollection(globalIgnoreConfig.IgnoredFileExtensions, @"\.html", true); FileRegexExistsInCollection(globalIgnoreConfig.IgnoredFileExtensions, @"\.dll", false); } // Check Requirements Config { Assert.AreEqual(1, config.GlobalRequireConfigs.Count); RequireConfig globalRequireConfig = config.GlobalRequireConfigs[0]; // Should only contain 1 file: Assert.AreEqual(1, globalRequireConfig.RequiredFiles.Count); PathExistsInCollection(globalRequireConfig.RequiredFiles, TestDirManager.Dir1_HelloHtml); // Should only contain 1 dir: Assert.AreEqual(1, globalRequireConfig.RequiredDirs.Count); PathExistsInCollection(globalRequireConfig.RequiredDirs, TestDirManager.Dir1); } // Check Patterns Assert.AreEqual(3, config.PatternConfigs.Count); // Check pattern 0 { PatternConfig config0 = config.PatternConfigs[0]; Assert.AreEqual("public", config0.Pattern.ToString()); Assert.AreEqual(RegexOptions.Compiled | RegexOptions.IgnoreCase, config0.Pattern.Options); // No ignores or requirements. Assert.AreEqual(0, config0.IgnoreConfigs.Count); Assert.AreEqual(0, config0.RequireConfigs.Count); } // Check pattern 1: { PatternConfig config1 = config.PatternConfigs[1]; Assert.AreEqual("class", config1.Pattern.ToString()); Assert.AreEqual(RegexOptions.Compiled, config1.Pattern.Options); // Check ignore config { Assert.AreEqual(1, config1.IgnoreConfigs.Count); IgnoreConfig ignoreConfig = config1.IgnoreConfigs[0]; // Should only contain 1 file: Assert.AreEqual(1, ignoreConfig.IgnoredFiles.Count); PathExistsInCollection(ignoreConfig.IgnoredFiles, TestDirManager.RootFile2); // Should only contain 1 dir: Assert.AreEqual(1, ignoreConfig.IgnoredDirectories.Count); PathExistsInCollection(ignoreConfig.IgnoredDirectories, TestDirManager.Dir1); // Should only contain 1 file with regex: Assert.AreEqual(1, ignoreConfig.IgnoredFilesWithRegex.Count); FileRegexExistsInCollection(ignoreConfig.IgnoredFilesWithRegex, "Hello", false); // Should only contain 1 dir with regex: Assert.AreEqual(1, ignoreConfig.IgnoredDirectoriesWithRegex.Count); DirRegexExistsInCollection(ignoreConfig.IgnoredDirectoriesWithRegex, "Dir1", false); // Should contain 2 extensions to ignore. Assert.AreEqual(2, ignoreConfig.IgnoredFileExtensions.Count); FileRegexExistsInCollection(ignoreConfig.IgnoredFileExtensions, @"\.txt", true); FileRegexExistsInCollection(ignoreConfig.IgnoredFileExtensions, @"\.EXE", false); } // Check requirements config { Assert.AreEqual(1, config1.RequireConfigs.Count); RequireConfig requireConfig = config1.RequireConfigs[0]; // Should only contain 1 file: Assert.AreEqual(1, requireConfig.RequiredFiles.Count); PathExistsInCollection(requireConfig.RequiredFiles, TestDirManager.Dir2_MyfileTxt); // Should only contain 1 dir: Assert.AreEqual(1, requireConfig.RequiredDirs.Count); PathExistsInCollection(requireConfig.RequiredDirs, TestDirManager.Dir2_MyDir); } } // Check pattern 2: { PatternConfig config2 = config.PatternConfigs[2]; Assert.AreEqual("hello", config2.Pattern.ToString()); Assert.AreEqual(RegexOptions.Compiled | RegexOptions.IgnoreCase, config2.Pattern.Options); // No ignores or requirements. Assert.AreEqual(0, config2.IgnoreConfigs.Count); Assert.AreEqual(0, config2.RequireConfigs.Count); } }