@zokugun/artifact 0.1.0

package/lib/steps/merge-text-files.js

@@ -0,0 +1,57 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    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) : adopt(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 });
+exports.mergeTextFiles = void 0;
+const path_1 = __importDefault(require("path"));
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const journeys_1 = require("../journeys");
+function mergeTextFiles({ targetPath, textFiles, mergedTextFiles, options }) {
+    return __awaiter(this, void 0, void 0, function* () {
+        for (const file of textFiles) {
+            if (file.data.length === 0) {
+                mergedTextFiles.push(file);
+                continue;
+            }
+            const journey = (0, journeys_1.getJourney)(file.name);
+            if (!journey) {
+                if (options.verbose) {
+                    console.log(`${file.name}, no merger found`);
+                }
+                mergedTextFiles.push(file);
+                continue;
+            }
+            const name = journey.alias ? path_1.default.join(path_1.default.dirname(file.name), journey.alias) : file.name;
+            let currentData;
+            try {
+                currentData = yield fs_extra_1.default.readFile(path_1.default.join(targetPath, name), 'utf-8');
+            }
+            catch (_a) {
+            }
+            const data = journey.travel({
+                current: currentData,
+                incoming: file.data,
+            });
+            mergedTextFiles.push({
+                name,
+                data,
+                finalNewLine: file.finalNewLine,
+                mode: file.mode,
+            });
+            if (options.verbose) {
+                console.log(`${file.name} has been merged`);
+            }
+        }
+    });
+}
+exports.mergeTextFiles = mergeTextFiles;

package/lib/steps/read-editor-config.js

@@ -0,0 +1,97 @@
+"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    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) : adopt(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 });
+exports.readEditorConfig = void 0;
+const path_1 = __importDefault(require("path"));
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const editorconfig = __importStar(require("editorconfig"));
+const format_1 = require("../types/format");
+function buildFullGlob(glob) {
+    switch (glob.indexOf('/')) {
+        case -1:
+            glob = '**/' + glob;
+            break;
+        case 0:
+            glob = glob.slice(1);
+            break;
+        default:
+            break;
+    }
+    return glob.replace(/\*\*/g, '{*,**/**/**}');
+} // }}}
+function readEditorConfig({ incomingPath, targetPath, formats }) {
+    return __awaiter(this, void 0, void 0, function* () {
+        let data;
+        try {
+            const dir = path_1.default.join(incomingPath, 'configs');
+            const file = path_1.default.join(dir, '.editorconfig');
+            data = yield fs_extra_1.default.readFile(file, 'utf-8');
+        }
+        catch (_a) {
+        }
+        if (!data) {
+            try {
+                const file = path_1.default.join(targetPath, '.editorconfig');
+                data = yield fs_extra_1.default.readFile(file, 'utf-8');
+            }
+            catch (_b) {
+            }
+        }
+        if (!data) {
+            return;
+        }
+        const rules = editorconfig.parseString(data);
+        for (const [glob, rule] of rules) {
+            if (!glob) {
+                continue;
+            }
+            const indentStyle = (rule.indent_style || 'space');
+            const indentSize = (rule.indent_size && Number.parseInt(rule.indent_size, 10)) || 2;
+            const insertFinalNewline = typeof rule.insert_final_newline === 'undefined' ? true : rule.insert_final_newline === 'true';
+            formats.push({
+                glob: buildFullGlob(glob),
+                indentStyle,
+                indentSize,
+                insertFinalNewline,
+            });
+        }
+        formats.push({
+            glob: buildFullGlob('{*.yml,*.yaml}'),
+            indentStyle: format_1.IndentStyle.SPACE,
+            indentSize: 2,
+            insertFinalNewline: true,
+        });
+        formats.reverse();
+    });
+}
+exports.readEditorConfig = readEditorConfig;

package/lib/steps/read-files.js

@@ -0,0 +1,66 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    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) : adopt(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 });
+exports.readFiles = void 0;
+const path_1 = __importDefault(require("path"));
+const istextorbinary_1 = require("istextorbinary");
+const globby_1 = __importDefault(require("globby"));
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const read_buffer_1 = require("../utils/read-buffer");
+function readFiles(context) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const cwd = path_1.default.join(context.incomingPath, 'configs');
+        const files = yield (0, globby_1.default)(['**/*', '!**/*.lock', '!**/*-lock.*'], {
+            cwd,
+            dot: true,
+        });
+        for (const file of files) {
+            const filePath = path_1.default.join(cwd, file);
+            if ((0, istextorbinary_1.isText)(file) || (0, istextorbinary_1.getEncoding)(yield (0, read_buffer_1.readBuffer)(filePath, 24)) === 'utf8') {
+                const data = yield fs_extra_1.default.readFile(filePath, 'utf-8');
+                const finalNewLine = data.endsWith('\n');
+                if (data.startsWith('#!')) {
+                    // the text file might be executable
+                    const { mode } = yield fs_extra_1.default.stat(filePath);
+                    context.textFiles.push({
+                        name: file,
+                        data,
+                        mode,
+                        finalNewLine,
+                    });
+                    if (context.options.verbose) {
+                        console.log(`${file} is a shebang file`);
+                    }
+                }
+                else {
+                    context.textFiles.push({
+                        name: file,
+                        data,
+                        finalNewLine,
+                    });
+                    if (context.options.verbose) {
+                        console.log(`${file} is a text file`);
+                    }
+                }
+            }
+            else {
+                context.binaryFiles.push(file);
+                if (context.options.verbose) {
+                    console.log(`${file} is a binary file`);
+                }
+            }
+        }
+    });
+}
+exports.readFiles = readFiles;

package/lib/steps/read-incoming-package.js

@@ -0,0 +1,24 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    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) : adopt(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 });
+exports.readIncomingPackage = void 0;
+const path_1 = __importDefault(require("path"));
+const fs_extra_1 = __importDefault(require("fs-extra"));
+function readIncomingPackage(context) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const filePath = path_1.default.resolve(context.incomingPath, './package.json');
+        context.incomingPackage = (yield fs_extra_1.default.readJSON(filePath));
+    });
+}
+exports.readIncomingPackage = readIncomingPackage;

package/lib/steps/read-target-config.js

@@ -0,0 +1,78 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    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) : adopt(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 });
+exports.readTargetConfig = void 0;
+const path_1 = __importDefault(require("path"));
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const yaml_1 = __importDefault(require("yaml"));
+const places = [
+    {
+        name: '.artifactrc.yml',
+        type: 'yaml',
+    },
+    {
+        name: '.artifactrc.yaml',
+        type: 'yaml',
+    },
+    {
+        name: '.artifactrc.json',
+        type: 'json',
+    },
+    {
+        name: '.artifactrc',
+    },
+];
+function readTargetConfig(context) {
+    return __awaiter(this, void 0, void 0, function* () {
+        let data;
+        let name;
+        let type;
+        for (const place of places) {
+            try {
+                data = yield fs_extra_1.default.readFile(path_1.default.join(context.targetPath, place.name), 'utf-8');
+                name = place.name;
+                type = place.type;
+                break;
+            }
+            catch (_a) {
+            }
+        }
+        if (!data) {
+            return;
+        }
+        const finalNewLine = data.endsWith('\n');
+        if (type === 'json') {
+            context.configs = JSON.parse(data);
+        }
+        else if (type === 'yaml') {
+            context.configs = yaml_1.default.parse(data);
+        }
+        else {
+            try {
+                context.configs = JSON.parse(data);
+                type = 'json';
+            }
+            catch (_b) {
+                context.configs = yaml_1.default.parse(data);
+                type = 'yaml';
+            }
+        }
+        context.configInfo = {
+            name: name,
+            type,
+            finalNewLine,
+        };
+    });
+}
+exports.readTargetConfig = readTargetConfig;

package/lib/steps/update-target-config.js

@@ -0,0 +1,50 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    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) : adopt(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 });
+exports.updateTargetConfig = void 0;
+const yaml_1 = __importDefault(require("yaml"));
+function updateTargetConfig({ configs, configInfo, incomingPackage, mergedTextFiles }) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const name = incomingPackage.name;
+        const version = incomingPackage.version;
+        let nf = true;
+        for (const config of configs) {
+            if (config.name === name) {
+                config.version = version;
+                nf = false;
+                break;
+            }
+        }
+        if (nf) {
+            configs.push({
+                name,
+                version,
+            });
+        }
+        if (!configInfo) {
+            configInfo = {
+                name: '.artifactrc.yml',
+                type: 'yaml',
+                finalNewLine: true,
+            };
+        }
+        const data = configInfo.type === 'yaml' ? yaml_1.default.stringify(configs) : JSON.stringify(configs, null, '\t');
+        mergedTextFiles.push({
+            name: configInfo.name,
+            data,
+            finalNewLine: configInfo.finalNewLine,
+        });
+    });
+}
+exports.updateTargetConfig = updateTargetConfig;

package/lib/steps/write-text-files.js

@@ -0,0 +1,32 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    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) : adopt(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 });
+exports.writeTextFiles = void 0;
+const path_1 = __importDefault(require("path"));
+const fs_extra_1 = __importDefault(require("fs-extra"));
+function writeTextFiles({ mergedTextFiles, targetPath, options }) {
+    return __awaiter(this, void 0, void 0, function* () {
+        for (const file of mergedTextFiles) {
+            const filePath = path_1.default.join(targetPath, file.name);
+            yield fs_extra_1.default.outputFile(filePath, file.data, 'utf-8');
+            if (file.mode) {
+                yield fs_extra_1.default.chmod(filePath, file.mode);
+            }
+            if (options.verbose) {
+                console.log(`${file.name} has been written as a text file`);
+            }
+        }
+    });
+}
+exports.writeTextFiles = writeTextFiles;

package/lib/types/config.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/types/context.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/types/format.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IndentStyle = void 0;
+var IndentStyle;
+(function (IndentStyle) {
+    IndentStyle["SPACE"] = "space";
+    IndentStyle["TAB"] = "tab";
+})(IndentStyle = exports.IndentStyle || (exports.IndentStyle = {}));

package/lib/types/step.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/types/text-file.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/types/travel.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/utils/build-journey-plan.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildJourneyPlan = void 0;
+function buildJourneyPlan(plan, alias) {
+    return (basename) => {
+        const travel = plan(basename);
+        if (travel) {
+            return {
+                travel,
+                alias,
+            };
+        }
+        else {
+            return undefined;
+        }
+    };
+}
+exports.buildJourneyPlan = buildJourneyPlan;

package/lib/utils/build-travel-plan.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildTravelPlan = void 0;
+function buildTravelPlan(...mappers) {
+    return (basename) => {
+        const mapper = mappers.find((mapper) => {
+            if (mapper[0] instanceof RegExp) {
+                return mapper[0].test(basename);
+            }
+            return mapper[0] === basename;
+        });
+        if (mapper) {
+            return mapper[1];
+        }
+        else {
+            return undefined;
+        }
+    };
+}
+exports.buildTravelPlan = buildTravelPlan;

package/lib/utils/command/command.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/utils/command/index.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.splitCommand = exports.joinCommand = void 0;
+var join_command_1 = require("./join-command");
+Object.defineProperty(exports, "joinCommand", { enumerable: true, get: function () { return join_command_1.joinCommand; } });
+var split_command_1 = require("./split-command");
+Object.defineProperty(exports, "splitCommand", { enumerable: true, get: function () { return split_command_1.splitCommand; } });

package/lib/utils/command/join-command.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.joinCommand = void 0;
+function joinCommand(commands) {
+    const subcommands = [];
+    for (const [key, values] of Object.entries(commands)) {
+        if (values.length === 0) {
+            subcommands.push(key);
+            continue;
+        }
+        for (const value of values) {
+            let subcommand = key;
+            if (value.env.length > 0) {
+                subcommand = `${value.env.join(' ')} ${subcommand}`;
+            }
+            if (value.args.length > 0) {
+                subcommand = `${subcommand} ${value.args.join(' ')}`;
+            }
+            if (value.separator) {
+                subcommand = `${subcommand} ${value.separator}`;
+            }
+            subcommands.push(subcommand);
+        }
+    }
+    return subcommands.join(' ');
+}
+exports.joinCommand = joinCommand;

package/lib/utils/command/split-command.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.splitCommand = void 0;
+const lodash_1 = require("lodash");
+function splitCommand(command) {
+    const result = {};
+    const splitted = command.split(/([&|]{1,2}|;)/).map(lodash_1.trim);
+    for (let i = 0; i < splitted.length; i++) {
+        const command = splitted[i];
+        const splittedSubcommand = command.split(/([\w-]+=\S+)\s/).filter(lodash_1.identity);
+        const subcommandWithArgs = (0, lodash_1.last)(splittedSubcommand).split(' ');
+        const subcommand = (0, lodash_1.head)(subcommandWithArgs).trim();
+        const args = subcommandWithArgs.slice(1);
+        const env = splittedSubcommand.slice(0, -1);
+        const parsedSubcommand = {
+            args: args.map(lodash_1.trim),
+            env: env.map(lodash_1.trim),
+            separator: splitted[i + 1],
+        };
+        if (result[subcommand]) {
+            result[subcommand].push(parsedSubcommand);
+        }
+        else {
+            result[subcommand] = [parsedSubcommand];
+        }
+        i++;
+    }
+    return result;
+}
+exports.splitCommand = splitCommand;

package/lib/utils/read-buffer.js

@@ -0,0 +1,38 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    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) : adopt(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 });
+exports.readBuffer = void 0;
+const promises_1 = __importDefault(require("fs/promises"));
+const buffer_1 = require("buffer");
+function readBuffer(filepath, size, offset = 0) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const buffer = buffer_1.Buffer.alloc(size);
+        const file = yield promises_1.default.open(filepath, 'r');
+        try {
+            const { bytesRead } = yield file.read(buffer, offset, size, 0);
+            if (bytesRead < size) {
+                const smaller = buffer_1.Buffer.alloc(bytesRead);
+                buffer.copy(smaller, 0, 0, bytesRead);
+                return smaller;
+            }
+            else {
+                return buffer;
+            }
+        }
+        finally {
+            yield file.close();
+        }
+    });
+}
+exports.readBuffer = readBuffer;

package/lib/utils/to-lines.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toLines = void 0;
+function toLines(value) {
+    return value.split(/\r?\n/g);
+}
+exports.toLines = toLines;

package/lib/utils/trim-final-newline.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.trimFinalNewLine = void 0;
+const FINAL_NEWLINE_REGEX = /(\r?\n)*$/;
+function trimFinalNewLine(value) {
+    return value.replace(FINAL_NEWLINE_REGEX, '');
+}
+exports.trimFinalNewLine = trimFinalNewLine;