private string GetColor(GroupDependency dep, HashSet<GroupDependency> inversible)
{
if (inversible.Contains(dep))
return "red";
if (dep.Type == GroupDependency.Types.Conflicted)
return "yellow";
return null;
}
private string GetStyle(GroupDependency dep)
{
switch (dep.Type)
{
case GroupDependency.Types.Conflicted:
return "dotted";
case GroupDependency.Types.Implicit:
return "dashed";
default:
return null;
}
}
public static ArchitectureGraph Load(Config config, DependencyGraph graph)
{
var rules = config.Rules.OfType<DepenendencyRule>()
.Where(r => r.Severity == Severity.Error)
.Cast<Rule>()
.ToList();
var libs = graph.Vertices.Where(v => v.GroupElement != null)
.ToList();
var allowed = new HashSet<GroupDependency>();
var notAllowed = new HashSet<GroupDependency>();
foreach (var p1 in libs)
{
foreach (var p2 in libs)
{
if (p1.GroupElement.Name == p2.GroupElement.Name)
continue;
var dep = new GroupDependency(p1.GroupElement.Name, p2.GroupElement.Name);
if (allowed.Contains(dep) && notAllowed.Contains(dep))
continue;
var match = RulesMatcher.FindMatch(rules, Dependency.WithProject(p1, p2, new Location("a", 1))) as DependencyRuleMatch;
if (match != null)
{
if (match.Allowed)
allowed.Add(dep);
else
notAllowed.Add(dep);
}
match = RulesMatcher.FindMatch(rules, Dependency.WithLibrary(p1, p2, new Location("a", 1), null)) as DependencyRuleMatch;
if (match != null)
{
if (match.Allowed)
allowed.Add(dep);
else
notAllowed.Add(dep);
}
}
}
var groups = libs.Select(p => p.GroupElement.Name)
.Distinct()
.ToList();
var deps = new HashSet<GroupDependency>();
foreach (var g1 in groups)
{
foreach (var g2 in groups)
{
if (g1 == g2)
continue;
var dep = new GroupDependency(g1, g2);
var isAllowed = allowed.Contains(dep);
var isNotAllowed = notAllowed.Contains(dep);
if (isAllowed && isNotAllowed)
dep = new GroupDependency(g1, g2, GroupDependency.Types.Conflicted);
else if (!isAllowed && !isNotAllowed)
dep = new GroupDependency(g1, g2, GroupDependency.Types.Implicit);
else if (isNotAllowed)
dep = null;
if (dep != null)
deps.Add(dep);
}
}
var groupGraph = new ArchitectureGraph();
groupGraph.AddVertexRange(groups);
groupGraph.AddEdgeRange(deps);
return groupGraph;
}
public static GroupDependency GetGroupDependency(IEnumerable <Vertex> vertices)
{
HashSet <Edge> inEdges = new HashSet <Edge>();
HashSet <Edge> outEdges = new HashSet <Edge>();
int N = 0;
foreach (Vertex v in vertices)
{
N += 1;
foreach (Edge e in v.AdjacentEdges)
{
if (!vertices.Contains(e.VertexA) || !vertices.Contains(e.VertexB))
{
outEdges.Add(e);
}
else
{
inEdges.Add(e);
}
}
}
double depIn = 0;
foreach (Edge e in inEdges)
{
if (e.VertexA.IsDependentOn(e.VertexB))
{
depIn += 1;
}
if (e.VertexB.IsDependentOn(e.VertexA))
{
depIn += 1;
}
}
double depOut = 0;
foreach (Edge e in outEdges)
{
if (vertices.Contains(e.VertexA) && e.VertexA.IsDependentOn(e.VertexB))
{
depOut += 1;
}
else if (vertices.Contains(e.VertexB) && e.VertexB.IsDependentOn(e.VertexA))
{
depOut += 1;
}
}
if (depIn > 0)
{
depIn /= 2 * inEdges.Count;
}
if (depOut > 0)
{
depOut /= outEdges.Count;
}
GroupDependency d = new GroupDependency(depIn, depOut);
return(d);
}
