) => async (
+const handleCommandErrors = (what: string, command: (...args: P) => Promise) => async (
...args: P
): Promise => {
try {
return await command(...args)
} catch (error) {
- await showError(error)
+ if (error instanceof Error) {
+ log.error(what, error)
+ await showError(error)
+ }
}
}
+export const fs = new SourcegraphFileSystemProvider()
+export const files = new FilesTreeDataProvider(fs)
+export const diffs = new DiffsTreeDataProvider(fs)
+export const blames = new BlameDecorationProvider(fs)
+
/**
- * The command implementation for opening a cursor selection on Sourcegraph.
+ * Called when the extension is activated.
*/
-async function openCommand(): Promise {
- const editor = vscode.window.activeTextEditor
- if (!editor) {
- throw new Error('No active editor')
- }
- const repositoryInfo = await repoInfo(editor.document.uri.fsPath)
- if (!repositoryInfo) {
- return
- }
- const { remoteURL, branch, fileRelative } = repositoryInfo
+export function activate(context: vscode.ExtensionContext): void {
+ // Register our extension commands (see package.json).
+ context.subscriptions.push(
+ vscode.commands.registerCommand(
+ 'extension.open',
+ handleCommandErrors('extension.open', () => openCommand(version))
+ )
+ )
+ context.subscriptions.push(
+ vscode.commands.registerCommand(
+ 'extension.search',
+ handleCommandErrors('extension.search', () => searchCommand())
+ )
+ )
- // Open in browser.
- await open(
- `${getSourcegraphUrl()}/-/editor` +
- `?remote_url=${encodeURIComponent(remoteURL)}` +
- `&branch=${encodeURIComponent(branch)}` +
- `&file=${encodeURIComponent(fileRelative)}` +
- `&editor=${encodeURIComponent('VSCode')}` +
- `&version=${encodeURIComponent(version)}` +
- `&start_row=${encodeURIComponent(String(editor.selection.start.line))}` +
- `&start_col=${encodeURIComponent(String(editor.selection.start.character))}` +
- `&end_row=${encodeURIComponent(String(editor.selection.end.line))}` +
- `&end_col=${encodeURIComponent(String(editor.selection.end.character))}`
+ context.subscriptions.push(
+ vscode.commands.registerCommand(
+ 'extension.search.selection',
+ handleCommandErrors('extension.search.selection', () => searchSelectionCommand(version))
+ )
)
-}
-/**
- * The command implementation for searching a cursor selection on Sourcegraph.
- */
-async function searchSelectionCommand(): Promise {
- const editor = vscode.window.activeTextEditor
- if (!editor) {
- throw new Error('No active editor')
- }
- const repositoryInfo = await repoInfo(editor.document.uri.fsPath)
- if (!repositoryInfo) {
- return
- }
- const { remoteURL, branch, fileRelative } = repositoryInfo
+ // Register file-system related functionality.
+ vscode.workspace.registerFileSystemProvider('sourcegraph', fs, { isReadonly: true })
+ vscode.languages.registerHoverProvider({ scheme: 'sourcegraph' }, new SourcegraphHoverProvider(fs))
+ vscode.languages.registerDefinitionProvider({ scheme: 'sourcegraph' }, new SourcegraphDefinitionProvider(fs))
+ const referenceProvider = new SourcegraphReferenceProvider(fs)
+ vscode.languages.registerReferenceProvider({ scheme: 'sourcegraph' }, referenceProvider)
- const query = editor.document.getText(editor.selection)
- if (query === '') {
- return // nothing to query
- }
+ const filesTreeView = vscode.window.createTreeView('sourcegraph.files', {
+ treeDataProvider: files,
+ showCollapseAll: true,
+ })
+ files.setTreeView(filesTreeView)
- // Search in browser.
- await open(
- `${getSourcegraphUrl()}/-/editor` +
- `?remote_url=${encodeURIComponent(remoteURL)}` +
- `&branch=${encodeURIComponent(branch)}` +
- `&file=${encodeURIComponent(fileRelative)}` +
- `&editor=${encodeURIComponent('VSCode')}` +
- `&version=${encodeURIComponent(version)}` +
- `&search=${encodeURIComponent(query)}`
- )
-}
+ const diffsTreeView = vscode.window.createTreeView('sourcegraph.diffs', {
+ treeDataProvider: diffs,
+ showCollapseAll: true,
+ })
-/**
- * The command implementation for searching on Sourcegraph.com
- */
+ diffs.setTreeView(diffsTreeView)
+ for (const treeView of [filesTreeView, diffsTreeView]) {
+ context.subscriptions.push(treeView)
+ }
-async function searchCommand(): Promise {
- await vscode.window.showInputBox().then(value => {
- if (!value) {
- return
- }
- return open(`${getSourcegraphUrl()}/search?patternType=literal&q=${encodeURIComponent(value)}`)
- })
-}
+ const semanticTokens = new SourcegraphSemanticTokenProvider()
+ context.subscriptions.push(
+ vscode.commands.registerCommand('extension.goToFileInFolder', async (uri: string | undefined) => {
+ if (typeof uri === 'string') {
+ await goToFileCommand(fs, uri)
+ } else {
+ log.error(`extension.goToFileInFolder - invalid argument ${uri || 'undefined'}`)
+ }
+ })
+ )
+ context.subscriptions.push(
+ vscode.commands.registerCommand(
+ 'extension.goToFile',
+ handleCommandErrors('extension.goToFile', () => goToFileCommand(fs))
+ )
+ )
+ context.subscriptions.push(
+ vscode.commands.registerCommand(
+ 'extension.goToRepository',
+ handleCommandErrors('extension.goToRepository', () => goToRepositoryCommand(fs))
+ )
+ )
+ context.subscriptions.push(
+ vscode.commands.registerCommand(
+ 'extension.switchGitRevision',
+ handleCommandErrors('extension.switchGitRevision', (uri: string | undefined) =>
+ switchGitRevisionCommand(files, uri)
+ )
+ )
+ )
+ context.subscriptions.push(
+ vscode.commands.registerCommand('extension.updateCompareRange', async (...commandArguments) => {
+ await updateCompareRange(diffs, commandArguments)
+ })
+ )
+ context.subscriptions.push(
+ vscode.commands.registerCommand(
+ 'extension.openFileInBrowser',
+ handleCommandErrors('extension.openFileInBrowser', (uri: string | undefined) =>
+ openFileInBrowserCommand(files, uri)
+ )
+ )
+ )
+ context.subscriptions.push(
+ vscode.commands.registerCommand(
+ 'extension.newNotebook',
+ handleCommandErrors('extension.newNotebook', () => createNewNotebookCommand())
+ )
+ )
+ context.subscriptions.push(
+ vscode.commands.registerCommand(
+ 'extension.focusActiveFile',
+ handleCommandErrors('extension.focusActiveFile', () => files.focusActiveFile())
+ )
+ )
+ context.subscriptions.push(
+ vscode.commands.registerCommand('extension.openFile', async uri => {
+ if (typeof uri === 'string') {
+ await openSourcegraphUriCommand(fs, SourcegraphUri.parse(uri))
+ } else {
+ // eslint-disable-next-line @typescript-eslint/restrict-template-expressions
+ log.error(`extension.openFile(${uri}) argument is not a string`)
+ }
+ })
+ )
-/**
- * Called when the extension is activated.
- */
-export function activate(context: vscode.ExtensionContext): void {
- // Register our extension commands (see package.json).
- context.subscriptions.push(vscode.commands.registerCommand('extension.open', handleCommandErrors(openCommand)))
+ // Register Notebooks related functionality.
+ vscode.languages.registerReferenceProvider({ language: 'sourcegraph' }, referenceProvider)
+ vscode.languages.registerDocumentSemanticTokensProvider({ language: 'sourcegraph' }, semanticTokens, semanticTokens)
+ vscode.languages.registerCompletionItemProvider(
+ { language: 'sourcegraph' },
+ new SourcegraphCompletionItemProvider()
+ )
+ for (const treeProvider of [files, diffs]) {
+ context.subscriptions.push(
+ vscode.window.onDidChangeActiveTextEditor(editor => treeProvider.didFocus(editor?.document.uri))
+ )
+ treeProvider.didFocus(vscode.window.activeTextEditor?.document.uri).then(
+ () => {},
+ () => {}
+ )
+ }
+ context.subscriptions.push(activateEndpointSetting())
+ context.subscriptions.push(
+ vscode.window.onDidChangeTextEditorSelection(event => blames.onDidChangeTextEditorSelection(event))
+ )
context.subscriptions.push(
- vscode.commands.registerCommand('extension.search.selection', handleCommandErrors(searchSelectionCommand))
+ vscode.commands.registerCommand('extension.goToCommit', (...commandArguments) =>
+ goToCommitCommand(diffs, commandArguments)
+ )
)
- context.subscriptions.push(vscode.commands.registerCommand('extension.search', handleCommandErrors(searchCommand)))
+ vscode.workspace.registerNotebookSerializer('sourcegraph-notebook', new SourcegraphNotebookSerializer(fs), {})
}
export function deactivate(): void {
diff --git a/src/file-system/BlameDecorationProvider.ts b/src/file-system/BlameDecorationProvider.ts
new file mode 100644
index 00000000..e4a72694
--- /dev/null
+++ b/src/file-system/BlameDecorationProvider.ts
@@ -0,0 +1,137 @@
+import { formatDistance, parseISO } from 'date-fns'
+import * as vscode from 'vscode'
+import { GoToCommitParameters } from '../commands/goToCommitCommand'
+import { log } from '../log'
+import { GitBlame, gitBlameQuery } from '../queries/gitBlameQuery'
+import { emptyCancelationToken } from './emptyCancelationToken'
+import { SourcegraphFileSystemProvider } from './SourcegraphFileSystemProvider'
+import { SourcegraphUri } from './SourcegraphUri'
+
+export class BlameDecorationProvider {
+ constructor(public readonly fs: SourcegraphFileSystemProvider) {}
+
+ private gitBlameCache = new Map()
+ private cancelToken = new vscode.CancellationTokenSource()
+ private blameDecorationType = vscode.window.createTextEditorDecorationType({
+ isWholeLine: false,
+ rangeBehavior: vscode.DecorationRangeBehavior.ClosedClosed,
+ })
+
+ public async onDidChangeTextEditorSelection(event: vscode.TextEditorSelectionChangeEvent): Promise {
+ this.cancelToken.cancel()
+ if (event.textEditor.document.uri.scheme !== 'sourcegraph') {
+ return
+ }
+ this.cancelToken = new vscode.CancellationTokenSource()
+ try {
+ await this.onGitBlameDecorationsDidChange(event, this.cancelToken.token)
+ } catch (error) {
+ log.error(`onGitBlameDecorationsDidChange(${event.textEditor.document.uri.toString(true)})`, error)
+ }
+ }
+ private async onGitBlameDecorationsDidChange(
+ event: vscode.TextEditorSelectionChangeEvent,
+ token: vscode.CancellationToken
+ ): Promise {
+ const uri = this.fs.sourcegraphUri(event.textEditor.document.uri)
+ const blames = await this.gitBlame(uri)
+ if (token.isCancellationRequested) {
+ // Don't update decorations if the selection has changed.
+ return
+ }
+ const options: vscode.DecorationOptions[] = []
+ for (const selection of event.selections) {
+ const blameCandidates = blames.filter(
+ // NOTE: Sourcegraph blame line numbers are 1-based, while VS Code selection lines are 0-based.
+ blame => selection.end.line >= blame.startLine - 1 && selection.end.line < blame.endLine - 1
+ )
+ if (blameCandidates.length > 1) {
+ log.debug({ blameCandidates })
+ }
+ if (blameCandidates.length !== 1) {
+ continue
+ }
+ options.push(this.decorationOptions(uri, selection, blameCandidates[0]))
+ }
+ event.textEditor.setDecorations(this.blameDecorationType, options)
+ }
+
+ private decorationOptions(
+ uri: SourcegraphUri,
+ selection: vscode.Selection,
+ blame: GitBlame
+ ): vscode.DecorationOptions {
+ const avatarURL = blame.author?.person?.avatarURL ? `` : ''
+ const displayName = blame.author?.person?.displayName ? blame.author.person.displayName : ''
+ const humanDate = blame.author?.date ? `, ${formatDistance(parseISO(blame.author.date), Date.now())} ago` : ''
+ const date = blame.author?.date
+ ? ` (${parseISO(blame.author.date).toLocaleTimeString(undefined, {
+ second: undefined,
+ year: 'numeric',
+ month: 'short',
+ day: 'numeric',
+ })})`
+ : ''
+ const messageHeader = blame?.message ? ` • ${blame.message}` : ''
+ const commit = this.commitLink(selection, blame, uri)
+ const message = blame?.message || ''
+ const hoverMessage = new vscode.MarkdownString(`${avatarURL}${displayName}${humanDate}${date}
+
+---
+
+${commit}${message}`)
+ hoverMessage.isTrusted = true
+ return {
+ range: new vscode.Range(selection.end.line, 1000, selection.end.line, 1001),
+ hoverMessage,
+ renderOptions: {
+ after: {
+ margin: '2em',
+ contentText: `${displayName}${humanDate}${messageHeader}`,
+ },
+ light: {
+ after: {
+ color: '#5B5C5E',
+ },
+ },
+ dark: {
+ after: {
+ color: '#989A9E',
+ },
+ },
+ },
+ }
+ }
+
+ private commitLink(selection: vscode.Selection, blame: GitBlame, uri: SourcegraphUri): string {
+ if (!blame?.commit?.abbreviatedOID || !blame?.commit?.oid) {
+ return ''
+ }
+ const parameters: GoToCommitParameters = {
+ revision: blame.commit.oid,
+ uri: uri.uri,
+ line: selection.end.line,
+ filenameAtRevision: blame.filename,
+ }
+ const encodedParameters = encodeURIComponent(JSON.stringify(parameters))
+ return `[${blame.commit.abbreviatedOID}](command:extension.goToCommit?${encodedParameters} "Show Commit") • `
+ }
+
+ private async gitBlame(uri: SourcegraphUri): Promise {
+ let blame = this.gitBlameCache.get(uri.uri)
+ if (!blame) {
+ blame = await gitBlameQuery(
+ {
+ repositoryName: uri.repositoryName,
+ revision: uri.revision,
+ filePath: uri.path || '',
+ // Don't use cancelation token because we want to cache the
+ // result even if the selection range has been updated.
+ },
+ emptyCancelationToken()
+ )
+ this.gitBlameCache.set(uri.uri, blame)
+ }
+ return blame
+ }
+}
diff --git a/src/file-system/DiffsTreeDataProvider.ts b/src/file-system/DiffsTreeDataProvider.ts
new file mode 100644
index 00000000..9bda1032
--- /dev/null
+++ b/src/file-system/DiffsTreeDataProvider.ts
@@ -0,0 +1,435 @@
+import * as vscode from 'vscode'
+import { log } from '../log'
+import {
+ repositoryComparisonDiffQuery,
+ FileDiffNode,
+ RepositoryComparisonParameters,
+ RepositoryComparison,
+} from '../queries/repositoryComparisonDiffQuery'
+import { endpointHostnameSetting } from '../settings/endpointSetting'
+import { emptyCancelationToken } from './emptyCancelationToken'
+import { FileTree } from './FileTree'
+import { SourcegraphFileSystemProvider } from './SourcegraphFileSystemProvider'
+import { CompareRange, SourcegraphUri } from './SourcegraphUri'
+
+const DEFAULT_COMMIT_HISTORY_LENGTH = 10
+
+export class DiffsTreeDataProvider implements vscode.TreeDataProvider {
+ private repositoryComparisonCache = new Map()
+ private treeItemCache = new Map()
+ private compareRangesByRepositoryName = new Map()
+ private diffNodeChanges = new vscode.EventEmitter()
+ public activeUri: vscode.Uri | undefined
+ public onDidChangeTreeData?: vscode.Event = this.diffNodeChanges.event
+ constructor(public readonly fs: SourcegraphFileSystemProvider) {
+ fs.onDidDownloadRepositoryFilenames(() => this.diffNodeChanges.fire(undefined))
+ }
+ // private treeView: vscode.TreeView | undefined
+ public updateCompareRangePart(repositoryName: string, kind: 'base' | 'head', revision: string): void {
+ const old = this.compareRangeName(repositoryName)
+ const updatedRange: CompareRange = { ...old }
+ updatedRange[kind] = revision
+ this.updateCompareRange(repositoryName, updatedRange)
+ }
+ public updateCompareRange(repositoryName: string, updatedRange: CompareRange): void {
+ this.compareRangesByRepositoryName.set(repositoryName, updatedRange)
+ this.diffNodeChanges.fire(undefined)
+ }
+ public setTreeView(newTreeView: vscode.TreeView): void {
+ // this.treeView = newTreeView
+ }
+ public async didFocus(vscodeUri: vscode.Uri | undefined): Promise {
+ this.activeUri = vscodeUri
+ // if (vscodeUri && this.treeView) {
+ // this.treeView.reveal(this.counter % 2 === 0 ? first.toString() : second.toString(), { select: true })
+ // }
+ return Promise.resolve()
+ }
+ public getTreeItem(element: string): vscode.TreeItem {
+ // log.appendLine(`getTreeItem(${element})`)
+ try {
+ const node = DiffNode.parse(element)
+ if (node.isRepositoryName()) {
+ return {
+ label: node.repositoryName,
+ collapsibleState: vscode.TreeItemCollapsibleState.Expanded,
+ }
+ }
+ switch (node.kind) {
+ case 'base':
+ case 'head':
+ return {
+ id: node.toString(),
+ label: `${node.kind[0].toUpperCase()}${node.kind.slice(1)}: ${
+ this.compareRange(node)[node.kind]
+ }`,
+ resourceUri: vscode.Uri.parse('sourcegraph://host/.gitignore'),
+ tooltip: `Update ${node.kind} revision`,
+ contextValue: 'compareRange',
+ command: {
+ command: 'extension.updateCompareRange',
+ title: `Update ${node.kind} revision`,
+ arguments: [node.repositoryName, node.kind],
+ },
+ }
+ case 'commits':
+ if (!node.commit) {
+ return {
+ label: 'Commits',
+ collapsibleState: vscode.TreeItemCollapsibleState.Collapsed,
+ }
+ }
+ return this.treeItemCache.get(node.toString()) || {}
+ case 'files':
+ if (!node.path) {
+ return { label: 'Files', collapsibleState: vscode.TreeItemCollapsibleState.Expanded }
+ }
+ return this.treeItemCache.get(node.toString()) || {}
+ default:
+ return {}
+ }
+ } catch (error) {
+ log.error(`getTreeItem(${element})`, error)
+ return {}
+ }
+ }
+
+ public async getChildren(element?: string): Promise {
+ // log.appendLine(`getChildren(${element})`)
+ if (!element) {
+ const repositoryNames = [
+ ...new Set(this.fs.allRepositoryUris().map(uri => SourcegraphUri.parse(uri).repositoryName)),
+ ]
+ return repositoryNames.map(name => DiffNode.repositoryName(name).toString())
+ }
+ const node = DiffNode.parse(element)
+ if (node.isRepositoryName()) {
+ return [
+ node.with({ kind: 'base' }),
+ node.with({ kind: 'head' }),
+ node.with({ kind: 'commits' }),
+ node.with({ kind: 'files' }),
+ ].map(node => node.toString())
+ }
+ switch (node.kind) {
+ case 'files':
+ return this.fileTreeChildren(node)
+ case 'commits':
+ if (!node.commit) {
+ const comparison = await this.nodeComparison(node)
+ const result: string[] = []
+ for (const commit of comparison.commits) {
+ if (!commit.oid) {
+ continue
+ }
+ const childNode = node.with({ commit: commit.oid })
+ const childKey = childNode.toString()
+ const commitMessageHeader = commit.message?.split(/\n\r?/)?.[0]
+ const avatarURL = commit.author?.person?.avatarURL
+ const childItem: vscode.TreeItem = {
+ id: childKey,
+ iconPath: avatarURL ? vscode.Uri.parse(avatarURL) : undefined,
+ label: commitMessageHeader || commit.abbreviatedOID || commit.oid,
+ tooltip: commit.message ? new vscode.MarkdownString(commit.message) : undefined,
+ collapsibleState: vscode.TreeItemCollapsibleState.Collapsed,
+ }
+ this.treeItemCache.set(childKey, childItem)
+ result.push(childKey)
+ }
+ return result
+ }
+ return this.fileTreeChildren(node)
+ case 'base':
+ case 'head':
+ default:
+ return []
+ }
+ }
+
+ public getParent(element: string): string | undefined {
+ return undefined
+ }
+
+ private async fileTreeChildren(node: DiffNode): Promise {
+ const { tree, comparison } = await this.comparisonFileTree(node)
+ const directChildren = tree.directChildren(node.path || '')
+ const parent = SourcegraphUri.fromParts(endpointHostnameSetting(), node.repositoryName, {
+ revision: this.compareRange(node).head,
+ path: node.path,
+ })
+ const range = this.compareRange(node)
+ const result: string[] = []
+ for (const child of directChildren) {
+ const uri = SourcegraphUri.parse(child)
+ const childNode = node.with({ path: uri.path })
+ const treeItem = this.newTreeItem(
+ uri,
+ childNode,
+ parent,
+ directChildren.length,
+ range,
+ this.oldPath(uri.path || '', comparison.files),
+ comparison
+ )
+ if (uri.isFile() && !treeItem.command) {
+ continue
+ }
+ const childKey = childNode.toString()
+ this.treeItemCache.set(childKey, treeItem)
+ result.push(childKey)
+ }
+ return result
+ }
+
+ private oldPath(newPath: string, nodes: FileDiffNode[]): FileDiffNode | undefined {
+ for (const node of nodes) {
+ if (newPath === node.newPath) {
+ return node
+ }
+ }
+ return
+ }
+ private async comparisonFileTree(node: DiffNode): Promise<{ tree: FileTree; comparison: RepositoryComparison }> {
+ const comparison = await this.nodeComparison(node)
+ const filenames: string[] = []
+ for (const node of comparison.files) {
+ if (node.newPath) {
+ filenames.push(node.newPath)
+ }
+ }
+ return {
+ comparison,
+ tree: new FileTree(
+ SourcegraphUri.parse(`sourcegraph://${endpointHostnameSetting()}/${node.repositoryName}`),
+ filenames
+ ),
+ }
+ }
+
+ private async nodeComparison(node: DiffNode): Promise {
+ const id = (await this.fs.repositoryMetadata(node.repositoryName))?.id
+ if (!id) {
+ return { commits: [], files: [] }
+ }
+ const parameters: RepositoryComparisonParameters = {
+ repositoryId: id,
+ first: 1000,
+ ...this.compareRange(node),
+ }
+ const key = JSON.stringify(parameters)
+ let comparison = this.repositoryComparisonCache.get(key)
+ if (!comparison) {
+ comparison = await repositoryComparisonDiffQuery(parameters, emptyCancelationToken())
+ this.repositoryComparisonCache.set(key, comparison)
+ }
+ return comparison
+ }
+
+ private compareRange(node: DiffNode): CompareRange {
+ if (node.kind === 'commits' && node.commit) {
+ return { head: node.commit, base: `${node.commit}~1` }
+ }
+ return this.compareRangeName(node.repositoryName)
+ }
+ private compareRangeName(repositoryName: string): CompareRange {
+ let range = this.compareRangesByRepositoryName.get(repositoryName)
+ if (!range) {
+ range = {
+ base: `HEAD~${DEFAULT_COMMIT_HISTORY_LENGTH}`,
+ head: 'HEAD',
+ }
+ this.fs.repositoryMetadata(repositoryName).then(
+ metadata => {
+ if (metadata?.defaultBranch) {
+ const head = metadata.defaultBranch
+ this.compareRangesByRepositoryName.set(repositoryName, {
+ base: `${head}~${DEFAULT_COMMIT_HISTORY_LENGTH}`,
+ head,
+ })
+ this.diffNodeChanges.fire(undefined)
+ }
+ },
+ () => {}
+ )
+ this.compareRangesByRepositoryName.set(repositoryName, range)
+ }
+ return range
+ }
+
+ public diffTitle(basename: string, range: CompareRange): string {
+ return `${basename} (${range.base.slice(0, 7)} ↔ ${range.head.slice(0, 7)})`
+ }
+
+ private newTreeItem(
+ uri: SourcegraphUri,
+ childNode: DiffNode,
+ parent: SourcegraphUri | undefined,
+ parentChildrenCount: number,
+ range: CompareRange,
+ fileDiff: FileDiffNode | undefined,
+ comparison: RepositoryComparison
+ ): vscode.TreeItem {
+ const command = uri.isFile()
+ ? {
+ command: 'vscode.diff',
+ title: 'Compare files',
+ arguments: [
+ vscode.Uri.parse(
+ fileDiff?.oldPath
+ ? uri.withRevision(range.base).withPath(fileDiff.oldPath).uri
+ : this.fs.emptyFileUri()
+ ),
+ vscode.Uri.parse(uri.withRevision(range.head).uri),
+ this.diffTitle(uri.basename(), range),
+ ],
+ }
+ : undefined
+
+ const fileStats = fileDiffStats(uri, fileDiff, comparison)
+ const label = uri.treeItemLabel(parent)
+ return {
+ id: childNode.toString(),
+ label,
+ tooltip: fileStats.tooltip,
+ collapsibleState: uri.isFile()
+ ? vscode.TreeItemCollapsibleState.None
+ : parentChildrenCount === 1 || comparison.files.length < 50
+ ? // Expand by default for "small" diffs, where "small" is defined as touching less than 50 files.
+ vscode.TreeItemCollapsibleState.Expanded
+ : vscode.TreeItemCollapsibleState.Collapsed,
+ command,
+ resourceUri: vscode.Uri.parse(uri.uri),
+ // TODO: figure out how to get an icon on the right side similar to
+ // gitlens. We can use the resourceUri below, but then we loose the
+ // file icon.
+ // resourceUri: vscode.Uri.parse('gitlens-view://commit-file/status/M'),
+ contextValue: fileStats.contextValue,
+ }
+ }
+}
+
+interface FileStats {
+ tooltip: string
+ contextValue: string
+}
+
+function fileDiffStats(
+ uri: SourcegraphUri,
+ fileDiff: FileDiffNode | undefined,
+ comparison: RepositoryComparison
+): FileStats {
+ let added = fileDiff?.stat?.added || 0
+ let deleted = fileDiff?.stat?.deleted || 0
+ let changed = fileDiff?.stat?.changed || 0
+ if (uri.isDirectory()) {
+ const path = uri.path ? uri.path + '/' : ''
+ for (const file of comparison.files) {
+ if (file.newPath?.startsWith(path)) {
+ added += file.stat?.added || 0
+ deleted += file.stat?.deleted || 0
+ changed += file.stat?.changed || 0
+ }
+ }
+ }
+ const parts: string[] = []
+ const addCount = (what: string, count: number): void => {
+ if (count < 1) {
+ return
+ }
+ const suffix = count > 1 ? 's' : ''
+ parts.push(`${count.toLocaleString()} ${what}${suffix}`)
+ }
+ addCount('addition', added)
+ addCount('change', changed)
+ addCount('deletion', deleted)
+
+ if (parts.length === 0) {
+ return { tooltip: '', contextValue: '' }
+ }
+ const third = (added + deleted + changed) / 3
+ const total = added + deleted + changed
+ const maxColor = (): string => {
+ if (added > deleted && added > changed) {
+ added -= third
+ return 'green'
+ }
+ if (deleted > added && deleted > changed) {
+ deleted -= third
+ return 'red'
+ }
+ changed -= third
+ return 'orange'
+ }
+ const contextValue: string[] = [maxColor() + '1']
+ if (total > 10) {
+ contextValue.push(maxColor() + '2')
+ }
+ if (total > 100) {
+ contextValue.push(maxColor() + '3')
+ }
+
+ return {
+ tooltip: parts.join(', '),
+ contextValue: contextValue.join('-'),
+ }
+}
+
+type DiffNodeKind = 'base' | 'head' | 'commits' | 'files'
+interface DiffNodeOptionals {
+ kind?: DiffNodeKind
+ commit?: string
+ path?: string
+}
+
+class DiffNode {
+ private constructor(
+ public readonly repositoryName: string,
+ public readonly kind: DiffNodeKind | undefined,
+ public readonly commit: string | undefined,
+ public readonly path: string | undefined
+ ) {}
+
+ public isRepositoryName(): boolean {
+ return !this.kind && !this.commit && !this.path
+ }
+ public static repositoryName(repositoryName: string, optionals?: DiffNodeOptionals): DiffNode {
+ return DiffNode.fromAny({ repositoryName, ...optionals })
+ }
+ public with(optionals: DiffNodeOptionals): DiffNode {
+ return DiffNode.repositoryName(this.repositoryName, {
+ kind: this.kind,
+ commit: this.commit,
+ path: this.path,
+ ...optionals,
+ })
+ }
+ public static parse(json: string): DiffNode {
+ try {
+ return this.fromAny(JSON.parse(json))
+ } catch (error) {
+ return log.errorAndThrow(`DiffUri.parse(json=${json})`, error)
+ }
+ }
+ private static fromAny(any: any): DiffNode {
+ const repositoryName = any?.repositoryName
+ if (typeof repositoryName !== 'string') {
+ throw new TypeError('DiffUri.fromAny() missing repositoryName')
+ }
+ let kind: DiffNodeKind | undefined
+ if (any?.kind === 'base' || any?.kind === 'head' || any?.kind === 'commits' || any?.kind === 'files') {
+ kind = any.kind
+ }
+ let commit: string | undefined
+ if (typeof any?.commit === 'string') {
+ commit = any.commit
+ }
+ let path: string | undefined
+ if (typeof any?.path === 'string') {
+ path = any.path
+ }
+ return new DiffNode(repositoryName, kind, commit, path)
+ }
+ public toString(): string {
+ return JSON.stringify(this)
+ }
+}
diff --git a/src/file-system/FileTree.test.ts b/src/file-system/FileTree.test.ts
new file mode 100644
index 00000000..6ea8faba
--- /dev/null
+++ b/src/file-system/FileTree.test.ts
@@ -0,0 +1,64 @@
+import assert from 'assert'
+import { FileTree } from './FileTree'
+import { SourcegraphUri } from './SourcegraphUri'
+
+const tree = new FileTree(SourcegraphUri.parse('https://sourcegraph.com/sourcegraph-vscode@v8'), [
+ '.eslintrc.json',
+ '.github/workflows/build.yml',
+ '.gitignore',
+ '.vscode/extensions.json',
+ '.vscode/launch.json',
+ '.vscode/settings.json',
+ '.vscode/tasks.json',
+ '.vscodeignore',
+ 'README.md',
+ 'images/logo.png',
+ 'renovate.json',
+ 'src/browse/BrowseFileSystemProvider.ts',
+ 'src/browse/browseCommand.ts',
+ 'src/browse/graphqlQuery.ts',
+ 'src/browse/parseRepoUri.test.ts',
+ 'src/browse/parseRepoUrl.ts',
+ 'src/config.ts',
+ 'src/extension.ts',
+ 'src/git/helpers.ts',
+ 'src/git/index.ts',
+ 'src/git/remoteNameAndBranch.test.ts',
+ 'src/git/remoteNameAndBranch.ts',
+ 'src/git/remoteUrl.test.ts',
+ 'src/git/remoteUrl.ts',
+ 'src/log.ts',
+ 'tests/config.json',
+ 'tsconfig.json',
+])
+
+function checkChildren(directory: string, expected: string[]) {
+ it(`directChildren('${directory}')`, () => {
+ const childUris = tree.directChildren(directory)
+ const obtained: string[] = []
+ for (const childUri of childUris) {
+ const uri = SourcegraphUri.parse(childUri)
+ if (uri.path) {
+ const path = uri.isDirectory() ? uri.path + '/' : uri.path
+ obtained.push(path)
+ }
+ }
+ assert.deepStrictEqual(obtained, expected)
+ })
+}
+describe('FileTree', () => {
+ checkChildren('src', ['src/browse/', 'src/git/', 'src/config.ts', 'src/extension.ts', 'src/log.ts'])
+ checkChildren('', [
+ '.github/workflows/',
+ '.vscode/',
+ 'images/',
+ 'src/',
+ 'tests/',
+ '.eslintrc.json',
+ '.gitignore',
+ '.vscodeignore',
+ 'README.md',
+ 'renovate.json',
+ 'tsconfig.json',
+ ])
+})
diff --git a/src/file-system/FileTree.ts b/src/file-system/FileTree.ts
new file mode 100644
index 00000000..5aead386
--- /dev/null
+++ b/src/file-system/FileTree.ts
@@ -0,0 +1,115 @@
+import { SourcegraphUri } from './SourcegraphUri'
+
+/**
+ * Helper class to represent a flat list of relative file paths (type `string[]`) as a hierarchical file tree.
+ */
+export class FileTree {
+ constructor(public readonly uri: SourcegraphUri, public readonly files: string[]) {
+ files.sort()
+ }
+
+ public toString(): string {
+ return `FileTree(${this.uri.uri}, files.length=${this.files.length})`
+ }
+
+ public directChildren(directory: string): string[] {
+ return this.directChildrenInternal(directory, true)
+ }
+
+ private directChildrenInternal(directory: string, allowRecursion: boolean): string[] {
+ const depth = this.depth(directory)
+ const directFiles = new Set()
+ const directDirectories = new Set()
+ const isRoot = directory === ''
+ if (!isRoot && !directory.endsWith('/')) {
+ directory = directory + '/'
+ }
+ let index = this.binarySearchDirectoryStart(directory)
+ while (index < this.files.length) {
+ const startIndex = index
+ const file = this.files[index]
+ if (file === '') {
+ index++
+ continue
+ }
+ if (file.startsWith(directory)) {
+ const fileDepth = this.depth(file)
+ const isFile = isRoot ? fileDepth === 0 : fileDepth === depth + 1
+ let path = isFile ? file : file.slice(0, file.indexOf('/', directory.length))
+ let nestedChildren = allowRecursion && !isFile ? this.directChildrenInternal(path, false) : []
+ while (allowRecursion && nestedChildren.length === 1) {
+ const child = SourcegraphUri.parse(nestedChildren[0])
+ if (child.isDirectory()) {
+ path = child.path || ''
+ nestedChildren = this.directChildrenInternal(path, false)
+ } else {
+ break
+ }
+ }
+ const uri = SourcegraphUri.fromParts(this.uri.host, this.uri.repositoryName, {
+ revision: this.uri.revision,
+ path,
+ isDirectory: !isFile,
+ }).uri
+ if (isFile) {
+ directFiles.add(uri)
+ } else {
+ index = this.binarySearchDirectoryEnd(path + '/', index + 1)
+ directDirectories.add(uri)
+ // log.appendLine(`directory=${path} end=${this.files[index]}`)
+ }
+ }
+ if (index === startIndex) {
+ index++
+ }
+ }
+ return [...directDirectories, ...directFiles]
+ }
+
+ private binarySearchDirectoryStart(directory: string): number {
+ if (directory === '') {
+ return 0
+ }
+ return this.binarySearch(
+ { low: 0, high: this.files.length },
+ midpoint => this.files[midpoint].localeCompare(directory) > 0
+ )
+ }
+
+ private binarySearchDirectoryEnd(directory: string, low: number): number {
+ while (low < this.files.length && this.files[low].localeCompare(directory) <= 0) {
+ low++
+ }
+ return this.binarySearch(
+ { low, high: this.files.length },
+ midpoint => !this.files[midpoint].startsWith(directory)
+ )
+ }
+
+ private binarySearch({ low, high }: SearchRange, isGreater: (midpoint: number) => boolean): number {
+ while (low < high) {
+ const midpoint = Math.floor(low + (high - low) / 2)
+ if (isGreater(midpoint)) {
+ high = midpoint
+ } else {
+ low = midpoint + 1
+ }
+ }
+ return high
+ }
+
+ private depth(path: string): number {
+ let result = 0
+ for (const char of path) {
+ if (char === '/') {
+ result += 1
+ }
+ }
+ return result
+ }
+}
+
+interface SearchRange {
+ low: number
+ high: number
+}
diff --git a/src/file-system/FilesTreeDataProvider.ts b/src/file-system/FilesTreeDataProvider.ts
new file mode 100644
index 00000000..0eff49d3
--- /dev/null
+++ b/src/file-system/FilesTreeDataProvider.ts
@@ -0,0 +1,218 @@
+import * as vscode from 'vscode'
+import { log } from '../log'
+import { SourcegraphFileSystemProvider } from './SourcegraphFileSystemProvider'
+import { SourcegraphUri } from './SourcegraphUri'
+
+export class FilesTreeDataProvider implements vscode.TreeDataProvider {
+ constructor(public readonly fs: SourcegraphFileSystemProvider) {
+ fs.onDidDownloadRepositoryFilenames(() => this.didChangeTreeData.fire(undefined))
+ }
+
+ private _isViewVisible = false
+ private isExpandedNode = new Set()
+ private treeView: vscode.TreeView | undefined
+ private activeUri: vscode.Uri | undefined
+ private didFocusToken = new vscode.CancellationTokenSource()
+ private treeItemCache = new Map()
+ private readonly didChangeTreeData = new vscode.EventEmitter()
+ public readonly onDidChangeTreeData: vscode.Event = this.didChangeTreeData.event
+
+ public activeTextDocument(): SourcegraphUri | undefined {
+ return this.activeUri && this.activeUri.scheme === 'sourcegraph'
+ ? this.fs.sourcegraphUri(this.activeUri)
+ : undefined
+ }
+ public isViewVisible(): boolean {
+ return this._isViewVisible
+ }
+ public setTreeView(treeView: vscode.TreeView): void {
+ this.treeView = treeView
+ treeView.onDidChangeVisibility(event => {
+ const didBecomeVisible = !this._isViewVisible && event.visible
+ this._isViewVisible = event.visible
+ if (didBecomeVisible) {
+ // NOTE: do not remove the line below even if you think it
+ // doesn't have an effect. Before you remove this line, make
+ // sure that the following steps don't cause the "Collapse All"
+ // button to become disabled:
+ // 1. Close "Files" view.
+ // 2. Execute "Reload window" command.
+ // 3. After VS Code loads, open the "Files" view.
+ this.didChangeTreeData.fire(undefined)
+
+ this.didFocus(this.activeUri).then(
+ () => {},
+ () => {}
+ )
+ }
+ })
+ treeView.onDidExpandElement(event => {
+ this.isExpandedNode.add(event.element)
+ })
+ treeView.onDidCollapseElement(event => {
+ this.isExpandedNode.delete(event.element)
+ })
+ }
+
+ public async getParent(uriString?: string): Promise {
+ // log.appendLine(`getParent(${uriString})`)
+ try {
+ // Implementation note: this method is not implemented as
+ // `SourcegraphUri.parse(uri).parentUri()` because that would return
+ // URIs to directories that don't exist because they have no siblings
+ // and are therefore automatically merged with their parent. For example,
+ // imagine the following folder structure:
+ // .gitignore
+ // .github/workflows/ci.yml
+ // src/command.ts
+ // src/browse.ts
+ // The parent of `.github/workflows/ci.yml` is `.github/` because the `workflows/`
+ // directory has no sibling.
+ if (!uriString) {
+ return undefined
+ }
+ const uri = SourcegraphUri.parse(uriString)
+ if (!uri.path) {
+ return undefined
+ }
+ let ancestor: string | undefined = uri.repositoryUri()
+ let children = await this.getChildren(ancestor)
+ while (ancestor) {
+ const isParent = children?.includes(uriString)
+ if (isParent) {
+ break
+ }
+ ancestor = children?.find(childUri => {
+ const child = SourcegraphUri.parse(childUri)
+ return child.path && uri.path?.startsWith(child.path + '/')
+ })
+ if (!ancestor) {
+ log.errorAndThrow(`getParent(${uriString || 'undefined'}) nothing startsWith`)
+ }
+ children = await this.getChildren(ancestor)
+ }
+ return ancestor
+ } catch (error) {
+ log.errorAndThrow(`getParent(${uriString || 'undefined'})`, error)
+ return undefined
+ }
+ }
+
+ public async getChildren(uriString?: string): Promise {
+ // log.appendLine(`getChildren(${uriString})`)
+ try {
+ if (!uriString) {
+ // await this.getTreeItem(undefined)
+ const repos = [...this.fs.allRepositoryUris()]
+ return repos.map(repo => repo.replace('https://', 'sourcegraph://'))
+ }
+ const uri = SourcegraphUri.parse(uriString)
+ const tree = await this.fs.getFileTree(uri)
+ const directChildren = tree.directChildren(uri.path || '')
+ for (const child of directChildren) {
+ this.treeItemCache.set(child, this.newTreeItem(SourcegraphUri.parse(child), uri, directChildren.length))
+ }
+ return directChildren
+ } catch (error) {
+ return log.errorAndThrow(`getChildren(${uriString || ''})`, error)
+ }
+ }
+
+ public async focusActiveFile(): Promise {
+ await vscode.commands.executeCommand('sourcegraph.files.focus')
+ await this.didFocus(this.activeUri)
+ }
+
+ public async didFocus(vscodeUri: vscode.Uri | undefined): Promise {
+ log.appendLine(`didFocus=${vscodeUri?.toString(true) || 'undefined'}`)
+ this.didFocusToken.cancel()
+ this.didFocusToken = new vscode.CancellationTokenSource()
+ this.activeUri = vscodeUri
+ vscode.commands
+ .executeCommand('setContext', 'sourcegraph.canFocusActiveDocument', vscodeUri?.scheme === 'sourcegraph')
+ .then(
+ () => {},
+ () => {}
+ )
+ if (vscodeUri && vscodeUri.scheme === 'sourcegraph' && this.treeView && this._isViewVisible) {
+ const uri = this.fs.sourcegraphUri(vscodeUri)
+ if (uri.uri === this.fs.emptyFileUri()) {
+ return
+ }
+ await this.fs.downloadFiles(uri)
+ await this.didFocusString(uri, true, this.didFocusToken.token)
+ }
+ }
+
+ public async getTreeItem(uriString: string): Promise {
+ // log.appendLine(`getTreeItem(${uriString})`)
+ try {
+ const fromCache = this.treeItemCache.get(uriString)
+ if (fromCache) {
+ return fromCache
+ }
+ const uri = SourcegraphUri.parse(uriString)
+ const parentUri = await this.getParent(uri.uri)
+ return this.newTreeItem(uri, parentUri ? SourcegraphUri.parse(parentUri) : undefined, 0)
+ } catch (error) {
+ log.errorAndThrow(`getTreeItem(${uriString})`, error)
+ }
+ return {}
+ }
+
+ private async didFocusString(
+ uri: SourcegraphUri,
+ isDestinationNode: boolean,
+ token: vscode.CancellationToken
+ ): Promise {
+ try {
+ if (this.treeView) {
+ const parent = await this.getParent(uri.uri)
+ // if (parent && !this.isExpandedNode.has(parent)) {
+ if (parent) {
+ await this.didFocusString(SourcegraphUri.parse(parent), false, token)
+ } else {
+ await this.getChildren(undefined)
+ }
+ if (token.isCancellationRequested) {
+ return
+ }
+ // log.appendLine(`didFocusString(${uri.uri})`)
+ await this.treeView.reveal(uri.uri, {
+ focus: true,
+ select: isDestinationNode,
+ expand: !isDestinationNode,
+ })
+ }
+ } catch (error) {
+ log.error(`didFocusString(${uri.uri})`, error)
+ }
+ }
+
+ private newTreeItem(
+ uri: SourcegraphUri,
+ parent: SourcegraphUri | undefined,
+ parentChildrenCount: number
+ ): vscode.TreeItem {
+ const command = uri.isFile()
+ ? {
+ command: 'extension.openFile',
+ title: 'Open file',
+ arguments: [uri.uri],
+ }
+ : undefined
+ return {
+ id: uri.uri,
+ label: uri.treeItemLabel(parent),
+ tooltip: uri.uri.replace('sourcegraph://', 'https://'),
+ collapsibleState: uri.isFile()
+ ? vscode.TreeItemCollapsibleState.None
+ : parentChildrenCount === 1
+ ? vscode.TreeItemCollapsibleState.Expanded
+ : vscode.TreeItemCollapsibleState.Collapsed,
+ command,
+ resourceUri: vscode.Uri.parse(uri.uri),
+ contextValue: uri.isFile() ? 'file' : 'directory',
+ }
+ }
+}
diff --git a/src/file-system/SourcegraphFileSystemProvider.ts b/src/file-system/SourcegraphFileSystemProvider.ts
new file mode 100644
index 00000000..c1b95f65
--- /dev/null
+++ b/src/file-system/SourcegraphFileSystemProvider.ts
@@ -0,0 +1,295 @@
+/* eslint-disable @typescript-eslint/no-unused-vars */
+import * as vscode from 'vscode'
+import { SourcegraphUri } from './SourcegraphUri'
+import { log } from '../log'
+import { FileTree } from './FileTree'
+import { filesQuery } from '../queries/filesQuery'
+import { LocationNode } from '../queries/LocationNode'
+import { RepositoryMetadata, repositoryMetadataQuery } from '../queries/repositoryMetadataQuery'
+import { contentQuery as contents } from '../queries/contentQuery'
+import { emptyCancelationToken } from './emptyCancelationToken'
+import { endpointHostnameSetting } from '../settings/endpointSetting'
+
+export interface RepositoryFileNames {
+ repositoryUri: string
+ repositoryName: string
+ fileNames: string[]
+}
+
+export interface Blob {
+ uri: string
+ repositoryName: string
+ revision: string
+ path: string
+ content: Uint8Array
+ isBinaryFile: boolean
+ byteSize: number
+ time: number
+ type: vscode.FileType
+}
+
+export class SourcegraphFileSystemProvider implements vscode.FileSystemProvider {
+ private fileNamesByRepository: Map> = new Map()
+ private metadata: Map = new Map()
+ private didDownloadFilenames = new vscode.EventEmitter()
+
+ // ======================
+ // FileSystemProvider API
+ // ======================
+ private didChangeFile = new vscode.EventEmitter() // Never used.
+ public readonly onDidChangeFile: vscode.Event = this.didChangeFile.event
+ public async stat(vscodeUri: vscode.Uri): Promise {
+ const uri = this.sourcegraphUri(vscodeUri)
+ const now = Date.now()
+ if (uri.uri === this.emptyFileUri()) {
+ return { mtime: now, ctime: now, size: 0, type: vscode.FileType.File }
+ }
+ const files = await this.downloadFiles(uri)
+ const isFile = uri.path && files.includes(uri.path)
+ const type = isFile ? vscode.FileType.File : vscode.FileType.Directory
+ // log.appendLine(
+ // `stat(${uri.uri}) path=${uri.path || '""'} files.length=${files.length} type=${vscode.FileType[type]}`
+ // )
+ return {
+ // It seems to be OK to return hardcoded values for the timestamps
+ // and the byte size. If it turns out the byte size needs to be
+ // correct for some reason, then we can use
+ // `this.fetchBlob(uri).byteSize` to get the value for files.
+ mtime: now,
+ ctime: now,
+ size: 1337,
+ type,
+ }
+ }
+
+ public emptyFileUri(): string {
+ return 'sourcegraph://sourcegraph.com/empty-file.txt'
+ }
+
+ public async readFile(vscodeUri: vscode.Uri): Promise {
+ const uri = this.sourcegraphUri(vscodeUri)
+ if (uri.uri === this.emptyFileUri()) {
+ return new Uint8Array()
+ }
+ const blob = await this.fetchBlob(uri)
+ return blob.content
+ }
+
+ public async readDirectory(vscodeUri: vscode.Uri): Promise<[string, vscode.FileType][]> {
+ const uri = this.sourcegraphUri(vscodeUri)
+ if (uri.uri.endsWith('/-')) {
+ return []
+ }
+ const tree = await this.getFileTree(uri)
+ const children = tree.directChildren(uri.path || '')
+ return children.map(childUri => {
+ const child = SourcegraphUri.parse(childUri)
+ const type = child.isDirectory() ? vscode.FileType.Directory : vscode.FileType.File
+ return [child.basename(), type]
+ })
+ }
+
+ public createDirectory(uri: vscode.Uri): void {
+ throw new Error('Method not supported in read-only file system.')
+ }
+ public writeFile(
+ _uri: vscode.Uri,
+ _content: Uint8Array,
+ _options: { create: boolean; overwrite: boolean }
+ ): void | Thenable {
+ throw new Error('Method not supported in read-only file system.')
+ }
+ public delete(_uri: vscode.Uri, _options: { recursive: boolean }): void {
+ throw new Error('Method not supported in read-only file system.')
+ }
+ public rename(_oldUri: vscode.Uri, _newUri: vscode.Uri, _options: { overwrite: boolean }): void {
+ throw new Error('Method not supported in read-only file system.')
+ }
+ public watch(_uri: vscode.Uri, _options: { recursive: boolean; excludes: string[] }): vscode.Disposable {
+ throw new Error('Method not supported in read-only file system.')
+ }
+
+ // ===============================
+ // Helper methods for external use
+ // ===============================
+
+ public onDidDownloadRepositoryFilenames: vscode.Event = this.didDownloadFilenames.event
+
+ public allRepositoryUris(): string[] {
+ return [...this.fileNamesByRepository.keys()]
+ }
+
+ public async allFilesFromOpenRepositories(folder?: SourcegraphUri): Promise {
+ const promises: RepositoryFileNames[] = []
+ const folderRepositoryUri = folder?.repositoryUri()
+ for (const [repositoryUri, downloadingFileNames] of this.fileNamesByRepository.entries()) {
+ if (folderRepositoryUri && repositoryUri !== folderRepositoryUri) {
+ continue
+ }
+ try {
+ const fileNames = await downloadingFileNames
+ const uri = SourcegraphUri.parse(repositoryUri)
+ promises.push({
+ repositoryUri: uri.repositoryUri(),
+ repositoryName: `${uri.repositoryName}${uri.revisionPart()}`,
+ fileNames,
+ })
+ } catch {
+ log.error(`failed to download files for repository '${repositoryUri}'`)
+ }
+ }
+ return promises
+ }
+
+ public toVscodeLocation(node: LocationNode): vscode.Location {
+ const metadata = this.metadata.get(node.resource.repository.name)
+ let revision = node.resource.commit.oid
+ if (metadata?.defaultBranch && revision === metadata?.defaultOid) {
+ revision = metadata.defaultBranch
+ }
+ return new vscode.Location(
+ vscode.Uri.parse(
+ SourcegraphUri.fromParts(endpointHostnameSetting(), node.resource.repository.name, {
+ revision,
+ path: node.resource.path,
+ }).uri
+ ),
+ new vscode.Range(
+ new vscode.Position(node.range.start.line, node.range.start.character),
+ new vscode.Position(node.range.end.line, node.range.end.character)
+ )
+ )
+ }
+
+ /**
+ * @returns the URI of a file in the given repository. The file is the
+ * toplevel readme file if it exists, otherwise it's the file with the
+ * shortest name in the repository.
+ */
+ public async defaultFileUri(repositoryName: string): Promise {
+ const token = emptyCancelationToken()
+ const defaultBranch = (await this.repositoryMetadata(repositoryName, token))?.defaultBranch
+ if (!defaultBranch) {
+ log.errorAndThrow(`repository '${repositoryName}' has no default branch`)
+ }
+ const uri = SourcegraphUri.fromParts(endpointHostnameSetting(), repositoryName, { revision: defaultBranch })
+ const files = await this.downloadFiles(uri)
+ const readmes = files.filter(name => name.match(/readme/i))
+ const candidates = readmes.length > 0 ? readmes : files
+ let readme: string | undefined
+ for (const candidate of candidates) {
+ if (candidate === '' || candidate === 'lsif-java.json') {
+ // Skip auto-generated file for JVM packages
+ continue
+ }
+ if (!readme) {
+ readme = candidate
+ } else if (candidate.length < readme.length) {
+ readme = candidate
+ }
+ }
+ const defaultFile = readme || files[0]
+ return SourcegraphUri.fromParts(endpointHostnameSetting(), repositoryName, {
+ revision: defaultBranch,
+ path: defaultFile,
+ })
+ }
+
+ public async fetchBlob(uri: SourcegraphUri): Promise {
+ await this.repositoryMetadata(uri.repositoryName)
+ const token = emptyCancelationToken()
+ if (!uri.revision) {
+ log.errorAndThrow(`missing revision for URI '${uri.uri}'`)
+ }
+ const path = uri.path || ''
+ const content = await contents(
+ {
+ repository: uri.repositoryName,
+ revision: uri.revision,
+ path,
+ },
+ token
+ )
+
+ if (content) {
+ const toCacheResult: Blob = {
+ uri: uri.uri,
+ repositoryName: uri.repositoryName,
+ revision: uri.revision,
+ content: content.content,
+ isBinaryFile: content.isBinary,
+ byteSize: content.byteSize,
+ path,
+ time: new Date().getMilliseconds(),
+ type: vscode.FileType.File,
+ }
+
+ // Start downloading the repository files in the background.
+ this.downloadFiles(uri).then(
+ () => {},
+ () => {}
+ )
+
+ return toCacheResult
+ }
+ return log.errorAndThrow(`fetchBlob(${uri.uri}) not found`)
+ }
+
+ public async repositoryMetadata(
+ repositoryName: string,
+ token?: vscode.CancellationToken
+ ): Promise {
+ let metadata = this.metadata.get(repositoryName)
+ if (metadata) {
+ return metadata
+ }
+ metadata = await repositoryMetadataQuery({ repositoryName }, token || emptyCancelationToken())
+ this.metadata.set(repositoryName, metadata)
+ return metadata
+ }
+
+ public downloadFiles(uri: SourcegraphUri): Promise {
+ const key = uri.repositoryUri()
+ const fileNamesByRepository = this.fileNamesByRepository
+ let downloadingFiles = this.fileNamesByRepository.get(key)
+ if (!downloadingFiles) {
+ downloadingFiles = filesQuery(
+ { repository: uri.repositoryName, revision: uri.revision },
+ emptyCancelationToken()
+ )
+ vscode.window
+ .withProgress(
+ {
+ location: vscode.ProgressLocation.Window,
+ title: `Loading ${uri.repositoryName}`,
+ },
+ async progress => {
+ try {
+ await downloadingFiles
+ this.didDownloadFilenames.fire(key)
+ } catch (error) {
+ log.error(`downloadFiles(${key})`, error)
+ fileNamesByRepository.delete(key)
+ }
+ progress.report({ increment: 100 })
+ }
+ )
+ .then(
+ () => {},
+ () => {}
+ )
+
+ this.fileNamesByRepository.set(key, downloadingFiles)
+ }
+ return downloadingFiles
+ }
+
+ public sourcegraphUri(uri: vscode.Uri): SourcegraphUri {
+ return SourcegraphUri.parse(uri.toString(true))
+ }
+
+ public async getFileTree(uri: SourcegraphUri): Promise {
+ const files = await this.downloadFiles(uri)
+ return new FileTree(uri, files)
+ }
+}
diff --git a/src/file-system/SourcegraphUri.test.ts b/src/file-system/SourcegraphUri.test.ts
new file mode 100644
index 00000000..bd9dc648
--- /dev/null
+++ b/src/file-system/SourcegraphUri.test.ts
@@ -0,0 +1,87 @@
+import assert from 'assert'
+import { SourcegraphUri } from './SourcegraphUri'
+
+function check(
+ input: string,
+ expected: { repositoryName: string; revision: string; path?: string },
+ assertion?: (uri: SourcegraphUri) => void
+) {
+ it(`parseBrowserRepoURL('${input})'`, () => {
+ const obtained = SourcegraphUri.parse(input)
+ assert.deepStrictEqual(obtained.repositoryName, expected.repositoryName, 'repositoryName does not match')
+ assert.deepStrictEqual(obtained.revision, expected.revision, 'revision does not match')
+ assert.deepStrictEqual(obtained.path, expected.path, 'path does not match')
+ if (assertion) {
+ assertion(obtained)
+ }
+ const roundtrip = SourcegraphUri.parse(obtained.uri)
+ assert.deepStrictEqual(obtained, roundtrip, 'roundtrip test failed, uri !== Sourcegraph.parse(uri.uri)')
+ })
+}
+
+function checkParent(input: string, expected: string | undefined) {
+ it(`checkParent('${input}')`, () => {
+ const obtained = SourcegraphUri.parse(input).parentUri()
+ assert.deepStrictEqual(obtained, expected)
+ })
+}
+
+describe('SourcegraphUri', () => {
+ check('sourcegraph://sourcegraph.com/jdk@v8/-/blob/java/lang/String.java', {
+ repositoryName: 'jdk',
+ revision: 'v8',
+ path: 'java/lang/String.java',
+ })
+ checkParent(
+ 'sourcegraph://sourcegraph.com/jdk@v8/-/blob/java/lang/String.java',
+ 'sourcegraph://sourcegraph.com/jdk@v8/-/tree/java/lang'
+ )
+ checkParent(
+ 'sourcegraph://sourcegraph.com/github.com/sourcegraph@v8/-/blob/indexing/dependency_indexing_scheduler_test.go',
+ 'sourcegraph://sourcegraph.com/github.com/sourcegraph@v8/-/tree/indexing'
+ )
+ checkParent(
+ 'sourcegraph://sourcegraph.com/github.com/sourcegraph/-/blob/indexing/dependency_indexing_scheduler_test.go#L102:1',
+ 'sourcegraph://sourcegraph.com/github.com/sourcegraph/-/tree/indexing'
+ )
+ checkParent(
+ 'sourcegraph://sourcegraph.com/jdk@v8/-/tree/java/lang',
+ 'sourcegraph://sourcegraph.com/jdk@v8/-/tree/java'
+ )
+ checkParent('sourcegraph://sourcegraph.com/jdk@v8/-/tree/java', 'sourcegraph://sourcegraph.com/jdk@v8')
+ checkParent('sourcegraph://sourcegraph.com/jdk@v8', undefined)
+ check(
+ 'sourcegraph://sourcegraph.com/REPO/-/commit/COMMIT?visible=1',
+ {
+ repositoryName: 'REPO',
+ revision: 'COMMIT',
+ path: '',
+ },
+ uri => {
+ assert.strictEqual(uri.isCommit(), true)
+ }
+ )
+ check(
+ 'sourcegraph://sourcegraph.com/REPO/-/commit/COMMIT',
+ { repositoryName: 'REPO', revision: 'COMMIT', path: '' },
+ uri => assert.strictEqual(uri.isCommit(), true)
+ )
+ check(
+ 'sourcegraph://sourcegraph.com/REPO/-/compare/COMMIT1...COMMIT2',
+ { repositoryName: 'REPO', revision: '', path: undefined },
+ uri => {
+ assert(uri.isCompare())
+ assert.deepStrictEqual(uri.compareRange, { base: 'COMMIT1', head: 'COMMIT2' })
+ }
+ )
+ check(
+ 'sourcegraph://sourcegraph.com/github.com/sourcegraph/sourcegraph/-/compare/main...code-intel/cesar/22229/keyboard-shortcut-fuzzy-finder?visible=6',
+ { repositoryName: 'github.com/sourcegraph/sourcegraph', revision: '', path: undefined },
+ uri => {
+ assert.deepStrictEqual(uri.compareRange, {
+ base: 'main',
+ head: 'code-intel/cesar/22229/keyboard-shortcut-fuzzy-finder',
+ })
+ }
+ )
+})
diff --git a/src/file-system/SourcegraphUri.ts b/src/file-system/SourcegraphUri.ts
new file mode 100644
index 00000000..727a26dc
--- /dev/null
+++ b/src/file-system/SourcegraphUri.ts
@@ -0,0 +1,423 @@
+import { URL, URLSearchParams } from 'url'
+import { Position } from '../queries/Range'
+interface Optionals {
+ revision?: string
+ path?: string
+ position?: Position
+ isDirectory?: boolean
+ isCommit?: boolean
+ compareRange?: CompareRange
+}
+
+/**
+ * SourcegraphUri encodes a URI like `sourcegraph://HOST/REPOSITORY@REVISION/-/blob/PATH?L1337`.
+ */
+export class SourcegraphUri {
+ private constructor(
+ public readonly uri: string,
+ public readonly host: string,
+ public readonly repositoryName: string,
+ public readonly revision: string,
+ public readonly path: string | undefined,
+ public readonly position: Position | undefined,
+ public readonly compareRange: CompareRange | undefined
+ ) {}
+
+ public withRevision(newRevision: string | undefined): SourcegraphUri {
+ const newRevisionPath = newRevision ? `@${newRevision}` : ''
+ return SourcegraphUri.parse(
+ `sourcegraph://${this.host}/${this.repositoryName}${newRevisionPath}/-/blob/${
+ this.path || ''
+ }${this.positionSuffix()}`
+ )
+ }
+
+ public with(optionals: Optionals): SourcegraphUri {
+ return SourcegraphUri.fromParts(this.host, this.repositoryName, {
+ path: this.path,
+ revision: this.revision,
+ compareRange: this.compareRange,
+ position: this.position,
+ ...optionals,
+ })
+ }
+
+ public withPath(newPath: string): SourcegraphUri {
+ return SourcegraphUri.parse(`${this.repositoryUri()}/-/blob/${newPath}${this.positionSuffix()}`)
+ }
+
+ public basename(): string {
+ const parts = (this.path || '').split('/')
+ return parts[parts.length - 1]
+ }
+
+ public dirname(): string {
+ const parts = (this.path || '').split('/')
+ return parts.slice(0, -1).join('/')
+ }
+
+ public parentUri(): string | undefined {
+ if (typeof this.path === 'string') {
+ const slash = this.uri.lastIndexOf('/')
+ if (slash < 0 || !this.path.includes('/')) {
+ return `sourcegraph://${this.host}/${this.repositoryName}${this.revisionPart()}`
+ }
+ const parent = this.uri.slice(0, slash).replace('/-/blob/', '/-/tree/')
+ return parent
+ }
+ return undefined
+ }
+
+ public withIsDirectory(isDirectory: boolean): SourcegraphUri {
+ return SourcegraphUri.fromParts(this.host, this.repositoryName, {
+ isDirectory,
+ path: this.path,
+ revision: this.revision,
+ position: this.position,
+ })
+ }
+
+ public isCommit(): boolean {
+ return this.uri.includes('/-/commit/')
+ }
+
+ public isCompare(): boolean {
+ return this.uri.includes('/-/compare/') && this.compareRange !== undefined
+ }
+
+ public isDirectory(): boolean {
+ return this.uri.includes('/-/tree/')
+ }
+
+ public isFile(): boolean {
+ return this.uri.includes('/-/blob/')
+ }
+
+ public static fromParts(host: string, repositoryName: string, optional?: Optionals): SourcegraphUri {
+ const revisionPart = optional?.revision && !optional.isCommit ? `@${optional.revision}` : ''
+ const directoryPart = optional?.isDirectory
+ ? 'tree'
+ : optional?.isCommit
+ ? 'commit'
+ : optional?.compareRange
+ ? 'compare'
+ : 'blob'
+ const pathPart = optional?.compareRange
+ ? `/-/compare/${optional.compareRange.base}...${optional.compareRange.head}`
+ : optional?.isCommit && optional.revision
+ ? `/-/commit/${optional.revision}`
+ : optional?.path
+ ? `/-/${directoryPart}/${optional?.path}`
+ : ''
+ const uri = `sourcegraph://${host}/${repositoryName}${revisionPart}${pathPart}`
+ return new SourcegraphUri(
+ uri,
+ host,
+ repositoryName,
+ optional?.revision || '',
+ optional?.path,
+ optional?.position,
+ optional?.compareRange
+ )
+ }
+ public repositoryUri(): string {
+ return `sourcegraph://${this.host}/${this.repositoryName}${this.revisionPart()}`
+ }
+ public treeItemLabel(parent?: SourcegraphUri): string {
+ if (this.path) {
+ if (parent?.path) {
+ return this.path.slice(parent.path.length + 1)
+ }
+ return this.path
+ }
+ return `${this.repositoryName}${this.revisionPart()}`
+ }
+ public revisionPart(): string {
+ return this.revision ? `@${this.revision}` : ''
+ }
+ public positionSuffix(): string {
+ return typeof this.position === 'undefined' ? '' : `?L${this.position.line}:${this.position.character}`
+ }
+
+ // NOTE: The code below is copy-pasted from the sourcegraph/sourcegraph repository
+ // https://sourcegraph.com/github.com/sourcegraph/sourcegraph@56dfaaa3e3172f9afd4a29a4780a7f1a34198238/-/blob/client/shared/src/util/url.ts?L287
+ public static parse(uri: string): SourcegraphUri {
+ uri = uri.replace('https://', 'sourcegraph://')
+ const url = new URL(uri.replace('sourcegraph://', 'https://'))
+ let pathname = url.pathname.slice(1) // trim leading '/'
+ if (pathname.endsWith('/')) {
+ pathname = pathname.slice(0, -1) // trim trailing '/'
+ }
+
+ const indexOfSeparator = pathname.indexOf('/-/')
+
+ // examples:
+ // - 'github.com/gorilla/mux'
+ // - 'github.com/gorilla/mux@revision'
+ // - 'foo/bar' (from 'sourcegraph.mycompany.com/foo/bar')
+ // - 'foo/bar@revision' (from 'sourcegraph.mycompany.com/foo/bar@revision')
+ // - 'foobar' (from 'sourcegraph.mycompany.com/foobar')
+ // - 'foobar@revision' (from 'sourcegraph.mycompany.com/foobar@revision')
+ let repoRevision: string
+ if (indexOfSeparator === -1) {
+ repoRevision = pathname // the whole string
+ } else {
+ repoRevision = pathname.slice(0, indexOfSeparator) // the whole string leading up to the separator (allows revision to be multiple path parts)
+ }
+ let { repositoryName, revision } = parseRepoRevision(repoRevision)
+
+ let path: string | undefined
+ let compareRange: CompareRange | undefined
+ const treeSeparator = pathname.indexOf('/-/tree/')
+ const blobSeparator = pathname.indexOf('/-/blob/')
+ const commitSeparator = pathname.indexOf('/-/commit/')
+ const comparisonSeparator = pathname.indexOf('/-/compare/')
+ if (treeSeparator !== -1) {
+ path = decodeURIComponent(pathname.slice(treeSeparator + '/-/tree/'.length))
+ }
+ if (blobSeparator !== -1) {
+ path = decodeURIComponent(pathname.slice(blobSeparator + '/-/blob/'.length))
+ }
+ if (commitSeparator !== -1) {
+ path = decodeURIComponent(pathname.slice(commitSeparator + '/-/commit/'.length))
+ }
+ if (comparisonSeparator !== -1) {
+ const range = pathname.slice(comparisonSeparator + '/-/compare/'.length)
+ const parts = range.split('...')
+ if (parts.length === 2) {
+ const [base, head] = parts
+ compareRange = { base, head }
+ }
+ }
+ let position: Position | undefined
+ // let range: Range | undefined
+
+ const parsedHash = parseQueryAndHash(url.search, url.hash)
+ if (parsedHash.line) {
+ position = {
+ line: parsedHash.line,
+ character: parsedHash.character || 0,
+ }
+ // if (parsedHash.endLine) {
+ // range = {
+ // start: position,
+ // end: {
+ // line: parsedHash.endLine,
+ // character: parsedHash.endCharacter || 0,
+ // },
+ // }
+ // }
+ }
+ const isDirectory = uri.includes('/-/tree/')
+ const isCommit = uri.includes('/-/commit/')
+ if (isCommit) {
+ revision = url.pathname.replace(new RegExp('.*/-/commit/([^/]+).*'), (_unused, oid: string) => oid)
+ path = path?.slice(`${revision}/`.length)
+ }
+ return SourcegraphUri.fromParts(url.host, repositoryName, {
+ revision,
+ path,
+ position,
+ isDirectory,
+ isCommit,
+ compareRange,
+ })
+ }
+}
+
+/**
+ * Represents a line, a position, a line range, or a position range. It forbids
+ * just a character, or a range from a line to a position or vice versa (such as
+ * "L1-2:3" or "L1:2-3"), none of which would make much sense.
+ *
+ * 1-indexed.
+ */
+type LineOrPositionOrRange =
+ | { line?: undefined; character?: undefined; endLine?: undefined; endCharacter?: undefined }
+ | { line: number; character?: number; endLine?: undefined; endCharacter?: undefined }
+ | { line: number; character?: undefined; endLine?: number; endCharacter?: undefined }
+ | { line: number; character: number; endLine: number; endCharacter: number }
+
+/**
+ * Parses the URL search (query) portion and looks for a parameter which matches a line, position, or range in the file. If not found, it
+ * falls back to parsing the hash for backwards compatibility.
+ *
+ * @template V The type that describes the view state (typically a union of string constants). There is no runtime check that the return value satisfies V.
+ */
+function parseQueryAndHash(query: string, hash: string): LineOrPositionOrRange & { viewState?: V } {
+ const lpr = findLineInSearchParameters(new URLSearchParams(query))
+ const parsedHash = parseHash(hash)
+ if (!lpr) {
+ return parsedHash
+ }
+ return { ...lpr, viewState: parsedHash.viewState }
+}
+
+/**
+ * Parses the URL fragment (hash) portion, which consists of a line, position, or range in the file, plus an
+ * optional "viewState" parameter (that encodes other view state, such as for the panel).
+ *
+ * For example, in the URL fragment "#L17:19-21:23$foo:bar", the "viewState" is "foo:bar".
+ *
+ * @template V The type that describes the view state (typically a union of string constants). There is no runtime check that the return value satisfies V.
+ */
+function parseHash(hash: string): LineOrPositionOrRange & { viewState?: V } {
+ if (hash.startsWith('#')) {
+ hash = hash.slice('#'.length)
+ }
+
+ if (!isLegacyFragment(hash)) {
+ // Modern hash parsing logic (e.g. for hashes like `"#L17:19-21:23&tab=foo:bar"`:
+ const searchParameters = new URLSearchParams(hash)
+ const lpr = (findLineInSearchParameters(searchParameters) || {}) as LineOrPositionOrRange & {
+ viewState?: V
+ }
+ if (searchParameters.get('tab')) {
+ lpr.viewState = searchParameters.get('tab') as V
+ }
+ return lpr
+ }
+
+ // Legacy hash parsing logic (e.g. for hashes like "#L17:19-21:23$foo:bar" where the "viewState" is "foo:bar"):
+ if (!/^(L\d+(:\d+)?(-\d+(:\d+)?)?)?(\$.*)?$/.test(hash)) {
+ // invalid or empty hash
+ return {}
+ }
+ const lineCharModalInfo = hash.split('$', 2) // e.g. "L17:19-21:23$references"
+ const lpr = parseLineOrPositionOrRange(lineCharModalInfo[0]) as LineOrPositionOrRange & { viewState?: V }
+ if (lineCharModalInfo[1]) {
+ lpr.viewState = lineCharModalInfo[1] as V
+ }
+ return lpr
+}
+
+/**
+ * Tells if the given fragment component is a legacy blob hash component or not.
+ *
+ * @param hash The URL fragment.
+ */
+function isLegacyFragment(hash: string): boolean {
+ if (hash.startsWith('#')) {
+ hash = hash.slice('#'.length)
+ }
+ return (
+ hash !== '' &&
+ !hash.includes('=') &&
+ (hash.includes('$info') ||
+ hash.includes('$def') ||
+ hash.includes('$references') ||
+ hash.includes('$impl') ||
+ hash.includes('$history'))
+ )
+}
+
+/**
+ * Finds the URL search parameter which has a key like "L1-2:3" without any
+ * value.
+ *
+ * @param searchParameters The URLSearchParams to look for the line in.
+ */
+function findLineInSearchParameters(searchParameters: URLSearchParams): LineOrPositionOrRange | undefined {
+ const key = findLineKeyInSearchParameters(searchParameters)
+ return key ? parseLineOrPositionOrRange(key) : undefined
+}
+
+/**
+ * Parses a string like "L1-2:3", a range from a line to a position.
+ */
+function parseLineOrPositionOrRange(lineChar: string): LineOrPositionOrRange {
+ if (!/^(L\d+(:\d+)?(-L?\d+(:\d+)?)?)?$/.test(lineChar)) {
+ return {} // invalid
+ }
+
+ // Parse the line or position range, ensuring we don't get an inconsistent result
+ // (such as L1-2:3, a range from a line to a position).
+ let line: number | undefined // 17
+ let character: number | undefined // 19
+ let endLine: number | undefined // 21
+ let endCharacter: number | undefined // 23
+ if (lineChar.startsWith('L')) {
+ const positionOrRangeString = lineChar.slice(1)
+ const [startString, endString] = positionOrRangeString.split('-', 2)
+ if (startString) {
+ const parsed = parseLineOrPosition(startString)
+ line = parsed.line
+ character = parsed.character
+ }
+ if (endString) {
+ const parsed = parseLineOrPosition(endString)
+ endLine = parsed.line
+ endCharacter = parsed.character
+ }
+ }
+ // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+ let lpr = { line, character, endLine, endCharacter } as LineOrPositionOrRange
+ if (typeof line === 'undefined' || (typeof endLine !== 'undefined' && typeof character !== typeof endCharacter)) {
+ lpr = {}
+ } else if (typeof character === 'undefined') {
+ lpr = typeof endLine === 'undefined' ? { line } : { line, endLine }
+ } else if (typeof endLine === 'undefined' || typeof endCharacter === 'undefined') {
+ lpr = { line, character }
+ } else {
+ lpr = { line, character, endLine, endCharacter }
+ }
+ return lpr
+}
+
+function findLineKeyInSearchParameters(searchParameters: URLSearchParams): string | undefined {
+ for (const key of searchParameters.keys()) {
+ if (key.startsWith('L')) {
+ return key
+ }
+ break
+ }
+ return undefined
+}
+
+function parseLineOrPosition(
+ string: string
+): { line: undefined; character: undefined } | { line: number; character?: number } {
+ if (string.startsWith('L')) {
+ string = string.slice(1)
+ }
+ const parts = string.split(':', 2)
+ let line: number | undefined
+ let character: number | undefined
+ if (parts.length >= 1) {
+ line = parseInt(parts[0], 10)
+ }
+ if (parts.length === 2) {
+ character = parseInt(parts[1], 10)
+ }
+ line = typeof line === 'number' && isNaN(line) ? undefined : line
+ character = typeof character === 'number' && isNaN(character) ? undefined : character
+ if (typeof line === 'undefined') {
+ return { line: undefined, character: undefined }
+ }
+ return { line, character }
+}
+
+/** The results of parsing a repo-revision string like "my/repo@my/revision". */
+interface ParsedRepoRevision {
+ repositoryName: string
+
+ /** The URI-decoded revision (e.g., "my#branch" in "my/repo@my%23branch"). */
+ revision?: string
+
+ /** The raw revision (e.g., "my%23branch" in "my/repo@my%23branch"). */
+ rawRevision?: string
+}
+
+function parseRepoRevision(repoRevision: string): ParsedRepoRevision {
+ const [repository, revision] = repoRevision.split('@', 2) as [string, string | undefined]
+ return {
+ repositoryName: decodeURIComponent(repository),
+ revision: revision && decodeURIComponent(revision),
+ rawRevision: revision,
+ }
+}
+
+export interface CompareRange {
+ base: string
+ head: string
+}
diff --git a/src/file-system/emptyCancelationToken.ts b/src/file-system/emptyCancelationToken.ts
new file mode 100644
index 00000000..4c8f17be
--- /dev/null
+++ b/src/file-system/emptyCancelationToken.ts
@@ -0,0 +1,5 @@
+import * as vscode from 'vscode'
+
+export function emptyCancelationToken(): vscode.CancellationToken {
+ return new vscode.CancellationTokenSource().token
+}
diff --git a/src/git/index.ts b/src/git/index.ts
index 862518e4..1adab0e9 100644
--- a/src/git/index.ts
+++ b/src/git/index.ts
@@ -1,6 +1,7 @@
import * as path from 'path'
import { log } from '../log'
-import { getRemoteUrlReplacements, getDefaultBranch } from '../config'
+import { defaultBranchSetting } from '../settings/defaultBranchSetting'
+import { remoteUrlReplacementsSetting } from '../settings/remoteUrlReplacementsSetting'
import { gitHelpers } from './helpers'
import { Branch, gitRemoteNameAndBranch } from './remoteNameAndBranch'
import { gitRemoteUrlWithReplacements } from './remoteUrl'
@@ -30,11 +31,11 @@ export async function repoInfo(filePath: string): Promise {
+ outputChannel.appendLine(`ERROR ${errorMessage(what, error)}`)
+ },
+ errorAndThrow: (what: string, error?: any): never => {
+ log.error(what, error)
+ throw new Error(errorMessage(what, error))
+ },
+ debug: (what: any): void => {
+ for (const key of Object.keys(what)) {
+ const value = JSON.stringify(what[key])
+ outputChannel.appendLine(`${key}=${value}`)
+ }
+ },
+ appendLine: (message: string): void => {
+ outputChannel.appendLine(message)
+ },
+}
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function errorMessage(what: string, error?: any): string {
+ const errorMessage =
+ error instanceof Error
+ ? ` ${error.message} ${error.stack || ''}`
+ : error !== undefined
+ ? ` ${JSON.stringify(error)}`
+ : ''
+ return what + errorMessage
+}
diff --git a/src/queries/LocationNode.ts b/src/queries/LocationNode.ts
new file mode 100644
index 00000000..98452322
--- /dev/null
+++ b/src/queries/LocationNode.ts
@@ -0,0 +1,14 @@
+import { Range } from './Range'
+
+export interface LocationNode {
+ resource: {
+ path: string
+ repository: {
+ name: string
+ }
+ commit: {
+ oid: string
+ }
+ }
+ range: Range
+}
diff --git a/src/queries/PositionParameters.ts b/src/queries/PositionParameters.ts
new file mode 100644
index 00000000..76653912
--- /dev/null
+++ b/src/queries/PositionParameters.ts
@@ -0,0 +1,7 @@
+export interface PositionParameters {
+ repositoryName: string
+ revision: string
+ path: string
+ line: number
+ character: number
+}
diff --git a/src/queries/Range.ts b/src/queries/Range.ts
new file mode 100644
index 00000000..e40360bc
--- /dev/null
+++ b/src/queries/Range.ts
@@ -0,0 +1,15 @@
+/**
+ * Identical to vscode.Position except it's a plain interface instead of a class.
+ */
+export interface Position {
+ line: number
+ character: number
+}
+
+/**
+ * Identical to vscode.Range except it's a plain interface instead of a class.
+ */
+export interface Range {
+ start: Position
+ end: Position
+}
diff --git a/src/queries/contentQuery.ts b/src/queries/contentQuery.ts
new file mode 100644
index 00000000..de13201e
--- /dev/null
+++ b/src/queries/contentQuery.ts
@@ -0,0 +1,60 @@
+import * as vscode from 'vscode'
+import { graphqlQuery } from './graphqlQuery'
+import { TextEncoder } from 'util'
+import gql from 'tagged-template-noop'
+
+export interface FileContents {
+ content: Uint8Array
+ isBinary: boolean
+ byteSize: number
+}
+
+export async function contentQuery(
+ parameters: ContentParameters,
+ token: vscode.CancellationToken
+): Promise {
+ const contentResult = await graphqlQuery(
+ gql`
+ query Content($repository: String!, $revision: String!, $path: String!) {
+ repository(name: $repository) {
+ commit(rev: $revision) {
+ blob(path: $path) {
+ content
+ binary
+ byteSize
+ }
+ }
+ }
+ }
+ `,
+ parameters,
+ token
+ )
+ const content = contentResult?.data?.repository?.commit?.blob?.content
+ const isBinary = contentResult?.data?.repository?.commit?.blob?.binary
+ const byteSize = contentResult?.data?.repository?.commit?.blob?.byteSize
+ if (typeof content === 'string' && typeof isBinary === 'boolean' && typeof byteSize === 'number') {
+ return { content: new TextEncoder().encode(content), isBinary, byteSize }
+ }
+ return undefined
+}
+
+interface ContentParameters {
+ repository: string
+ revision: string
+ path: string
+}
+
+interface ContentResult {
+ data?: {
+ repository?: {
+ commit?: {
+ blob?: {
+ content?: string
+ binary?: boolean
+ byteSize?: number
+ }
+ }
+ }
+ }
+}
diff --git a/src/queries/currentUserQuery.ts b/src/queries/currentUserQuery.ts
new file mode 100644
index 00000000..120c94d7
--- /dev/null
+++ b/src/queries/currentUserQuery.ts
@@ -0,0 +1,25 @@
+import { emptyCancelationToken } from '../file-system/emptyCancelationToken'
+import { graphqlQueryWithAccessToken } from './graphqlQuery'
+
+export async function currentUserQuery(accessToken: string): Promise {
+ const result = await graphqlQueryWithAccessToken(
+ 'query { currentUser { username }}',
+ {},
+ emptyCancelationToken(),
+ accessToken
+ )
+ const username = result?.data?.currentUser?.username
+ if (username) {
+ return username
+ }
+ throw new Error(`invalid access token ${accessToken}`)
+}
+
+interface CurrentUserParameters {}
+interface CurrentUserResult {
+ data?: {
+ currentUser?: {
+ username?: string
+ }
+ }
+}
diff --git a/src/queries/definitionQuery.ts b/src/queries/definitionQuery.ts
new file mode 100644
index 00000000..cd0cda69
--- /dev/null
+++ b/src/queries/definitionQuery.ts
@@ -0,0 +1,73 @@
+import { PositionParameters } from './PositionParameters'
+import * as vscode from 'vscode'
+import gql from 'tagged-template-noop'
+import { graphqlQuery } from './graphqlQuery'
+import { LocationNode } from './LocationNode'
+
+export async function definitionQuery(
+ parameters: PositionParameters,
+ token: vscode.CancellationToken
+): Promise {
+ const definition = await graphqlQuery(
+ gql`
+ query Definition(
+ $repositoryName: String!
+ $revision: String!
+ $path: String!
+ $line: Int!
+ $character: Int!
+ ) {
+ repository(name: $repositoryName) {
+ commit(rev: $revision) {
+ blob(path: $path) {
+ lsif {
+ definitions(line: $line, character: $character) {
+ nodes {
+ resource {
+ path
+ repository {
+ name
+ }
+ commit {
+ oid
+ }
+ }
+ range {
+ start {
+ line
+ character
+ }
+ end {
+ line
+ character
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ `,
+ parameters,
+ token
+ )
+ return definition?.data?.repository?.commit?.blob?.lsif?.definitions?.nodes || []
+}
+
+interface DefinitionResult {
+ data: {
+ repository: {
+ commit: {
+ blob: {
+ lsif: {
+ definitions: {
+ nodes: LocationNode[]
+ }
+ }
+ }
+ }
+ }
+ }
+}
diff --git a/src/queries/filesQuery.ts b/src/queries/filesQuery.ts
new file mode 100644
index 00000000..b4a07faf
--- /dev/null
+++ b/src/queries/filesQuery.ts
@@ -0,0 +1,35 @@
+import * as vscode from 'vscode'
+import { graphqlQuery } from './graphqlQuery'
+import gql from 'tagged-template-noop'
+
+export async function filesQuery(parameters: FilesParameters, token: vscode.CancellationToken): Promise {
+ const result = await graphqlQuery(
+ gql`
+ query FileNames($repository: String!, $revision: String!) {
+ repository(name: $repository) {
+ commit(rev: $revision) {
+ fileNames
+ }
+ }
+ }
+ `,
+ parameters,
+ token
+ )
+ return result?.data?.repository?.commit?.fileNames || []
+}
+
+interface FilesParameters {
+ repository: string
+ revision: string
+}
+
+interface FilesResult {
+ data?: {
+ repository?: {
+ commit?: {
+ fileNames?: string[]
+ }
+ }
+ }
+}
diff --git a/src/queries/gitBlameQuery.ts b/src/queries/gitBlameQuery.ts
new file mode 100644
index 00000000..f1b03d46
--- /dev/null
+++ b/src/queries/gitBlameQuery.ts
@@ -0,0 +1,83 @@
+import * as vscode from 'vscode'
+import { graphqlQuery } from './graphqlQuery'
+import gql from 'tagged-template-noop'
+import { endpointGraphQLSchema } from '../settings/endpointSetting'
+
+export async function gitBlameQuery(
+ parameters: GitBlameParameters,
+ token: vscode.CancellationToken
+): Promise {
+ const response = await graphqlQuery(
+ gql`
+ query GitBlame($repositoryName: String!, $revision: String!, $filePath: String!) {
+ repository(name: $repositoryName) {
+ commit(rev: $revision) {
+ blob(path: $filePath) {
+ blame(startLine: 0, endLine: 0) {
+ ${(await endpointGraphQLSchema()).blameFilenameField}
+ startLine
+ endLine
+ author {
+ person {
+ email
+ displayName
+ avatarURL
+ user {
+ username
+ }
+ }
+ date
+ }
+ message
+ commit {
+ oid
+ abbreviatedOID
+ }
+ }
+ }
+ }
+ }
+ }
+ `,
+ parameters,
+ token
+ )
+ return response?.data?.repository?.commit?.blob?.blame || []
+}
+
+export interface GitBlame {
+ filename?: string // This field got added in the PR https://github.com/sourcegraph/sourcegraph/pull/25729
+ startLine: number
+ endLine: number
+ author?: {
+ person?: {
+ email?: string
+ displayName?: string
+ avatarURL?: string
+ }
+ date?: string
+ }
+ message?: string
+ commit?: {
+ oid?: string
+ abbreviatedOID?: string
+ }
+}
+
+export interface GitBlameParameters {
+ repositoryName: string
+ revision: string
+ filePath: string
+}
+
+export interface GitBlameResponse {
+ data?: {
+ repository?: {
+ commit?: {
+ blob?: {
+ blame?: GitBlame[]
+ }
+ }
+ }
+ }
+}
diff --git a/src/queries/gitReferencesQuery.ts b/src/queries/gitReferencesQuery.ts
new file mode 100644
index 00000000..b6c98e6a
--- /dev/null
+++ b/src/queries/gitReferencesQuery.ts
@@ -0,0 +1,86 @@
+import * as vscode from 'vscode'
+import { graphqlQuery } from './graphqlQuery'
+import gql from 'tagged-template-noop'
+
+export interface GitReference {
+ displayName: string
+ name: string
+ url: string
+ type: string
+}
+
+export async function gitReferencesQuery(
+ parameters: GitReferencesParameters,
+ token: vscode.CancellationToken
+): Promise {
+ const type = parameters.query.startsWith('branch:')
+ ? ', type: GIT_BRANCH'
+ : parameters.query.startsWith('tag:')
+ ? ', type: GIT_TAG'
+ : ''
+ if (parameters.query.startsWith('branch:')) {
+ parameters.query = parameters.query.slice('branch:'.length)
+ }
+ if (parameters.query.startsWith('tag:')) {
+ parameters.query = parameters.query.slice('tag:'.length)
+ }
+ const ancestoryQuery = /~(\d+)/
+ const ancestorSuffix = parameters.query.match(ancestoryQuery)?.[0]
+ parameters.query = parameters.query.replace(ancestoryQuery, '')
+ const response = await graphqlQuery(
+ gql`
+ query RepositoryGitRefs($repositoryId: ID!, $query: String) {
+ node(id: $repositoryId) {
+ __typename
+ ... on Repository {
+ gitRefs(first: 100, query: $query, orderBy: AUTHORED_OR_COMMITTED_AT${type}) {
+ __typename
+ ...GitRefConnectionFields
+ }
+ __typename
+ }
+ }
+ }
+
+ fragment GitRefConnectionFields on GitRefConnection {
+ nodes {
+ __typename
+ ...GitRefFields
+ }
+ }
+
+ fragment GitRefFields on GitRef {
+ displayName
+ name
+ url
+ type
+ }
+ `,
+ parameters,
+ token
+ )
+
+ const result = response?.data?.node?.gitRefs?.nodes || []
+ if (ancestorSuffix) {
+ for (const reference of result) {
+ reference.displayName = reference.displayName + ancestorSuffix
+ reference.name = reference.name + ancestorSuffix
+ reference.url = reference.url + ancestorSuffix
+ }
+ }
+ return result
+}
+
+interface GitReferencesParameters {
+ repositoryId: string
+ query: string
+}
+interface GitReferencesResult {
+ data?: {
+ node?: {
+ gitRefs?: {
+ nodes?: GitReference[]
+ }
+ }
+ }
+}
diff --git a/src/queries/graphqlQuery.ts b/src/queries/graphqlQuery.ts
new file mode 100644
index 00000000..b3c1ffd0
--- /dev/null
+++ b/src/queries/graphqlQuery.ts
@@ -0,0 +1,115 @@
+import { request, RequestOptions } from 'https'
+import { CancellationToken } from 'vscode'
+import { log } from '../log'
+import { debugEnabledSetting } from '../settings/debugEnabledSetting'
+import { endpointPortSetting, endpointHostnameSetting, endpointSetting } from '../settings/endpointSetting'
+import {
+ accessTokenSetting,
+ deleteAccessTokenSetting,
+ promptUserForAccessTokenSetting,
+} from '../settings/accessTokenSetting'
+import { version } from '../extension'
+
+export function graphqlQuery(query: string, variables: A, token: CancellationToken): Promise {
+ return graphqlQueryWithAccessToken(query, variables, token, accessTokenSetting())
+}
+
+export function graphqlQueryWithAccessToken(
+ query: string,
+ variables: A,
+ token: CancellationToken,
+ accessToken?: string
+): Promise {
+ if (accessToken) {
+ accessToken = accessToken.trim()
+ }
+ return new Promise((resolve, reject) => {
+ const data = JSON.stringify({
+ query,
+ variables,
+ })
+ const headers: any = {
+ 'Content-Length': data.length,
+ 'User-Agent': `VS Code/${version}`,
+ }
+ if (accessToken) {
+ headers.Authorization = `token ${accessToken}`
+ }
+ const options: RequestOptions = {
+ hostname: endpointHostnameSetting(),
+ port: endpointPortSetting(),
+ path: '/.api/graphql',
+ method: 'POST',
+ headers,
+ }
+ const curlCommand = (): string => {
+ const data: string = JSON.stringify({ query: query.replace(/\s+/g, ' '), variables })
+ const authorization = accessToken ? `-H 'Authorization: token ${accessToken}' ` : ''
+ return `curl ${authorization}-d '${data}' ${endpointSetting()}/.api/graphql`
+ }
+ const onReject = async (error: any) => {
+ if (error === 'Invalid access token.\n') {
+ // Prompt the user to update the access token setting and try again with the new setting.
+ try {
+ if (accessToken) {
+ await deleteAccessTokenSetting(accessToken)
+ }
+ const toFixThisProblem =
+ process.env.SRC_ACCESS_TOKEN === accessToken
+ ? '. To fix this problem, remove the environment variables SRC_ACCESS_TOKEN and reload VS Code.'
+ : ''
+ const newAccessToken = await promptUserForAccessTokenSetting(
+ 'Invalid Sourcegraph Access Token',
+ `The server at ${endpointHostnameSetting()} is unable to use the access token ${accessToken}.` +
+ toFixThisProblem
+ )
+ log.appendLine(`re-trying GraphQL query with new access token '${newAccessToken}'`)
+ const newResult = await graphqlQueryWithAccessToken(query, variables, token, newAccessToken)
+ resolve(newResult)
+ } catch (newError) {
+ log.error('failed to get valid access token', error)
+ reject(newError)
+ }
+ } else {
+ reject(error)
+ }
+ }
+ const req = request(options, res => {
+ const body: Uint8Array[] = []
+ res.on('data', json => {
+ body.push(json)
+ })
+ res.on('error', onReject)
+ const onClose = () => {
+ const json = Buffer.concat(body).toString()
+ if (res.statusCode === 200) {
+ try {
+ const parsed = JSON.parse(json)
+ const errors = parsed['errors']
+ if (errors) {
+ reject(JSON.stringify(errors))
+ }
+ resolve(parsed)
+ } catch (error) {
+ log.error(`graphql(${curlCommand()})`, error)
+ onReject(error)
+ }
+ } else {
+ log.error(`graphql(${curlCommand()}), statusCode=${res.statusCode}`, json)
+ onReject(json)
+ }
+ }
+ res.on('close', onClose)
+ res.on('end', onClose)
+ })
+ req.on('error', onReject)
+ req.write(data)
+ req.end()
+ if (debugEnabledSetting()) {
+ log.appendLine(curlCommand())
+ }
+ token.onCancellationRequested(() => {
+ req.destroy()
+ })
+ })
+}
diff --git a/src/queries/graphqlSchemaQuery.ts b/src/queries/graphqlSchemaQuery.ts
new file mode 100644
index 00000000..fee4c00e
--- /dev/null
+++ b/src/queries/graphqlSchemaQuery.ts
@@ -0,0 +1,54 @@
+import { graphqlQuery } from './graphqlQuery'
+import gql from 'tagged-template-noop'
+import { emptyCancelationToken } from '../file-system/emptyCancelationToken'
+// import { log } from '../log'
+// import { endpointHostnameSetting } from '../settings/endpointSetting'
+
+export class GraphQLSchema {
+ public readonly blameFilenameField: string
+ constructor(private readonly types: Map) {
+ const isBlameFilenameSupported = this.types.get('Hunk')?.includes('filename') || false
+ this.blameFilenameField = isBlameFilenameSupported ? 'filename\n' : ''
+ }
+ public static empty(): GraphQLSchema {
+ return new GraphQLSchema(new Map())
+ }
+}
+
+export async function graphqlSchemaQuery(): Promise {
+ const response = await graphqlQuery<{}, SchemaResponse>(
+ gql`
+ query {
+ __schema {
+ types {
+ name
+ fields {
+ name
+ }
+ }
+ }
+ }
+ `,
+ {},
+ emptyCancelationToken()
+ )
+ const result = new Map()
+ for (const type of response?.data?.__schema?.types || []) {
+ const fields = type.fields?.map(field => field.name) || []
+ result.set(type.name, fields)
+ }
+ return new GraphQLSchema(result)
+}
+
+interface SchemaResponse {
+ data?: {
+ __schema?: {
+ types: SchemaType[]
+ }
+ }
+}
+
+interface SchemaType {
+ name: string
+ fields?: { name: string }[]
+}
diff --git a/src/queries/hoverQuery.ts b/src/queries/hoverQuery.ts
new file mode 100644
index 00000000..f5e8ffd7
--- /dev/null
+++ b/src/queries/hoverQuery.ts
@@ -0,0 +1,61 @@
+import * as vscode from 'vscode'
+import { graphqlQuery } from './graphqlQuery'
+import { PositionParameters } from './PositionParameters'
+import gql from 'tagged-template-noop'
+
+export async function hoverQuery(
+ parameters: PositionParameters,
+ token: vscode.CancellationToken
+): Promise {
+ const response = await graphqlQuery(
+ gql`
+ query Hover($repositoryName: String!, $revision: String!, $path: String!, $line: Int!, $character: Int!) {
+ repository(name: $repositoryName) {
+ commit(rev: $revision) {
+ blob(path: $path) {
+ lsif {
+ hover(line: $line, character: $character) {
+ markdown {
+ text
+ }
+ range {
+ start {
+ line
+ character
+ }
+ end {
+ line
+ character
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ `,
+ parameters,
+ token
+ )
+ return response?.data?.repository?.commit?.blob?.lsif?.hover?.markdown?.text
+}
+
+interface HoverResult {
+ data?: {
+ repository?: {
+ commit?: {
+ blob?: {
+ lsif?: {
+ hover?: {
+ markdown?: {
+ text?: string
+ }
+ range?: Range
+ }
+ }
+ }
+ }
+ }
+ }
+}
diff --git a/src/queries/referencesQuery.ts b/src/queries/referencesQuery.ts
new file mode 100644
index 00000000..909789d7
--- /dev/null
+++ b/src/queries/referencesQuery.ts
@@ -0,0 +1,78 @@
+import * as vscode from 'vscode'
+import { graphqlQuery } from './graphqlQuery'
+import gql from 'tagged-template-noop'
+import { PositionParameters } from './PositionParameters'
+import { LocationNode } from './LocationNode'
+
+export async function referencesQuery(
+ parameters: PositionParameters,
+ token: vscode.CancellationToken
+): Promise {
+ const response = await graphqlQuery(
+ gql`
+ query References(
+ $repositoryName: String!
+ $revision: String!
+ $path: String!
+ $line: Int!
+ $character: Int!
+ $after: String
+ ) {
+ repository(name: $repositoryName) {
+ commit(rev: $revision) {
+ blob(path: $path) {
+ lsif {
+ references(line: $line, character: $character, after: $after) {
+ nodes {
+ resource {
+ path
+ repository {
+ name
+ }
+ commit {
+ oid
+ }
+ }
+ range {
+ start {
+ line
+ character
+ }
+ end {
+ line
+ character
+ }
+ }
+ }
+ pageInfo {
+ endCursor
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ `,
+
+ parameters,
+ token
+ )
+ return response?.data?.repository?.commit?.blob?.lsif?.references?.nodes || []
+}
+
+interface ReferencesResult {
+ data?: {
+ repository?: {
+ commit?: {
+ blob?: {
+ lsif?: {
+ references?: {
+ nodes?: LocationNode[]
+ }
+ }
+ }
+ }
+ }
+ }
+}
diff --git a/src/queries/repositoriesQuery.ts b/src/queries/repositoriesQuery.ts
new file mode 100644
index 00000000..b47ca4af
--- /dev/null
+++ b/src/queries/repositoriesQuery.ts
@@ -0,0 +1,46 @@
+import * as vscode from 'vscode'
+import { graphqlQuery } from './graphqlQuery'
+import gql from 'tagged-template-noop'
+
+export async function repositoriesQuery(query: string, token: vscode.CancellationToken): Promise {
+ const response = await graphqlQuery(
+ gql`
+ query RepositoriesForPopover($query: String, $first: Int) {
+ repositories(first: $first, query: $query) {
+ nodes {
+ name
+ isFork
+ }
+ totalCount
+ pageInfo {
+ hasNextPage
+ }
+ }
+ }
+ `,
+ {
+ query,
+ first: 10000,
+ },
+ token
+ )
+ return response?.data?.repositories?.nodes?.filter(node => !node.isFork).map(node => node.name) || []
+}
+
+interface RepositoryParameters {
+ query: string
+ first: number
+}
+
+interface RepositoryResult {
+ data?: {
+ repositories?: {
+ nodes?: RepositoryNode[]
+ }
+ }
+ first: number
+}
+interface RepositoryNode {
+ name: string
+ isFork: boolean
+}
diff --git a/src/queries/repositoryComparisonDiffQuery.ts b/src/queries/repositoryComparisonDiffQuery.ts
new file mode 100644
index 00000000..79a00b7b
--- /dev/null
+++ b/src/queries/repositoryComparisonDiffQuery.ts
@@ -0,0 +1,120 @@
+import * as vscode from 'vscode'
+import { graphqlQuery } from './graphqlQuery'
+import gql from 'tagged-template-noop'
+
+export interface RepositoryComparison {
+ files: FileDiffNode[]
+ commits: CommitNode[]
+}
+
+export async function repositoryComparisonDiffQuery(
+ parameters: RepositoryComparisonParameters,
+ token: vscode.CancellationToken
+): Promise {
+ const response = await graphqlQuery(
+ gql`
+ query RepositoryComparisonDiff(
+ $repositoryId: ID!
+ $base: String
+ $head: String
+ $first: Int
+ $after: String
+ ) {
+ node(id: $repositoryId) {
+ ... on Repository {
+ comparison(base: $base, head: $head) {
+ fileDiffs(first: $first, after: $after) {
+ nodes {
+ ...FileDiffFields
+ }
+ totalCount
+ diffStat {
+ ...DiffStatFields
+ }
+ }
+ commits(first: $first) {
+ nodes {
+ oid
+ abbreviatedOID
+ message
+ author {
+ person {
+ displayName
+ avatarURL
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+
+ fragment FileDiffFields on FileDiff {
+ oldPath
+ newPath
+ stat {
+ added
+ changed
+ deleted
+ }
+ }
+
+ fragment DiffStatFields on DiffStat {
+ added
+ changed
+ deleted
+ }
+ `,
+ parameters,
+ token
+ )
+ return {
+ files: response?.data?.node?.comparison?.fileDiffs?.nodes || [],
+ commits: response?.data?.node?.comparison?.commits?.nodes || [],
+ }
+}
+
+interface RepositoryComparisonResult {
+ data?: {
+ node?: {
+ comparison?: {
+ fileDiffs?: {
+ nodes?: FileDiffNode[]
+ }
+ commits?: {
+ nodes?: CommitNode[]
+ }
+ }
+ }
+ }
+}
+
+export interface CommitNode {
+ oid?: string
+ abbreviatedOID?: string
+ message?: string
+ author?: {
+ person?: {
+ displayName?: string
+ avatarURL?: string
+ }
+ }
+}
+
+export interface FileDiffNode {
+ oldPath?: string
+ newPath?: string
+ stat?: {
+ added?: number
+ changed?: number
+ deleted?: number
+ }
+}
+
+export interface RepositoryComparisonParameters {
+ repositoryId: string
+ base: string
+ head: string
+ first: number
+}
diff --git a/src/queries/repositoryMetadataQuery.ts b/src/queries/repositoryMetadataQuery.ts
new file mode 100644
index 00000000..84c93c78
--- /dev/null
+++ b/src/queries/repositoryMetadataQuery.ts
@@ -0,0 +1,76 @@
+import * as vscode from 'vscode'
+import { graphqlQuery } from './graphqlQuery'
+import gql from 'tagged-template-noop'
+
+export interface RepositoryMetadata {
+ defaultOid?: string
+ defaultAbbreviatedOid?: string
+ defaultBranch?: string
+ id?: string
+ commitToReferenceName?: Map
+}
+
+export async function repositoryMetadataQuery(
+ parameters: RevisionParameters,
+ token: vscode.CancellationToken
+): Promise {
+ const response = await graphqlQuery(
+ gql`
+ query RepositoryMetadata($repositoryName: String!) {
+ repositoryRedirect(name: $repositoryName) {
+ ... on Repository {
+ id
+ mirrorInfo {
+ cloneInProgress
+ cloneProgress
+ cloned
+ }
+ commit(rev: "") {
+ oid
+ abbreviatedOID
+ tree(path: "") {
+ url
+ }
+ }
+ defaultBranch {
+ abbrevName
+ }
+ }
+ ... on Redirect {
+ url
+ }
+ }
+ }
+ `,
+ parameters,
+ token
+ )
+ return {
+ id: response?.data?.repositoryRedirect?.id,
+ defaultOid: response?.data?.repositoryRedirect?.commit?.oid,
+ defaultAbbreviatedOid: response?.data?.repositoryRedirect?.commit?.abbreviatedOID,
+ defaultBranch: response?.data?.repositoryRedirect?.defaultBranch?.abbrevName,
+ }
+}
+
+interface RevisionParameters {
+ repositoryName: string
+}
+
+interface RevisionResult {
+ data?: {
+ repositoryRedirect?: {
+ id?: string
+ commit?: {
+ oid?: string
+ abbreviatedOID?: string
+ tree?: {
+ url?: string
+ }
+ }
+ defaultBranch?: {
+ abbrevName?: string
+ }
+ }
+ }
+}
diff --git a/src/queries/resolveRevisionQuery.ts b/src/queries/resolveRevisionQuery.ts
new file mode 100644
index 00000000..954a904a
--- /dev/null
+++ b/src/queries/resolveRevisionQuery.ts
@@ -0,0 +1,38 @@
+import * as vscode from 'vscode'
+import { graphqlQuery } from './graphqlQuery'
+import gql from 'tagged-template-noop'
+
+export async function resolveRevisionQuery(
+ parameters: ResolveRevisionParameters,
+ token: vscode.CancellationToken
+): Promise {
+ const result = await graphqlQuery(
+ gql`
+ query ResolveRevision($repositoryName: String!, $revision: String!) {
+ repository(name: $repositoryName) {
+ commit(rev: $revision) {
+ oid
+ }
+ }
+ }
+ `,
+ parameters,
+ token
+ )
+ return result?.data?.repository?.commit?.oid
+}
+
+export interface ResolveRevisionParameters {
+ repositoryName: string
+ revision: string
+}
+
+interface ResolveRevisionResponse {
+ data?: {
+ repository?: {
+ commit?: {
+ oid?: string
+ }
+ }
+ }
+}
diff --git a/src/queries/searchQuery.ts b/src/queries/searchQuery.ts
new file mode 100644
index 00000000..330cdbc1
--- /dev/null
+++ b/src/queries/searchQuery.ts
@@ -0,0 +1,178 @@
+import * as vscode from 'vscode'
+import { SearchPatternType } from '../search/scanner'
+import { graphqlQuery } from './graphqlQuery'
+import gql from 'tagged-template-noop'
+
+export function searchQueryResult(
+ query: string,
+ patternType: SearchPatternType,
+ token: vscode.CancellationToken
+): Promise {
+ return graphqlQuery(
+ gql`
+ query($query: String!) {
+ search(query: $query) {
+ results {
+ results {
+ __typename
+ ... on FileMatch {
+ ...FileMatchFields
+ }
+ ... on CommitSearchResult {
+ ...CommitSearchResultFields
+ }
+ ... on Repository {
+ ...RepositoryFields
+ }
+ }
+ ...SearchResultsAlertFields
+ }
+ }
+ }
+ fragment FileMatchFields on FileMatch {
+ repository {
+ name
+ url
+ }
+ file {
+ name
+ path
+ url
+ content
+ commit {
+ oid
+ }
+ }
+ lineMatches {
+ preview
+ lineNumber
+ offsetAndLengths
+ limitHit
+ }
+ }
+
+ fragment CommitSearchResultFields on CommitSearchResult {
+ commit {
+ message
+ author {
+ person {
+ name
+ }
+ }
+ }
+ matches {
+ url
+ body {
+ text
+ }
+ highlights {
+ character
+ line
+ length
+ }
+ }
+ }
+
+ fragment RepositoryFields on Repository {
+ name
+ stars
+ }
+
+ fragment SearchResultsAlertFields on SearchResults {
+ alert {
+ title
+ description
+ proposedQueries {
+ description
+ query
+ }
+ }
+ }
+ `,
+ { query },
+ token
+ )
+}
+
+export async function searchQuery(
+ host: string,
+ query: string,
+ patternType: SearchPatternType,
+ token: vscode.CancellationToken
+): Promise {
+ const result = await searchQueryResult(query, patternType, token)
+ const results: vscode.Location[] = []
+ const nodes = result?.data?.search?.results?.results
+ for (const node of nodes || []) {
+ const url = node?.file?.url
+ if (!url) {
+ continue
+ }
+ for (const lineMatch of node.lineMatches || []) {
+ const line = lineMatch.lineNumber
+ if (!line) {
+ continue
+ }
+ for (const offsetsAndLength of lineMatch.offsetAndLengths || []) {
+ const [character, length] = offsetsAndLength
+ const start = new vscode.Position(line, character)
+ const end = new vscode.Position(line, character + length)
+ results.push(
+ new vscode.Location(vscode.Uri.parse(`sourcegraph://${host}${url}`), new vscode.Range(start, end))
+ )
+ }
+ }
+ }
+ return results
+}
+
+export interface SearchParameters {
+ query: string
+}
+
+export interface SearchResult {
+ data?: {
+ search?: {
+ results?: {
+ results?: SearchResultNode[]
+ }
+ }
+ }
+}
+
+export interface SearchResultNode {
+ __typename: string
+ name?: string
+ stars?: number
+ file?: {
+ url?: string
+ }
+ repository?: {
+ stars?: number
+ }
+ lineMatches?: LineMatch[]
+ matches?: CommitMatch[]
+ commit?: {
+ message?: string
+ }
+}
+
+export interface LineMatch {
+ lineNumber?: number
+ offsetAndLengths?: [number, number][]
+ preview?: string
+}
+
+export interface CommitMatch {
+ url?: string
+ body?: {
+ text?: string
+ }
+ highlights?: CommitHighlight[]
+}
+
+export interface CommitHighlight {
+ character?: number
+ line?: number
+ length?: number
+}
diff --git a/src/queries/treeCommitsQuery.ts b/src/queries/treeCommitsQuery.ts
new file mode 100644
index 00000000..4175dcc8
--- /dev/null
+++ b/src/queries/treeCommitsQuery.ts
@@ -0,0 +1,60 @@
+import * as vscode from 'vscode'
+import { graphqlQuery } from './graphqlQuery'
+import gql from 'tagged-template-noop'
+import { log } from '../log'
+
+export async function treeCommitsQuery(
+ parameters: TreeCommitsParameters,
+ token: vscode.CancellationToken
+): Promise {
+ const response = await graphqlQuery(
+ gql`
+ query TreeCommits($repositoryId: ID!, $revision: String!, $filePath: String, $first: Int) {
+ node(id: $repositoryId) {
+ ... on Repository {
+ commit(rev: $revision) {
+ ancestors(first: $first, path: $filePath) {
+ nodes {
+ ...GitCommitFields
+ }
+ }
+ }
+ }
+ }
+ }
+
+ fragment GitCommitFields on GitCommit {
+ oid
+ }
+ `,
+ parameters,
+ token
+ )
+
+ const result = response?.data?.node?.commit?.ancestors?.nodes?.flatMap(node => (node.oid ? [node.oid] : [])) || []
+ log.appendLine(`TREE_COMMITS ${JSON.stringify(result)}`)
+ return result
+}
+
+export interface TreeCommitsParameters {
+ repositoryId: string
+ revision: string
+ filePath: string
+ first: number
+}
+
+interface TreeCommitsResult {
+ data?: {
+ node?: {
+ commit?: {
+ ancestors?: {
+ nodes?: TreeCommitNode[]
+ }
+ }
+ }
+ }
+}
+
+interface TreeCommitNode {
+ oid?: string
+}
diff --git a/src/search/MarkdownFile.test.ts b/src/search/MarkdownFile.test.ts
new file mode 100644
index 00000000..c511bcbb
--- /dev/null
+++ b/src/search/MarkdownFile.test.ts
@@ -0,0 +1,36 @@
+import assert from 'assert'
+import { MarkdownFile } from './MarkdownFile'
+
+function checkRoundtrip(name: string, input: string) {
+ it(name, () => {
+ const original = input.replace(/'''/g, '```')
+ const file = MarkdownFile.parseContent(original)
+ const obtained = file.renderAsString()
+ assert.deepStrictEqual(obtained, original)
+ })
+}
+
+describe('MarkdownFile', () => {
+ checkRoundtrip(
+ 'basic',
+ `This is markdown
+'''sourcegraph
+lang:go Indexer
+'''
+This is after
+'''go
+const x = 42
+'''
+`
+ )
+
+ checkRoundtrip(
+ 'no-closing-backticks',
+ `This is markdown
+'''sourcegraph
+lang:go Indexer
+
+Hello
+`
+ )
+})
diff --git a/src/search/MarkdownFile.ts b/src/search/MarkdownFile.ts
new file mode 100644
index 00000000..78a780cd
--- /dev/null
+++ b/src/search/MarkdownFile.ts
@@ -0,0 +1,74 @@
+export class MarkdownFile {
+ public static parseContent(content: string): MarkdownFile {
+ return new MarkdownFile(parseMarkdownParts(content))
+ }
+ constructor(public readonly parts: MarkdownPart[]) {}
+ public renderAsString(): string {
+ const lines: string[] = []
+ for (const part of this.parts) {
+ if (part.startBackticks) {
+ lines.push(part.startBackticks)
+ }
+ lines.push(part.value)
+ if (part.endBackticks) {
+ lines.push(part.endBackticks)
+ }
+ }
+ return lines.join('\n')
+ }
+}
+
+function parseMarkdownParts(content: string): MarkdownPart[] {
+ const lines = content.split(/\r?\n/g)
+ const result: MarkdownPart[] = []
+ let index = 0
+ let markupBuffer: string[] = []
+ const flushMarkupBuffer = (): void => {
+ if (markupBuffer.length > 0) {
+ result.push(new MarkdownPart(MarkdownPartKind.Markup, markupBuffer.join('\n')))
+ markupBuffer = []
+ }
+ }
+ while (index < lines.length) {
+ const line = lines[index]
+ if (line.startsWith('```sourcegraph')) {
+ flushMarkupBuffer()
+ index += 1
+ const query: string[] = []
+ let isEmittedPart = false
+ while (index < lines.length) {
+ const queryLine = lines[index]
+ if (queryLine.startsWith('```')) {
+ result.push(new MarkdownPart(MarkdownPartKind.CodeFence, query.join('\n'), line, queryLine))
+ isEmittedPart = true
+ break
+ } else {
+ query.push(queryLine)
+ index += 1
+ }
+ }
+ if (!isEmittedPart) {
+ result.push(new MarkdownPart(MarkdownPartKind.CodeFence, query.join('\n'), line))
+ }
+ } else {
+ markupBuffer.push(line)
+ }
+ index += 1
+ }
+ flushMarkupBuffer()
+ return result
+}
+
+export enum MarkdownPartKind {
+ Markup = 1,
+ CodeFence = 2,
+}
+
+export class MarkdownPart {
+ constructor(
+ public readonly kind: MarkdownPartKind,
+ public readonly value: string,
+ public readonly startBackticks?: string,
+ public readonly endBackticks?: string
+ ) {}
+}
diff --git a/src/search/SourcegraphCompletionItemProvider.ts b/src/search/SourcegraphCompletionItemProvider.ts
new file mode 100644
index 00000000..546e8384
--- /dev/null
+++ b/src/search/SourcegraphCompletionItemProvider.ts
@@ -0,0 +1,20 @@
+import * as vscode from 'vscode'
+import { getCompletionItems } from './completion'
+import { scanSearchQuery, SearchPatternType } from './scanner'
+
+export class SourcegraphCompletionItemProvider implements vscode.CompletionItemProvider {
+ public provideCompletionItems(
+ document: vscode.TextDocument,
+ position: vscode.Position,
+ // eslint-disable-next-line @typescript-eslint/no-unused-vars
+ _token: vscode.CancellationToken,
+ // eslint-disable-next-line @typescript-eslint/no-unused-vars
+ _context: vscode.CompletionContext
+ ): vscode.CompletionList | null {
+ const scanned = scanSearchQuery(document.getText(), true, SearchPatternType.literal)
+ if (scanned.type === 'success') {
+ return getCompletionItems(scanned.term, position, true, true)
+ }
+ return null
+ }
+}
diff --git a/src/search/SourcegraphLocationRenderer.js b/src/search/SourcegraphLocationRenderer.js
new file mode 100644
index 00000000..79cb91dc
--- /dev/null
+++ b/src/search/SourcegraphLocationRenderer.js
@@ -0,0 +1,27 @@
+/**
+ * Renders the 'application/sourcegraph-location' MIME type for Sourcegraph Notebooks
+ *
+ * This file is intentionally written in JavaScript (not TypeScript) so that it
+ * can be used un-processed (no compilation) by the VS Code Notebook renderer API.
+ *
+ * @see https://code.visualstudio.com/api/extension-guides/notebook#notebook-renderer
+ * @param {vscode-notebook-renderer.RendererContext} context
+ * @returns {vscode-notebook-renderer.RendererApi}
+ */
+export const activate = context => ({
+ renderOutputItem(data /* vscode-notebook-renderer.OutputItem */, element /* HTMLElement */) {
+ if (!context.postMessage) {
+ return
+ }
+ element.innerHTML = data.json().html
+ const elements = document.querySelectorAll(`.sourcegraph-location`)
+ for (const element of elements) {
+ element.addEventListener('click', () => {
+ context.postMessage({
+ request: 'openEditor',
+ uri: element.id,
+ })
+ })
+ }
+ },
+})
diff --git a/src/search/SourcegraphNotebookSerializer.ts b/src/search/SourcegraphNotebookSerializer.ts
new file mode 100644
index 00000000..4831042c
--- /dev/null
+++ b/src/search/SourcegraphNotebookSerializer.ts
@@ -0,0 +1,138 @@
+import { TextDecoder, TextEncoder } from 'util'
+import * as vscode from 'vscode'
+import { log } from '../log'
+import { openSourcegraphUriCommand } from '../commands/openSourcegraphUriCommand'
+import { searchHtml } from './searchHtml'
+import { SearchPatternType } from './scanner'
+import { MarkdownPart, MarkdownPartKind, MarkdownFile } from './MarkdownFile'
+import { SourcegraphUri } from '../file-system/SourcegraphUri'
+import { SourcegraphFileSystemProvider } from '../file-system/SourcegraphFileSystemProvider'
+import { endpointHostnameSetting } from '../settings/endpointSetting'
+
+export class SourcegraphNotebookSerializer implements vscode.NotebookSerializer {
+ private readonly decoder = new TextDecoder()
+ private readonly encoder = new TextEncoder()
+ private readonly messageChannel = vscode.notebooks.createRendererMessaging('sourcegraph-location-renderer')
+ private order = 0
+
+ constructor(fs: SourcegraphFileSystemProvider) {
+ const controller = vscode.notebooks.createNotebookController(
+ 'sourcegraph-notebook-controller-id',
+ 'sourcegraph-notebook',
+ 'Sourcegraph Notebook'
+ )
+ controller.supportedLanguages = ['sourcegraph']
+ controller.supportsExecutionOrder = true
+ controller.executeHandler = (cells, notebook, controller) => this.executeNotebook(cells, notebook, controller)
+ this.messageChannel.onDidReceiveMessage(async event => {
+ const uriString: unknown = event.message?.uri
+ if (event.message?.request === 'openEditor' && typeof uriString === 'string') {
+ let uri = SourcegraphUri.parse(uriString)
+ if (uri.isCommit()) {
+ log.debug({ uri: uri.uri })
+ return
+ }
+ if (!uri.path) {
+ uri = await fs.defaultFileUri(uri.repositoryName)
+ }
+ if (!uri.revision) {
+ uri = uri.withRevision((await fs.repositoryMetadata(uri.repositoryName))?.defaultBranch)
+ }
+ await openSourcegraphUriCommand(fs, uri)
+ } else if (event.message?.request === 'logMessage' && typeof event.message?.message === 'string') {
+ log.appendLine(event.message.message)
+ }
+ })
+ }
+
+ public async executeNotebook(
+ cells: vscode.NotebookCell[],
+ _notebook: vscode.NotebookDocument,
+ controller: vscode.NotebookController
+ ): Promise {
+ for (const cell of cells) {
+ const execution = controller.createNotebookCellExecution(cell)
+ execution.token.onCancellationRequested(() => {
+ log.appendLine(`cancelled execution ${cell.index}`)
+ execution.end(false)
+ })
+ execution.executionOrder = ++this.order
+ try {
+ execution.start(Date.now())
+ const html = await searchHtml(
+ endpointHostnameSetting(),
+ cell.document.getText(),
+ SearchPatternType.literal,
+ execution.token
+ )
+ await execution.replaceOutput(
+ new vscode.NotebookCellOutput([
+ new vscode.NotebookCellOutputItem(
+ new TextEncoder().encode(
+ JSON.stringify({
+ html,
+ })
+ ),
+ 'application/sourcegraph-location'
+ ),
+ ])
+ )
+ execution.end(true, Date.now())
+ } catch (error) {
+ const message = error instanceof Error ? error.message : JSON.stringify(error)
+ await execution.replaceOutput(
+ new vscode.NotebookCellOutput([vscode.NotebookCellOutputItem.text(`ERROR: ${message}`)])
+ )
+ execution.end(false, Date.now())
+ }
+ }
+ }
+
+ public deserializeNotebook(
+ data: Uint8Array,
+ // eslint-disable-next-line @typescript-eslint/no-unused-vars
+ _token: vscode.CancellationToken
+ ): vscode.NotebookData {
+ const content = this.decoder.decode(data)
+ const file = MarkdownFile.parseContent(content)
+ const cells: vscode.NotebookCellData[] = []
+ for (const part of file.parts) {
+ cells.push({
+ kind:
+ part.kind === MarkdownPartKind.Markup
+ ? vscode.NotebookCellKind.Markup
+ : vscode.NotebookCellKind.Code,
+ languageId: part.kind === MarkdownPartKind.Markup ? 'markdown' : 'sourcegraph',
+ metadata: {
+ startBackticks: part.startBackticks,
+ endBackticks: part.endBackticks,
+ },
+ value: part.value,
+ })
+ }
+ return { cells }
+ }
+
+ public serializeNotebook(
+ data: vscode.NotebookData,
+ // eslint-disable-next-line @typescript-eslint/no-unused-vars
+ _token: vscode.CancellationToken
+ ): Uint8Array {
+ const parts: MarkdownPart[] = []
+ for (const cell of data.cells) {
+ if (cell.kind === vscode.NotebookCellKind.Code) {
+ parts.push(
+ new MarkdownPart(
+ MarkdownPartKind.CodeFence,
+ cell.value,
+ cell.metadata?.startBackticks || '```sourcegraph',
+ cell.metadata?.endBackticks || '```'
+ )
+ )
+ } else if (cell.kind === vscode.NotebookCellKind.Markup) {
+ parts.push(new MarkdownPart(MarkdownPartKind.Markup, cell.value))
+ }
+ }
+ return this.encoder.encode(new MarkdownFile(parts).renderAsString())
+ }
+}
diff --git a/src/search/SourcegraphSemanticTokenProvider.ts b/src/search/SourcegraphSemanticTokenProvider.ts
new file mode 100644
index 00000000..c9786921
--- /dev/null
+++ b/src/search/SourcegraphSemanticTokenProvider.ts
@@ -0,0 +1,90 @@
+import * as vscode from 'vscode'
+import { scanSearchQuery, SearchPatternType } from './scanner'
+import { decorate, DecoratedToken } from './decoratedToken'
+
+export class SourcegraphSemanticTokenProvider
+ implements vscode.DocumentSemanticTokensProvider, vscode.SemanticTokensLegend {
+ public tokenTypes: string[] = [
+ 'namespace',
+ 'class',
+ 'enum',
+ 'interface',
+ 'struct',
+ 'typeParameter',
+ 'type',
+ 'parameter',
+ 'variable',
+ 'property',
+ 'enumMember',
+ 'event',
+ 'function',
+ 'method',
+ 'macro',
+ 'label',
+ 'comment',
+ 'string',
+ 'keyword',
+ 'number',
+ 'regexp',
+ 'operator',
+ ]
+ public tokenModifiers: string[] = []
+ public onDidChangeSemanticTokens?: vscode.Event | undefined
+ public provideDocumentSemanticTokens(
+ document: vscode.TextDocument,
+ // eslint-disable-next-line @typescript-eslint/no-unused-vars
+ token: vscode.CancellationToken
+ ): vscode.SemanticTokens {
+ const builder = new vscode.SemanticTokensBuilder(this)
+ const lines = document.getText().split(/\r?\n/g)
+ const patternType = SearchPatternType.regexp
+ const interpretComments = true
+ for (const [line, text] of lines.entries()) {
+ const result = scanSearchQuery(text, interpretComments, patternType)
+ if (result.type === 'success') {
+ for (const token of result.term) {
+ for (const decoratedToken of decorate(token)) {
+ const start = new vscode.Position(line, decoratedToken.range.start)
+ const end = new vscode.Position(line, decoratedToken.range.end)
+ const range = new vscode.Range(start, end)
+ const type = sourcegraphDecoratedTokenTypeToSemanticTokenType(decoratedToken)
+ if (type) {
+ builder.push(range, type)
+ }
+ }
+ }
+ }
+ }
+ return builder.build()
+ }
+}
+
+function sourcegraphDecoratedTokenTypeToSemanticTokenType(token: DecoratedToken): string {
+ switch (token.type) {
+ case 'closingParen':
+ case 'openingParen':
+ return 'namespace'
+ case 'comment':
+ return 'comment'
+ case 'field':
+ return 'property'
+ case 'filter':
+ return 'class'
+ case 'keyword':
+ return 'keyword'
+ case 'literal':
+ return 'number'
+ case 'metaPath':
+ return 'regexp'
+ case 'metaContextPrefix':
+ case 'metaPredicate':
+ case 'metaRegexp':
+ case 'metaRepoRevisionSeparator':
+ case 'metaRevision':
+ return 'interface'
+ case 'pattern':
+ return ''
+ default:
+ return ''
+ }
+}
diff --git a/src/search/completion.ts b/src/search/completion.ts
new file mode 100644
index 00000000..74ff1dcb
--- /dev/null
+++ b/src/search/completion.ts
@@ -0,0 +1,145 @@
+// This source file is copy-pasted and adjusted from the sourcegraph/sourcegraph repo
+// https://sourcegraph.com/github.com/sourcegraph/sourcegraph@7ce0484274d7382f4b9b2898d77c3987e51fffa6/-/blob/client/shared/src/search/query/completion.ts?L4
+import * as vscode from 'vscode'
+
+import { FilterType, isNegatableFilter, resolveFilter, FILTERS } from './filters'
+import { Filter, Token } from './token'
+
+export const repositoryCompletionItemKind = vscode.CompletionItemKind.Color
+const filterCompletionItemKind = vscode.CompletionItemKind.Issue
+
+const FILTER_TYPE_COMPLETIONS: Omit[] = Object.keys(FILTERS)
+ .flatMap(label => {
+ const filterType = label as FilterType
+ const completionItem: Omit = {
+ label,
+ kind: filterCompletionItemKind,
+ insertText: `${label}:`,
+ filterText: label,
+ }
+ if (isNegatableFilter(filterType)) {
+ return [
+ {
+ ...completionItem,
+ detail: FILTERS[filterType].description(false),
+ },
+ {
+ ...completionItem,
+ label: `-${label}`,
+ insertText: `-${label}:`,
+ filterText: `-${label}`,
+ detail: FILTERS[filterType].description(true),
+ },
+ ]
+ }
+ return [
+ {
+ ...completionItem,
+ detail: FILTERS[filterType].description,
+ },
+ ]
+ })
+ // Set a sortText so that filter type suggestions
+ // are shown before dynamic suggestions.
+ .map((completionItem, index) => ({
+ ...completionItem,
+ sortText: `0${index}`,
+ }))
+
+const completeStart = (): vscode.CompletionList => ({
+ items: FILTER_TYPE_COMPLETIONS.map(
+ (suggestion): vscode.CompletionItem => ({
+ ...suggestion,
+ })
+ ),
+})
+
+function completeDefault(
+ token: Token,
+ // eslint-disable-next-line @typescript-eslint/no-unused-vars
+ _globbing: boolean
+): vscode.CompletionList {
+ // Offer autocompletion of filter values
+ const staticSuggestions = FILTER_TYPE_COMPLETIONS.map(
+ (suggestion): vscode.CompletionItem => ({
+ ...suggestion,
+ })
+ )
+ // If the token being typed matches a known filter,
+ // only return static filter type suggestions.
+ // This avoids blocking on dynamic suggestions to display
+ // the suggestions widget.
+ if (
+ token.type === 'pattern' &&
+ staticSuggestions.some(({ label }) => typeof label === 'string' && label.startsWith(token.value.toLowerCase()))
+ ) {
+ return { items: staticSuggestions }
+ }
+
+ return { items: staticSuggestions }
+}
+
+function completeFilter(
+ token: Filter,
+ column: number,
+ globbing: boolean,
+ isSourcegraphDotCom?: boolean
+): vscode.CompletionList | null {
+ const { value } = token
+ const completingValue = !value || value.range.start + 1 <= column
+ if (!completingValue) {
+ return null
+ }
+ const resolvedFilter = resolveFilter(token.field.value)
+ if (!resolvedFilter) {
+ return null
+ }
+ let staticSuggestions: vscode.CompletionItem[] = []
+ if (resolvedFilter.definition.discreteValues) {
+ staticSuggestions = resolvedFilter.definition.discreteValues(token.value, isSourcegraphDotCom).map(
+ ({ label, insertText }, index): vscode.CompletionItem => ({
+ label,
+ sortText: index.toString().padStart(2, '1'), // suggestions sort by order in the list, not alphabetically (up to 99 values).
+ kind: vscode.CompletionItemKind.Value,
+ insertText: `${insertText || label} `,
+ filterText: label,
+ })
+ )
+ }
+ if (isSourcegraphDotCom === true && (value === undefined || (value.type === 'literal' && value.value === ''))) {
+ // On Sourcegraph.com, prompt only static suggestions if there is no value to use for generating dynamic suggestions yet.
+ return { items: staticSuggestions }
+ }
+ return { items: staticSuggestions }
+}
+
+/**
+ * Returns the completion items for a search query being typed in the Monaco query input,
+ * including both static and dynamically fetched suggestions.
+ */
+export function getCompletionItems(
+ tokens: Token[],
+ { character }: Pick,
+ globbing: boolean,
+ isSourcegraphDotCom?: boolean
+): vscode.CompletionList | null {
+ character += 1
+ if (character === 1) {
+ // Show all filter suggestions on the first column.
+ return completeStart()
+ }
+ const tokenAtColumn = tokens.find(({ range }) => range.start + 1 <= character && range.end + 1 >= character)
+ if (!tokenAtColumn) {
+ throw new Error('getCompletionItems: no token at character')
+ }
+ const token = tokenAtColumn
+ // When the token at column is labeled as a pattern or whitespace, and none of filter,
+ // operator, nor quoted value, show static filter type suggestions, followed by dynamic suggestions.
+ if (token.type === 'pattern' || token.type === 'whitespace') {
+ return completeDefault(token, globbing)
+ }
+ if (token.type === 'filter') {
+ return completeFilter(token, character, globbing, isSourcegraphDotCom)
+ }
+ return null
+}
diff --git a/src/search/decoratedToken.ts b/src/search/decoratedToken.ts
new file mode 100644
index 00000000..c4ac9dd4
--- /dev/null
+++ b/src/search/decoratedToken.ts
@@ -0,0 +1,1049 @@
+// This source file is copy-pasted and adjusted from the sourcegraph/sourcegraph repo
+// https://sourcegraph.com/github.com/sourcegraph/sourcegraph@7ce0484274d7382f4b9b2898d77c3987e51fffa6/-/blob/client/shared/src/search/query/decoratedToken.ts
+import { RegExpParser, visitRegExpAST } from 'regexpp'
+import {
+ Alternative,
+ Assertion,
+ CapturingGroup,
+ Character,
+ CharacterClass,
+ CharacterClassRange,
+ CharacterSet,
+ Group,
+ Quantifier,
+} from 'regexpp/ast'
+
+import { Predicate, scanPredicate } from './predicates'
+import { scanSearchQuery, SearchPatternType } from './scanner'
+import { Token, Pattern, Literal, PatternKind, CharacterRange, createLiteral } from './token'
+
+/* eslint-disable unicorn/better-regex */
+
+/**
+ * A DecoratedToken is a type of token used for syntax highlighting, hovers, and diagnostics. All
+ * standard Token types are compatible where DecoratedTokens are used. A DecoratedToken extends
+ * the definition of standard tokens to language-specific metasyntax tokens, like .* in regexp,
+ * or :[holes] in structural search.
+ */
+export type DecoratedToken = Token | MetaToken
+
+/**
+ * A MetaToken defines a token that is associated with some language-specific metasyntax.
+ */
+export type MetaToken =
+ | MetaRegexp
+ | MetaStructural
+ | MetaField
+ | MetaRepoRevisionSeparator
+ | MetaRevision
+ | MetaContextPrefix
+ | MetaSelector
+ | MetaPath
+ | MetaPredicate
+
+/**
+ * Defines common properties for meta tokens.
+ */
+export interface BaseMetaToken {
+ type: MetaToken['type']
+ range: CharacterRange
+ value: string
+}
+
+/**
+ * A token that is labeled and interpreted as regular expression syntax.
+ */
+export interface MetaRegexp extends BaseMetaToken {
+ type: 'metaRegexp'
+ groupRange?: CharacterRange
+ kind: MetaRegexpKind
+}
+
+/**
+ * Classifications of the kinds of regexp metasyntax.
+ */
+export enum MetaRegexpKind {
+ Assertion = 'Assertion', // like ^ or \b
+ Alternative = 'Alternative', // like |
+ Delimited = 'Delimited', // like ( or )
+ EscapedCharacter = 'EscapedCharacter', // like \(
+ CharacterSet = 'CharacterSet', // like \s
+ CharacterClass = 'CharacterClass', // like [a-z]
+ CharacterClassRange = 'CharacterClassRange', // the a-z part in [a-z]
+ CharacterClassRangeHyphen = 'CharacterClassRangeHyphen', // the - part in [a-z]
+ CharacterClassMember = 'CharacterClassMember', // a character inside a charcter class like [abcd]
+ LazyQuantifier = 'LazyQuantifier', // the ? after a range quantifier
+ RangeQuantifier = 'RangeQuantifier', // like +
+}
+
+/**
+ * A token that is labeled and interpreted as structural search syntax.
+ */
+export interface MetaStructural extends BaseMetaToken {
+ type: 'metaStructural'
+ groupRange?: CharacterRange
+ kind: MetaStructuralKind
+}
+
+/**
+ * Classifications of the kinds of structural metasyntax.
+ */
+export enum MetaStructuralKind {
+ Hole = 'Hole',
+ RegexpHole = 'RegexpHole',
+ Variable = 'Variable',
+ RegexpSeparator = 'RegexpSeparator',
+}
+
+/**
+ * A token that is labeled and interpreted as a field, like "repo:" in the Sourcegraph language syntax.
+ */
+export interface MetaField extends BaseMetaToken {
+ type: 'field'
+}
+
+/**
+ * A token that is labeled and interpreted as repository revision syntax in Sourcegraph. Note: there
+ * are syntactic differences from pure Git ref syntax.
+ * See https://docs.sourcegraph.com/code_search/reference/queries#repository-revisions.
+ */
+export interface MetaRevision extends BaseMetaToken {
+ type: 'metaRevision'
+ kind: MetaRevisionKind
+}
+
+export type MetaRevisionKind = MetaGitRevision | MetaSourcegraphRevision
+
+/**
+ * A custom revision syntax that is only valid in Sourcegraph search queries.
+ */
+export enum MetaSourcegraphRevision {
+ Separator = 'Separator', // a ':' that separates revision patterns
+ IncludeGlobMarker = 'IncludeGlobMarker', // a '*' at the beginning of a revision pattern to mark it as an "include" glob pattern.
+ ExcludeGlobMarker = 'ExcludeGlobMarker', // a '*!' at the beginning of a revision pattern to mark it as an "exclude" glob pattern.
+}
+
+/**
+ * Revision syntax that correspond to git glob pattern syntax, git refs (e.g., branches), or git objects (e.g., commits, tags).
+ */
+export enum MetaGitRevision {
+ CommitHash = 'CommitHash', // a commit hash
+ Label = 'Label', // a catch-all string that refers to a git object or ref, like a branch name or tag
+ ReferencePath = 'ReferencePath', // the part of a revision that refers to a git reference path, like refs/heads/ part in refs/heads/*
+ Wildcard = 'Wildcard', // a '*' in glob syntax
+}
+
+/**
+ * A token that denotes a revision separator in the Sourcegraph query language. I.e., the '@' in
+ * "repo:^foo$@revision" syntax.
+ */
+export interface MetaRepoRevisionSeparator extends BaseMetaToken {
+ type: 'metaRepoRevisionSeparator'
+}
+
+/**
+ * A token that denotes the context prefix in a search context value (the '@' in "context:@user").
+ */
+export interface MetaContextPrefix extends BaseMetaToken {
+ type: 'metaContextPrefix'
+}
+
+export interface MetaSelector extends BaseMetaToken {
+ type: 'metaSelector'
+ kind: MetaSelectorKind
+}
+
+export enum MetaSelectorKind {
+ Repo = 'repo',
+ File = 'file',
+ Content = 'content',
+ Symbol = 'symbol',
+ Commit = 'commit',
+}
+
+export enum MetaPathKind {
+ Separator = 'Separator',
+}
+
+/**
+ * Tokens that are meaningful in path patterns, like
+ * path separators / or wildcards *.
+ */
+export interface MetaPath {
+ type: 'metaPath'
+ range: CharacterRange
+ kind: MetaPathKind
+ value: string
+}
+
+export enum MetaPredicateKind {
+ NameAccess = 'NameAccess',
+ Dot = 'Dot',
+ Parenthesis = 'Parenthesis',
+}
+
+/**
+ * Predicate members for decoration.
+ */
+export interface MetaPredicate {
+ type: 'metaPredicate'
+ range: CharacterRange
+ groupRange?: CharacterRange
+ kind: MetaPredicateKind
+ value: Predicate
+}
+
+/**
+ * Coalesces consecutive pattern tokens. Used, for example, when parsing
+ * literal characters like 'f', 'o', 'o' in regular expressions, which are
+ * coalesced to 'foo' for hovers.
+ */
+const coalescePatterns = (tokens: DecoratedToken[]): DecoratedToken[] => {
+ let previous: Pattern | undefined
+ const newTokens: DecoratedToken[] = []
+ for (const token of tokens) {
+ if (token.type === 'pattern') {
+ if (previous === undefined) {
+ previous = token
+ continue
+ }
+ // Merge with previous
+ previous.value = previous.value + token.value
+ previous.range = { start: previous.range.start, end: token.range.end }
+ continue
+ }
+ if (previous) {
+ newTokens.push(previous)
+ previous = undefined
+ }
+ newTokens.push(token)
+ }
+ if (previous) {
+ newTokens.push(previous)
+ }
+ return newTokens
+}
+
+const mapRegexpMeta = (pattern: Pattern): DecoratedToken[] | undefined => {
+ const tokens: DecoratedToken[] = []
+ try {
+ const ast = new RegExpParser().parsePattern(pattern.value)
+ const offset = pattern.range.start
+ visitRegExpAST(ast, {
+ onAlternativeEnter(node: Alternative) {
+ // regexpp doesn't tell us where a '|' operator is. We infer it by visiting any
+ // pattern of an Alternative node, and for a '|' directly after it. Based on
+ // regexpp's implementation, we know this is a true '|' operator, and _not_ an
+ // escaped \| or part of a character class like [abcd|].
+ if (pattern.value[node.end] && pattern.value[node.end] === '|') {
+ tokens.push({
+ type: 'metaRegexp',
+ range: { start: offset + node.end, end: offset + node.end + 1 },
+ value: '|',
+ kind: MetaRegexpKind.Alternative,
+ })
+ }
+ },
+ onAssertionEnter(node: Assertion) {
+ tokens.push({
+ type: 'metaRegexp',
+ range: { start: offset + node.start, end: offset + node.end },
+ value: node.raw,
+ kind: MetaRegexpKind.Assertion,
+ })
+ },
+ onGroupEnter(node: Group) {
+ // Push the leading '('
+ tokens.push({
+ type: 'metaRegexp',
+ range: { start: offset + node.start, end: offset + node.start + 1 },
+ value: '(',
+ kind: MetaRegexpKind.Delimited,
+ })
+ // Push the trailing ')'
+ tokens.push({
+ type: 'metaRegexp',
+ range: { start: offset + node.end - 1, end: offset + node.end },
+ value: ')',
+ kind: MetaRegexpKind.Delimited,
+ })
+ },
+ onCapturingGroupEnter(node: CapturingGroup) {
+ // Push the leading '('
+ tokens.push({
+ type: 'metaRegexp',
+ range: { start: offset + node.start, end: offset + node.start + 1 },
+ groupRange: { start: offset + node.start, end: offset + node.end },
+ value: '(',
+ kind: MetaRegexpKind.Delimited,
+ })
+ // Push the trailing ')'
+ tokens.push({
+ type: 'metaRegexp',
+ range: { start: offset + node.end - 1, end: offset + node.end },
+ groupRange: { start: offset + node.start, end: offset + node.end },
+ value: ')',
+ kind: MetaRegexpKind.Delimited,
+ })
+ },
+ onCharacterSetEnter(node: CharacterSet) {
+ tokens.push({
+ type: 'metaRegexp',
+ range: { start: offset + node.start, end: offset + node.end },
+ value: node.raw,
+ kind: MetaRegexpKind.CharacterSet,
+ })
+ },
+ onCharacterClassEnter(node: CharacterClass) {
+ const negatedOffset = node.negate ? 1 : 0
+ // Push the leading '['
+ tokens.push({
+ type: 'metaRegexp',
+ range: { start: offset + node.start, end: offset + node.start + 1 + negatedOffset },
+ groupRange: { start: offset + node.start, end: offset + node.end },
+ value: node.negate ? '[^' : '[',
+ kind: MetaRegexpKind.CharacterClass,
+ })
+ // Push the trailing ']'
+ tokens.push({
+ type: 'metaRegexp',
+ range: { start: offset + node.end - 1, end: offset + node.end },
+ groupRange: { start: offset + node.start, end: offset + node.end },
+ value: ']',
+ kind: MetaRegexpKind.CharacterClass,
+ })
+ },
+ onCharacterClassRangeEnter(node: CharacterClassRange) {
+ // Push the min and max characters of the range to associate them with the
+ // same groupRange for hovers.
+ tokens.push(
+ {
+ type: 'metaRegexp',
+ range: { start: offset + node.min.start, end: offset + node.min.end },
+ groupRange: { start: offset + node.start, end: offset + node.end },
+ value: node.raw,
+ kind: MetaRegexpKind.CharacterClassRange,
+ },
+ // Highlight the '-' in [a-z]. Take care to use node.min.end, because we
+ // don't want to highlight the first '-' in [--z], nor an escaped '-' with a
+ // two-character offset as in [\--z].
+ {
+ type: 'metaRegexp',
+ range: { start: offset + node.min.end, end: offset + node.min.end + 1 },
+ groupRange: { start: offset + node.start, end: offset + node.end },
+ value: node.raw,
+ kind: MetaRegexpKind.CharacterClassRangeHyphen,
+ },
+ {
+ type: 'metaRegexp',
+ range: { start: offset + node.max.start, end: offset + node.max.end },
+ groupRange: { start: offset + node.start, end: offset + node.end },
+ value: node.raw,
+ kind: MetaRegexpKind.CharacterClassRange,
+ }
+ )
+ },
+ onQuantifierEnter(node: Quantifier) {
+ // the lazy quantifier ? adds one
+ const lazyQuantifierOffset = node.greedy ? 0 : 1
+ if (!node.greedy) {
+ tokens.push({
+ type: 'metaRegexp',
+ range: { start: offset + node.end - 1, end: offset + node.end },
+ value: '?',
+ kind: MetaRegexpKind.LazyQuantifier,
+ })
+ }
+
+ const quantifier = node.raw[node.raw.length - lazyQuantifierOffset - 1]
+ if (quantifier === '+' || quantifier === '*' || quantifier === '?') {
+ tokens.push({
+ type: 'metaRegexp',
+ range: {
+ start: offset + node.end - 1 - lazyQuantifierOffset,
+ end: offset + node.end - lazyQuantifierOffset,
+ },
+ value: quantifier,
+ kind: MetaRegexpKind.RangeQuantifier,
+ })
+ } else {
+ // regexpp provides no easy way to tell whether the quantifier is a range '{number, number}',
+ // nor the offsets of this range.
+ // At this point we know it is none of +, *, or ?, so it is a ranged quantifier.
+ // We need to then find the opening brace of {number, number}, and go backwards from the end
+ // of this quantifier to avoid dealing with other leading braces that are not part of it.
+ let openBrace = node.end - 1 - lazyQuantifierOffset
+ while (pattern.value[openBrace] && pattern.value[openBrace] !== '{') {
+ openBrace = openBrace - 1
+ }
+ tokens.push({
+ type: 'metaRegexp',
+ range: { start: offset + openBrace, end: offset + node.end - lazyQuantifierOffset },
+ value: pattern.value.slice(openBrace, node.end - lazyQuantifierOffset),
+ kind: MetaRegexpKind.RangeQuantifier,
+ })
+ }
+ },
+ onCharacterEnter(node: Character) {
+ if (node.end - node.start > 1 && node.raw.startsWith('\\')) {
+ // This is an escaped value like `\.`, `\u0065`, `\x65`.
+ // If this escaped value is part of a range, like [a-\\],
+ // set the group range to associate it with hovers.
+ const groupRange =
+ node.parent.type === 'CharacterClassRange'
+ ? { start: offset + node.parent.start, end: offset + node.parent.end }
+ : undefined
+ tokens.push({
+ type: 'metaRegexp',
+ range: { start: offset + node.start, end: offset + node.end },
+ groupRange,
+ value: node.raw,
+ kind: MetaRegexpKind.EscapedCharacter,
+ })
+ return
+ }
+ if (node.parent.type === 'CharacterClassRange') {
+ return // This unescaped character is handled by onCharacterClassRangeEnter.
+ }
+ if (node.parent.type === 'CharacterClass') {
+ // This character is inside a character class like [abcd] and is contextually special for hover tooltips.
+ tokens.push({
+ type: 'metaRegexp',
+ range: { start: offset + node.start, end: offset + node.end },
+ value: node.raw,
+ kind: MetaRegexpKind.CharacterClassMember,
+ })
+ return
+ }
+ tokens.push({
+ type: 'pattern',
+ range: { start: offset + node.start, end: offset + node.end },
+ value: node.raw,
+ kind: PatternKind.Regexp,
+ })
+ },
+ })
+ } catch {
+ return undefined
+ }
+ // The AST is not necessarily traversed in increasing range. We need
+ // to sort by increasing range because the ordering is significant to Monaco.
+ tokens.sort((left, right) => left.range.start - right.range.start)
+ return coalescePatterns(tokens)
+}
+
+/**
+ * Returns true for filter values that have path-like values, i.e., values that typically
+ * contain path separators like `/`.
+ */
+export const hasPathLikeValue = (field: string): boolean => {
+ const fieldName = field.startsWith('-') ? field.slice(1) : field
+ switch (fieldName.toLocaleLowerCase()) {
+ case 'repo':
+ case 'r':
+ case 'file':
+ case 'f':
+ case 'repohasfile':
+ return true
+ default:
+ return false
+ }
+}
+
+// Tokenize a literal value like "^foo/bar/baz$" by a path separator '/'.
+const mapPathMeta = (token: Literal): DecoratedToken[] => {
+ const tokens: DecoratedToken[] = []
+ const offset = token.range.start
+ let start = 0
+ let current = 0
+ while (token.value[current]) {
+ if (token.value[current] === '\\') {
+ current = current + 2 // Continue past escaped value.
+ continue
+ }
+ if (token.value[current] === '/') {
+ tokens.push(
+ createLiteral(token.value.slice(start, current), { start: offset + start, end: offset + current - 1 })
+ )
+ tokens.push({
+ type: 'metaPath',
+ range: { start: offset + current, end: offset + current + 1 },
+ kind: MetaPathKind.Separator,
+ value: '/',
+ })
+ current = current + 1
+ start = current
+ continue
+ }
+ current = current + 1
+ }
+ // Push last token.
+ tokens.push(createLiteral(token.value.slice(start, current), { start: offset + start, end: offset + current }))
+ return tokens
+}
+
+/**
+ * Tries to parse a pattern into decorated regexp tokens.
+ * It always succeeds, even if regexp fails to parse.
+ */
+const mapRegexpMetaSucceed = (token: Pattern): DecoratedToken[] => mapRegexpMeta(token) || [token]
+
+const toPattern = (token: Literal): Pattern => ({
+ type: 'pattern',
+ kind: PatternKind.Regexp,
+ value: token.value,
+ range: token.range,
+})
+
+/**
+ * Tries to convert all literal tokens in a list of tokens to regular expression tokens.
+ * If any tokens fail to parse, the result is undefined.
+ */
+const tryMapLiteralsToRegexp = (tokens: DecoratedToken[]): DecoratedToken[] | undefined => {
+ const decorated: DecoratedToken[] = []
+ for (const token of tokens) {
+ if (token.type === 'literal') {
+ const parsedRegexp = mapRegexpMeta(toPattern(token))
+ if (!parsedRegexp) {
+ return undefined
+ }
+ decorated.push(...parsedRegexp)
+ continue
+ }
+ decorated.push(token)
+ }
+ return decorated
+}
+
+/**
+ * A helper function for converting path-like regexp values like ^github.com/foo$ to
+ * tokens that highlight regexp metasyntax and path separator syntax. It always succeeds,
+ * even if regexp fails to parse.
+ */
+const mapPathMetaForRegexp = (token: Literal): DecoratedToken[] => {
+ const patterns = tryMapLiteralsToRegexp(mapPathMeta(token))
+ if (!patterns) {
+ return mapRegexpMetaSucceed(toPattern(token))
+ }
+ return patterns
+}
+
+const mapRevisionMeta = (token: Literal): DecoratedToken[] => {
+ const offset = token.range.start
+
+ const decorated: DecoratedToken[] = []
+ let current = ''
+ let start = 0
+ let accumulator: string[] = []
+
+ const nextChar = (): string => {
+ current = token.value[start]
+ start = start + 1
+ return current
+ }
+
+ // Appends a decorated token to the list of tokens, and resets the current accumulator to be empty.
+ const appendDecoratedToken = (endIndex: number, kind?: MetaRevisionKind): void => {
+ const value = accumulator.join('')
+ if (kind === undefined) {
+ if (value.includes('refs/')) {
+ kind = MetaGitRevision.ReferencePath
+ } else if (value.match(/^[\dA-Fa-f]+$/) && value.length > 6) {
+ kind = MetaGitRevision.CommitHash
+ } else {
+ kind = MetaGitRevision.Label
+ }
+ }
+ const range = { start: offset + endIndex - value.length, end: offset + endIndex }
+ decorated.push({ type: 'metaRevision', kind, value, range })
+ accumulator = []
+ }
+
+ // Return true when we're at the beginning of a revision: at the beginning of the string,
+ // or when the preceding character is a ':' revision separator.
+ const atRevision = (index: number): boolean =>
+ index === 0 || (token.value[index - 1] !== null && token.value[index - 1] === ':')
+
+ while (token.value[start] !== undefined) {
+ current = nextChar()
+ switch (current) {
+ case '*': {
+ appendDecoratedToken(start - 1) // Push the running revision string up to this special syntax.
+ if (atRevision(start - 1) && token.value[start] !== '!') {
+ // Demarcates that this is an "include" glob pattern that follows.
+ accumulator.push(current)
+ appendDecoratedToken(start, MetaSourcegraphRevision.IncludeGlobMarker)
+ } else if (atRevision(start - 1) && token.value[start] === '!') {
+ // Demarcates that this is an "exclude" glob pattern that follows.
+ current = nextChar() // Consume the '!'
+ accumulator.push('*!')
+ appendDecoratedToken(start, MetaSourcegraphRevision.ExcludeGlobMarker)
+ } else {
+ accumulator.push(current)
+ appendDecoratedToken(start, MetaGitRevision.Wildcard)
+ }
+ break
+ }
+ case ':':
+ appendDecoratedToken(start - 1)
+ accumulator.push(current)
+ appendDecoratedToken(start, MetaSourcegraphRevision.Separator)
+ break
+ default:
+ accumulator.push(current)
+ }
+ }
+ appendDecoratedToken(start)
+ return decorated
+}
+
+const mapStructuralMeta = (pattern: Pattern): DecoratedToken[] => {
+ const offset = pattern.range.start
+
+ const decorated: DecoratedToken[] = []
+ let current = ''
+ let start = 0
+ let token: string[] = []
+
+ // Track context of whether we are inside an opening hole, e.g., after
+ // ':['. Value is greater than 1 when inside.
+ let open = 0
+ // Track whether we are balanced inside a regular expression character
+ // set like '[a]' inside an open hole, e.g., :[foo~[a]]. Value is greater
+ // than 1 when inside.
+ let inside = 0
+
+ const nextChar = (): string => {
+ current = pattern.value[start]
+ start = start + 1
+ return current
+ }
+
+ // Appends a decorated token to the list of tokens, and resets the current token to be empty.
+ const appendDecoratedToken = (endIndex: number, kind: PatternKind.Literal | MetaStructuralKind.Hole): void => {
+ const value = token.join('')
+ const range = { start: offset + endIndex - value.length, end: offset + endIndex }
+ if (kind === PatternKind.Literal) {
+ decorated.push({ type: 'pattern', kind, value, range })
+ } else if (value.match(/^:\[(\w*)~(.*)\]$/)) {
+ // Handle regexp hole.
+ const [, variable, pattern] = value.match(/^:\[(\w*)~(.*)\]$/)!
+ const variableStart = range.start + 2 /* :[ */
+ const variableRange = { start: variableStart, end: variableStart + variable.length }
+ const patternStart = variableRange.end + 1 /* ~ */
+ const patternRange = { start: patternStart, end: patternStart + pattern.length }
+ decorated.push(
+ ...([
+ {
+ type: 'metaStructural',
+ kind: MetaStructuralKind.RegexpHole,
+ range: { start: range.start, end: variableStart },
+ groupRange: range,
+ value: ':[',
+ },
+ {
+ type: 'metaStructural',
+ kind: MetaStructuralKind.Variable,
+ range: variableRange,
+ value: variable,
+ },
+ {
+ type: 'metaStructural',
+ kind: MetaStructuralKind.RegexpSeparator,
+ range: { start: variableRange.end, end: variableRange.end + 1 },
+ value: '~',
+ },
+ ...mapRegexpMetaSucceed({
+ type: 'pattern',
+ kind: PatternKind.Regexp,
+ range: patternRange,
+ value: pattern,
+ }),
+ {
+ type: 'metaStructural',
+ kind: MetaStructuralKind.RegexpHole,
+ range: { start: patternRange.end, end: patternRange.end + 1 },
+ groupRange: range,
+ value: ']',
+ },
+ ] as DecoratedToken[])
+ )
+ } else {
+ decorated.push({ type: 'metaStructural', kind, value, range })
+ }
+ token = []
+ }
+
+ while (pattern.value[start] !== undefined) {
+ current = nextChar()
+ switch (current) {
+ case '.':
+ // Look ahead and see if this is a ... hole alias.
+ if (pattern.value.slice(start, start + 2) === '..') {
+ // It is a ... hole.
+ if (token.length > 0) {
+ // Append the value before this '...'.
+ appendDecoratedToken(start - 1, PatternKind.Literal)
+ }
+ start = start + 2
+ // Append the value of '...' after advancing.
+ token.push('...')
+ appendDecoratedToken(start, MetaStructuralKind.Hole)
+ continue
+ }
+ token.push('.')
+ break
+ case ':':
+ if (open > 0) {
+ // ':' inside a hole, likely part of a regexp pattern.
+ token.push(':')
+ continue
+ }
+ if (pattern.value[start] !== undefined) {
+ // Look ahead and see if this is the start of a hole.
+ if (pattern.value[start] === '[') {
+ // It is the start of a hole, consume the '['.
+ current = nextChar()
+ open = open + 1
+ // Persist the literal token scanned up to this point.
+ appendDecoratedToken(start - 2, PatternKind.Literal)
+ token.push(':[')
+ continue
+ }
+ // Something else, push the ':' we saw and continue.
+ token.push(':')
+ continue
+ }
+ // Trailing ':'.
+ token.push(current)
+ break
+ case '\\':
+ if (pattern.value[start] !== undefined && open > 0) {
+ // Assume this is an escape sequence inside a regexp hole.
+ current = nextChar()
+ token.push('\\', current)
+ continue
+ }
+ token.push('\\')
+ break
+ case '[':
+ if (open > 0) {
+ // Assume this is a character set inside a regexp hole.
+ inside = inside + 1
+ token.push('[')
+ continue
+ }
+ token.push('[')
+ break
+ case ']':
+ if (open > 0 && inside > 0) {
+ // This ']' closes a regular expression inside a hole.
+ inside = inside - 1
+ token.push(current)
+ continue
+ }
+ if (open > 0) {
+ // This ']' closes a hole.
+ open = open - 1
+ token.push(']')
+ appendDecoratedToken(start, MetaStructuralKind.Hole)
+ continue
+ }
+ token.push(current)
+ break
+ default:
+ token.push(current)
+ }
+ }
+ if (token.length > 0) {
+ // Append any left over literal at the end.
+ appendDecoratedToken(start, PatternKind.Literal)
+ }
+ return decorated
+}
+
+/**
+ * Returns true for filter values that have regexp values, e.g., repo, file.
+ * Excludes FilterType.content because that depends on the pattern kind.
+ */
+export const hasRegexpValue = (field: string): boolean => {
+ const fieldName = field.startsWith('-') ? field.slice(1) : field
+ switch (fieldName.toLocaleLowerCase()) {
+ case 'repo':
+ case 'r':
+ case 'file':
+ case 'f':
+ case 'repohasfile':
+ case 'message':
+ case 'msg':
+ case 'm':
+ case 'commiter':
+ case 'author':
+ return true
+ default:
+ return false
+ }
+}
+
+const specifiesRevision = (value: string): boolean => value.match(/@/) !== null
+
+const decorateRepoRevision = (token: Literal): DecoratedToken[] => {
+ const [repo, revision] = token.value.split('@', 2)
+ const offset = token.range.start
+
+ return [
+ ...mapPathMetaForRegexp(createLiteral(repo, { start: offset, end: offset + repo.length })),
+ {
+ type: 'metaRepoRevisionSeparator',
+ value: '@',
+ range: {
+ start: offset + repo.length,
+ end: offset + repo.length + 1,
+ },
+ },
+ ...mapRevisionMeta(
+ createLiteral(revision, {
+ start: token.range.start + repo.length + 1,
+ end: token.range.start + repo.length + 1 + revision.length,
+ })
+ ),
+ ]
+}
+
+const decorateContext = (token: Literal): DecoratedToken[] => {
+ if (!token.value.startsWith('@')) {
+ return [token]
+ }
+
+ const { start, end } = token.range
+ return [
+ { type: 'metaContextPrefix', range: { start, end: start + 1 }, value: '@' },
+ createLiteral(token.value.slice(1), { start: start + 1, end }),
+ ]
+}
+
+const decorateSelector = (token: Literal): DecoratedToken[] => {
+ const kind = token.value as MetaSelectorKind
+ if (!kind) {
+ return [token]
+ }
+ return [{ type: 'metaSelector', range: token.range, value: token.value, kind }]
+}
+
+/**
+ * Adds offset to the range of a given token and returns that token.
+ * Note that the offset change is side-effecting.
+ */
+const mapOffset = (token: Token, offset: number): Token => {
+ switch (token.type) {
+ case 'filter':
+ token.range = { start: token.range.start + offset, end: token.range.end + offset }
+ token.field.range = token.range = {
+ start: token.field.range.start + offset,
+ end: token.field.range.end + offset,
+ }
+ if (token.value) {
+ token.value.range = token.range = {
+ start: token.value.range.start + offset,
+ end: token.value.range.end + offset,
+ }
+ }
+ default:
+ token.range = { start: token.range.start + offset, end: token.range.end + offset }
+ }
+ return token
+}
+
+/**
+ * Returns true if a `contains(...)` predicate is valid. This predicate is currently valid when one of
+ * `file:` or `content:` is specified, or both. Any additional filters or tokens besides whitespace
+ * makes this body invalid.
+ */
+const validContainsBody = (tokens: Token[]): boolean => {
+ const fileIndex = tokens.findIndex(token => token.type === 'filter' && token.field.value === 'file')
+ if (fileIndex !== -1) {
+ tokens.splice(fileIndex, 1)
+ }
+ const contentIndex = tokens.findIndex(token => token.type === 'filter' && token.field.value === 'content')
+ if (contentIndex !== -1) {
+ tokens.splice(contentIndex, 1)
+ }
+ if (tokens.filter(value => value.type !== 'whitespace').length > 0) {
+ return false
+ }
+ return true
+}
+
+/**
+ * Attempts to decorate `contains(file:foo content:bar)` syntax. Fails if
+ * the body contains unsupported syntax. This function takes care to
+ * decorate `content:` values as regular expression syntax.
+ */
+const decorateContainsBody = (body: string, offset: number): DecoratedToken[] | undefined => {
+ const result = scanSearchQuery(body, false, SearchPatternType.regexp)
+ if (result.type === 'error') {
+ return undefined
+ }
+ if (!validContainsBody([...result.term])) {
+ // There are more things in this query than we support.
+ return undefined
+ }
+ const decorated: DecoratedToken[] = []
+ for (const token of result.term) {
+ if (token.type === 'filter' && token.field.value === 'file') {
+ decorated.push(...decorate(mapOffset(token, offset)))
+ }
+ if (token.type === 'filter' && token.field.value === 'content') {
+ decorated.push(
+ {
+ type: 'field',
+ value: token.field.value,
+ range: {
+ start: token.field.range.start + offset,
+ end: token.field.range.end + offset,
+ },
+ },
+ ...(token.value
+ ? token.value.quoted
+ ? [mapOffset(token.value, offset)]
+ : mapRegexpMetaSucceed(toPattern(mapOffset(token.value, offset) as Literal))
+ : [])
+ )
+ }
+ decorated.push(mapOffset(token, offset))
+ }
+ return decorated
+}
+
+/**
+ * Decorates the body part of predicate syntax `name(body)`.
+ */
+const decoratePredicateBody = (path: string[], body: string, offset: number): DecoratedToken[] => {
+ const decorated: DecoratedToken[] = []
+ switch (path.join('.')) {
+ case 'contains':
+ // eslint-disable-next-line no-case-declarations
+ const result = decorateContainsBody(body, offset)
+ if (result !== undefined) {
+ return result
+ }
+ break
+ case 'contains.file':
+ case 'contains.content':
+ return mapRegexpMetaSucceed({
+ type: 'pattern',
+ range: { start: offset, end: body.length },
+ value: body,
+ kind: PatternKind.Regexp,
+ })
+ }
+ decorated.push({
+ type: 'literal',
+ value: body,
+ range: { start: offset, end: offset + body.length },
+ quoted: false,
+ })
+ return decorated
+}
+
+const decoratePredicate = (predicate: Predicate, range: CharacterRange): DecoratedToken[] => {
+ let offset = range.start
+ const decorated: DecoratedToken[] = []
+ for (const nameAccess of predicate.path) {
+ decorated.push({
+ type: 'metaPredicate',
+ kind: MetaPredicateKind.NameAccess,
+ range: { start: offset, end: offset + nameAccess.length },
+ groupRange: range,
+ value: predicate,
+ })
+ offset = offset + nameAccess.length
+ decorated.push({
+ type: 'metaPredicate',
+ kind: MetaPredicateKind.Dot,
+ range: { start: offset, end: offset + 1 },
+ groupRange: range,
+ value: predicate,
+ })
+ offset = offset + 1
+ }
+ decorated.pop() // Pop trailling '.'
+ offset = offset - 1 // Backtrack offset
+ const body = predicate.parameters.slice(1, -1)
+ decorated.push({
+ type: 'metaPredicate',
+ kind: MetaPredicateKind.Parenthesis,
+ range: { start: offset, end: offset + 1 },
+ groupRange: range,
+ value: predicate,
+ })
+ offset = offset + 1
+ decorated.push(...decoratePredicateBody(predicate.path, body, offset))
+ offset = offset + body.length
+ decorated.push({
+ type: 'metaPredicate',
+ kind: MetaPredicateKind.Parenthesis,
+ range: { start: offset, end: offset + 1 },
+ groupRange: range,
+ value: predicate,
+ })
+ return decorated
+}
+
+export const decorate = (token: Token): DecoratedToken[] => {
+ const decorated: DecoratedToken[] = []
+ switch (token.type) {
+ case 'pattern':
+ switch (token.kind) {
+ case PatternKind.Regexp:
+ decorated.push(...mapRegexpMetaSucceed(token))
+ break
+ case PatternKind.Structural:
+ decorated.push(...mapStructuralMeta(token))
+ break
+ case PatternKind.Literal:
+ decorated.push(token)
+ break
+ }
+ break
+ case 'filter': {
+ decorated.push({
+ type: 'field',
+ range: token.field.range,
+ value: token.field.value,
+ })
+ const predicate = scanPredicate(token.field.value, token.value?.value || '')
+ if (predicate && token.value) {
+ decorated.push(...decoratePredicate(predicate, token.value.range))
+ break
+ }
+ if (
+ token.value &&
+ token.field.value.toLowerCase().match(/^-?(repo|r)$/i) &&
+ !token.value.quoted &&
+ specifiesRevision(token.value.value)
+ ) {
+ decorated.push(...decorateRepoRevision(token.value))
+ } else if (token.value && token.field.value.toLowerCase().match(/rev|revision/i) && !token.value.quoted) {
+ decorated.push(...mapRevisionMeta(createLiteral(token.value.value, token.value.range)))
+ } else if (token.value && !token.value.quoted && hasRegexpValue(token.field.value)) {
+ // Highlight fields with regexp values.
+ if (hasPathLikeValue(token.field.value) && token.value?.type === 'literal') {
+ decorated.push(...mapPathMetaForRegexp(token.value))
+ } else {
+ decorated.push(...mapRegexpMetaSucceed(toPattern(token.value)))
+ }
+ } else if (token.field.value === 'context' && token.value && !token.value.quoted) {
+ decorated.push(...decorateContext(token.value))
+ } else if (token.field.value === 'select' && token.value && !token.value.quoted) {
+ decorated.push(...decorateSelector(token.value))
+ } else if (token.value) {
+ decorated.push(token.value)
+ }
+ break
+ }
+ default:
+ decorated.push(token)
+ }
+ return decorated
+}
diff --git a/src/search/filters.ts b/src/search/filters.ts
new file mode 100644
index 00000000..4a37d98f
--- /dev/null
+++ b/src/search/filters.ts
@@ -0,0 +1,463 @@
+// This source file is copy-pasted and adjusted from the sourcegraph/sourcegraph repo
+// https://sourcegraph.com/github.com/sourcegraph/sourcegraph@7ce0484274d7382f4b9b2898d77c3987e51fffa6/-/blob/client/shared/src/search/query/filters.ts
+import { languageCompletion } from './languageFilter'
+import { predicateCompletion } from './predicates'
+import { selectorCompletion } from './selectFilter'
+import { Filter, Literal } from './token'
+
+export enum FilterType {
+ after = 'after',
+ archived = 'archived',
+ author = 'author',
+ before = 'before',
+ case = 'case',
+ committer = 'committer',
+ content = 'content',
+ context = 'context',
+ count = 'count',
+ file = 'file',
+ fork = 'fork',
+ lang = 'lang',
+ message = 'message',
+ patterntype = 'patterntype',
+ repo = 'repo',
+ repogroup = 'repogroup',
+ repohascommitafter = 'repohascommitafter',
+ repohasfile = 'repohasfile',
+ // eslint-disable-next-line unicorn/prevent-abbreviations
+ rev = 'rev',
+ select = 'select',
+ timeout = 'timeout',
+ type = 'type',
+ visibility = 'visibility',
+}
+
+/* eslint-disable unicorn/prevent-abbreviations */
+export enum AliasedFilterType {
+ f = 'file',
+ g = 'repogroup',
+ l = 'lang',
+ language = 'lang',
+ m = 'message',
+ msg = 'message',
+ r = 'repo',
+ revision = 'rev',
+ since = 'after',
+ until = 'before',
+}
+/* eslint-enable unicorn/prevent-abbreviations */
+
+export const ALIASES: Record = {
+ r: 'repo',
+ g: 'repogroup',
+ f: 'file',
+ l: 'lang',
+ language: 'language',
+ since: 'after',
+ until: 'before',
+ m: 'message',
+ msg: 'message',
+ revision: 'rev',
+}
+
+export const resolveFieldAlias = (field: string): string => ALIASES[field] || field
+
+export const isFilterType = (filter: string): filter is FilterType => filter in FilterType
+export const isAliasedFilterType = (filter: string): boolean => filter in AliasedFilterType
+
+export const filterTypeKeys: FilterType[] = Object.keys(FilterType) as FilterType[]
+export const filterTypeKeysWithAliases: (FilterType | AliasedFilterType)[] = [
+ ...filterTypeKeys,
+ ...Object.keys(AliasedFilterType),
+] as (FilterType | AliasedFilterType)[]
+
+export enum NegatedFilters {
+ author = '-author',
+ committer = '-committer',
+ content = '-content',
+ f = '-f',
+ file = '-file',
+ l = '-l',
+ lang = '-lang',
+ message = '-message',
+ r = '-r',
+ repo = '-repo',
+ repohasfile = '-repohasfile',
+}
+
+/** The list of filters that are able to be negated. */
+export type NegatableFilter =
+ | FilterType.repo
+ | FilterType.file
+ | FilterType.repohasfile
+ | FilterType.lang
+ | FilterType.content
+ | FilterType.committer
+ | FilterType.author
+ | FilterType.message
+
+export const isNegatableFilter = (filter: FilterType): filter is NegatableFilter =>
+ Object.keys(NegatedFilters).includes(filter)
+
+/** The list of all negated filters. i.e. all valid filters that have `-` as a suffix. */
+export const negatedFilters = Object.values(NegatedFilters)
+
+export const isNegatedFilter = (filter: string): filter is NegatedFilters =>
+ negatedFilters.includes(filter as NegatedFilters)
+
+const negatedFilterToNegatableFilter: { [key: string]: NegatableFilter } = {
+ '-author': FilterType.author,
+ '-committer': FilterType.committer,
+ '-content': FilterType.content,
+ '-f': FilterType.file,
+ '-file': FilterType.file,
+ '-l': FilterType.lang,
+ '-lang': FilterType.lang,
+ '-message': FilterType.message,
+ '-r': FilterType.repo,
+ '-repo': FilterType.repo,
+ '-repohasfile': FilterType.repohasfile,
+}
+
+export const resolveNegatedFilter = (filter: NegatedFilters): NegatableFilter => negatedFilterToNegatableFilter[filter]
+
+/**
+ * Completion values generated by filters. By default
+ * the completion value is `label`, unless `insertText`
+ * is specified, which overrides the default completion
+ * value. If asSnippet is set, the insertText will be
+ * treated as a snippet for completion.
+ */
+export interface Completion {
+ label: string
+ insertText?: string
+ asSnippet?: boolean
+}
+
+interface BaseFilterDefinition {
+ alias?: string
+ description: string
+ discreteValues?: (value: Literal | undefined, isSourcegraphDotCom?: boolean) => Completion[]
+ default?: string
+ /** Whether the filter may only be used 0 or 1 times in a query. */
+ singular?: boolean
+}
+
+interface NegatableFilterDefinition extends Omit {
+ negatable: true
+ description: (negated: boolean) => string
+}
+
+export type FilterDefinition = BaseFilterDefinition | NegatableFilterDefinition
+
+const SOURCEGRAPH_DOT_COM_REPO_COMPLETION: Completion[] = [
+ {
+ label: 'Search a GitHub organization',
+ // eslint-disable-next-line no-template-curly-in-string
+ insertText: '^github\\.com/${1:ORGANIZATION}/.*',
+ asSnippet: true,
+ },
+ {
+ label: 'Search a single GitHub repository',
+ // eslint-disable-next-line no-template-curly-in-string
+ insertText: '^github\\.com/${1:ORGANIZATION}/${2:REPO-NAME}$',
+ asSnippet: true,
+ },
+ {
+ label: 'Search for repositories with fuzzy string search',
+ // eslint-disable-next-line no-template-curly-in-string
+ insertText: '${1:STRING}',
+ asSnippet: true,
+ },
+]
+
+export const FILTERS: Record &
+ Record, BaseFilterDefinition> = {
+ [FilterType.after]: {
+ alias: 'since',
+ description: 'Commits made after a certain date',
+ },
+ [FilterType.archived]: {
+ description: 'Include results from archived repositories.',
+ singular: true,
+ },
+ [FilterType.author]: {
+ negatable: true,
+ description: negated => `${negated ? 'Exclude' : 'Include only'} commits or diffs authored by a user.`,
+ },
+ [FilterType.before]: {
+ alias: 'unitl',
+ description: 'Commits made before a certain date',
+ },
+ [FilterType.case]: {
+ description: 'Treat the search pattern as case-sensitive.',
+ discreteValues: () => ['yes', 'no'].map(value => ({ label: value })),
+ default: 'no',
+ singular: true,
+ },
+ [FilterType.committer]: {
+ description: (negated: boolean): string =>
+ `${negated ? 'Exclude' : 'Include only'} commits and diffs committed by a user.`,
+ negatable: true,
+ singular: true,
+ },
+ [FilterType.content]: {
+ description: (negated: boolean): string =>
+ `${negated ? 'Exclude' : 'Include only'} results from files if their content matches the search pattern.`,
+ negatable: true,
+ singular: true,
+ },
+ [FilterType.context]: {
+ description: 'Search only repositories within a specified context',
+ singular: true,
+ },
+ [FilterType.count]: {
+ description: 'Number of results to fetch (integer) or "all"',
+ singular: true,
+ },
+ [FilterType.file]: {
+ alias: 'f',
+ negatable: true,
+ description: negated =>
+ `${negated ? 'Exclude' : 'Include only'} results from files matching the given search pattern.`,
+ },
+ [FilterType.fork]: {
+ discreteValues: () => ['yes', 'no', 'only'].map(value => ({ label: value })),
+ description: 'Include results from forked repositories.',
+ singular: true,
+ },
+ [FilterType.lang]: {
+ alias: 'l',
+ discreteValues: value => languageCompletion(value).map(toCompletionItem),
+ negatable: true,
+ description: negated => `${negated ? 'Exclude' : 'Include only'} results from the given language`,
+ },
+ [FilterType.message]: {
+ alias: 'm',
+ negatable: true,
+ description: negated =>
+ `${negated ? 'Exclude' : 'Include only'} Commits with messages matching a certain string`,
+ },
+ [FilterType.patterntype]: {
+ discreteValues: () => ['regexp', 'literal', 'structural'].map(value => ({ label: value })),
+ description: 'The pattern type (regexp, literal, structural) in use',
+ singular: true,
+ },
+ [FilterType.repo]: {
+ alias: 'r',
+ negatable: true,
+ discreteValues: (_value, isSourcegraphDotCom) => [
+ ...(isSourcegraphDotCom === true ? SOURCEGRAPH_DOT_COM_REPO_COMPLETION : []),
+ ...predicateCompletion('repo'),
+ ],
+ description: negated =>
+ `${negated ? 'Exclude' : 'Include only'} results from repositories matching the given search pattern.`,
+ },
+ [FilterType.repogroup]: {
+ alias: 'g',
+ description: 'group-name (include results from the named group)',
+ singular: true,
+ },
+ [FilterType.repohascommitafter]: {
+ description: '"string specifying time frame" (filter out stale repositories without recent commits)',
+ singular: true,
+ },
+ [FilterType.repohasfile]: {
+ negatable: true,
+ description: negated =>
+ `${negated ? 'Exclude' : 'Include only'} results from repos that contain a matching file`,
+ },
+ [FilterType.rev]: {
+ alias: 'rev',
+ description: 'Search a revision (branch, commit hash, or tag) instead of the default branch.',
+ singular: true,
+ },
+ [FilterType.select]: {
+ discreteValues: value => selectorCompletion(value).map(value => ({ label: value })),
+ description: 'Selects the kind of result to display.',
+ singular: true,
+ },
+ [FilterType.timeout]: {
+ description: 'Duration before timeout',
+ singular: true,
+ },
+ [FilterType.type]: {
+ description: 'Limit results to the specified type.',
+ discreteValues: () => ['diff', 'commit', 'symbol', 'repo', 'path', 'file'].map(value => ({ label: value })),
+ },
+ [FilterType.visibility]: {
+ discreteValues: () => ['any', 'private', 'public'].map(value => ({ label: value })),
+ description: 'Include results from repositories with the matching visibility (private, public, any).',
+ singular: true,
+ },
+}
+
+export const discreteValueAliases: { [key: string]: string[] } = {
+ yes: ['yes', 'y', 'Y', 'YES', 'Yes', '1', 't', 'T', 'true', 'TRUE', 'True'],
+ no: ['n', 'N', 'no', 'NO', 'No', '0', 'f', 'F', 'false', 'FALSE', 'False'],
+ only: ['o', 'only', 'ONLY', 'Only'],
+}
+
+/**
+ * Returns the {@link FilterDefinition} for the given filterType if it exists, or `undefined` otherwise.
+ */
+export const resolveFilter = (
+ filterType: string
+):
+ | { type: NegatableFilter; negated: boolean; definition: NegatableFilterDefinition }
+ | { type: Exclude; definition: BaseFilterDefinition }
+ | undefined => {
+ filterType = filterType.toLowerCase()
+
+ if (isAliasedFilterType(filterType)) {
+ const aliasKey = filterType as keyof typeof AliasedFilterType
+ filterType = AliasedFilterType[aliasKey]
+ }
+
+ if (isNegatedFilter(filterType)) {
+ const type = resolveNegatedFilter(filterType)
+ return {
+ type,
+ definition: FILTERS[type],
+ negated: true,
+ }
+ }
+ if (isFilterType(filterType)) {
+ if (isNegatableFilter(filterType)) {
+ return {
+ type: filterType,
+ definition: FILTERS[filterType],
+ negated: false,
+ }
+ }
+ if (FILTERS[filterType]) {
+ return { type: filterType, definition: FILTERS[filterType] }
+ }
+ }
+ for (const [type, definition] of Object.entries(FILTERS as Record)) {
+ if (definition.alias && filterType === definition.alias) {
+ return {
+ type: type as Exclude,
+ definition: definition as BaseFilterDefinition,
+ }
+ }
+ }
+ return undefined
+}
+
+/**
+ * Checks whether a discrete value is valid for a given filter, accounting for valid aliases.
+ */
+const isValidDiscreteValue = (
+ definition: NegatableFilterDefinition | BaseFilterDefinition,
+ input: Literal,
+ value: string
+): boolean => {
+ if (
+ !definition.discreteValues ||
+ definition
+ .discreteValues(input)
+ .map(value => value.label)
+ .includes(value)
+ ) {
+ return true
+ }
+ const validDiscreteValuesForDefinition = Object.keys(discreteValueAliases).filter(
+ key =>
+ !definition.discreteValues ||
+ definition
+ .discreteValues(input)
+ .map(value => value.label)
+ .includes(key)
+ )
+
+ for (const discreteValue of validDiscreteValuesForDefinition) {
+ if (discreteValueAliases[discreteValue].includes(value)) {
+ return true
+ }
+ }
+ return false
+}
+
+/**
+ * Validates a filter given its field and value.
+ */
+export const validateFilter = (
+ field: string,
+ value: Filter['value']
+): { valid: true } | { valid: false; reason: string } => {
+ const typeAndDefinition = resolveFilter(field)
+ if (!typeAndDefinition) {
+ return { valid: false, reason: 'Invalid filter type.' }
+ }
+ if (typeAndDefinition.type === FilterType.repo) {
+ // Repo filter is made exempt from checking discrete valid values, since a valid `contain` predicate
+ // has infinite valid discrete values. TODO(rvantonder): value validation should be separated to
+ // account for finite discrete values and exemption of checks.
+ return { valid: true }
+ }
+ if (typeAndDefinition.type === FilterType.lang) {
+ // Lang filter is exempt because our discrete completion values are only a subset of all valid
+ // language values, which are captured by a Go library. The backend takes care of returning an
+ // alert for invalid values.
+ return { valid: true }
+ }
+ const { definition } = typeAndDefinition
+ if (definition.discreteValues && (!value || !isValidDiscreteValue(definition, value, value.value))) {
+ return {
+ valid: false,
+ reason: `Invalid filter value, expected one of: ${definition
+ .discreteValues(value)
+ .map(value => value.label)
+ .join(', ')}.`,
+ }
+ }
+ return { valid: true }
+}
+
+/**
+ * Prepends a \ to spaces, taking care to skip over existing escape sequences. We apply this to
+ * regexp field values like repo: and file:.
+ *
+ * @param value the value to escape
+ */
+export const escapeSpaces = (value: string): string => {
+ const escaped: string[] = []
+ let current = 0
+ while (value[current]) {
+ switch (value[current]) {
+ case '\\': {
+ if (value[current + 1]) {
+ escaped.push('\\', value[current + 1])
+ current = current + 2 // Continue past escaped value.
+ continue
+ }
+ escaped.push('\\')
+ current = current + 1
+ continue
+ }
+ case ' ': {
+ escaped.push('\\', ' ')
+ current = current + 1
+ continue
+ }
+ default:
+ escaped.push(value[current])
+ current = current + 1
+ continue
+ }
+ }
+ return escaped.join('')
+}
+
+/**
+ * Helper function to convert a string to a completion item. It quotes the
+ * string as necessary.
+ */
+function toCompletionItem(value: string): Completion {
+ const item: Completion = { label: value }
+ if (/\s/.test(value)) {
+ item.insertText = `"${value}"`
+ }
+ return item
+}
diff --git a/src/search/languageFilter.ts b/src/search/languageFilter.ts
new file mode 100644
index 00000000..b33652c6
--- /dev/null
+++ b/src/search/languageFilter.ts
@@ -0,0 +1,644 @@
+// This source file is copy-pasted and adjusted from the sourcegraph/sourcegraph repo
+// https://sourcegraph.com/github.com/sourcegraph/sourcegraph@7ce0484274d7382f4b9b2898d77c3987e51fffa6/-/blob/client/shared/src/search/query/languageFilter.ts
+import { Literal } from './token'
+
+/**
+ * List of languages that is shown initially when the `lang:` filter doesn't
+ * have a value yet.
+ */
+export const POPULAR_LANGUAGES: string[] = [
+ 'Assembly',
+ 'Bash',
+ 'C',
+ 'C++',
+ 'C#',
+ 'CSS',
+ 'Dart',
+ 'Elixir',
+ 'Erlang',
+ 'Go',
+ 'GraphQL',
+ 'Groovy',
+ 'Haskell',
+ 'HTML',
+ 'Java',
+ 'JavaScript',
+ 'Kotlin',
+ 'JSON',
+ 'Julia',
+ 'Lua',
+ 'Markdown',
+ 'Objective-C',
+ 'OCaml',
+ 'PHP',
+ 'PowerShell',
+ 'Python',
+ 'R',
+ 'Ruby',
+ 'Rust',
+ 'Sass',
+ 'Scala',
+ 'SQL',
+ 'Swift',
+ 'Terraform',
+ 'TypeScript',
+ 'VBA',
+ 'XML',
+ 'YAML',
+ 'Zig',
+]
+
+/**
+ * A list of all supported languages, ranking the popular languages higher by
+ * including them first.
+ * The whole list was extracted from
+ * https://github.com/go-enry/go-enry/blob/master/data/alias.go via
+ *
+ curl "https://raw.githubusercontent.com/go-enry/go-enry/$(grep go-enry go.mod|cut -d ' ' -f 2)/data/alias.go" \
+ | awk -F : '/^var LanguageByAliasMap/ { MATCH=1; next } /^}/ { exit } MATCH==1 { gsub(/^ +/, "", $2); print $2 }' \
+ | sort | uniq
+ *
+ */
+export const ALL_LANGUAGES = [
+ ...new Set(
+ POPULAR_LANGUAGES.concat([
+ '1C Enterprise',
+ '4D',
+ 'ABAP',
+ 'ABNF',
+ 'ActionScript',
+ 'Ada',
+ 'Adobe Font Metrics',
+ 'Agda',
+ 'AGS Script',
+ 'AL',
+ 'Alloy',
+ 'Alpine Abuild',
+ 'Altium Designer',
+ 'AMPL',
+ 'AngelScript',
+ 'Ant Build System',
+ 'ANTLR',
+ 'ApacheConf',
+ 'Apex',
+ 'API Blueprint',
+ 'APL',
+ 'Apollo Guidance Computer',
+ 'AppleScript',
+ 'Arc',
+ 'AsciiDoc',
+ 'ASL',
+ 'ASN.1',
+ 'AspectJ',
+ 'ASP.NET',
+ 'Assembly',
+ 'Asymptote',
+ 'ATS',
+ 'Augeas',
+ 'AutoHotkey',
+ 'AutoIt',
+ 'Avro IDL',
+ 'Awk',
+ 'Ballerina',
+ 'Batchfile',
+ 'Befunge',
+ 'BibTeX',
+ 'Bison',
+ 'BitBake',
+ 'Blade',
+ 'BlitzBasic',
+ 'BlitzMax',
+ 'Bluespec',
+ 'Boo',
+ 'Brainfuck',
+ 'Brightscript',
+ 'C',
+ 'C#',
+ 'C++',
+ 'C2hs Haskell',
+ 'Cabal Config',
+ "Cap'n Proto",
+ 'CartoCSS',
+ 'Ceylon',
+ 'Chapel',
+ 'Charity',
+ 'ChucK',
+ 'Cirru',
+ 'Clarion',
+ 'Classic ASP',
+ 'Clean',
+ 'Click',
+ 'CLIPS',
+ 'Clojure',
+ 'Closure Templates',
+ 'Cloud Firestore Security Rules',
+ 'CMake',
+ 'C-ObjDump',
+ 'COBOL',
+ 'CodeQL',
+ 'CoffeeScript',
+ 'ColdFusion',
+ 'ColdFusion CFC',
+ 'COLLADA',
+ 'Common Lisp',
+ 'Common Workflow Language',
+ 'Component Pascal',
+ 'CoNLL-U',
+ 'Cool',
+ 'Coq',
+ 'Cpp-ObjDump',
+ 'Creole',
+ 'Crystal',
+ 'CSON',
+ 'Csound',
+ 'Csound Document',
+ 'Csound Score',
+ 'CSS',
+ 'CSV',
+ 'Cuda',
+ 'cURL Config',
+ 'CWeb',
+ 'Cycript',
+ 'Cython',
+ 'D',
+ 'Dafny',
+ 'Darcs Patch',
+ 'Dart',
+ 'DataWeave',
+ 'desktop',
+ 'Dhall',
+ 'Diff',
+ 'DIGITAL Command Language',
+ 'dircolors',
+ 'DirectX 3D File',
+ 'DM',
+ 'DNS Zone',
+ 'D-ObjDump',
+ 'Dockerfile',
+ 'Dogescript',
+ 'DTrace',
+ 'Dylan',
+ 'E',
+ 'Eagle',
+ 'Easybuild',
+ 'EBNF',
+ 'eC',
+ 'Ecere Projects',
+ 'ECL',
+ 'ECLiPSe',
+ 'EditorConfig',
+ 'Edje Data Collection',
+ 'edn',
+ 'Eiffel',
+ 'EJS',
+ 'Elixir',
+ 'Elm',
+ 'Emacs Lisp',
+ 'EmberScript',
+ 'EML',
+ 'EQ',
+ 'Erlang',
+ 'F#',
+ 'F*',
+ 'Factor',
+ 'Fancy',
+ 'Fantom',
+ 'Faust',
+ 'FIGlet Font',
+ 'Filebench WML',
+ 'Filterscript',
+ 'fish',
+ 'FLUX',
+ 'Formatted',
+ 'Forth',
+ 'Fortran',
+ 'Fortran Free Form',
+ 'FreeMarker',
+ 'Frege',
+ 'Futhark',
+ 'Game Maker Language',
+ 'GAML',
+ 'GAMS',
+ 'GAP',
+ 'GCC Machine Description',
+ 'G-code',
+ 'GDB',
+ 'GDScript',
+ 'GEDCOM',
+ 'Genie',
+ 'Genshi',
+ 'Gentoo Ebuild',
+ 'Gentoo Eclass',
+ 'Gerber Image',
+ 'Gettext Catalog',
+ 'Gherkin',
+ 'Git Attributes',
+ 'Git Config',
+ 'GLSL',
+ 'Glyph',
+ 'Glyph Bitmap Distribution Format',
+ 'GN',
+ 'Gnuplot',
+ 'Go',
+ 'Golo',
+ 'Gosu',
+ 'Grace',
+ 'Gradle',
+ 'Grammatical Framework',
+ 'Graph Modeling Language',
+ 'GraphQL',
+ 'Graphviz (DOT)',
+ 'Groovy',
+ 'Groovy Server Pages',
+ 'Hack',
+ 'Haml',
+ 'Handlebars',
+ 'HAProxy',
+ 'Harbour',
+ 'Haskell',
+ 'Haxe',
+ 'HCL',
+ 'HiveQL',
+ 'HLSL',
+ 'HolyC',
+ 'HTML',
+ 'HTML+Django',
+ 'HTML+ECR',
+ 'HTML+EEX',
+ 'HTML+ERB',
+ 'HTML+PHP',
+ 'HTML+Razor',
+ 'HTTP',
+ 'HXML',
+ 'Hy',
+ 'HyPhy',
+ 'IDL',
+ 'Idris',
+ 'Ignore List',
+ 'IGOR Pro',
+ 'Inform 7',
+ 'INI',
+ 'Inno Setup',
+ 'Io',
+ 'Ioke',
+ 'IRC log',
+ 'Isabelle',
+ 'Isabelle ROOT',
+ 'J',
+ 'Jasmin',
+ 'Java',
+ 'Java Properties',
+ 'JavaScript',
+ 'JavaScript+ERB',
+ 'Java Server Pages',
+ 'JFlex',
+ 'Jison',
+ 'Jison Lex',
+ 'Jolie',
+ 'JSON',
+ 'JSON5',
+ 'JSONiq',
+ 'JSONLD',
+ 'Jsonnet',
+ 'JSON with Comments',
+ 'JSX',
+ 'Julia',
+ 'Jupyter Notebook',
+ 'Kaitai Struct',
+ 'KiCad Layout',
+ 'KiCad Legacy Layout',
+ 'KiCad Schematic',
+ 'Kit',
+ 'Kotlin',
+ 'KRL',
+ 'LabVIEW',
+ 'Lark',
+ 'Lasso',
+ 'Latte',
+ 'Lean',
+ 'Less',
+ 'Lex',
+ 'LFE',
+ 'LilyPond',
+ 'Limbo',
+ 'Linker Script',
+ 'Linux Kernel Module',
+ 'Liquid',
+ 'Literate Agda',
+ 'Literate CoffeeScript',
+ 'Literate Haskell',
+ 'LiveScript',
+ 'LLVM',
+ 'Logos',
+ 'Logtalk',
+ 'LOLCODE',
+ 'LookML',
+ 'LoomScript',
+ 'LSL',
+ 'LTspice Symbol',
+ 'Lua',
+ 'M',
+ 'M4',
+ 'M4Sugar',
+ 'Macaulay2',
+ 'Makefile',
+ 'Mako',
+ 'Markdown',
+ 'Marko',
+ 'Mask',
+ 'Mathematica',
+ 'MATLAB',
+ 'Maven POM',
+ 'Max',
+ 'MAXScript',
+ 'mcfunction',
+ 'MediaWiki',
+ 'Mercury',
+ 'Meson',
+ 'Metal',
+ 'Microsoft Developer Studio Project',
+ 'MiniD',
+ 'Mirah',
+ 'mIRC Script',
+ 'MLIR',
+ 'Modelica',
+ 'Modula-2',
+ 'Modula-3',
+ 'Module Management System',
+ 'Monkey',
+ 'Moocode',
+ 'MoonScript',
+ 'Motorola 68K Assembly',
+ 'MQL4',
+ 'MQL5',
+ 'MTML',
+ 'MUF',
+ 'mupad',
+ 'Muse',
+ 'Mustache',
+ 'Myghty',
+ 'nanorc',
+ 'NASL',
+ 'NCL',
+ 'Nearley',
+ 'Nemerle',
+ 'NEON',
+ 'nesC',
+ 'NetLinx',
+ 'NetLinx+ERB',
+ 'NetLogo',
+ 'NewLisp',
+ 'Nextflow',
+ 'Nginx',
+ 'Nim',
+ 'Ninja',
+ 'Nit',
+ 'Nix',
+ 'NL',
+ 'NPM Config',
+ 'NSIS',
+ 'Nu',
+ 'NumPy',
+ 'NWScript',
+ 'ObjDump',
+ 'Object Data Instance Notation',
+ 'Objective-C',
+ 'Objective-C++',
+ 'Objective-J',
+ 'ObjectScript',
+ 'OCaml',
+ 'Odin',
+ 'Omgrofl',
+ 'ooc',
+ 'Opa',
+ 'Opal',
+ 'OpenCL',
+ 'OpenEdge ABL',
+ 'Open Policy Agent',
+ 'OpenQASM',
+ 'OpenRC runscript',
+ 'OpenSCAD',
+ 'OpenStep Property List',
+ 'OpenType Feature File',
+ 'Org',
+ 'Ox',
+ 'Oxygene',
+ 'Oz',
+ 'P4',
+ 'Pan',
+ 'Papyrus',
+ 'Parrot',
+ 'Parrot Assembly',
+ 'Parrot Internal Representation',
+ 'Pascal',
+ 'Pawn',
+ 'Pep8',
+ 'Perl',
+ 'PHP',
+ 'Pic',
+ 'Pickle',
+ 'PicoLisp',
+ 'PigLatin',
+ 'Pike',
+ 'PlantUML',
+ 'PLpgSQL',
+ 'PLSQL',
+ 'Pod',
+ 'Pod 6',
+ 'PogoScript',
+ 'Pony',
+ 'PostCSS',
+ 'PostScript',
+ 'POV-Ray SDL',
+ 'PowerBuilder',
+ 'PowerShell',
+ 'Prisma',
+ 'Processing',
+ 'Proguard',
+ 'Prolog',
+ 'Propeller Spin',
+ 'Protocol Buffer',
+ 'Public Key',
+ 'Pug',
+ 'Puppet',
+ 'PureBasic',
+ 'Pure Data',
+ 'PureScript',
+ 'Python',
+ 'Python console',
+ 'Python traceback',
+ 'q',
+ 'Q#',
+ 'QMake',
+ 'QML',
+ 'Qt Script',
+ 'Quake',
+ 'R',
+ 'Racket',
+ 'Ragel',
+ 'Raku',
+ 'RAML',
+ 'Rascal',
+ 'Raw token data',
+ 'RDoc',
+ 'Readline Config',
+ 'REALbasic',
+ 'Reason',
+ 'Rebol',
+ 'Red',
+ 'Redcode',
+ 'Regular Expression',
+ 'RenderScript',
+ "Ren'Py",
+ 'ReScript',
+ 'reStructuredText',
+ 'REXX',
+ 'Rich Text Format',
+ 'Ring',
+ 'Riot',
+ 'RMarkdown',
+ 'RobotFramework',
+ 'Roff',
+ 'Roff Manpage',
+ 'Rouge',
+ 'RPC',
+ 'RPM Spec',
+ 'Ruby',
+ 'RUNOFF',
+ 'Rust',
+ 'Sage',
+ 'SaltStack',
+ 'SAS',
+ 'Sass',
+ 'Scala',
+ 'Scaml',
+ 'Scheme',
+ 'Scilab',
+ 'SCSS',
+ 'sed',
+ 'Self',
+ 'ShaderLab',
+ 'Shell',
+ 'ShellSession',
+ 'Shen',
+ 'Sieve',
+ 'Slash',
+ 'Slice',
+ 'Slim',
+ 'Smali',
+ 'Smalltalk',
+ 'Smarty',
+ 'SmPL',
+ 'SMT',
+ 'Solidity',
+ 'SourcePawn',
+ 'SPARQL',
+ 'Spline Font Database',
+ 'SQF',
+ 'SQL',
+ 'SQLPL',
+ 'Squirrel',
+ 'SRecode Template',
+ 'SSH Config',
+ 'Stan',
+ 'Standard ML',
+ 'Starlark',
+ 'Stata',
+ 'STON',
+ 'Stylus',
+ 'SubRip Text',
+ 'SugarSS',
+ 'SuperCollider',
+ 'Svelte',
+ 'SVG',
+ 'Swift',
+ 'SWIG',
+ 'SystemVerilog',
+ 'Tcl',
+ 'Tcsh',
+ 'Tea',
+ 'Terra',
+ 'TeX',
+ 'Texinfo',
+ 'Text',
+ 'Textile',
+ 'Thrift',
+ 'TI Program',
+ 'TLA',
+ 'TOML',
+ 'TSQL',
+ 'TSV',
+ 'TSX',
+ 'Turing',
+ 'Turtle',
+ 'Twig',
+ 'TXL',
+ 'Type Language',
+ 'TypeScript',
+ 'Unified Parallel C',
+ 'Unity3D Asset',
+ 'Unix Assembly',
+ 'Uno',
+ 'UnrealScript',
+ 'UrWeb',
+ 'V',
+ 'Vala',
+ 'VBA',
+ 'VBScript',
+ 'VCL',
+ 'Verilog',
+ 'VHDL',
+ 'Vim Help File',
+ 'Vim script',
+ 'Vim Snippet',
+ 'Visual Basic .NET',
+ 'Volt',
+ 'Vue',
+ 'Wavefront Material',
+ 'Wavefront Object',
+ 'wdl',
+ 'WebAssembly',
+ 'WebIDL',
+ 'Web Ontology Language',
+ 'WebVTT',
+ 'Wget Config',
+ 'Windows Registry Entries',
+ 'wisp',
+ 'Wollok',
+ 'World of Warcraft Addon Data',
+ 'X10',
+ 'xBase',
+ 'X BitMap',
+ 'XC',
+ 'XCompose',
+ 'X Font Directory Index',
+ 'XML',
+ 'XML Property List',
+ 'Xojo',
+ 'XPages',
+ 'X PixMap',
+ 'XProc',
+ 'XQuery',
+ 'XS',
+ 'XSLT',
+ 'Xtend',
+ 'Yacc',
+ 'YAML',
+ 'YANG',
+ 'YARA',
+ 'YASnippet',
+ 'ZAP',
+ 'Zeek',
+ 'ZenScript',
+ 'Zephir',
+ 'Zig',
+ 'ZIL',
+ 'Zimpl',
+ ])
+ ),
+]
+
+// Returns a list of popular languages initially and a complete list when the
+// user has provided input.
+export const languageCompletion = (value: Literal | undefined): string[] =>
+ value?.value ? ALL_LANGUAGES : POPULAR_LANGUAGES
diff --git a/src/search/predicates.ts b/src/search/predicates.ts
new file mode 100644
index 00000000..4dc14d39
--- /dev/null
+++ b/src/search/predicates.ts
@@ -0,0 +1,172 @@
+// This source file is copy-pasted and adjusted from the sourcegraph/sourcegraph repo
+// https://sourcegraph.com/github.com/sourcegraph/sourcegraph@7ce0484274d7382f4b9b2898d77c3987e51fffa6/-/blob/client/shared/src/search/query/predicates.ts
+/* eslint-disable no-template-curly-in-string */
+import { Completion, resolveFieldAlias } from './filters'
+
+interface Access {
+ name: string
+ fields?: Access[]
+}
+
+/**
+ * Represents recognized predicate accesses associated with fields. The
+ * data structure is a tree, where nodes are lists to preserve ordering
+ * for autocomplete suggestions.
+ */
+export const PREDICATES: Access[] = [
+ {
+ name: 'repo',
+ fields: [
+ {
+ name: 'contains',
+ fields: [
+ { name: 'file' },
+ { name: 'content' },
+ {
+ name: 'commit',
+ fields: [{ name: 'after' }],
+ },
+ ],
+ },
+ ],
+ },
+ {
+ name: 'file',
+ fields: [
+ {
+ name: 'contains',
+ fields: [{ name: 'content' }],
+ },
+ ],
+ },
+]
+
+/** Represents a predicate's components corresponding to the syntax path(parameters). */
+export interface Predicate {
+ path: string[]
+ parameters: string
+}
+
+/** Returns the access tree for a predicate path. */
+export const resolveAccess = (path: string[], tree: Access[]): Access[] | undefined => {
+ if (path.length === 0) {
+ return tree
+ }
+ const subtree = tree.find(value => value.name === path[0])
+ if (!subtree) {
+ return undefined
+ }
+ if (!subtree.fields) {
+ return []
+ }
+ return resolveAccess(path.slice(1), subtree.fields)
+}
+
+// scans a string up to closing parentheses. Examples:
+// - `foo` succeeds, parentheses are absent, so it is vacuously balanced
+// - `foo(...)` succeeds up to the closing `)`
+// - `foo(...))` succeeds up to the first `)`, which is recognized as the closing paren
+// - `foo(` does not succeed, it is not balanced
+// - `foo)` does not succeed, it is not balanced
+export const scanBalancedParens = (input: string): string | undefined => {
+ let adjustedStart = 0
+ let balanced = 0
+ let current = ''
+ const result: string[] = []
+
+ const nextChar = (): void => {
+ current = input[adjustedStart]
+ adjustedStart += 1
+ }
+
+ while (input[adjustedStart] !== undefined) {
+ nextChar()
+ if (current === '(') {
+ balanced += 1
+ result.push(current)
+ } else if (current === ')') {
+ balanced -= 1
+ result.push(current)
+ if (balanced === 0) {
+ // we've reached a closing parenthesis where the string is balanced
+ break
+ }
+ } else if (current === '\\') {
+ if (input[adjustedStart] !== undefined) {
+ nextChar() // consume escaped
+ result.push('\\', current)
+ continue
+ }
+ result.push(current)
+ } else if (current.match(/^\s+/) && balanced <= 0) {
+ // Whitespace signals we've reached the end of this parenthesized expr.
+ break
+ } else {
+ result.push(current)
+ }
+ }
+
+ if (balanced !== 0) {
+ return undefined
+ }
+ return result.join('')
+}
+
+/**
+ * Scans predicate syntax of the form field:foo.bar(parameters) and
+ * returns the name and parameters components. It checks that:
+ *
+ * (1) The (field, name) pair is a recognized predicate.
+ * (2) The parameters value is well-balanced.
+ */
+export const scanPredicate = (field: string, value: string): Predicate | undefined => {
+ const match = value.match(/^[.a-z]+/i)
+ if (!match) {
+ return undefined
+ }
+ const name = match[0]
+ const path = name.split('.')
+ field = resolveFieldAlias(field)
+ const access = resolveAccess([field, ...path], PREDICATES)
+ if (!access) {
+ return undefined
+ }
+ const rest = value.slice(name.length)
+ const parameters = scanBalancedParens(rest)
+ if (!parameters) {
+ return undefined
+ }
+ if (!parameters.startsWith('(') || !parameters.endsWith(')')) {
+ return undefined
+ }
+
+ return { path, parameters }
+}
+
+export const predicateCompletion = (field: string): Completion[] => {
+ if (field === 'repo') {
+ return [
+ {
+ label: 'contains.file(...)',
+ insertText: 'contains.file(${1:CHANGELOG})',
+ asSnippet: true,
+ },
+ {
+ label: 'contains.content(...)',
+ insertText: 'contains.content(${1:TODO})',
+ asSnippet: true,
+ },
+ {
+ label: 'contains(...)',
+ insertText: 'contains(file:${1:CHANGELOG} content:${2:fix})',
+ asSnippet: true,
+ },
+ {
+ label: 'contains.commit.after(...)',
+ insertText: 'contains.commit.after(${1:1 month ago})',
+ asSnippet: true,
+ },
+ ]
+ }
+ return []
+}
diff --git a/src/search/scanner.ts b/src/search/scanner.ts
new file mode 100644
index 00000000..6f4d8894
--- /dev/null
+++ b/src/search/scanner.ts
@@ -0,0 +1,502 @@
+// This source file is copy-pasted and adjusted from the sourcegraph/sourcegraph repo
+// https://sourcegraph.com/github.com/sourcegraph/sourcegraph@7ce0484274d7382f4b9b2898d77c3987e51fffa6/-/blob/client/shared/src/search/query/scanner.ts
+import { filterTypeKeysWithAliases } from './filters'
+import { scanPredicate } from './predicates'
+import {
+ Token,
+ Whitespace,
+ OpeningParen,
+ ClosingParen,
+ Keyword,
+ Comment,
+ Literal,
+ Pattern,
+ Filter,
+ KeywordKind,
+ PatternKind,
+ CharacterRange,
+ createLiteral,
+ Separator,
+} from './token'
+
+/**
+ * A scanner produces a term, which is either a token or a list of tokens.
+ */
+export type Term = Token | Token[]
+
+/**
+ * Represents the failed result of running a {@link Scanner} on a search query.
+ */
+interface ScanError {
+ type: 'error'
+
+ /**
+ * A string representing the token that would have been expected
+ * for successful scanning at {@link ScannerError#at}.
+ */
+ expected: string
+
+ /**
+ * The index in the search query string where scanning failed.
+ */
+ at: number
+}
+
+/**
+ * Represents the successful result of running a {@link Scannerer} on a search query.
+ */
+export interface ScanSuccess {
+ type: 'success'
+
+ /**
+ * The resulting term.
+ */
+ term: T
+}
+
+/**
+ * Represents the result of running a {@link Scanner} on a search query.
+ */
+export type ScanResult = ScanError | ScanSuccess
+
+type Scanner = (input: string, start: number) => ScanResult
+
+/**
+ * Returns a {@link Scanner} that succeeds if zero or more tokens are scanned
+ * by the given `scanToken` scanners.
+ */
+const zeroOrMore = (scanToken: Scanner): Scanner => (input, start) => {
+ const tokens: Token[] = []
+ let adjustedStart = start
+ let end = start + 1
+ while (input[adjustedStart] !== undefined) {
+ const result = scanToken(input, adjustedStart)
+ if (result.type === 'error') {
+ return result
+ }
+ if (Array.isArray(result.term)) {
+ for (const token of result.term) {
+ tokens.push(token)
+ end = token.range.end
+ }
+ } else {
+ tokens.push(result.term)
+ end = result.term.range.end
+ }
+ adjustedStart = end
+ }
+ return { type: 'success', term: tokens }
+}
+
+/**
+ * Returns a {@link Scanner} that succeeds if any of the given scanner succeeds.
+ */
+const oneOf = (...scanners: Scanner[]): Scanner => (input, start) => {
+ const expected: string[] = []
+ for (const scanner of scanners) {
+ const result = scanner(input, start)
+ if (result.type === 'success') {
+ return result
+ }
+ expected.push(result.expected)
+ }
+ return {
+ type: 'error',
+ expected: `One of: ${expected.join(', ')}`,
+ at: start,
+ }
+}
+
+/**
+ * A {@link Scanner} that will attempt to scan delimited strings for an arbitrary
+ * delimiter. `\` is treated as an escape character for the delimited string.
+ */
+const quoted = (delimiter: string): Scanner => (input, start) => {
+ if (input[start] !== delimiter) {
+ return { type: 'error', expected: delimiter, at: start }
+ }
+ let end = start + 1
+ while (input[end] && (input[end] !== delimiter || input[end - 1] === '\\')) {
+ end = end + 1
+ }
+ if (!input[end]) {
+ return { type: 'error', expected: delimiter, at: end }
+ }
+ return {
+ type: 'success',
+ // end + 1 as `end` is currently the index of the quote in the string.
+ term: createLiteral(input.slice(start + 1, end), { start, end: end + 1 }, true),
+ }
+}
+
+/**
+ * A {@link Scanner} that scans a ':' separator for fields.
+ */
+const filterSeparator = (input: string, start: number): ScanResult => {
+ if (input[start] !== ':') {
+ return { type: 'error', expected: ':', at: start }
+ }
+ return {
+ type: 'success',
+ term: createLiteral(':', { start, end: start + 1 }),
+ }
+}
+
+/**
+ * A {@link Scanner} that will attempt to scan
+ * tokens matching the given RegExp pattern in a search query.
+ */
+const scanToken = (
+ regexp: RegExp,
+ output?: T | ((input: string, range: CharacterRange) => T),
+ expected?: string
+): Scanner => {
+ if (!regexp.source.startsWith('^')) {
+ regexp = new RegExp(`^${regexp.source}`, regexp.flags)
+ }
+ return (input, start) => {
+ const matchTarget = input.slice(Math.max(0, start))
+ if (!matchTarget) {
+ return { type: 'error', expected: expected || `/${regexp.source}/`, at: start }
+ }
+ const match = matchTarget.match(regexp)
+ if (!match) {
+ return { type: 'error', expected: expected || `/${regexp.source}/`, at: start }
+ }
+ const range = { start, end: start + match[0].length }
+ return {
+ type: 'success',
+ term: output
+ ? typeof output === 'function'
+ ? output(match[0], range)
+ : output
+ : ({ type: 'literal', value: match[0], range } as T),
+ }
+ }
+}
+
+/**
+ * ScanBalancedLiteral attempts to scan balanced parentheses as literal strings. This
+ * ensures that we interpret patterns containing parentheses _as patterns_ and not
+ * groups. For example, it accepts these patterns:
+ *
+ * ((a|b)|c) - a regular expression with balanced parentheses for grouping
+ * myFunction(arg1, arg2) - a literal string with parens that should be literally interpreted
+ * foo(...) - a structural search pattern
+ *
+ * If it weren't for this scanner, the above parentheses would have to be
+ * interpreted as part of the query language group syntax, like these:
+ *
+ * (foo or (bar and baz))
+ *
+ * So, this scanner detects parentheses as patterns without needing the user to
+ * explicitly escape them. As such, there are cases where this scanner should
+ * not succeed:
+ *
+ * (foo or (bar and baz)) - a valid query with and/or expression groups in the query langugae
+ * (repo:foo bar baz) - a valid query containing a recognized repo: field. Here parentheses are interpreted as a group, not a pattern.
+ */
+export const scanBalancedLiteral: Scanner = (input, start) => {
+ let adjustedStart = start
+ let balanced = 0
+ let current = ''
+ const result: string[] = []
+
+ const nextChar = (): void => {
+ current = input[adjustedStart]
+ adjustedStart += 1
+ }
+
+ if (!keepScanning(input, start)) {
+ return {
+ type: 'error',
+ expected: 'no recognized filter or keyword',
+ at: start,
+ }
+ }
+
+ while (input[adjustedStart] !== undefined) {
+ nextChar()
+ if (current.match(/\s/) && balanced === 0) {
+ // Stop scanning a potential pattern when we see whitespace in a balanced state.
+ adjustedStart -= 1 // Backtrack.
+ break
+ } else if (current === '(') {
+ if (!keepScanning(input, adjustedStart)) {
+ return {
+ type: 'error',
+ expected: 'no recognized filter or keyword',
+ at: adjustedStart,
+ }
+ }
+ balanced += 1
+ result.push(current)
+ } else if (current === ')') {
+ balanced -= 1
+ if (balanced < 0 && adjustedStart > 1) {
+ // This paren is an unmatched closing paren, so we stop treating it as a potential
+ // pattern here--it might be closing a group.
+ adjustedStart -= 1 // Backtrack.
+ balanced = 0 // Pattern is balanced up to this point
+ break
+ }
+ result.push(current)
+ } else if (current === ' ') {
+ if (!keepScanning(input, adjustedStart)) {
+ return {
+ type: 'error',
+ expected: 'no recognized filter or keyword',
+ at: adjustedStart,
+ }
+ }
+ result.push(current)
+ } else if (current === '\\') {
+ if (input[adjustedStart] !== undefined) {
+ nextChar()
+ // Accept anything anything escaped. The point is to consume escaped spaces like "\ "
+ // so that we don't recognize it as terminating a pattern.
+ result.push('\\', current)
+ continue
+ }
+ result.push(current)
+ } else {
+ result.push(current)
+ }
+ }
+
+ if (balanced !== 0) {
+ return {
+ type: 'error',
+ expected: 'no unbalanced parentheses',
+ at: adjustedStart,
+ }
+ }
+
+ return {
+ type: 'success',
+ term: createLiteral(result.join(''), { start, end: adjustedStart }),
+ }
+}
+
+/**
+ * Scan predicate syntax like repo:contains(file:README.md). Predicate scanning
+ * takes precedence over other value scanners like scanBalancedLiteral.
+ */
+export const scanPredicateValue = (input: string, start: number, field: Literal): ScanResult => {
+ const result = scanPredicate(field.value, input.slice(start))
+ if (!result) {
+ return {
+ type: 'error',
+ expected: 'recognized predicate',
+ at: start,
+ }
+ }
+ const value = `${result.path.join('.')}${result.parameters}`
+ return {
+ type: 'success',
+ term: createLiteral(value, { start, end: start + value.length }),
+ }
+}
+
+const whitespace = scanToken(/\s+/, (_value, range) => ({
+ type: 'whitespace',
+ range,
+}))
+
+const literal = scanToken(/[^\s)]+/)
+
+const keywordNot = scanToken(/(not|NOT)/, (value, { start, end }) => ({
+ type: 'keyword',
+ value,
+ range: { start, end },
+ kind: KeywordKind.Not,
+}))
+
+const keywordAnd = scanToken(/(and|AND)/, (value, { start, end }) => ({
+ type: 'keyword',
+ value,
+ range: { start, end },
+ kind: KeywordKind.And,
+}))
+
+const keywordOr = scanToken(/(or|OR)/, (value, { start, end }) => ({
+ type: 'keyword',
+ value,
+ range: { start, end },
+ kind: KeywordKind.Or,
+}))
+
+const keyword = oneOf(keywordAnd, keywordOr, keywordNot)
+
+const comment = scanToken(
+ /\/\/.*/,
+ (value, { start, end }): Comment => ({ type: 'comment', value, range: { start, end } })
+)
+
+const filterField = scanToken(new RegExp(`-?(${filterTypeKeysWithAliases.join('|')})+(?=:)`, 'i'))
+
+const filterValue = oneOf(quoted('"'), quoted("'"), scanBalancedLiteral, literal)
+
+const openingParen = scanToken(/\(/, (_input, range): OpeningParen => ({ type: 'openingParen', range }))
+
+const closingParen = scanToken(/\)/, (_input, range): ClosingParen => ({ type: 'closingParen', range }))
+
+/**
+ * Returns a {@link Scanner} that succeeds if `scanTerm` succeeds,
+ * followed by `scanNext`.
+ */
+const followedBy = (scanTerm: Scanner, scanNext: Scanner): Scanner => (input, start) => {
+ const result = scanTerm(input, start)
+ if (result.type === 'error') {
+ return result
+ }
+ let end: number | undefined
+ const tokens: Token[] = []
+ if (Array.isArray(result.term)) {
+ for (const token of result.term) {
+ tokens.push(token)
+ end = token.range.end
+ }
+ } else {
+ tokens.push(result.term)
+ end = result.term.range.end
+ }
+ // Invariant: end is defined.
+ if (end && input[end] !== undefined) {
+ const next = scanNext(input, end)
+ if (next.type === 'error') {
+ return next
+ }
+ tokens.push(next.term)
+ end = next.term.range.end
+ }
+ return {
+ type: 'success',
+ term: tokens,
+ }
+}
+
+/**
+ * A {@link Scanner} that will attempt to scan {@link Filter} tokens
+ * (consisting a of a filter type and a filter value, separated by a colon)
+ * in a search query.
+ */
+const filter: Scanner = (input, start) => {
+ const scanPrefix = followedBy(filterField, filterSeparator)
+ const result = scanPrefix(input, start)
+ if (result.type === 'error') {
+ return result
+ }
+ const [field, separator] = result.term as [Literal, Separator]
+ let value: ScanResult | undefined
+ if (input[separator.range.end] === undefined) {
+ value = undefined
+ } else {
+ value = scanPredicateValue(input, separator.range.end, field)
+ if (value.type === 'error') {
+ value = filterValue(input, separator.range.end)
+ }
+ }
+ if (value && value.type === 'error') {
+ return value
+ }
+ return {
+ type: 'success',
+ term: {
+ type: 'filter',
+ range: { start, end: value ? value.term.range.end : separator.range.end },
+ field,
+ value: value?.term,
+ negated: field.value.startsWith('-'),
+ },
+ }
+}
+
+const createPattern = (value: string, range: CharacterRange, kind: PatternKind): ScanSuccess => ({
+ type: 'success',
+ term: {
+ type: 'pattern',
+ range,
+ kind,
+ value,
+ },
+})
+
+const scanFilterOrKeyword = oneOf(filterField, followedBy(keyword, whitespace))
+const keepScanning = (input: string, start: number): boolean => scanFilterOrKeyword(input, start).type !== 'success'
+
+/**
+ * A helper function that maps a {@link Literal} scanner result to a {@link Pattern} scanner.
+ *
+ * @param scanner The literal scanner.
+ * @param kind The {@link PatternKind} label to apply to the resulting pattern scanner.
+ */
+export const toPatternResult = (scanner: Scanner, kind: PatternKind): Scanner => (input, start) => {
+ const result = scanner(input, start)
+ if (result.type === 'success') {
+ return createPattern(result.term.value, result.term.range, kind)
+ }
+ return result
+}
+
+const scanPattern = (kind: PatternKind): Scanner =>
+ toPatternResult(oneOf(scanBalancedLiteral, literal), kind)
+
+const whitespaceOrClosingParen = oneOf(whitespace, closingParen)
+
+/**
+ * A {@link Scanner} for a Sourcegraph search query, interpreting patterns for {@link PatternKind}.
+ *
+ * @param interpretComments Interpets C-style line comments for multiline queries.
+ */
+const createScanner = (kind: PatternKind, interpretComments?: boolean): Scanner => {
+ const baseQuotedScanner = [quoted('"'), quoted("'")]
+ const quotedScanner = kind === PatternKind.Regexp ? [quoted('/'), ...baseQuotedScanner] : baseQuotedScanner
+
+ const baseScanner = [keyword, filter, ...quotedScanner, scanPattern(kind)]
+ const tokenScanner: Scanner[] = interpretComments ? [comment, ...baseScanner] : baseScanner
+
+ const baseEarlyPatternScanner = [...quotedScanner, toPatternResult(scanBalancedLiteral, kind)]
+ const earlyPatternScanner = interpretComments ? [comment, ...baseEarlyPatternScanner] : baseEarlyPatternScanner
+
+ return zeroOrMore(
+ oneOf(
+ whitespace,
+ ...earlyPatternScanner.map(token => followedBy(token, whitespaceOrClosingParen)),
+ openingParen,
+ closingParen,
+ ...tokenScanner.map(token => followedBy(token, whitespaceOrClosingParen))
+ )
+ )
+}
+
+/**
+ * Scans a search query string.
+ */
+export const scanSearchQuery = (
+ query: string,
+ interpretComments?: boolean,
+ searchPatternType = SearchPatternType.literal
+): ScanResult => {
+ let patternKind
+ switch (searchPatternType) {
+ case SearchPatternType.literal:
+ patternKind = PatternKind.Literal
+ break
+ case SearchPatternType.regexp:
+ patternKind = PatternKind.Regexp
+ break
+ case SearchPatternType.structural:
+ patternKind = PatternKind.Structural
+ break
+ }
+ const scanner = createScanner(patternKind, interpretComments)
+ return scanner(query, 0)
+}
+
+/** The search pattern type. */
+export enum SearchPatternType {
+ literal = 'literal',
+ regexp = 'regexp',
+ structural = 'structural',
+}
diff --git a/src/search/searchHtml.ts b/src/search/searchHtml.ts
new file mode 100644
index 00000000..b30c5aaa
--- /dev/null
+++ b/src/search/searchHtml.ts
@@ -0,0 +1,156 @@
+import * as vscode from 'vscode'
+import { SearchPatternType } from './scanner'
+import { searchQueryResult, SearchResultNode } from '../queries/searchQuery'
+import { log } from '../log'
+
+export async function searchHtml(
+ host: string,
+ query: string,
+ patternType: SearchPatternType,
+ token: vscode.CancellationToken
+): Promise {
+ const result = await searchQueryResult(query, patternType, token)
+ const html: string[] = []
+ const nodes = result?.data?.search?.results?.results
+ for (const node of nodes || []) {
+ formatFileMatch(host, node, html)
+ formatRepository(host, node, html)
+ formatCommit(host, node, html)
+ }
+ return html.join('')
+}
+
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+function formatCommit(host: string, node: SearchResultNode, html: string[]): void {
+ if (node.__typename !== 'CommitSearchResult') {
+ return
+ }
+ log.debug({ node })
+ if (!node?.commit?.message) {
+ return
+ }
+ const match = node.matches?.[0]
+ if (!match) {
+ return
+ }
+ if (!match?.body?.text) {
+ return
+ }
+ if (!match.url) {
+ return
+ }
+ const url = `sourcegraph://${host}${match.url}`
+ html.push('')
+ html.push(`${match.url}`)
+ if (node.commit?.message) {
+ html.push(`
${node.commit?.message}`)
+ }
+ html.push('
')
+}
+
+function formatRepository(host: string, node: SearchResultNode, html: string[]): void {
+ if (node.__typename !== 'Repository') {
+ return
+ }
+ if (!node.name) {
+ return
+ }
+ const url = `sourcegraph://${host}/${node.name}`
+ const stars = formatStars(node.stars)
+ html.push('')
+ html.push(
+ `${node.name}${stars}`
+ )
+ html.push('
')
+}
+
+function formatFileMatch(host: string, node: SearchResultNode, html: string[]): void {
+ if (node.__typename !== 'FileMatch') {
+ return
+ }
+ const url = node?.file?.url
+ if (!url) {
+ return
+ }
+ const lineMatches = node.lineMatches || []
+ if (lineMatches.length === 0) {
+ return
+ }
+ let first = true
+ let filenameMatchesCount = 0
+ for (const [lineMatchIndex, lineMatch] of lineMatches.entries()) {
+ const line = lineMatch.lineNumber
+ if (!line) {
+ continue
+ }
+ const preview = lineMatch.preview
+ if (!preview) {
+ continue
+ }
+ let index = 0
+ const highlightedPreview: string[] = []
+ if (lineMatchIndex > 0) {
+ highlightedPreview.push('\n')
+ }
+ highlightedPreview.push(`L${line}: `)
+ let character = 0
+ for (const offsetsAndLength of lineMatch.offsetAndLengths || []) {
+ const [start, length] = offsetsAndLength
+ if (!character) {
+ // Position the cursor at the first match on the line.
+ character = start
+ }
+ const end = start + length
+ highlightedPreview.push(escapeHtml(preview.slice(index, start)))
+ highlightedPreview.push('')
+ highlightedPreview.push(escapeHtml(preview.slice(start, end)))
+ highlightedPreview.push('')
+ index = end
+ }
+ highlightedPreview.push(escapeHtml(preview.slice(index, preview.length)))
+ if (first) {
+ first = false
+ html.push('')
+ html.push(`${url}${formatStars(node?.repository?.stars)}`)
+ html.push('
')
+ }
+ const uri = `sourcegraph://${host}${url}?L${line + 1}:${character}`
+ html.push(
+ `${highlightedPreview.join('')}`
+ )
+ filenameMatchesCount++
+ if (filenameMatchesCount > 5) {
+ break
+ }
+ }
+ html.push('')
+ html.push('