@theia/search-in-workspace 1.65.0-next.6 → 1.66.0-next.0

package/src/browser-only/browser-search-in-workspace-server.ts

@@ -0,0 +1,471 @@
+// *****************************************************************************
+// Copyright (C) 2025 Maksim Kachurin and others.
+//
+// This program and the accompanying materials are made available under the
+// terms of the Eclipse Public License v. 2.0 which is available at
+// http://www.eclipse.org/legal/epl-2.0.
+//
+// This Source Code may also be made available under the following Secondary
+// Licenses when the conditions for such availability set forth in the Eclipse
+// Public License v. 2.0 are satisfied: GNU General Public License, version 2
+// with the GNU Classpath Exception which is available at
+// https://www.gnu.org/software/classpath/license.html.
+//
+// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
+// *****************************************************************************
+import { inject, injectable, named } from '@theia/core/shared/inversify';
+import type {
+    SearchInWorkspaceClient,
+    SearchInWorkspaceOptions,
+    SearchInWorkspaceResult,
+    SearchInWorkspaceServer,
+    SearchMatch
+} from '../common/search-in-workspace-interface';
+import { FileUri } from '@theia/core/lib/common/file-uri';
+import { URI, ILogger } from '@theia/core';
+import { FileService, TextFileOperationError, TextFileOperationResult } from '@theia/filesystem/lib/browser/file-service';
+import { normalizeGlob, matchesPattern, createIgnoreMatcher, getIgnorePatterns } from '@theia/filesystem/lib/browser-only/file-search';
+import { escapeRegExpCharacters } from '@theia/core/lib/common/strings';
+import { BinarySize, type FileStatWithMetadata } from '@theia/filesystem/lib/common/files';
+
+interface SearchController {
+    regex: RegExp;
+    searchPaths: URI[];
+    options: SearchInWorkspaceOptions;
+    isAborted: () => boolean;
+    abort: () => void;
+};
+
+const minimatchOpts = {
+    dot: true,
+    matchBase: true,
+    nocase: true
+};
+
+@injectable()
+export class BrowserSearchInWorkspaceServer implements SearchInWorkspaceServer {
+    @inject(ILogger) @named('search-in-workspace')
+    protected readonly logger: ILogger;
+
+    @inject(FileService)
+    protected readonly fs: FileService;
+
+    private client: SearchInWorkspaceClient | undefined;
+    private ongoingSearches: Map<number, SearchController> = new Map();
+    private nextSearchId: number = 1;
+
+    /**
+     * Sets the client for receiving search results
+     */
+    setClient(client: SearchInWorkspaceClient | undefined): void {
+        this.client = client;
+    }
+
+    /**
+     * Initiates a search operation and returns a search ID.
+     * @param what - The search term or pattern
+     * @param rootUris - Array of root URIs to search in
+     * @param opts - Search options including filters and limits
+     * @returns Promise resolving to the search ID
+     */
+    async search(what: string, rootUris: string[], opts: SearchInWorkspaceOptions = {}): Promise<number> {
+        const searchId = this.nextSearchId++;
+        const controller = new AbortController();
+
+        const { regex, searchPaths, options } = await this.processSearchOptions(
+            what,
+            rootUris,
+            opts,
+        );
+
+        this.ongoingSearches.set(searchId, {
+            regex,
+            searchPaths,
+            options,
+            isAborted: () => controller.signal.aborted,
+            abort: () => controller.abort()
+        });
+
+        // Start search asynchronously and return searchId immediately
+        this.doSearch(searchId).catch((error: Error) => {
+            const errorStr = `An error happened while searching (${error.message}).`;
+
+            this.client?.onDone(searchId, errorStr);
+        }).finally(() => {
+            this.ongoingSearches.delete(searchId);
+        });
+
+        return searchId;
+    }
+
+    /**
+     * Cancels an ongoing search operation.
+     * @param searchId - The ID of the search to cancel
+     */
+    cancel(searchId: number): Promise<void> {
+        const controller = this.ongoingSearches.get(searchId);
+
+        if (controller) {
+            this.ongoingSearches.delete(searchId);
+
+            controller.abort();
+            this.client?.onDone(searchId);
+        }
+
+        return Promise.resolve();
+    }
+
+    /**
+     * Disposes the service by aborting all ongoing searches.
+     */
+    dispose(): void {
+        this.ongoingSearches.forEach(controller => controller.abort());
+        this.ongoingSearches.clear();
+    }
+
+    /**
+     * Internal method to perform the search.
+     * @param searchId - The ID of the search to perform.
+     * @returns A promise that resolves when the search is complete.
+     */
+    private async doSearch(searchId: number): Promise<void> {
+        const ctx = this.ongoingSearches.get(searchId);
+
+        if (!ctx) {
+            return;
+        }
+
+        const { regex, searchPaths, options, isAborted } = ctx;
+
+        const maxFileSize = options.maxFileSize ? BinarySize.parseSize(options.maxFileSize) : 20 * BinarySize.MB;
+        const matcher = createIgnoreMatcher();
+
+        let remaining = options.maxResults ?? Number.POSITIVE_INFINITY;
+
+        for (const root of searchPaths) {
+            if (isAborted()) {
+                break;
+            }
+
+            const pathsStack: URI[] = [root];
+            let index = 0;
+
+            while (index < pathsStack.length && !isAborted() && remaining > 0) {
+                const current = pathsStack[index++];
+                const relPath = current.path.toString().replace(/^\/|^\.\//, '');
+
+                // Skip excluded paths
+                if (this.shouldExcludePath(current, options.exclude)) {
+                    continue;
+                }
+
+                // Skip ignored files unless explicitly included
+                if (!options.includeIgnored && relPath && matcher.ignores(relPath)) {
+                    continue;
+                }
+
+                let stat: FileStatWithMetadata;
+
+                try {
+                    stat = await this.fs.resolve(current, { resolveMetadata: true });
+                } catch {
+                    continue;
+                }
+
+                // Skip files not matching include patterns
+                if (stat.isFile && !this.shouldIncludePath(current, options.include)) {
+                    continue;
+                }
+
+                // Skip files exceeding size limit
+                if (stat.isFile && stat.size > maxFileSize) {
+                    continue;
+                }
+
+                // Process directory contents
+                if (stat.isDirectory) {
+                    if (Array.isArray(stat.children)) {
+                        // Load ignore patterns from files
+                        if (!options.includeIgnored) {
+                            const patterns = await getIgnorePatterns(
+                                current,
+                                uri => this.fs.read(uri).then(content => content.value)
+                            );
+
+                            matcher.add(patterns);
+                        }
+
+                        for (const child of stat.children) {
+                            pathsStack.push(child.resource);
+                        }
+                    }
+
+                    continue;
+                }
+
+                try {
+                    const matches = await this.searchFileByLines(current, regex, isAborted, {
+                        autoGuessEncoding: true,
+                        acceptTextOnly: true
+                    }, remaining);
+
+                    if (matches.length > 0) {
+                        const result: SearchInWorkspaceResult = {
+                            root: root.path.toString(),
+                            fileUri: current.path.toString(),
+                            matches
+                        };
+
+                        this.client?.onResult(searchId, result);
+
+                        remaining -= matches.length;
+                        if (remaining <= 0) {
+                            break;
+                        }
+                    }
+                } catch (err) {
+                    if (err instanceof TextFileOperationError && err.textFileOperationResult === TextFileOperationResult.FILE_IS_BINARY) {
+                        continue;
+                    }
+
+                    this.logger.error(`Error reading file ${current.path.toString()}: ${err.message}`);
+                    continue;
+                }
+            }
+
+            if (remaining <= 0 || isAborted()) {
+                break;
+            }
+        }
+
+        this.client?.onDone(searchId);
+    }
+
+    /**
+     * Searches for matches within a file by processing it line by line.
+     * @param uri - The file URI to search
+     * @param re - The regex pattern to match
+     * @param isAborted - Function to check if search was aborted
+     * @param opts - File reading options
+     * @param limit - Maximum number of matches to return
+     * @returns Array of search matches found in the file
+     */
+    private async searchFileByLines(
+        uri: URI,
+        re: RegExp,
+        isAborted: () => boolean,
+        opts: { autoGuessEncoding: boolean; acceptTextOnly: boolean },
+        limit: number
+    ): Promise<SearchMatch[]> {
+        const { value: stream } = await this.fs.readStream(uri, opts);
+
+        let leftover = '';
+        let lineNo = 0;
+        const matches: SearchMatch[] = [];
+
+        await new Promise<void>((resolve, reject) => {
+            stream.on('data', chunk => {
+                if (isAborted()) {
+                    stream.pause();
+                    resolve();
+                    return;
+                }
+
+                const data = leftover + chunk;
+                const lines = data.split(/\r?\n/);
+                leftover = lines.pop() ?? '';
+
+                for (const line of lines) {
+                    lineNo += 1; // 1-based
+
+                    if (!line) {
+                        continue;
+                    }
+
+                    // Reset regex lastIndex for global patterns
+                    if (re.global) {
+                        re.lastIndex = 0;
+                    }
+
+                    let m: RegExpExecArray | null;
+
+                    while ((m = re.exec(line))) {
+                        matches.push({
+                            line: lineNo,
+                            character: m.index + 1, // 1-based
+                            length: m[0].length,
+                            lineText: line
+                        });
+
+                        if (matches.length >= limit) {
+                            resolve();
+                            return;
+                        }
+                    }
+                }
+            });
+
+            stream.on('error', err => reject(err));
+
+            stream.on('end', () => {
+                if (leftover.length && matches.length < limit) {
+                    lineNo += 1;
+                    const line = leftover;
+
+                    // Reset regex lastIndex for global patterns
+                    if (re.global) {
+                        re.lastIndex = 0;
+                    }
+
+                    let m: RegExpExecArray | null;
+
+                    while ((m = re.exec(line))) {
+                        matches.push({
+                            line: lineNo,
+                            character: m.index + 1,
+                            length: m[0].length,
+                            lineText: line
+                        });
+
+                        if (matches.length >= limit) {
+                            break;
+                        }
+                    }
+                }
+
+                resolve();
+            });
+        });
+
+        return matches;
+    }
+
+    /**
+     * Processes search options and returns clean paths and processed options.
+     * This method consolidates the path processing logic and matchWholeWord handling for better readability.
+     */
+    private async processSearchOptions(_searchTerm: string, _searchPaths: string[], _options: SearchInWorkspaceOptions): Promise<{
+        regex: RegExp,
+        searchPaths: URI[],
+        options: SearchInWorkspaceOptions,
+    }> {
+        const options = { ..._options };
+
+        options.maxResults = typeof options.maxResults === 'number' && options.maxResults > 0 ? options.maxResults : Number.POSITIVE_INFINITY;
+        options.include = (options.include ?? []).map(glob => normalizeGlob(glob));
+        options.exclude = (options.exclude ?? []).map(glob => normalizeGlob(glob));
+
+        // If there are absolute paths in `include` we will remove them and use
+        // those as paths to search from
+        const paths = await this.extractSearchPathsFromIncludes(
+            _searchPaths.map(p => FileUri.fsPath(p)),
+            options.include
+        );
+
+        // Build regex with consideration of useRegExp/matchCase/matchWholeWord
+        const useRegExp = !!options.useRegExp;
+        const matchCase = !!options.matchCase;
+        const matchWholeWord = !!options.matchWholeWord;
+
+        const flags = 'g' + (matchCase ? '' : 'i') + 'u';
+        let source = useRegExp ? _searchTerm : escapeRegExpCharacters(_searchTerm);
+
+        // Unicode word boundaries: letters/numbers/underscore
+        if (matchWholeWord) {
+            const wbL = '(?<![\\p{L}\\p{N}_])';
+            const wbR = '(?![\\p{L}\\p{N}_])';
+            source = `${wbL}${source}${wbR}`;
+        }
+
+        const regex = new RegExp(source, flags);
+
+        const searchPaths = paths.map(p => URI.fromFilePath(p));
+
+        return { regex, searchPaths, options };
+    }
+
+    /**
+     * Checks if a path should be excluded based on exclude patterns.
+     * @param uri - The URI to check
+     * @param exclude - Array of exclude patterns
+     * @returns True if the path should be excluded
+     */
+    protected shouldExcludePath(uri: URI, exclude: string[] | undefined): boolean {
+        if (!exclude?.length) {
+            return false;
+        }
+
+        return matchesPattern(uri.path.toString(), exclude, minimatchOpts);
+    }
+
+    /**
+     * Checks if a path should be included based on include patterns.
+     * @param uri - The URI to check
+     * @param include - Array of include patterns
+     * @returns True if the path should be included
+     */
+    private shouldIncludePath(uri: URI, include: string[] | undefined): boolean {
+        if (!include?.length) {
+            return true;
+        }
+
+        return matchesPattern(uri.path.toString(), include, minimatchOpts);
+    }
+
+    /**
+     * The default search paths are set to be the root paths associated to a workspace
+     * however the search scope can be further refined with the include paths available in the search options.
+     * This method will replace the searching paths to the ones specified in the 'include' options but as long
+     * as the 'include' paths can be successfully validated as existing.
+     *
+     * Therefore the returned array of paths can be either the workspace root paths or a set of validated paths
+     * derived from the include options which can be used to perform the search.
+     *
+     * Any pattern that resulted in a valid search path will be removed from the 'include' list as it is
+     * provided as an equivalent search path instead.
+     */
+    protected async extractSearchPathsFromIncludes(searchPaths: string[], include: string[]): Promise<string[]> {
+        if (!include) {
+            return searchPaths;
+        }
+
+        const resolvedPaths = new Set<string>();
+        const searchPathsUris = searchPaths.map(p => new URI(p));
+
+        for (const pattern of include) {
+            const [base, _] = getGlobBase(pattern);
+            const baseUri = new URI(base);
+
+            for (const rootUri of searchPathsUris) {
+                if (rootUri.isEqualOrParent(baseUri) && await this.fs.exists(baseUri)) {
+                    resolvedPaths.add(baseUri.path.toString());
+                }
+            }
+        }
+
+        return resolvedPaths.size ? Array.from(resolvedPaths) : searchPaths;
+    }
+}
+
+/**
+ * Get the base + rest of a glob pattern.
+ *
+ * @param pattern - The glob pattern to get the base of (like 'workspace2/foo/*.md')
+ * @returns The base + rest of the glob pattern. (like ['workspace2/foo/', '*.md'])
+ */
+function getGlobBase(pattern: string): [string, string] {
+    const isAbsolute = pattern.startsWith('/');
+    const parts = pattern.replace(/^\//, '').split('/');
+    const magic = /[*?[\]{}]/;
+
+    const staticParts: string[] = [];
+
+    for (const part of parts) {
+        if (magic.test(part)) { break; }
+        staticParts.push(part);
+    }
+
+    const base = (isAbsolute ? '/' : '') + staticParts.join('/');
+
+    return [base, pattern.substring(base.length)];
+}

package/src/browser-only/search-in-workspace-frontend-only-module.ts

@@ -0,0 +1,35 @@
+// *****************************************************************************
+// Copyright (C) 2025 Maksim Kachurin and others.
+//
+// This program and the accompanying materials are made available under the
+// terms of the Eclipse Public License v. 2.0 which is available at
+// http://www.eclipse.org/legal/epl-2.0.
+//
+// This Source Code may also be made available under the following Secondary
+// Licenses when the conditions for such availability set forth in the Eclipse
+// Public License v. 2.0 are satisfied: GNU General Public License, version 2
+// with the GNU Classpath Exception which is available at
+// https://www.gnu.org/software/classpath/license.html.
+//
+// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
+// *****************************************************************************
+
+import { ContainerModule } from '@theia/core/shared/inversify';
+import { SearchInWorkspaceServer } from '../common/search-in-workspace-interface';
+import { BrowserSearchInWorkspaceServer } from './browser-search-in-workspace-server';
+import { SearchInWorkspaceService } from '../browser/search-in-workspace-service';
+import { BrowserOnlySearchInWorkspaceService } from './browser-only-search-in-workspace-service';
+
+export default new ContainerModule((bind, _unbind, isBound, rebind) => {
+    if (isBound(SearchInWorkspaceServer)) {
+        rebind(SearchInWorkspaceServer).to(BrowserSearchInWorkspaceServer).inSingletonScope();
+    } else {
+        bind(SearchInWorkspaceServer).to(BrowserSearchInWorkspaceServer).inSingletonScope();
+    }
+
+    if (isBound(SearchInWorkspaceService)) {
+        rebind(SearchInWorkspaceService).to(BrowserOnlySearchInWorkspaceService).inSingletonScope();
+    } else {
+        bind(SearchInWorkspaceService).to(BrowserOnlySearchInWorkspaceService).inSingletonScope();
+    }
+});

package/src/{browser → common}/search-in-workspace-preferences.ts

@@ -15,11 +15,12 @@
 // *****************************************************************************
 
 import { nls } from '@theia/core/lib/common/nls';
-import { PreferenceSchema, PreferenceProxy, PreferenceService, createPreferenceProxy, PreferenceContribution } from '@theia/core/lib/browser/preferences';
+import { PreferenceProxy, PreferenceScope, PreferenceService, createPreferenceProxy } from '@theia/core/lib/common/preferences';
 import { interfaces } from '@theia/core/shared/inversify';
+import { PreferenceContribution, PreferenceSchema } from '@theia/core/lib/common/preferences/preference-schema';
 
 export const searchInWorkspacePreferencesSchema: PreferenceSchema = {
-    type: 'object',
+    scope: PreferenceScope.Folder,
     properties: {
         'search.lineNumbers': {
             description: nls.localizeByDefault('Controls whether to show line numbers for search results.'),

package/src/node/search-in-workspace-backend-module.ts

@@ -19,6 +19,7 @@ import { ConnectionHandler, RpcConnectionHandler } from '@theia/core/lib/common'
 import { SearchInWorkspaceServer, SearchInWorkspaceClient, SIW_WS_PATH } from '../common/search-in-workspace-interface';
 import { RipgrepSearchInWorkspaceServer, RgPath } from './ripgrep-search-in-workspace-server';
 import { rgPath } from '@vscode/ripgrep';
+import { bindSearchInWorkspacePreferences } from '../common/search-in-workspace-preferences';
 
 export default new ContainerModule(bind => {
     bind(SearchInWorkspaceServer).to(RipgrepSearchInWorkspaceServer);
@@ -30,4 +31,5 @@ export default new ContainerModule(bind => {
             return server;
         }));
     bind(RgPath).toConstantValue(rgPath);
+    bindSearchInWorkspacePreferences(bind);
 });

package/lib/browser/search-in-workspace-preferences.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"search-in-workspace-preferences.d.ts","sourceRoot":"","sources":["../../src/browser/search-in-workspace-preferences.ts"],"names":[],"mappings":"AAiBA,OAAO,EAAE,gBAAgB,EAAE,eAAe,EAAE,iBAAiB,EAAiD,MAAM,qCAAqC,CAAC;AAC1J,OAAO,EAAE,UAAU,EAAE,MAAM,8BAA8B,CAAC;AAE1D,eAAO,MAAM,kCAAkC,EAAE,gBA+ChD,CAAC;AAEF,qBAAa,8BAA8B;IACvC,oBAAoB,EAAE,OAAO,CAAC;IAC9B,wBAAwB,EAAE,MAAM,CAAC;IACjC,qBAAqB,EAAE,OAAO,CAAC;IAC/B,mCAAmC,EAAE,MAAM,CAAC;IAC5C,mCAAmC,EAAE,OAAO,CAAC;IAC7C,kBAAkB,EAAE,OAAO,CAAC;IAC5B,uBAAuB,EAAE,OAAO,CAAC;CACpC;AAED,eAAO,MAAM,uCAAuC,eAAoD,CAAC;AACzG,eAAO,MAAM,4BAA4B,eAAyC,CAAC;AACnF,MAAM,MAAM,4BAA4B,GAAG,eAAe,CAAC,8BAA8B,CAAC,CAAC;AAE3F,wBAAgB,kCAAkC,CAAC,WAAW,EAAE,iBAAiB,EAAE,MAAM,GAAE,gBAAqD,GAAG,4BAA4B,CAE9K;AAED,wBAAgB,gCAAgC,CAAC,IAAI,EAAE,UAAU,CAAC,IAAI,GAAG,IAAI,CAQ5E"}

package/lib/browser/search-in-workspace-preferences.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"search-in-workspace-preferences.js","sourceRoot":"","sources":["../../src/browser/search-in-workspace-preferences.ts"],"names":[],"mappings":"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"}