Feature Requet: Smart Run Current Target

[baxelrod-bdai]

Similar to the Build Current Target feature, it would be great if there was a "smart run" feature that would either bazel run, bazel test, or bazel build the current target depending on it's type. if the cursor is on a target that is of type *_binary then it will be run. If it is on a target that is of type *_test then it will be tested. Otherwise, it will simply be built.

[baxelrod-bdai]

FYI I was able to accomplish this without using bazel query. Just simple regex.

[baxelrod-bdai]

export function activate(context: vscode.ExtensionContext) {
    ...
	// Register command: Smart run - auto-detects run/test/build (Ctrl+Shift+R)
	context.subscriptions.push(
		vscode.commands.registerCommand('Bazel.smartRun', async () => {
			const editor = vscode.window.activeTextEditor;
			if (!editor) {
				return;
			}

			const document = editor.document;
			const position = editor.selection.active;

			const targetPath = getBazelTargetPath(document, position);
			if (!targetPath) {
				return; // Error already shown by getBazelTargetPath
			}

			// Get the rule type to determine the appropriate command
			const ruleType = getRuleTypeAtPosition(document, position);
			if (!ruleType) {
				vscode.window.showErrorMessage('Could not determine target rule type');
				return;
			}

			// Determine the appropriate Bazel command based on rule type
			let bazelCommand: string;
			let terminalName: string;

			if (ruleType.includes('_binary')) {
				bazelCommand = 'run';
				terminalName = 'Bazel Run';
			} else if (ruleType.includes('_test')) {
				bazelCommand = 'test';
				terminalName = 'Bazel Test';
			} else {
				bazelCommand = 'build';
				terminalName = 'Bazel Build';
			}

			runBazelCommand(document, bazelCommand, targetPath, terminalName);
		})
	);
}

/**
 * Runs a Bazel command in a new terminal.
 * @param document The document containing the BUILD file
 * @param command The Bazel subcommand (build, run, test)
 * @param targetPath The full Bazel target path (e.g., "//path/to:target")
 * @param terminalName The name to display for the terminal
 */
function runBazelCommand(
	document: vscode.TextDocument,
	command: string,
	targetPath: string,
	terminalName: string
): void {
	const workspaceFolder = vscode.workspace.getWorkspaceFolder(document.uri);
	if (!workspaceFolder) {
		vscode.window.showErrorMessage('File is not in a workspace');
		return;
	}

	// TODO: use existing terminal
	const terminal = vscode.window.createTerminal({
		name: terminalName,
		cwd: workspaceFolder.uri.fsPath
	});
	terminal.show();
	terminal.sendText(`bazel ${command} ${targetPath}`);
}

/**
 * Information about a Bazel target at a specific position.
 */
interface TargetInfo {
	ruleName: string;    // e.g., "cc_test", "py_binary"
	targetName: string;  // e.g., "my_math_test"
	startPos: number;    // Start position of the target block
	endPos: number;      // End position of the target block
}

/**
 * Finds information about the Bazel target at the cursor position.
 * @returns Target information including rule name and target name, or null if cursor is not in a target
 */
function getTargetInfoAtPosition(document: vscode.TextDocument, position: vscode.Position): TargetInfo | null {
	const text = document.getText();
	const cursorOffset = document.offsetAt(position);

	// Regular expression to match Bazel target blocks: rule_name(name = "target_name", ...)
	const targetRegex = /(\w+)\s*\(\s*name\s*=\s*"([^"]+)"/g;

	let match;
	while ((match = targetRegex.exec(text)) !== null) {
		const matchStart = match.index;

		// Find the end of this target block (matching closing parenthesis)
		const blockEnd = findMatchingClosingParen(text, matchStart);

		// Check if cursor is within this target block
		if (cursorOffset >= matchStart && cursorOffset <= blockEnd) {
			return {
				ruleName: match[1],    // e.g., "cc_test"
				targetName: match[2],  // e.g., "my_math_test"
				startPos: matchStart,
				endPos: blockEnd
			};
		}
	}

	return null;
}

/**
 * Gets the full Bazel target path for the target at the cursor position.
 * @returns The target path in format "//path/to/package:target_name", or null if not in a target
 */
function getBazelTargetPath(document: vscode.TextDocument, position: vscode.Position): string | null {
	const targetInfo = getTargetInfoAtPosition(document, position);
	if (!targetInfo) {
		vscode.window.showErrorMessage('No Bazel target found at cursor position');
		return null;
	}

	const buildFilePath = document.uri.fsPath;
	const workspaceFolder = vscode.workspace.getWorkspaceFolder(document.uri);

	if (!workspaceFolder) {
		vscode.window.showErrorMessage('File is not in a workspace');
		return null;
	}

	// Get the directory containing the BUILD file, relative to workspace root
	const buildFileDir = path.dirname(buildFilePath);
	const relativePath = path.relative(workspaceFolder.uri.fsPath, buildFileDir);

	// Convert to Bazel target format: //path/to/package:target_name
	const bazelPath = relativePath === '' ? '//' : '//' + relativePath.replace(/\\/g, '/');
	const targetPath = `${bazelPath}:${targetInfo.targetName}`;

	return targetPath;
}

/**
 * Gets the Bazel rule type at the cursor position.
 * @returns The rule name (e.g., "cc_test", "py_binary"), or null if cursor is not in a target
 */
function getRuleTypeAtPosition(document: vscode.TextDocument, position: vscode.Position): string | null {
	const targetInfo = getTargetInfoAtPosition(document, position);
	return targetInfo ? targetInfo.ruleName : null;
}

/**
 * Finds the position of the matching closing parenthesis for a Bazel target block.
 * Uses a depth counter to handle nested parentheses.
 */
function findMatchingClosingParen(text: string, startPos: number): number {
	let depth = 0;
	let foundOpen = false;

	for (let i = startPos; i < text.length; i++) {
		const char = text[i];
		if (char === '(') {
			depth++;
			foundOpen = true;
		} else if (char === ')') {
			depth--;
			if (foundOpen && depth === 0) {
				return i;
			}
		}
	}

	return text.length; // If no matching closing paren, return end of file
}