protected override void InvokeInternal()
{
Debug.Assert(this.propertyManager != null, "Should not be invokable with no property manager");
IList <Project> projects = this.propertyManager
.GetSelectedProjects()
.ToList();
Debug.Assert(projects.Any(), "No projects selected");
Debug.Assert(projects.All(x => ProjectToLanguageMapper.GetLanguageForProject(x).IsSupported), "Unsupported projects");
if (projects.Count == 1 ||
projects.Select(x => this.propertyManager.GetBooleanProperty(x, PropertyName)).AllEqual())
{
// Single project, or multiple projects & consistent property values
foreach (Project project in projects)
{
this.ToggleProperty(project);
}
}
else
{
// Multiple projects & mixed property values
foreach (Project project in projects)
{
this.propertyManager.SetBooleanProperty(project, PropertyName, true);
}
}
}
protected override void QueryStatusInternal(OleMenuCommand command)
{
command.Enabled = false;
command.Visible = false;
if (this.propertyManager == null)
{
return;
}
IList <Project> projects = this.propertyManager
.GetSelectedProjects()
.ToList();
if (projects.Any() && projects.All(x => ProjectToLanguageMapper.GetLanguageForProject(x).IsSupported))
{
IList <bool?> properties = projects.Select(x =>
this.propertyManager.GetBooleanProperty(x, PropertyName)).ToList();
command.Enabled = true;
command.Visible = true;
// Checked if all projects have the same value, and that value is
// the same as the value this instance is responsible for.
command.Checked = properties.AllEqual() && (properties.First() == this.commandPropertyValue);
}
}
public IProjectBinder Get(Project project)
{
var languages = ProjectToLanguageMapper.GetAllBindingLanguagesForProject(project).ToList();
var isCSharpVBLanguage = languages.Contains(Core.Language.VBNET) || languages.Contains(Core.Language.CSharp);
return(isCSharpVBLanguage
? (IProjectBinder) new CSharpVBProjectBinder(serviceProvider, fileSystem, logger)
: new CFamilyProjectBinder(serviceProvider, logger, fileSystem));
}
public bool IsBindingRequired(BindingConfiguration binding, Project project)
{
Debug.Assert(binding != null);
Debug.Assert(project != null);
var languages = ProjectToLanguageMapper.GetAllBindingLanguagesForProject(project);
languages = languages.Where(x => x.Equals(Language.VBNET) || x.Equals(Language.CSharp));
return(languages.Any(l => !IsFullyBoundProject(binding, project, l)));
}
public void Mapper_ForProject_UnknownLanguage_ReturnsUnknown()
{
// Arrange
var otherProject = new ProjectMock("other.proj");
// Act
var otherProjectLanguage = ProjectToLanguageMapper.GetLanguageForProject(otherProject);
// Assert
otherProjectLanguage.Should().Be(Language.Unknown, "Unexpected Language for unknown project");
}
public bool DiscoverProjects()
{
var patternFilteredProjects = this.projectSystem.GetFilteredSolutionProjects();
var pluginAndPatternFilteredProjects =
patternFilteredProjects.Where(p => this.host.SupportedPluginLanguages
.Any(l => ProjectToLanguageMapper.GetAllBindingLanguagesForProject(p).Contains(l)));
this.InternalState.BindingProjects.UnionWith(pluginAndPatternFilteredProjects);
this.InformAboutFilteredOutProjects();
return(this.InternalState.BindingProjects.Any());
}
public void Mapper_ForProject_KnownLanguage_ReturnsCorrectLanguage_CS()
{
// Arrange
var csProject = new ProjectMock("cs1.csproj");
csProject.SetCSProjectKind();
// Act
var csProjectLanguage = ProjectToLanguageMapper.GetLanguageForProject(csProject);
// Assert
csProjectLanguage.Should().Be(Language.CSharp, "Unexpected Language for C# project");
}
private void SetValidSolutionRuleSetPerProjectKind()
{
foreach (var project in this.projectHelper.FilteredProjects)
{
var bindingConfiguration = configProvider.GetConfiguration();
var solutionRuleSet =
bindingConfiguration.BuildPathUnderConfigDirectory(ProjectToLanguageMapper
.GetLanguageForProject(project).FileSuffixAndExtension);
fileSystem.AddFile(solutionRuleSet, new MockFileData(""));
}
}
public void Mapper_ForProject_KnownLanguage_ReturnsCorrectLanguage_CS_CaseSensitivity2()
{
// Arrange
var csProject = new ProjectMock("cs1.csproj");
csProject.ProjectKind = ProjectSystemHelper.CSharpProjectKind.ToLower();
// Act
var csProjectLanguage = ProjectToLanguageMapper.GetLanguageForProject(csProject);
// Assert
csProjectLanguage.Should().Be(Language.CSharp, "Unexpected Language for C# project");
}
public void Mapper_ForProject_KnownLanguage_ReturnsCorrectLanguage_VBCore()
{
// Arrange
var vbNetProject = new ProjectMock("vb1.vbproj");
vbNetProject.ProjectKind = ProjectSystemHelper.VbCoreProjectKind;
// Act
var vbNetProjectLanguage = ProjectToLanguageMapper.GetLanguageForProject(vbNetProject);
// Assert
vbNetProjectLanguage.Should().Be(Language.VBNET, "Unexpected Language for VB Core project");
}
private void SetValidSolutionRuleSetPerProjectKind()
{
ISolutionRuleSetsInformationProvider rsInfoProvider = this.ruleSetInfoProvider;
foreach (var project in this.projectHelper.FilteredProjects)
{
string solutionRuleSet = rsInfoProvider.CalculateSolutionSonarQubeRuleSetFilePath(
this.configProvider.ProjectToReturn.ProjectKey,
ProjectToLanguageMapper.GetLanguageForProject(project),
SonarLintMode.LegacyConnected);
this.fileSystem.AddFile(solutionRuleSet, new MockFileData(""));
}
}
public void Mapper_ForProject_KnownLanguage_ReturnsCorrectLanguage_VB()
{
// Test case 3: VB - non-Core
// Arrange
var vbNetProject = new ProjectMock("vb1.vbproj");
vbNetProject.SetVBProjectKind();
// Act
var vbNetProjectLanguage = ProjectToLanguageMapper.GetLanguageForProject(vbNetProject);
// Assert
vbNetProjectLanguage.Should().Be(Language.VBNET, "Unexpected Language for VB project");
}
private static void CheckGetAllBindingsLanguages(string projectTypeGuid, params Language[] expectedLanguages)
{
// Arrange
var project = new ProjectMock("any.xxx")
{
ProjectKind = projectTypeGuid
};
// Act
var actualLanguage = ProjectToLanguageMapper.GetAllBindingLanguagesForProject(project);
// Assert
actualLanguage.Should().BeEquivalentTo(expectedLanguages);
}
public bool IsBindingRequired(BindingConfiguration binding, Project project)
{
Debug.Assert(binding != null);
Debug.Assert(project != null);
var languages = ProjectToLanguageMapper.GetAllBindingLanguagesForProject(project);
languages = languages.Where(x => x.Equals(Language.C) || x.Equals(Language.Cpp));
return(languages.Any(language =>
{
var slnLevelBindingConfigFilepath = binding.BuildPathUnderConfigDirectory(language.FileSuffixAndExtension);
return !fileSystem.File.Exists(slnLevelBindingConfigFilepath);
}));
}
protected override void QueryStatusInternal(OleMenuCommand command)
{
Debug.Assert(this.propertyManager != null, "Property manager should not be null");
command.Enabled = false;
command.Visible = false;
IList <Project> projects = this.propertyManager
.GetSelectedProjects()
.ToList();
if (projects.Any() && projects.All(x => ProjectToLanguageMapper.GetLanguageForProject(x).IsSupported))
{
command.Enabled = true;
command.Visible = true;
}
}
private static void CheckGetLanguage(string projectTypeGuid, Language expectedLanguage)
{
// Arrange
var project = new ProjectMock("any.xxx")
{
ProjectKind = projectTypeGuid
};
// Act
#pragma warning disable CS0618 // Type or member is obsolete
var actualLanguage = ProjectToLanguageMapper.GetLanguageForProject(project);
#pragma warning restore CS0618 // Type or member is obsolete
// Assert
actualLanguage.Should().Be(expectedLanguage);
}
protected override void InvokeInternal()
{
Debug.Assert(this.propertyManager != null, "Should not be invokable with no property manager");
IList <Project> projects = this.propertyManager
.GetSelectedProjects()
.ToList();
Debug.Assert(projects.Any(), "No projects selected");
Debug.Assert(projects.All(x => ProjectToLanguageMapper.GetLanguageForProject(x).IsSupported), "Unsupported projects");
foreach (Project project in projects)
{
this.propertyManager.SetBooleanProperty(project, PropertyName, this.commandPropertyValue);
}
}
// ISSUE : this method is doing too many things
private RuleSetInformation[] CheckSlnLevelConfigExistsAndReturnAllProjectRuleSetsForAllConfigurations(
BoundSonarQubeProject bindingInfo)
{
var projectSystem = this.serviceProvider.GetService <IProjectSystemHelper>();
projectSystem.AssertLocalServiceIsNotNull();
var ruleSetInfoProvider = this.serviceProvider.GetService <ISolutionRuleSetsInformationProvider>();
ruleSetInfoProvider.AssertLocalServiceIsNotNull();
var fileSystem = this.serviceProvider.GetService <IFileSystem>();
fileSystem.AssertLocalServiceIsNotNull();
var projectRuleSetAggregation = new Dictionary <string, RuleSetInformation>(StringComparer.OrdinalIgnoreCase);
foreach (Project project in projectSystem.GetFilteredSolutionProjects())
{
// Solution-level checks (done here because the expected solution-level config
// depends on the languages supported by the project that exist)
string baselineRuleSet = ruleSetInfoProvider.CalculateSolutionSonarQubeRuleSetFilePath(
bindingInfo.ProjectKey,
ProjectToLanguageMapper.GetLanguageForProject(project),
SonarLintMode.LegacyConnected);
if (!fileSystem.FileExist(baselineRuleSet))
{
this.WriteWarning(Strings.ExpectedRuleSetNotFound, baselineRuleSet, project.FullName);
continue;
}
if (!BindingRefactoringDumpingGround.IsProjectLevelBindingRequired(project))
{
continue;
}
foreach (RuleSetDeclaration declaration in ruleSetInfoProvider.GetProjectRuleSetsDeclarations(project))
{
string projectRuleSet = CalculateProjectRuleSetFullPath(ruleSetInfoProvider, project, declaration);
this.AddOrUpdateAggregatedRuleSetInformation(projectRuleSetAggregation, baselineRuleSet, declaration, projectRuleSet);
}
}
return(projectRuleSetAggregation.Values.ToArray());
}
public void ConflictsManager_GetCurrentConflicts_MissingBaselineFile()
{
// Arrange
this.SetSolutionBinding(SonarLintMode.LegacyConnected);
this.SetValidProjects();
// Act + Assert
testSubject.GetCurrentConflicts().Should().BeEmpty("Not expecting any conflicts since the solution baseline is missing");
this.outputWindowPane.AssertOutputStrings(1);
var expectedBaselineLocation = configProvider.GetConfiguration()
.BuildPathUnderConfigDirectory(ProjectToLanguageMapper
.GetLanguageForProject(projectHelper.FilteredProjects.First()).FileSuffixAndExtension);
outputWindowPane.AssertOutputStrings(1);
this.outputWindowPane.AssertPartialOutputStrings(expectedBaselineLocation);
}
public void Prepare(CancellationToken token)
{
Debug.Assert(this.SolutionFullPath != null, "Expected to be initialized");
foreach (var keyValue in this.bindingConfigInformationMap)
{
if (token.IsCancellationRequested)
{
return;
}
var info = keyValue.Value;
sourceControlledFileSystem.QueueFileWrites(info.SolutionLevelFilePaths, () =>
{
foreach (var solutionItem in info.SolutionLevelFilePaths)
{
var ruleSetDirectoryPath = Path.GetDirectoryName(solutionItem);
fileSystem.Directory.CreateDirectory(ruleSetDirectoryPath); // will no-op if exists
}
info.Save();
return(true);
});
Debug.Assert(sourceControlledFileSystem.FilesExistOrQueuedToBeWritten(info.SolutionLevelFilePaths), "Expected solution items to be queued for writing");
}
foreach (var project in projects)
{
if (token.IsCancellationRequested)
{
return;
}
var languageForProject = ProjectToLanguageMapper.GetLanguageForProject(project);
var bindingConfigFile = GetBindingConfig(languageForProject);
var projectBinder = projectBinderFactory.Get(project);
var bindAction = projectBinder.GetBindAction(bindingConfigFile, project, token);
projectBinders.Add(bindAction);
}
}
protected override void QueryStatusInternal(OleMenuCommand command)
{
command.Enabled = false;
command.Visible = false;
if (this.propertyManager == null)
{
return;
}
IList <Project> projects = this.propertyManager
.GetSelectedProjects()
.ToList();
if (projects.Any() && projects.All(x => ProjectToLanguageMapper.GetLanguageForProject(x).IsSupported))
{
IList <bool> properties = projects.Select(x =>
this.propertyManager.GetBooleanProperty(x, PropertyName) ?? false).ToList();
command.Enabled = true;
command.Visible = true;
command.Checked = properties.AllEqual() && properties.First();
}
}
private void CaptureProject()
{
this.ProjectLanguage = ProjectToLanguageMapper.GetLanguageForProject(this.initializedProject);
this.ProjectFullPath = this.initializedProject.FullName;
}
// ISSUE : this method is doing too many things
private RuleSetInformation[] CheckSlnLevelConfigExistsAndReturnAllProjectRuleSetsForAllConfigurations(BindingConfiguration bindingConfiguration)
{
var projectSystem = this.serviceProvider.GetService <IProjectSystemHelper>();
projectSystem.AssertLocalServiceIsNotNull();
var ruleSetInfoProvider = this.serviceProvider.GetService <ISolutionRuleSetsInformationProvider>();
ruleSetInfoProvider.AssertLocalServiceIsNotNull();
var projectRuleSetAggregation = new Dictionary <string, RuleSetInformation>(StringComparer.OrdinalIgnoreCase);
foreach (Project project in projectSystem.GetFilteredSolutionProjects())
{
// Solution-level checks (done here because the expected solution-level config
// depends on the languages supported by the project that exist)
string baselineRuleSet = bindingConfiguration.BuildPathUnderConfigDirectory(ProjectToLanguageMapper.GetLanguageForProject(project).FileSuffixAndExtension);
if (!fileSystem.File.Exists(baselineRuleSet))
{
this.WriteWarning(Strings.ExpectedRuleSetNotFound, baselineRuleSet, project.FullName);
continue;
}
if (projectBinderFactory.Get(project) is CSharpVBProjectBinder)
{
foreach (var declaration in ruleSetInfoProvider.GetProjectRuleSetsDeclarations(project))
{
string projectRuleSet =
CalculateProjectRuleSetFullPath(ruleSetInfoProvider, declaration);
this.AddOrUpdateAggregatedRuleSetInformation(projectRuleSetAggregation, baselineRuleSet,
declaration, projectRuleSet);
}
}
}
return(projectRuleSetAggregation.Values.ToArray());
}
public void Mapper_GetLanguage_KnownLanguage_ArgChecks()
{
#pragma warning disable CS0618 // Type or member is obsolete
Exceptions.Expect <ArgumentNullException>(() => ProjectToLanguageMapper.GetLanguageForProject(null));
#pragma warning restore CS0618 // Type or member is obsolete
}
internal /* for testing */ static bool IsProjectLevelBindingRequired(Project project)
{
var languages = ProjectToLanguageMapper.GetAllBindingLanguagesForProject(project);
return(languages.Contains(Core.Language.VBNET) || languages.Contains(Core.Language.CSharp));
}
/// <summary>
/// Will install the NuGet packages for the current managed projects.
/// The packages that will be installed will be based on the information from <see cref="Analyzer.GetRequiredNuGetPackages"/>
/// and is specific to the <see cref="RuleSet"/>.
/// </summary>
public bool InstallPackages(ISet <Project> projectsToBind, IProgress <FixedStepsProgress> progress, CancellationToken token)
{
if (this.NuGetPackages.Count == 0)
{
return(true);
}
Debug.Assert(this.NuGetPackages.Count == this.NuGetPackages.Distinct().Count(), "Duplicate NuGet packages specified");
if (projectsToBind == null || projectsToBind.Count == 0)
{
Debug.Fail("Not expected to be called when there are no projects");
return(true);
}
var projectNugets = projectsToBind
.SelectMany(bindingProject =>
{
var projectLanguage = ProjectToLanguageMapper.GetLanguageForProject(bindingProject);
List <NuGetPackageInfo> nugetPackages;
if (!this.NuGetPackages.TryGetValue(projectLanguage, out nugetPackages))
{
var message = string.Format(Strings.BindingProjectLanguageNotMatchingAnyQualityProfileLanguage, bindingProject.Name);
this.logger.WriteLine(Strings.SubTextPaddingFormat, message);
nugetPackages = new List <NuGetPackageInfo>();
}
return(nugetPackages.Select(nugetPackage => new { Project = bindingProject, NugetPackage = nugetPackage }));
})
.ToArray();
bool overallSuccess = true;
int currentProject = 0;
foreach (var projectNuget in projectNugets)
{
if (token.IsCancellationRequested)
{
break;
}
string message = string.Format(CultureInfo.CurrentCulture, Strings.EnsuringNugetPackagesProgressMessage, projectNuget.NugetPackage.Id, projectNuget.Project.Name);
this.logger.WriteLine(Strings.SubTextPaddingFormat, message);
var isNugetInstallSuccessful = NuGetHelper.TryInstallPackage(this.serviceProvider, this.logger, projectNuget.Project, projectNuget.NugetPackage.Id, projectNuget.NugetPackage.Version);
if (isNugetInstallSuccessful) // NuGetHelper.TryInstallPackage already displayed the error message so only take care of the success message
{
message = string.Format(CultureInfo.CurrentCulture, Strings.SuccessfullyInstalledNugetPackageForProject, projectNuget.NugetPackage.Id, projectNuget.Project.Name);
this.logger.WriteLine(Strings.SubTextPaddingFormat, message);
}
// TODO: SVS-33 (https://jira.sonarsource.com/browse/SVS-33) Trigger a Team Explorer warning notification to investigate the partial binding in the output window.
overallSuccess &= isNugetInstallSuccessful;
currentProject++;
progress?.Report(new FixedStepsProgress(string.Empty, currentProject, projectNugets.Length));
}
return(overallSuccess);
}
public void Mapper_ForProject_KnownLanguage_ArgChecks()
{
Exceptions.Expect <ArgumentNullException>(() => ProjectToLanguageMapper.GetLanguageForProject(null));
}