meteor-boilerplate

var fs = require('fs'),
  args = process.argv,
  util = require('util'),
  cliRoot = './private/cli/',
  readline = require('readline'),
  exec = require('child_process').exec;

/**
 *  General Helper Functions
 */
function execute(command, callback){
  exec(command, function(error, stdout, stderr){ callback(stdout); });
}

function quote(regex) {
  return regex.replace(/([()[{*+.$^\\|?])/g, '\\$1');
}

function slugify(text) {
  return text
    .replace(/[^-a-zA-Z0-9\s\/\.+]+/ig, '')
    .replace(/\s+/gi, "_")
  ;
}

function commandsAreSimiliar(firstCommand, secondCommand) {
  var sameCharOccurences = 0,
    firstCommandChars = firstCommand.split(''),
    secondCommandChars = secondCommand.split('');

  firstCommandChars.forEach(function (character, index) {
    if (character === secondCommandChars[index]) {
      sameCharOccurences += 1;
    }
  });

  return sameCharOccurences > parseInt((firstCommand.length / 1.5).toFixed(0), 10);
}

function getSuggestions(command) {
  var foundSuggestions = [];

  Object.keys(commands).forEach(function (existingCommand) {
    if (commandsAreSimiliar(command, existingCommand)) {
      foundSuggestions.push(existingCommand);
    }
  });

  return foundSuggestions;
}

/**
 * File Manager
 *
 * Handles creation of files and folders for create:* commands
 */
var FileManager = {

  createFoldersAndFile: function (conf) {
    var fileExists = false,
      absolutePath = '',
      pathParts = conf.path.split('/');

    pathParts.forEach(function (part, index) {
      var isDirectory = false;

      absolutePath += part;

      if (pathParts.length - 1 !== index) {
        absolutePath += '/';
        isDirectory = true;
      }

      if (!fs.existsSync(absolutePath)) {
        if (isDirectory) {
          fs.mkdirSync(absolutePath);
        } else {
          // It has to be the file
          fs.writeFileSync(conf.path, conf.contents, { encoding: 'utf8' });
        }
      } else if (fs.existsSync(absolutePath) && !isDirectory) {
        fileExists = true;
      }
    });

    return !fileExists;
  },

  processFiles: function (path, variables, filesConfiguration, callback) {
    var managerScope = this,
      alreadyExistingFilePath = '';

    filesConfiguration.forEach(function (file) {
      var continueCreating;

      if (alreadyExistingFilePath) {
        return;
      }

      file.contents = fs.readFileSync(path + '/templates/' + file.template, { encoding: "utf8" });

      variables.forEach(function (variable) {
        var variableRegExp = new RegExp(quote('__' + variable.name + '__'), 'g');

        file.path = slugify(file.path.replace(variableRegExp, variable.value));
        file.contents = file.contents.replace(variableRegExp, variable.value);
      });

      continueCreating = managerScope.createFoldersAndFile(file);

      if (!continueCreating) {
        alreadyExistingFilePath = file.path;
      }
    });

    if (alreadyExistingFilePath) {
      Errors.fileExists(alreadyExistingFilePath);
    } else {
      InteractiveConsole.print();

      filesConfiguration.forEach(function (file) {
        process.stdout.write('-- Created ');
        InteractiveConsole.printInfo(file.path);
      });

      InteractiveConsole.print();

      if (callback) {
        callback();
      }
    }
  }
};

/**
 * Interactive Console
 *
 * Prints output to the user and takes input through the readline interface
 */
var InteractiveConsole = {

  init : function (runnerScope) {
    this.readLine = readline.createInterface({
      input: process.stdin,
      output: process.stdout
    });
  },

  showQuestions: function (variables, callback) {
    var userInput = [],
      consoleScope = this,
      argument = variables.shift();

    InteractiveConsole.print(argument.question);

    this.readLine.prompt();

    this.readLine.on('line', function(line) {
      if (!line) {
        InteractiveConsole.print('Please enter a value!');
        consoleScope.readLine.prompt();
      } else {
        userInput.push({ 'name' : argument.name, 'value' : line });

        if (variables.length === 0) {
          callback(userInput);
        } else {
          argument = variables.shift();

          InteractiveConsole.print(argument.question);
          consoleScope.readLine.prompt();
        }
      }
    });
  },

  print: function () {
    if (!arguments[0])
      arguments[0] = '';

    process.stdout.write(arguments[0] + '\n');
  },

  printError: function (content, callback) {
    execute('echo $(tput setab 1)$(tput setaf 7) ' + content + ' $(tput sgr0)', function (string) {
      process.stdout.write('\n' + string + '\n');
      callback(string);
    });
  },

  printInfo: function (content) {
    process.stdout.write(util.inspect(content, { colors: true }).replace(/\'/g, '') + '\n');
  },

  printCommand: function (command, description) {
    process.stdout.write(util.inspect(command, { colors: true }).replace(/\'/g, '') + "\t - " + description + '\n');
  }

};

/**
 * Errors
 *
 * Helper Objec for printing out certain types of errors.
 */
var Errors = {

  commandNotFound: function (command) {
    InteractiveConsole.printError('The command ' + command + ' does not exist!', function () {
      var suggestions = getSuggestions(command);

      if (suggestions.length > 0) {
        InteractiveConsole.print('Did you mean? ');
        suggestions.forEach(function (suggestion) {
          process.stdout.write('   ');
          InteractiveConsole.printInfo(suggestion);
        });
      }
      process.exit(0);
    });
  },

  amountOfParametersInvalid: function (command, parameters) {
    InteractiveConsole.printError('Amount of parameters is invalid!', function () {
      InteractiveConsole.print('node meteor-boilerplate ' + command + ' ' + parameters.map(function (v) { return v.name; }).join(' ') + '\n');
      process.exit(0);
    });
  },

  fileExists: function (path) {
    InteractiveConsole.printError('Remove existing file "' + path + '" manually! ', function () {
      process.exit(0);
    });
  },

  executeWithinMeteorProject: function () {
    InteractiveConsole.print('Execute this script within the meteor project!');
    process.exit(0);
  },

  nonExistentProfile: function (name, availableProfiles) {
    InteractiveConsole.printError('Profile "' + name + '" does not exist!', function () {
      InteractiveConsole.print('Available profiles: ');
      InteractiveConsole.printInfo(availableProfiles);
      process.exit(0);
    });
  }

};

/**
 * Main Command Runner Class
 */
var CommandRunner = function (nodeArgs) {
  this.command = nodeArgs[2].toLowerCase();
  this.arguments = nodeArgs;
  this.commandParts = this.command.split(':');
};

CommandRunner.prototype.exists = function () {
  return commands[this.command];
};

CommandRunner.prototype.run = function () {
  var questions,
    userInput,
    commandArgs,
    runnerScope = this;

  commands[this.command].init(this);
  questions = commands[this.command].getQuestions();

  if (this.arguments.length === 3 && questions.length > 0) {
    // Show an interactive console, if there are exactly 3 arguments
    // for example "node meteor-boilerplate create:view"
    InteractiveConsole.init(this);

    InteractiveConsole.showQuestions(questions, function (userInput) {
      commands[runnerScope.command].execute(userInput);
    });
  } else {
    // If more, expect it to be the exact amount of variables needed
    commandArgs = this.arguments.splice(3);

    if (commandArgs.length === questions.length) {
      userInput = questions.map(function (variable) {
        variable.value = commandArgs.shift();
        return variable;
      });

      commands[runnerScope.command].execute(userInput);
    } else {
      Errors.amountOfParametersInvalid(runnerScope.command, questions)
    }
  }
};

/**
 * Project Wide Configuration
 *
 * Has all the configuration needed for the project and this script,
 * for example the profile which is used for creating files and more (with coffeescript support)
 *
 * found under private/cli/configuration.json
 */
var configuration;

/**
 * Commands
 *
 * Holds all commands where the key is the command itself ('create:view')
 * and the value is an object used for processing all commands in a general way
 *
 * create:*
 *   found in each profile, private/cli/<profile-name>/create/<*>
 * change:profile
 *   Change the profile specified in private/cli/configuration.json
 */
var commands = {
  'change:profile' : {
    init: function (runnerScope) {
      this.availableProfiles = fs.readdirSync(cliRoot).filter(function (element) {
        return element.indexOf('.') === -1;
      });
    },
    getQuestions: function () {
      return [{
        'question' : 'Which profile do you want to change to?',
        'name' : 'profileName'
      }];
    },
    execute: function (userInput) {
      var commandScope = this,
        profileName = userInput[0].value;

      if (this.availableProfiles.indexOf(profileName) === -1) {
        Errors.nonExistentProfile(profileName, commandScope.availableProfiles.join(', '));
      } else {
        this.changeProfile(profileName);
        InteractiveConsole.print();

        if (profileName === 'coffee' && fs.readFileSync('.meteor/packages', { encoding: 'utf8' }).indexOf('coffeescript') === -1) {
          InteractiveConsole.printInfo('Coffeescript package missing!');
          execute('meteor add coffeescript', function () {
            commandScope.success(profileName);
            InteractiveConsole.print('-- Added coffeescript package to project');
            InteractiveConsole.print();
            process.exit(0);
          });
        } else {
          commandScope.success(profileName);
          InteractiveConsole.print();
          process.exit(0);
        }
      }
    },

    success: function (profileName) {
      process.stdout.write('-- Changed profile to ');
      InteractiveConsole.printInfo(profileName);
    },

    changeProfile: function (name) {
      configuration.profile = name;
      fs.unlinkSync(cliRoot + 'configuration.json');
      fs.writeFileSync(cliRoot + 'configuration.json', JSON.stringify(configuration), { encoding: 'utf8' });
    },

    getDescription: function () {
      return 'Change your project wide profile for generating files';
    }
  },
  'reset:project' : {
    init: function (runnerScope) {
    },
    getQuestions: function () {
      return [{
        'question' : 'Do you really want to reset this project (Y/n)?',
        'name' : 'resetProject'
      }];
    },
    execute: function (userInput) {
      var commandScope = this,
        folders = this.deletableFolders(),
        resetRootPath = cliRoot + configuration.profile + '/reset/';

      if (userInput[0].value.toLowerCase() === 'y') {
        execute('rm -rf ' + folders.join(' '), function () {
          folders.forEach(function (f) { commandScope.printFileChange('Removed', f) });

          // Create files
          JSON
            .parse(fs.readFileSync(resetRootPath + 'configuration.json' , { encoding: 'utf8' }))
            .files
            .forEach(function (fileConf) {
              fileConf.contents = fs.readFileSync(resetRootPath + fileConf.template, { encoding: 'utf8' });
              commandScope.printFileChange('Added', fileConf.path);
              FileManager.createFoldersAndFile(fileConf);
            })
          ;

          process.exit(0);
        });
      } else {
        process.exit(0);
      }
    },

    deletableFolders: function () {
      return [
        'client/views', 'client/modules', 'client/modules', 'client/stylesheets',
        'client/routes', 'client/config', 'client/subscriptions', 'client/startup',
        'server/publications', 'server/startup', 'server/fixtures',
        'model', 'public', 'tests'
      ];
    },

    printFileChange: function (action, path) {
      process.stdout.write('-- ' + action +  ' ');
      InteractiveConsole.printInfo(path);
    },

    getDescription: function () {
      return 'Removes a lot of files, perfect for a fresh start';
    }

  }
};

// Check if the command has been entered within the meteor directory
if (!fs.existsSync('.meteor')) {
  Errors.executeWithinMeteorProject();
}

configuration = JSON.parse(fs.readFileSync(cliRoot + 'configuration.json', { encoding: "utf8" }));

// Fill 'commands' object with all create commands
fs.readdirSync(cliRoot + '/' + configuration.profile + '/create').forEach(function (createPart) {
  commands['create:' + createPart] = {
    init: function (runnerScope) {
      this.createPath = cliRoot + '/' + configuration.profile +'/create/' + runnerScope.commandParts[1];

      this.configuration = JSON.parse(fs.readFileSync(
        this.createPath + '/configuration.json',
        { encoding: "utf8" }
      ));
    },
    getQuestions: function () {
      return this.configuration.variables.map(function (variable) {
        variable.question = variable.description;
        return variable;
      });
    },
    execute: function (userInput) {
      FileManager.processFiles(this.createPath, userInput, this.configuration.files, function () {
        process.exit(0);
      });
    },
    getDescription: function () {
      return fs.readFileSync(
        cliRoot + '/' + configuration.profile + '/create/' + createPart + '/info.txt',
        { encoding: "utf8" }
      ).replace('\n', '');
    }
  };
});

// TODO: README.md
if (args.length >= 3) {
  var command = new CommandRunner(args);

  if (command.exists()) {
    command.run();
  } else {
    Errors.commandNotFound(command.command);
  }
} else {
  InteractiveConsole.print("                   __                              __          _ __                __      __     ");
  InteractiveConsole.print("   ____ ___  ___  / /____  ____  _____            / /_  ____  (_) /__  _________  / /___ _/ /____ ");
  InteractiveConsole.print("  / __ `__ \\/ _ \\/ __/ _ \\/ __ \\/ ___/  ______   / __ \\/ __ \\/ / / _ \\/ ___/ __ \\/ / __ `/ __/ _ \\");
  InteractiveConsole.print(" / / / / / /  __/ /_/  __/ /_/ / /     /_____/  / /_/ / /_/ / / /  __/ /  / /_/ / / /_/ / /_/  __/");
  InteractiveConsole.print("/_/ /_/ /_/\\___/\\__/\\___/\\____/_/              /_.___/\\____/_/_/\\___/_/  / .___/_/\\__,_/\\__/\\___/ ");
  InteractiveConsole.print("                                                                        /_/                       ");
  InteractiveConsole.print("Use one of the following commands:\n");

  Object.keys(commands).sort().forEach(function (command) {
    InteractiveConsole.printCommand(command, commands[command].getDescription());
  });

  InteractiveConsole.print();
}