@ckomi/basic-cli/lib/commands/new-page.js

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const command_1 = require("@oclif/command");
// Constants
const Mustache = require('mustache');
const fs = require('fs');
const path = require('path');
var helper = require('../helper');
// Global variables
var exec = require('child_process').exec;
var name;
var validationErrors = new Set([]);
// Type declarations
var MainAdditions;
(function (MainAdditions) {
    MainAdditions["ImportPages"] = "ImportPages";
    MainAdditions["ModelPages"] = "ModelPages";
    MainAdditions["ViewPages"] = "ViewPages";
    MainAdditions["UpdatePages"] = "UpdatePages";
    MainAdditions["MsgPages"] = "MsgPages";
    MainAdditions["SubscriptionPages"] = "SubscriptionPages";
    MainAdditions["RoutePages"] = "RoutePages";
    MainAdditions["ToSession"] = "ToSession";
})(MainAdditions || (MainAdditions = {}));
var RouteAdditions;
(function (RouteAdditions) {
    RouteAdditions["RouteToString"] = "RouteToString";
    RouteAdditions["RouteParser"] = "RouteParser";
    RouteAdditions["RouteType"] = "RouteType";
})(RouteAdditions || (RouteAdditions = {}));
var errorMessages = [
    {
        msg: "Add -- TO SESSION comment inside toSession function.",
        additionType: MainAdditions.ToSession
    },
    {
        msg: "Add -- ROUTE MAIN comment inside maybeRoute case of changeRouteTo function.",
        additionType: MainAdditions.RoutePages
    },
    {
        msg: "Add -- SUBSCRIPTIONS PAGES comment inside model case of subscriptions function.",
        additionType: MainAdditions.SubscriptionPages
    },
    {
        msg: "Add -- MSG PAGES comment inside type Msg sum type.",
        additionType: MainAdditions.MsgPages
    },
    {
        msg: "Add -- UPDATE PAGES comment inside (msg, model) case in update function.",
        additionType: MainAdditions.UpdatePages
    },
    {
        msg: "Add -- VIEW PAGES comment inside model case of view function.",
        additionType: MainAdditions.ViewPages
    },
    {
        msg: "Add -- MODEL PAGES comment inside type Model sum type.",
        additionType: MainAdditions.ModelPages
    },
    {
        msg: "Add -- IMPORT PAGES comment in top of the file bellow module Main line.",
        additionType: MainAdditions.ImportPages
    },
    {
        msg: "Add -- ROUTE TYPE comment inside type Route sum type.",
        additionType: RouteAdditions.RouteType
    },
    {
        msg: "Add -- ROUTE TO STRING comment inside case page of routeToString function.",
        additionType: RouteAdditions.RouteToString
    },
    {
        msg: "Add -- ROUTE PARSER comment inside oneOf list in parser function.",
        additionType: RouteAdditions.RouteParser
    }
];
// Function declarations
function ucfirst(n) {
    return n.charAt(0).toUpperCase() + n.slice(1);
}
function checkIfCommentExsists(addition, data) {
    var doesExsist = data.join("\n").includes(addition.comment.trim());
    if (doesExsist === false) {
        validationErrors.add(addition.additionType);
    }
    ;
}
function renderMustache(name) {
    var view = { name: ucfirst(name) };
    fs.readFile(path.join(__dirname, '..', '/..', "/templates/page-template.mustache"), function (err, data) {
        if (err)
            helper.logError(err);
        else {
            var template = data.toString();
            Mustache.parse(template);
            var rendered = Mustache.render(template, view);
            fs.writeFile("elm/Page/" + ucfirst(name) + ".elm", rendered, function (err) {
                if (err) {
                    return helper.logError(err);
                }
            });
        }
    });
}
function oneAddition(search, text, data) {
    var index = data.findIndex(function (v) {
        return v.includes(search);
    });
    if (index === -1) {
        return data.join("\n");
    }
    if (text === undefined) {
        return data.join("\n");
    }
    data.splice(index + 1, 0, text);
    helper.logInfo({ added: search });
    return data.join("\n");
}
function writeToFile(addition, data, name) {
    helper.logInfo("Writing to " + name + ".elm");
    var text;
    addition.map(x => text = oneAddition(x.comment, x.text, data));
    text = data.join("\n");
    fs.writeFile(process.cwd() + "\\" + name, text, function (err) {
        if (err)
            return helper.logInfo(err);
    });
}
function maybeAddToMainAndRoute(additionsToMain, additionsToRoute) {
    fs.readFile(process.cwd() + "\\elm/Main.elm", function (err, dataOld) {
        helper.logInfo("Reading Main.elm");
        let dataMain;
        dataMain = dataOld.toString().split("\n");
        additionsToMain.map(x => checkIfCommentExsists(x, dataMain));
        if (dataMain.includes("import Page." + ucfirst(name) + " as " + ucfirst(name))) {
            helper.logInfo("Page " + ucfirst(name) + " was already added!");
            return;
        }
        fs.readFile(process.cwd() + "\\elm/Route.elm", function (err, dataOld) {
            helper.logInfo("Reading Route.elm");
            let dataRoute;
            dataRoute = dataOld.toString().split("\n");
            additionsToRoute.map(x => checkIfCommentExsists(x, dataRoute));
            if (validationErrors.size > 0) {
                showErrors(validationErrors);
                return;
            }
            if (fs.existsSync("elm/Page/" + name + ".elm")) {
                helper.logInfo("File elm/Page" + name + ".elm already exsists. Adding needed code to Main.elm and Route.elm...");
            }
            else {
                helper.logInfo("Rendering " + name + ".elm " + "file");
                renderMustache(name);
            }
            writeToFile(additionsToMain, dataMain, "elm/Main.elm");
            writeToFile(additionsToRoute, dataRoute, "elm/Route.elm");
            helper.execWithOutput(exec('elm-format elm/Main.elm --yes'));
            helper.logSuccess("Page has successfully been added!");
        });
    });
}
function showErrors(errors) {
    let filteredMessages = errorMessages.filter(x => errors.has(x.additionType));
    var obj = [];
    var data = {};
    for (var i = 0; i < filteredMessages.length; i++) {
        data = {
            error: filteredMessages[i].msg
        };
        obj.push(data);
    }
    obj.map(x => helper.logError(x));
}
class NewPage extends command_1.Command {
    async run() {
        const { args, flags } = this.parse(NewPage);
        name = flags.name;
        var additionsToMain = [
            {
                comment: "IMPORT PAGES",
                text: "import Page." + ucfirst(flags.name) + " as " + ucfirst(flags.name) + "\n",
                additionType: MainAdditions.ImportPages
            },
            {
                comment: "MODEL PAGES",
                text: "    | " + ucfirst(flags.name) + " " + ucfirst(flags.name) + ".Model",
                additionType: MainAdditions.ModelPages
            },
            {
                comment: "VIEW PAGES",
                text: '            ' + ucfirst(flags.name) + ' ' + 'arg ->' + '\n' +
                    '                viewPage Page.Other Got' + ucfirst(flags.name) + 'Msg' + ' (' + ucfirst(flags.name) + '.view arg)' + '\n',
                additionType: MainAdditions.ViewPages
            },
            {
                comment: "UPDATE PAGES",
                text: "        ( Got" + ucfirst(flags.name) + "Msg subMsg, " + ucfirst(flags.name) + " arg ) ->\n" +
                    "            " + ucfirst(flags.name) + ".update subMsg arg\n" +
                    "              |> updateWith " + ucfirst(flags.name) + " Got" + ucfirst(flags.name) + "Msg model\n",
                additionType: MainAdditions.UpdatePages
            },
            {
                comment: "MSG PAGES",
                text: "    | " + 'Got' + ucfirst(flags.name) + 'Msg' + ' ' + ucfirst(flags.name) + ".Msg",
                additionType: MainAdditions.MsgPages
            },
            {
                comment: "SUBSCRIPTIONS PAGES",
                text: "        " + ucfirst(flags.name) + " arg ->\n" +
                    "            " + "Sub.map " + "Got" + ucfirst(flags.name) + "Msg (" + ucfirst(flags.name) + ".subscriptions arg)\n",
                additionType: MainAdditions.SubscriptionPages
            },
            {
                comment: "ROUTE MAIN",
                text: '            Just Route.' + ucfirst(flags.name) + '->\n' +
                    '                ' + ucfirst(flags.name) + '.init session\n' +
                    '                    |> updateWith ' + ucfirst(flags.name) + ' Got' + ucfirst(flags.name) + 'Msg model\n',
                additionType: MainAdditions.RoutePages
            },
            {
                comment: "TO SESSION",
                text: '        ' + ucfirst(flags.name) + ' arg ->\n' +
                    '            ' + ucfirst(flags.name) + '.toSession arg\n',
                additionType: MainAdditions.ToSession
            }
        ];
        var additionsToRoute = [
            {
                comment: "ROUTE TO STRING",
                text: '                ' + ucfirst(flags.name) + ' ->\n' +
                    '                    [ "' + flags.name.toLowerCase() + ' " ]',
                additionType: RouteAdditions.RouteToString
            },
            {
                comment: "ROUTE PARSER",
                text: "        , " + "Parser.map " + ucfirst(flags.name) + ' (s "' + flags.name.toLowerCase() + '")',
                additionType: RouteAdditions.RouteParser
            },
            {
                comment: "ROUTE TYPE",
                text: "    | " + ucfirst(flags.name),
                additionType: RouteAdditions.RouteType
            }
        ];
        maybeAddToMainAndRoute(additionsToMain, additionsToRoute);
    }
}
NewPage.description = 'describe the command here';
NewPage.flags = {
    help: command_1.flags.help({ char: 'h' }),
    // flag with a value (-n, --name=VALUE)
    name: command_1.flags.string({ char: 'n', description: 'name to print' }),
};
NewPage.args = [{ name: 'file' }];
exports.default = NewPage;
// interactivno dal želimo dodat manualno ili rollbackat 
// dodavanje paketa
// rollback moguća opcija
// refaktor da data nisu globalne varijable nego parametri - 1
// refaktor writeToMain i writeToRoute funkcija - 1
// refaktorat da je validationErrors set a ne array -1
// error msg i prettyfier - 1
// izvuć console pretty u zaseban file +
// elm format logging bug +
// success message kod uspješnog dodavanja - console.info +