_id stringlengths 2 6 | title stringlengths 0 58 | partition stringclasses 3
values | text stringlengths 27 233k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q42700 | train | function () {
var prefix = '%(',
suffix = ')',
data = this.data,
output = '',
dataKey;
output = this.__message__;
for (dataKey in data) {
if (data.hasOwnProperty(dataKey)) {
output = output.replace(prefix + dataKey + s... | javascript | {
"resource": ""
} | |
q42701 | train | function (full) {
var output, data;
output = this.name + '[' + this.code + ']: ';
output += this.message;
if (full) {
output += '\n';
| javascript | {
"resource": ""
} | |
q42702 | setView | train | function setView({ action, config, route, routes, method }) {
const ws = route.ws;
return exports.getView(action, config).then(view => {
routes[ws ? 'ws' : route.type].push({
| javascript | {
"resource": ""
} |
q42703 | train | function() {
var rangeList = this,
bookmark = CKEDITOR.dom.walker.bookmark(),
bookmarks = [],
current;
return {
/**
* Retrieves the next range in the list.
*
* @member CKEDITOR.dom.rangeListIterator
* @param {Boolean} [mergeConsequent=false] Whether join two adjacent
* ra... | javascript | {
"resource": ""
} | |
q42704 | train | function(typeCode) {
switch (typeCode) {
case this.types.undefined:
return this.Undefined;
case this.types.string:
return this.String;
case this.types.integer:
return this.Integer;
case this.types.double:
return this.Double;... | javascript | {
"resource": ""
} | |
q42705 | addType | train | function addType(descriptor) {
if (!(descriptor instanceof fs.Stats)) {
return descriptor;
}
[
"isFile", "isDirectory", "isBlockDevice", "isCharacterDevice",
"isSymbolicLink", "isFIFO", "isSocket",
| javascript | {
"resource": ""
} |
q42706 | getArgs | train | function getArgs(userArgs, defaultArgs, userCallback) {
let args = { };
let callback = userCallback || function() { };
defaultArgs.unshift(args);
_.assign.apply(null, defaultArgs);
if (_.isPlainObject(userArgs)) | javascript | {
"resource": ""
} |
q42707 | removeDuplicates | train | function removeDuplicates(files, duplicates) {
var i;
var ret = [];
var found = {};
if (duplicates) {
for (i=0; i < duplicates.length; i++) {
| javascript | {
"resource": ""
} |
q42708 | flatten | train | function flatten(files) {
var ret = [];
for (var i=0; i | javascript | {
"resource": ""
} |
q42709 | prefixDest | train | function prefixDest(prefix, files) {
for (var i = 0; i < files.length; i++) {
files[i].dst = prefix + | javascript | {
"resource": ""
} |
q42710 | filesInRepository | train | function filesInRepository(dir) {
var ignoreDirs = cog.getOption('ignore_dirs');
// TODO: Allow an array and move to config.
var ignoreFiles = /~$/;
var files = glob.sync(dir ? dir + '/*' : '*');
var ret = [];
for (var i = 0; i < files.length; i++) {
if (fs.ls... | javascript | {
"resource": ""
} |
q42711 | excludeFiles | train | function excludeFiles(list, regex) {
var ret = [];
for (var i=0; i < list.length; i++) { | javascript | {
"resource": ""
} |
q42712 | srcFiles | train | function srcFiles() {
return removeDuplicates(configFiles().concat(libFiles()).concat(model | javascript | {
"resource": ""
} |
q42713 | otherNonJsFiles | train | function otherNonJsFiles() {
return removeDuplicates(files(cog.getConfig('src.other'), | javascript | {
"resource": ""
} |
q42714 | includeJsFiles | train | function includeJsFiles() {
if (cog.getOption('include_only_external')) {
return extLibFiles().concat(generatedJsFiles());
| javascript | {
"resource": ""
} |
q42715 | allJavascriptFiles | train | function allJavascriptFiles() {
return srcFiles().concat(otherJsFiles()).concat(unitTestFiles()).conca | javascript | {
"resource": ""
} |
q42716 | workTextFiles | train | function workTextFiles() {
return indexFiles().concat(srcFiles()).concat(allTestFiles()).concat(otherJsFiles()).concat(otherNonJsFiles()).concat(taskFiles()).concat(cssFiles())
| javascript | {
"resource": ""
} |
q42717 | generatedJsFiles | train | function generatedJsFiles(what) {
var ret = [];
if ((!what || what === 'templates') && cog.getOption('template')) {
ret.push({src: null, dst: cog.getOption('template')});
}
if (cog.getOption('compile_typescript')) {
| javascript | {
"resource": ""
} |
q42718 | fileCategoryMap | train | function fileCategoryMap() {
// Go over every file lookup function we export.
var exports = module.exports(grunt);
// This list of categories must contain all non-overlapping file categories.
var categories = ['extLibFiles', 'extLibMapFiles', 'extCssFiles', 'extFontFiles', 'fontFiles',
... | javascript | {
"resource": ""
} |
q42719 | validateBemJson | train | function validateBemJson(bemJson, fileName) {
let errors = [];
if (Array.isArray(bemJson)) {
bemJson.forEach((childBemJson) => {
errors = errors.concat(validateBemJson(childBemJson, fileName));
});
| javascript | {
"resource": ""
} |
q42720 | extractBemJsonNode | train | function extractBemJsonNode(bemJson) {
let result = JSON.parse(JSON.stringify(bemJson));
Object.keys(result).forEach((key) => {
| javascript | {
"resource": ""
} |
q42721 | train | function(){
var copy = [];
// Handle recursive loops
if ( queue.running ) {
queue.waiting = true;
return;
}
// Mark queue as running, then search for
queue.running = true;
munit.each( queue.modules, function( assert, index ) {
if ( ! queue.objects.length ) {
return false;
}
else if (... | javascript | {
"resource": ""
} | |
q42722 | recreate | train | function recreate(makeStream, options) {
if (options === undefined && isObject(makeStream)) {
options = makeStream;
makeStream = options.makeStream;
}
options = options || {};
if (options.connect === undefined) {
options.connect = true;
}
var connectedEvent = options.connectedEvent || 'open';... | javascript | {
"resource": ""
} |
q42723 | createServer | train | function createServer() {
grunt.log.ok('Registered as a grunt-net server | javascript | {
"resource": ""
} |
q42724 | train | function (token) {
var pp = new JavascriptPreprocessor(this.parser, this.compiler, this.actions, this.scope, this.state);
if (token) {
| javascript | {
"resource": ""
} | |
q42725 | train | function (action) {
if (action) {
switch (action.type) {
case "replace" :
this.code = `${ this.code.substr(0, action.start) }${ action.value }${ this.code.substr(action.end) }`;
return true;
case "remove" : | javascript | {
"resource": ""
} | |
q42726 | train | function (name, definition, is_return) {
var pp = this.$new(),
code = `PP.define("${ | javascript | {
"resource": ""
} | |
q42727 | train | function (code, tokens) {
var actions = [], i = 0;
this.code = code;
for (; i < tokens.length; ++i) { | javascript | {
"resource": ""
} | |
q42728 | train | function (code) {
try {
return this.parser.parse(code);
} catch(e) {
console.log("E", | javascript | {
"resource": ""
} | |
q42729 | callNew | train | function callNew(T, args)
{
return new | javascript | {
"resource": ""
} |
q42730 | earley | train | function earley(tokens, grammar) {
let states = Array.apply(null, Array(tokens.length + 1)).map(() => []);
var i, j;
let rulePairs = grammar.map((rule) => ({
name : rule.lhs.name,
rule : rule,
position: 0,
origin : 0
}));
[].push.apply(states[0], rulePairs);
for (i = 0; i <= token... | javascript | {
"resource": ""
} |
q42731 | removeUnfinishedItems | train | function removeUnfinishedItems(states) {
return states.map((state) => state.filter((earleyItem) => {
return | javascript | {
"resource": ""
} |
q42732 | swap | train | function swap(states) {
let newStates = Array.apply(null, Array(states.length)).map(() => []);
states.forEach((state, i) | javascript | {
"resource": ""
} |
q42733 | dfsHelper | train | function dfsHelper(states, root, state, depth, tokens) {
var edges;
// Base case: we finished the root rule
if (state === root.origin && depth === root.rule.length) {
return [];
}
// If the current production symbol is a terminal
if (root.rule[depth] instanceof RegExp) {
if (root.rule[depth].test(... | javascript | {
"resource": ""
} |
q42734 | remove | train | function remove(ddqBackendInstance, recordId, callback) {
// Note, this is not what we want.
// it does not handle the times when the
// isProcessing flag is true. | javascript | {
"resource": ""
} |
q42735 | requeue | train | function requeue(ddqBackendInstance, recordId, callback) {
var record;
record = ddqBackendInstance.getRecord(recordId);
| javascript | {
"resource": ""
} |
q42736 | Command | train | function Command (name, cli, action) {
if (!(this instanceof Command)) { | javascript | {
"resource": ""
} |
q42737 | sortedArray | train | function sortedArray(arr, comparator1, comparator2, comparator3) {
var _ = {};
arr = arr || [];
if (typeof arr._sortedArray === "object") {
throw new Error("(sortedArray) Cannot extend array: Special key _sortedArray is already defined. Did you apply it twice?");
}
arr._sortedArray = _;
... | javascript | {
"resource": ""
} |
q42738 | indexOf | train | function indexOf(element, fromIndex) {
/* jshint validthis:true */
var arr = toArray(this),
index;
if (fromIndex) {
arr = arr.slice(fromIndex);
}
| javascript | {
"resource": ""
} |
q42739 | reverse | train | function reverse() {
/* jshint validthis:true */
var _ = this._sortedArray,
reversed = _.reversed;
if (reversed) {
this.comparator = this.comparator.original;
} else | javascript | {
"resource": ""
} |
q42740 | sortedIndex | train | function sortedIndex(element) {
/* jshint validthis:true */
var index = binarySearch(toArray(this), element, this.comparator);
if (index < 0) {
// binarySearch decreases the negative index by one because otherwise the index 0 would stand for two results
| javascript | {
"resource": ""
} |
q42741 | pushSingle | train | function pushSingle(arr, element) {
var index = arr.sortedIndex(element),
_ = arr._sortedArray;
// original push and unshift are faster than splice
if (index === 0) {
| javascript | {
"resource": ""
} |
q42742 | getInversionOf | train | function getInversionOf(comparator) {
function inversion(a, b) {
return -comparator(a, b);
}
| javascript | {
"resource": ""
} |
q42743 | multipleComparators | train | function multipleComparators(comparators) {
return function applyComparators(a, b) {
var i,
result;
for (i = 0; i < comparators.length; i++) {
result = comparators[i](a, b);
if (result !== | javascript | {
"resource": ""
} |
q42744 | train | function(inName, inValue) {
this.attributes[inName] = inValue; | javascript | {
"resource": ""
} | |
q42745 | train | function(inClass) {
if (inClass && !this.hasClass(inClass)) {
| javascript | {
"resource": ""
} | |
q42746 | train | function(inClass) {
if (inClass && this.hasClass(inClass)) {
var c = this.getClassAttribute();
| javascript | {
"resource": ""
} | |
q42747 | train | function(inParentNode) {
// clean up render flags and memoizations
this.teardownRender();
// inParentNode can be a string id or a node reference
var pn = enyo.dom.byId(inParentNode);
if (pn == document.body) {
this.setupBodyFitting();
} else if (this.fit) { | javascript | {
"resource": ""
} | |
q42748 | train | function(inBounds, inUnit) {
var s = this.domStyles, unit = inUnit || "px";
var extents = ["width", "height", "left", "top", "right", "bottom"];
for (var i=0, b, e; e=extents[i]; i++) {
b = inBounds[e]; | javascript | {
"resource": ""
} | |
q42749 | train | function(inName, inValue) {
if (inValue === null || inValue === false || inValue === "") {
this.node.removeAttribute(inName);
| javascript | {
"resource": ""
} | |
q42750 | simpleGetStream | train | function simpleGetStream (opts) {
var stream = through2()
stream.req = simpleGet.call(this, opts, function callback (err, res) {
stream.res = res
if (err) | javascript | {
"resource": ""
} |
q42751 | multiDimArrayIndex | train | function multiDimArrayIndex (dimensions, indices) {
// Check that indices fit inside dimensions shape.
for (var i = 0; i < dimensions.length; i++) {
if (indices[i] > dimensions[i]) {
throw new TypeError(error.outOfBoundIndex)
}
}
var order = dimensions.length
// Handle order 1
if (order === ... | javascript | {
"resource": ""
} |
q42752 | hasPositionByBoardSize | train | function hasPositionByBoardSize(boardSize, position) {
return position && position.x >= 0 && position.y >= 0 && | javascript | {
"resource": ""
} |
q42753 | mapBoard | train | function mapBoard(board, func) {
return board.map(function (col) { | javascript | {
"resource": ""
} |
q42754 | getBoardWithPieces | train | function getBoardWithPieces(board, pieces) {
return mapBoard(board, function (p) {
var x = p.x,
y = p.y;
var | javascript | {
"resource": ""
} |
q42755 | getStartWhiteBlack | train | function getStartWhiteBlack(x, whiteY) {
return [{ x: x, y: 0, isBlack: true }, { | javascript | {
"resource": ""
} |
q42756 | addStartPieces | train | function addStartPieces(x, whiteY, positions) {
return x < 0 | javascript | {
"resource": ""
} |
q42757 | getPositionFromBoard | train | function getPositionFromBoard(board, position) {
try {
return board[position.y][position.x];
} catch (e) { | javascript | {
"resource": ""
} |
q42758 | getAllNearPositions | train | function getAllNearPositions(position) {
return [[-1, -1], [0, -1], [1, -1], [-1, 0], [1, 0], [-1, 1], [0, 1], [1, 1] | javascript | {
"resource": ""
} |
q42759 | getNearPositions | train | function getNearPositions(board, position) {
var nearPositions = _getNearPositions(getBoardSize(board), | javascript | {
"resource": ""
} |
q42760 | getEmptyNearPositions | train | function getEmptyNearPositions(board, position) {
return getNearPositions(board, position).filter(function (p) | javascript | {
"resource": ""
} |
q42761 | getNotEmptyNearPositions | train | function getNotEmptyNearPositions(board, position) {
return getNearPositions(board, | javascript | {
"resource": ""
} |
q42762 | getJumpXY | train | function getJumpXY(from, toJump) {
return {
x: getJump(from.x, toJump.x),
| javascript | {
"resource": ""
} |
q42763 | getBoardWhereCanIGo | train | function getBoardWhereCanIGo(board, from) {
var positions = getPositionsWhereCanIGo(board, from);
return mapBoard(board, function (position) | javascript | {
"resource": ""
} |
q42764 | getPiecesFromBoard | train | function getPiecesFromBoard(board) {
var initialPieces = {
white: [],
black: []
};
return board.reduce(function (piecesRow, row) {
return row.reduce(function (pieces, position) {
if (Position.hasBlackPiece(position)) pieces.black | javascript | {
"resource": ""
} |
q42765 | train | function(sessionId) {
if (sessionId) {
if (sessionId.length < 24) {
throw new CError('sid length undersized').log();
| javascript | {
"resource": ""
} | |
q42766 | getImageRaw | train | function getImageRaw(options, _onProgress = () => {}){
return new Promise((resolve, reject) => {
var request = new XMLHttpRequest();
request.open('GET', options.url, true);
request.responseType = options.responseType || 'blob';
function transferComplete(){
var res... | javascript | {
"resource": ""
} |
q42767 | JSONPRequest | train | function JSONPRequest(url, timeout = 3000){
var self = this;
self.timeout = timeout;
self.called = false;
if (window.document) {
var ts = Date.now();
self.scriptTag = window.document.createElement('script');
// url += '&callback=window.__jsonpHandler_' + ts;
var _url = ''... | javascript | {
"resource": ""
} |
q42768 | copy | train | function copy(source, target) {
for (var name in source) {
if (source.hasOwnProperty(name)) {
| javascript | {
"resource": ""
} |
q42769 | train | function(localPath, globalPath)
{
if (!(this instanceof HAControl))
{
return new HAControl(localPath, globalPath);
}
this.localHa = true;
| javascript | {
"resource": ""
} | |
q42770 | _keySourceHintFrom | train | function _keySourceHintFrom( method, source, environment ){
var hints = [];
if( method ) hints.push( method );
if( source ) hints.push( source | javascript | {
"resource": ""
} |
q42771 | isGoogCallExpression | train | function isGoogCallExpression(node, name) {
const callee = node.callee;
return callee && callee.type === 'MemberExpression' &&
callee.object.type === 'Identifier' && callee.object.name === 'goog' &&
| javascript | {
"resource": ""
} |
q42772 | isGoogStatement | train | function isGoogStatement(node, name) {
return node.expression && node.expression.type === 'CallExpression' && | javascript | {
"resource": ""
} |
q42773 | train | function () {
logger.info('Records sent to Tone Analyzer: ' + amaStats.processed_record_count);
// these records could be fetched using other API calls
logger.info('Records missing (no comment text available): ' + amaStats.missing_record_count);
logger.info('Maximum processed comment thread depth: '... | javascript | {
"resource": ""
} | |
q42774 | listFiles | train | function listFiles(dir, callback) {
return new Promise((resolveThis, reject) => {
walk.walk(dir, { followLinks: true })
.on('file', (root, stats, next) => {
const destDir = relative(dir, root);
| javascript | {
"resource": ""
} |
q42775 | symlinkOrCopySync | train | function symlinkOrCopySync(dir, target) {
try {
symlinkOrCopy.sync(dir, target);
} catch (e) {
if (existsSync(target)) {
| javascript | {
"resource": ""
} |
q42776 | Tree | train | function Tree(source, parent, githubClient) {
this.gh = githubClient;
this.sha = source.sha;
| javascript | {
"resource": ""
} |
q42777 | task | train | function task() {
// make sure the release task has been initialized
init.apply(this, arguments);
var name, desc, deps, cb;
for (var i = 0; i < arguments.length; i++) {
if (typeof arguments[i] === 'string') {
if (name) {
desc = arguments[i];
} else {
name = arguments[i];
}
} else if (typeof arg... | javascript | {
"resource": ""
} |
q42778 | taskCallback | train | function taskCallback(fn) {
return fn.length ? taskAsyncCb : taskSyncCb;
function taskAsyncCb(cb) {
return taskCb(this || {}, arguments, fn, cb, true);
}
function taskSyncCb() {
return taskCb(this || {}, arguments, fn, null, false);
}
function taskCb(cxt, args, fn, done, isAsync) {
cxt.done = isAsync && typ... | javascript | {
"resource": ""
} |
q42779 | processTemplate | train | function processTemplate(val, data) {
if (rbot.env.usingGrunt) {
return rbot.env.taskRunner.template.process(val, data);
}
// TODO : add gulp | javascript | {
"resource": ""
} |
q42780 | train | function (emits, message, daemonPid) {
var monitor = new Monitor(message, options, daemonPid, shutdown, child, function () {
// emit events before starting child
Object.keys(emits).forEach(function (name) {
// skip the process event until the child spawns
if (name === 'process') return;... | javascript | {
"resource": ""
} | |
q42781 | train | function(other) {
if (other.getSessionToken()) {
this._sessionToken = other.getSessionToken();
} | javascript | {
"resource": ""
} | |
q42782 | train | function(attrs) {
if (attrs.sessionToken) {
this._sessionToken = attrs.sessionToken;
delete attrs.sessionToken;
}
| javascript | {
"resource": ""
} | |
q42783 | train | function(provider, options) {
var authType;
if (_.isString(provider)) {
authType = provider;
provider = Parse.User._authProviders[provider];
} else {
authType = provider.getAuthType();
}
var newOptions = _.clone(options);
var self = this;
newOptions.auth... | javascript | {
"resource": ""
} | |
q42784 | train | function(email, options) {
options = options || {};
var request = Parse._request({
route: "requestPasswordReset",
method: "POST",
| javascript | {
"resource": ""
} | |
q42785 | train | function() {
if (Parse.User._currentUser) {
return Parse.User._currentUser;
}
if (Parse.User._currentUserMatchesDisk) {
return Parse.User._currentUser;
}
// Load the user from local storage.
Parse.User._currentUserMatchesDisk = true;
var userData = P... | javascript | {
"resource": ""
} | |
q42786 | train | function(){
spy.history = [];
spy.args = [];
spy.count = 0;
spy.scope = | javascript | {
"resource": ""
} | |
q42787 | train | function(){
if ( spy.wrapped ) {
spy._module[ | javascript | {
"resource": ""
} | |
q42788 | SpyCall | train | function SpyCall( scope, args, spy ) {
var self = this;
if ( ! ( self instanceof SpyCall ) ) {
return new SpyCall( args );
}
self.scope = scope;
self.args = args;
self.time = new Date();
| javascript | {
"resource": ""
} |
q42789 | translate | train | function translate(tx) {
var ty = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
return {
| javascript | {
"resource": ""
} |
q42790 | log | train | function log(msg) {
process.stdout.write(time + ' ');
| javascript | {
"resource": ""
} |
q42791 | mixInTo | train | function mixInTo(target) {
var descriptor;
for (var key in this) {
if ((descriptor = | javascript | {
"resource": ""
} |
q42792 | mixIn | train | function mixIn(source) {
var descriptor;
for (var key in source) {
if ((descriptor = | javascript | {
"resource": ""
} |
q42793 | cleanObject | train | function cleanObject(obj) {
if (obj instanceof Object) {
Object.keys(obj).forEach((key) => (obj[key] == | javascript | {
"resource": ""
} |
q42794 | getDockerfileContext | train | function getDockerfileContext(context) {
const fs = require('fs');
let files = [];
let dockerfile = exports.resolveDockerfile(context);
let file = fs.readFileSync(dockerfile, {encoding: 'utf8'});
for (let line of file.split('\n')) {
if (line.match(/^\s*(ADD|COPY).*$/)) {
let entries = line.split(' '... | javascript | {
"resource": ""
} |
q42795 | tagOutput | train | function tagOutput(descriptor, innerDescriptor, name) {
var out = '<' + name + innerDescriptor.attributes;
if (innerDescriptor.style)
out += ' style="' + innerDescriptor.style + '"';
if (innerDescriptor.classes)
out += ' class="' + innerDescriptor.classes + '"';
if (innerDescriptor.children)
descriptor.childr... | javascript | {
"resource": ""
} |
q42796 | train | function(width, height){
var canvas = document.createElement("canvas");
canvas.width = width;
canvas.height = height;
var context = canvas.getContext("2d");
var imageData = context.getImageData(0, 0, width, height);
var buffer = new ArrayBuffer(width*height*4);
var buffer8 = new Uint8Clamped... | javascript | {
"resource": ""
} | |
q42797 | FileEmitter | train | function FileEmitter(folder, opt_options) {
if (!(this instanceof FileEmitter)) {
return new FileEmitter(folder, opt_options);
}
events.EventEmitter.call(this);
opt_options = opt_options || {};
this.root = path.resolve(process.cwd(), folder);
// flags & options
this.buffer = opt_options.buffer || fa... | javascript | {
"resource": ""
} |
q42798 | reportCoverage | train | function reportCoverage(cov) {
// Stats
print('\n [bold]{Test Coverage}\n');
var sep = ' +------------------------------------------+----------+------+------+--------+',
lastSep = ' +----------+------+------+--------+';
result = sep+'\n';
result ... | javascript | {
"resource": ""
} |
q42799 | populateCoverage | train | function populateCoverage(cov) {
cov.LOC =
cov.SLOC =
cov.totalFiles =
cov.totalHits =
cov.totalMisses =
cov.coverage = 0;
for (var name in cov) {
var file = cov[name];
if (Array.isArray(file)) {
// Stats
++cov.totalFiles;
cov.totalHits += ... | javascript | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.