265 lines
8.6 KiB
TypeScript
265 lines
8.6 KiB
TypeScript
import { Neovim } from '@chemzqm/neovim'
|
|
import { CancellationToken, Color, ColorInformation, ColorPresentation, Disposable, Position, Range } from 'vscode-languageserver-protocol'
|
|
import { TextDocument } from 'vscode-languageserver-textdocument'
|
|
import commands from '../../commands'
|
|
import { toHexString } from '../../util/color'
|
|
import Colors from '../../handler/colors/index'
|
|
import languages from '../../languages'
|
|
import { ProviderResult } from '../../provider'
|
|
import { disposeAll } from '../../util'
|
|
import path from 'path'
|
|
import helper from '../helper'
|
|
|
|
let nvim: Neovim
|
|
let state = 'normal'
|
|
let colors: Colors
|
|
let disposables: Disposable[] = []
|
|
let colorPresentations: ColorPresentation[] = []
|
|
beforeAll(async () => {
|
|
await helper.setup()
|
|
nvim = helper.nvim
|
|
await nvim.command(`source ${path.join(process.cwd(), 'autoload/coc/color.vim')}`)
|
|
colors = helper.plugin.getHandler().colors
|
|
disposables.push(languages.registerDocumentColorProvider([{ language: '*' }], {
|
|
provideColorPresentations: (
|
|
_color: Color,
|
|
_context: { document: TextDocument; range: Range },
|
|
_token: CancellationToken
|
|
): ColorPresentation[] => colorPresentations,
|
|
provideDocumentColors: (
|
|
document: TextDocument,
|
|
_token: CancellationToken
|
|
): ProviderResult<ColorInformation[]> => {
|
|
if (state == 'empty') return []
|
|
if (state == 'error') return Promise.reject(new Error('no color'))
|
|
let matches = Array.from((document.getText() as any).matchAll(/#\w{6}/g)) as any
|
|
return matches.map(o => {
|
|
let start = document.positionAt(o.index)
|
|
let end = document.positionAt(o.index + o[0].length)
|
|
return {
|
|
range: Range.create(start, end),
|
|
color: getColor(255, 255, 255)
|
|
}
|
|
})
|
|
}
|
|
}))
|
|
})
|
|
|
|
beforeEach(() => {
|
|
helper.updateConfiguration('colors.filetypes', ['*'])
|
|
})
|
|
|
|
afterAll(async () => {
|
|
disposeAll(disposables)
|
|
await helper.shutdown()
|
|
})
|
|
|
|
afterEach(async () => {
|
|
colorPresentations = []
|
|
await helper.reset()
|
|
})
|
|
|
|
function getColor(r: number, g: number, b: number): Color {
|
|
return { red: r / 255, green: g / 255, blue: b / 255, alpha: 1 }
|
|
}
|
|
|
|
describe('Colors', () => {
|
|
describe('utils', () => {
|
|
it('should get hex string', () => {
|
|
let color = getColor(255, 255, 255)
|
|
let hex = toHexString(color)
|
|
expect(hex).toBe('ffffff')
|
|
})
|
|
})
|
|
|
|
describe('configuration', () => {
|
|
it('should toggle enable state on configuration change', async () => {
|
|
let doc = await helper.createDocument()
|
|
helper.updateConfiguration('colors.filetypes', [])
|
|
let enabled = colors.isEnabled(doc.bufnr)
|
|
helper.updateConfiguration('colors.filetypes', ['*'])
|
|
expect(enabled).toBe(false)
|
|
})
|
|
})
|
|
|
|
describe('commands', () => {
|
|
it('should register editor.action.pickColor command', async () => {
|
|
await helper.mockFunction('coc#color#pick_color', [0, 0, 0])
|
|
let doc = await helper.createDocument()
|
|
await nvim.setLine('#ffffff')
|
|
doc.forceSync()
|
|
await colors.doHighlight(doc.bufnr)
|
|
await commands.executeCommand('editor.action.pickColor')
|
|
let line = await nvim.getLine()
|
|
expect(line).toBe('#000000')
|
|
})
|
|
|
|
it('should register editor.action.colorPresentation command', async () => {
|
|
colorPresentations = [ColorPresentation.create('red'), ColorPresentation.create('#ff0000')]
|
|
let doc = await helper.createDocument()
|
|
await nvim.setLine('#ffffff')
|
|
doc.forceSync()
|
|
await colors.doHighlight(doc.bufnr)
|
|
let p = commands.executeCommand('editor.action.colorPresentation')
|
|
await helper.wait(100)
|
|
await nvim.input('1<enter>')
|
|
await p
|
|
let line = await nvim.getLine()
|
|
expect(line).toBe('red')
|
|
})
|
|
})
|
|
|
|
describe('doHighlight', () => {
|
|
it('should clearHighlight on empty result', async () => {
|
|
let doc = await helper.createDocument()
|
|
await nvim.setLine('#ffffff')
|
|
state = 'empty'
|
|
await colors.doHighlight(doc.bufnr)
|
|
let res = colors.hasColor(doc.bufnr)
|
|
expect(res).toBe(false)
|
|
state = 'normal'
|
|
})
|
|
|
|
it('should not highlight on error result', async () => {
|
|
let doc = await helper.createDocument()
|
|
await nvim.setLine('#ffffff')
|
|
state = 'error'
|
|
let err
|
|
try {
|
|
await colors.doHighlight(doc.bufnr)
|
|
} catch (e) {
|
|
err = e
|
|
}
|
|
expect(err).toBeDefined()
|
|
state = 'normal'
|
|
})
|
|
|
|
it('should highlight after document changed', async () => {
|
|
let doc = await helper.createDocument()
|
|
doc.forceSync()
|
|
await colors.doHighlight(doc.bufnr)
|
|
expect(colors.hasColor(doc.bufnr)).toBe(false)
|
|
expect(colors.hasColorAtPosition(doc.bufnr, Position.create(0, 1))).toBe(false)
|
|
await nvim.setLine('#ffffff #ff0000')
|
|
await doc.synchronize()
|
|
await helper.wait(100)
|
|
expect(colors.hasColorAtPosition(doc.bufnr, Position.create(0, 1))).toBe(true)
|
|
expect(colors.hasColor(doc.bufnr)).toBe(true)
|
|
})
|
|
|
|
it('should clearHighlight on clearHighlight', async () => {
|
|
let doc = await helper.createDocument()
|
|
await nvim.setLine('#ffffff #ff0000')
|
|
doc.forceSync()
|
|
await colors.doHighlight(doc.bufnr)
|
|
expect(colors.hasColor(doc.bufnr)).toBe(true)
|
|
colors.clearHighlight(doc.bufnr)
|
|
expect(colors.hasColor(doc.bufnr)).toBe(false)
|
|
})
|
|
|
|
it('should highlight colors', async () => {
|
|
let doc = await helper.createDocument()
|
|
await nvim.setLine('#ffffff')
|
|
await colors.doHighlight(doc.bufnr)
|
|
let exists = await nvim.call('hlexists', 'BGffffff')
|
|
expect(exists).toBe(1)
|
|
})
|
|
})
|
|
|
|
describe('hasColor()', () => {
|
|
it('should return false when bufnr does not exist', async () => {
|
|
let res = colors.hasColor(99)
|
|
colors.clearHighlight(99)
|
|
expect(res).toBe(false)
|
|
})
|
|
})
|
|
|
|
describe('getColorInformation()', () => {
|
|
it('should return null when highlighter does not exist', async () => {
|
|
let res = await colors.getColorInformation(99)
|
|
expect(res).toBe(null)
|
|
})
|
|
|
|
it('should return null when color not found', async () => {
|
|
let doc = await helper.createDocument()
|
|
await nvim.setLine('#ffffff foo ')
|
|
doc.forceSync()
|
|
await colors.doHighlight(doc.bufnr)
|
|
await nvim.call('cursor', [1, 12])
|
|
let res = await colors.getColorInformation(doc.bufnr)
|
|
expect(res).toBe(null)
|
|
})
|
|
})
|
|
|
|
describe('hasColorAtPosition()', () => {
|
|
it('should return false when bufnr does not exist', async () => {
|
|
let res = colors.hasColorAtPosition(99, Position.create(0, 0))
|
|
expect(res).toBe(false)
|
|
})
|
|
})
|
|
|
|
describe('pickPresentation()', () => {
|
|
it('should show warning when color does not exist', async () => {
|
|
await helper.createDocument()
|
|
await colors.pickPresentation()
|
|
let msg = await helper.getCmdline()
|
|
expect(msg).toMatch('Color not found')
|
|
})
|
|
|
|
it('should not throw when presentations do not exist', async () => {
|
|
colorPresentations = []
|
|
let doc = await helper.createDocument()
|
|
await nvim.setLine('#ffffff')
|
|
doc.forceSync()
|
|
await colors.doHighlight(99)
|
|
await colors.doHighlight(doc.bufnr)
|
|
await helper.doAction('colorPresentation')
|
|
})
|
|
|
|
it('should pick presentations', async () => {
|
|
colorPresentations = [ColorPresentation.create('red'), ColorPresentation.create('#ff0000')]
|
|
let doc = await helper.createDocument()
|
|
await nvim.setLine('#ffffff')
|
|
doc.forceSync()
|
|
await colors.doHighlight(doc.bufnr)
|
|
let p = helper.doAction('colorPresentation')
|
|
await helper.wait(100)
|
|
await nvim.input('1<enter>')
|
|
await p
|
|
let line = await nvim.getLine()
|
|
expect(line).toBe('red')
|
|
})
|
|
})
|
|
|
|
describe('pickColor()', () => {
|
|
it('should show warning when color does not exist', async () => {
|
|
await helper.createDocument()
|
|
await colors.pickColor()
|
|
let msg = await helper.getCmdline()
|
|
expect(msg).toMatch('not found')
|
|
})
|
|
|
|
it('should pickColor', async () => {
|
|
await helper.mockFunction('coc#color#pick_color', [0, 0, 0])
|
|
let doc = await helper.createDocument()
|
|
await nvim.setLine('#ffffff')
|
|
doc.forceSync()
|
|
await colors.doHighlight(doc.bufnr)
|
|
await helper.doAction('pickColor')
|
|
let line = await nvim.getLine()
|
|
expect(line).toBe('#000000')
|
|
})
|
|
|
|
it('should not throw when pick color return 0', async () => {
|
|
await helper.mockFunction('coc#color#pick_color', 0)
|
|
let doc = await helper.createDocument()
|
|
await nvim.setLine('#ffffff')
|
|
doc.forceSync()
|
|
await colors.doHighlight(doc.bufnr)
|
|
await helper.doAction('pickColor')
|
|
let line = await nvim.getLine()
|
|
expect(line).toBe('#ffffff')
|
|
})
|
|
})
|
|
})
|