private static IEnumerable <string> EnumerateFilesWithFilters(string path, IList <string> patterns,
Gitignore gitignore, FileFilter filter)
{
DirectoryInfo di = new DirectoryInfo(path);
// the root of the drive has the hidden attribute set, so don't stop on this hidden directory
if (di.Attributes.HasFlag(FileAttributes.Hidden) && (di.Root != di))
{
yield break;
}
int startDepth = 0;
if (filter.MaxSubfolderDepth > 0)
{
startDepth = GetDepth(di);
}
IEnumerable <string> directories = new string[] { path };
if (filter.IncludeSubfolders)
{
directories = directories.Concat(EnumerateDirectoriesImpl(path, filter, startDepth, gitignore));
}
foreach (var directory in directories)
{
IEnumerable <string> matches = EnumerateFilesImpl(directory, patterns, filter, gitignore);
foreach (var file in matches)
{
yield return(file);
}
}
}
public static IEnumerable <string> EnumerateFiles(string path, IList <string> patterns,
Gitignore gitignore, FileFilter filter)
{
if (string.IsNullOrWhiteSpace(path) || !Directory.Exists(path))
{
return(Enumerable.Empty <string>());
}
if (patterns == null)
{
throw new ArgumentNullException(nameof(patterns));
}
if (filter == null)
{
throw new ArgumentNullException(nameof(filter));
}
bool simpleSearch = filter.IncludeHidden && filter.MaxSubfolderDepth == -1 &&
(gitignore == null || gitignore.IsEmpty) &&
string.IsNullOrWhiteSpace(filter.NamePatternToExclude);
if (simpleSearch)
{
return(EnumerateAllFiles(path, patterns, filter.IncludeArchive, filter.IncludeSubfolders, filter.FollowSymlinks));
}
else
{
return(EnumerateFilesWithFilters(path, patterns, gitignore, filter));
}
}
public static Gitignore GetGitignore(IList <string> paths)
{
if (paths == null)
{
throw new ArgumentNullException(nameof(paths));
}
Gitignore results = new Gitignore();
foreach (var path in paths)
{
results.Merge(GetGitignore(path));
}
return(results);
}
public void Merge(Gitignore other)
{
if (other == null)
{
throw new ArgumentNullException(nameof(other));
}
foreach (var item in other.Directories)
{
if (!directories.Contains(item))
{
directories.Add(item);
}
}
foreach (var item in other.Files)
{
if (!files.Contains(item))
{
files.Add(item);
}
}
}
private static IEnumerable <string> EnumerateFilesImpl(string path, IList <string> patterns,
FileFilter filter, Gitignore gitignore)
{
DirectoryEnumerationFilters fileFilters = new DirectoryEnumerationFilters
{
ErrorFilter = (errorCode, errorMessage, pathProcessed) =>
{
logger.Error($"Find file error {errorCode}: {errorMessage} on {pathProcessed}");
return(true);
}
};
bool includeAllFiles = (patterns.Count == 0 ||
(patterns.Count == 1 && (patterns[0] == "*.*" || patterns[0] == "*"))) &&
(gitignore == null || gitignore.Files.Count == 0);
if (includeAllFiles)
{
fileFilters.InclusionFilter = fsei =>
{
if (!filter.IncludeHidden && fsei.IsHidden)
{
return(false);
}
return(true);
};
}
else
{
fileFilters.InclusionFilter = fsei =>
{
if (!filter.IncludeHidden && fsei.IsHidden)
{
return(false);
}
if (gitignore != null && gitignore.Files.Contains(fsei.FullPath))
{
return(false);
}
foreach (string pattern in patterns)
{
if (WildcardMatch(fsei.FileName, pattern, true))
{
return(true);
}
}
if (filter.IncludeArchive)
{
foreach (string pattern in ArchiveDirectory.Patterns)
{
if (WildcardMatch(fsei.FileName, pattern, true))
{
return(true);
}
}
}
return(false);
};
}
var fileOptions = baseFileOptions;
if (filter.FollowSymlinks)
{
fileOptions &= ~DirectoryEnumerationOptions.SkipReparsePoints;
}
return(Directory.EnumerateFiles(path, fileOptions, fileFilters, PathFormat.FullPath));
}
private static IEnumerable <string> EnumerateDirectoriesImpl(string path,
FileFilter filter, int startDepth, Gitignore gitignore)
{
var dirOptions = baseDirOptions;
if (filter.IncludeSubfolders)
{
dirOptions |= DirectoryEnumerationOptions.Recursive;
}
if (filter.FollowSymlinks)
{
dirOptions &= ~DirectoryEnumerationOptions.SkipReparsePoints;
}
DirectoryEnumerationFilters dirFilters = new DirectoryEnumerationFilters
{
ErrorFilter = (errorCode, errorMessage, pathProcessed) =>
{
logger.Error($"Find file error {errorCode}: {errorMessage} on {pathProcessed}");
return(true);
},
RecursionFilter = fsei =>
{
if (gitignore != null && gitignore.Directories.Contains(fsei.FullPath))
{
return(false);
}
if (!filter.IncludeHidden && fsei.IsHidden)
{
return(false);
}
if (filter.MaxSubfolderDepth >= 0)
{
int depth = GetDepth(new DirectoryInfo(fsei.FullPath));
if (depth - startDepth > filter.MaxSubfolderDepth)
{
return(false);
}
}
if (filter.UseGitIgnore && fsei.FileName == ".git")
{
return(false);
}
return(true);
},
InclusionFilter = fsei =>
{
if (gitignore != null && gitignore.Directories.Contains(fsei.FullPath))
{
return(false);
}
if (!filter.IncludeHidden && fsei.IsHidden)
{
return(false);
}
if (filter.MaxSubfolderDepth >= 0)
{
int depth = GetDepth(new DirectoryInfo(fsei.FullPath));
if (depth - startDepth > filter.MaxSubfolderDepth)
{
return(false);
}
}
if (filter.UseGitIgnore && fsei.FileName == ".git")
{
return(false);
}
return(true);
},
};
return(Directory.EnumerateDirectories(path, dirOptions, dirFilters, PathFormat.FullPath));
}
