Esempio n. 1
0
        public AutoCompletionResult TryComplete(string line)
        {
            List <AutoCompletionResult> results = new List <AutoCompletionResult>();

            foreach (var command in GConsole.Instance.Commands)
            {
                results.Add(command.AutoComplete(line));
            }

            int successCount         = results.Count(x => x.WasSuccessful == AutoCompletionResultType.SuccessOneOption);
            int successMultipleCount = results.Count(x => x.WasSuccessful == AutoCompletionResultType.SuccessMultipleOptions);

            if (successCount == 1 && successMultipleCount == 0)
            {
                return(results.Find(x => x.WasSuccessful == AutoCompletionResultType.SuccessOneOption));
            }
            else if (successMultipleCount > 0 || successCount > 1)
            {
                AutoCompletionResult result = new AutoCompletionResult();
                result.WasSuccessful = AutoCompletionResultType.SuccessMultipleOptions;

                foreach (var successResults in results.FindAll(
                             x => x.WasSuccessful == AutoCompletionResultType.SuccessOneOption ||
                             x.WasSuccessful == AutoCompletionResultType.SuccessMultipleOptions))
                {
                    result.Results.AddRange(successResults.Results);
                }
                return(result);
            }
            else
            {
                return(new AutoCompletionResult());
            }
        }
        public void MetricsShouldGetSortedGivenUnSortedArray()
        {
            AutoCompletionResult result = new AutoCompletionResult();
            int duration = 2000;

            Thread.Sleep(duration);
            result.CompleteResult(new CompletionItem[] { });
            Assert.True(result.Duration >= duration);
        }
        public void CompletionShouldRecordDuration()
        {
            AutoCompletionResult result = new AutoCompletionResult();
            int duration = 200;

            Thread.Sleep(duration);
            result.CompleteResult(new CompletionItem[] { });
            Assert.True(result.Duration >= duration);
        }
        // Disable flaky test (mairvine - 3/15/2018)
        // [Fact]
        public void CompletionItemsShouldCreatedUsingSqlParserIfTheProcessDoesNotTimeout()
        {
            ConnectedBindingQueue bindingQueue      = new ConnectedBindingQueue();
            ScriptDocumentInfo    docInfo           = CreateScriptDocumentInfo();
            CompletionService     completionService = new CompletionService(bindingQueue);
            ConnectionInfo        connectionInfo    = new ConnectionInfo(null, null, null);
            bool useLowerCaseSuggestions            = true;

            CompletionItem[] defaultCompletionList = AutoCompleteHelper.GetDefaultCompletionItems(docInfo, useLowerCaseSuggestions);

            List <Declaration> declarations = new List <Declaration>();

            var sqlParserWrapper = new Mock <ISqlParserWrapper>();

            sqlParserWrapper.Setup(x => x.FindCompletions(docInfo.ScriptParseInfo.ParseResult, docInfo.ParserLine, docInfo.ParserColumn,
                                                          It.IsAny <IMetadataDisplayInfoProvider>())).Returns(declarations);
            completionService.SqlParserWrapper = sqlParserWrapper.Object;

            AutoCompletionResult result = completionService.CreateCompletions(connectionInfo, docInfo, useLowerCaseSuggestions);

            Assert.NotNull(result);
            Assert.NotEqual(result.CompletionItems == null ? 0 : result.CompletionItems.Count(), defaultCompletionList.Count());
        }
        public void CompletionItemsShouldCreatedUsingDefaultListIfTheSqlParserProcessTimesout()
        {
            ConnectedBindingQueue bindingQueue      = new ConnectedBindingQueue();
            ScriptDocumentInfo    docInfo           = CreateScriptDocumentInfo();
            CompletionService     completionService = new CompletionService(bindingQueue);
            ConnectionInfo        connectionInfo    = new ConnectionInfo(null, null, null);
            bool useLowerCaseSuggestions            = true;
            List <Declaration> declarations         = new List <Declaration>();

            CompletionItem[] defaultCompletionList = AutoCompleteHelper.GetDefaultCompletionItems(docInfo, useLowerCaseSuggestions);

            var sqlParserWrapper = new Mock <ISqlParserWrapper>();

            sqlParserWrapper.Setup(x => x.FindCompletions(docInfo.ScriptParseInfo.ParseResult, docInfo.ParserLine, docInfo.ParserColumn,
                                                          It.IsAny <IMetadataDisplayInfoProvider>())).Callback(() => Thread.Sleep(LanguageService.BindingTimeout + 100)).Returns(declarations);
            completionService.SqlParserWrapper = sqlParserWrapper.Object;

            AutoCompletionResult result = completionService.CreateCompletions(connectionInfo, docInfo, useLowerCaseSuggestions);

            Assert.NotNull(result);
            Assert.Equal(result.CompletionItems.Count(), defaultCompletionList.Count());
            Thread.Sleep(3000);
            Assert.True(connectionInfo.IntellisenseMetrics.Quantile.Any());
        }
        public AutoCompletionResult Autocomplete(string text, bool includeExplanation = false)
        {
            if (string.IsNullOrWhiteSpace(text))
            {
                return(AutoCompletionResult.NoResult(text));
            }

            var searchers = _directoryFactory.GetAllDirectories().Select(d =>
            {
                try
                {
                    return(new IndexSearcher(d, true));
                }
                catch (Exception e)
                {
                    _log.Error(e, "While searching directory {0}", d);
                    return(null);
                }
            })
                            .Where(s => s != null)
                            .ToArray();

            using (var searcher = new MultiSearcher(searchers))
            {
                try
                {
                    BooleanQuery query = GetQueryForText(text);

                    var results  = searcher.Search(query, 10);
                    var commands = results.ScoreDocs
                                   .Select(d =>
                    {
                        var document = searcher.Doc(d.Doc);
                        try
                        {
                            Explanation explanation = null;
                            if (includeExplanation)
                            {
                                explanation = searcher.Explain(query, d.Doc);
                            }
                            var coreDoc = CoreDocument.Rehydrate(document);
                            var command = _converterRepository.FromDocumentToItem(coreDoc);

                            return(new AutoCompletionResult.CommandResult(command, coreDoc.GetDocumentId(), explanation));
                        }
                        catch (Exception e)
                        {
                            _log.Error(e, "Error getting command result for document {0}:{1}",
                                       document.GetField(SpecialFields.ConverterId).StringValue,
                                       document.GetField(SpecialFields.Id).StringValue);
                            return(null);
                        }
                    })
                                   .Where(r => r != null);
                    return(AutoCompletionResult.OrderedResult(text, commands));
                }
                catch (ParseException e)
                {
                    _log.Error(e, "Error parsing '{0}'", text);
                    return(AutoCompletionResult.NoResult(text));
                }
            }
        }