Merge branch 'rubberduck-vba/next' into 4349_RenameClash

BZngr · BZngr · commit 8a38df798f23 · 2018-10-09T06:35:08.000-07:00
diff --git a/Rubberduck.CodeAnalysis/Inspections/Concrete/ModuleWithoutFolderInspection.cs b/Rubberduck.CodeAnalysis/Inspections/Concrete/ModuleWithoutFolderInspection.cs
@@ -0,0 +1,29 @@
+﻿using System.Collections.Generic;
+using System.Linq;
+using Rubberduck.Inspections.Abstract;
+using Rubberduck.Inspections.Results;
+using Rubberduck.Parsing.Inspections.Abstract;
+using Rubberduck.Resources.Inspections;
+using Rubberduck.Parsing.VBA;
+using Rubberduck.Parsing.Annotations;
+
+namespace Rubberduck.Inspections.Concrete
+{
+    public sealed class ModuleWithoutFolderInspection : InspectionBase
+    {
+        public ModuleWithoutFolderInspection(RubberduckParserState state)
+            : base(state)
+        {
+        }
+
+        protected override IEnumerable<IInspectionResult> DoGetInspectionResults()
+        {
+            var modulesWithoutFolderAnnotation = State.DeclarationFinder.UserDeclarations(Parsing.Symbols.DeclarationType.Module)
+                .Where(w => w.Annotations.All(a => a.AnnotationType != AnnotationType.Folder))
+                .ToList();
+
+            return modulesWithoutFolderAnnotation.Select(declaration =>
+                new DeclarationInspectionResult(this, string.Format(InspectionResults.ModuleWithoutFolderInspection, declaration.IdentifierName), declaration));
+        }
+    }
+}
diff --git a/Rubberduck.CodeAnalysis/Inspections/Concrete/UnreachableCaseInspection/UnreachableCaseInspection.cs b/Rubberduck.CodeAnalysis/Inspections/Concrete/UnreachableCaseInspection/UnreachableCaseInspection.cs
@@ -20,15 +20,15 @@ public sealed class UnreachableCaseInspection : ParseTreeInspectionBase
         private readonly IUnreachableCaseInspectorFactory _unreachableCaseInspectorFactory;
         private readonly IParseTreeValueFactory _valueFactory;
 
-        private enum CaseInpectionResult { Unreachable, InherentlyUnreachable, MismatchType, Overflow, CaseElse };
+        private enum CaseInspectionResult { Unreachable, InherentlyUnreachable, MismatchType, Overflow, CaseElse };
 
-        private static readonly Dictionary<CaseInpectionResult, string> ResultMessages = new Dictionary<CaseInpectionResult, string>()
+        private static readonly Dictionary<CaseInspectionResult, string> ResultMessages = new Dictionary<CaseInspectionResult, string>()
         {
-            [CaseInpectionResult.Unreachable] = InspectionResults.UnreachableCaseInspection_Unreachable,
-            [CaseInpectionResult.InherentlyUnreachable] = InspectionResults.UnreachableCaseInspection_InherentlyUnreachable,
-            [CaseInpectionResult.MismatchType] = InspectionResults.UnreachableCaseInspection_TypeMismatch,
-            [CaseInpectionResult.Overflow] = InspectionResults.UnreachableCaseInspection_Overflow,
-            [CaseInpectionResult.CaseElse] = InspectionResults.UnreachableCaseInspection_CaseElse
+            [CaseInspectionResult.Unreachable] = InspectionResults.UnreachableCaseInspection_Unreachable,
+            [CaseInspectionResult.InherentlyUnreachable] = InspectionResults.UnreachableCaseInspection_InherentlyUnreachable,
+            [CaseInspectionResult.MismatchType] = InspectionResults.UnreachableCaseInspection_TypeMismatch,
+            [CaseInspectionResult.Overflow] = InspectionResults.UnreachableCaseInspection_Overflow,
+            [CaseInspectionResult.CaseElse] = InspectionResults.UnreachableCaseInspection_CaseElse
         };
 
         public UnreachableCaseInspection(RubberduckParserState state) : base(state)
@@ -62,11 +62,11 @@ protected override IEnumerable<IInspectionResult> DoGetInspectionResults()
 
                 selectCaseInspector.InspectForUnreachableCases();
 
-                selectCaseInspector.UnreachableCases.ForEach(uc => CreateInspectionResult(qualifiedSelectCaseStmt, uc, ResultMessages[CaseInpectionResult.Unreachable]));
-                selectCaseInspector.MismatchTypeCases.ForEach(mm => CreateInspectionResult(qualifiedSelectCaseStmt, mm, ResultMessages[CaseInpectionResult.MismatchType]));
-                selectCaseInspector.OverflowCases.ForEach(mm => CreateInspectionResult(qualifiedSelectCaseStmt, mm, ResultMessages[CaseInpectionResult.Overflow]));
-                selectCaseInspector.InherentlyUnreachableCases.ForEach(mm => CreateInspectionResult(qualifiedSelectCaseStmt, mm, ResultMessages[CaseInpectionResult.InherentlyUnreachable]));
-                selectCaseInspector.UnreachableCaseElseCases.ForEach(ce => CreateInspectionResult(qualifiedSelectCaseStmt, ce, ResultMessages[CaseInpectionResult.CaseElse]));
+                selectCaseInspector.UnreachableCases.ForEach(uc => CreateInspectionResult(qualifiedSelectCaseStmt, uc, ResultMessages[CaseInspectionResult.Unreachable]));
+                selectCaseInspector.MismatchTypeCases.ForEach(mm => CreateInspectionResult(qualifiedSelectCaseStmt, mm, ResultMessages[CaseInspectionResult.MismatchType]));
+                selectCaseInspector.OverflowCases.ForEach(mm => CreateInspectionResult(qualifiedSelectCaseStmt, mm, ResultMessages[CaseInspectionResult.Overflow]));
+                selectCaseInspector.InherentlyUnreachableCases.ForEach(mm => CreateInspectionResult(qualifiedSelectCaseStmt, mm, ResultMessages[CaseInspectionResult.InherentlyUnreachable]));
+                selectCaseInspector.UnreachableCaseElseCases.ForEach(ce => CreateInspectionResult(qualifiedSelectCaseStmt, ce, ResultMessages[CaseInspectionResult.CaseElse]));
             }
             return _inspectionResults;
         }
diff --git a/Rubberduck.CodeAnalysis/Rubberduck.CodeAnalysis.csproj b/Rubberduck.CodeAnalysis/Rubberduck.CodeAnalysis.csproj
@@ -81,6 +81,7 @@
     <Compile Include="Inspections\Concrete\EmptyForEachBlockInspection.cs" />
     <Compile Include="Inspections\Concrete\EmptyForLoopBlockInspection.cs" />
     <Compile Include="Inspections\Concrete\BooleanAssignedInIfElseInspection.cs" />
+    <Compile Include="Inspections\Concrete\ModuleWithoutFolderInspection.cs" />
     <Compile Include="Inspections\Concrete\EmptyWhileWendBlockInspection.cs" />
     <Compile Include="Inspections\Concrete\ObsoleteCallingConventionInspection.cs" />
     <Compile Include="Inspections\Concrete\ObsoleteErrorSyntaxInspection.cs" />
diff --git a/Rubberduck.Core/Properties/Settings.Designer.cs b/Rubberduck.Core/Properties/Settings.Designer.cs
diff --git a/Rubberduck.Core/Properties/Settings.settings b/Rubberduck.Core/Properties/Settings.settings
@@ -279,6 +279,7 @@
     &lt;CodeInspection Name="ObsoleteMemberUsageInspection" Severity="Warning" InspectionType="MaintainabilityAndReadabilityIssues" /&gt;
     &lt;CodeInspection Name="ObsoleteCallingConventionInspection" Severity="Warning" InspectionType="CodeQualityIssues" /&gt;
     &lt;CodeInspection Name="DuplicatedAnnotationInspection" Severity="Error" InspectionType="RubberduckOpportunities" /&gt;
+    &lt;CodeInspection Name="ModuleWithoutFolderInspection" Severity="Suggestion" InspectionType="RubberduckOpportunities" /&gt;
   &lt;/CodeInspections&gt;
   &lt;WhitelistedIdentifiers /&gt;
   &lt;RunInspectionsOnSuccessfulParse&gt;true&lt;/RunInspectionsOnSuccessfulParse&gt;
diff --git a/Rubberduck.Core/Settings/CodeInspectionConfigProvider.cs b/Rubberduck.Core/Settings/CodeInspectionConfigProvider.cs
@@ -18,7 +18,7 @@ public CodeInspectionConfigProvider(IPersistanceService<CodeInspectionSettings>
             _persister = persister;
             _foundInspectionNames = inspectionProvider.Inspections.Select(inspection => inspection.Name).ToHashSet();
             _defaultSettings = new DefaultSettings<CodeInspectionSettings>().Default;
-            // Ignore settings for unknown inpections, for example when using the Experimental attribute
+            // Ignore settings for unknown inspections, for example when using the Experimental attribute
             _defaultSettings.CodeInspections = _defaultSettings.CodeInspections.Where(setting => _foundInspectionNames.Contains(setting.Name)).ToHashSet();
 
             var defaultNames = _defaultSettings.CodeInspections.Select(x => x.Name);
diff --git a/Rubberduck.Core/app.config b/Rubberduck.Core/app.config
@@ -402,6 +402,8 @@
                 InspectionType="CodeQualityIssues" />
               <CodeInspection Name="DuplicatedAnnotationInspection" Severity="Error"
                 InspectionType="RubberduckOpportunities" />
+              <CodeInspection Name="ModuleWithoutFolderInspection" Severity="Suggestion"
+                InspectionType="RubberduckOpportunities" />
             </CodeInspections>
             <WhitelistedIdentifiers />
             <RunInspectionsOnSuccessfulParse>true</RunInspectionsOnSuccessfulParse>
diff --git a/Rubberduck.Resources/Inspections/InspectionInfo.Designer.cs b/Rubberduck.Resources/Inspections/InspectionInfo.Designer.cs
diff --git a/Rubberduck.Resources/Inspections/InspectionInfo.resx b/Rubberduck.Resources/Inspections/InspectionInfo.resx
@@ -334,4 +334,7 @@ If the parameter can be null, ignore this inspection result; passing a null valu
   <data name="DuplicatedAnnotationInspection" xml:space="preserve">
     <value>An annotation is specified multiple times, but is intended to be specified only once.</value>
   </data>
+  <data name="ModuleWithoutFolderInspection" xml:space="preserve">
+    <value>Modules without the '@Folder' annotation cannot receive custom groupings in the Code Explorer. </value>
+  </data>
 </root>
diff --git a/Rubberduck.Resources/Inspections/InspectionNames.Designer.cs b/Rubberduck.Resources/Inspections/InspectionNames.Designer.cs
diff --git a/Rubberduck.Resources/Inspections/InspectionNames.resx b/Rubberduck.Resources/Inspections/InspectionNames.resx
@@ -333,4 +333,7 @@
   <data name="DuplicatedAnnotationInspection" xml:space="preserve">
     <value>Annotation is duplicated</value>
   </data>
+  <data name="ModuleWithoutFolderInspection" xml:space="preserve">
+    <value>Module without '@Folder' annotation</value>
+  </data>
 </root>
diff --git a/Rubberduck.Resources/Inspections/InspectionResults.Designer.cs b/Rubberduck.Resources/Inspections/InspectionResults.Designer.cs
diff --git a/Rubberduck.Resources/Inspections/InspectionResults.resx b/Rubberduck.Resources/Inspections/InspectionResults.resx
@@ -240,7 +240,7 @@
   </data>
   <data name="AggregateInspection" xml:space="preserve">
     <value>{0} ({1} results).</value>
-    <comment>{0} inpection description, {1} result count</comment>
+    <comment>{0} inspection description, {1} result count</comment>
   </data>
   <data name="MemberNotOnInterfaceInspection" xml:space="preserve">
     <value>Member '{0}' was not found on the compile-time interface for type '{1}'.</value>
@@ -363,4 +363,7 @@
   <data name="DuplicatedAnnotationInspection" xml:space="preserve">
     <value>Annotation '{0}' is duplicated.</value>
   </data>
+  <data name="ModuleWithoutFolderInspection" xml:space="preserve">
+    <value>Module '{0}' has no '@Folder' annotation</value>
+  </data>
 </root>
diff --git a/RubberduckTests/Inspections/ModuleWithoutFolderInspectionTests.cs b/RubberduckTests/Inspections/ModuleWithoutFolderInspectionTests.cs
@@ -0,0 +1,62 @@
+﻿using NUnit.Framework;
+using Rubberduck.Inspections.Concrete;
+using RubberduckTests.Mocks;
+using System.Linq;
+using System.Threading;
+
+namespace RubberduckTests.Inspections
+{
+    [TestFixture]
+    public class ModuleWithoutFolderInspectionTests
+    {
+        [Test]
+        [Category("Inspections")]
+        public void Module_NoFolderAnnotation()
+        {
+            const string inputCode = "Option Explicit";
+
+            var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out _);
+            using (var state = MockParser.CreateAndParse(vbe.Object))
+            {
+                var inspection = new ModuleWithoutFolderInspection(state);
+                var inspectionResults = inspection.GetInspectionResults(CancellationToken.None);
+
+                Assert.AreEqual(1, inspectionResults.Count());
+            }
+        }
+
+        [Test]
+        [Category("Inspections")]
+        public void Module_FolderAnnotation()
+        {
+            const string inputCode = @"'@Folder Foo.Bar
+Option Explicit";
+
+            var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out _);
+            using (var state = MockParser.CreateAndParse(vbe.Object))
+            {
+                var inspection = new ModuleWithoutFolderInspection(state);
+                var inspectionResults = inspection.GetInspectionResults(CancellationToken.None);
+
+                Assert.AreEqual(0, inspectionResults.Count());
+            }
+        }
+
+        [Test]
+        [Category("Inspections")]
+        public void Module_NonFolderAnnotation()
+        {
+            const string inputCode = @"'@IgnoreModule
+Option Explicit";
+
+            var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out _);
+            using (var state = MockParser.CreateAndParse(vbe.Object))
+            {
+                var inspection = new ModuleWithoutFolderInspection(state);
+                var inspectionResults = inspection.GetInspectionResults(CancellationToken.None);
+
+                Assert.AreEqual(1, inspectionResults.Count());
+            }
+        }
+    }
+}
diff --git a/RubberduckTests/RubberduckTests.csproj b/RubberduckTests/RubberduckTests.csproj
@@ -110,6 +110,7 @@
     <Compile Include="CodeAnalysis\CodeMetrics\LineCountTests.cs" />
     <Compile Include="CodeExplorer\CodeExplorerTests.cs" />
     <Compile Include="Inspections\ImplicitDefaultMemberAssignmentInspectionTests.cs" />
+    <Compile Include="Inspections\ModuleWithoutFolderInspectionTests.cs" />
     <Compile Include="Inspections\UnreachableCase\ExpressionFilterUnitTests.cs" />
     <Compile Include="Inspections\UnreachableCase\ParseTreeExpressionEvaluatorUnitTests.cs" />
     <Compile Include="Inspections\UnreachableCase\ParseTreeValueUnitTests.cs" />
