diff --git a/dist/index.d.ts b/dist/index.d.ts new file mode 100644 index 0000000..b602d1a --- /dev/null +++ b/dist/index.d.ts @@ -0,0 +1 @@ +export * from './smartscaf.classes.smartscaf'; diff --git a/dist/index.js b/dist/index.js new file mode 100644 index 0000000..9772c3c --- /dev/null +++ b/dist/index.js @@ -0,0 +1,7 @@ +"use strict"; +function __export(m) { + for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p]; +} +Object.defineProperty(exports, "__esModule", { value: true }); +__export(require("./smartscaf.classes.smartscaf")); +//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi90cy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7OztBQUFBLG1EQUE4QyJ9 \ No newline at end of file diff --git a/dist/smartscaf.classes.smartscaf.d.ts b/dist/smartscaf.classes.smartscaf.d.ts new file mode 100644 index 0000000..cde9740 --- /dev/null +++ b/dist/smartscaf.classes.smartscaf.d.ts @@ -0,0 +1,74 @@ +import { Smartfile } from '@pushrocks/smartfile'; +export interface ScafTemplateContructorOptions { + name?: string; + description?: string; + sourceDir?: string; +} +export declare class ScafTemplate { + static createTemplateFromDir(): Promise; + /** + * the name of the template + */ + name: string; + /** + * the descriptions of the template + */ + description: string; + /** + * the location on disk of the template + */ + dirPath: string; + /** + * the files of the template as array of Smartfiles + */ + templateSmartfileArray: Smartfile[]; + requiredVariables: string[]; + defaultVariables: any; + suppliedVariables: any; + missingVariables: string[]; + constructor(dirPathArg: string); + /** + * read a template from a directory + */ + readTemplateFromDir(): Promise; + /** + * supply the variables to render the teplate with + * @param variablesArg gets merged with this.suppliedVariables + */ + supplyVariables(variablesArg: any): Promise; + /** + * Will ask for the missing variables by cli interaction + */ + askCliForMissingVariables(): Promise; + /** + * writes a file to disk + * @param destinationDirArg + */ + writeToDisk(destinationDirArg: any): Promise; + /** + * finds all variables in a Template in as string + * e.g. myobject.someKey and myobject.someOtherKey + */ + private _findVariablesInTemplate; + /** + * checks if supplied Variables satisfy the template + */ + private _checkSuppliedVariables; + /** + * checks the smartscaf.yml default values at the root of a template + * allows 2 ways of notation in YAML: + * >> myObject.myKey.someDeeperKey: someValue + * >> myObject.yourKey.yourDeeperKey: yourValue + * or + * >> myObject: + * >> - someKey: + * >> - someDeeperKey: someValue + * >> - yourKey: + * >> - yourDeeperKey: yourValue + */ + private _checkDefaultVariables; + /** + * resolve template dependencies + */ + private _resolveTemplateDependencies; +} diff --git a/dist/smartscaf.classes.smartscaf.js b/dist/smartscaf.classes.smartscaf.js new file mode 100644 index 0000000..929f920 --- /dev/null +++ b/dist/smartscaf.classes.smartscaf.js @@ -0,0 +1,180 @@ +"use strict"; +var __importStar = (this && this.__importStar) || function (mod) { + if (mod && mod.__esModule) return mod; + var result = {}; + if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k]; + result["default"] = mod; + return result; +}; +Object.defineProperty(exports, "__esModule", { value: true }); +const plugins = __importStar(require("./smartscaf.plugins")); +const helpers = __importStar(require("./smartscaf.helpers")); +class ScafTemplate { + constructor(dirPathArg) { + this.suppliedVariables = {}; + this.missingVariables = []; + this.dirPath = plugins.path.resolve(dirPathArg); + } + static async createTemplateFromDir() { } + /** + * read a template from a directory + */ + async readTemplateFromDir() { + this.templateSmartfileArray = await plugins.smartfile.fs.fileTreeToObject(this.dirPath, '**/*'); + await this._resolveTemplateDependencies(); + await this._findVariablesInTemplate(); + await this._checkSuppliedVariables(); + await this._checkDefaultVariables(); + } + /** + * supply the variables to render the teplate with + * @param variablesArg gets merged with this.suppliedVariables + */ + async supplyVariables(variablesArg) { + this.suppliedVariables = Object.assign(Object.assign({}, this.suppliedVariables), variablesArg); + this.missingVariables = await this._checkSuppliedVariables(); + } + /** + * Will ask for the missing variables by cli interaction + */ + async askCliForMissingVariables() { + this.missingVariables = await this._checkSuppliedVariables(); + let localSmartInteract = new plugins.smartinteract.SmartInteract(); + for (let missingVariable of this.missingVariables) { + localSmartInteract.addQuestions([ + { + name: missingVariable, + type: 'input', + default: (() => { + if (this.defaultVariables && this.defaultVariables[missingVariable]) { + return this.defaultVariables[missingVariable]; + } + else { + return 'undefined variable'; + } + })(), + message: `What is the value of ${missingVariable}?` + } + ]); + } + let answerBucket = await localSmartInteract.runQueue(); + await answerBucket.answerMap.forEach(async (answer) => { + await helpers.deepAddToObject(this.suppliedVariables, answer.name, answer.value); + }); + } + /** + * writes a file to disk + * @param destinationDirArg + */ + async writeToDisk(destinationDirArg) { + const smartfileArrayToWrite = []; + for (let smartfile of this.templateSmartfileArray) { + // lets filter out template files + if (smartfile.path === '.smartscaf.yml') { + continue; + } + // render the template + let template = await plugins.smarthbs.getTemplateForString(smartfile.contents.toString()); + let renderedTemplateString = template(this.suppliedVariables); + // handle frontmatter + const smartfmInstance = new plugins.smartfm.Smartfm({ + fmType: 'yaml' + }); + let parsedTemplate = smartfmInstance.parse(renderedTemplateString); + if (parsedTemplate.data.fileName) { + smartfile.updateFileName(parsedTemplate.data.fileName); + } + smartfile.contents = Buffer.from(parsedTemplate.content); + smartfileArrayToWrite.push(smartfile); + } + await plugins.smartfile.memory.smartfileArrayToFs(smartfileArrayToWrite, destinationDirArg); + } + /** + * finds all variables in a Template in as string + * e.g. myobject.someKey and myobject.someOtherKey + */ + async _findVariablesInTemplate() { + let templateVariables = []; + for (let templateSmartfile of this.templateSmartfileArray) { + let localTemplateVariables = await plugins.smarthbs.findVarsInHbsString(templateSmartfile.contents.toString()); + templateVariables = [...templateVariables, ...localTemplateVariables]; + } + templateVariables = templateVariables.filter((value, index, self) => { + return self.indexOf(value) === index; + }); + } + /** + * checks if supplied Variables satisfy the template + */ + async _checkSuppliedVariables() { + let missingVars = []; + for (let templateSmartfile of this.templateSmartfileArray) { + let localMissingVars = await plugins.smarthbs.checkVarsSatisfaction(templateSmartfile.contents.toString(), this.suppliedVariables); + // combine with other missingVars + missingVars = [...missingVars, ...localMissingVars]; + } + // dedupe + missingVars = missingVars.filter((value, index, self) => { + return self.indexOf(value) === index; + }); + return missingVars; + } + /** + * checks the smartscaf.yml default values at the root of a template + * allows 2 ways of notation in YAML: + * >> myObject.myKey.someDeeperKey: someValue + * >> myObject.yourKey.yourDeeperKey: yourValue + * or + * >> myObject: + * >> - someKey: + * >> - someDeeperKey: someValue + * >> - yourKey: + * >> - yourDeeperKey: yourValue + */ + async _checkDefaultVariables() { + let smartscafSmartfile = this.templateSmartfileArray.find(smartfileArg => { + return smartfileArg.parsedPath.base === '.smartscaf.yml'; + }); + if (smartscafSmartfile) { + const smartscafObject = await plugins.smartyaml.yamlStringToObject(smartscafSmartfile.contents.toString()); + const defaultObject = smartscafObject.defaults; + this.defaultVariables = defaultObject; + } + // safeguard against non existent defaults + if (!this.defaultVariables) { + console.log('this template does not specify defaults'); + this.defaultVariables = {}; + } + } + /** + * resolve template dependencies + */ + async _resolveTemplateDependencies() { + const smartscafSmartfile = this.templateSmartfileArray.find(smartfileArg => { + return smartfileArg.parsedPath.base === '.smartscaf.yml'; + }); + if (!smartscafSmartfile) { + console.log('No further template dependencies defined!'); + return; + } + console.log('Found template dependencies! Resolving them now!'); + console.log('looking at templates to merge!'); + const smartscafYamlObject = await plugins.smartyaml.yamlStringToObject(smartscafSmartfile.contentBuffer.toString()); + if (!smartscafYamlObject) { + console.log('Something seems strange about the supplied dependencies.yml file.'); + return; + } + for (const dependency of smartscafYamlObject.dependencies.merge) { + console.log(`Now resolving ${dependency}`); + const templatePathToMerge = plugins.path.join(this.dirPath, dependency); + if (!plugins.smartfile.fs.isDirectory(templatePathToMerge)) { + console.log(`dependency ${dependency} resolves to ${templatePathToMerge} which ist NOT a directory`); + continue; + } + const templateSmartfileArray = await plugins.smartfile.fs.fileTreeToObject(templatePathToMerge, '**/*'); + this.templateSmartfileArray = this.templateSmartfileArray.concat(templateSmartfileArray); + } + } +} +exports.ScafTemplate = ScafTemplate; +//# sourceMappingURL=data:application/json;base64,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 \ No newline at end of file diff --git a/dist/smartscaf.helpers.d.ts b/dist/smartscaf.helpers.d.ts new file mode 100644 index 0000000..13e6ede --- /dev/null +++ b/dist/smartscaf.helpers.d.ts @@ -0,0 +1,4 @@ +/** + * adds a variable in string dot notation to an already more or less expanded object + */ +export declare let deepAddToObject: (objectArg: any, varStringArg: string, valueArg: string) => Promise; diff --git a/dist/smartscaf.helpers.js b/dist/smartscaf.helpers.js new file mode 100644 index 0000000..a6a1a38 --- /dev/null +++ b/dist/smartscaf.helpers.js @@ -0,0 +1,35 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +/** + * adds a variable in string dot notation to an already more or less expanded object + */ +exports.deepAddToObject = async (objectArg, varStringArg, valueArg) => { + let varNamesArray = varStringArg.split('.'); + let referencePointer = objectArg; + for (let i = 0; i !== varNamesArray.length; i++) { + let varName = varNamesArray[i]; + // is there a next variable ? + let varNameNext = (() => { + if (varNamesArray[i + 1]) { + return varNamesArray[i + 1]; + } + return null; + })(); + // build the tree in suppliedVariables + if (!referencePointer[varName] && !varNameNext) { + referencePointer[varName] = valueArg; + referencePointer = null; + } + else if (!referencePointer[varName] && varNameNext) { + referencePointer[varName] = {}; + referencePointer = referencePointer[varName]; + } + else if (referencePointer[varName] && varNameNext) { + referencePointer = referencePointer[varName]; + } + else { + throw new Error('Something is strange!'); + } + } +}; +//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic21hcnRzY2FmLmhlbHBlcnMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi90cy9zbWFydHNjYWYuaGVscGVycy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOztBQUVBOztHQUVHO0FBQ1EsUUFBQSxlQUFlLEdBQUcsS0FBSyxFQUFFLFNBQVMsRUFBRSxZQUFvQixFQUFFLFFBQWdCLEVBQUUsRUFBRTtJQUN2RixJQUFJLGFBQWEsR0FBRyxZQUFZLENBQUMsS0FBSyxDQUFDLEdBQUcsQ0FBQyxDQUFDO0lBQzVDLElBQUksZ0JBQWdCLEdBQUcsU0FBUyxDQUFDO0lBQ2pDLEtBQUssSUFBSSxDQUFDLEdBQUcsQ0FBQyxFQUFFLENBQUMsS0FBSyxhQUFhLENBQUMsTUFBTSxFQUFFLENBQUMsRUFBRSxFQUFFO1FBQy9DLElBQUksT0FBTyxHQUFHLGFBQWEsQ0FBQyxDQUFDLENBQUMsQ0FBQztRQUUvQiw2QkFBNkI7UUFDN0IsSUFBSSxXQUFXLEdBQVcsQ0FBQyxHQUFHLEVBQUU7WUFDOUIsSUFBSSxhQUFhLENBQUMsQ0FBQyxHQUFHLENBQUMsQ0FBQyxFQUFFO2dCQUN4QixPQUFPLGFBQWEsQ0FBQyxDQUFDLEdBQUcsQ0FBQyxDQUFDLENBQUM7YUFDN0I7WUFDRCxPQUFPLElBQUksQ0FBQztRQUNkLENBQUMsQ0FBQyxFQUFFLENBQUM7UUFFTCxzQ0FBc0M7UUFDdEMsSUFBSSxDQUFDLGdCQUFnQixDQUFDLE9BQU8sQ0FBQyxJQUFJLENBQUMsV0FBVyxFQUFFO1lBQzlDLGdCQUFnQixDQUFDLE9BQU8sQ0FBQyxHQUFHLFFBQVEsQ0FBQztZQUNyQyxnQkFBZ0IsR0FBRyxJQUFJLENBQUM7U0FDekI7YUFBTSxJQUFJLENBQUMsZ0JBQWdCLENBQUMsT0FBTyxDQUFDLElBQUksV0FBVyxFQUFFO1lBQ3BELGdCQUFnQixDQUFDLE9BQU8sQ0FBQyxHQUFHLEVBQUUsQ0FBQztZQUMvQixnQkFBZ0IsR0FBRyxnQkFBZ0IsQ0FBQyxPQUFPLENBQUMsQ0FBQztTQUM5QzthQUFNLElBQUksZ0JBQWdCLENBQUMsT0FBTyxDQUFDLElBQUksV0FBVyxFQUFFO1lBQ25ELGdCQUFnQixHQUFHLGdCQUFnQixDQUFDLE9BQU8sQ0FBQyxDQUFDO1NBQzlDO2FBQU07WUFDTCxNQUFNLElBQUksS0FBSyxDQUFDLHVCQUF1QixDQUFDLENBQUM7U0FDMUM7S0FDRjtBQUNILENBQUMsQ0FBQyJ9 \ No newline at end of file diff --git a/dist/smartscaf.plugins.d.ts b/dist/smartscaf.plugins.d.ts new file mode 100644 index 0000000..94693ea --- /dev/null +++ b/dist/smartscaf.plugins.d.ts @@ -0,0 +1,9 @@ +import * as path from 'path'; +import * as lik from '@pushrocks/lik'; +import * as smartfile from '@pushrocks/smartfile'; +import * as smartfm from '@pushrocks/smartfm'; +import * as smarthbs from '@pushrocks/smarthbs'; +import * as smartinteract from '@pushrocks/smartinteract'; +import * as smartq from '@pushrocks/smartpromise'; +import * as smartyaml from '@pushrocks/smartyaml'; +export { path, lik, smartfile, smartfm, smarthbs, smartinteract, smartq, smartyaml }; diff --git a/dist/smartscaf.plugins.js b/dist/smartscaf.plugins.js new file mode 100644 index 0000000..21c85be --- /dev/null +++ b/dist/smartscaf.plugins.js @@ -0,0 +1,26 @@ +"use strict"; +var __importStar = (this && this.__importStar) || function (mod) { + if (mod && mod.__esModule) return mod; + var result = {}; + if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k]; + result["default"] = mod; + return result; +}; +Object.defineProperty(exports, "__esModule", { value: true }); +const path = __importStar(require("path")); +exports.path = path; +const lik = __importStar(require("@pushrocks/lik")); +exports.lik = lik; +const smartfile = __importStar(require("@pushrocks/smartfile")); +exports.smartfile = smartfile; +const smartfm = __importStar(require("@pushrocks/smartfm")); +exports.smartfm = smartfm; +const smarthbs = __importStar(require("@pushrocks/smarthbs")); +exports.smarthbs = smarthbs; +const smartinteract = __importStar(require("@pushrocks/smartinteract")); +exports.smartinteract = smartinteract; +const smartq = __importStar(require("@pushrocks/smartpromise")); +exports.smartq = smartq; +const smartyaml = __importStar(require("@pushrocks/smartyaml")); +exports.smartyaml = smartyaml; +//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic21hcnRzY2FmLnBsdWdpbnMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi90cy9zbWFydHNjYWYucGx1Z2lucy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7QUFBQSwyQ0FBNkI7QUFTcEIsb0JBQUk7QUFSYixvREFBc0M7QUFRdkIsa0JBQUc7QUFQbEIsZ0VBQWtEO0FBTzlCLDhCQUFTO0FBTjdCLDREQUE4QztBQU1mLDBCQUFPO0FBTHRDLDhEQUFnRDtBQUtSLDRCQUFRO0FBSmhELHdFQUEwRDtBQUlSLHNDQUFhO0FBSC9ELGdFQUFrRDtBQUdlLHdCQUFNO0FBRnZFLGdFQUFrRDtBQUV1Qiw4QkFBUyJ9 \ No newline at end of file