sortedEdits.forEach(e => {
let startOffset = document.offsetAt(e.range.start);
let endOffset = document.offsetAt(e.range.end);
assert.ok(startOffset <= endOffset);
assert.ok(endOffset <= lastOffset);
formatted = formatted.substring(0, startOffset) + e.newText + formatted.substring(endOffset, formatted.length);
lastOffset = startOffset;
});
function getEOL(document: TextDocument): string {
let text = document.getText();
if (document.lineCount > 1) {
let to = document.offsetAt(Position.create(1, 0));
let from = to;
while (from > 0 && isEOL(text, from - 1)) {
from--;
}
return text.substr(from, to - from);
}
return '\n';
}
export async function syntaxCheck(document: TextDocument) {
const diagnostics: Diagnostic[] = []
try {
const client = await clientFromUrl(document.uri)
if (!client) return
const obj = await getObject(document.uri)
// no object or include without a main program
if (!obj || !objectIsValid(obj)) return
const source = document.getText()
const checks = await client.syntaxCheck(
obj.url,
obj.mainUrl,
source,
obj.mainProgram
)
checks.forEach(c => {
const range = sourceRange(document, c.line, c.offset)
diagnostics.push({
message: c.text,
range,
severity: decodeSeverity(c.severity)
})
})
} catch (e) {
log("Exception in syntax check:", e.toString()) // ignore
}
connection.sendDiagnostics({ uri: document.uri, diagnostics })
}
export function validateTextDocumentAsync(textDocument: TextDocument, options: CSpellUserSettings): Rx.Observable<Diagnostic> {
const limit = (options.checkLimit || defaultCheckLimit) * 1024;
const text = textDocument.getText().slice(0, limit);
return Rx.Observable.fromPromise<cspell.TextOffset[]>(validateText(text, options))
.flatMap(a => a)
.filter(a => !!a)
.map(a => a!)
// Convert the offset into a position
.map(offsetWord => ({...offsetWord, position: textDocument.positionAt(offsetWord.offset) }))
// Calculate the range
.map(word => ({
...word,
range: {
start: word.position,
end: ({...word.position, character: word.position.character + word.text.length })
}
}))
// Convert it to a Diagnostic
.map(({text, range}) => ({
severity: DiagnosticSeverity.Information,
range: range,
message: `Unknown word: "${text}"`,
source: diagSource
}))
;
}
export function validateTextDocumentAsync(textDocument: TextDocument, options: CSpellUserSettings): Observable<Diagnostic> {
const { diagnosticLevel = DiagnosticSeverity.Information.toString() } = options;
const severity = diagSeverityMap.get(diagnosticLevel.toLowerCase()) || DiagnosticSeverity.Information;
const limit = (options.checkLimit || defaultCheckLimit) * 1024;
const text = textDocument.getText().slice(0, limit);
return from(validateText(text, options)).pipe(
flatMap(a => a),
filter(a => !!a),
map(a => a!),
// Convert the offset into a position
map(offsetWord => ({...offsetWord, position: textDocument.positionAt(offsetWord.offset) })),
// Calculate the range
map(word => ({
...word,
range: {
start: word.position,
end: ({...word.position, character: word.position.character + word.text.length })
}
})),
// Convert it to a Diagnostic
map(({text, range}) => ({
severity,
range: range,
message: `"${text}": Unknown word.`,
source: diagSource
})),
);
}
export function nodeMcuSignatureHelpHandler(remoteConsole: RemoteConsole, document: TextDocument, textDocumentPosition: TextDocumentPositionParams): SignatureHelp {
remoteConsole.log("Server nodeMcuSignatureHelpHandler entered");
let text = document.getText();
let lineText = text.split(/\r?\n/g)[textDocumentPosition.position.line];
let analyzeResult = analyze(lineText, textDocumentPosition.position);
remoteConsole.log("Server nodeMcuSignatureHelpHandler word: " + JSON.stringify(analyzeResult));
if (analyzeResult.inSignatureDefinition && analyzeResult.signatureName && analyzeResult.moduleName && api[analyzeResult.moduleName]) {
let currentApi: CompletionItem[] = api[analyzeResult.moduleName];
let filtered = currentApi.filter(function (value: CompletionItem, index: number, array: CompletionItem[]) {
return value.label == analyzeResult.signatureName;
});
if (filtered.length > 0) {
let signatureInfo: SignatureInformation = {
label: filtered[0].detail,
documentation: filtered[0].documentation
};
let result: SignatureHelp = {
signatures: [signatureInfo],
};
return result;
}
}
return null;
}
function assertStyleSheet(input: string, ...rules: Rule[]): void {
let p = new Parser();
let document = TextDocument.create('test://test/test.css', 'css', 0, input);
let node = p.parseStylesheet(document);
assertEntries(node, rules);
}
export function assertColor(parser: Parser, text: string, selection: string, isColor: boolean): void {
let document = TextDocument.create('test://test/test.css', 'css', 0, text);
let stylesheet = parser.parseStylesheet(document);
assert.equal(0, nodes.ParseErrorCollector.entries(stylesheet).length, 'compile errors');
let node = nodes.getNodeAtOffset(stylesheet, text.indexOf(selection));
assert.equal(isColor, languageFacts.isColorValue(node));
}
// If the selection range just has whitespace before it in the line,
// extend the range to account for that whitespace
private modifyRange() {
const { start } = this.range;
const offset = this.document.offsetAt(start);
const prefixLineText = this.originalText.substring(offset - start.character, offset);
if (/^\s+$/.test(prefixLineText)) {
this.range.start.character = 0;
}
}
function getOutline(value: string): Promise<SymbolInformation[]> {
var uri = 'test://test.json';
var symbolProvider = new JSONDocumentSymbols();
var document = TextDocument.create(uri, 'json', 0, value);
var jsonDoc = Parser.parse(value);
return symbolProvider.findDocumentSymbols(document, jsonDoc);
}
