private void MoveCloserToUsage()
{
if (!_target.References.Any())
{
var message = string.Format(RubberduckUI.MoveCloserToUsage_TargetHasNoReferences, _target.IdentifierName);
_messageBox.Show(message, RubberduckUI.MoveCloserToUsage_Caption, MessageBoxButtons.OK,
MessageBoxIcon.Exclamation);
return;
}
if (TargetIsReferencedFromMultipleMethods(_target))
{
var message = string.Format(RubberduckUI.MoveCloserToUsage_TargetIsUsedInMultipleMethods, _target.IdentifierName);
_messageBox.Show(message, RubberduckUI.MoveCloserToUsage_Caption, MessageBoxButtons.OK,
MessageBoxIcon.Exclamation);
return;
}
// it doesn't make sense to do it backwards, but we need to work from the bottom up so our selections are accurate
InsertDeclaration();
_state.StateChanged += _state_StateChanged;
_state.OnParseRequested(this);
}
public void NewTestMethod()
{
if (_vbe.ActiveCodePane == null)
{
return;
}
try
{
var declaration = _state.AllUserDeclarations.First(f =>
f.DeclarationType == Parsing.Symbols.DeclarationType.ProceduralModule &&
f.QualifiedName.QualifiedModuleName.Component.CodeModule == _vbe.ActiveCodePane.CodeModule);
if (declaration.Annotations.Any(a => a.AnnotationType == AnnotationType.TestModule))
{
var module = _vbe.ActiveCodePane.CodeModule;
var name = GetNextTestMethodName(module.Parent);
var body = TestMethodTemplate.Replace(NamePlaceholder, name);
module.InsertLines(module.CountOfLines, body);
}
}
catch (COMException)
{
}
_state.OnParseRequested(this, _vbe.SelectedVBComponent);
}
public void Refactor()
{
var presenter = _factory.Create();
if (presenter == null)
{
return;
}
_model = presenter.Show();
if (_model == null)
{
return;
}
QualifiedSelection?oldSelection = null;
if (_vbe.ActiveCodePane != null)
{
oldSelection = _vbe.ActiveCodePane.CodeModule.GetSelection();
}
AddInterface();
if (oldSelection.HasValue)
{
oldSelection.Value.QualifiedName.Component.CodeModule.SetSelection(oldSelection.Value.Selection);
oldSelection.Value.QualifiedName.Component.CodeModule.CodePane.ForceFocus();
}
_state.OnParseRequested(this);
}
public void Fix(IQuickFix fix, IInspectionResult result)
{
if (!CanFix(fix, result))
{
return;
}
fix.Fix(result);
_state.RewriteAllModules();
_state.OnParseRequested(this);
}
private void PromoteVariable(Declaration target)
{
if (new[] { DeclarationType.ClassModule, DeclarationType.ProceduralModule }.Contains(target.ParentDeclaration.DeclarationType))
{
_messageBox.Show(RubberduckUI.PromoteVariable_InvalidSelection, RubberduckUI.IntroduceParameter_Caption,
MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
return;
}
QualifiedSelection?oldSelection = null;
if (_vbe.ActiveCodePane != null)
{
oldSelection = _vbe.ActiveCodePane.CodeModule.GetQualifiedSelection();
}
RemoveVariable(target);
AddField(target);
if (oldSelection.HasValue)
{
var module = oldSelection.Value.QualifiedName.Component.CodeModule;
var pane = module.CodePane;
{
pane.Selection = oldSelection.Value.Selection;
}
}
_state.OnParseRequested(this);
}
private void PromoteVariable(Declaration target)
{
if (!PromptIfMethodImplementsInterface(target))
{
return;
}
if (new[] { DeclarationType.ClassModule, DeclarationType.ProceduralModule }.Contains(target.ParentDeclaration.DeclarationType))
{
_messageBox.Show(RubberduckUI.PromoteVariable_InvalidSelection, RubberduckUI.IntroduceParameter_Caption,
MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
return;
}
QualifiedSelection?oldSelection = null;
if (_vbe.ActiveCodePane != null)
{
oldSelection = _vbe.ActiveCodePane.CodeModule.GetSelection();
}
RemoveVariable(target);
UpdateSignature(target);
if (oldSelection.HasValue)
{
oldSelection.Value.QualifiedName.Component.CodeModule.SetSelection(oldSelection.Value.Selection);
oldSelection.Value.QualifiedName.Component.CodeModule.CodePane.ForceFocus();
}
_state.OnParseRequested(this);
}
private void AddInterface()
{
var components = _model.TargetDeclaration.Project.VBComponents;
var interfaceComponent = components.Add(ComponentType.ClassModule);
var interfaceModule = interfaceComponent.CodeModule;
{
interfaceComponent.Name = _model.InterfaceName;
var optionPresent = interfaceModule.CountOfLines > 1;
if (!optionPresent)
{
interfaceModule.InsertLines(1, Tokens.Option + ' ' + Tokens.Explicit + Environment.NewLine);
}
interfaceModule.InsertLines(3, GetInterfaceModuleBody());
var module = _model.TargetDeclaration.QualifiedSelection.QualifiedName.Component.CodeModule;
{
_insertionLine = module.CountOfDeclarationLines + 1;
module.InsertLines(_insertionLine, Tokens.Implements + ' ' + _model.InterfaceName + Environment.NewLine);
_state.StateChanged += _state_StateChanged;
_state.OnParseRequested(this);
}
}
}
protected override void OnExecute(object parameter)
{
var parameterIsModuleDeclaration = parameter is ProceduralModuleDeclaration || parameter is ClassModuleDeclaration;
switch (parameter)
{
case IVBProject project:
_codeGenerator.AddTestModuleToProject(project);
break;
case Declaration declaration when parameterIsModuleDeclaration:
var declarationProject = _projectsProvider.Project(declaration.ProjectId);
_codeGenerator.AddTestModuleToProject(declarationProject, declaration);
break;
default:
using (var project = GetProject())
{
_codeGenerator.AddTestModuleToProject(project, null);
}
break;
}
_state.OnParseRequested(this);
}
protected override void OnExecute(object parameter)
{
using (var pane = _vbe.ActiveCodePane)
{
if (pane.IsWrappingNullReference)
{
return;
}
using (var module = pane.CodeModule)
{
var declaration = _state.GetTestModules()
.FirstOrDefault(f => _state.ProjectsProvider.Component(f.QualifiedModuleName).HasEqualCodeModule(module));
if (declaration == null)
{
return;
}
string name;
using (var component = module.Parent)
{
name = GetNextTestMethodName(component);
}
var body = TestMethodTemplate.Replace(NamePlaceholder, name);
module.InsertLines(module.CountOfLines, body);
}
}
_state.OnParseRequested(this);
}
protected override void ExecuteImpl(object parameter)
{
if (_vbe.ActiveCodePane == null)
{
return;
}
try
{
var declaration = _state.GetTestModules().FirstOrDefault(f =>
f.QualifiedName.QualifiedModuleName.Component.CodeModule == _vbe.ActiveCodePane.CodeModule);
if (declaration != null)
{
var module = _vbe.ActiveCodePane.CodeModule;
var name = GetNextTestMethodName(module.Parent);
var body = TestMethodExpectedErrorTemplate.Replace(NamePlaceholder, name);
module.InsertLines(module.CountOfLines, body);
}
}
catch (COMException)
{
}
_state.OnParseRequested(this, _vbe.SelectedVBComponent);
}
protected override void OnExecute(object parameter)
{
using (var pane = _vbe.ActiveCodePane)
{
if (pane?.IsWrappingNullReference ?? true)
{
return;
}
using (var module = pane.CodeModule)
{
var declaration = _state.GetTestModules()
.FirstOrDefault(f => _state.ProjectsProvider.Component(f.QualifiedModuleName).HasEqualCodeModule(module));
if (declaration == null)
{
return;
}
using (var component = module.Parent)
{
module.InsertLines(module.CountOfLines, _codeGenerator.GetNewTestMethodCode(component));
}
}
}
_state.OnParseRequested(this);
}
protected override void ExecuteImpl(object parameter)
{
var pane = _vbe.ActiveCodePane;
if (pane.IsWrappingNullReference)
{
return;
}
var activeModule = pane.CodeModule;
var declaration = _state.GetTestModules().FirstOrDefault(f =>
{
var thisModule = f.QualifiedName.QualifiedModuleName.Component.CodeModule;
return(thisModule.Equals(activeModule));
});
if (declaration != null)
{
var module = pane.CodeModule;
var name = GetNextTestMethodName(module.Parent);
var body = TestMethodExpectedErrorTemplate.Replace(NamePlaceholder, name);
module.InsertLines(module.CountOfLines, body);
}
_state.OnParseRequested(this, _vbe.SelectedVBComponent);
}
public void Refactor(QualifiedSelection selection)
{
_targetInterface = _state.DeclarationFinder.FindInterface(selection);
_targetClass = _declarations.SingleOrDefault(d =>
ImplementingModuleTypes.Contains(d.DeclarationType) &&
d.QualifiedSelection.QualifiedName.Equals(selection.QualifiedName)) as ClassModuleDeclaration;
if (_targetClass == null || _targetInterface == null)
{
_messageBox.NotifyWarn(RubberduckUI.ImplementInterface_InvalidSelectionMessage, RubberduckUI.ImplementInterface_Caption);
return;
}
var oldSelection = _vbe.GetActiveSelection();
ImplementMissingMembers(_state.GetRewriter(_targetClass));
if (oldSelection.HasValue)
{
using (var module = _state.ProjectsProvider.Component(oldSelection.Value.QualifiedName).CodeModule)
{
using (var pane = module.CodePane)
{
pane.Selection = oldSelection.Value.Selection;
}
}
}
_state.OnParseRequested(this);
}
protected override void OnExecute(object parameter)
{
// WPF binds to EvaluateCanExecute asychronously, which means that in some instances the bound refresh control will
// enable itself based on a "stale" ParserState. There's no easy way to test for race conditions inside WPF, so we
// need to make this test again...
if (!EvaluateCanExecute(parameter))
{
return;
}
if (_settings.CompileBeforeParse)
{
if (!VerifyCompileOnDemand())
{
return;
}
if (AreAllProjectsCompiled(out var failedNames))
{
if (!PromptUserToContinue(failedNames))
{
return;
}
}
}
_state.OnParseRequested(this);
}
protected override void OnExecute(object parameter)
{
if (!CanExecute(parameter) ||
!(parameter is CodeExplorerProjectViewModel node) ||
node.Declaration == null)
{
return;
}
var project = _projectsProvider.Project(node.Declaration.ProjectId);
if (project == null)
{
return;
}
try
{
using (var vbProjects = _vbe.VBProjects)
{
vbProjects.StartProject = project;
_parserState.OnParseRequested(this);
}
}
catch (COMException exception)
{
Logger.Error(exception);
}
}
private void Reparse()
{
if (RequestParseAfterRename)
{
_state.OnParseRequested(this);
}
}
public override void Execute(object parameter)
{
var node = (CodeExplorerComponentViewModel)parameter;
// ReSharper disable once PossibleInvalidOperationException - CanExecute ensures it has a value
_state.OnParseRequested(this, node.QualifiedSelection.Value.QualifiedName.Component);
}
protected override void OnExecute(object parameter)
{
if (_state.Status != ParserState.Ready)
{
return;
}
var declaration = parameter is CodeExplorerItemViewModel explorerItem
? explorerItem.Declaration
: GetDeclaration();
if (!(Declaration.GetProjectParent(declaration) is ProjectDeclaration project))
{
return;
}
var dialog = _factory.Create(project);
var model = dialog?.Show();
if (model is null)
{
return;
}
_reconciler.ReconcileReferences(model);
_state.OnParseRequested(this);
}
protected override void OnExecute(object parameter)
{
try
{
if (_vbe.ProjectsCount <= 1)
{
return;
}
var project = GetDeclaration(parameter as CodeExplorerItemViewModel)?.Project;
using (var vbProjects = _vbe.VBProjects)
{
if (!vbProjects.StartProject.Equals(project))
{
vbProjects.StartProject = project;
_parserState.OnParseRequested(this);
}
}
}
catch (COMException exception)
{
Logger.Error(exception);
}
}
public void Refactor(QualifiedSelection selection)
{
_targetInterface = _declarations.FindInterface(selection);
_targetClass = _declarations.SingleOrDefault(d =>
!d.IsBuiltIn && ImplementingModuleTypes.Contains(d.DeclarationType) &&
d.QualifiedSelection.QualifiedName.Equals(selection.QualifiedName));
if (_targetClass == null || _targetInterface == null)
{
_messageBox.Show(RubberduckUI.ImplementInterface_InvalidSelectionMessage, RubberduckUI.ImplementInterface_Caption,
System.Windows.Forms.MessageBoxButtons.OK, System.Windows.Forms.MessageBoxIcon.Exclamation);
return;
}
QualifiedSelection?oldSelection = null;
if (_vbe.ActiveCodePane != null)
{
oldSelection = _vbe.ActiveCodePane.CodeModule.GetQualifiedSelection();
}
ImplementMissingMembers();
if (oldSelection.HasValue)
{
var module = oldSelection.Value.QualifiedName.Component.CodeModule;
var pane = module.CodePane;
pane.Selection = oldSelection.Value.Selection;
}
_state.OnParseRequested(this);
}
protected override void OnExecute(object parameter)
{
_indenter.IndentCurrentProcedure();
if (_state.Status >= ParserState.Ready || _state.Status == ParserState.Pending)
{
_state.OnParseRequested(this, _vbe.ActiveCodePane.CodeModule.Parent);
}
}
protected override void OnExecute(object parameter)
{
_indenter.IndentCurrentModule();
if (_state.Status >= ParserState.Ready || _state.Status == ParserState.Pending)
{
_state.OnParseRequested(this);
}
}
public ToDoExplorerViewModel(
RubberduckParserState state,
IConfigurationService <Configuration> configService,
ISettingsFormFactory settingsFormFactory,
IUiDispatcher uiDispatcher,
INavigateCommand navigateCommand)
{
_state = state;
_configService = configService;
_settingsFormFactory = settingsFormFactory;
_uiDispatcher = uiDispatcher;
_state.StateChanged += HandleStateChanged;
NavigateCommand = navigateCommand;
RefreshCommand = new DelegateCommand(LogManager.GetCurrentClassLogger(),
_ =>
{
switch (_state.Status)
{
case ParserState.Ready:
case ParserState.Error:
case ParserState.ResolverError:
case ParserState.UnexpectedError:
case ParserState.Pending:
_state.OnParseRequested(this);
break;
}
},
_ =>
{
switch (_state.Status)
{
case ParserState.Ready:
case ParserState.Error:
case ParserState.ResolverError:
case ParserState.UnexpectedError:
case ParserState.Pending:
return(true);
default:
return(false);
}
});
RemoveCommand = new DelegateCommand(LogManager.GetCurrentClassLogger(), ExecuteRemoveCommand, CanExecuteRemoveCommand);
CollapseAllCommand = new DelegateCommand(LogManager.GetCurrentClassLogger(), ExecuteCollapseAll);
ExpandAllCommand = new DelegateCommand(LogManager.GetCurrentClassLogger(), ExecuteExpandAll);
CopyResultsCommand = new DelegateCommand(LogManager.GetCurrentClassLogger(), ExecuteCopyResultsCommand, CanExecuteCopyResultsCommand);
OpenTodoSettingsCommand = new DelegateCommand(LogManager.GetCurrentClassLogger(), ExecuteOpenTodoSettingsCommand);
Items = CollectionViewSource.GetDefaultView(_items);
OnPropertyChanged(nameof(Items));
Grouping = ToDoItemGrouping.Marker;
_columnHeaders = _configService.Read().UserSettings.ToDoListSettings.ColumnHeadersInformation;
}
private void MoveCloserToUsage()
{
if (!_target.References.Any())
{
var message = string.Format(RubberduckUI.MoveCloserToUsage_TargetHasNoReferences, _target.IdentifierName);
_messageBox.Show(message, RubberduckUI.MoveCloserToUsage_Caption, MessageBoxButtons.OK,
MessageBoxIcon.Exclamation);
return;
}
if (TargetIsReferencedFromMultipleMethods(_target))
{
var message = string.Format(RubberduckUI.MoveCloserToUsage_TargetIsUsedInMultipleMethods, _target.IdentifierName);
_messageBox.Show(message, RubberduckUI.MoveCloserToUsage_Caption, MessageBoxButtons.OK,
MessageBoxIcon.Exclamation);
return;
}
QualifiedSelection?oldSelection = null;
var pane = _vbe.ActiveCodePane;
var module = pane.CodeModule;
{
if (!module.IsWrappingNullReference)
{
oldSelection = module.GetQualifiedSelection();
}
// it doesn't make sense to do it backwards, but we need to work from the bottom up so our selections are accurate
InsertDeclaration();
if (oldSelection.HasValue)
{
pane.Selection = oldSelection.Value.Selection;
}
_state.StateChanged += _state_StateChanged;
_state.OnParseRequested(this);
}
}
public void Refactor()
{
var presenter = _factory.Create();
if (presenter == null)
{
return;
}
_model = presenter.Show();
if (_model == null)
{
return;
}
AddInterface();
_state.OnParseRequested(this);
}
protected override void OnExecute(object parameter)
{
var declarations = _state.AllDeclarations;
var qualifiedSelection = _vbe.GetActiveSelection();
var extractMethodValidation = new ExtractMethodSelectionValidation(declarations);
var canExecute = extractMethodValidation.withinSingleProcedure(qualifiedSelection.Value);
if (!canExecute)
{
return;
}
using (var pane = _vbe.ActiveCodePane)
using (var module = pane.CodeModule)
{
var extraction = new ExtractMethodExtraction();
// bug: access to disposed closure
// todo: make ExtractMethodRefactoring request reparse like everyone else.
var refactoring = new ExtractMethodRefactoring(module, ParseRequest, CreateMethodModel, extraction);
refactoring.InvalidSelection += HandleInvalidSelection;
refactoring.Refactor();
void ParseRequest(object obj) => _state.OnParseRequested(obj);
IExtractMethodModel CreateMethodModel(QualifiedSelection?qs, string code)
{
if (qs == null)
{
return(null);
}
//TODO: Pull these even further back;
// and implement with IProvider<IExtractMethodRule>
var rules = new List <IExtractMethodRule>
{
new ExtractMethodRuleInSelection(),
new ExtractMethodRuleIsAssignedInSelection(),
new ExtractMethodRuleUsedAfter(),
new ExtractMethodRuleUsedBefore()
};
var paramClassify = new ExtractMethodParameterClassification(rules);
var extractedMethod = new ExtractedMethod();
var extractedMethodModel = new ExtractMethodModel(extractedMethod, paramClassify);
extractedMethodModel.extract(declarations, qs.Value, code);
return(extractedMethodModel);
}
}
}
private async void ExecuteRefreshCommandAsync(object parameter)
{
CanRefresh = _vbe.HostApplication() != null;
if (!CanRefresh)
{
return;
}
IsBusy = true;
Debug.WriteLine("InspectionResultsViewModel.ExecuteRefreshCommand - requesting reparse");
_state.OnParseRequested(this);
}
private async void ExecuteRefreshCommandAsync()
{
CanRefresh = _vbe.HostApplication() != null && _state.IsDirty();
if (!CanRefresh)
{
return;
}
await Task.Yield();
IsBusy = true;
_state.OnParseRequested(this);
}
public CodeExplorerViewModel(FolderHelper folderHelper, RubberduckParserState state, List <ICommand> commands)
{
_folderHelper = folderHelper;
_state = state;
_state.StateChanged += ParserState_StateChanged;
_refreshCommand = new DelegateCommand(param => _state.OnParseRequested(this),
param => !IsBusy && _state.IsDirty());
_refreshComponentCommand = commands.OfType <CodeExplorer_RefreshComponentCommand>().FirstOrDefault();
_navigateCommand = commands.OfType <CodeExplorer_NavigateCommand>().FirstOrDefault();
_addTestModuleCommand = commands.OfType <CodeExplorer_AddTestModuleCommand>().FirstOrDefault();
_addStdModuleCommand = commands.OfType <CodeExplorer_AddStdModuleCommand>().FirstOrDefault();
_addClassModuleCommand = commands.OfType <CodeExplorer_AddClassModuleCommand>().FirstOrDefault();
_addUserFormCommand = commands.OfType <CodeExplorer_AddUserFormCommand>().FirstOrDefault();
_openDesignerCommand = commands.OfType <CodeExplorer_OpenDesignerCommand>().FirstOrDefault();
_renameCommand = commands.OfType <CodeExplorer_RenameCommand>().FirstOrDefault();
_indenterCommand = commands.OfType <CodeExplorer_IndentCommand>().FirstOrDefault();
_findAllReferencesCommand = commands.OfType <CodeExplorer_FindAllReferencesCommand>().FirstOrDefault();
_findAllImplementationsCommand = commands.OfType <CodeExplorer_FindAllImplementationsCommand>().FirstOrDefault();
_importCommand = commands.OfType <CodeExplorer_ImportCommand>().FirstOrDefault();
_exportCommand = commands.OfType <CodeExplorer_ExportCommand>().FirstOrDefault();
_externalRemoveCommand = commands.OfType <CodeExplorer_RemoveCommand>().FirstOrDefault();
if (_externalRemoveCommand != null)
{
_removeCommand = new DelegateCommand(ExecuteRemoveComand, _externalRemoveCommand.CanExecute);
}
_printCommand = commands.OfType <CodeExplorer_PrintCommand>().FirstOrDefault();
_commitCommand = commands.OfType <CodeExplorer_CommitCommand>().FirstOrDefault();
_undoCommand = commands.OfType <CodeExplorer_UndoCommand>().FirstOrDefault();
_copyResultsCommand = commands.OfType <CodeExplorer_CopyResultsCommand>().FirstOrDefault();
_setNameSortCommand = new DelegateCommand(param =>
{
SortByName = (bool)param;
SortBySelection = !(bool)param;
});
_setSelectionSortCommand = new DelegateCommand(param =>
{
SortBySelection = (bool)param;
SortByName = !(bool)param;
});
}
private void PromoteVariable(Declaration target)
{
if (new[] { DeclarationType.ClassModule, DeclarationType.ProceduralModule }.Contains(target.ParentDeclaration.DeclarationType))
{
_messageBox.Show(RubberduckUI.PromoteVariable_InvalidSelection, RubberduckUI.IntroduceParameter_Caption,
MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
return;
}
RemoveVariable(target);
AddField(target);
_state.OnParseRequested(this);
}
