@zokugun/artifact 0.3.1 → 0.4.0

package/lib/steps/execute-first-block.js

@@ -0,0 +1,113 @@
+"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.executeFirstBlock = void 0;
+const node_path_1 = __importDefault(require("node:path"));
+const lodash_1 = require("lodash");
+const configs_1 = require("../configs");
+function executeFirstBlock(context) {
+    var _a, _b, _c, _d;
+    return __awaiter(this, void 0, void 0, function* () {
+        const { name, version } = context.incomingPackage;
+        const root = String((_b = (_a = context.incomingConfig.variants) === null || _a === void 0 ? void 0 : _a.root) !== null && _b !== void 0 ? _b : '');
+        if (context.incomingVariant) {
+            let variant;
+            let alias;
+            if ((0, lodash_1.isNil)(context.incomingConfig.variants[context.incomingVariant])) {
+                variant = context.incomingVariant;
+                alias = false;
+            }
+            else {
+                variant = String(context.incomingConfig.variants[context.incomingVariant]);
+                alias = true;
+            }
+            const variantPath = node_path_1.default.join(context.packagePath, 'variants', variant);
+            const variantConfig = yield (0, configs_1.readPackageConfig)(variantPath);
+            if (variantConfig.orphan) {
+                pushToResult(name, version, variant, alias, context);
+                context.incomingConfig = variantConfig;
+                yield context.commonFlow(name, version, variant, undefined, variantPath, context);
+            }
+            else if (variantConfig.extends) {
+                context.blocks.unshift({
+                    name,
+                    version,
+                    variant,
+                    incomingPath: node_path_1.default.join(context.packagePath, 'variants', variant),
+                });
+                pushToResult(name, version, variant, alias, context);
+                const extend = String((_c = context.incomingConfig.variants[variantConfig.extends]) !== null && _c !== void 0 ? _c : variantConfig.extends);
+                context.incomingVariant = extend;
+                return executeFirstBlock(context);
+            }
+            else {
+                if (root.length === 0) {
+                    throw new Error('No root variant has been defined');
+                }
+                if (root === variant) {
+                    pushToResult(name, version, variant, alias, context);
+                    context.incomingConfig = variantConfig;
+                    yield context.commonFlow(name, version, variant, undefined, variantPath, context);
+                }
+                else {
+                    const variant = String((_d = context.incomingConfig.variants[context.request.variant]) !== null && _d !== void 0 ? _d : context.request.variant);
+                    context.blocks.unshift({
+                        name,
+                        version,
+                        variant,
+                        incomingPath: node_path_1.default.join(context.packagePath, 'variants', variant),
+                    });
+                    pushToResult(name, version, variant, alias, context);
+                    const incomingPath = node_path_1.default.join(context.packagePath, 'variants', root);
+                    context.incomingConfig = undefined;
+                    yield context.commonFlow(name, version, root, undefined, incomingPath, context);
+                }
+            }
+        }
+        else if (root.length > 0) {
+            context.result = {
+                name,
+                version,
+                provides: [root],
+            };
+            const incomingPath = node_path_1.default.join(context.packagePath, 'variants', root);
+            context.incomingConfig = undefined;
+            yield context.commonFlow(name, version, root, undefined, incomingPath, context);
+        }
+        else {
+            context.result = { name, version };
+            yield context.commonFlow(name, version, undefined, undefined, context.incomingPath, context);
+        }
+    });
+}
+exports.executeFirstBlock = executeFirstBlock;
+function pushToResult(name, version, variant, alias, context) {
+    var _a, _b;
+    var _c;
+    (_a = context.result) !== null && _a !== void 0 ? _a : (context.result = {
+        name,
+        version,
+        requires: [context.request.variant],
+    });
+    const provider = context.incomingVariant !== context.request.variant;
+    if (provider || alias) {
+        (_b = (_c = context.result).provides) !== null && _b !== void 0 ? _b : (_c.provides = []);
+        if (provider) {
+            context.result.provides.unshift(context.incomingVariant);
+        }
+        if (alias) {
+            context.result.provides.unshift(variant);
+        }
+    }
+}

package/lib/steps/execute-next-block.js

@@ -0,0 +1,23 @@
+"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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.executeNextBlock = void 0;
+const lodash_1 = require("lodash");
+function executeNextBlock(context) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const block = context.blocks.shift();
+        if (!(0, lodash_1.isNil)(block)) {
+            const { name, version, variant, branch, incomingPath } = block;
+            yield context.commonFlow(name, version, variant, branch, incomingPath, context);
+        }
+    });
+}
+exports.executeNextBlock = executeNextBlock;

package/lib/steps/index.js

@@ -11,51 +11,67 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.composeSteps = exports.steps = void 0;
 const apply_formatting_1 = require("./apply-formatting");
+const configure_branches_1 = require("./configure-branches");
+const configure_install_file_actions_1 = require("./configure-install-file-actions");
+const configure_update_file_actions_1 = require("./configure-update-file-actions");
 const copy_binary_files_1 = require("./copy-binary-files");
+const execute_first_block_1 = require("./execute-first-block");
+const execute_next_block_1 = require("./execute-next-block");
 const insert_final_new_line_1 = require("./insert-final-new-line");
 const merge_text_files_1 = require("./merge-text-files");
 const read_editor_config_1 = require("./read-editor-config");
 const read_files_1 = require("./read-files");
 const read_incoming_config_1 = require("./read-incoming-config");
 const read_incoming_package_1 = require("./read-incoming-package");
+const remove_files_1 = require("./remove-files");
 const replace_templates_1 = require("./replace-templates");
 const validate_newer_package_1 = require("./validate-newer-package");
 const validate_not_present_package_1 = require("./validate-not-present-package");
-const validate_updatability_1 = require("./validate-updatability");
 const write_text_files_1 = require("./write-text-files");
 exports.steps = {
     applyFormatting: apply_formatting_1.applyFormatting,
+    configureBranches: configure_branches_1.configureBranches,
+    configureInstallFileActions: configure_install_file_actions_1.configureInstallFileActions,
+    configureUpdateFileActions: configure_update_file_actions_1.configureUpdateFileActions,
     copyBinaryFiles: copy_binary_files_1.copyBinaryFiles,
+    executeFirstBlock: execute_first_block_1.executeFirstBlock,
+    executeNextBlock: execute_next_block_1.executeNextBlock,
     insertFinalNewLine: insert_final_new_line_1.insertFinalNewLine,
     mergeTextFiles: merge_text_files_1.mergeTextFiles,
     readEditorConfig: read_editor_config_1.readEditorConfig,
     readFiles: read_files_1.readFiles,
     readIncomingConfig: read_incoming_config_1.readIncomingConfig,
     readIncomingPackage: read_incoming_package_1.readIncomingPackage,
+    removeFiles: remove_files_1.removeFiles,
     replaceTemplates: replace_templates_1.replaceTemplates,
     validateNewerPackage: validate_newer_package_1.validateNewerPackage,
     validateNotPresentPackage: validate_not_present_package_1.validateNotPresentPackage,
-    validateUpdatability: validate_updatability_1.validateUpdatability,
     writeTextFiles: write_text_files_1.writeTextFiles,
 };
-function composeSteps(...steps) {
-    return (targetPath, incomingPath, config, options) => __awaiter(this, void 0, void 0, function* () {
+function composeSteps(validations, processes) {
+    const mainFlow = (targetPath, incomingPath, request, config, options) => __awaiter(this, void 0, void 0, function* () {
         const context = {
+            packagePath: incomingPath,
+            request,
             targetPath,
             incomingPath,
-            onMissing: () => false,
-            onUpdate: () => false,
+            incomingVariant: request.variant,
+            onExisting: () => 'merge',
+            onMissing: () => 'continue',
             filters: () => undefined,
             routes: () => undefined,
             binaryFiles: [],
             textFiles: [],
             mergedTextFiles: [],
+            removedPatterns: [],
             formats: [],
             config,
             options,
+            commonFlow,
+            blocks: [],
         };
         let skipped = false;
-        for (const step of steps) {
+        for (const step of validations) {
             if (yield step(context)) {
                 skipped = true;
                 break;
@@ -63,5 +79,27 @@ function composeSteps(...steps) {
         }
         return skipped ? undefined : context;
     });
+    const commonFlow = (name, version, variant, branch, incomingPath, mainContext) => __awaiter(this, void 0, void 0, function* () {
+        if (mainContext.options.verbose) {
+            let message = `--> ${name}@${version}`;
+            if (variant) {
+                message += `:${variant}`;
+            }
+            if (branch) {
+                message += `(${branch})`;
+            }
+            console.log(message);
+        }
+        const context = Object.assign(Object.assign({}, mainContext), { incomingPath, incomingName: name, incomingVersion: version, incomingVariant: variant, incomingBranch: branch, incomingConfig: undefined, onExisting: () => 'merge', onMissing: () => 'continue', filters: () => undefined, routes: () => undefined, binaryFiles: [], textFiles: [], mergedTextFiles: [], formats: [] });
+        let skipped = false;
+        for (const step of processes) {
+            if (yield step(context)) {
+                skipped = true;
+                break;
+            }
+        }
+        return skipped ? undefined : context;
+    });
+    return { mainFlow, commonFlow };
 }
 exports.composeSteps = composeSteps;

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

@@ -16,7 +16,7 @@ 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, onMissing, onUpdate, filters, routes, options }) {
+function mergeTextFiles({ targetPath, textFiles, mergedTextFiles, onExisting, onMissing, filters, routes, options }) {
     var _a;
     return __awaiter(this, void 0, void 0, function* () {
         for (const file of textFiles) {
@@ -28,50 +28,80 @@ function mergeTextFiles({ targetPath, textFiles, mergedTextFiles, onMissing, onU
                 if (options.verbose) {
                     console.log(`${file.name}, no merger has been found`);
                 }
-                try {
-                    yield fs_extra_1.default.access(path_1.default.join(targetPath, file.name));
-                    if (onUpdate(file.name)) {
-                        continue;
+                const filePath = path_1.default.join(targetPath, file.name);
+                const exists = yield fs_extra_1.default.pathExists(filePath);
+                if (exists) {
+                    switch (onExisting(file.name)) {
+                        case 'merge':
+                            break;
+                        case 'overwrite':
+                            break;
+                        case 'skip':
+                            continue;
                     }
                 }
-                catch (_b) {
-                    if (onMissing(file.name)) {
-                        continue;
+                else {
+                    switch (onMissing(file.name)) {
+                        case 'continue':
+                            break;
+                        case 'skip':
+                            continue;
                     }
                 }
                 mergedTextFiles.push(file);
+                if (options.verbose) {
+                    console.log(`${file.name} has been copied`);
+                }
                 continue;
             }
             if (options.verbose) {
                 console.log(`${file.name}, a merger has been found`);
             }
-            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');
-                if (onUpdate(name)) {
-                    continue;
+            const fileName = journey.alias ? path_1.default.join(path_1.default.dirname(file.name), journey.alias) : file.name;
+            const filePath = path_1.default.join(targetPath, fileName);
+            const exists = yield fs_extra_1.default.pathExists(filePath);
+            if (exists) {
+                switch (onExisting(file.name)) {
+                    case 'merge': {
+                        const currentData = yield fs_extra_1.default.readFile(filePath, 'utf-8');
+                        const data = journey.travel({
+                            current: currentData,
+                            incoming: file.data,
+                            filters: filters(file.name),
+                        });
+                        mergedTextFiles.push({
+                            name: fileName,
+                            data,
+                            finalNewLine: file.finalNewLine,
+                            mode: file.mode,
+                        });
+                        if (options.verbose) {
+                            console.log(`${file.name} has been merged`);
+                        }
+                        break;
+                    }
+                    case 'overwrite':
+                        mergedTextFiles.push(file);
+                        if (options.verbose) {
+                            console.log(`${file.name} has been overwritten`);
+                        }
+                        continue;
+                    case 'skip':
+                        continue;
                 }
             }
-            catch (_c) {
-                if (onMissing(name)) {
-                    continue;
+            else {
+                switch (onMissing(file.name)) {
+                    case 'continue':
+                        mergedTextFiles.push(Object.assign(Object.assign({}, file), { name: fileName }));
+                        if (options.verbose) {
+                            console.log(`${file.name} has been copied`);
+                        }
+                        continue;
+                    case 'skip':
+                        continue;
                 }
             }
-            const data = journey.travel({
-                current: currentData,
-                incoming: file.data,
-                filters: filters(file.name),
-            });
-            mergedTextFiles.push({
-                name,
-                data,
-                finalNewLine: file.finalNewLine,
-                mode: file.mode,
-            });
-            if (options.verbose) {
-                console.log(`${file.name} has been merged`);
-            }
         }
     });
 }

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

@@ -10,11 +10,16 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.readIncomingConfig = void 0;
-const config_1 = require("../config");
+const configs_1 = require("../configs");
 function readIncomingConfig(context) {
     return __awaiter(this, void 0, void 0, function* () {
-        const [config] = yield (0, config_1.readConfig)(context.incomingPath);
-        context.incomingConfig = config;
+        if (!context.incomingConfig) {
+            const config = yield (0, configs_1.readPackageConfig)(context.incomingPath);
+            if (!config) {
+                return true;
+            }
+            context.incomingConfig = config;
+        }
     });
 }
 exports.readIncomingConfig = readIncomingConfig;

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

@@ -15,13 +15,22 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.readIncomingPackage = void 0;
 const path_1 = __importDefault(require("path"));
 const fs_extra_1 = __importDefault(require("fs-extra"));
+const lodash_1 = require("lodash");
 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));
-        if (!context.incomingPackage) {
+        const incomingPackage = yield fs_extra_1.default.readJSON(filePath);
+        if (!isPackageManifest(incomingPackage)) {
             throw new Error('The package of the incoming artifact can\'t be found.');
         }
+        context.incomingPackage = incomingPackage;
     });
 }
 exports.readIncomingPackage = readIncomingPackage;
+function isPackageManifest(value) {
+    if ((0, lodash_1.isNil)(value) || !(0, lodash_1.isPlainObject)(value)) {
+        return false;
+    }
+    const manifest = value;
+    return typeof manifest.name === 'string' && typeof manifest.version === 'string';
+}

package/lib/steps/remove-files.js

@@ -0,0 +1,41 @@
+"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.removeFiles = void 0;
+const path_1 = __importDefault(require("path"));
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const globby_1 = __importDefault(require("globby"));
+const micromatch_1 = require("micromatch");
+function removeFiles({ removedPatterns, targetPath, options }) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (removedPatterns.length === 0) {
+            return;
+        }
+        const cwd = path_1.default.join(targetPath);
+        const files = yield (0, globby_1.default)(['**/*', '!**/*.lock', '!**/*-lock.*', '!.git'], {
+            cwd,
+            dot: true,
+        });
+        for (const file of files) {
+            if ((0, micromatch_1.isMatch)(file, removedPatterns)) {
+                const filePath = path_1.default.join(cwd, file);
+                yield fs_extra_1.default.unlink(filePath);
+                if (options.verbose) {
+                    console.log(`${file} has been removed`);
+                }
+            }
+        }
+    });
+}
+exports.removeFiles = removeFiles;

package/lib/steps/validate-newer-package.js

@@ -16,7 +16,7 @@ function validateNewerPackage({ incomingPackage, config, options }) {
         if (options.force) {
             return;
         }
-        const artifact = config.artifacts.find(({ name }) => name === incomingPackage.name);
+        const artifact = config.artifacts[incomingPackage.name];
         if (artifact) {
             return !(0, semver_1.gt)(incomingPackage.version, artifact.version);
         }

package/lib/steps/validate-not-present-package.js

@@ -16,7 +16,7 @@ function validateNotPresentPackage({ incomingPackage, config, options }) {
             return;
         }
         const { name } = incomingPackage;
-        const artifact = config.artifacts.find((artifact) => artifact.name === name);
+        const artifact = config.artifacts[name];
         if (artifact) {
             if (options.skip) {
                 if (options.verbose) {

package/lib/utils/resolve-request.js

@@ -0,0 +1,43 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveRequest = void 0;
+const untildify_1 = __importDefault(require("untildify"));
+function resolveRequest(spec) {
+    if (spec.startsWith('~')) {
+        spec = (0, untildify_1.default)(spec);
+    }
+    else if (spec.startsWith('/')) {
+        // skip
+    }
+    else if (spec.includes('/')) {
+        const [scope, name] = spec.split('/');
+        if (name.startsWith('artifact-')) {
+            // skip
+        }
+        else {
+            spec = `${scope}/artifact-${name}`;
+        }
+    }
+    else {
+        if (spec.startsWith('artifact-')) {
+            // skip
+        }
+        else {
+            spec = `artifact-${spec}`;
+        }
+    }
+    if (spec.includes(':')) {
+        const [name, variant] = spec.split(':');
+        if (variant.length === 0) {
+            throw new Error(`Missing variant in "${spec}"`);
+        }
+        return { name, variant };
+    }
+    else {
+        return { name: spec };
+    }
+} // }}}
+exports.resolveRequest = resolveRequest;

package/lib/utils/template.js

@@ -31,6 +31,7 @@ const path_1 = __importDefault(require("path"));
 const dayjs_1 = __importDefault(require("dayjs"));
 const utc_1 = __importDefault(require("dayjs/plugin/utc"));
 const fs_extra_1 = __importDefault(require("fs-extra"));
+const lodash_1 = require("lodash");
 const YAML = __importStar(require("../parsers/yaml"));
 const try_json_1 = require("./try-json");
 dayjs_1.default.extend(utc_1.default);
@@ -58,7 +59,7 @@ class TemplateEngine {
             }
             const fileContent = this.readConfigFile(name);
             const value = this.getValueByPath(fileContent, propertyPath);
-            if (value === null || value === undefined) {
+            if ((0, lodash_1.isNil)(value)) {
                 throw new TemplateError(placeholder);
             }
             return String(value);
@@ -68,12 +69,12 @@ class TemplateEngine {
         const parts = propertyPath.split('.');
         let current = values;
         for (const part of parts) {
-            if (current === null || current === undefined || typeof current !== 'object') {
+            if (!(0, lodash_1.isPlainObject)(current)) {
                 throw new TemplateError(`Property path not found: ${propertyPath}`);
             }
             current = current[part];
         }
-        if (current === null || current === undefined) {
+        if ((0, lodash_1.isNil)(current)) {
             throw new TemplateError(`Property not found: ${propertyPath}`);
         }
         return current;

package/package.json

@@ -1,7 +1,7 @@
 {
 	"name": "@zokugun/artifact",
 	"description": "Boilerplate your project & keep your configurations up to date",
-	"version": "0.3.1",
+	"version": "0.4.0",
 	"author": {
 		"name": "Baptiste Augrain",
 		"email": "daiyam@zokugun.org"
@@ -28,12 +28,12 @@
 		"release": "release-it",
 		"test": "tsc -p test && mocha",
 		"test:dev": "mocha",
-		"test:watch": "tsc-watch -p test --onSuccess 'mocha'",
-		"watch": "tsc-watch -p src",
+		"test:watch": "tsc-watch -p src -p test --onSuccess 'mocha'",
 		"watch:src": "tsc-watch -p src",
 		"watch:test": "tsc-watch -p test"
 	},
 	"dependencies": {
+		"@zokugun/configdotts-merge": "^0.1.0",
 		"ansi-colors": "^4.1.1",
 		"commander": "^9.0.0",
 		"dayjs": "^1.11.13",
@@ -50,6 +50,7 @@
 		"pacote": "^13.0.5",
 		"semver": "^7.3.5",
 		"tempy": "^1.0.1",
+		"untildify": "^4.0.0",
 		"yaml": "^1.10.2"
 	},
 	"devDependencies": {

package/lib/config/index.js

@@ -1,7 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.writeConfig = exports.readConfig = void 0;
-var read_config_1 = require("./read-config");
-Object.defineProperty(exports, "readConfig", { enumerable: true, get: function () { return read_config_1.readConfig; } });
-var write_config_1 = require("./write-config");
-Object.defineProperty(exports, "writeConfig", { enumerable: true, get: function () { return write_config_1.writeConfig; } });