public override ActionResult ApplyActionTo(StringBuilder sb)
{
if (FunctionToChange.Name == NewName)
{
return(new ActionResult());
}
// Search FunctionToChange TextRange for name
int searchStart = FunctionToChange.TextRange.StartOffset;
int searchEnd = FunctionToChange.TextRange.EndOffset;
string text = sb.ToString();
int nameIndex = InsertionHelpers.GetFunctionNameIndex(text, FunctionToChange, searchStart, searchEnd);
// The last "word" between the start of the property and the name is the type.
var substring = text.Substring(nameIndex, searchEnd - nameIndex);
var name = Regex.Split(substring, @"\s+").Where(s => !string.IsNullOrEmpty(s)).FirstOrDefault();
if (string.IsNullOrEmpty(name))
{
log.ErrorFormat("Could not find name of function {0} to change.", FunctionToChange.Name);
return(new ActionResult());
}
// Find the index of the existing type
int nameLength = name.Length;
// Replace the old type with the new one.
sb.Replace(name, NewName, nameIndex, nameLength);
FunctionToChange.Name = NewName;
return(new ActionResult(searchStart + nameIndex, NewName.Length - nameLength, null));
}
public override ActionResult ApplyActionTo(StringBuilder sb)
{
int startSearch = PropertyToAddTo.TextRange.StartOffset;
string text = sb.ToString();
// Put the new Attribute just in front of the property declaration.
int insertionPoint = text.LastIndexOf("\n", startSearch) + 1;
AttributeSection section = new AttributeSection(AttributeToAdd.Controller);
section.AddAttribute(AttributeToAdd);
section.PreceedingBlankLines = -1;
var indentLevel = InsertionHelpers.GetIndentationInFrontOf(text, startSearch);
section.Controller.IndentLevel = indentLevel;
string newText = Helper.StandardizeLineBreaks(section.ToString(), "\n") + "\n";
// Calculate the Attribute's Text Range
// The start index is the insertion point + the number of tabs in front of the attribute, +1 for the \n
AttributeToAdd.TextRange.StartOffset = insertionPoint + indentLevel + 1;
AttributeToAdd.TextRange.EndOffset = AttributeToAdd.TextRange.StartOffset + (newText.Trim()).Length;
sb.Insert(insertionPoint, newText);
PropertyToAddTo.AttributeSections.Add(section);
//return new ActionResult(insertionPoint, newText.Length, new[] { AttributeToAdd });
return(new ActionResult(AttributeToAdd.TextRange.StartOffset, newText.Length, new[] { AttributeToAdd }));
}
public override ActionResult ApplyActionTo(StringBuilder sb)
{
int searchStart = PropertyToChange.TextRange.StartOffset;
int searchEnd = PropertyToChange.TextRange.EndOffset;
string text = sb.ToString();
// Find the opening brace.
var endOfOpeningBraceIndex = text.IndexOf("{", searchStart, searchEnd - searchStart) + 1;
int numTabs = InsertionHelpers.GetIndentationInFrontOf(text, searchStart) + 1;
NewAccessor.Controller.IndentLevel = numTabs;
string newAccessorText = Helper.RemoveTrailingLineBreaks(NewAccessor.ToString());
// The "+ numTabs + 2" is account for the /r/n and the tabs that are at the start
// of the new text. If we don't trim those off the text range, then it will
// include the whitespace before the actual property, which the objects which have actually
// been parsed will not have. If this number is wrong, the next object to be placed after it
// will not be able to get the tabs correctly.
NewAccessor.TextRange.StartOffset = endOfOpeningBraceIndex + numTabs + 2;
NewAccessor.TextRange.EndOffset = endOfOpeningBraceIndex + newAccessorText.Length - (numTabs + 2);
NewAccessor.Index = endOfOpeningBraceIndex + numTabs + 2;
sb.Insert(endOfOpeningBraceIndex, newAccessorText);
// Add accessor to the property
PropertyToChange.AddChild(NewAccessor);
NewAccessor.Parent = PropertyToChange;
NewAccessor.Controller = PropertyToChange.Controller;
//return new ActionResult(endOfOpeningBraceIndex, newAccessorText.Length, new[] { NewAccessor });
return(new ActionResult(NewAccessor.TextRange.StartOffset, newAccessorText.Length, new[] { NewAccessor }));
}
protected ActionResult InsertAtStartOfParent(StringBuilder sb)
{
int searchStart = ClassToAddTo.TextRange.StartOffset;
int searchEnd = ClassToAddTo.TextRange.EndOffset;
var text = sb.ToString();
// Figure out where the first NewLine is after the class's opening brace
int braceIndex = text.IndexOf("{", searchStart, searchEnd - searchStart);
// Find the first NewLine after the brace
int newLineIndex = text.IndexOf("\n", braceIndex, searchEnd - braceIndex);
// Indent one level further than the Class we are adding to.
int numTabs = InsertionHelpers.GetIndentationInFrontOf(text, braceIndex) + 1;
ConstructToAdd.Controller.IndentLevel = numTabs;
ConstructToAdd.PreceedingBlankLines = -1;
string newPropertyText = ConstructToAdd.ToString();
int insertionIndex = newLineIndex + 1;
ConstructToAdd.TextRange.StartOffset = insertionIndex + numTabs;
ConstructToAdd.TextRange.EndOffset = insertionIndex + (newPropertyText).Length - numTabs;
ConstructToAdd.Index = insertionIndex + numTabs;
BeforeInsert(insertionIndex, newPropertyText);
sb.Insert(insertionIndex, newPropertyText);
//return new ActionResult(insertionIndex, newPropertyText.Length, new[] { ConstructToAdd });
return(new ActionResult(ConstructToAdd.TextRange.StartOffset, newPropertyText.Length, new[] { ConstructToAdd }));
}
public override ActionResult ApplyActionTo(StringBuilder sb)
{
int searchStart = FunctionToChange.TextRange.StartOffset;
int searchEnd = FunctionToChange.TextRange.EndOffset;
string text = sb.ToString();
if (InsertAtStart)
{
sb.Insert(searchStart, NewModifier + " ");
FunctionToChange.Modifiers.Insert(0, NewModifier);
return(new ActionResult(searchStart, NewModifier.Length + 1, null));
}
int nameIndex = InsertionHelpers.GetFunctionNameIndex(text, FunctionToChange, searchStart, searchEnd);
// Search Function TextRange for class keyword
// The last "word" between the start of the function and the name is the return-type.
var substring = text.Substring(0, nameIndex);
string typeName = InsertionHelpers.GetLastWord(substring);
if (typeName == null)
{
log.ErrorFormat("Could not find return-type of function {0} to change, so can't insert modifier before it.", FunctionToChange.Name);
return(new ActionResult());
}
// Find the index of the existing type
int typeIndex = substring.LastIndexOf(typeName);
//Insert the new modifier just before the class keyword
sb.Insert(typeIndex, NewModifier + " ");
FunctionToChange.Modifiers.Add(NewModifier);
return(new ActionResult(typeIndex, NewModifier.Length + 1, null));
}
public override ActionResult ApplyActionTo(StringBuilder sb)
{
int searchStart = FieldToChange.TextRange.StartOffset;
int searchEnd = FieldToChange.TextRange.EndOffset;
string text = sb.ToString();
int nameIndex = InsertionHelpers.GetFieldNameIndex(text, FieldToChange, searchStart, searchEnd);
int endOfNameIndex = nameIndex + FieldToChange.Name.Length + 1;
// Find the old initial value and remove it, if it exists
int lengthRemoved = searchEnd - endOfNameIndex;
sb.Remove(endOfNameIndex, lengthRemoved);
string textToInsert = "";
if (!string.IsNullOrWhiteSpace(NewInitialValue))
{
textToInsert = string.Format(" = {0};", NewInitialValue);
sb.Insert(endOfNameIndex + 1, textToInsert);
}
// Add the new modifier only if it is not null
if (string.IsNullOrEmpty(NewInitialValue))
{
FieldToChange.InitialValue = "";
return(new ActionResult(searchStart, -lengthRemoved, null));
}
sb.Insert(searchStart, NewInitialValue + " ");
FieldToChange.InitialValue = NewInitialValue;
return(new ActionResult(searchStart, textToInsert.Length + 1 - lengthRemoved, null));
}
protected ActionResult InsertAtEndOfParent(StringBuilder sb, IBaseConstruct insertAfter)
{
if (insertAfter == null)
{
return(InsertAtStartOfParent(sb));
}
int lastSiblingStartOffset = insertAfter.TextRange.StartOffset;
int lastSiblingEndOffset = insertAfter.TextRange.EndOffset;
int endIndex = ClassToAddTo.TextRange.EndOffset;
string text = sb.ToString();
if (lastSiblingEndOffset < 0 || string.IsNullOrWhiteSpace(text))
{
return(InsertAtStartOfParent(sb));
}
int firstNewLine;
if (endIndex > lastSiblingEndOffset)
{
firstNewLine = text.IndexOf('\n', lastSiblingEndOffset, (endIndex - lastSiblingEndOffset));
}
else
{
firstNewLine = text.IndexOf('\n', lastSiblingEndOffset);
}
int newStartIndex = firstNewLine + 1;
int numTabs = InsertionHelpers.GetIndentationInFrontOf(sb, lastSiblingStartOffset);
ConstructToAdd.Controller.IndentLevel = numTabs;
ConstructToAdd.PreceedingBlankLines = -1;
string newPropertyText = ConstructToAdd.ToString();
// The "+ numTabs" is account for the tabs that are at the start
// of the new text. If we don't trim those off the text range, then it will
// include the whitespace before the actual property, which the objects which have actually
// been parsed will not have. If this number is wrong, the next object to be placed after it
// will not be able to get the tabs correctly.
ConstructToAdd.TextRange.StartOffset = newStartIndex + numTabs;
ConstructToAdd.TextRange.EndOffset = newStartIndex + numTabs + newPropertyText.Trim().Length;
ConstructToAdd.Index = newStartIndex + numTabs;
BeforeInsert(newStartIndex, newPropertyText);
sb.Insert(newStartIndex, newPropertyText);
return(new ActionResult(ConstructToAdd.TextRange.StartOffset, newPropertyText.Length, new[] { ConstructToAdd }));
}
public override ActionResult ApplyActionTo(StringBuilder sb)
{
int searchStart = ClassToChange.TextRange.StartOffset;
int searchEnd = ClassToChange.TextRange.EndOffset;
string text = sb.ToString();
if (InsertAtStart)
{
sb.Insert(searchStart, NewModifier + " ");
ClassToChange.Modifiers.Insert(0, NewModifier);
return(new ActionResult(searchStart, NewModifier.Length + 1, null));
}
// Search Class TextRange for class keyword
int classIndex = InsertionHelpers.GetClassKeywordIndex(text, searchStart, searchEnd);
//Insert the new modifier just before the class keyword
sb.Insert(classIndex, NewModifier + " ");
ClassToChange.Modifiers.Add(NewModifier);
return(new ActionResult(classIndex, NewModifier.Length + 1, null));
}
public override ActionResult ApplyActionTo(StringBuilder sb)
{
int searchStart = ClassToChange.TextRange.StartOffset;
int searchEnd = ClassToChange.TextRange.EndOffset;
string text = sb.ToString();
// Find the :
int colonIndex = text.IndexOf(":", searchStart, searchEnd - searchStart);
// Find the first brace after that
int firstBraceIndex = text.IndexOf("{", colonIndex, searchEnd - colonIndex);
// Trim to just the text between the : and {
text = text.Substring(colonIndex, firstBraceIndex - colonIndex);
// Remove each instance of the implement text between the : and {
// as well as the whitespace and comma that comes just after it.
Regex removalRegex = new Regex(@"[\s,]+" + ImplementToRemove);
var newText = removalRegex.Replace(text, "");
// Remove the implement from the class object.
ClassToChange.BaseNames.RemoveAll(s => s == ImplementToRemove);
if (ClassToChange.BaseNames.Count == 0)
{
// Remove the colon as well by moving the start of the removal
// to just before it.
colonIndex--;
int numTabs = InsertionHelpers.GetIndentationInFrontOf(sb, searchStart);
newText = Environment.NewLine + new string('\t', numTabs);
}
sb.Remove(colonIndex, firstBraceIndex - colonIndex);
sb.Insert(colonIndex, newText);
return(new ActionResult(colonIndex, newText.Length - (firstBraceIndex - colonIndex), null));
}
public override ActionResult ApplyActionTo(StringBuilder sb)
{
if (FieldToChange.DataType.ToString() == NewType.ToString())
{
return(new ActionResult());
}
// Search FieldToChange TextRange for name
int searchStart = FieldToChange.TextRange.StartOffset;
int searchEnd = FieldToChange.TextRange.EndOffset;
string text = sb.ToString();
int nameIndex = InsertionHelpers.GetFieldNameIndex(text, FieldToChange, searchStart, searchEnd);
// The last "word" between the start of the field and the name is the type.
var substring = text.Substring(searchStart, nameIndex - searchStart);
int dataTypeStart = substring.IndexOf(FieldToChange.DataType.ToString());
var typeName = substring.Substring(dataTypeStart).TrimEnd(); // FieldToChange.DataType.ToString();
if (typeName == null)
{
log.ErrorFormat("Could not find type of field {0} to change.", FieldToChange.Name);
return(new ActionResult());
}
// Find the index of the existing type
int typeIndex = substring.LastIndexOf(typeName);
int typeLength = typeName.Length;
// Replace the old type with the new one.
var newTypeName = NewType.ToString();
sb.Replace(typeName, newTypeName, searchStart + typeIndex, typeLength);
FieldToChange.DataType = NewType;
return(new ActionResult(searchStart + typeIndex, newTypeName.Length - typeLength, null));
}