@abaplint/cli 2.82.2 → 2.82.6

package/build/src/apack_dependency_provider.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApackDependencyProvider = void 0;
+const xml_js_1 = require("xml-js");
+class ApackDependencyProvider {
+    static fromManifest(manifestContents) {
+        var _a, _b;
+        if (!manifestContents || !manifestContents.length) {
+            return [];
+        }
+        const result = [];
+        const manifest = (0, xml_js_1.xml2js)(manifestContents, { compact: true });
+        let apackDependencies = (_b = (_a = manifest["asx:abap"]["asx:values"]["DATA"]) === null || _a === void 0 ? void 0 : _a["DEPENDENCIES"]) === null || _b === void 0 ? void 0 : _b.item;
+        if (!apackDependencies) {
+            return [];
+        }
+        else if (!apackDependencies.length) {
+            apackDependencies = [apackDependencies];
+        }
+        for (const dependency of apackDependencies) {
+            result.push({
+                files: "/src/**/*.*",
+                url: dependency["GIT_URL"]["_text"],
+            });
+        }
+        return result;
+    }
+}
+exports.ApackDependencyProvider = ApackDependencyProvider;
+//# sourceMappingURL=apack_dependency_provider.js.map

package/build/src/compressed_file.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CompressedFile = void 0;
+const core_1 = require("@abaplint/core");
+const zlib = require("zlib");
+class CompressedFile extends core_1.AbstractFile {
+    constructor(filename, compressed) {
+        super(filename);
+        this.compressed = compressed;
+    }
+    getRaw() {
+        return this.decompress(this.compressed);
+    }
+    getRawRows() {
+        return this.decompress(this.compressed).split("\n");
+    }
+    decompress(compressed) {
+        return zlib.inflateSync(Buffer.from(compressed, "base64")).toString("utf8");
+    }
+}
+exports.CompressedFile = CompressedFile;
+//# sourceMappingURL=compressed_file.js.map

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

@@ -3,13 +3,13 @@ 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;
+    compress?: boolean;
+    parsingPerformance?: boolean;
+    showHelp?: boolean;
+    showVersion?: boolean;
+    outputDefaultConfig?: boolean;
+    runFix?: boolean;
+    runRename?: boolean;
     outFormat?: string;
     outFile?: string;
 };