private static int GetNumberOfCrossReferences(AnalyzerLanguage language) { return RuleDetailBuilder.GetParameterlessRuleDetails(language) .Select(rule => rule.Description) .Select(description => Regex.Matches(description, RuleImplementationMeta.CrosslinkPattern).Count) .Sum(); }
public IEnumerable<Type> GetParameterlessAnalyzerTypes(AnalyzerLanguage language) { return diagnosticAnalyzers .Where(analyzerType => !analyzerType.GetProperties() .Any(p => p.GetCustomAttributes<RuleParameterAttribute>().Any())) .Where(type => GetTargetLanguages(type).IsAlso(language)); }
public static Solution GetSolutionWithEmptyFile(AnalyzerLanguage language) { using (var workspace = new AdhocWorkspace()) { var lang = language == AnalyzerLanguage.CSharp ? LanguageNames.CSharp : LanguageNames.VisualBasic; return workspace.CurrentSolution.AddProject("foo", "foo.dll", lang) .AddMetadataReference(SystemMetadataReference) .AddDocument($"foo.{language.GetFileExtension()}", string.Empty) .Project .Solution; } }
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); }
private static void CheckRuleDescriptorsNotEmpty(AnalyzerLanguage language) { var ruleDetails = RuleDetailBuilder.GetAllRuleDetails(language).ToList(); foreach (var ruleDetail in ruleDetails) { Assert.IsNotNull(ruleDetail); Assert.IsNotNull(ruleDetail.Description); Assert.IsNotNull(ruleDetail.Key); Assert.IsNotNull(ruleDetail.Title); } Assert.AreEqual(ruleDetails.Count, ruleDetails.Select(descriptor => descriptor.Key).Distinct().Count()); }
public static RuleImplementationMeta Convert(RuleDetail detail, string productVersion, AnalyzerLanguage language) { return new RuleImplementationMeta { Id = detail.Key, Language = language.GetFriendlyName(), Severity = detail.Severity, Title = detail.Title, Description = GetParameterDescription(detail.Parameters) + AddLinksBetweenRulesToDescription(detail.Description, productVersion) + GetCodeFixDescription(detail), Tags = detail.Tags }; }
public bool IsAlso(AnalyzerLanguage other) { if (other == null) { throw new ArgumentNullException(nameof(other)); } if (other == None) { throw new NotSupportedException("IsAlso doesn't support AnalyzerLanguage.None."); } return this == other || this == Both; }
public static Solution GetSolutionFromFiles(string filePath, AnalyzerLanguage language) { using (var workspace = new AdhocWorkspace()) { var file = new FileInfo(filePath); var lang = language == AnalyzerLanguage.CSharp ? LanguageNames.CSharp : LanguageNames.VisualBasic; var project = workspace.CurrentSolution.AddProject("foo", "foo.dll", lang) .AddMetadataReference(SystemMetadataReference); var document = project.AddDocument(file.Name, File.ReadAllText(file.FullName, Encoding.UTF8)); project = document.Project; return project.Solution; } }
public AnalyzerLanguage AddLanguage(AnalyzerLanguage other) { if (other == null) { throw new ArgumentNullException(nameof(other)); } if (this == None || this == other) { return other; } return Both; }
public Configuration(string path, AnalyzerLanguage language) { if (!ParameterLoader.ConfigurationFilePathMatchesExpected(path)) { throw new ArgumentException( $"Input configuration doesn't match expected file name: '{ParameterLoader.ParameterConfigurationFileName}'", nameof(path)); } Path = path; analyzers = ImmutableArray.Create(GetAnalyzers(language).ToArray()); var xml = XDocument.Load(path); var settings = ParseSettings(xml); IgnoreHeaderComments = "true".Equals(settings[$"sonar.{language}.ignoreHeaderComments"], StringComparison.OrdinalIgnoreCase); Files = xml.Descendants("File").Select(e => e.Value).ToImmutableList(); AnalyzerIds = xml.Descendants("Rule").Select(e => e.Elements("Key").Single().Value).ToImmutableHashSet(); }
private static RuleDetail GetRuleDetail(Type analyzerType, AnalyzerLanguage language) { var rule = analyzerType.GetCustomAttributes<RuleAttribute>().Single(); var ruleDetail = new RuleDetail { Key = rule.Key, Title = rule.Title, Severity = rule.Severity.ToString(), IsActivatedByDefault = rule.IsActivatedByDefault, Description = GetResourceHtml(rule, language) }; GetParameters(analyzerType, ruleDetail); GetTags(analyzerType, ruleDetail); GetSqale(analyzerType, ruleDetail); GetCodeFixNames(analyzerType, ruleDetail); return ruleDetail; }
public static RuleDescription Convert(RuleDetail detail, string productVersion, AnalyzerLanguage language) { return new RuleDescription { Key = detail.Key, Data = new Dictionary<string, RuleMetaData> { { language.ToString(), new RuleMetaData { Title = detail.Title, Description = GetParameterDescription(detail.Parameters) + AddLinksBetweenRulesToDescription(detail.Description, productVersion) + GetCodeFixDescription(detail), Tags = detail.Tags, Severity = detail.Severity, IdeSeverity = detail.IdeSeverity } } } }; }
public Configuration(XContainer xml, AnalyzerLanguage language) { this.language = language; nonTemplateAnalyzers = ImmutableArray.Create(GetNonTemplateAnalyzers(language).ToArray()); var settings = ParseSettings(xml); IgnoreHeaderComments = "true".Equals(settings["sonar.cs.ignoreHeaderComments"]); Files = xml.Descendants("File").Select(e => e.Value).ToImmutableList(); AnalyzerIds = xml.Descendants("Rule").Select(e => e.Elements("Key").Single().Value).ToImmutableHashSet(); var builder = ImmutableList.CreateBuilder<RuleParameterValues>(); foreach (var rule in xml.Descendants("Rule").Where(e => e.Elements("Parameters").Any())) { var analyzerId = rule.Elements("Key").Single().Value; var parameterValues = rule .Elements("Parameters").Single() .Elements("Parameter") .Select(e => new RuleParameterValue { ParameterKey = e.Elements("Key").Single().Value, ParameterValue = e.Elements("Value").Single().Value }); var pvs = new RuleParameterValues { RuleId = analyzerId }; pvs.ParameterValues.AddRange(parameterValues); builder.Add(pvs); } parameters = builder.ToImmutable(); }
private static int Lines(AnalyzerLanguage language, string text) => MetricsFor(language, text).LineCount;
private static Distribution FunctionComplexityDistribution(AnalyzerLanguage language, string text) => MetricsFor(language, text).FunctionComplexityDistribution;
private static int Classes(AnalyzerLanguage language, string text) => MetricsFor(language, text).ClassCount;
private static IImmutableSet<int> LinesOfCode(AnalyzerLanguage language, string text) { return MetricsFor(language, text).GetLinesOfCode(); }
private static int Lines(AnalyzerLanguage language, string text) { return MetricsFor(language, text).GetLineCount(); }
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 int Accessors(AnalyzerLanguage language, string text) => MetricsFor(language, text).AccessorCount;
private static int PublicUndocumentedApi(AnalyzerLanguage language, string text) => MetricsFor(language, text).PublicUndocumentedApiCount;
private static int Functions(AnalyzerLanguage language, string text) => MetricsFor(language, text).FunctionCount;
private static string GetResourceHtml(Type analyzerType, RuleAttribute rule, AnalyzerLanguage language) { var resources = SonarLintExtraAssembly.GetManifestResourceNames(); var resource = GetResource(resources, rule.Key, language); if (resource == null) { throw new InvalidDataException(string.Format("Could not locate resource for rule {0}", rule.Key)); } using (var stream = SonarLintExtraAssembly.GetManifestResourceStream(resource)) using (var reader = new StreamReader(stream)) { return reader.ReadToEnd(); } }
private static int Complexity(AnalyzerLanguage language, string text) => MetricsFor(language, text).Complexity;
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(nameof(language)); }
private static MetricsBase MetricsFor(AnalyzerLanguage language, string text) { if (language != AnalyzerLanguage.CSharp && language != AnalyzerLanguage.VisualBasic) { throw new ArgumentException("Supplied language is not C# neither VB.Net", nameof(language)); } return language == AnalyzerLanguage.CSharp ? (MetricsBase)new SonarLint.Common.CSharp.Metrics(CSharpSyntaxTree.ParseText(text)) : new SonarLint.Common.VisualBasic.Metrics(VisualBasicSyntaxTree.ParseText(text)); }
public static IEnumerable<RuleDetail> GetParameterlessRuleDetails(AnalyzerLanguage language) { return new RuleFinder().GetParameterlessAnalyzerTypes(language).Select(t => GetRuleDetail(t, language)); }
private static IImmutableSet<int> LinesOfCode(AnalyzerLanguage language, string text) => MetricsFor(language, text).LinesOfCode;
public static IEnumerable<DiagnosticAnalyzer> GetAnalyzers(AnalyzerLanguage language) { return new RuleFinder().GetAnalyzerTypes(language) .Select(type => (DiagnosticAnalyzer) Activator.CreateInstance(type)); }