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);
}
