internal static string GetTextToFirstMatch(TextPoint startPoint, string matchString)
{
var startEditPoint = startPoint.CreateEditPoint();
var endEditPoint = startEditPoint.CreateEditPoint();
TextRanges subGroupMatches = null;
if (endEditPoint.FindPattern(matchString, StandardFindOptions, ref endEditPoint, ref subGroupMatches))
{
return startEditPoint.GetText(endEditPoint);
}
return null;
}
void Execute(TextPoint StartPoint, TextPoint EndPoint, bool force)
{
TextDocument doc = (TextDocument)(_applicationObject.ActiveDocument.
Object("TextDocument"));
//if (StartPoint.Line == EndPoint.Line && StartPoint.LineCharOffset == EndPoint.LineCharOffset)
// return;
if (AStyle.fileMode == AStyleInterface.AstyleFilemode.CPP && doc.Language != "C/C++")
return;
if (AStyle.fileMode == AStyleInterface.AstyleFilemode.JAVA && doc.Language != "Java")
return;
if (AStyle.fileMode == AStyleInterface.AstyleFilemode.SHARP && doc.Language != "C#")
return;
if (!force && !AStyle.working)
return;
EditPoint startEditPoint = StartPoint.CreateEditPoint();
EditPoint curEditPoint = StartPoint.CreateEditPoint();
EditPoint endEditPoint = EndPoint.CreateEditPoint();
startEditPoint.StartOfLine();
curEditPoint.StartOfLine();
endEditPoint.EndOfLine();
string text = curEditPoint.GetText(endEditPoint);
String textOut = AStyle.FormatSource(text, AStyleInterface.AstyleFilemode.SHARP);
int hashik = text.GetHashCode() ^ endEditPoint.AbsoluteCharOffset;
if(_hashes.Contains(hashik))
return;
if (textOut.TrimStart('\t') == text.TrimStart('\t'))
return;
if (_hashes.Count > 1000000)
_hashes.Clear(); // no memory licking!
_hashes.Add(hashik);
var curOffset = doc.Selection.ActivePoint.AbsoluteCharOffset;
int beginLinePos = curEditPoint.AbsoluteCharOffset;
int beforeLength = endEditPoint.AbsoluteCharOffset - startEditPoint.AbsoluteCharOffset;
curEditPoint.Delete(endEditPoint);
curEditPoint.Insert(textOut);
curEditPoint.MoveToAbsoluteOffset(startEditPoint.AbsoluteCharOffset + textOut.Length);
doc.Selection.Cancel();
doc.Selection.MoveToPoint(startEditPoint, false);
doc.Selection.MoveToPoint(curEditPoint, true);
_applicationObject.ExecuteCommand("Edit.FormatSelection", "");
curEditPoint.EndOfLine();
if (curOffset > beginLinePos)
{
doc.Selection.MoveToAbsoluteOffset(curOffset - beforeLength
+ (curEditPoint.AbsoluteCharOffset - startEditPoint.AbsoluteCharOffset), false);
_applicationObject.ExecuteCommand("Edit.FormatSelection", "");
}
else
doc.Selection.MoveToAbsoluteOffset(curOffset, false);
}
private EditPoint Expand(TextPoint point, Action<EditPoint> foundAction)
{
EditPoint i = point.CreateEditPoint();
EditPoint result = null;
do
{
var line = i.Line;
var text = i.GetLine();
if (CodeCommentHelper.LineMatchesRegex(i, _commentLineRegex).Success)
{
result = i.CreateEditPoint();
foundAction(i);
// If result and iterator line are the same, the found action (move line up or
// down) did nothing. This means there is no point to keep searching, it would
// create an infinite loop.
if (result.Line == i.Line)
{
break;
}
}
else
{
if (i != null && result != null && CodeCommentHelper.LineMatchesRegex(i, _codeLineRegex).Success)
{
result = null;
}
i = null;
}
} while (i != null);
return result;
}
/// <summary>
/// Expands a text point to the full comment.
/// </summary>
/// <param name="point">The original text point to expand from.</param>
private void Expand(TextPoint point)
{
var i = point.CreateEditPoint();
// Look up to find the start of the comment.
_startPoint = Expand(point, p => p.LineUp());
// If a valid start is found, look down to find the end of the comment.
if (_startPoint != null)
{
_endPoint = Expand(point, p => p.LineDown());
}
if (StartPoint != null && EndPoint != null)
{
_startPoint.StartOfLine();
_endPoint.EndOfLine();
IsValid = true;
}
else
{
IsValid = false;
}
}
/// <summary>
/// Expand a textpoint to the full comment, in the direction specified by the <paramref name="foundAction"/>.
/// </summary>
/// <param name="point">The initial starting point for the expansion.</param>
/// <param name="foundAction">An action which advances the search either up or down.</param>
/// <returns>
/// The endpoint of the comment, or <c>null</c> if the expansion did not find a valid comment.
/// </returns>
private EditPoint Expand(TextPoint point, Action<EditPoint> foundAction)
{
EditPoint current = point.CreateEditPoint();
EditPoint result = null;
string prefix = null;
do
{
var line = current.Line;
var text = current.GetLine();
var match = _commentLineRegex.Match(text);
if (match.Success)
{
// Cancel the expansion if the prefix does not match. This takes priority over
// the initial spacer check to allow formatting comments adjacent to Stylecop
// SA1626 style commented code.
var currentPrefix = match.Groups["prefix"].Value.TrimStart();
if (prefix != null && !string.Equals(prefix, currentPrefix))
{
break;
}
else
{
prefix = currentPrefix;
}
// The initial spacer is required, otherwise we assume this is commented out
// code and do not format.
if (match.Groups["initialspacer"].Success)
{
result = current.CreateEditPoint();
foundAction(current);
// If result and iterator line are the same, the found action (move line up or
// down) did nothing. This means we're at the start or end of the file, and
// there is no point to keep searching, it would create an infinite loop.
if (result.Line == current.Line)
{
break;
}
}
else
{
// Did not succesfully match the intial spacer, we have to assume this is
// code and cancel all formatting.
result = null;
current = null;
}
}
else
{
current = null;
}
} while (current != null);
return result;
}
private EditPoint Expand(TextPoint point, Action<EditPoint> foundAction)
{
EditPoint current = point.CreateEditPoint();
EditPoint result = null;
string prefix = null;
do
{
var line = current.Line;
var text = current.GetLine();
var match = _commentLineRegex.Match(text);
if (match.Success)
{
// The initial spacer is required, otherwise we assume this is commented out
// code and do not format.
if (match.Groups["initialspacer"].Success)
{
// Get the comment prefix for the current line.
var currentPrefix = match.Groups["prefix"].Value.TrimStart();
if (prefix == null) { prefix = currentPrefix; }
// Cancel the expanding if the prefix does not match.
if (prefix != currentPrefix)
{
break;
}
result = current.CreateEditPoint();
foundAction(current);
// If result and iterator line are the same, the found action (move line up or
// down) did nothing. This means we're at the start or end of the file, and
// there is no point to keep searching, it would create an infinite loop.
if (result.Line == current.Line)
{
break;
}
}
else
{
// This is code! Set to null to abandon loop.
result = null;
current = null;
}
}
else
{
current = null;
}
} while (current != null);
return result;
}
/// <summary>Parses for strings by iterating through the text lines.</summary>
/// <param name="element">The element.</param>
/// <param name="stringResources">The string resources.</param>
/// <param name="settings">The settings.</param>
/// <param name="isCSharp">If set to <c>true</c> it is CSharp code.</param>
/// <param name="startLine">The start line.</param>
/// <param name="endLine">The end line.</param>
/// <returns>The last parsed line number or -1.</returns>
private static int ParseForStrings(CodeElement element,
List <StringResource> stringResources,
Settings settings,
bool isCSharp,
int startLine,
int endLine)
{
TextPoint startPoint = element.StartPoint,
endPoint = element.EndPoint;
EditPoint2 editPoint = null;
try
{
if (element.Kind == vsCMElement.vsCMElementFunction)
{
#if DEBUG_OUTPUT
System.Diagnostics.Debug.Print(" function kind: {0}", (element as CodeFunction).FunctionKind);
#endif
try
{
//we want to have the body only (throws COMException when inspecting an expression bodied function)
startPoint = element.GetStartPoint(vsCMPart.vsCMPartBody);
endPoint = element.GetEndPoint(vsCMPart.vsCMPartBody);
}
catch (Exception ex)
{
System.Diagnostics.Debug.Print("ParseForStrings(vsCMElementFunction, line {0}): {1} - {2}", startPoint.Line, ex.GetType().Name, ex.Message);
}
}
editPoint = startPoint.CreateEditPoint() as EditPoint2;
int editLine = editPoint.Line,
editColumn = editPoint.LineCharOffset;
string text = editPoint.GetText(endPoint);
string[] txtLines = text.Replace("\r", string.Empty).Split('\n');
bool isComment = false;
#if IGNORE_METHOD_ARGUMENTS
bool isIgnoreMethodArguments = false;
#endif
foreach (string txtLine in txtLines)
{
if ((editLine >= startLine) && (editLine <= endLine))
{
//this is a changed text line in the block
#if !IGNORE_METHOD_ARGUMENTS
if (txtLine.Contains("\""))
{
ParseForStrings(txtLine, editLine, editColumn, stringResources, settings, isCSharp, ref isComment);
}
#else
if (line.Contains("\""))
{
ParseForStrings(line, editLine, editColumn, stringResources, settings, ref isComment, ref isIgnoreMethodArguments);
}
#endif
}
++editLine;
//only for the first line of the text block LineCharOffset will be used
if (editColumn > 1)
{
editColumn = 1;
}
}
}
catch (Exception ex)
{
System.Diagnostics.Debug.Print("### Error: ParseForStrings(): {0} - {1}", ex.GetType().Name, ex.Message);
}
return(endPoint?.Line ?? (-1));
}
/// <summary>Parses for strings by iterating through the FileCodeModel.</summary>
/// <param name="startPoint">The start point.</param>
/// <param name="endPoint">The end point.</param>
/// <param name="lastDocumentLength">Last length of the document.</param>
private void ParseForStrings(TextPoint startPoint,
TextPoint endPoint,
int lastDocumentLength)
{
//0.35-0.06 seconds (threaded: 2.47-1.77 seconds)
List <StringResource> stringResources = new List <StringResource>();
bool isFullDocument = startPoint.AtStartOfDocument && endPoint.AtEndOfDocument,
isTextWithStringLiteral = true;
int startLine = startPoint.Line,
startCol = startPoint.LineCharOffset,
endLine = endPoint.Line,
endCol = endPoint.LineCharOffset,
documentLength = endPoint.Parent.EndPoint.Line,
insertIndex = 0;
if (isFullDocument)
{
m_StringResources.Clear();
}
else
{
#region document manipulated -> adapt string resources and locations
//determine whether the text between startLine and endLine (including) contains double quotes
EditPoint editPoint = startPoint.CreateEditPoint() as EditPoint2;
if (!startPoint.AtStartOfLine)
{
editPoint.StartOfLine();
}
isTextWithStringLiteral = editPoint.GetLines(startLine, endLine + 1).Contains("\"");
//move trailing locations behind changed lines if needed and
//remove string resources on changed lines
int lineOffset = documentLength - lastDocumentLength;
#if DEBUG_OUTPUT
System.Diagnostics.Debug.Print(" Line offset is {0}", lineOffset);
#endif
for (int i = m_StringResources.Count - 1; i >= 0; --i)
{
StringResource stringResource = m_StringResources[i];
int lineNo = stringResource.Location.X;
if (lineNo + lineOffset > endLine)
{
if (lineOffset != 0)
{
#if DEBUG_OUTPUT
System.Diagnostics.Debug.Print(" Move string literal from line {0} to {1}", lineNo, lineNo + lineOffset);
#endif
stringResource.Offset(lineOffset, 0); //move
}
}
else if (lineNo >= startLine)
{
#if DEBUG_OUTPUT
System.Diagnostics.Debug.Print(" Remove string literal {0} ({1}): {2}", i, stringResource.Location, stringResource.Text);
#endif
m_StringResources.RemoveAt(i); //remove changed line
}
else if (insertIndex == 0)
{
#if DEBUG_OUTPUT
System.Diagnostics.Debug.Print(" List insert index is {0} / {1}", i + 1, m_StringResources.Count - 1);
#endif
insertIndex = i + 1;
}
}
#endregion
}
#if DEBUG_OUTPUT
System.Diagnostics.Debug.Print(" Text has{0} string literals.", isTextWithStringLiteral ? string.Empty : " no");
#endif
if (isTextWithStringLiteral)
{
CodeElements elements = m_Window.Document.ProjectItem.FileCodeModel.CodeElements;
foreach (CodeElement element in elements)
{
ParseForStrings(element, m_DoProgress, stringResources, m_Settings, m_IsCSharp, startLine, endLine);
#if DEBUG
if (element.Kind == vsCMElement.vsCMElementProperty)
{
CodeProperty prop = element as CodeProperty;
if ((prop.Getter == null) && (prop.Setter == null))
{
}
}
#endif
}
#if DEBUG_OUTPUT
System.Diagnostics.Debug.Print(" Found {0} string literals", stringResources.Count);
#endif
if (isFullDocument)
{
m_StringResources.AddRange(stringResources);
}
else if (stringResources.Count > 0)
{
m_StringResources.InsertRange(insertIndex, stringResources);
}
}
m_DoCompleted(isFullDocument || (stringResources.Count > 0));
}
private void EditMigrations(Dictionary <string, string> properties)
{
// Edit migrations
var migration = _viewModel.SelectedMigration.CodeType;
var cc = migration as CodeClass;
// get functions
var members = cc.Members;
// list of ints
List <int> migrations = new List <int>();
// iterate through functions
foreach (CodeElement member in members)
{
var func = member as CodeFunction;
if (func == null)
{
continue;
}
// TODO: investigate use of CodeFunction
var createIndex = member.Name == "Create";
if (createIndex)
{
migrations.Add(0);
continue;
}
var index = member.Name.IndexOf("UpdateFrom");
if (index == -1)
{
continue;
}
migrations.Add(Int32.Parse(member.Name.Last().ToString()));
}
// sort numbers, just in case
migrations.Sort();
// get new update number
var update = migrations.Count == 0 ? 0 : migrations.Last() + 1;
// create method, either update or create
var methodName = update == 0 ? "Create" : "UpdateFrom" + update;
CodeFunction cf = cc.AddFunction(methodName, vsCMFunction.vsCMFunctionFunction, vsCMTypeRef.vsCMTypeRefInt, -1, vsCMAccess.vsCMAccessPublic);
// access new method
TextPoint tp = cf.GetStartPoint(vsCMPart.vsCMPartBody);
TextPoint end = cf.GetEndPoint(vsCMPart.vsCMPartBody);
EditPoint ep = tp.CreateEditPoint();
// delete auto generated code
ep.Delete(end);
var partName = _viewModel.PartName.Trim();
// add part bits and bobs
if (_viewModel.Attachable)
{
ep.Insert(String.Format(@"ContentDefinitionManager.AlterPartDefinition(""{0}"", builder => builder", partName) + Environment.NewLine);
// make attachable
ep.Insert(".Attachable()");
// add description
if (!String.IsNullOrEmpty(_viewModel.HelpText))
{
ep.Insert(Environment.NewLine + @".WithDescription(""" + _viewModel.HelpText + @""")");
}
ep.Insert(");" + Environment.NewLine + Environment.NewLine);
}
// add record migration
if (_viewModel.Storage.Contains("Record Storage"))
{
ep.Insert(String.Format(@"SchemaBuilder.CreateTable(""{0}Record"", table => table", partName) +
Environment.NewLine +
".ContentPartRecord()");
foreach (var prop in properties)
{
ep.Insert(Environment.NewLine + ".Column<" + prop.Value + @">(""" + prop.Key + @""")");
}
ep.Insert(");" + Environment.NewLine + Environment.NewLine);
}
// create widget
if (_viewModel.CreateWidget)
{
ep.Insert(String.Format(@"ContentDefinitionManager.AlterTypeDefinition(""{0}"", widget => widget", (_viewModel.WidgetName ?? partName + "Widget").Trim()) +
Environment.NewLine +
@".WithPart(""CommonPart"")" +
Environment.NewLine +
@".WithPart(""WidgetPart"")" +
Environment.NewLine +
@".WithPart(""" + partName + @""")" +
Environment.NewLine +
@".WithSetting(""Stereotype"", ""Widget"")"
);
ep.Insert(");" + Environment.NewLine + Environment.NewLine + Environment.NewLine);
}
var returnVal = update + 1;
ep.Insert("return" + returnVal);
// format document
tp.CreateEditPoint().SmartFormat(ep);
}
public ICheckCPPoint CheckCursorPos()
{
ICheckCPPoint checkPnt = null;
Document activeDoc = ChartPoints.Globals.dte.ActiveDocument;
string projName = activeDoc.ProjectItem.ContainingProject.Name;
TextSelection sel = (TextSelection)activeDoc.Selection;
TextPoint caretPnt = (TextPoint)sel.ActivePoint;
VCCodeElement targetClassElem;
for (;;)
{
// checks if we are in text document
if (activeDoc == null)
{
break;
}
var textDoc = activeDoc.Object() as TextDocument;
if (textDoc == null)
{
break;
}
// we work only with project items
ProjectItem projItem = activeDoc.ProjectItem;
if (projItem == null)
{
break;
}
// only c++ items
FileCodeModel fcModel = projItem.FileCodeModel;
if (fcModel == null)
{
break;
}
if (fcModel.Language != CodeModelLanguageConstants.vsCMLanguageVC)
{
break;
}
vcCodeModel.Synchronize();// !!! MOVE TO METHOD ???
// chartpoint allowed only in class methods
CodeElement elem = fcModel.CodeElementFromPoint(caretPnt, vsCMElement.vsCMElementFunction);
if (elem == null)
{
break;
}
if (elem.Kind != vsCMElement.vsCMElementFunction)
{
break;
}
VCCodeFunction targetFunc = (VCCodeFunction)elem;
if (targetFunc == null)
{
break;
}
// check that we are in method definition (not declaration) in case of declaration in one file & definition in other
if (!targetFunc.File.Equals(activeDoc.FullName, StringComparison.OrdinalIgnoreCase))
{
break;
}
// we are working only with class methods not global function
targetFunc.CodeModel.Synchronize();
targetFunc.CodeModel.SynchronizeFiles();
foreach (CodeElement _cl in targetFunc.CodeModel.Classes)
{
foreach (CodeElement _f in _cl.Children)
{
if (targetFunc.FullName.Equals(_f.FullName, StringComparison.OrdinalIgnoreCase))
{
targetFunc = (VCCodeFunction)_f;
break;
}
}
}
targetClassElem = (VCCodeElement)targetFunc.Parent;
if (targetClassElem == null)
{
break;
}
if (targetClassElem.Kind != vsCMElement.vsCMElementClass)
{
targetClassElem = null;
break;
}
VCCodeClass ownerClass = (VCCodeClass)targetClassElem;
TextPoint startFuncBody = targetFunc.StartPointOf[vsCMPart.vsCMPartBody, vsCMWhere.vsCMWhereDefinition];
TextPoint endFuncBody = targetFunc.EndPointOf[vsCMPart.vsCMPartBody, vsCMWhere.vsCMWhereDefinition];
EditPoint startPnt = startFuncBody.CreateEditPoint();
EditPoint endPnt = endFuncBody.CreateEditPoint();
startPnt.FindPattern("{", (int)vsFindOptions.vsFindOptionsBackwards);
endPnt.FindPattern("}");
if ((caretPnt.Line > startPnt.Line && caretPnt.Line < endPnt.Line) ||
(caretPnt.Line == startPnt.Line && caretPnt.LineCharOffset >= startPnt.LineCharOffset) ||
(caretPnt.Line == endPnt.Line && caretPnt.LineCharOffset <= endPnt.LineCharOffset))
{
// Oh, oh you're in the body, now.. (c)
int linePos = (caretPnt.Line == startPnt.Line ? startPnt.LineCharOffset + 1 : 1 /*0*/);
checkPnt = new CheckCPPoint(ownerClass, projName, activeDoc.Name, System.IO.Path.GetFullPath(activeDoc.FullName).ToLower(), caretPnt.Line, linePos);
return(checkPnt);
}
break;
}
return(checkPnt);
}
public override CodeFunction GenerateTest(CodeClass unitTestCodeClass, CodeProperty originalClassCodeProperty)
{
vsCMFunction functionKind = vsCMFunction.vsCMFunctionFunction;
object functionType = null;
functionKind = vsCMFunction.vsCMFunctionFunction;
functionType = vsCMTypeRef.vsCMTypeRefVoid;
//functionKind = vsCMFunction.vsCMFunctionSub;
//functionType = vsCMTypeRef.vsCMTypeRefVoid;
string nextAvailableName = originalClassCodeProperty.Name;
if (!CodeSelectionHandler.CanGenerateHandleCodeFunction(unitTestCodeClass,
nextAvailableName))
{
nextAvailableName = GetNextAvailableCopyName(unitTestCodeClass, ref nextAvailableName, unitTestCodeClass.ProjectItem.ContainingProject);
}
CodeFunction unitTestCodeFunction = unitTestCodeClass.AddFunction(
nextAvailableName,
functionKind,
functionType,
-1,
originalClassCodeProperty.Access,
-1);
unitTestCodeFunction.AddAttribute("NUnit.Framework.Test", "", -1);
try{
unitTestCodeFunction.Comment = originalClassCodeProperty.Comment;
unitTestCodeFunction.DocComment = originalClassCodeProperty.DocComment;
}
catch (Exception ex) {
Logger.LogException(ex);
//ignore
}
TextPoint bodyStartingPoint =
unitTestCodeFunction.GetStartPoint(vsCMPart.vsCMPartBody);
EditPoint boydEditPoint = bodyStartingPoint.CreateEditPoint();
//Stop here if not read-write type property now...
if (originalClassCodeProperty.Setter == null)
{
boydEditPoint = bodyStartingPoint.CreateEditPoint();
boydEditPoint.Insert(StringHelper.GetTabString() + "// Property is not read-write please add your own code here." + Environment.NewLine);
//boydEditPoint.Insert(StringHelper.GetTabString() + "' Property is not read-write please add your own code here." + Environment.NewLine);
return(unitTestCodeFunction);
}
string tvFunctionCallTemplate = string.Empty; // "iv{0}Type.{1} = default({2});";
tvFunctionCallTemplate = "iv{0}Type.{1} = default({2});" + Environment.NewLine;
// tvFunctionCallTemplate = "iv{0}Type.{1} = New {2}()" + Environment.NewLine;
string tvFunctionCall = tvFunctionCallTemplate;
CodeTypeRef tvPropertyType = originalClassCodeProperty.Type;
string tvPropertyTypeAsString = tvPropertyType.AsString;
tvFunctionCall = string.Format(tvFunctionCall, ((CodeClass)originalClassCodeProperty.Parent).Name, originalClassCodeProperty.Name, tvPropertyTypeAsString);
bodyStartingPoint = unitTestCodeFunction.GetStartPoint(vsCMPart.vsCMPartBody);
boydEditPoint = bodyStartingPoint.CreateEditPoint();
//FIX ME (tabing)
boydEditPoint.Insert(StringHelper.GetTabString() + tvFunctionCall + Environment.NewLine);
//FIX ME (tabbing)
string tvTempString = string.Empty; // "iv{0}Type.{1}, default({2})";
tvTempString = "iv{0}Type.{1}, default({2})";
// tvTempString = "iv{0}Type.{1}, New {2}()";
tvTempString = string.Format(tvTempString, ((CodeClass)originalClassCodeProperty.Parent).Name, originalClassCodeProperty.Name, tvPropertyTypeAsString);
boydEditPoint.Insert(Environment.NewLine);
boydEditPoint.Insert("\t\t\t// TODO: Update Assert to meet test needs" + Environment.NewLine);
boydEditPoint.Insert("\t\t\t//Assert.AreEqual(" + tvTempString + ");" + Environment.NewLine);
boydEditPoint.Insert("\t\t\t" + Environment.NewLine);
boydEditPoint.Insert("\t\t\tthrow new Exception(\"Not Implemented\");" + Environment.NewLine);
return(unitTestCodeFunction);
}
public override CodeFunction GenerateTest(CodeClass unitTestCodeClass, CodeFunction originalClassCodeFuntion)
{
vsCMFunction functionKind = vsCMFunction.vsCMFunctionFunction;
object functionType = null;
functionKind = vsCMFunction.vsCMFunctionFunction;
functionType = vsCMTypeRef.vsCMTypeRefVoid;
/*
* functionKind = vsCMFunction.vsCMFunctionSub;
* functionType = vsCMTypeRef.vsCMTypeRefVoid;
*/
string nextAvailableName = originalClassCodeFuntion.Name;
if (!CodeSelectionHandler.CanGenerateHandleCodeFunction(unitTestCodeClass,
nextAvailableName))
{
nextAvailableName = GetNextAvailableCopyName(unitTestCodeClass, ref nextAvailableName, unitTestCodeClass.ProjectItem.ContainingProject);
}
CodeFunction unitTestCodeFunction = unitTestCodeClass.AddFunction(
nextAvailableName,
functionKind,
functionType,
-1,
originalClassCodeFuntion.Access,
-1);
bool tvIsStatic = originalClassCodeFuntion.IsShared;
//add the NUnit attribute to the function
unitTestCodeFunction.AddAttribute("NUnit.Framework.Test", "", -1);
try{
unitTestCodeFunction.Comment = originalClassCodeFuntion.Comment;
unitTestCodeFunction.DocComment = originalClassCodeFuntion.DocComment;
}
catch (Exception ex) {
//ignore, for some reason the doc throws in vb
Logger.LogException(ex);
}
string tvFunctionCallTemplate = string.Empty; //"iv{0}Type.{1}(";
string tvFunctionReturnTemplate = string.Empty; //"{0} iv{1}Return = ";
tvFunctionCallTemplate = "iv{0}Type.{1}(";
if (tvIsStatic)
{
tvFunctionCallTemplate = "{0}.{1}(";
}
tvFunctionReturnTemplate = "{0} iv{1}Return = ";
//tvFunctionReturnTemplate = "Dim iv{1}Return As {0} = ";
string tvTempParameterList = string.Empty;
string tvFunctionCall = tvFunctionCallTemplate;
string tvFunctionReturn = tvFunctionReturnTemplate;
if (!originalClassCodeFuntion.FunctionKind.ToString().Equals("vsCMFunctionConstructor"))
{
CodeElements tvParameters = originalClassCodeFuntion.Parameters;
foreach (CodeElement tvCodeElement in tvParameters)
{
if (!tvFunctionCall.Equals(tvFunctionCallTemplate))
{
tvFunctionCall += ", ";
}
CodeParameter2 tvCodeParameter = (CodeParameter2)tvCodeElement;
string parameterName = tvCodeParameter.Name;
CodeTypeRef tvParameterType = tvCodeParameter.Type;
vsCMParameterKind tvParameterKind = tvCodeParameter.ParameterKind;
string parameterTypeAsString = tvParameterType.AsString;
tvTempParameterList += parameterTypeAsString + " " + parameterName + " = default(" + parameterTypeAsString + ");" + Environment.NewLine + StringHelper.GetTabString();
//tvTempParameterList += "Dim " + parameterName + " As " + parameterTypeAsString + " = New " + parameterTypeAsString + "()" + Environment.NewLine + StringHelper.GetTabString();
if (tvParameterKind == vsCMParameterKind.vsCMParameterKindRef)
{
tvFunctionCall += "ref " + parameterName;
// tvFunctionCall += parameterName;
}
else if (tvParameterKind == vsCMParameterKind.vsCMParameterKindOut)
{
tvFunctionCall += "out " + parameterName;
// tvFunctionCall += parameterName
}
else if (tvParameterKind == vsCMParameterKind.vsCMParameterKindIn)
{
tvFunctionCall += "in " + parameterName;
//tvFunctionCall += parameterName;
}
else
{
tvFunctionCall += parameterName;
}
}
tvFunctionCall = string.Format(tvFunctionCall + ");" + Environment.NewLine, ((CodeClass)originalClassCodeFuntion.Parent).Name, originalClassCodeFuntion.Name);
//tvFunctionCall = string.Format(tvFunctionCall + ")" + Environment.NewLine, ((CodeClass)originalClassCodeFuntion.Parent).Name, originalClassCodeFuntion.Name);
}
if (originalClassCodeFuntion.Type.TypeKind != vsCMTypeRef.vsCMTypeRefVoid)
{
tvFunctionReturn = string.Format(tvFunctionReturn, originalClassCodeFuntion.Type.AsString, originalClassCodeFuntion.Name);
tvFunctionCall = tvFunctionReturn + tvFunctionCall;
}
TextPoint bodyStartingPoint =
unitTestCodeFunction.GetStartPoint(vsCMPart.vsCMPartBody);
EditPoint boydEditPoint = bodyStartingPoint.CreateEditPoint();
if (!originalClassCodeFuntion.FunctionKind.ToString().Equals("vsCMFunctionConstructor"))
{
boydEditPoint.Insert("\t\t\t// TODO: Update variable/s' defaults to meet test needs" + Environment.NewLine);
//boydEditPoint.Insert("\t\t\t' TODO: Update variable/s' defaults to meet test needs" + Environment.NewLine);
boydEditPoint.Insert(StringHelper.GetTabString() + tvTempParameterList + Environment.NewLine);
boydEditPoint.Insert(StringHelper.GetTabString() + tvFunctionCall + Environment.NewLine);
}
if (originalClassCodeFuntion.Type.TypeKind != vsCMTypeRef.vsCMTypeRefVoid)
{
string stringHolder = "iv{0}Return";
stringHolder = string.Format(stringHolder, originalClassCodeFuntion.Name);
//FIX ME (tabing)
//boydEditPoint.Insert(string.Format("\t\t\tAssert.AreEqual({0}, default({1}));\r\n", stringHolder, originalClassCodeFuntion.Type.AsString));
}
boydEditPoint.Insert(Environment.NewLine);
boydEditPoint.Insert("\t\t\t//TODO: Update Assert to meet test needs" + Environment.NewLine);
boydEditPoint.Insert("\t\t\t//Assert.AreEqual( , );" + Environment.NewLine);
boydEditPoint.Insert("\t\t\t" + Environment.NewLine);
boydEditPoint.Insert("\t\t\tthrow new Exception(\"Not Implemented\");" + Environment.NewLine);
return(unitTestCodeFunction);
}
/// <summary>
/// Explores given method using VB lookuper
/// </summary>
protected override void Explore(AbstractBatchCommand parentCommand, CodeFunction2 codeFunction, CodeNamespace parentNamespace, CodeElement2 codeClassOrStruct, Predicate <CodeElement> exploreable, bool isLocalizableFalse)
{
if (codeFunction.MustImplement)
{
return; // method must not be abstract
}
if (!exploreable(codeFunction as CodeElement))
{
return; // predicate must eval to true
}
// there is no way of knowing whether a function is not declared 'extern'. In that case, following will throw an exception.
string functionText = null;
try {
functionText = codeFunction.GetText(); // get method text
} catch (Exception) { }
if (string.IsNullOrEmpty(functionText))
{
return;
}
TextPoint startPoint = codeFunction.GetStartPoint(vsCMPart.vsCMPartBody);
// is method decorated with Localizable(false)
bool functionLocalizableFalse = (codeFunction as CodeElement).HasLocalizableFalseAttribute();
var list = parentCommand.LookupInVB(functionText, startPoint, parentNamespace, codeClassOrStruct, codeFunction.Name, null, isLocalizableFalse || functionLocalizableFalse);
// add context to result items (surounding few lines of code)
EditPoint2 editPoint = (EditPoint2)startPoint.CreateEditPoint();
foreach (AbstractResultItem item in list)
{
item.CodeModelSource = codeFunction;
AddContextToItem(item, editPoint);
}
// read optional arguments initializers (just to show them - they cannot be moved)
TextPoint headerStartPoint = null;
try {
headerStartPoint = codeFunction.GetStartPoint(vsCMPart.vsCMPartHeader);
} catch (Exception) { }
if (headerStartPoint == null)
{
return;
}
string headerText = codeFunction.GetHeaderText();
// search method header
var headerList = parentCommand.LookupInVB(headerText, headerStartPoint, parentNamespace, codeClassOrStruct, codeFunction.Name, null, isLocalizableFalse || functionLocalizableFalse);
// add to list
editPoint = (EditPoint2)startPoint.CreateEditPoint();
foreach (AbstractResultItem item in headerList)
{
item.IsConst = true;
item.CodeModelSource = codeFunction;
AddContextToItem(item, editPoint);
}
}
