public void shouldConcatenateASeriesOfLines()
{
var notifyCalls = new List <Tuple <int, int> >();
var codeModule = new Mock <ICodeModuleWrapper>();
codeModule.Setup(cm => cm.get_Lines(It.IsAny <int>(), It.IsAny <int>()))
.Callback <int, int>((start, count) => notifyCalls.Add(Tuple.Create(start, count)));
var selections = new List <Selection>()
{
new Selection(5, 1, 5, 20), new Selection(10, 1, 12, 20)
};
var model = new Mock <IExtractMethodModel>();
var method = new ExtractedMethod();
method.Accessibility = Accessibility.Private;
method.Parameters = new List <ExtractedParameter>();
method.MethodName = "NewMethod";
model.Setup(m => m.RowsToRemove).Returns(selections);
model.Setup(m => m.Method).Returns(method);
var SUT = new ExtractMethodExtraction();
//Act
SUT.constructLinesOfProc(codeModule.Object, model.Object);
//Assert
Assert.AreEqual(Tuple.Create(5, 1), notifyCalls[0]);
Assert.AreEqual(Tuple.Create(10, 3), notifyCalls[1]);
}
protected override void OnExecute(object parameter)
{
var declarations = _state.AllDeclarations;
var qualifiedSelection = _vbe.GetActiveSelection();
var extractMethodValidation = new ExtractMethodSelectionValidation(declarations);
var canExecute = extractMethodValidation.withinSingleProcedure(qualifiedSelection.Value);
if (!canExecute)
{
return;
}
using (var pane = _vbe.ActiveCodePane)
using (var module = pane.CodeModule)
{
var extraction = new ExtractMethodExtraction();
// bug: access to disposed closure
// todo: make ExtractMethodRefactoring request reparse like everyone else.
var refactoring = new ExtractMethodRefactoring(module, ParseRequest, CreateMethodModel, extraction);
refactoring.InvalidSelection += HandleInvalidSelection;
refactoring.Refactor();
void ParseRequest(object obj) => _state.OnParseRequested(obj);
IExtractMethodModel CreateMethodModel(QualifiedSelection?qs, string code)
{
if (qs == null)
{
return(null);
}
//TODO: Pull these even further back;
// and implement with IProvider<IExtractMethodRule>
var rules = new List <IExtractMethodRule>
{
new ExtractMethodRuleInSelection(),
new ExtractMethodRuleIsAssignedInSelection(),
new ExtractMethodRuleUsedAfter(),
new ExtractMethodRuleUsedBefore()
};
var paramClassify = new ExtractMethodParameterClassification(rules);
var extractedMethod = new ExtractedMethod();
var extractedMethodModel = new ExtractMethodModel(extractedMethod, paramClassify);
extractedMethodModel.extract(declarations, qs.Value, code);
return(extractedMethodModel);
}
}
}
public override void Execute(object parameter)
{
var declarations = _state.AllDeclarations;
var qualifiedSelection = Vbe.ActiveCodePane.GetQualifiedSelection();
var extractMethodValidation = new ExtractMethodSelectionValidation(declarations);
var canExecute = extractMethodValidation.withinSingleProcedure(qualifiedSelection.Value);
if (!canExecute)
{
return;
}
ICodeModuleWrapper codeModuleWrapper = new CodeModuleWrapper(Vbe.ActiveCodePane.CodeModule);
VBComponent vbComponent = Vbe.SelectedVBComponent;
Func <QualifiedSelection?, string, IExtractMethodModel> createMethodModel = (qs, code) =>
{
if (qs == null)
{
return(null);
}
//TODO: Pull these even further back;
// and implement with IProvider<IExtractMethodRule>
var rules = new List <IExtractMethodRule>()
{
new ExtractMethodRuleInSelection(),
new ExtractMethodRuleIsAssignedInSelection(),
new ExtractMethodRuleUsedAfter(),
new ExtractMethodRuleUsedBefore()
};
var paramClassify = new ExtractMethodParameterClassification(rules);
var extractedMethod = new ExtractedMethod();
var extractedMethodModel = new ExtractMethodModel(extractedMethod, paramClassify);
extractedMethodModel.extract(declarations, qs.Value, code);
return(extractedMethodModel);
};
var extraction = new ExtractMethodExtraction();
Action <Object> parseRequest = (obj) => _state.OnParseRequested(obj, vbComponent);
var refactoring = new ExtractMethodRefactoring(codeModuleWrapper, parseRequest, createMethodModel, extraction);
refactoring.InvalidSelection += HandleInvalidSelection;
refactoring.Refactor();
}
public void shouldRemoveLinesFromCodeModuleFromBottomUp()
{
var notifyCalls = new List <Tuple <int, int> >();
var codeModule = new Mock <ICodeModuleWrapper>();
codeModule.Setup(cm => cm.DeleteLines(It.IsAny <int>(), It.IsAny <int>()))
.Callback <int, int>((start, count) => notifyCalls.Add(Tuple.Create(start, count)));
var selections = new List <Selection>()
{
new Selection(5, 1, 5, 20), new Selection(10, 1, 12, 20)
};
var SUT = new ExtractMethodExtraction();
//Act
SUT.removeSelection(codeModule.Object, selections);
//Assert
Assert.AreEqual(Tuple.Create(5, 1), notifyCalls[1]);
Assert.AreEqual(Tuple.Create(10, 3), notifyCalls[0]);
}
public void shouldNotProduceDuplicateDimOfz()
{
#region inputCode
var inputCode = @"
Option explicit
Public Sub CodeWithDeclaration()
Dim x as long
Dim y as long
x = 1 + 2
DebugPrint x '8
y = x + 1
Dim z as long
z = x
DebugPrint z '12
x = 2
DebugPrint y
End Sub '17
Public Sub DebugPrint(byval g as long)
End Sub
'20
";
var selectedCode = @"
DebugPrint x '8
y = x + 1
Dim z as long
z = x
DebugPrint z '12
";
var expectedCode = @"
Option explicit
Public Sub CodeWithDeclaration()
Dim x as long
Dim y as long
x = 1 + 2
NewMethod x, y
x = 2
DebugPrint y
End Sub '17
Private Sub NewMethod(ByRef x As long, ByRef y As long)
Dim z as long
DebugPrint x '8
y = x + 1
z = x
DebugPrint z '12
End Sub
Public Sub DebugPrint(byval g as long)
End Sub
'20
";
#endregion
QualifiedModuleName qualifiedModuleName;
RubberduckParserState state;
MockParser.ParseString(inputCode, out qualifiedModuleName, out state);
var declarations = state.AllDeclarations;
var selection = new Selection(8, 1, 12, 50);
QualifiedSelection?qSelection = new QualifiedSelection(qualifiedModuleName, selection);
List <IExtractMethodRule> emRules = new List <IExtractMethodRule>()
{
new ExtractMethodRuleInSelection(),
new ExtractMethodRuleIsAssignedInSelection(),
new ExtractMethodRuleUsedBefore(),
new ExtractMethodRuleUsedAfter(),
new ExtractMethodRuleExternalReference()
};
var codeModule = new CodeModuleWrapper(qualifiedModuleName.Component.CodeModule);
var extractedMethod = new ExtractedMethod();
var paramClassify = new ExtractMethodParameterClassification(emRules);
var model = new ExtractMethodModel(extractedMethod, paramClassify);
model.extract(declarations, qSelection.Value, selectedCode);
var SUT = new ExtractMethodExtraction();
//Act
SUT.apply(codeModule, model, selection);
//Assert
var actual = codeModule.get_Lines(1, 1000);
Assert.AreEqual(expectedCode, actual);
}
