public void RoslynConfig_NoAnalyzerAssemblies_Succeeds()
{
// Arrange
string rootDir = CreateTestFolders();
TestLogger logger = new TestLogger();
TeamBuildSettings settings = CreateSettings(rootDir);
MockSonarQubeServer mockServer = CreateValidServer("valid.project", null, "valid.profile");
QualityProfile csProfile = mockServer.Data.FindProfile("valid.profile", RoslynAnalyzerProvider.CSharpLanguage);
csProfile.SetExport(RoslynAnalyzerProvider.RoslynCSharpFormatName, @"<?xml version=""1.0"" encoding=""utf-8""?>
<RoslynExportProfile Version=""1.0="">
<Configuration>
<RuleSet />
<AdditionalFiles />
</Configuration>
<Deployment>
<Plugins /> <!-- empty -->
</Deployment>
</RoslynExportProfile>");
RoslynAnalyzerProvider testSubject = CreateTestSubject(logger);
// Act
AnalyzerSettings actualSettings = testSubject.SetupAnalyzers(mockServer, settings, "valid.project", null);
// Assert
CheckSettingsInvariants(actualSettings);
CheckExpectedAssemblies(actualSettings /* none */);
logger.AssertErrorsLogged(0);
logger.AssertWarningsLogged(0);
}
public void RoslynConfig_ValidRealSonarLintProfile()
{
// Arrange
string rootDir = CreateTestFolders();
TestLogger logger = new TestLogger();
TeamBuildSettings settings = CreateSettings(rootDir);
WellKnownProfile testProfile = CreateRealSonarLintProfile();
MockSonarQubeServer mockServer = CreateServer("valid.project", null, "valid.profile", testProfile);
RoslynAnalyzerProvider testSubject = CreateTestSubject(logger);
// Act
AnalyzerSettings actualSettings = testSubject.SetupAnalyzers(mockServer, settings, "valid.project", null);
// Assert
CheckSettingsInvariants(actualSettings);
logger.AssertWarningsLogged(0);
logger.AssertErrorsLogged(0);
CheckRuleset(actualSettings, rootDir);
CheckExpectedAdditionalFiles(testProfile, actualSettings);
// Check the additional file is valid XML
Assert.AreEqual(1, actualSettings.AdditionalFilePaths.Count(), "Test setup error: expecting only one additional file. Check the sample export XML has not changed");
string filePath = actualSettings.AdditionalFilePaths.First();
CheckFileIsXml(filePath);
}
public void RoslynConfig_ValidProfile()
{
// Arrange
string rootDir = CreateTestFolders();
TestLogger logger = new TestLogger();
TeamBuildSettings settings = CreateSettings(rootDir);
WellKnownProfile testProfile = CreateValidCSharpProfile();
MockSonarQubeServer mockServer = CreateServer("valid.project", null, "valid.profile", testProfile);
MockAnalyzerInstaller mockInstaller = new MockAnalyzerInstaller();
mockInstaller.AssemblyPathsToReturn = new HashSet <string>(new string[] { "c:\\assembly1.dll", "d:\\foo\\assembly2.dll" });
RoslynAnalyzerProvider testSubject = new RoslynAnalyzerProvider(mockInstaller, logger);
// Act
AnalyzerSettings actualSettings = testSubject.SetupAnalyzers(mockServer, settings, "valid.project", null);
// Assert
CheckSettingsInvariants(actualSettings);
logger.AssertWarningsLogged(0);
logger.AssertErrorsLogged(0);
CheckRuleset(actualSettings, rootDir);
CheckExpectedAdditionalFiles(testProfile, actualSettings);
mockInstaller.AssertExpectedPluginsRequested(testProfile.Plugins);
CheckExpectedAssemblies(actualSettings, "c:\\assembly1.dll", "d:\\foo\\assembly2.dll");
}
public void RoslynConfig_BranchMissingRuleset()
{
// This test is a regression scenario for SONARMSBRU-187:
// We do not expect the project profile to be returned if we ask for a branch-specific profile
// Arrange
string rootDir = CreateTestFolders();
TestLogger logger = new TestLogger();
TeamBuildSettings settings = CreateSettings(rootDir);
WellKnownProfile testProfile = CreateValidCSharpProfile();
MockSonarQubeServer mockServer = CreateServer("valid.project", null, "valid.profile", testProfile);
MockAnalyzerInstaller mockInstaller = new MockAnalyzerInstaller();
mockInstaller.AssemblyPathsToReturn = new HashSet <string>(new string[] { "c:\\assembly1.dll", "d:\\foo\\assembly2.dll" });
RoslynAnalyzerProvider testSubject = new RoslynAnalyzerProvider(mockInstaller, logger);
// Act
AnalyzerSettings actualSettings = testSubject.SetupAnalyzers(mockServer, settings, "valid.project", "missingBranch");
// Assert
AssertAnalyzerSetupNotPerformed(actualSettings, rootDir);
logger.AssertErrorsLogged(0);
logger.AssertWarningsLogged(0);
}
private TaskOutputs CreateLegacyProductProjectSettings(AnalyzerSettings settings)
{
var configOnlyAnalyzers = settings.AnalyzerPlugins.SelectMany(p => p.AssemblyPaths);
var additionalFilePaths = MergeFileLists(settings.AdditionalFilePaths, OriginalAdditionalFiles);
return(new TaskOutputs(settings.RulesetPath, configOnlyAnalyzers, additionalFilePaths));
}
private IncludeResolveStrategy CreateIncludeResolveStrategy()
{
string testDataDirectory = TestData.TestDataDirectory;
Assert.IsNotNull(testDataDirectory);
List <string> projectIncludeDirectories = new List <string>
{
Path.Combine(testDataDirectory, "DirA"),
Path.Combine(testDataDirectory, "DirB")
};
List <string> interfaceIncludeDirectories = new List <string>
{
Path.Combine(testDataDirectory, "DirInterfaces")
};
List <string> externalIncludeDirectories = new List <string>
{
Path.Combine(testDataDirectory, "DirExternal")
};
AnalyzerSettings analyzerSettings = AnalyzerSettings.CreateDefault();
List <string> systemIncludeDirectories = analyzerSettings.SystemIncludeDirectories;
return(new IncludeResolveStrategy(projectIncludeDirectories, interfaceIncludeDirectories, externalIncludeDirectories, systemIncludeDirectories));
}
public void CheckBits1()
{
var tmpIniData = DataHelper.LoadIni("");
var tmpObjectInformation = new JavaLoader().CreateObjectInformation(new List <string> {
JavaBits
}, tmpIniData);
var tmpAnalyerSettings = new AnalyzerSettings();
var tmpUnknownTypeCounter = 0;
tmpAnalyerSettings.UnknownTypeAdded += (UnknownTypeClass inItem) => { tmpUnknownTypeCounter++; };
new AnalyzerCore().LinkProjectInformation(tmpObjectInformation, tmpAnalyerSettings);
new NamingConvertionHelper(new ConverterLucene()).ConvertProject(tmpObjectInformation);
var tmpResult = CSharpWriter.CreateClassesFromObjectInformation(tmpObjectInformation, new ConverterLucene()).ToList();
Assert.AreEqual(1, tmpResult.Count);
Assert.AreEqual("Bits", tmpResult[0].FullName);
//Check for inner classes existing
//Expecting four unknown Types: true, false, int and boolean, two which I have not yet added a Pre-Runtime class
Assert.AreEqual(0, tmpUnknownTypeCounter);
Assert.AreEqual(true, tmpResult[0].Content.Contains("MatchAllBits"));
Assert.AreEqual(true, tmpResult[0].Content.Contains("this.len = inLen;"));
Assert.AreEqual(true, tmpResult[0].Content.Contains("Bits[] EMPTY_ARRAY = new Bits[0];"));
}
public void AnalyzerSettingsTypeProperty_GetSet()
{
var instance = new AnalyzerSettings();
instance.Type = "type";
Assert.AreEqual("type", instance.Type);
}
public void AnalyzerSettingsWeightProperty_GetSet()
{
var instance = new AnalyzerSettings();
instance.Weight = 3;
Assert.AreEqual(3, instance.Weight);
}
public Analyzer(IDsiModel model, AnalyzerSettings analyzerSettings, IProgress <ProgressInfo> progress)
{
_model = model;
_analyzerSettings = analyzerSettings;
_progress = progress;
_solutionFile = new SolutionFile(analyzerSettings.InputFilename, _analyzerSettings, progress);
}
public void AnalyzerSettingsAliasProperty_GetSet()
{
var instance = new AnalyzerSettings();
instance.Alias = "alias";
Assert.AreEqual("alias", instance.Alias);
}
public override bool Execute()
{
bool taskSuccess = true;
AnalysisConfig config = TaskUtilities.TryGetConfig(this.AnalysisConfigDir, new MSBuildLoggerAdapter(this.Log));
if (config != null)
{
AnalyzerSettings settings = config.AnalyzerSettings;
if (settings == null)
{
this.Log.LogMessage(MessageImportance.Low, Resources.AnalyzerSettings_NotSpecifiedInConfig);
}
else
{
this.RuleSetFilePath = settings.RuleSetFilePath;
if (settings.AnalyzerAssemblyPaths != null)
{
this.AnalyzerFilePaths = settings.AnalyzerAssemblyPaths.Where(f => IsAssemblyLibraryFileName(f)).ToArray();
}
if (settings.AdditionalFilePaths != null)
{
this.AdditionalFiles = settings.AdditionalFilePaths.ToArray();
}
}
}
return(!this.Log.HasLoggedErrors && taskSuccess);
}
private void CheckRuleset(AnalyzerSettings actualSettings, string rootTestDir, string language)
{
string.IsNullOrWhiteSpace(actualSettings.RuleSetFilePath).Should().BeFalse("Ruleset file path should be set");
Path.IsPathRooted(actualSettings.RuleSetFilePath).Should().BeTrue("Ruleset file path should be absolute");
File.Exists(actualSettings.RuleSetFilePath).Should().BeTrue("Specified ruleset file does not exist: {0}", actualSettings.RuleSetFilePath);
TestContext.AddResultFile(actualSettings.RuleSetFilePath);
CheckFileIsXml(actualSettings.RuleSetFilePath);
Path.GetFileName(actualSettings.RuleSetFilePath).Should().Be(RoslynAnalyzerProvider.GetRoslynRulesetFileName(language), "Ruleset file does not have the expected name");
var expectedFilePath = GetExpectedRulesetFilePath(rootTestDir, language);
actualSettings.RuleSetFilePath.Should().Be(expectedFilePath, "Ruleset was not written to the expected location");
var expectedContent = @"<?xml version=""1.0"" encoding=""utf-8""?>
<RuleSet xmlns:xsi=""http://www.w3.org/2001/XMLSchema-instance"" xmlns:xsd=""http://www.w3.org/2001/XMLSchema"" Name=""Rules for SonarQube"" Description=""This rule set was automatically generated from SonarQube"" ToolsVersion=""14.0"">
<Rules AnalyzerId=""SonarAnalyzer.CSharp"" RuleNamespace=""SonarAnalyzer.CSharp"">
<Rule Id=""S1116"" Action=""Warning"" />
<Rule Id=""S1125"" Action=""Warning"" />
<Rule Id=""S1000"" Action=""None"" />
</Rules>
<Rules AnalyzerId=""Wintellect.Analyzers"" RuleNamespace=""Wintellect.Analyzers"">
<Rule Id=""Wintellect003"" Action=""Warning"" />
</Rules>
</RuleSet>";
File.ReadAllText(actualSettings.RuleSetFilePath).Should().Be(expectedContent, "Ruleset file does not have the expected content: {0}", actualSettings.RuleSetFilePath);
}
public AnalyzerSettings SetupAnalyzer(TeamBuildSettings settings, IDictionary <string, string> serverSettings,
IEnumerable <ActiveRule> activeRules, IEnumerable <string> inactiveRules, string language)
{
this.sqSettings = settings ?? throw new ArgumentNullException(nameof(settings));
this.sqServerSettings = serverSettings ?? throw new ArgumentNullException(nameof(serverSettings));
if (language == null)
{
throw new ArgumentNullException(nameof(language));
}
if (inactiveRules == null)
{
throw new ArgumentNullException(nameof(inactiveRules));
}
if (activeRules == null)
{
throw new ArgumentNullException(nameof(activeRules));
}
if (!activeRules.Any())
{
return(null);
}
AnalyzerSettings analyzer = ConfigureAnalyzer(language, activeRules, inactiveRules);
if (analyzer == null)
{
logger.LogInfo(Resources.RAP_NoPluginInstalled, language);
}
return(analyzer);
}
public void RoslynConfig_MissingRuleset()
{
// Arrange
string rootDir = CreateTestFolders();
TestLogger logger = new TestLogger();
TeamBuildSettings settings = CreateSettings(rootDir);
MockSonarQubeServer mockServer = CreateValidServer("valid.project", null, "valid.profile");
QualityProfile csProfile = mockServer.Data.FindProfile("valid.profile", RoslynAnalyzerProvider.CSharpLanguage);
csProfile.SetExport(RoslynAnalyzerProvider.RoslynCSharpFormatName, @"<?xml version=""1.0"" encoding=""utf-8""?>
<RoslynExportProfile Version=""1.0="">
<Configuration>
<!-- Missing ruleset -->
<AdditionalFiles>
<AdditionalFile FileName=""SonarLint.xml"" >
</AdditionalFile>
</AdditionalFiles>
</Configuration>
<Deployment />
</RoslynExportProfile>");
RoslynAnalyzerProvider testSubject = CreateTestSubject(logger);
// Act
AnalyzerSettings actualSettings = testSubject.SetupAnalyzers(mockServer, settings, "valid.project", null);
// Assert
AssertAnalyzerSetupNotPerformed(actualSettings, rootDir);
logger.AssertErrorsLogged(0);
logger.AssertWarningsLogged(0);
}
private static void CompareAnalyzerSettings(IList <AnalyzerSettings> expectedList, IList <AnalyzerSettings> actualList)
{
Assert.IsNotNull(actualList, "Not expecting the AnalyzersSettings to be null for a reloaded file");
if (expectedList == null)
{
Assert.IsTrue(actualList.Count == 0, "Expecting the reloaded analyzers settings to be empty");
return;
}
Assert.IsNotNull(actualList, "Not expecting the actual analyzers settings to be null for a reloaded file");
Assert.AreEqual(expectedList.Count, actualList.Count, "Expecting number of analyzer settings to be the same");
for (int i = 0; i < actualList.Count; i++)
{
AnalyzerSettings actual = actualList[i];
AnalyzerSettings expected = expectedList[i];
Assert.AreEqual(expected.RuleSetFilePath, actual.RuleSetFilePath, "Unexpected Ruleset value");
CollectionAssert.AreEqual(expected.AnalyzerAssemblyPaths, actual.AnalyzerAssemblyPaths, "Analyzer assembly paths do not match");
CollectionAssert.AreEqual(expected.AdditionalFilePaths, actual.AdditionalFilePaths, "Additional file paths do not match");
}
}
private void FFRKViewInventory_Load(object sender, EventArgs e)
{
if (DesignMode)
{
return;
}
if (FFRKProxy.Instance != null)
{
mAnalyzerSettings = AnalyzerSettings.DefaultSettings;
mAnalyzerSettings.LevelConsideration = TranslateLevelConsideration((ScoreUpgradeModeComboIndex)comboBoxScoreSelection.SelectedIndex);
mAnalyzer = new EquipmentAnalyzer(mAnalyzerSettings);
FFRKProxy.Instance.OnPartyList += FFRKProxy_OnPartyList;
DataPartyDetails party = FFRKProxy.Instance.GameState.PartyDetails;
if (party != null)
{
// Run the initial analysis before updating the grids, so we can pass the
// scores straight through. We'll run the analysis again every time they
// change one of the settings, so that the scores update on the fly.
mAnalyzer.Items = party.Equipments;
mAnalyzer.Buddies = party.Buddies;
mAnalyzer.Run();
UpdatePartyGrid(party.Buddies.ToList());
UpdateEquipmentGrid(party.Equipments);
}
}
}
public Analyzer(IDsiModel model, AnalyzerSettings analyzerSettings, IProgress <ProgressInfo> progress)
{
_model = model;
_analyzerSettings = analyzerSettings;
_progress = progress;
_repository = new EA.Repository();
}
private string CreateMergedRuleset(AnalyzerSettings languageSpecificSettings)
{
// The original ruleset should have been provided to the task.
// This should never be null when using the default targets
// (if the user hasn't specified anything then it will be the
// Microsoft minimum recommended tooleset).
// However, we'll be defensive and handle nulls in case the
// user has customised their build.
if (OriginalRulesetFilePath == null)
{
// If the project doesn't already have a ruleset can just
// return the generated one directly
Log.LogMessage(MessageImportance.Low, Resources.AnalyzerSettings_OriginalRulesetNotSpecified, languageSpecificSettings.RuleSetFilePath);
return(languageSpecificSettings.RuleSetFilePath);
}
string resolvedRulesetPath = GetAbsoluteRulesetPath();
var mergedRulesetFilePath = Path.Combine(ProjectSpecificConfigDirectory, "merged.ruleset");
Log.LogMessage(MessageImportance.Low, Resources.AnalyzerSettings_CreatingMergedRuleset, mergedRulesetFilePath);
WriteMergedRuleSet(resolvedRulesetPath, languageSpecificSettings.RuleSetFilePath, mergedRulesetFilePath);
return(mergedRulesetFilePath);
}
private void CheckExpectedAdditionalFiles(AnalyzerSettings actualSettings)
{
// Currently, only SonarLint.xml is written
var filePaths = actualSettings.AdditionalFilePaths;
filePaths.Should().ContainSingle();
CheckExpectedAdditionalFileExists("SonarLint.xml", @"<?xml version=""1.0"" encoding=""UTF-8""?>
<AnalysisInput>
<Settings>
</Settings>
<Rules>
<Rule>
<Key>S1116</Key>
<Parameters>
<Parameter>
<Key>key</Key>
<Value>value</Value>
</Parameter>
</Parameters>
</Rule>
<Rule>
<Key>S1125</Key>
</Rule>
</Rules>
<Files>
</Files>
</AnalysisInput>
", actualSettings);
}
public void AnalyzerSettingsOptionsProperty_GetSet()
{
var instance = new AnalyzerSettings();
instance.Options = new List <AnalyzerOption>();
Assert.IsNotNull(instance.Options);
}
public void RoslynConfig_ValidProfile()
{
// Arrange
string rootFolder = CreateTestFolders();
TestLogger logger = new TestLogger();
IList <ActiveRule> activeRules = createActiveRules();
IList <string> inactiveRules = createInactiveRules();
string language = RoslynAnalyzerProvider.CSharpLanguage;
MockAnalyzerInstaller mockInstaller = new MockAnalyzerInstaller();
mockInstaller.AssemblyPathsToReturn = new HashSet <string>(new string[] { "c:\\assembly1.dll", "d:\\foo\\assembly2.dll" });
TeamBuildSettings settings = CreateSettings(rootFolder);
RoslynAnalyzerProvider testSubject = new RoslynAnalyzerProvider(mockInstaller, logger);
// Act
AnalyzerSettings actualSettings = testSubject.SetupAnalyzer(settings, ServerSettings, activeRules, inactiveRules, language);
// Assert
CheckSettingsInvariants(actualSettings);
logger.AssertWarningsLogged(0);
logger.AssertErrorsLogged(0);
CheckRuleset(actualSettings, rootFolder, language);
CheckExpectedAdditionalFiles(rootFolder, language, settings.SonarOutputDirectory, actualSettings);
CheckExpectedAssemblies(actualSettings, "c:\\assembly1.dll", "d:\\foo\\assembly2.dll");
List <string> plugins = new List <string>();
plugins.Add("wintellect");
plugins.Add("csharp");
mockInstaller.AssertExpectedPluginsRequested(plugins);
}
public SolutionFile(string solutionPath, AnalyzerSettings analyzerSettings, IProgress <ProgressInfo> progress)
{
_solutionFileInfo = new FileInfo(solutionPath);
_name = _solutionFileInfo.Name;
_analyzerSettings = analyzerSettings;
_progress = progress;
}
private void LoadSettings(string basePath)
{
if (!basePath.EndsWith(Path.DirectorySeparatorChar))
{
basePath += Path.DirectorySeparatorChar;
}
GeneralSettingsWrapper gsw = JsonConvert.DeserializeObject <GeneralSettingsWrapper>(File.ReadAllText(basePath + "settings.general.json"));
_generalSettings = gsw.GeneralSettings;
AnalyzerSettingsWrapper asw = JsonConvert.DeserializeObject <AnalyzerSettingsWrapper>(File.ReadAllText(basePath + "settings.analyzer.json"));
_analyzerSettings = asw.AnalyzerSettings;
if (!_generalSettings.Application.ProfitTrailerMonitorURL.EndsWith("/"))
{
_generalSettings.Application.ProfitTrailerMonitorURL += "/";
}
if (File.Exists(basePath + "settings.secure.json"))
{
SecureSettingsWrapper ssw = JsonConvert.DeserializeObject <SecureSettingsWrapper>(File.ReadAllText(basePath + "settings.secure.json"));
_secureSettings = ssw.SecureSettings;
}
}
static void Main(string[] args)
{
Logger.Init(Assembly.GetExecutingAssembly());
if (args.Length < 1)
{
Logger.LogUserMessage("Usage: DsmSuite.Analyzer.Jdeps <settingsfile>");
}
else
{
FileInfo settingsFileInfo = new FileInfo(args[0]);
if (!settingsFileInfo.Exists)
{
AnalyzerSettings.WriteToFile(settingsFileInfo.FullName, AnalyzerSettings.CreateDefault());
Logger.LogUserMessage("Settings file does not exist. Default one created");
}
else
{
AnalyzerSettings analyzerSettings = AnalyzerSettings.ReadFromFile(settingsFileInfo.FullName);
Logger.LoggingEnabled = analyzerSettings.LoggingEnabled;
ConsoleAction action = new ConsoleAction(analyzerSettings);
action.Execute();
}
}
}
public Analyzer(IDsiModel model, AnalyzerSettings analyzerSettings, IProgress <ProgressInfo> progress)
{
_model = model;
_analyzerSettings = analyzerSettings;
_progress = progress;
_sourceDirectory = new SourceDirectory(_analyzerSettings);
}
public void AnalysisConfGen_Simple()
{
// Arrange
string analysisDir = TestUtils.CreateTestSpecificFolder(this.TestContext);
TestLogger logger = new TestLogger();
ListPropertiesProvider propertyProvider = new ListPropertiesProvider();
propertyProvider.AddProperty(SonarProperties.HostUrl, "http://foo");
ProcessedArgs args = new ProcessedArgs("valid.key", "valid.name", "1.0", false, EmptyPropertyProvider.Instance, propertyProvider);
TeamBuildSettings tbSettings = TeamBuildSettings.CreateNonTeamBuildSettingsForTesting(analysisDir);
Dictionary <string, string> serverSettings = new Dictionary <string, string>();
serverSettings.Add("server.key.1", "server.value.1");
AnalyzerSettings analyzerSettings = new AnalyzerSettings();
analyzerSettings.RuleSetFilePath = "c:\\xxx.ruleset";
analyzerSettings.AdditionalFilePaths = new List <string>();
analyzerSettings.AdditionalFilePaths.Add("f:\\additionalPath1.txt");
analyzerSettings.AnalyzerAssemblyPaths = new List <string>();
analyzerSettings.AnalyzerAssemblyPaths.Add("f:\\temp\\analyzer1.dll");
List <AnalyzerSettings> analyzersSettings = new List <AnalyzerSettings>();
analyzersSettings.Add(analyzerSettings);
Directory.CreateDirectory(tbSettings.SonarConfigDirectory); // config directory needs to exist
// Act
AnalysisConfig actualConfig = AnalysisConfigGenerator.GenerateFile(args, tbSettings, serverSettings, analyzersSettings, logger);
// Assert
AssertConfigFileExists(actualConfig);
logger.AssertErrorsLogged(0);
logger.AssertWarningsLogged(0);
Assert.AreEqual("valid.key", actualConfig.SonarProjectKey);
Assert.AreEqual("valid.name", actualConfig.SonarProjectName);
Assert.AreEqual("1.0", actualConfig.SonarProjectVersion);
Assert.AreEqual("http://foo", actualConfig.SonarQubeHostUrl);
Assert.AreEqual(tbSettings.SonarBinDirectory, actualConfig.SonarBinDir);
Assert.AreEqual(tbSettings.SonarConfigDirectory, actualConfig.SonarConfigDir);
Assert.AreEqual(tbSettings.SonarOutputDirectory, actualConfig.SonarOutputDir);
Assert.AreEqual(tbSettings.SonarScannerWorkingDirectory, actualConfig.SonarScannerWorkingDirectory);
Assert.AreEqual(tbSettings.BuildUri, actualConfig.GetBuildUri());
Assert.AreEqual(tbSettings.TfsUri, actualConfig.GetTfsUri());
Assert.IsNotNull(actualConfig.ServerSettings);
Property serverProperty = actualConfig.ServerSettings.SingleOrDefault(s => string.Equals(s.Id, "server.key.1", System.StringComparison.Ordinal));
Assert.IsNotNull(serverProperty);
Assert.AreEqual("server.value.1", serverProperty.Value);
Assert.AreSame(analyzerSettings, actualConfig.AnalyzersSettings[0]);
}
public void GetAnalyzerSettings_ConfigExists_DataReturned()
{
// Arrange
var testDir = TestUtils.CreateTestSpecificFolder(TestContext);
var testSubject = new GetAnalyzerSettings();
var expectedAnalyzers = new string[] { "c:\\analyzer1.DLL", "c:\\analyzer2.dll" };
var expectedAdditionalFiles = new string[] { "c:\\add1.txt", "d:\\add2.txt" };
// SONARMSBRU-216: non-assembly files should be filtered out
var filesInConfig = new List <string>(expectedAnalyzers)
{
"c:\\not_an_assembly.exe",
"c:\\not_an_assembly.zip",
"c:\\not_an_assembly.txt",
"c:\\not_an_assembly.dll.foo",
"c:\\not_an_assembly.winmd"
};
var config = new AnalysisConfig
{
AnalyzersSettings = new List <AnalyzerSettings>()
};
var settings = new AnalyzerSettings
{
Language = "my lang",
RuleSetFilePath = "f:\\yyy.ruleset",
AnalyzerAssemblyPaths = filesInConfig,
AdditionalFilePaths = expectedAdditionalFiles.ToList()
};
config.AnalyzersSettings.Add(settings);
var anotherSettings = new AnalyzerSettings
{
Language = "cobol",
RuleSetFilePath = "f:\\xxx.ruleset",
AnalyzerAssemblyPaths = filesInConfig,
AdditionalFilePaths = expectedAdditionalFiles.ToList()
};
config.AnalyzersSettings.Add(anotherSettings);
var fullPath = Path.Combine(testDir, FileConstants.ConfigFileName);
config.Save(fullPath);
testSubject.AnalysisConfigDir = testDir;
testSubject.Language = "my lang";
// Act
ExecuteAndCheckSuccess(testSubject);
// Assert
Assert.AreEqual("f:\\yyy.ruleset", testSubject.RuleSetFilePath);
CollectionAssert.AreEquivalent(expectedAnalyzers, testSubject.AnalyzerFilePaths);
CollectionAssert.AreEquivalent(expectedAdditionalFiles, testSubject.AdditionalFiles);
}
private TaskOutputs CreateMergedAnalyzerSettings(AnalyzerSettings settings)
{
var mergedRuleset = CreateMergedRuleset(settings);
var allAnalyzers = MergeFileLists(settings.AnalyzerPlugins.SelectMany(ap => ap.AssemblyPaths), OriginalAnalyzers);
var additionalFilePaths = MergeFileLists(settings.AdditionalFilePaths, OriginalAdditionalFiles);
return(new TaskOutputs(mergedRuleset, allAnalyzers, additionalFilePaths));
}
private TaskOutputs CreateDeactivatedProjectSettings(AnalyzerSettings settings)
{
var sonarDotNetAnalyzers = settings.AnalyzerPlugins
.Where(p => this.SonarDotNetPluginKeys.Contains(p.Key, StringComparer.OrdinalIgnoreCase))
.SelectMany(p => p.AssemblyPaths);
return(new TaskOutputs(settings.DeactivatedRulesetPath, sonarDotNetAnalyzers, settings.AdditionalFilePaths));
}
/// <summary>
/// Process nested declarations.
/// </summary>
/// <param name="file">
/// The <see cref="ICSharpFile"/> to use.
/// </param>
/// <param name="typeDeclarations">
/// The type <see cref="ICSharpTypeDeclaration"/> to check.
/// </param>
/// <param name="analyzerSettings">
/// The analyzer Settings.
/// </param>
private static void ProcessNestedTypeDeclarations(ICSharpFile file, IEnumerable<ITypeDeclaration> typeDeclarations, AnalyzerSettings analyzerSettings)
{
Param.RequireNotNull(file, "file");
Param.RequireNotNull(typeDeclarations, "typeDeclarations");
foreach (ITypeDeclaration typeDeclaration in typeDeclarations)
{
CheckDeclarationDocumentation(file, typeDeclaration, analyzerSettings);
CheckClassDeclarationForParams(typeDeclaration, analyzerSettings);
foreach (ITypeMemberDeclaration memberDeclaration in typeDeclaration.MemberDeclarations)
{
CheckDeclarationDocumentation(file, memberDeclaration, analyzerSettings);
}
ProcessNestedTypeDeclarations(file, typeDeclaration.NestedTypeDeclarations, analyzerSettings);
}
}
/// <summary>
/// Inserts any missing items from the file header.
/// Also formats the existing header ensuring that the top and bottom line start with 2 slashes and a space and that a newline follows the header.
/// </summary>
/// <param name="file">
/// The file to update.
/// </param>
/// <param name="analyzerSettings">
/// The analyzer Settings.
/// </param>
private static void UpdateFileHeader(ICSharpFile file, AnalyzerSettings analyzerSettings)
{
// The idea here is to load the existing header into our FileHeader object
// The FileHeader object will ensure that the format of the header is correct even if we're not changing its contents
// Thus we'll swap it out if its changed at the end.
string fileName = file.GetSourceFile().ToProjectFile().Location.Name;
// TODO: How do we handle updating the file header?
// From the main options page?
// Actually, looks like ReplaceCopyrightElement is the best option. It fixes the filename,
// the company name and the copyright, and it'll update the summary, if it isn't already set.
UpdateFileHeaderStyle updateFileHeaderOption = UpdateFileHeaderStyle.ReplaceCopyrightElement;
if (updateFileHeaderOption == UpdateFileHeaderStyle.Ignore)
{
return;
}
Lifetimes.Using(
lifetime =>
{
DocumentationRulesConfiguration docConfig = GetDocumentationRulesConfig(lifetime, file);
string summaryText = Utils.GetSummaryText(file);
FileHeader fileHeader = new FileHeader(file) { InsertSummary = analyzerSettings.IsRuleEnabled("FileHeaderMustHaveSummary") };
switch (updateFileHeaderOption)
{
case UpdateFileHeaderStyle.ReplaceCopyrightElement:
fileHeader.FileName = fileName;
fileHeader.CompanyName = docConfig.CompanyName;
fileHeader.CopyrightText = docConfig.Copyright;
fileHeader.Summary = string.IsNullOrEmpty(fileHeader.Summary) ? summaryText : fileHeader.Summary;
break;
case UpdateFileHeaderStyle.ReplaceAll:
fileHeader.FileName = fileName;
fileHeader.CompanyName = docConfig.CompanyName;
fileHeader.CopyrightText = docConfig.Copyright;
fileHeader.Summary = summaryText;
break;
case UpdateFileHeaderStyle.InsertMissing:
fileHeader.FileName = string.IsNullOrEmpty(fileHeader.FileName) ? fileName : fileHeader.FileName;
fileHeader.CompanyName = string.IsNullOrEmpty(fileHeader.CompanyName) ? docConfig.CompanyName : fileHeader.CompanyName;
fileHeader.CopyrightText = string.IsNullOrEmpty(fileHeader.CopyrightText) ? docConfig.Copyright : fileHeader.CopyrightText;
fileHeader.Summary = string.IsNullOrEmpty(fileHeader.Summary) ? summaryText : fileHeader.Summary;
break;
}
fileHeader.Update();
});
}
/// <summary>
/// Checks declaration comment blocks.
/// </summary>
/// <param name="file">
/// The <see cref="ICSharpFile"/> to use.
/// </param>
/// <param name="declaration">
/// The <see cref="IDeclaration"/> to check.
/// </param>s
/// <param name="options">
/// <see cref="AnalyzerSettings"/>Current options that we can reference.
/// </param>
public static void CheckDeclarationDocumentation(ICSharpFile file, IDeclaration declaration, AnalyzerSettings options)
{
Param.RequireNotNull(file, "file");
Param.RequireNotNull(declaration, "declaration");
Param.Ignore(options);
bool insertMissingElementDocOption = options.IsRuleEnabled("ElementsMustBeDocumented");
bool documentationTextMustBeginWithACapitalLetter = options.IsRuleEnabled("DocumentationTextMustBeginWithACapitalLetter");
bool documentationTextMustEndWithAPeriod = options.IsRuleEnabled("DocumentationTextMustEndWithAPeriod");
bool elementDocumentationMustHaveSummary = options.IsRuleEnabled("ElementDocumentationMustHaveSummary");
bool constructorSummaryDocBeginsWithStandardText = options.IsRuleEnabled("ConstructorSummaryDocumentationMustBeginWithStandardText");
bool destructorSummaryDocBeginsWithStandardText = options.IsRuleEnabled("DestructorSummaryDocumentationMustBeginWithStandardText");
bool propertyDocumentationMustHaveValueDocumented = options.IsRuleEnabled("PropertyDocumentationMustHaveValue");
bool insertMissingParamTagOption = options.IsRuleEnabled("ElementParametersMustBeDocumented");
bool genericTypeParametersMustBeDocumented = options.IsRuleEnabled("GenericTypeParametersMustBeDocumented");
DeclarationHeader declarationHeader = new DeclarationHeader(declaration);
bool formatSummary = false;
if (insertMissingElementDocOption && !Utils.IsRuleSuppressed(declaration, StyleCopRules.SA1600) && declarationHeader.IsMissing)
{
formatSummary = InsertMissingDeclarationHeader(file, declaration);
}
if (elementDocumentationMustHaveSummary && !Utils.IsRuleSuppressed(declaration, StyleCopRules.SA1604) && !declarationHeader.HasSummary)
{
formatSummary = formatSummary | InsertMissingSummaryElement(declaration);
}
if (formatSummary)
{
FormatSummaryElement(declaration);
}
if (declaration is IConstructorDeclaration)
{
if (insertMissingParamTagOption && !Utils.IsRuleSuppressed(declaration, StyleCopRules.SA1611))
{
IConstructorDeclaration constructorDeclaration = declaration as IConstructorDeclaration;
if (constructorDeclaration.ParameterDeclarations.Count > 0)
{
InsertMissingParamElement(constructorDeclaration);
}
}
if (constructorSummaryDocBeginsWithStandardText && !Utils.IsRuleSuppressed(declaration, StyleCopRules.SA1642))
{
EnsureConstructorSummaryDocBeginsWithStandardText(declaration as IConstructorDeclaration);
}
}
Lifetimes.Using(
lifetime =>
{
DocumentationRulesConfiguration docConfig = GetDocumentationRulesConfig(lifetime, file);
// However it can be on/off depending on the file so we'd have to cache it per file
bool ruleIsEnabled = docConfig.GetStyleCopRuleEnabled("DocumentationTextMustBeginWithACapitalLetter");
if (documentationTextMustBeginWithACapitalLetter && ruleIsEnabled && !Utils.IsRuleSuppressed(declaration, StyleCopRules.SA1628))
{
EnsureDocumentationTextIsUppercase(declaration);
}
ruleIsEnabled = docConfig.GetStyleCopRuleEnabled("DocumentationTextMustEndWithAPeriod");
if (documentationTextMustEndWithAPeriod && ruleIsEnabled && !Utils.IsRuleSuppressed(declaration, StyleCopRules.SA1629))
{
EnsureDocumentationTextEndsWithAPeriod(declaration);
}
if (declaration is IDestructorDeclaration)
{
if (destructorSummaryDocBeginsWithStandardText && !Utils.IsRuleSuppressed(declaration, StyleCopRules.SA1643))
{
EnsureDestructorSummaryDocBeginsWithStandardText(declaration as IDestructorDeclaration);
}
}
if (declaration is IMethodDeclaration || declaration is IIndexerDeclaration)
{
CheckMethodAndIndexerDeclarationDocumentation(declaration as IParametersOwnerDeclaration, options);
}
if (declaration is IPropertyDeclaration)
{
ruleIsEnabled = docConfig.GetStyleCopRuleEnabled("PropertyDocumentationMustHaveValue");
if (propertyDocumentationMustHaveValueDocumented && ruleIsEnabled && !Utils.IsRuleSuppressed(declaration, StyleCopRules.SA1609))
{
InsertValueElement(declaration as IPropertyDeclaration);
}
}
if (declaration is ITypeParametersOwner && (genericTypeParametersMustBeDocumented && !Utils.IsRuleSuppressed(declaration, StyleCopRules.SA1618)))
{
InsertMissingTypeParamElement(declaration);
}
});
}
/// <summary>
/// The Execute method.
/// </summary>
/// <param name="file">
/// The file to fix
/// </param>
/// <param name="settings">
/// The settings to use in the fix.
/// </param>
public static void ExecuteAll(ICSharpFile file, Settings settings)
{
StyleCopTrace.In(file, settings);
var analyzerSettings = new AnalyzerSettings(settings, typeof(CSharp.MaintainabilityRules).FullName);
if (analyzerSettings.IsRuleEnabled("StatementMustNotUseUnnecessaryParenthesis"))
{
RemoveUnnecessaryParenthesisFromStatements(file.FirstChild);
}
StyleCopTrace.Out();
}
/// <summary>
/// Processes the given element.
/// </summary>
/// <param name="element">The element being visited.</param>
/// <param name="parentElement">The parent element, if any.</param>
/// <param name="settings">The analyzer settings.</param>
/// <returns>Returns true to continue, or false to stop the walker.</returns>
private bool CheckDocumentationForElement(
CsElement element,
CsElement parentElement,
AnalyzerSettings settings)
{
Param.AssertNotNull(element, "element");
Param.Ignore(parentElement);
Param.Ignore(settings);
if (this.Cancel)
{
return false;
}
if (!element.Generated)
{
if (element.ElementType == ElementType.Class ||
element.ElementType == ElementType.Interface ||
element.ElementType == ElementType.Struct)
{
ClassBase classElement = element as ClassBase;
Debug.Assert(classElement != null, "The element is not a class.");
this.CheckClassElementHeader(classElement, settings);
}
else if (element.ElementType == ElementType.Enum ||
element.ElementType == ElementType.Delegate ||
element.ElementType == ElementType.Event ||
element.ElementType == ElementType.Property ||
element.ElementType == ElementType.Indexer ||
element.ElementType == ElementType.Method ||
element.ElementType == ElementType.Constructor ||
element.ElementType == ElementType.Destructor ||
element.ElementType == ElementType.Field)
{
this.CheckHeader(element, settings, false);
}
if (element.ElementType == ElementType.Enum)
{
this.CheckEnumHeaders(element as Microsoft.StyleCop.CSharp.Enum, settings);
}
// Check the comments within the element, only for
// elements which contain statements.
if (element.ElementType == ElementType.Accessor ||
element.ElementType == ElementType.Constructor ||
element.ElementType == ElementType.Destructor ||
element.ElementType == ElementType.Method)
{
this.CheckElementComments(element);
}
}
return true;
}
/// <summary>
/// Implement the Execute method.
/// </summary>
/// <param name="file">
/// The file to use.
/// </param>
/// <param name="settings">
/// The settings to use.
/// </param>
public static void ExecuteAll(ICSharpFile file, Settings settings)
{
StyleCopTrace.In(file, settings);
var analyzerSettings = new AnalyzerSettings(settings, typeof(CSharp.SpacingRules).FullName);
if (analyzerSettings.IsRuleEnabled("CodeMustNotContainMultipleWhitespaceInARow"))
{
CodeMustNotContainMultipleWhitespaceInARow(file.FirstChild);
}
if (analyzerSettings.IsRuleEnabled("CommasMustBeSpacedCorrectly"))
{
CommasMustBeSpacedCorrectly(file.FirstChild);
}
if (analyzerSettings.IsRuleEnabled("SingleLineCommentsMustBeginWithSingleSpace"))
{
SingleLineCommentsMustBeginWithSingleSpace(file.FirstChild);
}
if (analyzerSettings.IsRuleEnabled("PreprocessorKeywordsMustNotBePrecededBySpace"))
{
PreprocessorKeywordsMustNotBePrecededBySpace(file.FirstChild);
}
if (analyzerSettings.IsRuleEnabled("NegativeSignsMustBeSpacedCorrectly"))
{
NegativeAndPositiveSignsMustBeSpacedCorrectly(file.FirstChild, CSharpTokenType.MINUS);
}
if (analyzerSettings.IsRuleEnabled("PositiveSignsMustBeSpacedCorrectly"))
{
NegativeAndPositiveSignsMustBeSpacedCorrectly(file.FirstChild, CSharpTokenType.PLUS);
}
StyleCopTrace.Out();
}
/// <summary>
/// Checks a class comments block for parameters.
/// </summary>
/// <param name="typeDeclaration">
/// The <see cref="ITypeDeclaration"/> to check.
/// </param>
/// <param name="analyzerSettings">
/// The <see cref="AnalyzerSettings"/> for the current analyzer.
/// </param>
private static void CheckClassDeclarationForParams(ITypeDeclaration typeDeclaration, AnalyzerSettings analyzerSettings)
{
Param.RequireNotNull(typeDeclaration, "typeDeclaration");
Param.RequireNotNull(analyzerSettings, "analyzerSettings");
if (analyzerSettings.IsRuleEnabled("ElementParametersMustBeDocumented"))
{
if (typeDeclaration.DeclaredElement != null)
{
if (typeDeclaration.DeclaredElement.TypeParameters.Count > 0)
{
InsertMissingTypeParamElement(typeDeclaration);
}
}
}
}
/// <summary>
/// Checks the Xml header block for consistency with the element it belongs to.
/// </summary>
/// <param name="element">The element to parse.</param>
/// <param name="settings">The analyzer settings.</param>
private void CheckEnumHeaders(Microsoft.StyleCop.CSharp.Enum element, AnalyzerSettings settings)
{
Param.AssertNotNull(element, "element");
Param.Ignore(settings);
foreach (EnumItem item in element.Items)
{
if (null == item.Header || item.Header.Text.Length == 0)
{
if ((!settings.IgnorePrivates || element.Declaration.AccessModifierType != AccessModifierType.Private) &&
(!settings.IgnoreInternals || element.Declaration.AccessModifierType != AccessModifierType.Internal))
{
this.AddViolation(item, Rules.EnumerationItemsMustBeDocumented);
}
}
else
{
this.ParseHeader(item, item.Header, item.LineNumber, false);
}
}
}
/// <summary>
/// Checks the contents of the documentation for the elements in the document.
/// </summary>
/// <param name="document">The document to check.</param>
private void CheckElementDocumentation(CsDocument document)
{
Param.AssertNotNull(document, "document");
// Get the settings.
AnalyzerSettings settings = new AnalyzerSettings();
settings.IgnorePrivates = DocumentationRules.IgnorePrivatesDefaultValue;
settings.IgnoreInternals = DocumentationRules.IgnoreInternalsDefaultValue;
settings.RequireFields = DocumentationRules.IncludeFieldsDefaultValue;
if (document.Settings != null)
{
BooleanProperty setting = document.Settings.GetAddInSetting(this, DocumentationRules.IgnorePrivates) as BooleanProperty;
if (setting != null)
{
settings.IgnorePrivates = setting.Value;
}
setting = document.Settings.GetAddInSetting(this, DocumentationRules.IgnoreInternals) as BooleanProperty;
if (setting != null)
{
settings.IgnoreInternals = setting.Value;
}
setting = document.Settings.GetAddInSetting(this, DocumentationRules.IncludeFieldsProperty) as BooleanProperty;
if (setting != null)
{
settings.RequireFields = setting.Value;
}
}
((CsDocument)document).WalkDocument<AnalyzerSettings>(
new CodeWalkerElementVisitor<AnalyzerSettings>(this.CheckDocumentationForElement),
settings);
}
/// <summary>
/// The Execute method.
/// </summary>
/// <param name="file">
/// The file to fix.
/// </param>
/// <param name="settings">
/// The settings to use.
/// </param>
public static void ExecuteAll(ICSharpFile file, Settings settings)
{
StyleCopTrace.In(file, settings);
var analyzerSettings = new AnalyzerSettings(settings, typeof(CSharp.LayoutRules).FullName);
if (analyzerSettings.IsRuleEnabled("SingleLineCommentMustBeProceededByBlankLine"))
{
CommentsMustBePreceededByBlankLine(file.FirstChild);
}
if (analyzerSettings.IsRuleEnabled("SingleLineCommentsMustNotBeFollowedByBlankLine"))
{
CommentsMustNotBeFollowedByBlankLine(file.FirstChild);
}
if (analyzerSettings.IsRuleEnabled("ClosingCurlyBracketMustBeFollowedByBlankLine"))
{
ClosingCurlyBracketMustBeFollowedByBlankLine(file.FirstChild);
}
if (analyzerSettings.IsRuleEnabled("WhileDoFooterMustNotBePrecededByBlankLine"))
{
WhileDoFooterMustNotBePrecededByBlankLine(file.FirstChild);
}
if (analyzerSettings.IsRuleEnabled("ChainedStatementBlocksMustNotBePrecededByBlankLine"))
{
ChainedStatementBlocksMustNotBePrecededByBlankLine(file.FirstChild);
}
if (analyzerSettings.IsRuleEnabled("OpeningCurlyBracketsMustNotBePrecededByBlankLine"))
{
OpeningCurlyBracketsMustNotBePrecededByBlankLine(file.FirstChild);
}
if (analyzerSettings.IsRuleEnabled("ElementDocumentationHeaderMustBePrecededByBlankLine"))
{
ElementDocumentationHeadersMustBePrecededByBlankLine(file.FirstChild);
}
if (analyzerSettings.IsRuleEnabled("CurlyBracketsForMultiLineStatementsMustNotShareLine"))
{
CurlyBracketsForMultiLineStatementsMustNotShareLine(file.FirstChild);
}
StyleCopTrace.Out();
}
/// <summary>
/// Checks the Xml header block for consistency with the element it belongs to.
/// </summary>
/// <param name="element">The element to parse.</param>
/// <param name="settings">The analyzer settings.</param>
private void CheckEnumHeaders(StyleCop.CSharp.CodeModel.Enum element, AnalyzerSettings settings)
{
Param.AssertNotNull(element, "element");
Param.Ignore(settings);
foreach (EnumItem item in element.Items)
{
ElementHeader header = item.Header;
if (header == null || header.IsEmpty)
{
if ((!settings.IgnorePrivates || element.AccessModifierType != AccessModifierType.Private) &&
(!settings.IgnoreInternals || element.AccessModifierType != AccessModifierType.Internal))
{
this.AddViolation(item, Rules.EnumerationItemsMustBeDocumented);
}
}
else
{
this.ParseHeader(item, header, item.LineNumber, false);
}
}
}
/// <summary>
/// Checks the contents of the documentation for the elements in the document.
/// </summary>
/// <param name="document">The document to check.</param>
private void CheckElementDocumentation(CsDocument document)
{
Param.AssertNotNull(document, "document");
// Get the settings.
AnalyzerSettings settings = new AnalyzerSettings();
settings.IgnorePrivates = DocumentationRules.IgnorePrivatesDefaultValue;
settings.IgnoreInternals = DocumentationRules.IgnoreInternalsDefaultValue;
settings.RequireFields = DocumentationRules.IncludeFieldsDefaultValue;
BooleanProperty setting = this.GetSetting(document, DocumentationRules.IgnorePrivates) as BooleanProperty;
if (setting != null)
{
settings.IgnorePrivates = setting.Value;
}
setting = this.GetSetting(document, DocumentationRules.IgnoreInternals) as BooleanProperty;
if (setting != null)
{
settings.IgnoreInternals = setting.Value;
}
setting = this.GetSetting(document, DocumentationRules.IncludeFieldsProperty) as BooleanProperty;
if (setting != null)
{
settings.RequireFields = setting.Value;
}
for (Element element = document.FindFirstDescendentElement(); element != null; element = element.FindNextDescendentElementOf(document))
{
if (this.Cancel)
{
break;
}
this.CheckDocumentationForElement(element, settings);
}
}
private static void CompareAnalyzerSettings(AnalyzerSettings expected, AnalyzerSettings actual)
{
if (expected == null)
{
Assert.IsNull(actual, "Expecting the reloaded analyzer settings to be null");
return;
}
Assert.IsNotNull(actual, "Not expecting the actual analyzer settings to be null for a reloaded file");
Assert.AreEqual(expected.RuleSetFilePath, actual.RuleSetFilePath, "Unexpected Ruleset value");
CollectionAssert.AreEqual(expected.AnalyzerAssemblyPaths, actual.AnalyzerAssemblyPaths, "Analyzer assembly paths do not match");
CollectionAssert.AreEqual(expected.AdditionalFilePaths, actual.AdditionalFilePaths, "Additional file paths do not match");
}
/// <summary>
/// Checks method comment blocks.
/// </summary>
/// <param name="methodDeclaration">
/// The method <see cref="IDeclaration"/> to check.
/// </param>
/// <param name="options">
/// The options.
/// </param>
private static void CheckMethodAndIndexerDeclarationDocumentation(IParametersOwnerDeclaration methodDeclaration, AnalyzerSettings options)
{
Param.Ignore(options);
if (methodDeclaration == null)
{
return;
}
bool insertMissingParamTagOption = options.IsRuleEnabled("ElementParametersMustBeDocumented");
bool insertMissingReturnTagOption = options.IsRuleEnabled("ElementReturnValueMustBeDocumented");
bool removeReturnTagOnVoidElementsOption = options.IsRuleEnabled("VoidReturnValueMustNotBeDocumented");
if (insertMissingParamTagOption && !Utils.IsRuleSuppressed(methodDeclaration, StyleCopRules.SA1611))
{
if (methodDeclaration.ParameterDeclarations.Count > 0)
{
InsertMissingParamElement(methodDeclaration);
}
}
if (methodDeclaration.DeclaredElement == null)
{
return;
}
DeclaredTypeFromCLRName declaredTypeFromClrName = methodDeclaration.DeclaredParametersOwner.ReturnType as DeclaredTypeFromCLRName;
if (removeReturnTagOnVoidElementsOption && !Utils.IsRuleSuppressed(methodDeclaration, StyleCopRules.SA1617))
{
// Remove the <returns> if the return type is void
if (declaredTypeFromClrName != null && declaredTypeFromClrName.GetClrName().FullName == "System.Void")
{
RemoveReturnsElement(methodDeclaration as ITypeMemberDeclaration);
}
}
if (insertMissingReturnTagOption && !Utils.IsRuleSuppressed(methodDeclaration, StyleCopRules.SA1615))
{
// Insert the <returns> if the return type is not void and it was missing
if ((declaredTypeFromClrName != null && declaredTypeFromClrName.GetClrName().FullName != "System.Void") || declaredTypeFromClrName == null)
{
InsertReturnsElement(methodDeclaration as ITypeMemberDeclaration, Utils.GetXmlPresentableName(methodDeclaration.DeclaredParametersOwner.ReturnType));
}
}
}
/// <summary>
/// Checks the Xml header block for consistency with the element it belongs to.
/// </summary>
/// <param name="element">The element to parse.</param>
/// <param name="settings">The analyzer settings.</param>
/// <param name="partialElement">Indicates whether the element has the partial attribute.</param>
private void CheckHeader(CsElement element, AnalyzerSettings settings, bool partialElement)
{
Param.AssertNotNull(element, "element");
Param.Ignore(settings);
Param.Ignore(partialElement);
// See whether this element has a header at all.
if (null == element.Header || element.Header.Text.Length == 0)
{
// Empty or missing header is a violation if:
// 1. The element is a class, interface, or struct
// 2. The element is a field and the RequireFields flag is set
// 3. The element is not private, or the element is private but the IgnorePrivates flag is not set
// 4. The element is not internal, or the element is internal but the IgnoreInternals flag is not set
if ((element.ElementType == ElementType.Class || element.ElementType == ElementType.Interface || element.ElementType == ElementType.Struct) ||
((settings.RequireFields || element.ElementType != ElementType.Field) &&
(!settings.IgnorePrivates || element.Declaration.AccessModifierType != AccessModifierType.Private) &&
(!settings.IgnoreInternals || element.Declaration.AccessModifierType != AccessModifierType.Internal)))
{
if (partialElement)
{
this.AddViolation(element, Rules.PartialElementsMustBeDocumented, element.FriendlyTypeText);
}
else
{
// We do not require headers for non-public static extern methods.
if (!IsNonPublicStaticExternDllImport(element))
{
this.AddViolation(element, Rules.ElementsMustBeDocumented, element.FriendlyTypeText);
}
}
}
}
else
{
this.ParseHeader(element, element.Header, element.LineNumber, partialElement);
}
}
/// <summary>
/// Checks the Xml header block of the given class for consistency with the class.
/// </summary>
/// <param name="classElement">The element to parse.</param>
/// <param name="settings">The analyzer settings.</param>
private void CheckClassElementHeader(ClassBase classElement, AnalyzerSettings settings)
{
Param.AssertNotNull(classElement, "classElement");
Param.Ignore(settings);
AnalyzerSettings adjustedSettings = settings;
adjustedSettings.RequireFields = false;
if (classElement.Declaration.ContainsModifier(CsTokenType.Partial))
{
// This is a partial element. Check for the possible partial element header types.
this.CheckHeader(classElement, adjustedSettings, true);
}
else
{
// Just perform the regular set of checks on the header.
this.CheckHeader(classElement, adjustedSettings, false);
}
}
/// <summary>
/// Checks the Xml header block of the given class for consistency with the class.
/// </summary>
/// <param name="classElement">
/// The element to parse.
/// </param>
/// <param name="settings">
/// The analyzer settings.
/// </param>
private void CheckClassElementHeader(ClassBase classElement, AnalyzerSettings settings)
{
Param.AssertNotNull(classElement, "classElement");
Param.Ignore(settings);
AnalyzerSettings adjustedSettings = settings;
adjustedSettings.RequireFields = false;
this.CheckHeader(classElement, adjustedSettings, classElement.Declaration.ContainsModifier(CsTokenType.Partial));
}
/// <summary>
/// Executes the cleanup rules.
/// </summary>
/// <param name="file">
/// The file to process.
/// </param>
/// <param name="settings">
/// The merged settings for the given file
/// </param>
public static void ExecuteAll(ICSharpFile file, Settings settings)
{
StyleCopTrace.In(file);
var analyzerSettings = new AnalyzerSettings(settings, typeof(CSharp.ReadabilityRules).FullName);
if (analyzerSettings.IsRuleEnabled("DoNotPlaceRegionsWithinElements"))
{
DoNotPlaceRegionsWithinElements(file.FirstChild);
}
if (analyzerSettings.IsRuleEnabled("BlockStatementsMustNotContainEmbeddedComments"))
{
BlockStatementsMustNotContainEmbeddedComments(file.FirstChild);
}
if (analyzerSettings.IsRuleEnabled("BlockStatementsMustNotContainEmbeddedRegions"))
{
BlockStatementsMustNotContainEmbeddedRegions(file.FirstChild);
}
if (analyzerSettings.IsRuleEnabled("CodeMustNotContainEmptyStatements"))
{
CodeMustNotContainEmptyStatements(file.FirstChild);
}
if (analyzerSettings.IsRuleEnabled("CodeMustNotContainEmptyRegions"))
{
CodeMustNotContainEmptyRegions(file.FirstChild);
}
if (analyzerSettings.IsRuleEnabled("UseStringEmptyForEmptyStrings"))
{
ReplaceEmptyStringsWithStringDotEmpty(file.FirstChild);
}
if (analyzerSettings.IsRuleEnabled("UseBuiltInTypeAlias"))
{
SwapToBuiltInTypeAlias(file.FirstChild);
}
if (analyzerSettings.IsRuleEnabled("CommentsMustContainText"))
{
RemoveEmptyComments(file.FirstChild);
}
if (analyzerSettings.IsRuleEnabled("DoNotPrefixCallsWithBaseUnlessLocalImplementationExists"))
{
DoNotPrefixCallsWithBaseUnlessLocalImplementationExists(file.FirstChild);
}
StyleCopTrace.Out();
}
