1977

pending completion

Build # 1977

Build Type

push

travis-ci-com

Committed by

SukkaW

Commit Message

<a href="https://github.com/hexojs/hexo/commit/<a class=hub.com/hexojs/hexo/commit/6f6084cb4d5772061aa45703b258634a0db13cee">6f6084cb4<a href="https://github.com/hexojs/hexo/commit/6f6084cb4d5772061aa45703b258634a0db13cee">&quot;&gt;perf(cache): improve cache and reduce Memory Usages (#3756)

* test(cache): verify whether the cache works properly
* fix(fragment_cache): reset the cache on generateBefore event so we can enable cache on watch mode.
* fix(cache): disable save cache for rendered contents when generate files. Added at (https://github.com/hexojs/hexo/commit/</a><a class="double-link" href="https://github.com/hexojs/hexo/commit/<a class="double-link" href="https://github.com/hexojs/hexo/commit/e8e45ed0f379f975147a214fbf52b2c28a6c806a">e8e45ed0f</a>">e8e45ed0f</a><a href="https://github.com/hexojs/hexo/commit/6f6084cb4d5772061aa45703b258634a0db13cee">#diff-b9bb6fa7bb069bab9948daba90c6c3b2). Should enable save cache for rendered contents when run server mode.

Run Details

3436 of 3786 branches covered (90.76%)

11 of 11 new or added lines in 2 files covered. (100.0%)

6920 of 7114 relevant lines covered (97.27%)

189.33 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

97.98

/lib/hexo/index.js

'use strict';

const Promise = require('bluebird');
const { sep, join, dirname } = require('path');
const tildify = require('tildify');
const Database = require('warehouse');
const _ = require('lodash');
const chalk = require('chalk');
const { EventEmitter } = require('events');
const fs = require('hexo-fs');
const Module = require('module');
const vm = require('vm');
const pkg = require('../../package.json');
const logger = require('hexo-log');
const extend = require('../extend');
const Render = require('./render');
const registerModels = require('./register_models');
const Post = require('./post');
const Scaffold = require('./scaffold');
const Source = require('./source');
const Router = require('./router');
const Theme = require('../theme');
const Locals = require('./locals');
const defaultConfig = require('./default_config');
const loadDatabase = require('./load_database');
const multiConfigPath = require('./multi_config_path');
const resolve = require('resolve');
const full_url_for = require('../plugins/helper/full_url_for');

const { cloneDeep, debounce } = _;

const libDir = dirname(__dirname);
const dbVersion = 1;

function Hexo(base = process.cwd(), args = {}) {
  Reflect.apply(EventEmitter, this, []);

  this.base_dir = base + sep;
  this.public_dir = join(base, 'public') + sep;
  this.source_dir = join(base, 'source') + sep;
  this.plugin_dir = join(base, 'node_modules') + sep;
  this.script_dir = join(base, 'scripts') + sep;
  this.scaffold_dir = join(base, 'scaffolds') + sep;
  this.theme_dir = join(base, 'themes', defaultConfig.theme) + sep;
  this.theme_script_dir = join(this.theme_dir, 'scripts') + sep;

  this.env = {
    args,
    debug: Boolean(args.debug),
    safe: Boolean(args.safe),
    silent: Boolean(args.silent),
    env: process.env.NODE_ENV || 'development',
    version: pkg.version,
    cmd: args._ ? args._[0] : '',
    init: false
  };

  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()
  };

  this.config = cloneDeep(defaultConfig);

  this.log = logger(this.env);

  this.render = new Render(this);

  this.route = new Router();

  this.post = new Post(this);

  this.scaffold = new Scaffold(this);

  this._dbLoaded = false;

  this._isGenerating = false;

  // If `output` is provided, use that as the
  // root for saving the db. Otherwise default to `base`.
  const dbPath = args.output || base;

  this.log.d(`Writing database to ${dbPath}/db.json`);

  this.database = new Database({
    version: dbVersion,
    path: join(dbPath, 'db.json')
  });

  const mcp = multiConfigPath(this);

  this.config_path = args.config ? mcp(base, args.config, args.output) :
    join(base, '_config.yml');

  registerModels(this);

  this.source = new Source(this);
  this.theme = new Theme(this);
  this.locals = new Locals(this);
  this._bindLocals();
}

require('util').inherits(Hexo, EventEmitter);

Hexo.prototype._bindLocals = function() {
  const db = this.database;
  const { locals } = this;

  locals.set('posts', () => {
    const query = {};

    if (!this.config.future) {
      query.date = {$lte: Date.now()};
    }

    if (!this._showDrafts()) {
      query.published = true;
    }

    return db.model('Post').find(query);
  });

  locals.set('pages', () => {
    const query = {};

    if (!this.config.future) {
      query.date = {$lte: Date.now()};
    }

    return db.model('Page').find(query);
  });

  locals.set('categories', () => {
    // Ignore categories with zero posts
    return db.model('Category').filter(category => category.length);
  });

  locals.set('tags', () => {
    // Ignore tags with zero posts
    return db.model('Tag').filter(tag => tag.length);
  });

  locals.set('data', () => {
    const obj = {};

    db.model('Data').forEach(data => {
      obj[data._id] = data.data;
    });

    return obj;
  });
};

Hexo.prototype.init = function() {
  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);
  require('../plugins/filter')(this);
  require('../plugins/generator')(this);
  require('../plugins/helper')(this);
  require('../plugins/processor')(this);
  require('../plugins/renderer')(this);
  require('../plugins/tag')(this);

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

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

  return new Promise((resolve, reject) => {
    const c = this.extend.console.get(name);

    if (c) {
      Reflect.apply(c, this, [args]).then(resolve, reject);
    } else {
      reject(new Error(`Console \`${name}\` has not been registered yet!`));
    }
  }).asCallback(callback);
};

Hexo.prototype.model = function(name, schema) {
  return this.database.model(name, schema);
};

Hexo.prototype.resolvePlugin = function(name) {
  const baseDir = this.base_dir;

  try {
    // Try to resolve the plugin with the resolve.sync.
    return resolve.sync(name, { basedir: baseDir });
  } catch (err) {
    // There was an error (likely the plugin wasn't found), so return a possibly
    // non-existing path that a later part of the resolution process will check.
    return join(baseDir, 'node_modules', name);
  }
};

Hexo.prototype.loadPlugin = function(path, callback) {
  return fs.readFile(path).then(script => {
    // Based on: https://github.com/joyent/node/blob/v0.10.33/src/node.js#L516
    const module = new Module(path);
    module.filename = path;
    module.paths = Module._nodeModulePaths(path);

    function require(path) {
      return module.require(path);
    }

    require.resolve = request => Module._resolveFilename(request, module);

    require.main = process.mainModule;
    require.extensions = Module._extensions;
    require.cache = Module._cache;

    script = `(function(exports, require, module, __filename, __dirname, hexo){${script}});`;

    const fn = vm.runInThisContext(script, path);

    return fn(module.exports, require, module, path, dirname(path), this);
  }).asCallback(callback);
};

Hexo.prototype._showDrafts = function() {
  const { args } = this.env;
  return args.draft || args.drafts || this.config.render_drafts;
};

Hexo.prototype.load = function(callback) {
  return loadDatabase(this).then(() => {
    this.log.info('Start processing');

    return Promise.all([
      this.source.process(),
      this.theme.process()
    ]);
  }).then(() => this._generate({cache: false})).asCallback(callback);
};

Hexo.prototype.watch = function(callback) {
  let useCache = false;
  if (this.env.cmd.startsWith('s')) {
    // enable cache when run hexo server
    useCache = true;
  }
  this._watchBox = debounce(() => this._generate({cache: useCache}), 100);

  return loadDatabase(this).then(() => {
    this.log.info('Start processing');

    return Promise.all([
      this.source.watch(),
      this.theme.watch()
    ]);
  }).then(() => {
    this.source.on('processAfter', this._watchBox);
    this.theme.on('processAfter', this._watchBox);

    return this._generate({cache: useCache});
  }).asCallback(callback);
};

Hexo.prototype.unwatch = function() {
  if (this._watchBox != null) {
    this.source.removeListener('processAfter', this._watchBox);
    this.theme.removeListener('processAfter', this._watchBox);

    this._watchBox = null;
  }

  stopWatcher(this.source);
  stopWatcher(this.theme);
};

function stopWatcher(box) {
  if (box.isWatching()) box.unwatch();
}

Hexo.prototype._generateLocals = function() {
  const { config, theme } = this;
  const ctx = { config: { url: this.config.url } };

  function Locals(path, locals) {
    this.page = typeof locals === 'object' ? locals : {};
    if (this.page.path == null) this.page.path = path;

    this.path = path;
    this.url = full_url_for.call(ctx, path);
  }

  Locals.prototype.config = config;
  Locals.prototype.theme = Object.assign({}, config, theme.config, config.theme_config);
  Locals.prototype._ = _;
  Locals.prototype.layout = 'layout';
  Locals.prototype.env = this.env;
  Locals.prototype.view_dir = join(this.theme_dir, 'layout') + sep;
  Locals.prototype.site = this.locals.toObject();

  return Locals;
};

Hexo.prototype._runGenerators = function() {
  this.locals.invalidate();
  const siteLocals = this.locals.toObject();
  const generators = this.extend.generator.list();
  const { log } = this;

  // Run generators
  return Promise.map(Object.keys(generators), key => {
    const generator = generators[key];

    return Reflect.apply(generator, this, [siteLocals]).then(data => {
      log.debug('Generator: %s', chalk.magenta(key));
      return data;
    });
  }).reduce((result, data) => {
    return data ? result.concat(data) : result;
  }, []);
};

const routeCache = new WeakMap();

const unique = array => array.filter((item, index, self) => self.indexOf(item) === index);

const castArray = obj => { return Array.isArray(obj) ? obj : [obj]; };

const createLoadThemeRoute = function(generatorResult, locals, ctx) {
  const { log, theme } = ctx;
  const { path, cache: useCache } = locals;

  const layout = unique(castArray(generatorResult.layout));
  const layoutLength = layout.length;

  // allways use cache in fragment_cache
  locals.cache = true;
  return () => {
    if (useCache && routeCache.has(generatorResult)) return routeCache.get(generatorResult);

    for (let i = 0; i < layoutLength; i++) {
      const name = layout[i];
      const view = theme.getView(name);

      if (view) {
        log.debug(`Rendering HTML ${name}: ${chalk.magenta(path)}`);
        return view.render(locals).tap(result => {
          if (useCache) {
            routeCache.set(generatorResult, result);
          }
        }).tapCatch(err => {
          log.error({ err }, `Render HTML failed: ${chalk.magenta(path)}`);
        });
      }
    }

    log.warn(`No layout: ${chalk.magenta(path)}`);
  };
};

Hexo.prototype._routerReflesh = function(runningGenerators, useCache) {
  const { route } = this;
  const routeList = route.list();
  const Locals = this._generateLocals();
  Locals.prototype.cache = useCache;

  return runningGenerators.map(generatorResult => {
    if (typeof generatorResult !== 'object' || generatorResult.path == null) return undefined;

    // add Route
    const path = route.format(generatorResult.path);
    const { data, layout } = generatorResult;

    if (!layout) {
      route.set(path, data);
      return path;
    }

    return this.execFilter('template_locals', new Locals(path, data), {context: this})
      .then(locals => { route.set(path, createLoadThemeRoute(generatorResult, locals, this)); })
      .thenReturn(path);
  }).then(newRouteList => {
    // Remove old routes
    const removed = routeList.filter(item => !newRouteList.includes(item));

    for (let i = 0, len = removed.length; i < len; i++) {
      route.remove(removed[i]);
    }
  });
};

Hexo.prototype._generate = function(options = {}) {
  if (this._isGenerating) return;

  const useCache = options.cache;

  this._isGenerating = true;

  this.emit('generateBefore');

  // Run before_generate filters
  return this.execFilter('before_generate', this.locals.get('data'), {context: this})
    .then(() => this._routerReflesh(this._runGenerators(), useCache)).then(() => {
      this.emit('generateAfter');

      // Run after_generate filters
      return this.execFilter('after_generate', null, {context: this});
    }).finally(() => {
      this._isGenerating = false;
    });
};

Hexo.prototype.exit = function(err) {
  if (err) {
    this.log.fatal(
      {err},
      'Something\'s wrong. Maybe you can find the solution here: %s',
      chalk.underline('https://hexo.io/docs/troubleshooting.html')
    );
  }

  return this.execFilter('before_exit', null, {context: this}).then(() => {
    this.emit('exit', err);
  });
};

Hexo.prototype.execFilter = function(type, data, options) {
  return this.extend.filter.exec(type, data, options);
};

Hexo.prototype.execFilterSync = function(type, data, options) {
  return this.extend.filter.execSync(type, data, options);
};

Hexo.lib_dir = Hexo.prototype.lib_dir = libDir + sep;

Hexo.core_dir = Hexo.prototype.core_dir = dirname(libDir) + sep;

Hexo.version = Hexo.prototype.version = pkg.version;

module.exports = Hexo;

1	'use strict';
2
3	const Promise = require('bluebird');	3✔
4	const { sep, join, dirname } = require('path');	3✔
5	const tildify = require('tildify');	3✔
6	const Database = require('warehouse');	3✔
7	const _ = require('lodash');	3✔
8	const chalk = require('chalk');	3✔
9	const { EventEmitter } = require('events');	3✔
10	const fs = require('hexo-fs');	3✔
11	const Module = require('module');	3✔
12	const vm = require('vm');	3✔
13	const pkg = require('../../package.json');	3✔
14	const logger = require('hexo-log');	3✔
15	const extend = require('../extend');	3✔
16	const Render = require('./render');	3✔
17	const registerModels = require('./register_models');	3✔
18	const Post = require('./post');	3✔
19	const Scaffold = require('./scaffold');	3✔
20	const Source = require('./source');	3✔
21	const Router = require('./router');	3✔
22	const Theme = require('../theme');	3✔
23	const Locals = require('./locals');	3✔
24	const defaultConfig = require('./default_config');	3✔
25	const loadDatabase = require('./load_database');	3✔
26	const multiConfigPath = require('./multi_config_path');	3✔
27	const resolve = require('resolve');	3✔
28	const full_url_for = require('../plugins/helper/full_url_for');	3✔
29
30	const { cloneDeep, debounce } = _;	3✔
31
32	const libDir = dirname(__dirname);	3✔
33	const dbVersion = 1;	3✔
34
35	function Hexo(base = process.cwd(), args = {}) {	246✔
36	Reflect.apply(EventEmitter, this, []);	369✔
37
38	this.base_dir = base + sep;	369✔
39	this.public_dir = join(base, 'public') + sep;	369✔
40	this.source_dir = join(base, 'source') + sep;	369✔
41	this.plugin_dir = join(base, 'node_modules') + sep;	369✔
42	this.script_dir = join(base, 'scripts') + sep;	369✔
43	this.scaffold_dir = join(base, 'scaffolds') + sep;	369✔
44	this.theme_dir = join(base, 'themes', defaultConfig.theme) + sep;	369✔
45	this.theme_script_dir = join(this.theme_dir, 'scripts') + sep;	369✔
46
47	this.env = {	369✔
48	args,
49	debug: Boolean(args.debug),
50	safe: Boolean(args.safe),
51	silent: Boolean(args.silent),
52	env: process.env.NODE_ENV \|\| 'development',	738✔
53	version: pkg.version,
54	cmd: args._ ? args._[0] : '',	369✔
55	init: false
56	};
57
58	this.extend = {	369✔
59	console: new extend.Console(),
60	deployer: new extend.Deployer(),
61	filter: new extend.Filter(),
62	generator: new extend.Generator(),
63	helper: new extend.Helper(),
64	migrator: new extend.Migrator(),
65	processor: new extend.Processor(),
66	renderer: new extend.Renderer(),
67	tag: new extend.Tag()
68	};
69
70	this.config = cloneDeep(defaultConfig);	369✔
71
72	this.log = logger(this.env);	369✔
73
74	this.render = new Render(this);	369✔
75
76	this.route = new Router();	369✔
77
78	this.post = new Post(this);	369✔
79
80	this.scaffold = new Scaffold(this);	369✔
81
82	this._dbLoaded = false;	369✔
83
84	this._isGenerating = false;	369✔
85
86	// If `output` is provided, use that as the
87	// root for saving the db. Otherwise default to `base`.
88	const dbPath = args.output \|\| base;	369✔
89
90	this.log.d(`Writing database to ${dbPath}/db.json`);	369✔
91
92	this.database = new Database({	369✔
93	version: dbVersion,
94	path: join(dbPath, 'db.json')
95	});
96
97	const mcp = multiConfigPath(this);	369✔
98
99	this.config_path = args.config ? mcp(base, args.config, args.output) :	369✔
100	join(base, '_config.yml');
101
102	registerModels(this);	369✔
103
104	this.source = new Source(this);	369✔
105	this.theme = new Theme(this);	369✔
106	this.locals = new Locals(this);	369✔
107	this._bindLocals();	369✔
108	}
109
110	require('util').inherits(Hexo, EventEmitter);	3✔
111
112	Hexo.prototype._bindLocals = function() {	3✔
113	const db = this.database;	369✔
114	const { locals } = this;	369✔
115
116	locals.set('posts', () => {	369✔
117	const query = {};	246✔
118
119	if (!this.config.future) {	246✔
120	query.date = {$lte: Date.now()};	51✔
121	}
122
123	if (!this._showDrafts()) {	246✔
124	query.published = true;	237✔
125	}
126
127	return db.model('Post').find(query);	246✔
128	});
129
130	locals.set('pages', () => {	369✔
131	const query = {};	171✔
132
133	if (!this.config.future) {	171✔
134	query.date = {$lte: Date.now()};	45✔
135	}
136
137	return db.model('Page').find(query);	171✔
138	});
139
140	locals.set('categories', () => {	369✔
141	// Ignore categories with zero posts
142	return db.model('Category').filter(category => category.length);	165✔
143	});
144
145	locals.set('tags', () => {	369✔
146	// Ignore tags with zero posts
147	return db.model('Tag').filter(tag => tag.length);	165✔
148	});
149
150	locals.set('data', () => {	369✔
151	const obj = {};	210✔
152
153	db.model('Data').forEach(data => {	210✔
154	obj[data._id] = data.data;	6✔
155	});
156
157	return obj;	210✔
158	});
159	};
160
161	Hexo.prototype.init = function() {	3✔
162	this.log.debug('Hexo version: %s', chalk.magenta(this.version));	186✔
163	this.log.debug('Working directory: %s', chalk.magenta(tildify(this.base_dir)));	186✔
164
165	// Load internal plugins
166	require('../plugins/console')(this);	186✔
167	require('../plugins/filter')(this);	186✔
168	require('../plugins/generator')(this);	186✔
169	require('../plugins/helper')(this);	186✔
170	require('../plugins/processor')(this);	186✔
171	require('../plugins/renderer')(this);	186✔
172	require('../plugins/tag')(this);	186✔
173
174	// Load config
175	return Promise.each([	186✔
176	'update_package', // Update package.json
177	'load_config', // Load config
178	'load_plugins' // Load external plugins & scripts
179	], name => require(`./${name}`)(this)).then(() => this.execFilter('after_init', null, {context: this})).then(() => {	558✔
180	// Ready to go!
181	this.emit('ready');	186✔
182	});
183	};
184
185	Hexo.prototype.call = function(name, args, callback) {	3✔
186	if (!callback && typeof args === 'function') {	21✔
187	callback = args;	3✔
188	args = {};	3✔
189	}
190
191	return new Promise((resolve, reject) => {	21✔
192	const c = this.extend.console.get(name);	21✔
193
194	if (c) {	21✔
195	Reflect.apply(c, this, [args]).then(resolve, reject);	18✔
196	} else {
197	reject(new Error(`Console \`${name}\` has not been registered yet!`));	3✔
198	}
199	}).asCallback(callback);
200	};
201
202	Hexo.prototype.model = function(name, schema) {	3✔
203	return this.database.model(name, schema);	7,434✔
204	};
205
206	Hexo.prototype.resolvePlugin = function(name) {	3✔
207	const baseDir = this.base_dir;	39✔
208
209	try {	39✔
210	// Try to resolve the plugin with the resolve.sync.
211	return resolve.sync(name, { basedir: baseDir });	39✔
212	} catch (err) {
213	// There was an error (likely the plugin wasn't found), so return a possibly
214	// non-existing path that a later part of the resolution process will check.
215	return join(baseDir, 'node_modules', name);	18✔
216	}
217	};
218
219	Hexo.prototype.loadPlugin = function(path, callback) {	3✔
220	return fs.readFile(path).then(script => {	42✔
221	// Based on: https://github.com/joyent/node/blob/v0.10.33/src/node.js#L516
222	const module = new Module(path);	33✔
223	module.filename = path;	33✔
224	module.paths = Module._nodeModulePaths(path);	33✔
225
226	function require(path) {
227	return module.require(path);	15✔
228	}
229
230	require.resolve = request => Module._resolveFilename(request, module);	33✔
231
232	require.main = process.mainModule;	33✔
233	require.extensions = Module._extensions;	33✔
234	require.cache = Module._cache;	33✔
235
236	script = `(function(exports, require, module, __filename, __dirname, hexo){${script}});`;	33✔
237
238	const fn = vm.runInThisContext(script, path);	33✔
239
240	return fn(module.exports, require, module, path, dirname(path), this);	33✔
241	}).asCallback(callback);
242	};
243
244	Hexo.prototype._showDrafts = function() {	3✔
245	const { args } = this.env;	258✔
246	return args.draft \|\| args.drafts \|\| this.config.render_drafts;	258✔
247	};
248
249	Hexo.prototype.load = function(callback) {	3✔
250	return loadDatabase(this).then(() => {	57✔
251	this.log.info('Start processing');	57✔
252
253	return Promise.all([	57✔
254	this.source.process(),
255	this.theme.process()
256	]);
257	}).then(() => this._generate({cache: false})).asCallback(callback);	57✔
258	};
259
260	Hexo.prototype.watch = function(callback) {	3✔
261	let useCache = false;	12✔
262	if (this.env.cmd.startsWith('s')) {	12!
263	// enable cache when run hexo server
264	useCache = true;	×
265	}
266	this._watchBox = debounce(() => this._generate({cache: useCache}), 100);	12✔
267
268	return loadDatabase(this).then(() => {	12✔
269	this.log.info('Start processing');	12✔
270
271	return Promise.all([	12✔
272	this.source.watch(),
273	this.theme.watch()
274	]);
275	}).then(() => {
276	this.source.on('processAfter', this._watchBox);	12✔
277	this.theme.on('processAfter', this._watchBox);	12✔
278
279	return this._generate({cache: useCache});	12✔
280	}).asCallback(callback);
281	};
282
283	Hexo.prototype.unwatch = function() {	3✔
284	if (this._watchBox != null) {	12!
285	this.source.removeListener('processAfter', this._watchBox);	12✔
286	this.theme.removeListener('processAfter', this._watchBox);	12✔
287
288	this._watchBox = null;	12✔
289	}
290
291	stopWatcher(this.source);	12✔
292	stopWatcher(this.theme);	12✔
293	};
294
295	function stopWatcher(box) {
296	if (box.isWatching()) box.unwatch();	24!
297	}
298
299	Hexo.prototype._generateLocals = function() {	3✔
300	const { config, theme } = this;	123✔
301	const ctx = { config: { url: this.config.url } };	123✔
302
303	function Locals(path, locals) {
304	this.page = typeof locals === 'object' ? locals : {};	42✔
305	if (this.page.path == null) this.page.path = path;	42!
306
307	this.path = path;	42✔
308	this.url = full_url_for.call(ctx, path);	42✔
309	}
310
311	Locals.prototype.config = config;	123✔
312	Locals.prototype.theme = Object.assign({}, config, theme.config, config.theme_config);	123✔
313	Locals.prototype._ = _;	123✔
314	Locals.prototype.layout = 'layout';	123✔
315	Locals.prototype.env = this.env;	123✔
316	Locals.prototype.view_dir = join(this.theme_dir, 'layout') + sep;	123✔
317	Locals.prototype.site = this.locals.toObject();	123✔
318
319	return Locals;	123✔
320	};
321
322	Hexo.prototype._runGenerators = function() {	3✔
323	this.locals.invalidate();	123✔
324	const siteLocals = this.locals.toObject();	123✔
325	const generators = this.extend.generator.list();	123✔
326	const { log } = this;	123✔
327
328	// Run generators
329	return Promise.map(Object.keys(generators), key => {	123✔
330	const generator = generators[key];	264✔
331
332	return Reflect.apply(generator, this, [siteLocals]).then(data => {	264✔
333	log.debug('Generator: %s', chalk.magenta(key));	264✔
334	return data;	264✔
335	});
336	}).reduce((result, data) => {
337	return data ? result.concat(data) : result;	264✔
338	}, []);
339	};
340
341	const routeCache = new WeakMap();	3✔
342
343	const unique = array => array.filter((item, index, self) => self.indexOf(item) === index);	48✔
344
345	const castArray = obj => { return Array.isArray(obj) ? obj : [obj]; };	42✔
346
347	const createLoadThemeRoute = function(generatorResult, locals, ctx) {	3✔
348	const { log, theme } = ctx;	42✔
349	const { path, cache: useCache } = locals;	42✔
350
351	const layout = unique(castArray(generatorResult.layout));	42✔
352	const layoutLength = layout.length;	42✔
353
354	// allways use cache in fragment_cache
355	locals.cache = true;	42✔
356	return () => {	42✔
357	if (useCache && routeCache.has(generatorResult)) return routeCache.get(generatorResult);	60✔
358
359	for (let i = 0; i < layoutLength; i++) {	51✔
360	const name = layout[i];	57✔
361	const view = theme.getView(name);	57✔
362
363	if (view) {	57✔
364	log.debug(`Rendering HTML ${name}: ${chalk.magenta(path)}`);	48✔
365	return view.render(locals).tap(result => {	48✔
366	if (useCache) {	39✔
367	routeCache.set(generatorResult, result);	9✔
368	}
369	}).tapCatch(err => {
370	log.error({ err }, `Render HTML failed: ${chalk.magenta(path)}`);	9✔
371	});
372	}
373	}
374
375	log.warn(`No layout: ${chalk.magenta(path)}`);	3✔
376	};
377	};
378
379	Hexo.prototype._routerReflesh = function(runningGenerators, useCache) {	3✔
380	const { route } = this;	123✔
381	const routeList = route.list();	123✔
382	const Locals = this._generateLocals();	123✔
383	Locals.prototype.cache = useCache;	123✔
384
385	return runningGenerators.map(generatorResult => {	123✔
386	if (typeof generatorResult !== 'object' \|\| generatorResult.path == null) return undefined;	141!
387
388	// add Route
389	const path = route.format(generatorResult.path);	141✔
390	const { data, layout } = generatorResult;	141✔
391
392	if (!layout) {	141✔
393	route.set(path, data);	99✔
394	return path;	99✔
395	}
396
397	return this.execFilter('template_locals', new Locals(path, data), {context: this})	42✔
398	.then(locals => { route.set(path, createLoadThemeRoute(generatorResult, locals, this)); })	42✔
399	.thenReturn(path);
400	}).then(newRouteList => {
401	// Remove old routes
402	const removed = routeList.filter(item => !newRouteList.includes(item));	123✔
403
404	for (let i = 0, len = removed.length; i < len; i++) {	123✔
405	route.remove(removed[i]);	12✔
406	}
407	});
408	};
409
410	Hexo.prototype._generate = function(options = {}) {	3✔
411	if (this._isGenerating) return;	126✔
412
413	const useCache = options.cache;	123✔
414
415	this._isGenerating = true;	123✔
416
417	this.emit('generateBefore');	123✔
418
419	// Run before_generate filters
420	return this.execFilter('before_generate', this.locals.get('data'), {context: this})	123✔
421	.then(() => this._routerReflesh(this._runGenerators(), useCache)).then(() => {	123✔
422	this.emit('generateAfter');	123✔
423
424	// Run after_generate filters
425	return this.execFilter('after_generate', null, {context: this});	123✔
426	}).finally(() => {
427	this._isGenerating = false;	123✔
428	});
429	};
430
431	Hexo.prototype.exit = function(err) {	3✔
432	if (err) {	9✔
433	this.log.fatal(	6✔
434	{err},
435	'Something\'s wrong. Maybe you can find the solution here: %s',
436	chalk.underline('https://hexo.io/docs/troubleshooting.html')
437	);
438	}
439
440	return this.execFilter('before_exit', null, {context: this}).then(() => {	9✔
441	this.emit('exit', err);	9✔
442	});
443	};
444
445	Hexo.prototype.execFilter = function(type, data, options) {	3✔
446	return this.extend.filter.exec(type, data, options);	975✔
447	};
448
449	Hexo.prototype.execFilterSync = function(type, data, options) {	3✔
450	return this.extend.filter.execSync(type, data, options);	753✔
451	};
452
453	Hexo.lib_dir = Hexo.prototype.lib_dir = libDir + sep;	3✔
454
455	Hexo.core_dir = Hexo.prototype.core_dir = dirname(libDir) + sep;	3✔
456
457	Hexo.version = Hexo.prototype.version = pkg.version;	3✔
458
459	module.exports = Hexo;	3✔

hexojs / hexo / 1977

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous