ern-api-gen/dist/AbstractGenerator.js

"use strict";
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
const LoggerFactory_1 = __importDefault(require("./java/LoggerFactory"));
const File_1 = __importDefault(require("./java/File"));
const fs_1 = __importDefault(require("fs"));
const path_1 = __importDefault(require("path"));
const File = File_1.default;
const ABSTRACT_SEARCH_PATHS = [path_1.default.join(__dirname, '..', 'resources')];
class AbstractGenerator {
    writeToFile(filename, contents) {
        Log.info('writing file ' + filename);
        const f = new File(filename);
        f.getParentFile().mkdirs();
        return fs_1.default.writeFileSync(f.getPath(), contents, 'utf8');
    }
    readTemplate(name) {
        const reader = this.getTemplateReader(name);
        if (reader == null) {
            throw new Error(`no file found for "${name}"`);
        }
        return reader;
    }
    getTemplateReader(name) {
        const f = this._resolveFilePath(name);
        if (f == null) {
            throw new Error("can't load template " + name);
        }
        try {
            return fs_1.default.readFileSync(f, 'utf-8');
        }
        catch (e) {
            Log.trace(e);
        }
    }
    /**
     * Get the template file path with template dir prepended, and use the
     * library template if exists.
     *
     * Resolve from embeddedTemplate/library, than embeddedTemplate,  then templateDir
     *
     * @param config Codegen config
     * @param templateFile Template file
     * @return String Full template file path
     */
    getFullTemplateFile(config, templateFile) {
        const library = config.getLibrary();
        if (library) {
            const libTemplateFile = this._resolveFilePath(config.embeddedTemplateDir(), 'libraries', library, templateFile);
            if (libTemplateFile != null) {
                return libTemplateFile;
            }
        }
        const embeddedTemplate = this._resolveFilePath(config.embeddedTemplateDir(), templateFile);
        if (embeddedTemplate != null) {
            return embeddedTemplate;
        }
        const template = this._resolveFilePath(config.templateDir(), templateFile);
        if (template != null) {
            return template;
        }
    }
    readResourceContents(resourceFilePath) {
        const file = this._resolveFilePath(resourceFilePath);
        if (file == null) {
            Log.warn(`Could not resolve ${resourceFilePath}`);
            return;
        }
        return fs_1.default.readFileSync(file, 'utf8');
    }
    embeddedTemplateExists(name) {
        const f = this._resolveFile(name);
        return f != null;
    }
    getCPResourcePath(name) {
        if (!('/' === File.separator)) {
            return name.replace(new RegExp(File.separator, 'g'), '/');
        }
        return name;
    }
    _resolveFilePath(...paths) {
        const f = this._resolveFile(...paths);
        if (f == null) {
            return;
        }
        return f.getAbsolutePath();
    }
    _resolveFile(...paths) {
        for (const p of AbstractGenerator.SEARCH_PATHS) {
            const file = new File(p, ...paths);
            if (file.exists()) {
                return file;
            }
        }
        const last = new File(paths.shift(), ...paths);
        if (last.exists()) {
            return last;
        }
    }
}
exports.default = AbstractGenerator;
AbstractGenerator.SEARCH_PATHS = ABSTRACT_SEARCH_PATHS;
const Log = LoggerFactory_1.default.getLogger(AbstractGenerator);
//# sourceMappingURL=AbstractGenerator.js.map