private static PropertyAccessContext CreateContext <TSyntaxNodeType>(string testInput, string propertyName, AnalyzerLanguage language) where TSyntaxNodeType : SyntaxNode
{
var testCode = new SnippetCompiler(testInput, false, language);
var expression = testCode.GetNodes <TSyntaxNodeType>().First();
return(new PropertyAccessContext(expression, propertyName, testCode.SemanticModel));
}
private static FileComments CommentsWithHeaders(AnalyzerLanguage language, string text)
{
return(MetricsFor(language, text).GetComments(false));
}
private static int Statements(AnalyzerLanguage language, string text) => MetricsFor(language, text).StatementCount;
private static ICollection <int> ExecutableLines(AnalyzerLanguage language, string text) => MetricsFor(language, text).ExecutableLines;
public QualityProfileRoot(AnalyzerLanguage language)
{
Rules = new List <QualityProfileRuleDescriptor>();
Language = language.ToString();
Name = "Sonar way";
}
private static int PublicUndocumentedApi(AnalyzerLanguage language, string text) => MetricsFor(language, text).PublicUndocumentedApiCount;
private static int Lines(AnalyzerLanguage language, string text) => MetricsFor(language, text).LineCount;
private static void WriteQualityProfileFile(string filePath, IEnumerable <RuleDetail> ruleDetails, AnalyzerLanguage language)
{
var root = new QualityProfileRoot(language);
root.Rules.AddRange(ruleDetails
.Where(descriptor => descriptor.IsActivatedByDefault)
.Select(descriptor => new QualityProfileRuleDescriptor(language)
{
Key = descriptor.Key
}));
SerializeObjectToFile(filePath, root);
}
public static IEnumerable <RuleDetail> GetAllRuleDetails(AnalyzerLanguage language)
{
return(new RuleFinder().GetAnalyzerTypes(language).Select(t => GetRuleDetail(t, language)));
}
public void AnalyzerLanguage_Parse_Fail()
{
var parsed = AnalyzerLanguage.Parse("csharp");
parsed.Should().Be(AnalyzerLanguage.CSharp);
}
private static ObjectCreationContext CreateContext <TSyntaxNodeType>(string testInput, AnalyzerLanguage language) where TSyntaxNodeType : SyntaxNode
{
var testCode = new SnippetCompiler(testInput, true, language);
var node = testCode.GetNodes <TSyntaxNodeType>().First();
var context = new ObjectCreationContext(testCode.CreateAnalysisContext(node));
return(context);
}
private static Document CreateDocument(string path, IEnumerable <MetadataReference> additionalReferences) => SolutionBuilder.Create() .AddProject(AnalyzerLanguage.FromPath(path)) .AddReferences(additionalReferences) .AddDocument(path, true) .FindDocument(Path.GetFileName(path));
private static IEnumerable <DiagnosticDescriptor> GetSupportedDiagnostics(AnalyzerLanguage language) => new RuleFinder() .GetAnalyzerTypes(language) .SelectMany(type => GetSupportedDiagnostics(type));
public ProjectBuilder AddProject(AnalyzerLanguage language, bool createExtraEmptyFile = true)
{
return(AddProject(language, $"{GeneratedAssemblyName}{ProjectIds.Count}", createExtraEmptyFile));
}
private static RuleDetail GetRuleDetail(RuleAttribute rule, Type analyzerType, AnalyzerLanguage language)
{
var resources = new ResourceManager("SonarAnalyzer.RspecStrings", analyzerType.Assembly);
var ruleDetail = new RuleDetail
{
Key = rule.Key,
Type = GetBackwardsCompatibleType(resources.GetString($"{rule.Key}_Type")),
Title = resources.GetString($"{rule.Key}_Title"),
Severity = resources.GetString($"{rule.Key}_Severity"),
IsActivatedByDefault = bool.Parse(resources.GetString($"{rule.Key}_IsActivatedByDefault")),
Description = GetResourceHtml(rule, language),
Remediation = ToSonarQubeRemediationFunction(resources.GetString($"{rule.Key}_Remediation")),
RemediationCost = resources.GetString($"{rule.Key}_RemediationCost")
};
ruleDetail.Tags.AddRange(resources.GetString($"{rule.Key}_Tags").Split(new[] { ',' },
StringSplitOptions.RemoveEmptyEntries));
GetParameters(analyzerType, ruleDetail);
GetCodeFixNames(analyzerType, ruleDetail);
return(ruleDetail);
}
public QualityProfileRuleDescriptor(AnalyzerLanguage language)
{
RepositoryKey = language.RepositoryKey;
}
public IEnumerable <Type> GetAnalyzerTypes(AnalyzerLanguage language)
{
return(diagnosticAnalyzers
.Where(type => GetTargetLanguages(type).IsAlso(language)));
}
private static FieldAccessContext CreateContext <TSyntaxNodeType>(string testInput, string fieldName, AnalyzerLanguage language) where TSyntaxNodeType : SyntaxNode
{
var testCode = new SnippetCompiler(testInput, true, language);
var node = testCode.GetNodes <TSyntaxNodeType>().First(x => x.ToString() == fieldName);
return(new FieldAccessContext(testCode.CreateAnalysisContext(node), fieldName));
}
private static int Complexity(AnalyzerLanguage language, string text) => MetricsFor(language, text).Complexity;
private static void CheckLanguageSpecificParameterlessRuleDescriptorsHaveRuleId(AnalyzerLanguage language) => new RuleFinder().GetParameterlessAnalyzerTypes(language) .Any(at => !at.GetCustomAttributes <RuleAttribute>().Any()) .Should() .BeFalse();
private static Distribution FunctionComplexityDistribution(AnalyzerLanguage language, string text) => MetricsFor(language, text).FunctionComplexityDistribution;
private static InvocationContext CreateContext <TSyntaxNodeType>(string testInput, string methodName, AnalyzerLanguage language, int skip = 0) where TSyntaxNodeType : SyntaxNode
{
var testCode = new SnippetCompiler(testInput, true, language);
var invocationSyntaxNode = testCode.GetNodes <TSyntaxNodeType>().Skip(skip).First();
var context = new InvocationContext(invocationSyntaxNode, methodName, testCode.SemanticModel);
return(context);
}
private static ISet <int> LinesOfCode(AnalyzerLanguage language, string text) => MetricsFor(language, text).CodeLines;
private static string GetResource(IEnumerable <string> resources, string key, AnalyzerLanguage language)
{
if (language == AnalyzerLanguage.CSharp)
{
return(resources.FirstOrDefault(r =>
r.EndsWith(string.Format(CultureInfo.InvariantCulture, RuleDescriptionPathPattern, key),
StringComparison.OrdinalIgnoreCase) ||
r.EndsWith(string.Format(CultureInfo.InvariantCulture, RuleDescriptionPathPattern, key + "_cs"),
StringComparison.OrdinalIgnoreCase)));
}
if (language == AnalyzerLanguage.VisualBasic)
{
return(resources.FirstOrDefault(r =>
r.EndsWith(string.Format(CultureInfo.InvariantCulture, RuleDescriptionPathPattern, key),
StringComparison.OrdinalIgnoreCase) ||
r.EndsWith(string.Format(CultureInfo.InvariantCulture, RuleDescriptionPathPattern, key + "_vb"),
StringComparison.OrdinalIgnoreCase)));
}
throw new ArgumentException("Language needs to be either C# or VB.NET", nameof(language));
}
private static ElementAccessContext CreateContext <TSyntaxNodeType>(string testInput, int skip, AnalyzerLanguage language) where TSyntaxNodeType : SyntaxNode
{
var testCode = new SnippetCompiler(testInput, true, language);
var node = testCode.GetNodes <TSyntaxNodeType>().Skip(skip).First();
var context = new ElementAccessContext(testCode.CreateAnalysisContext(node));
return(context);
}
public static IEnumerable <RuleDetail> GetParameterlessRuleDetails(AnalyzerLanguage language)
{
return(new RuleFinder()
.GetParameterlessAnalyzerTypes(language)
.SelectMany(t => GetRuleDetailFromRuleAttributes(t, language)));
}
private static int Classes(AnalyzerLanguage language, string text) => MetricsFor(language, text).ClassCount;
private static IEnumerable <RuleDetail> GetRuleDetailFromRuleAttributes(Type analyzerType,
AnalyzerLanguage language)
{
return(analyzerType.GetCustomAttributes <RuleAttribute>()
.Select(ruleAttribute => GetRuleDetail(ruleAttribute, analyzerType, language)));
}
private static int Functions(AnalyzerLanguage language, string text) => MetricsFor(language, text).FunctionCount;
public ProjectBuilder AddProject(AnalyzerLanguage language, bool createExtraEmptyFile = true, OutputKind outputKind = OutputKind.DynamicallyLinkedLibrary) =>
AddProject(language, $"{GeneratedAssemblyName}{ProjectIds.Count}", createExtraEmptyFile, outputKind);
