public List <GrepSearchResult> CaptureGroupSearch(IEnumerable <string> files, string filePatternInclude,
GrepSearchOption searchOptions, SearchType searchType, string searchPattern, int codePage)
{
searchResults.Clear();
if (files == null || !files.Any())
{
return(searchResults);
}
Utils.CancelSearch = false;
try
{
foreach (string filePath in files)
{
string fileName = Path.GetFileName(filePath);
string modSearchPattern = Regex.Replace(fileName, filePatternInclude, searchPattern,
RegexOptions.IgnoreCase, TimeSpan.FromSeconds(4.0));
if (string.IsNullOrEmpty(modSearchPattern))
{
continue;
}
else if (searchType == SearchType.Regex && !Utils.ValidateRegex(modSearchPattern))
{
logger.Error($"Capture group search pattern is not a valid regular expression: '{modSearchPattern}'");
continue;
}
Search(filePath, searchType, modSearchPattern, searchOptions, codePage);
if (searchOptions.HasFlag(GrepSearchOption.StopAfterFirstMatch) && searchResults.Count > 0)
{
break;
}
if (Utils.CancelSearch)
{
break;
}
}
}
catch (Exception ex)
{
logger.Error(ex, "Failed in capture group search");
}
finally
{
if (cancellationTokenSource != null)
{
cancellationTokenSource.Dispose();
cancellationTokenSource = null;
}
GrepEngineFactory.UnloadEngines();
}
return(new List <GrepSearchResult>(searchResults));
}
/// <summary>
/// Searches folder for files whose content matches regex
/// </summary>
/// <param name="files">Files to search in. If one of the files does not exist or is open, it is skipped.</param>
/// <param name="searchRegex">Regex pattern</param>
/// <returns>List of results. If nothing is found returns empty list</returns>
public List <GrepSearchResult> Search(IEnumerable <string> files, SearchType searchType, string searchPattern, GrepSearchOption searchOptions, int codePage)
{
List <GrepSearchResult> searchResults = new List <GrepSearchResult>();
if (files == null)
{
return(searchResults);
}
Utils.CancelSearch = false;
if (searchPattern == null || searchPattern.Trim() == "")
{
foreach (string file in files)
{
searchResults.Add(new GrepSearchResult(file, searchPattern, null));
if ((searchOptions & GrepSearchOption.StopAfterFirstMatch) == GrepSearchOption.StopAfterFirstMatch)
{
break;
}
}
if (ProcessedFile != null)
{
ProcessedFile(this, new ProgressStatus(searchResults.Count, searchResults));
}
return(searchResults);
}
else
{
int processedFiles = 0;
try
{
foreach (string file in files)
{
try
{
IGrepEngine engine = GrepEngineFactory.GetSearchEngine(file, SearchParams);
processedFiles++;
Encoding encoding = null;
if (codePage == -1)
{
encoding = Utils.GetFileEncoding(file);
}
else
{
encoding = Encoding.GetEncoding(codePage);
}
if (Utils.CancelSearch)
{
return(searchResults);
}
List <GrepSearchResult> fileSearchResults = engine.Search(file, searchPattern, searchType, searchOptions, encoding);
if (fileSearchResults != null && fileSearchResults.Count > 0)
{
searchResults.AddRange(fileSearchResults);
}
if (ProcessedFile != null)
{
ProcessedFile(this, new ProgressStatus(processedFiles, fileSearchResults));
}
}
catch (Exception ex)
{
logger.LogException(LogLevel.Error, ex.Message, ex);
searchResults.Add(new GrepSearchResult(file, searchPattern, ex.Message, false));
if (ProcessedFile != null)
{
List <GrepSearchResult> _results = new List <GrepSearchResult>();
_results.Add(new GrepSearchResult(file, searchPattern, ex.Message, false));
ProcessedFile(this, new ProgressStatus(processedFiles, _results));
}
}
if ((searchOptions & GrepSearchOption.StopAfterFirstMatch) == GrepSearchOption.StopAfterFirstMatch && searchResults.Count > 0)
{
break;
}
}
}
finally
{
GrepEngineFactory.UnloadEngines();
}
return(searchResults);
}
}
public int Replace(IEnumerable <string> files, SearchType searchType, string baseFolder, string searchPattern, string replacePattern, GrepSearchOption searchOptions, int codePage)
{
string tempFolder = Utils.GetTempFolder();
if (Directory.Exists(tempFolder))
{
Utils.DeleteFolder(tempFolder);
}
Directory.CreateDirectory(tempFolder);
if (files == null || !Directory.Exists(tempFolder) || !Directory.Exists(baseFolder))
{
return(0);
}
baseFolder = Utils.FixFolderName(baseFolder);
tempFolder = Utils.FixFolderName(tempFolder);
replacePattern = Utils.ReplaceSpecialCharacters(replacePattern);
int processedFiles = 0;
Utils.CancelSearch = false;
try
{
foreach (string file in files)
{
if (!file.Contains(baseFolder))
{
continue;
}
string tempFileName = file.Replace(baseFolder, tempFolder);
IGrepEngine engine = GrepEngineFactory.GetReplaceEngine(file, searchParams);
try
{
processedFiles++;
// Copy file
Utils.CopyFile(file, tempFileName, true);
Utils.DeleteFile(file);
Encoding encoding = null;
if (codePage == -1)
{
encoding = Utils.GetFileEncoding(tempFileName);
}
else
{
encoding = Encoding.GetEncoding(codePage);
}
if (Utils.CancelSearch)
{
break;
}
if (!engine.Replace(tempFileName, file, searchPattern, replacePattern, searchType, searchOptions, encoding))
{
throw new ApplicationException("Replace failed for file: " + file);
}
if (!Utils.CancelSearch && ProcessedFile != null)
{
ProcessedFile(this, new ProgressStatus(processedFiles, null));
}
File.SetAttributes(file, File.GetAttributes(tempFileName));
if (Utils.CancelSearch)
{
// Replace the file
Utils.DeleteFile(file);
Utils.CopyFile(tempFileName, file, true);
break;
}
}
catch (Exception ex)
{
logger.LogException(LogLevel.Error, ex.Message, ex);
try
{
// Replace the file
if (File.Exists(tempFileName) && File.Exists(file))
{
Utils.DeleteFile(file);
Utils.CopyFile(tempFileName, file, true);
}
}
catch
{
// DO NOTHING
}
return(-1);
}
}
}
finally
{
GrepEngineFactory.UnloadEngines();
}
return(processedFiles);
}
/// <summary>
/// Searches folder for files whose content matches regex
/// </summary>
/// <param name="files">Files to search in. If one of the files does not exist or is open, it is skipped.</param>
/// <param name="searchRegex">Regex pattern</param>
/// <returns>List of results. If nothing is found returns empty list</returns>
public List <GrepSearchResult> Search(IEnumerable <string> files, SearchType searchType, string searchPattern, GrepSearchOption searchOptions, int codePage)
{
searchResults.Clear();
if (files == null)
{
return(searchResults);
}
Utils.CancelSearch = false;
if (searchPattern == null || searchPattern.Trim() == "")
{
int count = 0;
foreach (string file in files)
{
count++;
ProcessedFile(this, new ProgressStatus(true, searchResults.Count, count, null, file));
searchResults.Add(new GrepSearchResult(file, searchPattern, null, Encoding.Default));
if ((searchOptions & GrepSearchOption.StopAfterFirstMatch) == GrepSearchOption.StopAfterFirstMatch)
{
break;
}
if (Utils.CancelSearch)
{
break;
}
}
ProcessedFile(this, new ProgressStatus(false, searchResults.Count, count, searchResults, null));
return(new List <GrepSearchResult>(searchResults));
}
else
{
processedFilesCount = 0;
foundfilesCount = 0;
try
{
if (SearchParams.SearchParallel)
{
cancellationTokenSource = new CancellationTokenSource();
ParallelOptions po = new ParallelOptions();
po.MaxDegreeOfParallelism = Environment.ProcessorCount * 4 / 5;
po.CancellationToken = cancellationTokenSource.Token;
Parallel.ForEach(files, po, f => Search(f, searchType, searchPattern, searchOptions, codePage));
}
else
{
foreach (var file in files)
{
Search(file, searchType, searchPattern, searchOptions, codePage);
if (searchOptions.HasFlag(GrepSearchOption.StopAfterFirstMatch) && searchResults.Count > 0)
{
break;
}
}
}
}
catch (OperationCanceledException)
{
// expected for stop after first match or user cancel
}
catch (Exception ex)
{
logger.Error(ex, "Failed in search in files");
}
finally
{
if (cancellationTokenSource != null)
{
cancellationTokenSource.Dispose();
cancellationTokenSource = null;
}
GrepEngineFactory.UnloadEngines();
}
return(new List <GrepSearchResult>(searchResults));
}
}
public int Replace(Dictionary <string, string> files, SearchType searchType, string searchPattern, string replacePattern, GrepSearchOption searchOptions, int codePage)
{
string tempFolder = Utils.GetTempFolder();
if (files == null || files.Count == 0 || !Directory.Exists(tempFolder))
{
return(0);
}
replacePattern = Utils.ReplaceSpecialCharacters(replacePattern);
int processedFiles = 0;
Utils.CancelSearch = false;
string tempFileName = null;
try
{
foreach (string file in files.Keys)
{
ProcessedFile(this, new ProgressStatus(true, processedFiles, processedFiles, null, file));
// the value in the files dictionary is the temp file name assigned by
// the caller for any possible Undo operation
tempFileName = Path.Combine(tempFolder, files[file]);
IGrepEngine engine = GrepEngineFactory.GetReplaceEngine(file, SearchParams, FileFilter);
try
{
processedFiles++;
// Copy file
Utils.CopyFile(file, tempFileName, true);
Utils.DeleteFile(file);
Encoding encoding = Encoding.Default;
if (codePage > -1)
{
encoding = Encoding.GetEncoding(codePage);
}
else if (!Utils.IsBinary(tempFileName))
{
encoding = Utils.GetFileEncoding(tempFileName);
}
if (Utils.CancelSearch)
{
break;
}
if (!engine.Replace(tempFileName, file, searchPattern, replacePattern, searchType, searchOptions, encoding))
{
throw new ApplicationException("Replace failed for file: " + file);
}
if (!Utils.CancelSearch)
{
ProcessedFile(this, new ProgressStatus(false, processedFiles, processedFiles, null, file));
}
File.SetAttributes(file, File.GetAttributes(tempFileName));
GrepEngineFactory.ReturnToPool(file, engine);
if (Utils.CancelSearch)
{
// Replace the file
Utils.DeleteFile(file);
Utils.CopyFile(tempFileName, file, true);
break;
}
}
catch (Exception ex)
{
logger.Log <Exception>(LogLevel.Error, ex.Message, ex);
try
{
// Replace the file
if (File.Exists(tempFileName) && File.Exists(file))
{
Utils.DeleteFile(file);
Utils.CopyFile(tempFileName, file, true);
}
}
catch
{
// DO NOTHING
}
return(-1);
}
}
}
finally
{
GrepEngineFactory.UnloadEngines();
}
return(processedFiles);
}
public int Replace(IEnumerable <ReplaceDef> files, SearchType searchType, string searchPattern, string replacePattern, GrepSearchOption searchOptions, int codePage)
{
string tempFolder = Utils.GetTempFolder();
if (files == null || !files.Any() || !Directory.Exists(tempFolder))
{
return(0);
}
GrepEngineBase.ResetGuidxCache();
replacePattern = Utils.ReplaceSpecialCharacters(replacePattern);
int processedFiles = 0;
Utils.CancelSearch = false;
string tempFileName = null;
try
{
foreach (var item in files)
{
ProcessedFile(this, new ProgressStatus(true, processedFiles, processedFiles, null, item.OrginalFile));
// the value in the files dictionary is the temp file name assigned by
// the caller for any possible Undo operation
tempFileName = Path.Combine(tempFolder, item.BackupName);
IGrepEngine engine = GrepEngineFactory.GetReplaceEngine(item.OrginalFile, SearchParams, FileFilter);
try
{
processedFiles++;
// Copy file
Utils.CopyFile(item.OrginalFile, tempFileName, true);
Utils.DeleteFile(item.OrginalFile);
Encoding encoding = Encoding.Default;
if (codePage > -1)
{
encoding = Encoding.GetEncoding(codePage);
}
else if (!Utils.IsBinary(tempFileName))
{
encoding = Utils.GetFileEncoding(tempFileName);
}
// The UTF-8 encoding returned from Encoding.GetEncoding("utf-8") includes the BOM - see Encoding.GetPreamble()
// If this file does not have the BOM, then change to an encoder without the BOM so the BOM is not added in
// the replace operation
if (encoding is UTF8Encoding && !Utils.HasUtf8ByteOrderMark(tempFileName))
{
encoding = new UTF8Encoding(false);
}
if (Utils.CancelSearch)
{
break;
}
if (!engine.Replace(tempFileName, item.OrginalFile, searchPattern, replacePattern, searchType, searchOptions, encoding, item.ReplaceItems))
{
throw new ApplicationException("Replace failed for file: " + item.OrginalFile);
}
if (!Utils.CancelSearch)
{
ProcessedFile(this, new ProgressStatus(false, processedFiles, processedFiles, null, item.OrginalFile));
}
File.SetAttributes(item.OrginalFile, File.GetAttributes(tempFileName));
GrepEngineFactory.ReturnToPool(item.OrginalFile, engine);
if (Utils.CancelSearch)
{
// Replace the file
Utils.DeleteFile(item.OrginalFile);
Utils.CopyFile(tempFileName, item.OrginalFile, true);
break;
}
}
catch (Exception ex)
{
logger.Log <Exception>(LogLevel.Error, ex.Message, ex);
try
{
// Replace the file
if (File.Exists(tempFileName) && File.Exists(item.OrginalFile))
{
Utils.DeleteFile(item.OrginalFile);
Utils.CopyFile(tempFileName, item.OrginalFile, true);
}
}
catch
{
// DO NOTHING
}
return(-1);
}
}
}
finally
{
GrepEngineFactory.UnloadEngines();
}
return(processedFiles);
}
/// <summary>
/// Searches folder for files whose content matches regex
/// </summary>
/// <param name="files">Files to search in. If one of the files does not exist or is open, it is skipped.</param>
/// <param name="searchRegex">Regex pattern</param>
/// <returns>List of results. If nothing is found returns empty list</returns>
public List <GrepSearchResult> Search(IEnumerable <string> files, SearchType searchType, string searchPattern, GrepSearchOption searchOptions, int codePage)
{
searchResults.Clear();
if (files == null)
{
return(searchResults);
}
Utils.CancelSearch = false;
if (searchPattern == null || searchPattern.Trim() == "")
{
int count = 0;
foreach (string file in files)
{
count++;
ProcessedFile(this, new ProgressStatus(true, searchResults.Count, count, null, file));
Encoding encoding = Encoding.Default;
if (codePage > -1)
{
encoding = Encoding.GetEncoding(codePage);
}
try
{
if (GrepSettings.Instance.Get <bool>(GrepSettings.Key.DetectEncodingForFileNamePattern))
{
if (codePage == -1 && !Utils.IsArchive(file) && !Utils.IsBinary(file) && !Utils.IsPdfFile(file))
{
encoding = Utils.GetFileEncoding(file);
}
}
searchResults.Add(new GrepSearchResult(file, searchPattern, null, encoding));
}
catch (Exception ex)
{
// will catch file not found errors (Everything search):
logger.Error(ex, "Failed in File Search");
AddSearchResult(new GrepSearchResult(file, searchPattern, ex.Message, false));
}
if (searchOptions.HasFlag(GrepSearchOption.StopAfterFirstMatch))
{
break;
}
if (Utils.CancelSearch)
{
break;
}
}
ProcessedFile(this, new ProgressStatus(false, searchResults.Count, count, searchResults, null));
return(new List <GrepSearchResult>(searchResults));
}
else
{
processedFilesCount = 0;
foundfilesCount = 0;
try
{
if (SearchParams.SearchParallel)
{
cancellationTokenSource = new CancellationTokenSource();
ParallelOptions po = new ParallelOptions
{
MaxDegreeOfParallelism = Math.Max(1, Environment.ProcessorCount * 4 / 5),
CancellationToken = cancellationTokenSource.Token
};
Parallel.ForEach(files, po, f => Search(f, searchType, searchPattern, searchOptions, codePage));
}
else
{
foreach (var file in files)
{
Search(file, searchType, searchPattern, searchOptions, codePage);
if (searchOptions.HasFlag(GrepSearchOption.StopAfterFirstMatch) && searchResults.Count > 0)
{
break;
}
if (Utils.CancelSearch)
{
break;
}
}
}
}
catch (OperationCanceledException)
{
// expected for stop after first match or user cancel
}
catch (Exception ex)
{
logger.Error(ex, "Failed in search in files");
}
finally
{
if (cancellationTokenSource != null)
{
cancellationTokenSource.Dispose();
cancellationTokenSource = null;
}
GrepEngineFactory.UnloadEngines();
}
return(new List <GrepSearchResult>(searchResults));
}
}
/// <summary>
/// Searches folder for files whose content matches regex
/// </summary>
/// <param name="files">Files to search in. If one of the files does not exist or is open, it is skipped.</param>
/// <param name="searchRegex">Regex pattern</param>
/// <returns>List of results. If nothing is found returns empty list</returns>
public List <GrepSearchResult> Search(IEnumerable <string> files, SearchType searchType, string searchPattern, GrepSearchOption searchOptions, int codePage)
{
searchResults.Clear();
if (files == null)
{
return(searchResults);
}
if (string.IsNullOrEmpty(searchPattern))
{
return(searchResults);
}
Utils.CancelSearch = false;
processedFilesCount = 0;
foundfilesCount = 0;
try
{
if (SearchParams.SearchParallel)
{
cancellationTokenSource = new CancellationTokenSource();
ParallelOptions po = new ParallelOptions
{
MaxDegreeOfParallelism = Math.Max(1, Environment.ProcessorCount * 4 / 5),
CancellationToken = cancellationTokenSource.Token
};
Parallel.ForEach(files, po, f => Search(f, searchType, searchPattern, searchOptions, codePage));
}
else
{
foreach (var file in files)
{
Search(file, searchType, searchPattern, searchOptions, codePage);
if (searchOptions.HasFlag(GrepSearchOption.StopAfterFirstMatch) && searchResults.Count > 0)
{
break;
}
if (Utils.CancelSearch)
{
break;
}
}
}
}
catch (OperationCanceledException)
{
// expected for stop after first match or user cancel
}
catch (Exception ex)
{
logger.Error(ex, "Failed in search in files");
}
finally
{
if (cancellationTokenSource != null)
{
cancellationTokenSource.Dispose();
cancellationTokenSource = null;
}
GrepEngineFactory.UnloadEngines();
}
return(new List <GrepSearchResult>(searchResults));
}
public int Replace(IEnumerable <string> files, SearchType searchType, string searchPattern, string replacePattern, GrepSearchOption searchOptions, int codePage)
{
string tempFolder = Utils.GetTempFolder();
if (files == null || !Directory.Exists(tempFolder))
{
return(0);
}
replacePattern = Utils.ReplaceSpecialCharacters(replacePattern);
int processedFiles = 0;
Utils.CancelSearch = false;
string tempFileName = null;
try
{
foreach (string file in files)
{
ProcessedFile(this, new ProgressStatus(processedFiles, null, file));
tempFileName = Path.Combine(tempFolder, Path.GetFileName(file));
IGrepEngine engine = GrepEngineFactory.GetReplaceEngine(file, SearchParams, FileFilter);
try
{
processedFiles++;
// Copy file
Utils.CopyFile(file, tempFileName, true);
Utils.DeleteFile(file);
Encoding encoding = Encoding.Default;
if (codePage > -1)
{
encoding = Encoding.GetEncoding(codePage);
}
else if (!Utils.IsBinary(file))
{
encoding = Utils.GetFileEncoding(tempFileName);
}
if (Utils.CancelSearch)
{
break;
}
if (!engine.Replace(tempFileName, file, searchPattern, replacePattern, searchType, searchOptions, encoding))
{
throw new ApplicationException("Replace failed for file: " + file);
}
if (!Utils.CancelSearch)
{
ProcessedFile(this, new ProgressStatus(processedFiles, null, file));
}
File.SetAttributes(file, File.GetAttributes(tempFileName));
if (Utils.CancelSearch)
{
// Replace the file
Utils.DeleteFile(file);
Utils.CopyFile(tempFileName, file, true);
break;
}
}
catch (Exception ex)
{
logger.Log <Exception>(LogLevel.Error, ex.Message, ex);
try
{
// Replace the file
if (File.Exists(tempFileName) && File.Exists(file))
{
Utils.DeleteFile(file);
Utils.CopyFile(tempFileName, file, true);
}
}
catch
{
// DO NOTHING
}
return(-1);
}
finally
{
try
{
if (!string.IsNullOrWhiteSpace(tempFileName))
{
Utils.DeleteFile(tempFileName);
}
}
catch
{
// DO NOTHING
}
}
}
}
finally
{
GrepEngineFactory.UnloadEngines();
}
return(processedFiles);
}