public ProjectShadowingException(IDependencyPathBasedRuleTarget previousProject, IDependencyPathBasedRuleTarget newProject)
: base(
"Two distinct projects are being added with the same path. " +
$"{previousProject} would be shadowed by {newProject}. " +
"This typically indicates a programmer error.")
{
}
public IDependencyPathInProgress CloneWith(IDependencyPathBasedRuleTarget project)
{
return(new DependencyPathInProgress(
_destination,
_pathFactory,
_referencedProjects.Concat(new [] { project }).ToList()
));
}
public bool Matches(IProjectSearchResult depending, IDependencyPathBasedRuleTarget dependency)
{
if (_condition1.Matches(depending, dependency))
{
return(_condition2.Matches(depending, dependency));
}
return(false);
}
private void AssertThisIsAddingTheSameReferenceNotShadowing(
ProjectId referencingProjectId,
IDependencyPathBasedRuleTarget referencingProject)
{
if (_referencingProjects.ContainsKey(referencingProjectId) &&
!_referencingProjects[referencingProjectId].Equals(referencingProject))
{
throw new ProjectShadowingException(_referencingProjects[referencingProjectId], referencingProject);
}
}
public bool Matches(IProjectSearchResult depending, IDependencyPathBasedRuleTarget dependency)
{
return(dependency.HasPackageReferenceMatching(_packagePattern));
}
public void FinalizeWith(IDependencyPathBasedRuleTarget finalProject)
{
IReadOnlyList <IDependencyPathBasedRuleTarget> finalPath = _referencedProjects.Concat(new [] { finalProject }).ToList();
_destination.Add(_pathFactory(finalPath));
}
public void AddReferencingProject(ProjectId projectId, IDependencyPathBasedRuleTarget referencingProject)
{
_referencingProjects.Put(projectId, referencingProject);
}
public bool IsNot(IDependencyPathBasedRuleTarget e)
{
return(!_foundProject.Equals(e));
}
public bool Matches(IProjectSearchResult depending, IDependencyPathBasedRuleTarget dependency)
{
return(_dependencyCondition.Matches(depending, dependency));
}
public bool IsNot(IDependencyPathBasedRuleTarget e)
{
return(true);
}
public bool Matches(IProjectSearchResult depending, IDependencyPathBasedRuleTarget dependency)
{
return(depending.IsNot(dependency));
}
public bool Matches(IProjectSearchResult depending, IDependencyPathBasedRuleTarget dependency)
{
return(dependency.HasProjectAssemblyNameMatching(_dependencyAssemblyNamePattern));
}
public IProjectSearchResult ItemFound(IDependencyPathBasedRuleTarget foundProject, int position)
{
return(new ProjectFoundSearchResult(foundProject, position));
}
public bool Matches(IProjectSearchResult depending, IDependencyPathBasedRuleTarget dependency)
{
return(dependency.HasAssemblyReferenceWithNameMatching(_pattern));
}
private static IDependencyPathBasedRuleTarget[] ArrayConsistingOf(IDependencyPathBasedRuleTarget root1, IDotNetProject root2)
{
return(Arg <IDependencyPathBasedRuleTarget[]> .That(a => a.Should().Equal(root1, root2)));
}
public void Put(ProjectId projectId, IDependencyPathBasedRuleTarget referencingProject)
{
AssertThisIsAddingTheSameReferenceNotShadowing(projectId, referencingProject);
_referencingProjects[projectId] = referencingProject;
}
public ProjectFoundSearchResult(IDependencyPathBasedRuleTarget foundProject, int occurenceIndex)
{
_foundProject = foundProject;
_occurenceIndex = occurenceIndex;
}
public void FillAllBranchesOf(IDependencyPathInProgress dependencyPathInProgress, IDependencyPathBasedRuleTarget owner)
{
if (_referencedProjects.Any())
{
foreach (var reference in _referencedProjects.Values)
{
reference.FillAllBranchesOf(dependencyPathInProgress.CloneWith(owner));
}
}
else
{
dependencyPathInProgress.FinalizeWith(owner);
}
}
