_id
stringlengths 2
6
| title
stringlengths 0
58
| partition
stringclasses 3
values | text
stringlengths 52
373k
| language
stringclasses 1
value | meta_information
dict |
|---|---|---|---|---|---|
q16000
|
onResize
|
train
|
function onResize(cm) {
let d = cm.display
// Might be a text scaling operation, clear size caches.
d.cachedCharWidth = d.cachedTextHeight = d.cachedPaddingH = null
d.scrollbarsClipped = false
cm.setSize()
}
|
javascript
|
{
"resource": ""
}
|
q16001
|
makeChangeSingleDocInEditor
|
train
|
function makeChangeSingleDocInEditor(cm, change, spans) {
let doc = cm.doc, display = cm.display, from = change.from, to = change.to
let recomputeMaxLength = false, checkWidthStart = from.line
if (!cm.options.lineWrapping) {
checkWidthStart = lineNo(visualLine(getLine(doc, from.line)))
doc.iter(checkWidthStart, to.line + 1, line => {
if (line == display.maxLine) {
recomputeMaxLength = true
return true
}
})
}
if (doc.sel.contains(change.from, change.to) > -1)
signalCursorActivity(cm)
updateDoc(doc, change, spans, estimateHeight(cm))
if (!cm.options.lineWrapping) {
doc.iter(checkWidthStart, from.line + change.text.length, line => {
let len = lineLength(line)
if (len > display.maxLineLength) {
display.maxLine = line
display.maxLineLength = len
display.maxLineChanged = true
recomputeMaxLength = false
}
})
if (recomputeMaxLength) cm.curOp.updateMaxLine = true
}
retreatFrontier(doc, from.line)
startWorker(cm, 400)
let lendiff = change.text.length - (to.line - from.line) - 1
// Remember that these lines changed, for updating the display
if (change.full)
regChange(cm)
else if (from.line == to.line && change.text.length == 1 && !isWholeLineUpdate(cm.doc, change))
regLineChange(cm, from.line, "text")
else
regChange(cm, from.line, to.line + 1, lendiff)
let changesHandler = hasHandler(cm, "changes"), changeHandler = hasHandler(cm, "change")
if (changeHandler || changesHandler) {
let obj = {
from: from, to: to,
text: change.text,
removed: change.removed,
origin: change.origin
}
if (changeHandler) signalLater(cm, "change", cm, obj)
if (changesHandler) (cm.curOp.changeObjs || (cm.curOp.changeObjs = [])).push(obj)
}
cm.display.selForContextMenu = null
}
|
javascript
|
{
"resource": ""
}
|
q16002
|
actPolyfill
|
train
|
function actPolyfill(cb) {
ReactDOM.unstable_batchedUpdates(cb)
ReactDOM.render(<div />, document.createElement('div'))
}
|
javascript
|
{
"resource": ""
}
|
q16003
|
asyncActPolyfill
|
train
|
async function asyncActPolyfill(cb) {
// istanbul-ignore-next
if (
!youHaveBeenWarned &&
actSupported &&
reactDomSixteenPointNineIsReleased
) {
// if act is supported and async act isn't and they're trying to use async
// act, then they need to upgrade from 16.8 to 16.9.
// This is a seemless upgrade, so we'll add a warning
console.error(
`It looks like you're using a version of react-dom that supports the "act" function, but not an awaitable version of "act" which you will need. Please upgrade to at least react-dom@16.9.0 to remove this warning.`,
)
youHaveBeenWarned = true
}
await cb()
// make all effects resolve after
act(() => {})
}
|
javascript
|
{
"resource": ""
}
|
q16004
|
readPackageVersion
|
train
|
function readPackageVersion(root) {
let pkg = JSON.parse(fs.readFileSync(path.join(root, 'package.json'), 'utf8'));
// use _originalVersion if present if we've already mutated it
return pkg._originalVersion || pkg.version;
}
|
javascript
|
{
"resource": ""
}
|
q16005
|
getNumStr
|
train
|
function getNumStr(num, fixed = 4) {
let numStr = '';
if (typeof num != "number") {
num = Number(num);
if (isNaN(num)) {
// console.log("Pushbullet Plugin: Number Conversion Failed");
return "Conversion Failure";
}
}
if (Number.isInteger(num)) {
numStr = num.toString();
} else {
//Create modNum Max - Must be a better way...
let modNumMax = '1';
for (let i = 1; i < fixed; i++) {
modNumMax = modNumMax + '0';
}
modNumMax = Number(modNumMax);
let i = 0;
if (num < 1) {
let modNum = num - Math.floor(num);
while (modNum < modNumMax && i < 8) {
modNum *= 10;
i += 1;
}
} else {
i = fixed;
}
numStr = num.toFixed(i);
//Remove any excess zeros
while (numStr.charAt(numStr.length - 1) === '0') {
numStr = numStr.substring(0, numStr.length - 1);
}
//If last char remaining is a decimal point, remove it
if (numStr.charAt(numStr.length - 1) === '.') {
numStr = numStr.substring(0, numStr.length - 1);
}
}
//Add commas for thousands etc
let dp = numStr.indexOf('.'); //find deciaml point
if (dp < 0) { //no dp found
dp = numStr.length;
}
let insPos = dp - 3;
insCount = 0;
while (insPos > 0) {
insCount++;
numStr = numStr.slice(0, insPos) + ',' + numStr.slice(insPos);
insPos -= 3;
}
return (numStr);
}
|
javascript
|
{
"resource": ""
}
|
q16006
|
humanizer
|
train
|
function humanizer (passedOptions) {
var result = function humanizer (ms, humanizerOptions) {
var options = extend({}, result, humanizerOptions || {})
return doHumanization(ms, options)
}
return extend(result, {
language: 'en',
delimiter: ', ',
spacer: ' ',
conjunction: '',
serialComma: true,
units: ['y', 'mo', 'w', 'd', 'h', 'm', 's'],
languages: {},
round: false,
unitMeasures: {
y: 31557600000,
mo: 2629800000,
w: 604800000,
d: 86400000,
h: 3600000,
m: 60000,
s: 1000,
ms: 1
}
}, passedOptions)
}
|
javascript
|
{
"resource": ""
}
|
q16007
|
train
|
function(from, to) {
config.backtest.daterange = {
from: moment.unix(from).utc().format(),
to: moment.unix(to).utc().format(),
};
util.setConfig(config);
}
|
javascript
|
{
"resource": ""
}
|
|
q16008
|
train
|
function (name) {
if (useSingleDatabase()) {
name = watch.exchange.replace(/\-/g,'') + '_' + name;
}
var fullName = [name, settings.pair.join('_')].join('_');
return useLowerCaseTableNames() ? fullName.toLowerCase() : fullName;
}
|
javascript
|
{
"resource": ""
}
|
|
q16009
|
lexicalDistance
|
train
|
function lexicalDistance(aStr, bStr) {
if (aStr === bStr) {
return 0;
}
let i;
let j;
const d = [];
const a = aStr.toLowerCase();
const b = bStr.toLowerCase();
const aLength = a.length;
const bLength = b.length;
// Any case change counts as a single edit
if (a === b) {
return 1;
}
for (i = 0; i <= aLength; i++) {
d[i] = [i];
}
for (j = 1; j <= bLength; j++) {
d[0][j] = j;
}
for (i = 1; i <= aLength; i++) {
for (j = 1; j <= bLength; j++) {
const cost = a[i - 1] === b[j - 1] ? 0 : 1;
d[i][j] = Math.min(
d[i - 1][j] + 1,
d[i][j - 1] + 1,
d[i - 1][j - 1] + cost,
);
if (i > 1 && j > 1 && a[i - 1] === b[j - 2] && a[i - 2] === b[j - 1]) {
d[i][j] = Math.min(d[i][j], d[i - 2][j - 2] + cost);
}
}
}
return d[aLength][bLength];
}
|
javascript
|
{
"resource": ""
}
|
q16010
|
hashForRevision
|
train
|
function hashForRevision(revision) {
const out = execSync(`git rev-parse "${revision}"`, { encoding: 'utf8' });
const match = /[0-9a-f]{8,40}/.exec(out);
if (!match) {
throw new Error(`Bad results for revision ${revision}: ${out}`);
}
return match[0];
}
|
javascript
|
{
"resource": ""
}
|
q16011
|
prepareAndRunBenchmarks
|
train
|
function prepareAndRunBenchmarks(benchmarkPatterns, revisions) {
// Find all benchmark tests to be run.
let benchmarks = findFiles(LOCAL_DIR('src'), '*/__tests__/*-benchmark.js');
if (benchmarkPatterns.length !== 0) {
benchmarks = benchmarks.filter(benchmark =>
benchmarkPatterns.some(pattern =>
path.join('src', benchmark).includes(pattern)
)
);
}
if (benchmarks.length === 0) {
console.warn(
'No benchmarks matching: ' +
`\u001b[1m${benchmarkPatterns.join('\u001b[0m or \u001b[1m')}\u001b[0m`
);
return;
}
const environments = revisions.map(revision => ({
revision,
distPath: prepareRevision(revision),
}));
benchmarks.forEach(benchmark => runBenchmark(benchmark, environments));
}
|
javascript
|
{
"resource": ""
}
|
q16012
|
moveArticle
|
train
|
function moveArticle(summary, origin, target) {
// Coerce to level
var originLevel = is.string(origin)? origin : origin.getLevel();
var targetLevel = is.string(target)? target : target.getLevel();
var article = summary.getByLevel(originLevel);
// Remove first
var removed = removeArticle(summary, originLevel);
return insertArticle(removed, article, targetLevel);
}
|
javascript
|
{
"resource": ""
}
|
q16013
|
hasPlugin
|
train
|
function hasPlugin(deps, pluginName, version) {
return !!deps.find(function(dep) {
return dep.getName() === pluginName && (!version || dep.getVersion() === version);
});
}
|
javascript
|
{
"resource": ""
}
|
q16014
|
onPage
|
train
|
function onPage(output, page) {
var options = output.getOptions();
// Inline assets
return Modifiers.modifyHTML(page, [
Modifiers.inlineAssets(options.get('root'), page.getFile().getPath())
])
// Write page using website generator
.then(function(resultPage) {
return WebsiteGenerator.onPage(output, resultPage);
});
}
|
javascript
|
{
"resource": ""
}
|
q16015
|
pluginType
|
train
|
function pluginType(plugin) {
var name = plugin.getName();
return (name && name.indexOf(THEME_PREFIX) === 0) ? TYPE_THEME : TYPE_PLUGIN;
}
|
javascript
|
{
"resource": ""
}
|
q16016
|
sortDependencies
|
train
|
function sortDependencies(plugins) {
var byTypes = plugins.groupBy(pluginType);
return byTypes.get(TYPE_PLUGIN, Immutable.List())
.concat(byTypes.get(TYPE_THEME, Immutable.List()));
}
|
javascript
|
{
"resource": ""
}
|
q16017
|
listDependencies
|
train
|
function listDependencies(deps) {
// Extract list of plugins to disable (starting with -)
var toRemove = deps
.filter(function(plugin) {
return !plugin.isEnabled();
})
.map(function(plugin) {
return plugin.getName();
});
// Concat with default plugins
deps = deps.concat(DEFAULT_PLUGINS);
// Remove plugins
deps = deps.filterNot(function(plugin) {
return toRemove.includes(plugin.getName());
});
// Sort
return sortDependencies(deps);
}
|
javascript
|
{
"resource": ""
}
|
q16018
|
writeSummary
|
train
|
function writeSummary(output) {
var options = output.getOptions();
var prefix = options.get('prefix');
var filePath = SUMMARY_FILE;
var engine = WebsiteGenerator.createTemplateEngine(output, filePath);
var context = JSONUtils.encodeOutput(output);
// Render the theme
return Templating.renderFile(engine, prefix + '/summary.html', context)
// Write it to the disk
.then(function(tplOut) {
return writeFile(output, filePath, tplOut.getContent());
});
}
|
javascript
|
{
"resource": ""
}
|
q16019
|
runEbookConvert
|
train
|
function runEbookConvert(output) {
var logger = output.getLogger();
var options = output.getOptions();
var format = options.get('format');
var outputFolder = output.getRoot();
if (!format) {
return Promise(output);
}
return getConvertOptions(output)
.then(function(options) {
var cmd = [
'ebook-convert',
path.resolve(outputFolder, SUMMARY_FILE),
path.resolve(outputFolder, 'index.' + format),
command.optionsToShellArgs(options)
].join(' ');
return command.exec(cmd)
.progress(function(data) {
logger.debug(data);
})
.fail(function(err) {
if (err.code == 127) {
throw error.RequireInstallError({
cmd: 'ebook-convert',
install: 'Install it from Calibre: https://calibre-ebook.com'
});
}
throw error.EbookError(err);
});
})
.thenResolve(output);
}
|
javascript
|
{
"resource": ""
}
|
q16020
|
validatePlugin
|
train
|
function validatePlugin(plugin) {
var packageInfos = plugin.getPackage();
var isValid = (
plugin.isLoaded() &&
packageInfos &&
packageInfos.get('name') &&
packageInfos.get('engines') &&
packageInfos.get('engines').get('gitbook')
);
if (!isValid) {
return Promise.reject(new Error('Error loading plugin "' + plugin.getName() + '" at "' + plugin.getPath() + '"'));
}
var engine = packageInfos.get('engines').get('gitbook');
if (!gitbook.satisfies(engine)) {
return Promise.reject(new Error('GitBook doesn\'t satisfy the requirements of this plugin: ' + engine));
}
return Promise(plugin);
}
|
javascript
|
{
"resource": ""
}
|
q16021
|
applyShortcut
|
train
|
function applyShortcut(content, shortcut) {
var start = shortcut.getStart();
var end = shortcut.getEnd();
var tagStart = shortcut.getStartTag();
var tagEnd = shortcut.getEndTag();
var regex = new RegExp(
escapeStringRegexp(start) + '([\\s\\S]*?[^\\$])' + escapeStringRegexp(end),
'g'
);
return content.replace(regex, function(all, match) {
return '{% ' + tagStart + ' %}' + match + '{% ' + tagEnd + ' %}';
});
}
|
javascript
|
{
"resource": ""
}
|
q16022
|
replaceShortcuts
|
train
|
function replaceShortcuts(blocks, filePath, content) {
var shortcuts = listShortcuts(blocks, filePath);
return shortcuts.reduce(applyShortcut, content);
}
|
javascript
|
{
"resource": ""
}
|
q16023
|
validatePluginConfig
|
train
|
function validatePluginConfig(book, plugin) {
var config = book.getConfig();
var packageInfos = plugin.getPackage();
var configKey = [
'pluginsConfig',
plugin.getName()
].join('.');
var pluginConfig = config.getValue(configKey, {}).toJS();
var schema = (packageInfos.get('gitbook') || Immutable.Map()).toJS();
if (!schema) return book;
// Normalize schema
schema.id = '/' + configKey;
schema.type = 'object';
// Validate and throw if invalid
var v = new jsonschema.Validator();
var result = v.validate(pluginConfig, schema, {
propertyName: configKey
});
// Throw error
if (result.errors.length > 0) {
throw new error.ConfigurationError(new Error(result.errors[0].stack));
}
// Insert default values
var defaults = jsonSchemaDefaults(schema);
pluginConfig = mergeDefaults(pluginConfig, defaults);
// Update configuration
config = config.setValue(configKey, pluginConfig);
// Return new book
return book.set('config', config);
}
|
javascript
|
{
"resource": ""
}
|
q16024
|
validateConfig
|
train
|
function validateConfig(book, plugins) {
return Promise.reduce(plugins, function(newBook, plugin) {
return validatePluginConfig(newBook, plugin);
}, book);
}
|
javascript
|
{
"resource": ""
}
|
q16025
|
insertArticle
|
train
|
function insertArticle(summary, article, level) {
article = SummaryArticle(article);
level = is.string(level)? level : level.getLevel();
var parent = summary.getParent(level);
if (!parent) {
return summary;
}
// Find the index to insert at
var articles = parent.getArticles();
var index = getLeafIndex(level);
// Insert the article at the right index
articles = articles.insert(index, article);
// Reindex the level from here
parent = parent.set('articles', articles);
parent = indexArticleLevels(parent);
return mergeAtLevel(summary, parent.getLevel(), parent);
}
|
javascript
|
{
"resource": ""
}
|
q16026
|
listBlocks
|
train
|
function listBlocks(plugins) {
return plugins
.reverse()
.reduce(function(result, plugin) {
var blocks = plugin.getBlocks();
return result.merge(blocks);
}, Immutable.Map());
}
|
javascript
|
{
"resource": ""
}
|
q16027
|
parseConfig
|
train
|
function parseConfig(book) {
var fs = book.getFS();
var config = book.getConfig();
return Promise.some(CONFIG_FILES, function(filename) {
// Is this file ignored?
if (book.isFileIgnored(filename)) {
return;
}
// Try loading it
return fs.loadAsObject(filename)
.then(function(cfg) {
return fs.statFile(filename)
.then(function(file) {
return {
file: file,
values: cfg
};
});
})
.fail(function(err) {
if (err.code != 'MODULE_NOT_FOUND') throw(err);
else return Promise(false);
});
})
.then(function(result) {
var values = result? result.values : {};
values = validateConfig(values);
// Set the file
if (result.file) {
config = config.setFile(result.file);
}
// Merge with old values
config = config.mergeValues(values);
return book.setConfig(config);
});
}
|
javascript
|
{
"resource": ""
}
|
q16028
|
parseFilePage
|
train
|
function parseFilePage(book, filePath) {
var fs = book.getContentFS();
return fs.statFile(filePath)
.then(
function(file) {
var page = Page.createForFile(file);
return parsePage(book, page);
},
function(err) {
// file doesn't exist
return null;
}
)
.fail(function(err) {
var logger = book.getLogger();
logger.error.ln('error while parsing page "' + filePath + '":');
throw err;
});
}
|
javascript
|
{
"resource": ""
}
|
q16029
|
parsePagesList
|
train
|
function parsePagesList(book) {
var summary = book.getSummary();
var glossary = book.getGlossary();
var map = Immutable.OrderedMap();
// Parse pages from summary
return timing.measure(
'parse.listPages',
walkSummary(summary, function(article) {
if (!article.isPage()) return;
var filepath = article.getPath();
// Is the page ignored?
if (book.isContentFileIgnored(filepath)) return;
return parseFilePage(book, filepath)
.then(function(page) {
// file doesn't exist
if (!page) {
return;
}
map = map.set(filepath, page);
});
})
)
// Parse glossary
.then(function() {
var file = glossary.getFile();
if (!file.exists()) {
return;
}
return parseFilePage(book, file.getPath())
.then(function(page) {
// file doesn't exist
if (!page) {
return;
}
map = map.set(file.getPath(), page);
});
})
.then(function() {
return map;
});
}
|
javascript
|
{
"resource": ""
}
|
q16030
|
walkArticles
|
train
|
function walkArticles(articles, fn) {
return Promise.forEach(articles, function(article) {
return Promise(fn(article))
.then(function() {
return walkArticles(article.getArticles(), fn);
});
});
}
|
javascript
|
{
"resource": ""
}
|
q16031
|
walkSummary
|
train
|
function walkSummary(summary, fn) {
var parts = summary.getParts();
return Promise.forEach(parts, function(part) {
return walkArticles(part.getArticles(), fn);
});
}
|
javascript
|
{
"resource": ""
}
|
q16032
|
insertPart
|
train
|
function insertPart(summary, part, index) {
part = SummaryPart(part);
var parts = summary.getParts().insert(index, part);
return indexLevels(summary.set('parts', parts));
}
|
javascript
|
{
"resource": ""
}
|
q16033
|
prepareI18n
|
train
|
function prepareI18n(output) {
var state = output.getState();
var i18n = state.getI18n();
var searchPaths = listSearchPaths(output);
searchPaths
.reverse()
.forEach(function(searchPath) {
var i18nRoot = path.resolve(searchPath, '_i18n');
if (!fs.existsSync(i18nRoot)) return;
i18n.load(i18nRoot);
});
return Promise(output);
}
|
javascript
|
{
"resource": ""
}
|
q16034
|
reduce
|
train
|
function reduce(arr, iter, base) {
arr = Immutable.Iterable.isIterable(arr)? arr : Immutable.List(arr);
return arr.reduce(function(prev, elem, key) {
return prev
.then(function(val) {
return iter(val, elem, key);
});
}, Q(base));
}
|
javascript
|
{
"resource": ""
}
|
q16035
|
forEach
|
train
|
function forEach(arr, iter) {
return reduce(arr, function(val, el, key) {
return iter(el, key);
});
}
|
javascript
|
{
"resource": ""
}
|
q16036
|
serie
|
train
|
function serie(arr, iter, base) {
return reduce(arr, function(before, item, key) {
return Q(iter(item, key))
.then(function(r) {
before.push(r);
return before;
});
}, []);
}
|
javascript
|
{
"resource": ""
}
|
q16037
|
map
|
train
|
function map(arr, iter) {
if (Immutable.Map.isMap(arr)) {
var type = 'Map';
if (Immutable.OrderedMap.isOrderedMap(arr)) {
type = 'OrderedMap';
}
return mapAsList(arr, function(value, key) {
return Q(iter(value, key))
.then(function(result) {
return [key, result];
});
})
.then(function(result) {
return Immutable[type](result);
});
} else {
return mapAsList(arr, iter)
.then(function(result) {
return Immutable.List(result);
});
}
}
|
javascript
|
{
"resource": ""
}
|
q16038
|
listShortcuts
|
train
|
function listShortcuts(blocks, filePath) {
var parser = parsers.getForFile(filePath);
if (!parser) {
return Immutable.List();
}
return blocks
.map(function(block) {
return block.getShortcuts();
})
.filter(function(shortcuts) {
return (
shortcuts &&
shortcuts.acceptParser(parser.getName())
);
});
}
|
javascript
|
{
"resource": ""
}
|
q16039
|
renderDOM
|
train
|
function renderDOM($, dom, options) {
if (!dom && $._root && $._root.children) {
dom = $._root.children;
}
options = options|| dom.options || $._options;
return domSerializer(dom, options);
}
|
javascript
|
{
"resource": ""
}
|
q16040
|
svgToImg
|
train
|
function svgToImg(baseFolder, currentFile, $) {
var currentDirectory = path.dirname(currentFile);
return editHTMLElement($, 'svg', function($svg) {
var content = '<?xml version="1.0" encoding="UTF-8"?>' +
renderDOM($, $svg);
// We avoid generating twice the same PNG
var hash = crc.crc32(content).toString(16);
var fileName = hash + '.svg';
var filePath = path.join(baseFolder, fileName);
// Write the svg to the file
return fs.assertFile(filePath, function() {
return fs.writeFile(filePath, content, 'utf8');
})
// Return as image
.then(function() {
var src = LocationUtils.relative(currentDirectory, fileName);
$svg.replaceWith('<img src="' + src + '" />');
});
});
}
|
javascript
|
{
"resource": ""
}
|
q16041
|
getLanguageForClass
|
train
|
function getLanguageForClass(classNames) {
return Immutable.List(classNames)
.map(function(cl) {
// Markdown
if (cl.search('lang-') === 0) {
return cl.slice('lang-'.length);
}
// Asciidoc
if (cl.search('language-') === 0) {
return cl.slice('language-'.length);
}
return null;
})
.find(function(cl) {
return Boolean(cl);
});
}
|
javascript
|
{
"resource": ""
}
|
q16042
|
highlightCode
|
train
|
function highlightCode(highlight, $) {
return editHTMLElement($, 'code', function($code) {
var classNames = ($code.attr('class') || '').split(' ');
var lang = getLanguageForClass(classNames);
var source = $code.text();
return Promise(highlight(lang, source))
.then(function(r) {
if (is.string(r.html)) {
$code.html(r.html);
} else {
$code.text(r.text);
}
});
});
}
|
javascript
|
{
"resource": ""
}
|
q16043
|
generatePage
|
train
|
function generatePage(output, page) {
var book = output.getBook();
var engine = createTemplateEngine(output);
return timing.measure(
'page.generate',
Promise(page)
.then(function(resultPage) {
var file = resultPage.getFile();
var filePath = file.getPath();
var parser = file.getParser();
var context = JSONUtils.encodeOutputWithPage(output, resultPage);
if (!parser) {
return Promise.reject(error.FileNotParsableError({
filename: filePath
}));
}
// Call hook "page:before"
return callPageHook('page:before', output, resultPage)
// Escape code blocks with raw tags
.then(function(currentPage) {
return parser.preparePage(currentPage.getContent());
})
// Render templating syntax
.then(function(content) {
var absoluteFilePath = path.join(book.getContentRoot(), filePath);
return Templating.render(engine, absoluteFilePath, content, context);
})
.then(function(output) {
var content = output.getContent();
return parser.parsePage(content)
.then(function(result) {
return output.setContent(result.content);
});
})
// Post processing for templating syntax
.then(function(output) {
return Templating.postRender(engine, output);
})
// Return new page
.then(function(content) {
return resultPage.set('content', content);
})
// Call final hook
.then(function(currentPage) {
return callPageHook('page', output, currentPage);
});
})
);
}
|
javascript
|
{
"resource": ""
}
|
q16044
|
parseBookContent
|
train
|
function parseBookContent(book) {
return Promise(book)
.then(parseReadme)
.then(parseSummary)
.then(parseGlossary);
}
|
javascript
|
{
"resource": ""
}
|
q16045
|
parseMultilingualBook
|
train
|
function parseMultilingualBook(book) {
var languages = book.getLanguages();
var langList = languages.getList();
return Promise.reduce(langList, function(currentBook, lang) {
var langID = lang.getID();
var child = Book.createFromParent(currentBook, langID);
var ignore = currentBook.getIgnore();
return Promise(child)
.then(parseConfig)
.then(parseBookContent)
.then(function(result) {
// Ignore content of this book when generating parent book
ignore = ignore.add(langID + '/**');
currentBook = currentBook.set('ignore', ignore);
return currentBook.addLanguageBook(langID, result);
});
}, book);
}
|
javascript
|
{
"resource": ""
}
|
q16046
|
parseBook
|
train
|
function parseBook(book) {
return timing.measure(
'parse.book',
Promise(book)
.then(parseIgnore)
.then(parseConfig)
.then(parseLanguages)
.then(function(resultBook) {
if (resultBook.isMultilingual()) {
return parseMultilingualBook(resultBook);
} else {
return parseBookContent(resultBook);
}
})
);
}
|
javascript
|
{
"resource": ""
}
|
q16047
|
inlinePng
|
train
|
function inlinePng(rootFolder, currentFile, $) {
var currentDirectory = path.dirname(currentFile);
return editHTMLElement($, 'img', function($img) {
var src = $img.attr('src');
if (!LocationUtils.isDataURI(src)) {
return;
}
// We avoid generating twice the same PNG
var hash = crc.crc32(src).toString(16);
var fileName = hash + '.png';
// Result file path
var filePath = path.join(rootFolder, fileName);
return fs.assertFile(filePath, function() {
return imagesUtil.convertInlinePNG(src, filePath);
})
.then(function() {
// Convert filename to a relative filename
fileName = LocationUtils.relative(currentDirectory, fileName);
// Replace src
$img.attr('src', fileName);
});
});
}
|
javascript
|
{
"resource": ""
}
|
q16048
|
unshiftArticle
|
train
|
function unshiftArticle(summary, article) {
article = SummaryArticle(article);
var parts = summary.getParts();
var part = parts.get(0) || SummaryPart();
var articles = part.getArticles();
articles = articles.unshift(article);
part = part.set('articles', articles);
parts = parts.set(0, part);
summary = summary.set('parts', parts);
return indexLevels(summary);
}
|
javascript
|
{
"resource": ""
}
|
q16049
|
encodeSummaryPart
|
train
|
function encodeSummaryPart(part) {
return {
title: part.getTitle(),
articles: part.getArticles()
.map(encodeSummaryArticle).toJS()
};
}
|
javascript
|
{
"resource": ""
}
|
q16050
|
initNPM
|
train
|
function initNPM() {
if (npmIsReady) return npmIsReady;
npmIsReady = Promise.nfcall(npm.load, {
silent: true,
loglevel: 'silent'
});
return npmIsReady;
}
|
javascript
|
{
"resource": ""
}
|
q16051
|
resolveVersion
|
train
|
function resolveVersion(plugin) {
var npmId = Plugin.nameToNpmID(plugin.getName());
var requiredVersion = plugin.getVersion();
if (plugin.isGitDependency()) {
return Promise.resolve(requiredVersion);
}
return initNPM()
.then(function() {
return Promise.nfcall(npm.commands.view, [npmId + '@' + requiredVersion, 'engines'], true);
})
.then(function(versions) {
versions = Immutable.Map(versions).entrySeq();
var result = versions
.map(function(entry) {
return {
version: entry[0],
gitbook: (entry[1].engines || {}).gitbook
};
})
.filter(function(v) {
return v.gitbook && gitbook.satisfies(v.gitbook);
})
.sort(function(v1, v2) {
return semver.lt(v1.version, v2.version)? 1 : -1;
})
.get(0);
if (!result) {
return undefined;
} else {
return result.version;
}
});
}
|
javascript
|
{
"resource": ""
}
|
q16052
|
createTemplateEngine
|
train
|
function createTemplateEngine(output, currentFile) {
var book = output.getBook();
var state = output.getState();
var i18n = state.getI18n();
var config = book.getConfig();
var summary = book.getSummary();
var outputFolder = output.getRoot();
// Search paths for templates
var searchPaths = listSearchPaths(output);
var tplSearchPaths = searchPaths.map(templateFolder);
// Create loader
var loader = new Templating.ThemesLoader(tplSearchPaths);
// Get languages
var language = config.getValue('language');
// Create API context
var context = Api.encodeGlobal(output);
/**
* Check if a file exists
* @param {String} fileName
* @return {Boolean}
*/
function fileExists(fileName) {
if (!fileName) {
return false;
}
var filePath = PathUtils.resolveInRoot(outputFolder, fileName);
return fs.existsSync(filePath);
}
/**
* Return an article by its path
* @param {String} filePath
* @return {Object|undefined}
*/
function getArticleByPath(filePath) {
var article = summary.getByPath(filePath);
if (!article) return undefined;
return JSONUtils.encodeSummaryArticle(article);
}
/**
* Return a page by its path
* @param {String} filePath
* @return {Object|undefined}
*/
function getPageByPath(filePath) {
var page = output.getPage(filePath);
if (!page) return undefined;
return JSONUtils.encodePage(page, summary);
}
return TemplateEngine.create({
loader: loader,
context: context,
globals: {
getArticleByPath: getArticleByPath,
getPageByPath: getPageByPath,
fileExists: fileExists
},
filters: defaultFilters.merge({
/**
* Translate a sentence
*/
t: function t(s) {
return i18n.t(language, s);
},
/**
* Resolve an absolute file path into a
* relative path.
* it also resolve pages
*/
resolveFile: function(filePath) {
filePath = resolveFileToURL(output, filePath);
return LocationUtils.relativeForFile(currentFile, filePath);
},
resolveAsset: function(filePath) {
filePath = LocationUtils.toAbsolute(filePath, '', '');
filePath = path.join('gitbook', filePath);
filePath = LocationUtils.relativeForFile(currentFile, filePath);
// Use assets from parent if language book
if (book.isLanguageBook()) {
filePath = path.join('../', filePath);
}
return LocationUtils.normalize(filePath);
},
fileExists: deprecate.method(book, 'fileExists', fileExists, 'Filter "fileExists" is deprecated, use "fileExists(filename)" '),
getArticleByPath: deprecate.method(book, 'getArticleByPath', fileExists, 'Filter "getArticleByPath" is deprecated, use "getArticleByPath(filename)" '),
contentURL: function(filePath) {
return fileToURL(output, filePath);
}
}),
extensions: {
'DoExtension': new DoExtension()
}
});
}
|
javascript
|
{
"resource": ""
}
|
q16053
|
getArticleByPath
|
train
|
function getArticleByPath(filePath) {
var article = summary.getByPath(filePath);
if (!article) return undefined;
return JSONUtils.encodeSummaryArticle(article);
}
|
javascript
|
{
"resource": ""
}
|
q16054
|
getPageByPath
|
train
|
function getPageByPath(filePath) {
var page = output.getPage(filePath);
if (!page) return undefined;
return JSONUtils.encodePage(page, summary);
}
|
javascript
|
{
"resource": ""
}
|
q16055
|
indexPartLevels
|
train
|
function indexPartLevels(part, index) {
var baseLevel = String(index + 1);
var articles = part.getArticles();
articles = articles.map(function(inner, i) {
return indexArticleLevels(inner, baseLevel + '.' + (i + 1));
});
return part.merge({
level: baseLevel,
articles: articles
});
}
|
javascript
|
{
"resource": ""
}
|
q16056
|
setExtension
|
train
|
function setExtension(filename, ext) {
return path.join(
path.dirname(filename),
path.basename(filename, path.extname(filename)) + ext
);
}
|
javascript
|
{
"resource": ""
}
|
q16057
|
generateAssets
|
train
|
function generateAssets(generator, output) {
var assets = output.getAssets();
var logger = output.getLogger();
// Is generator ignoring assets?
if (!generator.onAsset) {
return Promise(output);
}
return Promise.reduce(assets, function(out, assetFile) {
logger.debug.ln('copy asset "' + assetFile + '"');
return generator.onAsset(out, assetFile);
}, output);
}
|
javascript
|
{
"resource": ""
}
|
q16058
|
fetchRemoteImages
|
train
|
function fetchRemoteImages(rootFolder, currentFile, $) {
var currentDirectory = path.dirname(currentFile);
return editHTMLElement($, 'img', function($img) {
var src = $img.attr('src');
var extension = path.extname(src);
if (!LocationUtils.isExternal(src)) {
return;
}
// We avoid generating twice the same PNG
var hash = crc.crc32(src).toString(16);
var fileName = hash + extension;
var filePath = path.join(rootFolder, fileName);
return fs.assertFile(filePath, function() {
return fs.download(src, filePath);
})
.then(function() {
// Convert to relative
src = LocationUtils.relative(currentDirectory, fileName);
$img.replaceWith('<img src="' + src + '" />');
});
});
}
|
javascript
|
{
"resource": ""
}
|
q16059
|
convertSVGToPNG
|
train
|
function convertSVGToPNG(source, dest, options) {
if (!fs.existsSync(source)) return Promise.reject(new error.FileNotFoundError({ filename: source }));
return command.spawn('svgexport', [source, dest])
.fail(function(err) {
if (err.code == 'ENOENT') {
err = error.RequireInstallError({
cmd: 'svgexport',
install: 'Install it using: "npm install svgexport -g"'
});
}
throw err;
})
.then(function() {
if (fs.existsSync(dest)) return;
throw new Error('Error converting '+source+' into '+dest);
});
}
|
javascript
|
{
"resource": ""
}
|
q16060
|
convertSVGBufferToPNG
|
train
|
function convertSVGBufferToPNG(buf, dest) {
// Create a temporary SVG file to convert
return fs.tmpFile({
postfix: '.svg'
})
.then(function(tmpSvg) {
return fs.writeFile(tmpSvg, buf)
.then(function() {
return convertSVGToPNG(tmpSvg, dest);
});
});
}
|
javascript
|
{
"resource": ""
}
|
q16061
|
prepareResources
|
train
|
function prepareResources(output) {
var plugins = output.getPlugins();
var options = output.getOptions();
var type = options.get('prefix');
var state = output.getState();
var context = Api.encodeGlobal(output);
var result = Immutable.Map();
return Promise.forEach(plugins, function(plugin) {
var pluginResources = plugin.getResources(type);
return Promise()
.then(function() {
// Apply resources if is a function
if (is.fn(pluginResources)) {
return Promise()
.then(pluginResources.bind(context));
}
else {
return pluginResources;
}
})
.then(function(resources) {
result = result.set(plugin.getName(), Immutable.Map(resources));
});
})
.then(function() {
// Set output resources
state = state.merge({
resources: result
});
output = output.merge({
state: state
});
return output;
});
}
|
javascript
|
{
"resource": ""
}
|
q16062
|
listDepsForBook
|
train
|
function listDepsForBook(book) {
var config = book.getConfig();
var plugins = config.getPluginDependencies();
return listDependencies(plugins);
}
|
javascript
|
{
"resource": ""
}
|
q16063
|
getModifiers
|
train
|
function getModifiers(output, page) {
var book = output.getBook();
var plugins = output.getPlugins();
var glossary = book.getGlossary();
var file = page.getFile();
// Glossary entries
var entries = glossary.getEntries();
var glossaryFile = glossary.getFile();
var glossaryFilename = fileToOutput(output, glossaryFile.getPath());
// Current file path
var currentFilePath = file.getPath();
// Get TemplateBlock for highlighting
var blocks = Plugins.listBlocks(plugins);
var code = blocks.get(CODEBLOCK) || defaultBlocks.get(CODEBLOCK);
// Current context
var context = Api.encodeGlobal(output);
return [
// Normalize IDs on headings
Modifiers.addHeadingId,
// Annotate text with glossary entries
Modifiers.annotateText.bind(null, entries, glossaryFilename),
// Resolve images
Modifiers.resolveImages.bind(null, currentFilePath),
// Resolve links (.md -> .html)
Modifiers.resolveLinks.bind(null,
currentFilePath,
resolveFileToURL.bind(null, output)
),
// Highlight code blocks using "code" block
Modifiers.highlightCode.bind(null, function(lang, source) {
return Promise(code.applyBlock({
body: source,
kwargs: {
language: lang
}
}, context))
.then(function(result) {
if (result.html === false) {
return { text: result.body };
} else {
return { html: result.body };
}
});
})
];
}
|
javascript
|
{
"resource": ""
}
|
q16064
|
removePart
|
train
|
function removePart(summary, index) {
var parts = summary.getParts().remove(index);
return indexLevels(summary.set('parts', parts));
}
|
javascript
|
{
"resource": ""
}
|
q16065
|
train
|
function(filePath) {
var page = output.getPage(filePath);
if (!page) return undefined;
return encodePage(output, page);
}
|
javascript
|
{
"resource": ""
}
|
|
q16066
|
train
|
function(name, blockData) {
var block = blocks.get(name) || defaultBlocks.get(name);
return Promise(block.applyBlock(blockData, result));
}
|
javascript
|
{
"resource": ""
}
|
|
q16067
|
train
|
function(fileName, content) {
return Promise()
.then(function() {
var filePath = PathUtils.resolveInRoot(outputFolder, fileName);
return fs.exists(filePath);
});
}
|
javascript
|
{
"resource": ""
}
|
|
q16068
|
train
|
function(fileName, content) {
return Promise()
.then(function() {
var filePath = PathUtils.resolveInRoot(outputFolder, fileName);
return fs.ensureFile(filePath)
.then(function() {
return fs.writeFile(filePath, content);
});
});
}
|
javascript
|
{
"resource": ""
}
|
|
q16069
|
train
|
function(inputFile, outputFile, content) {
return Promise()
.then(function() {
var outputFilePath = PathUtils.resolveInRoot(outputFolder, outputFile);
return fs.ensureFile(outputFilePath)
.then(function() {
return fs.copy(inputFile, outputFilePath);
});
});
}
|
javascript
|
{
"resource": ""
}
|
|
q16070
|
onAsset
|
train
|
function onAsset(output, asset) {
var book = output.getBook();
var options = output.getOptions();
var bookFS = book.getContentFS();
var outputFolder = options.get('root');
var outputPath = path.resolve(outputFolder, asset);
return fs.ensureFile(outputPath)
.then(function() {
return bookFS.readAsStream(asset)
.then(function(stream) {
return fs.writeStream(outputPath, stream);
});
})
.thenResolve(output);
}
|
javascript
|
{
"resource": ""
}
|
q16071
|
listResources
|
train
|
function listResources(plugins, resources) {
return plugins.reduce(function(result, plugin) {
var npmId = plugin.getNpmID();
var pluginResources = resources.get(plugin.getName());
PLUGIN_RESOURCES.forEach(function(resourceType) {
var assets = pluginResources.get(resourceType);
if (!assets) return;
var list = result.get(resourceType) || Immutable.List();
assets = assets.map(function(assetFile) {
if (LocationUtils.isExternal(assetFile)) {
return {
url: assetFile
};
} else {
return {
path: LocationUtils.normalize(path.join(npmId, assetFile))
};
}
});
list = list.concat(assets);
result = result.set(resourceType, list);
});
return result;
}, Immutable.Map());
}
|
javascript
|
{
"resource": ""
}
|
q16072
|
enforce
|
train
|
function enforce(err) {
if (is.string(err)) err = new Error(err);
err.message = err.message.replace(/^Error: /, '');
return err;
}
|
javascript
|
{
"resource": ""
}
|
q16073
|
getCoverPath
|
train
|
function getCoverPath(output) {
var outputRoot = output.getRoot();
var book = output.getBook();
var config = book.getConfig();
var coverName = config.getValue('cover', 'cover.jpg');
// Resolve to absolute
var cover = fs.pickFile(outputRoot, coverName);
if (cover) {
return cover;
}
// Multilingual? try parent folder
if (book.isLanguageBook()) {
cover = fs.pickFile(path.join(outputRoot, '..'), coverName);
}
return cover;
}
|
javascript
|
{
"resource": ""
}
|
q16074
|
parseReadme
|
train
|
function parseReadme(book) {
var logger = book.getLogger();
return parseStructureFile(book, 'readme')
.spread(function(file, result) {
if (!file) {
throw new error.FileNotFoundError({ filename: 'README' });
}
logger.debug.ln('readme found at', file.getPath());
var readme = Readme.create(file, result);
return book.set('readme', readme);
});
}
|
javascript
|
{
"resource": ""
}
|
q16075
|
moveArticleAfter
|
train
|
function moveArticleAfter(summary, origin, afterTarget) {
// Coerce to level
var originLevel = is.string(origin)? origin : origin.getLevel();
var afterTargetLevel = is.string(afterTarget)? afterTarget : afterTarget.getLevel();
var article = summary.getByLevel(originLevel);
var targetLevel = increment(afterTargetLevel);
if (targetLevel < origin) {
// Remove first
var removed = removeArticle(summary, originLevel);
// Insert then
return insertArticle(removed, article, targetLevel);
} else {
// Insert right after first
var inserted = insertArticle(summary, article, targetLevel);
// Remove old one
return removeArticle(inserted, originLevel);
}
}
|
javascript
|
{
"resource": ""
}
|
q16076
|
loadForBook
|
train
|
function loadForBook(book) {
var logger = book.getLogger();
// List the dependencies
var requirements = listDepsForBook(book);
// List all plugins installed in the book
return findForBook(book)
.then(function(installedMap) {
var missing = [];
var plugins = requirements.reduce(function(result, dep) {
var name = dep.getName();
var installed = installedMap.get(name);
if (installed) {
var deps = installedMap
.filter(function(plugin) {
return plugin.getParent() === name;
})
.toArray();
result = result.concat(deps);
result.push(installed);
} else {
missing.push(name);
}
return result;
}, []);
// Convert plugins list to a map
plugins = Immutable.List(plugins)
.map(function(plugin) {
return [
plugin.getName(),
plugin
];
});
plugins = Immutable.OrderedMap(plugins);
// Log state
logger.info.ln(installedMap.size + ' plugins are installed');
if (requirements.size != installedMap.size) {
logger.info.ln(requirements.size + ' explicitly listed');
}
// Verify that all plugins are present
if (missing.length > 0) {
throw new Error('Couldn\'t locate plugins "' + missing.join(', ') + '", Run \'gitbook install\' to install plugins from registry.');
}
return Promise.map(plugins, function(plugin) {
return loadPlugin(book, plugin);
});
});
}
|
javascript
|
{
"resource": ""
}
|
q16077
|
encodeBookToJson
|
train
|
function encodeBookToJson(book) {
var config = book.getConfig();
var language = book.getLanguage();
var variables = config.getValue('variables', {});
return {
summary: encodeSummary(book.getSummary()),
glossary: encodeGlossary(book.getGlossary()),
readme: encodeReadme(book.getReadme()),
config: book.getConfig().getValues().toJS(),
languages: book.isMultilingual()? encodeLanguages(book.getLanguages()) : undefined,
gitbook: {
version: gitbook.version,
time: gitbook.START_TIME
},
book: extend({
language: language? language : undefined
}, variables.toJS())
};
}
|
javascript
|
{
"resource": ""
}
|
q16078
|
parseSummary
|
train
|
function parseSummary(book) {
var readme = book.getReadme();
var logger = book.getLogger();
var readmeFile = readme.getFile();
return parseStructureFile(book, 'summary')
.spread(function(file, result) {
var summary;
if (!file) {
logger.warn.ln('no summary file in this book');
summary = Summary();
} else {
logger.debug.ln('summary file found at', file.getPath());
summary = Summary.createFromParts(file, result.parts);
}
// Insert readme as first entry if not in SUMMARY.md
var readmeArticle = summary.getByPath(readmeFile.getPath());
if (readmeFile.exists() && !readmeArticle) {
summary = SummaryModifier.unshiftArticle(summary, {
title: 'Introduction',
ref: readmeFile.getPath()
});
}
// Set new summary
return book.setSummary(summary);
});
}
|
javascript
|
{
"resource": ""
}
|
q16079
|
copyPluginAssets
|
train
|
function copyPluginAssets(output) {
var book = output.getBook();
// Don't copy plugins assets for language book
// It'll be resolved to the parent folder
if (book.isLanguageBook()) {
return Promise(output);
}
var plugins = output.getPlugins()
// We reverse the order of plugins to copy
// so that first plugins can replace assets from other plugins.
.reverse();
return Promise.forEach(plugins, function(plugin) {
return copyAssets(output, plugin)
.then(function() {
return copyResources(output, plugin);
});
})
.thenResolve(output);
}
|
javascript
|
{
"resource": ""
}
|
q16080
|
copyAssets
|
train
|
function copyAssets(output, plugin) {
var logger = output.getLogger();
var pluginRoot = plugin.getPath();
var options = output.getOptions();
var outputRoot = options.get('root');
var assetOutputFolder = path.join(outputRoot, 'gitbook');
var prefix = options.get('prefix');
var assetFolder = path.join(pluginRoot, ASSET_FOLDER, prefix);
if (!fs.existsSync(assetFolder)) {
return Promise();
}
logger.debug.ln('copy assets from theme', assetFolder);
return fs.copyDir(
assetFolder,
assetOutputFolder,
{
deleteFirst: false,
overwrite: true,
confirm: true
}
);
}
|
javascript
|
{
"resource": ""
}
|
q16081
|
copyResources
|
train
|
function copyResources(output, plugin) {
var logger = output.getLogger();
var options = output.getOptions();
var outputRoot = options.get('root');
var state = output.getState();
var resources = state.getResources();
var pluginRoot = plugin.getPath();
var pluginResources = resources.get(plugin.getName());
var assetsFolder = pluginResources.get('assets');
var assetOutputFolder = path.join(outputRoot, 'gitbook', plugin.getNpmID());
if (!assetsFolder) {
return Promise();
}
// Resolve assets folder
assetsFolder = path.resolve(pluginRoot, assetsFolder);
if (!fs.existsSync(assetsFolder)) {
logger.warn.ln('assets folder for plugin "' + plugin.getName() + '" doesn\'t exist');
return Promise();
}
logger.debug.ln('copy resources from plugin', assetsFolder);
return fs.copyDir(
assetsFolder,
assetOutputFolder,
{
deleteFirst: false,
overwrite: true,
confirm: true
}
);
}
|
javascript
|
{
"resource": ""
}
|
q16082
|
writeFile
|
train
|
function writeFile(output, filePath, content) {
var rootFolder = output.getRoot();
filePath = path.join(rootFolder, filePath);
return fs.ensureFile(filePath)
.then(function() {
return fs.writeFile(filePath, content);
})
.thenResolve(output);
}
|
javascript
|
{
"resource": ""
}
|
q16083
|
encodeProgress
|
train
|
function encodeProgress(output, page) {
var current = page.getPath();
var navigation = encodeNavigation(output);
navigation = Immutable.Map(navigation);
var n = navigation.size;
var percent = 0, prevPercent = 0, currentChapter = null;
var done = true;
var chapters = navigation
.map(function(nav, chapterPath) {
nav.path = chapterPath;
return nav;
})
.valueSeq()
.sortBy(function(nav) {
return nav.index;
})
.map(function(nav, i) {
// Calcul percent
nav.percent = (i * 100) / Math.max((n - 1), 1);
// Is it done
nav.done = done;
if (nav.path == current) {
currentChapter = nav;
percent = nav.percent;
done = false;
} else if (done) {
prevPercent = nav.percent;
}
return nav;
})
.toJS();
return {
// Previous percent
prevPercent: prevPercent,
// Current percent
percent: percent,
// List of chapter with progress
chapters: chapters,
// Current chapter
current: currentChapter
};
}
|
javascript
|
{
"resource": ""
}
|
q16084
|
inlineAssets
|
train
|
function inlineAssets(rootFolder, currentFile) {
return function($) {
return Promise()
// Resolving images and fetching external images should be
// done before svg conversion
.then(resolveImages.bind(null, currentFile, $))
.then(fetchRemoteImages.bind(null, rootFolder, currentFile, $))
.then(svgToImg.bind(null, rootFolder, currentFile, $))
.then(svgToPng.bind(null, rootFolder, currentFile, $))
.then(inlinePng.bind(null, rootFolder, currentFile, $));
};
}
|
javascript
|
{
"resource": ""
}
|
q16085
|
findForBook
|
train
|
function findForBook(book) {
return timing.measure(
'plugins.findForBook',
Promise.all([
findInstalled(locateRootFolder()),
findInstalled(book.getRoot())
])
// Merge all plugins
.then(function(results) {
return Immutable.List(results)
.reduce(function(out, result) {
return out.merge(result);
}, Immutable.OrderedMap());
})
);
}
|
javascript
|
{
"resource": ""
}
|
q16086
|
parseIgnore
|
train
|
function parseIgnore(book) {
if (book.isLanguageBook()) {
return Promise.reject(new Error('Ignore files could be parsed for language books'));
}
var fs = book.getFS();
var ignore = book.getIgnore();
ignore = ignore.add(DEFAULT_IGNORES);
return Promise.serie(IGNORE_FILES, function(filename) {
return fs.readAsString(filename)
.then(function(content) {
ignore = ignore.add(content.toString().split(/\r?\n/));
}, function(err) {
return Promise();
});
})
.then(function() {
return book.setIgnore(ignore);
});
}
|
javascript
|
{
"resource": ""
}
|
q16087
|
getOutputFolder
|
train
|
function getOutputFolder(args) {
var bookRoot = path.resolve(args[0] || process.cwd());
var defaultOutputRoot = path.join(bookRoot, '_book');
var outputFolder = args[1]? path.resolve(process.cwd(), args[1]) : defaultOutputRoot;
return outputFolder;
}
|
javascript
|
{
"resource": ""
}
|
q16088
|
decodeGlobal
|
train
|
function decodeGlobal(config, result) {
var values = result.values;
delete values.generator;
delete values.output;
return config.updateValues(values);
}
|
javascript
|
{
"resource": ""
}
|
q16089
|
encodeNavigation
|
train
|
function encodeNavigation(output) {
var book = output.getBook();
var pages = output.getPages();
var summary = book.getSummary();
var articles = summary.getArticlesAsList();
var navigation = articles
.map(function(article, i) {
var ref = article.getRef();
if (!ref) {
return undefined;
}
var prev = articles.get(i - 1);
var next = articles.get(i + 1);
return [
ref,
{
index: i,
title: article.getTitle(),
introduction: (i === 0),
prev: prev? encodeArticle(pages, prev) : undefined,
next: next? encodeArticle(pages, next) : undefined,
level: article.getLevel()
}
];
})
.filter(function(e) {
return Boolean(e);
});
return Immutable.Map(navigation).toJS();
}
|
javascript
|
{
"resource": ""
}
|
q16090
|
encodeOutputToJson
|
train
|
function encodeOutputToJson(output) {
var book = output.getBook();
var generator = output.getGenerator();
var options = output.getOptions();
var result = encodeBook(book);
result.output = {
name: generator
};
result.options = options.toJS();
return result;
}
|
javascript
|
{
"resource": ""
}
|
q16091
|
parsePage
|
train
|
function parsePage(book, page) {
var fs = book.getContentFS();
var file = page.getFile();
return fs.readAsString(file.getPath())
.then(function(content) {
return parsePageFromString(page, content);
});
}
|
javascript
|
{
"resource": ""
}
|
q16092
|
listAssets
|
train
|
function listAssets(book, pages) {
var fs = book.getContentFS();
var summary = book.getSummary();
var summaryFile = summary.getFile().getPath();
var glossary = book.getGlossary();
var glossaryFile = glossary.getFile().getPath();
var langs = book.getLanguages();
var langsFile = langs.getFile().getPath();
var config = book.getConfig();
var configFile = config.getFile().getPath();
function filterFile(file) {
return !(
file === summaryFile ||
file === glossaryFile ||
file === langsFile ||
file === configFile ||
book.isContentFileIgnored(file) ||
pages.has(file)
);
}
return timing.measure(
'parse.listAssets',
fs.listAllFiles('.', filterFile)
);
}
|
javascript
|
{
"resource": ""
}
|
q16093
|
createMockFS
|
train
|
function createMockFS(files) {
files = Immutable.fromJS(files);
var mtime = new Date();
function getFile(filePath) {
var parts = path.normalize(filePath).split(path.sep);
return parts.reduce(function(list, part, i) {
if (!list) return null;
var file;
if (!part || part === '.') file = list;
else file = list.get(part);
if (!file) return null;
if (is.string(file)) {
if (i === (parts.length - 1)) return file;
else return null;
}
return file;
}, files);
}
function fsExists(filePath) {
return Boolean(getFile(filePath) !== null);
}
function fsReadFile(filePath) {
var file = getFile(filePath);
if (!is.string(file)) {
throw error.FileNotFoundError({
filename: filePath
});
}
return new Buffer(file, 'utf8');
}
function fsStatFile(filePath) {
var file = getFile(filePath);
if (!file) {
throw error.FileNotFoundError({
filename: filePath
});
}
return {
mtime: mtime
};
}
function fsReadDir(filePath) {
var dir = getFile(filePath);
if (!dir || is.string(dir)) {
throw error.FileNotFoundError({
filename: filePath
});
}
return dir
.map(function(content, name) {
if (!is.string(content)) {
name = name + '/';
}
return name;
})
.valueSeq();
}
return FS.create({
root: '',
fsExists: fsExists,
fsReadFile: fsReadFile,
fsStatFile: fsStatFile,
fsReadDir: fsReadDir
});
}
|
javascript
|
{
"resource": ""
}
|
q16094
|
fileExists
|
train
|
function fileExists(filename) {
var d = Promise.defer();
fs.exists(filename, function(exists) {
d.resolve(exists);
});
return d.promise;
}
|
javascript
|
{
"resource": ""
}
|
q16095
|
ensureFile
|
train
|
function ensureFile(filename) {
var base = path.dirname(filename);
return Promise.nfcall(mkdirp, base);
}
|
javascript
|
{
"resource": ""
}
|
q16096
|
pickFile
|
train
|
function pickFile(rootFolder, fileName) {
var result = path.join(rootFolder, fileName);
if (fs.existsSync(result)) {
return result;
}
return undefined;
}
|
javascript
|
{
"resource": ""
}
|
q16097
|
ensureFolder
|
train
|
function ensureFolder(rootFolder) {
return rmDir(rootFolder)
.fail(function() {
return Promise();
})
.then(function() {
return Promise.nfcall(mkdirp, rootFolder);
});
}
|
javascript
|
{
"resource": ""
}
|
q16098
|
decodeGlobal
|
train
|
function decodeGlobal(output, result) {
var book = output.getBook();
var config = book.getConfig();
// Update config
config = decodeConfig(config, result.config);
book = book.set('config', config);
return output.set('book', book);
}
|
javascript
|
{
"resource": ""
}
|
q16099
|
encodeFileToJson
|
train
|
function encodeFileToJson(file) {
var filePath = file.getPath();
if (!filePath) {
return undefined;
}
return {
path: filePath,
mtime: file.getMTime(),
type: file.getType()
};
}
|
javascript
|
{
"resource": ""
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.