Find Unused Step Definitions command

CHANGELOG.md

@@ -1,4 +1,6 @@
 # [vNext]
+* FEATURE: FindUnused Step Definitions Command - from within a binding class a new context menu command, "FindUsusedStepDefinitions", is available. 
+	* This will list any Step Definition methods that are not matched by one or more Feature steps in the current project.
 
 * FIX for Create Step Definition Snippets Generates Reqnroll Using Statements for SpecFlow Projects #6
 * Fix for GH7 - "Find step definitions usages command not visible for SpecFlow projects

Reqnroll.VisualStudio.Package/Commands/ReqnrollVsPackage.vsct

@@ -107,6 +107,19 @@
 		      <ToolTipText>Finds usages of the step definition in feature files.</ToolTipText>
 	      </Strings>
       </Button>
+      <Button guid="guidReqnrollPackageCmdSet" id="FindUnusedStepDefinitionsCommandId" priority="0x0103" type="Button">
+        <Parent guid="guidReqnrollPackageCmdSet" id="EditorContextMenuGroup" />
+        <Icon guid="guidImages" id="bmpReqnroll" />
+        <CommandFlag>DynamicVisibility</CommandFlag>
+        <CommandFlag>DefaultInvisible</CommandFlag>
+        <Strings>
+          <ButtonText>Find Unused Step Definitions</ButtonText>
+          <CommandName>Reqnroll - Find Unused Step Definitions</CommandName>
+          <CanonicalName>Reqnroll.FindUnusedStepDefinitions</CanonicalName>
+          <LocCanonicalName>Reqnroll.FindUnusedStepDefinitions</LocCanonicalName>
+          <ToolTipText>Finds step definitions that are not used in feature files.</ToolTipText>
+        </Strings>
+      </Button>
     </Buttons>
 
     <!--The bitmaps section is used to define the bitmaps that are used for the commands.-->
@@ -140,6 +153,7 @@
       <IDSymbol name="FindStepDefinitionUsagesCommandId" value="0x0101" />
       <IDSymbol name="RenameStepCommandId" value="0x0103" />
       <IDSymbol name="GoToHookCommandId" value="0x0104" />
+      <IDSymbol name="FindUnusedStepDefinitionsCommandId" value="0x0102" />
     </GuidSymbol>
 
     <GuidSymbol name="guidImages" value="{027c70d2-dbf1-49ee-ba67-c4796aa26a87}" >

Reqnroll.VisualStudio.Package/ProjectSystem/NullVsIdeScope.cs

@@ -159,6 +159,10 @@ public void MonitorCommandFindStepDefinitionUsages(int usagesCount, bool isCance
         {
         }
 
+        public void MonitorCommandFindUnusedStepDefinitions(int unusedStepDefinitions, int scannedFeatureFiles, bool isCancellationRequested)
+        {
+        }
+
         public void MonitorCommandGoToStepDefinition(bool generateSnippet)
         {
         }
@@ -232,5 +236,6 @@ public void MonitorWelcomeDialogDismissed(Dictionary<string, object> additionalP
         public void TransmitEvent(IAnalyticsEvent runtimeEvent)
         {
         }
+
     }
 }

Reqnroll.VisualStudio.Package/ProjectSystem/VsProjectScope.cs

@@ -58,7 +58,7 @@ public string[] GetProjectFiles(string extension)
         {
             return VsUtils.GetPhysicalFileProjectItems(_project)
                 .Select(VsUtils.GetFilePath)
-                .Where(fp => FileSystemHelper.IsOfType(fp, ".feature"))
+                .Where(fp => FileSystemHelper.IsOfType(fp, extension))
                 .ToArray();
         }
         catch (Exception e)

Reqnroll.VisualStudio/Editor/Commands/FindUnusedStepDefinitionsCommand.cs

@@ -0,0 +1,169 @@
+namespace Reqnroll.VisualStudio.Editor.Commands
+{
+    [Export(typeof(IDeveroomCodeEditorCommand))]
+
+    public class FindUnusedStepDefinitionsCommand : DeveroomEditorCommandBase, IDeveroomCodeEditorCommand
+    {
+        private const string PopupHeader = "Unused Step Definitions";
+
+        private readonly UnusedStepDefinitionsFinder _stepDefinitionsUnusedFinder;
+
+        [ImportingConstructor]
+        public FindUnusedStepDefinitionsCommand(
+            IIdeScope ideScope,
+            IBufferTagAggregatorFactoryService aggregatorFactory,
+            IDeveroomTaggerProvider taggerProvider)
+            : base(ideScope, aggregatorFactory, taggerProvider)
+        {
+            _stepDefinitionsUnusedFinder = new UnusedStepDefinitionsFinder(ideScope);
+        }
+
+
+        public override DeveroomEditorCommandTargetKey[] Targets => new[]
+        {
+        new DeveroomEditorCommandTargetKey(ReqnrollVsCommands.DefaultCommandSet,
+            ReqnrollVsCommands.FindUnusedStepDefinitionsCommandId)
+        };
+
+        public override DeveroomEditorCommandStatus QueryStatus(IWpfTextView textView,
+            DeveroomEditorCommandTargetKey commandKey)
+        {
+            var status = base.QueryStatus(textView, commandKey);
+
+            var heuristicTest = textView.TextBuffer.CurrentSnapshot.GetText().Contains("Reqnroll") || textView.TextBuffer.CurrentSnapshot.GetText().Contains("SpecFlow");
+
+            if (status != DeveroomEditorCommandStatus.NotSupported)
+                // very basic heuristic: if the word "Reqnroll" or "SpecFlow" is in the content of the file, it might be a binding class
+                status = heuristicTest
+                    ? DeveroomEditorCommandStatus.Supported
+                    : DeveroomEditorCommandStatus.NotSupported;
+
+            return status;
+        }
+
+
+        public override bool PreExec(IWpfTextView textView, DeveroomEditorCommandTargetKey commandKey, IntPtr inArgs = default)
+        {
+            Logger.LogVerbose("Find Unused Step Definitions");
+
+            var textBuffer = textView.TextBuffer;
+
+            var project = IdeScope.GetProject(textBuffer);
+            if (project == null || !project.GetProjectSettings().IsReqnrollProject)
+            {
+                IdeScope.Actions.ShowProblem(
+                    "Unable to find step definition usages: the project is not detected to be a Reqnroll project or it is not initialized yet.");
+                return true;
+            }
+
+            var reqnrollTestProjects = new IProjectScope[] { project };
+
+            var asyncContextMenu = IdeScope.Actions.ShowAsyncContextMenu(PopupHeader);
+            Task.Run(
+                () => FindUnusedStepDefinitionsInProjectsAsync(reqnrollTestProjects, asyncContextMenu,
+                    asyncContextMenu.CancellationToken), asyncContextMenu.CancellationToken);
+            return true;
+        }
+
+        private async Task FindUnusedStepDefinitionsInProjectsAsync(IProjectScope[] reqnrollTestProjects, IAsyncContextMenu asyncContextMenu, CancellationToken cancellationToken)
+        {
+            var summary = new UnusedStepDefinitionSummary();
+            summary.ScannedProjects = reqnrollTestProjects.Length;
+            try
+            {
+                await FindUsagesInternalAsync(reqnrollTestProjects, asyncContextMenu, cancellationToken, summary);
+            }
+            catch (Exception ex)
+            {
+                Logger.LogException(MonitoringService, ex);
+                summary.WasError = true;
+            }
+
+            if (summary.WasError)
+                asyncContextMenu.AddItems(new ContextMenuItem("Could not complete find operation because of an error"));
+            else if (summary.FoundStepDefinitions == 0)
+                asyncContextMenu.AddItems(
+                    new ContextMenuItem("Could not find any step definitions in the current solution"));
+            else if (summary.UnusedStepDefinitions == 0)
+                asyncContextMenu.AddItems(
+                    new ContextMenuItem("There are no unused step definitions"));
+
+            MonitoringService.MonitorCommandFindUnusedStepDefinitions(summary.UnusedStepDefinitions, summary.ScannedFeatureFiles,
+                cancellationToken.IsCancellationRequested);
+            if (cancellationToken.IsCancellationRequested)
+                Logger.LogVerbose("Finding unused step definitions cancelled");
+            else
+                Logger.LogInfo($"Found {summary.UnusedStepDefinitions} unused step definitions in {summary.ScannedProjects} Projects");
+            asyncContextMenu.Complete();
+            Finished.Set();
+        }
+        private async Task FindUsagesInternalAsync(IProjectScope[] reqnrollTestProjects, IAsyncContextMenu asyncContextMenu,
+            CancellationToken cancellationToken, UnusedStepDefinitionSummary summary)
+        {
+            foreach (var project in reqnrollTestProjects)
+            {
+                if (cancellationToken.IsCancellationRequested)
+                    break;
+
+                var bindingRegistry = project.GetDiscoveryService().BindingRegistryCache.Value;
+                if (bindingRegistry == ProjectBindingRegistry.Invalid)
+                {
+                    Logger.LogWarning(
+                        $"Unable to get step definitions from project '{project.ProjectName}', usages will not be found for this project.");
+                    continue;
+                }
+
+                // At this point, the binding registry contains StepDefinitions from the current project and any referenced assemblies that contain StepDefinitions.
+                // We need to filter out any step definitions that are not from the current project.
+
+                var projectCodeFiles = project.GetProjectFiles(".cs");
+                var projectScopedBindingRegistry = bindingRegistry.Where(sd => projectCodeFiles.Contains(sd.Implementation?.SourceLocation?.SourceFile));
+
+                var stepDefinitionCount = projectScopedBindingRegistry.StepDefinitions.Length;
+
+                summary.FoundStepDefinitions += stepDefinitionCount;
+                if (stepDefinitionCount == 0)
+                    continue;
+
+                var featureFiles = project.GetProjectFiles(".feature");
+                var configuration = project.GetDeveroomConfiguration();
+                var projectUnusedStepDefinitions = _stepDefinitionsUnusedFinder.FindUnused(projectScopedBindingRegistry, featureFiles, configuration);
+                foreach (var unused in projectUnusedStepDefinitions)
+                {
+                    if (cancellationToken.IsCancellationRequested)
+                        break;
+
+                    //await Task.Delay(500);
+
+                    asyncContextMenu.AddItems(CreateMenuItem(unused, project, GetUsageLabel(unused), unused.Implementation.Method));
+                    summary.UnusedStepDefinitions++;
+                }
+
+                summary.ScannedFeatureFiles += featureFiles.Length;
+            }
+        }
+
+        private static string GetUsageLabel(ProjectStepDefinitionBinding stepDefinition)
+        {
+            return $"[{stepDefinition.StepDefinitionType}(\"{stepDefinition.Expression}\")] {stepDefinition.Implementation.Method}";
+        }
+        private string GetIcon() => null;
+
+        private ContextMenuItem CreateMenuItem(ProjectStepDefinitionBinding stepDefinition, IProjectScope project, string menuLabel, string shortDescription)
+        {
+            return new SourceLocationContextMenuItem(
+                stepDefinition.Implementation.SourceLocation, project.ProjectFolder,
+                menuLabel, _ => { PerformJump<string>(shortDescription, "", stepDefinition.Implementation, _ => { }  ); }, GetIcon());
+        }
+
+        private class UnusedStepDefinitionSummary
+        {
+            public int FoundStepDefinitions { get; set; }
+            public int UnusedStepDefinitions { get; set; }
+            public int ScannedFeatureFiles { get; set; }
+            public int ScannedProjects { get; set; }
+            public bool WasError { get; set; }
+
+        }
+    }
+}

Reqnroll.VisualStudio/Editor/Commands/Infrastructure/DeveroomEditorCommandBroker.cs

@@ -27,7 +27,7 @@ public class DeveroomCodeEditorCommandBroker : DeveroomEditorCommandBroker<IDeve
         [ImportMany] IEnumerable<IDeveroomCodeEditorCommand> commands, IDeveroomLogger logger)
         : base(adaptersFactory, commands, logger)
     {
-        Debug.Assert(_commands.Count == 2, "There have to be 2 code file editor Reqnroll commands");
+        Debug.Assert(_commands.Count == 3, "There have to be 3 code file editor Reqnroll commands");
     }
 }
 

Reqnroll.VisualStudio/Editor/Commands/ReqnrollVsCommands.cs

@@ -8,5 +8,6 @@ public static class ReqnrollVsCommands
     public const int FindStepDefinitionUsagesCommandId = 0x0101;
     public const int RenameStepCommandId = 0x0103;
     public const int GoToHookCommandId = 0x0104;
+    public const int FindUnusedStepDefinitionsCommandId = 0x0102;
     public static readonly Guid DefaultCommandSet = new("7fd3ed5d-2cf1-4200-b28b-cf1cc6b00c5a");
 }

Reqnroll.VisualStudio/Editor/Services/StepFinderBase.cs

@@ -0,0 +1,71 @@
+using Reqnroll.VisualStudio.ProjectSystem;
+
+namespace Reqnroll.VisualStudio.Editor.Services
+{
+    public abstract class StepFinderBase
+    {
+        private readonly IIdeScope _ideScope;
+
+        protected StepFinderBase(IIdeScope ideScope)
+        {
+            _ideScope = ideScope;
+        }
+        protected bool LoadContent(string featureFilePath, out string content)
+        {
+            if (LoadAlreadyOpenedContent(featureFilePath, out string openedContent))
+            {
+                content = openedContent;
+                return true;
+            }
+
+            if (LoadContentFromFile(featureFilePath, out string fileContent))
+            {
+                content = fileContent;
+                return true;
+            }
+
+            content = string.Empty;
+            return false;
+        }
+
+        private bool LoadContentFromFile(string featureFilePath, out string content)
+        {
+            try
+            {
+                content = _ideScope.FileSystem.File.ReadAllText(featureFilePath);
+                return true;
+            }
+            catch (Exception ex)
+            {
+                _ideScope.Logger.LogDebugException(ex);
+                content = string.Empty;
+                return false;
+            }
+        }
+
+        private bool LoadAlreadyOpenedContent(string featureFilePath, out string content)
+        {
+            var sl = new SourceLocation(featureFilePath, 1, 1);
+            if (!_ideScope.GetTextBuffer(sl, out ITextBuffer tb))
+            {
+                content = string.Empty;
+                return false;
+            }
+
+            content = tb.CurrentSnapshot.GetText();
+            return true;
+        }
+
+        protected class StepFinderContext : IGherkinDocumentContext
+        {
+            public StepFinderContext(object node, IGherkinDocumentContext parent = null)
+            {
+                Node = node;
+                Parent = parent;
+            }
+
+            public IGherkinDocumentContext Parent { get; }
+            public object Node { get; }
+        }
+    }
+}

Reqnroll.VisualStudio/Editor/Services/UnusedStepDefinitionsFinder.cs

@@ -0,0 +1,69 @@
+using Reqnroll.VisualStudio.ProjectSystem;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+#nullable disable
+
+namespace Reqnroll.VisualStudio.Editor.Services;
+
+public class UnusedStepDefinitionsFinder : StepFinderBase
+{
+    private readonly IIdeScope _ideScope;
+
+    public UnusedStepDefinitionsFinder(IIdeScope ideScope) : base(ideScope)
+    {
+        _ideScope = ideScope;
+    }
+
+    public IEnumerable<ProjectStepDefinitionBinding> FindUnused(ProjectBindingRegistry bindingRegistry,
+                                                        string[] featureFiles, DeveroomConfiguration configuration)
+    {
+        var stepDefUsageCounts = bindingRegistry.StepDefinitions.ToDictionary(stepDef => stepDef, _ => 0);
+        foreach (var ff in featureFiles)
+        {
+            var usedSteps = FindUsed(bindingRegistry, ff, configuration);
+            foreach (var step in usedSteps) stepDefUsageCounts[step]++;
+        }
+
+        return stepDefUsageCounts.Where(x => x.Value == 0).Select(x => x.Key);
+    }
+
+    protected IEnumerable<ProjectStepDefinitionBinding> FindUsed(ProjectBindingRegistry bindingRegistry,
+        string featureFilePath, DeveroomConfiguration configuration) =>
+        LoadContent(featureFilePath, out string featureFileContent)
+        ? FindUsagesFromContent(bindingRegistry, featureFileContent, featureFilePath, configuration)
+        : Enumerable.Empty<ProjectStepDefinitionBinding>();
+
+    private IEnumerable<ProjectStepDefinitionBinding> FindUsagesFromContent(ProjectBindingRegistry bindingRegistry, string featureFileContent, string featureFilePath, DeveroomConfiguration configuration)
+    {
+        var dialectProvider = ReqnrollGherkinDialectProvider.Get(configuration.DefaultFeatureLanguage);
+        var parser = new DeveroomGherkinParser(dialectProvider, _ideScope.MonitoringService);
+        parser.ParseAndCollectErrors(featureFileContent, _ideScope.Logger,
+            out var gherkinDocument, out _);
+
+        var featureNode = gherkinDocument?.Feature;
+        if (featureNode == null)
+            return Enumerable.Empty<ProjectStepDefinitionBinding>();
+
+        var featureContext = new StepFinderContext(featureNode);
+        var usedSteps = new List<ProjectStepDefinitionBinding>();
+
+        foreach (var scenarioDefinition in featureNode.FlattenStepsContainers())
+        {
+            var context = new StepFinderContext(scenarioDefinition, featureContext);
+
+            foreach (var step in scenarioDefinition.Steps)
+            {
+                var matchResult = bindingRegistry.MatchStep(step, context);
+
+                usedSteps.AddRange(matchResult.Items.Where(m => m.Type == MatchResultType.Defined || m.Type == MatchResultType.Ambiguous)
+                                                 .Select(i => i.MatchedStepDefinition));
+            }
+        }
+
+        return usedSteps;
+    }
+}

Reqnroll.VisualStudio/Monitoring/IMonitoringService.cs

@@ -17,6 +17,7 @@ public interface IMonitoringService
     void MonitorCommandCommentUncomment();
     void MonitorCommandDefineSteps(CreateStepDefinitionsDialogResult action, int snippetCount);
     void MonitorCommandFindStepDefinitionUsages(int usagesCount, bool isCancelled);
+    void MonitorCommandFindUnusedStepDefinitions(int unusedStepDefinitions, int scannedFeatureFiles, bool isCancellationRequested);
     void MonitorCommandGoToStepDefinition(bool generateSnippet);
     void MonitorCommandGoToHook();
     void MonitorCommandAutoFormatTable();