private RuleSet FindSonarQubeSolutionRuleSet(IRuleSetSerializer ruleSetSerializer, BindingConfiguration binding, Project project)
{
string expectedSolutionRuleSet = ruleSetInfoProvider.CalculateSolutionSonarQubeRuleSetFilePath(
binding.Project.ProjectKey,
Language.ForProject(project),
binding.Mode);
return(ruleSetSerializer.LoadRuleSet(expectedSolutionRuleSet));
}
private RuleSet FindDeclarationRuleSet(IRuleSetSerializer ruleSetSerializer, Project project, RuleSetDeclaration declaration)
{
string ruleSetFilePath;
// Check if project rule set is found (we treat missing/erroneous rule set settings as not found)
if (!ruleSetInfoProvider.TryGetProjectRuleSetFilePath(project, declaration, out ruleSetFilePath))
{
return(null);
}
return(ruleSetSerializer.LoadRuleSet(ruleSetFilePath));
}
internal CSharpVBProjectBinder(IServiceProvider serviceProvider, IFileSystem fileSystem, IRuleSetReferenceChecker ruleSetReferenceChecker, ICSharpVBAdditionalFileReferenceChecker additionalFileReferenceChecker, CreateBindingOperationFunc createBindingOperationFunc)
{
if (serviceProvider == null)
{
throw new ArgumentNullException(nameof(serviceProvider));
}
this.fileSystem = fileSystem ?? throw new ArgumentNullException(nameof(fileSystem));
this.ruleSetReferenceChecker = ruleSetReferenceChecker ?? throw new ArgumentNullException(nameof(ruleSetReferenceChecker));
this.additionalFileReferenceChecker = additionalFileReferenceChecker ?? throw new ArgumentNullException(nameof(additionalFileReferenceChecker));
this.createBindingOperationFunc = createBindingOperationFunc ?? throw new ArgumentNullException(nameof(createBindingOperationFunc));
ruleSetSerializer = serviceProvider.GetService <IRuleSetSerializer>();
ruleSetSerializer.AssertLocalServiceIsNotNull();
}
public RuleSetReferenceChecker(IServiceProvider serviceProvider, ILogger logger)
{
if (serviceProvider == null)
{
throw new ArgumentNullException(nameof(serviceProvider));
}
this.logger = logger ?? throw new ArgumentNullException(nameof(logger));
ruleSetInfoProvider = serviceProvider.GetService <ISolutionRuleSetsInformationProvider>();
ruleSetInfoProvider.AssertLocalServiceIsNotNull();
ruleSetSerializer = serviceProvider.GetService <IRuleSetSerializer>();
ruleSetSerializer.AssertLocalServiceIsNotNull();
}
private bool IsFullyBoundProject(IRuleSetSerializer ruleSetSerializer, BindingConfiguration binding, Project project)
{
Debug.Assert(binding != null);
Debug.Assert(project != null);
// If solution is not bound/has a missing ruleset, no need to go further
RuleSet sonarQubeRuleSet = this.FindSonarQubeSolutionRuleSet(ruleSetSerializer, binding, project);
if (sonarQubeRuleSet == null)
{
return(false);
}
RuleSetDeclaration[] declarations = ruleSetInfoProvider.GetProjectRuleSetsDeclarations(project).ToArray();
return(declarations.Length > 0 && // Need at least one
declarations.All(declaration => this.IsRuleSetBound(ruleSetSerializer, project, declaration, sonarQubeRuleSet)));
}
private void OnFixConflicts(IEnumerable <ProjectRuleSetConflict> conflicts)
{
if (this.OnFixConflictsStatus(conflicts))
{
var componentModel = host.GetService <SComponentModel, IComponentModel>();
TelemetryLoggerAccessor.GetLogger(componentModel)?.ReportEvent(TelemetryEvent.FixConflictsCommandCalled);
IRuleSetInspector inspector = this.host.GetService <IRuleSetInspector>();
inspector.AssertLocalServiceIsNotNull();
ISourceControlledFileSystem sccFileSystem = this.host.GetService <ISourceControlledFileSystem>();
sccFileSystem.AssertLocalServiceIsNotNull();
IRuleSetSerializer ruleSetSerializer = this.host.GetService <IRuleSetSerializer>();
ruleSetSerializer.AssertLocalServiceIsNotNull();
var fixedConflictsMap = new Dictionary <RuleSetInformation, FixedRuleSetInfo>();
foreach (RuleSetInformation ruleSetInfo in conflicts.Select(c => c.RuleSetInfo))
{
FixedRuleSetInfo fixInfo = inspector.FixConflictingRules(ruleSetInfo.BaselineFilePath, ruleSetInfo.RuleSetFilePath, ruleSetInfo.RuleSetDirectories);
Debug.Assert(fixInfo != null);
fixedConflictsMap[ruleSetInfo] = fixInfo;
sccFileSystem.QueueFileWrite(fixInfo.FixedRuleSet.FilePath, () =>
{
ruleSetSerializer.WriteRuleSetFile(fixInfo.FixedRuleSet, fixInfo.FixedRuleSet.FilePath);
return(true);
});
}
this.WriteFixSummaryToOutputWindow(fixedConflictsMap);
if (sccFileSystem.WriteQueuedFiles())
{
this.Clear();
}
else
{
Debug.Fail("Failed to write one or more of the queued files");
}
}
}
public CachingRulesetSerializer(IRuleSetSerializer ruleSetSerializer)
{
Debug.Assert(ruleSetSerializer != null);
serializer = ruleSetSerializer;
}
private bool IsRuleSetBound(IRuleSetSerializer ruleSetSerializer, Project project, RuleSetDeclaration declaration, RuleSet sonarQubeRuleSet)
{
RuleSet projectRuleSet = this.FindDeclarationRuleSet(ruleSetSerializer, project, declaration);
return(projectRuleSet != null && RuleSetIncludeChecker.HasInclude(projectRuleSet, sonarQubeRuleSet));
}
private bool IsFullyBoundProject(ISolutionRuleSetsInformationProvider ruleSetInfoProvider, IRuleSetSerializer ruleSetSerializer,
BindingConfiguration binding, Project project, Core.Language language)
{
Debug.Assert(binding != null);
Debug.Assert(project != null);
// If solution is not bound/is missing a rules configuration file, no need to go further
var slnLevelBindingConfigFilepath = CalculateSonarQubeSolutionBindingConfigPath(ruleSetInfoProvider, binding, language);
if (!fileSystem.File.Exists(slnLevelBindingConfigFilepath))
{
return(false);
}
if (!BindingRefactoringDumpingGround.IsProjectLevelBindingRequired(project))
{
return(true); // nothing else to check
}
// Projects that required project-level binding should be using RuleSets for configuration,
// so we assume that the solution-level config file is a ruleset.
RuleSet sonarQubeRuleSet = ruleSetSerializer.LoadRuleSet(slnLevelBindingConfigFilepath);
if (sonarQubeRuleSet == null)
{
return(false);
}
RuleSetDeclaration[] declarations = ruleSetInfoProvider.GetProjectRuleSetsDeclarations(project).ToArray();
return(declarations.Length > 0 && // Need at least one
declarations.All(declaration => this.IsRuleSetBound(ruleSetSerializer, project, declaration, sonarQubeRuleSet)));
}
private bool IsFullyBoundProject(ISolutionRuleSetsInformationProvider ruleSetInfoProvider, IRuleSetSerializer ruleSetSerializer,
BindingConfiguration binding, Project project)
{
var languages = ProjectToLanguageMapper.GetAllBindingLanguagesForProject(project);
return(languages.All(l => IsFullyBoundProject(ruleSetInfoProvider, ruleSetSerializer, binding, project, l)));
}
