Exemple #1
0
 public PaketSearchDataSource(SearchPopupSearchPattern searchPattern)
 {
     searchResults = PaketSearchCommands
                     .FilterCommands(searchPattern.Pattern)
                     .Select(command => new PaketSearchResult(command))
                     .ToList();
 }
Exemple #2
0
 public override Task GetResults(ISearchResultCallback searchResultCallback, SearchPopupSearchPattern pattern, CancellationToken token)
 {
     if (IsProjectSelected())
     {
         searchResultCallback.ReportResult(new SearchPackageSearchResult(pattern));
     }
     return(Task.CompletedTask);
 }
        static async Task <List <SearchResult> > Search(string pattern)
        {
            var category = new RoslynSearchCategory();
            var callback = new GatherResultCallback();

            await category.GetResults(callback, SearchPopupSearchPattern.ParsePattern(pattern), CancellationToken.None);

            return(callback.Results);
        }
 public override Task <ISearchDataSource> GetResults(SearchPopupSearchPattern searchPattern, int resultsCount, CancellationToken token)
 {
     return(Task.Factory.StartNew(() => {
         if ((searchPattern.Tag == null) || IsValidTag(searchPattern.Tag))
         {
             return (ISearchDataSource) new PortableClassLibraryDataSource(searchPattern);
         }
         return null;
     }));
 }
 public override Task GetResults(
     ISearchResultCallback searchResultCallback,
     SearchPopupSearchPattern pattern,
     CancellationToken token)
 {
     if (pattern.Tag == null || IsValidTag(pattern.Tag))
     {
         searchResultCallback.ReportResult(new PortableClassLibrarySearchResult());
     }
     return(Task.FromResult(1));
 }
        public override Task <ISearchDataSource> GetResults(SearchPopupSearchPattern searchPattern, int resultsCount, CancellationToken token)
        {
            return(Task.Factory.StartNew(() => {
                if (!IsValidTag(searchPattern.Tag))
                {
                    return null;
                }

                return (ISearchDataSource) new NuGetPackageDataSource(searchPattern);
            }));
        }
Exemple #7
0
        public override Task GetResults(ISearchResultCallback searchResultCallback, SearchPopupSearchPattern searchPattern, CancellationToken token)
        {
            return(Task.Run(async delegate {
                if (searchPattern.Tag != null && !(typeTags.Contains(searchPattern.Tag) || memberTags.Contains(searchPattern.Tag)) || searchPattern.HasLineNumber)
                {
                    return;
                }
                try {
                    if (SymbolInfoTask == null)
                    {
                        SymbolInfoTask = Task.FromResult(default(SymbolCache)).ContinueWith(t => GetSymbolInfos(token));
                    }
                    var cache = await SymbolInfoTask.ConfigureAwait(false);
                    if (token.IsCancellationRequested)
                    {
                        return;
                    }

                    string toMatch = searchPattern.Pattern;
                    var newResult = new WorkerResult();
                    newResult.pattern = searchPattern.Pattern;
                    newResult.Tag = searchPattern.Tag;
                    newResult.matcher = StringMatcher.GetMatcher(toMatch, false);
                    newResult.FullSearch = toMatch.IndexOf('.') > 0;

                    var oldLastResult = lastResult;
                    if (newResult.FullSearch && oldLastResult != null && !oldLastResult.FullSearch)
                    {
                        oldLastResult = new WorkerResult();
                    }

                    if (token.IsCancellationRequested)
                    {
                        return;
                    }

                    IReadOnlyList <DeclaredSymbolInfo> allTypes = null;
                    if (!IsSameFilterStart(oldLastResult, newResult))
                    {
                        allTypes = cache.GetAllTypes(searchPattern.Tag, token);
                    }

//					var now = DateTime.Now;
                    AllResults(searchResultCallback, newResult, allTypes ?? lastResult.filteredSymbols, token);
                    //newResult.results.SortUpToN (new DataItemComparer (token), resultsCount);
                    lastResult = newResult;
                    //					Console.WriteLine ((now - DateTime.Now).TotalMilliseconds);
                } catch {
                    token.ThrowIfCancellationRequested();
                    throw;
                }
            }, token));
        }
        public override Task GetResults(
            ISearchResultCallback searchResultCallback,
            SearchPopupSearchPattern pattern,
            CancellationToken token)
        {
            var activeDocument = IdeApp.Workbench.ActiveDocument;

            if (activeDocument != null)
            {
                return(GetResults(activeDocument, searchResultCallback, pattern, token));
            }
            return(Task.CompletedTask);
        }
        Task GetResults(
            Document activeDocument,
            ISearchResultCallback searchResultCallback,
            SearchPopupSearchPattern pattern,
            CancellationToken token)
        {
            LanguageClientSession session = LanguageClientServices.Workspace.GetSession(activeDocument, false);

            if (session?.IsWorkspaceSymbolProvider == true)
            {
                return(GetResults(session, searchResultCallback, pattern, token));
            }

            return(Task.CompletedTask);
        }
 public override Task GetResults(
     ISearchResultCallback searchResultCallback,
     SearchPopupSearchPattern pattern,
     CancellationToken token)
 {
     if (pattern.Tag == null || IsValidTag(pattern.Tag))
     {
         var command = new InstallPackageCommand(pattern.Pattern);
         var result  = new InstallPackageSearchResult(command);
         if (result.CanBeDisplayed())
         {
             searchResultCallback.ReportResult(result);
         }
     }
     return(Task.FromResult(0));
 }
        async Task GetResults(
            LanguageClientSession session,
            ISearchResultCallback searchResultCallback,
            SearchPopupSearchPattern pattern,
            CancellationToken token)
        {
            SymbolInformation[] results = await session.GetWorkspaceSymbols(pattern.Pattern, token).ConfigureAwait(false);

            if (results != null && results.Length > 0)
            {
                foreach (var result in results)
                {
                    var searchResult = new WorkspaceSymbolSearchResult(pattern.Pattern, result);
                    searchResultCallback.ReportResult(searchResult);
                }
            }
        }
        public override Task GetResults(
            ISearchResultCallback searchResultCallback,
            SearchPopupSearchPattern pattern,
            CancellationToken token)
        {
            if (!CanSearch(pattern.Tag))
            {
                return(Task.FromResult(0));
            }

            return(Task.Factory.StartNew(() => {
                var dataSource = new PaketSearchDataSource(pattern);
                foreach (PaketSearchResult result in dataSource.GetResults())
                {
                    searchResultCallback.ReportResult(result);
                }
            }));
        }
        public override Task <ISearchDataSource> GetResults(SearchPopupSearchPattern s, int resultsCount, CancellationToken token)
        {
            return(Task.Factory.StartNew(delegate {
                var l = new List <INode>();

                foreach (var project in IdeApp.Workspace.GetAllProjects())
                {
                    var dprj = project as AbstractDProject;
                    if (dprj == null)
                    {
                        continue;
                    }

                    ModulePackage pack;
                    foreach (var p in dprj.GetSourcePaths())
                    {
                        if ((pack = GlobalParseCache.GetRootPackage(p)) != null)
                        {
                            foreach (DModule m in pack)
                            {
                                SearchResultsIn(m, s.Pattern, l, resultsCount);
                            }
                        }
                    }

                    foreach (var p in dprj.IncludePaths)
                    {
                        if ((pack = GlobalParseCache.GetRootPackage(p)) != null)
                        {
                            foreach (DModule m in pack)
                            {
                                SearchResultsIn(m, s.Pattern, l, resultsCount);
                            }
                        }
                    }
                }

                return (ISearchDataSource) new DSearchDataSource(l)
                {
                    SearchPattern = s.Pattern
                };
            }, token));
        }
        public override Task GetResults(ISearchResultCallback searchResultCallback, SearchPopupSearchPattern searchPattern, CancellationToken token)
        {
            return(Task.Run(async delegate {
                if (searchPattern.Tag != null && !(typeTags.Contains(searchPattern.Tag) || memberTags.Contains(searchPattern.Tag)) || searchPattern.HasLineNumber)
                {
                    return null;
                }
                try {
                    var newResult = new WorkerResult(widget);
                    newResult.pattern = searchPattern.Pattern;
                    newResult.Tag = searchPattern.Tag;
                    List <DeclaredSymbolInfo> allTypes;
                    if (SymbolInfoTask == null)
                    {
                        SymbolInfoTask = Task.FromResult(GetSymbolInfos(token));
                    }
                    var cache = await SymbolInfoTask.ConfigureAwait(false);
                    allTypes = cache.AllTypes;
                    string toMatch = searchPattern.Pattern;
                    newResult.matcher = StringMatcher.GetMatcher(toMatch, false);
                    newResult.FullSearch = toMatch.IndexOf('.') > 0;
                    var oldLastResult = lastResult;
                    if (newResult.FullSearch && oldLastResult != null && !oldLastResult.FullSearch)
                    {
                        oldLastResult = new WorkerResult(widget);
                    }
//					var now = DateTime.Now;

                    AllResults(searchResultCallback, oldLastResult, newResult, allTypes, token);
                    //newResult.results.SortUpToN (new DataItemComparer (token), resultsCount);
                    lastResult = newResult;
//					Console.WriteLine ((now - DateTime.Now).TotalMilliseconds);
                    return (ISearchDataSource)newResult.results;
                } catch {
                    token.ThrowIfCancellationRequested();
                    throw;
                }
            }, token));
        }
        public void TestLineNumberAndColumnFormat2()
        {
            var pattern = SearchPopupSearchPattern.ParsePattern("foo:4711:1174");

            Assert.AreEqual(new SearchPopupSearchPattern(null, "foo", 4711, 1174), pattern);
        }
        public void TestSimplePattern()
        {
            var pattern = SearchPopupSearchPattern.ParsePattern("foo");

            Assert.AreEqual(new SearchPopupSearchPattern(null, "foo", -1), pattern);
        }
        public void TestEmptyPattern()
        {
            var pattern = SearchPopupSearchPattern.ParsePattern("");

            Assert.AreEqual(new SearchPopupSearchPattern(null, ""), pattern);
        }
        public void TestIgnoreSpacesInCategory()
        {
            var pattern = SearchPopupSearchPattern.ParsePattern("file: MyClass.cs ");

            Assert.AreEqual(new SearchPopupSearchPattern("file", "MyClass.cs"), pattern);
        }
        public void TestIgnoreSpaces()
        {
            var pattern = SearchPopupSearchPattern.ParsePattern("foo : bar : 12");

            Assert.AreEqual(new SearchPopupSearchPattern("foo", "bar", 12), pattern);
        }
        public void TestOriginalSearchPatternStored()
        {
            var pattern = SearchPopupSearchPattern.ParsePattern("id:json");

            Assert.AreEqual("id:json", pattern.UnparsedPattern);
        }
        public void TestGithub()
        {
            var pattern = SearchPopupSearchPattern.ParsePattern("ExceptionCaughtDialog.cs#L510");

            Assert.AreEqual(new SearchPopupSearchPattern(null, "ExceptionCaughtDialog.cs", 510, -1), pattern);
        }
        public void TestLineStyle()
        {
            var pattern = SearchPopupSearchPattern.ParsePattern("cat:foo:line 1337");

            Assert.AreEqual(new SearchPopupSearchPattern("cat", "foo", 1337, -1), pattern);
        }
        public void TestInvalidLineNumber()
        {
            var pattern = SearchPopupSearchPattern.ParsePattern("cat:foo:bar");

            Assert.AreEqual(new SearchPopupSearchPattern("cat", "foo", 0), pattern);
        }
        public void TestCategoryAndLineNumberAndColumn()
        {
            var pattern = SearchPopupSearchPattern.ParsePattern("cat:foo:1337:5");

            Assert.AreEqual(new SearchPopupSearchPattern("cat", "foo", 1337, 5), pattern);
        }
        public void TestEmptyThirdPart()
        {
            var pattern = SearchPopupSearchPattern.ParsePattern("foo:bar:");

            Assert.AreEqual(new SearchPopupSearchPattern("foo", "bar", 0), pattern);
        }
        public void TestLineNumberAndMissingColumn()
        {
            var pattern = SearchPopupSearchPattern.ParsePattern(":4711:");

            Assert.AreEqual(new SearchPopupSearchPattern(null, null, 4711, 0), pattern);
        }
        public void TestEmptySecondPart()
        {
            var pattern = SearchPopupSearchPattern.ParsePattern("foo:");

            Assert.AreEqual(new SearchPopupSearchPattern("foo", "", -1), pattern);
        }
        public void TestLineNumberAndColumnOnlySyntax2()
        {
            var pattern = SearchPopupSearchPattern.ParsePattern(":5:8");

            Assert.AreEqual(new SearchPopupSearchPattern(null, null, 5, 8), pattern);
        }
        public void TestLineNumberOnly()
        {
            var pattern = SearchPopupSearchPattern.ParsePattern(":4711");

            Assert.AreEqual(new SearchPopupSearchPattern(null, null, 4711), pattern);
        }
        public void TestCategory()
        {
            var pattern = SearchPopupSearchPattern.ParsePattern("cat:foo");

            Assert.AreEqual(new SearchPopupSearchPattern("cat", "foo", -1), pattern);
        }