public MapProcessor(MapResults results, string pattern)
{
string[] patternParts = pattern.Split(" > ");
if (patternParts.Length < 4)
{
throw new ArgumentException($"Invalid pattern '{pattern}'");
}
HashSet <string> options = patternParts[3]
.Split(',', StringSplitOptions.RemoveEmptyEntries)
.ToHashSet(StringComparer.OrdinalIgnoreCase);
_pattern = options.Contains("CaseSensitive")
? new Regex(Unescape(patternParts[0]))
: new Regex(Unescape(patternParts[0]), RegexOptions.IgnoreCase);
_options = options;
_replacement = Unescape(patternParts[1]);
_replacementGroupMatches = _groupSubstitution.Matches(_replacement);
string outputFile = patternParts[2];
if (!string.IsNullOrEmpty(outputFile))
{
_results = results.InitializeForFile(outputFile, options);
}
_replaceOrigin = options.Contains("ReplaceOrigin");
}
public MapPattern(MapResults results, IEnumerable <string> patterns)
{
_processors = patterns
.Where(item => !string.IsNullOrWhiteSpace(item))
.Select(pattern => new MapProcessor(results, pattern))
.ToArray();
}
private static ICollection <ICollection <MapPattern> > GetMapChains(IConfiguration configuration, MapResults mapResults)
{
int mapFlowIndex = 0;
bool mapFlowFailed = false;
ICollection <ICollection <MapPattern> > results = new List <ICollection <MapPattern> >();
while (!mapFlowFailed)
{
bool mapPatternFailed = false;
mapFlowFailed = true;
int mapPatternIndex = 0;
List <MapPattern> currentList = null;
while (!mapPatternFailed)
{
string patternFilesKey = $"mapConfigurations:{mapFlowIndex}:{mapPatternIndex}:patternFiles";
string patternsKey = $"mapConfigurations:{mapFlowIndex}:{mapPatternIndex}:patterns";
string[] patternFiles = configuration.GetSection(patternFilesKey).Get <string[]>();
string[] patterns = configuration.GetSection(patternsKey).Get <string[]>();
mapPatternFailed = patternFiles == null && patterns == null;
if (!mapPatternFailed)
{
if (currentList == null)
{
currentList = new List <MapPattern>();
results.Add(currentList);
}
mapFlowFailed = false;
}
if (patternFiles != null)
{
IEnumerable <MapPattern> mapPatterns = patternFiles
.Select(File.ReadAllLines)
.Select(lines => new MapPattern(mapResults, lines));
currentList.AddRange(mapPatterns);
}
if (patterns != null)
{
currentList.Add(new MapPattern(mapResults, patterns));
}
++mapPatternIndex;
}
++mapFlowIndex;
}
return(results);
}
private static void Main()
{
Logger logger;
IConfiguration appConfiguration;
IConfiguration searchConfiguration;
try
{
appConfiguration = GetConfiguration();
string configurationName = DisplayAndChooseConfiguration(appConfiguration);
logger = SetupLogger(configurationName);
searchConfiguration = GetSearchConfiguration(appConfiguration, configurationName);
}
catch (Exception e)
{
Console.WriteLine(e.ToString());
Console.ReadLine();
return;
}
try
{
Regex[] fileExcludePatterns = GetFileExcludePatterns(searchConfiguration);
Regex[] fileIncludePatterns = GetFileIncludePatterns(searchConfiguration);
Regex[] excludePatterns = GetExcludePatterns(searchConfiguration);
string[] itemsToSearch = GetItemsToSearch(searchConfiguration);
MapResults mapResults = new MapResults();
ICollection <ICollection <MapPattern> > mapChains = GetMapChains(searchConfiguration, mapResults);
IEnumerable <string> files = Directory
.EnumerateFiles(appConfiguration["searchRoot"],
"*",
SearchOption.AllDirectories
)
.Where(file =>
fileExcludePatterns.All(pattern => !pattern.IsMatch(file)) ||
fileIncludePatterns.Any(pattern => pattern.IsMatch(file))
);
int foundItemCount = 0;
FileCounter fileCounter = new FileCounter();
Parallel.ForEach(
files,
(file, state) =>
{
FileNameWriter fileNameWriter = new FileNameWriter(file, logger, fileCounter);
bool somethingReplaced = false;
string[] fileLines = File.ReadAllLines(file);
for (int lineIndex = 0; lineIndex < fileLines.Length; lineIndex++)
{
string fileLine = fileLines[lineIndex];
string currentLine = fileLine;
if (string.IsNullOrEmpty(currentLine))
{
continue;
}
if (itemsToSearch
.All(itemToSearch => !currentLine.Contains(itemToSearch, StringComparison.OrdinalIgnoreCase)))
{
continue;
}
for (int index = 0; index < excludePatterns.Length; index++)
{
Regex excludePattern = excludePatterns[index];
currentLine = excludePattern.Replace(currentLine, string.Empty);
}
for (int index = 0; index < excludePatterns.Length; index++)
{
Regex excludePattern = excludePatterns[index];
currentLine = excludePattern.Replace(currentLine, string.Empty);
}
if (itemsToSearch
.All(itemToSearch => !currentLine.Contains(itemToSearch, StringComparison.OrdinalIgnoreCase)))
{
continue;
}
fileNameWriter.Write();
logger.Information($" {lineIndex} {fileLine}");
++foundItemCount;
foreach (ICollection <MapPattern> mapChain in mapChains)
{
string processingLine = fileLine;
foreach (MapPattern mapPattern in mapChain)
{
(string outputLine, bool replaceOrigin) = mapPattern.Process(processingLine);
processingLine = outputLine;
if (replaceOrigin)
{
logger.Information("Replaced with:");
logger.Information($" {lineIndex} {processingLine}");
fileLines[lineIndex] = processingLine;
somethingReplaced = true;
}
}
}
}
if (somethingReplaced)
{
File.WriteAllLines(file, fileLines);
}
Console.WriteLine($"'{file}' has been processed");
}
);
logger.Information($"Found: {foundItemCount} items in {fileCounter.Count} files");
foreach ((string FileName, ICollection <string> Values)mapResult
in mapResults
.GetFiles()
.Select(fileName => (FileName: fileName, Results: mapResults.GetResults(fileName)))
)
{
ICollection <string> collection = mapResult.Values;
if (!collection.Any())
{
continue;
}
logger.Information(string.Empty);
logger.Information($"Results for output '{mapResult.FileName}':");
foreach (string item in collection)
{
logger.Information(item);
}
}
}
catch (Exception e)
{
logger.Error(e.ToString());
Console.ReadLine();
}
logger.Information(string.Empty);
logger.Information("Done");
}
