Add new namingRules property - allowedNamespaceComponentTerms

jedidja · jedidja · commit b66a00c6e4f7 · 2019-08-27T05:36:19.000-04:00
diff --git a/StyleCop.Analyzers/StyleCop.Analyzers.Test/NamingRules/SA1300UnitTests.cs b/StyleCop.Analyzers/StyleCop.Analyzers.Test/NamingRules/SA1300UnitTests.cs
@@ -44,6 +44,31 @@ public async Task TestLowerCaseNamespaceAsync()
             await VerifyCSharpFixAsync(testCode, expected, fixedCode, CancellationToken.None).ConfigureAwait(false);
         }
 
+        [Fact]
+        public async Task TestAllowedLowerCaseNamespaceIsNotReportedAsync()
+        {
+            var customTestSettings = @"
+{
+  ""settings"": {
+    ""namingRules"": {
+      ""allowedNamespaceComponentTerms"": [ ""eBay"" ]
+    }
+  }
+}
+";
+
+            var testCode = @"namespace eBay
+{ 
+
+}";
+
+            await new CSharpTest
+            {
+                TestCode = testCode,
+                Settings = customTestSettings,
+            }.RunAsync(CancellationToken.None).ConfigureAwait(false);
+        }
+
         [Fact]
         public async Task TestLowerCaseComlicatedNamespaceAsync()
         {
@@ -67,6 +92,31 @@ public async Task TestLowerCaseComlicatedNamespaceAsync()
             await VerifyCSharpFixAsync(testCode, expected, fixedCode, CancellationToken.None).ConfigureAwait(false);
         }
 
+        [Fact]
+        public async Task TestAllowedLowerCaseComplicatedNamespaceIsNotReportedAsync()
+        {
+            var customTestSettings = @"
+{
+  ""settings"": {
+    ""namingRules"": {
+      ""allowedNamespaceComponentTerms"": [ ""iPod"" ]
+    }
+  }
+}
+";
+
+            var testCode = @"namespace Apple.iPod.Library
+{ 
+
+}";
+
+            await new CSharpTest
+            {
+                TestCode = testCode,
+                Settings = customTestSettings,
+            }.RunAsync(CancellationToken.None).ConfigureAwait(false);
+        }
+
         [Fact]
         public async Task TestUpperCaseClassAsync()
         {
diff --git a/StyleCop.Analyzers/StyleCop.Analyzers.Test/Settings/SettingsUnitTests.cs b/StyleCop.Analyzers/StyleCop.Analyzers.Test/Settings/SettingsUnitTests.cs
@@ -29,6 +29,7 @@ public void VerifySettingsDefaults()
             Assert.Equal("Copyright (c) PlaceholderCompany. All rights reserved.", styleCopSettings.DocumentationRules.GetCopyrightText("unused"));
             Assert.True(styleCopSettings.NamingRules.AllowCommonHungarianPrefixes);
             Assert.Empty(styleCopSettings.NamingRules.AllowedHungarianPrefixes);
+            Assert.Empty(styleCopSettings.NamingRules.AllowedNamespaceComponentTerms);
 
             Assert.NotNull(styleCopSettings.OrderingRules);
             Assert.Equal(UsingDirectivesPlacement.InsideNamespace, styleCopSettings.OrderingRules.UsingDirectivesPlacement);
@@ -61,6 +62,7 @@ public async Task VerifySettingsAreReadCorrectlyAsync()
     ""namingRules"": {
       ""allowCommonHungarianPrefixes"": false,
       ""allowedHungarianPrefixes"": [""a"", ""ab"", ""ignoredTooLong""],
+      ""allowedNamespaceComponentTerms"": [""eBay"", ""iMac""],
       ""unrecognizedValue"": 3
     },
     ""layoutRules"": {
@@ -93,6 +95,7 @@ public async Task VerifySettingsAreReadCorrectlyAsync()
             Assert.Equal("ru-RU", styleCopSettings.DocumentationRules.DocumentationCulture);
             Assert.False(styleCopSettings.NamingRules.AllowCommonHungarianPrefixes);
             Assert.Equal(new[] { "a", "ab" }, styleCopSettings.NamingRules.AllowedHungarianPrefixes);
+            Assert.Equal(new[] { "eBay", "iMac" }, styleCopSettings.NamingRules.AllowedNamespaceComponentTerms);
 
             Assert.NotNull(styleCopSettings.LayoutRules);
             Assert.Equal(OptionSetting.Require, styleCopSettings.LayoutRules.NewlineAtEndOfFile);
diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/NamingRules/SA1300ElementMustBeginWithUpperCaseLetter.cs b/StyleCop.Analyzers/StyleCop.Analyzers/NamingRules/SA1300ElementMustBeginWithUpperCaseLetter.cs
@@ -12,6 +12,7 @@ namespace StyleCop.Analyzers.NamingRules
     using Microsoft.CodeAnalysis.Diagnostics;
     using StyleCop.Analyzers.Helpers;
     using StyleCop.Analyzers.Lightup;
+    using StyleCop.Analyzers.Settings.ObjectModel;
 
     /// <summary>
     /// The name of a C# element does not begin with an upper-case letter.
@@ -45,7 +46,7 @@ internal class SA1300ElementMustBeginWithUpperCaseLetter : DiagnosticAnalyzer
         private static readonly DiagnosticDescriptor Descriptor =
             new DiagnosticDescriptor(DiagnosticId, Title, MessageFormat, AnalyzerCategory.NamingRules, DiagnosticSeverity.Warning, AnalyzerConstants.EnabledByDefault, Description, HelpLink);
 
-        private static readonly Action<SyntaxNodeAnalysisContext> NamespaceDeclarationAction = HandleNamespaceDeclaration;
+        private static readonly Action<SyntaxNodeAnalysisContext, StyleCopSettings> NamespaceDeclarationAction = HandleNamespaceDeclaration;
         private static readonly Action<SyntaxNodeAnalysisContext> ClassDeclarationAction = HandleClassDeclaration;
         private static readonly Action<SyntaxNodeAnalysisContext> EnumDeclarationAction = HandleEnumDeclaration;
         private static readonly Action<SyntaxNodeAnalysisContext> EnumMemberDeclarationAction = HandleEnumMemberDeclaration;
@@ -82,13 +83,13 @@ public override void Initialize(AnalysisContext context)
             context.RegisterSyntaxNodeAction(PropertyDeclarationAction, SyntaxKind.PropertyDeclaration);
         }
 
-        private static void HandleNamespaceDeclaration(SyntaxNodeAnalysisContext context)
+        private static void HandleNamespaceDeclaration(SyntaxNodeAnalysisContext context, StyleCopSettings settings)
         {
             NameSyntax nameSyntax = ((NamespaceDeclarationSyntax)context.Node).Name;
-            CheckNameSyntax(context, nameSyntax);
+            CheckNameSyntax(context, nameSyntax, settings);
         }
 
-        private static void CheckNameSyntax(SyntaxNodeAnalysisContext context, NameSyntax nameSyntax)
+        private static void CheckNameSyntax(SyntaxNodeAnalysisContext context, NameSyntax nameSyntax, StyleCopSettings settings)
         {
             if (nameSyntax == null || nameSyntax.IsMissing)
             {
@@ -97,12 +98,13 @@ private static void CheckNameSyntax(SyntaxNodeAnalysisContext context, NameSynta
 
             if (nameSyntax is QualifiedNameSyntax qualifiedNameSyntax)
             {
-                CheckNameSyntax(context, qualifiedNameSyntax.Left);
-                CheckNameSyntax(context, qualifiedNameSyntax.Right);
+                CheckNameSyntax(context, qualifiedNameSyntax.Left, settings);
+                CheckNameSyntax(context, qualifiedNameSyntax.Right, settings);
                 return;
             }
 
-            if (nameSyntax is SimpleNameSyntax simpleNameSyntax)
+            if (nameSyntax is SimpleNameSyntax simpleNameSyntax &&
+                !settings.NamingRules.AllowedNamespaceComponentTerms.Contains(simpleNameSyntax.Identifier.ValueText))
             {
                 CheckElementNameToken(context, simpleNameSyntax.Identifier);
                 return;
diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Settings/ObjectModel/NamingSettings.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Settings/ObjectModel/NamingSettings.cs
@@ -3,7 +3,9 @@
 
 namespace StyleCop.Analyzers.Settings.ObjectModel
 {
+    using System.Collections.Generic;
     using System.Collections.Immutable;
+    using System.Linq;
     using System.Text.RegularExpressions;
     using LightJson;
 
@@ -14,13 +16,19 @@ internal class NamingSettings
         /// </summary>
         private readonly ImmutableArray<string>.Builder allowedHungarianPrefixes;
 
+        /// <summary>
+        /// This is the backing field for the <see cref="AllowedNamespaceComponentTerms"/> property.
+        /// </summary>
+        private readonly ImmutableArray<string>.Builder allowedNamespaceComponentTerms;
+
         /// <summary>
         /// Initializes a new instance of the <see cref="NamingSettings"/> class.
         /// </summary>
         protected internal NamingSettings()
         {
             this.AllowCommonHungarianPrefixes = true;
             this.allowedHungarianPrefixes = ImmutableArray.CreateBuilder<string>();
+            this.allowedNamespaceComponentTerms = ImmutableArray.CreateBuilder<string>();
 
             this.IncludeInferredTupleElementNames = false;
             this.TupleElementNameCasing = TupleElementNameCase.CamelCase;
@@ -57,6 +65,11 @@ protected internal NamingSettings(JsonObject namingSettingsObject)
 
                     break;
 
+                case "allowedNamespaceComponentTerms":
+                    kvp.AssertIsArray();
+                    this.allowedNamespaceComponentTerms.AddRange(kvp.Value.AsJsonArray.Select(x => x.ToStringValue(kvp.Key)));
+                    break;
+
                 case "includeInferredTupleElementNames":
                     this.IncludeInferredTupleElementNames = kvp.ToBooleanValue();
                     break;
@@ -76,6 +89,9 @@ protected internal NamingSettings(JsonObject namingSettingsObject)
         public ImmutableArray<string> AllowedHungarianPrefixes
             => this.allowedHungarianPrefixes.ToImmutable();
 
+        public ImmutableArray<string> AllowedNamespaceComponentTerms
+            => this.allowedNamespaceComponentTerms.ToImmutable();
+
         public bool IncludeInferredTupleElementNames { get; }
 
         public TupleElementNameCase TupleElementNameCasing { get; }

Original file line number	Diff line number	Diff line change
`@@ -12,6 +12,7 @@ namespace StyleCop.Analyzers.NamingRules`
`12`	`12`	`using Microsoft.CodeAnalysis.Diagnostics;`
`13`	`13`	`using StyleCop.Analyzers.Helpers;`
`14`	`14`	`using StyleCop.Analyzers.Lightup;`
	`15`	`+ using StyleCop.Analyzers.Settings.ObjectModel;`
`15`	`16`
`16`	`17`	`/// <summary>`
`17`	`18`	`/// The name of a C# element does not begin with an upper-case letter.`
`@@ -45,7 +46,7 @@ internal class SA1300ElementMustBeginWithUpperCaseLetter : DiagnosticAnalyzer`
`45`	`46`	`private static readonly DiagnosticDescriptor Descriptor =`
`46`	`47`	`new DiagnosticDescriptor(DiagnosticId, Title, MessageFormat, AnalyzerCategory.NamingRules, DiagnosticSeverity.Warning, AnalyzerConstants.EnabledByDefault, Description, HelpLink);`
`47`	`48`
`48`		`- private static readonly Action<SyntaxNodeAnalysisContext> NamespaceDeclarationAction = HandleNamespaceDeclaration;`
	`49`	`+ private static readonly Action<SyntaxNodeAnalysisContext, StyleCopSettings> NamespaceDeclarationAction = HandleNamespaceDeclaration;`
`49`	`50`	`private static readonly Action<SyntaxNodeAnalysisContext> ClassDeclarationAction = HandleClassDeclaration;`
`50`	`51`	`private static readonly Action<SyntaxNodeAnalysisContext> EnumDeclarationAction = HandleEnumDeclaration;`
`51`	`52`	`private static readonly Action<SyntaxNodeAnalysisContext> EnumMemberDeclarationAction = HandleEnumMemberDeclaration;`
`@@ -82,13 +83,13 @@ public override void Initialize(AnalysisContext context)`
`82`	`83`	`context.RegisterSyntaxNodeAction(PropertyDeclarationAction, SyntaxKind.PropertyDeclaration);`
`83`	`84`	`}`
`84`	`85`
`85`		`- private static void HandleNamespaceDeclaration(SyntaxNodeAnalysisContext context)`
	`86`	`+ private static void HandleNamespaceDeclaration(SyntaxNodeAnalysisContext context, StyleCopSettings settings)`
`86`	`87`	`{`
`87`	`88`	`NameSyntax nameSyntax = ((NamespaceDeclarationSyntax)context.Node).Name;`
`88`		`- CheckNameSyntax(context, nameSyntax);`
	`89`	`+ CheckNameSyntax(context, nameSyntax, settings);`
`89`	`90`	`}`
`90`	`91`
`91`		`- private static void CheckNameSyntax(SyntaxNodeAnalysisContext context, NameSyntax nameSyntax)`
	`92`	`+ private static void CheckNameSyntax(SyntaxNodeAnalysisContext context, NameSyntax nameSyntax, StyleCopSettings settings)`
`92`	`93`	`{`
`93`	`94`	`if (nameSyntax == null \|\| nameSyntax.IsMissing)`
`94`	`95`	`{`
`@@ -97,12 +98,13 @@ private static void CheckNameSyntax(SyntaxNodeAnalysisContext context, NameSynta`
`97`	`98`
`98`	`99`	`if (nameSyntax is QualifiedNameSyntax qualifiedNameSyntax)`
`99`	`100`	`{`
`100`		`- CheckNameSyntax(context, qualifiedNameSyntax.Left);`
`101`		`- CheckNameSyntax(context, qualifiedNameSyntax.Right);`
	`101`	`+ CheckNameSyntax(context, qualifiedNameSyntax.Left, settings);`
	`102`	`+ CheckNameSyntax(context, qualifiedNameSyntax.Right, settings);`
`102`	`103`	`return;`
`103`	`104`	`}`
`104`	`105`
`105`		`- if (nameSyntax is SimpleNameSyntax simpleNameSyntax)`
	`106`	`+ if (nameSyntax is SimpleNameSyntax simpleNameSyntax &&`
	`107`	`+ !settings.NamingRules.AllowedNamespaceComponentTerms.Contains(simpleNameSyntax.Identifier.ValueText))`
`106`	`108`	`{`
`107`	`109`	`CheckElementNameToken(context, simpleNameSyntax.Identifier);`
`108`	`110`	`return;`