public ReferencedProjects(
IReadOnlyList <ProjectId> referencedProjectsIds,
INScanSupport support)
{
_referencedProjectsIds = referencedProjectsIds;
_support = support;
}
private static void LogProjectScopedRules(
IEnumerable <ProjectScopedRuleUnionDto> enumerable,
INScanSupport support)
{
foreach (var ruleUnion in enumerable)
{
ruleUnion.Accept(new ProjectScopedRuleLoggingVisitor(support));
}
}
private static void LogDependencyPathRules(
IEnumerable <DependencyPathBasedRuleUnionDto> enumerable,
INScanSupport support)
{
foreach (var ruleUnion in enumerable)
{
ruleUnion.Accept(new PathBasedRuleLoggingVisitor(support));
}
}
private static void LogNamespaceBasedRules(
IEnumerable <NamespaceBasedRuleUnionDto> enumerable,
INScanSupport support)
{
foreach (var ruleUnion in enumerable)
{
ruleUnion.Accept(new NamespaceBasedRuleLoggingVisitor(support));
}
}
public static ProjectPaths From(string solutionFilePath, INScanSupport consoleSupport)
{
var analyzerManager = new AnalyzerManager(solutionFilePath);
var projectFilePaths = analyzerManager.Projects
.Select(p => p.Value.ProjectFile.Path)
.Select(AbsoluteFilePath).ToList();
var paths = new ProjectPaths(projectFilePaths, consoleSupport);
return(paths);
}
/// <summary>
/// Entry point
/// </summary>
/// <param name="inputArguments">arguments</param>
/// <param name="output">output for report</param>
/// <param name="support">logging stuff</param>
/// <returns></returns>
public static int Run(
InputArgumentsDto inputArguments,
INScanOutput output,
INScanSupport support)
{
try
{
//SpinWait.SpinUntil(() => Debugger.IsAttached);
output.WriteVersion(Versioning.VersionOf(Assembly.GetExecutingAssembly()));
var csharpProjectDtos = ReadCsharpProjects(inputArguments, support);
var analysis = Analysis.PrepareFor(csharpProjectDtos, support);
var rulesString = ReadRulesTextFrom(inputArguments);
var dependencyPathDtos = ParserRulePreface.Then(ParseDependencyPathBasedRule.Complement).Many().Parse(rulesString).WhereValueExist();
LogDependencyPathRules(dependencyPathDtos, support);
analysis.AddDependencyPathRules(dependencyPathDtos);
var projectScopedDtos = ParserRulePreface.Then(ParseProjectScopedRule.Complement).Many().Parse(rulesString).WhereValueExist();
analysis.AddProjectScopedRules(projectScopedDtos);
LogProjectScopedRules(projectScopedDtos, support);
var namespaceBasedDtos = ParserRulePreface.Then(ParseNamespaceBasedRule.Complement).Many().Parse(rulesString).WhereValueExist();
LogNamespaceBasedRules(namespaceBasedDtos, support);
analysis.AddNamespaceBasedRules(namespaceBasedDtos);
analysis.Run();
output.WriteAnalysisReport(analysis.Report);
return(analysis.ReturnCode);
}
catch (Exception e)
{
support.Report(e);
return(-2);
}
}
private static IEnumerable <CsharpProjectDto> ReadCsharpProjects(InputArgumentsDto inputArguments, INScanSupport support)
{
var paths = ProjectPaths.From(
inputArguments.SolutionPath.OrThrow().ToString(),
support);
return(paths.LoadXmlProjects());
}
public int ReturnCode => _analysisReportInProgress.IsFailure() ? -1 : 0; //bug UI implementation leak
public static Analysis PrepareFor(IEnumerable <CsharpProjectDto> csharpProjectDtos, INScanSupport support)
{
return(new Analysis(new AnalysisReportInProgress(new RuleReportFactory()),
DependencyAnalysis.PrepareFor(csharpProjectDtos, support),
ProjectAnalysis.PrepareFor(csharpProjectDtos),
ProjectNamespacesAnalysis.PrepareFor(csharpProjectDtos), new ResultBuilderFactory()));
}
public DependencyPathBasedRuleTargetFactory(INScanSupport support)
{
_support = support;
}
public static DependencyAnalysis PrepareFor(IEnumerable <CsharpProjectDto> csharpProjectDtos, INScanSupport support)
{
return(new DependencyAnalysis(
new SolutionForDependencyPathRules(
new PathCache(
new DependencyPathFactory()),
new DependencyPathBasedRuleTargetFactory(support)
.CreateDependencyPathRuleTargetsByIds(csharpProjectDtos)),
new PathRuleSet(),
new DependencyPathRuleFactory(
new DependencyPathRuleViolationFactory(
new DependencyPathReportFragmentsFormat()))));
}
public NamespaceBasedRuleLoggingVisitor(INScanSupport support)
{
_support = support;
}
public PathBasedRuleLoggingVisitor(INScanSupport support)
{
_support = support;
}
public ProjectScopedRuleLoggingVisitor(INScanSupport support)
{
_support = support;
}
public ProjectPaths(IEnumerable <AbsoluteFilePath> projectFilePaths, INScanSupport support)
{
_projectFilePaths = projectFilePaths;
_support = support;
}
