bump version number

package.json

@@ -1,6 +1,6 @@
 {
   "name": "simple-scaffold",
-  "version": "1.0.0-alpha.17",
+  "version": "1.0.0-alpha.18",
   "description": "Create files based on templates",
   "repository": "https://github.com/chenasraf/simple-scaffold.git",
   "author": "Chen Asraf <inbox@casraf.com>",

src/scaffold.ts

@@ -41,7 +41,7 @@ export async function Scaffold({ ...options }: ScaffoldConfig) {
     log(options, LogLevel.Info, "Data:", options.data)
     for (let template of options.templates) {
       try {
-        const _isGlob = template.includes("*")
+        const _isGlob = glob.hasMagic(template)
         if (!_isGlob && !(await pathExists(template))) {
           const err: NodeJS.ErrnoException = new Error(`ENOENT, no such file or directory ${template}`)
           err.code = "ENOENT"
@@ -61,37 +61,34 @@ export async function Scaffold({ ...options }: ScaffoldConfig) {
         log(options, LogLevel.Debug, "before glob")
         const files = await promisify(glob)(template, {
           dot: true,
-          debug: false,
-          nodir: options.verbose === LogLevel.Debug,
-          nobrace: true,
-          noext: true,
-          nocomment: true,
-          nonegate: true,
+          debug: options.verbose === LogLevel.Debug,
+          nodir: true,
         })
         log(options, LogLevel.Debug, "after glob")
         for (const inputFilePath of files) {
-          if (!(await isDir(inputFilePath))) {
-            const relPath = makeRelativePath(path.dirname(removeGlob(inputFilePath).replace(_nonGlobTemplate, "")))
-            const basePath = path
-              .resolve(process.cwd(), relPath)
-              .replace(process.cwd() + "/", "")
-              .replace(process.cwd(), "")
-            log(
-              options,
-              LogLevel.Debug,
-              `\nprocess.cwd(): ${process.cwd()}`,
-              `\norigTemplate: ${origTemplate}`,
-              `\nrelPath: ${relPath}`,
-              `\ntemplate: ${template}`,
-              `\ninputFilePath: ${inputFilePath}`,
-              `\nnonGlobTemplate: ${_nonGlobTemplate}`,
-              `\nbasePath: ${basePath}`,
-              `\nisDir: ${_isDir}`,
-              `\nisGlob: ${_isGlob}`,
-              `\n`
-            )
-            await handleTemplateFile(inputFilePath, basePath, options, options.data)
+          if (await isDir(inputFilePath)) {
+            continue
           }
+          const relPath = makeRelativePath(path.dirname(removeGlob(inputFilePath).replace(_nonGlobTemplate, "")))
+          const basePath = path
+            .resolve(process.cwd(), relPath)
+            .replace(process.cwd() + "/", "")
+            .replace(process.cwd(), "")
+          log(
+            options,
+            LogLevel.Debug,
+            `\nprocess.cwd(): ${process.cwd()}`,
+            `\norigTemplate: ${origTemplate}`,
+            `\nrelPath: ${relPath}`,
+            `\ntemplate: ${template}`,
+            `\ninputFilePath: ${inputFilePath}`,
+            `\nnonGlobTemplate: ${_nonGlobTemplate}`,
+            `\nbasePath: ${basePath}`,
+            `\nisDir: ${_isDir}`,
+            `\nisGlob: ${_isGlob}`,
+            `\n`
+          )
+          await handleTemplateFile(inputFilePath, basePath, options, options.data)
         }
       } catch (e: any) {
         handleErr(e)
@@ -112,12 +109,12 @@ async function handleTemplateFile(
   return new Promise(async (resolve, reject) => {
     try {
       const inputPath = path.resolve(process.cwd(), templatePath)
-      const outputPathOpt = getOptionValueForFile(inputPath, data, options.output)
+      const outputPathOpt = getOptionValueForFile(options, inputPath, data, options.output)
       const outputDir = path.resolve(
         process.cwd(),
         ...([outputPathOpt, basePath, options.createSubFolder ? options.name : undefined].filter(Boolean) as string[])
       )
-      const outputPath = handlebarsParse(path.join(outputDir, path.basename(inputPath)), data)
+      const outputPath = handlebarsParse(options, path.join(outputDir, path.basename(inputPath)), data).toString()
       log(
         options,
         LogLevel.Debug,
@@ -129,7 +126,7 @@ async function handleTemplateFile(
         `\nFull output path: ${outputPath}`,
         `\n`
       )
-      const overwrite = getOptionValueForFile(inputPath, data, options.overwrite ?? false)
+      const overwrite = getOptionValueForFile(options, inputPath, data, options.overwrite ?? false)
       const exists = await pathExists(outputPath)
 
       await createDirIfNotExists(path.dirname(outputPath), options)
@@ -140,7 +137,7 @@ async function handleTemplateFile(
           log(options, LogLevel.Info, `File ${outputPath} exists, overwriting`)
         }
         const templateBuffer = await readFile(inputPath)
-        const outputContents = handlebarsParse(templateBuffer, data)
+        const outputContents = handlebarsParse(options, templateBuffer, data)
 
         if (!options.dryRun) {
           await writeFile(outputPath, outputContents)

src/utils.ts

@@ -80,6 +80,7 @@ export async function createDirIfNotExists(dir: string, options: ScaffoldConfig)
 }
 
 export function getOptionValueForFile<T>(
+  options: ScaffoldConfig,
   filePath: string,
   data: Record<string, string>,
   fn: FileResponse<T>,
@@ -90,15 +91,24 @@ export function getOptionValueForFile<T>(
   }
   return (fn as FileResponseFn<T>)(
     filePath,
-    path.dirname(handlebarsParse(filePath, data)),
-    path.basename(handlebarsParse(filePath, data))
+    path.dirname(handlebarsParse(options, filePath, data).toString()),
+    path.basename(handlebarsParse(options, filePath, data).toString())
   )
 }
 
-export function handlebarsParse(templateBuffer: Buffer | string, data: Record<string, string>) {
-  const parser = Handlebars.compile(templateBuffer.toString(), { noEscape: true })
-  const outputContents = parser(data)
-  return outputContents
+export function handlebarsParse(
+  options: ScaffoldConfig,
+  templateBuffer: Buffer | string,
+  data: Record<string, string>
+) {
+  try {
+    const parser = Handlebars.compile(templateBuffer.toString(), { noEscape: true })
+    const outputContents = parser(data)
+    return outputContents
+  } catch {
+    log(options, LogLevel.Warning, "Couldn't parse file with handlebars, returning original content")
+    return templateBuffer
+  }
 }
 
 export async function pathExists(filePath: string): Promise<boolean> {