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); }