Use kebab-case urls. Close #14

JohanLarsson · JohanLarsson · commit d8829b808ce3 · 2018-12-31T13:24:30.000+01:00
diff --git a/AspNetCoreAnalyzers.Tests/ASP009KebabCaseUrlTests/CodeFix.cs b/AspNetCoreAnalyzers.Tests/ASP009KebabCaseUrlTests/CodeFix.cs
@@ -1,4 +1,4 @@
-namespace AspNetCoreAnalyzers.Tests.ASP009LowercaseUrlsTests
+namespace AspNetCoreAnalyzers.Tests.ASP009KebabCaseUrlTests
 {
     using Gu.Roslyn.Asserts;
     using Microsoft.CodeAnalysis.CodeFixes;
@@ -8,10 +8,13 @@ namespace AspNetCoreAnalyzers.Tests.ASP009LowercaseUrlsTests
     public class CodeFix
     {
         private static readonly DiagnosticAnalyzer Analyzer = new AttributeAnalyzer();
-        private static readonly ExpectedDiagnostic ExpectedDiagnostic = ExpectedDiagnostic.Create(ASP009LowercaseUrl.Descriptor);
+        private static readonly ExpectedDiagnostic ExpectedDiagnostic = ExpectedDiagnostic.Create(ASP009KebabCaseUrl.Descriptor);
         private static readonly CodeFixProvider Fix = new TemplateTextFix();
 
-        [TestCase("\"api/↓Orders/{id}\"", "\"api/orders/{id}\"")]
+        [TestCase("\"api/↓Orders/{id}\"",    "\"api/orders/{id}\"")]
+        [TestCase("\"api/↓TwoWords/{id}\"",  "\"api/two-words/{id}\"")]
+        [TestCase("\"api/↓twoWords/{id}\"",  "\"api/two-words/{id}\"")]
+        [TestCase("\"api/↓two_words/{id}\"", "\"api/two-words/{id}\"")]
         public void WhenMethodAttribute(string before, string after)
         {
             var code = @"
@@ -48,15 +51,18 @@ public IActionResult GetId(string id)
             AnalyzerAssert.CodeFix(Analyzer, Fix, ExpectedDiagnostic, code, fixedCode);
         }
 
-        [TestCase("\"api/↓Orders\"", "\"api/orders\"")]
+        [TestCase("\"api/↓Orders\"",    "\"api/orders\"")]
+        [TestCase("\"api/↓TwoWords\"",  "\"api/two-words\"")]
+        [TestCase("\"api/↓twoWords\"",  "\"api/two-words\"")]
+        [TestCase("\"api/↓two_words\"", "\"api/two-words\"")]
         public void WhenRouteAttribute(string before, string after)
         {
             var code = @"
 namespace ValidCode
 {
     using Microsoft.AspNetCore.Mvc;
 
-    [Route(""api/Orders"")]
+    [Route(""api/↓TwoWords"")]
     [ApiController]
     public class OrdersController : Controller
     {
@@ -66,7 +72,7 @@ public IActionResult GetId(string id)
             return this.Ok(id);
         }
     }
-}".AssertReplace("\"api/Orders\"", before);
+}".AssertReplace("\"api/↓TwoWords\"", before);
 
             var fixedCode = @"
 namespace ValidCode
diff --git a/AspNetCoreAnalyzers.Tests/ASP009KebabCaseUrlTests/ValidCode.cs b/AspNetCoreAnalyzers.Tests/ASP009KebabCaseUrlTests/ValidCode.cs
@@ -1,4 +1,4 @@
-namespace AspNetCoreAnalyzers.Tests.ASP009LowercaseUrlsTests
+namespace AspNetCoreAnalyzers.Tests.ASP009KebabCaseUrlTests
 {
     using Gu.Roslyn.Asserts;
     using Microsoft.CodeAnalysis.Diagnostics;
@@ -10,7 +10,7 @@ public class ValidCode
 
         [TestCase("\"{value}\"")]
         [TestCase("\"api/orders/{value}\"")]
-        [TestCase("\"api/TwoWords/{value}\"")]
+        [TestCase("\"api/two-words/{value}\"")]
         public void WithParameter(string parameter)
         {
             var code = @"
diff --git a/AspNetCoreAnalyzers/ASP009KebabCaseUrl.cs b/AspNetCoreAnalyzers/ASP009KebabCaseUrl.cs
@@ -2,18 +2,18 @@ namespace AspNetCoreAnalyzers
 {
     using Microsoft.CodeAnalysis;
 
-    internal static class ASP009LowercaseUrl
+    internal static class ASP009KebabCaseUrl
     {
         public const string DiagnosticId = "ASP009";
 
         internal static readonly DiagnosticDescriptor Descriptor = new DiagnosticDescriptor(
             id: DiagnosticId,
-            title: "Use lowercase urls.",
-            messageFormat: "Use lowercase urls.",
+            title: "Use kebab-cased urls.",
+            messageFormat: "Use kebab-cased urls.",
             category: AnalyzerCategory.Routing,
             defaultSeverity: DiagnosticSeverity.Warning,
             isEnabledByDefault: true,
-            description: "Use lowercase urls.",
+            description: "Use kebab-cased urls.",
             helpLinkUri: HelpLink.ForId(DiagnosticId));
     }
 }
diff --git a/AspNetCoreAnalyzers/Analyzers/AttributeAnalyzer.cs b/AspNetCoreAnalyzers/Analyzers/AttributeAnalyzer.cs
@@ -23,7 +23,7 @@ public class AttributeAnalyzer : DiagnosticAnalyzer
             ASP006ParameterRegex.Descriptor,
             ASP007MissingParameter.Descriptor,
             ASP008ValidRouteParameterName.Descriptor,
-            ASP009LowercaseUrl.Descriptor);
+            ASP009KebabCaseUrl.Descriptor);
 
         public override void Initialize(AnalysisContext context)
         {
@@ -134,19 +134,17 @@ context.Node is AttributeSyntax attribute &&
                                 ASP008ValidRouteParameterName.Descriptor,
                                 location,
                                 name == null
-                                    ? ImmutableDictionary<string, string>.Empty
-                                    : ImmutableDictionary<string, string>.Empty.Add(nameof(Text), name)));
+                                ? ImmutableDictionary<string, string>.Empty
+                                : ImmutableDictionary<string, string>.Empty.Add(nameof(Text), name)));
                     }
 
-                    if (IsUpperCase(segment, out var lowercase))
+                    if (ShouldKebabCase(segment, out var kebabCase))
                     {
                         context.ReportDiagnostic(
                             Diagnostic.Create(
-                                ASP009LowercaseUrl.Descriptor,
+                                ASP009KebabCaseUrl.Descriptor,
                                 segment.Span.GetLocation(),
-                                lowercase == null
-                                    ? ImmutableDictionary<string, string>.Empty
-                                    : ImmutableDictionary<string, string>.Empty.Add(nameof(Text), lowercase)));
+                                ImmutableDictionary<string, string>.Empty.Add(nameof(Text), kebabCase)));
                     }
                 }
             }
@@ -518,8 +516,7 @@ private static bool HasInvalidName(PathSegment segment, out Location location, o
                     parameter.Name.EndsWith(" ", StringComparison.OrdinalIgnoreCase))
                 {
                     location = parameter.Name.GetLocation();
-                    correctName = parameter.Name.ToString()
-                                           .Trim();
+                    correctName = parameter.Name.ToString().Trim();
                     return true;
                 }
 
@@ -540,7 +537,7 @@ private static bool HasInvalidName(PathSegment segment, out Location location, o
             return false;
         }
 
-        private static bool IsUpperCase(PathSegment segment, out string lowercase)
+        private static bool IsUppercase(PathSegment segment, out string lowercase)
         {
             if (segment.Parameter == null &&
                 segment.Span.Length > 0 &&
@@ -562,5 +559,56 @@ private static bool IsUpperCase(PathSegment segment, out string lowercase)
             lowercase = null;
             return false;
         }
+
+        private static bool ShouldKebabCase(PathSegment segment, out string kebabCase)
+        {
+            if (segment.Parameter == null &&
+                IsHumpOrSnakeCased(segment.Span))
+            {
+                var builder = StringBuilderPool.Borrow();
+                for (var i = 0; i < segment.Span.Length; i++)
+                {
+                    var c = segment.Span[i];
+                    if (char.IsUpper(c))
+                    {
+                        if (i > 0)
+                        {
+                            _ = builder.Append("-");
+                        }
+
+                        _ = builder.Append(char.ToLower(c));
+                    }
+                    else if (c == '_')
+                    {
+                        _ = builder.Append("-");
+                    }
+                    else
+                    {
+                        _ = builder.Append(c);
+                    }
+                }
+
+                kebabCase = builder.Return();
+                return true;
+            }
+
+            kebabCase = null;
+            return false;
+
+            bool IsHumpOrSnakeCased(Span span)
+            {
+                for (var i = 0; i < segment.Span.Length; i++)
+                {
+                    var c = segment.Span[i];
+                    if (char.IsUpper(c) ||
+                        c == '_')
+                    {
+                        return true;
+                    }
+                }
+
+                return false;
+            }
+        }
     }
 }
diff --git a/AspNetCoreAnalyzers/CodeFixes/TemplateTextFix.cs b/AspNetCoreAnalyzers/CodeFixes/TemplateTextFix.cs
@@ -21,7 +21,7 @@ public class TemplateTextFix : CodeFixProvider
             ASP005ParameterSyntax.DiagnosticId,
             ASP006ParameterRegex.DiagnosticId,
             ASP008ValidRouteParameterName.DiagnosticId,
-            ASP009LowercaseUrl.DiagnosticId);
+            ASP009KebabCaseUrl.DiagnosticId);
 
         public override FixAllProvider GetFixAllProvider() => null;
 
@@ -66,7 +66,7 @@ private static string GetTitle(Diagnostic diagnostic)
                     return "Escape regex.";
                 case ASP008ValidRouteParameterName.DiagnosticId:
                     return "Fix name.";
-                case ASP009LowercaseUrl.DiagnosticId:
+                case ASP009KebabCaseUrl.DiagnosticId:
                     return "To lowercase.";
                 default:
                     throw new InvalidOperationException("Should never get here.");
diff --git a/README.md b/README.md
@@ -45,7 +45,7 @@ Roslyn analyzers for ASP.NET.Core.
   </tr>
   <tr>
     <td><a href="https://github.com/DotNetAnalyzers/AspNetCoreAnalyzers/tree/master/documentation/ASP009.md">ASP009</a></td>
-    <td>Use lowercase urls.</td>
+    <td>Use kebab-cased urls.</td>
   </tr>
 <table>
 <!-- end generated table -->
diff --git a/documentation/ASP009.md b/documentation/ASP009.md
@@ -1,5 +1,5 @@
 # ASP009
-## Use lowercase urls.
+## Use kebab-cased urls.
 
 <!-- start generated table -->
 <table>
@@ -28,7 +28,7 @@
 
 ## Description
 
-Use lowercase urls.
+Use kebab-cased urls.
 
 ## Motivation
 
@@ -47,21 +47,21 @@ Configure the severity per project, for more info see [MSDN](https://msdn.micros
 
 ### Via #pragma directive.
 ```C#
-#pragma warning disable ASP009 // Use lowercase urls.
+#pragma warning disable ASP009 // Use kebab-cased urls.
 Code violating the rule here
-#pragma warning restore ASP009 // Use lowercase urls.
+#pragma warning restore ASP009 // Use kebab-cased urls.
 ```
 
 Or put this at the top of the file to disable all instances.
 ```C#
-#pragma warning disable ASP009 // Use lowercase urls.
+#pragma warning disable ASP009 // Use kebab-cased urls.
 ```
 
 ### Via attribute `[SuppressMessage]`.
 
 ```C#
 [System.Diagnostics.CodeAnalysis.SuppressMessage("AspNetCoreAnalyzers.Routing", 
-    "ASP009:Use lowercase urls.", 
+    "ASP009:Use kebab-cased urls.", 
     Justification = "Reason...")]
 ```
 <!-- end generated config severity -->

Original file line number	Diff line number	Diff line change
`@@ -1,4 +1,4 @@`
`1`		`-namespace AspNetCoreAnalyzers.Tests.ASP009LowercaseUrlsTests`
	`1`	`+namespace AspNetCoreAnalyzers.Tests.ASP009KebabCaseUrlTests`
`2`	`2`	`{`
`3`	`3`	`using Gu.Roslyn.Asserts;`
`4`	`4`	`using Microsoft.CodeAnalysis.CodeFixes;`
`@@ -8,10 +8,13 @@ namespace AspNetCoreAnalyzers.Tests.ASP009LowercaseUrlsTests`
`8`	`8`	`public class CodeFix`
`9`	`9`	`{`
`10`	`10`	`private static readonly DiagnosticAnalyzer Analyzer = new AttributeAnalyzer();`
`11`		`- private static readonly ExpectedDiagnostic ExpectedDiagnostic = ExpectedDiagnostic.Create(ASP009LowercaseUrl.Descriptor);`
	`11`	`+ private static readonly ExpectedDiagnostic ExpectedDiagnostic = ExpectedDiagnostic.Create(ASP009KebabCaseUrl.Descriptor);`
`12`	`12`	`private static readonly CodeFixProvider Fix = new TemplateTextFix();`
`13`	`13`
`14`		`- [TestCase("\"api/↓Orders/{id}\"", "\"api/orders/{id}\"")]`
	`14`	`+ [TestCase("\"api/↓Orders/{id}\"", "\"api/orders/{id}\"")]`
	`15`	`+ [TestCase("\"api/↓TwoWords/{id}\"", "\"api/two-words/{id}\"")]`
	`16`	`+ [TestCase("\"api/↓twoWords/{id}\"", "\"api/two-words/{id}\"")]`
	`17`	`+ [TestCase("\"api/↓two_words/{id}\"", "\"api/two-words/{id}\"")]`
`15`	`18`	`public void WhenMethodAttribute(string before, string after)`
`16`	`19`	`{`
`17`	`20`	`var code = @"`
`@@ -48,15 +51,18 @@ public IActionResult GetId(string id)`
`48`	`51`	`AnalyzerAssert.CodeFix(Analyzer, Fix, ExpectedDiagnostic, code, fixedCode);`
`49`	`52`	`}`
`50`	`53`
`51`		`- [TestCase("\"api/↓Orders\"", "\"api/orders\"")]`
	`54`	`+ [TestCase("\"api/↓Orders\"", "\"api/orders\"")]`
	`55`	`+ [TestCase("\"api/↓TwoWords\"", "\"api/two-words\"")]`
	`56`	`+ [TestCase("\"api/↓twoWords\"", "\"api/two-words\"")]`
	`57`	`+ [TestCase("\"api/↓two_words\"", "\"api/two-words\"")]`
`52`	`58`	`public void WhenRouteAttribute(string before, string after)`
`53`	`59`	`{`
`54`	`60`	`var code = @"`
`55`	`61`	`namespace ValidCode`
`56`	`62`	`{`
`57`	`63`	`using Microsoft.AspNetCore.Mvc;`
`58`	`64`
`59`		`- [Route(""api/Orders"")]`
	`65`	`+ [Route(""api/↓TwoWords"")]`
`60`	`66`	`[ApiController]`
`61`	`67`	`public class OrdersController : Controller`
`62`	`68`	`{`
`@@ -66,7 +72,7 @@ public IActionResult GetId(string id)`
`66`	`72`	`return this.Ok(id);`
`67`	`73`	`}`
`68`	`74`	`}`
`69`		`-}".AssertReplace("\"api/Orders\"", before);`
	`75`	`+}".AssertReplace("\"api/↓TwoWords\"", before);`
`70`	`76`
`71`	`77`	`var fixedCode = @"`
`72`	`78`	`namespace ValidCode`
Original file line number	Diff line number	Diff line change
`@@ -2,18 +2,18 @@ namespace AspNetCoreAnalyzers`
`2`	`2`	`{`
`3`	`3`	`using Microsoft.CodeAnalysis;`
`4`	`4`
`5`		`- internal static class ASP009LowercaseUrl`
	`5`	`+ internal static class ASP009KebabCaseUrl`
`6`	`6`	`{`
`7`	`7`	`public const string DiagnosticId = "ASP009";`
`8`	`8`
`9`	`9`	`internal static readonly DiagnosticDescriptor Descriptor = new DiagnosticDescriptor(`
`10`	`10`	`id: DiagnosticId,`
`11`		`- title: "Use lowercase urls.",`
`12`		`- messageFormat: "Use lowercase urls.",`
	`11`	`+ title: "Use kebab-cased urls.",`
	`12`	`+ messageFormat: "Use kebab-cased urls.",`
`13`	`13`	`category: AnalyzerCategory.Routing,`
`14`	`14`	`defaultSeverity: DiagnosticSeverity.Warning,`
`15`	`15`	`isEnabledByDefault: true,`
`16`		`- description: "Use lowercase urls.",`
	`16`	`+ description: "Use kebab-cased urls.",`
`17`	`17`	`helpLinkUri: HelpLink.ForId(DiagnosticId));`
`18`	`18`	`}`
`19`	`19`	`}`