Make "find in folder" multiroot aware

src/vs/base/common/paths.ts

@@ -393,3 +393,37 @@ export function isEqualOrParent(path: string, candidate: string, ignoreCase?: bo
 
 	return path.indexOf(candidate) === 0;
 }
+
+/**
+ * Adapted from Node's path.isAbsolute functions
+ * @param path
+ */
+export function isAbsolute(path: string): boolean {
+	return isWindows ?
+		isAbsolute_win32(path) :
+		isAbsolute_posix(path);
+}
+
+export function isAbsolute_win32(path: string): boolean {
+	if (!path) {
+		return false;
+	}
+
+	const char0 = path.charCodeAt(0);
+	if (char0 === CharCode.Slash || char0 === CharCode.Backslash) {
+		return true;
+	} else if ((char0 >= CharCode.A && char0 <= CharCode.Z) || (char0 >= CharCode.a && char0 <= CharCode.z)) {
+		if (path.length > 2 && path.charCodeAt(1) === CharCode.Colon) {
+			const char2 = path.charCodeAt(2);
+			if (char2 === CharCode.Slash || char0 === CharCode.Backslash) {
+				return true;
+			}
+		}
+	}
+
+	return false;
+}
+
+export function isAbsolute_posix(path: string): boolean {
+	return path && path.charCodeAt(0) === CharCode.Slash;
+}
\ No newline at end of file

src/vs/base/test/common/paths.test.ts

@@ -201,4 +201,54 @@ suite('Paths', () => {
 			assert.ok(!paths.isValidBasename('tes"t.txt'));
 		}
 	});
+
+	test('isAbsolute_win', () => {
+		// Absolute paths
+		[
+			'C:/',
+			'C:/foo',
+			'z:/foo/bar.txt',
+
+			'\\\\localhost\\c$\\foo',
+
+			'/',
+			'/foo'
+		].forEach(absolutePath => {
+			assert.ok(paths.isAbsolute_win32(absolutePath), absolutePath);
+		});
+
+		// Not absolute paths
+		[
+			'',
+			'foo',
+			'foo/bar',
+			'./foo',
+			'http://foo.com/bar'
+		].forEach(nonAbsolutePath => {
+			assert.ok(!paths.isAbsolute_win32(nonAbsolutePath), nonAbsolutePath);
+		});
+	});
+
+	test('isAbsolute_posix', () => {
+		// Absolute paths
+		[
+			'/',
+			'/foo',
+			'/foo/bar.txt'
+		].forEach(absolutePath => {
+			assert.ok(paths.isAbsolute_posix(absolutePath), absolutePath);
+		});
+
+		// Not absolute paths
+		[
+			'',
+			'foo',
+			'foo/bar',
+			'./foo',
+			'http://foo.com/bar',
+			'z:/foo/bar.txt',
+		].forEach(nonAbsolutePath => {
+			assert.ok(!paths.isAbsolute_posix(nonAbsolutePath), nonAbsolutePath);
+		});
+	});
 });
\ No newline at end of file

src/vs/workbench/parts/search/browser/patternInputWidget.ts

@@ -6,6 +6,7 @@
 import nls = require('vs/nls');
 import * as dom from 'vs/base/browser/dom';
 import strings = require('vs/base/common/strings');
+import paths = require('vs/base/common/paths');
 import collections = require('vs/base/common/collections');
 import { $ } from 'vs/base/browser/builder';
 import { Widget } from 'vs/base/browser/ui/widget';
@@ -122,7 +123,7 @@ export class PatternInputWidget extends Widget {
 			exprSegments = groups.exprSegments;
 		} else {
 			const segments = pattern.split(',')
-				.map(s => strings.trim(s.trim(), '/'))
+				.map(s => s.trim())
 				.filter(s => !!s.length);
 
 			const groups = this.groupByPathsAndExprSegments(segments);
@@ -142,22 +143,16 @@ export class PatternInputWidget extends Widget {
 	}
 
 	private groupByPathsAndExprSegments(segments: string[]) {
-		const isSearchPath = segment => segment.match(/^\.\//);
+		const isSearchPath = (segment: string) => {
+			// An segment is a search path if it is an absolute path and doesn't contain any glob characters
+			return paths.isAbsolute(segment) && !segment.match(/[\*\{\}\(\)\[\]\?]/);
+		};
 
 		const groups = collections.groupBy(segments,
 			segment => isSearchPath(segment) ? 'searchPaths' : 'exprSegments');
 		groups.searchPaths = groups.searchPaths || [];
-		groups.exprSegments = groups.exprSegments || [];
-
-		// If a ./searchPath has a glob character, remove ./ and use it as an expression segment
-		groups.searchPaths = groups.searchPaths.filter(searchPath => {
-			if (searchPath.match(/[\*\{\}\(\)\[\]\?]/)) {
-				groups.exprSegments.push(strings.ltrim(searchPath, './'));
-				return false;
-			}
-
-			return true;
-		});
+		groups.exprSegments = (groups.exprSegments || [])
+			.map(segment => strings.trim(segment, '/'));
 
 		return groups;
 	}

src/vs/workbench/parts/search/browser/searchActions.ts

@@ -273,7 +273,9 @@ export const findInFolderCommand = (accessor: ServicesAccessor, resource?: URI)
 	}
 
 	viewletService.openViewlet(Constants.VIEWLET_ID, true).then((viewlet: SearchViewlet) => {
-		viewlet.searchInFolder(resource);
+		if (resource) {
+			viewlet.searchInFolder(resource);
+		}
 	}).done(null, errors.onUnexpectedError);
 };
 

src/vs/workbench/parts/search/browser/searchViewlet.ts

@@ -894,20 +894,14 @@ export class SearchViewlet extends Viewlet {
 		}
 	}
 
-	public searchInFolder(resource?: URI): void {
-		const workspaceRelativePath = this.contextService.toWorkspaceRelativePath(resource);
-		if (!workspaceRelativePath || workspaceRelativePath === '.') {
-			this.inputPatternIncludes.setValue('');
-			this.searchWidget.focus();
-			return;
-		}
-
+	public searchInFolder(resource: URI): void {
+		// Show 'files to include' box
 		if (!this.showsFileTypes()) {
 			this.toggleQueryDetails(true, true);
 		}
 
 		this.inputPatternIncludes.setIsGlobPattern(false);
-		this.inputPatternIncludes.setValue('./' + workspaceRelativePath);
+		this.inputPatternIncludes.setValue(resource.fsPath);
 		this.searchWidget.focus(false);
 	}