@eclipse-glsp/cli 2.2.1 → 2.3.0-next.17

package/src/commands/check-header.ts

@@ -1,280 +0,0 @@
-/********************************************************************************
- * Copyright (c) 2022-2024 EclipseSource and others.
- *
- * This program and the accompanying materials are made available under the
- * terms of the Eclipse Public License v. 2.0 which is available at
- * http://www.eclipse.org/legal/epl-2.0.
- *
- * This Source Code may also be made available under the following Secondary
- * Licenses when the conditions for such availability set forth in the Eclipse
- * Public License v. 2.0 are satisfied: GNU General Public License, version 2
- * with the GNU Classpath Exception which is available at
- * https://www.gnu.org/software/classpath/license.html.
- *
- * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
- ********************************************************************************/
-/* eslint-disable max-len */
-import { Option } from 'commander';
-import * as fs from 'fs';
-import { glob } from 'glob';
-import * as minimatch from 'minimatch';
-import * as readline from 'readline-sync';
-import sh from 'shelljs';
-import { baseCommand, configureShell, getShellConfig } from '../util/command-util';
-import { getChangesOfLastCommit, getLastModificationDate, getUncommittedChanges } from '../util/git-util';
-
-import * as path from 'path';
-import { LOGGER } from '../util/logger';
-import { validateGitDirectory } from '../util/validation-util';
-
-export interface HeaderCheckOptions {
-    type: CheckType;
-    exclude: string[];
-    fileExtensions: string[];
-    json: boolean;
-    excludeDefaults: boolean;
-    autoFix: boolean;
-}
-
-const checkTypes = ['full', 'changes', 'lastCommit'] as const;
-type CheckType = (typeof checkTypes)[number];
-
-const DEFAULT_EXCLUDES = ['**/@(node_modules|lib|dist|bundle)/**'];
-const YEAR_RANGE_REGEX = /\d{4}/g;
-const HEADER_PATTERN = 'Copyright \\([cC]\\) \\d{4}';
-const AUTO_FIX_MESSAGE = 'Fix copyright header violations';
-
-export const CheckHeaderCommand = baseCommand() //
-    .name('checkHeaders')
-    .description('Validates the copyright year range (end year) of license header files')
-    .argument('<rootDir>', 'The starting directory for the check', validateGitDirectory)
-    .addOption(
-        new Option(
-            '-t, --type <type>',
-            'The scope of the check. In addition to a full recursive check, is also possible to only' +
-                ' consider pending changes or the last commit'
-        )
-            .choices(checkTypes)
-            .default('full')
-    )
-    .option('-f, --fileExtensions <extensions...>', 'File extensions that should be checked', ['ts', 'tsx'])
-    .addOption(
-        new Option(
-            '-e, --exclude <exclude...>',
-            'File patterns that should be excluded from the check. New exclude patterns are added to the default patterns'
-        ).default([], `[${DEFAULT_EXCLUDES}]`)
-    )
-    .option(
-        '--no-exclude-defaults',
-        'Disables the default excludes patterns. Only explicitly passed exclude patterns (-e, --exclude) are considered'
-    )
-    .option('-j, --json', 'Also persist validation results as json file', false)
-    .option('-a, --autoFix', 'Auto apply & commit fixes without prompting the user', false)
-    .action(checkHeaders);
-
-export function checkHeaders(rootDir: string, options: HeaderCheckOptions): void {
-    configureShell({ silent: true, fatal: true });
-
-    if (options.excludeDefaults) {
-        options.exclude.push(...DEFAULT_EXCLUDES);
-    }
-
-    sh.cd(rootDir);
-    const files = getFiles(rootDir, options);
-    LOGGER.info(`Check copy right headers of ${files.length} files`);
-    if (files.length === 0) {
-        LOGGER.info('Check completed');
-        return;
-    }
-    const results = validate(rootDir, files, options);
-    handleValidationResults(rootDir, results, options);
-}
-
-function getFiles(rootDir: string, options: HeaderCheckOptions): string[] {
-    const includePattern = `**/*.@(${options.fileExtensions.join('|')})`;
-    const excludePattern = options.exclude;
-
-    if (options.type === 'full') {
-        return glob.sync(includePattern, {
-            cwd: rootDir,
-            ignore: excludePattern
-        });
-    }
-
-    let changedFiles = options.type === 'changes' ? getUncommittedChanges(rootDir) : getChangesOfLastCommit(rootDir);
-    changedFiles = changedFiles.filter(minimatch.filter(includePattern));
-
-    excludePattern.forEach(pattern => {
-        changedFiles = changedFiles.filter(minimatch.filter(`!${pattern}`));
-    });
-    return changedFiles.filter(file => fs.existsSync(file));
-}
-
-function validate(rootDir: string, files: string[], options: HeaderCheckOptions): ValidationResult[] {
-    // Derives all files with valid headers and all files with no or invalid headers
-    const filesWithHeader = sh.grep('-l', HEADER_PATTERN, files).stdout.trim().split('\n');
-    const noHeaders = files.filter(file => !filesWithHeader.includes(file));
-
-    const results: ValidationResult[] = [];
-    const allFilesLength = files.length;
-
-    // Create validation results for all files with no or invalid headers
-    const noHeadersLength = noHeaders.length;
-    if (noHeadersLength > 0) {
-        LOGGER.info(`Found ${noHeadersLength} files with no (or an invalid) copyright header`);
-    }
-    noHeaders.forEach((file, i) => {
-        printFileProgress(i + 1, allFilesLength, `Validating ${file}`);
-        results.push({ file: path.resolve(rootDir, file), violation: 'noOrMissingHeader' });
-    });
-
-    // Performance optimization: avoid retrieving the dates for each individual file by precalculating the endYear if possible.
-    let defaultEndYear: number | undefined;
-    if (options.type === 'changes') {
-        defaultEndYear = new Date().getFullYear();
-    } else if (options.type === 'lastCommit') {
-        defaultEndYear = getLastModificationDate(undefined, rootDir)?.getFullYear();
-    }
-
-    // Create validation results for all files with valid headers
-    filesWithHeader.forEach((file, i) => {
-        printFileProgress(i + 1 + noHeadersLength, allFilesLength, `Validating ${file}`);
-        const copyrightLine = sh.head({ '-n': 2 }, file).stdout.trim().split('\n')[1];
-        const copyRightYears = copyrightLine.match(YEAR_RANGE_REGEX)!;
-        if (!copyRightYears) {
-            const result: ValidationResult = { file, violation: 'noYear', line: copyrightLine };
-            results.push(result);
-        } else {
-            const currentStartYear = Number.parseInt(copyRightYears[0], 10);
-            const currentEndYear = copyRightYears[1] ? Number.parseInt(copyRightYears[1], 10) : undefined;
-            const result: DateValidationResult = {
-                currentStartYear,
-                currentEndYear,
-                expectedEndYear: defaultEndYear ?? getLastModificationDate(file, rootDir, AUTO_FIX_MESSAGE)!.getFullYear(),
-                file,
-                violation: 'none'
-            };
-            validateEndYear(result);
-            results.push(result);
-        }
-    });
-
-    results.sort((a, b) => a.file.localeCompare(b.file));
-
-    process.stdout.clearLine(0);
-    return results;
-}
-
-function validateEndYear(result: DateValidationResult): void {
-    const { currentStartYear, expectedEndYear, currentEndYear } = result;
-    result.violation = 'invalidEndYear';
-
-    const valid = currentEndYear ? currentEndYear === expectedEndYear : currentStartYear === expectedEndYear;
-
-    if (valid) {
-        result.violation = 'none';
-        return;
-    }
-}
-
-function printFileProgress(currentFileCount: number, maxFileCount: number, message: string, clear = true): void {
-    if (clear) {
-        process.stdout.clearLine(0);
-        process.stdout.cursorTo(0);
-    }
-    process.stdout.write(`[${currentFileCount} of ${maxFileCount}] ${message}`);
-    if (!clear) {
-        process.stdout.write('\n');
-    }
-}
-
-export function handleValidationResults(rootDir: string, results: ValidationResult[], options: HeaderCheckOptions): void {
-    LOGGER.newLine();
-    LOGGER.info(`Header validation for ${results.length} files completed`);
-    const violations = results.filter(result => result.violation !== 'none');
-    // Adjust results to print based on configured severity level
-    const toPrint = violations;
-
-    LOGGER.info(`Found ${toPrint.length} copyright header violations:`);
-    LOGGER.newLine();
-
-    toPrint.forEach((result, i) => LOGGER.info(`${i + 1}. `, result.file, ':', toPrintMessage(result)));
-
-    LOGGER.newLine();
-
-    if (options.json) {
-        fs.writeFileSync(path.join(rootDir, 'headerCheck.json'), JSON.stringify(results, undefined, 2));
-    }
-
-    if (
-        violations.length > 0 &&
-        (options.autoFix || readline.keyInYN('Do you want to automatically fix copyright year range violations?'))
-    ) {
-        const toFix = violations.filter(violation => isDateValidationResult(violation)) as DateValidationResult[];
-        fixViolations(rootDir, toFix, options);
-    }
-
-    LOGGER.info('Check completed');
-}
-
-function toPrintMessage(result: ValidationResult): string {
-    const error = '\x1b[31m';
-    const info = '\x1b[32m';
-
-    if (isDateValidationResult(result) && result.violation === 'invalidEndYear') {
-        const expected = result.expectedEndYear.toString();
-        const actual = result.currentEndYear
-            ? `${result.currentEndYear} (${result.currentStartYear}-${result.currentEndYear})`
-            : result.currentStartYear.toString();
-        const message = 'Invalid copyright end year';
-        return `${error} ${message}! Expected end year '${expected}' but is '${actual}'`;
-    } else if (result.violation === 'noOrMissingHeader') {
-        return `${error} No or invalid copyright header!`;
-    } else if (result.violation === 'noYear') {
-        return `${error} No year found!${result.line ? ' (line: ' + result.line + ')' : ''}`;
-    }
-
-    return `${info} OK`;
-}
-
-function fixViolations(rootDir: string, violations: DateValidationResult[], options: HeaderCheckOptions): void {
-    LOGGER.newLine();
-    violations.forEach((violation, i) => {
-        printFileProgress(i + 1, violations.length, `Fix ${violation.file}`, false);
-
-        const currentRange = `${violation.currentStartYear}${violation.currentEndYear ? '-' + violation.currentEndYear : ''}`;
-        const fixedRange =
-            violation.currentEndYear || violation.currentStartYear < violation.expectedEndYear
-                ? `${violation.currentStartYear}-${violation.expectedEndYear}`
-                : `${violation.expectedEndYear}`;
-
-        sh.sed('-i', RegExp('Copyright \\([cC]\\) ' + currentRange), `Copyright (c) ${fixedRange}`, violation.file);
-    });
-    LOGGER.newLine();
-    if (options.autoFix || readline.keyInYN('Do you want to create a commit for the fixed files?')) {
-        LOGGER.newLine();
-        const files = violations.map(violation => violation.file).join(' ');
-        sh.exec(`git add ${files}`, getShellConfig());
-        sh.exec(`git commit -m "${AUTO_FIX_MESSAGE}"`);
-        LOGGER.newLine();
-    }
-}
-
-// Helper types
-interface ValidationResult {
-    file: string;
-    violation: Violation;
-    line?: string;
-}
-
-interface DateValidationResult extends ValidationResult {
-    currentStartYear: number;
-    currentEndYear?: number;
-    expectedEndYear: number;
-}
-
-function isDateValidationResult(object: ValidationResult): object is DateValidationResult {
-    return 'currentStartYear' in object && 'expectedEndYear' in object;
-}
-
-type Violation = 'none' | 'noOrMissingHeader' | 'invalidEndYear' | 'noYear';

package/src/commands/coverage-report.ts

@@ -1,113 +0,0 @@
-/********************************************************************************
- * Copyright (c) 2022-2024 EclipseSource and others.
- *
- * This program and the accompanying materials are made available under the
- * terms of the Eclipse Public License v. 2.0 which is available at
- * http://www.eclipse.org/legal/epl-2.0.
- *
- * This Source Code may also be made available under the following Secondary
- * Licenses when the conditions for such availability set forth in the Eclipse
- * Public License v. 2.0 are satisfied: GNU General Public License, version 2
- * with the GNU Classpath Exception which is available at
- * https://www.gnu.org/software/classpath/license.html.
- *
- * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
- ********************************************************************************/
-
-import * as fs from 'fs';
-import * as path from 'path';
-import sh from 'shelljs';
-import { baseCommand, fatalExec, getShellConfig } from '../util/command-util';
-import { LOGGER } from '../util/logger';
-import { validateDirectory } from '../util/validation-util';
-
-export interface CoverageCmdOptions {
-    coverageScript: string;
-    projectRoot: string;
-}
-
-export const CoverageReportCommand = baseCommand() //
-    .name('coverageReport')
-    .description('Generate a test coverage report for a glsp component')
-    .option('-p, --projectRoot <projectRoot>', 'The root directory of the GLSP component', validateDirectory, process.cwd())
-    .option('-c, --coverageScript <script>', 'Script command of the package root for creating coverage reports', 'test:coverage')
-    .action(generateCoverageReport);
-
-/**
- * Generates and aggregates an 'nyc' coverage report for lerna/yarn mono repositories.
- * First, individual reports for each package are generated. Then, they are aggregated into one combined HTML report.
- * @param options configuration options
- */
-export function generateCoverageReport(options: CoverageCmdOptions): void {
-    sh.cd(options.projectRoot);
-    const packages = validateAndRetrievePackages(options);
-    LOGGER.info('Create individual package coverage reports');
-    const jsonReports = collectPackageReportFiles(packages, options);
-    combineReports(jsonReports, options);
-    LOGGER.info('Coverage reported generation successful');
-}
-
-export function validateAndRetrievePackages(options: CoverageCmdOptions): string[] {
-    const packagePath = path.join(options.projectRoot, 'package.json');
-    if (!fs.existsSync(packagePath)) {
-        CoverageReportCommand.error(`Invalid root directory. '${options.projectRoot}' does not contain a package.json.`);
-    }
-
-    fatalExec('yarn nyc -h', 'Nyc is not installed!', getShellConfig({ silent: true }));
-
-    const packageJson = JSON.parse(fs.readFileSync(packagePath).toString());
-
-    if (!packageJson?.scripts?.[options.coverageScript]) {
-        CoverageReportCommand.error(
-            `Invalid coverage script! The package.json does not have a script with name '${options.coverageScript}'!`
-        );
-    }
-
-    if (!Array.isArray(packageJson.workspaces)) {
-        CoverageReportCommand.error('Invalid package.json! No yarn workspaces are configured!');
-    }
-    return (packageJson.workspaces as string[]).map(pkg => pkg.replace('/*', ''));
-}
-
-export function collectPackageReportFiles(packages: string[], options: CoverageCmdOptions): string[] {
-    LOGGER.info('Create combined report');
-    sh.exec(`yarn ${options.coverageScript}`);
-    // collect reports
-    const reports: string[] = [];
-    packages.forEach(pkg => {
-        sh.find(pkg)
-            .filter(file => file.endsWith('coverage-final.json'))
-            .forEach(json => reports.push(path.resolve(options.projectRoot, json)));
-    });
-    return reports;
-}
-
-function combineReports(reportFiles: string[], options: CoverageCmdOptions): void {
-    //  Copy coverage into root/.nyc_output
-    const reportsDir = path.join(options.projectRoot, '.nyc_output');
-    if (fs.existsSync(reportsDir)) {
-        fs.rmSync(reportsDir, { force: true, recursive: true });
-    }
-    fs.mkdirSync(reportsDir);
-
-    for (let i = 0; i < reportFiles.length; i++) {
-        fs.copyFileSync(reportFiles[i], path.resolve('.nyc_output', `coverage-final-${i}.json`));
-    }
-
-    // Temporarily remove root nyc configs otherwise the report command might fail.
-    sh.cd(options.projectRoot);
-    const configFiles = ['.nycrc', '.nycrc.json', '.nyc-config.js'];
-    const tempFiles: string[] = [];
-    configFiles.forEach(config => {
-        if (fs.existsSync(path.join(options.projectRoot, config))) {
-            sh.mv(config, '_' + config);
-            tempFiles.push('_' + config);
-        }
-    });
-
-    // Generate report
-    sh.exec('yarn nyc report --reporter html', getShellConfig());
-
-    // Restore nyc configs (if any)
-    tempFiles.forEach(config => sh.mv(config, config.substring(1)));
-}

package/src/commands/generate-index.ts

@@ -1,169 +0,0 @@
-/********************************************************************************
- * Copyright (c) 2023-2024 EclipseSource and others.
- *
- * This program and the accompanying materials are made available under the
- * terms of the Eclipse Public License v. 2.0 which is available at
- * http://www.eclipse.org/legal/epl-2.0.
- *
- * This Source Code may also be made available under the following Secondary
- * Licenses when the conditions for such availability set forth in the Eclipse
- * Public License v. 2.0 are satisfied: GNU General Public License, version 2
- * with the GNU Classpath Exception which is available at
- * https://www.gnu.org/software/classpath/license.html.
- *
- * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
- ********************************************************************************/
-
-import { createOption } from 'commander';
-import * as fs from 'fs';
-import * as os from 'os';
-import * as path from 'path';
-import sh from 'shelljs';
-import { baseCommand } from '../util/command-util';
-import { LOGGER, configureLogger } from '../util/logger';
-import { validateDirectory } from '../util/validation-util';
-
-export interface GenerateIndexCmdOptions {
-    singleIndex: boolean;
-    forceOverwrite: boolean;
-    match: string[] | boolean;
-    ignore: string[] | boolean;
-    ignoreFile: string;
-    style: 'commonjs' | 'esm';
-    verbose: boolean;
-}
-
-// Partial type of the globby imports since we can not use the esm type directly
-interface GlobbyOptions {
-    ignore: string[];
-    cwd: string;
-    onlyFiles: boolean;
-    markDirectories: true;
-    ignoreFiles: string;
-}
-
-export const GenerateIndex = baseCommand() //
-    .name('generateIndex')
-    .description('Generate index files in a given source directory.')
-    .argument('<rootDir...>', 'The source directory for index generation.')
-    .option('-s, --singleIndex', 'Generate a single index file in the source directory instead of indices in each sub-directory', false)
-    .option('-f, --forceOverwrite', 'Overwrite existing index files and remove them if there are no entries', false)
-    .option('-m, --match [match patterns...]', 'File patterns to consider during indexing', ['**/*.ts', '**/*.tsx'])
-    .option('-i, --ignore [ignore patterns...]', 'File patterns to ignore during indexing', ['**/*.spec.ts', '**/*.spec.tsx', '**/*.d.ts'])
-    .addOption(createOption('-s, --style <importStyle>', 'Import Style').choices(['commonjs', 'esm']).default('commonjs'))
-    .option('--ignoreFile <ignoreFile>', 'The file that is used to specify patterns that should be ignored during indexing', '.indexignore')
-    .option('-v, --verbose', 'Generate verbose output during generation', false)
-    .action(generateIndices);
-
-export async function generateIndices(rootDirs: string[], options: GenerateIndexCmdOptions): Promise<void> {
-    const dirs = rootDirs.map(rootDir => validateDirectory(path.resolve(rootDir)));
-    const globby = await import('globby');
-    const ignoreFilter: (pattern: string[], options: GlobbyOptions) => string[] = (pattern, globbyOptions) =>
-        globby.globbySync(pattern, globbyOptions);
-    dirs.forEach(dir => generateIndex(dir, ignoreFilter, options));
-}
-
-export async function generateIndex(
-    rootDir: string,
-    ignoreFilter: (pattern: string[], options: GlobbyOptions) => string[],
-    options: GenerateIndexCmdOptions
-): Promise<void> {
-    configureLogger(options.verbose);
-    LOGGER.debug('Run generateIndex for', rootDir, 'with the following options:', options);
-    sh.cd(rootDir);
-    const cwd = process.cwd();
-
-    // we want to match all given patterns and subdirectories and ignore all given patterns and (generated) index files
-    const pattern = typeof options.match === 'boolean' ? ['**/'] : [...options.match, '**/'];
-    const ignore = typeof options.ignore === 'boolean' ? ['**/index.ts'] : [...options.ignore, '**/index.ts'];
-    const globbyOptions: GlobbyOptions = {
-        ignore,
-        cwd,
-        onlyFiles: options.singleIndex,
-        markDirectories: true, // directories have '/' at the end
-        ignoreFiles: '**/' + options.ignoreFile // users can add this file in their directories to ignore files for indexing
-    };
-    LOGGER.debug('Search for children using the following globby options', globbyOptions);
-    const files = ignoreFilter(pattern, globbyOptions);
-    LOGGER.debug('All children considered in the input directory', files);
-
-    const relativeRootDirectory = '';
-    if (options.singleIndex) {
-        writeIndex(relativeRootDirectory, files.filter(isFile), options);
-    } else {
-        // sort by length so we deal with sub-directories before we deal with their parents to determine whether they are empty
-        const directories = [...files.filter(isDirectory), relativeRootDirectory].sort((left, right) => right.length - left.length);
-        const directoryChildren = new Map<string, string[]>();
-        for (const directory of directories) {
-            const children = files.filter(file => isDirectChild(directory, file, () => !!directoryChildren.get(file)?.length));
-            directoryChildren.set(directory, children);
-            writeIndex(directory, children, options);
-        }
-    }
-}
-
-export function isDirectChild(parent: string, child: string, childHasChildren: () => boolean): boolean {
-    return isChildFile(parent, child) || (isChildDirectory(parent, child) && childHasChildren());
-}
-
-export function isDirectory(file: string): boolean {
-    return file.endsWith('/');
-}
-
-export function isFile(file: string): boolean {
-    return !isDirectory(file);
-}
-
-export function getLevel(file: string): number {
-    return file.split('/').length;
-}
-
-export function isChild(parent: string, child: string): boolean {
-    return child.startsWith(parent);
-}
-
-export function isChildDirectory(parent: string, child: string): boolean {
-    return isDirectory(child) && isChild(parent, child) && getLevel(child) === getLevel(parent) + 1;
-}
-
-export function isChildFile(parent: string, child: string): boolean {
-    return isFile(child) && isChild(parent, child) && getLevel(child) === getLevel(parent);
-}
-
-export function writeIndex(directory: string, exports: string[], options: GenerateIndexCmdOptions): void {
-    const indexFile = path.join(process.cwd(), directory, 'index.ts');
-    if (exports.length === 0) {
-        if (options.forceOverwrite && fs.existsSync(indexFile)) {
-            LOGGER.info('Remove index file', indexFile);
-            fs.rmSync(indexFile);
-        }
-        return;
-    }
-    const exists = fs.existsSync(indexFile);
-    if (exists && !options.forceOverwrite) {
-        LOGGER.info("Do not overwrite existing index file. Use '-f' to force an overwrite.", indexFile);
-        return;
-    }
-
-    const headerContent = exists ? extractReusableContent(fs.readFileSync(indexFile, { encoding: 'utf-8' })) : '';
-    const exportContent = exports.map(exported => createExport(directory, exported, options)).sort();
-    const content = headerContent + exportContent.join(os.EOL) + os.EOL; // end with an empty line
-    LOGGER.info((exists ? 'Overwrite' : 'Write') + ' index file', indexFile);
-    LOGGER.debug('  ' + content.split(os.EOL).join(os.EOL + '  '));
-    fs.writeFileSync(indexFile, content, { flag: 'w' });
-}
-
-export function createExport(directory: string, relativePath: string, options: GenerateIndexCmdOptions): string {
-    // remove directory prefix, file extension and directory ending '/'
-    const parentPrefix = directory.length;
-    const suffix = isFile(relativePath) ? path.extname(relativePath).length : 1;
-    const relativeName = relativePath.substring(parentPrefix, relativePath.length - suffix);
-    const exportName = options.style === 'esm' && isFile(relativePath) ? relativeName + '.js' : relativeName;
-    const exportLine = `export * from './${exportName}';`;
-    return exportLine;
-}
-
-export function extractReusableContent(fileContent: string): string {
-    // all code before any actual export lines are considered re-usable
-    return fileContent.match(/^(.*?)(?=^export)/ms)?.[0] ?? '';
-}