Exemple #1
0
        private static async Task <CodeElement> GetContainingCodeElementAsync(OmniSharpTestHost host, string filePath, int line, int column)
        {
            var codeStructureService = host.GetRequestHandler <CodeStructureService>(OmniSharpEndpoints.V2.CodeStructure);

            var request = new CodeStructureRequest
            {
                FileName = filePath
            };

            var response = await codeStructureService.Handle(request);

            CodeElement result   = null;
            var         elements = response.Elements;

            while (elements != null)
            {
                foreach (var element in elements)
                {
                    if (element.Ranges[CodeElementRangeNames.Full].Contains(line, column))
                    {
                        result   = element;
                        elements = element.Children;
                        break;
                    }
                }
            }

            Assert.NotNull(result);

            return(result);
        }
        private async Task <(CodeStructureResponse, TestFile)> GetCodeStructureAsync(string contents)
        {
            using (var testProject = await TestAssets.Instance.GetTestProjectAsync("CakeProject", shadowCopy: false))
                using (var host = CreateOmniSharpHost(testProject.Directory))
                {
                    var testFile = new TestFile(Path.Combine(testProject.Directory, "build.cake"), contents);

                    var request = new CodeStructureRequest
                    {
                        FileName = testFile.FileName
                    };

                    var updateBufferRequest = new UpdateBufferRequest
                    {
                        Buffer   = testFile.Content.Code,
                        FileName = testFile.FileName,
                        FromDisk = false
                    };

                    await GetUpdateBufferHandler(host).Handle(updateBufferRequest);

                    var requestHandler = GetRequestHandler(host);

                    return(await requestHandler.Handle(request), testFile);
                }
        }
        public async override Task <SymbolInformationOrDocumentSymbolContainer> Handle(DocumentSymbolParams request, CancellationToken token)
        {
            var omnisharpRequest = new CodeStructureRequest()
            {
                FileName = Helpers.FromUri(request.TextDocument.Uri),
            };

            var omnisharpResponse = await _codeStructureHandler.Handle(omnisharpRequest);

            return(omnisharpResponse.Elements?.Select(ToDocumentSymbolInformationOrDocumentSymbol).ToArray() ??
                   Array.Empty <SymbolInformationOrDocumentSymbol>());
        }
Exemple #4
0
        public async Task NonExistingFile()
        {
            var request = new CodeStructureRequest
            {
                FileName = $"{Guid.NewGuid().ToString("N")}.cs"
            };

            var requestHandler = GetRequestHandler(SharedOmniSharpTestHost);
            var response       = await requestHandler.Handle(request);

            Assert.NotNull(response);
            Assert.Empty(response.Elements);
        }
Exemple #5
0
        private Task <CodeStructureResponse> GetCodeStructureAsync(TestFile testFile, OmniSharpTestHost host = null)
        {
            host = host ?? SharedOmniSharpTestHost;

            host.AddFilesToWorkspace(testFile);

            var requestHandler = GetRequestHandler(host);

            var request = new CodeStructureRequest
            {
                FileName = "test.cs"
            };

            return(requestHandler.Handle(request));
        }
        public static async Task <CodeStructureResponse> TranslateAsync(this CodeStructureResponse response, OmniSharpWorkspace workspace, CodeStructureRequest request)
        {
            var zeroIndex = await LineIndexHelper.TranslateToGenerated(request.FileName, 0, workspace);

            var elements = new List <CodeElement>();

            foreach (var element in response.Elements)
            {
                if (element.Ranges.Values.Any(x => x.Start.Line < zeroIndex))
                {
                    continue;
                }

                var translatedElement = await element.TranslateAsync(workspace, request);

                if (translatedElement.Ranges.Values.Any(x => x.Start.Line < 0))
                {
                    continue;
                }

                elements.Add(translatedElement);
            }

            response.Elements = elements;
            return(response);
        }