internal MethodEntityProcessor(MethodEntity methodEntity, IDispatcher dispatcher, ICodeProvider codeProvider, IEntityDescriptor entityDescriptor = null, bool verbose = false) : base(methodEntity, entityDescriptor, dispatcher) { Contract.Assert(methodEntity != null); this.MethodEntity = methodEntity; this.EntityDescriptor = entityDescriptor==null?methodEntity.EntityDescriptor :entityDescriptor; this.Verbose = true; // verbose; // It gets a code provider for the method. if (codeProvider!=null || dispatcher is OrleansDispatcher) { this.codeProvider = codeProvider; //this.codeProvider = ProjectGrainWrapper.CreateProjectGrainWrapperAsync(methodEntity.MethodDescriptor).Result; //SetCodeProviderAsync(methodEntity.MethodDescriptor); } else { var pair = ProjectCodeProvider.GetProjectProviderAndSyntaxAsync(methodEntity.MethodDescriptor).Result; if (pair != null) { this.codeProvider = pair.Item1; } } // We use the codeProvider for Propagation and HandleCall and ReturnEvents (in the method DiffProp that uses IsAssignable) // We can get rid of this by passing codeProvider as parameter in this 3 methods this.MethodEntity.PropGraph.SetCodeProvider(this.codeProvider); }
public void Generate(StreamWriter sw, ICodeProvider codeProvider) { StringBuilder sb = new StringBuilder(); AddStringCollection(sb, GetText(codeProvider)); sw.Write(sb.ToString()); }
public void Record(ICodeProvider codeProvider, params object[] args) { var step = Sequence.AddStep(codeProvider.Origin); step.AddStatement(codeProvider.Code(args)); OnRecordAdded?.Invoke(); }
internal async Task<ISet<TypeDescriptor>> GetPotentialTypesAsync(PropGraphNodeDescriptor n, PropagationGraph propGraph, ICodeProvider codeProvider) { var result = new HashSet<TypeDescriptor>(); foreach (var typeDescriptor in propGraph.GetTypes(n)) { // TO-DO fix by adding a where T: AnalysisType if (typeDescriptor.IsConcreteType) { result.Add(typeDescriptor); } else { Contract.Assert(this.InstatiatedTypes != null); foreach(var candidateType in this.InstatiatedTypes) { var isSubtype = await codeProvider.IsSubtypeAsync(candidateType, typeDescriptor); if(isSubtype) { result.Add(candidateType); } } } } return result; }
public override void ExecuteCommandImpl(object sender, EventArgs args) { var project = projectManager.SelectedProject; string projectConfigPath = projectManager.ProjectConfigPath; string methodConfigPath = projectManager.MethodConfigPath; var projectConfiguration = projectConfigurationManager.Load(projectConfigPath); string selectedMethodPath = projectManager.MethodPath; string selectedMethodName = Path.GetFileNameWithoutExtension(selectedMethodPath); MethodInfo methodInformation = projectConfiguration.MethodInfos.FirstOrDefault(m => m.MethodName == selectedMethodName); if (methodInformation == null) { throw new Exception(); } var templateLoader = new TemplateLoader(this.dialogFactory); templateLoader.Load(methodConfigPath); var packageManager = new PackageManager(authManager); var updateView = dialogFactory.GetUpdateFromArasView(projectConfigurationManager, projectConfiguration, templateLoader, packageManager, methodInformation, projectConfigPath, project.Name, project.FullName); var updateViewResult = updateView.ShowDialog(); if (updateViewResult?.DialogOperationResult != true) { return; } var eventData = CommonData.EventSpecificDataTypeList.First(x => x.EventSpecificData == updateViewResult.EventSpecificData); ICodeProvider codeProvider = codeProviderFactory.GetCodeProvider(project.CodeModel.Language, projectConfiguration); GeneratedCodeInfo codeInfo = codeProvider.GenerateCodeInfo(updateViewResult.SelectedTemplate, eventData, updateViewResult.MethodName, false, updateViewResult.MethodCode, updateViewResult.IsUseVSFormattingCode); projectManager.CreateMethodTree(codeInfo); var methodInfo = new MethodInfo() { InnovatorMethodConfigId = updateViewResult.MethodConfigId, InnovatorMethodId = updateViewResult.MethodId, MethodLanguage = updateViewResult.MethodLanguage, MethodName = updateViewResult.MethodName, MethodType = updateViewResult.MethodType, PackageName = updateViewResult.PackageName, TemplateName = updateViewResult.SelectedTemplate.TemplateName, EventData = updateViewResult.EventSpecificData, ExecutionAllowedToId = updateViewResult.ExecutionIdentityId, ExecutionAllowedToKeyedName = updateViewResult.ExecutionIdentityKeyedName, MethodComment = updateViewResult.MethodComment, PartialClasses = codeInfo.PartialCodeInfoList.Select(pci => pci.Path).ToList(), ExternalItems = codeInfo.ExternalItemsInfoList.Select(pci => pci.Path).ToList() }; projectConfiguration.AddMethodInfo(methodInfo); projectConfiguration.UseVSFormatting = updateViewResult.IsUseVSFormattingCode; projectConfigurationManager.Save(projectConfigPath, projectConfiguration); }
private bool ModelToObject(object source, Type resultType, out object result) { result = null; Type sourceType = source.GetType(); if ((ReflectionHelper.Is <IIdProvider>(sourceType) || ReflectionHelper.Is <ICodeProvider>(sourceType) || ReflectionHelper.Is <IGuidProvider>(sourceType)) && !this._coreManager.Contains(sourceType) && this._coreManager.Contains(resultType)) { if (source is IIdProvider) { IIdProvider idProviderSource = source as IIdProvider; result = this._coreManager.Get(idProviderSource.ID, resultType); return(true); } else if (source is IGuidProvider) { IGuidProvider guidProviderSource = source as IGuidProvider; result = this._coreManager.Get(guidProviderSource.Guid, resultType); return(true); } else if (source is ICodeProvider) { ICodeProvider codeProviderSource = source as ICodeProvider; result = this._coreManager.Get(codeProviderSource.Code, resultType); return(true); } } return(false); }
public SimpleSubroutineBuilder(ICodeProvider <Label> codeProvider, SubroutineFacade subroutineFacade, Label entry) : base(codeProvider, subroutineFacade, entry) { Initialize(entry); }
public void Init() { projectManager = Substitute.For <IProjectManager>(); projectConfigurationManager = new ProjectConfigurationManager(); dialogFactory = Substitute.For <IDialogFactory>(); authManager = new AuthManagerStub(); codeProviderFactory = Substitute.For <ICodeProviderFactory>(); globalConfiguration = Substitute.For <IGlobalConfiguration>();; CreateMethodCmd.Initialize(projectManager, authManager, dialogFactory, projectConfigurationManager, codeProviderFactory, globalConfiguration); createMethodCmd = CreateMethodCmd.Instance; iVsUIShell = Substitute.For <IVsUIShell>(); var currentPath = AppDomain.CurrentDomain.BaseDirectory; projectManager.ProjectConfigPath.Returns(Path.Combine(currentPath, "TestData\\projectConfig.xml")); projectManager.MethodConfigPath.Returns(Path.Combine(currentPath, "TestData\\method-config.xml")); template = new TemplateInfo { TemplateName = string.Empty }; eventSpecificDataType = new EventSpecificDataType { EventSpecificData = EventSpecificData.None }; templateLoader = new TemplateLoader(dialogFactory); packageManager = new PackageManager(authManager); codeProvider = Substitute.For <ICodeProvider>(); projectConfiguration = projectConfigurationManager.Load(projectManager.ProjectConfigPath); templateLoader.Load(projectManager.MethodConfigPath); codeProviderFactory.GetCodeProvider(null, null).ReturnsForAnyArgs(codeProvider); }
public override void ExecuteCommandImpl(object sender, EventArgs args) { Document activeDocument = projectManager.ActiveDocument; SyntaxNode activeSyntaxNode = projectManager.ActiveSyntaxNode; string activeDocumentMethodName = projectManager.ActiveDocumentMethodName; string activeDocumentMethodFullPath = projectManager.ActiveDocumentMethodFullPath; string activeDocumentMethodFolderPath = projectManager.ActiveDocumentMethodFolderPath; string serverMethodFolderPath = projectManager.ServerMethodFolderPath; MethodInfo methodInformation = projectConfigurationManager.CurrentProjectConfiguraiton.MethodInfos.FirstOrDefault(m => m.MethodName == activeDocumentMethodName); if (string.Equals(activeDocument.FilePath, activeDocumentMethodFullPath, StringComparison.InvariantCultureIgnoreCase)) { // main to external var moveToViewAdapter = this.dialogFactory.GetMoveToView(activeDocumentMethodFolderPath, activeSyntaxNode); var moveToViewResult = moveToViewAdapter.ShowDialog(); if (moveToViewResult.DialogOperationResult == false) { return; } ICodeProvider codeProvider = codeProviderFactory.GetCodeProvider(activeDocument.Project.Language); CodeInfo activeDocumentCodeInfo = codeProvider.RemoveActiveNodeFromActiveDocument(activeDocument, activeSyntaxNode, serverMethodFolderPath); CodeInfo itemCodeInfo = null; if (moveToViewResult.SelectedCodeType == CodeType.Partial) { itemCodeInfo = codeProvider.InsertActiveNodeToPartial(moveToViewResult.SelectedFullPath, serverMethodFolderPath, activeDocumentMethodName, activeSyntaxNode, projectManager.ActiveDocumentMethodFullPath); } else { itemCodeInfo = codeProvider.InsertActiveNodeToExternal(moveToViewResult.SelectedFullPath, serverMethodFolderPath, activeDocumentMethodName, activeSyntaxNode, projectManager.ActiveDocumentMethodFullPath); } projectManager.AddItemTemplateToProjectNew(activeDocumentCodeInfo, methodInformation.Package.MethodFolderPath, false); projectManager.AddItemTemplateToProjectNew(itemCodeInfo, methodInformation.Package.MethodFolderPath, false); projectConfigurationManager.Save(projectManager.ProjectConfigPath); } else { // external to main var messageBoxWindow = dialogFactory.GetMessageBoxWindow(); var messageBoxWindowResult = messageBoxWindow.ShowDialog( this.messageManager.GetMessage("SelectedCodeWillBeMovedToMainMethodFileClickOKToContinue"), this.messageManager.GetMessage("MoveToMainMethod"), MessageButtons.OKCancel, MessageIcon.Question); if (messageBoxWindowResult == MessageDialogResult.OK) { ICodeProvider codeProvider = codeProviderFactory.GetCodeProvider(activeDocument.Project.Language); CodeInfo activeDocumentCodeInfo = codeProvider.RemoveActiveNodeFromActiveDocument(activeDocument, activeSyntaxNode, serverMethodFolderPath); CodeInfo methodDocumentCodeInfo = codeProvider.InsertActiveNodeToMainMethod(activeDocumentMethodFullPath, serverMethodFolderPath, activeSyntaxNode, activeDocument.FilePath); projectManager.AddItemTemplateToProjectNew(activeDocumentCodeInfo, methodInformation.Package.MethodFolderPath, false); projectManager.AddItemTemplateToProjectNew(methodDocumentCodeInfo, methodInformation.Package.MethodFolderPath, false); } } }
public void GetCodeProvider_ShouldReturnCSharpCodeProvider(string projectLanguageCode) { // Act ICodeProvider codeProvider = codeProviderFactory.GetCodeProvider(projectLanguageCode); // Assert Assert.IsInstanceOf(typeof(CSharpCodeProvider), codeProvider); }
protected SubroutineBuilder(ICodeProvider <Label> codeProvider, SubroutineFacade subroutineFacade, Label entry) { this.SubroutineFacade = subroutineFacade; CodeProvider = codeProvider; AddTargetLabel(entry); }
public override List <string> GetText(ICodeProvider codeProvider) { List <string> result = new List <string>(); result.Add("namespace " + name); result.Add("{"); return(base.GetText(codeProvider)); }
public void Setup() { this.innovatorUser = new InnovatorUser(); this.serverConnection = Substitute.For <IServerConnection>(); this.innovatorInstance = new Innovator(this.serverConnection); this.iOMWrapper = Substitute.For <IIOMWrapper>(); this.authManager = new AuthenticationManagerProxy(serverConnection, innovatorInstance, innovatorUser, iOMWrapper); this.dialogFactory = Substitute.For <IDialogFactory>(); this.projectConfigurationManager = Substitute.For <IProjectConfigurationManager>(); this.projectConfiguration = Substitute.For <IProjectConfiguraiton>(); this.messageManager = Substitute.For <MessageManager>(); this.packageManager = new PackageManager(authManager, messageManager); this.arasDataProvider = Substitute.For <IArasDataProvider>(); this.methodInformation = new MethodInfo(); this.templateLoader = new TemplateLoader(); this.projectManager = Substitute.For <IProjectManager>(); this.codeProvider = Substitute.For <ICodeProvider>(); this.globalConfiguration = Substitute.For <IGlobalConfiguration>(); this.globalConfiguration.GetUserCodeTemplatesPaths().Returns(new List <string>()); this.serverConnection.When(x => x.CallAction("ApplyItem", Arg.Is <XmlDocument>(doc => doc.DocumentElement.Attributes["type"].Value == "Value"), Arg.Any <XmlDocument>())) .Do(x => { (x[2] as XmlDocument).Load(Path.Combine(currentPath, @"Dialogs\ViewModels\TestData\ActionLocationsListValue.xml")); }); this.serverConnection.When(x => x.CallAction("ApplyItem", Arg.Is <XmlDocument>(doc => doc.DocumentElement.Attributes["type"].Value == "Filter Value"), Arg.Any <XmlDocument>())) .Do(x => { (x[2] as XmlDocument).Load(Path.Combine(currentPath, @"Dialogs\ViewModels\TestData\MethodTypesListFilterValue.xml")); }); this.projectConfiguration.LastSavedSearch.Returns(new Dictionary <string, List <PropertyInfo> >()); XmlDocument methodItemTypeAML = new XmlDocument(); methodItemTypeAML.Load(Path.Combine(currentPath, @"Dialogs\ViewModels\TestData\MethodItemType.xml")); Item methodItemType = this.innovatorInstance.newItem(); methodItemType.loadAML(methodItemTypeAML.OuterXml); this.arasDataProvider.GetMethodItemTypeInfo().Returns(new MethodItemTypeInfo(methodItemType, messageManager)); this.createMethodViewModel = new CreateMethodViewModel(authManager, dialogFactory, projectConfiguration, templateLoader, packageManager, projectManager, arasDataProvider, codeProvider, globalConfiguration, messageManager); }
public CallQuery( ICodeProvider <Label, Local, Parameter, Method, Field, Type> codeProvider, CallGraphOrder <Local, Parameter, Method, Field, Property, Event, Type, Attribute, Assembly> parent, Node currentNode ) { this.codeProvider = codeProvider; this.parent = parent; this.currentNode = currentNode; }
public void JsParserEventsHandler(JsParserEvent args) { _codeProvider = args.Code; if (args is JsParserErrorsNotificationArgs args1) { SetErrors(args1); return; } }
public void ExecuteCommandImpl_Partial_ShouldSaveConfigfile() { //Arange string partialfileName = "testPartialfileName"; string methodName = "methodName"; Project selectedProject = Substitute.For <Project>(); selectedProject.CodeModel.Language.Returns("C#"); this.projectManager.MethodName.Returns(methodName); this.projectManager.ServerMethodFolderPath.Returns(@"C:\Users\Vladimir\source\repos\Aras11SP15MethodProject12\Aras11SP15MethodProject12\ServerMethods\"); this.projectManager.SelectedFolderPath.Returns(@"C:\Users\Vladimir\source\repos\Aras11SP15MethodProject12\Aras11SP15MethodProject12\ServerMethods\MSO_Standard\Import\Method\MSO_GetAllSettings\Partials"); this.projectManager.SelectedProject.Returns(selectedProject); this.projectManager.ProjectConfigPath.Returns("ProjectConfigPath"); MethodInfo testMethodInfo = new MethodInfo() { MethodName = methodName, Package = new PackageInfo("MSO_Standard") }; IProjectConfiguraiton projectConfiguraiton = Substitute.For <IProjectConfiguraiton>(); projectConfiguraiton.MethodInfos.Returns(new List <MethodInfo>() { testMethodInfo }); projectConfigurationManager.CurrentProjectConfiguraiton.Returns(projectConfiguraiton); CreateCodeItemViewAdaper createCodeItemViewAdaper = new CreateCodeItemViewAdaper(partialfileName, Aras.Method.Libs.Code.CodeType.Partial, true); this.dialogFactory.GetCreateCodeItemView(Arg.Any <ICodeItemProvider>(), Arg.Any <bool>()).Returns(createCodeItemViewAdaper); ICodeProvider codeProvider = Substitute.For <ICodeProvider>(); CodeInfo codeItemInfo = new CodeInfo() { Code = "code", Path = @"path\testPartialfileName.cs" }; codeProviderFactory.GetCodeProvider("C#").Returns(codeProvider); codeProvider.CreatePartialCodeItemInfo(testMethodInfo, partialfileName, Arg.Any <CodeElementType>(), Arg.Any <bool>(), projectManager.ServerMethodFolderPath, projectManager.SelectedFolderPath, projectManager.MethodName, this.templateLoader, projectManager.MethodPath) .Returns(codeItemInfo); //Act this.createCodeItemCmd.ExecuteCommandImpl(null, null); //Assert this.projectConfigurationManager.Received().Save("ProjectConfigPath"); }
/// <summary> /// Send the error that occured in <see cref="ExecuteAsync"/>. /// </summary> internal static async Task SendErrorAsync( IContext e, string key, object error, ICodeProvider codeProvider, object rangeObj = null) { var sb = new StringBuilder(); switch (rangeObj) { case SourceRange range: { var code = await codeProvider.GetAsync(); sb.AppendLine(); sb.AppendLine(); sb.Append(error); sb.Append(" at "); sb.Append(range.StartLine); sb.Append(':'); sb.Append(range.StartColumn); sb.AppendLine(); sb.AppendLine("```"); sb.Append(code.GetPeek(range.Index, range.Length)); sb.AppendLine("```"); break; } case CompiledSourceRange range: { var code = await codeProvider.GetAsync(); sb.AppendLine(); sb.AppendLine(); sb.Append(error); sb.AppendLine(); sb.AppendLine("```"); sb.Append(code.GetPeek(range.Index, range.Length)); sb.AppendLine("```"); break; } default: sb.AppendLine("```"); sb.Append(error); sb.AppendLine(); sb.AppendLine("```"); break; } await e.ErrorEmbedResource(key) .AppendDescription(sb.ToString()) .ToEmbed().QueueAsync(e, e.GetChannel()); }
private async ValueTask <bool> ExecuteAsync(IContext e, Block block, ICodeProvider codeProvider) { var isDonator = await userService.UserIsDonatorAsync((long)e.GetGuild().OwnerId); var options = isDonator ? DonatorOptions : DefaultOptions; var storage = await CreateStorageAsync(e, isDonator); var say = new ScriptSayFunction(); var global = await CreateGlobalAsync(e, say); var runner = e.GetService <Runner>(); var context = new Context(block, global, runner, options); global["storage"] = storage; try { await runner.ExecuteAsync(context); await SendResultAsync(e, say); await storage.UpdateAsync(context); return(true); } catch (MiScriptLimitException ex) { var type = ex.Type switch { LimitType.Instructions => "instructions", LimitType.Stack => "function calls", LimitType.ArrayItems => "array items", LimitType.ObjectItems => "object items", LimitType.StringLength => "string size", _ => throw new ArgumentOutOfRangeException() }; await e.ErrorEmbedResource("user_error_miscript_limit", type) .ToEmbed().QueueAsync(e, e.GetChannel()); } catch (UserMiScriptException ex) { await SendErrorAsync(e, "user_error_miscript_execute", ex.Value, codeProvider, ex.Position); } catch (MiScriptException ex) { await SendErrorAsync(e, "error_miscript_execute", ex.Message, codeProvider, ex.Position); } catch (Exception ex) { await SendErrorAsync(e, "error_miscript_execute", "Internal error in MiScript: " + ex.Message, codeProvider); } return(false); }
public void GetCodeProvider_NotSupporteCode_ShouldThrowNotSupportedException(string projectLanguageCode) { // Assert NotSupportedException exception = Assert.Throws <NotSupportedException>(new TestDelegate(() => { // Act ICodeProvider codeProvider = codeProviderFactory.GetCodeProvider(projectLanguageCode); })); Assert.AreEqual(messageManager.GetMessage("CurrentProjectTypeIsNotSupported"), exception.Message); }
public CsharpCompilationProvider(ISyntaxTreeProvider syntaxTreeProvider, ICodeProvider codeProvider, IFileNameProvider fileNameProvider, IReferenceProvider referenceProvider, ICompilationOptionProvider compilationOptionProvider) { _syntaxTreeProvider = syntaxTreeProvider; _codeProvider = codeProvider; _fileNameProvider = fileNameProvider; _referenceProvider = referenceProvider; _compilationOptionProvider = compilationOptionProvider; }
public static string Get_Code(ICodeProvider obj) { Stream resourceStream; if (TryGetResourceStream(obj.ResourceName, out resourceStream)) { using (StreamReader reader = new StreamReader(resourceStream, Encoding.UTF8)) { return(reader.ReadToEnd()); } } return(null); }
public override void ExecuteCommandImpl(object sender, EventArgs args) { var project = projectManager.SelectedProject; string selectedMethodName = projectManager.MethodName; string serverMethodFolderPath = projectManager.ServerMethodFolderPath; string selectedFolderPath = projectManager.SelectedFolderPath; string projectConfigPath = projectManager.ProjectConfigPath; var projectConfiguration = projectConfigurationManager.Load(projectConfigPath); MethodInfo methodInformation = projectConfiguration.MethodInfos.FirstOrDefault(m => m.MethodName == selectedMethodName); if (methodInformation == null) { throw new Exception($"Configurations for the {selectedMethodName} method not found."); } var view = dialogFactory.GetCreateCodeItemView(this.codeProviderFactory.GetCodeItemProvider(project.CodeModel.Language), projectConfiguration.UseVSFormatting); var viewResult = view.ShowDialog(); if (viewResult?.DialogOperationResult != true) { return; } string codeItemPath = selectedFolderPath.Substring(serverMethodFolderPath.IndexOf(serverMethodFolderPath) + serverMethodFolderPath.Length); codeItemPath = Path.Combine(codeItemPath, viewResult.FileName); if (methodInformation.PartialClasses.Contains(codeItemPath, StringComparer.InvariantCultureIgnoreCase) || methodInformation.ExternalItems.Contains(codeItemPath, StringComparer.InvariantCultureIgnoreCase)) { throw new Exception($"Code item already exists."); } ICodeProvider codeProvider = codeProviderFactory.GetCodeProvider(project.CodeModel.Language, projectConfiguration); CodeInfo codeItemInfo = codeProvider.CreateCodeItemInfo(methodInformation, viewResult.FileName, viewResult.SelectedCodeType, viewResult.SelectedElementType, viewResult.IsUseVSFormattingCode); projectManager.AddItemTemplateToProjectNew(codeItemInfo, true, 0); if (viewResult.SelectedCodeType == CodeType.Partial) { methodInformation.PartialClasses.Add(codeItemInfo.Path); } else if (viewResult.SelectedCodeType == CodeType.External) { methodInformation.ExternalItems.Add(codeItemInfo.Path); } projectConfiguration.UseVSFormatting = viewResult.IsUseVSFormattingCode; projectConfigurationManager.Save(projectManager.ProjectConfigPath, projectConfiguration); }
public void ExecuteCommandImpl_External_ShouldSaveConfigfile() { //Arange string externalfileName = "testExternalFileName"; string methodName = "methodName"; Project selectedProject = Substitute.For <Project>(); selectedProject.CodeModel.Language.Returns("C#"); this.projectManager.MethodName.Returns(methodName); this.projectManager.SelectedProject.Returns(selectedProject); this.projectManager.ProjectConfigPath.Returns("ProjectConfigPath"); MethodInfo testMethodInfo = new MethodInfo() { MethodName = methodName }; IProjectConfiguraiton projectConfiguraiton = Substitute.For <IProjectConfiguraiton>(); projectConfiguraiton.MethodInfos.Returns(new List <MethodInfo>() { testMethodInfo }); projectConfigurationManager.CurrentProjectConfiguraiton.Returns(projectConfiguraiton); CreateCodeItemViewAdaper createCodeItemViewAdaper = new CreateCodeItemViewAdaper(externalfileName, Aras.Method.Libs.Code.CodeType.External, true); this.dialogFactory.GetCreateCodeItemView(Arg.Any <ICodeItemProvider>(), Arg.Any <bool>()).Returns(createCodeItemViewAdaper); ICodeProvider codeProvider = Substitute.For <ICodeProvider>(); CodeInfo codeItemInfo = new CodeInfo() { Code = "code", Path = @"path\testExternalFileName.cs" }; codeProviderFactory.GetCodeProvider("C#").Returns(codeProvider); codeProvider.CreateExternalCodeItemInfo(testMethodInfo, externalfileName, Arg.Any <CodeElementType>(), Arg.Any <bool>(), this.projectManager.ServerMethodFolderPath, this.projectManager.SelectedFolderPath, this.projectManager.MethodName, this.templateLoader, this.projectManager.MethodPath) .Returns(codeItemInfo); //Act this.createCodeItemCmd.ExecuteCommandImpl(null, null); //Assert this.projectConfigurationManager.Received().Save("ProjectConfigPath"); }
public Recorder(AutomationType automationType, CodeProviderFactory codeProviderFactory, string codeProviderName, Process targetProcess) { _automation = automationType == AutomationType.UIA2 ? (AutomationBase) new FlaUI.UIA2.UIA2Automation() : new FlaUI.UIA3.UIA3Automation(); _codeProvider = CreateCodeProvider(codeProviderFactory, codeProviderName, targetProcess); State = RecorderState.Paused; // Initialize workers _workers.Add(new HoverWorker(_automation, targetProcess.Id)); var click = new ClickRecognizeWorker(_automation, targetProcess.Id); click.ElementClicked += Click_ElementClicked; click.ElementRightClicked += Click_ElementRightClicked; _workers.Add(click); }
public void Init() { serverConnection = Substitute.For <IServerConnection>(); Innovator innovatorIns = new Innovator(serverConnection); this.authManager = new AuthenticationManagerProxy(this.serverConnection, innovatorIns, new InnovatorUser(), Substitute.For <IIOMWrapper>()); this.dialogFactory = Substitute.For <IDialogFactory>(); this.projectConfigurationManager = Substitute.For <IProjectConfigurationManager>(); this.projectConfiguration = Substitute.For <IProjectConfiguraiton>(); this.messageManager = Substitute.For <MessageManager>(); this.packageManager = new PackageManager(this.authManager, this.messageManager); this.templateLoader = new TemplateLoader(); this.codeProvider = Substitute.For <ICodeProvider>(); this.projectManager = Substitute.For <IProjectManager>(); this.arasDataProvider = Substitute.For <IArasDataProvider>(); this.iOWrapper = Substitute.For <IIOWrapper>(); this.methodInformation = new MethodInfo() { MethodName = string.Empty, Package = new PackageInfo(string.Empty) }; this.projectConfiguration.LastSavedSearch.Returns(new Dictionary <string, List <PropertyInfo> >()); XmlDocument methodItemTypeDoc = new XmlDocument(); methodItemTypeDoc.Load(Path.Combine(currentPath, @"Dialogs\ViewModels\TestData\MethodItemType.xml")); Item methodItemType = innovatorIns.newItem(); methodItemType.loadAML(methodItemTypeDoc.OuterXml); MethodItemTypeInfo methodItemTypeInfo = new MethodItemTypeInfo(methodItemType, messageManager); this.arasDataProvider.GetMethodItemTypeInfo().Returns(methodItemTypeInfo); string pathToFileForSave = Path.Combine(currentPath, @"Dialogs\ViewModels\TestData\MethodAml\ReturnNullMethodAml.xml"); this.saveToPackageViewModel = new SaveToPackageViewModel(authManager, dialogFactory, projectConfiguration, templateLoader, packageManager, codeProvider, projectManager, arasDataProvider, iOWrapper, messageManager, methodInformation, pathToFileForSave); }
/// <summary> /// Resolves branch instructions. /// </summary> public static void Resolve(IList <Branch> branches, ICodeProvider provider) { #if DEBUG DebugHooks.LogInfo("ResolveBranches started"); #endif for (int i = 0; i < branches.Count; ++i) { var br = branches[i].Source; var bb = branches[i].TargetBlock; if (br.IsSwitch) { var e = bb.FirstOut; int deftarget = e.To.TranslatedEntryIndex; var targets = new List <int>(); for (e = e.NextOut; e != null; e = e.NextOut) { targets.Add(e.To.TranslatedEntryIndex); } provider.SetCaseTargets(br, targets.ToArray(), deftarget); } else if (br.IsConditionalBranch) { var e = bb.TrueEdge; provider.SetBranchTarget(br, e.To.TranslatedEntryIndex); } else //unconditional branch { #if DEBUG if (!br.IsUnconditionalBranch) //sanity check { throw new ILTranslatorException("Invalid branch instruction"); } #endif var e = bb.FirstOut; if (e.To != bb) //avoid cycle! { provider.SetBranchTarget(br, e.To.TranslatedEntryIndex); } else { provider.SetBranchTarget(br, bb.TranslatedExitIndex - 1); } } } #if DEBUG DebugHooks.LogInfo("ResolveBranches succeeded"); #endif }
public void ExecuteCommandImpl_ShouldAddPartialClassesAndSaveConfigfile() { //Arange string partialfileName = "testPartialfileName"; string methodName = "methodName"; Project selectedProject = Substitute.For <Project>(); selectedProject.CodeModel.Language.Returns("C#"); this.projectManager.MethodName.Returns(methodName); this.projectManager.SelectedProject.Returns(selectedProject); this.projectManager.ProjectConfigPath.Returns("ProjectConfigPath"); MethodInfo testMethodInfo = new MethodInfo() { MethodName = methodName, PartialClasses = new List <string>() }; IProjectConfiguraiton projectConfiguraiton = Substitute.For <IProjectConfiguraiton>(); projectConfiguraiton.MethodInfos.Returns(new List <MethodInfo>() { testMethodInfo }); this.projectConfigurationManager.Load(Arg.Any <string>()).Returns(projectConfiguraiton); CreateCodeItemViewAdaper createCodeItemViewAdaper = new CreateCodeItemViewAdaper(partialfileName, MethodPlugin.Code.CodeType.Partial, true); this.dialogFactory.GetCreateCodeItemView(Arg.Any <ICodeItemProvider>(), Arg.Any <bool>()).Returns(createCodeItemViewAdaper); ICodeProvider codeProvider = Substitute.For <ICodeProvider>(); CodeInfo codeItemInfo = new CodeInfo() { Code = "code", Path = @"path\testPartialfileName.cs" }; codeProviderFactory.GetCodeProvider("C#", projectConfiguraiton).Returns(codeProvider); codeProvider.CreateCodeItemInfo(testMethodInfo, partialfileName, Arg.Any <MethodPlugin.Code.CodeType>(), Arg.Any <CodeElementType>(), Arg.Any <bool>()).Returns(codeItemInfo); //Act this.createCodeItemCmd.ExecuteCommandImpl(null, null); //Assert Assert.IsTrue(testMethodInfo.PartialClasses.Contains(codeItemInfo.Path)); this.projectConfigurationManager.Received().Save("ProjectConfigPath", projectConfiguraiton); }
public override void ExecuteCommandImpl(object sender, EventArgs args) { var project = projectManager.SelectedProject; var projectConfiguration = projectConfigurationManager.Load(projectManager.ProjectConfigPath); var templateLoader = new Templates.TemplateLoader(this.dialogFactory); templateLoader.Load(projectManager.MethodConfigPath); PackageManager packageManager = new PackageManager(authManager); ICodeProvider codeProvider = codeProviderFactory.GetCodeProvider(project.CodeModel.Language, projectConfiguration); var createView = dialogFactory.GetCreateView(projectConfiguration, templateLoader, packageManager, projectManager, codeProvider, globalConfiguration); var createViewResult = createView.ShowDialog(); if (createViewResult?.DialogOperationResult != true) { return; } GeneratedCodeInfo codeInfo = codeProvider.GenerateCodeInfo(createViewResult.SelectedTemplate, createViewResult.SelectedEventSpecificData, createViewResult.MethodName, createViewResult.UseRecommendedDefaultCode, createViewResult.SelectedUserCodeTemplate.Code, createViewResult.IsUseVSFormattingCode); projectManager.CreateMethodTree(codeInfo); string newInnovatorMethodId = authManager.InnovatorInstance.getNewID(); var methodInfo = new MethodInfo() { InnovatorMethodConfigId = newInnovatorMethodId, InnovatorMethodId = newInnovatorMethodId, MethodLanguage = createViewResult.SelectedLanguage.Value, MethodName = createViewResult.MethodName, MethodType = createViewResult.SelectedActionLocation.Value, MethodComment = createViewResult.MethodComment, PackageName = createViewResult.SelectedPackage, TemplateName = createViewResult.SelectedTemplate.TemplateName, EventData = createViewResult.SelectedEventSpecificData.EventSpecificData, ExecutionAllowedToId = createViewResult.SelectedIdentityId, ExecutionAllowedToKeyedName = createViewResult.SelectedIdentityKeyedName, PartialClasses = codeInfo.PartialCodeInfoList.Select(pci => pci.Path).ToList(), ExternalItems = codeInfo.ExternalItemsInfoList.Select(pci => pci.Path).ToList() }; projectConfiguration.AddMethodInfo(methodInfo); projectConfiguration.UseVSFormatting = createViewResult.IsUseVSFormattingCode; projectConfigurationManager.Save(projectManager.ProjectConfigPath, projectConfiguration); }
public void Init() { projectManager = Substitute.For <IProjectManager>(); projectConfigurationManager = Substitute.For <ProjectConfigurationManager>(); dialogFactory = Substitute.For <IDialogFactory>(); authManager = new AuthManagerStub(); codeProviderFactory = Substitute.For <ICodeProviderFactory>(); codeProvider = Substitute.For <ICodeProvider>(); codeProviderFactory.GetCodeProvider(null).ReturnsForAnyArgs(codeProvider); iVsUIShell = Substitute.For <IVsUIShell>(); var currentPath = AppDomain.CurrentDomain.BaseDirectory; projectManager.ProjectConfigPath.Returns(Path.Combine(currentPath, "TestData\\projectConfig.xml")); projectConfigurationManager.Load(projectManager.ProjectConfigPath); projectManager.MethodName.Returns("TestMethod"); projectManager.MethodPath.Returns(Path.Combine(currentPath, "TestData\\TestMethod.txt")); messageManager = Substitute.For <MessageManager>(); DebugMethodCmd.Initialize(projectManager, authManager, dialogFactory, projectConfigurationManager, codeProviderFactory, messageManager); debugMethodCmd = DebugMethodCmd.Instance; var project = Substitute.For <Project>(); var properties = Substitute.For <EnvDTE.Properties>(); var property = Substitute.For <Property>(); var propertiesForActiveConfigurations = Substitute.For <EnvDTE.Properties>(); var propertyForActiveConfiguration = Substitute.For <Property>(); var configurationManager = Substitute.For <ConfigurationManager>(); var activeConfigurator = Substitute.For <Configuration>(); projectManager.SelectedProject.Returns(project); project.FileName.Returns(currentPath); project.Properties.Returns(properties); properties.Item(Arg.Any <string>()).Returns(property); property.Value = ""; project.ConfigurationManager.Returns(configurationManager); configurationManager.ActiveConfiguration.Returns(activeConfigurator); activeConfigurator.Properties.Returns(propertiesForActiveConfigurations); propertiesForActiveConfigurations.Item(Arg.Any <string>()).Returns(propertyForActiveConfiguration); propertyForActiveConfiguration.Value = ""; projectManager.When(x => x.AttachToProcess(Arg.Any <System.Diagnostics.Process>())).Do(x => { }); var codeModel = Substitute.For <CodeModel>(); project.CodeModel.Returns(codeModel); codeModel.Language.Returns(""); }
public bool TraceAggregateSequentally(Label current) { bool isCurrentBranches; bool isCurrentHasSuccessor; do { ICodeProvider <Label> codeProvider = this.parent.CodeProvider; isCurrentBranches = codeProvider.Decode <BlockStartGatherer <Label>, Dummy, bool> (current, this, Dummy.Value); isCurrentHasSuccessor = codeProvider.Next(current, out current); if (isCurrentBranches && isCurrentHasSuccessor) { AddBlockStart(current); } } while (isCurrentHasSuccessor); return(isCurrentBranches); }
public void Init() { projectManager = Substitute.For <IProjectManager>(); projectConfigurationManager = Substitute.For <ProjectConfigurationManager>(); dialogFactory = Substitute.For <IDialogFactory>(); codeProviderFactory = Substitute.For <ICodeProviderFactory>(); CreatePartialElementCmd.Initialize(projectManager, dialogFactory, projectConfigurationManager, codeProviderFactory); createPartialElementCmd = CreatePartialElementCmd.Instance; iVsUIShell = Substitute.For <IVsUIShell>(); var currentPath = AppDomain.CurrentDomain.BaseDirectory; projectManager.ProjectConfigPath.Returns(Path.Combine(currentPath, "TestData\\projectConfig.xml")); projectManager.MethodName.Returns("TestMethod"); projectConfiguration = projectConfigurationManager.Load(projectManager.ProjectConfigPath); projectConfiguration.UseVSFormatting = false; codeProvider = Substitute.For <ICodeProvider>(); codeProviderFactory.GetCodeProvider(null, null).ReturnsForAnyArgs(codeProvider); }
public Code(IMethod method, IClrMethodBody body, ICodeProvider provider) { if (method == null) { throw new ArgumentNullException("method"); } if (body == null) { throw new ArgumentNullException("body"); } if (provider == null) { throw new ArgumentNullException("provider"); } Method = method; Body = body; Provider = provider; }
public void CallParserForDocument(ICodeProvider codeProvider) { _activeDocFullName = codeProvider.FullName; var result = _jsParserService.Process(codeProvider); var toolWindow = _findWindowDelegate(); if (result == null) { // Not JS case - need to clean tree _jsParserService.InvalidateCash(); if (toolWindow != null) { toolWindow.NavigationTreeView.Clear(); } return; } if (result.IsEmpty) { // skip - cached result return; } JsParserEventsBroadcaster.FireActionsForDoc( _activeDocFullName, new JsParserErrorsNotificationArgs { Code = codeProvider, FullFileName = _activeDocFullName, Errors = result.Errors }); if (toolWindow != null) { NotifyColorChangeToToolWindow(); toolWindow.NavigationTreeView.UpdateTree(result, codeProvider); } }
internal ISet<TypeDescriptor> GetPotentialTypes(PropGraphNodeDescriptor n, PropagationGraph propGraph, ICodeProvider codeProvider) { var result = new HashSet<TypeDescriptor>(); foreach (var typeDescriptor in propGraph.GetTypes(n)) { // TO-DO fix by adding a where T: AnalysisType if (typeDescriptor.IsConcreteType) { result.Add(typeDescriptor); } else { // If it is a declaredTyped it means we were not able to compute a concrete type // Therefore, we instantiate all compatible types for the set of instantiated types //result.UnionWith(this.InstatiatedTypes.Where(iType => iType.IsSubtype(typeDescriptor))); Contract.Assert(this.InstatiatedTypes != null); // Diego: This requires a Code Provider. Now it will simply fail. result.UnionWith(this.InstatiatedTypes.Where(candidateTypeDescriptor => codeProvider.IsSubtype(candidateTypeDescriptor, typeDescriptor))); } } return result; }
public JSParserResult Process(ICodeProvider codeProvider, bool skipHashCheck = false) { Code = codeProvider; string docName = Path.Combine(Code.Path, Code.Name); if (!CheckExt(docName)) { return null; } var code = Code.LoadCode(); var hash = Convert.ToBase64String(MD5.Create().ComputeHash(Encoding.Default.GetBytes(code))); if (!skipHashCheck && _loadedCodeHash == hash) { return new JSParserResult(); } _loadedCodeHash = hash; var parserSettings = new JavascriptParserSettings { MaxParametersLength = _settings.MaxParametersLength, MaxParametersLengthInFunctionChain = _settings.MaxParametersLengthInFunctionChain, SkipAnonymousFuntions = _settings.HideAnonymousFunctions, Filename = docName, ScriptStripEnabled = _settings.ScriptStripEnabled, ScriptStripExtensions = _settings.ScriptStripExtensions.OfType<string>().ToArray(), ToDoKeyWords = _settings.ToDoKeywords.OfType<string>().ToArray(), FixAspNetTags = _settings.FixAspNetTags, FixAspNetTagsExtensions = _settings.FixAspNetTagsExtensions.OfType<string>().ToArray(), FixRazorSyntax = _settings.FixRazorSyntax, FixRazorSyntaxExtensions = _settings.FixRazorSyntaxExtensions.OfType<string>().ToArray(), }; var result = (new JavascriptParser(parserSettings)).Parse(code); result.FileName = docName; return result; }
/// <summary> /// Build the tree. /// </summary> public bool UpdateTree(JSParserResult result, ICodeProvider codeProvider) { if (result == null) { Clear(); return false; } if(string.IsNullOrEmpty(result.FileName)) { return false; } StatisticsManager.Instance.Statistics.Container = codeProvider.ContainerName; PerformNetworkActivity(); _lastParserResult = result; _codeProvider = codeProvider; _loadedDocName = _lastParserResult.FileName; _expandedNodesManager.SetFile(_loadedDocName); _marksManager.SetFile(_loadedDocName); var isSort = Settings.SortingEnabled; var isHierarchy = true; _treeRefreshing = true; treeView1.BeginUpdate(); treeView1.Nodes.Clear(); _tempTreeNodes.Clear(); _canExpand = true; var nodes = result.Nodes; if (result.Errors.Count > 0) { btnErrorDiagnosis.Visible = true; btnErrorSeparator.Visible = true; btnErrorDiagnosis.DropDownItems.Clear(); result.Errors.ForEach(er => { var item = btnErrorDiagnosis.DropDownItems.Add(er.Message.SplitWordsByCamelCase() + ".\r\nLine: " + er.StartLine, null, ErrorDiagnosisClick); item.Tag = er; }); } else { btnErrorDiagnosis.Visible = false; btnErrorSeparator.Visible = false; } var tasksDataSource = new List<object>(); if (result.TaskList.Count > 0) { lbTaskList.Text = string.Format(" Task List: {0} items", result.TaskList.Count); int i = 0; result.TaskList.ForEach(t => { ++i; var item = new { No = i.ToString(), Desc = t.Description, Line = t.StartLine.ToString(), }; tasksDataSource.Add(item); }); splitContainer1.Panel2Collapsed = false; SetToDoSplitterPosition(); } else { splitContainer1.Panel2Collapsed = true; tasksDataSource.Add(new {No = "", Desc="", Line="" }); //add fake row to workaround column sizing bug } taskListDataGrid.DataSource = tasksDataSource; taskListDataGrid.CurrentCell = null; _lastCodeLine = -1; _functions = new List<CodeNode>(); FillNodes(nodes, treeView1.Nodes, 0, _functions); if (!isHierarchy) { if (isSort) { _tempTreeNodes.Sort((n1, n2) => string.Compare(n1.Text, n2.Text)); } foreach (TreeNode node in _tempTreeNodes) { treeView1.Nodes.Add(node); } } if (filterByMarksToolStripMenuItem.Checked) { HideUnmarkedNodes(treeView1.Nodes); } treeView1.EndUpdate(); _treeRefreshing = false; AdjustLineNumbersPanelSize(); panelLinesNumbers.Refresh(); return treeView1.Nodes.Count > 0; }
/// <summary> /// Use this method to add a <see cref="ICodeProvider"/> impelementation /// that will be used when (and only) generating the final Composite.Generated.dll. /// </summary> /// <param name="codeProvider"></param> public static void AddAssemblyCodeProvider(ICodeProvider codeProvider) { _dynamicallyAddedCodeProviders.Add(codeProvider); }
internal void SetCodeProvider(ICodeProvider codeProvider) { this.codeProvider = codeProvider; }
internal override ISet<MethodDescriptor> ComputeCalleesForNode(PropagationGraph propGraph, ICodeProvider codeProvider) { var calleesForNode = new HashSet<MethodDescriptor>(); if (this.Receiver != null) { // I replaced the invocation for a local call to mark that functionality is missing //var callees = GetPotentialTypes(this.Receiver, propGraph) // .Select(t => this.Callee.FindMethodImplementation(t)); var callees = GetPotentialTypes(this.Receiver, propGraph, codeProvider) .Select(t => codeProvider.FindMethodImplementation(this.Callee,t)); calleesForNode.UnionWith(callees); } else { calleesForNode.Add(this.Callee); } return calleesForNode; }
public void JsParserEventsHandler(JsParserEvent args) { _codeProvider = args.Code; if (args is JsParserErrorsNotificationArgs) { SetErrors(((JsParserErrorsNotificationArgs)args)); return; } }
internal virtual Task<ISet<MethodDescriptor>> ComputeCalleesForNodeAsync(PropagationGraph propGraph, ICodeProvider codeProvider) { throw new NotImplementedException(); }
internal abstract ISet<MethodDescriptor> ComputeCalleesForNode(PropagationGraph propGraph, ICodeProvider codeProvider);
private async Task<ISet<MethodDescriptor>> GetDelegateCalleesAsync(VariableNode delegateNode, PropagationGraph propGraph, ICodeProvider codeProvider) { var callees = new HashSet<MethodDescriptor>(); var typeDescriptors = propGraph.GetTypes(delegateNode); foreach (var delegateInstance in propGraph.GetDelegates(delegateNode)) { if (typeDescriptors.Count() > 0) { foreach (var typeDescriptor in typeDescriptors) { // TO-DO!!! // Ugly: I'll fix it //var aMethod = delegateInstance.FindMethodImplementation(type); var aMethod = await codeProvider.FindMethodImplementationAsync(delegateInstance, typeDescriptor); callees.Add(aMethod); } } else { // if Count is 0, it is a delegate that do not came form an instance variable callees.Add(delegateInstance); } } return callees; }
internal override ISet<MethodDescriptor> ComputeCalleesForNode(PropagationGraph propGraph, ICodeProvider codeProvider) { return GetDelegateCallees(this.CalleeDelegate, propGraph, codeProvider); }
internal async override Task<ISet<MethodDescriptor>> ComputeCalleesForNodeAsync(PropagationGraph propGraph, ICodeProvider codeProvider) { var calleesForNode = new HashSet<MethodDescriptor>(); if (this.Receiver != null) { // I replaced the invocation for a local call to mark that functionality is missing //var callees = GetPotentialTypes(this.Receiver, propGraph) // .Select(t => this.Callee.FindMethodImplementation(t)); foreach(var type in GetPotentialTypes(this.Receiver, propGraph, codeProvider)) { var realCallee = await codeProvider.FindMethodImplementationAsync(this.Callee, type); calleesForNode.Add(realCallee); } } else { calleesForNode.Add(this.Callee); } return calleesForNode; }
internal override async Task<ISet<MethodDescriptor>> ComputeCalleesForNodeAsync(PropagationGraph propGraph, ICodeProvider codeProvider) { return await GetDelegateCalleesAsync(this.CalleeDelegate, propGraph, codeProvider); }
internal PropagationEffects Propagate(ICodeProvider codeProvider) { this.codeProvider = codeProvider; var calls = new HashSet<AnalysisInvocationExpession>(); bool retModified = false; while (workList.Count > 0) { var analysisNode = workList.First(); this.RemoveFromWorkList(analysisNode); if (IsCallNode(analysisNode) || IsDelegateCallNode(analysisNode)) { calls.Add(GetInvocationInfo(analysisNode)); continue; } if (IsRetNode(analysisNode)) { retModified = true; } var v = GetVertex(analysisNode); var types = GetTypes(analysisNode); foreach (var v1 in graph.GetTargets(v.Id)) { var n1 = GetAnalysisNode(v1); DiffProp(types, n1); var e = graph.GetEdge(v.Id, v1.Id); e.Value.Types = types; DiffPropDelegates(GetDelegates(analysisNode), n1); } } HasBeenPropagated = true; return new PropagationEffects(calls, retModified); }