public IEnumerable<Violation> Verify(VerificationContext context, Node node)
{
if(this.unusedCommands.Contains((CommandNode)node))
{
yield return new UnusedCommandViolation((CommandNode) node);
}
}
public IEnumerable<Violation> Verify(VerificationContext context, Node node)
{
var methodNode = (MethodNode)node;
var forbiddenMethods = new[]
{
typeof (DateTime).GetProperty("Now").GetMethod,
typeof (DateTime).GetProperty("UtcNow").GetMethod,
typeof (DateTimeOffset).GetProperty("Now").GetMethod,
typeof (DateTimeOffset).GetProperty("UtcNow").GetMethod,
};
var violatingInstructions = from instruction in methodNode.Method.GetInstructions()
where instruction.IsCall()
let callee = (MethodBase) instruction.Operand
where forbiddenMethods.Contains(callee)
select instruction;
foreach (var violatingInstruction in violatingInstructions)
{
var sourceLocation = FindSourceLocation(violatingInstruction, methodNode);
yield return new UsesDateTimeNowViolation(node, sourceLocation);
}
}
public void Initialize(VerificationContext context, Graph graph)
{
this.aggregateForMethod = new Dictionary<MethodNode, AggregateNode>();
var bfs = new LambdaBreadthFirstSearch<Node, Link>
{
AvailableTargets = n => n.OutboundLinks
.Where(l => l is HasOneEntityLink || l is HasManyEntityLink)
.GroupBy(x => x.Target)
.Union(n.InboundLinks.Where(l => l is ContainedInLink && l.Target is EntityNode && l.Source is MethodNode).GroupBy(x => x.Source))
};
var aggregates = graph.Nodes.OfType<AggregateNode>();
foreach (var node in aggregates)
{
bfs.HandlingNode = (n, _) =>
{
var methodNode = n as MethodNode;
if (methodNode != null && !methodNode.Method.IsSpecialName)
{
this.aggregateForMethod[methodNode] = node;
}
};
bfs.Walk(node);
}
}
public IEnumerable<Violation> Verify(VerificationContext context, Node node)
{
foreach (var queryExecutionLink in node.OutboundLinks.OfType<QueryExecutionLink>().GroupBy(x => (QueryNode)x.Target).Select(x => x.Key))
{
yield return new CommandHandlerExecutesQueryViolation((CommandHandlerNode) node, (QueryNode) queryExecutionLink);
}
}
public IEnumerable<Violation> Verify(VerificationContext context, Node node)
{
var v = new PathVerify();
v.Walk(node);
return v.Violations;
}
public IEnumerable<Violation> Verify(VerificationContext context, Node node)
{
var typeNode = (TypeNode)node;
return VerifyNotSettingField(context, typeNode)
.Union(VerifyNotSettingProperty(context, typeNode))
.Union(VerifyNoNotPrivatePropertySetters(context, typeNode))
.Union(VerifyNoWritableFields(context, typeNode))
;
}
public IEnumerable<Violation> Verify(VerificationContext context, Node node)
{
var containers = node.InboundLinks.OfType<ReferenceLink>().Select(x => x.Source).Distinct();
var backReferences = containers.SelectMany(x => x.OutboundLinks).OfType<ReferenceLink>()
.Where(x => x.Target == node);
foreach (var backReference in backReferences)
{
yield return new BidirectionalReferenceViolation(backReference.Source, backReference.Target);
}
}
public IEnumerable<Violation> Verify(VerificationContext context, Node node)
{
var property = (PropertyNode) node;
var referencedAggregate = this.aggregates.FirstOrDefault(x => x.Type == property.Property.PropertyType);
if (referencedAggregate != null)
{
yield return new DirectAggregateReferenceViolation(node, referencedAggregate);
}
}
private IEnumerable<Violation> VerifyNoWritableFields(VerificationContext context, TypeNode typeNode)
{
var violatingFields = from field in typeNode.InboundFrom<FieldNode, ContainedInLink>()
where !field.Field.IsInitOnly
select field;
foreach (var field in violatingFields)
{
yield return new ImmutableTypeHasWritableFieldViolation(typeNode, field);
}
}
private IEnumerable<Violation> VerifyNotSettingProperty(VerificationContext context, TypeNode typeNode)
{
var violatingMethods = from method in typeNode.InboundFrom<MethodNode, ContainedInLink>()
where method.OutboundLinks.OfType<SetPropertyLink>().Any()
select method;
foreach (var method in violatingMethods)
{
yield return new ImmutableTypeSetsPropertyOutsideOfConstructorViolation(typeNode, method);
}
}
private IEnumerable<Violation> VerifyNoNotPrivatePropertySetters(VerificationContext context, TypeNode typeNode)
{
var violatingProperties = from property in typeNode.InboundFrom<PropertyNode, ContainedInLink>()
where property.Property.CanWrite && !property.Property.SetMethod.IsPrivate
select property;
foreach (var property in violatingProperties)
{
yield return new ImmutableTypeHasNonPrivateSetterViolation(typeNode, property);
}
}
public IEnumerable<Violation> Verify(VerificationContext context, Node node)
{
var count = node.Annotation<CommandExecutionCount>();
if (count == null || count.HighestCount <= 1)
{
yield break;
}
yield return new MethodExecutesMoreThanOneCommandViolation(node);
}
public IEnumerable<Violation> Verify(VerificationContext context, Node node)
{
var calledMethods = node.OutboundLinks.OfType<MethodCallLink>().Select(x => (MethodNode)x.Target);
foreach (var calledMethod in calledMethods)
{
if (IsInvalidCall((MethodNode)node, calledMethod))
{
yield return new DoNotCallEntityMethodsFromOutsideOfAggregateViolation((MethodNode)node, calledMethod);
}
}
}
public IEnumerable<Violation> Verify(VerificationContext context, Graph graph)
{
var finder = new FindCycles<Node, Link>()
{
NodeFilter = x => x is TypeNode,
OutboundTargets = x => x.OutboundLinks.OfType<DependencyLink>().GroupBy(y => y.Target)
};
var cycles = finder.Find(graph);
foreach (var cycle in cycles)
{
yield return new CycleInDependenciesViolation(cycle.OfType<TypeNode>());
}
}
public void Initialize(VerificationContext context, Graph graph)
{
var entryPoint = graph.LookupNode<ApplicationEntryPoint>(ApplicationEntryPoint.NodeId);
this.unusedCommands = new HashSet<CommandNode>(graph.Nodes.OfType<CommandNode>());
var bfs = new LambdaBreadthFirstSearch<Node, Link>
{
HandlingNode = (node, links) =>
{
var commandNode = node as CommandNode;
if (commandNode != null && links.OfType<ExecuteCommandLink>().Any())
{
this.unusedCommands.Remove(commandNode);
}
}
};
bfs.Walk(entryPoint);
}
private void RunRules()
{
this.verificator = new Verificator();
this.verificator.RegisterConventionsFrom(this.conventionAssemblies.ToArray());
this.verificator.StartingRule += (s, e) =>
{
Log.Debug("Starting rule {0}", e.Rule.GetType().Name);
this.Report.VerificationRule(e.Rule);
};
this.verificator.NodeVerified += (s, e) =>
{
this.Report.NodeVerification(e.Rule, e.Node, e.Violations);
};
this.verificator.GraphVerified += (s, e) =>
{
this.Report.GraphVerification(e.Rule, e.Violations);
};
this.verificator.FinishedRule += (s, e) => Log.Info("Finished rule {0}", e.Rule.GetType().Name);
this.verificationContext = new VerificationContext();
foreach (var rule in this.runlist.Elements.Where(x => x.IsRule))
{
this.verificator.AddRule(rule.Type);
}
try
{
this.verificator.Verify(this.verificationContext, this.modelBuilder);
}
catch (Exception e)
{
Log.Fatal("Error running rules", e);
}
ReportViolations(this.verificationContext.Violations);
}
public void Initialize(VerificationContext context, Graph graph)
{
this.aggregates = graph.Nodes.OfType<AggregateNode>().ToList();
}
