@abaplint/cli 2.82.1 → 2.82.5

package/build/src/file_operations.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FileOperations = void 0;
+const fs = require("fs");
+const path = require("path");
+const zlib = require("zlib");
+const glob = require("glob");
+const core_1 = require("@abaplint/core");
+const compressed_file_1 = require("./compressed_file");
+class FileOperations {
+    static deleteFolderRecursive(dir) {
+        if (fs.existsSync(dir) === false) {
+            return;
+        }
+        fs.rmSync(dir, { recursive: true });
+    }
+    static loadFileNames(arg, error = true) {
+        const files = glob.sync(arg, { nosort: true, nodir: true });
+        if (files.length === 0 && error) {
+            throw "Error: No files found";
+        }
+        return files;
+    }
+    static async loadFiles(compress, input, bar) {
+        const files = [];
+        bar.set(input.length, "Reading files");
+        for (const filename of input) {
+            bar.tick("Reading files - " + path.basename(filename));
+            const base = filename.split("/").reverse()[0];
+            if (base.split(".").length <= 2) {
+                continue; // not a abapGit file
+            }
+            // note that readFileSync is typically faster than async readFile,
+            // https://medium.com/@adamhooper/node-synchronous-code-runs-faster-than-asynchronous-code-b0553d5cf54e
+            const raw = fs.readFileSync(filename, "utf8");
+            if (compress === true) {
+                // todo, util.promisify(zlib.deflate) does not seem to work?
+                files.push(new compressed_file_1.CompressedFile(filename, zlib.deflateSync(raw).toString("base64")));
+            }
+            else {
+                files.push(new core_1.MemoryFile(filename, raw));
+            }
+        }
+        return files;
+    }
+}
+exports.FileOperations = FileOperations;
+//# sourceMappingURL=file_operations.js.map

package/build/src/fixes.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.applyFixes = void 0;
+const core_1 = require("@abaplint/core");
+function applyFixes(inputIssues, reg, fs, bar) {
+    let changed = [];
+    let iteration = 1;
+    let issues = inputIssues;
+    const MAX_ITERATIONS = 30;
+    bar === null || bar === void 0 ? void 0 : bar.set(MAX_ITERATIONS, "Apply Fixes");
+    while (iteration <= MAX_ITERATIONS) {
+        bar === null || bar === void 0 ? void 0 : bar.tick("Apply Fixes, iteration " + iteration + ", " + issues.length + " candidates");
+        changed = applyList(issues, reg, fs);
+        if (changed.length === 0) {
+            break;
+        }
+        iteration++;
+        issues = reg.parse().findIssues();
+    }
+    // always end the progress indicator at 100%
+    while (iteration <= MAX_ITERATIONS) {
+        bar === null || bar === void 0 ? void 0 : bar.tick("Apply Fixes, iteration " + iteration + ", " + issues.length + " candidates");
+        iteration++;
+    }
+    return issues;
+}
+exports.applyFixes = applyFixes;
+function possibleOverlap(edit, list) {
+    // only checks if the edits have changes in the same rows
+    for (const e of list) {
+        for (const file1 of Object.keys(e)) {
+            for (const file2 of Object.keys(edit)) {
+                if (file1 === file2) {
+                    for (const list1 of e[file1]) {
+                        for (const list2 of edit[file2]) {
+                            if (list2.range.start.getRow() <= list1.range.start.getRow()
+                                && list2.range.end.getRow() >= list1.range.start.getRow()) {
+                                return true;
+                            }
+                            if (list2.range.start.getRow() <= list1.range.start.getRow()
+                                && list2.range.end.getRow() >= list1.range.end.getRow()) {
+                                return true;
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+    return false;
+}
+function applyList(issues, reg, fs) {
+    const edits = [];
+    for (const i of issues) {
+        const edit = i.getFix();
+        if (edit === undefined) {
+            continue;
+        }
+        else if (possibleOverlap(edit, edits) === true) {
+            continue;
+        }
+        edits.push(edit);
+    }
+    const changed = (0, core_1.applyEditList)(reg, edits);
+    for (const filename of changed) {
+        const file = reg.getFileByName(filename);
+        if (file === undefined) {
+            continue;
+        }
+        fs.writeFileSync(file.getFilename(), file.getRaw());
+    }
+    return changed;
+}
+//# sourceMappingURL=fixes.js.map

package/build/src/formatters/_format.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Formatter = void 0;
+const Formatters = require(".");
+class Formatter {
+    static format(issues, format, fileCount) {
+        // todo, this can be done more generic, move to artifacts.ts?
+        switch (format) {
+            case "total":
+                return new Formatters.Total().output(issues, fileCount);
+            case "json":
+                return new Formatters.Json().output(issues, fileCount);
+            case "junit":
+                return new Formatters.Junit().output(issues, fileCount);
+            case "codeframe":
+                return new Formatters.CodeFrame().output(issues, fileCount);
+            default:
+                return new Formatters.Standard().output(issues, fileCount);
+        }
+    }
+}
+exports.Formatter = Formatter;
+//# sourceMappingURL=_format.js.map

package/build/src/formatters/_iformatter.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=_iformatter.js.map

package/build/src/formatters/codeframe.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CodeFrame = void 0;
+const total_1 = require("./total");
+const fs = require("fs");
+const chalk_1 = require("chalk");
+function issueSort(a, b) {
+    return a.filename.localeCompare(b.filename)
+        || (a.row - b.row)
+        || (a.col - b.col);
+}
+class CodeFrame {
+    constructor() {
+        this.currentFilename = "";
+        this.currentFileLinesCount = 0;
+        this.fileContent = [];
+    }
+    output(issues, fileCount) {
+        const builtIssues = this.convertAllIssues(issues).sort(issueSort); // Make sure it is sorted by filename for caching to work
+        return [
+            ...builtIssues.map(i => this.renderIssue(i)),
+            (issues.length > 0 ? (0, chalk_1.red)(new total_1.Total().output(issues, fileCount)) : (0, chalk_1.green)(new total_1.Total().output(issues, fileCount))),
+        ].join("\n");
+    }
+    convertAllIssues(issues) {
+        return issues.map(i => this.convertIssue(i));
+    }
+    cacheFile(filename) {
+        if (filename !== this.currentFilename) {
+            this.currentFilename = filename;
+            this.fileContent = fs.readFileSync(filename, "utf8").split(/\r?\n/);
+            this.currentFileLinesCount = this.fileContent.length;
+        }
+    }
+    renderIssue(issue) {
+        this.cacheFile(issue.filename);
+        const frameSize = 1;
+        const lineFrom = Math.max(issue.row - frameSize, 1);
+        const lineTo = Math.min(issue.row + frameSize, this.currentFileLinesCount);
+        const issueLineIndex = issue.row - 1;
+        const padSize = Math.ceil(Math.log10(lineTo)) + 4;
+        const code = [];
+        for (let lineIndex = lineFrom - 1; lineIndex < lineTo; lineIndex++) {
+            const prefix = `${ /*(lineIndex === issueLineIndex) ? ">" :*/" "}${lineIndex + 1} |`.padStart(padSize);
+            code.push(prefix + this.fileContent[lineIndex]);
+            if (lineIndex === issueLineIndex) {
+                code.push("|".padStart(padSize) + " ".repeat(issue.col - 1) + "^");
+            }
+        }
+        const severityStr = issue.severity === "E"
+            ? (0, chalk_1.red)(issue.severity)
+            : (0, chalk_1.yellow)(issue.severity);
+        return `[${severityStr}] ${issue.description} (${issue.issueKey}) @ ${issue.location}`
+            + "\n"
+            + code.map(str => (0, chalk_1.grey)(str)).join("\n")
+            + "\n";
+    }
+    renderLocation(issue) {
+        return issue.getFilename() + "[" + issue.getStart().getRow() + ", " + issue.getStart().getCol() + "]";
+    }
+    convertIssue(issue) {
+        return {
+            location: this.renderLocation(issue),
+            description: issue.getMessage(),
+            issueKey: issue.getKey(),
+            filename: issue.getFilename(),
+            severity: issue.getSeverity().toString().charAt(0),
+            row: issue.getStart().getRow(),
+            col: issue.getStart().getCol(),
+        };
+    }
+}
+exports.CodeFrame = CodeFrame;
+//# sourceMappingURL=codeframe.js.map

package/build/src/formatters/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./json"), exports);
+__exportStar(require("./junit"), exports);
+__exportStar(require("./standard"), exports);
+__exportStar(require("./total"), exports);
+__exportStar(require("./codeframe"), exports);
+//# sourceMappingURL=index.js.map

package/build/src/formatters/json.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Json = void 0;
+class Json {
+    output(issues, _fileCount) {
+        const out = [];
+        for (const issue of issues) {
+            const single = {
+                description: issue.getMessage(),
+                key: issue.getKey(),
+                file: issue.getFilename(),
+                start: {
+                    row: issue.getStart().getRow(),
+                    col: issue.getStart().getCol(),
+                },
+                end: {
+                    row: issue.getEnd().getRow(),
+                    col: issue.getEnd().getCol(),
+                },
+                severity: issue.getSeverity(),
+            };
+            out.push(single);
+        }
+        return JSON.stringify(out) + "\n";
+    }
+}
+exports.Json = Json;
+//# sourceMappingURL=json.js.map

package/build/src/formatters/junit.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Junit = void 0;
+const xml_js_1 = require("xml-js");
+class Junit {
+    output(issues, _fileCount) {
+        const outputObj = {
+            _declaration: {
+                _attributes: {
+                    version: "1.0",
+                    encoding: "UTF-8",
+                },
+            },
+            testsuites: {
+                testsuite: {
+                    _attributes: {
+                        name: "abaplint",
+                        tests: issues.length || 1,
+                        failures: issues.length,
+                        errors: 0,
+                        skipped: 0,
+                    },
+                    testcase: [],
+                },
+            },
+        };
+        if (issues.length > 0) {
+            for (const issue of issues) {
+                outputObj.testsuites.testsuite.testcase.push({
+                    _attributes: {
+                        classname: issue.getFilename().split(".")[0],
+                        file: issue.getFilename(),
+                        name: `${issue.getFilename()}: [${issue.getStart().getRow()}, ${issue.getStart().getCol()}] - ${issue.getKey()}`,
+                    },
+                    failure: {
+                        _attributes: {
+                            message: issue.getKey(),
+                            type: issue.getSeverity().toString(),
+                        },
+                        _cdata: `${issue.getMessage()}`,
+                    },
+                });
+            }
+        }
+        else {
+            outputObj.testsuites.testsuite.testcase.push({
+                _attributes: {
+                    classname: "none",
+                    name: "OK",
+                },
+            });
+        }
+        const xml = (0, xml_js_1.js2xml)(outputObj, { compact: true, spaces: 2 });
+        return xml;
+    }
+}
+exports.Junit = Junit;
+//# sourceMappingURL=junit.js.map

package/build/src/formatters/standard.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Standard = void 0;
+const total_1 = require("./total");
+class Standard {
+    output(issues, fileCount) {
+        const tuples = [];
+        for (const issue of issues) {
+            tuples.push(this.build(issue));
+        }
+        tuples.sort((a, b) => {
+            const nameCompare = a.rawFilename.localeCompare(b.rawFilename);
+            if (nameCompare === 0) {
+                const rowCompare = a.startPos.getRow() - b.startPos.getRow();
+                if (rowCompare === 0) {
+                    return a.startPos.getCol() - b.startPos.getCol();
+                }
+                else {
+                    return rowCompare;
+                }
+            }
+            else {
+                return nameCompare;
+            }
+        });
+        const result = this.columns(tuples);
+        return result + new total_1.Total().output(issues, fileCount);
+    }
+    columns(issues) {
+        let max = 0;
+        issues.forEach((tuple) => { if (max < tuple.filename.length) {
+            max = tuple.filename.length;
+        } });
+        let result = "";
+        issues.forEach((issue) => {
+            result = result +
+                this.pad(issue.filename, max - issue.filename.length) +
+                issue.description +
+                ` [${issue.severity.charAt(0)}]\n`; //E/W/I
+        });
+        return result;
+    }
+    pad(input, length) {
+        let output = input;
+        for (let i = 0; i < length; i++) {
+            output = output + " ";
+        }
+        return output + " - ";
+    }
+    build(issue) {
+        return {
+            filename: issue.getFilename() + "[" + issue.getStart().getRow() + ", " + issue.getStart().getCol() + "]",
+            description: issue.getMessage() + " (" + issue.getKey() + ")",
+            startPos: issue.getStart(),
+            rawFilename: issue.getFilename(),
+            severity: issue.getSeverity().toString(),
+        };
+    }
+}
+exports.Standard = Standard;
+//# sourceMappingURL=standard.js.map

package/build/src/formatters/total.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Total = void 0;
+class Total {
+    output(issues, fileCount) {
+        return "abaplint: " + issues.length + " issue(s) found, " + fileCount + " file(s) analyzed\n";
+    }
+}
+exports.Total = Total;
+//# sourceMappingURL=total.js.map

package/build/src/index.d.ts

@@ -0,0 +1,20 @@
+import { Issue, IRegistry } from "@abaplint/core";
+export declare const GENERIC_ERROR = "generic_error";
+export declare type Arguments = {
+    configFilename?: string;
+    format: string;
+    compress?: boolean;
+    parsingPerformance?: boolean;
+    showHelp?: boolean;
+    showVersion?: boolean;
+    outputDefaultConfig?: boolean;
+    runFix?: boolean;
+    runRename?: boolean;
+    outFormat?: string;
+    outFile?: string;
+};
+export declare function run(arg: Arguments): Promise<{
+    output: string;
+    issues: Issue[];
+    reg: IRegistry | undefined;
+}>;

package/build/src/index.js

@@ -0,0 +1,206 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.run = exports.GENERIC_ERROR = void 0;
+const fs = require("fs");
+const os = require("os");
+const path = require("path");
+const ProgressBar = require("progress");
+const childProcess = require("child_process");
+const JSON5 = require("json5");
+const core_1 = require("@abaplint/core");
+const _format_1 = require("./formatters/_format");
+const file_operations_1 = require("./file_operations");
+const apack_dependency_provider_1 = require("./apack_dependency_provider");
+const fixes_1 = require("./fixes");
+const rename_1 = require("./rename");
+exports.GENERIC_ERROR = "generic_error";
+class Progress {
+    set(total, _text) {
+        this.bar = new ProgressBar(":percent - :elapseds - :text", { total, renderThrottle: 100 });
+    }
+    async tick(text) {
+        this.bar.tick({ text });
+        this.bar.render();
+    }
+    tickSync(text) {
+        this.bar.tick({ text });
+        this.bar.render();
+    }
+}
+function loadConfig(filename) {
+    // possible cases:
+    // a) nothing specified, using abaplint.json from cwd
+    // b) nothing specified, no abaplint.json in cwd
+    // c) specified and found
+    // d) specified and not found => use default
+    // e) supplied but a directory => use default
+    let f = "";
+    if (filename === undefined) {
+        f = process.cwd() + path.sep + "abaplint.json";
+        if (fs.existsSync(f) === false) {
+            f = process.cwd() + path.sep + "abaplint.jsonc";
+        }
+        if (fs.existsSync(f) === false) {
+            f = process.cwd() + path.sep + "abaplint.json5";
+        }
+        if (fs.existsSync(f) === false) {
+            process.stderr.write("Using default config\n");
+            return { config: core_1.Config.getDefault(), base: "." };
+        }
+    }
+    else {
+        if (fs.existsSync(filename) === false) {
+            process.stderr.write("ERROR: Specified abaplint configuration file does not exist, using default config\n");
+            return { config: core_1.Config.getDefault(), base: "." };
+        }
+        else if (fs.statSync(filename).isDirectory() === true) {
+            process.stderr.write("Supply filename, not directory, using default config\n");
+            return { config: core_1.Config.getDefault(), base: "." };
+        }
+        f = filename;
+    }
+    // evil hack to get JSON5 working
+    if (JSON5.parse === undefined) {
+        // @ts-ignore
+        JSON5.parse = JSON5.default.parse;
+    }
+    process.stderr.write("Using config: " + f + "\n");
+    const json = fs.readFileSync(f, "utf8");
+    const parsed = JSON5.parse(json);
+    const vers = core_1.Version;
+    if (Object.keys(core_1.Version).some(v => vers[v] === parsed.syntax.version) === false) {
+        throw "Error: Unknown version in abaplint.json";
+    }
+    return {
+        config: new core_1.Config(json),
+        base: path.dirname(f) === process.cwd() ? "." : path.dirname(f),
+    };
+}
+async function loadDependencies(config, compress, bar, base) {
+    let files = [];
+    const deps = config.get().dependencies || [];
+    const useApack = config.get().global.useApackDependencies;
+    if (useApack) {
+        const apackPath = path.join(base, ".apack-manifest.xml");
+        if (fs.existsSync(apackPath)) {
+            const apackManifest = fs.readFileSync(apackPath, "utf8");
+            deps.push(...apack_dependency_provider_1.ApackDependencyProvider.fromManifest(apackManifest));
+        }
+    }
+    if (!deps) {
+        return [];
+    }
+    for (const d of deps) {
+        if (d.folder) {
+            const g = base + d.folder + d.files;
+            const names = file_operations_1.FileOperations.loadFileNames(g, false);
+            if (names.length > 0) {
+                process.stderr.write("Using dependency from: " + g + "\n");
+                files = files.concat(await file_operations_1.FileOperations.loadFiles(compress, names, bar));
+                continue;
+            }
+        }
+        if (d.url) {
+            process.stderr.write("Clone: " + d.url + "\n");
+            const dir = fs.mkdtempSync(path.join(os.tmpdir(), "abaplint-"));
+            childProcess.execSync("git clone --quiet --depth 1 " + d.url + " .", { cwd: dir, stdio: "inherit" });
+            const names = file_operations_1.FileOperations.loadFileNames(dir + d.files);
+            files = files.concat(await file_operations_1.FileOperations.loadFiles(compress, names, bar));
+            file_operations_1.FileOperations.deleteFolderRecursive(dir);
+        }
+    }
+    return files;
+}
+function displayHelp() {
+    // follow https://docopt.org conventions,
+    return "Usage:\n" +
+        "  abaplint [<abaplint.json> -f <format> -c --outformat <format> --outfile <file> --fix] \n" +
+        "  abaplint -h | --help      show this help\n" +
+        "  abaplint -v | --version   show version\n" +
+        "  abaplint -d | --default   show default configuration\n" +
+        "\n" +
+        "Options:\n" +
+        "  -f, --format <format>  output format (standard, total, json, summary, junit, codeframe)\n" +
+        "  --outformat <format>   output format, use in combination with outfile\n" +
+        "  --outfile <file>       output issues to file in format\n" +
+        "  --fix                  apply quick fixes to files\n" +
+        "  --rename               rename object according to rules in abaplint.json\n" +
+        "  -p                     output performance information\n" +
+        "  -c                     compress files in memory\n";
+}
+function out(issues, length, arg) {
+    const output = _format_1.Formatter.format(issues, arg.format, length);
+    if (arg.outFormat && arg.outFile) {
+        const fileContents = _format_1.Formatter.format(issues, arg.outFile, length);
+        fs.writeFileSync(arg.outFile, fileContents, "utf-8");
+    }
+    return output;
+}
+async function run(arg) {
+    var _a, _b;
+    // evil hack to get JSON5 working
+    if (JSON5.parse === undefined) {
+        // @ts-ignore
+        JSON5.parse = JSON5.default.parse;
+    }
+    if (JSON5.stringify === undefined) {
+        // @ts-ignore
+        JSON5.stringify = JSON5.default.stringify;
+    }
+    let output = "";
+    let issues = [];
+    let reg = undefined;
+    const progress = new Progress();
+    if (arg.showHelp === true) {
+        output = output + displayHelp();
+    }
+    else if (arg.showVersion === true) {
+        output = output + core_1.Registry.abaplintVersion() + "\n";
+    }
+    else if (arg.outputDefaultConfig === true) {
+        output = output + JSON.stringify(core_1.Config.getDefault().get(), undefined, 2) + "\n";
+    }
+    else {
+        process.stderr.write("abaplint " + core_1.Registry.abaplintVersion() + "\n");
+        let loaded = [];
+        let deps = [];
+        const { config, base } = loadConfig(arg.configFilename);
+        try {
+            if (config.get().global.files === undefined) {
+                throw "Error: Update abaplint configuration file to latest format";
+            }
+            const files = file_operations_1.FileOperations.loadFileNames(base + config.get().global.files);
+            loaded = await file_operations_1.FileOperations.loadFiles(arg.compress, files, progress);
+            deps = await loadDependencies(config, arg.compress, progress, base);
+            reg = new core_1.Registry(config);
+            reg.addDependencies(deps);
+            reg.addFiles(loaded); // if the object exists in repo, it should take precedence over deps
+            await reg.parseAsync({ progress, outputPerformance: arg.parsingPerformance });
+            issues = issues.concat(reg.findIssues({ progress, outputPerformance: arg.parsingPerformance }));
+        }
+        catch (error) {
+            const file = new core_1.MemoryFile("generic", "dummy");
+            const message = error.toString() + " " + ((_b = (_a = error.stack) === null || _a === void 0 ? void 0 : _a.split("\n")[1]) === null || _b === void 0 ? void 0 : _b.trim());
+            const issue = core_1.Issue.atPosition(file, new core_1.Position(1, 1), message, exports.GENERIC_ERROR);
+            issues = [issue];
+        }
+        let extra = "";
+        if (arg.runFix === true && reg) {
+            issues = (0, fixes_1.applyFixes)(issues, reg, fs, progress);
+            extra = "Fixes applied";
+        }
+        else if (arg.runRename === true && reg) {
+            if (issues.length === 0) {
+                new rename_1.Rename(reg).run(config, base);
+                extra = "Renames applied";
+            }
+            else {
+                extra = "Renames NOT applied, issues found";
+            }
+        }
+        output = out(issues, loaded.length, arg) + extra;
+    }
+    return { output, issues, reg };
+}
+exports.run = run;
+//# sourceMappingURL=index.js.map