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);
}
}
