344 lines
13 KiB
TypeScript
344 lines
13 KiB
TypeScript
'use strict'
|
|
import { Neovim } from '@chemzqm/neovim'
|
|
import { CodeActionKind, Disposable, DocumentSymbol, Position, Range, SymbolKind, SymbolTag } from 'vscode-languageserver-protocol'
|
|
import events from '../../events'
|
|
import languages from '../../languages'
|
|
import BufferSync from '../../model/bufferSync'
|
|
import BasicDataProvider, { TreeNode } from '../../tree/BasicDataProvider'
|
|
import BasicTreeView from '../../tree/TreeView'
|
|
import { ConfigurationChangeEvent, HandlerDelegate } from '../../types'
|
|
import { disposeAll } from '../../util'
|
|
import { comparePosition, positionInRange } from '../../util/position'
|
|
import window from '../../window'
|
|
import workspace from '../../workspace'
|
|
import SymbolsBuffer from './buffer'
|
|
const logger = require('../../util/logger')('symbols-outline')
|
|
|
|
// Support expand level.
|
|
interface OutlineNode extends TreeNode {
|
|
kind: SymbolKind
|
|
range: Range
|
|
selectRange: Range
|
|
}
|
|
|
|
interface OutlineConfig {
|
|
splitCommand: string
|
|
switchSortKey: string
|
|
followCursor: boolean
|
|
keepWindow: boolean
|
|
expandLevel: number
|
|
checkBufferSwitch: boolean
|
|
showLineNumber: boolean
|
|
autoWidth: boolean
|
|
detailAsDescription: boolean
|
|
codeActionKinds: CodeActionKind[]
|
|
sortBy: 'position' | 'name' | 'category'
|
|
}
|
|
|
|
/**
|
|
* Manage TreeViews and Providers of outline.
|
|
*/
|
|
export default class SymbolsOutline {
|
|
private treeViewList: BasicTreeView<OutlineNode>[] = []
|
|
private providersMap: Map<number, BasicDataProvider<OutlineNode>> = new Map()
|
|
private sortByMap: Map<number, string> = new Map()
|
|
private config: OutlineConfig
|
|
private disposables: Disposable[] = []
|
|
constructor(
|
|
private nvim: Neovim,
|
|
private buffers: BufferSync<SymbolsBuffer>,
|
|
private handler: HandlerDelegate
|
|
) {
|
|
this.loadConfiguration()
|
|
workspace.onDidChangeConfiguration(this.loadConfiguration, this, this.disposables)
|
|
workspace.onDidCloseTextDocument(async e => {
|
|
let { bufnr } = e
|
|
let provider = this.providersMap.get(bufnr)
|
|
if (!provider) return
|
|
let loaded = await nvim.call('bufloaded', [bufnr]) as number
|
|
// reload detected
|
|
if (loaded) return
|
|
this.providersMap.delete(bufnr)
|
|
provider.dispose()
|
|
}, null, this.disposables)
|
|
window.onDidChangeActiveTextEditor(async editor => {
|
|
if (!this.config.checkBufferSwitch) return
|
|
let view = this.treeViewList.find(v => v.visible && v.targetTabnr == editor.tabpagenr)
|
|
if (view) {
|
|
await this.showOutline(editor.document.bufnr, editor.tabpagenr)
|
|
await nvim.command(`noa call win_gotoid(${editor.winid})`)
|
|
}
|
|
}, null, this.disposables)
|
|
events.on('CursorHold', async bufnr => {
|
|
if (!this.config.followCursor) return
|
|
let provider = this.providersMap.get(bufnr)
|
|
if (!provider) return
|
|
let tabnr = await nvim.call('tabpagenr')
|
|
let view = this.treeViewList.find(o => o.visible && o.targetBufnr == bufnr && o.targetTabnr == tabnr)
|
|
if (!view) return
|
|
let pos = await window.getCursorPosition()
|
|
await this.revealPosition(view, pos)
|
|
}, null, this.disposables)
|
|
}
|
|
|
|
private async revealPosition(treeView: BasicTreeView<OutlineNode>, position: Position): Promise<void> {
|
|
let curr: OutlineNode
|
|
let checkNode = (node: OutlineNode): boolean => {
|
|
if (positionInRange(position, node.range) != 0) return false
|
|
curr = node
|
|
if (Array.isArray(node.children)) {
|
|
for (let n of node.children) {
|
|
if (n.kind === SymbolKind.Variable) continue
|
|
if (checkNode(n)) break
|
|
}
|
|
}
|
|
return true
|
|
}
|
|
let provider = this.providersMap.get(treeView.targetBufnr)
|
|
if (!provider) return
|
|
let nodes = await Promise.resolve(provider.getChildren())
|
|
for (let n of nodes) {
|
|
if (checkNode(n)) break
|
|
}
|
|
if (curr) await treeView.reveal(curr)
|
|
}
|
|
|
|
private loadConfiguration(e?: ConfigurationChangeEvent): void {
|
|
if (!e || e.affectsConfiguration('outline')) {
|
|
let c = workspace.getConfiguration('outline')
|
|
this.config = {
|
|
splitCommand: c.get<string>('splitCommand'),
|
|
switchSortKey: c.get<string>('switchSortKey'),
|
|
followCursor: c.get<boolean>('followCursor'),
|
|
keepWindow: c.get<boolean>('keepWindow'),
|
|
expandLevel: c.get<number>('expandLevel'),
|
|
autoWidth: c.get<boolean>('autoWidth'),
|
|
checkBufferSwitch: c.get<boolean>('checkBufferSwitch'),
|
|
detailAsDescription: c.get<boolean>('detailAsDescription'),
|
|
sortBy: c.get<'position' | 'name' | 'category'>('sortBy'),
|
|
showLineNumber: c.get<boolean>('showLineNumber'),
|
|
codeActionKinds: c.get<string[]>('codeActionKinds')
|
|
}
|
|
}
|
|
}
|
|
|
|
private convertSymbolToNode(documentSymbol: DocumentSymbol, sortFn: (a: OutlineNode, b: OutlineNode) => number): OutlineNode {
|
|
let descs = []
|
|
let { detailAsDescription, showLineNumber } = this.config
|
|
if (detailAsDescription && documentSymbol.detail) descs.push(documentSymbol.detail)
|
|
if (showLineNumber) descs.push(`${documentSymbol.selectionRange.start.line + 1}`)
|
|
return {
|
|
label: documentSymbol.name,
|
|
tooltip: detailAsDescription ? undefined : documentSymbol.detail,
|
|
description: descs.join(' '),
|
|
icon: this.handler.getIcon(documentSymbol.kind),
|
|
deprecated: documentSymbol.tags?.includes(SymbolTag.Deprecated),
|
|
kind: documentSymbol.kind,
|
|
range: documentSymbol.range,
|
|
selectRange: documentSymbol.selectionRange,
|
|
children: Array.isArray(documentSymbol.children) ? documentSymbol.children.map(o => {
|
|
return this.convertSymbolToNode(o, sortFn)
|
|
}).sort(sortFn) : undefined
|
|
}
|
|
}
|
|
|
|
private setMessage(bufnr: number, msg: string | undefined): void {
|
|
let views = this.treeViewList.filter(v => v.valid && v.targetBufnr == bufnr)
|
|
if (views) {
|
|
views.forEach(view => {
|
|
view.message = msg
|
|
})
|
|
}
|
|
}
|
|
|
|
private convertSymbols(bufnr: number, symbols: DocumentSymbol[]): OutlineNode[] {
|
|
let sortBy = this.getSortBy(bufnr)
|
|
let sortFn = (a: OutlineNode, b: OutlineNode): number => {
|
|
if (sortBy === 'name') {
|
|
return a.label < b.label ? -1 : 1
|
|
}
|
|
if (sortBy === 'category') {
|
|
if (a.kind == b.kind) return a.label < b.label ? -1 : 1
|
|
return a.kind - b.kind
|
|
}
|
|
return comparePosition(a.selectRange.start, b.selectRange.start)
|
|
}
|
|
return symbols.map(s => this.convertSymbolToNode(s, sortFn)).sort(sortFn)
|
|
}
|
|
|
|
public onSymbolsUpdate(bufnr: number, symbols: DocumentSymbol[]): void {
|
|
let provider = this.providersMap.get(bufnr)
|
|
if (provider) provider.update(this.convertSymbols(bufnr, symbols))
|
|
}
|
|
|
|
private createProvider(bufnr: number): BasicDataProvider<OutlineNode> {
|
|
let { nvim } = this
|
|
let disposable: Disposable
|
|
let provider = new BasicDataProvider({
|
|
expandLevel: this.config.expandLevel,
|
|
provideData: async () => {
|
|
let buf = this.buffers.getItem(bufnr)
|
|
if (!buf) throw new Error('Document not attached')
|
|
let doc = workspace.getDocument(bufnr)
|
|
if (!languages.hasProvider('documentSymbol', doc.textDocument)) {
|
|
throw new Error('Document symbol provider not found')
|
|
}
|
|
let meta = languages.getDocumentSymbolMetadata(doc.textDocument)
|
|
if (meta && meta.label) {
|
|
let views = this.treeViewList.filter(v => v.valid && v.targetBufnr == bufnr)
|
|
views.forEach(view => view.description = meta.label)
|
|
}
|
|
this.setMessage(bufnr, 'Loading document symbols')
|
|
let arr = await buf.getSymbols()
|
|
if (!arr || arr.length == 0) {
|
|
// server may return empty symbols on buffer initialize, throw error to force reload.
|
|
throw new Error('Empty symbols returned from language server. ')
|
|
}
|
|
this.setMessage(bufnr, undefined)
|
|
return this.convertSymbols(bufnr, arr)
|
|
},
|
|
handleClick: async item => {
|
|
let winnr = await nvim.call('bufwinnr', [bufnr])
|
|
if (winnr == -1) return
|
|
nvim.pauseNotification()
|
|
nvim.command(`${winnr}wincmd w`, true)
|
|
let pos = item.selectRange.start
|
|
nvim.call('coc#cursor#move_to', [pos.line, pos.character], true)
|
|
nvim.command(`normal! zz`, true)
|
|
let buf = nvim.createBuffer(bufnr)
|
|
buf.highlightRanges('outline-hover', 'CocHoverRange', [item.selectRange])
|
|
nvim.command('redraw', true)
|
|
await nvim.resumeNotification()
|
|
setTimeout(() => {
|
|
buf.clearNamespace('outline-hover')
|
|
nvim.command('redraw', true)
|
|
}, global.hasOwnProperty('__TEST__') ? 10 : 300)
|
|
},
|
|
resolveActions: async (_, element) => {
|
|
let winnr = await nvim.call('bufwinnr', [bufnr])
|
|
if (winnr == -1) return
|
|
let doc = workspace.getDocument(bufnr)
|
|
let actions = await this.handler.getCodeActions(doc, element.range, this.config.codeActionKinds)
|
|
let arr = actions.map(o => {
|
|
return {
|
|
title: o.title,
|
|
handler: async () => {
|
|
let position = element.range.start
|
|
await nvim.command(`${winnr}wincmd w`)
|
|
await this.nvim.call('coc#cursor#move_to', [position.line, position.character])
|
|
await this.handler.applyCodeAction(o)
|
|
}
|
|
}
|
|
})
|
|
return [...arr, {
|
|
title: 'Visual Select',
|
|
handler: async item => {
|
|
await nvim.command(`${winnr}wincmd w`)
|
|
await window.selectRange(item.range)
|
|
}
|
|
}]
|
|
},
|
|
onDispose: () => {
|
|
if (disposable) disposable.dispose()
|
|
for (let view of this.treeViewList) {
|
|
if (view.provider === provider) view.dispose()
|
|
}
|
|
}
|
|
})
|
|
return provider
|
|
}
|
|
|
|
private getSortBy(bufnr: number): string {
|
|
return this.sortByMap.get(bufnr) ?? this.config.sortBy
|
|
}
|
|
|
|
private async showOutline(bufnr: number, tabnr: number): Promise<BasicTreeView<OutlineNode>> {
|
|
if (!this.providersMap.has(bufnr)) {
|
|
this.providersMap.set(bufnr, this.createProvider(bufnr))
|
|
}
|
|
let treeView = this.treeViewList.find(v => v.valid && v.targetBufnr == bufnr && v.targetTabnr == tabnr)
|
|
if (!treeView) {
|
|
treeView = new BasicTreeView('OUTLINE', {
|
|
autoWidth: this.config.autoWidth,
|
|
bufhidden: 'hide',
|
|
enableFilter: true,
|
|
treeDataProvider: this.providersMap.get(bufnr),
|
|
})
|
|
let sortBy = this.getSortBy(bufnr)
|
|
treeView.description = `${sortBy[0].toUpperCase()}${sortBy.slice(1)}`
|
|
this.treeViewList.push(treeView)
|
|
treeView.onDispose(() => {
|
|
let idx = this.treeViewList.findIndex(v => v === treeView)
|
|
if (idx !== -1) this.treeViewList.splice(idx, 1)
|
|
})
|
|
}
|
|
let shown = await treeView.show(this.config.splitCommand)
|
|
if (shown) {
|
|
treeView.registerLocalKeymap('n', this.config.switchSortKey, async () => {
|
|
let arr = ['category', 'name', 'position']
|
|
let curr = this.getSortBy(bufnr)
|
|
let items = arr.map(s => {
|
|
return { text: s, disabled: s === curr }
|
|
})
|
|
let res = await window.showMenuPicker(items, { title: 'Choose sort method' })
|
|
if (res < 0) return
|
|
let sortBy = arr[res]
|
|
this.sortByMap.set(bufnr, sortBy)
|
|
let views = this.treeViewList.filter(o => o.targetBufnr == bufnr)
|
|
views.forEach(view => {
|
|
view.description = `${sortBy[0].toUpperCase()}${sortBy.slice(1)}`
|
|
})
|
|
let item = this.buffers.getItem(bufnr)
|
|
if (item && item.symbols) this.onSymbolsUpdate(bufnr, item.symbols)
|
|
})
|
|
}
|
|
return treeView
|
|
}
|
|
|
|
/**
|
|
* Create outline view.
|
|
*/
|
|
public async show(keep?: number): Promise<void> {
|
|
let [filetype, bufnr, tabnr, winid] = await this.nvim.eval('[&filetype,bufnr("%"),tabpagenr(),win_getid()]') as [string, number, number, number]
|
|
if (filetype === 'coctree') return
|
|
let position = await window.getCursorPosition()
|
|
let treeView = await this.showOutline(bufnr, tabnr)
|
|
if (keep == 1 || (keep === undefined && this.config.keepWindow)) {
|
|
await this.nvim.command(`noa call win_gotoid(${winid})`)
|
|
} else if (this.config.followCursor) {
|
|
let disposable = treeView.onDidRefrash(async () => {
|
|
disposable.dispose()
|
|
let filetype = await this.nvim.eval('&filetype')
|
|
if (filetype == 'coctree' && treeView.visible) {
|
|
await this.revealPosition(treeView, position)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
public has(bufnr: number): boolean {
|
|
return this.providersMap.has(bufnr)
|
|
}
|
|
|
|
/**
|
|
* Hide outline of current tab.
|
|
*/
|
|
public async hide(): Promise<void> {
|
|
let winid = await this.nvim.call('coc#window#find', ['cocViewId', 'OUTLINE']) as number
|
|
if (winid == -1) return
|
|
await this.nvim.call('coc#window#close', [winid])
|
|
}
|
|
|
|
public dispose(): void {
|
|
for (let view of this.treeViewList) {
|
|
view.dispose()
|
|
}
|
|
this.treeViewList = []
|
|
for (let provider of this.providersMap.values()) {
|
|
provider.dispose()
|
|
}
|
|
this.providersMap.clear()
|
|
disposeAll(this.disposables)
|
|
}
|
|
}
|