feat(create): pick an action when current directory is not empty

neikvon · neikvon · commit 144e4ffeea45 · 2020-09-28T17:46:02.000+08:00
diff --git a/package.json b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "fbi",
-  "description": "A workflow tool in command-line",
+  "description": "A workflow tool in the command line",
   "version": "4.0.4",
   "author": "shaw @neikvon",
   "main": "lib/index.js",
diff --git a/src/commands/create.ts b/src/commands/create.ts
@@ -1,3 +1,4 @@
+import { sep } from 'path'
 import { Fbi } from '../fbi'
 import { Factory } from '../core/Factory'
 import { Command } from '../core/command'
@@ -7,7 +8,7 @@ import { groupBy, flatten, isValidArray } from '../utils'
 export default class CommandCreate extends Command {
   id = 'create'
   alias = ''
-  args = '[template&#65372;factory] [project]'
+  args = '[template|factory]'
   description = `create a project via template or factory`
   flags = [
     ['-p, --package-manager <name>', 'Specifying a package manager. e.g. pnpm/yarn/npm', 'npm']
@@ -17,10 +18,9 @@ export default class CommandCreate extends Command {
     super()
   }
 
-  async run(inputTemplate: any, project: any, flags: any) {
+  async run(inputTemplate: any, flags: any) {
     this.debug(`Running command "${this.id}" from factory "${this.factory.id}" with options:`, {
       inputTemplate,
-      project,
       flags
     })
     const factories = this.factory.createAllFactories()
@@ -32,29 +32,44 @@ export default class CommandCreate extends Command {
     if (usingFactory?.id) {
       this.debug(`current project using factory "${usingFactory.id}"`)
       const factory = this.factory.resolveFactory(usingFactory.id)
-      // console.log({ factory })
       if (usingFactory.template) {
         const template = factory?.resolveTemplate(usingFactory.template)
-        // console.log({ template })
         subTemplates = template?.templates
       }
     }
-    // console.log({ subTemplates })
 
+    let subDirectory = false
     if (usingFactory) {
       this.log()
       this.log(
-        `current project is using template "${usingFactory.template}" from factory "${usingFactory.id}"`
+        `current project is using template ${this.style.cyan(
+          usingFactory.template
+        )} from ${this.style.cyan(usingFactory.id)}`
       )
       this.log(`you can only use sub-templates`)
       if (!isValidArray(subTemplates)) {
         this.warn(`but there are no sub-templates`).exit()
       }
       this.log()
     }
+    // check current dir is empty or not
+    else if (await this.fs.pathExists(process.cwd())) {
+      const { selectedAction } = (await this.prompt({
+        type: 'select',
+        name: 'selectedAction',
+        message: `Current directory is not empty. Pick an action:`,
+        hint: 'Use arrow-keys, <return> to submit',
+        choices: ['Overwrite', 'New subdirectory', 'Cancel']
+      })) as any
+      if (selectedAction === 'Cancel') {
+        this.exit()
+      }
+      if (selectedAction === 'New subdirectory') {
+        subDirectory = true
+      }
+    }
 
     // get all templates
-    // const factories = this.factory.createAllFactories()
     let templates = subTemplates || flatten(factories.map((f: Factory) => f.templates))
 
     let templateInstances
@@ -107,6 +122,8 @@ export default class CommandCreate extends Command {
       (t: Template) => t.id === selected.templateId && t.factory.id === selected.factoryId
     )
 
+    const projectName = process.cwd().split(sep).pop()
+
     if (selectedTemplate) {
       // set init data
       const factoryInfo = this.store.get(selected.factoryId)
@@ -119,8 +136,9 @@ export default class CommandCreate extends Command {
             template: selected.templateId
           },
           project: {
-            name: project
-          }
+            name: projectName
+          },
+          subDirectory
         },
         flags
       )
diff --git a/src/commands/list.ts b/src/commands/list.ts
@@ -99,13 +99,11 @@ export default class CommandList extends Command {
     const index = showIdx ? this.style.bold(symbols.numbers[idx as number]) : ' '
     const title = this.style.bold(obj.id)
     const version = isCurrent && current.version ? this.style.italic(`@${current.version}`) : ''
-    const path = this.style.dim(
-      obj.rootDir
-        ? obj.rootDir.startsWith(process.cwd())
-          ? obj.rootDir.replace(process.cwd() + '/', '')
-          : obj.rootDir
-        : ''
-    )
+    const rootDir =
+      obj.options &&
+      obj.options.rootDir &&
+      obj.options.rootDir.replace(this.context.get('env.home'), '~')
+    const path = this.style.dim(rootDir)
     let txt = `\n${index} ${title}${version} ${path}`
 
     if (obj.description) {
diff --git a/src/core/template.ts b/src/core/template.ts
@@ -30,14 +30,36 @@ export abstract class Template extends BaseClass {
   protected targetDir = process.cwd()
   protected _debugPrefix = ''
   private rootPath = ''
+  private subDirectory = false
 
   constructor() {
     super()
-    
+  }
+
+  // public methods
+  public resolveTemplate(templateId: string) {
+    const template = this.templates.find((x) => x.id === templateId)
+    if (!template) {
+      this.debug(
+        `Template (${this.id}${this.factory ? `:${this.factory.id}` : ''}):`,
+        `template "${templateId}" not found`
+      )
+    } else {
+      this.debug(
+        `Template (${this.id}${this.factory ? `:${this.factory.id}` : ''}):`,
+        `found template "${templateId}"`
+      )
+    }
+
+    return template
   }
 
   public async run(data: Record<string, any>, flags: any): Promise<any> {
-    this.prepare(data)
+    if (data?.subDirectory) {
+      this.subDirectory = data.subDirectory
+    }
+
+    await this.prepare(data)
 
     // 1. gathering: this.data
     this.debug(`${this._debugPrefix} run gathering`)
@@ -73,74 +95,55 @@ export abstract class Template extends BaseClass {
     }
   }
 
-  public resolveTemplate(templateId: string) {
-    const template = this.templates.find(x => x.id === templateId)
-    if (!template) {
-      this.debug(
-        `Template (${this.id}${this.factory ? `:${this.factory.id}` : ''}):`,
-        `template "${templateId}" not found`
-      )
-    } else {
-      this.debug(
-        `Template (${this.id}${this.factory ? `:${this.factory.id}` : ''}):`,
-        `found template "${templateId}"`
-      )
+  // processes
+  private async prepare(data?: any) {
+    this._debugPrefix = `Template "${this.id}"`
+
+    if (data && isValidObject(data)) {
+      this.data = data
     }
 
-    return template
-  }
+    if (!this.data.factory || !this.data?.factory?.path) {
+      this.error(`need path of factory`)
+      return this.exit()
+    }
 
+    this.rootPath = join(this.data.factory.path, this.path)
+  }
   protected async gathering(flags: any): Promise<any> {}
-  protected async checking(): Promise<any> {}
-  protected async writing(): Promise<any> {}
-  protected async installing(flags: any): Promise<any> {}
-  protected async ending(): Promise<any> {}
-
   private async afterGathering() {
-    const { project } = this.data
-    this.targetDir = join(process.cwd(), (project && project.name) || '')
-    this.debug(`${this._debugPrefix} rootPath: ${this.rootPath} targetDir: ${this.targetDir}`)
+    if (this.subDirectory) {
+      this.targetDir = join(this.targetDir, this.data?.project?.name || '')
+    }
+    this.debug(`${this._debugPrefix} rootPath: ${this.rootPath}; targetDir: ${this.targetDir}`)
   }
+  protected async checking(): Promise<any> {}
   private async afterChecking() {}
+  protected async writing(): Promise<any> {}
   private async afterWriting() {
     if (this.files.copy && isValidArray(this.files.copy)) {
       this.debug(`${this._debugPrefix} start copy`, this.files.copy)
       await this.copy(this.files.copy)
     }
 
     if (isFunction(this.renderer) && this.files.render && isValidArray(this.files.render)) {
-      this.debug(`${this._debugPrefix} start render`, this.files.render)
-      await this.render(this.files.render, this.data, this.renderOptions)
+      this.debug(`${this._debugPrefix} start render`, this.files.render, this.files?.renderOptions)
+      await this.render(this.files.render, this.data, this.files?.renderOptions)
     }
   }
+  protected async installing(flags: any): Promise<any> {}
   private async afterInstalling() {}
+  protected async ending(): Promise<any> {}
   private async afterEnding() {}
 
-  private prepare(data?: any) {
-    this._debugPrefix = `Template "${this.id}"`
-
-    if (data && isValidObject(data)) {
-      this.data = data
-    }
-
-    if (!this.data.factory || !this.data.factory.path) {
-      this.error(`need path of factory`)
-      return this.exit()
-    }
-
-    this.rootPath = join(this.data.factory.path, this.path)
-  }
-
+  // utils
   private async copy(fileMaps: StringOrFileMap[]) {
     const maps: FileMap[] = this.foramtFileMaps(fileMaps)
     for (const map of maps) {
       const paths = await this.globFile(map)
       const replace = map.to.split('/').filter(Boolean)
       for (const p of paths) {
-        const rest = p
-          .split('/')
-          .filter(Boolean)
-          .slice(replace.length)
+        const rest = p.split('/').filter(Boolean).slice(replace.length)
         const src = join(this.rootPath, p)
         if (!(await this.fs.pathExists(src))) {
           this.warn(`${src} not found`)
@@ -161,7 +164,7 @@ export abstract class Template extends BaseClass {
   private async render(
     fileMaps: StringOrFileMap[],
     data: Record<string | number, any>,
-    options: [] | {}
+    options?: [] | {}
   ) {
     if (!this.renderer || !isFunction(this.renderer)) {
       return
@@ -171,10 +174,7 @@ export abstract class Template extends BaseClass {
       const paths = await this.globFile(map)
       const replace = map.to.split('/').filter(Boolean)
       for (const p of paths) {
-        const rest = p
-          .split('/')
-          .filter(Boolean)
-          .slice(replace.length)
+        const rest = p.split('/').filter(Boolean).slice(replace.length)
         const src = join(this.rootPath, p)
         const stats = await this.fs.stat(src)
         if (stats.isFile()) {
diff --git a/src/index.ts b/src/index.ts
@@ -6,4 +6,4 @@ export * from './core/factory'
 export * from './core/command'
 export * from './core/template'
 export * from './core/version'
-export const utils = require('./utils/')
+export * as utils from './utils/'
diff --git a/src/utils/index.ts b/src/utils/index.ts
@@ -5,6 +5,7 @@ export * from './type'
 export * from './format'
 export * from './version'
 
+export const enquirer = require('enquirer')
 export const symbols: SymbolsType = require('enquirer/lib/symbols')
 
 export const timeMeasurement = (
@@ -32,12 +33,12 @@ export function applyMixins(
   baseCtors: any[],
   exclude: string[] = ['constructor']
 ) {
-  baseCtors.forEach(baseCtor => {
+  baseCtors.forEach((baseCtor) => {
     const instance = baseCtor.prototype || baseCtor
     const propertyNames = Object.getOwnPropertyNames(instance).filter(
       (name: string) => !exclude.includes(name)
     )
-    propertyNames.forEach(name => {
+    propertyNames.forEach((name) => {
       if (exclude.includes(name)) return
       const propDesc = Object.getOwnPropertyDescriptor(instance, name) as
         | PropertyDescriptor

Original file line number	Diff line number	Diff line change
`@@ -1,6 +1,6 @@`
`1`	`1`	`{`
`2`	`2`	`"name": "fbi",`
`3`		`- "description": "A workflow tool in command-line",`
	`3`	`+ "description": "A workflow tool in the command line",`
`4`	`4`	`"version": "4.0.4",`
`5`	`5`	`"author": "shaw @neikvon",`
`6`	`6`	`"main": "lib/index.js",`