Build has been canceled!

rcjsuen / dockerfile-language-service / 84

pending completion

Build # 84

Build Type

push

travis-ci

Committed by

rcjsuen

Commit Message

WIP #54 Add initial support for semantic highlighting

Signed-off-by: Remy Suen <remy.suen@gmail.com>

Run Details

905 of 915 branches covered (98.91%)

Branch coverage included in aggregate %.

158 of 158 new or added lines in 2 files covered. (100.0%)

1406 of 1418 relevant lines covered (99.15%)

2234.81 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

98.06

/src/dockerSemanticTokens.ts

/* --------------------------------------------------------------------------------------------
 * Copyright (c) Remy Suen. All rights reserved.
 * Licensed under the MIT License. See License.txt in the project root for license information.
 * ------------------------------------------------------------------------------------------ */
'use strict';

import { SemanticTokens, SemanticTokenTypes, SemanticTokenModifiers } from 'vscode-languageserver-protocol/lib/protocol.sematicTokens.proposed';
import { DockerfileParser, Keyword, Comment, Instruction, Line, Healthcheck, ModifiableInstruction, From, Onbuild } from 'dockerfile-ast';
import { Range, TextDocument } from 'vscode-languageserver-types';

export class TokensLegend {

    private static tokenTypes = {};

    private static tokenModifiers = {};
    
    public static init() {
        this.tokenTypes[SemanticTokenTypes.keyword] = 0;
        this.tokenTypes[SemanticTokenTypes.comment] = 1;
        this.tokenTypes[SemanticTokenTypes.parameter] = 2;
        this.tokenTypes[SemanticTokenTypes.property] = 3;
        this.tokenTypes[SemanticTokenTypes.label] = 4;
        this.tokenTypes[SemanticTokenTypes.class] = 5;
        this.tokenTypes[SemanticTokenTypes.marco] = 6;
        this.tokenTypes[SemanticTokenTypes.string] = 7;
        this.tokenTypes[SemanticTokenTypes.variable] = 8;

        this.tokenModifiers[SemanticTokenModifiers.declaration] = 1;
        this.tokenModifiers[SemanticTokenModifiers.definition] = 2;
        this.tokenModifiers[SemanticTokenModifiers.deprecated] = 4;
        this.tokenModifiers[SemanticTokenModifiers.reference] = 8;
    }

    public static getTokenType(type: string): number {
        const tokenType = this.tokenTypes[type];
        return tokenType;
    }

    public static getTokenModifiers(modifiers: string[]): number {
        let bit = 0;
        for (const modifier of modifiers) {
            bit |= this.tokenModifiers[modifier];
        }
        return bit;
    }
}

TokensLegend.init();

export class DockerSemanticTokens {

    private currentRange: Range | null = null;

    public computeSemanticTokens(content: string): SemanticTokens {
        const document = TextDocument.create("", "", 0, content);
        const dockerfile = DockerfileParser.parse(content);
        let tokens: number[] = [];
        let lines: Line[] = dockerfile.getComments()
        lines = lines.concat(dockerfile.getInstructions());
        lines.sort((a: Line, b: Line): number => {
            return a.getRange().start.line - b.getRange().start.line;
        });

        for (const directive of dockerfile.getDirectives()) {
            const directiveRange = directive.getRange();
            tokens = tokens.concat(this.createToken(directiveRange, SemanticTokenTypes.marco));
        }

        const escapeCharacter = dockerfile.getEscapeCharacter();
        for (let i = 0; i < lines.length; i++) {
            if (lines[i] instanceof Comment) {
                const range = lines[i].getRange();
                tokens = tokens.concat(this.createToken(range, SemanticTokenTypes.comment));
                this.currentRange = range;
            } else {
                tokens = this.createTokensForInstruction(document, escapeCharacter, lines[i] as Instruction, tokens);
            }
        }
        return {
            data: tokens
        }
    }

    private createTokensForInstruction(document: TextDocument, escapeCharacter: string, instruction: Instruction, tokens: number[]): number[] {
        const instructionRange = instruction.getInstructionRange();
        tokens = tokens.concat(this.createToken(instructionRange, SemanticTokenTypes.keyword));
        this.currentRange = instructionRange;

        if (instruction instanceof ModifiableInstruction) {
            for (const flag of instruction.getFlags()) {
                const flagRange = flag.getRange();
                const nameRange = flag.getNameRange();
                const mergedRange = {
                    start: { line: flagRange.start.line, character: flagRange.start.character },
                    end: { line: nameRange.end.line, character: nameRange.end.character }
                };
                tokens = tokens.concat(this.createToken(mergedRange, SemanticTokenTypes.parameter));
                this.currentRange = flagRange;
                const flagValue = flag.getValue();
                if (flagValue !== null && flagValue !== "") {
                    const valueRange = flag.getValueRange();
                    tokens = tokens.concat(this.createToken(valueRange, SemanticTokenTypes.property));
                    this.currentRange = valueRange;
                }
            }
        }

        switch (instruction.getKeyword()) {
            case Keyword.FROM:
                const from = instruction as From;
                const nameRange = from.getImageNameRange();
                if (nameRange !== null) {
                    tokens = tokens.concat(this.createToken(nameRange, SemanticTokenTypes.class));
                    this.currentRange = nameRange;
                }
                const tagRange = from.getImageTagRange();
                if (tagRange !== null) {
                    tokens = tokens.concat(this.createToken(tagRange, SemanticTokenTypes.label));
                    this.currentRange = tagRange;
                }
                const digestRange = from.getImageDigestRange();
                if (digestRange !== null) {
                    tokens = tokens.concat(this.createToken(digestRange, SemanticTokenTypes.label));
                    this.currentRange = digestRange;
                }
                const fromArgs = instruction.getArguments();
                if (fromArgs.length > 1 && fromArgs[1].getValue().toUpperCase() === "AS") {
                    let range = fromArgs[1].getRange();
                    tokens = tokens.concat(this.createToken(range, SemanticTokenTypes.keyword));
                    this.currentRange = range;
                    range = from.getBuildStageRange();
                    if (range !== null) {
                        tokens = tokens.concat(this.createToken(range, SemanticTokenTypes.label));
                    }
                }
                break;
            case Keyword.HEALTHCHECK:
                const healthcheck = instruction as Healthcheck;
                const subcommand = healthcheck.getSubcommand();
                if (subcommand !== null) {
                    const range = subcommand.getRange();
                    tokens = tokens.concat(this.createToken(range, SemanticTokenTypes.keyword));
                }
                break;
            case Keyword.ONBUILD:
                const onbuild = instruction as Onbuild;
                const range = onbuild.getTriggerRange()
                if (range !== null) {
                    tokens = this.createTokensForInstruction(document, escapeCharacter, onbuild.getTriggerInstruction(), tokens);
                }
                break;
        }

        const args = instruction.getArguments();
        if (args.length === 0) {
            return tokens;
        }

        const start = args[0].getRange().start;
        const startOffset = document.offsetAt(start);
        const argsContent = instruction.getRawArgumentsContent();
        let variables = instruction.getVariables();
        let quote = null;
        let offset = -1;
        argsLoop: for (let i = 0; i < argsContent.length; i++) {
            const ch = argsContent.charAt(i);
            switch (ch) {
                case escapeCharacter:
                    for (let j = i + 1; j < argsContent.length; j++) {
                        const escapedChar = argsContent.charAt(j);
                        switch (escapedChar) {
                            case '\"':
                            case '\'':
                                if (quote === null) {
                                    let range = {
                                        start: document.positionAt(startOffset + i),
                                        end: document.positionAt(startOffset + j + 1)
                                    };
                                    tokens = tokens.concat(this.createToken(range, SemanticTokenTypes.string));
                                    this.currentRange = range;
                                    i = j;
                                    continue argsLoop;
                                } else {
                                    let range = {
                                        start: document.positionAt(startOffset + offset),
                                        end: document.positionAt(startOffset + i)
                                    };
                                    tokens = tokens.concat(this.createToken(range, SemanticTokenTypes.string));
                                    this.currentRange = range;
                                    range = {
                                        start: document.positionAt(startOffset + i),
                                        end: document.positionAt(startOffset + j + 1)
                                    };
                                    tokens = tokens.concat(this.createToken(range, SemanticTokenTypes.string));
                                    this.currentRange = range;
                                    // reset as the string has been cut off part ways
                                    quote = null;
                                    offset = -1;
                                }
                            default:
                                i = j;
                                continue argsLoop;
                        }
                    }
                    break;
                case '$':
                    for (let variable of variables) {
                        const range = variable.getRange();
                        if (startOffset + i === document.offsetAt(range.start)) {
                            tokens = tokens.concat(
                                this.createToken(
                                    range, SemanticTokenTypes.variable, [SemanticTokenModifiers.reference]
                                )
                            );
                            this.currentRange = range;
                            variables = variables.splice(0, 1);
                            break;
                        }
                    }
                    break;
                case '\"':
                case '\'':
                    if (quote === null) {
                        quote = ch;
                        offset = i;
                    } else if (quote === ch) {
                        // ensure that quotes match
                        const range = {
                            start: document.positionAt(startOffset + offset),
                            end: document.positionAt(startOffset + i + 1)
                        };
                        tokens = tokens.concat(this.createToken(range, SemanticTokenTypes.string));
                        this.currentRange = range;
                        quote = null;
                        offset = -1;
                    }
                    break;
            }
        }

        if (quote !== null) {
            // trailing string token
            const range = {
                start: document.positionAt(startOffset + offset),
                end: document.positionAt(startOffset + argsContent.length)
            };
            tokens = tokens.concat(this.createToken(range, SemanticTokenTypes.string));
            this.currentRange = range;
        }

        return tokens;
    }

    private createToken(range: Range, tokenType: string, tokenModifiers: string[] = []): number[] {
        if (this.currentRange === null) {
            return [
                range.start.line,
                range.start.character,
                range.end.character - range.start.character,
                TokensLegend.getTokenType(tokenType),
                TokensLegend.getTokenModifiers(tokenModifiers)
            ];
        } else if (this.currentRange.end.line !== range.start.line) {
            return [
                range.start.line - this.currentRange.end.line,
                range.start.character,
                range.end.character - range.start.character,
                TokensLegend.getTokenType(tokenType),
                TokensLegend.getTokenModifiers(tokenModifiers)
            ];
        }
        return [
            range.start.line - this.currentRange.start.line,
            range.start.character - this.currentRange.start.character,
            range.end.character - range.start.character,
            TokensLegend.getTokenType(tokenType),
            TokensLegend.getTokenModifiers(tokenModifiers)
        ];
    }

}

1	/* --------------------------------------------------------------------------------------------
2	* Copyright (c) Remy Suen. All rights reserved.
3	* Licensed under the MIT License. See License.txt in the project root for license information.
4	* ------------------------------------------------------------------------------------------ */
5	'use strict';
6
7	import { SemanticTokens, SemanticTokenTypes, SemanticTokenModifiers } from 'vscode-languageserver-protocol/lib/protocol.sematicTokens.proposed';	1✔
8	import { DockerfileParser, Keyword, Comment, Instruction, Line, Healthcheck, ModifiableInstruction, From, Onbuild } from 'dockerfile-ast';	1✔
9	import { Range, TextDocument } from 'vscode-languageserver-types';	1✔
10
11	export class TokensLegend {	1✔
12
13	private static tokenTypes = {};	1✔
14
15	private static tokenModifiers = {};	1✔
16
17	public static init() {
18	this.tokenTypes[SemanticTokenTypes.keyword] = 0;	1✔
19	this.tokenTypes[SemanticTokenTypes.comment] = 1;	1✔
20	this.tokenTypes[SemanticTokenTypes.parameter] = 2;	1✔
21	this.tokenTypes[SemanticTokenTypes.property] = 3;	1✔
22	this.tokenTypes[SemanticTokenTypes.label] = 4;	1✔
23	this.tokenTypes[SemanticTokenTypes.class] = 5;	1✔
24	this.tokenTypes[SemanticTokenTypes.marco] = 6;	1✔
25	this.tokenTypes[SemanticTokenTypes.string] = 7;	1✔
26	this.tokenTypes[SemanticTokenTypes.variable] = 8;	1✔
27
28	this.tokenModifiers[SemanticTokenModifiers.declaration] = 1;	1✔
29	this.tokenModifiers[SemanticTokenModifiers.definition] = 2;	1✔
30	this.tokenModifiers[SemanticTokenModifiers.deprecated] = 4;	1✔
31	this.tokenModifiers[SemanticTokenModifiers.reference] = 8;	1✔
32	}
33
34	public static getTokenType(type: string): number {
35	const tokenType = this.tokenTypes[type];	404✔
36	return tokenType;	404✔
37	}
38
39	public static getTokenModifiers(modifiers: string[]): number {
40	let bit = 0;	202✔
41	for (const modifier of modifiers) {	202✔
42	bit \|= this.tokenModifiers[modifier];	4✔
43	}
44	return bit;	202✔
45	}
46	}
47
48	TokensLegend.init();	1✔
49
50	export class DockerSemanticTokens {	1✔
51
52	private currentRange: Range \| null = null;	42✔
53
54	public computeSemanticTokens(content: string): SemanticTokens {
55	const document = TextDocument.create("", "", 0, content);	42✔
56	const dockerfile = DockerfileParser.parse(content);	42✔
57	let tokens: number[] = [];	42✔
58	let lines: Line[] = dockerfile.getComments()	42✔
59	lines = lines.concat(dockerfile.getInstructions());	42✔
60	lines.sort((a: Line, b: Line): number => {	42✔
61	return a.getRange().start.line - b.getRange().start.line;	16✔
62	});
63
64	for (const directive of dockerfile.getDirectives()) {	42✔
65	const directiveRange = directive.getRange();	1✔
66	tokens = tokens.concat(this.createToken(directiveRange, SemanticTokenTypes.marco));	1✔
67	}
68
69	const escapeCharacter = dockerfile.getEscapeCharacter();	42✔
70	for (let i = 0; i < lines.length; i++) {	42✔
71	if (lines[i] instanceof Comment) {	55✔
72	const range = lines[i].getRange();	14✔
73	tokens = tokens.concat(this.createToken(range, SemanticTokenTypes.comment));	14✔
74	this.currentRange = range;	14✔
75	} else {
76	tokens = this.createTokensForInstruction(document, escapeCharacter, lines[i] as Instruction, tokens);	41✔
77	}
78	}
79	return {	42✔
80	data: tokens
81	}
82	}
83
84	private createTokensForInstruction(document: TextDocument, escapeCharacter: string, instruction: Instruction, tokens: number[]): number[] {
85	const instructionRange = instruction.getInstructionRange();	43✔
86	tokens = tokens.concat(this.createToken(instructionRange, SemanticTokenTypes.keyword));	43✔
87	this.currentRange = instructionRange;	43✔
88
89	if (instruction instanceof ModifiableInstruction) {	43✔
90	for (const flag of instruction.getFlags()) {	39✔
91	const flagRange = flag.getRange();	3✔
92	const nameRange = flag.getNameRange();	3✔
93	const mergedRange = {	3✔
94	start: { line: flagRange.start.line, character: flagRange.start.character },
95	end: { line: nameRange.end.line, character: nameRange.end.character }
96	};
97	tokens = tokens.concat(this.createToken(mergedRange, SemanticTokenTypes.parameter));	3✔
98	this.currentRange = flagRange;	3✔
99	const flagValue = flag.getValue();	3✔
100	if (flagValue !== null && flagValue !== "") {	3✔
101	const valueRange = flag.getValueRange();	1✔
102	tokens = tokens.concat(this.createToken(valueRange, SemanticTokenTypes.property));	1✔
103	this.currentRange = valueRange;	1✔
104	}
105	}
106	}
107
108	switch (instruction.getKeyword()) {	43✔
109	case Keyword.FROM:	19✔
110	const from = instruction as From;	10✔
111	const nameRange = from.getImageNameRange();	10✔
112	if (nameRange !== null) {	10✔
113	tokens = tokens.concat(this.createToken(nameRange, SemanticTokenTypes.class));	7✔
114	this.currentRange = nameRange;	7✔
115	}
116	const tagRange = from.getImageTagRange();	10✔
117	if (tagRange !== null) {	10✔
118	tokens = tokens.concat(this.createToken(tagRange, SemanticTokenTypes.label));	1✔
119	this.currentRange = tagRange;	1✔
120	}
121	const digestRange = from.getImageDigestRange();	10✔
122	if (digestRange !== null) {	10✔
123	tokens = tokens.concat(this.createToken(digestRange, SemanticTokenTypes.label));	1✔
124	this.currentRange = digestRange;	1✔
125	}
126	const fromArgs = instruction.getArguments();	10✔
127	if (fromArgs.length > 1 && fromArgs[1].getValue().toUpperCase() === "AS") {	10✔
128	let range = fromArgs[1].getRange();	1✔
129	tokens = tokens.concat(this.createToken(range, SemanticTokenTypes.keyword));	1✔
130	this.currentRange = range;	1✔
131	range = from.getBuildStageRange();	1✔
132	if (range !== null) {	1!
133	tokens = tokens.concat(this.createToken(range, SemanticTokenTypes.label));	1✔
134	}
135	}
136	break;	10✔
137	case Keyword.HEALTHCHECK:
138	const healthcheck = instruction as Healthcheck;	7✔
139	const subcommand = healthcheck.getSubcommand();	7✔
140	if (subcommand !== null) {	7✔
141	const range = subcommand.getRange();	6✔
142	tokens = tokens.concat(this.createToken(range, SemanticTokenTypes.keyword));	6✔
143	}
144	break;	7✔
145	case Keyword.ONBUILD:
146	const onbuild = instruction as Onbuild;	2✔
147	const range = onbuild.getTriggerRange()	2✔
148	if (range !== null) {	2!
149	tokens = this.createTokensForInstruction(document, escapeCharacter, onbuild.getTriggerInstruction(), tokens);	2✔
150	}
151	break;	2✔
152	}
153
154	const args = instruction.getArguments();	43✔
155	if (args.length === 0) {	43✔
156	return tokens;	6✔
157	}
158
159	const start = args[0].getRange().start;	37✔
160	const startOffset = document.offsetAt(start);	37✔
161	const argsContent = instruction.getRawArgumentsContent();	37✔
162	let variables = instruction.getVariables();	37✔
163	let quote = null;	37✔
164	let offset = -1;	37✔
165	argsLoop: for (let i = 0; i < argsContent.length; i++) {	37✔
166	const ch = argsContent.charAt(i);	449✔
167	switch (ch) {	449✔
168	case escapeCharacter:	42✔
169	for (let j = i + 1; j < argsContent.length; j++) {	6✔
170	const escapedChar = argsContent.charAt(j);	6✔
171	switch (escapedChar) {	6✔
172	case '\"':	10✔
173	case '\'':
174	if (quote === null) {	5✔
175	let range = {	4✔
176	start: document.positionAt(startOffset + i),
177	end: document.positionAt(startOffset + j + 1)
178	};
179	tokens = tokens.concat(this.createToken(range, SemanticTokenTypes.string));	4✔
180	this.currentRange = range;	4✔
181	i = j;	4✔
182	continue argsLoop;	4✔
183	} else {
184	let range = {	1✔
185	start: document.positionAt(startOffset + offset),
186	end: document.positionAt(startOffset + i)
187	};
188	tokens = tokens.concat(this.createToken(range, SemanticTokenTypes.string));	1✔
189	this.currentRange = range;	1✔
190	range = {	1✔
191	start: document.positionAt(startOffset + i),
192	end: document.positionAt(startOffset + j + 1)
193	};
194	tokens = tokens.concat(this.createToken(range, SemanticTokenTypes.string));	1✔
195	this.currentRange = range;	1✔
196	// reset as the string has been cut off part ways
197	quote = null;	1✔
198	offset = -1;	1✔
199	}
200	default:
201	i = j;	2✔
202	continue argsLoop;	2✔
203	}
204	}
205	break;	×
206	case '$':
207	for (let variable of variables) {	2✔
208	const range = variable.getRange();	2✔
209	if (startOffset + i === document.offsetAt(range.start)) {	2!
210	tokens = tokens.concat(	2✔
211	this.createToken(
212	range, SemanticTokenTypes.variable, [SemanticTokenModifiers.reference]
213	)
214	);
215	this.currentRange = range;	2✔
216	variables = variables.splice(0, 1);	2✔
217	break;	2✔
218	}
219	}
220	break;	2✔
221	case '\"':
222	case '\'':
223	if (quote === null) {	24✔
224	quote = ch;	15✔
225	offset = i;	15✔
226	} else if (quote === ch) {	9✔
227	// ensure that quotes match
228	const range = {	5✔
229	start: document.positionAt(startOffset + offset),
230	end: document.positionAt(startOffset + i + 1)
231	};
232	tokens = tokens.concat(this.createToken(range, SemanticTokenTypes.string));	5✔
233	this.currentRange = range;	5✔
234	quote = null;	5✔
235	offset = -1;	5✔
236	}
237	break;	24✔
238	}
239	}
240
241	if (quote !== null) {	37✔
242	// trailing string token
243	const range = {	9✔
244	start: document.positionAt(startOffset + offset),
245	end: document.positionAt(startOffset + argsContent.length)
246	};
247	tokens = tokens.concat(this.createToken(range, SemanticTokenTypes.string));	9✔
248	this.currentRange = range;	9✔
249	}
250
251	return tokens;	37✔
252	}
253
254	private createToken(range: Range, tokenType: string, tokenModifiers: string[] = []): number[] {	99✔
255	if (this.currentRange === null) {	101✔
256	return [	42✔
257	range.start.line,
258	range.start.character,
259	range.end.character - range.start.character,
260	TokensLegend.getTokenType(tokenType),
261	TokensLegend.getTokenModifiers(tokenModifiers)
262	];
263	} else if (this.currentRange.end.line !== range.start.line) {	59✔
264	return [	14✔
265	range.start.line - this.currentRange.end.line,
266	range.start.character,
267	range.end.character - range.start.character,
268	TokensLegend.getTokenType(tokenType),
269	TokensLegend.getTokenModifiers(tokenModifiers)
270	];
271	}
272	return [	45✔
273	range.start.line - this.currentRange.start.line,
274	range.start.character - this.currentRange.start.character,
275	range.end.character - range.start.character,
276	TokensLegend.getTokenType(tokenType),
277	TokensLegend.getTokenModifiers(tokenModifiers)
278	];
279	}
280
281	}

rcjsuen / dockerfile-language-service / 84

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous