private bool PassesFilter(LocalRoot root, IEnumerable <RelativePath> paths, IDiagnosticsLog log = null) { var filter = GetFilterFor(root); if (!filter.Exists) { return(true); } var relativePath = RelativePath.Combine(paths); var match = filter.Evaluate(relativePath); switch (match.Rule) { case FilterRule.Exclude: log?.Debug(new ExcludedByFilterEvent(root, relativePath, match)); return(false); case FilterRule.Include: if (default(RelativePathMatcher).Equals(match)) { log?.Debug(new ExcludedByFilterEvent(root, relativePath, match)); } return(true); default: throw new ArgumentOutOfRangeException($"Not a valid rule type: {match.Rule}"); } }
private Graft CreateGraftInternal(LocalRoot parent, string relativePath, LocalRoot child) { var segments = PathUtils.GetRelativePathSegments(relativePath); var graftPath = fileSystemApi.GetCanonicalRelativePath(parent.RootUri.LocalPath, segments).AsContainer(); return(new Graft(new QualifiedPath(parent, graftPath), child)); }
private bool TryAddLocalRoot(LocalRoot node, LocalRoot validEnclosingParent, out ConfigurationRuleViolation violation) { if (nodes.Contains(node)) { violation = new DuplicateLocalRootDeclaration(node); return(false); } if (nodePaths.Contains(node)) { violation = new DuplicateLocalRootDeclaration(node); return(false); } foreach (var existing in nodes) { if (node.RootUri.IsBaseOf(existing.RootUri)) { violation = new OverlappingLocalRootDeclaration(node, existing); return(false); } if (existing == validEnclosingParent) { continue; } if (existing.RootUri.IsBaseOf(node.RootUri)) { violation = new OverlappingLocalRootDeclaration(existing, node); return(false); } } nodes.Add(node); nodePaths.Add(node); violation = null; return(true); }
public ExcludedByFilterEvent(LocalRoot localRoot, RelativePath relativePath, RelativePathMatcher matcher) : base(localRoot, relativePath) { if (matcher.Rule != FilterRule.Exclude) { throw new ArgumentException("Matcher is not an exclude rule."); } this.matcher = matcher; }
private void AssertLocalRootExistsInModel(LocalRoot root) { if (rootsLongestToShortest.Contains(root)) { return; } throw new InvalidOperationException($"Unrecognised LocalRoot: {root}"); }
public Graft(QualifiedPath graftPoint, LocalRoot childRoot) { if (!graftPoint.RelativePath.IsContainer()) { throw new ArgumentException($"Graft point must be a container: {graftPoint}", nameof(graftPoint)); } GraftPoint = graftPoint; ChildRoot = childRoot ?? throw new ArgumentNullException(nameof(childRoot)); }
public NamedRoot(string name, LocalRoot localRoot) { if (string.IsNullOrWhiteSpace(name)) { throw new ArgumentException("Name cannot be null or whitespace.", nameof(name)); } Name = name; LocalRoot = localRoot ?? throw new ArgumentNullException(nameof(localRoot)); }
public ConfigurationRuleViolation AddGraftPoint(LocalRoot parent, string relativePath, LocalRoot child) { if (!nodes.Contains(parent)) { throw new InvalidOperationException($"Parent is not yet declared: {parent}"); } var graft = CreateGraftInternal(parent, relativePath, child); return(AddGraftInternal(graft)); }
public ConfigurationRuleViolation AddLocation(LocalRoot parent, string relativePath, out LocalRoot child) { if (!nodes.Contains(parent)) { throw new InvalidOperationException($"Parent is not yet declared: {parent}"); } var childRootPath = new Uri(parent.RootUri, relativePath).LocalPath; child = fileSystemApi.CreateStorageRoot(childRootPath.AsDirectoryPath(), parent.Casing); var graft = CreateGraftInternal(parent, relativePath, child); return(AddGraftInternal(graft, parent)); }
public ConfigurationRuleViolation AddNamedRoot(string name, LocalRoot node) { var namedRoot = new NamedRoot(name, node); if (namedRoots.TryGetValue(namedRoot.Name, out var conflict)) { return(errors.Record(new DuplicateNamedRootDeclaration(namedRoot, conflict))); } if (!TryAddLocalRoot(node, null, out var violation)) { return(errors.Record(violation)); } namedRoots.Add(namedRoot.Name, namedRoot); return(null); }
public ConfigurationRuleViolation AddFilter(LocalRoot owner, RelativePathMatcher filterRule) { if (!nodes.Contains(owner)) { throw new InvalidOperationException($"Owner is not yet declared: {owner}"); } if (!filters.TryGetValue(owner, out var list)) { list = new List <RelativePathMatcher>(); filters.Add(owner, list); } list.Add(filterRule); return(null); }
private ConfigurationRuleViolation AddGraftInternal(Graft graft, LocalRoot validEnclosingParent = null) { if (grafts.TryGetValue(graft.GraftPoint, out var conflict)) { return(errors.Record(new DuplicateGraftDeclaration(graft, conflict))); } if (graft.ChildRoot.Casing != graft.GraftPoint.Root.Casing) { return(errors.Record(new FileSystemCasingConflict(graft))); } if (!TryAddLocalRoot(graft.ChildRoot, validEnclosingParent, out var violation)) { return(errors.Record(violation)); } grafts.Add(graft.GraftPoint, graft); return(null); }
public RelativePathFilter GetFilterFor(LocalRoot root) { AssertLocalRootExistsInModel(root); filtersByRoot.TryGetValue(root, out var filter); return(filter); }
protected FilterEvent(LocalRoot localRoot, RelativePath relativePath) { this.localRoot = localRoot; this.relativePath = relativePath; }
public QualifiedPath(LocalRoot root, RelativePath relativePath) { Root = root ?? throw new ArgumentNullException(nameof(root)); RelativePath = relativePath ?? throw new ArgumentNullException(nameof(relativePath)); }