public LocalRoot(Uri rootUri, FileSystemCasing casing)
{
if (rootUri == null)
{
throw new ArgumentNullException(nameof(rootUri));
}
if (!rootUri.IsAbsoluteUri)
{
throw new ArgumentException($"Not an absolute path: {rootUri.LocalPath}", nameof(rootUri));
}
if (!PathUtils.IsDirectoryUri(rootUri))
{
throw new ArgumentException($"Not a directory path: {rootUri.LocalPath}", nameof(rootUri));
}
if (!Enum.IsDefined(typeof(FileSystemCasing), casing))
{
throw new InvalidEnumArgumentException(nameof(casing), (int)casing, typeof(FileSystemCasing));
}
if (casing == FileSystemCasing.Unspecified)
{
throw new ArgumentException($"Must specify casing rule for path {rootUri}", nameof(casing));
}
RootUri = rootUri;
Casing = casing;
}
public Regex CompileRegex(string globPattern, FileSystemCasing casing)
{
var normalisedGlobPattern = SquashDirectorySeparators(globPattern);
var regexPattern = new Internal().Compile(normalisedGlobPattern);
return(FileSystemRegexHelpers.CreateRegex(regexPattern, casing));
}
public void QualifiedPathsWithDifferentRoots_AreNotEqual([ValueSource(nameof(ValidFileSystemCasings))] FileSystemCasing casing)
{
var relativePath = RelativePath.CreateFromSegments("a", "b", "c");
var a = new QualifiedPath(new LocalRoot(new Uri(@"C:\"), casing), relativePath);
var b = new QualifiedPath(new LocalRoot(new Uri(@"E:\"), casing), relativePath);
Assert.That(a, Is.Not.EqualTo(b).Using(default(QualifiedPath.DefaultEqualityComparer)));
}
public LocalRoot CreateNode(string absolutePath, FileSystemCasing casing)
{
if (!Path.IsPathRooted(absolutePath))
{
throw new ArgumentException($"Not an absolute path: {absolutePath}", nameof(absolutePath));
}
return(fileSystemApi.CreateStorageRoot(absolutePath.AsDirectoryPath(), casing));
}
public void PathIsContainedByParent([ValueSource(nameof(ValidFileSystemCasings))] FileSystemCasing casing)
{
var comparer = new PathEqualityComparer(casing);
var path = RelativePath.CreateFromSegments("a", "b", "c");
var parentPath = RelativePath.CreateFromSegments("a", "b").AsContainer();
Assert.That(parentPath.Contains(path, comparer), Is.True);
}
public void PathIsEqualToIdenticalCasePath([ValueSource(nameof(ValidFileSystemCasings))] FileSystemCasing casing)
{
var comparer = new PathEqualityComparer(casing);
var pathA = RelativePath.CreateFromSegments("a", "b", "c");
var pathB = RelativePath.CreateFromSegments("a", "b", "c");
Assert.That(pathA, Is.EqualTo(pathB).Using <RelativePath>(comparer));
}
public void PathDoesNotContainSibling([ValueSource(nameof(ValidFileSystemCasings))] FileSystemCasing casing)
{
var comparer = new PathEqualityComparer(casing);
var path = RelativePath.CreateFromSegments("a", "b", "c");
var siblingPath = RelativePath.CreateFromSegments("a", "b", "d");
Assert.That(path.Contains(siblingPath, comparer), Is.False);
Assert.That(path.AsContainer().Contains(siblingPath, comparer), Is.False);
}
public LocalRoot CreateStorageRoot(string absoluteFileSystemPath, FileSystemCasing casing)
{
if (!PathUtils.IsNormalisedAbsolutePath(absoluteFileSystemPath))
{
throw new ArgumentException($"Not a valid absolute path: {absoluteFileSystemPath}", nameof(absoluteFileSystemPath));
}
var canonicalUri = new Uri(absoluteFileSystemPath);
return(new LocalRoot(canonicalUri, casing == FileSystemCasing.Unspecified ? GetCasingRules(absoluteFileSystemPath) : casing));
}
public static Regex CreateRegex(string regex, FileSystemCasing casing)
{
var options = RegexOptions.Compiled;
if (casing == FileSystemCasing.CasePreservingInsensitive)
{
options |= RegexOptions.IgnoreCase;
}
return(new Regex(regex, options));
}
private static StringComparer SelectComparer(FileSystemCasing casing)
{
switch (casing)
{
case FileSystemCasing.Unspecified: throw new ArgumentException("Cannot compare paths when the casing rules are not known.");
case FileSystemCasing.CaseSensitive: return(StringComparer.Ordinal);
case FileSystemCasing.CasePreservingInsensitive: return(StringComparer.OrdinalIgnoreCase);
default: throw new ArgumentOutOfRangeException(nameof(casing), casing, null);
}
}
public Regex CompileRegex(string fileExtension, FileSystemCasing casing)
{
var trimmed = fileExtension.TrimStart('.');
if (fileExtension.Length - trimmed.Length > 1)
{
throw new FileExtensionFormatException("Multiple leading dots are not permitted.", fileExtension);
}
var regexPattern = $@"^.*\.{Regex.Escape(trimmed)}$";
return(FileSystemRegexHelpers.CreateRegex(regexPattern, casing));
}
public LocalRoot CreateStorageRoot(string absoluteFileSystemPath, FileSystemCasing casing)
{
if (!PathUtils.IsNormalisedAbsolutePath(absoluteFileSystemPath))
{
throw new ArgumentException($"Not a valid absolute path: {absoluteFileSystemPath}", nameof(absoluteFileSystemPath));
}
var canonicalUri = new WindowsPathCanonicaliser().CanonicaliseAbsolute(new Internal(), absoluteFileSystemPath);
if (casing == FileSystemCasing.Unspecified)
{
return(new LocalRoot(canonicalUri, GetActualCasingRules(canonicalUri)));
}
return(new LocalRoot(canonicalUri, casing));
}
public PathEqualityComparer(FileSystemCasing casing)
{
comparer = SelectComparer(casing);
}
public StubFileSystemApi(FileSystemCasing defaultCasing = FileSystemCasing.Unspecified)
{
this.defaultCasing = defaultCasing;
}
public FilterConfigurationReader(IErrorReceiver errors, FileSystemCasing casing)
{
this.errors = errors;
this.casing = casing;
}
