Introduce option to fix all selected occurrences

Author: MDoerner

Rubberduck.Core/UI/Inspections/InspectionResultsControl.xaml

@@ -22,11 +22,19 @@
             <codeInspections:InspectionImageSourceConverter x:Key="InspectionIconConverter" />
             <codeInspections:QuickFixImageSourceConverter x:Key="QuickFixIconConverter" />
             <codeInspections:InspectionsUIResourceKeyConverter x:Key="InspectionsUIResourceConverter" />
+            <codeInspections:QuickFixCommandParametersToTupleConverter x:Key="QuickFixCommandParametersToTupleConverter" />
 
             <Style TargetType="MenuItem" x:Key="QuickFixCommandStyle">
                 <Setter Property="Header" Value="{Binding Key, Converter={StaticResource InspectionsUIResourceConverter}}" />
+                <Setter Property="CommandParameter">
+                    <Setter.Value>
+                        <MultiBinding Converter="{StaticResource QuickFixCommandParametersToTupleConverter}">
+                            <Binding Path="Fix" />
+                            <Binding Path="SelectedItems" RelativeSource="{RelativeSource FindAncestor, AncestorType={x:Type controls:GroupingGrid}}" />
+                        </MultiBinding>
+                    </Setter.Value>
+                </Setter>
                 <Setter Property="Command" Value="{Binding Command}"/>
-                <Setter Property="CommandParameter" Value="{Binding Fix}"/>
             </Style>
 
             <Style TargetType="MenuItem" x:Key="QuickFixItemStyle">

Rubberduck.Core/UI/Inspections/InspectionResultsViewModel.cs

@@ -132,6 +132,7 @@ public InspectionResultsViewModel(
 
             DisableInspectionCommand = new DelegateCommand(LogManager.GetCurrentClassLogger(), ExecuteDisableInspectionCommand);
             QuickFixCommand = new DelegateCommand(LogManager.GetCurrentClassLogger(), ExecuteQuickFixCommand, CanExecuteQuickFixCommand);
+            QuickFixSelectedItemsCommand = new DelegateCommand(LogManager.GetCurrentClassLogger(), ExecuteQuickFixForSelection, CanExecuteQuickFixForSelection);
             QuickFixInProcedureCommand = new DelegateCommand(LogManager.GetCurrentClassLogger(), ExecuteQuickFixInProcedureCommand, CanExecuteQuickFixInProcedure);
             QuickFixInModuleCommand = new DelegateCommand(LogManager.GetCurrentClassLogger(), ExecuteQuickFixInModuleCommand, CanExecuteQuickFixInModule);
             QuickFixInProjectCommand = new DelegateCommand(LogManager.GetCurrentClassLogger(), ExecuteQuickFixInProjectCommand, CanExecuteQuickFixInProject);
@@ -144,6 +145,7 @@ public InspectionResultsViewModel(
             QuickFixCommands = new List<(ICommand command, string key)>
             {
                 (QuickFixCommand,"QuickFix_Instance"),
+                (QuickFixSelectedItemsCommand,"QuickFix_Selection"),
                 (QuickFixInProcedureCommand,"QuickFix_ThisProcedure"),
                 (QuickFixInModuleCommand,"QuickFix_ThisModule"),
                 (QuickFixInProjectCommand,"QuickFix_ThisProject"),
@@ -339,6 +341,7 @@ private bool InspectionFilter(IInspectionResult result)
         public INavigateCommand NavigateCommand { get; }
         public CommandBase RefreshCommand { get; }
         public CommandBase QuickFixCommand { get; }
+        public CommandBase QuickFixSelectedItemsCommand { get; }
         public CommandBase QuickFixInProcedureCommand { get; }
         public CommandBase QuickFixInModuleCommand { get; }
         public CommandBase QuickFixInProjectCommand { get; }
@@ -544,52 +547,92 @@ private void InvalidateStaleInspectionResults(ICollection<QualifiedModuleName> m
 
         private void ExecuteQuickFixCommand(object parameter)
         {
-            if (!(parameter is IQuickFix quickFix)
+            if (!(parameter is ValueTuple<IQuickFix, IEnumerable<IInspectionResult>> tpl)
                 || !(SelectedItem is IInspectionResult inspectionResult))
             {
                 return;
             }
 
+            var (quickFix, _) = tpl;
+
             _quickFixProvider.Fix(quickFix, inspectionResult);
         }
 
         private bool CanExecuteQuickFixCommand(object parameter)
         {
-            return !IsBusy 
-                   && parameter is IQuickFix
-                   && _state.Status == ParserState.Ready;
+            return !IsBusy
+                   && _state.Status == ParserState.Ready
+                   && parameter is ValueTuple<IQuickFix, IEnumerable<IInspectionResult>>;
+        }
+
+        private void ExecuteQuickFixForSelection(object parameter)
+        {
+            if (!(parameter is ValueTuple<IQuickFix, IEnumerable<IInspectionResult>> tpl))
+            {
+                return;
+            }
+
+            var (quickFix, selectedItems) = tpl;
+            
+            _quickFixProvider.Fix(
+                quickFix,
+                selectedItems);
+        }
+
+        public bool CanExecuteQuickFixForSelection(object parameter)
+        {
+            if (!CanExecuteQuickFixCommand(parameter)
+                || !(parameter is ValueTuple<IQuickFix, IEnumerable<IInspectionResult>> tpl))
+            {
+                return false;
+            }
+
+            var (quickFix, selectedItems) = tpl;
+
+            return quickFix.CanFixMultiple
+                   && (selectedItems?.All(result => _quickFixProvider.CanFix(quickFix, result)) ?? false);
         }
 
         private void ExecuteQuickFixInProcedureCommand(object parameter)
         {
-            if (!(parameter is IQuickFix quickFix)
+            if (!(parameter is ValueTuple<IQuickFix, IEnumerable<IInspectionResult>> tpl)
                 || !(SelectedItem is IInspectionResult inspectionResult))
             {
                 return;
             }
 
+            var (quickFix, _) = tpl;
+
             _quickFixProvider.FixInProcedure(
-                quickFix, 
+                quickFix,
                 inspectionResult.QualifiedMemberName,
-                inspectionResult.Inspection.GetType(), 
+                inspectionResult.Inspection.GetType(),
                 Results.OfType<IInspectionResult>());
         }
 
         public bool CanExecuteQuickFixInProcedure(object parameter)
         {
-            return CanExecuteQuickFixCommand(parameter)
-                   && parameter is IQuickFix quickFix
-                   && quickFix.CanFixInProcedure;
+            if (!CanExecuteQuickFixCommand(parameter)
+                || !(parameter is ValueTuple<IQuickFix, IEnumerable<IInspectionResult>> tpl))
+            {
+                return false;
+            }
+
+            var (quickFix, _) = tpl;
+
+            return quickFix.CanFixInProcedure;
         }
 
         private void ExecuteQuickFixInModuleCommand(object parameter)
         {
-            if (!(parameter is IQuickFix quickFix)
+            if (!(parameter is ValueTuple<IQuickFix, IEnumerable<IInspectionResult>> tpl)
                 || !(SelectedItem is IInspectionResult inspectionResult))
             {
                 return;
             }
 
+            var (quickFix, _) = tpl;
+
             _quickFixProvider.FixInModule(
                 quickFix,
                 inspectionResult.QualifiedSelection,
@@ -599,19 +642,27 @@ private void ExecuteQuickFixInModuleCommand(object parameter)
 
         public bool CanExecuteQuickFixInModule(object parameter)
         {
-            return CanExecuteQuickFixCommand(parameter)
-                   && parameter is IQuickFix quickFix
-                   && quickFix.CanFixInModule;
+            if (!CanExecuteQuickFixCommand(parameter)
+                || !(parameter is ValueTuple<IQuickFix, IEnumerable<IInspectionResult>> tpl))
+            {
+                return false;
+            }
+
+            var (quickFix, _) = tpl;
+
+            return quickFix.CanFixInModule;
         }
 
         private void ExecuteQuickFixInProjectCommand(object parameter)
         {
-            if (!(parameter is IQuickFix quickFix)
+            if (!(parameter is ValueTuple<IQuickFix, IEnumerable<IInspectionResult>> tpl)
                 || !(SelectedItem is IInspectionResult inspectionResult))
             {
                 return;
             }
 
+            var (quickFix, _) = tpl;
+
             _quickFixProvider.FixInProject(
                 quickFix,
                 inspectionResult.QualifiedSelection,
@@ -621,19 +672,27 @@ private void ExecuteQuickFixInProjectCommand(object parameter)
 
         public bool CanExecuteQuickFixInProject(object parameter)
         {
-            return CanExecuteQuickFixCommand(parameter)
-                   && parameter is IQuickFix quickFix
-                   && quickFix.CanFixInProject;
+            if (!CanExecuteQuickFixCommand(parameter)
+                || !(parameter is ValueTuple<IQuickFix, IEnumerable<IInspectionResult>> tpl))
+            {
+                return false;
+            }
+
+            var (quickFix, _) = tpl;
+
+            return quickFix.CanFixInProject;
         }
 
         private void ExecuteQuickFixInAllProjectsCommand(object parameter)
         {
-            if (!(parameter is IQuickFix quickFix)
+            if (!(parameter is ValueTuple<IQuickFix, IEnumerable<IInspectionResult>> tpl)
                 || !(SelectedItem is IInspectionResult inspectionResult))
             {
                 return;
             }
 
+            var (quickFix, _) = tpl;
+
             _quickFixProvider.FixAll(
                 quickFix,
                 inspectionResult.Inspection.GetType(),
@@ -642,9 +701,15 @@ private void ExecuteQuickFixInAllProjectsCommand(object parameter)
 
         public bool CanExecuteQuickFixAll(object parameter)
         {
-            return CanExecuteQuickFixCommand(parameter)
-                   && parameter is IQuickFix quickFix
-                   && quickFix.CanFixAll;
+            if (!CanExecuteQuickFixCommand(parameter)
+                || !(parameter is ValueTuple<IQuickFix, IEnumerable<IInspectionResult>> tpl))
+            {
+                return false;
+            }
+
+            var (quickFix, _) = tpl;
+
+            return quickFix.CanFixAll;
         }
 
         private void ExecuteDisableInspectionCommand(object parameter)

Rubberduck.Core/UI/Inspections/QuickFixCommandParametersToTupleConverter.cs

@@ -0,0 +1,27 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Globalization;
+using System.Linq;
+using System.Windows.Data;
+using Rubberduck.CodeAnalysis.Inspections;
+using Rubberduck.CodeAnalysis.QuickFixes;
+
+namespace Rubberduck.UI.Inspections
+{
+    public class QuickFixCommandParametersToTupleConverter : IMultiValueConverter
+    {
+        public object Convert(object[] values, Type targetType, object parameter, CultureInfo culture)
+        {
+            (IQuickFix quickFix, IEnumerable<IInspectionResult> selectedResults) data = (
+                values[0] as IQuickFix,
+                ((IEnumerable)values[1]).OfType<IInspectionResult>());
+            return data;
+        }
+
+        public object[] ConvertBack(object value, Type[] targetTypes, object parameter, CultureInfo culture)
+        {
+            throw new NotImplementedException();
+        }
+    }
+}

Rubberduck.Resources/Inspections/InspectionsUI.Designer.cs

@@ -202,6 +202,9 @@
     <value>Schweregrad</value>
   </data>
   <data name="QuickFix_Instance" xml:space="preserve">
-    <value>Ausgewähltes Vorkommnis  beheben</value>
+    <value>Ausgewähltes Vorkommnis beheben</value>
+  </data>
+  <data name="QuickFix_Selection" xml:space="preserve">
+    <value>Alle ausgewählten Vorkomnisse beheben</value>
   </data>
 </root>

Rubberduck.Resources/Inspections/InspectionsUI.de.resx

@@ -232,4 +232,7 @@
   <data name="QuickFix_Instance" xml:space="preserve">
     <value>Fix selected occurrence</value>
   </data>
+  <data name="QuickFix_Selection" xml:space="preserve">
+    <value>Fix all selected occurrences</value>
+  </data>
 </root>