public void EvaluateMethodsHavingCorrectAttributes(IAnalysisReportInProgress report, string parentClassName, RuleDescription description)
{
if (!_methodDeclarationInfo.Attributes.Any())
{
report.Add(_violationFactory.ProjectScopedRuleViolation(description, $"Method {_methodDeclarationInfo.Name} in class {parentClassName} does not have any attribute"));
}
}
public void Check(IPathCache cache, IAnalysisReportInProgress report)
{
foreach (var dependencyRule in _rules)
{
cache.Check(dependencyRule, report);
}
}
public void Check(IDependencyRule rule, IAnalysisReportInProgress report)
{
foreach (var path in _projectDependencyPaths)
{
rule.Check(report, path);
}
}
public void Check(IProjectScopedRuleTarget project, IAnalysisReportInProgress report)
{
if (project.HasProjectAssemblyNameMatching(_projectAssemblyPattern))
{
project.AddInfoAboutMatchingPatternTo(report);
_innerRule.Check(project, report);
}
}
public void ApplyTo(ISourceCodeFileInNamespace sourceCodeFile, RuleDescription description,
IAnalysisReportInProgress report)
{
sourceCodeFile.CheckMethodsHavingCorrectAttributes(
report,
_ruleDto.ClassNameInclusionPattern,
_ruleDto.MethodNameInclusionPattern, description);
}
public void EvaluateDecorationWithAttributes(
IAnalysisReportInProgress report,
Pattern methodNameInclusionPattern, RuleDescription description)
{
foreach (var method in _methods.Where(m => m.NameMatches(methodNameInclusionPattern)))
{
method.EvaluateMethodsHavingCorrectAttributes(report, _classDeclarationInfo.Name, description);
}
}
public void Evaluate(AssemblyName projectAssemblyName,
INamespacesDependenciesCache namespacesCache,
IAnalysisReportInProgress report)
{
var cycles = namespacesCache.RetrieveCycles();
if (cycles.Any())
{
report.Add(
_ruleViolationFactory.NoCyclesRuleViolation(Description(), projectAssemblyName, cycles));
}
}
public Analysis(IAnalysisReportInProgress analysisReportInProgress,
IDependencyAnalysis dependencyAnalysis,
IProjectAnalysis projectAnalysis,
IProjectNamespacesAnalysis projectNamespacesAnalysis,
IResultBuilderFactory resultBuilderFactory)
{
_analysisReportInProgress = analysisReportInProgress;
_dependencyAnalysis = dependencyAnalysis;
_projectAnalysis = projectAnalysis;
_projectNamespacesAnalysis = projectNamespacesAnalysis;
_resultBuilderFactory = resultBuilderFactory;
}
public void Evaluate(AssemblyName projectAssemblyName,
INamespacesDependenciesCache namespacesCache,
IAnalysisReportInProgress report)
{
var paths = namespacesCache.RetrievePathsBetween(_dto.FromPattern, _dto.ToPattern);
if (paths.Any())
{
report.Add(
_ruleViolationFactory.NoUsingsRuleViolation(Description(), projectAssemblyName, paths));
}
}
public void CheckMethodsHavingCorrectAttributes(
IAnalysisReportInProgress report,
Pattern classNameInclusionPattern,
Pattern methodNameInclusionPattern,
RuleDescription description)
{
foreach (var cSharpClass in _classes)
{
if (cSharpClass.NameMatches(classNameInclusionPattern))
{
cSharpClass.EvaluateDecorationWithAttributes(report, methodNameInclusionPattern, description);
}
}
}
public void Check(IAnalysisReportInProgress report, IProjectDependencyPath dependencyPath)
{
var dependingAssembly = dependencyPath.AssemblyWithNameMatching(_dependingAssemblyNamePattern);
if (dependingAssembly.Exists())
{
var dependencyAssembly = dependencyPath.AssemblyMatching(_condition, dependingAssembly);
if (dependencyAssembly.IsNotBefore(dependingAssembly))
{
var pathRuleViolation = _ruleViolationFactory.PathRuleViolation(
_condition.Description(),
dependencyPath.SegmentBetween(dependingAssembly, dependencyAssembly));
report.Add(pathRuleViolation);
}
}
report.FinishedEvaluatingRule(_condition.Description());
}
public void ApplyTo(
AssemblyName name,
IReadOnlyDictionary <string, string> properties,
IAnalysisReportInProgress report)
{
if (properties.ContainsKey(_propertyName))
{
var propertyValue = properties[_propertyName];
if (!_expectedPropertyValuePattern.IsMatchedBy(propertyValue))
{
report.Add(_violationFactory.ProjectScopedRuleViolation(_ruleDescription, $"Project {name} has {_propertyName}:{propertyValue}"));
}
}
else
{
report.Add(_violationFactory.ProjectScopedRuleViolation(_ruleDescription, $"Project {name} does not have {_propertyName} set explicitly"));
}
}
public void CheckNamespacesCorrectness(IAnalysisReportInProgress report, RuleDescription description)
{
//bug get rid of this code here. Move this to rule as another interface
if (_declaredNamespaces.Count == 0)
{
report.Add(_ruleViolationFactory.ProjectScopedRuleViolation(description, ViolationDescription("has no namespace declared"))
);
}
else if (_declaredNamespaces.Count > 1)
{
report.Add(_ruleViolationFactory.ProjectScopedRuleViolation(description, ViolationDescription($"declares multiple namespaces: {NamespacesString()}")));
}
else if (!_declaredNamespaces.Contains(CorrectNamespace()))
{
report.Add(_ruleViolationFactory.ProjectScopedRuleViolation(description, ViolationDescription($"has incorrect namespace {_declaredNamespaces.Single()}"))
);
}
}
public void PerformOn(IAnalysisReportInProgress analysisReportInProgress)
{
_solution.BuildNamespacesCache();
_solution.Check(_namespacesBasedRuleSet, analysisReportInProgress);
}
public void Check(IReadOnlyList <ISourceCodeFileInNamespace> sourceCodeFiles, IAnalysisReportInProgress report)
{
foreach (var sourceCodeFile in sourceCodeFiles)
{
_fileContentCheck.ApplyTo(sourceCodeFile, _ruleDescription, report);
}
report.FinishedEvaluatingRule(_ruleDescription);
}
public void Check(IProjectScopedRuleTarget project, IAnalysisReportInProgress report)
{
project.AnalyzeFiles(this, report);
}
public void Check(IProjectScopedRuleSet ruleSet, IAnalysisReportInProgress analysisReportInProgress)
{
ruleSet.Check(_projectScopedRuleTargets, analysisReportInProgress);
}
public void ValidateProperty(
IPropertyCheck propertyCheck,
IAnalysisReportInProgress analysisReportInProgress)
{
propertyCheck.ApplyTo(_assemblyName, _properties, analysisReportInProgress);
}
public void Check(IPathRuleSet ruleSet, IAnalysisReportInProgress analysisReportInProgress)
{
ruleSet.Check(_pathCache, analysisReportInProgress);
}
public void Evaluate(INamespacesBasedRule rule, IAnalysisReportInProgress report)
{
rule.Evaluate(_projectAssemblyName, _namespacesDependenciesCache, report);
}
public void AddInfoAboutMatchingPatternTo(IAnalysisReportInProgress report)
{
report.StartedCheckingTarget(_assemblyName);
}
public void Perform(IAnalysisReportInProgress analysisReportInProgress)
{
_solution.ResolveAllProjectsReferences();
_solution.BuildDependencyPathCache();
_solution.Check(_pathRuleSet, analysisReportInProgress);
}
public void Check(INamespacesBasedRuleSet ruleSet, IAnalysisReportInProgress analysisReportInProgress)
{
ruleSet.Check(_namespaceBasedRuleTargets, analysisReportInProgress);
}
public void Perform(IAnalysisReportInProgress analysisReportInProgress)
{
_solution.Check(_projectScopedRuleSet, analysisReportInProgress);
}
public void AnalyzeFiles(IProjectFilesetScopedRule rule, IAnalysisReportInProgress report)
{
rule.Check(_sourceCodeFiles, report);
}
public void Check(IProjectScopedRuleTarget project, IAnalysisReportInProgress report)
{
project.ValidateProperty(this, report);
}
public void ApplyTo(ISourceCodeFileInNamespace sourceCodeFile, RuleDescription description,
IAnalysisReportInProgress report)
{
sourceCodeFile.CheckNamespacesCorrectness(report, description);
}
