@molejs/mole-react-native-cli/bin/mole-react-native-cli.js

#! /usr/bin/env node
const path = require('path');
const fs = require('fs');
const readline = require('readline');
const help = require('./helper');
const shell = require('shelljs');
const colors = require('colors');
const cwdPath = process.cwd();
const package = require('../package.json');
const templatePath = path.resolve(__dirname, '../template');
const templateComponentPath = path.resolve(__dirname, '../cmp_template');
const program = require('../utils/commander');

const FILENAMEREGX = (() => {
  let regstr = '';
  /**
   * 二进制文件后缀，在rename的时候用来过滤
   */
  ['png', 'jpg', 'jpeg', 'bmp', 'webp', 'jar', 'gif', 'ttf', 'dll', 'svg'].forEach(e => {
    regstr += e + '|';
  });
  regstr = `\.(${regstr.slice(0, -1)})`;
  return new RegExp(regstr);
})();



/**
 *
 * @param {string} path
 * @returns {boolean} 路径是否存在
 */
function fsExistsSync(path) {
  try {
    fs.accessSync(path, fs.F_OK);
  } catch (e) {
    return false;
  }
  return true;
}
/**
 * copy file from templatePath to targetPath
 * 
 * @param {string} templatePath 
 * @param {string} targetPath 
 */
function copyFile(templatePath, targetPath) {
  fs.writeFileSync(targetPath, fs.readFileSync(templatePath));
}

function confirmOverride() {
  const terminal = readline.createInterface({
    input: process.stdin,
    output: process.stdout
  });
  return new Promise((resolve, reject) => {
    terminal.question('Floder is already exits, do you want override it ? yes/no ', answer => {
      if (answer === 'yes' || answer === 'y') {
        resolve(true);
        terminal.close();
      } else {
        process.exit();
      }
    });
  });
}
/**
 * copy template
 * 
 * @param {string} templatePath 
 * @param {string} targetPath 
 * @returns {boolean}
 */
function copyTemplate(templatePath, targetPath) {
  try {
    if (fs.statSync(templatePath).isDirectory() && !fsExistsSync(targetPath)) {
      fs.mkdirSync(targetPath);
    }
   
    const subpaths = fs.readdirSync(templatePath);
    subpaths.forEach(subpath => {
      const tarPath = path.resolve(targetPath, subpath);
      const tempPath = path.resolve(templatePath, subpath);
      
      if (fs.statSync(tempPath).isDirectory()) {
        copyTemplate(tempPath, tarPath);
      } else {
        copyFile(tempPath, tarPath);
      }
    });
  } catch (error) {
    console.log(error);
    return false;
  }
  return true;
}
/**
 * rename project
 * 
 * @param {string} targetPath 
 * @param {string} projectName 
 */
function renameProject(targetPath, projectName) {
  try {
    const paths = fs.readdirSync(targetPath);
    paths.forEach(subpath => {
      const subfile = path.resolve(targetPath, subpath);
      const newPath = subfile.replace(/MoleStarter/gim, projectName);
      if (!fs.statSync(subfile).isFile()) {
        if (subpath !== 'images') {
          fs.renameSync(subfile, newPath);
          renameProject(newPath, projectName);
        }
      } else {
        if (!FILENAMEREGX.test(subfile)) {
          fs.renameSync(subfile, newPath);
          fs.writeFileSync(
            newPath,
            fs
              .readFileSync(newPath)
              .toString()
              .replace(/MoleStarter/gim, projectName)
          );
        }
      }
    });
  } catch (error) {
    console.log(error);
  }
}
function renameComponent(targetPath, projectName) {
  try {
    const paths = fs.readdirSync(targetPath);
    paths.forEach(subpath => {
      const subfile = path.resolve(targetPath, subpath);
      const newPath = subfile.replace(/MoleUI/gim, projectName);
      if (!fs.statSync(subfile).isFile()) {
        if (subpath !== 'images') {
          fs.renameSync(subfile, newPath);
          renameComponent(newPath, projectName);
        }
      } else {
        if (!FILENAMEREGX.test(subfile)) {
          fs.renameSync(subfile, newPath);
          fs.writeFileSync(
            newPath,
            fs
              .readFileSync(newPath)
              .toString()
              .replace(/MoleUI/gim, projectName)
          );
        }
      }
    });
  } catch (error) {
    console.log(error);
  }
}
/**
 * mole-react-native-cli
 * @param {string} projectName 
 */
function installDependencies(projectName) {
  console.log('\ninstalling...');
  if (shell.exec(`cd ${projectName} && npm install`).code) {
    if (shell.exec(`cd ${projectName} && npm install`).code) {
      console.log(colors.red('install dependencies failed!'));
    } else {
      console.log(
        colors.yellow(
          [
            `Success! Created ${projectName} at ${cwdPath}.`,
            'Inside that directory, you can run several commands and more:',
            '  * npm run start-web: Starts you project for web.',
            '  * npm run start-rn: Starts you project for rn.',
            '  * npm run run-ios: Starts you project for ios.',
            '  * npm run run-android: Starts you project for android.',
            ' We suggest that you begin by typing:',
            `  cd ${projectName}`,
            '  npm run start-rn',
            'Happy coding!'
          ].join('\n')
        )
      );
    }
  }
}

function backupDir(templatePath, backupPath) {
  if (fs.statSync(templatePath).isDirectory()) {
    fs.mkdirSync(backupPath);
  }
  const subpaths = fs.readdirSync(templatePath);
  subpaths.forEach(subpath => {
    const bacPath = path.resolve(backupPath, subpath);
    const tempPath = path.resolve(templatePath, subpath);
    if (fs.statSync(tempPath).isDirectory()) {
      backupDir(tempPath, bacPath);
    } else {
      copyFile(tempPath, bacPath);
    }
  });
}

function removeBackup(backupPath) {
  shell.rm('-rf', backupPath);
}
/**
 * 
 * 
 * @param {string} projectName 
 */
// function newLatestProject(projectName) {
//   shell.exec(`git clone https://github.com/nihgwu/react-native-dva-starter.git`, error => {
//     if (!error) {
//       const tarPath = path.join(cwdPath, 'react-native-dva-starter');
//       removeGit();
//       renameProject(tarPath, projectName);
//       fs.renameSync(tarPath, projectName);
//       installDependencies(projectName);
//     } else {
//       console.log(error);
//     }
//   });
// }

async function newComponent(component){
  // console.log("初始化的组件名称为" + component)
  const targetPath = `${cwdPath}/${component}`;
  
  if (fsExistsSync(targetPath)) {
    if (await confirmOverride()) {
      if (copyTemplate(templateComponentPath, targetPath)) {
        renameComponent(targetPath, component);
        console.log('🎉🎉🎉恭喜您, 组件[' + component + ']创建成功.');
        // installDependencies(component);
      }
      // removeBackup(backupPath);
    }
  } else {
   
    if (copyTemplate(templateComponentPath, targetPath)) {
      renameComponent(targetPath, component);
      console.log('🎉🎉🎉恭喜您, 组件[' + component + ']创建成功.');
      // installDependencies(component);
    }
  }
}

/**
 * 
 * 
 * @param {string} projectName 
 */
async function newProject(projectName) {
  const targetPath = `${cwdPath}/${projectName}`;
  // const backupPath = `${cwdPath}/.${projectName}`;
  if (fsExistsSync(targetPath)) {
    if (await confirmOverride()) {
      if (copyTemplate(templatePath, targetPath)) {
        renameProject(targetPath, projectName);
        installDependencies(projectName);
      }
      // removeBackup(backupPath);
    }
  } else {
   
    if (copyTemplate(templatePath, targetPath)) {
      renameProject(targetPath, projectName);
      installDependencies(projectName);
    }
  }
}

try {
  program.option('-h, --help', help).option('-v, --version', () => {
    console.log(package.version);
  });
  program.command('project <project>').action(newProject);
  // program.command('git <project>').action(newLatestProject);
  program.command('component <component>').action(newComponent);
  program.catch((...argvs) => {
    // console.log(colors.red(`Do not use bsreact ${argvs}`));
    shell.exec('mole-rn-cli --help')
    //console.log('Run ' + colors.blue('bsreact --help') + ' to get the Commands that bsreact-native-cli supports');
  });
  program.parse(process.argv);
} catch (error) {
  console.log(error);
}