update repair logic

Author: erha19

.gitignore

@@ -1,5 +1,3 @@
-.vscode/
-
 node_modules/
 
 # coverage

.vscode/launch.json

@@ -0,0 +1,20 @@
+{
+  // Use IntelliSense to learn about possible attributes.
+  // Hover to view descriptions of existing attributes.
+  // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
+  "version": "0.2.0",
+  "configurations": [
+    {
+      "type": "node",
+      "request": "launch",
+      "name": "Launch Program",
+      "program": "${workspaceFolder}/bin/weex.js",
+      "args": [
+        "debug"
+      ],
+      "env": {
+        "WEEX_CORE_PATH": "/Users/kw/github/weex-toolkit/packages/@weex/core"
+      }
+    }
+  ]
+}

.vscode/settings.json

@@ -0,0 +1,3 @@
+{
+  "typescript.tsdk": "node_modules/typescript/lib"
+}

lib/cli.js

@@ -105,7 +105,6 @@ const cli = async (processArgv) => {
         (new Cli(coreData)).start()
       }
       catch(error) {
-        console.log(error, 555)
         // await prepare(repair)
       }
     }
@@ -127,18 +126,32 @@ const prepare = async (command, config) => {
   }
 
   if (command === 'repair') {
-    const repairModule = argv.first;
+    const repairModule = argv._[1];
     if (repairModule) {
       const arg = repairModule.split('@');
-      coreName = arg[0] || config.coreName;
-      coreVersion = arg[1] || 'latest';
+      if (arg.length > 1) {
+        coreVersion = arg.pop();
+        coreName = arg.join('@');
+        
+      }
+      else {
+        coreName = arg;
+        coreVersion = 'latest';
+      }
     }
     else {
+      coreName = config.coreName
       coreVersion = 'latest'
     }
-    needInstall = true
-    debug(`start repair ${config.coreName}`)
-    console.log(colors.yellow(`Start repair ${config.coreName}, please wait ...`));
+    // If repair module isn't the core module, pipe argv to the @weex-cli/core
+    if (coreName !== config.coreName) {
+      needInstall = false;
+    }
+    else {
+      needInstall = true;
+      debug(`start repair ${config.coreName}`)
+      console.log(colors.yellow(`Start repair ${config.coreName}, please wait ...`));
+    }
   }
   else {
     // checking if there has weex-cli/core
@@ -184,6 +197,7 @@ const prepare = async (command, config) => {
       force: argv.force || argv.f,
       registry: config.registry
     });
+    return ;
   }
 }
 

lib/trash.js

@@ -4,7 +4,6 @@ const path = require('path');
 const spawn = require('cross-spawn');
 
 module.exports = function(file) {
-  console.log(process.execPath, path.join(__dirname, '_trash.js'))
   try {
     spawn(
       process.execPath,

lib/utils.js

@@ -118,7 +118,6 @@ const _install = async (name, version, opts) => {
 			debug('use move');
 			const trashPath = opts.trash + '_core_' + t;
 			await fse.move(realDir, trashPath);
-			console.log(trashPath)
 			require('./trash')(trashPath);
 		}
 	}

packages/@weex/core/src/cli/cli.ts

@@ -1,58 +1,9 @@
-import { build, fs, IParameters, http, install } from '../index'
+import { build, fs, IParameters, http, install, logger, strings } from '../index'
 import { parseParams } from '../toolbox/parameter-tools'
 import * as path from 'path'
 
 const debug = require('debug')('weex:core')
 
-// export class Cli {
-//   private cli: any;
-//   constructor(options: {
-//     brand?: string
-//     help?: any
-//     defaultCommand?: any
-//     version?: any
-//     plugin?: {
-//       value?: string
-//       options?: any
-//     }
-//     plugins?: {
-//       value?: string
-//       options?: any
-//     }
-//     exclude?: string[]
-//   } = {}) {
-//     // create a CLI runtime
-//     this.cli = build(options.brand || 'weex')
-//               .src(__dirname)
-//               .help(options.help)
-//               .version(options.version)
-//               .exclude(options.exclude)
-//               .defaultCommand(options.defaultCommand);
-
-//     if (options.plugins && options.plugins.value) {
-//       this.cli = this.cli.plugins(options.plugins.value, options.plugins.options)
-//     }
-
-//     if (options.plugin) {
-//       if (Array.isArray(options.plugin)) {
-//         options.plugin.forEach(p => {
-//           this.cli = this.cli.plugin(p.value, p.options)
-//         })
-//       }
-//       else {
-//         this.cli = this.cli.plugin(options.plugin.value, options.plugin.options)
-//       }
-//     }
-//   }
-
-//   async start(argv?: string[] | string) {
-//     const params = parseParams(argv);
-//     // run the cli
-//     const toolbox = await this.cli.run(argv)
-//     // send it back (for testing, mostly)
-//     return toolbox
-//   }
-// }
 enum ModType {
   PLUGIN,
   EXTENSION,
@@ -150,23 +101,40 @@ export class Cli {
   }
 
   async start() {
-    // run the cli
-    // const toolbox = await this.cli.run(this.rawArgv)
-    // // send it back (for testing, mostly)
-    // return toolbox
     const command = this.argv.array[0]
-
     if (this.cliOptions.modules) {
       this.plugins = this.pickPlugins(this.cliOptions.modules)
     } else {
-      fs.file(path.join(this.cliOptions.moduleRoot, this.cliOptions.moduleName), {
-        mode: '777',
-        jsonIndent: 2,
-        content: JSON.stringify({ mods: {}, last_update_time: new Date().getTime() }),
-      })
+      fs.write(path.join(this.cliOptions.moduleRoot, this.cliOptions.moduleName), { mods: {}, last_update_time: new Date().getTime() })
     }
+    if (command === 'repair') {
+      debug(`Do repair`);
+      const repairModule = this.argv.array[1];
+      let repairName;
+      let repairVersion;
+      if (repairModule) {
+        const args = repairModule.split('@')
+        if (repairModule.slice(0,1) === '@') {
+          
+        }
+        else {
 
-    if (command) {
+        }
+        try {
+          await this.repairPackage(repairModule);
+          debug(`repair ${repairModule} successed!`);
+          logger.success(`\nRepair ${repairModule} successed!`)
+        }
+        catch(e) {
+          this.analyzer('repair', e.stack, {module: repairModule})
+        }
+      }
+      else {
+        logger.error('Need to specify the repaired module')
+      }
+      return ;
+    }
+    else if (command) {
       const plugin = this.searchPlugin(command, this.plugins)
       let commands = []
       let type = ModType.EXTENSION
@@ -175,7 +143,6 @@ export class Cli {
         if (!res.error) {
           const packages: any = await this.installPackage(`@weex-cli/${command}`, 'latest', {
             root: this.cliOptions.moduleRoot,
-            trash: this.cliOptions.trash,
             registry: this.cliOptions.registry,
           })
           for (let i = 0; i < packages.length; i++) {
@@ -216,11 +183,7 @@ export class Cli {
             }
           }
           // update module file
-          fs.file(path.join(this.cliOptions.moduleRoot, this.cliOptions.moduleName), {
-            mode: '777',
-            jsonIndent: 2,
-            content: JSON.stringify({ mods: this.cliOptions.modules.mods, last_update_time: new Date().getTime() }),
-          })
+          fs.write(path.join(this.cliOptions.moduleRoot, this.cliOptions.moduleName), { mods: this.cliOptions.modules.mods, last_update_time: new Date().getTime() })
         }
       }
       if (this.plugins.length > 0) {
@@ -229,13 +192,83 @@ export class Cli {
         })
       }
     }
+
     // run the cli
     const toolbox = await this.cli.create().run(this.rawArgv)
     // send it back (for testing, mostly)
     return toolbox
   }
 
-  async installPackage(name, version, options, result = []) {
+  async repairPackage(mod: string) {
+    let modVersion;
+    let modName;
+    let commands = [];
+    let type = ModType.EXTENSION;
+    const first = mod.slice(0,1);
+    // check for origin npm package
+    if (first === '@') {
+      const arg = mod.split('@');
+      if (arg.length > 2) {
+        modVersion = arg.pop();
+        modName = arg.join('@');
+      }
+      else {
+        modName = arg.join('@');
+        modVersion = 'latest';
+      }
+    }
+    else {
+      const arg = mod.split('@');
+      if (arg.length > 1) {
+        modVersion = arg.pop();
+        modName = arg.join('@');
+      }
+      else {
+        modName = arg[0];
+        modVersion = 'latest';
+      }
+    }
+    const packages: any = await this.installPackage(modName, modVersion, {
+      root: this.cliOptions.moduleRoot,
+      registry: this.cliOptions.registry,
+    })
+    for (let i = 0; i < packages.length; i++) {
+      const commandBasePath = path.join(packages[i].root, 'commands')
+      const commandFiles: string[] = fs.list(commandBasePath) || []
+      commandFiles.forEach(file => {
+        let content
+        try {
+          content = require(path.join(commandBasePath, file))
+        } catch (e) {
+          debug(`Check module error with: ${e.stack}`)
+          // try prev version
+        }
+        commands.push({
+          name: content.name || '',
+          alias: content.alias || '',
+          showed: typeof content.dashed === 'boolean' ? !content.dashed : true,
+          description: content.description || '',
+        })
+        type = ModType.PLUGIN
+      })
+      if (commands.length > 0) {
+        this.cliOptions.modules.mods[packages[i].package.name] = {
+          type: type,
+          version: packages[i].package.version,
+          next_version: '',
+          is_next: true,
+          changelog: packages[i].changelog || '',
+          local: packages[i].root,
+          commands: commands,
+        }
+      }
+    }
+    debug(`save modjson: ${JSON.stringify(this.cliOptions.modules.mods)}`)
+    // update module file
+    fs.write(path.join(this.cliOptions.moduleRoot, this.cliOptions.moduleName), { mods: this.cliOptions.modules.mods, last_update_time: new Date().getTime() })
+  }
+
+  async installPackage(name: string, version: string, options: any, result:any = []) {
     const info: any = await install(name, version || 'latest', options)
     if (Array.isArray(info.package.extensionDependencies)) {
       let len = info.package.extensionDependencies.length
@@ -247,14 +280,48 @@ export class Cli {
     return [info]
   }
 
-  async suggestPackage(command, registry) {
+  async suggestPackage(command: string, registry: string) {
     const npmApi = http.create({
       baseURL: `${registry}/@weex-cli/`,
     })
     const res = await npmApi.get(`${command}`)
     return res.data
   }
 
+  async analyzer(type: string, stack: string, options?: any) {
+    if (type === 'repair') {
+      if (/404 status/.test(stack)) {
+        const innerMods = [
+          '@weex-cli/debug',
+          '@weex-cli/generator',
+          '@weex-cli/build',
+          '@weex-cli/preview'
+        ]
+        let score;
+        let tempScore;
+        let suggestName;
+        innerMods.forEach(mod => {
+          tempScore = strings.strSimilarity2Number(mod, options.module);
+          if (!score) {
+            score = tempScore;
+            suggestName = mod;
+          }
+          else if (tempScore < score) {
+            score = tempScore;
+            suggestName = mod;
+          }
+        })
+        logger.warn(`Module "${options.module}" not found, do you mean "${suggestName}"?`)
+      }
+    }
+    else {
+      const logPath = path.join(process.cwd(), '.weex-error.log')
+      fs.write(logPath, stack);
+      logger.warn(`Unkown issue, see error stack on logPath.`)
+      logger.warn(`To fix this, you can create a issue on https://github.com/weexteam/weex-toolkit/issues.`)
+    }
+  }
+
   pickPlugins(modules: ModData): PluginItem[] {
     if (!modules) return []
     let plugins = []
@@ -271,14 +338,20 @@ export class Cli {
   }
 
   searchPlugin(command: string, mods: PluginItem[]): PluginItem | boolean {
-    mods.forEach((mod: PluginItem) => {
-      mod.commands.forEach(cmd => {
-        if (cmd.name === command || cmd.alias === command) {
-          return mod
-        }
+    if (mods.length > 0) {
+      let result
+      mods.forEach((mod: PluginItem) => {
+        mod.commands.forEach(cmd => {
+          if (cmd.name === command || cmd.alias === command) {
+            result = mod
+          }
+        })
       })
-    })
-    return false
+      return result;
+    } else {
+      return false
+    }
+    
   }
 }