8000 Add optional debug logging by felix-oq · Pull Request #95 · jvalue/jayvee · GitHub
[go: up one dir, main page]
More Web Proxy on the site http://driver.im/
Skip to content

Add optional debug logging #95

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
merged 2 commits into from
Jan 17, 2023
Merged

Add optional debug logging #95

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
2 commits
Select commit Hold shift + click to select a range
dfb87a0
Add optional debug logging
felix-oq Jan 13, 2023
0dd7972
Reintroduce execution result for error reporting
felix-oq Jan 16, 2023
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
220 changes: 22 additions & 198 deletions apps/interpreter/src/cli-util.ts
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -1,43 +1,34 @@
import { strict as assert } from 'assert';
import * as fs from 'fs';
import * as path from 'path';

import { Diagnostic } from '@jayvee/execution';
import * as chalk from 'chalk';
import {
AstNode,
LangiumDocument,
LangiumServices,
getDiagnosticRange,
getDocument,
toDiagnosticSeverity,
} from 'langium';
import { assertUnreachable } from 'langium/lib/utils/errors';
import {
DiagnosticSeverity,
Diagnostic as LspDiagnostic,
Range,
} from 'vscode-languageserver';
import { uinteger } from 'vscode-languageserver-types';
import { AstNode, LangiumDocument, LangiumServices } from 'langium';
import { URI } from 'vscode-uri';

import { DefaultLogger } from './default-logger';

export enum ExitCode {
SUCCESS = 0,
FAILURE = 1,
}

export async function extractDocument(
fileName: string,
services: LangiumServices,
logger: DefaultLogger,
): Promise<LangiumDocument> {
const extensions = services.LanguageMetaData.fileExtensions;
if (!extensions.includes(path.extname(fileName))) {
console.error(
chalk.yellow(
`Please choose a file with one of these extensions: ${extensions.toString()}.`,
),
);
process.exit(1);
const errorMessage = `Please choose a file with ${
extensions.length === 1 ? 'this extension' : 'one of these extensions'
}: ${extensions.map((extension) => `"${extension}"`).join(',')}`;

logger.logErr(errorMessage);
process.exit(ExitCode.FAILURE);
}

if (!fs.existsSync(fileName)) {
console.error(chalk.red(`File ${fileName} does not exist.`));
process.exit(1);
logger.logErr(`File ${fileName} does not exist.`);
process.exit(ExitCode.FAILURE);
}

const document =
Expand All @@ -53,9 +44,9 @@ export async function extractDocument(
);
if (validationErrors.length > 0) {
for (const validationError of validationErrors) {
logLspDiagnostic(validationError, document);
logger.logLspDiagnostic(validationError, document);
}
process.exit(1);
process.exit(ExitCode.FAILURE);
}

return document;
Expand All @@ -64,175 +55,8 @@ export async function extractDocument(
export async function extractAstNode<T extends AstNode>(
fileName: string,
services: LangiumServices,
logger: DefaultLogger,
): Promise<T> {
return (await extractDocument(fileName, services)).parseResult.value as T;
}

export function logDiagnostic(diagnostic: Diagnostic) {
const document = getDocument(diagnostic.info.node);

/**
* @see {@link DefaultDocumentValidator.toDiagnostic}
*/
const lspDiagnostic = {
message: diagnostic.message,
range: getDiagnosticRange(diagnostic.info),
severity: toDiagnosticSeverity(diagnostic.severity),
code: diagnostic.info.code,
codeDescription: diagnostic.info.codeDescription,
tags: diagnostic.info.tags,
relatedInformation: diagnostic.info.relatedInformation,
data: diagnostic.info.data,
source: document.textDocument.languageId,
} as LspDiagnostic;
logLspDiagnostic(lspDiagnostic, document);
}

const TAB_TO_SPACES = 4;

export function logLspDiagnostic(
diagnostic: LspDiagnostic,
document: LangiumDocument,
): void {
assert(
diagnostic.severity !== undefined,
'The diagnostic severity is assumed to always be present',
);
const severity = diagnostic.severity;

const printFn = inferPrintFunction(severity);
const colorFn = inferChalkColor(severity);

printFn(
chalk.bold(
`${colorFn(inferSeverityName(severity))}: ${diagnostic.message}`,
),
);

const diagnosticRange = diagnostic.range;
const startLineNumber = diagnosticRange.start.line + 1;
const endLineNumber = diagnosticRange.end.line + 1;

const fullRange: Range = {
start: {
line: diagnosticRange.start.line,
character: 0,
},
end: {
line: diagnosticRange.end.line,
character: uinteger.MAX_VALUE,
},
};
const text = document.textDocument.getText(fullRange).trimEnd();
const lines = text.split('\n');

const lineNumberLength = Math.floor(Math.log10(endLineNumber)) + 1;

printFn(
`In ${document.uri.path}:${startLineNumber}:${
diagnosticRange.start.character + 1
}`,
);
lines.forEach((line, i) => {
const lineNumber = startLineNumber + i;
const paddedLineNumber = String(lineNumber).padStart(lineNumberLength, ' ');
printFn(
`${chalk.grey(`${paddedLineNumber} |`)} ${line.replace(
/\t/g,
' '.repeat(TAB_TO_SPACES),
)}`,
);

let underlineFrom = 0;
let underlineTo = line.length;
if (lineNumber === startLineNumber) {
underlineFrom = diagnosticRange.start.character;
}
if (lineNumber === endLineNumber) {
underlineTo = diagnosticRange.end.character;
}

const underlineIndent = repeatCharAccordingToString(
' ',
line.substring(0, underlineFrom),
TAB_TO_SPACES,
);
const underline = repeatCharAccordingToString(
'^',
line.substring(underlineFrom, underlineTo),
TAB_TO_SPACES,
);

printFn(
`${chalk.grey(
`${' '.repeat(lineNumberLength)} |`,
)} ${underlineIndent}${colorFn(underline)}`,
);
});
printFn('');
}

/**
* Repeats {@link charToRepeat} as many times as {@link accordingTo} is long.
* For each occurrence of \t in {@link accordingTo},
* {@link charToRepeat} is repeated {@link tabRepeats} times instead of once.
*/
function repeatCharAccordingToString(
charToRepeat: string,
accordingTo: string,
tabRepeats: number,
): string {
return Array.from(accordingTo).reduce((prev, cur) => {
const repeatedChar =
cur === '\t' ? charToRepeat.repeat(tabRepeats) : charToRepeat;
return `${prev}${repeatedChar}`;
}, '');
}

function inferPrintFunction(
severity: DiagnosticSeverity,
): (message: string) => void {
switch (severity) {
case DiagnosticSeverity.Error:
return console.error;
case DiagnosticSeverity.Warning:
return console.warn;
case DiagnosticSeverity.Information:
case DiagnosticSeverity.Hint:
return console.info;
default:
assertUnreachable(severity);
}
}

function inferChalkColor(
severity: DiagnosticSeverity,
): (message: string) => string {
switch (severity) {
case DiagnosticSeverity.Error:
return chalk.red;
case DiagnosticSeverity.Warning:
return chalk.yellow;
case DiagnosticSeverity.Information:
return chalk.gray;
case DiagnosticSeverity.Hint:
return chalk.blue;
default:
assertUnreachable(severity);
}
}

function inferSeverityName(severity: DiagnosticSeverity): string {
switch (severity) {
case DiagnosticSeverity.Error:
return 'error';
case DiagnosticSeverity.Warning:
return 'warning';
case DiagnosticSeverity.Information:
return 'information';
case DiagnosticSeverity.Hint:
return 'hint';
default:
assertUnreachable(severity);
}
return (await extractDocument(fileName, services, logger)).parseResult
.value as T;
}
Loading
0