public object Initialize(JToken arg) { Log(Methods.InitializeName, arg); var capabilities = new ServerCapabilities(); capabilities.TextDocumentSync = new TextDocumentSyncOptions(); capabilities.TextDocumentSync.OpenClose = true; capabilities.TextDocumentSync.Change = TextDocumentSyncKind.Full; capabilities.CompletionProvider = new CompletionOptions(); capabilities.CompletionProvider.ResolveProvider = false; capabilities.CompletionProvider.TriggerCharacters = new string[] { ",", "." }; capabilities.CodeActionProvider = true; capabilities.SignatureHelpProvider = new SignatureHelpOptions(); capabilities.SignatureHelpProvider.TriggerCharacters = new string [] { "(" }; capabilities.DefinitionProvider = true; capabilities.ReferencesProvider = true; capabilities.HoverProvider = true; capabilities.WorkspaceSymbolProvider = true; var result = new InitializeResult(); result.Capabilities = capabilities; return(result); }
private void SendInitializationResponse(JsonRpc.RpcRequest request) { var initializeResult = new InitializeResult() { Capabilities = new ServerCapabilities() { TextDocumentSync = TextDocumentSyncKind.Full, // TOOD: change to incremental to improve perf. HoverProvider = true, DefinitionProvider = true, } }; _messageWriter.WriteResponse(request.Id, initializeResult); SendLogMessage($@" PeachPie Language Server PID: {Process.GetCurrentProcess().Id} Path: {System.Reflection.Assembly.GetEntryAssembly().Location} "); if (_options.IsDebug) { SendGreetingMessage(); } }
public bool Start( string ServerName, string ExcutablePath, string Arguments, string RootUri, string WorkspaceConfig, long HidemaruProcessId) { if (client_ != null) { //起動済み return(true); } options_ = new Option { ServerName = ServerName, ExcutablePath = ExcutablePath, Arguments = Arguments, RootUri = RootUri, WorkspaceConfig = WorkspaceConfig, }; hidemaruProcessId_ = HidemaruProcessId; InitializeClient(); var reqId = InitializeServer(); var response = client_.QueryResponse(reqId, millisecondsTimeout: defaultTimeout); if ((ResponseIsCorrect(response) == false) || (response.item == null)) { return(false); } initializeResult_ = (InitializeResult)response.item; InitializedClient(); return(true); }
public async Task InitializeAsync_InvokesHandlerWithParamsAndCapabilities() { // Arrange var originalInitParams = new InitializeParams() { Capabilities = new ClientCapabilities() { Experimental = true }, RootUri = new Uri("C:/path/to/workspace"), }; var initializeResult = new InitializeResult(); var handler = new Mock <IRequestHandler <InitializeParams, InitializeResult> >(MockBehavior.Strict); handler.Setup(h => h.HandleRequestAsync(It.IsAny <InitializeParams>(), It.IsAny <ClientCapabilities>(), It.IsAny <CancellationToken>())) .Callback <InitializeParams, ClientCapabilities, CancellationToken>((initParams, clientCapabilities, token) => { Assert.True((bool)initParams.Capabilities.Experimental); Assert.Equal(originalInitParams.RootUri.AbsoluteUri, initParams.RootUri.AbsoluteUri); }) .Returns(Task.FromResult(initializeResult)) .Verifiable(); var metadata = Mock.Of <IRequestHandlerMetadata>(rhm => rhm.MethodName == Methods.InitializeName, MockBehavior.Strict); using var languageServer = new RazorHtmlCSharpLanguageServer(new[] { new Lazy <IRequestHandler, IRequestHandlerMetadata>(() => handler.Object, metadata) }); var serializedInitParams = JToken.FromObject(originalInitParams); // Act var result = await languageServer.InitializeAsync(serializedInitParams, CancellationToken.None).ConfigureAwait(false); // Assert Assert.Same(initializeResult, result); handler.VerifyAll(); }
public void Deserialize_InitializeIsSuccessful_ReturnsNonEmptyRedirectUrl() { ResultParser resultParser = new ResultParser(); InitializeResult result = resultParser.Deserialize <InitializeResult>(Factory.InitializeResult); Assert.IsNotNullOrEmpty(result.RedirectUrl); }
public object Initialize(JToken arg) { /* We want to support the hover capability. When we get a hover request we will respond * with the appropriate text. * Check the client's declared capabilities to identify what hover format the client expects * before returning a hover response from the server. Stash away the expected format for use * when composing the hover response. */ var b = arg.ToObject <InitializeParams>(); MarkupKind[] m = b.Capabilities.TextDocument.Hover.ContentFormat; // in the case of Visual Studio, this is what I am observing. Capturing that as an assertion // just in case things change. System.Diagnostics.Debug.Assert(m != null && m.Length == 1 && m[0] == MarkupKind.PlainText); HoverContentFormat = m[0]; /* *"hover" is the only capability that we wil report back as supported. */ var capabilities = new ServerCapabilities(); capabilities.HoverProvider = true; var result = new InitializeResult(); result.Capabilities = capabilities; Initialized?.Invoke(this, new EventArgs()); return(result); }
public ServerCapabilities(InitializeResult result) { var capabilities = result.capabilities; CompletionProvider_ = Check(capabilities.completionProvider); HoverProvider_ = Check(capabilities.hoverProvider); SignatureHelpProvider_ = Check(capabilities.signatureHelpProvider); DeclarationProvider_ = Check(capabilities.declarationProvider); DefinitionProvider_ = Check(capabilities.definitionProvider); TypeDefinitionProvider_ = Check(capabilities.typeDefinitionProvider); ImplementationProvider_ = Check(capabilities.implementationProvider); ReferencesProvider_ = Check(capabilities.referencesProvider); DocumentHighlightProvider_ = Check(capabilities.documentHighlightProvider); DocumentSymbolProvider_ = Check(capabilities.documentSymbolProvider); CodeActionProvider_ = Check(capabilities.codeActionProvider); CodeLensProvider_ = Check(capabilities.codeLensProvider); DocumentLinkProvider_ = Check(capabilities.documentLinkProvider); ColorProvider_ = Check(capabilities.colorProvider); DocumentFormattingProvider_ = Check(capabilities.documentFormattingProvider); DocumentRangeFormattingProvider_ = Check(capabilities.documentRangeFormattingProvider); DocumentOnTypeFormattingProvider_ = Check(capabilities.documentOnTypeFormattingProvider); RenameProvider_ = Check(capabilities.renameProvider); FoldingRangeProvider_ = Check(capabilities.foldingRangeProvider); ExecuteCommandProvider_ = Check(capabilities.executeCommandProvider); SelectionRangeProvider_ = Check(capabilities.selectionRangeProvider); LinkedEditingRangeProvider_ = Check(capabilities.linkedEditingRangeProvider); CallHierarchyProvider_ = Check(capabilities.callHierarchyProvider); //ToDo:後で実装(semanticTokensProvider) //SemanticTokensProvider_ = Check(capabilities.semanticTokensProvider); MonikerProvider_ = Check(capabilities.monikerProvider); WorkspaceSymbolProvider_ = Check(capabilities.workspaceSymbolProvider); }
public static InitializeResult ParseInitializeResult(string xmlText) { var result = new InitializeResult { RawXml = xmlText }; var doc = XDocument.Parse(xmlText); var root = doc.Element("payex"); foreach (var node in root.Elements()) { var value = node.Value; var name = node.Name.LocalName.ToLower(); switch (name) { case "status": ParseStatus(result, node); break; case "orderref": result.OrderRef = value; break; case "redirecturl": result.RedirectUrl = value; break; case "sessionref": result.SessionRef = value; break; } } return(result); }
public PaymentInitializeResult Initialize(PaymentMethod currentPayment, string orderNumber, string returnUrl, string orderRef) { Log.InfoFormat("Initializing payment with ID:{0} belonging to order with ID: {1}", currentPayment.Payment.Id, currentPayment.OrderGroupId); PaymentInformation paymentInformation = CreateModel(currentPayment, orderNumber); InitializeResult result = _paymentManager.Initialize(currentPayment.Cart, paymentInformation, currentPayment.IsDirectModel, currentPayment.IsDirectModel); if (!result.Status.Success) { return new PaymentInitializeResult { Success = false, ErrorMessage = result.Status.Description } } ; Log.InfoFormat("Setting PayEx order reference to {0} on payment with ID:{1} belonging to order with ID: {2}", result.OrderRef, currentPayment.Payment.Id, currentPayment.OrderGroupId); currentPayment.Payment.PayExOrderRef = result.OrderRef.ToString(); _cartActions.UpdateCartInstanceId(currentPayment.Cart); // Save all the changes that have been done to the cart if (_paymentInitializer != null) { return(_paymentInitializer.Initialize(currentPayment, orderNumber, result.RedirectUrl, result.OrderRef.ToString())); } return(new PaymentInitializeResult { Success = true }); }
public InitializeResult Initialize(Cart cart, PaymentInformation payment, bool ignoreOrderLines = false, bool ignoreCustomerAddress = false) { Log.InfoFormat("Calling Initialize for cart with ID:{0}. PaymentInformation:{1}", cart.Id, payment); string hash = _hasher.Create(_payExSettings.AccountNumber, payment, _payExSettings.EncryptionKey); string xmlResult = _orderFacade.Initialize(_payExSettings.AccountNumber, payment, hash); InitializeResult result = _resultParser.Deserialize <InitializeResult>(xmlResult); if (!result.Status.Success) { Log.ErrorFormat("Error when calling Initialize for cart with ID:{0}. Result:{1}", cart.Id, xmlResult); return(result); } Log.InfoFormat("Successfully called Initialize for cart with ID:{0}. Result:{1}", cart.Id, xmlResult); if (!ignoreOrderLines && _payExSettings.IncludeOrderLines) { AddOrderLineItems(cart, payment, result); } if (!ignoreCustomerAddress && _payExSettings.IncludeCustomerAddress) { AddOrderAddress(cart, payment, result); } return(result); }
private static Task Started(ILanguageServer server, InitializeResult result, CancellationToken cancellationToken) { // TODO this currently only sent to get rid of the "Server answer pending" of the VSCode plugin. server.SendNotification("serverStarted", DafnyVersion); server.SendNotification("dafnyLanguageServerVersionReceived", DafnyVersion); return(Task.CompletedTask); }
public void SerializeInitializeResultWithSyncKindIncremental() { var obj = new InitializeResult(TextDocumentSyncKind.Incremental); var json = SerializeObject(obj); Assert.Equal(@"{""capabilities"":{""textDocumentSync"":{""openClose"":true,""change"":2},""hoverProvider"":true}}", json); }
public void Deserialize_InitializeIsSuccessful_ReturnsNonEmptyOrderRef() { ResultParser resultParser = new ResultParser(); InitializeResult result = resultParser.Deserialize <InitializeResult>(Factory.InitializeResult); Assert.IsTrue(result.OrderRef != Guid.Empty); }
public void Deserialize_InitializeResultXml_ReturnsInitializeResultObject() { ResultParser resultParser = new ResultParser(); InitializeResult result = resultParser.Deserialize <InitializeResult>(Factory.InitializeResult); Assert.IsNotNull(result); }
public void Deserialize_InitializeIsSuccessful_ReturnsSuccessTrue() { ResultParser resultParser = new ResultParser(); InitializeResult result = resultParser.Deserialize <InitializeResult>(Factory.InitializeResult); Assert.IsNotNull(result.Status); }
public async Task Initialize(CancellationToken token) { var @params = new InitializeParams { Trace = _trace, Capabilities = _clientCapabilities, ClientInfo = _clientInfo, RootUri = _rootUri, RootPath = _rootUri?.GetFileSystemPath(), WorkspaceFolders = new Container <WorkspaceFolder>(_workspaceFoldersManager.CurrentWorkspaceFolders), InitializationOptions = _initializationOptions }; RegisterCapabilities(@params.Capabilities); _workDoneManager.Initialize(@params.Capabilities.Window); ClientSettings = @params; _connection.Open(); var serverParams = await this.RequestLanguageProtocolInitialize(ClientSettings, token); _receiver.Initialized(); ServerSettings = serverParams; if (_collection.ContainsHandler(typeof(IRegisterCapabilityHandler))) { RegistrationManager.RegisterCapabilities(serverParams.Capabilities); } // TODO: pull supported fields and add any static registrations to the registration manager this.SendLanguageProtocolInitialized(new InitializedParams()); }
public object Initialize(JToken arg) { if (trace) { System.Console.Error.WriteLine("<-- Initialize"); System.Console.Error.WriteLine(arg.ToString()); } ServerCapabilities capabilities = new ServerCapabilities { TextDocumentSync = new TextDocumentSyncOptions { OpenClose = true, Change = TextDocumentSyncKind.Incremental, Save = new SaveOptions { IncludeText = true } }, HoverProvider = true, CompletionProvider = new CompletionOptions { ResolveProvider = true, TriggerCharacters = new string[] { ",", "." } }, ReferencesProvider = true, DefinitionProvider = true, TypeDefinitionProvider = false, // Does not make sense for Antlr. ImplementationProvider = false, // Does not make sense for Antlr. DocumentHighlightProvider = true, DocumentSymbolProvider = true, WorkspaceSymbolProvider = false, DocumentFormattingProvider = true, DocumentRangeFormattingProvider = false, RenameProvider = true }; InitializeResult result = new InitializeResult { Capabilities = capabilities }; string json = JsonConvert.SerializeObject(result); if (trace) { System.Console.Error.WriteLine("--> " + json); } return(result); }
async Task <InitializeResult> Initialize() { Log("Sending '{0}' message.", Methods.InitializeName); var message = CreateInitializeParams(client, rootPath); InitializeResult result = null; try { result = await jsonRpc.InvokeWithParameterObjectAsync(Methods.Initialize, message); await client.OnServerInitializedAsync(); } catch (Exception ex) { await client.OnServerInitializeFailedAsync(ex); throw; } try { Log("Sending '{0}' message.", Methods.InitializedName); await jsonRpc.NotifyWithParameterObjectAsync(Methods.Initialized, new InitializedParams()); } catch (Exception ex) { LogError("Sending Initialized notification to server failed.", ex); } Log("Initialized.", Id); return(result); }
public void SimpleTest(string expected) { var model = new InitializeResult { Capabilities = new ServerCapabilities { CodeActionProvider = true, CodeLensProvider = new CodeLensRegistrationOptions.StaticOptions { ResolveProvider = true, }, CompletionProvider = new CompletionRegistrationOptions.StaticOptions { ResolveProvider = true, TriggerCharacters = new[] { "a", "b", "c" } }, DefinitionProvider = true, DocumentFormattingProvider = true, DocumentHighlightProvider = true, DocumentLinkProvider = new DocumentLinkRegistrationOptions.StaticOptions { ResolveProvider = true }, DocumentOnTypeFormattingProvider = new DocumentOnTypeFormattingRegistrationOptions.StaticOptions { FirstTriggerCharacter = ".", MoreTriggerCharacter = new[] { ";", " " } }, DocumentRangeFormattingProvider = true, DocumentSymbolProvider = true, ExecuteCommandProvider = new ExecuteCommandRegistrationOptions.StaticOptions { Commands = new[] { "command1", "command2" } }, Experimental = new Dictionary <string, JToken> { { "abc", "123" } }, HoverProvider = true, ReferencesProvider = true, RenameProvider = true, SignatureHelpProvider = new SignatureHelpRegistrationOptions.StaticOptions { TriggerCharacters = new[] { ";", " " } }, TextDocumentSync = new TextDocumentSync( new TextDocumentSyncOptions { Change = TextDocumentSyncKind.Full, OpenClose = true, Save = new SaveOptions { IncludeText = true }, WillSave = true, WillSaveWaitUntil = true } ), WorkspaceSymbolProvider = true, } }; var result = Fixture.SerializeObject(model); result.Should().Be(expected); var deresult = new LspSerializer(ClientVersion.Lsp3).DeserializeObject <InitializeResult>(expected); deresult.Should().BeEquivalentTo(model, x => x.UsingStructuralRecordEquality()); }
// Add the plugins actions and data source public InitializeResult Initialize(PluginEnvironment env, Assembly assembly, IMessageReceiver receiver) { env.SetDataSource(PartTypeSourceName, new Sentence(new List <KeyValuePair <string, string> >())); env.AddAction(new StringParseHandler(env)); env.AddAction(new EnumerableParseHandler()); env.AddAction(new ParaphraseHandler(env)); return(InitializeResult.Success()); }
// Add the plugins actions and data source public InitializeResult Initialize(PluginEnvironment env, Assembly assembly, IMessageReceiver receiver) { // Data files contained in [datadrectory]/parser string morphodir = env.GetConfigDirectory("datadirectory") + Path.DirectorySeparatorChar + "morpho" + Path.DirectorySeparatorChar; MemcachedClient cache = MemcacheSource.DefaultClient(); GivenNames names = new GivenNames(morphodir, cache); return(InitializeResult.Success()); }
private static Task OnStartedCallback(ILanguageServer server, InitializeResult result, CancellationToken cancellationToken) { server.Window.ShowMessage(new ShowMessageParams { Message = $"{result.ServerInfo.Name} server started", Type = MessageType.Info }); return(Task.CompletedTask); }
public InitializeResult Initialize(PluginEnvironment env, Assembly assembly, IMessageReceiver receiver) { // Data files contained in [datadrectory]/wordnet string basedir = env.GetConfigDirectory("datadirectory") + Path.DirectorySeparatorChar + "morpho" + Path.DirectorySeparatorChar; InitializeNouns(env, basedir); InitializeVerbs(env, basedir); return(InitializeResult.Success()); }
private void AddOrderAddress(Cart cart, PaymentInformation payment, InitializeResult initializeResult) { Log.InfoFormat("Calling AddOrderAddress for cart with ID:{0}. PaymentInformation:{1}. InitializeResult:{2}", cart.Id, payment, initializeResult); PayExAddress address = CartHelper.OrderAddress(cart, payment, initializeResult); string hash = _hasher.Create(_payExSettings.AccountNumber, address, _payExSettings.EncryptionKey); string xmlResult = _orderFacade.AddOrderAddress(_payExSettings.AccountNumber, address, hash); Log.InfoFormat("Finished calling AddOrderAddress for cart with ID:{0}. PaymentInformation:{1}. InitializeResult:{2}. Result:{3}", cart.Id, payment, initializeResult, xmlResult); }
static void VerifyServerSettings(InitializeResult result) { result.Capabilities.Workspace.FileOperations.DidCreate.Should().NotBeNull(); result.Capabilities.Workspace.FileOperations.WillCreate.Should().NotBeNull(); var s = result.Capabilities.Workspace.FileOperations.DidCreate.Filters.Should().HaveCount(1).And.Subject.FirstOrDefault(); s.Scheme.Should().Be("file"); s.Pattern.Glob.Should().Be("**/*.cs"); s.Pattern.Matches.Should().Be(FileOperationPatternKind.File); s.Pattern.Options.IgnoreCase.Should().BeTrue(); }
public InitializeResult Initialize(string userAgent) { var initializeResult = new InitializeResult() { IsMobile = Utilities.IsMobile(userAgent), AvailableSortingAlgorithms = Utilities.GetAvailableSortingAlgorithms(), AvailableSearchingAlgorithms = Utilities.GetAvailableSearchingAlgorithms() }; return(initializeResult); }
public object Initialize(JToken arg) { if (trace) { System.Console.Error.WriteLine("<-- Initialize"); System.Console.Error.WriteLine(arg.ToString()); } var capabilities = new ServerCapabilities(); capabilities.TextDocumentSync = new TextDocumentSyncOptions(); capabilities.TextDocumentSync.OpenClose = true; capabilities.TextDocumentSync.Change = TextDocumentSyncKind.Incremental; capabilities.TextDocumentSync.Save = new SaveOptions(); capabilities.TextDocumentSync.Save.IncludeText = true; capabilities.HoverProvider = true; capabilities.CompletionProvider = new CompletionOptions(); capabilities.CompletionProvider.ResolveProvider = false; capabilities.CompletionProvider.TriggerCharacters = new string[] { ",", "." }; capabilities.ReferencesProvider = false; capabilities.DefinitionProvider = false; capabilities.TypeDefinitionProvider = false; // Does not make sense for Antlr. capabilities.ImplementationProvider = false; // Does not make sense for Antlr. capabilities.DocumentHighlightProvider = false; capabilities.DocumentSymbolProvider = false; capabilities.WorkspaceSymbolProvider = false; capabilities.DocumentFormattingProvider = false; capabilities.DocumentRangeFormattingProvider = false; capabilities.RenameProvider = false; var result = new InitializeResult(); result.Capabilities = capabilities; string json = JsonConvert.SerializeObject(result); if (trace) { System.Console.Error.WriteLine("--> " + json); } return(result); }
protected override Result <InitializeResult, ResponseError <InitializeErrorData> > Initialize(InitializeParams parameters) { var capabilities = new ServerCapabilities { textDocumentSync = TextDocumentSyncKind.Incremental, }; var result = new InitializeResult { capabilities = capabilities }; return(Result <InitializeResult, ResponseError <InitializeErrorData> > .Success(result)); }
// Add the plugins actions and data source public InitializeResult Initialize(PluginEnvironment env, Assembly assembly, IMessageReceiver receiver) { // Data files contained in [datadrectory]/parser string parserdir = env.GetConfigDirectory("datadirectory") + Path.DirectorySeparatorChar + "parser" + Path.DirectorySeparatorChar; POSTagger tagger = new POSTagger(parserdir + "lexicon_all", parserdir + "ruleset", assembly, null); env.SetDataSource <string, string[]>(LanguageNet.Grammarian.POSTagger.PartsSourceName, tagger); env.AddAction(new EnumerableTagHandler(tagger)); env.AddAction(new PhraseResolveHandler(tagger)); env.AddAction(new StringTagHandler(tagger)); return(InitializeResult.Success()); }
public void BooleanOrTest(string expected) { var model = new InitializeResult() { Capabilities = new ServerCapabilities { CodeActionProvider = new CodeActionOptions { CodeActionKinds = new[] { CodeActionKind.QuickFix } }, ColorProvider = new DocumentColorOptions { DocumentSelector = DocumentSelector.ForPattern("**/*.foo"), Id = "foo" }, DeclarationProvider = new DeclarationOptions { DocumentSelector = DocumentSelector.ForPattern("**/*.foo"), Id = "foo" }, FoldingRangeProvider = new FoldingRangeOptions { DocumentSelector = DocumentSelector.ForPattern("**/*.foo"), Id = "foo" }, ImplementationProvider = new ImplementationOptions { DocumentSelector = DocumentSelector.ForPattern("**/*.foo"), Id = "foo" }, RenameProvider = new RenameOptions { PrepareProvider = true }, TypeDefinitionProvider = new TypeDefinitionOptions { DocumentSelector = DocumentSelector.ForPattern("**/*.foo"), Id = "foo" } } }; var result = Fixture.SerializeObject(model); result.Should().Be(expected); var deresult = new Serializer(ClientVersion.Lsp3).DeserializeObject <InitializeResult>(expected); deresult.Should().BeEquivalentTo(model); }