Find Unused Step Definitions command

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/Editor/Commands/FindUnusedStepDefinitionsCommand.cs

@@ -0,0 +1,206 @@
+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);
+
+            if (status != DeveroomEditorCommandStatus.NotSupported)
+                // very basic heuristic: if the word "Reqnroll" is in the content of the file, it might be a binding class
+                status = textView.TextBuffer.CurrentSnapshot.GetText().Contains("Reqnroll")
+                    ? 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 fileName = GetEditorDocumentPath(textBuffer);
+            var triggerPoint = textView.Caret.Position.BufferPosition;
+
+            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 = IdeScope.GetProjectsWithFeatureFiles()
+                .Where(p => p.GetProjectSettings().IsReqnrollTestProject)
+                .ToArray();
+
+            if (reqnrollTestProjects.Length == 0)
+            {
+                IdeScope.Actions.ShowProblem(
+                    "Unable to find step definition usages: could not find any Reqnroll project with feature files.");
+                return true;
+            }
+
+            var asyncContextMenu = IdeScope.Actions.ShowAsyncContextMenu(PopupHeader);
+            Task.Run(
+                () => FindUnusedStepDefinitionsInProjectsAsync(reqnrollTestProjects, fileName, triggerPoint, asyncContextMenu,
+                    asyncContextMenu.CancellationToken), asyncContextMenu.CancellationToken);
+            return true;
+        }
+
+        private async Task FindUnusedStepDefinitionsInProjectsAsync(IProjectScope[] reqnrollTestProjects, string fileName,
+            SnapshotPoint triggerPoint, IAsyncContextMenu asyncContextMenu, CancellationToken cancellationToken)
+        {
+            var summary = new UnusedStepDefinitionSummary();
+
+            try
+            {
+                await FindUsagesInternalAsync(reqnrollTestProjects, fileName, triggerPoint, 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.UnusedStepDefinitions == 0)
+                asyncContextMenu.AddItems(
+                    new ContextMenuItem("Could not find any unused step definitions at the current position"));
+            //TODO: determine if this required/needed
+            //else if (summary.UsagesFound == 0) asyncContextMenu.AddItems(new ContextMenuItem("Could not find any usage"));
+
+            //TODO: modify monitoring to include finding unused step definitions
+            //MonitoringService.MonitorCommandFindStepDefinitionUsages(summary.UsagesFound,
+            //    cancellationToken.IsCancellationRequested);
+            if (cancellationToken.IsCancellationRequested)
+                Logger.LogVerbose("Finding unused step definitions cancelled");
+            else
+                Logger.LogInfo($"Found {summary.UnusedStepDefinitions} unused step definitions in {summary.ScannedFeatureFiles} feature files");
+            asyncContextMenu.Complete();
+            Finished.Set();
+        }
+        private async Task FindUsagesInternalAsync(IProjectScope[] reqnrollTestProjects, string fileName,
+    SnapshotPoint triggerPoint, IAsyncContextMenu asyncContextMenu, CancellationToken cancellationToken,
+    UnusedStepDefinitionSummary summary)
+        {
+            foreach (var project in reqnrollTestProjects)
+            {
+                if (cancellationToken.IsCancellationRequested)
+                    break;
+
+                var stepDefinitions = await GetStepDefinitionsAsync(project, fileName, triggerPoint);
+                //summary.FoundStepDefinitions += stepDefinitions.Length;
+                if (stepDefinitions.Length == 0)
+                    continue;
+
+                var featureFiles = project.GetProjectFiles(".feature");
+                var configuration = project.GetDeveroomConfiguration();
+                var projectUnusedStepDefinitions = _stepDefinitionsUnusedFinder.FindUnused(stepDefinitions, featureFiles, configuration);
+                foreach (var unused in projectUnusedStepDefinitions)
+                {
+                    if (cancellationToken.IsCancellationRequested)
+                        break;
+
+                    //await Task.Delay(500);
+
+                    //TODO: create menu item - what type of menu item?
+                    asyncContextMenu.AddItems(CreateMenuItem(unused, project));
+                    summary.UnusedStepDefinitions++;
+                }
+
+                summary.ScannedFeatureFiles += featureFiles.Length;
+            }
+        }
+
+        private async Task<ProjectStepDefinitionBinding[]> GetStepDefinitionsAsync(IProjectScope project, string fileName,
+     SnapshotPoint triggerPoint)
+        {
+            var discoveryService = project.GetDiscoveryService();
+            var bindingRegistry = await discoveryService.BindingRegistryCache.GetLatest();
+            if (bindingRegistry == ProjectBindingRegistry.Invalid)
+                Logger.LogWarning(
+                    $"Unable to get step definitions from project '{project.ProjectName}', usages will not be found for this project.");
+            return GetStepDefinitions(fileName, triggerPoint, bindingRegistry);
+        }
+
+        //TODO: since this Command doesn't need to filter the set of StepDefinitions, this can be merged with the method above
+        internal static ProjectStepDefinitionBinding[] GetStepDefinitions(string fileName, SnapshotPoint triggerPoint,
+            ProjectBindingRegistry bindingRegistry)
+        {
+            return bindingRegistry.StepDefinitions
+                    //                .Where(sd => sd.Implementation?.SourceLocation != null &&
+                    //                             sd.Implementation.SourceLocation.SourceFile == fileName &&
+                    //
+                    .ToArray();
+        }
+
+        //TODO: near duplicate of similar method in FindStepDefinitionUsagesCommand
+        private ContextMenuItem CreateMenuItem(ProjectStepDefinitionBinding stepDefinition, IProjectScope project)
+        {
+            return new SourceLocationContextMenuItem(
+                stepDefinition.Implementation.SourceLocation, project.ProjectFolder,
+                GetUsageLabel(stepDefinition), _ => { PerformJump(stepDefinition); }, null);
+        }
+
+        private static string GetUsageLabel(ProjectStepDefinitionBinding stepDefinition)
+        {
+            return $"[{stepDefinition.StepDefinitionType}(\"{stepDefinition.Expression}\")] {stepDefinition.Implementation.Method}";
+        }
+
+        //TODO: near duplicate of similar method in FindStepDefinitionUsagesCommand
+        private void PerformJump(ProjectStepDefinitionBinding binding)
+        {
+            var sourceLocation = binding.Implementation.SourceLocation;
+            if (sourceLocation == null)
+            {
+                Logger.LogWarning($"Cannot jump to {binding.Implementation.Method}: no source location");
+                IdeScope.Actions.ShowProblem("Unable to jump to the step. No source location detected.");
+                return;
+            }
+
+            Logger.LogInfo($"Jumping to {binding.Implementation.Method} at {sourceLocation}");
+            if (!IdeScope.Actions.NavigateTo(sourceLocation))
+            {
+                Logger.LogWarning($"Cannot jump to {binding.Implementation.Method}: invalid source file or position");
+                IdeScope.Actions.ShowProblem(
+                    $"Unable to jump to the step. Invalid source file or file position.{Environment.NewLine}{sourceLocation}");
+            }
+        }
+        private class UnusedStepDefinitionSummary
+        {
+            public int UnusedStepDefinitions { get; set; }
+            public int ScannedFeatureFiles { get; set; }
+            public bool WasError { get; set; }
+
+        }
+    }
+}

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

@@ -27,7 +27,7 @@ public DeveroomCodeEditorCommandBroker(IVsEditorAdaptersFactoryService adaptersF
         [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/UnusedStepDefinitionsFinder.cs

@@ -0,0 +1,127 @@
+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
+{
+    private readonly IIdeScope _ideScope;
+
+    public UnusedStepDefinitionsFinder(IIdeScope ideScope)
+    {
+        _ideScope = ideScope;
+    }
+
+    public IEnumerable<ProjectStepDefinitionBinding> FindUnused(ProjectStepDefinitionBinding[] stepDefinitions,
+                                                        string[] featureFiles, DeveroomConfiguration configuration)
+    {
+        return featureFiles.SelectMany(ff => FindUnused(stepDefinitions, ff, configuration));
+    }
+
+    public IEnumerable<ProjectStepDefinitionBinding> FindUnused(ProjectStepDefinitionBinding[] stepDefinitions, 
+        string featureFilePath, DeveroomConfiguration configuration) => 
+        LoadContent(featureFilePath, out string featureFileContent)
+        ? FindUsagesFromContent(stepDefinitions, featureFileContent, featureFilePath, configuration)
+        : Enumerable.Empty<ProjectStepDefinitionBinding>();
+
+    private IEnumerable<ProjectStepDefinitionBinding> FindUsagesFromContent(ProjectStepDefinitionBinding[] stepDefinitions, 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 dummyRegistry = ProjectBindingRegistry.FromBindings(stepDefinitions);
+
+        //this set keeps track of which step definitions have not been used. We start with ALL step definitions, and will subtract those that match steps in the feature file
+        HashSet<ProjectStepDefinitionBinding> stepDefinitionsSet = new(stepDefinitions);
+
+        var featureContext = new UnusedFinderContext(featureNode);
+
+        foreach (var scenarioDefinition in featureNode.FlattenStepsContainers())
+        {
+            var context = new UnusedFinderContext(scenarioDefinition, featureContext);
+
+            foreach (var step in scenarioDefinition.Steps)
+            {
+                var matchResult = dummyRegistry.MatchStep(step, context);
+
+                var usedSteps = matchResult.Items.Where(m => m.Type == MatchResultType.Defined || m.Type == MatchResultType.Ambiguous)
+                                                 .Select(i => i.MatchedStepDefinition)
+                                                 .ToHashSet<ProjectStepDefinitionBinding>();
+                stepDefinitionsSet.ExceptWith(usedSteps);
+            }
+        }
+
+        return stepDefinitionsSet.ToList();
+
+    }
+
+    //TODO: duplicate of what is in StepDefinitionUsageFinder; consider refactoring to shared implementation
+    private 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;
+    }
+
+    //TODO: duplicate of what is in StepDefinitionUsageFinder; consider refactoring to shared implementation
+    private class UnusedFinderContext : IGherkinDocumentContext
+    {
+        public UnusedFinderContext(object node, IGherkinDocumentContext parent = null)
+        {
+            Node = node;
+            Parent = parent;
+        }
+
+        public IGherkinDocumentContext Parent { get; }
+        public object Node { get; }
+    }
+}