remote-abap-compiler-cli/dist/lib/commands/compile.js

Remote ABAP compilation

"use strict";
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
    return new (P || (P = Promise))(function (resolve, reject) {
        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
        function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }
        step((generator = generator.apply(thisArg, _arguments || [])).next());
    });
};
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
const command_1 = require("@oclif/command");
const fs_1 = require("fs");
const read_1 = __importDefault(require("read"));
const remote_abap_compiler_1 = require("remote-abap-compiler");
const string_format_1 = __importDefault(require("string-format"));
class Compile extends command_1.Command {
    constructor() {
        super(...arguments);
        this.lineOffset = 0;
    }
    run() {
        return __awaiter(this, void 0, void 0, function* () {
            const { args, flags } = this.parse(Compile);
            fs_1.readFile(args.file, "utf8", (err, buffer) => {
                if (err) {
                    throw err;
                }
                buffer = this.filterOutCommentsAtStartOfFile(buffer);
                this.requirePassword(flags.url, flags.user, flags.client, flags.password, (url, user, client, password) => {
                    this.connectAndCompile(flags.url, flags.user, flags.client, password, buffer);
                });
            });
        });
    }
    filterOutCommentsAtStartOfFile(buffer) {
        const newBuffer = buffer.split(/\r?\n/);
        while (newBuffer.length > 0 && newBuffer[0].startsWith("#")) {
            newBuffer.shift();
            this.lineOffset += 1;
        }
        return newBuffer.length > 0 ? newBuffer.join("\n") : "";
    }
    requirePassword(url, user, client, password, callback) {
        if (!password) {
            read_1.default({ prompt: "Password: ", silent: true }, (err, pw) => {
                if (!err) {
                    callback(url, user, client, pw);
                }
                else {
                    console.log("Cancelled");
                }
            });
        }
        else {
            callback(url, user, client, password);
        }
    }
    connectAndCompile(url, user, client, password, code) {
        return __awaiter(this, void 0, void 0, function* () {
            try {
                const req = new remote_abap_compiler_1.CompilationRequest(url, user, client, password);
                const result = yield req.compile(code);
                if (result.success) {
                    if (result.output) {
                        console.log(result.output);
                    }
                }
                else {
                    if (result.errors) {
                        result.errors.forEach((error) => {
                            console.log(string_format_1.default("Line: {line}, Offset: {offset}, Error: \"{errorMessage}\"", {
                                errorMessage: error.errorMessage,
                                line: error.line === -1 ? -1 : (error.line !== undefined ? error.line : 0) + this.lineOffset,
                                offset: error.offset,
                            }));
                        });
                    }
                    else {
                        console.log(string_format_1.default("Internal error: \"{className}\"", result));
                    }
                }
            }
            catch (error) {
                console.log(error);
                if (error.message !== undefined && error.err !== undefined) {
                    console.log(string_format_1.default("HTTP error {err}, Message: \"{message}\"", error));
                }
                else {
                    console.error(error);
                }
            }
        });
    }
}
Compile.description = "Compile an ABAP source file";
Compile.examples = [
    `$ abapc compile -u https://server_name:port_number -u user file.abap
    `,
];
Compile.flags = {
    client: command_1.flags.string({ char: "c", description: "ABAP client", required: true }),
    help: command_1.flags.help({ char: "h" }),
    password: command_1.flags.string({ char: "p", description: "server password" }),
    url: command_1.flags.string({ char: "u", description: "server url", required: true }),
    user: command_1.flags.string({ char: "n", description: "username", required: true }),
};
Compile.args = [{ name: "file" }];
exports.default = Compile;