diff --git a/RetailCoder.VBE/API/ParserState.cs b/RetailCoder.VBE/API/ParserState.cs index f03adbb8a5..1f13660260 100644 --- a/RetailCoder.VBE/API/ParserState.cs +++ b/RetailCoder.VBE/API/ParserState.cs @@ -63,12 +63,12 @@ public void Initialize(VBE vbe) throw new InvalidOperationException("ParserState is already initialized."); } - _state = new RubberduckParserState(vbe, new Sinks(vbe)); + _state = new RubberduckParserState(new Sinks(vbe)); _state.StateChanged += _state_StateChanged; Func preprocessorFactory = () => new VBAPreprocessor(double.Parse(vbe.Version, CultureInfo.InvariantCulture)); _attributeParser = new AttributeParser(new ModuleExporter(), preprocessorFactory); - _parser = new RubberduckParser(_state, _attributeParser, preprocessorFactory, + _parser = new RubberduckParser(vbe, _state, _attributeParser, preprocessorFactory, new List { new DebugDeclarations(_state), new FormEventDeclarations(_state), new AliasDeclarations(_state) }); } diff --git a/RetailCoder.VBE/App.cs b/RetailCoder.VBE/App.cs index cb87d278b8..4e1b1a53ee 100644 --- a/RetailCoder.VBE/App.cs +++ b/RetailCoder.VBE/App.cs @@ -205,6 +205,7 @@ public void Dispose() { _parser.State.StateChanged -= Parser_StateChanged; _parser.State.StatusMessageUpdate -= State_StatusMessageUpdate; + _parser.State.Dispose(); _parser.Dispose(); // I won't set this to null because other components may try to release things } diff --git a/RetailCoder.VBE/Inspections/ConvertToProcedureQuickFix.cs b/RetailCoder.VBE/Inspections/ConvertToProcedureQuickFix.cs index 3530a3ef03..6a4e87cadc 100644 --- a/RetailCoder.VBE/Inspections/ConvertToProcedureQuickFix.cs +++ b/RetailCoder.VBE/Inspections/ConvertToProcedureQuickFix.cs @@ -6,24 +6,18 @@ using System.Collections.Generic; using System.Linq; using System.Text.RegularExpressions; -using Microsoft.Vbe.Interop; using Rubberduck.Parsing.Symbols; namespace Rubberduck.Inspections { public class ConvertToProcedureQuickFix : CodeInspectionQuickFix { - private readonly IEnumerable _returnStatements; + private readonly Declaration _target; - public ConvertToProcedureQuickFix(ParserRuleContext context, QualifiedSelection selection) - : this(context, selection, new List()) - { - } - - public ConvertToProcedureQuickFix(ParserRuleContext context, QualifiedSelection selection, IEnumerable returnStatements) + public ConvertToProcedureQuickFix(ParserRuleContext context, QualifiedSelection selection, Declaration target) : base(context, selection, InspectionsUI.ConvertFunctionToProcedureQuickFix) { - _returnStatements = returnStatements; + _target = target; } public override void Fix() @@ -37,47 +31,53 @@ public override void Fix() throw new InvalidOperationException(string.Format(InspectionsUI.InvalidContextTypeInspectionFix, Context.GetType(), GetType())); } + var functionName = Context is VBAParser.FunctionStmtContext + ? ((VBAParser.FunctionStmtContext) Context).functionName() + : ((VBAParser.PropertyGetStmtContext) Context).functionName(); - VBAParser.FunctionNameContext functionName = null; - if (Context is VBAParser.FunctionStmtContext) - { - functionName = ((VBAParser.FunctionStmtContext)Context).functionName(); - } - else - { - functionName = ((VBAParser.PropertyGetStmtContext)Context).functionName(); - } - - string token = functionContext != null + var token = functionContext != null ? Tokens.Function : Tokens.Property + ' ' + Tokens.Get; - string endToken = token == Tokens.Function + var endToken = token == Tokens.Function ? token : Tokens.Property; string visibility = context.visibility() == null ? string.Empty : context.visibility().GetText() + ' '; - string name = ' ' + Identifier.GetName(functionName.identifier()); - bool hasTypeHint = Identifier.GetTypeHintValue(functionName.identifier()) != null; + var name = ' ' + Identifier.GetName(functionName.identifier()); + var hasTypeHint = Identifier.GetTypeHintValue(functionName.identifier()) != null; string args = context.argList().GetText(); string asType = context.asTypeClause() == null ? string.Empty : ' ' + context.asTypeClause().GetText(); - string oldSignature = visibility + token + name + (hasTypeHint ? Identifier.GetTypeHintValue(functionName.identifier()) : string.Empty) + args + asType; - string newSignature = visibility + Tokens.Sub + name + args; + var oldSignature = visibility + token + name + (hasTypeHint ? Identifier.GetTypeHintValue(functionName.identifier()) : string.Empty) + args + asType; + var newSignature = visibility + Tokens.Sub + name + args; - string procedure = Context.GetText(); - string noReturnStatements = procedure; - _returnStatements.ToList().ForEach(returnStatement => + var procedure = Context.GetText(); + var noReturnStatements = procedure; + + GetReturnStatements(_target).ToList().ForEach(returnStatement => noReturnStatements = Regex.Replace(noReturnStatements, @"[ \t\f]*" + returnStatement + @"[ \t\f]*\r?\n?", "")); - string result = noReturnStatements.Replace(oldSignature, newSignature) + var result = noReturnStatements.Replace(oldSignature, newSignature) .Replace(Tokens.End + ' ' + endToken, Tokens.End + ' ' + Tokens.Sub) .Replace(Tokens.Exit + ' ' + endToken, Tokens.Exit + ' ' + Tokens.Sub); - CodeModule module = Selection.QualifiedName.Component.CodeModule; - Selection selection = Context.GetSelection(); + var module = Selection.QualifiedName.Component.CodeModule; + var selection = Context.GetSelection(); module.DeleteLines(selection.StartLine, selection.LineCount); module.InsertLines(selection.StartLine, result); } + + private IEnumerable GetReturnStatements(Declaration declaration) + { + return declaration.References + .Where(usage => IsReturnStatement(declaration, usage)) + .Select(usage => usage.Context.Parent.GetText()); + } + + private bool IsReturnStatement(Declaration declaration, IdentifierReference assignment) + { + return assignment.ParentScoping.Equals(declaration) && assignment.Declaration.Equals(declaration); + } } } diff --git a/RetailCoder.VBE/Inspections/EncapsulatePublicFieldInspection.cs b/RetailCoder.VBE/Inspections/EncapsulatePublicFieldInspection.cs index 3c3244129a..8b91dbd925 100644 --- a/RetailCoder.VBE/Inspections/EncapsulatePublicFieldInspection.cs +++ b/RetailCoder.VBE/Inspections/EncapsulatePublicFieldInspection.cs @@ -5,11 +5,16 @@ namespace Rubberduck.Inspections { + using SmartIndenter; + public sealed class EncapsulatePublicFieldInspection : InspectionBase { - public EncapsulatePublicFieldInspection(RubberduckParserState state) + private readonly IIndenter _indenter; + + public EncapsulatePublicFieldInspection(RubberduckParserState state, IIndenter indenter) : base(state, CodeInspectionSeverity.Suggestion) { + _indenter = indenter; } public override string Meta { get { return InspectionsUI.EncapsulatePublicFieldInspectionMeta; } } @@ -21,7 +26,7 @@ public override IEnumerable GetInspectionResults() var issues = UserDeclarations .Where(declaration => declaration.DeclarationType == DeclarationType.Variable && declaration.Accessibility == Accessibility.Public) - .Select(issue => new EncapsulatePublicFieldInspectionResult(this, issue, State)) + .Select(issue => new EncapsulatePublicFieldInspectionResult(this, issue, State, _indenter)) .ToList(); return issues; diff --git a/RetailCoder.VBE/Inspections/EncapsulatePublicFieldInspectionResult.cs b/RetailCoder.VBE/Inspections/EncapsulatePublicFieldInspectionResult.cs index 311c778711..8ee80cd88e 100644 --- a/RetailCoder.VBE/Inspections/EncapsulatePublicFieldInspectionResult.cs +++ b/RetailCoder.VBE/Inspections/EncapsulatePublicFieldInspectionResult.cs @@ -9,16 +9,18 @@ namespace Rubberduck.Inspections { + using SmartIndenter; + public class EncapsulatePublicFieldInspectionResult : InspectionResultBase { private readonly IEnumerable _quickFixes; - public EncapsulatePublicFieldInspectionResult(IInspection inspection, Declaration target, RubberduckParserState state) + public EncapsulatePublicFieldInspectionResult(IInspection inspection, Declaration target, RubberduckParserState state, IIndenter indenter) : base(inspection, target) { _quickFixes = new CodeInspectionQuickFix[] { - new EncapsulateFieldQuickFix(target.Context, target.QualifiedSelection, target, state), + new EncapsulateFieldQuickFix(target.Context, target.QualifiedSelection, target, state, indenter), new IgnoreOnceQuickFix(Context, QualifiedSelection, Inspection.AnnotationName) }; } @@ -38,22 +40,24 @@ public class EncapsulateFieldQuickFix : CodeInspectionQuickFix { private readonly Declaration _target; private readonly RubberduckParserState _state; + private readonly IIndenter _indenter; - public EncapsulateFieldQuickFix(ParserRuleContext context, QualifiedSelection selection, Declaration target, RubberduckParserState state) + public EncapsulateFieldQuickFix(ParserRuleContext context, QualifiedSelection selection, Declaration target, RubberduckParserState state, IIndenter indenter) : base(context, selection, string.Format(InspectionsUI.EncapsulatePublicFieldInspectionQuickFix, target.IdentifierName)) { _target = target; _state = state; + _indenter = indenter; } public override void Fix() { var vbe = Selection.QualifiedName.Project.VBE; - using (var view = new EncapsulateFieldDialog()) + using (var view = new EncapsulateFieldDialog(_state, _indenter)) { var factory = new EncapsulateFieldPresenterFactory(vbe, _state, view); - var refactoring = new EncapsulateFieldRefactoring(vbe, factory); + var refactoring = new EncapsulateFieldRefactoring(vbe, _indenter, factory); refactoring.Refactor(_target); IsCancelled = view.DialogResult != DialogResult.OK; } diff --git a/RetailCoder.VBE/Inspections/FunctionReturnValueNotUsedInspection.cs b/RetailCoder.VBE/Inspections/FunctionReturnValueNotUsedInspection.cs index 8ab10a942b..20c63a61e7 100644 --- a/RetailCoder.VBE/Inspections/FunctionReturnValueNotUsedInspection.cs +++ b/RetailCoder.VBE/Inspections/FunctionReturnValueNotUsedInspection.cs @@ -46,11 +46,10 @@ private IEnumerable GetInterfaceMemb implementationMember => Tuple.Create(implementationMember.Context, new QualifiedSelection(implementationMember.QualifiedName.QualifiedModuleName, - implementationMember.Selection), GetReturnStatements(implementationMember))) + implementationMember.Selection), implementationMember)) select new FunctionReturnValueNotUsedInspectionResult(this, interfaceMember.Context, - interfaceMember.QualifiedName, GetReturnStatements(interfaceMember), - implementationMemberIssues, interfaceMember); + interfaceMember.QualifiedName, implementationMemberIssues, interfaceMember); } private IEnumerable GetNonInterfaceIssues(IEnumerable nonInterfaceFunctions) @@ -62,18 +61,10 @@ private IEnumerable GetNonInterfaceI this, function.Context, function.QualifiedName, - GetReturnStatements(function), function)); return nonInterfaceIssues; } - private IEnumerable GetReturnStatements(Declaration function) - { - return function.References - .Where(usage => IsReturnStatement(function, usage)) - .Select(usage => usage.Context.Parent.Parent.Parent.GetText()); - } - private bool IsReturnValueUsed(Declaration function) { foreach (var usage in function.References) diff --git a/RetailCoder.VBE/Inspections/FunctionReturnValueNotUsedInspectionResult.cs b/RetailCoder.VBE/Inspections/FunctionReturnValueNotUsedInspectionResult.cs index 180ce98bcc..069e910bda 100644 --- a/RetailCoder.VBE/Inspections/FunctionReturnValueNotUsedInspectionResult.cs +++ b/RetailCoder.VBE/Inspections/FunctionReturnValueNotUsedInspectionResult.cs @@ -16,9 +16,8 @@ public FunctionReturnValueNotUsedInspectionResult( IInspection inspection, ParserRuleContext context, QualifiedMemberName qualifiedName, - IEnumerable returnStatements, Declaration target) - : this(inspection, context, qualifiedName, returnStatements, new List>>(), target) + : this(inspection, context, qualifiedName, new List>(), target) { } @@ -26,12 +25,11 @@ public FunctionReturnValueNotUsedInspectionResult( IInspection inspection, ParserRuleContext context, QualifiedMemberName qualifiedName, - IEnumerable returnStatements, - IEnumerable>> children, + IEnumerable> children, Declaration target) : base(inspection, qualifiedName.QualifiedModuleName, context, target) { - var root = new ConvertToProcedureQuickFix(context, QualifiedSelection, returnStatements); + var root = new ConvertToProcedureQuickFix(context, QualifiedSelection, target); var compositeFix = new CompositeCodeInspectionFix(root); children.ToList().ForEach(child => compositeFix.AddChild(new ConvertToProcedureQuickFix(child.Item1, child.Item2, child.Item3))); _quickFixes = new CodeInspectionQuickFix[] diff --git a/RetailCoder.VBE/Inspections/IInspector.cs b/RetailCoder.VBE/Inspections/IInspector.cs index b5e50e5755..717b752204 100644 --- a/RetailCoder.VBE/Inspections/IInspector.cs +++ b/RetailCoder.VBE/Inspections/IInspector.cs @@ -6,7 +6,7 @@ namespace Rubberduck.Inspections { - public interface IInspector + public interface IInspector : IDisposable { Task> FindIssuesAsync(RubberduckParserState state, CancellationToken token); } diff --git a/RetailCoder.VBE/Inspections/IParseTreeInspection.cs b/RetailCoder.VBE/Inspections/IParseTreeInspection.cs index f1b0520c10..4770533e77 100644 --- a/RetailCoder.VBE/Inspections/IParseTreeInspection.cs +++ b/RetailCoder.VBE/Inspections/IParseTreeInspection.cs @@ -25,6 +25,6 @@ public ParseTreeResults() public IEnumerable ObsoleteLetContexts; public IEnumerable ArgListsWithOneByRefParam; public IEnumerable EmptyStringLiterals; - public IEnumerable> MalformedAnnotations; + public IEnumerable MalformedAnnotations; } } diff --git a/RetailCoder.VBE/Inspections/InspectionsUI.Designer.cs b/RetailCoder.VBE/Inspections/InspectionsUI.Designer.cs index 55715ed126..b14a7313c5 100644 --- a/RetailCoder.VBE/Inspections/InspectionsUI.Designer.cs +++ b/RetailCoder.VBE/Inspections/InspectionsUI.Designer.cs @@ -1240,7 +1240,8 @@ public static string UnassignedVariableUsageInspectionResultFormat { } /// - /// Looks up a localized string similar to A string-returning equivalent function exists and should preferably be used to avoid implicit type conversions.. + /// Looks up a localized string similar to A string-returning equivalent function exists and should preferably be used to avoid implicit type conversions. + ///If the parameter can be null, ignore this inspection result; passing a null value to a function expecting a string would raise a type mismatch runtime error.. /// public static string UntypedFunctionUsageInspectionMeta { get { @@ -1391,5 +1392,14 @@ public static string WriteOnlyPropertyInspectionResultFormat { return ResourceManager.GetString("WriteOnlyPropertyInspectionResultFormat", resourceCulture); } } + + /// + /// Looks up a localized string similar to Add property get. + /// + public static string WriteOnlyPropertyQuickFix { + get { + return ResourceManager.GetString("WriteOnlyPropertyQuickFix", resourceCulture); + } + } } } diff --git a/RetailCoder.VBE/Inspections/InspectionsUI.de.resx b/RetailCoder.VBE/Inspections/InspectionsUI.de.resx index a101e684f2..5a2050762b 100644 --- a/RetailCoder.VBE/Inspections/InspectionsUI.de.resx +++ b/RetailCoder.VBE/Inspections/InspectionsUI.de.resx @@ -304,7 +304,8 @@ Variable wird genutzt ohne das ihr ein Wert zugewiesen wurde. - Eine gibt eine Funktion, die einen String Äquivalnet zurückgibt. Diese sollte bevorzugt genutzt werden, um implitizite Typumwandlungen zu vermeiden. + Eine gibt eine Funktion, die einen String Äquivalent zurückgibt. Diese sollte bevorzugt genutzt werden, um implitizite Typumwandlungen zu vermeiden. +Falls der Parameter 'null' sein kann, bitte dieses Auftreten ignorieren. 'null' an die Funktion zu übergeben, die einen String erwartet würde zu einem "Type Mismatch"-Laufzeitfehler führen. Nutzung einer Funktion, die einen 'String Variant' zurückgibt. @@ -554,4 +555,13 @@ Instruktion enthält Mehrfachdeklaration + + Unlesbare Annotation + + + Annotation '{0}' ist nicht lesbar + + + Eine Annotation in einem Kommentar konnte nicht gelesen werden. + diff --git a/RetailCoder.VBE/Inspections/InspectionsUI.fr.resx b/RetailCoder.VBE/Inspections/InspectionsUI.fr.resx index ecd1aa7928..b585c0616e 100644 --- a/RetailCoder.VBE/Inspections/InspectionsUI.fr.resx +++ b/RetailCoder.VBE/Inspections/InspectionsUI.fr.resx @@ -1,4 +1,4 @@ - + - + @@ -303,9 +303,6 @@ La variable est utilisée, mais non assignée - - Une fonction équivalente existe, qui retourne une valeur 'String' et pourrait éviter une conversion implicite de type. - Utilisation d'une fonction retournant une 'String' dans une variable 'Variant' @@ -494,64 +491,67 @@ Désactiver cette inspection - + Le type de contexte '{0}' est invalide pour {1}. - + Utiliser le mot-clé 'Set' - + {0}: {1} - {2} {3}.{4}, ligne {5} - + L'assignation d'une référence d'objet requiert le mot-clé 'Set' - + Préférez 'vbNullString' à une chaîne de caractères vide - + La variable '{0}' est assignée dans le mot-clé 'Set' - + Rubberduck voit cette variable comme étant une référence à un objet, assignée sans le mot-clé 'Set'. Ceci cause une erreur d'exécution (#91 'Object or With block variable not set'). - + Le membre '{0}' réfère implicitement au classeur actif - + L'instruction comporte plusieurs déclarations - + Utilisation - + Déclaration - + {0} '{1}' est implicitement de type 'Variant' - + Le projet '{0}' n'est pas nommé - + L'assignation utilise le mot-clé obsolète 'Call' - + L'assignation utilise le mot-clé obsolète 'Let' - + Le module '{0}' utilise 'Option Base 1' - + Le commentaire utilise la forme obsolète 'Rem' - + {0} de {1} '{2}' utilise un indicateur de type - + Le membre '{0}' réfère implicitement à la feuille active - + Remplacer la fonction '{0}' par la fonction typée équivalente - + + + + \ No newline at end of file diff --git a/RetailCoder.VBE/Inspections/InspectionsUI.ja.Designer.cs b/RetailCoder.VBE/Inspections/InspectionsUI.ja.Designer.cs deleted file mode 100644 index e69de29bb2..0000000000 diff --git a/RetailCoder.VBE/Inspections/InspectionsUI.ja.resx b/RetailCoder.VBE/Inspections/InspectionsUI.ja.resx deleted file mode 100644 index 45645ff840..0000000000 --- a/RetailCoder.VBE/Inspections/InspectionsUI.ja.resx +++ /dev/null @@ -1,557 +0,0 @@ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - text/microsoft-resx - - - 2.0 - - - System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 - - - System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - {0} Procedure name - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - {0} Property name - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - diff --git a/RetailCoder.VBE/Inspections/InspectionsUI.resx b/RetailCoder.VBE/Inspections/InspectionsUI.resx index 3124353204..05155ee82c 100644 --- a/RetailCoder.VBE/Inspections/InspectionsUI.resx +++ b/RetailCoder.VBE/Inspections/InspectionsUI.resx @@ -304,7 +304,8 @@ Variable is used but not assigned - A string-returning equivalent function exists and should preferably be used to avoid implicit type conversions. + A string-returning equivalent function exists and should preferably be used to avoid implicit type conversions. +If the parameter can be null, ignore this inspection result; passing a null value to a function expecting a string would raise a type mismatch runtime error. Use of variant-returning string function @@ -564,4 +565,7 @@ Malformed '{0}' annotation. + + Add property get + \ No newline at end of file diff --git a/RetailCoder.VBE/Inspections/InspectionsUI.sv.Designer.cs b/RetailCoder.VBE/Inspections/InspectionsUI.sv.Designer.cs deleted file mode 100644 index e69de29bb2..0000000000 diff --git a/RetailCoder.VBE/Inspections/InspectionsUI.sv.resx b/RetailCoder.VBE/Inspections/InspectionsUI.sv.resx deleted file mode 100644 index 45645ff840..0000000000 --- a/RetailCoder.VBE/Inspections/InspectionsUI.sv.resx +++ /dev/null @@ -1,557 +0,0 @@ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - text/microsoft-resx - - - 2.0 - - - System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 - - - System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - {0} Procedure name - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - {0} Property name - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - diff --git a/RetailCoder.VBE/Inspections/Inspector.cs b/RetailCoder.VBE/Inspections/Inspector.cs index b8d2dd9c11..b7916af31a 100644 --- a/RetailCoder.VBE/Inspections/Inspector.cs +++ b/RetailCoder.VBE/Inspections/Inspector.cs @@ -15,20 +15,20 @@ namespace Rubberduck.Inspections { namespace Rubberduck.Inspections { - public class Inspector : IInspector, IDisposable + public class Inspector : IInspector { private readonly IGeneralConfigService _configService; - private readonly IEnumerable _inspections; + private readonly List _inspections; public Inspector(IGeneralConfigService configService, IEnumerable inspections) { - _inspections = inspections; + _inspections = inspections.ToList(); _configService = configService; - configService.SettingsChanged += ConfigServiceLanguageChanged; + configService.SettingsChanged += ConfigServiceSettingsChanged; } - private void ConfigServiceLanguageChanged(object sender, EventArgs e) + private void ConfigServiceSettingsChanged(object sender, EventArgs e) { UpdateInspectionSeverity(); } @@ -125,8 +125,10 @@ public void Dispose() { if (_configService != null) { - _configService.SettingsChanged -= ConfigServiceLanguageChanged; + _configService.SettingsChanged -= ConfigServiceSettingsChanged; } + + _inspections.Clear(); } } } diff --git a/RetailCoder.VBE/Inspections/MalformedAnnotationInspection.cs b/RetailCoder.VBE/Inspections/MalformedAnnotationInspection.cs index 8d59a4c10e..1934cbec70 100644 --- a/RetailCoder.VBE/Inspections/MalformedAnnotationInspection.cs +++ b/RetailCoder.VBE/Inspections/MalformedAnnotationInspection.cs @@ -27,16 +27,18 @@ public override IEnumerable GetInspectionResults() var results = new List(); - foreach (var context in ParseTreeResults.MalformedAnnotations) + foreach (var result in ParseTreeResults.MalformedAnnotations) { - if (context.Context.annotationName().GetText() == AnnotationType.Ignore.ToString() || - context.Context.annotationName().GetText() == AnnotationType.Folder.ToString()) + var context = (VBAParser.AnnotationContext)result.Context; + + if (context.annotationName().GetText() == AnnotationType.Ignore.ToString() || + context.annotationName().GetText() == AnnotationType.Folder.ToString()) { - if (context.Context.annotationArgList() == null) + if (context.annotationArgList() == null) { results.Add(new MalformedAnnotationInspectionResult(this, - new QualifiedContext(context.ModuleName, - context.Context))); + new QualifiedContext(result.ModuleName, + context))); } } } diff --git a/RetailCoder.VBE/Inspections/NonReturningFunctionInspectionResult.cs b/RetailCoder.VBE/Inspections/NonReturningFunctionInspectionResult.cs index dc3ec0f333..a365a83fad 100644 --- a/RetailCoder.VBE/Inspections/NonReturningFunctionInspectionResult.cs +++ b/RetailCoder.VBE/Inspections/NonReturningFunctionInspectionResult.cs @@ -20,7 +20,7 @@ public NonReturningFunctionInspectionResult(IInspection inspection, ? new CodeInspectionQuickFix[] { } : new CodeInspectionQuickFix[] { - new ConvertToProcedureQuickFix(Context, QualifiedSelection), + new ConvertToProcedureQuickFix(Context, QualifiedSelection, target), new IgnoreOnceQuickFix(Context, QualifiedSelection, Inspection.AnnotationName), }; } diff --git a/RetailCoder.VBE/Inspections/ObsoleteCommentSyntaxInspectionResult.cs b/RetailCoder.VBE/Inspections/ObsoleteCommentSyntaxInspectionResult.cs index 5824d63092..d0532c5bf8 100644 --- a/RetailCoder.VBE/Inspections/ObsoleteCommentSyntaxInspectionResult.cs +++ b/RetailCoder.VBE/Inspections/ObsoleteCommentSyntaxInspectionResult.cs @@ -48,7 +48,7 @@ public override void Fix() return; } - var content = module.get_Lines(Selection.Selection.StartLine, Selection.Selection.LineCount); + var content = module.Lines[Selection.Selection.StartLine, Selection.Selection.LineCount]; int markerPosition; if (!content.HasComment(out markerPosition)) @@ -59,7 +59,7 @@ public override void Fix() var code = string.Empty; if (markerPosition > 0) { - code = content.Substring(0, markerPosition - 1); + code = content.Substring(0, markerPosition).TrimEnd(); } if (_comment.QualifiedSelection.Selection.LineCount > 1) @@ -89,7 +89,7 @@ public override void Fix() return; } - var content = module.get_Lines(Selection.Selection.StartLine, Selection.Selection.LineCount); + var content = module.Lines[Selection.Selection.StartLine, Selection.Selection.LineCount]; int markerPosition; if (!content.HasComment(out markerPosition)) @@ -100,7 +100,7 @@ public override void Fix() var code = string.Empty; if (markerPosition > 0) { - code = content.Substring(0, markerPosition - 1); + code = content.Substring(0, markerPosition); } var newContent = code + Tokens.CommentMarker + " " + _comment.CommentText; diff --git a/RetailCoder.VBE/Inspections/ParameterNotUsedInspection.cs b/RetailCoder.VBE/Inspections/ParameterNotUsedInspection.cs index df9c5e3deb..9fa7310819 100644 --- a/RetailCoder.VBE/Inspections/ParameterNotUsedInspection.cs +++ b/RetailCoder.VBE/Inspections/ParameterNotUsedInspection.cs @@ -1,24 +1,19 @@ using System.Collections.Generic; using System.Linq; -using Microsoft.Vbe.Interop; using Rubberduck.Common; using Rubberduck.Parsing.Symbols; using Rubberduck.Parsing.VBA; -using Rubberduck.Refactorings.RemoveParameters; using Rubberduck.UI; -using Rubberduck.UI.Refactorings; namespace Rubberduck.Inspections { public sealed class ParameterNotUsedInspection : InspectionBase { - private readonly VBE _vbe; private readonly IMessageBox _messageBox; - public ParameterNotUsedInspection(VBE vbe, RubberduckParserState state, IMessageBox messageBox) + public ParameterNotUsedInspection(RubberduckParserState state, IMessageBox messageBox) : base(state) { - _vbe = vbe; _messageBox = messageBox; } @@ -41,8 +36,6 @@ public override IEnumerable GetInspectionResults() && parameter.ParentDeclaration.DeclarationType != DeclarationType.LibraryProcedure); var unused = parameters.Where(parameter => !parameter.References.Any()).ToList(); - var quickFixRefactoring = - new RemoveParametersRefactoring(_vbe, new RemoveParametersPresenterFactory(_vbe, new RemoveParametersDialog(), State, _messageBox)); var issues = from issue in unused.Where(parameter => !IsInterfaceMemberParameter(parameter, interfaceMemberScopes) @@ -50,7 +43,7 @@ public override IEnumerable GetInspectionResults() let isInterfaceImplementationMember = IsInterfaceMemberImplementationParameter(issue, interfaceImplementationMemberScopes) select new ParameterNotUsedInspectionResult(this, issue, ((dynamic) issue.Context).unrestrictedIdentifier(), issue.QualifiedName, - isInterfaceImplementationMember, quickFixRefactoring, State); + isInterfaceImplementationMember, issue.Project.VBE, State, _messageBox); return issues.ToList(); } diff --git a/RetailCoder.VBE/Inspections/ParameterNotUsedInspectionResult.cs b/RetailCoder.VBE/Inspections/ParameterNotUsedInspectionResult.cs index 5ae6f58b49..4718f389a8 100644 --- a/RetailCoder.VBE/Inspections/ParameterNotUsedInspectionResult.cs +++ b/RetailCoder.VBE/Inspections/ParameterNotUsedInspectionResult.cs @@ -4,6 +4,9 @@ using Rubberduck.Parsing.VBA; using Rubberduck.Refactorings.RemoveParameters; using Rubberduck.VBEditor; +using Microsoft.Vbe.Interop; +using Rubberduck.UI; +using Rubberduck.UI.Refactorings; namespace Rubberduck.Inspections { @@ -13,12 +16,12 @@ public class ParameterNotUsedInspectionResult : InspectionResultBase public ParameterNotUsedInspectionResult(IInspection inspection, Declaration target, ParserRuleContext context, QualifiedMemberName qualifiedName, bool isInterfaceImplementation, - RemoveParametersRefactoring refactoring, RubberduckParserState state) + VBE vbe, RubberduckParserState state, IMessageBox messageBox) : base(inspection, qualifiedName.QualifiedModuleName, context, target) { _quickFixes = isInterfaceImplementation ? new CodeInspectionQuickFix[] {} : new CodeInspectionQuickFix[] { - new RemoveUnusedParameterQuickFix(Context, QualifiedSelection, refactoring, state), + new RemoveUnusedParameterQuickFix(Context, QualifiedSelection, vbe, state, messageBox), new IgnoreOnceQuickFix(Context, QualifiedSelection, Inspection.AnnotationName), }; } @@ -33,20 +36,28 @@ public override string Description public class RemoveUnusedParameterQuickFix : CodeInspectionQuickFix { - private readonly RemoveParametersRefactoring _quickFixRefactoring; + private readonly VBE _vbe; private readonly RubberduckParserState _state; + private readonly IMessageBox _messageBox; public RemoveUnusedParameterQuickFix(ParserRuleContext context, QualifiedSelection selection, - RemoveParametersRefactoring quickFixRefactoring, RubberduckParserState state) + VBE vbe, RubberduckParserState state, IMessageBox messageBox) : base(context, selection, InspectionsUI.RemoveUnusedParameterQuickFix) { - _quickFixRefactoring = quickFixRefactoring; + _vbe = vbe; _state = state; + _messageBox = messageBox; } public override void Fix() { - _quickFixRefactoring.QuickFix(_state, Selection); + using (var dialog = new RemoveParametersDialog()) + { + var refactoring = new RemoveParametersRefactoring(_vbe, + new RemoveParametersPresenterFactory(_vbe, dialog, _state, _messageBox)); + + refactoring.QuickFix(_state, Selection); + } } } } diff --git a/RetailCoder.VBE/Inspections/UnassignedVariableUsageInspection.cs b/RetailCoder.VBE/Inspections/UnassignedVariableUsageInspection.cs index 9cfbbd8106..7ef8238235 100644 --- a/RetailCoder.VBE/Inspections/UnassignedVariableUsageInspection.cs +++ b/RetailCoder.VBE/Inspections/UnassignedVariableUsageInspection.cs @@ -20,19 +20,17 @@ public UnassignedVariableUsageInspection(RubberduckParserState state) public override IEnumerable GetInspectionResults() { - var usages = UserDeclarations.Where(declaration => + var declarations = UserDeclarations.Where(declaration => declaration.DeclarationType == DeclarationType.Variable && !UserDeclarations.Any(d => d.DeclarationType == DeclarationType.UserDefinedType && d.IdentifierName == declaration.AsTypeName) && !declaration.IsSelfAssigned - && !declaration.References.Any(reference => reference.IsAssignment)) - .SelectMany(declaration => declaration.References) - .Where(usage => !usage.IsInspectionDisabled(AnnotationName)); + && !declaration.References.Any(reference => reference.IsAssignment)); var lenFunction = BuiltInDeclarations.SingleOrDefault(s => s.Scope == "VBE7.DLL;VBA.Strings.Len"); var lenbFunction = BuiltInDeclarations.SingleOrDefault(s => s.Scope == "VBE7.DLL;VBA.Strings.LenB"); - foreach (var issue in usages) + foreach (var issue in declarations) { if (DeclarationReferencesContainsReference(lenFunction, issue) || DeclarationReferencesContainsReference(lenbFunction, issue)) @@ -40,34 +38,29 @@ public override IEnumerable GetInspectionResults() continue; } - yield return - new UnassignedVariableUsageInspectionResult(this, issue.Context, issue.QualifiedModuleName, - issue.Declaration); + yield return new UnassignedVariableUsageInspectionResult(this, issue.Context, issue.QualifiedName.QualifiedModuleName, issue); } } - private bool DeclarationReferencesContainsReference(Declaration parentDeclaration, IdentifierReference issue) + private bool DeclarationReferencesContainsReference(Declaration parentDeclaration, Declaration target) { if (parentDeclaration == null) { return false; } - - var lenUsesIssue = false; - foreach (var reference in parentDeclaration.References) + + foreach (var targetReference in target.References) { - var context = (ParserRuleContext) reference.Context.Parent; - if (context.GetSelection().Contains(issue.Selection)) + foreach (var reference in parentDeclaration.References) { - lenUsesIssue = true; - break; + var context = (ParserRuleContext) reference.Context.Parent; + if (context.GetSelection().Contains(targetReference.Selection)) + { + return true; + } } } - - if (lenUsesIssue) - { - return true; - } + return false; } } diff --git a/RetailCoder.VBE/Inspections/UnassignedVariableUsageInspectionResult.cs b/RetailCoder.VBE/Inspections/UnassignedVariableUsageInspectionResult.cs index e7add5da61..c9b88161da 100644 --- a/RetailCoder.VBE/Inspections/UnassignedVariableUsageInspectionResult.cs +++ b/RetailCoder.VBE/Inspections/UnassignedVariableUsageInspectionResult.cs @@ -15,7 +15,7 @@ public UnassignedVariableUsageInspectionResult(IInspection inspection, ParserRul { _quickFixes = new CodeInspectionQuickFix[] { - new RemoveUnassignedVariableUsageQuickFix(Context, QualifiedSelection), + //new RemoveUnassignedVariableUsageQuickFix(Context, QualifiedSelection), // removed until we can reinstate this for a specific reference new IgnoreOnceQuickFix(Context, QualifiedSelection, Inspection.AnnotationName), }; } @@ -43,7 +43,7 @@ public override void Fix() var module = Selection.QualifiedName.Component.CodeModule; var selection = Selection.Selection; - var originalCodeLines = module.get_Lines(selection.StartLine, selection.LineCount) + var originalCodeLines = module.Lines[selection.StartLine, selection.LineCount] .Replace(Environment.NewLine, " ") .Replace("_", string.Empty); diff --git a/RetailCoder.VBE/Inspections/UseMeaningfulNameInspection.cs b/RetailCoder.VBE/Inspections/UseMeaningfulNameInspection.cs index ac54a91323..7c4b33a729 100644 --- a/RetailCoder.VBE/Inspections/UseMeaningfulNameInspection.cs +++ b/RetailCoder.VBE/Inspections/UseMeaningfulNameInspection.cs @@ -1,8 +1,11 @@ using System; using System.Collections.Generic; +using System.IO; using System.Linq; using Rubberduck.Parsing.Symbols; using Rubberduck.Parsing.VBA; +using Rubberduck.Settings; +using Rubberduck.SettingsProvider; using Rubberduck.UI; namespace Rubberduck.Inspections @@ -10,11 +13,13 @@ namespace Rubberduck.Inspections public sealed class UseMeaningfulNameInspection : InspectionBase { private readonly IMessageBox _messageBox; + private readonly IPersistanceService _settings; - public UseMeaningfulNameInspection(IMessageBox messageBox, RubberduckParserState state) + public UseMeaningfulNameInspection(IMessageBox messageBox, RubberduckParserState state, IPersistanceService settings) : base(state, CodeInspectionSeverity.Suggestion) { _messageBox = messageBox; + _settings = settings; } public override string Description { get { return InspectionsUI.UseMeaningfulNameInspectionName; } } @@ -22,8 +27,17 @@ public UseMeaningfulNameInspection(IMessageBox messageBox, RubberduckParserState public override IEnumerable GetInspectionResults() { + var whitelistedNames = new List(); + + try + { + whitelistedNames = _settings.Load(new CodeInspectionSettings()).WhitelistedIdentifiers.Select(s => s.Identifier).ToList(); + } + catch (IOException) { } + var issues = UserDeclarations - .Where(declaration => declaration.DeclarationType != DeclarationType.ModuleOption && + .Where(declaration => declaration.DeclarationType != DeclarationType.ModuleOption && + !whitelistedNames.Contains(declaration.IdentifierName) && (declaration.IdentifierName.Length < 3 || char.IsDigit(declaration.IdentifierName.Last()) || !declaration.IdentifierName.Any(c => diff --git a/RetailCoder.VBE/Inspections/VariableTypeNotDeclaredInspectionResult.cs b/RetailCoder.VBE/Inspections/VariableTypeNotDeclaredInspectionResult.cs index 6b7f10a132..777c30129c 100644 --- a/RetailCoder.VBE/Inspections/VariableTypeNotDeclaredInspectionResult.cs +++ b/RetailCoder.VBE/Inspections/VariableTypeNotDeclaredInspectionResult.cs @@ -66,7 +66,7 @@ public override void Fix() return; } - var fixedCodeLine = codeLine.Replace(originalInstruction, fix); + var fixedCodeLine = codeLine.Remove(Context.Start.Column, originalInstruction.Length).Insert(Context.Start.Column, fix); codeModule.ReplaceLine(Selection.Selection.StartLine, fixedCodeLine); } diff --git a/RetailCoder.VBE/Inspections/WriteOnlyPropertyInspection.cs b/RetailCoder.VBE/Inspections/WriteOnlyPropertyInspection.cs index 6637746c90..28c5e5c3c4 100644 --- a/RetailCoder.VBE/Inspections/WriteOnlyPropertyInspection.cs +++ b/RetailCoder.VBE/Inspections/WriteOnlyPropertyInspection.cs @@ -54,6 +54,7 @@ public override IEnumerable QuickFixes { return new CodeInspectionQuickFix[] { + new WriteOnlyPropertyQuickFix(Context, Target), new IgnoreOnceQuickFix(Context, QualifiedSelection, Inspection.AnnotationName) }; } diff --git a/RetailCoder.VBE/Inspections/WriteOnlyPropertyQuickFix.cs b/RetailCoder.VBE/Inspections/WriteOnlyPropertyQuickFix.cs new file mode 100644 index 0000000000..be09ef8cba --- /dev/null +++ b/RetailCoder.VBE/Inspections/WriteOnlyPropertyQuickFix.cs @@ -0,0 +1,36 @@ +using System; +using System.Linq; +using Antlr4.Runtime; +using Rubberduck.Parsing.Grammar; +using Rubberduck.Parsing.Symbols; + +namespace Rubberduck.Inspections +{ + public class WriteOnlyPropertyQuickFix : CodeInspectionQuickFix + { + private readonly Declaration _target; + + public WriteOnlyPropertyQuickFix(ParserRuleContext context, Declaration target) + : base(context, target.QualifiedSelection, InspectionsUI.WriteOnlyPropertyQuickFix) + { + _target = target; + } + + public override void Fix() + { + var parameters = ((IDeclarationWithParameter) _target).Parameters.Cast().ToList(); + + var signatureParams = parameters.Except(new[] {parameters.Last()}).Select(GetParamText); + var propertyGet = "Public Property Get " + _target.IdentifierName + "(" + string.Join(", ", signatureParams) + + ") As " + parameters.Last().AsTypeName + Environment.NewLine + "End Property"; + + var module = _target.QualifiedName.QualifiedModuleName.Component.CodeModule; + module.InsertLines(_target.Selection.StartLine, propertyGet); + } + + private string GetParamText(ParameterDeclaration param) + { + return (((VBAParser.ArgContext)param.Context).BYVAL() == null ? "ByRef " : "ByVal ") + param.IdentifierName + " As " + param.AsTypeName; + } + } +} diff --git a/RetailCoder.VBE/Navigation/CodeExplorer/CodeExplorerItemViewModel.cs b/RetailCoder.VBE/Navigation/CodeExplorer/CodeExplorerItemViewModel.cs index 07de00dbcc..01af484f5b 100644 --- a/RetailCoder.VBE/Navigation/CodeExplorer/CodeExplorerItemViewModel.cs +++ b/RetailCoder.VBE/Navigation/CodeExplorer/CodeExplorerItemViewModel.cs @@ -1,6 +1,7 @@ using System.Collections.Generic; using System.Linq; using System.Windows.Media.Imaging; +using Microsoft.Vbe.Interop; using Rubberduck.Parsing.Symbols; using Rubberduck.UI; using Rubberduck.VBEditor; @@ -74,15 +75,22 @@ public override int Compare(CodeExplorerItemViewModel x, CodeExplorerItemViewMod return xNode.Declaration.DeclarationType < yNode.Declaration.DeclarationType ? -1 : 1; } - // keep types with different icons and the same declaration type (document/class module) separate - // documents come first + if (xNode.Declaration.Accessibility != yNode.Declaration.Accessibility) + { + return xNode.Declaration.Accessibility < yNode.Declaration.Accessibility ? -1 : 1; + } + if (x.ExpandedIcon != y.ExpandedIcon) { - // ReSharper disable once PossibleInvalidOperationException - this will have a component - return x.QualifiedSelection.Value.QualifiedName.Component.Type == - Microsoft.Vbe.Interop.vbext_ComponentType.vbext_ct_Document - ? -1 - : 1; + // ReSharper disable PossibleInvalidOperationException - this will have a component + var xComponent = x.QualifiedSelection.Value.QualifiedName.Component; + var yComponent = y.QualifiedSelection.Value.QualifiedName.Component; + + if (xComponent.Type == vbext_ComponentType.vbext_ct_Document ^ + yComponent.Type == vbext_ComponentType.vbext_ct_Document) + { + return xComponent.Type == vbext_ComponentType.vbext_ct_Document ? -1 : 1; + } } return 0; @@ -163,7 +171,17 @@ protected set } } - public bool IsExpanded { get; set; } + private bool _isExpanded; + public bool IsExpanded + { + get { return _isExpanded; } + set + { + _isExpanded = value; + OnPropertyChanged(); + } + } + public bool IsSelected { get; set; } public abstract string Name { get; } diff --git a/RetailCoder.VBE/Navigation/CodeExplorer/CodeExplorerViewModel.cs b/RetailCoder.VBE/Navigation/CodeExplorer/CodeExplorerViewModel.cs index 95f0f4cf87..cb85567a79 100644 --- a/RetailCoder.VBE/Navigation/CodeExplorer/CodeExplorerViewModel.cs +++ b/RetailCoder.VBE/Navigation/CodeExplorer/CodeExplorerViewModel.cs @@ -33,35 +33,38 @@ public CodeExplorerViewModel(FolderHelper folderHelper, RubberduckParserState st _refreshCommand = new DelegateCommand(LogManager.GetCurrentClassLogger(), param => _state.OnParseRequested(this), param => !IsBusy && _state.IsDirty()); - _navigateCommand = commands.OfType().FirstOrDefault(); + _navigateCommand = commands.OfType().SingleOrDefault(); - _addTestModuleCommand = commands.OfType().FirstOrDefault(); - _addStdModuleCommand = commands.OfType().FirstOrDefault(); - _addClassModuleCommand = commands.OfType().FirstOrDefault(); - _addUserFormCommand = commands.OfType().FirstOrDefault(); + _addTestModuleCommand = commands.OfType().SingleOrDefault(); + _addStdModuleCommand = commands.OfType().SingleOrDefault(); + _addClassModuleCommand = commands.OfType().SingleOrDefault(); + _addUserFormCommand = commands.OfType().SingleOrDefault(); - _openDesignerCommand = commands.OfType().FirstOrDefault(); - _openProjectPropertiesCommand = commands.OfType().FirstOrDefault(); - _renameCommand = commands.OfType().FirstOrDefault(); - _indenterCommand = commands.OfType().FirstOrDefault(); + _openDesignerCommand = commands.OfType().SingleOrDefault(); + _openProjectPropertiesCommand = commands.OfType().SingleOrDefault(); + _renameCommand = commands.OfType().SingleOrDefault(); + _indenterCommand = commands.OfType().SingleOrDefault(); - _findAllReferencesCommand = commands.OfType().FirstOrDefault(); - _findAllImplementationsCommand = commands.OfType().FirstOrDefault(); + _findAllReferencesCommand = commands.OfType().SingleOrDefault(); + _findAllImplementationsCommand = commands.OfType().SingleOrDefault(); - _importCommand = commands.OfType().FirstOrDefault(); - _exportCommand = commands.OfType().FirstOrDefault(); - _externalRemoveCommand = commands.OfType().FirstOrDefault(); + _collapseAllSubnodesCommand = new DelegateCommand(LogManager.GetCurrentClassLogger(), ExecuteCollapseNodes); + _expandAllSubnodesCommand = new DelegateCommand(LogManager.GetCurrentClassLogger(), ExecuteExpandNodes); + + _importCommand = commands.OfType().SingleOrDefault(); + _exportCommand = commands.OfType().SingleOrDefault(); + _externalRemoveCommand = commands.OfType().SingleOrDefault(); if (_externalRemoveCommand != null) { _removeCommand = new DelegateCommand(LogManager.GetCurrentClassLogger(), ExecuteRemoveComand, _externalRemoveCommand.CanExecute); } - _printCommand = commands.OfType().FirstOrDefault(); + _printCommand = commands.OfType().SingleOrDefault(); - _commitCommand = commands.OfType().FirstOrDefault(); - _undoCommand = commands.OfType().FirstOrDefault(); + _commitCommand = commands.OfType().SingleOrDefault(); + _undoCommand = commands.OfType().SingleOrDefault(); - _copyResultsCommand = commands.OfType().FirstOrDefault(); + _copyResultsCommand = commands.OfType().SingleOrDefault(); _setNameSortCommand = new DelegateCommand(LogManager.GetCurrentClassLogger(), param => { @@ -409,6 +412,33 @@ private void SetErrorState(CodeExplorerItemViewModel itemNode, VBComponent compo } } + private void ExecuteCollapseNodes(object parameter) + { + var node = parameter as CodeExplorerItemViewModel; + if (node == null) { return; } + + SwitchNodeState(node, false); + } + + private void ExecuteExpandNodes(object parameter) + { + var node = parameter as CodeExplorerItemViewModel; + if (node == null) { return; } + + SwitchNodeState(node, true); + } + + private void SwitchNodeState(CodeExplorerItemViewModel node, bool expandedState) + { + node.IsExpanded = expandedState; + + foreach (var item in node.Items) + { + item.IsExpanded = expandedState; + SwitchNodeState(item, expandedState); + } + } + private readonly CommandBase _refreshCommand; public CommandBase RefreshCommand { get { return _refreshCommand; } } @@ -445,6 +475,12 @@ private void SetErrorState(CodeExplorerItemViewModel itemNode, VBComponent compo private readonly CommandBase _findAllImplementationsCommand; public CommandBase FindAllImplementationsCommand { get { return _findAllImplementationsCommand; } } + private readonly CommandBase _collapseAllSubnodesCommand; + public CommandBase CollapseAllSubnodesCommand { get { return _collapseAllSubnodesCommand; } } + + private readonly CommandBase _expandAllSubnodesCommand; + public CommandBase ExpandAllSubnodesCommand { get { return _expandAllSubnodesCommand; } } + private readonly CommandBase _importCommand; public CommandBase ImportCommand { get { return _importCommand; } } diff --git a/RetailCoder.VBE/Properties/AssemblyInfo.cs b/RetailCoder.VBE/Properties/AssemblyInfo.cs index a687ce20a3..f4d13cdb62 100644 --- a/RetailCoder.VBE/Properties/AssemblyInfo.cs +++ b/RetailCoder.VBE/Properties/AssemblyInfo.cs @@ -31,5 +31,5 @@ // You can specify all the values or you can default the Build and Revision Numbers // by using the '*' as shown below: // [assembly: AssemblyVersion("1.0.*")] -[assembly: AssemblyVersion("2.0.6.*")] -[assembly: AssemblyFileVersion("2.0.6.0")] +[assembly: AssemblyVersion("2.0.8.*")] +[assembly: AssemblyFileVersion("2.0.8.0")] diff --git a/RetailCoder.VBE/Refactorings/EncapsulateField/EncapsulateFieldModel.cs b/RetailCoder.VBE/Refactorings/EncapsulateField/EncapsulateFieldModel.cs index b543c083f6..11b961118d 100644 --- a/RetailCoder.VBE/Refactorings/EncapsulateField/EncapsulateFieldModel.cs +++ b/RetailCoder.VBE/Refactorings/EncapsulateField/EncapsulateFieldModel.cs @@ -18,6 +18,7 @@ public class EncapsulateFieldModel public string ParameterName { get; set; } public bool ImplementLetSetterType { get; set; } public bool ImplementSetSetterType { get; set; } + public bool CanImplementLet { get; set; } public EncapsulateFieldModel(RubberduckParserState state, QualifiedSelection selection) { diff --git a/RetailCoder.VBE/Refactorings/EncapsulateField/EncapsulateFieldPresenter.cs b/RetailCoder.VBE/Refactorings/EncapsulateField/EncapsulateFieldPresenter.cs index a2b6739685..9b77def338 100644 --- a/RetailCoder.VBE/Refactorings/EncapsulateField/EncapsulateFieldPresenter.cs +++ b/RetailCoder.VBE/Refactorings/EncapsulateField/EncapsulateFieldPresenter.cs @@ -41,8 +41,8 @@ public EncapsulateFieldModel Show() { if (_model.TargetDeclaration == null) { return null; } - _view.NewPropertyName = _model.TargetDeclaration.IdentifierName; _view.TargetDeclaration = _model.TargetDeclaration; + _view.NewPropertyName = _model.TargetDeclaration.IdentifierName; if (_model.TargetDeclaration.References.Any(r => r.IsAssignment)) { @@ -96,6 +96,7 @@ public EncapsulateFieldModel Show() _model.PropertyName = _view.NewPropertyName; _model.ImplementLetSetterType = _view.MustImplementLetSetterType; _model.ImplementSetSetterType = _view.MustImplementSetSetterType; + _model.CanImplementLet = _view.CanImplementLetSetterType; _model.ParameterName = _view.ParameterName; return _model; diff --git a/RetailCoder.VBE/Refactorings/EncapsulateField/EncapsulateFieldRefactoring.cs b/RetailCoder.VBE/Refactorings/EncapsulateField/EncapsulateFieldRefactoring.cs index 686dc77c38..4bedbeac48 100644 --- a/RetailCoder.VBE/Refactorings/EncapsulateField/EncapsulateFieldRefactoring.cs +++ b/RetailCoder.VBE/Refactorings/EncapsulateField/EncapsulateFieldRefactoring.cs @@ -5,18 +5,22 @@ using Rubberduck.Parsing.VBA; using Rubberduck.VBEditor; using Rubberduck.VBEditor.Extensions; +using Rubberduck.SmartIndenter; +using Selection = Rubberduck.VBEditor.Selection; namespace Rubberduck.Refactorings.EncapsulateField { public class EncapsulateFieldRefactoring : IRefactoring { private readonly VBE _vbe; + private readonly IIndenter _indenter; private readonly IRefactoringPresenterFactory _factory; private EncapsulateFieldModel _model; - public EncapsulateFieldRefactoring(VBE vbe, IRefactoringPresenterFactory factory) + public EncapsulateFieldRefactoring(VBE vbe, IIndenter indenter, IRefactoringPresenterFactory factory) { _vbe = vbe; + _indenter = indenter; _factory = factory; } @@ -29,21 +33,34 @@ public void Refactor() } _model = presenter.Show(); - if (_model == null) { return; } + QualifiedSelection? oldSelection = null; + if (_vbe.ActiveCodePane != null) + { + oldSelection = _vbe.ActiveCodePane.CodeModule.GetSelection(); + } + AddProperty(); + if (oldSelection.HasValue) + { + oldSelection.Value.QualifiedName.Component.CodeModule.SetSelection(oldSelection.Value.Selection); + oldSelection.Value.QualifiedName.Component.CodeModule.CodePane.ForceFocus(); + } + _model.State.OnParseRequested(this); } public void Refactor(QualifiedSelection target) { + _vbe.ActiveCodePane.CodeModule.SetSelection(target); Refactor(); } public void Refactor(Declaration target) { + _vbe.ActiveCodePane.CodeModule.SetSelection(target.QualifiedSelection); Refactor(); } @@ -177,7 +194,7 @@ private string GetPropertyText() var getterText = string.Join(Environment.NewLine, string.Format(Environment.NewLine + "Public Property Get {0}() As {1}", _model.PropertyName, _model.TargetDeclaration.AsTypeName), - string.Format(" {0} = {1}", _model.PropertyName, _model.TargetDeclaration.IdentifierName), + string.Format(" {0}{1} = {2}", !_model.CanImplementLet || _model.ImplementSetSetterType ? "Set " : string.Empty, _model.PropertyName, _model.TargetDeclaration.IdentifierName), "End Property" + Environment.NewLine); var letterText = string.Join(Environment.NewLine, @@ -189,13 +206,16 @@ private string GetPropertyText() var setterText = string.Join(Environment.NewLine, string.Format(Environment.NewLine + "Public Property Set {0}(ByVal {1} As {2})", _model.PropertyName, _model.ParameterName, _model.TargetDeclaration.AsTypeName), - string.Format(" {0} = {1}", _model.TargetDeclaration.IdentifierName, _model.ParameterName), + string.Format(" Set {0} = {1}", _model.TargetDeclaration.IdentifierName, _model.ParameterName), "End Property" + Environment.NewLine); - return string.Join(string.Empty, + var propertyText = string.Join(string.Empty, getterText, (_model.ImplementLetSetterType ? letterText : string.Empty), (_model.ImplementSetSetterType ? setterText : string.Empty)).TrimEnd() + Environment.NewLine; + + var propertyTextLines = propertyText.Split(new[] {Environment.NewLine}, StringSplitOptions.None); + return string.Join(Environment.NewLine, _indenter.Indent(propertyTextLines, "test", false)); } } } diff --git a/RetailCoder.VBE/Refactorings/ExtractInterface/ExtractInterfaceModel.cs b/RetailCoder.VBE/Refactorings/ExtractInterface/ExtractInterfaceModel.cs index fe5e3f9f6b..31751df7c4 100644 --- a/RetailCoder.VBE/Refactorings/ExtractInterface/ExtractInterfaceModel.cs +++ b/RetailCoder.VBE/Refactorings/ExtractInterface/ExtractInterfaceModel.cs @@ -42,7 +42,6 @@ public ExtractInterfaceModel(RubberduckParserState state, QualifiedSelection sel if (_targetDeclaration == null) { - //throw new InvalidOperationException(); return; } diff --git a/RetailCoder.VBE/Refactorings/ExtractInterface/ExtractInterfacePresenter.cs b/RetailCoder.VBE/Refactorings/ExtractInterface/ExtractInterfacePresenter.cs index 28e0eabd2d..504e93109d 100644 --- a/RetailCoder.VBE/Refactorings/ExtractInterface/ExtractInterfacePresenter.cs +++ b/RetailCoder.VBE/Refactorings/ExtractInterface/ExtractInterfacePresenter.cs @@ -22,7 +22,10 @@ public ExtractInterfacePresenter(IExtractInterfaceDialog view, ExtractInterfaceM public ExtractInterfaceModel Show() { - if (_model.TargetDeclaration == null) { return null; } + if (_model.TargetDeclaration == null) + { + return null; + } _view.ComponentNames = _model.TargetDeclaration.Project.VBComponents.Cast().Select(c => c.Name).ToList(); diff --git a/RetailCoder.VBE/Refactorings/ExtractInterface/ExtractInterfacePresenterFactory.cs b/RetailCoder.VBE/Refactorings/ExtractInterface/ExtractInterfacePresenterFactory.cs index 25d08f77a1..5b993b73f2 100644 --- a/RetailCoder.VBE/Refactorings/ExtractInterface/ExtractInterfacePresenterFactory.cs +++ b/RetailCoder.VBE/Refactorings/ExtractInterface/ExtractInterfacePresenterFactory.cs @@ -1,7 +1,6 @@ using System.Linq; using Microsoft.Vbe.Interop; using Rubberduck.Parsing.VBA; -using Rubberduck.VBEditor.Extensions; namespace Rubberduck.Refactorings.ExtractInterface { @@ -20,7 +19,7 @@ public ExtractInterfacePresenterFactory(VBE vbe, RubberduckParserState state, IE public ExtractInterfacePresenter Create() { - var selection = _vbe.ActiveCodePane.CodeModule.GetSelection(); + var selection = _vbe.ActiveCodePane.GetQualifiedSelection(); if (selection == null) { return null; diff --git a/RetailCoder.VBE/Refactorings/ExtractInterface/ExtractInterfaceRefactoring.cs b/RetailCoder.VBE/Refactorings/ExtractInterface/ExtractInterfaceRefactoring.cs index 4ba3d8eb38..35a0069278 100644 --- a/RetailCoder.VBE/Refactorings/ExtractInterface/ExtractInterfaceRefactoring.cs +++ b/RetailCoder.VBE/Refactorings/ExtractInterface/ExtractInterfaceRefactoring.cs @@ -17,11 +17,11 @@ public class ExtractInterfaceRefactoring : IRefactoring private readonly VBE _vbe; private readonly RubberduckParserState _state; private readonly IMessageBox _messageBox; - private readonly IRefactoringPresenterFactory _factory; + private readonly IRefactoringPresenterFactory _factory; private ExtractInterfaceModel _model; private static readonly Logger Logger = LogManager.GetCurrentClassLogger(); - public ExtractInterfaceRefactoring(VBE vbe, RubberduckParserState state, IMessageBox messageBox, IRefactoringPresenterFactory factory) + public ExtractInterfaceRefactoring(VBE vbe, RubberduckParserState state, IMessageBox messageBox, IRefactoringPresenterFactory factory) { _vbe = vbe; _state = state; @@ -38,14 +38,25 @@ public void Refactor() } _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); } @@ -66,8 +77,8 @@ private void AddInterface() var interfaceComponent = _model.TargetDeclaration.Project.VBComponents.Add(vbext_ComponentType.vbext_ct_ClassModule); interfaceComponent.Name = _model.InterfaceName; - _vbe.ActiveCodePane.CodeModule.InsertLines(1, Tokens.Option + ' ' + Tokens.Explicit + Environment.NewLine); - _vbe.ActiveCodePane.CodeModule.InsertLines(3, GetInterfaceModuleBody()); + interfaceComponent.CodeModule.InsertLines(1, Tokens.Option + ' ' + Tokens.Explicit + Environment.NewLine); + interfaceComponent.CodeModule.InsertLines(3, GetInterfaceModuleBody()); var module = _model.TargetDeclaration.QualifiedSelection.QualifiedName.Component.CodeModule; @@ -85,14 +96,13 @@ private void _state_StateChanged(object sender, EventArgs e) { return; } - + + _state.StateChanged -= _state_StateChanged; var qualifiedSelection = new QualifiedSelection(_model.TargetDeclaration.QualifiedSelection.QualifiedName, new Selection(_insertionLine, 1, _insertionLine, 1)); _vbe.ActiveCodePane.CodeModule.SetSelection(qualifiedSelection); var implementInterfaceRefactoring = new ImplementInterfaceRefactoring(_vbe, _state, _messageBox); implementInterfaceRefactoring.Refactor(qualifiedSelection); - - _state.StateChanged -= _state_StateChanged; } private string GetInterfaceModuleBody() diff --git a/RetailCoder.VBE/Refactorings/ExtractInterface/InterfaceMember.cs b/RetailCoder.VBE/Refactorings/ExtractInterface/InterfaceMember.cs index 5234c08fda..af4a546dd5 100644 --- a/RetailCoder.VBE/Refactorings/ExtractInterface/InterfaceMember.cs +++ b/RetailCoder.VBE/Refactorings/ExtractInterface/InterfaceMember.cs @@ -46,17 +46,25 @@ public InterfaceMember(Declaration member, IEnumerable declarations GetMethodType(); - MemberParams = declarations.Where(item => item.DeclarationType == DeclarationType.Parameter && - item.ParentScope == Member.Scope) - .OrderBy(o => o.Selection.StartLine) - .ThenBy(t => t.Selection.StartColumn) - .Select(p => new Parameter - { - ParamAccessibility = ((VBAParser.ArgContext)p.Context).BYREF() == null ? Tokens.ByVal : Tokens.ByRef, - ParamName = p.IdentifierName, - ParamType = p.AsTypeName - }) - .ToList(); + var memberWithParams = member as IDeclarationWithParameter; + if (memberWithParams != null) + { + MemberParams = memberWithParams.Parameters + .OrderBy(o => o.Selection.StartLine) + .ThenBy(t => t.Selection.StartColumn) + .Select(p => new Parameter + { + ParamAccessibility = + ((VBAParser.ArgContext) p.Context).BYVAL() != null ? Tokens.ByVal : Tokens.ByRef, + ParamName = p.IdentifierName, + ParamType = p.AsTypeName + }) + .ToList(); + } + else + { + MemberParams = new List(); + } if (MemberType == "Property Get") { diff --git a/RetailCoder.VBE/Refactorings/ImplementInterface/ImplementInterfaceRefactoring.cs b/RetailCoder.VBE/Refactorings/ImplementInterface/ImplementInterfaceRefactoring.cs index ccdf3b4452..db98d880d2 100644 --- a/RetailCoder.VBE/Refactorings/ImplementInterface/ImplementInterfaceRefactoring.cs +++ b/RetailCoder.VBE/Refactorings/ImplementInterface/ImplementInterfaceRefactoring.cs @@ -11,13 +11,15 @@ namespace Rubberduck.Refactorings.ImplementInterface { + using VBEditor.Extensions; + public class ImplementInterfaceRefactoring : IRefactoring { private readonly VBE _vbe; private readonly RubberduckParserState _state; private readonly IMessageBox _messageBox; - private List _declarations; + private readonly List _declarations; private Declaration _targetInterface; private Declaration _targetClass; @@ -66,8 +68,20 @@ public void Refactor(QualifiedSelection selection) return; } + QualifiedSelection? oldSelection = null; + if (_vbe.ActiveCodePane != null) + { + oldSelection = _vbe.ActiveCodePane.CodeModule.GetSelection(); + } + ImplementMissingMembers(); + if (oldSelection.HasValue) + { + oldSelection.Value.QualifiedName.Component.CodeModule.SetSelection(oldSelection.Value.Selection); + oldSelection.Value.QualifiedName.Component.CodeModule.CodePane.ForceFocus(); + } + _state.OnParseRequested(this); } @@ -91,7 +105,7 @@ private void AddItems(List members) var missingMembersText = members.Aggregate(string.Empty, (current, member) => current + Environment.NewLine + GetInterfaceMember(member)); - module.InsertLines(module.CountOfDeclarationLines + 2, missingMembersText); + module.InsertLines(module.CountOfDeclarationLines + 1, missingMembersText); } private string GetInterfaceMember(Declaration member) diff --git a/RetailCoder.VBE/Refactorings/IntroduceField/IntroduceFieldRefactoring.cs b/RetailCoder.VBE/Refactorings/IntroduceField/IntroduceFieldRefactoring.cs index 68a9301df0..f9060ce9d9 100644 --- a/RetailCoder.VBE/Refactorings/IntroduceField/IntroduceFieldRefactoring.cs +++ b/RetailCoder.VBE/Refactorings/IntroduceField/IntroduceFieldRefactoring.cs @@ -80,9 +80,21 @@ private void PromoteVariable(Declaration target) return; } + QualifiedSelection? oldSelection = null; + if (_vbe.ActiveCodePane != null) + { + oldSelection = _vbe.ActiveCodePane.CodeModule.GetSelection(); + } + RemoveVariable(target); AddField(target); + if (oldSelection.HasValue) + { + oldSelection.Value.QualifiedName.Component.CodeModule.SetSelection(oldSelection.Value.Selection); + oldSelection.Value.QualifiedName.Component.CodeModule.CodePane.ForceFocus(); + } + _state.OnParseRequested(this); } diff --git a/RetailCoder.VBE/Refactorings/IntroduceParameter/IntroduceParameterRefactoring.cs b/RetailCoder.VBE/Refactorings/IntroduceParameter/IntroduceParameterRefactoring.cs index 1073cae2b9..a5a5fdfb0e 100644 --- a/RetailCoder.VBE/Refactorings/IntroduceParameter/IntroduceParameterRefactoring.cs +++ b/RetailCoder.VBE/Refactorings/IntroduceParameter/IntroduceParameterRefactoring.cs @@ -95,9 +95,21 @@ private void PromoteVariable(Declaration target) 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); } diff --git a/RetailCoder.VBE/Refactorings/MoveCloserToUsage/MoveCloserToUsageRefactoring.cs b/RetailCoder.VBE/Refactorings/MoveCloserToUsage/MoveCloserToUsageRefactoring.cs index c579cabd72..b1ba0cff2e 100644 --- a/RetailCoder.VBE/Refactorings/MoveCloserToUsage/MoveCloserToUsageRefactoring.cs +++ b/RetailCoder.VBE/Refactorings/MoveCloserToUsage/MoveCloserToUsageRefactoring.cs @@ -101,9 +101,21 @@ private void MoveCloserToUsage() return; } + QualifiedSelection? oldSelection = null; + if (_vbe.ActiveCodePane != null) + { + oldSelection = _vbe.ActiveCodePane.CodeModule.GetSelection(); + } + // 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) + { + oldSelection.Value.QualifiedName.Component.CodeModule.SetSelection(oldSelection.Value.Selection); + oldSelection.Value.QualifiedName.Component.CodeModule.CodePane.ForceFocus(); + } + _state.StateChanged += _state_StateChanged; _state.OnParseRequested(this); } @@ -112,6 +124,12 @@ private void _state_StateChanged(object sender, ParserStateEventArgs e) { if (e.State != ParserState.Ready) { return; } + QualifiedSelection? oldSelection = null; + if (_vbe.ActiveCodePane != null) + { + oldSelection = _vbe.ActiveCodePane.CodeModule.GetSelection(); + } + var newTarget = _state.AllUserDeclarations.FirstOrDefault( item => item.ComponentName == _target.ComponentName && item.IdentifierName == _target.IdentifierName && @@ -125,6 +143,12 @@ private void _state_StateChanged(object sender, ParserStateEventArgs e) RemoveField(newTarget); } + if (oldSelection.HasValue) + { + oldSelection.Value.QualifiedName.Component.CodeModule.SetSelection(oldSelection.Value.Selection); + oldSelection.Value.QualifiedName.Component.CodeModule.CodePane.ForceFocus(); + } + _state.StateChanged -= _state_StateChanged; _state.OnParseRequested(this); } diff --git a/RetailCoder.VBE/Refactorings/RemoveParameters/RemoveParametersRefactoring.cs b/RetailCoder.VBE/Refactorings/RemoveParameters/RemoveParametersRefactoring.cs index b78d56afc4..d70413cbca 100644 --- a/RetailCoder.VBE/Refactorings/RemoveParameters/RemoveParametersRefactoring.cs +++ b/RetailCoder.VBE/Refactorings/RemoveParameters/RemoveParametersRefactoring.cs @@ -1,6 +1,7 @@ using System; using System.Collections.Generic; using System.Linq; +using Antlr4.Runtime; using Antlr4.Runtime.Misc; using Microsoft.Vbe.Interop; using Rubberduck.Common; @@ -40,8 +41,20 @@ public void Refactor() return; } + QualifiedSelection? oldSelection = null; + if (_vbe.ActiveCodePane != null) + { + oldSelection = _vbe.ActiveCodePane.CodeModule.GetSelection(); + } + RemoveParameters(); + if (oldSelection.HasValue) + { + oldSelection.Value.QualifiedName.Component.CodeModule.SetSelection(oldSelection.Value.Selection); + oldSelection.Value.QualifiedName.Component.CodeModule.CodePane.ForceFocus(); + } + _model.State.OnParseRequested(this); } @@ -84,7 +97,6 @@ private void AdjustReferences(IEnumerable references, Decla { foreach (var reference in references.Where(item => item.Context != method.Context)) { - var proc = (dynamic)reference.Context; var module = reference.QualifiedModuleName.Component.CodeModule; VBAParser.ArgumentListContext argumentList = null; var callStmt = ParserRuleContextHelper.GetParent(reference.Context); @@ -92,6 +104,16 @@ private void AdjustReferences(IEnumerable references, Decla { argumentList = CallStatement.GetArgumentList(callStmt); } + + if (argumentList == null) + { + var indexExpression = ParserRuleContextHelper.GetParent(reference.Context); + if (indexExpression != null) + { + argumentList = ParserRuleContextHelper.GetChild(indexExpression); + } + } + if (argumentList == null) { continue; } RemoveCallParameter(argumentList, module); } @@ -99,7 +121,7 @@ private void AdjustReferences(IEnumerable references, Decla private void RemoveCallParameter(VBAParser.ArgumentListContext paramList, CodeModule module) { - List paramNames = new List(); + var paramNames = new List(); if (paramList.positionalOrNamedArgumentList().positionalArgumentOrMissing() != null) { paramNames.AddRange(paramList.positionalOrNamedArgumentList().positionalArgumentOrMissing().Select(p => @@ -108,10 +130,8 @@ private void RemoveCallParameter(VBAParser.ArgumentListContext paramList, CodeMo { return ((VBAParser.SpecifiedPositionalArgumentContext)p).positionalArgument().GetText(); } - else - { - return string.Empty; - } + + return string.Empty; }).ToList()); } if (paramList.positionalOrNamedArgumentList().namedArgumentList() != null) @@ -124,48 +144,46 @@ private void RemoveCallParameter(VBAParser.ArgumentListContext paramList, CodeMo } var lineCount = paramList.Stop.Line - paramList.Start.Line + 1; // adjust for total line count - var newContent = module.Lines[paramList.Start.Line, lineCount].Replace(" _" + Environment.NewLine, string.Empty).RemoveExtraSpacesLeavingIndentation(); - var currentStringIndex = 0; + var newContent = module.Lines[paramList.Start.Line, lineCount]; + newContent = newContent.Remove(paramList.Start.Column, paramList.GetText().Length); - foreach ( - var param in - _model.Parameters.Where(item => item.IsRemoved && item.Index < paramNames.Count) - .Select(item => item.Declaration)) + var savedParamNames = paramNames; + for (var index = _model.Parameters.Count - 1; index >= 0; index--) { - var paramIndex = _model.Parameters.FindIndex(item => item.Declaration.Context.GetText() == param.Context.GetText()); - if (paramIndex >= paramNames.Count) { return; } - - do + var param = _model.Parameters[index]; + if (!param.IsRemoved) { - var paramToRemoveName = paramNames.ElementAt(0).Contains(":=") - ? paramNames.Find(item => item.Contains(param.IdentifierName + ":=")) - : paramNames.ElementAt(paramIndex); + continue; + } - if (paramToRemoveName == null || !newContent.Contains(paramToRemoveName)) + if (param.Name.Contains("ParamArray")) + { + // handle param arrays + while (savedParamNames.Count > index) { - continue; + savedParamNames.RemoveAt(index); } - - var valueToRemove = paramToRemoveName != paramNames.Last() - ? paramToRemoveName + "," - : paramToRemoveName; - - var parameterStringIndex = newContent.IndexOf(valueToRemove, currentStringIndex, StringComparison.Ordinal); - if (parameterStringIndex <= -1) { continue; } - - newContent = newContent.Remove(parameterStringIndex, valueToRemove.Length); - - currentStringIndex = parameterStringIndex; - - if (paramToRemoveName == paramNames.Last() && newContent.LastIndexOf(',') != -1) + } + else + { + if (index < savedParamNames.Count && !savedParamNames[index].StripStringLiterals().Contains(":=")) { - newContent = newContent.Remove(newContent.LastIndexOf(','), 1); + savedParamNames.RemoveAt(index); } - } while (paramIndex >= _model.Parameters.Count - 1 && ++paramIndex < paramNames.Count && - newContent.Contains(paramNames.ElementAt(paramIndex))); + else + { + var paramIndex = savedParamNames.FindIndex(s => s.StartsWith(param.Declaration.IdentifierName + ":=")); + if (paramIndex != -1 && paramIndex < savedParamNames.Count) + { + savedParamNames.RemoveAt(paramIndex); + } + } + } } - module.ReplaceLine(paramList.Start.Line, newContent); + newContent = newContent.Insert(paramList.Start.Column, string.Join(", ", savedParamNames)); + + module.ReplaceLine(paramList.Start.Line, newContent.Replace(" _" + Environment.NewLine, string.Empty)); module.DeleteLines(paramList.Start.Line + 1, lineCount - 1); } @@ -239,26 +257,6 @@ private string GetOldSignature(Declaration target) return rewriter.GetText(new Interval(firstTokenIndex, lastTokenIndex)); } - private string ReplaceCommas(string signature, int indexParamRemoved) - { - if (signature.Count(c => c == ',') > indexParamRemoved) { indexParamRemoved++; } - - for (int i = 0, commaCounter = 0; i < signature.Length && indexParamRemoved != 0; i++) - { - if (signature.ElementAt(i) == ',') - { - commaCounter++; - } - - if (commaCounter == indexParamRemoved) - { - return signature.Remove(i, 1); - } - } - - return signature; - } - private void AdjustSignatures() { var proc = (dynamic)_model.TargetDeclaration.Context; @@ -333,25 +331,17 @@ private void AdjustSignatures(Declaration declaration) private void RemoveSignatureParameters(Declaration target, VBAParser.ArgListContext paramList, CodeModule module) { - var paramNames = paramList.arg(); - - var paramsRemoved = _model.Parameters.Where(item => item.IsRemoved).ToList(); + // property set/let have one more parameter than is listed in the getter parameters + var nonRemovedParamNames = paramList.arg().Where((a, s) => s >= _model.Parameters.Count || !_model.Parameters[s].IsRemoved).Select(s => s.GetText()); var signature = GetOldSignature(target); + signature = signature.Remove(signature.IndexOf('(')); + + var asTypeText = target.AsTypeContext == null ? string.Empty : " " + target.AsTypeContext.GetText(); + signature += '(' + string.Join(", ", nonRemovedParamNames) + ")" + (asTypeText == " " ? string.Empty : asTypeText); - foreach (var param in paramsRemoved) - { - try - { - signature = ReplaceCommas(signature.Replace(paramNames.ElementAt(param.Index).GetText(), string.Empty), _model.Parameters.FindIndex(item => item == param) - paramsRemoved.FindIndex(item => item == param)); - } - catch (ArgumentOutOfRangeException) - { - } - } - var lineNum = paramList.GetSelection().LineCount; - + var lineCount = paramList.GetSelection().LineCount; module.ReplaceLine(paramList.Start.Line, signature.Replace(" _" + Environment.NewLine, string.Empty)); - module.DeleteLines(paramList.Start.Line + 1, lineNum - 1); + module.DeleteLines(paramList.Start.Line + 1, lineCount - 1); } } } diff --git a/RetailCoder.VBE/Refactorings/Rename/RenameRefactoring.cs b/RetailCoder.VBE/Refactorings/Rename/RenameRefactoring.cs index 97ac465f37..6673584582 100644 --- a/RetailCoder.VBE/Refactorings/Rename/RenameRefactoring.cs +++ b/RetailCoder.VBE/Refactorings/Rename/RenameRefactoring.cs @@ -38,10 +38,22 @@ public void Refactor() var presenter = _factory.Create(); _model = presenter.Show(); + QualifiedSelection? oldSelection = null; + if (_vbe.ActiveCodePane != null) + { + oldSelection = _vbe.ActiveCodePane.CodeModule.GetSelection(); + } + if (_model != null && _model.Declarations != null) { Rename(); } + + if (oldSelection.HasValue) + { + oldSelection.Value.QualifiedName.Component.CodeModule.SetSelection(oldSelection.Value.Selection); + oldSelection.Value.QualifiedName.Component.CodeModule.CodePane.ForceFocus(); + } } public void Refactor(QualifiedSelection target) @@ -55,10 +67,22 @@ public void Refactor(Declaration target) var presenter = _factory.Create(); _model = presenter.Show(target); + QualifiedSelection? oldSelection = null; + if (_vbe.ActiveCodePane != null) + { + oldSelection = _vbe.ActiveCodePane.CodeModule.GetSelection(); + } + if (_model != null && _model.Declarations != null) { Rename(); } + + if (oldSelection.HasValue) + { + oldSelection.Value.QualifiedName.Component.CodeModule.SetSelection(oldSelection.Value.Selection); + oldSelection.Value.QualifiedName.Component.CodeModule.CodePane.ForceFocus(); + } } private Declaration FindDeclarationForIdentifier() diff --git a/RetailCoder.VBE/Refactorings/ReorderParameters/ReorderParametersRefactoring.cs b/RetailCoder.VBE/Refactorings/ReorderParameters/ReorderParametersRefactoring.cs index 887dcf569b..6f99d56980 100644 --- a/RetailCoder.VBE/Refactorings/ReorderParameters/ReorderParametersRefactoring.cs +++ b/RetailCoder.VBE/Refactorings/ReorderParameters/ReorderParametersRefactoring.cs @@ -4,7 +4,6 @@ using Rubberduck.Parsing; using Rubberduck.Parsing.Grammar; using Rubberduck.Parsing.Symbols; -using Rubberduck.Parsing.VBA; using Rubberduck.UI; using Rubberduck.VBEditor; using Rubberduck.VBEditor.Extensions; @@ -43,9 +42,21 @@ public void Refactor() return; } + QualifiedSelection? oldSelection = null; + if (_vbe.ActiveCodePane != null) + { + oldSelection = _vbe.ActiveCodePane.CodeModule.GetSelection(); + } + AdjustReferences(_model.TargetDeclaration.References); AdjustSignatures(); + if (oldSelection.HasValue) + { + oldSelection.Value.QualifiedName.Component.CodeModule.SetSelection(oldSelection.Value.Selection); + oldSelection.Value.QualifiedName.Component.CodeModule.CodePane.ForceFocus(); + } + _model.State.OnParseRequested(this); } @@ -94,7 +105,6 @@ private void AdjustReferences(IEnumerable references) { foreach (var reference in references.Where(item => item.Context != _model.TargetDeclaration.Context)) { - dynamic proc = reference.Context; var module = reference.QualifiedModuleName.Component.CodeModule; VBAParser.ArgumentListContext argumentList = null; var callStmt = ParserRuleContextHelper.GetParent(reference.Context); @@ -102,6 +112,16 @@ private void AdjustReferences(IEnumerable references) { argumentList = CallStatement.GetArgumentList(callStmt); } + + if (argumentList == null) + { + var indexExpression = ParserRuleContextHelper.GetParent(reference.Context); + if (indexExpression != null) + { + argumentList = ParserRuleContextHelper.GetChild(indexExpression); + } + } + if (argumentList == null) { continue; } RewriteCall(argumentList, module); } @@ -109,55 +129,52 @@ private void AdjustReferences(IEnumerable references) private void RewriteCall(VBAParser.ArgumentListContext paramList, CodeModule module) { - List paramNames = new List(); + var argValues = new List(); if (paramList.positionalOrNamedArgumentList().positionalArgumentOrMissing() != null) { - paramNames.AddRange(paramList.positionalOrNamedArgumentList().positionalArgumentOrMissing().Select(p => + argValues.AddRange(paramList.positionalOrNamedArgumentList().positionalArgumentOrMissing().Select(p => { if (p is VBAParser.SpecifiedPositionalArgumentContext) { return ((VBAParser.SpecifiedPositionalArgumentContext)p).positionalArgument().GetText(); } - else - { - return string.Empty; - } + + return string.Empty; }).ToList()); } if (paramList.positionalOrNamedArgumentList().namedArgumentList() != null) { - paramNames.AddRange(paramList.positionalOrNamedArgumentList().namedArgumentList().namedArgument().Select(p => p.GetText()).ToList()); + argValues.AddRange(paramList.positionalOrNamedArgumentList().namedArgumentList().namedArgument().Select(p => p.GetText()).ToList()); } if (paramList.positionalOrNamedArgumentList().requiredPositionalArgument() != null) { - paramNames.Add(paramList.positionalOrNamedArgumentList().requiredPositionalArgument().GetText()); + argValues.Add(paramList.positionalOrNamedArgumentList().requiredPositionalArgument().GetText()); } var lineCount = paramList.Stop.Line - paramList.Start.Line + 1; // adjust for total line count - var newContent = module.Lines[paramList.Start.Line, lineCount].Replace(" _" + Environment.NewLine, string.Empty).RemoveExtraSpacesLeavingIndentation(); + var newContent = module.Lines[paramList.Start.Line, lineCount]; + newContent = newContent.Remove(paramList.Start.Column, paramList.GetText().Length); - var parameterIndex = 0; - var currentStringIndex = 0; - - for (var i = 0; i < paramNames.Count && parameterIndex < _model.Parameters.Count; i++) + var reorderedArgValues = new List(); + foreach (var param in _model.Parameters) { - var parameterStringIndex = newContent.IndexOf(paramNames.ElementAt(i), currentStringIndex, StringComparison.Ordinal); - - if (parameterStringIndex <= -1) { continue; } - - var oldParameterString = paramNames.ElementAt(i); - var newParameterString = paramNames.ElementAt(_model.Parameters.ElementAt(parameterIndex).Index); - var beginningSub = newContent.Substring(0, parameterStringIndex); - var replaceSub = newContent.Substring(parameterStringIndex).Replace(oldParameterString, newParameterString); - - newContent = beginningSub + replaceSub; + var argAtIndex = argValues.ElementAtOrDefault(param.Index); + if (argAtIndex != null) + { + reorderedArgValues.Add(argAtIndex); + } + } - parameterIndex++; - currentStringIndex = beginningSub.Length + newParameterString.Length; + // property let/set and paramarrays + for (var index = reorderedArgValues.Count; index < argValues.Count; index++) + { + reorderedArgValues.Add(argValues[index]); } - module.ReplaceLine(paramList.Start.Line, newContent); + newContent = newContent.Insert(paramList.Start.Column, string.Join(", ", reorderedArgValues)); + + module.ReplaceLine(paramList.Start.Line, newContent.Replace(" _" + Environment.NewLine, string.Empty)); module.DeleteLines(paramList.Start.Line + 1, lineCount - 1); } @@ -232,34 +249,33 @@ private void AdjustSignatures(Declaration declaration) private void RewriteSignature(Declaration target, VBAParser.ArgListContext paramList, CodeModule module) { - var argList = paramList.arg(); - - var newContent = GetOldSignature(target); - var lineNum = paramList.GetSelection().LineCount; + var parameters = paramList.arg().Select((s, i) => new {Index = i, Text = s.GetText()}).ToList(); - var parameterIndex = 0; - var currentStringIndex = 0; - - for (var i = parameterIndex; i < _model.Parameters.Count; i++) + var reorderedParams = new List(); + foreach (var param in _model.Parameters) { - var oldParam = argList.ElementAt(parameterIndex).GetText(); - var newParam = argList.ElementAt(_model.Parameters.ElementAt(parameterIndex).Index).GetText(); - var parameterStringIndex = newContent.IndexOf(oldParam, currentStringIndex, StringComparison.Ordinal); - - if (parameterStringIndex > -1) + var parameterAtIndex = parameters.SingleOrDefault(s => s.Index == param.Index); + if (parameterAtIndex != null) { - var beginningSub = newContent.Substring(0, parameterStringIndex); - var replaceSub = newContent.Substring(parameterStringIndex).Replace(oldParam, newParam); - - newContent = beginningSub + replaceSub; - - parameterIndex++; - currentStringIndex = beginningSub.Length + newParam.Length; + reorderedParams.Add(parameterAtIndex.Text); } } - module.ReplaceLine(paramList.Start.Line, newContent.Replace(" _" + Environment.NewLine, string.Empty)); - module.DeleteLines(paramList.Start.Line + 1, lineNum - 1); + // property let/set and paramarrays + for (var index = reorderedParams.Count; index < parameters.Count; index++) + { + reorderedParams.Add(parameters[index].Text); + } + + var signature = GetOldSignature(target); + signature = signature.Remove(signature.IndexOf('(')); + + var asTypeText = target.AsTypeContext == null ? string.Empty : " " + target.AsTypeContext.GetText(); + signature += '(' + string.Join(", ", reorderedParams) + ")" + (asTypeText == " " ? string.Empty : asTypeText); + + var lineCount = paramList.GetSelection().LineCount; + module.ReplaceLine(paramList.Start.Line, signature.Replace(" _" + Environment.NewLine, string.Empty)); + module.DeleteLines(paramList.Start.Line + 1, lineCount - 1); } private string GetOldSignature(Declaration target) diff --git a/RetailCoder.VBE/Resources/folder-open.png b/RetailCoder.VBE/Resources/folder-open.png new file mode 100644 index 0000000000..adc99d5f0c Binary files /dev/null and b/RetailCoder.VBE/Resources/folder-open.png differ diff --git a/RetailCoder.VBE/Resources/folder.png b/RetailCoder.VBE/Resources/folder.png new file mode 100644 index 0000000000..ada85c48b8 Binary files /dev/null and b/RetailCoder.VBE/Resources/folder.png differ diff --git a/RetailCoder.VBE/Root/RubberduckModule.cs b/RetailCoder.VBE/Root/RubberduckModule.cs index bc6955184d..480b38d6f1 100644 --- a/RetailCoder.VBE/Root/RubberduckModule.cs +++ b/RetailCoder.VBE/Root/RubberduckModule.cs @@ -9,7 +9,6 @@ using Ninject.Modules; using Rubberduck.Common; using Rubberduck.Inspections; -using Rubberduck.Navigation.CodeExplorer; using Rubberduck.Parsing; using Rubberduck.Parsing.VBA; using Rubberduck.Settings; @@ -27,11 +26,11 @@ using Rubberduck.UI.SourceControl; using Rubberduck.UI.ToDoItems; using Rubberduck.UI.UnitTesting; -using Rubberduck.UnitTesting; using Rubberduck.VBEditor.VBEHost; using Rubberduck.Parsing.Preprocessing; using System.Globalization; using Ninject.Extensions.Interception.Infrastructure.Language; +using Ninject.Extensions.NamedScope; using Rubberduck.Parsing.Symbols; using Rubberduck.UI.CodeExplorer.Commands; @@ -63,8 +62,6 @@ public override void Load() Bind().ToSelf().InSingletonScope(); Bind().ToSelf().InSingletonScope(); Bind().ToSelf().InSingletonScope(); - Bind().ToSelf().InSingletonScope(); - Bind().ToSelf().InSingletonScope(); Bind().ToSelf().InSingletonScope(); Bind().ToSelf().InSingletonScope(); Bind().To().InSingletonScope(); @@ -79,13 +76,13 @@ public override void Load() Assembly.GetAssembly(typeof(IIndenter)) }; - ApplyConfigurationConvention(assemblies); ApplyDefaultInterfacesConvention(assemblies); + ApplyConfigurationConvention(assemblies); ApplyAbstractFactoryConvention(assemblies); BindCommandsToMenuItems(); - Rebind().To().InSingletonScope(); + Rebind().To().InSingletonScope(); Rebind().To().InSingletonScope(); Rebind().To(); Bind>().ToMethod(t => () => Kernel.Get().LoadConfiguration().UserSettings.IndenterSettings); @@ -99,45 +96,39 @@ public override void Load() Bind().To() .WhenInjectedInto() - .InSingletonScope() - .WithConstructorArgument(new TestExplorerWindow { ViewModel = Kernel.Get() }); + .InSingletonScope(); Bind().To() .WhenInjectedInto() - .InSingletonScope() - .WithConstructorArgument(new CodeInspectionsWindow { ViewModel = Kernel.Get() }); + .InSingletonScope(); - Bind().To().Named("changesView"); - Bind().To().Named("branchesView"); - Bind().To().Named("unsyncedCommitsView"); - Bind().To().Named("settingsView"); + Bind().To().InCallScope(); + Bind().To().InCallScope(); + Bind().To().InCallScope(); + Bind().To().InCallScope(); Bind().To() - .WhenInjectedInto(); + .WhenInjectedInto().InCallScope(); Bind().To() - .WhenInjectedInto(); + .WhenInjectedInto().InCallScope(); Bind().To() - .WhenInjectedInto(); + .WhenInjectedInto().InCallScope(); Bind().To() - .WhenInjectedInto(); + .WhenInjectedInto().InCallScope(); Bind().To() .WhenInjectedInto(); - Bind().ToSelf() - .InSingletonScope() - .WithConstructorArgument(new SourceControlPanel { ViewModel = Kernel.Get() }); + Bind().ToSelf().InSingletonScope(); BindCommandsToCodeExplorer(); Bind().To() .WhenInjectedInto() - .InSingletonScope() - .WithConstructorArgument(new CodeExplorerWindow { ViewModel = Kernel.Get() }); + .InSingletonScope(); Bind().To() .WhenInjectedInto() - .InSingletonScope() - .WithConstructorArgument(new ToDoExplorerWindow { ViewModel = Kernel.Get() }); + .InSingletonScope(); ConfigureRubberduckMenu(); ConfigureCodePaneContextMenu(); @@ -145,7 +136,6 @@ public override void Load() ConfigureFormDesignerControlContextMenu(); ConfigureProjectExplorerContextMenu(); - BindWindowsHooks(); } @@ -167,7 +157,7 @@ private void ApplyDefaultInterfacesConvention(IEnumerable assemblies) // inspections & factories have their own binding rules .Where(type => !type.Name.EndsWith("Factory") && !type.Name.EndsWith("ConfigProvider") && !type.GetInterfaces().Contains(typeof(IInspection))) .BindDefaultInterface() - .Configure(binding => binding.InThreadScope())); // TransientScope wouldn't dispose disposables + .Configure(binding => binding.InCallScope())); // TransientScope wouldn't dispose disposables } // note: settings namespace classes are injected in singleton scope @@ -179,24 +169,24 @@ private void ApplyConfigurationConvention(IEnumerable assemblies) .BindAllInterfaces() .Configure(binding => binding.InSingletonScope())); - Bind>().To>().InSingletonScope(); - Bind>().To>().InSingletonScope(); - Bind>().To>().InSingletonScope(); - Bind>().To>().InSingletonScope(); - Bind>().To>().InSingletonScope(); - Bind>().To>().InSingletonScope(); - Bind>().To>().InSingletonScope(); - - Bind().To().InSingletonScope(); - Bind().To().InSingletonScope(); - - Bind().To(); - Bind().To(); - Bind().To(); - Bind().To(); - Bind().To(); - Bind().To(); - Bind().To(); + Bind>().To>().InCallScope(); + Bind>().To>().InCallScope(); + Bind>().To>().InCallScope(); + Bind>().To>().InCallScope(); + Bind>().To>().InCallScope(); + Bind>().To>().InCallScope(); + Bind>().To>().InCallScope(); + + Bind>().To().InCallScope(); + Bind>().To().InCallScope(); + + Bind().To().InCallScope(); + Bind().To().InCallScope(); + Bind().To().InCallScope(); + Bind().To().InCallScope(); + Bind().To().InCallScope(); + Bind().To().InCallScope(); + Bind().To().InCallScope(); } // note convention: abstract factory interface names end with "Factory". @@ -223,7 +213,7 @@ private void BindCodeInspectionTypes() { var binding = Bind() .To(inspection) - .InSingletonScope() + .InCallScope() .Named(inspection.FullName); binding.Intercept().With(); @@ -234,7 +224,7 @@ private void BindCodeInspectionTypes() } else { - var binding = Bind().To(inspection).InSingletonScope(); + var binding = Bind().To(inspection).InCallScope(); binding.Intercept().With(); binding.Intercept().With>(); } @@ -299,7 +289,7 @@ private void BindParentMenuItem(CommandBarControls parent, int befo { Bind().To(typeof(TParentMenu)) .WhenInjectedInto() - .InThreadScope() + .InCallScope() .WithConstructorArgument("items", items) .WithConstructorArgument("beforeIndex", beforeIndex) .WithPropertyValue("Parent", parent); @@ -321,7 +311,7 @@ private static int FindRubberduckMenuInsertionIndex(CommandBarControls controls, private void BindCommandsToMenuItems() { var types = Assembly.GetExecutingAssembly().GetTypes() - .Where(type => type.IsClass && type.Namespace != null && type.Namespace.StartsWith(typeof(CommandBase).Namespace ?? String.Empty)) + .Where(type => type.IsClass && type.Namespace != null && type.Namespace.StartsWith(typeof(CommandBase).Namespace ?? string.Empty)) .ToList(); // note: CommandBase naming convention: [Foo]Command @@ -343,7 +333,7 @@ private void BindCommandsToMenuItems() binding.WhenInjectedInto().BindingConfiguration.Condition; binding.When(request => whenCommandMenuItemCondition(request) || whenHooksCondition(request)) - .InSingletonScope(); + .InCallScope(); } } catch (InvalidOperationException) diff --git a/RetailCoder.VBE/Rubberduck.csproj b/RetailCoder.VBE/Rubberduck.csproj index 2f29c09c47..609288ffb3 100644 --- a/RetailCoder.VBE/Rubberduck.csproj +++ b/RetailCoder.VBE/Rubberduck.csproj @@ -253,6 +253,10 @@ ..\packages\Ninject.Extensions.Interception.DynamicProxy.3.2.0.0\lib\net45-full\Ninject.Extensions.Interception.DynamicProxy.dll True + + ..\packages\Ninject.Extensions.NamedScope.3.2.0.0\lib\net45-full\Ninject.Extensions.NamedScope.dll + True + @@ -364,21 +368,12 @@ True True - - InspectionsUI.sv.resx - True - True - - - InspectionsUI.ja.resx - True - True - + @@ -404,6 +399,7 @@ + AboutControl.xaml @@ -713,16 +709,6 @@ True RubberduckUI.resx - - True - True - RubberduckUI.ja.resx - - - True - True - RubberduckUI.sv.resx - @@ -971,8 +957,6 @@ - - @@ -1002,16 +986,6 @@ InspectionsUI.fr.Designer.cs Designer - - ResXFileCodeGenerator - InspectionsUI.sv.Designer.cs - Designer - - - ResXFileCodeGenerator - InspectionsUI.ja.Designer.cs - Designer - AboutDialog.cs @@ -1051,16 +1025,6 @@ RubberduckUI.de.Designer.cs Designer - - PublicResXFileCodeGenerator - RubberduckUI.ja.Designer.cs - Designer - - - PublicResXFileCodeGenerator - RubberduckUI.sv.Designer.cs - Designer - SettingsForm.cs @@ -1314,6 +1278,8 @@ + + diff --git a/RetailCoder.VBE/Settings/CodeInspectionConfigProvider.cs b/RetailCoder.VBE/Settings/CodeInspectionConfigProvider.cs index 20b2848ab7..281ed2238b 100644 --- a/RetailCoder.VBE/Settings/CodeInspectionConfigProvider.cs +++ b/RetailCoder.VBE/Settings/CodeInspectionConfigProvider.cs @@ -1,40 +1,28 @@ using System.Collections.Generic; -using System.Linq; using Rubberduck.Inspections; using Rubberduck.SettingsProvider; namespace Rubberduck.Settings { - public interface ICodeInspectionConfigProvider - { - CodeInspectionSettings Create(IEnumerable inspections); - CodeInspectionSettings CreateDefaults(); - void Save(CodeInspectionSettings settings); - } - - public class CodeInspectionConfigProvider : ICodeInspectionConfigProvider + public class CodeInspectionConfigProvider : IConfigProvider { private readonly IPersistanceService _persister; - private IEnumerable _inspections; public CodeInspectionConfigProvider(IPersistanceService persister) { _persister = persister; } - public CodeInspectionSettings Create(IEnumerable inspections) + public CodeInspectionSettings Create() { - if (inspections == null) return null; - - _inspections = inspections; - var prototype = new CodeInspectionSettings(GetDefaultCodeInspections()); - return _persister.Load(prototype) ?? prototype; + var prototype = new CodeInspectionSettings(GetDefaultCodeInspections(), new WhitelistedIdentifierSetting[] { }); + return _persister.Load(prototype) ?? prototype; } public CodeInspectionSettings CreateDefaults() { - //This sucks. - return _inspections != null ? new CodeInspectionSettings(GetDefaultCodeInspections()) : null; + //This no longer sucks. + return new CodeInspectionSettings(GetDefaultCodeInspections(), new WhitelistedIdentifierSetting[] {}); } public void Save(CodeInspectionSettings settings) @@ -44,9 +32,47 @@ public void Save(CodeInspectionSettings settings) public HashSet GetDefaultCodeInspections() { - return new HashSet(_inspections.Select(x => - new CodeInspectionSetting(x.Name, x.Description, x.InspectionType, x.DefaultSeverity, - x.DefaultSeverity))); + //*This* sucks now. + return new HashSet + { + new CodeInspectionSetting("ObjectVariableNotSetInspection", string.Empty, CodeInspectionType.CodeQualityIssues, CodeInspectionSeverity.Suggestion, CodeInspectionSeverity.Suggestion), + new CodeInspectionSetting("FunctionReturnValueNotUsedInspection", string.Empty, CodeInspectionType.CodeQualityIssues, CodeInspectionSeverity.Warning, CodeInspectionSeverity.Warning), + new CodeInspectionSetting("SelfAssignedDeclarationInspection", string.Empty, CodeInspectionType.CodeQualityIssues, CodeInspectionSeverity.Hint, CodeInspectionSeverity.Hint), + new CodeInspectionSetting("MoveFieldCloserToUsageInspection", string.Empty, CodeInspectionType.CodeQualityIssues, CodeInspectionSeverity.Suggestion, CodeInspectionSeverity.Suggestion), + new CodeInspectionSetting("EncapsulatePublicFieldInspection", string.Empty, CodeInspectionType.MaintainabilityAndReadabilityIssues, CodeInspectionSeverity.Suggestion, CodeInspectionSeverity.Suggestion), + new CodeInspectionSetting("EmptyStringLiteralInspection", string.Empty, CodeInspectionType.LanguageOpportunities, CodeInspectionSeverity.Warning, CodeInspectionSeverity.Warning), + new CodeInspectionSetting("ImplicitActiveSheetReferenceInspection", string.Empty, CodeInspectionType.MaintainabilityAndReadabilityIssues, CodeInspectionSeverity.Warning, CodeInspectionSeverity.Warning), + new CodeInspectionSetting("ImplicitActiveWorkbookReferenceInspection", string.Empty, CodeInspectionType.MaintainabilityAndReadabilityIssues, CodeInspectionSeverity.Warning, CodeInspectionSeverity.Warning), + new CodeInspectionSetting("MultipleFolderAnnotationsInspection", string.Empty, CodeInspectionType.MaintainabilityAndReadabilityIssues, CodeInspectionSeverity.Error, CodeInspectionSeverity.Error), + new CodeInspectionSetting("ProcedureCanBeWrittenAsFunctionInspection", string.Empty, CodeInspectionType.LanguageOpportunities, CodeInspectionSeverity.Suggestion, CodeInspectionSeverity.Suggestion), + new CodeInspectionSetting("UseMeaningfulNameInspection", string.Empty, CodeInspectionType.MaintainabilityAndReadabilityIssues, CodeInspectionSeverity.Suggestion, CodeInspectionSeverity.Suggestion), + new CodeInspectionSetting("WriteOnlyPropertyInspection", string.Empty, CodeInspectionType.CodeQualityIssues, CodeInspectionSeverity.Suggestion, CodeInspectionSeverity.Suggestion), + new CodeInspectionSetting("UntypedFunctionUsageInspection", string.Empty, CodeInspectionType.LanguageOpportunities, CodeInspectionSeverity.Hint, CodeInspectionSeverity.Hint), + new CodeInspectionSetting("AssignedByValParameterInspection", string.Empty, CodeInspectionType.LanguageOpportunities, CodeInspectionSeverity.Warning, CodeInspectionSeverity.Warning), + new CodeInspectionSetting("ConstantNotUsedInspection", string.Empty, CodeInspectionType.CodeQualityIssues, CodeInspectionSeverity.Warning, CodeInspectionSeverity.Warning), + new CodeInspectionSetting("DefaultProjectNameInspection", string.Empty, CodeInspectionType.MaintainabilityAndReadabilityIssues, CodeInspectionSeverity.Suggestion, CodeInspectionSeverity.Suggestion), + new CodeInspectionSetting("ImplicitPublicMemberInspection", string.Empty, CodeInspectionType.MaintainabilityAndReadabilityIssues, CodeInspectionSeverity.Hint, CodeInspectionSeverity.Hint), + new CodeInspectionSetting("MultilineParameterInspection", string.Empty, CodeInspectionType.MaintainabilityAndReadabilityIssues, CodeInspectionSeverity.Suggestion, CodeInspectionSeverity.Suggestion), + new CodeInspectionSetting("NonReturningFunctionInspection", string.Empty, CodeInspectionType.CodeQualityIssues, CodeInspectionSeverity.Error, CodeInspectionSeverity.Error), + new CodeInspectionSetting("ObsoleteCallStatementInspection", string.Empty, CodeInspectionType.LanguageOpportunities, CodeInspectionSeverity.Suggestion, CodeInspectionSeverity.Suggestion), + new CodeInspectionSetting("ObsoleteGlobalInspection", string.Empty, CodeInspectionType.LanguageOpportunities, CodeInspectionSeverity.Suggestion, CodeInspectionSeverity.Suggestion), + new CodeInspectionSetting("ObsoleteLetStatementInspection", string.Empty, CodeInspectionType.LanguageOpportunities, CodeInspectionSeverity.Suggestion, CodeInspectionSeverity.Suggestion), + new CodeInspectionSetting("ObsoleteTypeHintInspection", string.Empty, CodeInspectionType.LanguageOpportunities, CodeInspectionSeverity.Suggestion, CodeInspectionSeverity.Suggestion), + new CodeInspectionSetting("OptionBaseInspection", string.Empty, CodeInspectionType.MaintainabilityAndReadabilityIssues, CodeInspectionSeverity.Hint, CodeInspectionSeverity.Hint), + new CodeInspectionSetting("ParameterCanBeByValInspection", string.Empty, CodeInspectionType.CodeQualityIssues, CodeInspectionSeverity.Suggestion, CodeInspectionSeverity.Suggestion), + new CodeInspectionSetting("ParameterNotUsedInspection", string.Empty, CodeInspectionType.CodeQualityIssues, CodeInspectionSeverity.Warning, CodeInspectionSeverity.Warning), + new CodeInspectionSetting("ProcedureNotUsedInspection", string.Empty, CodeInspectionType.CodeQualityIssues, CodeInspectionSeverity.Warning, CodeInspectionSeverity.Warning), + new CodeInspectionSetting("UnassignedVariableUsageInspection", string.Empty, CodeInspectionType.CodeQualityIssues, CodeInspectionSeverity.Error, CodeInspectionSeverity.Error), + new CodeInspectionSetting("VariableNotUsedInspection", string.Empty, CodeInspectionType.CodeQualityIssues, CodeInspectionSeverity.Warning, CodeInspectionSeverity.Warning), + new CodeInspectionSetting("VariableNotAssignedInspection", string.Empty, CodeInspectionType.CodeQualityIssues, CodeInspectionSeverity.Warning, CodeInspectionSeverity.Warning), + new CodeInspectionSetting("ImplicitByRefParameterInspection", string.Empty, CodeInspectionType.CodeQualityIssues, CodeInspectionSeverity.Hint, CodeInspectionSeverity.Hint), + new CodeInspectionSetting("ImplicitVariantReturnTypeInspection", string.Empty, CodeInspectionType.CodeQualityIssues, CodeInspectionSeverity.Hint, CodeInspectionSeverity.Hint), + new CodeInspectionSetting("MultipleDeclarationsInspection", string.Empty, CodeInspectionType.MaintainabilityAndReadabilityIssues, CodeInspectionSeverity.Warning, CodeInspectionSeverity.Warning), + new CodeInspectionSetting("ObsoleteCommentSyntaxInspection", string.Empty, CodeInspectionType.LanguageOpportunities, CodeInspectionSeverity.Suggestion, CodeInspectionSeverity.Suggestion), + new CodeInspectionSetting("OptionExplicitInspection", string.Empty, CodeInspectionType.CodeQualityIssues, CodeInspectionSeverity.Error, CodeInspectionSeverity.Error), + new CodeInspectionSetting("VariableTypeNotDeclaredInspection", string.Empty, CodeInspectionType.LanguageOpportunities, CodeInspectionSeverity.Warning, CodeInspectionSeverity.Warning), + new CodeInspectionSetting("MalformedAnnotationInspection", string.Empty, CodeInspectionType.CodeQualityIssues, CodeInspectionSeverity.Error, CodeInspectionSeverity.Error) + }; } } } diff --git a/RetailCoder.VBE/Settings/CodeInspectionSettings.cs b/RetailCoder.VBE/Settings/CodeInspectionSettings.cs index 0f43d31213..81a9419e54 100644 --- a/RetailCoder.VBE/Settings/CodeInspectionSettings.cs +++ b/RetailCoder.VBE/Settings/CodeInspectionSettings.cs @@ -10,6 +10,7 @@ namespace Rubberduck.Settings public interface ICodeInspectionSettings { HashSet CodeInspections { get; set; } + WhitelistedIdentifierSetting[] WhitelistedIdentifiers { get; set; } } [XmlType(AnonymousType = true)] @@ -18,14 +19,17 @@ public class CodeInspectionSettings : ICodeInspectionSettings [XmlArrayItem("CodeInspection", IsNullable = false)] public HashSet CodeInspections { get; set; } - public CodeInspectionSettings() + [XmlArrayItem("WhitelistedIdentifier", IsNullable = false)] + public WhitelistedIdentifierSetting[] WhitelistedIdentifiers { get; set; } + + public CodeInspectionSettings() : this(new HashSet(), new WhitelistedIdentifierSetting[] {}) { - CodeInspections =new HashSet(); } - public CodeInspectionSettings(HashSet inspections) + public CodeInspectionSettings(HashSet inspections, WhitelistedIdentifierSetting[] whitelistedNames) { CodeInspections = inspections; + WhitelistedIdentifiers = whitelistedNames; } public CodeInspectionSetting GetSetting(Type inspection) diff --git a/RetailCoder.VBE/Settings/ConfigurationLoader.cs b/RetailCoder.VBE/Settings/ConfigurationLoader.cs index 4f7d3fe306..458bc7f129 100644 --- a/RetailCoder.VBE/Settings/ConfigurationLoader.cs +++ b/RetailCoder.VBE/Settings/ConfigurationLoader.cs @@ -1,7 +1,5 @@ using System; -using System.Collections.Generic; using System.Linq; -using Rubberduck.Inspections; using Rubberduck.SmartIndenter; namespace Rubberduck.Settings @@ -25,18 +23,15 @@ public interface IGeneralConfigService : IConfigurationService public class ConfigurationLoader : IGeneralConfigService { - private readonly IGeneralConfigProvider _generalProvider; - private readonly IHotkeyConfigProvider _hotkeyProvider; - private readonly IToDoListConfigProvider _todoProvider; - private readonly ICodeInspectionConfigProvider _inspectionProvider; - private readonly IUnitTestConfigProvider _unitTestProvider; - private readonly IIndenterConfigProvider _indenterProvider; + private readonly IConfigProvider _generalProvider; + private readonly IConfigProvider _hotkeyProvider; + private readonly IConfigProvider _todoProvider; + private readonly IConfigProvider _inspectionProvider; + private readonly IConfigProvider _unitTestProvider; + private readonly IConfigProvider _indenterProvider; - private readonly IEnumerable _inspections; - - public ConfigurationLoader(IGeneralConfigProvider generalProvider, IHotkeyConfigProvider hotkeyProvider, IToDoListConfigProvider todoProvider, - ICodeInspectionConfigProvider inspectionProvider, IUnitTestConfigProvider unitTestProvider, IIndenterConfigProvider indenterProvider, - IEnumerable inspections) + public ConfigurationLoader(IConfigProvider generalProvider, IConfigProvider hotkeyProvider, IConfigProvider todoProvider, + IConfigProvider inspectionProvider, IConfigProvider unitTestProvider, IConfigProvider indenterProvider) { _generalProvider = generalProvider; _hotkeyProvider = hotkeyProvider; @@ -44,7 +39,6 @@ public ConfigurationLoader(IGeneralConfigProvider generalProvider, IHotkeyConfig _inspectionProvider = inspectionProvider; _unitTestProvider = unitTestProvider; _indenterProvider = indenterProvider; - _inspections = inspections; } /// @@ -59,32 +53,14 @@ public virtual Configuration LoadConfiguration() _generalProvider.Create(), _hotkeyProvider.Create(), _todoProvider.Create(), - _inspectionProvider.Create(_inspections), + _inspectionProvider.Create(), _unitTestProvider.Create(), _indenterProvider.Create() ) - }; - MergeImplementedInspectionsNotInConfig(config.UserSettings.CodeInspectionSettings); + }; return config; } - private void MergeImplementedInspectionsNotInConfig(ICodeInspectionSettings config) - { - foreach (var implementedInspection in _inspections) - { - var inspection = config.CodeInspections.SingleOrDefault(i => i.Name.Equals(implementedInspection.Name)); - if (inspection == null) - { - config.CodeInspections.Add(new CodeInspectionSetting(implementedInspection)); - } - else - { - // description isn't serialized - inspection.Description = implementedInspection.Description; - } - } - } - public Configuration GetDefaultConfiguration() { return new Configuration @@ -104,7 +80,7 @@ public Configuration GetDefaultConfiguration() public void SaveConfiguration(Configuration toSerialize) { var langChanged = _generalProvider.Create().Language.Code != toSerialize.UserSettings.GeneralSettings.Language.Code; - var oldInspectionSettings = _inspectionProvider.Create(_inspections).CodeInspections.Select(s => Tuple.Create(s.Name, s.Severity)); + var oldInspectionSettings = _inspectionProvider.Create().CodeInspections.Select(s => Tuple.Create(s.Name, s.Severity)); var newInspectionSettings = toSerialize.UserSettings.CodeInspectionSettings.CodeInspections.Select(s => Tuple.Create(s.Name, s.Severity)); _generalProvider.Save(toSerialize.UserSettings.GeneralSettings); diff --git a/RetailCoder.VBE/Settings/GeneralConfigProvider.cs b/RetailCoder.VBE/Settings/GeneralConfigProvider.cs index a16f98fb6a..ce7af4f39f 100644 --- a/RetailCoder.VBE/Settings/GeneralConfigProvider.cs +++ b/RetailCoder.VBE/Settings/GeneralConfigProvider.cs @@ -3,15 +3,7 @@ namespace Rubberduck.Settings { - public interface IGeneralConfigProvider - { - GeneralSettings Create(); - GeneralSettings CreateDefaults(); - - void Save(GeneralSettings settings); - } - - public class GeneralConfigProvider : IGeneralConfigProvider + public class GeneralConfigProvider : IConfigProvider { private GeneralSettings _current; private readonly IPersistanceService _persister; diff --git a/RetailCoder.VBE/Settings/HotkeyConfigProvider.cs b/RetailCoder.VBE/Settings/HotkeyConfigProvider.cs index af39708ab3..22989db436 100644 --- a/RetailCoder.VBE/Settings/HotkeyConfigProvider.cs +++ b/RetailCoder.VBE/Settings/HotkeyConfigProvider.cs @@ -2,14 +2,7 @@ namespace Rubberduck.Settings { - public interface IHotkeyConfigProvider - { - HotkeySettings Create(); - HotkeySettings CreateDefaults(); - void Save(HotkeySettings settings); - } - - public class HotkeyConfigProvider : IHotkeyConfigProvider + public class HotkeyConfigProvider : IConfigProvider { private readonly IPersistanceService _persister; @@ -19,7 +12,7 @@ public HotkeyConfigProvider(IPersistanceService persister) } public HotkeySettings Create() - { + { var prototype = new HotkeySettings(); return _persister.Load(prototype) ?? prototype; } diff --git a/RetailCoder.VBE/Settings/HotkeySettings.cs b/RetailCoder.VBE/Settings/HotkeySettings.cs index d2c0ca5860..544a8b60e4 100644 --- a/RetailCoder.VBE/Settings/HotkeySettings.cs +++ b/RetailCoder.VBE/Settings/HotkeySettings.cs @@ -24,7 +24,8 @@ public class HotkeySettings : IHotkeySettings new HotkeySetting{Name=RubberduckHotkey.RefactorMoveCloserToUsage.ToString(), IsEnabled=true, HasCtrlModifier = true, HasShiftModifier = true, Key1="C" }, new HotkeySetting{Name=RubberduckHotkey.RefactorRename.ToString(), IsEnabled=true, HasCtrlModifier = true, HasShiftModifier = true, Key1="R" }, new HotkeySetting{Name=RubberduckHotkey.RefactorExtractMethod.ToString(), IsEnabled=true, HasCtrlModifier = true, HasShiftModifier = true, Key1="M" }, - new HotkeySetting{Name=RubberduckHotkey.SourceControl.ToString(), IsEnabled=true, HasCtrlModifier = true, HasShiftModifier = true, Key1="D6" } + new HotkeySetting{Name=RubberduckHotkey.SourceControl.ToString(), IsEnabled=true, HasCtrlModifier = true, HasShiftModifier = true, Key1="D6" }, + new HotkeySetting{Name=RubberduckHotkey.RefactorEncapsulateField.ToString(), IsEnabled=true, HasCtrlModifier = true, HasShiftModifier = true, Key1="E" } }; private HashSet _settings; diff --git a/RetailCoder.VBE/Settings/RubberduckHotkey.cs b/RetailCoder.VBE/Settings/RubberduckHotkey.cs index 73fd378fd2..c97a071986 100644 --- a/RetailCoder.VBE/Settings/RubberduckHotkey.cs +++ b/RetailCoder.VBE/Settings/RubberduckHotkey.cs @@ -13,6 +13,7 @@ public enum RubberduckHotkey RefactorMoveCloserToUsage, RefactorRename, RefactorExtractMethod, + RefactorEncapsulateField, SourceControl } } diff --git a/RetailCoder.VBE/Settings/ToDoListConfigProvider.cs b/RetailCoder.VBE/Settings/ToDoListConfigProvider.cs index 71bddaa9b6..bf79d7f5cd 100644 --- a/RetailCoder.VBE/Settings/ToDoListConfigProvider.cs +++ b/RetailCoder.VBE/Settings/ToDoListConfigProvider.cs @@ -2,14 +2,7 @@ namespace Rubberduck.Settings { - public interface IToDoListConfigProvider - { - ToDoListSettings Create(); - ToDoListSettings CreateDefaults(); - void Save(ToDoListSettings settings); - } - - public class ToDoListConfigProvider : IToDoListConfigProvider + public class ToDoListConfigProvider : IConfigProvider { private readonly IPersistanceService _persister; diff --git a/RetailCoder.VBE/Settings/UnitTestConfigProvider.cs b/RetailCoder.VBE/Settings/UnitTestConfigProvider.cs index 9021517fb1..de1e84dfab 100644 --- a/RetailCoder.VBE/Settings/UnitTestConfigProvider.cs +++ b/RetailCoder.VBE/Settings/UnitTestConfigProvider.cs @@ -2,15 +2,7 @@ namespace Rubberduck.Settings { - public interface IUnitTestConfigProvider - { - UnitTestSettings Create(); - UnitTestSettings CreateDefaults(); - - void Save(UnitTestSettings settings); - } - - public class UnitTestConfigProvider : IUnitTestConfigProvider + public class UnitTestConfigProvider : IConfigProvider { private readonly IPersistanceService _persister; diff --git a/RetailCoder.VBE/Settings/WhitelistedIdentifierSetting.cs b/RetailCoder.VBE/Settings/WhitelistedIdentifierSetting.cs new file mode 100644 index 0000000000..f33ba7380e --- /dev/null +++ b/RetailCoder.VBE/Settings/WhitelistedIdentifierSetting.cs @@ -0,0 +1,18 @@ +using System.Xml.Serialization; + +namespace Rubberduck.Settings +{ + [XmlType(AnonymousType = true)] + public class WhitelistedIdentifierSetting + { + [XmlAttribute] + public string Identifier { get; set; } + + public WhitelistedIdentifierSetting(string identifier) + { + Identifier = identifier; + } + + public WhitelistedIdentifierSetting() : this("*") { } + } +} \ No newline at end of file diff --git a/RetailCoder.VBE/Sinks.cs b/RetailCoder.VBE/Sinks.cs index 3e7773c96b..5e29fabe44 100644 --- a/RetailCoder.VBE/Sinks.cs +++ b/RetailCoder.VBE/Sinks.cs @@ -1,7 +1,6 @@ using System; using System.Collections.Generic; using System.Runtime.InteropServices.ComTypes; -using System.Threading.Tasks; using Microsoft.Vbe.Interop; using Rubberduck.Common.Dispatch; using Rubberduck.Parsing; @@ -11,18 +10,22 @@ namespace Rubberduck { public class ProjectEventArgs : EventArgs, IProjectEventArgs { - public ProjectEventArgs(string projectId) + public ProjectEventArgs(string projectId, VBProject project) { _projectId = projectId; + _project = project; } private readonly string _projectId; public string ProjectId { get { return _projectId; } } + + private readonly VBProject _project; + public VBProject Project { get { return _project; } } } public class ProjectRenamedEventArgs : ProjectEventArgs, IProjectRenamedEventArgs { - public ProjectRenamedEventArgs(string projectId, string oldName) : base(projectId) + public ProjectRenamedEventArgs(string projectId, VBProject project, string oldName) : base(projectId, project) { _oldName = oldName; } @@ -33,27 +36,28 @@ public ProjectRenamedEventArgs(string projectId, string oldName) : base(projectI public class ComponentEventArgs : EventArgs, IComponentEventArgs { - public ComponentEventArgs(string projectId, string componentName, vbext_ComponentType type) + public ComponentEventArgs(string projectId, VBProject project, VBComponent component) { _projectId = projectId; - _componentName = componentName; - _type = type; + _project = project; + _component = component; } private readonly string _projectId; public string ProjectId { get { return _projectId; } } - private readonly string _componentName; - public string ComponentName { get { return _componentName; } } + private readonly VBProject _project; + public VBProject Project { get { return _project; } } + + private readonly VBComponent _component; + public VBComponent Component { get { return _component; } } - private readonly vbext_ComponentType _type; - public vbext_ComponentType Type { get { return _type; } } } public class ComponentRenamedEventArgs : ComponentEventArgs, IComponentRenamedEventArgs { - public ComponentRenamedEventArgs(string projectId, string componentName, vbext_ComponentType type, string oldName) - : base(projectId, componentName, type) + public ComponentRenamedEventArgs(string projectId, VBProject project, VBComponent component, string oldName) + : base(projectId, project, component) { _oldName = oldName; } @@ -73,11 +77,11 @@ public class Sinks : ISinks, IDisposable private readonly IDictionary> _componentsEventsConnectionPoints = new Dictionary>(); - public bool IsEnabled { get; set; } + public bool ComponentSinksEnabled { get; set; } public Sinks(VBE vbe) { - IsEnabled = true; + ComponentSinksEnabled = true; _sink = new VBProjectsEventsSink(); var connectionPointContainer = (IConnectionPointContainer)vbe.VBProjects; @@ -100,70 +104,52 @@ public Sinks(VBE vbe) private void _sink_ProjectActivated(object sender, DispatcherEventArgs e) { - if (!IsEnabled) { return; } var projectId = e.Item.HelpFile; - - Task.Run(() => + + var handler = ProjectActivated; + if (handler != null) { - var handler = ProjectActivated; - if (handler != null) - { - handler(sender, new ProjectEventArgs(projectId)); - } - }); + handler(sender, new ProjectEventArgs(projectId, e.Item)); + } } private void _sink_ProjectAdded(object sender, DispatcherEventArgs e) { - if (!IsEnabled) { return; } - e.Item.AssignProjectId(); var projectId = e.Item.HelpFile; RegisterComponentsEventSink(e.Item.VBComponents, projectId); - - Task.Run(() => + + var handler = ProjectAdded; + if (handler != null) { - var handler = ProjectAdded; - if (handler != null) - { - handler(sender, new ProjectEventArgs(projectId)); - } - }); + handler(sender, new ProjectEventArgs(projectId, e.Item)); + } } private void _sink_ProjectRemoved(object sender, DispatcherEventArgs e) { UnregisterComponentsEventSink(e.Item.HelpFile); - if (!IsEnabled) { return; } var projectId = e.Item.HelpFile; - - Task.Run(() => + + var handler = ProjectRemoved; + if (handler != null) { - var handler = ProjectRemoved; - if (handler != null) - { - handler(sender, new ProjectEventArgs(projectId)); - } - }); + handler(sender, new ProjectEventArgs(projectId, e.Item)); + } } private void _sink_ProjectRenamed(object sender, DispatcherRenamedEventArgs e) { - if (!IsEnabled) { return; } - var projectId = e.Item.HelpFile; var oldName = e.OldName; - - Task.Run(() => + + var handler = ProjectRenamed; + if (handler != null) { - var handler = ProjectRenamed; - if (handler != null) - { - handler(sender, new ProjectRenamedEventArgs(projectId, oldName)); - } - }); + handler(sender, new ProjectRenamedEventArgs(projectId, e.Item, oldName)); + } } #endregion @@ -225,86 +211,79 @@ private void UnregisterComponentsEventSink(string projectId) private void ComponentsSink_ComponentActivated(object sender, DispatcherEventArgs e) { - if (!IsEnabled) { return; } + if (!ComponentSinksEnabled) { return; } var projectId = e.Item.Collection.Parent.HelpFile; - var componentName = e.Item.Name; var handler = ComponentActivated; if (handler != null) { - handler(sender, new ComponentEventArgs(projectId, componentName, e.Item.Type)); + handler(sender, new ComponentEventArgs(projectId, e.Item.Collection.Parent, e.Item)); } } private void ComponentsSink_ComponentAdded(object sender, DispatcherEventArgs e) { - if (!IsEnabled) { return; } + if (!ComponentSinksEnabled) { return; } var projectId = e.Item.Collection.Parent.HelpFile; - var componentName = e.Item.Name; var handler = ComponentAdded; if (handler != null) { - handler(sender, new ComponentEventArgs(projectId, componentName, e.Item.Type)); + handler(sender, new ComponentEventArgs(projectId, e.Item.Collection.Parent, e.Item)); } } private void ComponentsSink_ComponentReloaded(object sender, DispatcherEventArgs e) { - if (!IsEnabled) { return; } + if (!ComponentSinksEnabled) { return; } var projectId = e.Item.Collection.Parent.HelpFile; - var componentName = e.Item.Name; var handler = ComponentReloaded; if (handler != null) { - handler(sender, new ComponentEventArgs(projectId, componentName, e.Item.Type)); + handler(sender, new ComponentEventArgs(projectId, e.Item.Collection.Parent, e.Item)); } } private void ComponentsSink_ComponentRemoved(object sender, DispatcherEventArgs e) { - if (!IsEnabled) { return; } + if (!ComponentSinksEnabled) { return; } var projectId = e.Item.Collection.Parent.HelpFile; - var componentName = e.Item.Name; var handler = ComponentRemoved; if (handler != null) { - handler(sender, new ComponentEventArgs(projectId, componentName, e.Item.Type)); + handler(sender, new ComponentEventArgs(projectId, e.Item.Collection.Parent, e.Item)); } } private void ComponentsSink_ComponentRenamed(object sender, DispatcherRenamedEventArgs e) { - if (!IsEnabled) { return; } + if (!ComponentSinksEnabled) { return; } var projectId = e.Item.Collection.Parent.HelpFile; - var componentName = e.Item.Name; - var oldName = e.OldName; var handler = ComponentRenamed; if (handler != null) { - handler(sender, new ComponentRenamedEventArgs(projectId, componentName, e.Item.Type, oldName)); + handler(sender, new ComponentRenamedEventArgs(projectId, e.Item.Collection.Parent, e.Item, e.OldName)); } } private void ComponentsSink_ComponentSelected(object sender, DispatcherEventArgs e) { - if (!IsEnabled) { return; } + if (!ComponentSinksEnabled) { return; } var projectId = e.Item.Collection.Parent.HelpFile; - var componentName = e.Item.Name; var handler = ComponentSelected; if (handler != null) { - handler(sender, new ComponentEventArgs(projectId, componentName, e.Item.Type)); + handler(sender, new ComponentEventArgs(projectId, e.Item.Collection.Parent, e.Item)); } } #endregion diff --git a/RetailCoder.VBE/UI/CodeExplorer/CodeExplorerControl.xaml b/RetailCoder.VBE/UI/CodeExplorer/CodeExplorerControl.xaml index 8588f8ae10..5251d1a7c1 100644 --- a/RetailCoder.VBE/UI/CodeExplorer/CodeExplorerControl.xaml +++ b/RetailCoder.VBE/UI/CodeExplorer/CodeExplorerControl.xaml @@ -15,12 +15,13 @@ d:DesignHeight="300" d:DesignWidth="300" d:DataContext="{d:DesignInstance codeExplorer:CodeExplorerViewModel}"> + + - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + - - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + - - - - - - - - - - - - - - - - - - - - - - - - + + + + + + + + diff --git a/RetailCoder.VBE/UI/Settings/InspectionSettings.xaml.cs b/RetailCoder.VBE/UI/Settings/InspectionSettings.xaml.cs index 1702ca97f7..d14510fdd5 100644 --- a/RetailCoder.VBE/UI/Settings/InspectionSettings.xaml.cs +++ b/RetailCoder.VBE/UI/Settings/InspectionSettings.xaml.cs @@ -2,6 +2,8 @@ using System.Linq; using System.Windows.Controls; using Rubberduck.Inspections; +using System.Collections.ObjectModel; +using Rubberduck.Settings; namespace Rubberduck.UI.Settings { @@ -29,9 +31,29 @@ private void GroupingGrid_CellEditEnding(object sender, DataGridCellEditEndingEv var selectedSeverityName = ((ComboBox) e.EditingElement).SelectedItem.ToString(); var severities = Enum.GetValues(typeof(CodeInspectionSeverity)).Cast(); - var selectedSeverity = severities.Single(s => RubberduckUI.ResourceManager.GetString("CodeInspectionSeverity_" + s, UI.Settings.Settings.Culture) == selectedSeverityName); + var selectedSeverity = severities.Single(s => RubberduckUI.ResourceManager.GetString("CodeInspectionSeverity_" + s, Settings.Culture) == selectedSeverityName); ((InspectionSettingsViewModel) ViewModel).UpdateCollection(selectedSeverity); } + + private void WhitelistedIdentifierGrid_CellEditEnding(object sender, DataGridCellEditEndingEventArgs e) + { + if (e.Cancel || e.EditAction == DataGridEditAction.Cancel) { return; } + + var identifiers = WhitelistedIdentifiersGrid.ItemsSource.OfType().ToList(); + + var editedIndex = e.Row.GetIndex(); + identifiers.RemoveAt(editedIndex); + identifiers.Insert(editedIndex, new WhitelistedIdentifierSetting(((TextBox)e.EditingElement).Text)); + + ((InspectionSettingsViewModel)ViewModel).WhitelistedIdentifierSettings = new ObservableCollection(identifiers); + } + + private void AddNewItem(object sender, System.Windows.RoutedEventArgs e) + { + WhitelistedIdentifiersGrid.CommitEdit(); + ((InspectionSettingsViewModel) ViewModel).AddWhitelistedNameCommand.Execute(null); + e.Handled = true; + } } } diff --git a/RetailCoder.VBE/UI/Settings/InspectionSettingsViewModel.cs b/RetailCoder.VBE/UI/Settings/InspectionSettingsViewModel.cs index 517e172502..3c828816f3 100644 --- a/RetailCoder.VBE/UI/Settings/InspectionSettingsViewModel.cs +++ b/RetailCoder.VBE/UI/Settings/InspectionSettingsViewModel.cs @@ -1,8 +1,11 @@ using System.Collections.Generic; +using System.Collections.ObjectModel; using System.Linq; using System.Windows.Data; +using NLog; using Rubberduck.Inspections; using Rubberduck.Settings; +using Rubberduck.UI.Command; namespace Rubberduck.UI.Settings { @@ -13,6 +16,9 @@ public InspectionSettingsViewModel(Configuration config) InspectionSettings = new ListCollectionView( config.UserSettings.CodeInspectionSettings.CodeInspections.ToList()); + WhitelistedIdentifierSettings = new ObservableCollection( + config.UserSettings.CodeInspectionSettings.WhitelistedIdentifiers.OrderBy(o => o.Identifier).Distinct()); + if (InspectionSettings.GroupDescriptions != null) { InspectionSettings.GroupDescriptions.Add(new PropertyGroupDescription("TypeLabel")); @@ -45,9 +51,24 @@ public ListCollectionView InspectionSettings } } + private ObservableCollection _whitelistedNameSettings; + public ObservableCollection WhitelistedIdentifierSettings + { + get { return _whitelistedNameSettings; } + set + { + if (_whitelistedNameSettings != value) + { + _whitelistedNameSettings = value; + OnPropertyChanged(); + } + } + } + public void UpdateConfig(Configuration config) { config.UserSettings.CodeInspectionSettings.CodeInspections = new HashSet(InspectionSettings.SourceCollection.OfType()); + config.UserSettings.CodeInspectionSettings.WhitelistedIdentifiers = WhitelistedIdentifierSettings.Distinct().ToArray(); } public void SetToDefaults(Configuration config) @@ -59,6 +80,40 @@ public void SetToDefaults(Configuration config) { InspectionSettings.GroupDescriptions.Add(new PropertyGroupDescription("TypeLabel")); } + + WhitelistedIdentifierSettings = new ObservableCollection(); + } + + private CommandBase _addWhitelistedNameCommand; + public CommandBase AddWhitelistedNameCommand + { + get + { + if (_addWhitelistedNameCommand != null) + { + return _addWhitelistedNameCommand; + } + return _addWhitelistedNameCommand = new DelegateCommand(LogManager.GetCurrentClassLogger(), _ => + { + WhitelistedIdentifierSettings.Add(new WhitelistedIdentifierSetting()); + }); + } + } + + private CommandBase _deleteWhitelistedNameCommand; + public CommandBase DeleteWhitelistedNameCommand + { + get + { + if (_deleteWhitelistedNameCommand != null) + { + return _deleteWhitelistedNameCommand; + } + return _deleteWhitelistedNameCommand = new DelegateCommand(LogManager.GetCurrentClassLogger(), value => + { + WhitelistedIdentifierSettings.Remove(value as WhitelistedIdentifierSetting); + }); + } } } } diff --git a/RetailCoder.VBE/UI/Settings/TodoSettings.xaml b/RetailCoder.VBE/UI/Settings/TodoSettings.xaml index 4ae1f32847..2b6317ee05 100644 --- a/RetailCoder.VBE/UI/Settings/TodoSettings.xaml +++ b/RetailCoder.VBE/UI/Settings/TodoSettings.xaml @@ -244,7 +244,7 @@ - + - public class ToDoExplorerDockablePresenter : DockableToolwindowPresenter { - - public ToDoExplorerDockablePresenter(VBE vbe, AddIn addin, IDockableUserControl window) + public ToDoExplorerDockablePresenter(VBE vbe, AddIn addin, ToDoExplorerWindow window) : base(vbe, addin, window) { } diff --git a/RetailCoder.VBE/UI/ToDoItems/ToDoExplorerViewModel.cs b/RetailCoder.VBE/UI/ToDoItems/ToDoExplorerViewModel.cs index fbfdc53293..7005c2c37c 100644 --- a/RetailCoder.VBE/UI/ToDoItems/ToDoExplorerViewModel.cs +++ b/RetailCoder.VBE/UI/ToDoItems/ToDoExplorerViewModel.cs @@ -107,7 +107,7 @@ public CommandBase RefreshCommand private void _state_StateChanged(object sender, EventArgs e) { - if (_state.Status != ParserState.Ready) + if (_state.Status != ParserState.ResolvedDeclarations) { return; } diff --git a/RetailCoder.VBE/UI/ToDoItems/ToDoExplorerWindow.cs b/RetailCoder.VBE/UI/ToDoItems/ToDoExplorerWindow.cs index aac46f2eab..2046c658fb 100644 --- a/RetailCoder.VBE/UI/ToDoItems/ToDoExplorerWindow.cs +++ b/RetailCoder.VBE/UI/ToDoItems/ToDoExplorerWindow.cs @@ -10,21 +10,21 @@ public partial class ToDoExplorerWindow : UserControl, IDockableUserControl string IDockableUserControl.ClassId { get { return ClassId; } } string IDockableUserControl.Caption { get { return RubberduckUI.TodoExplorer_Caption; } } - public ToDoExplorerWindow() + private ToDoExplorerWindow() { InitializeComponent(); } - private ToDoExplorerViewModel _viewModel; + public ToDoExplorerWindow(ToDoExplorerViewModel viewModel) : this() + { + _viewModel = viewModel; + TodoExplorerControl.DataContext = _viewModel; + } + + private readonly ToDoExplorerViewModel _viewModel; public ToDoExplorerViewModel ViewModel { get { return _viewModel; } - set - { - _viewModel = value; - TodoExplorerControl.DataContext = _viewModel; - } } - } } diff --git a/RetailCoder.VBE/UI/UnitTesting/TestExplorerDockablePresenter.cs b/RetailCoder.VBE/UI/UnitTesting/TestExplorerDockablePresenter.cs index 44abf8f5ad..5124976d1a 100644 --- a/RetailCoder.VBE/UI/UnitTesting/TestExplorerDockablePresenter.cs +++ b/RetailCoder.VBE/UI/UnitTesting/TestExplorerDockablePresenter.cs @@ -4,7 +4,7 @@ namespace Rubberduck.UI.UnitTesting { public class TestExplorerDockablePresenter : DockableToolwindowPresenter { - public TestExplorerDockablePresenter(VBE vbe, AddIn addin, IDockableUserControl view) + public TestExplorerDockablePresenter(VBE vbe, AddIn addin, TestExplorerWindow view) : base(vbe, addin, view) { } diff --git a/RetailCoder.VBE/UI/UnitTesting/TestExplorerViewModel.cs b/RetailCoder.VBE/UI/UnitTesting/TestExplorerViewModel.cs index 4a9346c39e..aadb5cd990 100644 --- a/RetailCoder.VBE/UI/UnitTesting/TestExplorerViewModel.cs +++ b/RetailCoder.VBE/UI/UnitTesting/TestExplorerViewModel.cs @@ -32,8 +32,6 @@ public TestExplorerViewModel(VBE vbe, ITestEngine testEngine, TestExplorerModel model, IClipboardWriter clipboard, - NewUnitTestModuleCommand newTestModuleCommand, - NewTestMethodCommand newTestMethodCommand, IGeneralConfigService configService, IOperatingSystem operatingSystem) { @@ -51,9 +49,9 @@ public TestExplorerViewModel(VBE vbe, _runAllTestsCommand = new RunAllTestsCommand(vbe, state, testEngine, model); _runAllTestsCommand.RunCompleted += RunCompleted; - _addTestModuleCommand = new AddTestModuleCommand(vbe, state, newTestModuleCommand); - _addTestMethodCommand = new AddTestMethodCommand(vbe, state, newTestMethodCommand); - _addErrorTestMethodCommand = new AddTestMethodExpectedErrorCommand(vbe, state, newTestMethodCommand); + _addTestModuleCommand = new AddTestModuleCommand(vbe, state, configService); + _addTestMethodCommand = new AddTestMethodCommand(vbe, state); + _addErrorTestMethodCommand = new AddTestMethodExpectedErrorCommand(vbe, state); _refreshCommand = new DelegateCommand(LogManager.GetCurrentClassLogger(), ExecuteRefreshCommand, CanExecuteRefreshCommand); _repeatLastRunCommand = new DelegateCommand(LogManager.GetCurrentClassLogger(), ExecuteRepeatLastRunCommand, CanExecuteRepeatLastRunCommand); @@ -230,8 +228,22 @@ private bool CanExecuteRefreshCommand(object parameter) return !Model.IsBusy && _state.IsDirty(); } + private void EnsureRubberduckIsReferencedForEarlyBoundTests() + { + foreach (var member in _state.AllUserDeclarations) + { + if (member.AsTypeName == "Rubberduck.PermissiveAssertClass" || + member.AsTypeName == "Rubberduck.AssertClass") + { + member.Project.EnsureReferenceToAddInLibrary(); + } + } + } + private void ExecuteRepeatLastRunCommand(object parameter) { + EnsureRubberduckIsReferencedForEarlyBoundTests(); + var tests = _model.LastRun.ToList(); _model.ClearLastRun(); @@ -248,6 +260,8 @@ private void ExecuteRepeatLastRunCommand(object parameter) private void ExecuteRunNotExecutedTestsCommand(object parameter) { + EnsureRubberduckIsReferencedForEarlyBoundTests(); + _model.ClearLastRun(); var stopwatch = new Stopwatch(); @@ -263,6 +277,8 @@ private void ExecuteRunNotExecutedTestsCommand(object parameter) private void ExecuteRunFailedTestsCommand(object parameter) { + EnsureRubberduckIsReferencedForEarlyBoundTests(); + _model.ClearLastRun(); var stopwatch = new Stopwatch(); @@ -278,6 +294,8 @@ private void ExecuteRunFailedTestsCommand(object parameter) private void ExecuteRunPassedTestsCommand(object parameter) { + EnsureRubberduckIsReferencedForEarlyBoundTests(); + _model.ClearLastRun(); var stopwatch = new Stopwatch(); @@ -303,6 +321,8 @@ private void ExecuteSelectedTestCommand(object obj) return; } + EnsureRubberduckIsReferencedForEarlyBoundTests(); + _model.ClearLastRun(); var stopwatch = new Stopwatch(); diff --git a/RetailCoder.VBE/UI/UnitTesting/TestExplorerWindow.cs b/RetailCoder.VBE/UI/UnitTesting/TestExplorerWindow.cs index cfd9b73361..3f62ee7f85 100644 --- a/RetailCoder.VBE/UI/UnitTesting/TestExplorerWindow.cs +++ b/RetailCoder.VBE/UI/UnitTesting/TestExplorerWindow.cs @@ -4,20 +4,21 @@ namespace Rubberduck.UI.UnitTesting { public partial class TestExplorerWindow : UserControl, IDockableUserControl { - public TestExplorerWindow() + private TestExplorerWindow() { InitializeComponent(); } - private TestExplorerViewModel _viewModel; + public TestExplorerWindow(TestExplorerViewModel viewModel) : this() + { + _viewModel = viewModel; + wpfTestExplorerControl.DataContext = _viewModel; + } + + private readonly TestExplorerViewModel _viewModel; public TestExplorerViewModel ViewModel { get { return _viewModel; } - set - { - _viewModel = value; - wpfTestExplorerControl.DataContext = _viewModel; - } } public string ClassId diff --git a/RetailCoder.VBE/UnitTesting/NewTestMethodCommand.cs b/RetailCoder.VBE/UnitTesting/NewTestMethodCommand.cs deleted file mode 100644 index 7f9e115624..0000000000 --- a/RetailCoder.VBE/UnitTesting/NewTestMethodCommand.cs +++ /dev/null @@ -1,122 +0,0 @@ -using System.Linq; -using System.Runtime.InteropServices; -using Microsoft.Vbe.Interop; -using Rubberduck.Parsing.VBA; -using Rubberduck.UI; - -namespace Rubberduck.UnitTesting -{ - public class NewTestMethodCommand - { - private readonly VBE _vbe; - private readonly RubberduckParserState _state; - - public NewTestMethodCommand(VBE vbe, RubberduckParserState state) - { - _vbe = vbe; - _state = state; - } - - public const string NamePlaceholder = "%METHODNAME%"; - private const string TestMethodBaseName = "TestMethod"; - - public static readonly string TestMethodTemplate = string.Concat( - "'@TestMethod\n", - "Public Sub ", NamePlaceholder, "() 'TODO ", RubberduckUI.UnitTest_NewMethod_Rename, "\n", - " On Error GoTo TestFail\n", - " \n", - " 'Arrange:\n\n", - " 'Act:\n\n", - " 'Assert:\n", - " Assert.Inconclusive\n\n", - "TestExit:\n", - " Exit Sub\n", - "TestFail:\n", - " Assert.Fail \"", RubberduckUI.UnitTest_NewMethod_RaisedTestError, ": #\" & Err.Number & \" - \" & Err.Description\n", - "End Sub\n" - ); - - public static readonly string TestMethodExpectedErrorTemplate = string.Concat( - "'@TestMethod\n", - "Public Sub ", NamePlaceholder, "() 'TODO ", RubberduckUI.UnitTest_NewMethod_Rename, "\n", - " Const ExpectedError As Long = 0 'TODO ", RubberduckUI.UnitTest_NewMethod_ChangeErrorNo, "\n", - " On Error GoTo TestFail\n", - " \n", - " 'Arrange:\n\n", - " 'Act:\n\n", - "Assert:\n", - " Assert.Fail \"", RubberduckUI.UnitTest_NewMethod_ErrorNotRaised, ".\"\n\n", - "TestExit:\n", - " Exit Sub\n", - "TestFail:\n", - " If Err.Number = ExpectedError Then\n", - " Resume TestExit\n", - " Else\n", - " Resume Assert\n", - " End If\n", - "End Sub\n" - ); - - public void NewTestMethod() - { - 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 = TestMethodTemplate.Replace(NamePlaceholder, name); - module.InsertLines(module.CountOfLines, body); - } - } - catch (COMException) - { - } - - _state.OnParseRequested(this, _vbe.SelectedVBComponent); - } - - public void NewExpectedErrorTestMethod() - { - 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); - } - - private string GetNextTestMethodName(VBComponent component) - { - var names = component.GetTests(_vbe, _state).Select(test => test.Declaration.IdentifierName); - var index = names.Count(n => n.StartsWith(TestMethodBaseName)) + 1; - - return string.Concat(TestMethodBaseName, index); - } - } -} diff --git a/RetailCoder.VBE/UnitTesting/NewUnitTestModuleCommand.cs b/RetailCoder.VBE/UnitTesting/NewUnitTestModuleCommand.cs deleted file mode 100644 index 19aee768ab..0000000000 --- a/RetailCoder.VBE/UnitTesting/NewUnitTestModuleCommand.cs +++ /dev/null @@ -1,127 +0,0 @@ -using System; -using System.Linq; -using Microsoft.Vbe.Interop; -using Rubberduck.Parsing.VBA; -using Rubberduck.Settings; -using Rubberduck.UI; -using Rubberduck.VBEditor.Extensions; - -namespace Rubberduck.UnitTesting -{ - public class NewUnitTestModuleCommand - { - private readonly RubberduckParserState _state; - private readonly ConfigurationLoader _configLoader; - - public NewUnitTestModuleCommand(RubberduckParserState state, ConfigurationLoader configLoader) - { - _state = state; - _configLoader = configLoader; - } - - private const string ModuleLateBinding = "Private Assert As Object\n"; - private const string ModuleEarlyBinding = "Private Assert As New Rubberduck.{0}AssertClass\n"; - - private const string TestModuleEmptyTemplate = "'@TestModule\n{0}\n"; - - private const string ModuleInitLateBinding = "Set Assert = CreateObject(\"Rubberduck.{0}AssertClass\")\n"; - private readonly string _moduleInit = string.Concat( - "'@ModuleInitialize\n" - , "Public Sub ModuleInitialize()\n" - , " '", RubberduckUI.UnitTest_NewModule_RunOnce, ".\n {0}\n" - , "End Sub\n\n" - , "'@ModuleCleanup\n" - , "Public Sub ModuleCleanup()\n" - , " '", RubberduckUI.UnitTest_NewModule_RunOnce, ".\n" - , "End Sub\n\n" - ); - - private readonly string _methodInit = string.Concat( - "'@TestInitialize\n" - , "Public Sub TestInitialize()\n" - , " '", RubberduckUI.UnitTest_NewModule_RunBeforeTest, ".\n" - , "End Sub\n\n" - , "'@TestCleanup\n" - , "Public Sub TestCleanup()\n" - , " '", RubberduckUI.UnitTest_NewModule_RunAfterTest, ".\n" - , "End Sub\n\n" - ); - - private const string TestModuleBaseName = "TestModule"; - - private string GetTestModule(UnitTestSettings settings) - { - var assertClass = settings.AssertMode == AssertMode.StrictAssert ? string.Empty : "Permissive"; - var moduleBinding = settings.BindingMode == BindingMode.EarlyBinding - ? string.Format(ModuleEarlyBinding, assertClass) - : ModuleLateBinding; - - var formattedModuleTemplate = string.Format(TestModuleEmptyTemplate, moduleBinding); - - if (settings.ModuleInit) - { - var lateBindingString = string.Format(ModuleInitLateBinding, - settings.AssertMode == AssertMode.StrictAssert ? string.Empty : "Permissive"); - - formattedModuleTemplate += string.Format(_moduleInit, settings.BindingMode == BindingMode.EarlyBinding ? string.Empty : lateBindingString); - } - - if (settings.MethodInit) - { - formattedModuleTemplate += _methodInit; - } - - return formattedModuleTemplate; - } - - public void NewUnitTestModule(VBProject project) - { - var settings = _configLoader.LoadConfiguration().UserSettings.UnitTestSettings; - VBComponent component; - - try - { - if (settings.BindingMode == BindingMode.EarlyBinding) - { - project.EnsureReferenceToAddInLibrary(); - } - - component = project.VBComponents.Add(vbext_ComponentType.vbext_ct_StdModule); - component.Name = GetNextTestModuleName(project); - - var hasOptionExplicit = false; - if (component.CodeModule.CountOfLines > 0 && component.CodeModule.CountOfDeclarationLines > 0) - { - hasOptionExplicit = component.CodeModule.Lines[1, component.CodeModule.CountOfDeclarationLines].Contains("Option Explicit"); - } - - var options = string.Concat(hasOptionExplicit ? string.Empty : "Option Explicit\n", "Option Private Module\n\n"); - - var defaultTestMethod = string.Empty; - if (settings.DefaultTestStubInNewModule) - { - defaultTestMethod = NewTestMethodCommand.TestMethodTemplate.Replace( - NewTestMethodCommand.NamePlaceholder, "TestMethod1"); - } - - component.CodeModule.AddFromString(options + GetTestModule(settings) + defaultTestMethod); - component.Activate(); - } - catch (Exception) - { - //can we please comment when we swallow every possible exception? - return; - } - - _state.OnParseRequested(this, component); - } - - private string GetNextTestModuleName(VBProject project) - { - var names = project.ComponentNames(); - var index = names.Count(n => n.StartsWith(TestModuleBaseName)) + 1; - - return string.Concat(TestModuleBaseName, index); - } - } -} diff --git a/RetailCoder.VBE/packages.config b/RetailCoder.VBE/packages.config index b42f7d9e16..c006f9277c 100644 --- a/RetailCoder.VBE/packages.config +++ b/RetailCoder.VBE/packages.config @@ -8,6 +8,7 @@ + - + \ No newline at end of file diff --git a/Rubberduck.Parsing/ISinks.cs b/Rubberduck.Parsing/ISinks.cs index 147ed3e7e9..a4d68a787e 100644 --- a/Rubberduck.Parsing/ISinks.cs +++ b/Rubberduck.Parsing/ISinks.cs @@ -6,6 +6,7 @@ namespace Rubberduck.Parsing public interface IProjectEventArgs { string ProjectId { get; } + VBProject Project { get; } } public interface IProjectRenamedEventArgs : IProjectEventArgs @@ -16,8 +17,9 @@ public interface IProjectRenamedEventArgs : IProjectEventArgs public interface IComponentEventArgs { string ProjectId { get; } - string ComponentName { get; } - vbext_ComponentType Type { get; } + + VBProject Project { get; } + VBComponent Component { get; } } public interface IComponentRenamedEventArgs : IComponentEventArgs @@ -27,7 +29,7 @@ public interface IComponentRenamedEventArgs : IComponentEventArgs public interface ISinks { - bool IsEnabled { get; set; } + bool ComponentSinksEnabled { get; set; } event EventHandler ProjectActivated; event EventHandler ProjectAdded; diff --git a/Rubberduck.Parsing/ParsingText.ja.resx b/Rubberduck.Parsing/ParsingText.ja.resx deleted file mode 100644 index d9d2126738..0000000000 --- a/Rubberduck.Parsing/ParsingText.ja.resx +++ /dev/null @@ -1,103 +0,0 @@ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - text/microsoft-resx - - - 1.3 - - - System.Resources.ResXResourceReader, System.Windows.Forms, Version=2.0.3500.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 - - - System.Resources.ResXResourceWriter, System.Windows.Forms, Version=2.0.3500.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 - - - - - diff --git a/Rubberduck.Parsing/ParsingText.sv.resx b/Rubberduck.Parsing/ParsingText.sv.resx deleted file mode 100644 index d9d2126738..0000000000 --- a/Rubberduck.Parsing/ParsingText.sv.resx +++ /dev/null @@ -1,103 +0,0 @@ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - text/microsoft-resx - - - 1.3 - - - System.Resources.ResXResourceReader, System.Windows.Forms, Version=2.0.3500.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 - - - System.Resources.ResXResourceWriter, System.Windows.Forms, Version=2.0.3500.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 - - - - - diff --git a/Rubberduck.Parsing/Rubberduck.Parsing.csproj b/Rubberduck.Parsing/Rubberduck.Parsing.csproj index 8a532fb076..d9ecb8ccc1 100644 --- a/Rubberduck.Parsing/Rubberduck.Parsing.csproj +++ b/Rubberduck.Parsing/Rubberduck.Parsing.csproj @@ -322,12 +322,10 @@ - ResXFileCodeGenerator ParsingText.Designer.cs - diff --git a/Rubberduck.Parsing/Symbols/Accessibility.cs b/Rubberduck.Parsing/Symbols/Accessibility.cs index 4aec5377f9..8b116b24f9 100644 --- a/Rubberduck.Parsing/Symbols/Accessibility.cs +++ b/Rubberduck.Parsing/Symbols/Accessibility.cs @@ -2,11 +2,11 @@ { public enum Accessibility { - Implicit, - Private, - Public, - Global, - Friend, - Static, + Private = 1, + Friend = 2, + Implicit = 3, + Public = 4, + Global = 5, + Static = 6, } } diff --git a/Rubberduck.Parsing/Symbols/IdentifierReferenceResolver.cs b/Rubberduck.Parsing/Symbols/IdentifierReferenceResolver.cs index 73b7d68687..bf75b62fe9 100644 --- a/Rubberduck.Parsing/Symbols/IdentifierReferenceResolver.cs +++ b/Rubberduck.Parsing/Symbols/IdentifierReferenceResolver.cs @@ -4,6 +4,7 @@ using Rubberduck.Parsing.Binding; using Rubberduck.Parsing.Grammar; using Rubberduck.VBEditor; +using Rubberduck.VBEditor.Extensions; using System.Collections.Generic; using System.Linq; using System.Threading; diff --git a/Rubberduck.Parsing/Symbols/ParserRuleContextHelper.cs b/Rubberduck.Parsing/Symbols/ParserRuleContextHelper.cs index 40f8a8cbb0..1c80b45fd9 100644 --- a/Rubberduck.Parsing/Symbols/ParserRuleContextHelper.cs +++ b/Rubberduck.Parsing/Symbols/ParserRuleContextHelper.cs @@ -47,5 +47,24 @@ public static string GetText(ParserRuleContext context, ICharStream stream) // Gets the original source, without "synthetic" text such as "". return stream.GetText(new Interval(context.Start.StartIndex, context.Stop.StopIndex)); } + + public static T GetChild(RuleContext context) + { + if (context == null) + { + return default(T); + } + + for (var index = 0; index < context.ChildCount; index++) + { + var child = context.GetChild(index); + if (context.GetChild(index) is T) + { + return (T)child; + } + } + + return default(T); + } } } diff --git a/Rubberduck.Parsing/VBA/RubberduckParser.cs b/Rubberduck.Parsing/VBA/RubberduckParser.cs index 331f921e5f..8216981fa0 100644 --- a/Rubberduck.Parsing/VBA/RubberduckParser.cs +++ b/Rubberduck.Parsing/VBA/RubberduckParser.cs @@ -25,7 +25,8 @@ public class RubberduckParser : IRubberduckParser private readonly IDictionary, Attributes>> _componentAttributes = new Dictionary, Attributes>>(); - + + private readonly VBE _vbe; private readonly RubberduckParserState _state; private readonly IAttributeParser _attributeParser; private readonly Func _preprocessorFactory; @@ -35,12 +36,14 @@ private readonly IDictionary preprocessorFactory, IEnumerable customDeclarationLoaders, bool isTestScope = false) { + _vbe = vbe; _state = state; _attributeParser = attributeParser; _preprocessorFactory = preprocessorFactory; @@ -73,7 +76,7 @@ private void ReparseRequested(object sender, EventArgs e) /// public void Parse(CancellationTokenSource token) { - State.RefreshProjects(); + State.RefreshProjects(_vbe); var components = new List(); foreach (var project in State.Projects) @@ -149,7 +152,7 @@ public void Parse(CancellationTokenSource token) /// private void ParseAll(CancellationTokenSource token) { - State.RefreshProjects(); + State.RefreshProjects(_vbe); var components = new List(); foreach (var project in State.Projects) diff --git a/Rubberduck.Parsing/VBA/RubberduckParserState.cs b/Rubberduck.Parsing/VBA/RubberduckParserState.cs index 0d0e604381..93faf3afdb 100644 --- a/Rubberduck.Parsing/VBA/RubberduckParserState.cs +++ b/Rubberduck.Parsing/VBA/RubberduckParserState.cs @@ -43,7 +43,6 @@ public RubberduckStatusMessageEventArgs(string message) public sealed class RubberduckParserState : IDisposable { - private readonly VBE _vbe; // circumvents VBIDE API's tendency to return a new instance at every parse, which breaks reference equality checks everywhere private readonly IDictionary _projects = new Dictionary(); @@ -59,9 +58,8 @@ public sealed class RubberduckParserState : IDisposable public readonly ConcurrentDictionary, Declaration> CoClasses = new ConcurrentDictionary, Declaration>(); - public RubberduckParserState(VBE vbe, ISinks sinks) + public RubberduckParserState(ISinks sinks) { - _vbe = vbe; var values = Enum.GetValues(typeof(ParserState)); foreach (var value in values) { @@ -79,17 +77,17 @@ public RubberduckParserState(VBE vbe, ISinks sinks) private void Sinks_ProjectAdded(object sender, IProjectEventArgs e) { - if (!_vbe.IsInDesignMode()) { return; } + if (!e.Project.VBE.IsInDesignMode()) { return; } Logger.Debug("Project '{0}' was added.", e.ProjectId); - RefreshProjects(); // note side-effect: assigns ProjectId/HelpFile + RefreshProjects(e.Project.VBE); // note side-effect: assigns ProjectId/HelpFile OnParseRequested(sender); } private void Sinks_ProjectRemoved(object sender, IProjectEventArgs e) { - if (!_vbe.IsInDesignMode()) { return; } + if (!e.Project.VBE.IsInDesignMode()) { return; } Debug.Assert(e.ProjectId != null); @@ -99,7 +97,7 @@ private void Sinks_ProjectRemoved(object sender, IProjectEventArgs e) private void Sinks_ProjectRenamed(object sender, IProjectRenamedEventArgs e) { - if (!_vbe.IsInDesignMode()) { return; } + if (!e.Project.VBE.IsInDesignMode()) { return; } if (AllDeclarations.Count == 0) { @@ -109,47 +107,47 @@ private void Sinks_ProjectRenamed(object sender, IProjectRenamedEventArgs e) Logger.Debug("Project {0} was renamed.", e.ProjectId); RemoveProject(e.ProjectId); - RefreshProjects(); + RefreshProjects(e.Project.VBE); OnParseRequested(sender); } private void Sinks_ComponentAdded(object sender, IComponentEventArgs e) { - if (!_vbe.IsInDesignMode()) { return; } + if (!e.Project.VBE.IsInDesignMode()) { return; } if (AllDeclarations.Count == 0) { return; } - Logger.Debug("Component '{0}' was added.", e.ComponentName); + Logger.Debug("Component '{0}' was added.", e.Component.Name); OnParseRequested(sender); } private void Sinks_ComponentRemoved(object sender, IComponentEventArgs e) { - if (!_vbe.IsInDesignMode()) { return; } + if (!e.Project.VBE.IsInDesignMode()) { return; } if (AllDeclarations.Count == 0) { return; } - Logger.Debug("Component '{0}' was removed.", e.ComponentName); + Logger.Debug("Component '{0}' was removed.", e.Component.Name); OnParseRequested(sender); } private void Sinks_ComponentRenamed(object sender, IComponentRenamedEventArgs e) { - if (!_vbe.IsInDesignMode()) { return; } + if (!e.Project.VBE.IsInDesignMode()) { return; } if (AllDeclarations.Count == 0) { return; } - Logger.Debug("Component '{0}' was renamed to '{1}'.", e.OldName, e.ComponentName); + Logger.Debug("Component '{0}' was renamed to '{1}'.", e.OldName, e.Component.Name); var componentIsWorksheet = false; foreach (var declaration in AllUserDeclarations) @@ -174,9 +172,9 @@ private void Sinks_ComponentRenamed(object sender, IComponentRenamedEventArgs e) if (componentIsWorksheet) { RemoveProject(e.ProjectId); - Logger.Debug("Project '{0}' was removed.", e.ComponentName); + Logger.Debug("Project '{0}' was removed.", e.Component.Name); - RefreshProjects(); + RefreshProjects(e.Project.VBE); } else { @@ -202,12 +200,12 @@ public void OnStatusMessageUpdate(string message) /// were projects with duplicate ID's to clear the old /// declarations referencing the project by the old ID. /// - public void RefreshProjects() + public void RefreshProjects(VBE vbe) { lock (_projects) { _projects.Clear(); - foreach (VBProject project in _vbe.VBProjects) + foreach (VBProject project in vbe.VBProjects) { if (project.Protection == vbext_ProjectProtection.vbext_pp_locked) { @@ -238,13 +236,7 @@ public List Projects { get { - var projects = new List(); - foreach (var project in _projects.Values) - { - projects.Add(project); - } - - return projects; + return new List(_projects.Values); } } @@ -645,8 +637,6 @@ private void ClearStateCache(string projectId, bool notifyStateChanged = false) { try { - var qualifiedModuleName = new QualifiedModuleName(); - foreach (var moduleState in _moduleStates) { if (moduleState.Key.ProjectId == projectId && moduleState.Key.Component != null) @@ -659,15 +649,14 @@ private void ClearStateCache(string projectId, bool notifyStateChanged = false) else if (moduleState.Key.ProjectId == projectId && moduleState.Key.Component == null) { // store project module name - qualifiedModuleName = moduleState.Key; + var qualifiedModuleName = moduleState.Key; + ModuleState state; + if (_moduleStates.TryRemove(qualifiedModuleName, out state)) + { + state.Dispose(); + } } } - - ModuleState state; - if (_moduleStates.TryRemove(qualifiedModuleName, out state)) - { - state.Dispose(); - } } catch (COMException) { diff --git a/Rubberduck.SettingsProvider/IConfigProvider.cs b/Rubberduck.SettingsProvider/IConfigProvider.cs new file mode 100644 index 0000000000..b0cd917f56 --- /dev/null +++ b/Rubberduck.SettingsProvider/IConfigProvider.cs @@ -0,0 +1,10 @@ +namespace Rubberduck.Settings +{ + public interface IConfigProvider + { + T Create(); + T CreateDefaults(); + + void Save(T settings); + } +} \ No newline at end of file diff --git a/Rubberduck.SettingsProvider/Rubberduck.SettingsProvider.csproj b/Rubberduck.SettingsProvider/Rubberduck.SettingsProvider.csproj index ff03ec83e7..cb097d3e18 100644 --- a/Rubberduck.SettingsProvider/Rubberduck.SettingsProvider.csproj +++ b/Rubberduck.SettingsProvider/Rubberduck.SettingsProvider.csproj @@ -39,6 +39,7 @@ + diff --git a/Rubberduck.SettingsProvider/XmlPersistanceService.cs b/Rubberduck.SettingsProvider/XmlPersistanceService.cs index 2250476626..e0abb07415 100644 --- a/Rubberduck.SettingsProvider/XmlPersistanceService.cs +++ b/Rubberduck.SettingsProvider/XmlPersistanceService.cs @@ -15,10 +15,10 @@ namespace Rubberduck.SettingsProvider private const string DefaultConfigFile = "rubberduck.config"; private const string RootElement = "Configuration"; - private readonly XmlSerializerNamespaces _emptyNamespace = + private static readonly XmlSerializerNamespaces EmptyNamespace = new XmlSerializerNamespaces(new[] { new XmlQualifiedName(string.Empty, string.Empty) }); - private readonly XmlWriterSettings _outputXmlSettings = new XmlWriterSettings + private static readonly XmlWriterSettings OutputXmlSettings = new XmlWriterSettings { Encoding = new UTF8Encoding(false), Indent = true, @@ -72,7 +72,7 @@ public void Save(T toSerialize) using (var writer = new StreamWriter(stream)) { var serializer = new XmlSerializer(type); - serializer.Serialize(writer, toSerialize, _emptyNamespace); + serializer.Serialize(writer, toSerialize, EmptyNamespace); var settings = XElement.Parse(_outputEncoding.GetString(stream.ToArray()), LoadOptions.SetBaseUri); if (node != null) { @@ -91,7 +91,7 @@ public void Save(T toSerialize) Directory.CreateDirectory(_rootPath); } - using (var xml = XmlWriter.Create(FilePath, _outputXmlSettings)) + using (var xml = XmlWriter.Create(FilePath, OutputXmlSettings)) { doc.WriteTo(xml); } diff --git a/Rubberduck.SmartIndenter/IndenterConfigProvider.cs b/Rubberduck.SmartIndenter/IndenterConfigProvider.cs index b411c6475a..ae25ad9e45 100644 --- a/Rubberduck.SmartIndenter/IndenterConfigProvider.cs +++ b/Rubberduck.SmartIndenter/IndenterConfigProvider.cs @@ -1,16 +1,9 @@ -using Rubberduck.SettingsProvider; +using Rubberduck.Settings; +using Rubberduck.SettingsProvider; namespace Rubberduck.SmartIndenter { - public interface IIndenterConfigProvider - { - IndenterSettings Create(); - IndenterSettings CreateDefaults(); - - void Save(IndenterSettings settings); - } - - public class IndenterConfigProvider : IIndenterConfigProvider + public class IndenterConfigProvider : IConfigProvider { private readonly IPersistanceService _persister; diff --git a/Rubberduck.SourceControl/GitProvider.cs b/Rubberduck.SourceControl/GitProvider.cs index c153e6d77e..948a10f0bb 100644 --- a/Rubberduck.SourceControl/GitProvider.cs +++ b/Rubberduck.SourceControl/GitProvider.cs @@ -194,7 +194,7 @@ public override IRepository InitVBAProject(string directory) //The default behavior of LibGit2Sharp.Repo.Commit is to throw an exception if no signature is found, // but BuildSignature() does not throw if a signature is not found, it returns "unknown" instead. // so we pass a signature that won't throw along to the commit. - repo.Commit("Intial Commit", GetSignature(repo)); + repo.Commit("Initial Commit", GetSignature(repo)); } catch(LibGit2SharpException ex) { diff --git a/Rubberduck.SourceControl/ISourceControlProvider.cs b/Rubberduck.SourceControl/ISourceControlProvider.cs index 21b09183a5..1817baa859 100644 --- a/Rubberduck.SourceControl/ISourceControlProvider.cs +++ b/Rubberduck.SourceControl/ISourceControlProvider.cs @@ -11,8 +11,8 @@ public interface ISourceControlProvider IEnumerable Branches { get; } IList UnsyncedLocalCommits { get; } IList UnsyncedRemoteCommits { get; } - bool NotifyExternalFileChanges { get; } - bool HandleVbeSinkEvents { get; } + bool NotifyExternalFileChanges { get; set; } + bool HandleVbeSinkEvents { get; set; } event EventHandler BranchChanged; diff --git a/Rubberduck.SourceControl/SourceControlConfigProvider.cs b/Rubberduck.SourceControl/SourceControlConfigProvider.cs index f540774d03..269e192277 100644 --- a/Rubberduck.SourceControl/SourceControlConfigProvider.cs +++ b/Rubberduck.SourceControl/SourceControlConfigProvider.cs @@ -1,18 +1,11 @@ using System; using System.IO; +using Rubberduck.Settings; using Rubberduck.SettingsProvider; namespace Rubberduck.SourceControl { - public interface ISourceControlConfigProvider - { - SourceControlSettings Create(); - SourceControlSettings CreateDefaults(); - - void Save(SourceControlSettings settings); - } - - public class SourceControlConfigProvider : ISourceControlConfigProvider + public class SourceControlConfigProvider : IConfigProvider { private readonly string _rootPath = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData), "Rubberduck"); private readonly IFilePersistanceService _persister; diff --git a/Rubberduck.SourceControl/SourceControlProviderBase.cs b/Rubberduck.SourceControl/SourceControlProviderBase.cs index 7c53b3513c..50f234efa5 100644 --- a/Rubberduck.SourceControl/SourceControlProviderBase.cs +++ b/Rubberduck.SourceControl/SourceControlProviderBase.cs @@ -31,8 +31,8 @@ protected SourceControlProviderBase(VBProject project, IRepository repository, I public abstract IEnumerable Branches { get; } public abstract IList UnsyncedLocalCommits { get; } public abstract IList UnsyncedRemoteCommits { get; } - public bool NotifyExternalFileChanges { get; protected set; } - public bool HandleVbeSinkEvents { get; protected set; } + public bool NotifyExternalFileChanges { get; set; } + public bool HandleVbeSinkEvents { get; set; } public abstract IRepository Clone(string remotePathOrUrl, string workingDirectory, SecureCredentials credentials = null); public abstract void Push(); public abstract void Fetch(string remoteName); @@ -120,8 +120,6 @@ public virtual void Checkout(string branch) public virtual void Undo(string filePath) { - var componentName = Path.GetFileNameWithoutExtension(filePath); - if (File.Exists(filePath)) { var component = Project.VBComponents.OfType().FirstOrDefault(f => f.Name == filePath.Split('.')[0]); @@ -142,6 +140,7 @@ public virtual IEnumerable Status() { NotifyExternalFileChanges = false; Project.ExportSourceFiles(CurrentRepository.LocalLocation); + Project.ImportDocumentTypeSourceFiles(CurrentRepository.LocalLocation); NotifyExternalFileChanges = true; return null; } diff --git a/Rubberduck.VBEEditor/Extensions/VBComponentsExtensions.cs b/Rubberduck.VBEEditor/Extensions/VBComponentsExtensions.cs index a75fc1b0bb..28815ab488 100644 --- a/Rubberduck.VBEEditor/Extensions/VBComponentsExtensions.cs +++ b/Rubberduck.VBEEditor/Extensions/VBComponentsExtensions.cs @@ -48,11 +48,8 @@ public static void ImportSourceFile(this VBComponents components, string filePat if (ext == VBComponentExtensions.DocClassExtension) { var component = components.Item(name); - if (component != null) - { - component.CodeModule.Clear(); - component.CodeModule.AddFromString(codeString); - } + component.CodeModule.Clear(); + component.CodeModule.AddFromString(codeString); } else if (ext == VBComponentExtensions.FormExtension) { diff --git a/Rubberduck.VBEEditor/Extensions/VbProjectExtensions.cs b/Rubberduck.VBEEditor/Extensions/VbProjectExtensions.cs index e4d15d86f8..2b64bc275c 100644 --- a/Rubberduck.VBEEditor/Extensions/VbProjectExtensions.cs +++ b/Rubberduck.VBEEditor/Extensions/VbProjectExtensions.cs @@ -103,7 +103,33 @@ public static void ImportSourceFiles(this VBProject project, string filePath) project.VBComponents.ImportSourceFile(file.FullName); } } - + + + /// + /// Imports all source code files from target directory into project. + /// + /// + /// Only files with extensions "cls", "bas, "frm", and "doccls" are imported. + /// It is the callers responsibility to remove any existing components prior to importing. + /// + /// + /// Directory path containing the source files. + public static void ImportDocumentTypeSourceFiles(this VBProject project, string filePath) + { + var dirInfo = new DirectoryInfo(filePath); + + var files = dirInfo.EnumerateFiles() + .Where(f => f.Extension == VBComponentExtensions.DocClassExtension); + foreach (var file in files) + { + try + { + project.VBComponents.ImportSourceFile(file.FullName); + } + catch (IndexOutOfRangeException) { } // component didn't exist + } + } + public static void LoadAllComponents(this VBProject project, string filePath) { var dirInfo = new DirectoryInfo(filePath); @@ -127,7 +153,14 @@ public static void LoadAllComponents(this VBProject project, string filePath) var file = files.SingleOrDefault(f => f.Name == name + f.Extension); if (file != null) { - project.VBComponents.ImportSourceFile(file.FullName); + try + { + project.VBComponents.ImportSourceFile(file.FullName); + } + catch (IndexOutOfRangeException) + { + exceptions.Add(new IndexOutOfRangeException(string.Format(VBEEditorText.NonexistentComponentErrorText, Path.GetFileNameWithoutExtension(file.FullName)))); + } } } catch (Exception ex) @@ -142,7 +175,14 @@ public static void LoadAllComponents(this VBProject project, string filePath) { if (project.VBComponents.OfType().All(v => v.Name + file.Extension != file.Name)) { - project.VBComponents.ImportSourceFile(file.FullName); + try + { + project.VBComponents.ImportSourceFile(file.FullName); + } + catch (IndexOutOfRangeException) + { + exceptions.Add(new IndexOutOfRangeException(string.Format(VBEEditorText.NonexistentComponentErrorText, Path.GetFileNameWithoutExtension(file.FullName)))); + } } } catch (Exception ex) diff --git a/Rubberduck.VBEEditor/Rubberduck.VBEditor.csproj b/Rubberduck.VBEEditor/Rubberduck.VBEditor.csproj index dd00774f1a..b6ecb21ba6 100644 --- a/Rubberduck.VBEEditor/Rubberduck.VBEditor.csproj +++ b/Rubberduck.VBEEditor/Rubberduck.VBEditor.csproj @@ -141,9 +141,7 @@ - - ResXFileCodeGenerator VBEEditorText.Designer.cs diff --git a/Rubberduck.VBEEditor/VBEEditorText.Designer.cs b/Rubberduck.VBEEditor/VBEEditorText.Designer.cs index 4fe6b9ac77..fbf2845aca 100644 --- a/Rubberduck.VBEEditor/VBEEditorText.Designer.cs +++ b/Rubberduck.VBEEditor/VBEEditorText.Designer.cs @@ -1,10 +1,10 @@ //------------------------------------------------------------------------------ // -// Dieser Code wurde von einem Tool generiert. -// Laufzeitversion:4.0.30319.18444 +// This code was generated by a tool. +// Runtime Version:4.0.30319.42000 // -// Änderungen an dieser Datei können falsches Verhalten verursachen und gehen verloren, wenn -// der Code erneut generiert wird. +// Changes to this file may cause incorrect behavior and will be lost if +// the code is regenerated. // //------------------------------------------------------------------------------ @@ -13,12 +13,12 @@ namespace Rubberduck.VBEditor { /// - /// Eine stark typisierte Ressourcenklasse zum Suchen von lokalisierten Zeichenfolgen usw. + /// A strongly-typed resource class, for looking up localized strings, etc. /// - // Diese Klasse wurde von der StronglyTypedResourceBuilder automatisch generiert - // -Klasse über ein Tool wie ResGen oder Visual Studio automatisch generiert. - // Um einen Member hinzuzufügen oder zu entfernen, bearbeiten Sie die .ResX-Datei und führen dann ResGen - // mit der /str-Option erneut aus, oder Sie erstellen Ihr VS-Projekt neu. + // This class was auto-generated by the StronglyTypedResourceBuilder + // class via a tool like ResGen or Visual Studio. + // To add or remove a member, edit your .ResX file then rerun ResGen + // with the /str option, or rebuild your VS project. [global::System.CodeDom.Compiler.GeneratedCodeAttribute("System.Resources.Tools.StronglyTypedResourceBuilder", "4.0.0.0")] [global::System.Diagnostics.DebuggerNonUserCodeAttribute()] [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()] @@ -33,7 +33,7 @@ internal VBEEditorText() { } /// - /// Gibt die zwischengespeicherte ResourceManager-Instanz zurück, die von dieser Klasse verwendet wird. + /// Returns the cached ResourceManager instance used by this class. /// [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)] internal static global::System.Resources.ResourceManager ResourceManager { @@ -47,8 +47,8 @@ internal VBEEditorText() { } /// - /// Überschreibt die CurrentUICulture-Eigenschaft des aktuellen Threads für alle - /// Ressourcenzuordnungen, die diese stark typisierte Ressourcenklasse verwenden. + /// Overrides the current thread's CurrentUICulture property for all + /// resource lookups using this strongly typed resource class. /// [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)] internal static global::System.Globalization.CultureInfo Culture { @@ -61,7 +61,16 @@ internal VBEEditorText() { } /// - /// Sucht eine lokalisierte Zeichenfolge, die L{0}C{1} ähnelt. + /// Looks up a localized string similar to Document-type component {0} does not exist. Cannot import code from repository.. + /// + internal static string NonexistentComponentErrorText { + get { + return ResourceManager.GetString("NonexistentComponentErrorText", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to L{0}C{1}. /// internal static string SelectionLocationPosition { get { @@ -70,7 +79,7 @@ internal static string SelectionLocationPosition { } /// - /// Sucht eine lokalisierte Zeichenfolge, die L{0}C{1} - L{2}C{3} ähnelt. + /// Looks up a localized string similar to L{0}C{1} - L{2}C{3}. /// internal static string SelectionLocationRange { get { diff --git a/Rubberduck.VBEEditor/VBEEditorText.de.resx b/Rubberduck.VBEEditor/VBEEditorText.de.resx deleted file mode 100644 index 78ea75b8d4..0000000000 --- a/Rubberduck.VBEEditor/VBEEditorText.de.resx +++ /dev/null @@ -1,106 +0,0 @@ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - text/microsoft-resx - - - 1.3 - - - System.Resources.ResXResourceReader, System.Windows.Forms, Version=2.0.3500.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 - - - System.Resources.ResXResourceWriter, System.Windows.Forms, Version=2.0.3500.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 - - - Z{0}S{1} - Z{2}S{3} - - - Z{0}S{1} - - diff --git a/Rubberduck.VBEEditor/VBEEditorText.ja.resx b/Rubberduck.VBEEditor/VBEEditorText.ja.resx deleted file mode 100644 index 478242671f..0000000000 --- a/Rubberduck.VBEEditor/VBEEditorText.ja.resx +++ /dev/null @@ -1,106 +0,0 @@ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - text/microsoft-resx - - - 1.3 - - - System.Resources.ResXResourceReader, System.Windows.Forms, Version=2.0.3500.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 - - - System.Resources.ResXResourceWriter, System.Windows.Forms, Version=2.0.3500.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 - - - - - - - - diff --git a/Rubberduck.VBEEditor/VBEEditorText.resx b/Rubberduck.VBEEditor/VBEEditorText.resx index 3e4912cd84..75d6911dbe 100644 --- a/Rubberduck.VBEEditor/VBEEditorText.resx +++ b/Rubberduck.VBEEditor/VBEEditorText.resx @@ -1,76 +1,96 @@ - + - + mimetype: application/x-microsoft.net.object.bytearray.base64 + value : The object must be serialized into a byte array + : using a System.ComponentModel.TypeConverter + : and then encoded with base64 encoding. + --> + + + + + + + + + + + + + + + + + + + - + + @@ -89,13 +109,13 @@ text/microsoft-resx - 1.3 + 2.0 - System.Resources.ResXResourceReader, System.Windows.Forms, Version=2.0.3500.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 - System.Resources.ResXResourceWriter, System.Windows.Forms, Version=2.0.3500.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 L{0}C{1} - L{2}C{3} @@ -103,4 +123,7 @@ L{0}C{1} - + + Document-type component {0} does not exist. Cannot import code from repository. + + \ No newline at end of file diff --git a/Rubberduck.sln b/Rubberduck.sln index ecee501463..36b61ecd05 100644 --- a/Rubberduck.sln +++ b/Rubberduck.sln @@ -1,7 +1,7 @@  Microsoft Visual Studio Solution File, Format Version 12.00 -# Visual Studio 2013 -VisualStudioVersion = 12.0.40629.0 +# Visual Studio 14 +VisualStudioVersion = 14.0.25420.1 MinimumVisualStudioVersion = 10.0.40219.1 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Rubberduck", "RetailCoder.VBE\Rubberduck.csproj", "{20589DE8-432E-4359-9232-69EB070B7185}" ProjectSection(ProjectDependencies) = postProject diff --git a/RubberduckTests/Binding/IndexDefaultBindingTests.cs b/RubberduckTests/Binding/IndexDefaultBindingTests.cs index 4c9fc81250..8f32120e8e 100644 --- a/RubberduckTests/Binding/IndexDefaultBindingTests.cs +++ b/RubberduckTests/Binding/IndexDefaultBindingTests.cs @@ -86,7 +86,7 @@ End Property private static RubberduckParserState Parse(Moq.Mock vbe) { - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status != ParserState.Ready) { diff --git a/RubberduckTests/Binding/MemberAccessDefaultBindingTests.cs b/RubberduckTests/Binding/MemberAccessDefaultBindingTests.cs index daae668d8d..7f12d0a792 100644 --- a/RubberduckTests/Binding/MemberAccessDefaultBindingTests.cs +++ b/RubberduckTests/Binding/MemberAccessDefaultBindingTests.cs @@ -95,7 +95,7 @@ public void LExpressionIsEnum() private static RubberduckParserState Parse(Moq.Mock vbe) { - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status != ParserState.Ready) { diff --git a/RubberduckTests/Binding/MemberAccessProcedurePointerBindingTests.cs b/RubberduckTests/Binding/MemberAccessProcedurePointerBindingTests.cs index 5042792b4c..1d33182e81 100644 --- a/RubberduckTests/Binding/MemberAccessProcedurePointerBindingTests.cs +++ b/RubberduckTests/Binding/MemberAccessProcedurePointerBindingTests.cs @@ -40,7 +40,7 @@ public void ProceduralModuleWithAccessibleMember() private static RubberduckParserState Parse(Moq.Mock vbe) { - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status != ParserState.Ready) { diff --git a/RubberduckTests/Binding/MemberAccessTypeBindingTests.cs b/RubberduckTests/Binding/MemberAccessTypeBindingTests.cs index bcd4f2e009..e075d84463 100644 --- a/RubberduckTests/Binding/MemberAccessTypeBindingTests.cs +++ b/RubberduckTests/Binding/MemberAccessTypeBindingTests.cs @@ -144,7 +144,7 @@ public void NestedMemberAccessExpressions() private static RubberduckParserState Parse(Moq.Mock vbe) { - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status != ParserState.Ready) { diff --git a/RubberduckTests/Binding/SimpleNameDefaultBindingTests.cs b/RubberduckTests/Binding/SimpleNameDefaultBindingTests.cs index 33b9e9dfb5..59552edc9b 100644 --- a/RubberduckTests/Binding/SimpleNameDefaultBindingTests.cs +++ b/RubberduckTests/Binding/SimpleNameDefaultBindingTests.cs @@ -146,7 +146,7 @@ public void ReferencedProjectClassNotMarkedAsGlobalClassModuleIsNotReferenced() private static RubberduckParserState Parse(Moq.Mock vbe) { - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status != ParserState.Ready) { diff --git a/RubberduckTests/Binding/SimpleNameProcedurePointerBindingTests.cs b/RubberduckTests/Binding/SimpleNameProcedurePointerBindingTests.cs index 7c772304b3..ef71ef29dc 100644 --- a/RubberduckTests/Binding/SimpleNameProcedurePointerBindingTests.cs +++ b/RubberduckTests/Binding/SimpleNameProcedurePointerBindingTests.cs @@ -70,7 +70,7 @@ public void OtherProceduralModule() private static RubberduckParserState Parse(Moq.Mock vbe) { - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status != ParserState.Ready) { diff --git a/RubberduckTests/Binding/SimpleNameTypeBindingTests.cs b/RubberduckTests/Binding/SimpleNameTypeBindingTests.cs index 680f33410f..c230ad9f9e 100644 --- a/RubberduckTests/Binding/SimpleNameTypeBindingTests.cs +++ b/RubberduckTests/Binding/SimpleNameTypeBindingTests.cs @@ -130,7 +130,7 @@ public void ReferencedProjectType() private static RubberduckParserState Parse(Moq.Mock vbe) { - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status != ParserState.Ready) { diff --git a/RubberduckTests/CodeExplorer/CodeExplorerTests.cs b/RubberduckTests/CodeExplorer/CodeExplorerTests.cs index f1ae99d5a0..a8de52042e 100644 --- a/RubberduckTests/CodeExplorer/CodeExplorerTests.cs +++ b/RubberduckTests/CodeExplorer/CodeExplorerTests.cs @@ -15,7 +15,6 @@ using Rubberduck.UI; using Rubberduck.UI.CodeExplorer.Commands; using Rubberduck.UI.Command; -using Rubberduck.UnitTesting; using Rubberduck.VBEditor.VBEHost; using Rubberduck.VBEditor.Extensions; using RubberduckTests.Mocks; @@ -40,7 +39,7 @@ public void AddStdModule() var commands = new List { new AddStdModuleCommand(vbe.Object) }; - var state = new RubberduckParserState(vbe.Object, new Mock().Object); + var state = new RubberduckParserState(new Mock().Object); var vm = new CodeExplorerViewModel(new FolderHelper(state, GetDelimiterConfigLoader()), state, commands); var parser = MockParser.Create(vbe.Object, state); @@ -68,7 +67,7 @@ public void AddClassModule() var commands = new List { new AddClassModuleCommand(vbe.Object) }; - var state = new RubberduckParserState(vbe.Object, new Mock().Object); + var state = new RubberduckParserState(new Mock().Object); var vm = new CodeExplorerViewModel(new FolderHelper(state, GetDelimiterConfigLoader()), state, commands); var parser = MockParser.Create(vbe.Object, state); @@ -96,7 +95,7 @@ public void AddUserForm() var commands = new List { new AddUserFormCommand(vbe.Object) }; - var state = new RubberduckParserState(vbe.Object, new Mock().Object); + var state = new RubberduckParserState(new Mock().Object); var vm = new CodeExplorerViewModel(new FolderHelper(state, GetDelimiterConfigLoader()), state, commands); var parser = MockParser.Create(vbe.Object, state); @@ -122,13 +121,13 @@ public void AddTestModule() var mockHost = new Mock(); mockHost.SetupAllProperties(); - var configLoader = new Mock(null, null, null, null, null, null, null); + var configLoader = new Mock(null, null, null, null, null, null); configLoader.Setup(c => c.LoadConfiguration()).Returns(GetDefaultUnitTestConfig()); - var state = new RubberduckParserState(vbe.Object, new Mock().Object); + var state = new RubberduckParserState(new Mock().Object); var commands = new List { - new Rubberduck.UI.CodeExplorer.Commands.AddTestModuleCommand(vbe.Object, new NewUnitTestModuleCommand(state, configLoader.Object)) + new Rubberduck.UI.CodeExplorer.Commands.AddTestModuleCommand(vbe.Object, new Rubberduck.UI.Command.AddTestModuleCommand(vbe.Object, state, configLoader.Object)) }; var vm = new CodeExplorerViewModel(new FolderHelper(state, GetDelimiterConfigLoader()), state, commands); @@ -167,7 +166,7 @@ public void ImportModule() openFileDialog.Setup(o => o.FileNames).Returns(new[] {"C:\\Users\\Rubberduck\\Desktop\\StdModule1.bas"}); openFileDialog.Setup(o => o.ShowDialog()).Returns(DialogResult.OK); - var state = new RubberduckParserState(vbe.Object, new Mock().Object); + var state = new RubberduckParserState(new Mock().Object); var commands = new List { new ImportCommand(vbe.Object, openFileDialog.Object) @@ -209,7 +208,7 @@ public void ImportMultipleModules() openFileDialog.Setup(o => o.FileNames).Returns(new[] { "C:\\Users\\Rubberduck\\Desktop\\StdModule1.bas", "C:\\Users\\Rubberduck\\Desktop\\ClsModule1.cls" }); openFileDialog.Setup(o => o.ShowDialog()).Returns(DialogResult.OK); - var state = new RubberduckParserState(vbe.Object, new Mock().Object); + var state = new RubberduckParserState(new Mock().Object); var commands = new List { new ImportCommand(vbe.Object, openFileDialog.Object) @@ -252,7 +251,7 @@ public void ImportModule_Cancel() openFileDialog.Setup(o => o.FileName).Returns("C:\\Users\\Rubberduck\\Desktop\\StdModule1.bas"); openFileDialog.Setup(o => o.ShowDialog()).Returns(DialogResult.Cancel); - var state = new RubberduckParserState(vbe.Object, new Mock().Object); + var state = new RubberduckParserState(new Mock().Object); var commands = new List { new ImportCommand(vbe.Object, openFileDialog.Object) @@ -286,7 +285,7 @@ public void ExportModule() saveFileDialog.Setup(o => o.FileName).Returns("C:\\Users\\Rubberduck\\Desktop\\StdModule1.bas"); saveFileDialog.Setup(o => o.ShowDialog()).Returns(DialogResult.OK); - var state = new RubberduckParserState(vbe.Object, new Mock().Object); + var state = new RubberduckParserState(new Mock().Object); var commands = new List { new ExportCommand(saveFileDialog.Object) @@ -320,7 +319,7 @@ public void ExportModule_Cancel() saveFileDialog.Setup(o => o.FileName).Returns("C:\\Users\\Rubberduck\\Desktop\\StdModule1.bas"); saveFileDialog.Setup(o => o.ShowDialog()).Returns(DialogResult.Cancel); - var state = new RubberduckParserState(vbe.Object, new Mock().Object); + var state = new RubberduckParserState(new Mock().Object); var commands = new List { new ExportCommand(saveFileDialog.Object) @@ -349,7 +348,7 @@ public void OpenDesigner() var vbe = builder.AddProject(project).Build(); var component = projectMock.MockComponents.First(); - var state = new RubberduckParserState(vbe.Object, new Mock().Object); + var state = new RubberduckParserState(new Mock().Object); var commands = new List { new OpenDesignerCommand() @@ -399,7 +398,7 @@ public void RemoveModule_Export() new RemoveCommand(saveFileDialog.Object, messageBox.Object) }; - var state = new RubberduckParserState(vbe.Object, new Mock().Object); + var state = new RubberduckParserState(new Mock().Object); var vm = new CodeExplorerViewModel(new FolderHelper(state, GetDelimiterConfigLoader()), state, commands); var parser = MockParser.Create(vbe.Object, state); @@ -443,7 +442,7 @@ public void RemoveModule_Export_Cancel() new RemoveCommand(saveFileDialog.Object, messageBox.Object) }; - var state = new RubberduckParserState(vbe.Object, new Mock().Object); + var state = new RubberduckParserState(new Mock().Object); var vm = new CodeExplorerViewModel(new FolderHelper(state, GetDelimiterConfigLoader()), state, commands); var parser = MockParser.Create(vbe.Object, state); @@ -485,7 +484,7 @@ public void RemoveModule_NoExport() new RemoveCommand(saveFileDialog.Object, messageBox.Object) }; - var state = new RubberduckParserState(vbe.Object, new Mock().Object); + var state = new RubberduckParserState(new Mock().Object); var vm = new CodeExplorerViewModel(new FolderHelper(state, GetDelimiterConfigLoader()), state, commands); var parser = MockParser.Create(vbe.Object, state); @@ -527,7 +526,7 @@ public void RemoveModule_Cancel() new RemoveCommand(saveFileDialog.Object, messageBox.Object) }; - var state = new RubberduckParserState(vbe.Object, new Mock().Object); + var state = new RubberduckParserState(new Mock().Object); var vm = new CodeExplorerViewModel(new FolderHelper(state, GetDelimiterConfigLoader()), state, commands); var parser = MockParser.Create(vbe.Object, state); @@ -563,7 +562,7 @@ Dim d As Boolean var project = vbe.Object.VBProjects.Item(0); var module = project.VBComponents.Item(0).CodeModule; - var state = new RubberduckParserState(vbe.Object, new Mock().Object); + var state = new RubberduckParserState(new Mock().Object); var commands = new List { new IndentCommand(state, new Indenter(vbe.Object, GetDefaultIndenterSettings), null) @@ -598,7 +597,7 @@ Dim d As Boolean var mockHost = new Mock(); mockHost.SetupAllProperties(); - var state = new RubberduckParserState(vbe.Object, new Mock().Object); + var state = new RubberduckParserState(new Mock().Object); var commands = new List { new IndentCommand(state, new Indenter(vbe.Object, GetDefaultIndenterSettings), null) @@ -643,7 +642,7 @@ Dim d As Boolean var component2 = project.Object.VBComponents.Item(1); var module2 = component2.CodeModule; - var state = new RubberduckParserState(vbe.Object, new Mock().Object); + var state = new RubberduckParserState(new Mock().Object); var commands = new List { new IndentCommand(state, new Indenter(vbe.Object, GetDefaultIndenterSettings), null) @@ -698,7 +697,7 @@ Dim d As Boolean var component2 = project.Object.VBComponents.Item(1); var module2 = component2.CodeModule; - var state = new RubberduckParserState(vbe.Object, new Mock().Object); + var state = new RubberduckParserState(new Mock().Object); var commands = new List { new IndentCommand(state, new Indenter(vbe.Object, GetDefaultIndenterSettings), null) @@ -736,7 +735,7 @@ Dim d As Boolean var project = projectMock.Build(); var vbe = builder.AddProject(project).Build(); - var state = new RubberduckParserState(vbe.Object, new Mock().Object); + var state = new RubberduckParserState(new Mock().Object); var commands = new List { new IndentCommand(state, new Indenter(vbe.Object, GetDefaultIndenterSettings), null) @@ -786,7 +785,7 @@ Dim d As Boolean var component2 = project.Object.VBComponents.Item(1); var module2 = component2.CodeModule; - var state = new RubberduckParserState(vbe.Object, new Mock().Object); + var state = new RubberduckParserState(new Mock().Object); var commands = new List { new IndentCommand(state, new Indenter(vbe.Object, GetDefaultIndenterSettings), null) @@ -846,7 +845,7 @@ Dim d As Boolean var component2 = project.Object.VBComponents.Item(1); var module2 = component2.CodeModule; - var state = new RubberduckParserState(vbe.Object, new Mock().Object); + var state = new RubberduckParserState(new Mock().Object); var commands = new List { new IndentCommand(state, new Indenter(vbe.Object, GetDefaultIndenterSettings), null) @@ -885,7 +884,7 @@ Dim d As Boolean var project = projectMock.Build(); var vbe = builder.AddProject(project).Build(); - var state = new RubberduckParserState(vbe.Object, new Mock().Object); + var state = new RubberduckParserState(new Mock().Object); var commands = new List { new IndentCommand(state, new Indenter(vbe.Object, GetDefaultIndenterSettings), null) @@ -937,7 +936,7 @@ Sub Bar() msgbox.Setup(m => m.Show(It.IsAny(), It.IsAny(), MessageBoxButtons.YesNo, It.IsAny())) .Returns(DialogResult.Yes); - var state = new RubberduckParserState(vbe.Object, new Mock().Object); + var state = new RubberduckParserState(new Mock().Object); var commands = new List { new RenameCommand(vbe.Object, state, view.Object, msgbox.Object) @@ -955,6 +954,120 @@ Sub Bar() Assert.AreEqual(expectedCode, module.Lines()); } + [TestMethod] + public void ExpandAllNodes() + { + var inputCode = +@"Sub Foo() +End Sub"; + + var builder = new MockVbeBuilder(); + VBComponent component; + var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); + var mockHost = new Mock(); + mockHost.SetupAllProperties(); + + var state = new RubberduckParserState(new Mock().Object); + var vm = new CodeExplorerViewModel(new FolderHelper(state, GetDelimiterConfigLoader()), state, new List()); + + var parser = MockParser.Create(vbe.Object, state); + parser.Parse(new CancellationTokenSource()); + if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } + + vm.SelectedItem = vm.Projects.Single(); + vm.ExpandAllSubnodesCommand.Execute(vm.SelectedItem); + + Assert.IsTrue(vm.Projects.Single().IsExpanded); + Assert.IsTrue(vm.Projects.Single().Items.Single().IsExpanded); + Assert.IsTrue(vm.Projects.Single().Items.Single().Items.Single().IsExpanded); + Assert.IsTrue(vm.Projects.Single().Items.Single().Items.Single().Items.Single().IsExpanded); + } + + [TestMethod] + public void ExpandAllNodes_StartingWithSubnode() + { + var builder = new MockVbeBuilder(); + var project = builder.ProjectBuilder("Proj", vbext_ProjectProtection.vbext_pp_none) + .AddComponent("Comp1", vbext_ComponentType.vbext_ct_ClassModule, @"'@Folder ""Foo""") + .AddComponent("Comp2", vbext_ComponentType.vbext_ct_ClassModule, @"'@Folder ""Bar""") + .Build(); + var vbe = builder.AddProject(project).Build(); + var mockHost = new Mock(); + mockHost.SetupAllProperties(); + + var state = new RubberduckParserState(new Mock().Object); + var vm = new CodeExplorerViewModel(new FolderHelper(state, GetDelimiterConfigLoader()), state, new List()); + + var parser = MockParser.Create(vbe.Object, state); + parser.Parse(new CancellationTokenSource()); + if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } + + vm.Projects.Single().Items.Last().IsExpanded = false; + + vm.SelectedItem = vm.Projects.Single().Items.First(); + vm.ExpandAllSubnodesCommand.Execute(vm.SelectedItem); + + Assert.IsTrue(vm.Projects.Single().Items.First().IsExpanded); + Assert.IsFalse(vm.Projects.Single().Items.Last().IsExpanded); + } + + [TestMethod] + public void CollapseAllNodes() + { + var inputCode = +@"Sub Foo() +End Sub"; + + var builder = new MockVbeBuilder(); + VBComponent component; + var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); + var mockHost = new Mock(); + mockHost.SetupAllProperties(); + + var state = new RubberduckParserState(new Mock().Object); + var vm = new CodeExplorerViewModel(new FolderHelper(state, GetDelimiterConfigLoader()), state, new List()); + + var parser = MockParser.Create(vbe.Object, state); + parser.Parse(new CancellationTokenSource()); + if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } + + vm.SelectedItem = vm.Projects.Single(); + vm.CollapseAllSubnodesCommand.Execute(vm.SelectedItem); + + Assert.IsFalse(vm.Projects.Single().IsExpanded); + Assert.IsFalse(vm.Projects.Single().Items.Single().IsExpanded); + Assert.IsFalse(vm.Projects.Single().Items.Single().Items.Single().IsExpanded); + Assert.IsFalse(vm.Projects.Single().Items.Single().Items.Single().Items.Single().IsExpanded); + } + + [TestMethod] + public void CollapseAllNodes_StartingWithSubnode() + { + var builder = new MockVbeBuilder(); + var project = builder.ProjectBuilder("Proj", vbext_ProjectProtection.vbext_pp_none) + .AddComponent("Comp1", vbext_ComponentType.vbext_ct_ClassModule, @"'@Folder ""Foo""") + .AddComponent("Comp2", vbext_ComponentType.vbext_ct_ClassModule, @"'@Folder ""Bar""") + .Build(); + var vbe = builder.AddProject(project).Build(); + var mockHost = new Mock(); + mockHost.SetupAllProperties(); + + var state = new RubberduckParserState(new Mock().Object); + var vm = new CodeExplorerViewModel(new FolderHelper(state, GetDelimiterConfigLoader()), state, new List()); + + var parser = MockParser.Create(vbe.Object, state); + parser.Parse(new CancellationTokenSource()); + if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } + + vm.Projects.Single().Items.Last().IsExpanded = true; + + vm.SelectedItem = vm.Projects.Single().Items.First(); + vm.CollapseAllSubnodesCommand.Execute(vm.SelectedItem); + + Assert.IsFalse(vm.Projects.Single().Items.First().IsExpanded); + Assert.IsTrue(vm.Projects.Single().Items.Last().IsExpanded); + } + [TestMethod] public void CompareByName_ReturnsZeroForIdenticalNodes() { @@ -1002,7 +1115,7 @@ public void CompareByType_ReturnsEventAboveConst() var mockHost = new Mock(); mockHost.SetupAllProperties(); - var state = new RubberduckParserState(vbe.Object, new Mock().Object); + var state = new RubberduckParserState(new Mock().Object); var commands = new List(); var vm = new CodeExplorerViewModel(new FolderHelper(state, GetDelimiterConfigLoader()), state, commands); @@ -1029,7 +1142,7 @@ public void CompareByType_ReturnsConstAboveField() var mockHost = new Mock(); mockHost.SetupAllProperties(); - var state = new RubberduckParserState(vbe.Object, new Mock().Object); + var state = new RubberduckParserState(new Mock().Object); var commands = new List(); var vm = new CodeExplorerViewModel(new FolderHelper(state, GetDelimiterConfigLoader()), state, commands); @@ -1059,7 +1172,7 @@ End Property var mockHost = new Mock(); mockHost.SetupAllProperties(); - var state = new RubberduckParserState(vbe.Object, new Mock().Object); + var state = new RubberduckParserState(new Mock().Object); var commands = new List(); var vm = new CodeExplorerViewModel(new FolderHelper(state, GetDelimiterConfigLoader()), state, commands); @@ -1090,7 +1203,7 @@ End Property var mockHost = new Mock(); mockHost.SetupAllProperties(); - var state = new RubberduckParserState(vbe.Object, new Mock().Object); + var state = new RubberduckParserState(new Mock().Object); var commands = new List(); var vm = new CodeExplorerViewModel(new FolderHelper(state, GetDelimiterConfigLoader()), state, commands); @@ -1121,7 +1234,7 @@ End Property var mockHost = new Mock(); mockHost.SetupAllProperties(); - var state = new RubberduckParserState(vbe.Object, new Mock().Object); + var state = new RubberduckParserState(new Mock().Object); var commands = new List(); var vm = new CodeExplorerViewModel(new FolderHelper(state, GetDelimiterConfigLoader()), state, commands); @@ -1152,7 +1265,7 @@ End Function var mockHost = new Mock(); mockHost.SetupAllProperties(); - var state = new RubberduckParserState(vbe.Object, new Mock().Object); + var state = new RubberduckParserState(new Mock().Object); var commands = new List(); var vm = new CodeExplorerViewModel(new FolderHelper(state, GetDelimiterConfigLoader()), state, commands); @@ -1183,7 +1296,7 @@ End Sub var mockHost = new Mock(); mockHost.SetupAllProperties(); - var state = new RubberduckParserState(vbe.Object, new Mock().Object); + var state = new RubberduckParserState(new Mock().Object); var commands = new List(); var vm = new CodeExplorerViewModel(new FolderHelper(state, GetDelimiterConfigLoader()), state, commands); @@ -1211,7 +1324,7 @@ public void CompareByType_ReturnsClassModuleBelowDocument() var mockHost = new Mock(); mockHost.SetupAllProperties(); - var state = new RubberduckParserState(vbe.Object, new Mock().Object); + var state = new RubberduckParserState(new Mock().Object); var commands = new List(); var vm = new CodeExplorerViewModel(new FolderHelper(state, GetDelimiterConfigLoader()), state, commands); @@ -1246,7 +1359,7 @@ Sub Bar() var mockHost = new Mock(); mockHost.SetupAllProperties(); - var state = new RubberduckParserState(vbe.Object, new Mock().Object); + var state = new RubberduckParserState(new Mock().Object); var commands = new List(); var vm = new CodeExplorerViewModel(new FolderHelper(state, GetDelimiterConfigLoader()), state, commands); @@ -1277,7 +1390,7 @@ Sub Bar() var mockHost = new Mock(); mockHost.SetupAllProperties(); - var state = new RubberduckParserState(vbe.Object, new Mock().Object); + var state = new RubberduckParserState(new Mock().Object); var commands = new List(); var vm = new CodeExplorerViewModel(new FolderHelper(state, GetDelimiterConfigLoader()), state, commands); @@ -1308,7 +1421,7 @@ Sub Bar() var mockHost = new Mock(); mockHost.SetupAllProperties(); - var state = new RubberduckParserState(vbe.Object, new Mock().Object); + var state = new RubberduckParserState(new Mock().Object); var commands = new List(); var vm = new CodeExplorerViewModel(new FolderHelper(state, GetDelimiterConfigLoader()), state, commands); @@ -1385,7 +1498,7 @@ private IIndenterSettings GetDefaultIndenterSettings() private ConfigurationLoader GetDelimiterConfigLoader() { - var configLoader = new Mock(null, null, null, null, null, null, null); + var configLoader = new Mock(null, null, null, null, null, null); configLoader.Setup(c => c.LoadConfiguration()).Returns(GetDelimiterConfig()); return configLoader.Object; diff --git a/RubberduckTests/Commands/FindAllImplementationsTests.cs b/RubberduckTests/Commands/FindAllImplementationsTests.cs new file mode 100644 index 0000000000..678e0853d8 --- /dev/null +++ b/RubberduckTests/Commands/FindAllImplementationsTests.cs @@ -0,0 +1,341 @@ +using System.Linq; +using System.Threading; +using System.Windows.Forms; +using Microsoft.Vbe.Interop; +using Microsoft.VisualStudio.TestTools.UnitTesting; +using Moq; +using Rubberduck.Parsing; +using Rubberduck.Parsing.VBA; +using Rubberduck.UI; +using Rubberduck.UI.Command; +using Rubberduck.UI.Controls; +using Rubberduck.VBEditor; +using Rubberduck.VBEditor.VBEHost; +using RubberduckTests.Mocks; + +namespace RubberduckTests.Commands +{ + [TestClass] + public class FindAllImplementationsTests + { + [TestMethod] + public void FindAllImplementations_ReturnsCorrectNumber() + { + const string inputClass = +@"Implements IClass1 + +Public Sub IClass1_Foo() +End Sub"; + + const string inputInterface = +@"Public Sub Foo() +End Sub"; + + //Arrange + var builder = new MockVbeBuilder(); + var project = builder.ProjectBuilder("TestProject", vbext_ProjectProtection.vbext_pp_none) + .AddComponent("Class1", vbext_ComponentType.vbext_ct_ClassModule, inputClass) + .AddComponent("Class2", vbext_ComponentType.vbext_ct_ClassModule, inputClass) + .AddComponent("IClass1", vbext_ComponentType.vbext_ct_ClassModule, inputInterface) + .Build(); + + var vbe = builder.AddProject(project).Build(); + var mockHost = new Mock(); + mockHost.SetupAllProperties(); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + + parser.Parse(new CancellationTokenSource()); + if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } + + var vm = new SearchResultsWindowViewModel(); + var command = new FindAllImplementationsCommand(null, null, parser.State, vbe.Object, vm, null); + + command.Execute(parser.State.AllUserDeclarations.Single(s => s.IdentifierName == "Foo")); + + Assert.AreEqual(2, vm.Tabs[0].SearchResults.Count); + } + + [TestMethod] + public void FindAllImplementations_SelectedImplementation_ReturnsCorrectNumber() + { + const string inputClass = +@"Implements IClass1 + +Public Sub IClass1_Foo() +End Sub"; + + const string inputInterface = +@"Public Sub Foo() +End Sub"; + + //Arrange + var builder = new MockVbeBuilder(); + var project = builder.ProjectBuilder("TestProject", vbext_ProjectProtection.vbext_pp_none) + .AddComponent("Class1", vbext_ComponentType.vbext_ct_ClassModule, inputClass) + .AddComponent("Class2", vbext_ComponentType.vbext_ct_ClassModule, inputClass) + .AddComponent("IClass1", vbext_ComponentType.vbext_ct_ClassModule, inputInterface) + .Build(); + + var vbe = builder.AddProject(project).Build(); + var mockHost = new Mock(); + mockHost.SetupAllProperties(); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + + parser.Parse(new CancellationTokenSource()); + if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } + + var vm = new SearchResultsWindowViewModel(); + var command = new FindAllImplementationsCommand(null, null, parser.State, vbe.Object, vm, null); + + command.Execute(parser.State.AllUserDeclarations.First(s => s.IdentifierName == "IClass1_Foo")); + + Assert.AreEqual(2, vm.Tabs[0].SearchResults.Count); + } + + [TestMethod] + public void FindAllImplementations_SelectedReference_ReturnsCorrectNumber() + { + const string inputClass = +@"Implements IClass1 + +Public Sub IClass1_Foo() +End Sub + +Public Sub Buzz() + IClass1_Foo +End Sub"; + + const string inputInterface = +@"Public Sub Foo() +End Sub"; + + //Arrange + var builder = new MockVbeBuilder(); + var project = builder.ProjectBuilder("TestProject", vbext_ProjectProtection.vbext_pp_none) + .AddComponent("Class1", vbext_ComponentType.vbext_ct_ClassModule, inputClass, new Selection(7, 5, 7, 5)) + .AddComponent("Class2", vbext_ComponentType.vbext_ct_ClassModule, inputClass) + .AddComponent("IClass1", vbext_ComponentType.vbext_ct_ClassModule, inputInterface) + .Build(); + + var vbe = builder.AddProject(project).Build(); + vbe.Setup(v => v.ActiveCodePane).Returns(project.Object.VBComponents.Item("Class1").CodeModule.CodePane); + + var mockHost = new Mock(); + mockHost.SetupAllProperties(); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + + parser.Parse(new CancellationTokenSource()); + if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } + + var vm = new SearchResultsWindowViewModel(); + var command = new FindAllImplementationsCommand(null, null, parser.State, vbe.Object, vm, null); + + command.Execute(null); + + Assert.AreEqual(2, vm.Tabs[0].SearchResults.Count); + } + + [TestMethod] + public void FindAllImplementations_NoResults_DisplayMessageBox() + { + const string inputCode = +@"Public Sub Foo() +End Sub"; + + //Arrange + var builder = new MockVbeBuilder(); + VBComponent component; + var vbe = builder.BuildFromSingleModule(inputCode, vbext_ComponentType.vbext_ct_ClassModule, out component, default(Selection)); + var mockHost = new Mock(); + mockHost.SetupAllProperties(); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + + parser.Parse(new CancellationTokenSource()); + if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } + + var messageBox = new Mock(); + messageBox.Setup(m => + m.Show(It.IsAny(), It.IsAny(), It.IsAny(), + It.IsAny())).Returns(DialogResult.OK); + + var vm = new SearchResultsWindowViewModel(); + var command = new FindAllImplementationsCommand(null, messageBox.Object, parser.State, vbe.Object, vm, null); + + command.Execute(parser.State.AllUserDeclarations.Single(s => s.IdentifierName == "Foo")); + + messageBox.Verify(m => m.Show(It.IsAny(), It.IsAny(), It.IsAny(), + It.IsAny()), Times.Once); + } + + [TestMethod] + public void FindAllImplementations_SingleResult_Navigates() + { + const string inputClass = +@"Implements IClass1 + +Public Sub IClass1_Foo() +End Sub"; + + const string inputInterface = +@"Public Sub Foo() +End Sub"; + + //Arrange + var builder = new MockVbeBuilder(); + var project = builder.ProjectBuilder("TestProject", vbext_ProjectProtection.vbext_pp_none) + .AddComponent("Class1", vbext_ComponentType.vbext_ct_ClassModule, inputClass) + .AddComponent("IClass1", vbext_ComponentType.vbext_ct_ClassModule, inputInterface) + .Build(); + + var vbe = builder.AddProject(project).Build(); + var mockHost = new Mock(); + mockHost.SetupAllProperties(); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + + parser.Parse(new CancellationTokenSource()); + if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } + + var navigateCommand = new Mock(); + + var vm = new SearchResultsWindowViewModel(); + var command = new FindAllImplementationsCommand(navigateCommand.Object, null, parser.State, vbe.Object, vm, null); + + command.Execute(parser.State.AllUserDeclarations.Single(s => s.IdentifierName == "Foo")); + + navigateCommand.Verify(n => n.Execute(It.IsAny()), Times.Once); + } + + [TestMethod] + public void FindAllImplementations_NullTarget_Aborts() + { + //Arrange + var builder = new MockVbeBuilder(); + VBComponent component; + var vbe = builder.BuildFromSingleStandardModule(string.Empty, out component); + vbe.Setup(s => s.ActiveCodePane).Returns(value: null); + var mockHost = new Mock(); + mockHost.SetupAllProperties(); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + + parser.Parse(new CancellationTokenSource()); + if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } + + var vm = new SearchResultsWindowViewModel(); + var command = new FindAllImplementationsCommand(null, null, parser.State, vbe.Object, vm, null); + + command.Execute(null); + + Assert.IsFalse(vm.Tabs.Any()); + } + + [TestMethod] + public void FindAllImplementations_StateNotReady_Aborts() + { + const string inputCode = +@"Public Sub Foo() +End Sub + +Private Sub Bar() + Foo: Foo + Foo + Foo +End Sub"; + + //Arrange + var builder = new MockVbeBuilder(); + VBComponent component; + var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); + vbe.Setup(s => s.ActiveCodePane).Returns(value: null); + var mockHost = new Mock(); + mockHost.SetupAllProperties(); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + + parser.Parse(new CancellationTokenSource()); + if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } + + parser.State.SetStatusAndFireStateChanged(ParserState.ResolvedDeclarations); + + var vm = new SearchResultsWindowViewModel(); + var command = new FindAllImplementationsCommand(null, null, parser.State, vbe.Object, vm, null); + + command.Execute(parser.State.AllUserDeclarations.Single(s => s.IdentifierName == "Foo")); + + Assert.IsFalse(vm.Tabs.Any()); + } + + [TestMethod] + public void FindAllImplementations_CanExecute_NullTarget() + { + //Arrange + var builder = new MockVbeBuilder(); + VBComponent component; + var vbe = builder.BuildFromSingleStandardModule(string.Empty, out component); + vbe.Setup(s => s.ActiveCodePane).Returns(value: null); + var mockHost = new Mock(); + mockHost.SetupAllProperties(); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + + parser.Parse(new CancellationTokenSource()); + if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } + + var vm = new SearchResultsWindowViewModel(); + var command = new FindAllImplementationsCommand(null, null, parser.State, vbe.Object, vm, null); + + Assert.IsFalse(command.CanExecute(null)); + } + + [TestMethod] + public void FindAllImplementations_CanExecute_StateNotReady() + { + const string inputCode = +@"Public Sub Foo() +End Sub + +Private Sub Bar() + Foo: Foo + Foo + Foo +End Sub"; + + //Arrange + var builder = new MockVbeBuilder(); + VBComponent component; + var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); + vbe.Setup(s => s.ActiveCodePane).Returns(value: null); + var mockHost = new Mock(); + mockHost.SetupAllProperties(); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + + parser.Parse(new CancellationTokenSource()); + if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } + + parser.State.SetStatusAndFireStateChanged(ParserState.ResolvedDeclarations); + + var vm = new SearchResultsWindowViewModel(); + var command = new FindAllImplementationsCommand(null, null, parser.State, vbe.Object, vm, null); + + Assert.IsFalse(command.CanExecute(parser.State.AllUserDeclarations.Single(s => s.IdentifierName == "Foo"))); + } + + [TestMethod] + public void FindAllImplementations_CanExecute_NullActiveCodePane() + { + //Arrange + var builder = new MockVbeBuilder(); + VBComponent component; + var vbe = builder.BuildFromSingleStandardModule(string.Empty, out component); + vbe.Setup(s => s.ActiveCodePane).Returns(value: null); + var mockHost = new Mock(); + mockHost.SetupAllProperties(); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + + parser.Parse(new CancellationTokenSource()); + if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } + + var vm = new SearchResultsWindowViewModel(); + var command = new FindAllImplementationsCommand(null, null, parser.State, vbe.Object, vm, null); + + Assert.IsFalse(command.CanExecute(null)); + } + } +} diff --git a/RubberduckTests/Commands/FindAllReferencesTests.cs b/RubberduckTests/Commands/FindAllReferencesTests.cs new file mode 100644 index 0000000000..1238fd68f0 --- /dev/null +++ b/RubberduckTests/Commands/FindAllReferencesTests.cs @@ -0,0 +1,282 @@ +using System.Linq; +using System.Threading; +using System.Windows.Forms; +using Microsoft.Vbe.Interop; +using Microsoft.VisualStudio.TestTools.UnitTesting; +using Moq; +using Rubberduck.Parsing; +using Rubberduck.Parsing.VBA; +using Rubberduck.UI; +using Rubberduck.UI.Command; +using Rubberduck.UI.Controls; +using Rubberduck.VBEditor; +using Rubberduck.VBEditor.VBEHost; +using RubberduckTests.Mocks; + +namespace RubberduckTests.Commands +{ + [TestClass] + public class FindAllReferencesTests + { + [TestMethod] + public void FindAllReferences_ReturnsCorrectNumber() + { + const string inputCode = +@"Public Sub Foo() +End Sub + +Private Sub Bar() + Foo: Foo + Foo + Foo +End Sub"; + + //Arrange + var builder = new MockVbeBuilder(); + VBComponent component; + var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); + var mockHost = new Mock(); + mockHost.SetupAllProperties(); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + + parser.Parse(new CancellationTokenSource()); + if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } + + var vm = new SearchResultsWindowViewModel(); + var command = new FindAllReferencesCommand(null, null, parser.State, vbe.Object, vm, null); + + command.Execute(parser.State.AllUserDeclarations.Single(s => s.IdentifierName == "Foo")); + + Assert.AreEqual(4, vm.Tabs[0].SearchResults.Count); + } + + [TestMethod] + public void FindAllReferences_ReferenceSelected_ReturnsCorrectNumber() + { + const string inputCode = +@"Public Sub Foo() +End Sub + +Private Sub Bar() + Foo: Foo + Foo + Foo +End Sub"; + + //Arrange + var builder = new MockVbeBuilder(); + VBComponent component; + var vbe = builder.BuildFromSingleStandardModule(inputCode, out component, new Selection(5, 5, 5, 5)); + var mockHost = new Mock(); + mockHost.SetupAllProperties(); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + + parser.Parse(new CancellationTokenSource()); + if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } + + var vm = new SearchResultsWindowViewModel(); + var command = new FindAllReferencesCommand(null, null, parser.State, vbe.Object, vm, null); + + command.Execute(null); + + Assert.AreEqual(4, vm.Tabs[0].SearchResults.Count); + } + + [TestMethod] + public void FindAllReferences_NoResults_DisplayMessageBox() + { + const string inputCode = +@"Public Sub Foo() +End Sub"; + + //Arrange + var builder = new MockVbeBuilder(); + VBComponent component; + var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); + var mockHost = new Mock(); + mockHost.SetupAllProperties(); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + + parser.Parse(new CancellationTokenSource()); + if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } + + var messageBox = new Mock(); + messageBox.Setup(m => + m.Show(It.IsAny(), It.IsAny(), It.IsAny(), + It.IsAny())).Returns(DialogResult.OK); + + var vm = new SearchResultsWindowViewModel(); + var command = new FindAllReferencesCommand(null, messageBox.Object, parser.State, vbe.Object, vm, null); + + command.Execute(parser.State.AllUserDeclarations.Single(s => s.IdentifierName == "Foo")); + + messageBox.Verify(m => m.Show(It.IsAny(), It.IsAny(), It.IsAny(), + It.IsAny()), Times.Once); + } + + [TestMethod] + public void FindAllReferences_SingleResult_Navigates() + { + const string inputCode = +@"Public Sub Foo() +End Sub + +Private Sub Bar() + Foo +End Sub"; + + //Arrange + var builder = new MockVbeBuilder(); + VBComponent component; + var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); + var mockHost = new Mock(); + mockHost.SetupAllProperties(); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + + parser.Parse(new CancellationTokenSource()); + if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } + + var navigateCommand = new Mock(); + + var vm = new SearchResultsWindowViewModel(); + var command = new FindAllReferencesCommand(navigateCommand.Object, null, parser.State, vbe.Object, vm, null); + + command.Execute(parser.State.AllUserDeclarations.Single(s => s.IdentifierName == "Foo")); + + navigateCommand.Verify(n => n.Execute(It.IsAny()), Times.Once); + } + + [TestMethod] + public void FindAllReferences_NullTarget_Aborts() + { + //Arrange + var builder = new MockVbeBuilder(); + VBComponent component; + var vbe = builder.BuildFromSingleStandardModule(string.Empty, out component); + vbe.Setup(s => s.ActiveCodePane).Returns(value: null); + var mockHost = new Mock(); + mockHost.SetupAllProperties(); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + + parser.Parse(new CancellationTokenSource()); + if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } + + var vm = new SearchResultsWindowViewModel(); + var command = new FindAllReferencesCommand(null, null, parser.State, vbe.Object, vm, null); + + command.Execute(null); + + Assert.IsFalse(vm.Tabs.Any()); + } + + [TestMethod] + public void FindAllReferences_StateNotReady_Aborts() + { + const string inputCode = +@"Public Sub Foo() +End Sub + +Private Sub Bar() + Foo: Foo + Foo + Foo +End Sub"; + + //Arrange + var builder = new MockVbeBuilder(); + VBComponent component; + var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); + vbe.Setup(s => s.ActiveCodePane).Returns(value: null); + var mockHost = new Mock(); + mockHost.SetupAllProperties(); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + + parser.Parse(new CancellationTokenSource()); + if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } + + parser.State.SetStatusAndFireStateChanged(ParserState.ResolvedDeclarations); + + var vm = new SearchResultsWindowViewModel(); + var command = new FindAllReferencesCommand(null, null, parser.State, vbe.Object, vm, null); + + command.Execute(parser.State.AllUserDeclarations.Single(s => s.IdentifierName == "Foo")); + + Assert.IsFalse(vm.Tabs.Any()); + } + + [TestMethod] + public void FindAllReferences_CanExecute_NullTarget() + { + //Arrange + var builder = new MockVbeBuilder(); + VBComponent component; + var vbe = builder.BuildFromSingleStandardModule(string.Empty, out component); + vbe.Setup(s => s.ActiveCodePane).Returns(value: null); + var mockHost = new Mock(); + mockHost.SetupAllProperties(); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + + parser.Parse(new CancellationTokenSource()); + if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } + + var vm = new SearchResultsWindowViewModel(); + var command = new FindAllReferencesCommand(null, null, parser.State, vbe.Object, vm, null); + + Assert.IsFalse(command.CanExecute(null)); + } + + [TestMethod] + public void FindAllReferences_CanExecute_StateNotReady() + { + const string inputCode = +@"Public Sub Foo() +End Sub + +Private Sub Bar() + Foo: Foo + Foo + Foo +End Sub"; + + //Arrange + var builder = new MockVbeBuilder(); + VBComponent component; + var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); + vbe.Setup(s => s.ActiveCodePane).Returns(value: null); + var mockHost = new Mock(); + mockHost.SetupAllProperties(); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + + parser.Parse(new CancellationTokenSource()); + if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } + + parser.State.SetStatusAndFireStateChanged(ParserState.ResolvedDeclarations); + + var vm = new SearchResultsWindowViewModel(); + var command = new FindAllReferencesCommand(null, null, parser.State, vbe.Object, vm, null); + + Assert.IsFalse(command.CanExecute(parser.State.AllUserDeclarations.Single(s => s.IdentifierName == "Foo"))); + } + + [TestMethod] + public void FindAllReferences_CanExecute_NullActiveCodePane() + { + //Arrange + var builder = new MockVbeBuilder(); + VBComponent component; + var vbe = builder.BuildFromSingleStandardModule(string.Empty, out component); + vbe.Setup(s => s.ActiveCodePane).Returns(value: null); + var mockHost = new Mock(); + mockHost.SetupAllProperties(); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + + parser.Parse(new CancellationTokenSource()); + if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } + + var vm = new SearchResultsWindowViewModel(); + var command = new FindAllReferencesCommand(null, null, parser.State, vbe.Object, vm, null); + + Assert.IsFalse(command.CanExecute(null)); + } + } +} diff --git a/RubberduckTests/Commands/IndentCommandTests.cs b/RubberduckTests/Commands/IndentCommandTests.cs new file mode 100644 index 0000000000..52fdc075cb --- /dev/null +++ b/RubberduckTests/Commands/IndentCommandTests.cs @@ -0,0 +1,243 @@ +using System.Threading; +using Microsoft.Vbe.Interop; +using Microsoft.VisualStudio.TestTools.UnitTesting; +using Moq; +using Rubberduck.Parsing; +using Rubberduck.Parsing.VBA; +using Rubberduck.SmartIndenter; +using Rubberduck.UI.Command; +using Rubberduck.VBEditor.Extensions; +using Rubberduck.VBEditor.VBEHost; +using RubberduckTests.Mocks; + +namespace RubberduckTests.Commands +{ + [TestClass] + public class IndentCommandTests + { + [TestMethod] + public void AddNoIndentAnnotation() + { + var builder = new MockVbeBuilder(); + VBComponent component; + var vbe = builder.BuildFromSingleStandardModule("", out component); + var mockHost = new Mock(); + mockHost.SetupAllProperties(); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + + parser.Parse(new CancellationTokenSource()); + if (parser.State.Status >= ParserState.Error) + { + Assert.Inconclusive("Parser Error"); + } + + var noIndentAnnotationCommand = new NoIndentAnnotationCommand(vbe.Object, parser.State); + noIndentAnnotationCommand.Execute(null); + + Assert.AreEqual("'@NoIndent\r\n", component.CodeModule.Lines()); + } + + [TestMethod] + public void AddNoIndentAnnotation_ModuleContainsCode() + { + var input = +@"Option Explicit +Public Foo As Boolean + +Sub Foo() +End Sub"; + + var expected = +@"'@NoIndent +Option Explicit +Public Foo As Boolean + +Sub Foo() +End Sub"; + + var builder = new MockVbeBuilder(); + VBComponent component; + var vbe = builder.BuildFromSingleStandardModule(input, out component); + var mockHost = new Mock(); + mockHost.SetupAllProperties(); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + + parser.Parse(new CancellationTokenSource()); + if (parser.State.Status >= ParserState.Error) + { + Assert.Inconclusive("Parser Error"); + } + + var noIndentAnnotationCommand = new NoIndentAnnotationCommand(vbe.Object, parser.State); + noIndentAnnotationCommand.Execute(null); + + Assert.AreEqual(expected, component.CodeModule.Lines()); + } + + [TestMethod] + public void AddNoIndentAnnotation_CanExecute_NullActiveCodePane() + { + var builder = new MockVbeBuilder(); + VBComponent component; + var vbe = builder.BuildFromSingleStandardModule("", out component); + vbe.Setup(v => v.ActiveCodePane).Returns((CodePane) null); + var mockHost = new Mock(); + mockHost.SetupAllProperties(); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + + parser.Parse(new CancellationTokenSource()); + if (parser.State.Status >= ParserState.Error) + { + Assert.Inconclusive("Parser Error"); + } + + var noIndentAnnotationCommand = new NoIndentAnnotationCommand(vbe.Object, parser.State); + Assert.IsFalse(noIndentAnnotationCommand.CanExecute(null)); + } + + [TestMethod] + public void AddNoIndentAnnotation_CanExecute_ModuleAlreadyHasAnnotation() + { + var builder = new MockVbeBuilder(); + VBComponent component; + var vbe = builder.BuildFromSingleStandardModule("'@NoIndent\r\n", out component); + vbe.Setup(v => v.ActiveCodePane).Returns((CodePane)null); + var mockHost = new Mock(); + mockHost.SetupAllProperties(); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + + parser.Parse(new CancellationTokenSource()); + if (parser.State.Status >= ParserState.Error) + { + Assert.Inconclusive("Parser Error"); + } + + var noIndentAnnotationCommand = new NoIndentAnnotationCommand(vbe.Object, parser.State); + Assert.IsFalse(noIndentAnnotationCommand.CanExecute(null)); + } + + [TestMethod] + public void IndentModule_IndentsModule() + { + var input = +@" Option Explicit ' at least I used it... + Sub InverseIndent() +Dim d As Boolean +Dim s As Integer + + End Sub + + Sub RandomIndent() +Dim d As Boolean + Dim s As Integer + + End Sub +"; + + var expected = +@"Option Explicit ' at least I used it... +Sub InverseIndent() + Dim d As Boolean + Dim s As Integer + +End Sub + +Sub RandomIndent() + Dim d As Boolean + Dim s As Integer + +End Sub +"; + + var builder = new MockVbeBuilder(); + var project = builder.ProjectBuilder("Proj1", vbext_ProjectProtection.vbext_pp_none) + .AddComponent("Comp1", vbext_ComponentType.vbext_ct_ClassModule, input) + .AddComponent("Comp2", vbext_ComponentType.vbext_ct_ClassModule, input) + .Build(); + + var vbe = builder.AddProject(project).Build(); + vbe.Setup(s => s.ActiveCodePane).Returns(project.Object.VBComponents.Item("Comp2").CodeModule.CodePane); + + var mockHost = new Mock(); + mockHost.SetupAllProperties(); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + + parser.Parse(new CancellationTokenSource()); + if (parser.State.Status >= ParserState.Error) + { + Assert.Inconclusive("Parser Error"); + } + + var indentCommand = new IndentCurrentModuleCommand(vbe.Object, CreateIndenter(vbe.Object)); + indentCommand.Execute(null); + + Assert.AreEqual(input, project.Object.VBComponents.Item("Comp1").CodeModule.Lines()); + Assert.AreEqual(expected, project.Object.VBComponents.Item("Comp2").CodeModule.Lines()); + } + + [TestMethod] + public void IndentModule_CanExecute_NullActiveCodePane() + { + var builder = new MockVbeBuilder(); + VBComponent component; + var vbe = builder.BuildFromSingleStandardModule("", out component); + vbe.Setup(v => v.ActiveCodePane).Returns((CodePane) null); + + var mockHost = new Mock(); + mockHost.SetupAllProperties(); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + + parser.Parse(new CancellationTokenSource()); + if (parser.State.Status >= ParserState.Error) + { + Assert.Inconclusive("Parser Error"); + } + + var indentCommand = new IndentCurrentModuleCommand(vbe.Object, CreateIndenter(vbe.Object)); + Assert.IsFalse(indentCommand.CanExecute(null)); + } + + [TestMethod] + public void IndentModule_CanExecute() + { + var builder = new MockVbeBuilder(); + VBComponent component; + var vbe = builder.BuildFromSingleStandardModule("", out component); + var mockHost = new Mock(); + mockHost.SetupAllProperties(); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + + parser.Parse(new CancellationTokenSource()); + if (parser.State.Status >= ParserState.Error) + { + Assert.Inconclusive("Parser Error"); + } + + var indentCommand = new IndentCurrentModuleCommand(vbe.Object, CreateIndenter(vbe.Object)); + Assert.IsTrue(indentCommand.CanExecute(null)); + } + + private static IIndenter CreateIndenter(VBE vbe) + { + var settings = new Mock(); + settings.Setup(s => s.IndentEntireProcedureBody).Returns(true); + settings.Setup(s => s.IndentFirstCommentBlock).Returns(true); + settings.Setup(s => s.IndentFirstDeclarationBlock).Returns(true); + settings.Setup(s => s.AlignCommentsWithCode).Returns(true); + settings.Setup(s => s.AlignContinuations).Returns(true); + settings.Setup(s => s.IgnoreOperatorsInContinuations).Returns(true); + settings.Setup(s => s.IndentCase).Returns(false); + settings.Setup(s => s.ForceDebugStatementsInColumn1).Returns(false); + settings.Setup(s => s.ForceCompilerDirectivesInColumn1).Returns(false); + settings.Setup(s => s.IndentCompilerDirectives).Returns(true); + settings.Setup(s => s.AlignDims).Returns(false); + settings.Setup(s => s.AlignDimColumn).Returns(15); + settings.Setup(s => s.EnableUndo).Returns(true); + settings.Setup(s => s.EndOfLineCommentStyle).Returns(EndOfLineCommentStyle.AlignInColumn); + settings.Setup(s => s.EndOfLineCommentColumnSpaceAlignment).Returns(50); + settings.Setup(s => s.IndentSpaces).Returns(4); + + return new Indenter(vbe, () => new IndenterSettings()); + } + } +} \ No newline at end of file diff --git a/RubberduckTests/Commands/RefactorCommandTests.cs b/RubberduckTests/Commands/RefactorCommandTests.cs new file mode 100644 index 0000000000..323f54f03f --- /dev/null +++ b/RubberduckTests/Commands/RefactorCommandTests.cs @@ -0,0 +1,1518 @@ +using System.Threading; +using Microsoft.Vbe.Interop; +using Microsoft.VisualStudio.TestTools.UnitTesting; +using Moq; +using Rubberduck.Parsing; +using Rubberduck.Parsing.VBA; +using Rubberduck.UI.Command.Refactorings; +using Rubberduck.VBEditor; +using Rubberduck.VBEditor.VBEHost; +using RubberduckTests.Mocks; + +namespace RubberduckTests.Commands +{ + [TestClass] + public class RefactorCommandTests + { + [TestMethod] + public void EncapsulateField_CanExecute_NullActiveCodePane() + { + var builder = new MockVbeBuilder(); + VBComponent component; + var vbe = builder.BuildFromSingleStandardModule("", out component); + vbe.Setup(v => v.ActiveCodePane).Returns((CodePane)null); + var mockHost = new Mock(); + mockHost.SetupAllProperties(); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + + parser.Parse(new CancellationTokenSource()); + if (parser.State.Status >= ParserState.Error) + { + Assert.Inconclusive("Parser Error"); + } + + var encapsulateFieldCommand = new RefactorEncapsulateFieldCommand(vbe.Object, parser.State, null); + Assert.IsFalse(encapsulateFieldCommand.CanExecute(null)); + } + + [TestMethod] + public void EncapsulateField_CanExecute_NonReadyState() + { + var builder = new MockVbeBuilder(); + VBComponent component; + var vbe = builder.BuildFromSingleStandardModule("", out component); + var mockHost = new Mock(); + mockHost.SetupAllProperties(); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + + parser.Parse(new CancellationTokenSource()); + if (parser.State.Status >= ParserState.Error) + { + Assert.Inconclusive("Parser Error"); + } + parser.State.SetStatusAndFireStateChanged(ParserState.ResolvedDeclarations); + + var encapsulateFieldCommand = new RefactorEncapsulateFieldCommand(vbe.Object, parser.State, null); + Assert.IsFalse(encapsulateFieldCommand.CanExecute(null)); + } + + [TestMethod] + public void EncapsulateField_CanExecute_LocalVariable() + { + var input = +@"Sub Foo() + Dim d As Boolean +End Sub"; + + var builder = new MockVbeBuilder(); + VBComponent component; + var vbe = builder.BuildFromSingleStandardModule(input, out component, new Selection(2, 9, 2, 9)); + var mockHost = new Mock(); + mockHost.SetupAllProperties(); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + + parser.Parse(new CancellationTokenSource()); + if (parser.State.Status >= ParserState.Error) + { + Assert.Inconclusive("Parser Error"); + } + + var encapsulateFieldCommand = new RefactorEncapsulateFieldCommand(vbe.Object, parser.State, null); + Assert.IsFalse(encapsulateFieldCommand.CanExecute(null)); + } + + [TestMethod] + public void EncapsulateField_CanExecute_Proc() + { + var input = +@"Dim d As Boolean +Sub Foo() +End Sub"; + + var builder = new MockVbeBuilder(); + VBComponent component; + var vbe = builder.BuildFromSingleStandardModule(input, out component, new Selection(2, 7, 2, 7)); + var mockHost = new Mock(); + mockHost.SetupAllProperties(); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + + parser.Parse(new CancellationTokenSource()); + if (parser.State.Status >= ParserState.Error) + { + Assert.Inconclusive("Parser Error"); + } + + var encapsulateFieldCommand = new RefactorEncapsulateFieldCommand(vbe.Object, parser.State, null); + Assert.IsFalse(encapsulateFieldCommand.CanExecute(null)); + } + + [TestMethod] + public void EncapsulateField_CanExecute_Field() + { + var input = +@"Dim d As Boolean +Sub Foo() +End Sub"; + + var builder = new MockVbeBuilder(); + VBComponent component; + var vbe = builder.BuildFromSingleStandardModule(input, out component, new Selection(1, 5, 1, 5)); + var mockHost = new Mock(); + mockHost.SetupAllProperties(); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + + parser.Parse(new CancellationTokenSource()); + if (parser.State.Status >= ParserState.Error) + { + Assert.Inconclusive("Parser Error"); + } + + var encapsulateFieldCommand = new RefactorEncapsulateFieldCommand(vbe.Object, parser.State, null); + Assert.IsTrue(encapsulateFieldCommand.CanExecute(null)); + } + + [TestMethod] + public void ExtractInterface_CanExecute_NullActiveCodePane() + { + var builder = new MockVbeBuilder(); + VBComponent component; + var vbe = builder.BuildFromSingleStandardModule("", out component); + vbe.Setup(v => v.ActiveCodePane).Returns((CodePane)null); + var mockHost = new Mock(); + mockHost.SetupAllProperties(); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + + parser.Parse(new CancellationTokenSource()); + if (parser.State.Status >= ParserState.Error) + { + Assert.Inconclusive("Parser Error"); + } + + var extractInterfaceCommand = new RefactorExtractInterfaceCommand(vbe.Object, parser.State, null); + Assert.IsFalse(extractInterfaceCommand.CanExecute(null)); + } + + [TestMethod] + public void ExtractInterface_CanExecute_NonReadyState() + { + var builder = new MockVbeBuilder(); + VBComponent component; + var vbe = builder.BuildFromSingleModule("", vbext_ComponentType.vbext_ct_ClassModule, out component, new Selection()); + var mockHost = new Mock(); + mockHost.SetupAllProperties(); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + + parser.Parse(new CancellationTokenSource()); + if (parser.State.Status >= ParserState.Error) + { + Assert.Inconclusive("Parser Error"); + } + parser.State.SetStatusAndFireStateChanged(ParserState.ResolvedDeclarations); + + var extractInterfaceCommand = new RefactorExtractInterfaceCommand(vbe.Object, parser.State, null); + Assert.IsFalse(extractInterfaceCommand.CanExecute(null)); + } + + [TestMethod] + public void ExtractInterface_CanExecute_NoMembers() + { + var builder = new MockVbeBuilder(); + VBComponent component; + var vbe = builder.BuildFromSingleModule("Option Explicit", vbext_ComponentType.vbext_ct_ClassModule, out component, new Selection()); + var mockHost = new Mock(); + mockHost.SetupAllProperties(); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + + parser.Parse(new CancellationTokenSource()); + if (parser.State.Status >= ParserState.Error) + { + Assert.Inconclusive("Parser Error"); + } + + var extractInterfaceCommand = new RefactorExtractInterfaceCommand(vbe.Object, parser.State, null); + Assert.IsFalse(extractInterfaceCommand.CanExecute(null)); + } + + [TestMethod] + public void ExtractInterface_CanExecute_Proc_StdModule() + { + var input = +@"Sub foo() +End Sub"; + + var builder = new MockVbeBuilder(); + VBComponent component; + var vbe = builder.BuildFromSingleStandardModule(input, out component); + var mockHost = new Mock(); + mockHost.SetupAllProperties(); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + + parser.Parse(new CancellationTokenSource()); + if (parser.State.Status >= ParserState.Error) + { + Assert.Inconclusive("Parser Error"); + } + + var extractInterfaceCommand = new RefactorExtractInterfaceCommand(vbe.Object, parser.State, null); + Assert.IsFalse(extractInterfaceCommand.CanExecute(null)); + } + + [TestMethod] + public void ExtractInterface_CanExecute_Field() + { + var builder = new MockVbeBuilder(); + VBComponent component; + var vbe = builder.BuildFromSingleModule("Dim d As Boolean", vbext_ComponentType.vbext_ct_ClassModule, out component, new Selection()); + var mockHost = new Mock(); + mockHost.SetupAllProperties(); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + + parser.Parse(new CancellationTokenSource()); + if (parser.State.Status >= ParserState.Error) + { + Assert.Inconclusive("Parser Error"); + } + + var extractInterfaceCommand = new RefactorExtractInterfaceCommand(vbe.Object, parser.State, null); + Assert.IsFalse(extractInterfaceCommand.CanExecute(null)); + } + + [TestMethod] + public void ExtractInterface_CanExecute_ClassWithoutMembers_SameNameAsClassWithMembers() + { + var input = +@"Sub foo() +End Sub"; + + var builder = new MockVbeBuilder(); + var proj1 = builder.ProjectBuilder("TestProj1", vbext_ProjectProtection.vbext_pp_none).AddComponent("Comp1", vbext_ComponentType.vbext_ct_ClassModule, input).Build(); + var proj2 = builder.ProjectBuilder("TestProj2", vbext_ProjectProtection.vbext_pp_none).AddComponent("Comp1", vbext_ComponentType.vbext_ct_ClassModule, "").Build(); + + var vbe = builder.AddProject(proj1).AddProject(proj2).Build(); + vbe.Setup(s => s.ActiveCodePane).Returns(proj2.Object.VBComponents.Item(0).CodeModule.CodePane); + + var mockHost = new Mock(); + mockHost.SetupAllProperties(); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + + parser.Parse(new CancellationTokenSource()); + if (parser.State.Status >= ParserState.Error) + { + Assert.Inconclusive("Parser Error"); + } + + var extractInterfaceCommand = new RefactorExtractInterfaceCommand(vbe.Object, parser.State, null); + Assert.IsFalse(extractInterfaceCommand.CanExecute(null)); + } + + [TestMethod] + public void ExtractInterface_CanExecute_ClassWithMembers_SameNameAsClassWithMembers() + { + var input = +@"Sub foo() +End Sub"; + + var builder = new MockVbeBuilder(); + var proj1 = builder.ProjectBuilder("TestProj1", vbext_ProjectProtection.vbext_pp_none).AddComponent("Comp1", vbext_ComponentType.vbext_ct_ClassModule, input).Build(); + var proj2 = builder.ProjectBuilder("TestProj2", vbext_ProjectProtection.vbext_pp_none).AddComponent("Comp1", vbext_ComponentType.vbext_ct_ClassModule, "").Build(); + + var vbe = builder.AddProject(proj1).AddProject(proj2).Build(); + vbe.Setup(s => s.ActiveCodePane).Returns(proj1.Object.VBComponents.Item(0).CodeModule.CodePane); + + var mockHost = new Mock(); + mockHost.SetupAllProperties(); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + + parser.Parse(new CancellationTokenSource()); + if (parser.State.Status >= ParserState.Error) + { + Assert.Inconclusive("Parser Error"); + } + + var extractInterfaceCommand = new RefactorExtractInterfaceCommand(vbe.Object, parser.State, null); + Assert.IsTrue(extractInterfaceCommand.CanExecute(null)); + } + + [TestMethod] + public void ExtractInterface_CanExecute_Proc() + { + var input = +@"Sub foo() +End Sub"; + + var builder = new MockVbeBuilder(); + VBComponent component; + var vbe = builder.BuildFromSingleModule(input, vbext_ComponentType.vbext_ct_ClassModule, out component, new Selection()); + var mockHost = new Mock(); + mockHost.SetupAllProperties(); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + + parser.Parse(new CancellationTokenSource()); + if (parser.State.Status >= ParserState.Error) + { + Assert.Inconclusive("Parser Error"); + } + + var extractInterfaceCommand = new RefactorExtractInterfaceCommand(vbe.Object, parser.State, null); + Assert.IsTrue(extractInterfaceCommand.CanExecute(null)); + } + + [TestMethod] + public void ExtractInterface_CanExecute_Function() + { + var input = +@"Function foo() As Integer +End Function"; + + var builder = new MockVbeBuilder(); + VBComponent component; + var vbe = builder.BuildFromSingleModule(input, vbext_ComponentType.vbext_ct_ClassModule, out component, new Selection()); + var mockHost = new Mock(); + mockHost.SetupAllProperties(); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + + parser.Parse(new CancellationTokenSource()); + if (parser.State.Status >= ParserState.Error) + { + Assert.Inconclusive("Parser Error"); + } + + var extractInterfaceCommand = new RefactorExtractInterfaceCommand(vbe.Object, parser.State, null); + Assert.IsTrue(extractInterfaceCommand.CanExecute(null)); + } + + [TestMethod] + public void ExtractInterface_CanExecute_PropertyGet() + { + var input = +@"Property Get foo() As Boolean +End Property"; + + var builder = new MockVbeBuilder(); + VBComponent component; + var vbe = builder.BuildFromSingleModule(input, vbext_ComponentType.vbext_ct_ClassModule, out component, new Selection()); + var mockHost = new Mock(); + mockHost.SetupAllProperties(); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + + parser.Parse(new CancellationTokenSource()); + if (parser.State.Status >= ParserState.Error) + { + Assert.Inconclusive("Parser Error"); + } + + var extractInterfaceCommand = new RefactorExtractInterfaceCommand(vbe.Object, parser.State, null); + Assert.IsTrue(extractInterfaceCommand.CanExecute(null)); + } + + [TestMethod] + public void ExtractInterface_CanExecute_PropertyLet() + { + var input = +@"Property Let foo(value) +End Property"; + + var builder = new MockVbeBuilder(); + VBComponent component; + var vbe = builder.BuildFromSingleModule(input, vbext_ComponentType.vbext_ct_ClassModule, out component, new Selection()); + var mockHost = new Mock(); + mockHost.SetupAllProperties(); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + + parser.Parse(new CancellationTokenSource()); + if (parser.State.Status >= ParserState.Error) + { + Assert.Inconclusive("Parser Error"); + } + + var extractInterfaceCommand = new RefactorExtractInterfaceCommand(vbe.Object, parser.State, null); + Assert.IsTrue(extractInterfaceCommand.CanExecute(null)); + } + + [TestMethod] + public void ExtractInterface_CanExecute_PropertySet() + { + var input = +@"Property Set foo(value) +End Property"; + + var builder = new MockVbeBuilder(); + VBComponent component; + var vbe = builder.BuildFromSingleModule(input, vbext_ComponentType.vbext_ct_ClassModule, out component, new Selection()); + var mockHost = new Mock(); + mockHost.SetupAllProperties(); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + + parser.Parse(new CancellationTokenSource()); + if (parser.State.Status >= ParserState.Error) + { + Assert.Inconclusive("Parser Error"); + } + + var extractInterfaceCommand = new RefactorExtractInterfaceCommand(vbe.Object, parser.State, null); + Assert.IsTrue(extractInterfaceCommand.CanExecute(null)); + } + + [TestMethod] + public void ImplementInterface_CanExecute_NullActiveCodePane() + { + var builder = new MockVbeBuilder(); + VBComponent component; + var vbe = builder.BuildFromSingleStandardModule("", out component); + vbe.Setup(v => v.ActiveCodePane).Returns((CodePane)null); + var mockHost = new Mock(); + mockHost.SetupAllProperties(); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + + parser.Parse(new CancellationTokenSource()); + if (parser.State.Status >= ParserState.Error) + { + Assert.Inconclusive("Parser Error"); + } + + var implementInterfaceCommand = new RefactorImplementInterfaceCommand(vbe.Object, parser.State); + Assert.IsFalse(implementInterfaceCommand.CanExecute(null)); + } + + [TestMethod] + public void ImplementInterface_CanExecute_NonReadyState() + { + var builder = new MockVbeBuilder(); + VBComponent component; + var vbe = builder.BuildFromSingleStandardModule("", out component); + var mockHost = new Mock(); + mockHost.SetupAllProperties(); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + + parser.Parse(new CancellationTokenSource()); + if (parser.State.Status >= ParserState.Error) + { + Assert.Inconclusive("Parser Error"); + } + parser.State.SetStatusAndFireStateChanged(ParserState.ResolvedDeclarations); + + var implementInterfaceCommand = new RefactorImplementInterfaceCommand(vbe.Object, parser.State); + Assert.IsFalse(implementInterfaceCommand.CanExecute(null)); + } + + [TestMethod] + public void ImplementInterface_CanExecute_ImplementsInterfaceNotSelected() + { + var builder = new MockVbeBuilder(); + VBComponent component; + var vbe = builder.BuildFromSingleModule("", vbext_ComponentType.vbext_ct_ClassModule, out component, new Selection()); + var mockHost = new Mock(); + mockHost.SetupAllProperties(); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + + parser.Parse(new CancellationTokenSource()); + if (parser.State.Status >= ParserState.Error) + { + Assert.Inconclusive("Parser Error"); + } + + var implementInterfaceCommand = new RefactorImplementInterfaceCommand(vbe.Object, parser.State); + Assert.IsFalse(implementInterfaceCommand.CanExecute(null)); + } + + [TestMethod] + public void ImplementInterface_CanExecute_ImplementsInterfaceSelected() + { + var builder = new MockVbeBuilder(); + var project = builder.ProjectBuilder("TestProject", vbext_ProjectProtection.vbext_pp_none) + .AddComponent("IClass1", vbext_ComponentType.vbext_ct_ClassModule, "") + .AddComponent("Class1", vbext_ComponentType.vbext_ct_ClassModule, "Implements IClass1", Selection.Home) + .Build(); + + var vbe = builder.AddProject(project).Build(); + var mockHost = new Mock(); + mockHost.SetupAllProperties(); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + + parser.Parse(new CancellationTokenSource()); + if (parser.State.Status >= ParserState.Error) + { + Assert.Inconclusive("Parser Error"); + } + + var implementInterfaceCommand = new RefactorImplementInterfaceCommand(vbe.Object, parser.State); + Assert.IsTrue(implementInterfaceCommand.CanExecute(null)); + } + + [TestMethod] + public void IntroduceField_CanExecute_NullActiveCodePane() + { + var builder = new MockVbeBuilder(); + VBComponent component; + var vbe = builder.BuildFromSingleStandardModule("", out component); + vbe.Setup(v => v.ActiveCodePane).Returns((CodePane)null); + var mockHost = new Mock(); + mockHost.SetupAllProperties(); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + + parser.Parse(new CancellationTokenSource()); + if (parser.State.Status >= ParserState.Error) + { + Assert.Inconclusive("Parser Error"); + } + + var introduceFieldCommand = new RefactorIntroduceFieldCommand(vbe.Object, parser.State); + Assert.IsFalse(introduceFieldCommand.CanExecute(null)); + } + + [TestMethod] + public void IntroduceField_CanExecute_NonReadyState() + { + var builder = new MockVbeBuilder(); + VBComponent component; + var vbe = builder.BuildFromSingleStandardModule("", out component); + var mockHost = new Mock(); + mockHost.SetupAllProperties(); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + + parser.Parse(new CancellationTokenSource()); + if (parser.State.Status >= ParserState.Error) + { + Assert.Inconclusive("Parser Error"); + } + parser.State.SetStatusAndFireStateChanged(ParserState.ResolvedDeclarations); + + var introduceFieldCommand = new RefactorIntroduceFieldCommand(vbe.Object, parser.State); + Assert.IsFalse(introduceFieldCommand.CanExecute(null)); + } + + [TestMethod] + public void IntroduceField_CanExecute_Field() + { + var builder = new MockVbeBuilder(); + VBComponent component; + var vbe = builder.BuildFromSingleStandardModule("Dim d As Boolean", out component, Selection.Home); + var mockHost = new Mock(); + mockHost.SetupAllProperties(); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + + parser.Parse(new CancellationTokenSource()); + if (parser.State.Status >= ParserState.Error) + { + Assert.Inconclusive("Parser Error"); + } + + var introduceFieldCommand = new RefactorIntroduceFieldCommand(vbe.Object, parser.State); + Assert.IsFalse(introduceFieldCommand.CanExecute(null)); + } + + [TestMethod] + public void IntroduceField_CanExecute_LocalVariable() + { + var input = +@"Property Get foo() As Boolean + Dim d As Boolean +End Property"; + + var builder = new MockVbeBuilder(); + VBComponent component; + var vbe = builder.BuildFromSingleStandardModule(input, out component, new Selection(2, 10, 2, 10)); + var mockHost = new Mock(); + mockHost.SetupAllProperties(); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + + parser.Parse(new CancellationTokenSource()); + if (parser.State.Status >= ParserState.Error) + { + Assert.Inconclusive("Parser Error"); + } + + var introduceFieldCommand = new RefactorIntroduceFieldCommand(vbe.Object, parser.State); + Assert.IsTrue(introduceFieldCommand.CanExecute(null)); + } + + [TestMethod] + public void IntroduceParameter_CanExecute_NullActiveCodePane() + { + var builder = new MockVbeBuilder(); + VBComponent component; + var vbe = builder.BuildFromSingleStandardModule("", out component); + vbe.Setup(v => v.ActiveCodePane).Returns((CodePane)null); + var mockHost = new Mock(); + mockHost.SetupAllProperties(); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + + parser.Parse(new CancellationTokenSource()); + if (parser.State.Status >= ParserState.Error) + { + Assert.Inconclusive("Parser Error"); + } + + var introduceParameterCommand = new RefactorIntroduceParameterCommand(vbe.Object, parser.State); + Assert.IsFalse(introduceParameterCommand.CanExecute(null)); + } + + [TestMethod] + public void IntroduceParameter_CanExecute_NonReadyState() + { + var builder = new MockVbeBuilder(); + VBComponent component; + var vbe = builder.BuildFromSingleStandardModule("", out component); + var mockHost = new Mock(); + mockHost.SetupAllProperties(); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + + parser.Parse(new CancellationTokenSource()); + if (parser.State.Status >= ParserState.Error) + { + Assert.Inconclusive("Parser Error"); + } + parser.State.SetStatusAndFireStateChanged(ParserState.ResolvedDeclarations); + + var introduceParameterCommand = new RefactorIntroduceParameterCommand(vbe.Object, parser.State); + Assert.IsFalse(introduceParameterCommand.CanExecute(null)); + } + + [TestMethod] + public void IntroduceParameter_CanExecute_Field() + { + var builder = new MockVbeBuilder(); + VBComponent component; + var vbe = builder.BuildFromSingleStandardModule("Dim d As Boolean", out component, Selection.Home); + var mockHost = new Mock(); + mockHost.SetupAllProperties(); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + + parser.Parse(new CancellationTokenSource()); + if (parser.State.Status >= ParserState.Error) + { + Assert.Inconclusive("Parser Error"); + } + + var introduceParameterCommand = new RefactorIntroduceParameterCommand(vbe.Object, parser.State); + Assert.IsFalse(introduceParameterCommand.CanExecute(null)); + } + + [TestMethod] + public void IntroduceParameter_CanExecute_LocalVariable() + { + var input = +@"Property Get foo() As Boolean + Dim d As Boolean +End Property"; + + var builder = new MockVbeBuilder(); + VBComponent component; + var vbe = builder.BuildFromSingleStandardModule(input, out component, new Selection(2, 10, 2, 10)); + var mockHost = new Mock(); + mockHost.SetupAllProperties(); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + + parser.Parse(new CancellationTokenSource()); + if (parser.State.Status >= ParserState.Error) + { + Assert.Inconclusive("Parser Error"); + } + + var introduceParameterCommand = new RefactorIntroduceParameterCommand(vbe.Object, parser.State); + Assert.IsTrue(introduceParameterCommand.CanExecute(null)); + } + + [TestMethod] + public void MoveCloserToUsage_CanExecute_NullActiveCodePane() + { + var builder = new MockVbeBuilder(); + VBComponent component; + var vbe = builder.BuildFromSingleStandardModule("", out component); + vbe.Setup(v => v.ActiveCodePane).Returns((CodePane)null); + var mockHost = new Mock(); + mockHost.SetupAllProperties(); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + + parser.Parse(new CancellationTokenSource()); + if (parser.State.Status >= ParserState.Error) + { + Assert.Inconclusive("Parser Error"); + } + + var moveCloserToUsageCommand = new RefactorMoveCloserToUsageCommand(vbe.Object, parser.State, null); + Assert.IsFalse(moveCloserToUsageCommand.CanExecute(null)); + } + + [TestMethod] + public void MoveCloserToUsage_CanExecute_NonReadyState() + { + var builder = new MockVbeBuilder(); + VBComponent component; + var vbe = builder.BuildFromSingleStandardModule("", out component); + var mockHost = new Mock(); + mockHost.SetupAllProperties(); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + + parser.Parse(new CancellationTokenSource()); + if (parser.State.Status >= ParserState.Error) + { + Assert.Inconclusive("Parser Error"); + } + parser.State.SetStatusAndFireStateChanged(ParserState.ResolvedDeclarations); + + var moveCloserToUsageCommand = new RefactorMoveCloserToUsageCommand(vbe.Object, parser.State, null); + Assert.IsFalse(moveCloserToUsageCommand.CanExecute(null)); + } + + [TestMethod] + public void MoveCloserToUsage_CanExecute_Field_NoReferences() + { + var builder = new MockVbeBuilder(); + VBComponent component; + var vbe = builder.BuildFromSingleStandardModule("Dim d As Boolean", out component, Selection.Home); + var mockHost = new Mock(); + mockHost.SetupAllProperties(); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + + parser.Parse(new CancellationTokenSource()); + if (parser.State.Status >= ParserState.Error) + { + Assert.Inconclusive("Parser Error"); + } + + var moveCloserToUsageCommand = new RefactorMoveCloserToUsageCommand(vbe.Object, parser.State, null); + Assert.IsFalse(moveCloserToUsageCommand.CanExecute(null)); + } + + [TestMethod] + public void MoveCloserToUsage_CanExecute_LocalVariable_NoReferences() + { + var input = +@"Property Get foo() As Boolean + Dim d As Boolean +End Property"; + + var builder = new MockVbeBuilder(); + VBComponent component; + var vbe = builder.BuildFromSingleStandardModule(input, out component, new Selection(2, 10, 2, 10)); + var mockHost = new Mock(); + mockHost.SetupAllProperties(); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + + parser.Parse(new CancellationTokenSource()); + if (parser.State.Status >= ParserState.Error) + { + Assert.Inconclusive("Parser Error"); + } + + var moveCloserToUsageCommand = new RefactorMoveCloserToUsageCommand(vbe.Object, parser.State, null); + Assert.IsFalse(moveCloserToUsageCommand.CanExecute(null)); + } + + [TestMethod] + public void MoveCloserToUsage_CanExecute_Const_NoReferences() + { + var builder = new MockVbeBuilder(); + VBComponent component; + var vbe = builder.BuildFromSingleStandardModule("Private Const const_abc = 0", out component, Selection.Home); + var mockHost = new Mock(); + mockHost.SetupAllProperties(); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + + parser.Parse(new CancellationTokenSource()); + if (parser.State.Status >= ParserState.Error) + { + Assert.Inconclusive("Parser Error"); + } + + var moveCloserToUsageCommand = new RefactorMoveCloserToUsageCommand(vbe.Object, parser.State, null); + Assert.IsFalse(moveCloserToUsageCommand.CanExecute(null)); + } + + [TestMethod] + public void MoveCloserToUsage_CanExecute_Field() + { + var input = +@"Dim d As Boolean +Sub Foo() + d = True +End Sub"; + + var builder = new MockVbeBuilder(); + VBComponent component; + var vbe = builder.BuildFromSingleStandardModule(input, out component, new Selection(1, 5, 1, 5)); + var mockHost = new Mock(); + mockHost.SetupAllProperties(); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + + parser.Parse(new CancellationTokenSource()); + if (parser.State.Status >= ParserState.Error) + { + Assert.Inconclusive("Parser Error"); + } + + var moveCloserToUsageCommand = new RefactorMoveCloserToUsageCommand(vbe.Object, parser.State, null); + Assert.IsTrue(moveCloserToUsageCommand.CanExecute(null)); + } + + [TestMethod] + public void MoveCloserToUsage_CanExecute_LocalVariable() + { + var input = +@"Property Get foo() As Boolean + Dim d As Boolean + d = True +End Property"; + + var builder = new MockVbeBuilder(); + VBComponent component; + var vbe = builder.BuildFromSingleStandardModule(input, out component, new Selection(2, 10, 2, 10)); + var mockHost = new Mock(); + mockHost.SetupAllProperties(); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + + parser.Parse(new CancellationTokenSource()); + if (parser.State.Status >= ParserState.Error) + { + Assert.Inconclusive("Parser Error"); + } + + var moveCloserToUsageCommand = new RefactorMoveCloserToUsageCommand(vbe.Object, parser.State, null); + Assert.IsTrue(moveCloserToUsageCommand.CanExecute(null)); + } + + [TestMethod] + public void MoveCloserToUsage_CanExecute_Const() + { + var input = +@"Private Const const_abc = 0 +Sub Foo() + Dim d As Integer + d = const_abc +End Sub"; + + var builder = new MockVbeBuilder(); + VBComponent component; + var vbe = builder.BuildFromSingleStandardModule(input, out component, new Selection(1, 17, 1, 17)); + var mockHost = new Mock(); + mockHost.SetupAllProperties(); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + + parser.Parse(new CancellationTokenSource()); + if (parser.State.Status >= ParserState.Error) + { + Assert.Inconclusive("Parser Error"); + } + + var moveCloserToUsageCommand = new RefactorMoveCloserToUsageCommand(vbe.Object, parser.State, null); + Assert.IsTrue(moveCloserToUsageCommand.CanExecute(null)); + } + + [TestMethod] + public void RemoveParameters_CanExecute_NullActiveCodePane() + { + var builder = new MockVbeBuilder(); + VBComponent component; + var vbe = builder.BuildFromSingleStandardModule("", out component); + vbe.Setup(v => v.ActiveCodePane).Returns((CodePane)null); + var mockHost = new Mock(); + mockHost.SetupAllProperties(); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + + parser.Parse(new CancellationTokenSource()); + if (parser.State.Status >= ParserState.Error) + { + Assert.Inconclusive("Parser Error"); + } + + var removeParametersCommand = new RefactorRemoveParametersCommand(vbe.Object, parser.State); + Assert.IsFalse(removeParametersCommand.CanExecute(null)); + } + + [TestMethod] + public void RemoveParameters_CanExecute_NonReadyState() + { + var builder = new MockVbeBuilder(); + VBComponent component; + var vbe = builder.BuildFromSingleStandardModule("", out component); + var mockHost = new Mock(); + mockHost.SetupAllProperties(); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + + parser.Parse(new CancellationTokenSource()); + if (parser.State.Status >= ParserState.Error) + { + Assert.Inconclusive("Parser Error"); + } + parser.State.SetStatusAndFireStateChanged(ParserState.ResolvedDeclarations); + + var removeParametersCommand = new RefactorRemoveParametersCommand(vbe.Object, parser.State); + Assert.IsFalse(removeParametersCommand.CanExecute(null)); + } + + [TestMethod] + public void RemoveParameters_CanExecute_Event_NoParams() + { + const string input = +@"Public Event Foo()"; + + var builder = new MockVbeBuilder(); + VBComponent component; + var vbe = builder.BuildFromSingleStandardModule(input, out component, new Selection(1, 16, 1, 16)); + var mockHost = new Mock(); + mockHost.SetupAllProperties(); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + + parser.Parse(new CancellationTokenSource()); + if (parser.State.Status >= ParserState.Error) + { + Assert.Inconclusive("Parser Error"); + } + + var removeParametersCommand = new RefactorRemoveParametersCommand(vbe.Object, parser.State); + Assert.IsFalse(removeParametersCommand.CanExecute(null)); + } + + [TestMethod] + public void RemoveParameters_CanExecute_Proc_NoParams() + { + var input = +@"Sub foo() +End Sub"; + + var builder = new MockVbeBuilder(); + VBComponent component; + var vbe = builder.BuildFromSingleStandardModule(input, out component, new Selection(1, 6, 1, 6)); + var mockHost = new Mock(); + mockHost.SetupAllProperties(); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + + parser.Parse(new CancellationTokenSource()); + if (parser.State.Status >= ParserState.Error) + { + Assert.Inconclusive("Parser Error"); + } + + var removeParametersCommand = new RefactorRemoveParametersCommand(vbe.Object, parser.State); + Assert.IsFalse(removeParametersCommand.CanExecute(null)); + } + + [TestMethod] + public void RemoveParameters_CanExecute_Function_NoParams() + { + var input = +@"Function foo() As Integer +End Function"; + + var builder = new MockVbeBuilder(); + VBComponent component; + var vbe = builder.BuildFromSingleStandardModule(input, out component, new Selection(1, 11, 1, 11)); + var mockHost = new Mock(); + mockHost.SetupAllProperties(); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + + parser.Parse(new CancellationTokenSource()); + if (parser.State.Status >= ParserState.Error) + { + Assert.Inconclusive("Parser Error"); + } + + var removeParametersCommand = new RefactorRemoveParametersCommand(vbe.Object, parser.State); + Assert.IsFalse(removeParametersCommand.CanExecute(null)); + } + + [TestMethod] + public void RemoveParameters_CanExecute_PropertyGet_NoParams() + { + var input = +@"Property Get foo() As Boolean +End Property"; + + var builder = new MockVbeBuilder(); + VBComponent component; + var vbe = builder.BuildFromSingleStandardModule(input, out component, new Selection(1, 16, 1, 16)); + var mockHost = new Mock(); + mockHost.SetupAllProperties(); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + + parser.Parse(new CancellationTokenSource()); + if (parser.State.Status >= ParserState.Error) + { + Assert.Inconclusive("Parser Error"); + } + + var removeParametersCommand = new RefactorRemoveParametersCommand(vbe.Object, parser.State); + Assert.IsFalse(removeParametersCommand.CanExecute(null)); + } + + [TestMethod] + public void RemoveParameters_CanExecute_PropertyLet_OneParam() + { + var input = +@"Property Let foo(value) +End Property"; + + var builder = new MockVbeBuilder(); + VBComponent component; + var vbe = builder.BuildFromSingleStandardModule(input, out component, new Selection(1, 16, 1, 16)); + var mockHost = new Mock(); + mockHost.SetupAllProperties(); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + + parser.Parse(new CancellationTokenSource()); + if (parser.State.Status >= ParserState.Error) + { + Assert.Inconclusive("Parser Error"); + } + + var removeParametersCommand = new RefactorRemoveParametersCommand(vbe.Object, parser.State); + Assert.IsFalse(removeParametersCommand.CanExecute(null)); + } + + [TestMethod] + public void RemoveParameters_CanExecute_PropertySet_OneParam() + { + var input = +@"Property Set foo(value) +End Property"; + + var builder = new MockVbeBuilder(); + VBComponent component; + var vbe = builder.BuildFromSingleStandardModule(input, out component, new Selection(1, 16, 1, 16)); + var mockHost = new Mock(); + mockHost.SetupAllProperties(); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + + parser.Parse(new CancellationTokenSource()); + if (parser.State.Status >= ParserState.Error) + { + Assert.Inconclusive("Parser Error"); + } + + var removeParametersCommand = new RefactorRemoveParametersCommand(vbe.Object, parser.State); + Assert.IsFalse(removeParametersCommand.CanExecute(null)); + } + + [TestMethod] + public void RemoveParameters_CanExecute_Event_OneParam() + { + const string input = +@"Public Event Foo(value)"; + + var builder = new MockVbeBuilder(); + VBComponent component; + var vbe = builder.BuildFromSingleStandardModule(input, out component, new Selection(1, 16, 1, 16)); + var mockHost = new Mock(); + mockHost.SetupAllProperties(); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + + parser.Parse(new CancellationTokenSource()); + if (parser.State.Status >= ParserState.Error) + { + Assert.Inconclusive("Parser Error"); + } + + var removeParametersCommand = new RefactorRemoveParametersCommand(vbe.Object, parser.State); + Assert.IsTrue(removeParametersCommand.CanExecute(null)); + } + + [TestMethod] + public void RemoveParameters_CanExecute_Proc_OneParam() + { + var input = +@"Sub foo(value) +End Sub"; + + var builder = new MockVbeBuilder(); + VBComponent component; + var vbe = builder.BuildFromSingleStandardModule(input, out component, new Selection(1, 6, 1, 6)); + var mockHost = new Mock(); + mockHost.SetupAllProperties(); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + + parser.Parse(new CancellationTokenSource()); + if (parser.State.Status >= ParserState.Error) + { + Assert.Inconclusive("Parser Error"); + } + + var removeParametersCommand = new RefactorRemoveParametersCommand(vbe.Object, parser.State); + Assert.IsTrue(removeParametersCommand.CanExecute(null)); + } + + [TestMethod] + public void RemoveParameters_CanExecute_Function_OneParam() + { + var input = +@"Function foo(value) As Integer +End Function"; + + var builder = new MockVbeBuilder(); + VBComponent component; + var vbe = builder.BuildFromSingleStandardModule(input, out component, new Selection(1, 11, 1, 11)); + var mockHost = new Mock(); + mockHost.SetupAllProperties(); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + + parser.Parse(new CancellationTokenSource()); + if (parser.State.Status >= ParserState.Error) + { + Assert.Inconclusive("Parser Error"); + } + + var removeParametersCommand = new RefactorRemoveParametersCommand(vbe.Object, parser.State); + Assert.IsTrue(removeParametersCommand.CanExecute(null)); + } + + [TestMethod] + public void RemoveParameters_CanExecute_PropertyGet_OneParam() + { + var input = +@"Property Get foo(value) As Boolean +End Property"; + + var builder = new MockVbeBuilder(); + VBComponent component; + var vbe = builder.BuildFromSingleStandardModule(input, out component, new Selection(1, 16, 1, 16)); + var mockHost = new Mock(); + mockHost.SetupAllProperties(); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + + parser.Parse(new CancellationTokenSource()); + if (parser.State.Status >= ParserState.Error) + { + Assert.Inconclusive("Parser Error"); + } + + var removeParametersCommand = new RefactorRemoveParametersCommand(vbe.Object, parser.State); + Assert.IsTrue(removeParametersCommand.CanExecute(null)); + } + + [TestMethod] + public void RemoveParameters_CanExecute_PropertyLet_TwoParams() + { + var input = +@"Property Let foo(value1, value2) +End Property"; + + var builder = new MockVbeBuilder(); + VBComponent component; + var vbe = builder.BuildFromSingleStandardModule(input, out component, new Selection(1, 16, 1, 16)); + var mockHost = new Mock(); + mockHost.SetupAllProperties(); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + + parser.Parse(new CancellationTokenSource()); + if (parser.State.Status >= ParserState.Error) + { + Assert.Inconclusive("Parser Error"); + } + + var removeParametersCommand = new RefactorRemoveParametersCommand(vbe.Object, parser.State); + Assert.IsTrue(removeParametersCommand.CanExecute(null)); + } + + [TestMethod] + public void RemoveParameters_CanExecute_PropertySet_TwoParams() + { + var input = +@"Property Set foo(value1, value2) +End Property"; + + var builder = new MockVbeBuilder(); + VBComponent component; + var vbe = builder.BuildFromSingleStandardModule(input, out component, new Selection(1, 16, 1, 16)); + var mockHost = new Mock(); + mockHost.SetupAllProperties(); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + + parser.Parse(new CancellationTokenSource()); + if (parser.State.Status >= ParserState.Error) + { + Assert.Inconclusive("Parser Error"); + } + + var removeParametersCommand = new RefactorRemoveParametersCommand(vbe.Object, parser.State); + Assert.IsTrue(removeParametersCommand.CanExecute(null)); + } + + [TestMethod] + public void ReorderParameters_CanExecute_NullActiveCodePane() + { + var builder = new MockVbeBuilder(); + VBComponent component; + var vbe = builder.BuildFromSingleStandardModule("", out component); + vbe.Setup(v => v.ActiveCodePane).Returns((CodePane)null); + var mockHost = new Mock(); + mockHost.SetupAllProperties(); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + + parser.Parse(new CancellationTokenSource()); + if (parser.State.Status >= ParserState.Error) + { + Assert.Inconclusive("Parser Error"); + } + + var reorderParametersCommand = new RefactorReorderParametersCommand(vbe.Object, parser.State, null); + Assert.IsFalse(reorderParametersCommand.CanExecute(null)); + } + + [TestMethod] + public void ReorderParameters_CanExecute_NonReadyState() + { + var builder = new MockVbeBuilder(); + VBComponent component; + var vbe = builder.BuildFromSingleStandardModule("", out component); + var mockHost = new Mock(); + mockHost.SetupAllProperties(); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + + parser.Parse(new CancellationTokenSource()); + if (parser.State.Status >= ParserState.Error) + { + Assert.Inconclusive("Parser Error"); + } + parser.State.SetStatusAndFireStateChanged(ParserState.ResolvedDeclarations); + + var reorderParametersCommand = new RefactorReorderParametersCommand(vbe.Object, parser.State, null); + Assert.IsFalse(reorderParametersCommand.CanExecute(null)); + } + + [TestMethod] + public void ReorderParameters_CanExecute_Event_OneParam() + { + const string input = +@"Public Event Foo(value)"; + + var builder = new MockVbeBuilder(); + VBComponent component; + var vbe = builder.BuildFromSingleStandardModule(input, out component, new Selection(1, 16, 1, 16)); + var mockHost = new Mock(); + mockHost.SetupAllProperties(); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + + parser.Parse(new CancellationTokenSource()); + if (parser.State.Status >= ParserState.Error) + { + Assert.Inconclusive("Parser Error"); + } + + var reorderParametersCommand = new RefactorReorderParametersCommand(vbe.Object, parser.State, null); + Assert.IsFalse(reorderParametersCommand.CanExecute(null)); + } + + [TestMethod] + public void ReorderParameters_CanExecute_Proc_OneParam() + { + var input = +@"Sub foo(value) +End Sub"; + + var builder = new MockVbeBuilder(); + VBComponent component; + var vbe = builder.BuildFromSingleStandardModule(input, out component, new Selection(1, 6, 1, 6)); + var mockHost = new Mock(); + mockHost.SetupAllProperties(); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + + parser.Parse(new CancellationTokenSource()); + if (parser.State.Status >= ParserState.Error) + { + Assert.Inconclusive("Parser Error"); + } + + var reorderParametersCommand = new RefactorReorderParametersCommand(vbe.Object, parser.State, null); + Assert.IsFalse(reorderParametersCommand.CanExecute(null)); + } + + [TestMethod] + public void ReorderParameters_CanExecute_Function_OneParam() + { + var input = +@"Function foo(value) As Integer +End Function"; + + var builder = new MockVbeBuilder(); + VBComponent component; + var vbe = builder.BuildFromSingleStandardModule(input, out component, new Selection(1, 11, 1, 11)); + var mockHost = new Mock(); + mockHost.SetupAllProperties(); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + + parser.Parse(new CancellationTokenSource()); + if (parser.State.Status >= ParserState.Error) + { + Assert.Inconclusive("Parser Error"); + } + + var reorderParametersCommand = new RefactorReorderParametersCommand(vbe.Object, parser.State, null); + Assert.IsFalse(reorderParametersCommand.CanExecute(null)); + } + + [TestMethod] + public void ReorderParameters_CanExecute_PropertyGet_OneParam() + { + var input = +@"Property Get foo(value) As Boolean +End Property"; + + var builder = new MockVbeBuilder(); + VBComponent component; + var vbe = builder.BuildFromSingleStandardModule(input, out component, new Selection(1, 16, 1, 16)); + var mockHost = new Mock(); + mockHost.SetupAllProperties(); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + + parser.Parse(new CancellationTokenSource()); + if (parser.State.Status >= ParserState.Error) + { + Assert.Inconclusive("Parser Error"); + } + + var reorderParametersCommand = new RefactorReorderParametersCommand(vbe.Object, parser.State, null); + Assert.IsFalse(reorderParametersCommand.CanExecute(null)); + } + + [TestMethod] + public void ReorderParameters_CanExecute_PropertyLet_TwoParams() + { + var input = +@"Property Let foo(value1, value2) +End Property"; + + var builder = new MockVbeBuilder(); + VBComponent component; + var vbe = builder.BuildFromSingleStandardModule(input, out component, new Selection(1, 16, 1, 16)); + var mockHost = new Mock(); + mockHost.SetupAllProperties(); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + + parser.Parse(new CancellationTokenSource()); + if (parser.State.Status >= ParserState.Error) + { + Assert.Inconclusive("Parser Error"); + } + + var reorderParametersCommand = new RefactorReorderParametersCommand(vbe.Object, parser.State, null); + Assert.IsFalse(reorderParametersCommand.CanExecute(null)); + } + + [TestMethod] + public void ReorderParameters_CanExecute_PropertySet_TwoParams() + { + var input = +@"Property Set foo(value1, value2) +End Property"; + + var builder = new MockVbeBuilder(); + VBComponent component; + var vbe = builder.BuildFromSingleStandardModule(input, out component, new Selection(1, 16, 1, 16)); + var mockHost = new Mock(); + mockHost.SetupAllProperties(); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + + parser.Parse(new CancellationTokenSource()); + if (parser.State.Status >= ParserState.Error) + { + Assert.Inconclusive("Parser Error"); + } + + var reorderParametersCommand = new RefactorReorderParametersCommand(vbe.Object, parser.State, null); + Assert.IsFalse(reorderParametersCommand.CanExecute(null)); + } + + [TestMethod] + public void ReorderParameters_CanExecute_Event_TwoParams() + { + const string input = +@"Public Event Foo(value1, value2)"; + + var builder = new MockVbeBuilder(); + VBComponent component; + var vbe = builder.BuildFromSingleStandardModule(input, out component, new Selection(1, 16, 1, 16)); + var mockHost = new Mock(); + mockHost.SetupAllProperties(); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + + parser.Parse(new CancellationTokenSource()); + if (parser.State.Status >= ParserState.Error) + { + Assert.Inconclusive("Parser Error"); + } + + var reorderParametersCommand = new RefactorReorderParametersCommand(vbe.Object, parser.State, null); + Assert.IsTrue(reorderParametersCommand.CanExecute(null)); + } + + [TestMethod] + public void ReorderParameters_CanExecute_Proc_TwoParams() + { + var input = +@"Sub foo(value1, value2) +End Sub"; + + var builder = new MockVbeBuilder(); + VBComponent component; + var vbe = builder.BuildFromSingleStandardModule(input, out component, new Selection(1, 6, 1, 6)); + var mockHost = new Mock(); + mockHost.SetupAllProperties(); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + + parser.Parse(new CancellationTokenSource()); + if (parser.State.Status >= ParserState.Error) + { + Assert.Inconclusive("Parser Error"); + } + + var reorderParametersCommand = new RefactorReorderParametersCommand(vbe.Object, parser.State, null); + Assert.IsTrue(reorderParametersCommand.CanExecute(null)); + } + + [TestMethod] + public void ReorderParameters_CanExecute_Function_TwoParams() + { + var input = +@"Function foo(value1, value2) As Integer +End Function"; + + var builder = new MockVbeBuilder(); + VBComponent component; + var vbe = builder.BuildFromSingleStandardModule(input, out component, new Selection(1, 11, 1, 11)); + var mockHost = new Mock(); + mockHost.SetupAllProperties(); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + + parser.Parse(new CancellationTokenSource()); + if (parser.State.Status >= ParserState.Error) + { + Assert.Inconclusive("Parser Error"); + } + + var reorderParametersCommand = new RefactorReorderParametersCommand(vbe.Object, parser.State, null); + Assert.IsTrue(reorderParametersCommand.CanExecute(null)); + } + + [TestMethod] + public void ReorderParameters_CanExecute_PropertyGet_TwoParams() + { + var input = +@"Property Get foo(value1, value2) As Boolean +End Property"; + + var builder = new MockVbeBuilder(); + VBComponent component; + var vbe = builder.BuildFromSingleStandardModule(input, out component, new Selection(1, 16, 1, 16)); + var mockHost = new Mock(); + mockHost.SetupAllProperties(); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + + parser.Parse(new CancellationTokenSource()); + if (parser.State.Status >= ParserState.Error) + { + Assert.Inconclusive("Parser Error"); + } + + var reorderParametersCommand = new RefactorReorderParametersCommand(vbe.Object, parser.State, null); + Assert.IsTrue(reorderParametersCommand.CanExecute(null)); + } + + [TestMethod] + public void ReorderParameters_CanExecute_PropertyLet_ThreeParams() + { + var input = +@"Property Let foo(value1, value2, value3) +End Property"; + + var builder = new MockVbeBuilder(); + VBComponent component; + var vbe = builder.BuildFromSingleStandardModule(input, out component, new Selection(1, 16, 1, 16)); + var mockHost = new Mock(); + mockHost.SetupAllProperties(); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + + parser.Parse(new CancellationTokenSource()); + if (parser.State.Status >= ParserState.Error) + { + Assert.Inconclusive("Parser Error"); + } + + var reorderParametersCommand = new RefactorReorderParametersCommand(vbe.Object, parser.State, null); + Assert.IsTrue(reorderParametersCommand.CanExecute(null)); + } + + [TestMethod] + public void ReorderParameters_CanExecute_PropertySet_ThreeParams() + { + var input = +@"Property Set foo(value1, value2, value3) +End Property"; + + var builder = new MockVbeBuilder(); + VBComponent component; + var vbe = builder.BuildFromSingleStandardModule(input, out component, new Selection(1, 16, 1, 16)); + var mockHost = new Mock(); + mockHost.SetupAllProperties(); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + + parser.Parse(new CancellationTokenSource()); + if (parser.State.Status >= ParserState.Error) + { + Assert.Inconclusive("Parser Error"); + } + + var reorderParametersCommand = new RefactorReorderParametersCommand(vbe.Object, parser.State, null); + Assert.IsTrue(reorderParametersCommand.CanExecute(null)); + } + } +} \ No newline at end of file diff --git a/RubberduckTests/Commands/UnitTestCommandTests.cs b/RubberduckTests/Commands/UnitTestCommandTests.cs new file mode 100644 index 0000000000..d6a5cfbdcc --- /dev/null +++ b/RubberduckTests/Commands/UnitTestCommandTests.cs @@ -0,0 +1,340 @@ +using System; +using System.Threading; +using Microsoft.Vbe.Interop; +using Microsoft.VisualStudio.TestTools.UnitTesting; +using Moq; +using Rubberduck.Parsing; +using Rubberduck.Parsing.VBA; +using Rubberduck.Settings; +using Rubberduck.UI.Command; +using Rubberduck.VBEditor.Extensions; +using Rubberduck.VBEditor.VBEHost; +using RubberduckTests.Mocks; + +namespace RubberduckTests.Commands +{ + [TestClass] + public class UnitTestCommandTests + { + [TestMethod] + public void AddsTest() + { + var input = + @"Option Explicit +Option Private Module + + +'@TestModule +Private Assert As Object +{0}"; + + var builder = new MockVbeBuilder(); + VBComponent component; + var vbe = builder.BuildFromSingleStandardModule(string.Format(input, string.Empty), out component); + var mockHost = new Mock(); + mockHost.SetupAllProperties(); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + + parser.Parse(new CancellationTokenSource()); + if (parser.State.Status >= ParserState.Error) + { + Assert.Inconclusive("Parser Error"); + } + + var addTestMethodCommand = new AddTestMethodCommand(vbe.Object, parser.State); + + addTestMethodCommand.Execute(null); + + Assert.AreEqual( + string.Format(input, + AddTestMethodCommand.TestMethodTemplate.Replace(AddTestMethodCommand.NamePlaceholder, "TestMethod1")) + + Environment.NewLine, component.CodeModule.Lines()); + } + + [TestMethod] + public void AddsTest_NullActiveCodePane() + { + var input = + @"Option Explicit +Option Private Module + + +'@TestModule +Private Assert As Object +"; + + var builder = new MockVbeBuilder(); + VBComponent component; + var vbe = builder.BuildFromSingleStandardModule(input, out component); + vbe.Setup(s => s.ActiveCodePane).Returns((CodePane)null); + var mockHost = new Mock(); + mockHost.SetupAllProperties(); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + + parser.Parse(new CancellationTokenSource()); + if (parser.State.Status >= ParserState.Error) + { + Assert.Inconclusive("Parser Error"); + } + + var addTestMethodCommand = new AddTestMethodCommand(vbe.Object, parser.State); + + addTestMethodCommand.Execute(null); + + Assert.AreEqual(input, component.CodeModule.Lines()); + } + + [TestMethod] + public void AddTest_CanExecute_NonReadyState() + { + var builder = new MockVbeBuilder(); + VBComponent component; + var vbe = builder.BuildFromSingleStandardModule("", out component); + var mockHost = new Mock(); + mockHost.SetupAllProperties(); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + + parser.Parse(new CancellationTokenSource()); + if (parser.State.Status >= ParserState.Error) + { + Assert.Inconclusive("Parser Error"); + } + parser.State.SetStatusAndFireStateChanged(ParserState.ResolvingReferences); + + var addTestMethodCommand = new AddTestMethodCommand(vbe.Object, parser.State); + Assert.IsFalse(addTestMethodCommand.CanExecute(null)); + } + + [TestMethod] + public void AddTest_CanExecute_NoTestModule() + { + var builder = new MockVbeBuilder(); + VBComponent component; + var vbe = builder.BuildFromSingleStandardModule("", out component); + var mockHost = new Mock(); + mockHost.SetupAllProperties(); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + + parser.Parse(new CancellationTokenSource()); + if (parser.State.Status >= ParserState.Error) + { + Assert.Inconclusive("Parser Error"); + } + + var addTestMethodCommand = new AddTestMethodCommand(vbe.Object, parser.State); + Assert.IsFalse(addTestMethodCommand.CanExecute(null)); + } + + [TestMethod] + public void AddTest_CanExecute() + { + var input = + @"Option Explicit +Option Private Module + + +'@TestModule +Private Assert As Object +"; + + var builder = new MockVbeBuilder(); + VBComponent component; + var vbe = builder.BuildFromSingleStandardModule(input, out component); + var mockHost = new Mock(); + mockHost.SetupAllProperties(); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + + parser.Parse(new CancellationTokenSource()); + if (parser.State.Status >= ParserState.Error) + { + Assert.Inconclusive("Parser Error"); + } + + var addTestMethodCommand = new AddTestMethodCommand(vbe.Object, parser.State); + + Assert.IsTrue(addTestMethodCommand.CanExecute(null)); + } + + [TestMethod] + public void AddsExpectedErrorTest() + { + var input = +@"Option Explicit +Option Private Module + + +'@TestModule +Private Assert As Object +{0}"; + + var builder = new MockVbeBuilder(); + VBComponent component; + var vbe = builder.BuildFromSingleStandardModule(string.Format(input, string.Empty), out component); + var mockHost = new Mock(); + mockHost.SetupAllProperties(); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + + parser.Parse(new CancellationTokenSource()); + if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } + + var addTestMethodCommand = new AddTestMethodExpectedErrorCommand(vbe.Object, parser.State); + + addTestMethodCommand.Execute(null); + + Assert.AreEqual( + string.Format(input, + AddTestMethodExpectedErrorCommand.TestMethodExpectedErrorTemplate.Replace(AddTestMethodExpectedErrorCommand.NamePlaceholder, + "TestMethod1")) + Environment.NewLine, component.CodeModule.Lines()); + } + + [TestMethod] + public void AddExpectedErrorTest_CanExecute_NonReadyState() + { + var builder = new MockVbeBuilder(); + VBComponent component; + var vbe = builder.BuildFromSingleStandardModule("", out component); + var mockHost = new Mock(); + mockHost.SetupAllProperties(); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + + parser.Parse(new CancellationTokenSource()); + if (parser.State.Status >= ParserState.Error) + { + Assert.Inconclusive("Parser Error"); + } + parser.State.SetStatusAndFireStateChanged(ParserState.ResolvingReferences); + + var addTestMethodCommand = new AddTestMethodExpectedErrorCommand(vbe.Object, parser.State); + Assert.IsFalse(addTestMethodCommand.CanExecute(null)); + } + + [TestMethod] + public void AddExpectedErrorTest_CanExecute_NoTestModule() + { + var builder = new MockVbeBuilder(); + VBComponent component; + var vbe = builder.BuildFromSingleStandardModule("", out component); + var mockHost = new Mock(); + mockHost.SetupAllProperties(); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + + parser.Parse(new CancellationTokenSource()); + if (parser.State.Status >= ParserState.Error) + { + Assert.Inconclusive("Parser Error"); + } + + var addTestMethodCommand = new AddTestMethodExpectedErrorCommand(vbe.Object, parser.State); + Assert.IsFalse(addTestMethodCommand.CanExecute(null)); + } + + [TestMethod] + public void AddExpectedErrorTest_CanExecute() + { + var input = + @"Option Explicit +Option Private Module + + +'@TestModule +Private Assert As Object +"; + + var builder = new MockVbeBuilder(); + VBComponent component; + var vbe = builder.BuildFromSingleStandardModule(input, out component); + var mockHost = new Mock(); + mockHost.SetupAllProperties(); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + + parser.Parse(new CancellationTokenSource()); + if (parser.State.Status >= ParserState.Error) + { + Assert.Inconclusive("Parser Error"); + } + + var addTestMethodCommand = new AddTestMethodExpectedErrorCommand(vbe.Object, parser.State); + Assert.IsTrue(addTestMethodCommand.CanExecute(null)); + } + + [TestMethod] + public void AddsExpectedErrorTest_NullActiveCodePane() + { + var input = +@"Option Explicit +Option Private Module + + +'@TestModule +Private Assert As Object +"; + + var builder = new MockVbeBuilder(); + VBComponent component; + var vbe = builder.BuildFromSingleStandardModule(input, out component); + vbe.Setup(s => s.ActiveCodePane).Returns((CodePane)null); + var mockHost = new Mock(); + mockHost.SetupAllProperties(); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + + parser.Parse(new CancellationTokenSource()); + if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } + + var addTestMethodCommand = new AddTestMethodExpectedErrorCommand(vbe.Object, parser.State); + addTestMethodCommand.Execute(null); + + Assert.AreEqual(input, component.CodeModule.Lines()); + } + + [TestMethod] + public void AddsTestModule() + { + var expected = @" +Option Explicit +Option Private Module + +'@TestModule +Private Assert As New Rubberduck.AssertClass + +"; + + var builder = new MockVbeBuilder(); + VBComponent component; + var vbe = builder.BuildFromSingleStandardModule("", out component); + var mockHost = new Mock(); + mockHost.SetupAllProperties(); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + + parser.Parse(new CancellationTokenSource()); + if (parser.State.Status >= ParserState.Error) + { + Assert.Inconclusive("Parser Error"); + } + + var settings = new Mock(null, null, null, null, null, null); + var config = GetUnitTestConfig(); + settings.Setup(x => x.LoadConfiguration()).Returns(config); + + var addTestModuleCommand = new AddTestModuleCommand(vbe.Object, parser.State, settings.Object); + addTestModuleCommand.Execute(null); + + // mock suite auto-assigns "TestModule1" to the first component when we create the mock + Assert.AreEqual(expected, vbe.Object.VBProjects.Item(0).VBComponents.Item("TestModule2").CodeModule.Lines()); + } + + private Configuration GetUnitTestConfig() + { + var unitTestSettings = new UnitTestSettings + { + BindingMode = BindingMode.EarlyBinding, + AssertMode = AssertMode.StrictAssert, + ModuleInit = false, + MethodInit = false, + DefaultTestStubInNewModule = false + }; + + var userSettings = new UserSettings(null, null, null, null, unitTestSettings, null); + return new Configuration(userSettings); + } + } +} \ No newline at end of file diff --git a/RubberduckTests/ConfigurationTests.cs b/RubberduckTests/ConfigurationTests.cs index d47f6fb9c8..7f77d27e7b 100644 --- a/RubberduckTests/ConfigurationTests.cs +++ b/RubberduckTests/ConfigurationTests.cs @@ -30,7 +30,7 @@ public void DefaultCodeInspectionsIsAsSpecified() inspection.SetupGet(m => m.Severity).Returns(CodeInspectionSeverity.DoNotShow); var expected = new[] { inspection.Object }; - var actual = new CodeInspectionSettings(new HashSet {new CodeInspectionSetting(inspection.Object)}).CodeInspections; + var actual = new CodeInspectionSettings(new HashSet {new CodeInspectionSetting(inspection.Object)}, new WhitelistedIdentifierSetting[] {}).CodeInspections; Assert.AreEqual(expected.Length, actual.Count); Assert.AreEqual(inspection.Object.Name, actual.First().Name); diff --git a/RubberduckTests/Grammar/ResolverTests.cs b/RubberduckTests/Grammar/ResolverTests.cs index 415a416f9b..6daf3fa62c 100644 --- a/RubberduckTests/Grammar/ResolverTests.cs +++ b/RubberduckTests/Grammar/ResolverTests.cs @@ -20,7 +20,7 @@ private RubberduckParserState Resolve(string code, vbext_ComponentType moduleTyp var builder = new MockVbeBuilder(); VBComponent component; var vbe = builder.BuildFromSingleModule(code, moduleType, out component, new Rubberduck.VBEditor.Selection()); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status == ParserState.ResolverError) @@ -48,7 +48,7 @@ private RubberduckParserState Resolve(params string[] classes) builder.AddProject(project); var vbe = builder.Build(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status == ParserState.ResolverError) @@ -76,7 +76,7 @@ private RubberduckParserState Resolve(params Tuple[ builder.AddProject(project); var vbe = builder.Build(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status == ParserState.ResolverError) @@ -2138,7 +2138,7 @@ End Sub builder.AddProject(project.Build()); var vbe = builder.Build(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status == ParserState.ResolverError) diff --git a/RubberduckTests/Grammar/VBAParserValidityTests.cs b/RubberduckTests/Grammar/VBAParserValidityTests.cs index 91697f1551..2f331e09e3 100644 --- a/RubberduckTests/Grammar/VBAParserValidityTests.cs +++ b/RubberduckTests/Grammar/VBAParserValidityTests.cs @@ -47,7 +47,7 @@ private static string Parse(string code, string filename) var vbe = builder.BuildFromSingleStandardModule(code, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var state = new RubberduckParserState(vbe.Object, new Mock().Object); + var state = new RubberduckParserState(new Mock().Object); var parser = MockParser.Create(vbe.Object, state); parser.Parse(new CancellationTokenSource()); if (parser.State.Status == ParserState.Error) { Assert.Inconclusive("Parser Error: " + filename); } diff --git a/RubberduckTests/Inspections/AssignedByValParameterInspectionTests.cs b/RubberduckTests/Inspections/AssignedByValParameterInspectionTests.cs index 4c9aded09d..2bf3ea232c 100644 --- a/RubberduckTests/Inspections/AssignedByValParameterInspectionTests.cs +++ b/RubberduckTests/Inspections/AssignedByValParameterInspectionTests.cs @@ -30,7 +30,7 @@ public void AssignedByValParameter_ReturnsResult_Sub() var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -56,7 +56,7 @@ public void AssignedByValParameter_ReturnsResult_Function() var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -83,7 +83,7 @@ public void AssignedByValParameter_ReturnsResult_MultipleParams() var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -108,7 +108,7 @@ public void AssignedByValParameter_DoesNotReturnResult() var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -135,7 +135,7 @@ Public Sub Foo(ByVal arg1 As String) var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -164,7 +164,7 @@ Dim var1 As Integer var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -197,7 +197,7 @@ public void AssignedByValParameter_QuickFixWorks() var module = project.VBComponents.Item(0).CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -233,7 +233,7 @@ Public Sub Foo(ByVal arg1 As String) var module = project.VBComponents.Item(0).CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } diff --git a/RubberduckTests/Inspections/ConstantNotUsedInspectionTests.cs b/RubberduckTests/Inspections/ConstantNotUsedInspectionTests.cs index 26687b66a7..2967397afc 100644 --- a/RubberduckTests/Inspections/ConstantNotUsedInspectionTests.cs +++ b/RubberduckTests/Inspections/ConstantNotUsedInspectionTests.cs @@ -30,7 +30,7 @@ public void ConstantNotUsed_ReturnsResult() var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -57,7 +57,7 @@ public void ConstantNotUsed_ReturnsResult_MultipleConsts() var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -89,7 +89,7 @@ Public Sub Goo(ByVal arg1 As Integer) var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -119,7 +119,7 @@ Public Sub Goo(ByVal arg1 As Integer) var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -146,7 +146,7 @@ public void ConstantNotUsed_Ignored_DoesNotReturnResult() var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -178,7 +178,7 @@ public void ConstantNotUsed_QuickFixWorks() var module = project.VBComponents.Item(0).CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -214,7 +214,7 @@ public void ConstantNotUsed_IgnoreQuickFixWorks() var module = project.VBComponents.Item(0).CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } diff --git a/RubberduckTests/Inspections/DefaultProjectNameInspectionTests.cs b/RubberduckTests/Inspections/DefaultProjectNameInspectionTests.cs index 8dea2a7780..4fd2968555 100644 --- a/RubberduckTests/Inspections/DefaultProjectNameInspectionTests.cs +++ b/RubberduckTests/Inspections/DefaultProjectNameInspectionTests.cs @@ -27,7 +27,7 @@ public void DefaultProjectName_ReturnsResult() var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -51,7 +51,7 @@ public void DefaultProjectName_DoesNotReturnResult() var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -75,7 +75,7 @@ public void DefaultProjectName_NoIgnoreQuickFix() var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } diff --git a/RubberduckTests/Inspections/EmptyStringLiteralInspectionTests.cs b/RubberduckTests/Inspections/EmptyStringLiteralInspectionTests.cs index dc8ebab0c7..4f841c7228 100644 --- a/RubberduckTests/Inspections/EmptyStringLiteralInspectionTests.cs +++ b/RubberduckTests/Inspections/EmptyStringLiteralInspectionTests.cs @@ -39,7 +39,7 @@ Public Sub Foo(ByRef arg1 As String) var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -71,7 +71,7 @@ public void EmptyStringLiteral_ReturnsResult_Assignment() var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -103,7 +103,7 @@ public void NotEmptyStringLiteral_DoesNotReturnResult() var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -136,7 +136,7 @@ public void EmptyStringLiteral_Ignored_DoesNotReturnResult() var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -175,7 +175,7 @@ public void EmptyStringLiteral_QuickFixWorks() var module = project.VBComponents.Item(0).CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -217,7 +217,7 @@ public void EmptyStringLiteral_IgnoreQuickFixWorks() var module = project.VBComponents.Item(0).CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } diff --git a/RubberduckTests/Inspections/EncapsulatePublicFieldInspectionTests.cs b/RubberduckTests/Inspections/EncapsulatePublicFieldInspectionTests.cs index 70584ae914..fd84d4c3cb 100644 --- a/RubberduckTests/Inspections/EncapsulatePublicFieldInspectionTests.cs +++ b/RubberduckTests/Inspections/EncapsulatePublicFieldInspectionTests.cs @@ -4,10 +4,8 @@ using Microsoft.VisualStudio.TestTools.UnitTesting; using Moq; using Rubberduck.Inspections; -using Rubberduck.Inspections.Rubberduck.Inspections; using Rubberduck.Parsing; using Rubberduck.Parsing.VBA; -using Rubberduck.Settings; using Rubberduck.VBEditor.Extensions; using Rubberduck.VBEditor.VBEHost; using RubberduckTests.Mocks; @@ -30,12 +28,12 @@ public void PublicField_ReturnsResult() var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } - var inspection = new EncapsulatePublicFieldInspection(parser.State); + var inspection = new EncapsulatePublicFieldInspection(parser.State, null); var inspectionResults = inspection.GetInspectionResults(); Assert.AreEqual(1, inspectionResults.Count()); @@ -56,12 +54,12 @@ public void MultiplePublicFields_ReturnMultipleResult() var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } - var inspection = new EncapsulatePublicFieldInspection(parser.State); + var inspection = new EncapsulatePublicFieldInspection(parser.State, null); var inspectionResults = inspection.GetInspectionResults(); Assert.AreEqual(3, inspectionResults.Count()); @@ -80,12 +78,12 @@ public void PrivateField_DoesNotReturnResult() var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } - var inspection = new EncapsulatePublicFieldInspection(parser.State); + var inspection = new EncapsulatePublicFieldInspection(parser.State, null); var inspectionResults = inspection.GetInspectionResults(); Assert.AreEqual(0, inspectionResults.Count()); @@ -105,12 +103,12 @@ public void PublicNonField_DoesNotReturnResult() var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } - var inspection = new EncapsulatePublicFieldInspection(parser.State); + var inspection = new EncapsulatePublicFieldInspection(parser.State, null); var inspectionResults = inspection.GetInspectionResults(); Assert.AreEqual(0, inspectionResults.Count()); @@ -130,12 +128,12 @@ public void PublicField_Ignored_DoesNotReturnResult() var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } - var inspection = new EncapsulatePublicFieldInspection(parser.State); + var inspection = new EncapsulatePublicFieldInspection(parser.State, null); var inspectionResults = inspection.GetInspectionResults(); Assert.IsFalse(inspectionResults.Any()); @@ -160,12 +158,12 @@ public void EncapsulatePublicField_IgnoreQuickFixWorks() var module = project.VBComponents.Item(0).CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } - var inspection = new EncapsulatePublicFieldInspection(parser.State); + var inspection = new EncapsulatePublicFieldInspection(parser.State, null); var inspectionResults = inspection.GetInspectionResults(); inspectionResults.First().QuickFixes.Single(s => s is IgnoreOnceQuickFix).Fix(); @@ -177,7 +175,7 @@ public void EncapsulatePublicField_IgnoreQuickFixWorks() [TestCategory("Inspections")] public void InspectionType() { - var inspection = new EncapsulatePublicFieldInspection(null); + var inspection = new EncapsulatePublicFieldInspection(null, null); Assert.AreEqual(CodeInspectionType.MaintainabilityAndReadabilityIssues, inspection.InspectionType); } @@ -186,7 +184,7 @@ public void InspectionType() public void InspectionName() { const string inspectionName = "EncapsulatePublicFieldInspection"; - var inspection = new EncapsulatePublicFieldInspection(null); + var inspection = new EncapsulatePublicFieldInspection(null, null); Assert.AreEqual(inspectionName, inspection.Name); } diff --git a/RubberduckTests/Inspections/FunctionReturnValueNotUsedInspectionTests.cs b/RubberduckTests/Inspections/FunctionReturnValueNotUsedInspectionTests.cs index d622a3e5f1..c3e0ac24ab 100644 --- a/RubberduckTests/Inspections/FunctionReturnValueNotUsedInspectionTests.cs +++ b/RubberduckTests/Inspections/FunctionReturnValueNotUsedInspectionTests.cs @@ -31,7 +31,7 @@ Call Foo(""Test"") var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -58,7 +58,7 @@ Public Sub Bar() var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -85,7 +85,7 @@ Bar AddressOf Foo var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -111,7 +111,7 @@ Public Sub Bar() var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -139,7 +139,7 @@ Bar AddressOf Foo var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -167,7 +167,7 @@ Foo Foo(Foo(""Bar"")) var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -196,7 +196,7 @@ End If var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -227,7 +227,7 @@ Next Bar var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -258,7 +258,7 @@ While Foo var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -289,7 +289,7 @@ Do Until Foo var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -317,7 +317,7 @@ Public Sub Baz() var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -347,7 +347,7 @@ Bar Foo(""Test"") var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -373,7 +373,7 @@ public void FunctionReturnValueNotUsed_DoesNotReturnResult_IgnoresBuiltInFunctio var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -415,7 +415,7 @@ Dim result As Integer var vbe = projectBuilder.MockVbeBuilder().Build(); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -456,7 +456,7 @@ Dim testObj As IFoo var vbe = projectBuilder.MockVbeBuilder().Build(); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -483,8 +483,54 @@ End If const string expectedCode = @"Public Sub Foo(ByVal bar As String) If True Then -Else -End If + Else + End If +End Sub"; + + //Arrange + var builder = new MockVbeBuilder(); + VBComponent component; + var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); + var project = vbe.Object.VBProjects.Item(0); + var module = project.VBComponents.Item(0).CodeModule; + var mockHost = new Mock(); + mockHost.SetupAllProperties(); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + + parser.Parse(new CancellationTokenSource()); + if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } + + var inspection = new FunctionReturnValueNotUsedInspection(parser.State); + var inspectionResults = inspection.GetInspectionResults(); + + inspectionResults.First().QuickFixes.First().Fix(); + + string actual = module.Lines(); + Assert.AreEqual(expectedCode, actual); + } + + [TestMethod] + public void FunctionReturnValueNotUsed_QuickFixWorks_NoInterface_ManyBodyStatements() + { + const string inputCode = +@"Function foo(ByRef fizz As Boolean) As Boolean + fizz = True + goo +label1: + foo = fizz +End Function + +Sub goo() +End Sub"; + + const string expectedCode = +@"Sub foo(ByRef fizz As Boolean) + fizz = True + goo +label1: +End Sub + +Sub goo() End Sub"; //Arrange @@ -495,7 +541,7 @@ End If var module = project.VBComponents.Item(0).CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -550,7 +596,7 @@ Dim testObj As IFoo var vbe = projectBuilder.MockVbeBuilder().Build(); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -594,7 +640,7 @@ Public Sub Goo() var module = project.VBComponents.Item(0).CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } diff --git a/RubberduckTests/Inspections/ImplicitActiveSheetReferenceInspectionTests.cs b/RubberduckTests/Inspections/ImplicitActiveSheetReferenceInspectionTests.cs index 1e0b318e2b..3f6a9d99c9 100644 --- a/RubberduckTests/Inspections/ImplicitActiveSheetReferenceInspectionTests.cs +++ b/RubberduckTests/Inspections/ImplicitActiveSheetReferenceInspectionTests.cs @@ -41,7 +41,7 @@ End Sub var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); GetExcelRangeDeclarations().ForEach(d => parser.State.AddDeclaration(d)); @@ -78,7 +78,7 @@ End Sub var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); GetExcelRangeDeclarations().ForEach(d => parser.State.AddDeclaration(d)); @@ -119,7 +119,7 @@ Dim arr1() As Variant var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); GetExcelRangeDeclarations().ForEach(d => parser.State.AddDeclaration(d)); diff --git a/RubberduckTests/Inspections/ImplicitByRefParameterInspectionTests.cs b/RubberduckTests/Inspections/ImplicitByRefParameterInspectionTests.cs index eae0b9057d..ed2ad3b76c 100644 --- a/RubberduckTests/Inspections/ImplicitByRefParameterInspectionTests.cs +++ b/RubberduckTests/Inspections/ImplicitByRefParameterInspectionTests.cs @@ -29,7 +29,7 @@ public void ImplicitByRefParameter_ReturnsResult() var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -54,7 +54,7 @@ public void ImplicitByRefParameter_ReturnsResult_MultipleParams() var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -79,7 +79,7 @@ public void ImplicitByRefParameter_DoesNotReturnResult_ByRef() var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -104,7 +104,7 @@ public void ImplicitByRefParameter_DoesNotReturnResult_ByVal() var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -129,7 +129,7 @@ public void ImplicitByRefParameter_DoesNotReturnResult_ParamArray() var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -154,7 +154,7 @@ public void ImplicitByRefParameter_ReturnsResult_SomePassedByRefImplicitely() var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -189,7 +189,7 @@ Sub IClass1_Foo(arg1 As Integer) var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -215,7 +215,7 @@ Sub Foo(arg1 As Integer) var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -246,7 +246,7 @@ public void ImplicitByRefParameter_QuickFixWorks_PassByRef() var module = project.VBComponents.Item(0).CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -280,7 +280,7 @@ Sub Foo(arg1 As Integer) var module = project.VBComponents.Item(0).CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } diff --git a/RubberduckTests/Inspections/ImplicitPublicMemberInspectionTests.cs b/RubberduckTests/Inspections/ImplicitPublicMemberInspectionTests.cs index d3a4a0c647..9e624db9a7 100644 --- a/RubberduckTests/Inspections/ImplicitPublicMemberInspectionTests.cs +++ b/RubberduckTests/Inspections/ImplicitPublicMemberInspectionTests.cs @@ -30,7 +30,7 @@ End Sub var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -56,7 +56,7 @@ public void ImplicitPublicMember_ReturnsResult_Function() var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -84,7 +84,7 @@ Sub Goo() var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -109,7 +109,7 @@ public void ImplicitPublicMember_DoesNotReturnResult() var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -136,7 +136,7 @@ End Sub var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -164,7 +164,7 @@ Sub Goo() var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -199,7 +199,7 @@ public void ImplicitPublicMember_QuickFixWorks() var module = project.VBComponents.Item(0).CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -237,7 +237,7 @@ Sub Foo(ByVal arg1 as Integer) var module = project.VBComponents.Item(0).CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } diff --git a/RubberduckTests/Inspections/ImplicitVariantReturnTypeInspectionTests.cs b/RubberduckTests/Inspections/ImplicitVariantReturnTypeInspectionTests.cs index 3e65d132d5..d8cbd533ce 100644 --- a/RubberduckTests/Inspections/ImplicitVariantReturnTypeInspectionTests.cs +++ b/RubberduckTests/Inspections/ImplicitVariantReturnTypeInspectionTests.cs @@ -29,7 +29,7 @@ public void ImplicitVariantReturnType_ReturnsResult_Function() var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -63,7 +63,7 @@ public void ImplicitVariantReturnType_ReturnsResult_LibraryFunction() var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -97,7 +97,7 @@ public void ImplicitVariantReturnType_DoesNotReturnResult_LibraryFunction() var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -122,7 +122,7 @@ public void ImplicitVariantReturnType_ReturnsResult_PropertyGet() var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -150,7 +150,7 @@ Function Goo() var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -175,7 +175,7 @@ public void ImplicitVariantReturnType_DoesNotReturnResult() var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -203,7 +203,7 @@ Function Goo() As String var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -229,7 +229,7 @@ Function Foo() var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -260,7 +260,7 @@ public void ImplicitVariantReturnType_QuickFixWorks_Function() var module = project.VBComponents.Item(0).CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -293,7 +293,7 @@ public void ImplicitVariantReturnType_QuickFixWorks_PropertyGet() var module = project.VBComponents.Item(0).CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -344,7 +344,7 @@ public void ImplicitVariantReturnType_QuickFixWorks_LibraryFunction() var module = project.VBComponents.Item(0).CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -377,7 +377,7 @@ public void ImplicitVariantReturnType_QuickFixWorks_Function_HasComment() var module = project.VBComponents.Item(0).CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -411,7 +411,7 @@ Function Foo() var module = project.VBComponents.Item(0).CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } diff --git a/RubberduckTests/Inspections/MalformedAnnotationInspectionTests.cs b/RubberduckTests/Inspections/MalformedAnnotationInspectionTests.cs index c1fd110d5c..387132affe 100644 --- a/RubberduckTests/Inspections/MalformedAnnotationInspectionTests.cs +++ b/RubberduckTests/Inspections/MalformedAnnotationInspectionTests.cs @@ -33,7 +33,7 @@ public void MalformedAnnotation_ReturnsResult_Folder() var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -63,7 +63,7 @@ public void MalformedAnnotation_DoesNotReturnResult_Folder() var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -93,7 +93,7 @@ public void MalformedAnnotation_ReturnsResult_Ignore() var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -123,7 +123,7 @@ public void MalformedAnnotation_DoesNotReturnResult_Ignore() var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -154,7 +154,7 @@ public void MalformedAnnotation_ReturnsMultipleResults() var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -188,7 +188,7 @@ public void MalformedAnnotation_NoIgnoreQuickFix() var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } diff --git a/RubberduckTests/Inspections/MoveFieldCloserToUsageInspectionTests.cs b/RubberduckTests/Inspections/MoveFieldCloserToUsageInspectionTests.cs index 5452587bec..773f29f490 100644 --- a/RubberduckTests/Inspections/MoveFieldCloserToUsageInspectionTests.cs +++ b/RubberduckTests/Inspections/MoveFieldCloserToUsageInspectionTests.cs @@ -31,7 +31,7 @@ Public Sub Foo() var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -61,7 +61,7 @@ Public Sub For2() var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -88,7 +88,7 @@ Dim bar As String var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -114,7 +114,7 @@ Public Sub Foo() var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -141,7 +141,7 @@ Public Property Get Foo() As String var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -171,7 +171,7 @@ Public Property Let Foo(ByVal value As String) var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -201,7 +201,7 @@ Public Property Set Foo(ByVal value As Variant) var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -229,7 +229,7 @@ Public Sub Foo() var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -264,7 +264,7 @@ Public Sub Foo() var module = vbe.Object.VBProjects.Item(0).VBComponents.Item(0).CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -302,7 +302,7 @@ Dim bar As String var module = project.VBComponents.Item(0).CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } diff --git a/RubberduckTests/Inspections/MultilineParameterInspectionTests.cs b/RubberduckTests/Inspections/MultilineParameterInspectionTests.cs index 419316a3fc..8faac6a050 100644 --- a/RubberduckTests/Inspections/MultilineParameterInspectionTests.cs +++ b/RubberduckTests/Inspections/MultilineParameterInspectionTests.cs @@ -32,7 +32,7 @@ As _ var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -57,7 +57,7 @@ public void MultilineParameter_DoesNotReturnResult() var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -90,7 +90,7 @@ As _ var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -118,7 +118,7 @@ As _ var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -147,7 +147,7 @@ As _ var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -183,7 +183,7 @@ As _ var module = project.VBComponents.Item(0).CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -225,7 +225,7 @@ As _ var module = project.VBComponents.Item(0).CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } diff --git a/RubberduckTests/Inspections/MultipleDeclarationsInspectionTests.cs b/RubberduckTests/Inspections/MultipleDeclarationsInspectionTests.cs index b01b5dffc1..a82db7fd79 100644 --- a/RubberduckTests/Inspections/MultipleDeclarationsInspectionTests.cs +++ b/RubberduckTests/Inspections/MultipleDeclarationsInspectionTests.cs @@ -30,7 +30,7 @@ public void MultipleDeclarations_ReturnsResult_Variables() var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -56,7 +56,7 @@ public void MultipleDeclarations_ReturnsResult_Constants() var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -82,7 +82,7 @@ public void MultipleDeclarations_ReturnsResult_StaticVariables() var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -109,7 +109,7 @@ public void MultipleDeclarations_ReturnsResult_MultipleDeclarations() var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -136,7 +136,7 @@ Dim var3 As Boolean var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -163,7 +163,7 @@ public void MultipleDeclarations_Ignore_DoesNotReturnResult_Variables() var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -198,7 +198,7 @@ Dim var2 As String var module = project.VBComponents.Item(0).CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -235,7 +235,7 @@ public void MultipleDeclarations_QuickFixWorks_Constants() var module = project.VBComponents.Item(0).CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -272,7 +272,7 @@ Static var2 As String var module = project.VBComponents.Item(0).CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -308,7 +308,7 @@ public void MultipleDeclarations_IgnoreQuickFixWorks() var module = project.VBComponents.Item(0).CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } diff --git a/RubberduckTests/Inspections/MultipleFolderAnnotationsInspectionTests.cs b/RubberduckTests/Inspections/MultipleFolderAnnotationsInspectionTests.cs index a5c20256c3..338c282027 100644 --- a/RubberduckTests/Inspections/MultipleFolderAnnotationsInspectionTests.cs +++ b/RubberduckTests/Inspections/MultipleFolderAnnotationsInspectionTests.cs @@ -29,7 +29,7 @@ public void NoFolderAnnotation_NoResult() var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -56,7 +56,7 @@ Public Sub Foo() var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -84,7 +84,7 @@ Public Sub Foo() var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -115,7 +115,7 @@ Public Sub Foo() var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } diff --git a/RubberduckTests/Inspections/NonReturningFunctionInspectionTests.cs b/RubberduckTests/Inspections/NonReturningFunctionInspectionTests.cs index 09b76c4ac8..6f7931d2a3 100644 --- a/RubberduckTests/Inspections/NonReturningFunctionInspectionTests.cs +++ b/RubberduckTests/Inspections/NonReturningFunctionInspectionTests.cs @@ -29,7 +29,7 @@ public void NonReturningFunction_ReturnsResult() var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -54,7 +54,7 @@ public void NonReturningPropertyGet_ReturnsResult() var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -82,7 +82,7 @@ Function Goo() As String var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -108,7 +108,7 @@ public void NonReturningFunction_DoesNotReturnResult() var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -134,7 +134,7 @@ Function Foo() As Boolean var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -163,7 +163,7 @@ Function Goo() As String var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -198,7 +198,7 @@ Function IClass1_Foo() As Boolean var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -229,7 +229,7 @@ public void NonReturningFunction_QuickFixWorks_Function() var module = project.VBComponents.Item(0).CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -262,7 +262,7 @@ public void GivenFunctionNameWithTypeHint_SubNameHasNoTypeHint() var module = project.VBComponents.Item(0).CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -295,7 +295,7 @@ public void NonReturningFunction_QuickFixWorks_FunctionReturnsImplicitVariant() var module = project.VBComponents.Item(0).CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -328,7 +328,7 @@ public void NonReturningFunction_QuickFixWorks_FunctionHasVariable() var module = project.VBComponents.Item(0).CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -361,7 +361,7 @@ public void GivenNonReturningPropertyGetter_QuickFixConvertsToSub() var module = project.VBComponents.Item(0).CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -394,7 +394,7 @@ public void GivenNonReturningPropertyGetWithTypeHint_QuickFixDropsTypeHint() var module = project.VBComponents.Item(0).CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -427,7 +427,7 @@ public void GivenImplicitVariantPropertyGetter_StillConvertsToSub() var module = project.VBComponents.Item(0).CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -460,7 +460,7 @@ public void GivenParameterizedPropertyGetter_QuickFixKeepsParameter() var module = project.VBComponents.Item(0).CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -497,7 +497,7 @@ Function IClass1_Foo() As Boolean var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -529,7 +529,7 @@ Function Foo() As Boolean var module = project.VBComponents.Item(0).CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } diff --git a/RubberduckTests/Inspections/ObjectVariableNotSetInpsectionTests.cs b/RubberduckTests/Inspections/ObjectVariableNotSetInpsectionTests.cs index 3b36f34cca..4289b979ef 100644 --- a/RubberduckTests/Inspections/ObjectVariableNotSetInpsectionTests.cs +++ b/RubberduckTests/Inspections/ObjectVariableNotSetInpsectionTests.cs @@ -35,7 +35,7 @@ Dim target As String var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -66,7 +66,7 @@ Dim target As Variant var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -97,7 +97,7 @@ Dim target As Range var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -129,7 +129,7 @@ Dim target As Range var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -160,7 +160,7 @@ Dim target As Range var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -203,7 +203,7 @@ Dim target As Range var module = vbe.Object.VBProjects.Item(0).VBComponents.Item(0).CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } diff --git a/RubberduckTests/Inspections/ObsoleteCallStatementInspectionTests.cs b/RubberduckTests/Inspections/ObsoleteCallStatementInspectionTests.cs index 16468cbd40..699ed9b2ef 100644 --- a/RubberduckTests/Inspections/ObsoleteCallStatementInspectionTests.cs +++ b/RubberduckTests/Inspections/ObsoleteCallStatementInspectionTests.cs @@ -36,7 +36,7 @@ Call Foo var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -68,7 +68,7 @@ public void ObsoleteCallStatement_DoesNotReturnResult() var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -100,7 +100,7 @@ public void ObsoleteCallStatement_DoesNotReturnResult_InstructionSeparator() var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -132,7 +132,7 @@ public void ObsoleteCallStatement_ReturnsResult_ColonInComment() var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -164,7 +164,7 @@ Call Foo("":"") var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -200,7 +200,7 @@ Call Foo var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -236,7 +236,7 @@ Sub Goo(arg1 As Integer, arg1 As String) var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -269,7 +269,7 @@ Call Foo var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -316,7 +316,7 @@ Sub Goo(arg1 As Integer, arg1 As String) var module = project.VBComponents.Item(0).CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -371,7 +371,7 @@ Call Foo var module = project.VBComponents.Item(0).CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } diff --git a/RubberduckTests/Inspections/ObsoleteCommentSyntaxInspectionTests.cs b/RubberduckTests/Inspections/ObsoleteCommentSyntaxInspectionTests.cs index 5888117f13..84bd7e7258 100644 --- a/RubberduckTests/Inspections/ObsoleteCommentSyntaxInspectionTests.cs +++ b/RubberduckTests/Inspections/ObsoleteCommentSyntaxInspectionTests.cs @@ -27,7 +27,7 @@ public void ObsoleteCommentSyntax_ReturnsResult() var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -50,7 +50,34 @@ public void ObsoleteCommentSyntax_DoesNotReturnResult() var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + + parser.Parse(new CancellationTokenSource()); + if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } + + var inspection = new ObsoleteCommentSyntaxInspection(parser.State); + var inspectionResults = inspection.GetInspectionResults(); + + Assert.AreEqual(0, inspectionResults.Count()); + } + + [TestMethod] + [TestCategory("Inspections")] + public void ObsoleteCommentSyntax_DoesNotReturnResult_RemInStringLiteral() + { + const string inputCode = +@"Sub Foo() + Dim bar As String + bar = ""iejo rem oernp"" ' test +End Sub"; + + //Arrange + var builder = new MockVbeBuilder(); + VBComponent component; + var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); + var mockHost = new Mock(); + mockHost.SetupAllProperties(); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -75,7 +102,7 @@ public void ObsoleteCommentSyntax_ReturnsMultipleResults() var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -100,7 +127,7 @@ public void ObsoleteCommentSyntax_ReturnsResults_SomeObsoleteCommentSyntax() var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -125,7 +152,7 @@ public void ObsoleteCommentSyntax_Ignored_DoesNotReturnResult() var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -154,7 +181,7 @@ public void ObsoleteCommentSyntax_QuickFixWorks_UpdateComment() var module = project.VBComponents.Item(0).CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -185,7 +212,69 @@ public void ObsoleteCommentSyntax_QuickFixWorks_RemoveComment() var module = project.VBComponents.Item(0).CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + + parser.Parse(new CancellationTokenSource()); + if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } + + var inspection = new ObsoleteCommentSyntaxInspection(parser.State); + var inspectionResults = inspection.GetInspectionResults(); + + inspectionResults.First().QuickFixes.ElementAt(1).Fix(); + + Assert.AreEqual(expectedCode, module.Lines()); + } + + [TestMethod] + [TestCategory("Inspections")] + public void ObsoleteCommentSyntax_QuickFixWorks_UpdateComment_LineHasCode() + { + const string inputCode = +@"Dim Foo As Integer: Rem This is a comment"; + + const string expectedCode = +@"Dim Foo As Integer: ' This is a comment"; + + //Arrange + var builder = new MockVbeBuilder(); + VBComponent component; + var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); + var project = vbe.Object.VBProjects.Item(0); + var module = project.VBComponents.Item(0).CodeModule; + var mockHost = new Mock(); + mockHost.SetupAllProperties(); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + + parser.Parse(new CancellationTokenSource()); + if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } + + var inspection = new ObsoleteCommentSyntaxInspection(parser.State); + var inspectionResults = inspection.GetInspectionResults(); + + inspectionResults.First().QuickFixes.First().Fix(); + + Assert.AreEqual(expectedCode, module.Lines()); + } + + [TestMethod] + [TestCategory("Inspections")] + public void ObsoleteCommentSyntax_QuickFixWorks_RemoveComment_LineHasCode() + { + const string inputCode = +@"Dim Foo As Integer: Rem This is a comment"; + + const string expectedCode = +@"Dim Foo As Integer:"; + + //Arrange + var builder = new MockVbeBuilder(); + VBComponent component; + var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); + var project = vbe.Object.VBProjects.Item(0); + var module = project.VBComponents.Item(0).CodeModule; + var mockHost = new Mock(); + mockHost.SetupAllProperties(); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -217,7 +306,7 @@ public void ObsoleteCommentSyntax_IgnoreQuickFixWorks() var module = project.VBComponents.Item(0).CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } diff --git a/RubberduckTests/Inspections/ObsoleteGlobalInspectionTests.cs b/RubberduckTests/Inspections/ObsoleteGlobalInspectionTests.cs index 8ace258663..804bd90665 100644 --- a/RubberduckTests/Inspections/ObsoleteGlobalInspectionTests.cs +++ b/RubberduckTests/Inspections/ObsoleteGlobalInspectionTests.cs @@ -28,7 +28,7 @@ public void ObsoleteGlobal_ReturnsResult() var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -53,7 +53,7 @@ public void ObsoleteGlobal_ReturnsResult_MultipleGlobals() var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -77,7 +77,7 @@ public void ObsoleteGlobal_DoesNotReturnResult() var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -102,7 +102,7 @@ public void ObsoleteGlobal_ReturnsResult_SomeConstantsUsed() var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -127,7 +127,7 @@ public void ObsoleteGlobal_Ignored_DoesNotReturnResult() var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -156,7 +156,7 @@ public void ObsoleteGlobal_QuickFixWorks() var module = project.VBComponents.Item(0).CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -188,7 +188,7 @@ public void ObsoleteGlobal_IgnoreQuickFixWorks() var module = project.VBComponents.Item(0).CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } diff --git a/RubberduckTests/Inspections/ObsoleteLetStatementInspectionTests.cs b/RubberduckTests/Inspections/ObsoleteLetStatementInspectionTests.cs index abf3e28ae1..d928a240cc 100644 --- a/RubberduckTests/Inspections/ObsoleteLetStatementInspectionTests.cs +++ b/RubberduckTests/Inspections/ObsoleteLetStatementInspectionTests.cs @@ -39,7 +39,7 @@ Dim var2 As Integer var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -75,7 +75,7 @@ Dim var2 As Integer var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -110,7 +110,7 @@ Dim var2 As Integer var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -146,7 +146,7 @@ Dim var2 As Integer var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -182,7 +182,7 @@ Dim var2 As Integer var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -227,7 +227,7 @@ Dim var2 As Integer var module = project.VBComponents.Item(0).CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -275,7 +275,7 @@ Dim var2 As Integer var module = project.VBComponents.Item(0).CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } diff --git a/RubberduckTests/Inspections/ObsoleteTypeHintInspectionTests.cs b/RubberduckTests/Inspections/ObsoleteTypeHintInspectionTests.cs index db34dbb43a..908961ced7 100644 --- a/RubberduckTests/Inspections/ObsoleteTypeHintInspectionTests.cs +++ b/RubberduckTests/Inspections/ObsoleteTypeHintInspectionTests.cs @@ -28,7 +28,7 @@ public void ObsoleteTypeHint_FieldWithLongTypeHintReturnsResult() var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -52,7 +52,7 @@ public void ObsoleteTypeHint_FieldWithIntegerTypeHintReturnsResult() var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -76,7 +76,7 @@ public void ObsoleteTypeHint_FieldWithDoubleTypeHintReturnsResult() var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -100,7 +100,7 @@ public void ObsoleteTypeHint_FieldWithSingleTypeHintReturnsResult() var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -124,7 +124,7 @@ public void ObsoleteTypeHint_FieldWithDecimalTypeHintReturnsResult() var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -148,7 +148,7 @@ public void ObsoleteTypeHint_FieldWithStringTypeHintReturnsResult() var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -173,7 +173,7 @@ public void ObsoleteTypeHint_FunctionReturnsResult() var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -198,7 +198,7 @@ public void ObsoleteTypeHint_PropertyGetReturnsResult() var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -223,7 +223,7 @@ public void ObsoleteTypeHint_ParameterReturnsResult() var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -250,7 +250,7 @@ Dim buzz$ var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -277,7 +277,7 @@ Dim bar As String var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -302,7 +302,7 @@ public void ObsoleteTypeHint_FieldsReturnMultipleResults() var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -328,7 +328,7 @@ public void ObsoleteTypeHint_Ignored_DoesNotReturnResult() var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -357,7 +357,7 @@ public void ObsoleteTypeHint_QuickFixWorks_Field_LongTypeHint() var module = project.VBComponents.Item(0).CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -391,7 +391,7 @@ public void ObsoleteTypeHint_QuickFixWorks_Field_IntegerTypeHint() var module = project.VBComponents.Item(0).CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -425,7 +425,7 @@ public void ObsoleteTypeHint_QuickFixWorks_Field_DoubleTypeHint() var module = project.VBComponents.Item(0).CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -459,7 +459,7 @@ public void ObsoleteTypeHint_QuickFixWorks_Field_SingleTypeHint() var module = project.VBComponents.Item(0).CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -493,7 +493,7 @@ public void ObsoleteTypeHint_QuickFixWorks_Field_DecimalTypeHint() var module = project.VBComponents.Item(0).CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -527,7 +527,7 @@ public void ObsoleteTypeHint_QuickFixWorks_Field_StringTypeHint() var module = project.VBComponents.Item(0).CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -565,7 +565,7 @@ public void ObsoleteTypeHint_QuickFixWorks_Function_StringTypeHint() var module = project.VBComponents.Item(0).CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -603,7 +603,7 @@ public void ObsoleteTypeHint_QuickFixWorks_PropertyGet_StringTypeHint() var module = project.VBComponents.Item(0).CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -641,7 +641,7 @@ public void ObsoleteTypeHint_QuickFixWorks_Parameter_StringTypeHint() var module = project.VBComponents.Item(0).CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -679,7 +679,7 @@ Dim buzz As String var module = project.VBComponents.Item(0).CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -718,7 +718,7 @@ public void ObsoleteTypeHint_IgnoreQuickFixWorks() var module = project.VBComponents.Item(0).CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } diff --git a/RubberduckTests/Inspections/OptionBaseInspectionTests.cs b/RubberduckTests/Inspections/OptionBaseInspectionTests.cs index 591675ad7f..61e48377c3 100644 --- a/RubberduckTests/Inspections/OptionBaseInspectionTests.cs +++ b/RubberduckTests/Inspections/OptionBaseInspectionTests.cs @@ -27,7 +27,7 @@ public void OptionBaseOneSpecified_ReturnsResult() var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -50,7 +50,7 @@ public void OptionBaseNotSpecified_DoesNotReturnResult() var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -73,7 +73,7 @@ public void OptionBaseZeroSpecified_DoesNotReturnResult() var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -100,7 +100,7 @@ public void OptionBaseOneSpecified_ReturnsMultipleResults() var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -128,7 +128,7 @@ public void OptionBaseOnePartiallySpecified_ReturnsResults() var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -153,7 +153,7 @@ public void OptionBaseOneSpecified_Ignored_DoesNotReturnResult() var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -182,7 +182,7 @@ public void OptionBaseOneSpecified_IgnoreQuickFixWorks() var module = vbe.Object.VBProjects.Item(0).VBComponents.Item(0).CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } diff --git a/RubberduckTests/Inspections/OptionExplicitInspectionTests.cs b/RubberduckTests/Inspections/OptionExplicitInspectionTests.cs index 103c8eea99..922f7d7a13 100644 --- a/RubberduckTests/Inspections/OptionExplicitInspectionTests.cs +++ b/RubberduckTests/Inspections/OptionExplicitInspectionTests.cs @@ -27,7 +27,7 @@ public void NotAlreadySpecified_ReturnsResult() var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -50,7 +50,7 @@ public void AlreadySpecified_DoesNotReturnResult() var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -77,7 +77,7 @@ public void NotAlreadySpecified_ReturnsMultipleResults() var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -105,7 +105,7 @@ public void PartiallySpecified_ReturnsResults() var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -134,7 +134,7 @@ public void NotAlreadySpecified_QuickFixWorks() var module = project.VBComponents.Item(0).CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -160,7 +160,7 @@ public void OptionExplicit_NoIgnoreQuickFix() var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } diff --git a/RubberduckTests/Inspections/ParameterCanBeByValInspectionTests.cs b/RubberduckTests/Inspections/ParameterCanBeByValInspectionTests.cs index dba7e02f49..0597513f3f 100644 --- a/RubberduckTests/Inspections/ParameterCanBeByValInspectionTests.cs +++ b/RubberduckTests/Inspections/ParameterCanBeByValInspectionTests.cs @@ -29,7 +29,7 @@ public void ParameterCanBeByVal_ReturnsResult_PassedByNotSpecified() var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -54,7 +54,7 @@ public void ParameterCanBeByVal_ReturnsResult_PassedByRef_Unassigned() var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -79,7 +79,7 @@ public void ParameterCanBeByVal_ReturnsResult_Multiple() var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -104,7 +104,7 @@ public void ParameterCanBeByVal_DoesNotReturnResult_PassedByValExplicitly() var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -130,7 +130,7 @@ public void ParameterCanBeByVal_DoesNotReturnResult_PassedByRefAndAssigned() var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -156,7 +156,7 @@ public void ParameterCanBeByVal_DoesNotReturnResult_BuiltInEventParam() var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -181,7 +181,7 @@ public void ParameterCanBeByVal_ReturnsResult_SomeParams() var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -206,7 +206,7 @@ public void GivenArrayParameter_ReturnsNoResult() var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -236,7 +236,7 @@ Sub DoSomethingElse(ByVal bar As Integer) var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -266,7 +266,7 @@ Sub DoSomethingElse(ByRef bar As Integer) var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -296,7 +296,7 @@ Sub DoSomethingElse(ByVal bar As Integer) var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -322,7 +322,7 @@ Sub Foo(arg1 As String) var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -358,7 +358,7 @@ Private Sub IClass1_DoSomething(ByRef a As Integer) var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -394,7 +394,7 @@ Private Sub IClass1_DoSomething(ByVal a As Integer) var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -431,7 +431,7 @@ Private Sub IClass1_DoSomething(ByRef a As Integer) var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -473,7 +473,7 @@ Private Sub IClass1_DoSomething(ByRef a As Integer, ByRef b As Integer) var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -509,7 +509,7 @@ Private Sub abc_Foo(ByRef arg1 As Integer) var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -545,7 +545,7 @@ Private Sub abc_Foo(ByVal arg1 As Integer) var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -582,7 +582,7 @@ Private Sub abc_Foo(ByRef arg1 As Integer) var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -619,7 +619,7 @@ Private Sub abc_Foo(ByRef arg1 As Integer, ByRef arg2 As Integer) var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -650,7 +650,7 @@ public void ParameterCanBeByVal_QuickFixWorks_SubNameStartsWithParamName() var module = project.VBComponents.Item(0).CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -681,7 +681,7 @@ public void ParameterCanBeByVal_QuickFixWorks_PassedByUnspecified() var module = project.VBComponents.Item(0).CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -712,7 +712,7 @@ public void ParameterCanBeByVal_QuickFixWorks_PassedByRef() var module = project.VBComponents.Item(0).CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -745,7 +745,7 @@ public void ParameterCanBeByVal_QuickFixWorks_PassedByUnspecified_MultilineParam var module = project.VBComponents.Item(0).CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -778,7 +778,7 @@ public void ParameterCanBeByVal_QuickFixWorks_PassedByRef_MultilineParameter() var module = project.VBComponents.Item(0).CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -840,7 +840,7 @@ Private Sub IClass1_DoSomething(ByVal a As Integer, ByRef b As Integer) var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -904,7 +904,7 @@ Private Sub abc_Foo(ByRef a As Integer, ByVal b As Integer) var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -942,7 +942,7 @@ Sub Foo(ByRef _ var module = project.VBComponents.Item(0).CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } diff --git a/RubberduckTests/Inspections/ParameterNotUsedInspectionTests.cs b/RubberduckTests/Inspections/ParameterNotUsedInspectionTests.cs index d7c22cf573..636d1781ef 100644 --- a/RubberduckTests/Inspections/ParameterNotUsedInspectionTests.cs +++ b/RubberduckTests/Inspections/ParameterNotUsedInspectionTests.cs @@ -29,12 +29,12 @@ public void ParameterNotUsed_ReturnsResult() var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } - var inspection = new ParameterNotUsedInspection(vbe.Object, parser.State, null); + var inspection = new ParameterNotUsedInspection(parser.State, null); var inspectionResults = inspection.GetInspectionResults(); Assert.AreEqual(1, inspectionResults.Count()); @@ -57,12 +57,12 @@ Private Sub Goo(ByVal arg1 as Integer) var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } - var inspection = new ParameterNotUsedInspection(vbe.Object, parser.State, null); + var inspection = new ParameterNotUsedInspection(parser.State, null); var inspectionResults = inspection.GetInspectionResults(); Assert.AreEqual(2, inspectionResults.Count()); @@ -83,12 +83,12 @@ public void ParameterUsed_DoesNotReturnResult() var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } - var inspection = new ParameterNotUsedInspection(vbe.Object, parser.State, null); + var inspection = new ParameterNotUsedInspection(parser.State, null); var inspectionResults = inspection.GetInspectionResults(); Assert.AreEqual(0, inspectionResults.Count()); @@ -109,12 +109,12 @@ public void ParameterNotUsed_ReturnsResult_SomeParamsUsed() var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } - var inspection = new ParameterNotUsedInspection(vbe.Object, parser.State, null); + var inspection = new ParameterNotUsedInspection(parser.State, null); var inspectionResults = inspection.GetInspectionResults(); Assert.AreEqual(1, inspectionResults.Count()); @@ -144,12 +144,12 @@ Private Sub IClass1_DoSomething(ByVal a As Integer) var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } - var inspection = new ParameterNotUsedInspection(vbe.Object, parser.State, null); + var inspection = new ParameterNotUsedInspection(parser.State, null); var inspectionResults = inspection.GetInspectionResults().ToList(); Assert.AreEqual(1, inspectionResults.Count); @@ -171,12 +171,12 @@ Private Sub Foo(ByVal arg1 as Integer) var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } - var inspection = new ParameterNotUsedInspection(vbe.Object, parser.State, null); + var inspection = new ParameterNotUsedInspection(parser.State, null); var inspectionResults = inspection.GetInspectionResults(); Assert.IsFalse(inspectionResults.Any()); @@ -202,12 +202,12 @@ public void GivenPrivateSub_DefaultQuickFixRemovesParameter() var module = project.VBComponents.Item(0).CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } - var inspection = new ParameterNotUsedInspection(vbe.Object, parser.State, null); + var inspection = new ParameterNotUsedInspection(parser.State, null); var inspectionResults = inspection.GetInspectionResults(); inspectionResults.First().QuickFixes.First().Fix(); @@ -236,12 +236,12 @@ Private Sub Foo(ByVal arg1 as Integer) var module = project.VBComponents.Item(0).CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } - var inspection = new ParameterNotUsedInspection(vbe.Object, parser.State, null); + var inspection = new ParameterNotUsedInspection(parser.State, null); var inspectionResults = inspection.GetInspectionResults(); inspectionResults.First().QuickFixes.Single(s => s is IgnoreOnceQuickFix).Fix(); @@ -253,7 +253,7 @@ Private Sub Foo(ByVal arg1 as Integer) [TestCategory("Inspections")] public void InspectionType() { - var inspection = new ParameterNotUsedInspection(null, null, null); + var inspection = new ParameterNotUsedInspection(null, null); Assert.AreEqual(CodeInspectionType.CodeQualityIssues, inspection.InspectionType); } @@ -262,7 +262,7 @@ public void InspectionType() public void InspectionName() { const string inspectionName = "ParameterNotUsedInspection"; - var inspection = new ParameterNotUsedInspection(null, null, null); + var inspection = new ParameterNotUsedInspection(null, null); Assert.AreEqual(inspectionName, inspection.Name); } diff --git a/RubberduckTests/Inspections/ProcedureNotUsedInspectionTests.cs b/RubberduckTests/Inspections/ProcedureNotUsedInspectionTests.cs index bef821e20b..2b7543c587 100644 --- a/RubberduckTests/Inspections/ProcedureNotUsedInspectionTests.cs +++ b/RubberduckTests/Inspections/ProcedureNotUsedInspectionTests.cs @@ -29,7 +29,7 @@ public void ProcedureNotUsed_ReturnsResult() var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -57,7 +57,7 @@ Private Sub Goo() var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -87,7 +87,7 @@ Private Sub Goo() var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -116,7 +116,7 @@ Private Sub Goo() var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -151,7 +151,7 @@ Private Sub IClass1_DoSomething(ByVal a As Integer) var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -185,7 +185,7 @@ Private Sub abc_Foo(ByVal arg1 As Integer, ByVal arg2 As String) var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -213,7 +213,7 @@ public void ProcedureNotUsed_NoResultForClassInitialize() var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -239,7 +239,7 @@ Private Sub Foo() var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -268,7 +268,7 @@ public void ProcedureNotUsed_QuickFixWorks() var module = project.VBComponents.Item(0).CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -302,7 +302,7 @@ Private Sub Foo(ByVal arg1 as Integer) var module = project.VBComponents.Item(0).CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } diff --git a/RubberduckTests/Inspections/ProcedureShouldBeFunctionInspectionTests.cs b/RubberduckTests/Inspections/ProcedureShouldBeFunctionInspectionTests.cs index 4eb285249c..6bcdd2de7b 100644 --- a/RubberduckTests/Inspections/ProcedureShouldBeFunctionInspectionTests.cs +++ b/RubberduckTests/Inspections/ProcedureShouldBeFunctionInspectionTests.cs @@ -35,7 +35,7 @@ public void ProcedureShouldBeFunction_ReturnsResult() var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -71,7 +71,7 @@ Private Sub Goo(ByRef foo As Integer) var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -103,7 +103,7 @@ public void ProcedureShouldBeFunction_DoesNotReturnResult_Function() var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -134,7 +134,7 @@ public void ProcedureShouldBeFunction_DoesNotReturnResult_SingleByValParam() var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -165,7 +165,7 @@ public void ProcedureShouldBeFunction_DoesNotReturnsResult_MultipleByValParams() var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -187,7 +187,7 @@ public void ProcedureShouldBeFunction_DoesNotReturnsResult_MultipleByRefParams() End Sub"; //Arrange - var settings = new Mock(null, null, null, null, null, null, null); + var settings = new Mock(null, null, null, null, null, null); var config = GetTestConfig(); settings.Setup(x => x.LoadConfiguration()).Returns(config); @@ -196,7 +196,7 @@ public void ProcedureShouldBeFunction_DoesNotReturnsResult_MultipleByRefParams() var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -237,7 +237,7 @@ Private Sub IClass1_DoSomething(ByRef a As Integer) var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -277,7 +277,7 @@ Private Sub abc_Foo(ByRef arg1 As Integer) var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -309,7 +309,7 @@ Private Sub Foo(ByRef foo As Boolean) var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -349,7 +349,7 @@ public void ProcedureShouldBeFunction_QuickFixWorks() var module = project.VBComponents.Item(0).CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -389,7 +389,7 @@ public void ProcedureShouldBeFunction_QuickFixWorks_NoAsTypeClauseInParam() var module = project.VBComponents.Item(0).CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -439,7 +439,7 @@ Sub Goo(ByVal a As Integer) var module = project.VBComponents.Item(0).CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -486,7 +486,7 @@ Sub Goo(ByVal a As Integer) var module = project.VBComponents.Item(0).CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -533,7 +533,7 @@ Sub Goo(ByVal a As String) var module = project.VBComponents.Item(0).CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -583,7 +583,7 @@ Private Function Foo(ByVal arg1 As Integer) As Integer var module = project.VBComponents.Item(0).CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -633,7 +633,7 @@ Dim fizz As Integer var module = project.VBComponents.Item(0).CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -673,7 +673,7 @@ Private Sub Foo(ByRef arg1 As Integer) var module = project.VBComponents.Item(0).CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } diff --git a/RubberduckTests/Inspections/SelfAssignedDeclarationInspectionTests.cs b/RubberduckTests/Inspections/SelfAssignedDeclarationInspectionTests.cs index 366edbc60a..0003f7604d 100644 --- a/RubberduckTests/Inspections/SelfAssignedDeclarationInspectionTests.cs +++ b/RubberduckTests/Inspections/SelfAssignedDeclarationInspectionTests.cs @@ -33,7 +33,7 @@ Dim b As New Collection var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -62,7 +62,7 @@ Dim b As Collection var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -92,7 +92,7 @@ Dim b As New Collection var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -128,7 +128,7 @@ Dim b As New Collection var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } diff --git a/RubberduckTests/Inspections/UnassignedVariableUsageInspectionTests.cs b/RubberduckTests/Inspections/UnassignedVariableUsageInspectionTests.cs index fa86534bdc..52f79e70e3 100644 --- a/RubberduckTests/Inspections/UnassignedVariableUsageInspectionTests.cs +++ b/RubberduckTests/Inspections/UnassignedVariableUsageInspectionTests.cs @@ -35,7 +35,7 @@ Dim bb As Boolean var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -46,16 +46,21 @@ Dim bb As Boolean Assert.AreEqual(1, inspectionResults.Count()); } + // this test will eventually be removed once we can fire the inspection on a specific reference [TestMethod] [TestCategory("Inspections")] - public void UnassignedVariableUsage_DoesNotReturnResult() + public void UnassignedVariableUsage_ReturnsSingleResult_MultipleReferences() { const string inputCode = -@"Sub Foo() - Dim b As Boolean - Dim bb As Boolean - b = True - bb = b +@"Sub tester() + Dim myarr() As Variant + Dim i As Long + + ReDim myarr(1 To 10) + + For i = LBound(myarr) To UBound(myarr) + Next + End Sub"; //Arrange @@ -67,7 +72,7 @@ Dim bb As Boolean var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -75,19 +80,18 @@ Dim bb As Boolean var inspection = new UnassignedVariableUsageInspection(parser.State); var inspectionResults = inspection.GetInspectionResults(); - Assert.IsFalse(inspectionResults.Any()); + Assert.AreEqual(1, inspectionResults.Count()); } [TestMethod] [TestCategory("Inspections")] - public void UnassignedVariableUsage_Ignored_DoesNotReturnResult() + public void UnassignedVariableUsage_DoesNotReturnResult() { const string inputCode = @"Sub Foo() Dim b As Boolean Dim bb As Boolean - - '@Ignore UnassignedVariableUsage + b = True bb = b End Sub"; @@ -100,7 +104,7 @@ Dim bb As Boolean var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -113,31 +117,27 @@ Dim bb As Boolean [TestMethod] [TestCategory("Inspections")] - public void UnassignedVariableUsage_QuickFixWorks() + public void UnassignedVariableUsage_Ignored_DoesNotReturnResult() { const string inputCode = @"Sub Foo() + '@Ignore UnassignedVariableUsage Dim b As Boolean Dim bb As Boolean - bb = b -End Sub"; - const string expectedCode = -@"Sub Foo() - Dim b As Boolean - Dim bb As Boolean - TODOTODO = TODO + bb = b End Sub"; //Arrange var builder = new MockVbeBuilder(); - VBComponent component; - var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); - var project = vbe.Object.VBProjects.Item(0); - var module = project.VBComponents.Item(0).CodeModule; + var project = builder.ProjectBuilder("VBAProject", vbext_ProjectProtection.vbext_pp_none) + .AddComponent("MyClass", vbext_ComponentType.vbext_ct_ClassModule, inputCode) + .Build(); + var vbe = builder.AddProject(project).Build(); + var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -145,11 +145,49 @@ Dim bb As Boolean var inspection = new UnassignedVariableUsageInspection(parser.State); var inspectionResults = inspection.GetInspectionResults(); - inspectionResults.First().QuickFixes.First().Fix(); - - Assert.AreEqual(expectedCode, module.Lines()); + Assert.IsFalse(inspectionResults.Any()); } +// Ignored until we can reinstate the quick fix on a specific reference +// [TestMethod] +// [TestCategory("Inspections")] +// public void UnassignedVariableUsage_QuickFixWorks() +// { +// const string inputCode = +//@"Sub Foo() +// Dim b As Boolean +// Dim bb As Boolean +// bb = b +//End Sub"; + +// const string expectedCode = +//@"Sub Foo() +// Dim b As Boolean +// Dim bb As Boolean +// TODOTODO = TODO +//End Sub"; + +// //Arrange +// var builder = new MockVbeBuilder(); +// VBComponent component; +// var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); +// var project = vbe.Object.VBProjects.Item(0); +// var module = project.VBComponents.Item(0).CodeModule; +// var mockHost = new Mock(); +// mockHost.SetupAllProperties(); +// var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + +// parser.Parse(new CancellationTokenSource()); +// if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } + +// var inspection = new UnassignedVariableUsageInspection(parser.State); +// var inspectionResults = inspection.GetInspectionResults(); + +// inspectionResults.First().QuickFixes.First().Fix(); + +// Assert.AreEqual(expectedCode, module.Lines()); +// } + [TestMethod] [TestCategory("Inspections")] public void UnassignedVariableUsage_IgnoreQuickFixWorks() @@ -163,9 +201,9 @@ Dim bb As Boolean const string expectedCode = @"Sub Foo() +'@Ignore UnassignedVariableUsage Dim b As Boolean Dim bb As Boolean -'@Ignore UnassignedVariableUsage bb = b End Sub"; @@ -177,7 +215,7 @@ Dim bb As Boolean var module = project.VBComponents.Item(0).CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } diff --git a/RubberduckTests/Inspections/UntypedFunctionUsageInspectionTests.cs b/RubberduckTests/Inspections/UntypedFunctionUsageInspectionTests.cs index 6b8226cacc..aae3e1cac9 100644 --- a/RubberduckTests/Inspections/UntypedFunctionUsageInspectionTests.cs +++ b/RubberduckTests/Inspections/UntypedFunctionUsageInspectionTests.cs @@ -39,7 +39,7 @@ Dim str As String var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); GetBuiltInDeclarations().ForEach(d => parser.State.AddDeclaration(d)); @@ -71,7 +71,7 @@ Dim str As String var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); GetBuiltInDeclarations().ForEach(d => parser.State.AddDeclaration(d)); @@ -106,7 +106,7 @@ Dim str As String var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); GetBuiltInDeclarations().ForEach(d => parser.State.AddDeclaration(d)); @@ -146,7 +146,7 @@ Dim str As String var module = project.Object.VBComponents.Item(0).CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); GetBuiltInDeclarations().ForEach(d => parser.State.AddDeclaration(d)); @@ -189,7 +189,7 @@ Dim str As String var module = project.Object.VBComponents.Item(0).CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); GetBuiltInDeclarations().ForEach(d => parser.State.AddDeclaration(d)); diff --git a/RubberduckTests/Inspections/UseMeaningfulNameInspectionTests.cs b/RubberduckTests/Inspections/UseMeaningfulNameInspectionTests.cs index 74df8d4558..6cc1e34202 100644 --- a/RubberduckTests/Inspections/UseMeaningfulNameInspectionTests.cs +++ b/RubberduckTests/Inspections/UseMeaningfulNameInspectionTests.cs @@ -6,6 +6,8 @@ using Rubberduck.Inspections; using Rubberduck.Parsing; using Rubberduck.Parsing.VBA; +using Rubberduck.Settings; +using Rubberduck.SettingsProvider; using Rubberduck.VBEditor.VBEHost; using Rubberduck.VBEditor.Extensions; using RubberduckTests.Mocks; @@ -32,12 +34,12 @@ public void UseMeaningfulName_ReturnsResult_NameWithoutVowels() var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } - var inspection = new UseMeaningfulNameInspection(null, parser.State); + var inspection = new UseMeaningfulNameInspection(null, parser.State, GetInspectionSettings().Object); var inspectionResults = inspection.GetInspectionResults(); Assert.AreEqual(1, inspectionResults.Count()); @@ -60,12 +62,12 @@ public void UseMeaningfulName_ReturnsResult_NameUnderThreeLetters() var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } - var inspection = new UseMeaningfulNameInspection(null, parser.State); + var inspection = new UseMeaningfulNameInspection(null, parser.State, GetInspectionSettings().Object); var inspectionResults = inspection.GetInspectionResults(); Assert.AreEqual(1, inspectionResults.Count()); @@ -88,12 +90,12 @@ public void UseMeaningfulName_ReturnsResult_NameEndsWithDigit() var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } - var inspection = new UseMeaningfulNameInspection(null, parser.State); + var inspection = new UseMeaningfulNameInspection(null, parser.State, GetInspectionSettings().Object); var inspectionResults = inspection.GetInspectionResults(); Assert.AreEqual(1, inspectionResults.Count()); @@ -116,12 +118,12 @@ public void UseMeaningfulName_DoesNotReturnsResult_GoodName_LowerCaseVowels() var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } - var inspection = new UseMeaningfulNameInspection(null, parser.State); + var inspection = new UseMeaningfulNameInspection(null, parser.State, GetInspectionSettings().Object); var inspectionResults = inspection.GetInspectionResults(); Assert.AreEqual(0, inspectionResults.Count()); @@ -144,12 +146,12 @@ public void UseMeaningfulName_DoesNotReturnsResult_GoodName_UpperCaseVowels() var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } - var inspection = new UseMeaningfulNameInspection(null, parser.State); + var inspection = new UseMeaningfulNameInspection(null, parser.State, GetInspectionSettings().Object); var inspectionResults = inspection.GetInspectionResults(); Assert.AreEqual(0, inspectionResults.Count()); @@ -171,17 +173,45 @@ public void UseMeaningfulName_DoesNotReturnsResult_OptionBase() var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } - var inspection = new UseMeaningfulNameInspection(null, parser.State); + var inspection = new UseMeaningfulNameInspection(null, parser.State, GetInspectionSettings().Object); var inspectionResults = inspection.GetInspectionResults(); Assert.AreEqual(0, inspectionResults.Count()); } + [TestMethod] + [TestCategory("Inspections")] + public void UseMeaningfulName_DoesNotReturnResult_NameWithoutVowels_NameIsInWhitelist() + { + const string inputCode = +@"Sub sss() +End Sub"; + + //Arrange + var builder = new MockVbeBuilder(); + var project = builder.ProjectBuilder("VBAProject", vbext_ProjectProtection.vbext_pp_none) + .AddComponent("MyClass", vbext_ComponentType.vbext_ct_ClassModule, inputCode) + .Build(); + var vbe = builder.AddProject(project).Build(); + + var mockHost = new Mock(); + mockHost.SetupAllProperties(); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + + parser.Parse(new CancellationTokenSource()); + if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } + + var inspection = new UseMeaningfulNameInspection(null, parser.State, GetInspectionSettings().Object); + var inspectionResults = inspection.GetInspectionResults(); + + Assert.IsFalse(inspectionResults.Any()); + } + [TestMethod] [TestCategory("Inspections")] public void UseMeaningfulName_Ignored_DoesNotReturnResult() @@ -200,12 +230,12 @@ Sub Ffffff() var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } - var inspection = new UseMeaningfulNameInspection(null, parser.State); + var inspection = new UseMeaningfulNameInspection(null, parser.State, GetInspectionSettings().Object); var inspectionResults = inspection.GetInspectionResults(); Assert.IsFalse(inspectionResults.Any()); @@ -234,12 +264,12 @@ Sub Ffffff() var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } - var inspection = new UseMeaningfulNameInspection(null, parser.State); + var inspection = new UseMeaningfulNameInspection(null, parser.State, GetInspectionSettings().Object); var inspectionResults = inspection.GetInspectionResults(); inspectionResults.First().QuickFixes.Single(s => s is IgnoreOnceQuickFix).Fix(); @@ -251,7 +281,7 @@ Sub Ffffff() [TestCategory("Inspections")] public void InspectionType() { - var inspection = new UseMeaningfulNameInspection(null, null); + var inspection = new UseMeaningfulNameInspection(null, null, null); Assert.AreEqual(CodeInspectionType.MaintainabilityAndReadabilityIssues, inspection.InspectionType); } @@ -260,9 +290,21 @@ public void InspectionType() public void InspectionName() { const string inspectionName = "UseMeaningfulNameInspection"; - var inspection = new UseMeaningfulNameInspection(null, null); + var inspection = new UseMeaningfulNameInspection(null, null, null); Assert.AreEqual(inspectionName, inspection.Name); } + + private Mock> GetInspectionSettings() + { + var settings = new Mock>(); + settings.Setup(s => s.Load(It.IsAny())) + .Returns(new CodeInspectionSettings(null, new[] + { + new WhitelistedIdentifierSetting("sss") + })); + + return settings; + } } } diff --git a/RubberduckTests/Inspections/VariableNotAssignedInspectionTests.cs b/RubberduckTests/Inspections/VariableNotAssignedInspectionTests.cs index 22bcf42c28..7a28e4e7a6 100644 --- a/RubberduckTests/Inspections/VariableNotAssignedInspectionTests.cs +++ b/RubberduckTests/Inspections/VariableNotAssignedInspectionTests.cs @@ -30,7 +30,7 @@ Dim var1 As String var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -57,7 +57,7 @@ Dim var2 As Date var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -84,7 +84,7 @@ Dim var1 as String var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -113,7 +113,7 @@ Dim var2 as String var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -140,7 +140,7 @@ Dim var1 As String var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -172,7 +172,7 @@ Dim var1 as Integer var module = project.VBComponents.Item(0).CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -206,7 +206,7 @@ as _ var module = project.VBComponents.Item(0).CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -239,7 +239,7 @@ Dim var1 As Integer var module = project.VBComponents.Item(0).CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -272,7 +272,7 @@ Dim var1 As Integer var module = project.VBComponents.Item(0).CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -306,7 +306,7 @@ Dim var1 as Integer var module = project.VBComponents.Item(0).CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } diff --git a/RubberduckTests/Inspections/VariableNotUsedInspectionTests.cs b/RubberduckTests/Inspections/VariableNotUsedInspectionTests.cs index c03cbeaf38..77058cfe6b 100644 --- a/RubberduckTests/Inspections/VariableNotUsedInspectionTests.cs +++ b/RubberduckTests/Inspections/VariableNotUsedInspectionTests.cs @@ -30,7 +30,7 @@ Dim var1 As String var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -57,7 +57,7 @@ Dim var2 As Date var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -89,7 +89,7 @@ Sub Goo(ByVal arg1 As String) var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -123,7 +123,7 @@ Sub Goo(ByVal arg1 As Integer) var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -150,7 +150,7 @@ Dim var1 As String var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -182,7 +182,7 @@ Dim var1 As String var module = project.VBComponents.Item(0).CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -216,7 +216,7 @@ Dim var1 As String var module = project.VBComponents.Item(0).CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } diff --git a/RubberduckTests/Inspections/VariableTypeNotDeclaredInspectionTests.cs b/RubberduckTests/Inspections/VariableTypeNotDeclaredInspectionTests.cs index caa5c7cea5..e07825ad38 100644 --- a/RubberduckTests/Inspections/VariableTypeNotDeclaredInspectionTests.cs +++ b/RubberduckTests/Inspections/VariableTypeNotDeclaredInspectionTests.cs @@ -29,7 +29,7 @@ public void VariableTypeNotDeclared_ReturnsResult_Parameter() var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -54,7 +54,7 @@ public void VariableTypeNotDeclared_ReturnsResult_MultipleParams() var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -79,7 +79,7 @@ public void VariableTypeNotDeclared_DoesNotReturnResult_Parameter() var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -104,7 +104,7 @@ public void VariableTypeNotDeclared_ReturnsResult_SomeTypesNotDeclared_Parameter var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -131,7 +131,7 @@ Dim var2 As Date var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -157,7 +157,7 @@ Dim var1 var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -184,7 +184,7 @@ Dim var2 var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -210,7 +210,7 @@ Dim var1 As Integer var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -236,7 +236,7 @@ Sub Foo(arg1) var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -267,7 +267,39 @@ public void VariableTypeNotDeclared_QuickFixWorks_Parameter() var module = project.VBComponents.Item(0).CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + + parser.Parse(new CancellationTokenSource()); + if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } + + var inspection = new VariableTypeNotDeclaredInspection(parser.State); + inspection.GetInspectionResults().First().QuickFixes.First().Fix(); + + var actual = module.Lines(); + Assert.AreEqual(expectedCode, actual); + } + + [TestMethod] + [TestCategory("Inspections")] + public void VariableTypeNotDeclared_QuickFixWorks_SubNameContainsParameterName() + { + const string inputCode = +@"Sub Foo(Foo) +End Sub"; + + const string expectedCode = +@"Sub Foo(Foo As Variant) +End Sub"; + + //Arrange + var builder = new MockVbeBuilder(); + VBComponent component; + var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); + var project = vbe.Object.VBProjects.Item(0); + var module = project.VBComponents.Item(0).CodeModule; + var mockHost = new Mock(); + mockHost.SetupAllProperties(); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -301,7 +333,7 @@ Dim var1 As Variant var module = project.VBComponents.Item(0).CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -332,7 +364,7 @@ public void VariableTypeNotDeclared_QuickFixWorks_ParameterWithoutDefaultValue() var module = project.VBComponents.Item(0).CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -363,7 +395,7 @@ public void VariableTypeNotDeclared_QuickFixWorks_ParameterWithDefaultValue() var module = project.VBComponents.Item(0).CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -395,7 +427,7 @@ Sub Foo(arg1) var module = project.VBComponents.Item(0).CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } diff --git a/RubberduckTests/Inspections/WriteOnlyPropertyInspectionTests.cs b/RubberduckTests/Inspections/WriteOnlyPropertyInspectionTests.cs index 010291e465..f3d613e442 100644 --- a/RubberduckTests/Inspections/WriteOnlyPropertyInspectionTests.cs +++ b/RubberduckTests/Inspections/WriteOnlyPropertyInspectionTests.cs @@ -32,7 +32,7 @@ public void WriteOnlyProperty_ReturnsResult_Let() var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -60,7 +60,7 @@ public void WriteOnlyProperty_ReturnsResult_Set() var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -91,7 +91,7 @@ Property Set Foo(value) var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -119,7 +119,7 @@ public void WriteOnlyProperty_DoesNotReturnsResult_Get() var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -153,7 +153,7 @@ Property Set Foo(value) var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -182,7 +182,7 @@ Property Let Foo(value) var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -193,6 +193,117 @@ Property Let Foo(value) Assert.IsFalse(inspectionResults.Any()); } + [TestMethod] + [TestCategory("Inspections")] + public void WriteOnlyProperty_AddPropertyGetQuickFixWorks_ImplicitTypesAndAccessibility() + { + const string inputCode = +@"Property Let Foo(value) +End Property"; + + const string expectedCode = +@"Public Property Get Foo() As Variant +End Property +Property Let Foo(value) +End Property"; + + //Arrange + var builder = new MockVbeBuilder(); + var project = builder.ProjectBuilder("VBAProject", vbext_ProjectProtection.vbext_pp_none) + .AddComponent("MyClass", vbext_ComponentType.vbext_ct_ClassModule, inputCode) + .Build(); + var module = project.Object.VBComponents.Item(0).CodeModule; + var vbe = builder.AddProject(project).Build(); + + var mockHost = new Mock(); + mockHost.SetupAllProperties(); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + + parser.Parse(new CancellationTokenSource()); + if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } + + var inspection = new WriteOnlyPropertyInspection(parser.State); + var inspectionResults = inspection.GetInspectionResults(); + + inspectionResults.First().QuickFixes.Single(s => s is WriteOnlyPropertyQuickFix).Fix(); + + Assert.AreEqual(expectedCode, module.Lines()); + } + + [TestMethod] + [TestCategory("Inspections")] + public void WriteOnlyProperty_AddPropertyGetQuickFixWorks_ExlicitTypesAndAccessibility() + { + const string inputCode = +@"Public Property Let Foo(ByVal value As Integer) +End Property"; + + const string expectedCode = +@"Public Property Get Foo() As Integer +End Property +Public Property Let Foo(ByVal value As Integer) +End Property"; + + //Arrange + var builder = new MockVbeBuilder(); + var project = builder.ProjectBuilder("VBAProject", vbext_ProjectProtection.vbext_pp_none) + .AddComponent("MyClass", vbext_ComponentType.vbext_ct_ClassModule, inputCode) + .Build(); + var module = project.Object.VBComponents.Item(0).CodeModule; + var vbe = builder.AddProject(project).Build(); + + var mockHost = new Mock(); + mockHost.SetupAllProperties(); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + + parser.Parse(new CancellationTokenSource()); + if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } + + var inspection = new WriteOnlyPropertyInspection(parser.State); + var inspectionResults = inspection.GetInspectionResults(); + + inspectionResults.First().QuickFixes.Single(s => s is WriteOnlyPropertyQuickFix).Fix(); + + Assert.AreEqual(expectedCode, module.Lines()); + } + + [TestMethod] + [TestCategory("Inspections")] + public void WriteOnlyProperty_AddPropertyGetQuickFixWorks_MultipleParams() + { + const string inputCode = +@"Public Property Let Foo(value1, ByVal value2 As Integer, ByRef value3 As Long, value4 As Date, ByVal value5, value6 As String) +End Property"; + + const string expectedCode = +@"Public Property Get Foo(ByRef value1 As Variant, ByVal value2 As Integer, ByRef value3 As Long, ByRef value4 As Date, ByVal value5 As Variant) As String +End Property +Public Property Let Foo(value1, ByVal value2 As Integer, ByRef value3 As Long, value4 As Date, ByVal value5, value6 As String) +End Property"; + + //Arrange + var builder = new MockVbeBuilder(); + var project = builder.ProjectBuilder("VBAProject", vbext_ProjectProtection.vbext_pp_none) + .AddComponent("MyClass", vbext_ComponentType.vbext_ct_ClassModule, inputCode) + .Build(); + var module = project.Object.VBComponents.Item(0).CodeModule; + var vbe = builder.AddProject(project).Build(); + + var mockHost = new Mock(); + mockHost.SetupAllProperties(); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + + parser.Parse(new CancellationTokenSource()); + if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } + + var inspection = new WriteOnlyPropertyInspection(parser.State); + var inspectionResults = inspection.GetInspectionResults(); + + inspectionResults.First().QuickFixes.Single(s => s is WriteOnlyPropertyQuickFix).Fix(); + + Assert.AreEqual(expectedCode, module.Lines()); + } + [TestMethod] [TestCategory("Inspections")] public void WriteOnlyProperty_IgnoreQuickFixWorks() @@ -216,7 +327,7 @@ Property Let Foo(value) var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } diff --git a/RubberduckTests/Mocks/MockParser.cs b/RubberduckTests/Mocks/MockParser.cs index afad2aff2a..8eae3eeda7 100644 --- a/RubberduckTests/Mocks/MockParser.cs +++ b/RubberduckTests/Mocks/MockParser.cs @@ -23,7 +23,7 @@ public static void ParseString(string inputCode, out QualifiedModuleName qualifi VBComponent component; var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); qualifiedModuleName = new QualifiedModuleName(component); - var parser = Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status == ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -40,7 +40,7 @@ public static RubberduckParser Create(VBE vbe, RubberduckParserState state) public static RubberduckParser Create(VBE vbe, RubberduckParserState state, IAttributeParser attributeParser) { - return new RubberduckParser(state, attributeParser, + return new RubberduckParser(vbe, state, attributeParser, () => new VBAPreprocessor(double.Parse(vbe.Version, CultureInfo.InvariantCulture)), new List {new DebugDeclarations(state), new FormEventDeclarations(state), new AliasDeclarations(state)}, true); } diff --git a/RubberduckTests/Mocks/MockProjectBuilder.cs b/RubberduckTests/Mocks/MockProjectBuilder.cs index f0c43f9d35..821380bc79 100644 --- a/RubberduckTests/Mocks/MockProjectBuilder.cs +++ b/RubberduckTests/Mocks/MockProjectBuilder.cs @@ -158,17 +158,18 @@ private Mock CreateComponentsMock() result.Setup(m => m.Item(It.IsAny())).Returns(name => Components.Single(item => item.Name == name)); result.SetupGet(m => m.Count).Returns(Components.Count); - result.Setup(m => m.Add(It.IsAny())).Callback((vbext_ComponentType c) => - { - _componentsMock.Add(CreateComponentMock("test", c, string.Empty, new Selection())); - }); - result.Setup(m => m.Add(It.IsAny())).Returns(() => - { - var lastComponent = _componentsMock.LastOrDefault(); - return lastComponent == null - ? null - : lastComponent.Object; - }); + result.Setup(m => m.Add(It.IsAny())) + .Callback((vbext_ComponentType c) => + { + _componentsMock.Add(CreateComponentMock("test", c, string.Empty, new Selection())); + }) + .Returns(() => + { + var lastComponent = _componentsMock.LastOrDefault(); + return lastComponent == null + ? null + : lastComponent.Object; + }); result.Setup(m => m.Remove(It.IsAny())).Callback((VBComponent c) => { @@ -253,7 +254,6 @@ private Mock CreateCodeModuleMock(string name, string content, Selec codePane.SetupGet(m => m.CodeModule).Returns(() => result.Object); result.Setup(m => m.AddFromFile(It.IsAny())); - result.Setup(m => m.AddFromString(It.IsAny())); return result; } @@ -286,7 +286,7 @@ private Mock CreateCodeModuleMock(string content) { if (index - 1 >= lines.Count) { - lines.AddRange(newLine.Split(new[] {Environment.NewLine}, StringSplitOptions.None)); + lines.AddRange(newLine.Split(new[] { Environment.NewLine }, StringSplitOptions.None)); } else { @@ -294,6 +294,12 @@ private Mock CreateCodeModuleMock(string content) } }); + codeModule.Setup(m => m.AddFromString(It.IsAny())) + .Callback(newLine => + { + lines.AddRange(newLine.Split(new[] { Environment.NewLine }, StringSplitOptions.None)); + }); + return codeModule; } diff --git a/RubberduckTests/Preprocessing/VBAPreprocessorTests.cs b/RubberduckTests/Preprocessing/VBAPreprocessorTests.cs index 1a9b1c0515..801f6b9c2e 100644 --- a/RubberduckTests/Preprocessing/VBAPreprocessorTests.cs +++ b/RubberduckTests/Preprocessing/VBAPreprocessorTests.cs @@ -55,7 +55,7 @@ private string Parse(string code) var vbe = builder.BuildFromSingleStandardModule(code, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var state = new RubberduckParserState(vbe.Object, new Mock().Object); + var state = new RubberduckParserState(new Mock().Object); var parser = MockParser.Create(vbe.Object, state); parser.Parse(new CancellationTokenSource()); if (parser.State.Status == ParserState.Error) diff --git a/RubberduckTests/Refactoring/EncapsulateFieldTests.cs b/RubberduckTests/Refactoring/EncapsulateFieldTests.cs index 41a485c2cc..f4f52d78d5 100644 --- a/RubberduckTests/Refactoring/EncapsulateFieldTests.cs +++ b/RubberduckTests/Refactoring/EncapsulateFieldTests.cs @@ -13,6 +13,8 @@ using Rubberduck.VBEditor.VBEHost; using Rubberduck.VBEditor.VBEInterfaces.RubberduckCodePane; using RubberduckTests.Mocks; +using Rubberduck.SmartIndenter; +using Selection = Rubberduck.VBEditor.Selection; namespace RubberduckTests.Refactoring { @@ -48,7 +50,7 @@ End Property var module = project.VBComponents.Item(0).CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -59,6 +61,7 @@ End Property { ImplementLetSetterType = true, ImplementSetSetterType = false, + CanImplementLet = true, ParameterName = "value", PropertyName = "Name" }; @@ -67,7 +70,7 @@ End Property var factory = SetupFactory(model); //Act - var refactoring = new EncapsulateFieldRefactoring(vbe.Object, factory.Object); + var refactoring = new EncapsulateFieldRefactoring(vbe.Object, CreateIndenter(vbe.Object), factory.Object); refactoring.Refactor(qualifiedSelection); //Assert @@ -106,7 +109,7 @@ End Property var module = project.VBComponents.Item(0).CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -117,6 +120,7 @@ End Property { ImplementLetSetterType = true, ImplementSetSetterType = false, + CanImplementLet = true, ParameterName = "value", PropertyName = "Name" }; @@ -125,7 +129,7 @@ End Property var factory = SetupFactory(model); //Act - var refactoring = new EncapsulateFieldRefactoring(vbe.Object, factory.Object); + var refactoring = new EncapsulateFieldRefactoring(vbe.Object, CreateIndenter(vbe.Object), factory.Object); refactoring.Refactor(qualifiedSelection); //Assert @@ -145,11 +149,11 @@ public void EncapsulatePublicField_WithSetter() @"Private fizz As Variant Public Property Get Name() As Variant - Name = fizz + Set Name = fizz End Property Public Property Set Name(ByVal value As Variant) - fizz = value + Set fizz = value End Property "; @@ -161,7 +165,7 @@ End Property var module = project.VBComponents.Item(0).CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -172,6 +176,7 @@ End Property { ImplementLetSetterType = false, ImplementSetSetterType = true, + CanImplementLet = true, ParameterName = "value", PropertyName = "Name" }; @@ -180,7 +185,7 @@ End Property var factory = SetupFactory(model); //Act - var refactoring = new EncapsulateFieldRefactoring(vbe.Object, factory.Object); + var refactoring = new EncapsulateFieldRefactoring(vbe.Object, CreateIndenter(vbe.Object), factory.Object); refactoring.Refactor(qualifiedSelection); //Assert @@ -212,7 +217,7 @@ End Property var module = project.VBComponents.Item(0).CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -223,6 +228,7 @@ End Property { ImplementLetSetterType = false, ImplementSetSetterType = false, + CanImplementLet = true, ParameterName = "value", PropertyName = "Name" }; @@ -231,7 +237,7 @@ End Property var factory = SetupFactory(model); //Act - var refactoring = new EncapsulateFieldRefactoring(vbe.Object, factory.Object); + var refactoring = new EncapsulateFieldRefactoring(vbe.Object, CreateIndenter(vbe.Object), factory.Object); refactoring.Refactor(qualifiedSelection); //Assert @@ -280,7 +286,7 @@ Function Bar() As Integer var module = project.VBComponents.Item(0).CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -291,6 +297,7 @@ Function Bar() As Integer { ImplementLetSetterType = true, ImplementSetSetterType = false, + CanImplementLet = true, ParameterName = "value", PropertyName = "Name" }; @@ -299,7 +306,7 @@ Function Bar() As Integer var factory = SetupFactory(model); //Act - var refactoring = new EncapsulateFieldRefactoring(vbe.Object, factory.Object); + var refactoring = new EncapsulateFieldRefactoring(vbe.Object, CreateIndenter(vbe.Object), factory.Object); refactoring.Refactor(qualifiedSelection); //Assert @@ -354,7 +361,7 @@ Property Set Foo(ByVal vall As Variant) var module = project.VBComponents.Item(0).CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -365,6 +372,7 @@ Property Set Foo(ByVal vall As Variant) { ImplementLetSetterType = true, ImplementSetSetterType = false, + CanImplementLet = true, ParameterName = "value", PropertyName = "Name" }; @@ -373,7 +381,7 @@ Property Set Foo(ByVal vall As Variant) var factory = SetupFactory(model); //Act - var refactoring = new EncapsulateFieldRefactoring(vbe.Object, factory.Object); + var refactoring = new EncapsulateFieldRefactoring(vbe.Object, CreateIndenter(vbe.Object), factory.Object); refactoring.Refactor(qualifiedSelection); //Assert @@ -411,7 +419,7 @@ End Property var module = project.VBComponents.Item(0).CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -422,6 +430,7 @@ End Property { ImplementLetSetterType = true, ImplementSetSetterType = false, + CanImplementLet = true, ParameterName = "value", PropertyName = "Name" }; @@ -430,7 +439,7 @@ End Property var factory = SetupFactory(model); //Act - var refactoring = new EncapsulateFieldRefactoring(vbe.Object, factory.Object); + var refactoring = new EncapsulateFieldRefactoring(vbe.Object, CreateIndenter(vbe.Object), factory.Object); refactoring.Refactor(qualifiedSelection); //Assert @@ -453,7 +462,7 @@ public void EncapsulatePublicField_FieldDeclarationHasMultipleFields_MoveFirst() Private fizz As Variant Public Property Get Name() As Variant - Name = fizz + Set Name = fizz End Property Public Property Let Name(ByVal value As Variant) @@ -461,7 +470,7 @@ Public Property Let Name(ByVal value As Variant) End Property Public Property Set Name(ByVal value As Variant) - fizz = value + Set fizz = value End Property "; // note: VBE removes excess spaces @@ -473,7 +482,7 @@ End Property var module = project.VBComponents.Item(0).CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -484,6 +493,7 @@ End Property { ImplementLetSetterType = true, ImplementSetSetterType = true, + CanImplementLet = true, ParameterName = "value", PropertyName = "Name" }; @@ -492,7 +502,7 @@ End Property var factory = SetupFactory(model); //Act - var refactoring = new EncapsulateFieldRefactoring(vbe.Object, factory.Object); + var refactoring = new EncapsulateFieldRefactoring(vbe.Object, CreateIndenter(vbe.Object), factory.Object); refactoring.Refactor(qualifiedSelection); //Assert @@ -531,7 +541,7 @@ End Property var module = project.VBComponents.Item(0).CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -542,6 +552,7 @@ End Property { ImplementLetSetterType = true, ImplementSetSetterType = false, + CanImplementLet = true, ParameterName = "value", PropertyName = "Name" }; @@ -550,7 +561,7 @@ End Property var factory = SetupFactory(model); //Act - var refactoring = new EncapsulateFieldRefactoring(vbe.Object, factory.Object); + var refactoring = new EncapsulateFieldRefactoring(vbe.Object, CreateIndenter(vbe.Object), factory.Object); refactoring.Refactor(qualifiedSelection); //Assert @@ -589,7 +600,7 @@ End Property var module = project.VBComponents.Item(0).CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -600,6 +611,7 @@ End Property { ImplementLetSetterType = true, ImplementSetSetterType = false, + CanImplementLet = true, ParameterName = "value", PropertyName = "Name" }; @@ -608,7 +620,7 @@ End Property var factory = SetupFactory(model); //Act - var refactoring = new EncapsulateFieldRefactoring(vbe.Object, factory.Object); + var refactoring = new EncapsulateFieldRefactoring(vbe.Object, CreateIndenter(vbe.Object), factory.Object); refactoring.Refactor(qualifiedSelection); //Assert @@ -644,7 +656,7 @@ End Property var module = project.VBComponents.Item(0).CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -655,6 +667,7 @@ End Property { ImplementLetSetterType = true, ImplementSetSetterType = false, + CanImplementLet = true, ParameterName = "value", PropertyName = "Name" }; @@ -663,7 +676,7 @@ End Property var factory = SetupFactory(model); //Act - var refactoring = new EncapsulateFieldRefactoring(vbe.Object, factory.Object); + var refactoring = new EncapsulateFieldRefactoring(vbe.Object, CreateIndenter(vbe.Object), factory.Object); refactoring.Refactor(qualifiedSelection); //Assert @@ -714,7 +727,7 @@ Sub Bar(ByVal name As Integer) var module = project.VBComponents.Item(0).CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -725,6 +738,7 @@ Sub Bar(ByVal name As Integer) { ImplementLetSetterType = true, ImplementSetSetterType = false, + CanImplementLet = true, ParameterName = "value", PropertyName = "Name" }; @@ -733,7 +747,7 @@ Sub Bar(ByVal name As Integer) var factory = SetupFactory(model); //Act - var refactoring = new EncapsulateFieldRefactoring(vbe.Object, factory.Object); + var refactoring = new EncapsulateFieldRefactoring(vbe.Object, CreateIndenter(vbe.Object), factory.Object); refactoring.Refactor(qualifiedSelection); //Assert @@ -800,7 +814,7 @@ Sub Bar(ByVal v As Integer) var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -814,6 +828,7 @@ Sub Bar(ByVal v As Integer) { ImplementLetSetterType = true, ImplementSetSetterType = false, + CanImplementLet = true, ParameterName = "value", PropertyName = "Name" }; @@ -822,7 +837,7 @@ Sub Bar(ByVal v As Integer) var factory = SetupFactory(model); //Act - var refactoring = new EncapsulateFieldRefactoring(vbe.Object, factory.Object); + var refactoring = new EncapsulateFieldRefactoring(vbe.Object, CreateIndenter(vbe.Object), factory.Object); refactoring.Refactor(qualifiedSelection); var actualCode1 = module1.Lines(); @@ -862,7 +877,7 @@ End Property var module = project.VBComponents.Item(0).CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -873,6 +888,7 @@ End Property { ImplementLetSetterType = true, ImplementSetSetterType = false, + CanImplementLet = true, ParameterName = "value", PropertyName = "Name" }; @@ -881,7 +897,7 @@ End Property var factory = SetupFactory(model); //Act - var refactoring = new EncapsulateFieldRefactoring(vbe.Object, factory.Object); + var refactoring = new EncapsulateFieldRefactoring(vbe.Object, CreateIndenter(vbe.Object), factory.Object); refactoring.Refactor(parser.State.AllUserDeclarations.FindVariable(qualifiedSelection)); //Assert @@ -889,7 +905,7 @@ End Property } [TestMethod] - public void RemoveParams_PresenterIsNull() + public void EncapsulateField_PresenterIsNull() { //Input const string inputCode = @@ -902,7 +918,7 @@ public void RemoveParams_PresenterIsNull() var module = component.CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -910,14 +926,14 @@ public void RemoveParams_PresenterIsNull() var factory = new EncapsulateFieldPresenterFactory(vbe.Object, parser.State, null); //act - var refactoring = new EncapsulateFieldRefactoring(vbe.Object, factory); + var refactoring = new EncapsulateFieldRefactoring(vbe.Object, CreateIndenter(vbe.Object), factory); refactoring.Refactor(); Assert.AreEqual(inputCode, module.Lines()); } [TestMethod] - public void RemoveParams_ModelIsNull() + public void EncapsulateField_ModelIsNull() { //Input const string inputCode = @@ -931,7 +947,7 @@ public void RemoveParams_ModelIsNull() var module = component.CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -942,7 +958,7 @@ public void RemoveParams_ModelIsNull() var factory = SetupFactory(null); //Act - var refactoring = new EncapsulateFieldRefactoring(vbe.Object, factory.Object); + var refactoring = new EncapsulateFieldRefactoring(vbe.Object, CreateIndenter(vbe.Object), factory.Object); refactoring.Refactor(qualifiedSelection); //Assert @@ -966,7 +982,7 @@ public void Factory_NullSelectionReturnsNullPresenter() var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -995,7 +1011,7 @@ public void Presenter_ParameterlessTargetReturnsNullModel() var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -1027,7 +1043,7 @@ Private Sub Foo(ByVal arg1 As Integer, ByVal arg2 As String) var codePaneFactory = new CodePaneWrapperFactory(); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -1057,7 +1073,7 @@ public void Presenter_Accept_ReturnsModelWithParameterNameChanged() var vbe = builder.BuildFromSingleStandardModule(inputCode, out component, selection); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -1088,7 +1104,7 @@ public void Presenter_Reject_ReturnsNull() var vbe = builder.BuildFromSingleStandardModule(inputCode, out component, selection); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -1117,7 +1133,7 @@ public void Presenter_Accept_ReturnsModelWithPropertyNameChanged() var vbe = builder.BuildFromSingleStandardModule(inputCode, out component, selection); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -1133,6 +1149,36 @@ public void Presenter_Accept_ReturnsModelWithPropertyNameChanged() Assert.AreEqual("MyProperty", presenter.Show().PropertyName); } + [TestMethod] + public void Presenter_Accept_ReturnsModelWithCanImplementLetChanged() + { + //Input + const string inputCode = +@"Private fizz As Variant"; + var selection = new Selection(1, 15, 1, 15); + + //Arrange + var builder = new MockVbeBuilder(); + VBComponent component; + var vbe = builder.BuildFromSingleStandardModule(inputCode, out component, selection); + var mockHost = new Mock(); + mockHost.SetupAllProperties(); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + + parser.Parse(new CancellationTokenSource()); + if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } + + var view = new Mock(); + view.SetupProperty(v => v.CanImplementLetSetterType, true); + view.Setup(v => v.ShowDialog()).Returns(DialogResult.OK); + + var factory = new EncapsulateFieldPresenterFactory(vbe.Object, parser.State, view.Object); + + var presenter = factory.Create(); + + Assert.AreEqual(true, presenter.Show().CanImplementLet); + } + [TestMethod] public void Presenter_Accept_ReturnsModelWithImplementLetChanged() { @@ -1147,7 +1193,7 @@ public void Presenter_Accept_ReturnsModelWithImplementLetChanged() var vbe = builder.BuildFromSingleStandardModule(inputCode, out component, selection); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -1177,7 +1223,7 @@ public void Presenter_Accept_ReturnsModelWithImplementSetChanged() var vbe = builder.BuildFromSingleStandardModule(inputCode, out component, selection); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -1207,7 +1253,7 @@ public void Presenter_Accept_ReturnsModelWithImplementLetAllowedForPrimitiveType var vbe = builder.BuildFromSingleStandardModule(inputCode, out component, selection); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -1235,7 +1281,7 @@ public void Presenter_Accept_ReturnsModelWithImplementSetNotAllowedForPrimitiveT var vbe = builder.BuildFromSingleStandardModule(inputCode, out component, selection); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -1263,7 +1309,7 @@ public void Presenter_Accept_ReturnsModelWithImplementSetAllowedForNonVariantNon var vbe = builder.BuildFromSingleStandardModule(inputCode, out component, selection); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -1291,7 +1337,7 @@ public void Presenter_Accept_ReturnsModelWithImplementLetNotAllowedForNonVariant var vbe = builder.BuildFromSingleStandardModule(inputCode, out component, selection); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -1319,7 +1365,7 @@ public void Presenter_Accept_ReturnsModelWithImplementLetAllowedForVariant_NoRef var vbe = builder.BuildFromSingleStandardModule(inputCode, out component, selection); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -1347,7 +1393,7 @@ public void Presenter_Accept_ReturnsModelWithImplementSetAllowedForVariant_NoRef var vbe = builder.BuildFromSingleStandardModule(inputCode, out component, selection); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -1378,7 +1424,7 @@ Sub foo() var vbe = builder.BuildFromSingleStandardModule(inputCode, out component, selection); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -1409,7 +1455,7 @@ Sub foo() var vbe = builder.BuildFromSingleStandardModule(inputCode, out component, selection); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -1440,7 +1486,7 @@ Sub Foo() var vbe = builder.BuildFromSingleStandardModule(inputCode, out component, selection); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -1471,7 +1517,7 @@ Sub foo() var vbe = builder.BuildFromSingleStandardModule(inputCode, out component, selection); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -1499,7 +1545,7 @@ public void Presenter_Accept_DefaultCreateGetOnly_PrimitiveType_NoReference() var vbe = builder.BuildFromSingleStandardModule(inputCode, out component, selection); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -1528,7 +1574,7 @@ public void Presenter_Accept_DefaultCreateGetOnly_NonPrimitiveTypeNonVariant_NoR var vbe = builder.BuildFromSingleStandardModule(inputCode, out component, selection); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -1557,7 +1603,7 @@ public void Presenter_Accept_DefaultCreateGetOnly_Variant_NoReference() var vbe = builder.BuildFromSingleStandardModule(inputCode, out component, selection); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -1583,6 +1629,28 @@ private static Mock> Se return factory; } + private static IIndenter CreateIndenter(VBE vbe) + { + var settings = new Mock(); + settings.Setup(s => s.IndentEntireProcedureBody).Returns(true); + settings.Setup(s => s.IndentFirstCommentBlock).Returns(true); + settings.Setup(s => s.IndentFirstDeclarationBlock).Returns(true); + settings.Setup(s => s.AlignCommentsWithCode).Returns(true); + settings.Setup(s => s.AlignContinuations).Returns(true); + settings.Setup(s => s.IgnoreOperatorsInContinuations).Returns(true); + settings.Setup(s => s.IndentCase).Returns(false); + settings.Setup(s => s.ForceDebugStatementsInColumn1).Returns(false); + settings.Setup(s => s.ForceCompilerDirectivesInColumn1).Returns(false); + settings.Setup(s => s.IndentCompilerDirectives).Returns(true); + settings.Setup(s => s.AlignDims).Returns(false); + settings.Setup(s => s.AlignDimColumn).Returns(15); + settings.Setup(s => s.EnableUndo).Returns(true); + settings.Setup(s => s.EndOfLineCommentStyle).Returns(EndOfLineCommentStyle.AlignInColumn); + settings.Setup(s => s.EndOfLineCommentColumnSpaceAlignment).Returns(50); + settings.Setup(s => s.IndentSpaces).Returns(4); + + return new Indenter(vbe, () => new IndenterSettings()); + } #endregion } } diff --git a/RubberduckTests/Refactoring/ExtractInterfaceTests.cs b/RubberduckTests/Refactoring/ExtractInterfaceTests.cs new file mode 100644 index 0000000000..5677f7b53a --- /dev/null +++ b/RubberduckTests/Refactoring/ExtractInterfaceTests.cs @@ -0,0 +1,635 @@ +using System.Linq; +using System.Threading; +using System.Windows.Forms; +using Microsoft.Vbe.Interop; +using Microsoft.VisualStudio.TestTools.UnitTesting; +using Moq; +using Rubberduck.Parsing; +using Rubberduck.Parsing.Symbols; +using Rubberduck.Parsing.VBA; +using Rubberduck.Refactorings; +using Rubberduck.Refactorings.ExtractInterface; +using Rubberduck.VBEditor; +using Rubberduck.VBEditor.Extensions; +using Rubberduck.VBEditor.VBEHost; +using RubberduckTests.Mocks; + +namespace RubberduckTests.Refactoring +{ + [TestClass] + public class ExtractInterfaceTests + { + [TestMethod] + public void ExtractInterfaceRefactoring_ImplementProc() + { + //Input + const string inputCode = +@"Public Sub Foo(ByVal arg1 As Integer, ByVal arg2 As String) +End Sub"; + var selection = new Selection(1, 23, 1, 27); + + //Expectation + const string expectedCode = +@"Implements ITestModule1 + + +Private Sub ITestModule1_Foo(ByVal arg1 As Integer, ByVal arg2 As String) + Err.Raise 5 'TODO implement interface member +End Sub + +Public Sub Foo(ByVal arg1 As Integer, ByVal arg2 As String) +End Sub"; + + const string expectedInterfaceCode = +@"Option Explicit + +Public Sub Foo(ByVal arg1 As Integer, ByVal arg2 As String) +End Sub + +"; + + //Arrange + var builder = new MockVbeBuilder(); + VBComponent component; + var vbe = builder.BuildFromSingleModule(inputCode, vbext_ComponentType.vbext_ct_ClassModule, out component, selection); + var project = vbe.Object.VBProjects.Item(0); + var mockHost = new Mock(); + mockHost.SetupAllProperties(); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + + parser.Parse(new CancellationTokenSource()); + if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } + + var qualifiedSelection = new QualifiedSelection(new QualifiedModuleName(component), selection); + + //Specify Params to remove + var model = new ExtractInterfaceModel(parser.State, qualifiedSelection); + foreach (var member in model.Members) + { + member.IsSelected = true; + } + + //SetupFactory + var factory = SetupFactory(model); + + //Act + var refactoring = new ExtractInterfaceRefactoring(vbe.Object, parser.State, null, factory.Object); + refactoring.Refactor(qualifiedSelection); + + //Assert + Assert.AreEqual(expectedInterfaceCode, project.VBComponents.Item(1).CodeModule.Lines()); + Assert.AreEqual(expectedCode, project.VBComponents.Item(0).CodeModule.Lines()); + } + + [TestMethod] + public void ExtractInterfaceRefactoring_ImplementProcAndFuncAndPropGetSetLet() + { + //Input + const string inputCode = +@"Public Sub Foo(ByVal arg1 As Integer, ByVal arg2 As String) +End Sub + +Public Function Fizz(b) As Variant +End Function + +Public Property Get Buzz() +End Property + +Public Property Let Buzz(value) +End Property + +Public Property Set Buzz(value) +End Property"; + + var selection = new Selection(1, 23, 1, 27); + + //Expectation + const string expectedCode = +@"Implements ITestModule1 + + +Private Sub ITestModule1_Foo(ByVal arg1 As Integer, ByVal arg2 As String) + Err.Raise 5 'TODO implement interface member +End Sub + +Private Function ITestModule1_Fizz(ByRef b As Variant) As Variant + Err.Raise 5 'TODO implement interface member +End Function + +Private Property Get ITestModule1_Buzz() As Variant + Err.Raise 5 'TODO implement interface member +End Property + +Private Property Let ITestModule1_Buzz(ByRef value As Variant) + Err.Raise 5 'TODO implement interface member +End Property + +Private Property Set ITestModule1_Buzz(ByRef value As Variant) + Err.Raise 5 'TODO implement interface member +End Property + +Public Sub Foo(ByVal arg1 As Integer, ByVal arg2 As String) +End Sub + +Public Function Fizz(b) As Variant +End Function + +Public Property Get Buzz() +End Property + +Public Property Let Buzz(value) +End Property + +Public Property Set Buzz(value) +End Property"; + + const string expectedInterfaceCode = +@"Option Explicit + +Public Sub Foo(ByVal arg1 As Integer, ByVal arg2 As String) +End Sub + +Public Function Fizz(ByRef b As Variant) As Variant +End Function + +Public Property Get Buzz() As Variant +End Property + +Public Property Let Buzz(ByRef value As Variant) +End Property + +Public Property Set Buzz(ByRef value As Variant) +End Property + +"; + + //Arrange + var builder = new MockVbeBuilder(); + VBComponent component; + var vbe = builder.BuildFromSingleModule(inputCode, vbext_ComponentType.vbext_ct_ClassModule, out component, selection); + var project = vbe.Object.VBProjects.Item(0); + var mockHost = new Mock(); + mockHost.SetupAllProperties(); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + + parser.Parse(new CancellationTokenSource()); + if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } + + var qualifiedSelection = new QualifiedSelection(new QualifiedModuleName(component), selection); + + //Specify Params to remove + var model = new ExtractInterfaceModel(parser.State, qualifiedSelection); + foreach (var member in model.Members) + { + member.IsSelected = true; + } + + //SetupFactory + var factory = SetupFactory(model); + + //Act + var refactoring = new ExtractInterfaceRefactoring(vbe.Object, parser.State, null, factory.Object); + refactoring.Refactor(qualifiedSelection); + + //Assert + Assert.AreEqual(expectedInterfaceCode, project.VBComponents.Item(1).CodeModule.Lines()); + Assert.AreEqual(expectedCode, project.VBComponents.Item(0).CodeModule.Lines()); + } + + [TestMethod] + public void ExtractInterfaceRefactoring_ImplementProcAndFunc_IgnoreProperties() + { + //Input + const string inputCode = +@"Public Sub Foo(ByVal arg1 As Integer, ByVal arg2 As String) +End Sub + +Public Function Fizz(b) As Variant +End Function + +Public Property Get Buzz() +End Property + +Public Property Let Buzz(value) +End Property + +Public Property Set Buzz(value) +End Property"; + + var selection = new Selection(1, 23, 1, 27); + + //Expectation + const string expectedCode = +@"Implements ITestModule1 + + +Private Sub ITestModule1_Foo(ByVal arg1 As Integer, ByVal arg2 As String) + Err.Raise 5 'TODO implement interface member +End Sub + +Private Function ITestModule1_Fizz(ByRef b As Variant) As Variant + Err.Raise 5 'TODO implement interface member +End Function + +Public Sub Foo(ByVal arg1 As Integer, ByVal arg2 As String) +End Sub + +Public Function Fizz(b) As Variant +End Function + +Public Property Get Buzz() +End Property + +Public Property Let Buzz(value) +End Property + +Public Property Set Buzz(value) +End Property"; + + const string expectedInterfaceCode = +@"Option Explicit + +Public Sub Foo(ByVal arg1 As Integer, ByVal arg2 As String) +End Sub + +Public Function Fizz(ByRef b As Variant) As Variant +End Function + +"; + + //Arrange + var builder = new MockVbeBuilder(); + VBComponent component; + var vbe = builder.BuildFromSingleModule(inputCode, vbext_ComponentType.vbext_ct_ClassModule, out component, selection); + var project = vbe.Object.VBProjects.Item(0); + var mockHost = new Mock(); + mockHost.SetupAllProperties(); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + + parser.Parse(new CancellationTokenSource()); + if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } + + var qualifiedSelection = new QualifiedSelection(new QualifiedModuleName(component), selection); + + //Specify Params to remove + var model = new ExtractInterfaceModel(parser.State, qualifiedSelection); + foreach (var member in model.Members) + { + if (!member.FullMemberSignature.Contains("Property")) + { + member.IsSelected = true; + } + } + + //SetupFactory + var factory = SetupFactory(model); + + //Act + var refactoring = new ExtractInterfaceRefactoring(vbe.Object, parser.State, null, factory.Object); + refactoring.Refactor(qualifiedSelection); + + //Assert + Assert.AreEqual(expectedInterfaceCode, project.VBComponents.Item(1).CodeModule.Lines()); + Assert.AreEqual(expectedCode, project.VBComponents.Item(0).CodeModule.Lines()); + } + + [TestMethod] + public void ExtractInterfaceRefactoring_IgnoresField() + { + //Input + const string inputCode = +@"Public Fizz As Boolean"; + + var selection = new Selection(1, 23, 1, 27); + + //Arrange + var builder = new MockVbeBuilder(); + VBComponent component; + var vbe = builder.BuildFromSingleModule(inputCode, vbext_ComponentType.vbext_ct_ClassModule, out component, selection); + var mockHost = new Mock(); + mockHost.SetupAllProperties(); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + + parser.Parse(new CancellationTokenSource()); + if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } + + var qualifiedSelection = new QualifiedSelection(new QualifiedModuleName(component), selection); + + //Specify Params to remove + var model = new ExtractInterfaceModel(parser.State, qualifiedSelection); + Assert.AreEqual(0, model.Members.Count()); + } + + [TestMethod] + public void ExtractInterfaceRefactoring_NullPresenter_NoChanges() + { + //Input + const string inputCode = +@"Private Sub Foo(ByVal arg1 As Integer, ByVal arg2 As String) +End Sub"; + var selection = new Selection(1, 23, 1, 27); + + //Arrange + var builder = new MockVbeBuilder(); + VBComponent component; + var vbe = builder.BuildFromSingleModule(inputCode, vbext_ComponentType.vbext_ct_ClassModule, out component, selection); + var project = vbe.Object.VBProjects.Item(0); + var mockHost = new Mock(); + mockHost.SetupAllProperties(); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + + parser.Parse(new CancellationTokenSource()); + if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } + + var qualifiedSelection = new QualifiedSelection(new QualifiedModuleName(component), selection); + + //Specify Params to remove + var model = new ExtractInterfaceModel(parser.State, qualifiedSelection); + + //SetupFactory + var factory = SetupFactory(model); + factory.Setup(f => f.Create()).Returns(value: null); + + //Act + var refactoring = new ExtractInterfaceRefactoring(vbe.Object, parser.State, null, factory.Object); + refactoring.Refactor(); + + //Assert + Assert.AreEqual(1, project.VBComponents.Cast().Count()); // somehow, the VBComponents Count mock isn't working + Assert.AreEqual(inputCode, project.VBComponents.Item(0).CodeModule.Lines()); + } + + [TestMethod] + public void ExtractInterfaceRefactoring_NullModel_NoChanges() + { + //Input + const string inputCode = +@"Private Sub Foo(ByVal arg1 As Integer, ByVal arg2 As String) +End Sub"; + var selection = new Selection(1, 23, 1, 27); + + //Arrange + var builder = new MockVbeBuilder(); + VBComponent component; + var vbe = builder.BuildFromSingleModule(inputCode, vbext_ComponentType.vbext_ct_ClassModule, out component, selection); + var project = vbe.Object.VBProjects.Item(0); + var mockHost = new Mock(); + mockHost.SetupAllProperties(); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + + parser.Parse(new CancellationTokenSource()); + if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } + + var qualifiedSelection = new QualifiedSelection(new QualifiedModuleName(component), selection); + + //Specify Params to remove + var model = new ExtractInterfaceModel(parser.State, qualifiedSelection); + + var presenter = new Mock(); + presenter.Setup(p => p.Show()).Returns(value: null); + + //SetupFactory + var factory = SetupFactory(model); + factory.Setup(f => f.Create()).Returns(presenter.Object); + + //Act + var refactoring = new ExtractInterfaceRefactoring(vbe.Object, parser.State, null, factory.Object); + refactoring.Refactor(); + + //Assert + Assert.AreEqual(1, project.VBComponents.Cast().Count()); // somehow, the VBComponents Count mock isn't working + Assert.AreEqual(inputCode, project.VBComponents.Item(0).CodeModule.Lines()); + } + + [TestMethod] + public void ExtractInterfaceRefactoring_PassTargetIn() + { + //Input + const string inputCode = +@"Public Sub Foo(ByVal arg1 As Integer, ByVal arg2 As String) +End Sub"; + var selection = new Selection(1, 23, 1, 27); + + //Expectation + const string expectedCode = +@"Implements ITestModule1 + + +Private Sub ITestModule1_Foo(ByVal arg1 As Integer, ByVal arg2 As String) + Err.Raise 5 'TODO implement interface member +End Sub + +Public Sub Foo(ByVal arg1 As Integer, ByVal arg2 As String) +End Sub"; + + const string expectedInterfaceCode = +@"Option Explicit + +Public Sub Foo(ByVal arg1 As Integer, ByVal arg2 As String) +End Sub + +"; + + //Arrange + var builder = new MockVbeBuilder(); + VBComponent component; + var vbe = builder.BuildFromSingleModule(inputCode, vbext_ComponentType.vbext_ct_ClassModule, out component, selection); + var project = vbe.Object.VBProjects.Item(0); + var mockHost = new Mock(); + mockHost.SetupAllProperties(); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + + parser.Parse(new CancellationTokenSource()); + if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } + + var qualifiedSelection = new QualifiedSelection(new QualifiedModuleName(component), selection); + + //Specify Params to remove + var model = new ExtractInterfaceModel(parser.State, qualifiedSelection); + model.Members.ElementAt(0).IsSelected = true; + + //SetupFactory + var factory = SetupFactory(model); + + //Act + var refactoring = new ExtractInterfaceRefactoring(vbe.Object, parser.State, null, factory.Object); + refactoring.Refactor(parser.State.AllUserDeclarations.Single(s => s.DeclarationType == DeclarationType.ClassModule)); + + //Assert + Assert.AreEqual(expectedInterfaceCode, project.VBComponents.Item(1).CodeModule.Lines()); + Assert.AreEqual(expectedCode, project.VBComponents.Item(0).CodeModule.Lines()); + } + + [TestMethod] + public void Presenter_Reject_ReturnsNull() + { + //Input + const string inputCode = +@"Public Sub Foo(ByVal arg1 As Integer, ByVal arg2 As String) +End Sub"; + var selection = new Selection(1, 15, 1, 15); + + //Arrange + var builder = new MockVbeBuilder(); + VBComponent component; + var vbe = builder.BuildFromSingleModule(inputCode, vbext_ComponentType.vbext_ct_ClassModule, out component, selection); + var mockHost = new Mock(); + mockHost.SetupAllProperties(); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + + parser.Parse(new CancellationTokenSource()); + if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } + + var qualifiedSelection = new QualifiedSelection(new QualifiedModuleName(component), selection); + + var model = new ExtractInterfaceModel(parser.State, qualifiedSelection); + model.Members.ElementAt(0).IsSelected = true; + + var view = new Mock(); + view.Setup(v => v.ShowDialog()).Returns(DialogResult.Cancel); + + var factory = new ExtractInterfacePresenterFactory(vbe.Object, parser.State, view.Object); + + var presenter = factory.Create(); + + Assert.AreEqual(null, presenter.Show()); + } + + [TestMethod] + public void Presenter_NullTarget_ReturnsNull() + { + //Input + const string inputCode = +@"Public Sub Foo(ByVal arg1 As Integer, ByVal arg2 As String) +End Sub"; + var selection = new Selection(1, 15, 1, 15); + + //Arrange + var builder = new MockVbeBuilder(); + VBComponent component; + var vbe = builder.BuildFromSingleStandardModule(inputCode, out component, selection); + var mockHost = new Mock(); + mockHost.SetupAllProperties(); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + + parser.Parse(new CancellationTokenSource()); + if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } + + var qualifiedSelection = new QualifiedSelection(new QualifiedModuleName(component), selection); + + var model = new ExtractInterfaceModel(parser.State, qualifiedSelection); + + var view = new Mock(); + var presenter = new ExtractInterfacePresenter(view.Object, model); + + Assert.AreEqual(null, presenter.Show()); + } + + [TestMethod] + public void Presenter_Accept_ReturnsUpdatedModel() + { + //Input + const string inputCode = +@"Public Sub Foo(ByVal arg1 As Integer, ByVal arg2 As String) +End Sub"; + var selection = new Selection(1, 15, 1, 15); + + //Arrange + var builder = new MockVbeBuilder(); + VBComponent component; + var vbe = builder.BuildFromSingleModule(inputCode, vbext_ComponentType.vbext_ct_ClassModule, out component, selection); + var mockHost = new Mock(); + mockHost.SetupAllProperties(); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + + parser.Parse(new CancellationTokenSource()); + if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } + + var qualifiedSelection = new QualifiedSelection(new QualifiedModuleName(component), selection); + + var model = new ExtractInterfaceModel(parser.State, qualifiedSelection); + model.Members.ElementAt(0).IsSelected = true; + + var view = new Mock(); + view.Setup(v => v.ShowDialog()).Returns(DialogResult.OK); + view.Setup(v => v.InterfaceName).Returns("Class1"); + + var factory = new ExtractInterfacePresenterFactory(vbe.Object, parser.State, view.Object); + var presenter = factory.Create(); + + Assert.AreEqual("Class1", presenter.Show().InterfaceName); + } + + [TestMethod] + public void Factory_NoMembersInTarget_ReturnsNull() + { + //Input + const string inputCode = +@"Private Sub Foo() +End Sub"; + var selection = new Selection(1, 15, 1, 15); + + //Arrange + var builder = new MockVbeBuilder(); + var projectBuilder = builder.ProjectBuilder("TestProject1", vbext_ProjectProtection.vbext_pp_none); + projectBuilder.AddComponent("Module1", vbext_ComponentType.vbext_ct_StdModule, inputCode, selection); + var project = projectBuilder.Build(); + builder.AddProject(project); + var vbe = builder.Build(); + + var mockHost = new Mock(); + mockHost.SetupAllProperties(); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + + parser.Parse(new CancellationTokenSource()); + if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } + + var factory = new ExtractInterfacePresenterFactory(vbe.Object, parser.State, null); + + Assert.AreEqual(null, factory.Create()); + } + + [TestMethod] + public void Factory_NullSelectionNullReturnsNullPresenter() + { + //Input + const string inputCode = +@"Private Sub Foo() +End Sub"; + + //Arrange + var builder = new MockVbeBuilder(); + var projectBuilder = builder.ProjectBuilder("TestProject1", vbext_ProjectProtection.vbext_pp_none); + projectBuilder.AddComponent("Module1", vbext_ComponentType.vbext_ct_ClassModule, inputCode); + var project = projectBuilder.Build(); + builder.AddProject(project); + var vbe = builder.Build(); + + vbe.Setup(v => v.ActiveCodePane).Returns((CodePane)null); + + var mockHost = new Mock(); + mockHost.SetupAllProperties(); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + + parser.Parse(new CancellationTokenSource()); + if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } + + var factory = new ExtractInterfacePresenterFactory(vbe.Object, parser.State, null); + + Assert.AreEqual(null, factory.Create()); + } + + #region setup + private static Mock> SetupFactory(ExtractInterfaceModel model) + { + var presenter = new Mock(); + presenter.Setup(p => p.Show()).Returns(model); + + var factory = new Mock>(); + factory.Setup(f => f.Create()).Returns(presenter.Object); + return factory; + } + + #endregion + } +} \ No newline at end of file diff --git a/RubberduckTests/Refactoring/ImplementInterfaceTests.cs b/RubberduckTests/Refactoring/ImplementInterfaceTests.cs index 3e525cecd6..3e073f22a6 100644 --- a/RubberduckTests/Refactoring/ImplementInterfaceTests.cs +++ b/RubberduckTests/Refactoring/ImplementInterfaceTests.cs @@ -48,7 +48,60 @@ End Sub var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + + parser.Parse(new CancellationTokenSource()); + if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } + + var qualifiedSelection = new QualifiedSelection(new QualifiedModuleName(component), selection); + var module = project.Object.VBComponents.Item(1).CodeModule; + + //Act + var refactoring = new ImplementInterfaceRefactoring(vbe.Object, parser.State, null); + refactoring.Refactor(qualifiedSelection); + + //Assert + Assert.AreEqual(expectedCode, module.Lines()); + } + + [TestMethod] + public void ImplementInterface_Procedure_ClassHasOtherProcedure() + { + //Input + const string inputCode1 = +@"Public Sub Foo() +End Sub"; + + const string inputCode2 = +@"Implements Class1 +Public Sub Bar() +End Sub"; + + var selection = new Selection(1, 1, 1, 1); + + //Expectation + const string expectedCode = +@"Implements Class1 + +Private Sub Class1_Foo() + Err.Raise 5 'TODO implement interface member +End Sub + +Public Sub Bar() +End Sub"; + + //Arrange + var builder = new MockVbeBuilder(); + var project = builder.ProjectBuilder("TestProject1", vbext_ProjectProtection.vbext_pp_none) + .AddComponent("Class1", vbext_ComponentType.vbext_ct_ClassModule, inputCode1) + .AddComponent("Class2", vbext_ComponentType.vbext_ct_ClassModule, inputCode2) + .Build(); + var vbe = builder.AddProject(project).Build(); + var component = project.Object.VBComponents.Item(1); + + var mockHost = new Mock(); + mockHost.SetupAllProperties(); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -97,7 +150,7 @@ End Sub var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -146,7 +199,7 @@ End Function var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -195,7 +248,7 @@ End Function var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -244,7 +297,7 @@ End Function var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -293,7 +346,7 @@ End Property var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -342,7 +395,7 @@ End Property var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -391,7 +444,7 @@ End Property var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -440,7 +493,7 @@ End Property var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -489,7 +542,7 @@ End Property var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -538,7 +591,7 @@ End Property var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -587,7 +640,7 @@ End Property var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -657,7 +710,84 @@ End Property var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + + parser.Parse(new CancellationTokenSource()); + if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } + + var qualifiedSelection = new QualifiedSelection(new QualifiedModuleName(component), selection); + var module = project.Object.VBComponents.Item(1).CodeModule; + + //Act + var refactoring = new ImplementInterfaceRefactoring(vbe.Object, parser.State, null); + refactoring.Refactor(qualifiedSelection); + + //Assert + Assert.AreEqual(expectedCode, module.Lines()); + } + + [TestMethod] + public void ImplementInterface_AllTypes() + { + //Input + const string inputCode1 = +@"Public Sub Foo(ByVal arg1 As Integer, ByVal arg2 As String) +End Sub + +Public Function Fizz(b) +End Function + +Public Property Get Buzz() As Variant +End Property + +Public Property Let Buzz(value) +End Property + +Public Property Set Buzz(value) +End Property"; + + const string inputCode2 = +@"Implements Class1"; + + var selection = new Selection(1, 1, 1, 1); + + //Expectation + const string expectedCode = +@"Implements Class1 + +Private Sub Class1_Foo(ByVal arg1 As Integer, ByVal arg2 As String) + Err.Raise 5 'TODO implement interface member +End Sub + +Private Function Class1_Fizz(ByRef b As Variant) As Variant + Err.Raise 5 'TODO implement interface member +End Function + +Private Property Get Class1_Buzz() As Variant + Err.Raise 5 'TODO implement interface member +End Property + +Private Property Let Class1_Buzz(ByRef value As Variant) + Err.Raise 5 'TODO implement interface member +End Property + +Private Property Set Class1_Buzz(ByRef value As Variant) + Err.Raise 5 'TODO implement interface member +End Property +"; + + //Arrange + var builder = new MockVbeBuilder(); + var project = builder.ProjectBuilder("TestProject1", vbext_ProjectProtection.vbext_pp_none) + .AddComponent("Class1", vbext_ComponentType.vbext_ct_ClassModule, inputCode1) + .AddComponent("Class2", vbext_ComponentType.vbext_ct_ClassModule, inputCode2) + .Build(); + var vbe = builder.AddProject(project).Build(); + var component = project.Object.VBComponents.Item(1); + + var mockHost = new Mock(); + mockHost.SetupAllProperties(); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } diff --git a/RubberduckTests/Refactoring/IntroduceFieldTests.cs b/RubberduckTests/Refactoring/IntroduceFieldTests.cs index f27050d7a6..c6b0dcf671 100644 --- a/RubberduckTests/Refactoring/IntroduceFieldTests.cs +++ b/RubberduckTests/Refactoring/IntroduceFieldTests.cs @@ -46,7 +46,7 @@ Private Sub Foo() var module = project.VBComponents.Item(0).CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -88,7 +88,7 @@ Private Function Foo() As Boolean var module = project.VBComponents.Item(0).CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -130,7 +130,7 @@ Private Sub Foo(ByVal buz As Integer) var module = project.VBComponents.Item(0).CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -175,7 +175,7 @@ Private Sub Foo(ByVal buz As Integer) var module = project.VBComponents.Item(0).CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -221,7 +221,7 @@ Private Sub Foo(ByVal buz As Integer, _ var module = project.VBComponents.Item(0).CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -267,7 +267,7 @@ bap As Integer var module = project.VBComponents.Item(0).CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -313,7 +313,7 @@ bap As Integer var module = project.VBComponents.Item(0).CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -359,7 +359,7 @@ bat As Date var module = project.VBComponents.Item(0).CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -401,7 +401,7 @@ Private Sub Foo(ByVal buz As Integer, _ var module = project.VBComponents.Item(0).CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -435,7 +435,7 @@ Private Sub Foo() var module = project.VBComponents.Item(0).CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -476,7 +476,7 @@ Private Sub Foo() var module = project.VBComponents.Item(0).CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -523,7 +523,7 @@ Private Sub Foo() var module = project.VBComponents.Item(0).CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -555,7 +555,7 @@ Dim bar As Boolean var module = project.VBComponents.Item(0).CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } diff --git a/RubberduckTests/Refactoring/IntroduceParameterTests.cs b/RubberduckTests/Refactoring/IntroduceParameterTests.cs index 21a6986084..bec0385f53 100644 --- a/RubberduckTests/Refactoring/IntroduceParameterTests.cs +++ b/RubberduckTests/Refactoring/IntroduceParameterTests.cs @@ -45,7 +45,7 @@ Dim bar As Boolean var module = project.VBComponents.Item(0).CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -86,7 +86,7 @@ Dim bar As Boolean var module = project.VBComponents.Item(0).CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -125,7 +125,7 @@ Dim bar As Boolean var module = project.VBComponents.Item(0).CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -167,7 +167,7 @@ As _ var module = project.VBComponents.Item(0).CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -208,7 +208,7 @@ Dim bar As Boolean var module = project.VBComponents.Item(0).CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -253,7 +253,7 @@ bap As Integer var module = project.VBComponents.Item(0).CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -298,7 +298,7 @@ bap As Integer var module = project.VBComponents.Item(0).CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -343,7 +343,7 @@ bat As Date var module = project.VBComponents.Item(0).CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -384,7 +384,7 @@ public void IntroduceParameterRefactoring_MultipleVariablesInStatement_OnOneLine var module = project.VBComponents.Item(0).CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -418,7 +418,7 @@ Private Sub Foo() var module = project.VBComponents.Item(0).CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -459,7 +459,7 @@ Private Sub Foo() var module = project.VBComponents.Item(0).CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -513,7 +513,7 @@ Property Let Foo(ByVal fizz As Boolean, ByVal bar As Integer, ByVal buzz As Bool var module = project.VBComponents.Item(0).CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -560,7 +560,7 @@ Property Set Foo(ByVal fizz As Boolean, ByVal bar As Integer, ByVal buzz As Vari var module = project.VBComponents.Item(0).CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -615,7 +615,7 @@ Sub IClass1_fizz(ByVal boo As Boolean, ByVal fizz As Date) var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -691,7 +691,7 @@ Sub IClass1_fizz(ByVal boo As Boolean, ByVal fizz As Date) var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -744,7 +744,7 @@ Dim fizz As Date var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -791,7 +791,7 @@ Dim bar As Boolean var module = project.VBComponents.Item(0).CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -823,7 +823,7 @@ Dim bar As Boolean var module = project.VBComponents.Item(0).CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } diff --git a/RubberduckTests/Refactoring/MoveCloserToUsageTests.cs b/RubberduckTests/Refactoring/MoveCloserToUsageTests.cs index cee58e7090..c5851a79d4 100644 --- a/RubberduckTests/Refactoring/MoveCloserToUsageTests.cs +++ b/RubberduckTests/Refactoring/MoveCloserToUsageTests.cs @@ -47,7 +47,7 @@ Dim bar As Boolean var module = project.VBComponents.Item(0).CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -92,7 +92,7 @@ Dim bar As Boolean var module = project.VBComponents.Item(0).CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -142,7 +142,7 @@ Dim bar As Boolean var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -189,7 +189,7 @@ Dim bar As Boolean var module = project.VBComponents.Item(0).CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -236,7 +236,7 @@ Dim bar As Boolean var module = project.VBComponents.Item(0).CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -284,7 +284,7 @@ Dim bat As Boolean var module = project.VBComponents.Item(0).CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -331,7 +331,7 @@ Dim bar As Integer var module = project.VBComponents.Item(0).CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -378,7 +378,7 @@ Dim bat As Boolean var module = project.VBComponents.Item(0).CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -425,7 +425,7 @@ Dim bay As Date var module = project.VBComponents.Item(0).CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -474,7 +474,7 @@ Dim bar As Integer var module = project.VBComponents.Item(0).CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -523,7 +523,7 @@ Dim bat As Boolean var module = project.VBComponents.Item(0).CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -572,7 +572,7 @@ Dim bay As Date var module = project.VBComponents.Item(0).CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -605,7 +605,7 @@ Private Sub Foo() var module = project.VBComponents.Item(0).CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -649,7 +649,7 @@ Private Sub Bar() var module = project.VBComponents.Item(0).CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -697,7 +697,7 @@ Dim bar As Boolean var module = project.VBComponents.Item(0).CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -742,7 +742,7 @@ Sub Baz(ByVal bat As Boolean) var module = project.VBComponents.Item(0).CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -791,7 +791,7 @@ Sub Baz(ByVal bat As Boolean, ByVal bas As Boolean, ByVal bac As Boolean) var module = project.VBComponents.Item(0).CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -834,7 +834,7 @@ End Sub var module = project.VBComponents.Item(0).CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -867,7 +867,7 @@ Private Sub Foo() var module = project.VBComponents.Item(0).CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -916,7 +916,7 @@ Private Sub Foo() var module = project.VBComponents.Item(0).CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } diff --git a/RubberduckTests/Refactoring/RemoveParametersTests.cs b/RubberduckTests/Refactoring/RemoveParametersTests.cs index daff929a2d..fe6dabaee4 100644 --- a/RubberduckTests/Refactoring/RemoveParametersTests.cs +++ b/RubberduckTests/Refactoring/RemoveParametersTests.cs @@ -33,7 +33,7 @@ public void RemoveParametersRefactoring_RemoveBothParams() //Expectation const string expectedCode = -@"Private Sub Foo( ) +@"Private Sub Foo() End Sub"; //Arrange @@ -44,7 +44,7 @@ public void RemoveParametersRefactoring_RemoveBothParams() var module = project.VBComponents.Item(0).CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -87,7 +87,7 @@ public void RemoveParametersRefactoring_RemoveOnlyParam() var module = component.CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -120,8 +120,8 @@ public void RemoveParametersRefactoring_RemoveFirstParam() //Expectation const string expectedCode = -@"Private Sub Foo( ByVal arg2 As String) -End Sub"; //note: The IDE strips out the extra whitespace +@"Private Sub Foo(ByVal arg2 As String) +End Sub"; //Arrange var builder = new MockVbeBuilder(); @@ -130,7 +130,7 @@ public void RemoveParametersRefactoring_RemoveFirstParam() var module = component.CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -163,8 +163,8 @@ public void RemoveParametersRefactoring_RemoveSecondParam() //Expectation const string expectedCode = -@"Private Sub Foo(ByVal arg1 As Integer ) -End Sub"; //note: The IDE strips out the extra whitespace +@"Private Sub Foo(ByVal arg1 As Integer) +End Sub"; //Arrange var builder = new MockVbeBuilder(); @@ -173,7 +173,7 @@ public void RemoveParametersRefactoring_RemoveSecondParam() var module = component.CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -211,13 +211,66 @@ End Sub //Expectation const string expectedCode = -@"Public Sub Foo(ByVal arg1 As Integer, ByVal arg2 As String ) +@"Public Sub Foo(ByVal arg1 As Integer, ByVal arg2 As String) End Sub Public Sub Goo() - Foo arg2:=""test44"", arg1:=3 + Foo arg2:=""test44"", arg1:=3 +End Sub +"; + + //Arrange + var builder = new MockVbeBuilder(); + VBComponent component; + var vbe = builder.BuildFromSingleStandardModule(inputCode, out component, selection); + var module = component.CodeModule; + var mockHost = new Mock(); + mockHost.SetupAllProperties(); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + + parser.Parse(new CancellationTokenSource()); + if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } + + var qualifiedSelection = new QualifiedSelection(new QualifiedModuleName(component), selection); + + //Specify Param(s) to remove + var model = new RemoveParametersModel(parser.State, qualifiedSelection, null); + model.Parameters[2].IsRemoved = true; + + //SetupFactory + var factory = SetupFactory(model); + + //Act + var refactoring = new RemoveParametersRefactoring(vbe.Object, factory.Object); + refactoring.Refactor(qualifiedSelection); + + //Assert + Assert.AreEqual(expectedCode, module.Lines()); + } + + [TestMethod] + public void RemoveParametersRefactoring_CallerArgNameContainsOtherArgName() + { + //Input + const string inputCode = +@"Sub foo(a, b, c) + +End Sub + +Sub goo() + foo asd, sdf, s +End Sub"; + var selection = new Selection(1, 23, 1, 27); + + //Expectation + const string expectedCode = +@"Sub foo(a, b) + End Sub -"; //note: The IDE strips out the extra whitespace + +Sub goo() + foo asd, sdf +End Sub"; //Arrange var builder = new MockVbeBuilder(); @@ -226,7 +279,7 @@ End Sub var module = component.CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -259,8 +312,8 @@ public void RemoveParametersRefactoring_RemoveLastFromFunction() //Expectation const string expectedCode = -@"Private Function Foo(ByVal arg1 As Integer ) As Boolean -End Function"; //note: The IDE strips out the extra whitespace +@"Private Function Foo(ByVal arg1 As Integer) As Boolean +End Function"; //Arrange var builder = new MockVbeBuilder(); @@ -269,7 +322,7 @@ public void RemoveParametersRefactoring_RemoveLastFromFunction() var module = component.CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -302,8 +355,8 @@ public void RemoveParametersRefactoring_RemoveAllFromFunction() //Expectation const string expectedCode = -@"Private Function Foo( ) As Boolean -End Function"; //note: The IDE strips out the extra whitespace +@"Private Function Foo() As Boolean +End Function"; //Arrange var builder = new MockVbeBuilder(); @@ -312,7 +365,7 @@ public void RemoveParametersRefactoring_RemoveAllFromFunction() var module = component.CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -350,13 +403,13 @@ End Sub //Expectation const string expectedCode = -@"Private Function Foo( ) As Boolean +@"Private Function Foo() As Boolean End Function Private Sub Goo(ByVal arg1 As Integer, ByVal arg2 As String) - Foo + Foo End Sub -"; //note: The IDE strips out the extra whitespace +"; //Arrange var builder = new MockVbeBuilder(); @@ -365,7 +418,7 @@ End Sub var module = component.CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -387,6 +440,60 @@ End Sub Assert.AreEqual(expectedCode, module.Lines()); } + [TestMethod] + public void RemoveParametersRefactoring_ParentIdentifierContainsParameterName() + { + //Input + const string inputCode = +@"Private Sub foo(a, b, c, d, e, f, g) +End Sub + +Private Sub goo() + foo 1, 2, 3, 4, 5, 6, 7 +End Sub"; + var selection = new Selection(1, 23, 1, 27); + + //Expectation + const string expectedCode = +@"Private Sub foo(a, b, e, g) +End Sub + +Private Sub goo() + foo 1, 2, 5, 7 +End Sub"; + + //Arrange + var builder = new MockVbeBuilder(); + VBComponent component; + var vbe = builder.BuildFromSingleStandardModule(inputCode, out component, selection); + var project = vbe.Object.VBProjects.Item(0); + var module = project.VBComponents.Item(0).CodeModule; + var mockHost = new Mock(); + mockHost.SetupAllProperties(); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + + parser.Parse(new CancellationTokenSource()); + if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } + + var qualifiedSelection = new QualifiedSelection(new QualifiedModuleName(component), selection); + + //Specify Params to remove + var model = new RemoveParametersModel(parser.State, qualifiedSelection, null); + model.Parameters.ElementAt(2).IsRemoved = true; + model.Parameters.ElementAt(3).IsRemoved = true; + model.Parameters.ElementAt(5).IsRemoved = true; + + //SetupFactory + var factory = SetupFactory(model); + + //Act + var refactoring = new RemoveParametersRefactoring(vbe.Object, factory.Object); + refactoring.Refactor(qualifiedSelection); + + //Assert + Assert.AreEqual(expectedCode, module.Lines()); + } + [TestMethod] public void RemoveParametersRefactoring_RemoveFromGetter() { @@ -399,7 +506,7 @@ public void RemoveParametersRefactoring_RemoveFromGetter() //Expectation const string expectedCode = @"Private Property Get Foo() As Boolean -End Property"; //note: The IDE strips out the extra whitespace +End Property"; //Arrange var builder = new MockVbeBuilder(); @@ -408,7 +515,7 @@ public void RemoveParametersRefactoring_RemoveFromGetter() var module = component.CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -441,8 +548,8 @@ public void RemoveParametersRefactoring_QuickFix() //Expectation const string expectedCode = -@"Private Property Set Foo( ByVal arg2 As String) -End Property"; //note: The IDE strips out the extra whitespace +@"Private Property Set Foo(ByVal arg2 As String) +End Property"; //Arrange var builder = new MockVbeBuilder(); @@ -451,7 +558,7 @@ public void RemoveParametersRefactoring_QuickFix() var module = component.CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -483,8 +590,8 @@ public void RemoveParametersRefactoring_RemoveFirstParamFromSetter() //Expectation const string expectedCode = -@"Private Property Set Foo( ByVal arg2 As String) -End Property"; //note: The IDE strips out the extra whitespace +@"Private Property Set Foo(ByVal arg2 As String) +End Property"; //Arrange var builder = new MockVbeBuilder(); @@ -493,7 +600,7 @@ public void RemoveParametersRefactoring_RemoveFirstParamFromSetter() var module = component.CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -531,13 +638,74 @@ End Sub //Expectation const string expectedCode = -@"Private Sub Foo( ByVal arg2 As String) +@"Private Sub Foo(ByVal arg2 As String) End Sub Private Sub Bar() - Foo ""Hello"" + Foo ""Hello"" +End Sub +"; + + //Arrange + var builder = new MockVbeBuilder(); + VBComponent component; + var vbe = builder.BuildFromSingleStandardModule(inputCode, out component, selection); + var module = component.CodeModule; + var mockHost = new Mock(); + mockHost.SetupAllProperties(); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + + parser.Parse(new CancellationTokenSource()); + if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } + + var qualifiedSelection = new QualifiedSelection(new QualifiedModuleName(component), selection); + + //Specify Param(s) to remove + var model = new RemoveParametersModel(parser.State, qualifiedSelection, null); + model.Parameters[0].IsRemoved = true; + + //SetupFactory + var factory = SetupFactory(model); + + //Act + var refactoring = new RemoveParametersRefactoring(vbe.Object, factory.Object); + refactoring.Refactor(qualifiedSelection); + + //Assert + Assert.AreEqual(expectedCode, module.Lines()); + } + + [TestMethod] + public void RemoveParametersRefactoring_ClientReferencesAreUpdated_FirstParam_ParensAroundCall() + { + //Input + const string inputCode = +@"Private Sub bar() + Dim x As Integer + Dim y As Integer + y = foo(x, 42) + Debug.Print y, x End Sub -"; //note: The IDE strips out the extra whitespace + +Private Function foo(ByRef a As Integer, ByVal b As Integer) As Integer + a = b + foo = a + b +End Function"; + var selection = new Selection(8, 20, 8, 20); + + //Expectation + const string expectedCode = +@"Private Sub bar() + Dim x As Integer + Dim y As Integer + y = foo(42) + Debug.Print y, x +End Sub + +Private Function foo(ByVal b As Integer) As Integer + a = b + foo = a + b +End Function"; //Arrange var builder = new MockVbeBuilder(); @@ -546,7 +714,7 @@ End Sub var module = component.CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -584,13 +752,13 @@ End Sub //Expectation const string expectedCode = -@"Private Sub Foo(ByVal arg1 As Integer ) +@"Private Sub Foo(ByVal arg1 As Integer) End Sub Private Sub Bar() - Foo 10 + Foo 10 End Sub -"; //note: The IDE strips out the extra whitespace, you can't see it but there's a space after "Foo 10 " +"; //Arrange var builder = new MockVbeBuilder(); @@ -599,7 +767,7 @@ End Sub var module = component.CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -643,7 +811,7 @@ End Sub //Expectation const string expectedCode = -@"Sub Foo(ByVal arg1 As String ) +@"Sub Foo(ByVal arg1 As String) End Sub Public Sub Goo(ByVal arg1 As Integer, _ @@ -653,9 +821,9 @@ Public Sub Goo(ByVal arg1 As Integer, _ ByVal arg5 As Integer, _ ByVal arg6 As Integer) - Foo ""test"" + Foo ""test"" End Sub -"; //note: The IDE strips out the extra whitespace, you can't see it but there are several spaces after " ParamArrayTest ""test"" " +"; //Arrange var builder = new MockVbeBuilder(); @@ -664,7 +832,7 @@ End Sub var module = component.CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -701,7 +869,7 @@ public void RemoveParametersRefactoring_RemoveLastParamFromSetter_NotAllowed() var vbe = builder.BuildFromSingleStandardModule(inputCode, out component, selection); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -729,7 +897,7 @@ public void RemoveParametersRefactoring_RemoveLastParamFromLetter_NotAllowed() var vbe = builder.BuildFromSingleStandardModule(inputCode, out component, selection); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -759,8 +927,8 @@ Private Property Set Foo(ByVal arg1 As Integer, ByVal arg2 As String) @"Private Property Get Foo() End Property -Private Property Set Foo( ByVal arg2 As String) -End Property"; //note: The IDE strips out the extra whitespace +Private Property Set Foo(ByVal arg2 As String) +End Property"; //Arrange var builder = new MockVbeBuilder(); @@ -769,7 +937,7 @@ Private Property Set Foo( ByVal arg2 As String) var module = component.CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -808,8 +976,8 @@ Private Property Let Foo(ByVal arg1 As Integer, ByVal arg2 As String) @"Private Property Get Foo() End Property -Private Property Let Foo( ByVal arg2 As String) -End Property"; //note: The IDE strips out the extra whitespace +Private Property Let Foo(ByVal arg2 As String) +End Property"; //Arrange var builder = new MockVbeBuilder(); @@ -818,7 +986,7 @@ Private Property Let Foo( ByVal arg2 As String) var module = component.CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -855,7 +1023,7 @@ Foo arg1 //Expectation const string expectedCode = -@"Private Sub Foo( Optional ByVal arg2 As String) +@"Private Sub Foo(Optional ByVal arg2 As String) End Sub Private Sub Goo(ByVal arg1 As Integer) @@ -869,7 +1037,7 @@ Private Sub Goo(ByVal arg1 As Integer) var module = component.CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -891,6 +1059,59 @@ Private Sub Goo(ByVal arg1 As Integer) Assert.AreEqual(expectedCode, module.Lines()); } + [TestMethod] + public void RemoveParametersRefactoring_RemoveOptionalParam() + { + //Input + const string inputCode = +@"Private Sub Foo(ByVal arg1 As Integer, Optional ByVal arg2 As String) +End Sub + +Private Sub Goo(ByVal arg1 As Integer) + Foo arg1 + Foo 1, ""test"" +End Sub"; + var selection = new Selection(1, 23, 1, 27); + + //Expectation + const string expectedCode = +@"Private Sub Foo(ByVal arg1 As Integer) +End Sub + +Private Sub Goo(ByVal arg1 As Integer) + Foo arg1 + Foo 1 +End Sub"; + + //Arrange + var builder = new MockVbeBuilder(); + VBComponent component; + var vbe = builder.BuildFromSingleStandardModule(inputCode, out component, selection); + var module = component.CodeModule; + var mockHost = new Mock(); + mockHost.SetupAllProperties(); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + + parser.Parse(new CancellationTokenSource()); + if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } + + var qualifiedSelection = new QualifiedSelection(new QualifiedModuleName(component), selection); + + //Specify Params to remove + var model = new RemoveParametersModel(parser.State, qualifiedSelection, null); + model.Parameters[1].IsRemoved = true; + + //SetupFactory + var factory = SetupFactory(model); + + //Act + var refactoring = new RemoveParametersRefactoring(vbe.Object, factory.Object); + refactoring.Refactor(qualifiedSelection); + + //Assert + Assert.AreEqual(expectedCode, module.Lines()); + } + [TestMethod] public void RemoveParametersRefactoring_SignatureOnMultipleLines() { @@ -904,7 +1125,7 @@ public void RemoveParametersRefactoring_SignatureOnMultipleLines() //Expectation const string expectedCode = -@"Private Sub Foo( ByVal arg2 As String, ByVal arg3 As Date) +@"Private Sub Foo(ByVal arg2 As String, ByVal arg3 As Date) End Sub"; // note: VBE removes excess spaces //Arrange @@ -914,7 +1135,7 @@ public void RemoveParametersRefactoring_SignatureOnMultipleLines() var module = component.CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -949,7 +1170,7 @@ public void RemoveParametersRefactoring_SignatureOnMultipleLines_RemoveSecond() //Expectation const string expectedCode = -@"Private Sub Foo(ByVal arg1 As Integer, ByVal arg3 As Date) +@"Private Sub Foo(ByVal arg1 As Integer, ByVal arg3 As Date) End Sub"; // note: VBE removes excess spaces //Arrange @@ -959,7 +1180,7 @@ public void RemoveParametersRefactoring_SignatureOnMultipleLines_RemoveSecond() var module = component.CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -994,7 +1215,7 @@ public void RemoveParametersRefactoring_SignatureOnMultipleLines_RemoveLast() //Expectation const string expectedCode = -@"Private Sub Foo(ByVal arg1 As Integer, ByVal arg2 As String ) +@"Private Sub Foo(ByVal arg1 As Integer, ByVal arg2 As String) End Sub"; // note: VBE removes excess spaces //Arrange @@ -1004,7 +1225,7 @@ public void RemoveParametersRefactoring_SignatureOnMultipleLines_RemoveLast() var module = component.CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -1039,7 +1260,7 @@ public void RemoveParametersRefactoring_PassTargetIn() //Expectation const string expectedCode = -@"Private Sub Foo( ByVal arg2 As String, ByVal arg3 As Date) +@"Private Sub Foo(ByVal arg2 As String, ByVal arg3 As Date) End Sub"; // note: VBE removes excess spaces //Arrange @@ -1049,7 +1270,7 @@ public void RemoveParametersRefactoring_PassTargetIn() var module = component.CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -1091,12 +1312,12 @@ End Sub //Expectation const string expectedCode = -@"Private Sub Foo( ByVal arg2 As String, ByVal arg3 As Date) +@"Private Sub Foo(ByVal arg2 As String, ByVal arg3 As Date) End Sub Private Sub Goo(ByVal arg1 as Integer, ByVal arg2 As String, ByVal arg3 As Date) - Foo arg2, arg3 + Foo arg2, arg3 End Sub "; // note: IDE removes excess spaces @@ -1108,7 +1329,7 @@ End Sub var module = component.CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -1147,12 +1368,12 @@ Private Sub IClass1_DoSomething(ByVal a As Integer, ByVal b As String) //Expectation const string expectedCode1 = -@"Public Sub DoSomething(ByVal a As Integer ) +@"Public Sub DoSomething(ByVal a As Integer) End Sub"; const string expectedCode2 = @"Implements IClass1 -Private Sub IClass1_DoSomething(ByVal a As Integer ) +Private Sub IClass1_DoSomething(ByVal a As Integer) End Sub"; // note: IDE removes excess spaces //Arrange @@ -1166,7 +1387,7 @@ Private Sub IClass1_DoSomething(ByVal a As Integer ) var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -1209,12 +1430,12 @@ Private Sub IClass1_DoSomething(ByVal v1 As Integer, ByVal v2 As String) //Expectation const string expectedCode1 = -@"Public Sub DoSomething(ByVal a As Integer ) +@"Public Sub DoSomething(ByVal a As Integer) End Sub"; const string expectedCode2 = @"Implements IClass1 -Private Sub IClass1_DoSomething(ByVal v1 As Integer ) +Private Sub IClass1_DoSomething(ByVal v1 As Integer) End Sub"; // note: IDE removes excess spaces //Arrange @@ -1228,7 +1449,7 @@ Private Sub IClass1_DoSomething(ByVal v1 As Integer ) var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -1276,17 +1497,17 @@ Private Sub IClass1_DoSomething(ByVal i As Integer, ByVal s As String) //Expectation const string expectedCode1 = -@"Public Sub DoSomething(ByVal a As Integer ) +@"Public Sub DoSomething(ByVal a As Integer) End Sub"; const string expectedCode2 = @"Implements IClass1 -Private Sub IClass1_DoSomething(ByVal v1 As Integer ) +Private Sub IClass1_DoSomething(ByVal v1 As Integer) End Sub"; // note: IDE removes excess spaces const string expectedCode3 = @"Implements IClass1 -Private Sub IClass1_DoSomething(ByVal i As Integer ) +Private Sub IClass1_DoSomething(ByVal i As Integer) End Sub"; // note: IDE removes excess spaces //Arrange @@ -1301,7 +1522,7 @@ Private Sub IClass1_DoSomething(ByVal i As Integer ) var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -1346,12 +1567,12 @@ Private Sub abc_Foo(ByVal arg1 As Integer, ByVal arg2 As String) //Expectation const string expectedCode1 = -@"Public Event Foo(ByVal arg1 As Integer )"; +@"Public Event Foo(ByVal arg1 As Integer)"; const string expectedCode2 = @"Private WithEvents abc As Class1 -Private Sub abc_Foo(ByVal arg1 As Integer ) +Private Sub abc_Foo(ByVal arg1 As Integer) End Sub"; // note: IDE removes excess spaces //Arrange @@ -1365,7 +1586,7 @@ Private Sub abc_Foo(ByVal arg1 As Integer ) var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -1410,11 +1631,11 @@ Private Sub abc_Foo(ByVal arg1 As Integer, ByVal arg2 As String) const string expectedCode1 = @"Private WithEvents abc As Class2 -Private Sub abc_Foo(ByVal arg1 As Integer ) +Private Sub abc_Foo(ByVal arg1 As Integer) End Sub"; // note: IDE removes excess spaces const string expectedCode2 = -@"Public Event Foo(ByVal arg1 As Integer )"; +@"Public Event Foo(ByVal arg1 As Integer)"; //Arrange var builder = new MockVbeBuilder(); @@ -1427,7 +1648,7 @@ Private Sub abc_Foo(ByVal arg1 As Integer ) var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -1469,12 +1690,12 @@ Private Sub abc_Foo(ByVal i As Integer, ByVal s As String) //Expectation const string expectedCode1 = -@"Public Event Foo(ByVal arg1 As Integer )"; +@"Public Event Foo(ByVal arg1 As Integer)"; const string expectedCode2 = @"Private WithEvents abc As Class1 -Private Sub abc_Foo(ByVal i As Integer ) +Private Sub abc_Foo(ByVal i As Integer) End Sub"; // note: IDE removes excess spaces //Arrange @@ -1488,7 +1709,7 @@ Private Sub abc_Foo(ByVal i As Integer ) var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -1536,17 +1757,17 @@ Private Sub abc_Foo(ByVal v1 As Integer, ByVal v2 As String) //Expectation const string expectedCode1 = -@"Public Event Foo(ByVal arg1 As Integer )"; +@"Public Event Foo(ByVal arg1 As Integer)"; const string expectedCode2 = @"Private WithEvents abc As Class1 -Private Sub abc_Foo(ByVal i As Integer ) +Private Sub abc_Foo(ByVal i As Integer) End Sub"; // note: IDE removes excess spaces const string expectedCode3 = @"Private WithEvents abc As Class1 -Private Sub abc_Foo(ByVal v1 As Integer ) +Private Sub abc_Foo(ByVal v1 As Integer) End Sub"; // note: IDE removes excess spaces //Arrange @@ -1561,7 +1782,7 @@ Private Sub abc_Foo(ByVal v1 As Integer ) var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -1608,11 +1829,11 @@ Private Sub IClass1_DoSomething(ByVal a As Integer, ByVal b As String) const string expectedCode1 = @"Implements IClass1 -Private Sub IClass1_DoSomething(ByVal a As Integer ) +Private Sub IClass1_DoSomething(ByVal a As Integer) End Sub"; // note: IDE removes excess spaces const string expectedCode2 = -@"Public Sub DoSomething(ByVal a As Integer ) +@"Public Sub DoSomething(ByVal a As Integer) End Sub"; //Arrange @@ -1626,7 +1847,7 @@ Private Sub IClass1_DoSomething(ByVal a As Integer ) var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -1682,7 +1903,7 @@ Private Sub IClass1_DoSomething(ByVal a As Integer, ByVal b As String) var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -1713,7 +1934,7 @@ public void RemoveParams_RefactorDeclaration_FailsInvalidTarget() var vbe = builder.BuildFromSingleStandardModule(inputCode, out component, selection); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -1759,7 +1980,7 @@ public void RemoveParams_PresenterIsNull() var module = component.CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -1789,7 +2010,7 @@ public void RemoveParams_ModelIsNull() var module = component.CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -1825,7 +2046,7 @@ public void Presenter_Accept_ReturnsModelWithParametersChanged() var vbe = builder.BuildFromSingleStandardModule(inputCode, out component, selection); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -1861,7 +2082,7 @@ public void Presenter_Reject_ReturnsNull() var vbe = builder.BuildFromSingleStandardModule(inputCode, out component, selection); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -1897,7 +2118,7 @@ public void Presenter_Accept_AutoMarksSingleParamAsRemoved() var vbe = builder.BuildFromSingleStandardModule(inputCode, out component, selection); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -1933,7 +2154,7 @@ public void Presenter_ParameterlessTargetReturnsNullModel() var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -1967,7 +2188,7 @@ Private Sub Foo(ByVal arg1 As Integer, ByVal arg2 As String) var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -2004,7 +2225,7 @@ public void Factory_NullSelectionNullReturnsNullPresenter() var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } diff --git a/RubberduckTests/Refactoring/RenameTests.cs b/RubberduckTests/Refactoring/RenameTests.cs index c1e5eab500..aaa7224373 100644 --- a/RubberduckTests/Refactoring/RenameTests.cs +++ b/RubberduckTests/Refactoring/RenameTests.cs @@ -43,7 +43,7 @@ public void RenameRefactoring_RenameSub() var module = project.VBComponents.Item(0).CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -92,7 +92,7 @@ Dim val2 As Integer var module = project.VBComponents.Item(0).CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -138,7 +138,7 @@ public void RenameRefactoring_RenameParameter() var module = project.VBComponents.Item(0).CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -194,7 +194,7 @@ End Sub var module = project.VBComponents.Item(0).CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -244,7 +244,7 @@ Dim val2 As Integer var module = project.VBComponents.Item(0).CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -292,7 +292,7 @@ public void RenameRefactoring_RenameParameter_UpdatesReferences() var module = project.VBComponents.Item(0).CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -362,7 +362,7 @@ Dim d As Integer var module = project.VBComponents.Item(0).CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -428,7 +428,7 @@ Dim d As Variant var module = project.VBComponents.Item(0).CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -494,7 +494,7 @@ Dim d As Variant var module = project.VBComponents.Item(0).CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -546,7 +546,7 @@ Private Property Set Goo(ByVal arg1 As Integer, ByVal arg2 As String) var module = project.VBComponents.Item(0).CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -598,7 +598,7 @@ Private Property Let Goo(ByVal arg1 As String) var module = project.VBComponents.Item(0).CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -646,7 +646,7 @@ public void RenameRefactoring_RenameFunction() var module = project.VBComponents.Item(0).CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -706,7 +706,7 @@ End Sub var module = project.VBComponents.Item(0).CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -752,7 +752,7 @@ public void RenameRefactoring_RefactorWithDeclaration() var module = project.VBComponents.Item(0).CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -812,7 +812,7 @@ Private Sub IClass1_DoNothing(ByVal a As Integer, ByVal b As String) var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -874,7 +874,7 @@ Private Sub abc_Goo(ByVal i As Integer, ByVal s As String) var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -938,7 +938,7 @@ Private Sub IClass1_DoNothing(ByVal a As Integer, ByVal b As String) var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -992,7 +992,7 @@ Private Sub IClass1_DoSomething(ByVal a As Integer, ByVal b As String) var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -1024,7 +1024,7 @@ public void Rename_PresenterIsNull() var module = project.VBComponents.Item(0).CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -1062,7 +1062,7 @@ Private Sub Foo(ByVal arg1 As Integer, ByVal arg2 As String) var module = project.VBComponents.Item(0).CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -1097,7 +1097,7 @@ public void Factory_SelectionIsNull() var module = project.VBComponents.Item(0).CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -1132,7 +1132,7 @@ public void Factory_SelectionIsNotNull_Accept() var vbe = builder.BuildFromSingleStandardModule(inputCode, out component, selection); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -1172,7 +1172,7 @@ public void Factory_SelectionIsNotNull_Reject() var module = project.VBComponents.Item(0).CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -1221,7 +1221,7 @@ public void Factory_SelectionIsNotNull_PassInTarget_Accept() var module = project.VBComponents.Item(0).CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -1272,7 +1272,7 @@ public void Factory_SelectionIsNotNull_PassInTarget_Reject() var module = project.VBComponents.Item(0).CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -1321,7 +1321,7 @@ public void RenameRefactoring_RenameProject() var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -1367,7 +1367,7 @@ Dim Goo As Integer var module = project.VBComponents.Item(0).CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -1417,7 +1417,7 @@ Dim Goo As Integer var module = project.VBComponents.Item(0).CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -1465,7 +1465,7 @@ public void RenameRefactoring_RenameCodeModule() var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } diff --git a/RubberduckTests/Refactoring/ReorderParametersTests.cs b/RubberduckTests/Refactoring/ReorderParametersTests.cs index 1192f22019..28becaba5c 100644 --- a/RubberduckTests/Refactoring/ReorderParametersTests.cs +++ b/RubberduckTests/Refactoring/ReorderParametersTests.cs @@ -44,7 +44,101 @@ public void ReorderParams_SwapPositions() var module = project.VBComponents.Item(0).CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + + parser.Parse(new CancellationTokenSource()); + if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } + + var qualifiedSelection = new QualifiedSelection(new QualifiedModuleName(component), selection); + + //set up model + var model = new ReorderParametersModel(parser.State, qualifiedSelection, null); + model.Parameters.Reverse(); + + var factory = SetupFactory(model); + + //act + var refactoring = new ReorderParametersRefactoring(vbe.Object, factory.Object, null); + refactoring.Refactor(qualifiedSelection); + + //assert + Assert.AreEqual(expectedCode, module.Lines()); + } + + [TestMethod] + public void ReorderParams_SwapPositions_SignatureContainsParamName() + { + //Input + const string inputCode = +@"Private Sub Foo(a, ba) +End Sub"; + var selection = new Selection(1, 16, 1, 16); + + //Expectation + const string expectedCode = +@"Private Sub Foo(ba, a) +End Sub"; + + //Arrange + var builder = new MockVbeBuilder(); + VBComponent component; + var vbe = builder.BuildFromSingleStandardModule(inputCode, out component, selection); + var project = vbe.Object.VBProjects.Item(0); + var module = project.VBComponents.Item(0).CodeModule; + var mockHost = new Mock(); + mockHost.SetupAllProperties(); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + + parser.Parse(new CancellationTokenSource()); + if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } + + var qualifiedSelection = new QualifiedSelection(new QualifiedModuleName(component), selection); + + //set up model + var model = new ReorderParametersModel(parser.State, qualifiedSelection, null); + model.Parameters.Reverse(); + + var factory = SetupFactory(model); + + //act + var refactoring = new ReorderParametersRefactoring(vbe.Object, factory.Object, null); + refactoring.Refactor(qualifiedSelection); + + //assert + Assert.AreEqual(expectedCode, module.Lines()); + } + + [TestMethod] + public void ReorderParams_SwapPositions_ReferenceValueContainsOtherReferenceValue() + { + //Input + const string inputCode = +@"Private Sub Foo(a, ba) +End Sub + +Sub Goo() + Foo 1, 121 +End Sub"; + var selection = new Selection(1, 16, 1, 16); + + //Expectation + const string expectedCode = +@"Private Sub Foo(ba, a) +End Sub + +Sub Goo() + Foo 121, 1 +End Sub"; + + //Arrange + var builder = new MockVbeBuilder(); + VBComponent component; + var vbe = builder.BuildFromSingleStandardModule(inputCode, out component, selection); + var project = vbe.Object.VBProjects.Item(0); + var module = project.VBComponents.Item(0).CodeModule; + var mockHost = new Mock(); + mockHost.SetupAllProperties(); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -87,7 +181,7 @@ public void ReorderParams_RefactorDeclaration() var module = project.VBComponents.Item(0).CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -123,7 +217,7 @@ public void ReorderParams_RefactorDeclaration_FailsInvalidTarget() var vbe = builder.BuildFromSingleStandardModule(inputCode, out component, selection); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -177,7 +271,7 @@ public void ReorderParams_WithOptionalParam() var module = project.VBComponents.Item(0).CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -237,7 +331,68 @@ End Sub var module = project.VBComponents.Item(0).CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + + parser.Parse(new CancellationTokenSource()); + if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } + + var qualifiedSelection = new QualifiedSelection(new QualifiedModuleName(component), selection); + + //set up model + var model = new ReorderParametersModel(parser.State, qualifiedSelection, null); + model.Parameters.Reverse(); + + var factory = SetupFactory(model); + + //act + var refactoring = new ReorderParametersRefactoring(vbe.Object, factory.Object, null); + refactoring.Refactor(qualifiedSelection); + + //assert + Assert.AreEqual(expectedCode, module.Lines()); + } + + [TestMethod] + public void RemoveParametersRefactoring_ClientReferencesAreUpdated_ParensAroundCall() + { + //Input + const string inputCode = +@"Private Sub bar() + Dim x As Integer + Dim y As Integer + y = foo(x, 42) + Debug.Print y, x +End Sub + +Private Function foo(ByRef a As Integer, ByVal b As Integer) As Integer + a = b + foo = a + b +End Function"; + var selection = new Selection(8, 20, 8, 20); + + //Expectation + const string expectedCode = +@"Private Sub bar() + Dim x As Integer + Dim y As Integer + y = foo(42, x) + Debug.Print y, x +End Sub + +Private Function foo(ByVal b As Integer, ByRef a As Integer) As Integer + a = b + foo = a + b +End Function"; + + //Arrange + var builder = new MockVbeBuilder(); + VBComponent component; + var vbe = builder.BuildFromSingleStandardModule(inputCode, out component, selection); + var project = vbe.Object.VBProjects.Item(0); + var module = project.VBComponents.Item(0).CodeModule; + var mockHost = new Mock(); + mockHost.SetupAllProperties(); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -290,7 +445,7 @@ End Sub var module = project.VBComponents.Item(0).CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -343,7 +498,7 @@ public void ReorderParametersRefactoring_ReorderNamedParams_Function() var module = project.VBComponents.Item(0).CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -397,7 +552,7 @@ End Sub var module = project.VBComponents.Item(0).CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -448,7 +603,7 @@ public void ReorderParametersRefactoring_ReorderGetter() var module = project.VBComponents.Item(0).CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -499,7 +654,7 @@ public void ReorderParametersRefactoring_ReorderLetter() var module = project.VBComponents.Item(0).CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -543,7 +698,7 @@ public void ReorderParametersRefactoring_ReorderSetter() var module = project.VBComponents.Item(0).CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -580,7 +735,7 @@ public void ReorderParametersRefactoring_ReorderLastParamFromSetter_NotAllowed() var vbe = builder.BuildFromSingleStandardModule(inputCode, out component, selection); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -608,7 +763,7 @@ public void ReorderParametersRefactoring_ReorderLastParamFromLetter_NotAllowed() var vbe = builder.BuildFromSingleStandardModule(inputCode, out component, selection); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -634,7 +789,7 @@ public void ReorderParametersRefactoring_SignatureOnMultipleLines() //Expectation const string expectedCode = -@"Private Sub Foo(ByVal arg3 As Date, ByVal arg2 As String, ByVal arg1 As Integer) +@"Private Sub Foo(ByVal arg3 As Date, ByVal arg2 As String, ByVal arg1 As Integer) End Sub"; // note: IDE removes excess spaces //Arrange @@ -645,7 +800,7 @@ public void ReorderParametersRefactoring_SignatureOnMultipleLines() var module = project.VBComponents.Item(0).CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -705,7 +860,7 @@ End Sub var module = project.VBComponents.Item(0).CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -755,7 +910,7 @@ End Sub var module = project.VBComponents.Item(0).CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -826,7 +981,7 @@ End Sub var module = project.VBComponents.Item(0).CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -911,7 +1066,7 @@ End Sub var module = project.VBComponents.Item(0).CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -960,7 +1115,7 @@ public void ReorderParams_MoveOptionalParamBeforeNonOptionalParamFails() var module = project.VBComponents.Item(0).CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -1023,7 +1178,7 @@ End Sub var module = project.VBComponents.Item(0).CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -1079,7 +1234,7 @@ Private Property Set Foo(ByVal arg2 As String, ByVal arg1 As Integer, ByVal arg3 var module = project.VBComponents.Item(0).CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -1129,7 +1284,7 @@ Private Property Let Foo(ByVal arg2 As String, ByVal arg1 As Integer, ByVal arg3 var module = project.VBComponents.Item(0).CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -1167,7 +1322,7 @@ public void ReorderParams_PresenterIsNull() var module = project.VBComponents.Item(0).CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -1217,7 +1372,7 @@ Private Sub IClass1_DoSomething(ByVal b As String, ByVal a As Integer) var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -1278,7 +1433,7 @@ Private Sub IClass1_DoSomething(ByVal v2 As String, ByVal v1 As Integer) var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -1350,7 +1505,7 @@ Private Sub IClass1_DoSomething(ByVal s As String, ByVal i As Integer) var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -1414,7 +1569,7 @@ Private Sub IClass1_DoSomething(ByVal b As String, ByVal a As Integer) var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -1470,7 +1625,7 @@ Private Sub IClass1_DoSomething(ByVal a As Integer, ByVal b As String) var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -1522,7 +1677,7 @@ Private Sub abc_Foo(ByVal arg2 As String, ByVal arg1 As Integer) var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -1583,7 +1738,7 @@ Private Sub abc_Foo(ByVal arg2 As String, ByVal arg1 As Integer) var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -1644,7 +1799,7 @@ Private Sub abc_Foo(ByVal s As String, ByVal i As Integer) var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -1717,7 +1872,7 @@ Private Sub abc_Foo(ByVal v2 As String, ByVal v1 As Integer) var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -1759,7 +1914,7 @@ public void Presenter_AcceptDialog_ReordersProcedureWithTwoParameters() var vbe = builder.BuildFromSingleStandardModule(inputCode, out component, selection); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -1795,7 +1950,7 @@ public void Presenter_CancelDialogCreatesNullModel() var vbe = builder.BuildFromSingleStandardModule(inputCode, out component, selection); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -1833,7 +1988,7 @@ public void Presenter_ParameterlessMemberCreatesNullModel() var vbe = builder.BuildFromSingleStandardModule(inputCode, out component, selection); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -1867,7 +2022,7 @@ public void Presenter_SingleParameterMemberCreatesNullModel() var vbe = builder.BuildFromSingleStandardModule(inputCode, out component, selection); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -1902,7 +2057,7 @@ Private Sub Foo(ByVal arg1 As Integer, ByVal arg2 As String) var vbe = builder.BuildFromSingleStandardModule(inputCode, out component, selection); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -1932,7 +2087,7 @@ public void Factory_NullSelectionCreatesNullPresenter() var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); vbe.Setup(v => v.ActiveCodePane).Returns((CodePane) null); diff --git a/RubberduckTests/RubberduckTests.csproj b/RubberduckTests/RubberduckTests.csproj index 29bd6bdd84..3616bc7297 100644 --- a/RubberduckTests/RubberduckTests.csproj +++ b/RubberduckTests/RubberduckTests.csproj @@ -86,8 +86,13 @@ + + + + + @@ -139,6 +144,7 @@ + @@ -177,7 +183,6 @@ - diff --git a/RubberduckTests/Settings/GeneralSettingsTests.cs b/RubberduckTests/Settings/GeneralSettingsTests.cs index a58e2b46e8..7f99879ebc 100644 --- a/RubberduckTests/Settings/GeneralSettingsTests.cs +++ b/RubberduckTests/Settings/GeneralSettingsTests.cs @@ -43,7 +43,7 @@ private Configuration GetNondefaultConfig() { var generalSettings = new GeneralSettings { - Language = new DisplayLanguageSetting("sv-SE"), + Language = new DisplayLanguageSetting("fr-CA"), AutoSaveEnabled = true, AutoSavePeriod = 5, Delimiter = '/' diff --git a/RubberduckTests/Settings/HotkeySettingsTests.cs b/RubberduckTests/Settings/HotkeySettingsTests.cs index edfb675f36..2f145c816c 100644 --- a/RubberduckTests/Settings/HotkeySettingsTests.cs +++ b/RubberduckTests/Settings/HotkeySettingsTests.cs @@ -22,7 +22,8 @@ public void DefaultsSetInCtor() new HotkeySetting{Name=RubberduckHotkey.RefactorMoveCloserToUsage.ToString(), IsEnabled=true, HasCtrlModifier = true, HasShiftModifier = true, Key1="C" }, new HotkeySetting{Name=RubberduckHotkey.RefactorRename.ToString(), IsEnabled=true, HasCtrlModifier = true, HasShiftModifier = true, Key1="R" }, new HotkeySetting{Name=RubberduckHotkey.RefactorExtractMethod.ToString(), IsEnabled=true, HasCtrlModifier = true, HasShiftModifier = true, Key1="M" }, - new HotkeySetting{Name=RubberduckHotkey.SourceControl.ToString(), IsEnabled=true, HasCtrlModifier = true, HasShiftModifier = true, Key1="D6" } + new HotkeySetting{Name=RubberduckHotkey.SourceControl.ToString(), IsEnabled=true, HasCtrlModifier = true, HasShiftModifier = true, Key1="D6" }, + new HotkeySetting{Name=RubberduckHotkey.RefactorEncapsulateField.ToString(), IsEnabled=true, HasCtrlModifier = true, HasShiftModifier = true, Key1="E" } }; var settings = new HotkeySettings(); diff --git a/RubberduckTests/SourceControl/ChangesViewModelTests.cs b/RubberduckTests/SourceControl/ChangesViewModelTests.cs index 6c4da336a7..a4780accf7 100644 --- a/RubberduckTests/SourceControl/ChangesViewModelTests.cs +++ b/RubberduckTests/SourceControl/ChangesViewModelTests.cs @@ -86,7 +86,7 @@ public void ProviderCommits_NotificationOnSuccess() lock (errorThrown) { MultiAssert.Aggregate( - () => Assert.AreEqual(e.Message, Rubberduck.UI.RubberduckUI.SourceControl_CommitStatus), + () => Assert.AreEqual(e.Title, Rubberduck.UI.RubberduckUI.SourceControl_CommitStatus), () => Assert.AreEqual(e.InnerMessage, Rubberduck.UI.RubberduckUI.SourceControl_CommitStatus_CommitSuccess), diff --git a/RubberduckTests/SourceControl/SettingsViewModelTests.cs b/RubberduckTests/SourceControl/SettingsViewModelTests.cs index cf1b62de72..925debf9c4 100644 --- a/RubberduckTests/SourceControl/SettingsViewModelTests.cs +++ b/RubberduckTests/SourceControl/SettingsViewModelTests.cs @@ -2,6 +2,7 @@ using System.Windows.Forms; using Microsoft.VisualStudio.TestTools.UnitTesting; using Moq; +using Rubberduck.Settings; using Rubberduck.SourceControl; using Rubberduck.UI; using Rubberduck.UI.SourceControl; @@ -21,7 +22,7 @@ public class SettingsViewModelTests private const string OtherRepoLocation = @"C:\Users\KingLear\Documents"; private const string OtherCommandPromptLocation = @"C:\Windows\System32\WindowsPowerShell\v1.0\powershell.exe"; - private Mock _configService; + private Mock> _configService; private SourceControlSettings _config; private Mock _folderBrowserFactory; @@ -34,7 +35,7 @@ public void Initialize() { _config = new SourceControlSettings(Name, Email, RepoLocation, new List(), CommandPromptLocation); - _configService = new Mock(); + _configService = new Mock>(); _configService.Setup(s => s.Create()).Returns(_config); _folderBrowser = new Mock(); diff --git a/RubberduckTests/SourceControl/SourceControlViewModelTests.cs b/RubberduckTests/SourceControl/SourceControlViewModelTests.cs index 331f6bc6b2..f1a51bd34c 100644 --- a/RubberduckTests/SourceControl/SourceControlViewModelTests.cs +++ b/RubberduckTests/SourceControl/SourceControlViewModelTests.cs @@ -5,9 +5,9 @@ using Microsoft.Vbe.Interop; using Microsoft.VisualStudio.TestTools.UnitTesting; using Moq; -using Rubberduck; using Rubberduck.Parsing; using Rubberduck.Parsing.VBA; +using Rubberduck.Settings; using Rubberduck.SourceControl; using Rubberduck.UI; using Rubberduck.UI.SourceControl; @@ -34,7 +34,7 @@ public class SourceControlViewModelTests private UnsyncedCommitsViewViewModel _unsyncedVM; private SettingsViewViewModel _settingsVM; - private Mock _configService; + private Mock> _configService; private Mock _folderBrowserFactory; private Mock _folderBrowser; @@ -52,7 +52,7 @@ public void InitializeMocks() var mockHost = new Mock(); mockHost.SetupAllProperties(); - _configService = new Mock(); + _configService = new Mock>(); _configService.Setup(c => c.Create()).Returns(GetDummyConfig()); _folderBrowser = new Mock(); @@ -110,9 +110,16 @@ private void VerifyChildPresentersHaveProviders() private void SetupVM() { - _vm = new SourceControlViewViewModel(_vbe.Object, new RubberduckParserState(_vbe.Object, new Mock().Object), new Mock().Object, _providerFactory.Object, _folderBrowserFactory.Object, - _configService.Object, new ChangesView(_changesVM), new BranchesView(_branchesVM), - new UnsyncedCommitsView(_unsyncedVM), new SettingsView(_settingsVM), new CodePaneWrapperFactory(), new Mock().Object); + var views = new List + { + new ChangesView(_changesVM), + new BranchesView(_branchesVM), + new UnsyncedCommitsView(_unsyncedVM), + new SettingsView(_settingsVM) + }; + + _vm = new SourceControlViewViewModel(_vbe.Object, new RubberduckParserState(new Mock().Object), new Mock().Object, _providerFactory.Object, _folderBrowserFactory.Object, + _configService.Object, views, new CodePaneWrapperFactory(), new Mock().Object); } [TestMethod] diff --git a/RubberduckTests/TodoControllerTests.cs b/RubberduckTests/TodoControllerTests.cs deleted file mode 100644 index 035b065865..0000000000 --- a/RubberduckTests/TodoControllerTests.cs +++ /dev/null @@ -1,281 +0,0 @@ -//using System; -//using System.Collections.Generic; -//using System.ComponentModel; -//using Microsoft.VisualStudio.TestTools.UnitTesting; -//using Moq; -//using Rubberduck.Settings; -//using Rubberduck.ToDoItems; -//using Rubberduck.UI; -//using Rubberduck.UI.Settings; - -//namespace RubberduckTests -//{ -// [TestClass] -// public class TodoControllerTests -// { -// private static List GetTestMarkers() -// { -// var markers = new List -// { -// new ToDoMarker("Todo", TodoPriority.Medium), -// new ToDoMarker("Note", TodoPriority.Low), -// new ToDoMarker("Bug", TodoPriority.High) -// }; -// return markers; -// } - -// [TestMethod] -// public void ConstructorWorks() -// { -// //arrange -// var view = new Mock(); -// var addTodoMarkerView = new Mock(); - -// //act -// var controller = new TodoSettingPresenter(view.Object, addTodoMarkerView.Object); - -// //assert -// Assert.IsNotNull(controller); -// } - -// [TestMethod] -// public void ViewTextIsNotNullOrEmptyAfterControllerConstruction() -// { -// //arrange -// var markers = new List {new ToDoMarker("Todo", TodoPriority.Medium)}; - -// var view = new TodoListSettingsUserControl(markers, new Mock>("", false).Object); - -// //assert -// Assert.AreEqual("Todo", view.ActiveMarkerText); -// } - -// [TestMethod] -// public void SetActiveItemChangesViewSelectedIndex() -// { -// //arrange -// var markers = GetTestMarkers(); - -// var view = new TodoListSettingsUserControl(markers, new Mock>("", false).Object); - -// //act -// view.SelectedIndex = 1; - -// Assert.AreEqual(1, view.SelectedIndex); - -// } - -// [TestMethod] -// public void ViewPriorityMatchesAfterSelectionChange() -// { -// var markers = new List -// { -// new ToDoMarker("Todo", TodoPriority.Medium), -// new ToDoMarker("Note", TodoPriority.Low), -// new ToDoMarker("Bug", TodoPriority.High) -// }; - -// var view = new TodoListSettingsUserControl(markers, new Mock>("", false).Object); - -// //act -// view.SelectedIndex = 2; - -// Assert.AreEqual(TodoPriority.High, view.ActiveMarkerPriority); -// } - -// [TestMethod] -// public void ViewTextMatchesAfterSelectionChange() -// { -// var markers = new List -// { -// new ToDoMarker("Todo", TodoPriority.Medium), -// new ToDoMarker("Note", TodoPriority.Low) -// }; - -// var view = new TodoListSettingsUserControl(markers, new Mock>("", false).Object); - -// //act -// view.SelectedIndex = 1; - -// Assert.AreEqual("Note", view.ActiveMarkerText); -// } - -// [TestMethod] -// public void MarkerChangeSavedOnPriorityChanged() -// { -// var markers = GetTestMarkers(); - -// var view = new TodoListSettingsUserControl(markers, new Mock>("", false).Object); - -// view.ActiveMarkerPriority = TodoPriority.High; - -// Assert.AreEqual(view.ActiveMarkerPriority, view.TodoMarkers[0].Priority); -// } - -// [TestMethod] -// public void RemoveReallyDoesRemoveSelectedItem() -// { -// var markers = GetTestMarkers(); - -// var view = new Mock(); -// view.SetupProperty(v => v.TodoMarkers, new BindingList(markers)); - -// // Shut up R#, I need that to process the event -// // ReSharper disable once UnusedVariable -// var presenter = new TodoSettingPresenter(view.Object, new Mock().Object); - -// view.Raise(v => v.RemoveMarker += null, EventArgs.Empty); - -// Assert.AreEqual(markers.Count - 1, view.Object.TodoMarkers.Count); -// } - -// [TestMethod] -// public void AddReallyDoesDisplayAddMarkerWindow() -// { -// var markers = GetTestMarkers(); - -// var addView = new Mock(); - -// var view = new Mock(); -// view.SetupProperty(v => v.TodoMarkers, new BindingList(markers)); - -// // Shut up R#, I need that to process the event -// // ReSharper disable once UnusedVariable -// var presenter = new TodoSettingPresenter(view.Object, addView.Object); - -// view.Raise(v => v.AddMarker += null, EventArgs.Empty); - -// addView.Verify(a => a.Show(), Times.Once()); -// } - -// [TestMethod] -// public void AddMarkerReallyDoesBlockExistingNames() -// { -// var markers = GetTestMarkers(); - -// var addView = new Mock(); -// addView.SetupProperty(a => a.MarkerText, "TODO"); -// addView.SetupProperty(a => a.IsValidMarker); - -// var view = new Mock(); -// view.SetupProperty(v => v.TodoMarkers, new BindingList(markers)); - -// // Shut up R#, I need that to process the event -// // ReSharper disable once UnusedVariable -// var presenter = new TodoSettingPresenter(view.Object, addView.Object); - -// addView.Raise(a => a.TextChanged += null, EventArgs.Empty); - -// Assert.IsFalse(addView.Object.IsValidMarker); -// } - -// [TestMethod] -// public void AddMarkerReallyDoesBlockEmptyNames() -// { -// var markers = GetTestMarkers(); - -// var addView = new Mock(); -// addView.SetupProperty(a => a.MarkerText, ""); -// addView.SetupProperty(a => a.IsValidMarker); - -// var view = new Mock(); -// view.SetupProperty(v => v.TodoMarkers, new BindingList(markers)); - -// // Shut up R#, I need that to process the event -// // ReSharper disable once UnusedVariable -// var presenter = new TodoSettingPresenter(view.Object, addView.Object); - -// addView.Raise(a => a.TextChanged += null, EventArgs.Empty); - -// Assert.IsFalse(addView.Object.IsValidMarker); -// } - -// [TestMethod] -// public void AddMarkerReallyDoesAllowExistingNames() -// { -// var markers = GetTestMarkers(); - -// var addView = new Mock(); -// addView.SetupProperty(a => a.MarkerText, "Hi, guys:"); -// addView.SetupProperty(a => a.IsValidMarker); - -// var view = new Mock(); -// view.SetupProperty(v => v.TodoMarkers, new BindingList(markers)); - -// // Shut up R#, I need that to process the event -// // ReSharper disable once UnusedVariable -// var presenter = new TodoSettingPresenter(view.Object, addView.Object); - -// addView.Raise(a => a.TextChanged += null, EventArgs.Empty); - -// Assert.IsTrue(addView.Object.IsValidMarker); -// } - -// [TestMethod] -// public void AddMarkerReallyDoesAddNewMarker() -// { -// var markers = GetTestMarkers(); - -// var newMarkerText = "Hi, guys:"; -// var newMarkerPriority = TodoPriority.High; - -// var addView = new Mock(); -// addView.SetupProperty(a => a.MarkerText, newMarkerText); -// addView.SetupProperty(a => a.MarkerPriority, newMarkerPriority); -// addView.SetupProperty(a => a.TodoMarkers, markers); - -// var view = new Mock(); -// view.SetupProperty(v => v.TodoMarkers, new BindingList(markers)); - -// // Shut up R#, I need that to process the event -// // ReSharper disable once UnusedVariable -// var presenter = new TodoSettingPresenter(view.Object, addView.Object); - -// addView.Raise(a => a.AddMarker += null, EventArgs.Empty); - -// Assert.IsTrue(view.Object.TodoMarkers.Contains(new ToDoMarker(newMarkerText, newMarkerPriority))); -// } - -// [TestMethod] -// public void AddMarkerHidesOnAdd() -// { -// var markers = GetTestMarkers(); - -// var addView = new Mock(); -// addView.SetupProperty(a => a.MarkerPriority, TodoPriority.Low); -// addView.SetupProperty(a => a.MarkerText, "new marker"); -// addView.SetupProperty(a => a.TodoMarkers, markers); - -// var view = new Mock(); -// view.SetupProperty(v => v.TodoMarkers, new BindingList(markers)); - -// // Shut up R#, I need that to process the event -// // ReSharper disable once UnusedVariable -// var presenter = new TodoSettingPresenter(view.Object, addView.Object); - -// addView.Raise(v => v.AddMarker += null, EventArgs.Empty); - -// addView.Verify(a => a.Hide(), Times.Once()); -// } - -// [TestMethod] -// public void AddMarkerHidesOnCancel() -// { -// var markers = GetTestMarkers(); - -// var addView = new Mock(); -// addView.SetupProperty(a => a.MarkerPriority, TodoPriority.Low); -// addView.SetupProperty(a => a.MarkerText, "new marker"); - -// var view = new Mock(); - -// // Shut up R#, I need that to process the event -// // ReSharper disable once UnusedVariable -// var presenter = new TodoSettingPresenter(view.Object, addView.Object); - -// addView.Raise(v => v.Cancel += null, EventArgs.Empty); - -// addView.Verify(a => a.Hide(), Times.Once()); -// } -// } -//} diff --git a/RubberduckTests/TodoExplorer/TodoExplorerTests.cs b/RubberduckTests/TodoExplorer/TodoExplorerTests.cs index d1f9bc9a7c..8ddd8e6ef2 100644 --- a/RubberduckTests/TodoExplorer/TodoExplorerTests.cs +++ b/RubberduckTests/TodoExplorer/TodoExplorerTests.cs @@ -6,6 +6,7 @@ using Rubberduck.Parsing.VBA; using Rubberduck.Settings; using Rubberduck.UI.ToDoItems; +using Rubberduck.VBEditor.Extensions; using Rubberduck.VBEditor.VBEHost; using RubberduckTests.Mocks; using Rubberduck.Common; @@ -32,7 +33,7 @@ public void PicksUpComments() var vbe = builder.AddProject(project.Build()).Build(); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); var vm = new ToDoExplorerViewModel(parser.State, GetConfigService(), GetOperatingSystemMock().Object); @@ -61,7 +62,7 @@ public void PicksUpComments_StrangeCasing() var vbe = builder.AddProject(project.Build()).Build(); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); var vm = new ToDoExplorerViewModel(parser.State, GetConfigService(), GetOperatingSystemMock().Object); @@ -73,6 +74,37 @@ public void PicksUpComments_StrangeCasing() Assert.IsTrue(comments.SequenceEqual(new[] { "TODO ", "NOTE ", "BUG ", "BUG " })); } + [TestMethod] + public void RemoveRemovesComment() + { + var input = +@"Dim d As Variant ' bug should be Integer"; + + var expected = +@"Dim d As Variant "; + + var builder = new MockVbeBuilder(); + var project = builder.ProjectBuilder("TestProject1", vbext_ProjectProtection.vbext_pp_none) + .AddComponent("Module1", vbext_ComponentType.vbext_ct_StdModule, input) + .Build(); + + var vbe = builder.AddProject(project).Build(); + var mockHost = new Mock(); + mockHost.SetupAllProperties(); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + + var vm = new ToDoExplorerViewModel(parser.State, GetConfigService(), GetOperatingSystemMock().Object); + + parser.Parse(new CancellationTokenSource()); + if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } + + vm.SelectedItem = vm.Items.Single(); + vm.RemoveCommand.Execute(null); + + Assert.AreEqual(expected, project.Object.VBComponents.Item(0).CodeModule.Lines()); + Assert.IsFalse(vm.Items.Any()); + } + private IGeneralConfigService GetConfigService() { var configService = new Mock(); diff --git a/RubberduckTests/UnitTesting/DiscoveryTests.cs b/RubberduckTests/UnitTesting/DiscoveryTests.cs index 52d9b3c3f7..61cc18b535 100644 --- a/RubberduckTests/UnitTesting/DiscoveryTests.cs +++ b/RubberduckTests/UnitTesting/DiscoveryTests.cs @@ -29,7 +29,7 @@ Public Sub TestMethod1() var vbe = builder.AddProject(project.Build()).Build(); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -50,7 +50,7 @@ public void Discovery_IgnoresNonAnnotatedTestMethods() var vbe = builder.AddProject(project.Build()).Build(); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -72,7 +72,7 @@ Public Sub TestMethod1() var vbe = builder.AddProject(project.Build()).Build(); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -95,7 +95,7 @@ Public Sub TestMethod1() var vbe = builder.AddProject(project.Build()).Build(); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -119,7 +119,7 @@ public void Discovery_DiscoversAnnotatedTestInitInGivenTestModule() var vbe = builder.AddProject(project.Build()).Build(); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -145,7 +145,7 @@ public void Discovery_DiscoversAnnotatedTestCleanupInGivenTestModule() var vbe = builder.AddProject(project.Build()).Build(); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -170,7 +170,7 @@ public void Discovery_IgnoresNonAnnotatedTestInitInGivenTestModule() var vbe = builder.AddProject(project.Build()).Build(); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -192,7 +192,7 @@ public void Discovery_IgnoresNonAnnotatedTestCleanupInGivenTestModule() var vbe = builder.AddProject(project.Build()).Build(); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -214,7 +214,7 @@ public void Discovery_IgnoresNonAnnotatedTestInitInGivenNonTestModule() var vbe = builder.AddProject(project.Build()).Build(); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -236,7 +236,7 @@ public void Discovery_IgnoresNonAnnotatedTestCleanupInGivenNonTestModule() var vbe = builder.AddProject(project.Build()).Build(); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -259,7 +259,7 @@ public void Discovery_DiscoversAnnotatedModuleInitInGivenTestModule() var vbe = builder.AddProject(project.Build()).Build(); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -285,7 +285,7 @@ public void Discovery_DiscoversAnnotatedModuleCleanupInGivenTestModule() var vbe = builder.AddProject(project.Build()).Build(); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -310,7 +310,7 @@ public void Discovery_IgnoresNonAnnotatedModuleInitInGivenTestModule() var vbe = builder.AddProject(project.Build()).Build(); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -332,7 +332,7 @@ public void Discovery_IgnoresNonAnnotatedModuleCleanupInGivenTestModule() var vbe = builder.AddProject(project.Build()).Build(); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -354,7 +354,7 @@ public void Discovery_IgnoresNonAnnotatedModuleInitInGivenNonTestModule() var vbe = builder.AddProject(project.Build()).Build(); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -376,7 +376,7 @@ public void Discovery_IgnoresNonAnnotatedModuleCleanupInGivenNonTestModule() var vbe = builder.AddProject(project.Build()).Build(); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } diff --git a/RubberduckTests/UnitTesting/ViewModelTests.cs b/RubberduckTests/UnitTesting/ViewModelTests.cs index 48452ef29b..787558bfa6 100644 --- a/RubberduckTests/UnitTesting/ViewModelTests.cs +++ b/RubberduckTests/UnitTesting/ViewModelTests.cs @@ -30,7 +30,7 @@ Public Sub TestMethod1() var vbe = builder.AddProject(project.Build()).Build(); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); var model = new TestExplorerModel(vbe.Object, parser.State); @@ -55,7 +55,7 @@ Public Sub TestMethod1() var vbe = builder.AddProject(project.Build()).Build(); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); var model = new TestExplorerModel(vbe.Object, parser.State); @@ -86,7 +86,7 @@ Public Sub TestMethod1() var vbe = builder.AddProject(project.Build()).Build(); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); var model = new TestExplorerModel(vbe.Object, parser.State); @@ -113,7 +113,7 @@ Public Sub TestMethod1() var vbe = builder.AddProject(project.Build()).Build(); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); var model = new TestExplorerModel(vbe.Object, parser.State); @@ -140,7 +140,7 @@ Public Sub TestMethod1() var vbe = builder.AddProject(project.Build()).Build(); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); var model = new TestExplorerModel(vbe.Object, parser.State); @@ -179,7 +179,7 @@ Public Sub TestMethod4() var vbe = builder.AddProject(project.Build()).Build(); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); var model = new TestExplorerModel(vbe.Object, parser.State); @@ -221,7 +221,7 @@ Public Sub TestMethod3() var vbe = builder.AddProject(project.Build()).Build(); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); var model = new TestExplorerModel(vbe.Object, parser.State); @@ -257,7 +257,7 @@ Public Sub TestMethod2() var vbe = builder.AddProject(project.Build()).Build(); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); var model = new TestExplorerModel(vbe.Object, parser.State); @@ -287,7 +287,7 @@ Public Sub TestMethod1() var vbe = builder.AddProject(project.Build()).Build(); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); var model = new TestExplorerModel(vbe.Object, parser.State); @@ -316,7 +316,7 @@ Public Sub TestMethod1() var vbe = builder.AddProject(project.Build()).Build(); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); var model = new TestExplorerModel(vbe.Object, parser.State); @@ -345,7 +345,7 @@ Public Sub TestMethod1() var vbe = builder.AddProject(project.Build()).Build(); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); var model = new TestExplorerModel(vbe.Object, parser.State);