/// Adds a signal handler to the class
public void BindSignal(Stetic.Signal signal)
{
if (targetObject == null)
{
return;
}
var cls = GetClass();
if (cls == null)
{
return;
}
if (FindSignalHandler(cls.Resolve(project), signal) != null)
{
return;
}
var met = new DefaultUnresolvedMethod(cls, signal.Handler)
{
Accessibility = Accessibility.Protected,
ReturnType = ReflectionHelper.ParseReflectionName(signal.SignalDescriptor.HandlerReturnTypeName)
};
foreach (Stetic.ParameterDescriptor pinfo in signal.SignalDescriptor.HandlerParameters)
{
met.Parameters.Add(new DefaultUnresolvedParameter(ReflectionHelper.ParseReflectionName(pinfo.TypeName), pinfo.Name));
}
var resolvedCls = cls.Resolve(cls.ParsedFile.GetTypeResolveContext(TypeSystemService.GetCompilation(project), cls.Region.Begin)).GetDefinition();
CodeGenerationService.AddNewMember(resolvedCls, cls, met);
}
public static INamedElement AddMemberToClass(Project project, ITypeDefinition cls, IUnresolvedTypeDefinition specificPartToAffect, CodeTypeMember member, bool throwIfExists)
{
bool isChildClass = false;
foreach (var c in cls.Parts)
{
if (c == specificPartToAffect)
{
isChildClass = true;
}
}
if (!isChildClass)
{
throw new ArgumentException("Class specificPartToAffect is not a part of class cls");
}
var dom = TypeSystemService.GetCompilation(project);
var existingMember = GetCompatibleMemberInClass(dom, cls, member);
if (existingMember == null)
{
return(CodeGenerationService.AddCodeDomMember(project, specificPartToAffect, member));
}
if (throwIfExists)
{
throw new MemberExistsException(cls.Name, member, MemberType.Method, existingMember.BodyRegion, cls.Region.FileName);
}
return(existingMember);
}
/// Adds a signal handler to the class
public void BindSignal(Stetic.Signal signal)
{
if (targetObject == null)
{
return;
}
var cls = GetClass();
if (cls == null)
{
return;
}
if (FindSignalHandler(cls, signal) != null)
{
return;
}
var met = SyntaxFactory.MethodDeclaration(SyntaxFactory.ParseTypeName(signal.SignalDescriptor.HandlerReturnTypeName),
signal.Handler)
.WithBody(SyntaxFactory.Block())
.AddModifiers(SyntaxFactory.Token(SyntaxKind.ProtectedKeyword));
var parameters = new List <ParameterSyntax> ();
foreach (Stetic.ParameterDescriptor pinfo in signal.SignalDescriptor.HandlerParameters)
{
parameters.Add(SyntaxFactory.Parameter(new SyntaxList <AttributeListSyntax> (), new SyntaxTokenList(), SyntaxFactory.ParseTypeName(pinfo.TypeName), SyntaxFactory.Identifier(pinfo.Name), null));
}
met = met.AddParameterListParameters(parameters.ToArray());
CodeGenerationService.AddNewMember(project, cls, GetSourceLocation(cls), met);
}
/// Adds a field to the class
public async Task BindToField(Stetic.Component obj)
{
if (targetObject == null)
{
return;
}
string name = GetMemberName(obj);
var cls = GetClass();
if (FindField(cls, name) != null)
{
return;
}
var location = GetSourceLocation(cls);
var doc = await IdeApp.Workbench.OpenDocument(location.SourceTree.FilePath, project, true);
var editor = doc.Editor;
if (editor != null)
{
await CodeGenerationService.AddNewMember(project, cls, cls.Locations.First(), GetFieldCode (cls, obj, name));
}
}
public static IMember AddMemberToClass(Project project, IType cls, IType specificPartToAffect, CodeTypeMember member, bool throwIfExists)
{
bool isChildClass = false;
foreach (IType c in cls.Parts)
{
if (c == specificPartToAffect)
{
isChildClass = true;
}
}
if (!isChildClass)
{
throw new ArgumentException("Class specificPartToAffect is not a part of class cls");
}
ProjectDom dom = ProjectDomService.GetProjectDom(project);
IMember existingMember = GetCompatibleMemberInClass(dom, cls, member);
if (existingMember == null)
{
return(CodeGenerationService.AddCodeDomMember(specificPartToAffect, member));
}
if (throwIfExists)
{
throw new MemberExistsException(cls.Name, member, MemberType.Method, existingMember.BodyRegion, cls.CompilationUnit.FileName);
}
return(existingMember);
}
protected override void ForceJsonFileUpdate()
{
base.ForceJsonFileUpdate();
McMod mcMod = SessionContext.SelectedMod;
CodeGenerationService.RegenerateInitScript(SourceCodeLocator.SoundEvents(mcMod.ModInfo.Name, mcMod.Organization).ClassName, mcMod, Explorer.Folders.Files);
}
public override void Run(RefactoringOptions options)
{
DocumentLocation location = options.GetTextEditorData().Caret.Location;
IType interfaceType = options.Dom.GetType(options.ResolveResult.ResolvedType);
IType declaringType = options.Document.CompilationUnit.GetTypeAt(location.Line, location.Column);
var editor = options.GetTextEditorData().Parent;
InsertionCursorEditMode mode = new InsertionCursorEditMode(editor, CodeGenerationService.GetInsertionPoints(options.Document, declaringType));
ModeHelpWindow helpWindow = new ModeHelpWindow();
helpWindow.TransientFor = IdeApp.Workbench.RootWindow;
helpWindow.TitleText = GettextCatalog.GetString("<b>Implement Interface -- Targeting</b>");
helpWindow.Items.Add(new KeyValuePair <string, string> (GettextCatalog.GetString("<b>Key</b>"), GettextCatalog.GetString("<b>Behavior</b>")));
helpWindow.Items.Add(new KeyValuePair <string, string> (GettextCatalog.GetString("<b>Up</b>"), GettextCatalog.GetString("Move to <b>previous</b> target point.")));
helpWindow.Items.Add(new KeyValuePair <string, string> (GettextCatalog.GetString("<b>Down</b>"), GettextCatalog.GetString("Move to <b>next</b> target point.")));
helpWindow.Items.Add(new KeyValuePair <string, string> (GettextCatalog.GetString("<b>Enter</b>"), GettextCatalog.GetString("<b>Declare interface implementation</b> at target point.")));
helpWindow.Items.Add(new KeyValuePair <string, string> (GettextCatalog.GetString("<b>Esc</b>"), GettextCatalog.GetString("<b>Cancel</b> this refactoring.")));
mode.HelpWindow = helpWindow;
mode.CurIndex = mode.InsertionPoints.Count - 1;
mode.StartMode();
mode.Exited += delegate(object s, InsertionCursorEventArgs args) {
if (args.Success)
{
CodeGenerator generator = options.Document.CreateCodeGenerator();
args.InsertionPoint.Insert(options.GetTextEditorData(), generator.CreateInterfaceImplementation(declaringType, interfaceType, true));
}
};
}
protected SyntaxNode CreateTypeDeclaration(
SyntaxNode containerNode,
TypeKind typeKind,
string name,
EnvDTE.vsCMAccess access,
INamedTypeSymbol baseType = null,
ImmutableArray <INamedTypeSymbol> implementedInterfaces = default(ImmutableArray <INamedTypeSymbol>))
{
var destination = CodeModelService.GetDestination(containerNode);
var newTypeSymbol = CodeGenerationSymbolFactory.CreateNamedTypeSymbol(
attributes: default(ImmutableArray <AttributeData>),
accessibility: CodeModelService.GetAccessibility(access, SymbolKind.NamedType, destination),
modifiers: new DeclarationModifiers(),
typeKind: typeKind,
name: name,
typeParameters: default(ImmutableArray <ITypeParameterSymbol>),
baseType: baseType,
interfaces: implementedInterfaces,
specialType: SpecialType.None,
members: default(ImmutableArray <ISymbol>));
return(CodeGenerationService.CreateNamedTypeDeclaration(
newTypeSymbol, destination,
options: GetCodeGenerationOptions(access, containerNode.SyntaxTree.Options)));
}
/// Adds a field to the class
public void BindToField(Stetic.Component obj)
{
if (targetObject == null)
{
return;
}
string name = GetMemberName(obj);
var cls = GetClass();
if (FindField(cls.Resolve(project), name) != null)
{
return;
}
Document doc = IdeApp.Workbench.OpenDocument(cls.Region.FileName, true);
IEditableTextFile editor = doc.GetContent <IEditableTextFile> ();
if (editor != null)
{
var resolvedCls = cls.Resolve(cls.ParsedFile.GetTypeResolveContext(TypeSystemService.GetCompilation(project), cls.Region.Begin)).GetDefinition();
CodeGenerationService.AddNewMember(resolvedCls, cls, GetFieldCode(cls, obj, name));
}
}
public void TestMyCodeGeneratorGetsCalled()
{
MyArtifactLink link = new MyArtifactLink(ItemPath);
CodeGenerationService codeGenerator = CreateCodeGenerator(ItemPath, out rdt);
Assert.IsTrue(codeGenerator.GenerateArtifact(link) > 0);
Assert.AreEqual <string>(MyCodeGenerator.HelloWorld, GetGeneratedCode());
}
public void TestCreatedItemGeneratesErrorMessageInContent()
{
NoStrategyArtifactLink link = new NoStrategyArtifactLink(ItemPath);
CodeGenerationService codeGenerator = CreateCodeGenerator(ItemPath, out rdt);
Assert.IsFalse(codeGenerator.GenerateArtifact(link) > 0);
Assert.AreEqual <string>("An unexpected exception has occurred while generating code. Check the Error List Window.", GetGeneratedCode());
}
public void TestEmptyCodeGenerator()
{
EmptyArtifactLink link = new EmptyArtifactLink(ItemPath);
CodeGenerationService codeGenerator = CreateCodeGenerator(ItemPath, out rdt);
Assert.IsFalse(codeGenerator.GenerateArtifact(link) > 0);
Assert.AreEqual <string>("", GetGeneratedCode());
}
public void ShouldGenerateOnceWithMultipleSameFiles()
{
MyArtifactLink link = new MyArtifactLink(ItemPath);
CodeGenerationService codeGenerator = CreateCodeGenerator(ItemPath, out rdt);
Assert.AreEqual <int>(1, codeGenerator.GenerateArtifact(link));
Assert.AreEqual <int>(0, codeGenerator.GenerateArtifact(link));
Assert.AreEqual <string>(MyCodeGenerator.HelloWorld, GetGeneratedCode());
}
public void ShouldNotGenerateContentWithErrorsOnConfigFiles()
{
const string configFile = "foo.config";
NoStrategyArtifactLink link = new NoStrategyArtifactLink(configFile);
CodeGenerationService codeGenerator = CreateCodeGenerator(configFile, out rdt);
Assert.IsFalse(codeGenerator.GenerateArtifact(link) > 0);
Assert.AreEqual <string>("", GetGeneratedCode(configFile));
}
protected void CreateCommand(object sender, ItemEditedEventArgs <Command> e)
{
if (e.Result)
{
McMod mod = SessionContext.SelectedMod;
CodeGenerationService.CreateCustomScript(mod, e.ActualItem);
}
new FileInfo(tempFilePath).Delete();
}
public void TestWithDuplicateLink()
{
List <IArtifactLink> links = new List <IArtifactLink>();
links.Add(new MyArtifactLink(ItemPath));
links.Add(new MyArtifactLink(ItemPath));
CodeGenerationService codeGenerator = CreateCodeGenerator(ItemPath, out rdt);
Assert.AreEqual <int>(1, codeGenerator.GenerateArtifacts(links));
}
protected SyntaxNode CreateNamespaceDeclaration(SyntaxNode containerNode, string name)
{
var destination = CodeModelService.GetDestination(containerNode);
var newNamespaceSymbol = CodeGenerationSymbolFactory.CreateNamespaceSymbol(name);
var newNamespace = CodeGenerationService.CreateNamespaceDeclaration(
newNamespaceSymbol, destination);
return(newNamespace);
}
protected SyntaxNode CreateDestructorDeclaration(SyntaxNode containerNode, string typeName)
{
var destination = CodeModelService.GetDestination(containerNode);
var newMethodSymbol = CodeGenerationSymbolFactory.CreateDestructorSymbol(
attributes: default(ImmutableArray <AttributeData>),
typeName: typeName);
return(CodeGenerationService.CreateMethodDeclaration(
newMethodSymbol, destination));
}
public static void Implement(RefactoringOptions options, IType abstractType)
{
var document = options.Document;
TextEditor editor = document.Editor.Parent;
var loc = document.Editor.Caret.Location;
var declaringType = document.ParsedDocument.GetInnermostTypeDefinition(loc);
var type = options.ResolveResult.Type;
var mode = new InsertionCursorEditMode(editor, CodeGenerationService.GetInsertionPoints(document, declaringType));
if (mode.InsertionPoints.Count == 0)
{
MessageService.ShowError(
GettextCatalog.GetString("No valid insertion point can be found in type '{0}'.", declaringType.Name));
return;
}
var helpWindow = new InsertionCursorLayoutModeHelpWindow();
helpWindow.TransientFor = IdeApp.Workbench.RootWindow;
helpWindow.TitleText = GettextCatalog.GetString("Implement Abstract Members");
mode.HelpWindow = helpWindow;
mode.CurIndex = mode.InsertionPoints.Count - 1;
mode.StartMode();
mode.Exited += delegate(object s, InsertionCursorEventArgs args) {
if (args.Success)
{
var generator = options.CreateCodeGenerator();
if (generator == null)
{
return;
}
var def = type.GetDefinition();
var missingAbstractMembers = def.Members.Where(member => member.IsAbstract && !declaringType.Members.Any(m => member.Name == m.Name));
var sb = new StringBuilder();
foreach (var member in missingAbstractMembers)
{
if (sb.Length > 0)
{
sb.Append(editor.EolMarker);
sb.Append(editor.EolMarker);
}
var resolvedType = declaringType.Resolve(options.Document.ParsedDocument.GetTypeResolveContext(options.Document.Compilation, loc)).GetDefinition();
var impl = generator.CreateMemberImplementation(resolvedType, declaringType, member, false);
if (impl != null)
{
sb.Append(impl.Code);
}
}
args.InsertionPoint.Insert(document.Editor, generator.WrapInRegions("implemented abstract members of " + abstractType.FullName, sb.ToString()));
}
};
}
protected SyntaxNode CreatePropertyDeclaration(SyntaxNode containerNode, string name, bool generateGetter, bool generateSetter, EnvDTE.vsCMAccess access, ITypeSymbol type)
{
var destination = CodeModelService.GetDestination(containerNode);
IMethodSymbol getMethod = null;
if (generateGetter)
{
getMethod = CodeGenerationSymbolFactory.CreateMethodSymbol(
attributes: default(ImmutableArray <AttributeData>),
accessibility: Accessibility.NotApplicable,
modifiers: new DeclarationModifiers(),
returnType: null,
returnsByRef: false,
explicitInterfaceSymbol: null,
name: "get_" + name,
typeParameters: default(ImmutableArray <ITypeParameterSymbol>),
parameters: default(ImmutableArray <IParameterSymbol>),
statements: ImmutableArray.Create(CodeModelService.CreateReturnDefaultValueStatement(type)));
}
IMethodSymbol setMethod = null;
if (generateSetter)
{
setMethod = CodeGenerationSymbolFactory.CreateMethodSymbol(
attributes: default(ImmutableArray <AttributeData>),
accessibility: Accessibility.NotApplicable,
modifiers: new DeclarationModifiers(),
returnType: null,
returnsByRef: false,
explicitInterfaceSymbol: null,
name: "set_" + name,
typeParameters: default(ImmutableArray <ITypeParameterSymbol>),
parameters: default(ImmutableArray <IParameterSymbol>));
}
var newPropertySymbol = CodeGenerationSymbolFactory.CreatePropertySymbol(
attributes: default(ImmutableArray <AttributeData>),
accessibility: CodeModelService.GetAccessibility(access, SymbolKind.Field, destination),
modifiers: new DeclarationModifiers(),
type: type,
returnsByRef: false,
explicitInterfaceSymbol: null,
name: name,
parameters: default(ImmutableArray <IParameterSymbol>),
getMethod: getMethod,
setMethod: setMethod);
return(CodeGenerationService.CreatePropertyDeclaration(
newPropertySymbol, destination,
options: GetCodeGenerationOptions(access, containerNode.SyntaxTree.Options)));
}
public override void Run(RefactoringOptions options)
{
DocumentLocation location = options.GetTextEditorData().Caret.Location;
IType interfaceType = options.Dom.GetType(options.ResolveResult.ResolvedType);
IType declaringType = options.Document.CompilationUnit.GetTypeAt(location.Line, location.Column);
options.Document.Editor.Document.BeginAtomicUndo();
var missingAbstractMembers = interfaceType.Members.Where(member => member.IsAbstract && !declaringType.Members.Any(m => member.Name == m.Name));
CodeGenerationService.AddNewMembers(declaringType, missingAbstractMembers, "implemented abstract members of " + interfaceType.FullName);
options.Document.Editor.Document.EndAtomicUndo();
}
static IUnresolvedTypeDefinition CreateClass(Project project, Stetic.ActionGroupComponent group, string name, string namspace, string folder)
{
string fullName = namspace.Length > 0 ? namspace + "." + name : name;
var type = new CodeTypeDeclaration();
type.Name = name;
type.IsClass = true;
type.BaseTypes.Add(new CodeTypeReference("Gtk.ActionGroup"));
// Generate the constructor. It contains the call that builds the widget.
var ctor = new CodeConstructor();
ctor.Attributes = MemberAttributes.Public | MemberAttributes.Final;
ctor.BaseConstructorArgs.Add(new CodePrimitiveExpression(fullName));
var call = new CodeMethodInvokeExpression(
new CodeMethodReferenceExpression(
new CodeTypeReferenceExpression("Stetic.Gui"),
"Build"
),
new CodeThisReferenceExpression(),
new CodeTypeOfExpression(fullName)
);
ctor.Statements.Add(call);
type.Members.Add(ctor);
// Add signal handlers
foreach (Stetic.ActionComponent action in group.GetActions())
{
foreach (Stetic.Signal signal in action.GetSignals())
{
CodeMemberMethod met = new CodeMemberMethod();
met.Name = signal.Handler;
met.Attributes = MemberAttributes.Family;
met.ReturnType = new CodeTypeReference(signal.SignalDescriptor.HandlerReturnTypeName);
foreach (Stetic.ParameterDescriptor pinfo in signal.SignalDescriptor.HandlerParameters)
{
met.Parameters.Add(new CodeParameterDeclarationExpression(pinfo.TypeName, pinfo.Name));
}
type.Members.Add(met);
}
}
// Create the class
return(CodeGenerationService.AddType((DotNetProject)project, folder, namspace, type));
}
void OnOKClicked(object sender, EventArgs e)
{
TextEditorData data = options.GetTextEditorData();
Mono.TextEditor.TextEditor editor = data.Parent;
// Insertion cursor mode test:
if (editor != null)
{
IType type = properties.DeclaringMember.DeclaringType;
InsertionCursorEditMode mode = new InsertionCursorEditMode(editor, CodeGenerationService.GetInsertionPoints(options.Document, type));
for (int i = 0; i < mode.InsertionPoints.Count; i++)
{
var point = mode.InsertionPoints[i];
if (point.Location < editor.Caret.Location)
{
mode.CurIndex = i;
}
else
{
break;
}
}
ModeHelpWindow helpWindow = new ModeHelpWindow();
helpWindow.TransientFor = IdeApp.Workbench.RootWindow;
helpWindow.TitleText = GettextCatalog.GetString("<b>Extract Method -- Targeting</b>");
helpWindow.Items.Add(new KeyValuePair <string, string> (GettextCatalog.GetString("<b>Key</b>"), GettextCatalog.GetString("<b>Behavior</b>")));
helpWindow.Items.Add(new KeyValuePair <string, string> (GettextCatalog.GetString("<b>Up</b>"), GettextCatalog.GetString("Move to <b>previous</b> target point.")));
helpWindow.Items.Add(new KeyValuePair <string, string> (GettextCatalog.GetString("<b>Down</b>"), GettextCatalog.GetString("Move to <b>next</b> target point.")));
helpWindow.Items.Add(new KeyValuePair <string, string> (GettextCatalog.GetString("<b>Enter</b>"), GettextCatalog.GetString("<b>Declare new method</b> at target point.")));
helpWindow.Items.Add(new KeyValuePair <string, string> (GettextCatalog.GetString("<b>Esc</b>"), GettextCatalog.GetString("<b>Cancel</b> this refactoring.")));
mode.HelpWindow = helpWindow;
mode.StartMode();
methodName = entry.Text;
activeModifier = comboboxModifiers.Active;
generateComments = checkbuttonGenerateComment.Active;
mode.Exited += delegate(object s, InsertionCursorEventArgs args) {
if (args.Success)
{
SetProperties();
properties.InsertionPoint = args.InsertionPoint;
List <Change> changes = extractMethod.PerformChanges(options, properties);
IProgressMonitor monitor = IdeApp.Workbench.ProgressMonitors.GetBackgroundProgressMonitor(this.Title, null);
RefactoringService.AcceptChanges(monitor, options.Dom, changes);
}
};
}
((Widget)this).Destroy();
}
internal static void InternalRun(RefactoringOptions options, bool implementExplicit)
{
IType interfaceType;
if (!InternalIsValid(options, out interfaceType))
{
return;
}
var loc = options.Document.Editor.Caret.Location;
var declaringType = options.Document.ParsedDocument.GetInnermostTypeDefinition(loc);
if (declaringType == null)
{
return;
}
var editor = options.GetTextEditorData().Parent;
var mode = new InsertionCursorEditMode(
editor,
CodeGenerationService.GetInsertionPoints(options.Document, declaringType));
if (mode.InsertionPoints.Count == 0)
{
MessageService.ShowError(
GettextCatalog.GetString("No valid insertion point can be found in type '{0}'.", declaringType.Name)
);
return;
}
var helpWindow = new InsertionCursorLayoutModeHelpWindow();
helpWindow.TransientFor = IdeApp.Workbench.RootWindow;
helpWindow.TitleText = GettextCatalog.GetString("Implement Interface");
mode.HelpWindow = helpWindow;
mode.CurIndex = mode.InsertionPoints.Count - 1;
mode.StartMode();
mode.Exited += delegate(object s, InsertionCursorEventArgs args) {
if (args.Success)
{
var generator = options.CreateCodeGenerator();
if (generator == null)
{
return;
}
var type = declaringType.Resolve(options.Document.ParsedDocument.GetTypeResolveContext(options.Document.Compilation, loc)).GetDefinition();
args.InsertionPoint.Insert(options.GetTextEditorData(), generator.CreateInterfaceImplementation(type, declaringType, interfaceType, implementExplicit));
}
};
}
protected SyntaxNode CreateConstructorDeclaration(SyntaxNode containerNode, string typeName, EnvDTE.vsCMAccess access)
{
var destination = CodeModelService.GetDestination(containerNode);
var newMethodSymbol = CodeGenerationSymbolFactory.CreateConstructorSymbol(
attributes: default(ImmutableArray <AttributeData>),
accessibility: CodeModelService.GetAccessibility(access, SymbolKind.Method, destination),
modifiers: new DeclarationModifiers(),
typeName: typeName,
parameters: default(ImmutableArray <IParameterSymbol>));
return(CodeGenerationService.CreateMethodDeclaration(
newMethodSymbol, destination,
options: GetCodeGenerationOptions(access, containerNode.SyntaxTree.Options)));
}
protected SyntaxNode CreateDelegateTypeDeclaration(SyntaxNode containerNode, string name, EnvDTE.vsCMAccess access, INamedTypeSymbol returnType)
{
var destination = CodeModelService.GetDestination(containerNode);
var newTypeSymbol = CodeGenerationSymbolFactory.CreateDelegateTypeSymbol(
attributes: null,
accessibility: CodeModelService.GetAccessibility(access, SymbolKind.NamedType, destination),
modifiers: new DeclarationModifiers(),
returnType: returnType,
name: name);
return(CodeGenerationService.CreateNamedTypeDeclaration(
newTypeSymbol, destination,
options: GetCodeGenerationOptions(access)));
}
protected SyntaxNode CreateFieldDeclaration(SyntaxNode containerNode, string name, EnvDTE.vsCMAccess access, ITypeSymbol type)
{
var destination = CodeModelService.GetDestination(containerNode);
var newFieldSymbol = CodeGenerationSymbolFactory.CreateFieldSymbol(
attributes: default(ImmutableArray <AttributeData>),
accessibility: CodeModelService.GetAccessibility(access, SymbolKind.Field, destination),
modifiers: new DeclarationModifiers(isWithEvents: CodeModelService.GetWithEvents(access)),
type: type,
name: name);
return(CodeGenerationService.CreateFieldDeclaration(
newFieldSymbol, destination,
options: GetCodeGenerationOptions(access, containerNode.SyntaxTree.Options)));
}
private CodeGenerationOptions GetCodeGenerationOptions(
SyntaxNode containerNode,
OptionSet?options = null,
EnvDTE.vsCMAccess access = EnvDTE.vsCMAccess.vsCMAccessDefault,
bool generateMethodBodies = true)
{
var generateDefaultAccessibility = (access & EnvDTE.vsCMAccess.vsCMAccessDefault) == 0;
return(CodeGenerationService.GetOptions(
containerNode.SyntaxTree.Options,
options ?? Workspace.Options,
new CodeGenerationContext(
generateDefaultAccessibility: generateDefaultAccessibility,
generateMethodBodies: generateMethodBodies)));
}
public void TestArtifactIsGenerated()
{
MockServiceProvider serviceProvider = new MockServiceProvider();
MockVSHierarchy root = new MockVSHierarchy();
MockVsSolution solution = new MockVsSolution(root);
MockVSHierarchy project = new MockVSHierarchy("Project1.project");
root.AddProject(project);
serviceProvider.AddService(typeof(SVsSolution), solution);
CodeGenerationService target = new CodeGenerationService(serviceProvider);
MyArtifactLink validLink = new MyArtifactLink(project.GUID, "item1.cs");
Assert.IsFalse(target.IsArtifactAlreadyGenerated(validLink));
project.AddChild("item1.cs");
Assert.IsTrue(target.IsArtifactAlreadyGenerated(validLink));
}
void TestCreateMethod(string input, string outputString, bool returnWholeFile)
{
var generator = new CSharpCodeGeneratorNode();
MonoDevelop.Projects.CodeGeneration.CodeGenerator.AddGenerator(generator);
var refactoring = new CreateMethodCodeGenerator();
RefactoringOptions options = ExtractMethodTests.CreateRefactoringOptions(input);
Assert.IsTrue(refactoring.IsValid(options));
if (returnWholeFile)
{
refactoring.SetInsertionPoint(CodeGenerationService.GetInsertionPoints(options.Document, refactoring.DeclaringType).First());
}
else
{
DocumentLocation loc = new DocumentLocation(1, 1);
refactoring.SetInsertionPoint(new InsertionPoint(loc, NewLineInsertion.Eol, NewLineInsertion.Eol));
}
List <Change> changes = refactoring.PerformChanges(options, null);
// changes.ForEach (c => Console.WriteLine (c));
// get just the generated method.
string output = ExtractMethodTests.GetOutput(options, changes);
if (returnWholeFile)
{
Assert.IsTrue(ExtractMethodTests.CompareSource(output, outputString), "Expected:" + Environment.NewLine + outputString + Environment.NewLine + "was:" + Environment.NewLine + output);
return;
}
output = output.Substring(0, output.IndexOf('}') + 1).Trim();
// crop 1 level of indent
Document doc = new Document(output);
foreach (LineSegment line in doc.Lines)
{
if (doc.GetCharAt(line.Offset) == '\t')
{
((IBuffer)doc).Remove(line.Offset, 1);
}
}
output = doc.Text;
Assert.IsTrue(ExtractMethodTests.CompareSource(output, outputString), "Expected:" + Environment.NewLine + outputString + Environment.NewLine + "was:" + Environment.NewLine + output);
MonoDevelop.Projects.CodeGeneration.CodeGenerator.RemoveGenerator(generator);
}
public void TestArtifactIsGenerated()
{
MockServiceProvider serviceProvider = new MockServiceProvider();
MockVSHierarchy root = new MockVSHierarchy();
MockVsSolution solution = new MockVsSolution(root);
MockVSHierarchy project = new MockVSHierarchy("Project1.project");
root.AddProject(project);
serviceProvider.AddService(typeof(SVsSolution), solution);
CodeGenerationService target = new CodeGenerationService(serviceProvider);
MyArtifactLink validLink = new MyArtifactLink(project.GUID, "item1.cs");
Assert.IsFalse(target.IsArtifactAlreadyGenerated(validLink));
project.AddChild("item1.cs");
Assert.IsTrue(target.IsArtifactAlreadyGenerated(validLink));
}
public void TestValidate()
{
MockServiceProvider serviceProvider = new MockServiceProvider();
MockVSHierarchy root = new MockVSHierarchy();
MockVsSolution solution = new MockVsSolution(root);
MockVSHierarchy project = new MockVSHierarchy("Project1.project");
root.AddProject(project);
serviceProvider.AddService(typeof(SVsSolution), solution);
CodeGenerationService target = new CodeGenerationService(serviceProvider);
MyArtifactLink validLink = new MyArtifactLink(project.GUID, "item1.cs");
Assert.IsTrue(target.IsValid(validLink));
MyArtifactLink invalidLink1 = new MyArtifactLink(Guid.NewGuid(), "item2.cs");
Assert.IsFalse(target.IsValid(invalidLink1));
MyArtifactLink invalidLink2 = new MyArtifactLink(project.GUID, "it:em3.cs");
Assert.IsFalse(target.IsValid(invalidLink2));
MyArtifactLink invalidLink3 = new MyArtifactLink(Guid.NewGuid(), "<item3.cs>");
Assert.IsFalse(target.IsValid(invalidLink3));
}
