hope is coming

return hexo.call(cmd, args).then(function() {
     return hexo.exit();
   }).catch(function(err) {
     return hexo.exit(err).then(function() {
       handleError(err);
     });
   });

Hexo.prototype.call = function(name, args, callback){
	  if (!callback && typeof args === 'function'){
	    callback = args;
	    args = {};
	  }

	  var self = this;

	  return new Promise(function(resolve, reject){
	    var c = self.extend.console.get(name);

	    if (c){
	      c.call(self, args).then(resolve, reject);
	    } else {
	      reject(new Error('Console `' + name + '` has not been registered yet!'));
	    }
	  }).nodeify(callback);
};

function newConsole(args){
  /* jshint validthis: true */
  // Display help message if user didn't input any arguments
  //console.log('参数是：'+args._);
  if (!args._.length){
    return this.call('help', {_: ['new']});
  }

  var data = {
    title: args._.pop(),//标题
    //这里layout就是可以通过 hexo n  title layout获取
    layout: args._.length ? args._[0] : this.config.default_layout,
    slug: args.s || args.slug,
    path: args.p || args.path
  };

  var keys = Object.keys(args);
  var key = '';
  var self = this;

  for (var i = 0, len = keys.length; i < len; i++){
    key = keys[i];
    if (!reservedKeys[key]) data[key] = args[key];
  }

  return this.post.create(data, args.r || args.replace).then(function(post){
    self.log.info('Created: %s', chalk.magenta(tildify(post.path)));
  });
 }

Post.prototype.create = function(data, replace, callback){
  if (!callback && typeof replace === 'function'){
    callback = replace;
    replace = false;
  }

  var ctx = this.context;
  var config = ctx.config;

  data.slug = slugize((data.slug || data.title).toString(), {transform: config.filename_case});
  data.layout = (data.layout || config.default_layout).toLowerCase();
  data.date = data.date ? moment(data.date) : moment();

  return Promise.all([
    // Get the post path
    ctx.execFilter('new_post_path', data, {
      args: [replace],
      context: ctx
    }),
    // Get the scaffold
    this._getScaffold(data.layout)
  ]).spread(function(path, scaffold){
    // Split data part from the raw scaffold
    var split = yfm.split(scaffold);
    var separator = split.separator || '---';
    var jsonMode = separator[0] === ';';
    var frontMatter = prepareFrontMatter(_.clone(data));
    var content = '';

    // Compile front-matter with data
    var renderedData = swig.compile(split.data)(frontMatter);

    // Parse front-matter
    var compiled;

    if (jsonMode){
      compiled = JSON.parse('{' + renderedData + '}');
    } else {
      compiled = yaml.load(renderedData);
    }

    // Add data which are not in the front-matter
    var keys = Object.keys(data);
    var key = '';
    var obj = compiled;

    for (var i = 0, len = keys.length; i < len; i++){
      key = keys[i];

      if (!preservedKeys[key] && obj[key] == null){
        obj[key] = data[key];
      }
    }

    // Prepend the separator
    if (split.prefixSeparator) content += separator + '\n';

    content += yfm.stringify(obj, {
      mode: jsonMode ? 'json' : ''
    });

    // Concat content
    content += split.content;

    if (data.content){
      content += '\n' + data.content;
    }

    var result = {
      path: path,
      content: content
    };

    return Promise.all([
      // Write content to file
      fs.writeFile(path, content),
      // Create asset folder
      createAssetFolder(path, config.post_asset_folder)
    ]).then(function(){
      ctx.emit('new', result);
    }).thenReturn(result);
  }).nodeify(callback);
}

// Load config
 return Promise.each([
   'update_package', // Update package.json
   'load_config', // Load config
   'load_plugins' // Load external plugins & scripts
 ], function(name){
   return require('./' + name)(self);
 }).then(function(){
   return self.execFilter('after_init', null, {context: self});
 }).then(function(){
   // Ready to go!
   self.emit('ready');
 });

Hexo.prototype.call = function(name, args, callback){
  if (!callback && typeof args === 'function'){
    callback = args;
    args = {};
  }

  var self = this;

  return new Promise(function(resolve, reject){
    var c = self.extend.console.get(name);

    if (c){
      c.call(self, args).then(resolve, reject);
    } else {
      reject(new Error('Console `' + name + '` has not been registered yet!'));
    }
  }).nodeify(callback);
};

Hexo.prototype.load = function(callback){
  var self = this;

  return loadDatabase(this).then(function(){
    return Promise.all([
      self.source.process(),
      self.theme.process()
    ]);
  }).then(function(){
    return self._generate({cache: true});
  }).nodeify(callback);
};

var extend = require('../extend');

'use strict';

exports.Console = require('./console');
exports.Deployer = require('./deployer');
exports.Filter = require('./filter');
exports.Generator = require('./generator');
exports.Helper = require('./helper');
exports.Migrator = require('./migrator');
exports.Processor = require('./processor');
exports.Renderer = require('./renderer');
exports.Tag = require('./tag');

   ...部分代码省略
Console.prototype.get = function(name){
	  name = name.toLowerCase();
	  return this.store[this.alias[name]];
};
...部分代码省略

this.extend = {
   console: new extend.Console(),
   deployer: new extend.Deployer(),
   filter: new extend.Filter(),
   generator: new extend.Generator(),
   helper: new extend.Helper(),
   migrator: new extend.Migrator(),
   processor: new extend.Processor(),
   renderer: new extend.Renderer(),
   tag: new extend.Tag()
 };

  ...hexo_cli/lib/hexo.js中 找到hexo模块后调用此方法,部分代码省略
function(mod) {
   if (mod) hexo = mod;
   log = hexo.log;

   require('./console')(hexo);

   return hexo.init();
 }

Hexo.prototype.init = function(){
  var self = this;

  this.log.debug('Hexo version: %s', chalk.magenta(this.version));
  this.log.debug('Working directory: %s', chalk.magenta(tildify(this.base_dir)));

  // Load internal plugins
  //加载内部插件
  require('../plugins/console')(this);
}

//先获取在构造函数中定义的console对象
 var console = ctx.extend.console;

 ...部分代码省略
 console.register('new', 'Create a new post.', {
    usage: '[layout] <title>',
    arguments: [
      {name: 'layout', desc: 'Post layout. Use post, page, draft or whatever you want.'},
      {name: 'title', desc: 'Post title. Wrap it with quotations to escape.'}
    ],
    options: [
      {name: '-r, --replace', desc: 'Replace the current post if existed.'},
      {name: '-s, --slug', desc: 'Post slug. Customize the URL of the post.'},
      {name: '-p, --path', desc: 'Post path. Customize the path of the post.'}
    ]
  }, require('./new'));

Console.prototype.register = function(name, desc, options, fn){
	  if (!name) throw new TypeError('name is required');

	  if (!fn){
	    if (options){
	      if (typeof options === 'function'){
	        fn = options;

	        if (typeof desc === 'object'){ // name, options, fn
	          options = desc;
	          desc = '';
	        } else { // name, desc, fn
	          options = {};
	        }
	      } else {
	        throw new TypeError('fn must be a function');
	      }
	    } else {
	      // name, fn
	      if (typeof desc === 'function'){
	        fn = desc;
	        options = {};
	        desc = '';
	      } else {
	        throw new TypeError('fn must be a function');
	      }
	    }
	  }

	  if (fn.length > 1){
	    fn = Promise.promisify(fn);
	  } else {
	    fn = Promise.method(fn);
	  }

	  var c = this.store[name.toLowerCase()] = fn;
	  c.options = options;
	  c.desc = desc;
	  //new 变成n ne
	  this.alias = abbrev(Object.keys(this.store));
}

parents: function( elem ){
	var matched = [];
	var cur = elem.parentNode;
	while ( cur && cur != document ) {
		matched.push( cur );
		cur = cur.parentNode;
	}
	return matched;
},