public static RefactoringChange Refactor(GaugeMethod method, IList <Tuple <int, int> > parameterPositions,
IList <string> parameters, string newStepValue)
{
var tree = CSharpSyntaxTree.ParseText(File.ReadAllText(method.FileName));
var root = tree.GetRoot();
var stepMethods = from node in root.DescendantNodes().OfType <MethodDeclarationSyntax>()
let attributeSyntaxes = node.AttributeLists.SelectMany(syntax => syntax.Attributes)
let classDef = node.Parent as ClassDeclarationSyntax
where string.CompareOrdinal(node.Identifier.ValueText, method.Name) == 0 &&
string.CompareOrdinal(classDef.Identifier.ValueText, method.ClassName) == 0 &&
attributeSyntaxes.Any(syntax =>
string.CompareOrdinal(syntax.ToFullString(), LibType.Step.FullName()) > 0)
select node;
var stepMethod = stepMethods.First();
var stepSpan = stepMethod.AttributeLists.WithStepAttribute().Attributes.GetStepAttribute()
.ArgumentList.Arguments.First().GetLocation().GetLineSpan();
var paramsSpan = stepMethod.ParameterList.GetLocation().GetLineSpan();
var updatedAttribute = ReplaceAttribute(stepMethod, newStepValue);
var updatedParameters = ReplaceParameters(stepMethod, parameterPositions, parameters);
var declarationSyntax = stepMethod
.WithAttributeLists(updatedAttribute)
.WithParameterList(updatedParameters);
var replaceNode = root.ReplaceNode(stepMethod, declarationSyntax);
var change = new RefactoringChange
{
FileName = method.FileName,
Diffs = new List <Diff>(),
FileContent = replaceNode.ToFullString()
};
change.Diffs.Add(CreateDiff(stepSpan, $"\"{newStepValue}\""));
change.Diffs.Add(CreateDiff(paramsSpan, updatedParameters.ToFullString().Trim()));
return(change);
}
private static FileChanges ConvertToProtoFileChanges(RefactoringChange fileChanges)
{
var chages = new FileChanges
{
FileName = fileChanges.FileName,
FileContent = fileChanges.FileContent
};
foreach (var fileChangesDiff in fileChanges.Diffs)
{
chages.Diffs.Add(new TextDiff
{
Content = fileChangesDiff.Content,
Span = new Span
{
Start = fileChangesDiff.Range.Start.Line,
StartChar = fileChangesDiff.Range.Start.Character,
End = fileChangesDiff.Range.End.Line,
EndChar = fileChangesDiff.Range.End.Character
}
});
}
return(chages);
}
private void AssertParametersExist(RefactoringChange result, string methodName, IReadOnlyList <string> parameters)
{
var name = methodName.Split('.').Last().Split('-').First();
var tree =
CSharpSyntaxTree.ParseText(result.FileContent);
var root = tree.GetRoot();
var methodParameters = root.DescendantNodes().OfType <MethodDeclarationSyntax>()
.Where(syntax => string.CompareOrdinal(syntax.Identifier.Text, name) == 0)
.Select(syntax => syntax.ParameterList)
.SelectMany(syntax => syntax.Parameters)
.Select(syntax => syntax.Identifier.Text)
.ToArray();
for (var i = 0; i < parameters.Count; i++)
{
Assert.AreEqual(parameters[i], methodParameters[i]);
}
}
private void AssertStepAttributeWithTextExists(RefactoringChange result, string methodName, string text)
{
var name = methodName.Split('.').Last().Split('-').First();
var tree =
CSharpSyntaxTree.ParseText(result.FileContent);
var root = tree.GetRoot();
var stepTexts = root.DescendantNodes().OfType <MethodDeclarationSyntax>()
.Select(
node => new { node, attributeSyntaxes = node.AttributeLists.SelectMany(syntax => syntax.Attributes) })
.Where(t => string.CompareOrdinal(t.node.Identifier.ValueText, name) == 0
&&
t.attributeSyntaxes.Any(
syntax => string.CompareOrdinal(syntax.ToFullString(), typeof(Step).ToString()) > 0))
.SelectMany(t => t.node.AttributeLists.SelectMany(syntax => syntax.Attributes))
.SelectMany(syntax => syntax.ArgumentList.Arguments)
.Select(syntax => syntax.GetText().ToString().Trim('"'));
Assert.True(stepTexts.Contains(text));
}
