2017-12-01 04:13:30 +03:00
|
|
|
const {it, fit, ffit, fffit, beforeEach, afterEach} = require('./async-spec-helpers')
|
|
|
|
|
|
|
|
const dedent = require('dedent')
|
|
|
|
const TextBuffer = require('text-buffer')
|
2018-01-03 20:34:12 +03:00
|
|
|
const {Point} = TextBuffer
|
2017-12-01 04:13:30 +03:00
|
|
|
const TextEditor = require('../src/text-editor')
|
|
|
|
const TreeSitterGrammar = require('../src/tree-sitter-grammar')
|
|
|
|
const TreeSitterLanguageMode = require('../src/tree-sitter-language-mode')
|
|
|
|
|
2017-12-06 22:09:44 +03:00
|
|
|
const cGrammarPath = require.resolve('language-c/grammars/tree-sitter-c.cson')
|
|
|
|
const pythonGrammarPath = require.resolve('language-python/grammars/tree-sitter-python.cson')
|
2017-12-01 04:13:30 +03:00
|
|
|
const jsGrammarPath = require.resolve('language-javascript/grammars/tree-sitter-javascript.cson')
|
2018-06-19 00:27:49 +03:00
|
|
|
const htmlGrammarPath = require.resolve('language-html/grammars/tree-sitter-html.cson')
|
2017-12-01 04:13:30 +03:00
|
|
|
|
|
|
|
describe('TreeSitterLanguageMode', () => {
|
|
|
|
let editor, buffer
|
|
|
|
|
|
|
|
beforeEach(async () => {
|
|
|
|
editor = await atom.workspace.open('')
|
|
|
|
buffer = editor.getBuffer()
|
|
|
|
})
|
|
|
|
|
|
|
|
describe('highlighting', () => {
|
2018-05-16 03:53:47 +03:00
|
|
|
it('applies the most specific scope mapping to each node in the syntax tree', async () => {
|
2017-12-04 21:18:38 +03:00
|
|
|
const grammar = new TreeSitterGrammar(atom.grammars, jsGrammarPath, {
|
2017-12-01 04:13:30 +03:00
|
|
|
parser: 'tree-sitter-javascript',
|
|
|
|
scopes: {
|
|
|
|
'program': 'source',
|
|
|
|
'call_expression > identifier': 'function',
|
|
|
|
'property_identifier': 'property',
|
|
|
|
'call_expression > member_expression > property_identifier': 'method'
|
|
|
|
}
|
|
|
|
})
|
|
|
|
|
2018-06-27 23:36:17 +03:00
|
|
|
buffer.setText('aa.bbb = cc(d.eee());')
|
|
|
|
|
2018-05-16 03:53:47 +03:00
|
|
|
const languageMode = new TreeSitterLanguageMode({buffer, grammar})
|
|
|
|
buffer.setLanguageMode(languageMode)
|
|
|
|
await languageMode.reparsePromise
|
|
|
|
|
2017-12-15 20:44:45 +03:00
|
|
|
expectTokensToEqual(editor, [[
|
2017-12-01 04:13:30 +03:00
|
|
|
{text: 'aa.', scopes: ['source']},
|
|
|
|
{text: 'bbb', scopes: ['source', 'property']},
|
|
|
|
{text: ' = ', scopes: ['source']},
|
|
|
|
{text: 'cc', scopes: ['source', 'function']},
|
|
|
|
{text: '(d.', scopes: ['source']},
|
|
|
|
{text: 'eee', scopes: ['source', 'method']},
|
|
|
|
{text: '());', scopes: ['source']}
|
2017-12-15 20:44:45 +03:00
|
|
|
]])
|
2017-12-04 21:18:38 +03:00
|
|
|
})
|
|
|
|
|
2018-05-16 03:53:47 +03:00
|
|
|
it('can start or end multiple scopes at the same position', async () => {
|
2017-12-04 21:18:38 +03:00
|
|
|
const grammar = new TreeSitterGrammar(atom.grammars, jsGrammarPath, {
|
|
|
|
parser: 'tree-sitter-javascript',
|
|
|
|
scopes: {
|
|
|
|
'program': 'source',
|
|
|
|
'call_expression': 'call',
|
|
|
|
'member_expression': 'member',
|
|
|
|
'identifier': 'variable',
|
|
|
|
'"("': 'open-paren',
|
|
|
|
'")"': 'close-paren',
|
|
|
|
}
|
|
|
|
})
|
|
|
|
|
2018-06-27 23:36:17 +03:00
|
|
|
buffer.setText('a = bb.ccc();')
|
|
|
|
|
2018-05-16 03:53:47 +03:00
|
|
|
const languageMode = new TreeSitterLanguageMode({buffer, grammar})
|
|
|
|
buffer.setLanguageMode(languageMode)
|
|
|
|
await languageMode.reparsePromise
|
|
|
|
|
2017-12-15 20:44:45 +03:00
|
|
|
expectTokensToEqual(editor, [[
|
2017-12-04 21:18:38 +03:00
|
|
|
{text: 'a', scopes: ['source', 'variable']},
|
|
|
|
{text: ' = ', scopes: ['source']},
|
|
|
|
{text: 'bb', scopes: ['source', 'call', 'member', 'variable']},
|
|
|
|
{text: '.ccc', scopes: ['source', 'call', 'member']},
|
|
|
|
{text: '(', scopes: ['source', 'call', 'open-paren']},
|
|
|
|
{text: ')', scopes: ['source', 'call', 'close-paren']},
|
|
|
|
{text: ';', scopes: ['source']}
|
2017-12-15 20:44:45 +03:00
|
|
|
]])
|
|
|
|
})
|
|
|
|
|
2018-05-16 03:53:47 +03:00
|
|
|
it('can resume highlighting on a line that starts with whitespace', async () => {
|
2017-12-15 20:44:45 +03:00
|
|
|
const grammar = new TreeSitterGrammar(atom.grammars, jsGrammarPath, {
|
|
|
|
parser: 'tree-sitter-javascript',
|
|
|
|
scopes: {
|
|
|
|
'call_expression > member_expression > property_identifier': 'function',
|
|
|
|
'property_identifier': 'member',
|
|
|
|
'identifier': 'variable'
|
|
|
|
}
|
|
|
|
})
|
|
|
|
|
2018-06-27 23:36:17 +03:00
|
|
|
buffer.setText('a\n .b();')
|
|
|
|
|
2018-05-16 03:53:47 +03:00
|
|
|
const languageMode = new TreeSitterLanguageMode({buffer, grammar})
|
|
|
|
buffer.setLanguageMode(languageMode)
|
|
|
|
await languageMode.reparsePromise
|
|
|
|
|
2017-12-15 20:44:45 +03:00
|
|
|
expectTokensToEqual(editor, [
|
|
|
|
[
|
|
|
|
{text: 'a', scopes: ['variable']},
|
|
|
|
],
|
|
|
|
[
|
|
|
|
{text: ' ', scopes: ['whitespace']},
|
|
|
|
{text: '.', scopes: []},
|
|
|
|
{text: 'b', scopes: ['function']},
|
|
|
|
{text: '();', scopes: []}
|
|
|
|
]
|
2017-12-04 21:18:38 +03:00
|
|
|
])
|
2017-12-01 04:13:30 +03:00
|
|
|
})
|
2018-01-03 20:34:12 +03:00
|
|
|
|
2018-05-16 03:53:47 +03:00
|
|
|
it('correctly skips over tokens with zero size', async () => {
|
2018-01-03 20:34:12 +03:00
|
|
|
const grammar = new TreeSitterGrammar(atom.grammars, jsGrammarPath, {
|
|
|
|
parser: 'tree-sitter-c',
|
|
|
|
scopes: {
|
|
|
|
'primitive_type': 'type',
|
|
|
|
'identifier': 'variable',
|
|
|
|
}
|
|
|
|
})
|
|
|
|
|
2018-06-27 23:36:17 +03:00
|
|
|
buffer.setText('int main() {\n int a\n int b;\n}');
|
|
|
|
|
2018-01-03 20:34:12 +03:00
|
|
|
const languageMode = new TreeSitterLanguageMode({buffer, grammar})
|
|
|
|
buffer.setLanguageMode(languageMode)
|
2018-05-16 03:53:47 +03:00
|
|
|
await languageMode.reparsePromise
|
2018-01-03 20:34:12 +03:00
|
|
|
|
|
|
|
editor.screenLineForScreenRow(0)
|
|
|
|
expect(
|
2018-05-16 03:53:47 +03:00
|
|
|
languageMode.tree.rootNode.descendantForPosition(Point(1, 2), Point(1, 6)).toString()
|
2018-01-03 20:34:12 +03:00
|
|
|
).toBe('(declaration (primitive_type) (identifier) (MISSING))')
|
|
|
|
|
|
|
|
expectTokensToEqual(editor, [
|
|
|
|
[
|
|
|
|
{text: 'int', scopes: ['type']},
|
|
|
|
{text: ' ', scopes: []},
|
|
|
|
{text: 'main', scopes: ['variable']},
|
|
|
|
{text: '() {', scopes: []}
|
|
|
|
],
|
|
|
|
[
|
|
|
|
{text: ' ', scopes: ['whitespace']},
|
|
|
|
{text: 'int', scopes: ['type']},
|
|
|
|
{text: ' ', scopes: []},
|
|
|
|
{text: 'a', scopes: ['variable']}
|
|
|
|
],
|
|
|
|
[
|
|
|
|
{text: ' ', scopes: ['whitespace']},
|
|
|
|
{text: 'int', scopes: ['type']},
|
|
|
|
{text: ' ', scopes: []},
|
|
|
|
{text: 'b', scopes: ['variable']},
|
|
|
|
{text: ';', scopes: []}
|
|
|
|
],
|
|
|
|
[
|
|
|
|
{text: '}', scopes: []}
|
|
|
|
]
|
|
|
|
])
|
|
|
|
})
|
2018-01-26 01:02:31 +03:00
|
|
|
|
2018-05-16 03:53:47 +03:00
|
|
|
it('updates lines\' highlighting when they are affected by distant changes', async () => {
|
2018-01-26 01:02:31 +03:00
|
|
|
const grammar = new TreeSitterGrammar(atom.grammars, jsGrammarPath, {
|
|
|
|
parser: 'tree-sitter-javascript',
|
|
|
|
scopes: {
|
|
|
|
'call_expression > identifier': 'function',
|
|
|
|
'property_identifier': 'member'
|
|
|
|
}
|
|
|
|
})
|
|
|
|
|
2018-06-27 23:36:17 +03:00
|
|
|
buffer.setText('a(\nb,\nc\n')
|
|
|
|
|
2018-05-16 03:53:47 +03:00
|
|
|
const languageMode = new TreeSitterLanguageMode({buffer, grammar})
|
|
|
|
buffer.setLanguageMode(languageMode)
|
|
|
|
await languageMode.reparsePromise
|
2018-01-26 01:02:31 +03:00
|
|
|
|
|
|
|
// missing closing paren
|
|
|
|
expectTokensToEqual(editor, [
|
|
|
|
[{text: 'a(', scopes: []}],
|
|
|
|
[{text: 'b,', scopes: []}],
|
|
|
|
[{text: 'c', scopes: []}],
|
|
|
|
[{text: '', scopes: []}]
|
|
|
|
])
|
|
|
|
|
|
|
|
buffer.append(')')
|
2018-05-16 03:53:47 +03:00
|
|
|
await languageMode.reparsePromise
|
2018-01-26 01:02:31 +03:00
|
|
|
expectTokensToEqual(editor, [
|
|
|
|
[
|
|
|
|
{text: 'a', scopes: ['function']},
|
|
|
|
{text: '(', scopes: []}
|
|
|
|
],
|
|
|
|
[{text: 'b,', scopes: []}],
|
|
|
|
[{text: 'c', scopes: []}],
|
|
|
|
[{text: ')', scopes: []}]
|
|
|
|
])
|
|
|
|
})
|
2018-02-14 18:49:02 +03:00
|
|
|
|
2018-05-16 03:53:47 +03:00
|
|
|
it('handles edits after tokens that end between CR and LF characters (regression)', async () => {
|
2018-02-14 18:49:02 +03:00
|
|
|
const grammar = new TreeSitterGrammar(atom.grammars, jsGrammarPath, {
|
|
|
|
parser: 'tree-sitter-javascript',
|
|
|
|
scopes: {
|
|
|
|
'comment': 'comment',
|
|
|
|
'string': 'string',
|
|
|
|
'property_identifier': 'property',
|
|
|
|
}
|
|
|
|
})
|
|
|
|
|
|
|
|
buffer.setText([
|
|
|
|
'// abc',
|
|
|
|
'',
|
|
|
|
'a("b").c'
|
|
|
|
].join('\r\n'))
|
2018-06-27 23:36:17 +03:00
|
|
|
|
|
|
|
const languageMode = new TreeSitterLanguageMode({buffer, grammar})
|
|
|
|
buffer.setLanguageMode(languageMode)
|
2018-05-16 03:53:47 +03:00
|
|
|
await languageMode.reparsePromise
|
2018-02-14 18:49:02 +03:00
|
|
|
|
|
|
|
expectTokensToEqual(editor, [
|
|
|
|
[{text: '// abc', scopes: ['comment']}],
|
|
|
|
[{text: '', scopes: []}],
|
|
|
|
[
|
|
|
|
{text: 'a(', scopes: []},
|
|
|
|
{text: '"b"', scopes: ['string']},
|
|
|
|
{text: ').', scopes: []},
|
|
|
|
{text: 'c', scopes: ['property']}
|
|
|
|
]
|
|
|
|
])
|
|
|
|
|
|
|
|
buffer.insert([2, 0], ' ')
|
2018-05-16 03:53:47 +03:00
|
|
|
await languageMode.reparsePromise
|
2018-02-14 18:49:02 +03:00
|
|
|
expectTokensToEqual(editor, [
|
|
|
|
[{text: '// abc', scopes: ['comment']}],
|
|
|
|
[{text: '', scopes: []}],
|
|
|
|
[
|
|
|
|
{text: ' ', scopes: ['whitespace']},
|
|
|
|
{text: 'a(', scopes: []},
|
|
|
|
{text: '"b"', scopes: ['string']},
|
|
|
|
{text: ').', scopes: []},
|
|
|
|
{text: 'c', scopes: ['property']}
|
|
|
|
]
|
|
|
|
])
|
|
|
|
})
|
2018-05-22 21:12:40 +03:00
|
|
|
|
|
|
|
describe('when the buffer changes during a parse', () => {
|
|
|
|
it('immediately parses again when the current parse completes', async () => {
|
|
|
|
const grammar = new TreeSitterGrammar(atom.grammars, jsGrammarPath, {
|
|
|
|
parser: 'tree-sitter-javascript',
|
|
|
|
scopes: {
|
|
|
|
'identifier': 'variable',
|
|
|
|
'call_expression > identifier': 'function',
|
|
|
|
'new_expression > call_expression > identifier': 'constructor'
|
|
|
|
}
|
|
|
|
})
|
|
|
|
|
|
|
|
buffer.setText('abc;');
|
2018-06-27 23:36:17 +03:00
|
|
|
|
|
|
|
const languageMode = new TreeSitterLanguageMode({buffer, grammar})
|
|
|
|
buffer.setLanguageMode(languageMode)
|
2018-05-22 21:12:40 +03:00
|
|
|
await languageMode.reparsePromise
|
2018-06-27 23:36:17 +03:00
|
|
|
|
2018-05-22 21:12:40 +03:00
|
|
|
expectTokensToEqual(editor, [
|
|
|
|
[
|
|
|
|
{text: 'abc', scopes: ['variable']},
|
|
|
|
{text: ';', scopes: []}
|
|
|
|
],
|
|
|
|
])
|
|
|
|
|
|
|
|
buffer.setTextInRange([[0, 3], [0, 3]], '()');
|
|
|
|
expectTokensToEqual(editor, [
|
|
|
|
[
|
|
|
|
{text: 'abc()', scopes: ['variable']},
|
|
|
|
{text: ';', scopes: []}
|
|
|
|
],
|
|
|
|
])
|
|
|
|
|
|
|
|
buffer.setTextInRange([[0, 0], [0, 0]], 'new ');
|
|
|
|
expectTokensToEqual(editor, [
|
|
|
|
[
|
|
|
|
{text: 'new ', scopes: []},
|
|
|
|
{text: 'abc()', scopes: ['variable']},
|
|
|
|
{text: ';', scopes: []}
|
|
|
|
],
|
|
|
|
])
|
|
|
|
|
|
|
|
await languageMode.reparsePromise
|
|
|
|
expect(languageMode.reparsePromise).not.toBeNull()
|
|
|
|
expectTokensToEqual(editor, [
|
|
|
|
[
|
|
|
|
{text: 'new ', scopes: []},
|
|
|
|
{text: 'abc', scopes: ['function']},
|
|
|
|
{text: '();', scopes: []}
|
|
|
|
],
|
|
|
|
])
|
|
|
|
|
|
|
|
await languageMode.reparsePromise
|
|
|
|
expect(languageMode.reparsePromise).toBeNull()
|
|
|
|
expectTokensToEqual(editor, [
|
|
|
|
[
|
|
|
|
{text: 'new ', scopes: []},
|
|
|
|
{text: 'abc', scopes: ['constructor']},
|
|
|
|
{text: '();', scopes: []}
|
|
|
|
],
|
|
|
|
])
|
|
|
|
})
|
|
|
|
})
|
2018-06-22 03:06:55 +03:00
|
|
|
|
2018-06-27 23:36:17 +03:00
|
|
|
describe('injectionPoints and injectionPatterns', () => {
|
2018-06-27 01:30:03 +03:00
|
|
|
let jsGrammar, htmlGrammar
|
|
|
|
|
|
|
|
beforeEach(() => {
|
|
|
|
jsGrammar = new TreeSitterGrammar(atom.grammars, jsGrammarPath, {
|
|
|
|
id: 'javascript',
|
2018-06-22 03:06:55 +03:00
|
|
|
parser: 'tree-sitter-javascript',
|
|
|
|
scopes: {
|
|
|
|
'property_identifier': 'property',
|
|
|
|
'call_expression > identifier': 'function',
|
2018-06-27 01:30:03 +03:00
|
|
|
'template_string': 'string',
|
|
|
|
'template_substitution > "${"': 'interpolation',
|
|
|
|
'template_substitution > "}"': 'interpolation'
|
2018-06-22 03:06:55 +03:00
|
|
|
},
|
2018-06-26 23:46:33 +03:00
|
|
|
injectionPoints: [{
|
|
|
|
type: 'call_expression',
|
2018-06-27 23:13:08 +03:00
|
|
|
language (node) {
|
2018-06-26 23:46:33 +03:00
|
|
|
if (node.lastChild.type === 'template_string' && node.firstChild.type === 'identifier') {
|
2018-06-27 23:13:08 +03:00
|
|
|
return node.firstChild.text
|
2018-06-26 23:46:33 +03:00
|
|
|
}
|
|
|
|
},
|
2018-06-27 23:13:08 +03:00
|
|
|
content (node) {
|
|
|
|
return node.lastChild
|
|
|
|
}
|
2018-06-26 23:46:33 +03:00
|
|
|
}]
|
2018-06-22 03:06:55 +03:00
|
|
|
})
|
|
|
|
|
2018-06-27 01:30:03 +03:00
|
|
|
htmlGrammar = new TreeSitterGrammar(atom.grammars, htmlGrammarPath, {
|
|
|
|
id: 'html',
|
2018-06-22 03:06:55 +03:00
|
|
|
parser: 'tree-sitter-html',
|
|
|
|
scopes: {
|
2018-06-27 01:30:03 +03:00
|
|
|
fragment: 'html',
|
2018-06-22 03:06:55 +03:00
|
|
|
tag_name: 'tag',
|
|
|
|
attribute_name: 'attr'
|
|
|
|
},
|
2018-06-27 22:39:29 +03:00
|
|
|
injectionRegExp: 'html'
|
2018-06-22 03:06:55 +03:00
|
|
|
})
|
|
|
|
|
2018-06-27 01:30:03 +03:00
|
|
|
atom.grammars.addGrammar(jsGrammar)
|
2018-06-22 03:06:55 +03:00
|
|
|
atom.grammars.addGrammar(htmlGrammar)
|
2018-06-27 01:30:03 +03:00
|
|
|
})
|
2018-06-22 03:06:55 +03:00
|
|
|
|
2018-06-27 01:30:03 +03:00
|
|
|
it('highlights code inside of injection points', async () => {
|
2018-06-27 23:36:17 +03:00
|
|
|
buffer.setText('node.innerHTML = html `a ${b}<img src="d">\n`;')
|
|
|
|
|
2018-06-22 03:06:55 +03:00
|
|
|
const languageMode = new TreeSitterLanguageMode({buffer, grammar: jsGrammar, grammars: atom.grammars})
|
|
|
|
buffer.setLanguageMode(languageMode)
|
|
|
|
await languageMode.reparsePromise
|
|
|
|
|
|
|
|
expectTokensToEqual(editor, [
|
|
|
|
[
|
|
|
|
{text: 'node.', scopes: []},
|
|
|
|
{text: 'innerHTML', scopes: ['property']},
|
|
|
|
{text: ' = ', scopes: []},
|
|
|
|
{text: 'html', scopes: ['function']},
|
|
|
|
{text: ' ', scopes: []},
|
2018-06-27 01:30:03 +03:00
|
|
|
{text: '`', scopes: ['string']},
|
|
|
|
{text: 'a ', scopes: ['string', 'html']},
|
|
|
|
{text: '${', scopes: ['string', 'html', 'interpolation']},
|
|
|
|
{text: 'b', scopes: ['string', 'html']},
|
|
|
|
{text: '}', scopes: ['string', 'html', 'interpolation']},
|
|
|
|
{text: '<', scopes: ['string', 'html']},
|
|
|
|
{text: 'img', scopes: ['string', 'html', 'tag']},
|
|
|
|
{text: ' ', scopes: ['string', 'html']},
|
|
|
|
{text: 'src', scopes: ['string', 'html', 'attr']},
|
|
|
|
{text: '="d">', scopes: ['string', 'html']},
|
|
|
|
], [
|
|
|
|
{text: '`', scopes: ['string']},
|
2018-06-22 03:06:55 +03:00
|
|
|
{text: ';', scopes: []},
|
|
|
|
],
|
|
|
|
])
|
|
|
|
})
|
|
|
|
})
|
2017-12-01 04:13:30 +03:00
|
|
|
})
|
2017-12-04 22:02:24 +03:00
|
|
|
|
|
|
|
describe('folding', () => {
|
|
|
|
beforeEach(() => {
|
|
|
|
editor.displayLayer.reset({foldCharacter: '…'})
|
|
|
|
})
|
|
|
|
|
2018-05-16 03:53:47 +03:00
|
|
|
it('can fold nodes that start and end with specified tokens', async () => {
|
2017-12-04 22:02:24 +03:00
|
|
|
const grammar = new TreeSitterGrammar(atom.grammars, jsGrammarPath, {
|
|
|
|
parser: 'tree-sitter-javascript',
|
2017-12-05 23:39:52 +03:00
|
|
|
folds: [
|
|
|
|
{
|
|
|
|
start: {type: '{', index: 0},
|
|
|
|
end: {type: '}', index: -1}
|
|
|
|
},
|
|
|
|
{
|
|
|
|
start: {type: '(', index: 0},
|
|
|
|
end: {type: ')', index: -1}
|
|
|
|
}
|
|
|
|
]
|
2017-12-04 22:02:24 +03:00
|
|
|
})
|
|
|
|
|
|
|
|
buffer.setText(dedent `
|
|
|
|
module.exports =
|
|
|
|
class A {
|
|
|
|
getB (c,
|
|
|
|
d,
|
|
|
|
e) {
|
2017-12-05 23:39:52 +03:00
|
|
|
return this.f(g)
|
2017-12-04 22:02:24 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
`)
|
2018-06-27 23:36:17 +03:00
|
|
|
|
|
|
|
const languageMode = new TreeSitterLanguageMode({buffer, grammar})
|
|
|
|
buffer.setLanguageMode(languageMode)
|
2018-05-16 03:53:47 +03:00
|
|
|
await languageMode.reparsePromise
|
2017-12-04 22:02:24 +03:00
|
|
|
|
|
|
|
editor.screenLineForScreenRow(0)
|
|
|
|
|
|
|
|
expect(editor.isFoldableAtBufferRow(0)).toBe(false)
|
|
|
|
expect(editor.isFoldableAtBufferRow(1)).toBe(true)
|
|
|
|
expect(editor.isFoldableAtBufferRow(2)).toBe(true)
|
|
|
|
expect(editor.isFoldableAtBufferRow(3)).toBe(false)
|
|
|
|
expect(editor.isFoldableAtBufferRow(4)).toBe(true)
|
2017-12-06 22:09:44 +03:00
|
|
|
expect(editor.isFoldableAtBufferRow(5)).toBe(false)
|
2017-12-04 22:02:24 +03:00
|
|
|
|
|
|
|
editor.foldBufferRow(2)
|
|
|
|
expect(getDisplayText(editor)).toBe(dedent `
|
|
|
|
module.exports =
|
|
|
|
class A {
|
|
|
|
getB (…) {
|
2017-12-05 23:39:52 +03:00
|
|
|
return this.f(g)
|
2017-12-04 22:02:24 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
`)
|
|
|
|
|
|
|
|
editor.foldBufferRow(4)
|
|
|
|
expect(getDisplayText(editor)).toBe(dedent `
|
|
|
|
module.exports =
|
|
|
|
class A {
|
|
|
|
getB (…) {…}
|
|
|
|
}
|
|
|
|
`)
|
|
|
|
})
|
2017-12-04 22:40:44 +03:00
|
|
|
|
2018-05-16 03:53:47 +03:00
|
|
|
it('can fold nodes of specified types', async () => {
|
2017-12-05 23:39:52 +03:00
|
|
|
const grammar = new TreeSitterGrammar(atom.grammars, jsGrammarPath, {
|
|
|
|
parser: 'tree-sitter-javascript',
|
|
|
|
folds: [
|
2017-12-06 22:09:44 +03:00
|
|
|
// Start the fold after the first child (the opening tag) and end it at the last child
|
|
|
|
// (the closing tag).
|
2017-12-05 23:39:52 +03:00
|
|
|
{
|
|
|
|
type: 'jsx_element',
|
2017-12-06 22:09:44 +03:00
|
|
|
start: {index: 0},
|
|
|
|
end: {index: -1}
|
2017-12-05 23:39:52 +03:00
|
|
|
},
|
2017-12-06 22:09:44 +03:00
|
|
|
|
|
|
|
// End the fold at the *second* to last child of the self-closing tag: the `/`.
|
2017-12-05 23:39:52 +03:00
|
|
|
{
|
|
|
|
type: 'jsx_self_closing_element',
|
|
|
|
start: {index: 1},
|
2017-12-06 22:09:44 +03:00
|
|
|
end: {index: -2}
|
|
|
|
}
|
2017-12-05 23:39:52 +03:00
|
|
|
]
|
|
|
|
})
|
|
|
|
|
|
|
|
buffer.setText(dedent `
|
|
|
|
const element1 = <Element
|
|
|
|
className='submit'
|
|
|
|
id='something' />
|
|
|
|
|
|
|
|
const element2 = <Element>
|
|
|
|
<span>hello</span>
|
|
|
|
<span>world</span>
|
|
|
|
</Element>
|
|
|
|
`)
|
2018-06-27 23:36:17 +03:00
|
|
|
|
|
|
|
const languageMode = new TreeSitterLanguageMode({buffer, grammar})
|
|
|
|
buffer.setLanguageMode(languageMode)
|
2018-05-16 03:53:47 +03:00
|
|
|
await languageMode.reparsePromise
|
2017-12-05 23:39:52 +03:00
|
|
|
|
|
|
|
editor.screenLineForScreenRow(0)
|
|
|
|
|
|
|
|
expect(editor.isFoldableAtBufferRow(0)).toBe(true)
|
|
|
|
expect(editor.isFoldableAtBufferRow(1)).toBe(false)
|
|
|
|
expect(editor.isFoldableAtBufferRow(2)).toBe(false)
|
|
|
|
expect(editor.isFoldableAtBufferRow(3)).toBe(false)
|
|
|
|
expect(editor.isFoldableAtBufferRow(4)).toBe(true)
|
|
|
|
expect(editor.isFoldableAtBufferRow(5)).toBe(false)
|
|
|
|
|
|
|
|
editor.foldBufferRow(0)
|
|
|
|
expect(getDisplayText(editor)).toBe(dedent `
|
|
|
|
const element1 = <Element…/>
|
|
|
|
|
|
|
|
const element2 = <Element>
|
|
|
|
<span>hello</span>
|
|
|
|
<span>world</span>
|
|
|
|
</Element>
|
|
|
|
`)
|
|
|
|
|
|
|
|
editor.foldBufferRow(4)
|
|
|
|
expect(getDisplayText(editor)).toBe(dedent `
|
|
|
|
const element1 = <Element…/>
|
|
|
|
|
2017-12-08 02:29:11 +03:00
|
|
|
const element2 = <Element>…
|
|
|
|
</Element>
|
2017-12-05 23:39:52 +03:00
|
|
|
`)
|
|
|
|
})
|
|
|
|
|
2018-05-16 03:53:47 +03:00
|
|
|
it('can fold entire nodes when no start or end parameters are specified', async () => {
|
2017-12-04 22:40:44 +03:00
|
|
|
const grammar = new TreeSitterGrammar(atom.grammars, jsGrammarPath, {
|
|
|
|
parser: 'tree-sitter-javascript',
|
2017-12-05 23:39:52 +03:00
|
|
|
folds: [
|
2017-12-06 22:09:44 +03:00
|
|
|
// By default, for a node with no children, folds are started at the *end* of the first
|
|
|
|
// line of a node, and ended at the *beginning* of the last line.
|
2017-12-05 23:39:52 +03:00
|
|
|
{type: 'comment'}
|
|
|
|
]
|
2017-12-04 22:40:44 +03:00
|
|
|
})
|
|
|
|
|
|
|
|
buffer.setText(dedent `
|
|
|
|
/**
|
|
|
|
* Important
|
|
|
|
*/
|
2017-12-06 22:09:44 +03:00
|
|
|
const x = 1 /*
|
|
|
|
Also important
|
|
|
|
*/
|
2017-12-04 22:40:44 +03:00
|
|
|
`)
|
2018-06-27 23:36:17 +03:00
|
|
|
|
|
|
|
const languageMode = new TreeSitterLanguageMode({buffer, grammar})
|
|
|
|
buffer.setLanguageMode(languageMode)
|
2018-05-16 03:53:47 +03:00
|
|
|
await languageMode.reparsePromise
|
2017-12-04 22:40:44 +03:00
|
|
|
|
|
|
|
editor.screenLineForScreenRow(0)
|
|
|
|
|
|
|
|
expect(editor.isFoldableAtBufferRow(0)).toBe(true)
|
|
|
|
expect(editor.isFoldableAtBufferRow(1)).toBe(false)
|
|
|
|
expect(editor.isFoldableAtBufferRow(2)).toBe(false)
|
|
|
|
expect(editor.isFoldableAtBufferRow(3)).toBe(true)
|
|
|
|
expect(editor.isFoldableAtBufferRow(4)).toBe(false)
|
|
|
|
|
|
|
|
editor.foldBufferRow(0)
|
|
|
|
expect(getDisplayText(editor)).toBe(dedent `
|
|
|
|
/**… */
|
2017-12-06 22:09:44 +03:00
|
|
|
const x = 1 /*
|
|
|
|
Also important
|
|
|
|
*/
|
2017-12-04 22:40:44 +03:00
|
|
|
`)
|
|
|
|
|
|
|
|
editor.foldBufferRow(3)
|
|
|
|
expect(getDisplayText(editor)).toBe(dedent `
|
|
|
|
/**… */
|
2017-12-06 22:09:44 +03:00
|
|
|
const x = 1 /*…*/
|
|
|
|
`)
|
|
|
|
})
|
|
|
|
|
2018-05-16 03:53:47 +03:00
|
|
|
it('tries each folding strategy for a given node in the order specified', async () => {
|
2017-12-06 22:09:44 +03:00
|
|
|
const grammar = new TreeSitterGrammar(atom.grammars, cGrammarPath, {
|
|
|
|
parser: 'tree-sitter-c',
|
|
|
|
folds: [
|
|
|
|
// If the #ifdef has an `#else` clause, then end the fold there.
|
|
|
|
{
|
2017-12-08 02:29:11 +03:00
|
|
|
type: ['preproc_ifdef', 'preproc_elif'],
|
2017-12-06 22:09:44 +03:00
|
|
|
start: {index: 1},
|
2017-12-08 04:08:47 +03:00
|
|
|
end: {type: ['preproc_else', 'preproc_elif']}
|
2017-12-08 02:29:11 +03:00
|
|
|
},
|
2017-12-06 22:09:44 +03:00
|
|
|
|
|
|
|
// Otherwise, end the fold at the last child - the `#endif`.
|
|
|
|
{
|
|
|
|
type: 'preproc_ifdef',
|
|
|
|
start: {index: 1},
|
|
|
|
end: {index: -1}
|
|
|
|
},
|
|
|
|
|
|
|
|
// When folding an `#else` clause, the fold extends to the end of the clause.
|
|
|
|
{
|
|
|
|
type: 'preproc_else',
|
|
|
|
start: {index: 0}
|
|
|
|
}
|
|
|
|
]
|
|
|
|
})
|
|
|
|
|
|
|
|
buffer.setText(dedent `
|
|
|
|
#ifndef FOO_H_
|
|
|
|
#define FOO_H_
|
|
|
|
|
|
|
|
#ifdef _WIN32
|
|
|
|
|
|
|
|
#include <windows.h>
|
|
|
|
const char *path_separator = "\\";
|
|
|
|
|
2017-12-08 02:29:11 +03:00
|
|
|
#elif defined MACOS
|
|
|
|
|
|
|
|
#include <carbon.h>
|
|
|
|
const char *path_separator = "/";
|
|
|
|
|
2017-12-06 22:09:44 +03:00
|
|
|
#else
|
|
|
|
|
|
|
|
#include <dirent.h>
|
|
|
|
const char *path_separator = "/";
|
|
|
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#endif
|
2017-12-04 22:40:44 +03:00
|
|
|
`)
|
2018-06-27 23:36:17 +03:00
|
|
|
|
|
|
|
const languageMode = new TreeSitterLanguageMode({buffer, grammar})
|
|
|
|
buffer.setLanguageMode(languageMode)
|
2018-05-16 03:53:47 +03:00
|
|
|
await languageMode.reparsePromise
|
2017-12-06 22:09:44 +03:00
|
|
|
|
|
|
|
editor.screenLineForScreenRow(0)
|
|
|
|
|
|
|
|
editor.foldBufferRow(3)
|
|
|
|
expect(getDisplayText(editor)).toBe(dedent `
|
|
|
|
#ifndef FOO_H_
|
|
|
|
#define FOO_H_
|
|
|
|
|
2017-12-08 02:29:11 +03:00
|
|
|
#ifdef _WIN32…
|
|
|
|
#elif defined MACOS
|
|
|
|
|
|
|
|
#include <carbon.h>
|
|
|
|
const char *path_separator = "/";
|
|
|
|
|
|
|
|
#else
|
2017-12-06 22:09:44 +03:00
|
|
|
|
|
|
|
#include <dirent.h>
|
|
|
|
const char *path_separator = "/";
|
|
|
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#endif
|
|
|
|
`)
|
|
|
|
|
|
|
|
editor.foldBufferRow(8)
|
|
|
|
expect(getDisplayText(editor)).toBe(dedent `
|
|
|
|
#ifndef FOO_H_
|
|
|
|
#define FOO_H_
|
|
|
|
|
2017-12-08 02:29:11 +03:00
|
|
|
#ifdef _WIN32…
|
|
|
|
#elif defined MACOS…
|
|
|
|
#else
|
|
|
|
|
|
|
|
#include <dirent.h>
|
|
|
|
const char *path_separator = "/";
|
2017-12-06 22:09:44 +03:00
|
|
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#endif
|
|
|
|
`)
|
|
|
|
|
|
|
|
editor.foldBufferRow(0)
|
|
|
|
expect(getDisplayText(editor)).toBe(dedent `
|
2017-12-08 02:29:11 +03:00
|
|
|
#ifndef FOO_H_…
|
|
|
|
#endif
|
2017-12-06 22:09:44 +03:00
|
|
|
`)
|
2017-12-08 02:30:48 +03:00
|
|
|
|
|
|
|
editor.foldAllAtIndentLevel(1)
|
|
|
|
expect(getDisplayText(editor)).toBe(dedent `
|
|
|
|
#ifndef FOO_H_
|
|
|
|
#define FOO_H_
|
|
|
|
|
|
|
|
#ifdef _WIN32…
|
|
|
|
#elif defined MACOS…
|
|
|
|
#else…
|
|
|
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#endif
|
|
|
|
`)
|
2017-12-06 22:09:44 +03:00
|
|
|
})
|
|
|
|
|
2018-06-19 00:27:49 +03:00
|
|
|
it('does not fold when the start and end parameters match the same child', async () => {
|
|
|
|
const grammar = new TreeSitterGrammar(atom.grammars, htmlGrammarPath, {
|
|
|
|
parser: 'tree-sitter-html',
|
|
|
|
folds: [
|
|
|
|
{
|
|
|
|
type: 'element',
|
|
|
|
start: {index: 0},
|
|
|
|
end: {index: -1}
|
|
|
|
}
|
|
|
|
]
|
|
|
|
})
|
|
|
|
|
|
|
|
buffer.setText(dedent `
|
|
|
|
<head>
|
|
|
|
<meta name='key-1', content='value-1'>
|
|
|
|
<meta name='key-2', content='value-2'>
|
|
|
|
</head>
|
|
|
|
`)
|
|
|
|
|
2018-06-27 23:36:17 +03:00
|
|
|
const languageMode = new TreeSitterLanguageMode({buffer, grammar})
|
|
|
|
buffer.setLanguageMode(languageMode)
|
2018-06-19 00:27:49 +03:00
|
|
|
await languageMode.reparsePromise
|
|
|
|
|
|
|
|
// Void elements have only one child
|
|
|
|
expect(editor.isFoldableAtBufferRow(1)).toBe(false)
|
|
|
|
expect(editor.isFoldableAtBufferRow(2)).toBe(false)
|
|
|
|
|
|
|
|
editor.foldBufferRow(0)
|
|
|
|
expect(getDisplayText(editor)).toBe(dedent `
|
|
|
|
<head>…
|
|
|
|
</head>
|
|
|
|
`)
|
|
|
|
})
|
|
|
|
|
2017-12-06 22:09:44 +03:00
|
|
|
describe('when folding a node that ends with a line break', () => {
|
2018-06-22 03:06:55 +03:00
|
|
|
it('ends the fold at the end of the previous line', async () => {
|
2017-12-06 22:09:44 +03:00
|
|
|
const grammar = new TreeSitterGrammar(atom.grammars, pythonGrammarPath, {
|
|
|
|
parser: 'tree-sitter-python',
|
|
|
|
folds: [
|
|
|
|
{
|
|
|
|
type: 'function_definition',
|
|
|
|
start: {type: ':'}
|
|
|
|
}
|
|
|
|
]
|
|
|
|
})
|
|
|
|
|
|
|
|
buffer.setText(dedent `
|
|
|
|
def ab():
|
|
|
|
print 'a'
|
|
|
|
print 'b'
|
|
|
|
|
|
|
|
def cd():
|
|
|
|
print 'c'
|
|
|
|
print 'd'
|
|
|
|
`)
|
2018-06-27 23:36:17 +03:00
|
|
|
|
2018-05-16 03:53:47 +03:00
|
|
|
buffer.setLanguageMode(new TreeSitterLanguageMode({buffer, grammar}))
|
2018-06-27 23:36:17 +03:00
|
|
|
await buffer.getLanguageMode().reparsePromise
|
2017-12-06 22:09:44 +03:00
|
|
|
|
|
|
|
editor.screenLineForScreenRow(0)
|
|
|
|
|
|
|
|
editor.foldBufferRow(0)
|
|
|
|
expect(getDisplayText(editor)).toBe(dedent `
|
|
|
|
def ab():…
|
|
|
|
|
|
|
|
def cd():
|
|
|
|
print 'c'
|
|
|
|
print 'd'
|
|
|
|
`)
|
|
|
|
})
|
2017-12-04 22:40:44 +03:00
|
|
|
})
|
2017-12-04 22:02:24 +03:00
|
|
|
})
|
2017-12-04 23:07:05 +03:00
|
|
|
|
2017-12-16 04:10:20 +03:00
|
|
|
describe('.scopeDescriptorForPosition', () => {
|
2018-06-22 03:06:55 +03:00
|
|
|
it('returns a scope descriptor representing the given position in the syntax tree', async () => {
|
2017-12-16 04:10:20 +03:00
|
|
|
const grammar = new TreeSitterGrammar(atom.grammars, jsGrammarPath, {
|
|
|
|
id: 'javascript',
|
|
|
|
parser: 'tree-sitter-javascript'
|
|
|
|
})
|
|
|
|
|
|
|
|
buffer.setText('foo({bar: baz});')
|
2018-06-27 23:36:17 +03:00
|
|
|
|
2018-05-16 03:53:47 +03:00
|
|
|
buffer.setLanguageMode(new TreeSitterLanguageMode({buffer, grammar}))
|
2018-06-27 23:36:17 +03:00
|
|
|
await buffer.getLanguageMode().reparsePromise
|
2017-12-16 04:10:20 +03:00
|
|
|
|
|
|
|
editor.screenLineForScreenRow(0)
|
2018-02-21 21:16:42 +03:00
|
|
|
expect(editor.scopeDescriptorForBufferPosition([0, 6]).getScopesArray()).toEqual([
|
2017-12-16 04:10:20 +03:00
|
|
|
'javascript',
|
|
|
|
'program',
|
|
|
|
'expression_statement',
|
|
|
|
'call_expression',
|
|
|
|
'arguments',
|
|
|
|
'object',
|
|
|
|
'pair',
|
|
|
|
'property_identifier'
|
|
|
|
])
|
|
|
|
})
|
|
|
|
})
|
|
|
|
|
2017-12-04 23:07:05 +03:00
|
|
|
describe('TextEditor.selectLargerSyntaxNode and .selectSmallerSyntaxNode', () => {
|
2018-06-22 03:06:55 +03:00
|
|
|
it('expands and contract the selection based on the syntax tree', async () => {
|
2017-12-04 23:07:05 +03:00
|
|
|
const grammar = new TreeSitterGrammar(atom.grammars, jsGrammarPath, {
|
|
|
|
parser: 'tree-sitter-javascript',
|
|
|
|
scopes: {'program': 'source'}
|
|
|
|
})
|
|
|
|
|
|
|
|
buffer.setText(dedent `
|
|
|
|
function a (b, c, d) {
|
|
|
|
eee.f()
|
|
|
|
g()
|
|
|
|
}
|
|
|
|
`)
|
2018-06-27 23:36:17 +03:00
|
|
|
|
2018-05-16 03:53:47 +03:00
|
|
|
buffer.setLanguageMode(new TreeSitterLanguageMode({buffer, grammar}))
|
2018-06-27 23:36:17 +03:00
|
|
|
await buffer.getLanguageMode().reparsePromise
|
2017-12-04 23:07:05 +03:00
|
|
|
|
|
|
|
editor.screenLineForScreenRow(0)
|
|
|
|
|
|
|
|
editor.setCursorBufferPosition([1, 3])
|
|
|
|
editor.selectLargerSyntaxNode()
|
|
|
|
expect(editor.getSelectedText()).toBe('eee')
|
|
|
|
editor.selectLargerSyntaxNode()
|
|
|
|
expect(editor.getSelectedText()).toBe('eee.f')
|
|
|
|
editor.selectLargerSyntaxNode()
|
|
|
|
expect(editor.getSelectedText()).toBe('eee.f()')
|
|
|
|
editor.selectLargerSyntaxNode()
|
|
|
|
expect(editor.getSelectedText()).toBe('{\n eee.f()\n g()\n}')
|
|
|
|
editor.selectLargerSyntaxNode()
|
|
|
|
expect(editor.getSelectedText()).toBe('function a (b, c, d) {\n eee.f()\n g()\n}')
|
|
|
|
|
|
|
|
editor.selectSmallerSyntaxNode()
|
|
|
|
expect(editor.getSelectedText()).toBe('{\n eee.f()\n g()\n}')
|
|
|
|
editor.selectSmallerSyntaxNode()
|
|
|
|
expect(editor.getSelectedText()).toBe('eee.f()')
|
|
|
|
editor.selectSmallerSyntaxNode()
|
|
|
|
expect(editor.getSelectedText()).toBe('eee.f')
|
|
|
|
editor.selectSmallerSyntaxNode()
|
|
|
|
expect(editor.getSelectedText()).toBe('eee')
|
|
|
|
editor.selectSmallerSyntaxNode()
|
|
|
|
expect(editor.getSelectedBufferRange()).toEqual([[1, 3], [1, 3]])
|
|
|
|
})
|
|
|
|
})
|
2017-12-01 04:13:30 +03:00
|
|
|
})
|
|
|
|
|
2017-12-04 22:02:24 +03:00
|
|
|
function getDisplayText (editor) {
|
|
|
|
return editor.displayLayer.getText()
|
|
|
|
}
|
|
|
|
|
2017-12-15 20:44:45 +03:00
|
|
|
function expectTokensToEqual (editor, expectedTokenLines) {
|
|
|
|
const lastRow = editor.getLastScreenRow()
|
|
|
|
|
|
|
|
// Assert that the correct tokens are returned regardless of which row
|
|
|
|
// the highlighting iterator starts on.
|
|
|
|
for (let startRow = 0; startRow <= lastRow; startRow++) {
|
2018-01-26 01:02:31 +03:00
|
|
|
|
|
|
|
// Clear the screen line cache between iterations, but not on the first
|
|
|
|
// iteration, so that the first iteration tests that the cache has been
|
|
|
|
// correctly invalidated by any changes.
|
|
|
|
if (startRow > 0) {
|
|
|
|
editor.displayLayer.clearSpatialIndex()
|
|
|
|
}
|
|
|
|
|
2017-12-15 20:44:45 +03:00
|
|
|
editor.displayLayer.getScreenLines(startRow, Infinity)
|
|
|
|
|
|
|
|
const tokenLines = []
|
|
|
|
for (let row = startRow; row <= lastRow; row++) {
|
|
|
|
tokenLines[row] = editor.tokensForScreenRow(row).map(({text, scopes}) => ({
|
2017-12-01 04:13:30 +03:00
|
|
|
text,
|
|
|
|
scopes: scopes.map(scope => scope
|
|
|
|
.split(' ')
|
|
|
|
.map(className => className.slice('syntax--'.length))
|
|
|
|
.join(' '))
|
|
|
|
}))
|
2017-12-15 20:44:45 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
for (let row = startRow; row <= lastRow; row++) {
|
|
|
|
const tokenLine = tokenLines[row]
|
|
|
|
const expectedTokenLine = expectedTokenLines[row]
|
2017-12-04 21:18:38 +03:00
|
|
|
|
2017-12-15 20:44:45 +03:00
|
|
|
expect(tokenLine.length).toEqual(expectedTokenLine.length)
|
|
|
|
for (let i = 0; i < tokenLine.length; i++) {
|
|
|
|
expect(tokenLine[i]).toEqual(expectedTokenLine[i], `Token ${i}, startRow: ${startRow}`)
|
|
|
|
}
|
|
|
|
}
|
2017-12-04 21:18:38 +03:00
|
|
|
}
|
2018-01-26 01:02:31 +03:00
|
|
|
|
|
|
|
// Fully populate the screen line cache again so that cache invalidation
|
|
|
|
// due to subsequent edits can be tested.
|
|
|
|
editor.displayLayer.getScreenLines(0, Infinity)
|
2017-12-01 04:13:30 +03:00
|
|
|
}
|