_id stringlengths 2 6 | title stringlengths 0 58 | partition stringclasses 3
values | text stringlengths 52 373k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q5500 | formatIf | train | function formatIf (bool, format, arr, ref) {
if (bool) {
arr.unshift(format)
return util.format.apply({}, arr)
}
else
return ref
} | javascript | {
"resource": ""
} |
q5501 | prependUntilLength | train | function prependUntilLength (str, len, char) {
if (str.length >= len)
return str
else
return prependUntilLength(str=char+str, len, char)
} | javascript | {
"resource": ""
} |
q5502 | defined | train | function defined () {
for (var i=0; i<arguments.length; i++)
if (typeof arguments[i] !== 'undefined')
return arguments[i]
} | javascript | {
"resource": ""
} |
q5503 | Remote | train | function Remote(connection) {
this.timeout = 5000;
this._connection = connection;
this._handlers = {};
this._requestID = 1;
var self = this;
this._connection.addListener('response', function(res) {
if (res.id === null || res.id === undefined) { return; }
var handler = self._handlers[res.id];
... | javascript | {
"resource": ""
} |
q5504 | validate | train | function validate(args, required) {
var result = {
error: false,
message: 'No errors'
}
// ensure required properties were passed in the arguments hash
if (required) {
var keys = _.keys(args);
required.forEach(function(field) {
if(!_.contains(keys, field)) {
re... | javascript | {
"resource": ""
} |
q5505 | makeLogLineProto | train | function makeLogLineProto(message, time, level) {
var userAppLogLine = new apphosting.UserAppLogLine();
userAppLogLine.setTimestampUsec((time * 1000).toString());
userAppLogLine.setLevel(level);
userAppLogLine.setMessage(message);
return userAppLogLine;
} | javascript | {
"resource": ""
} |
q5506 | makeMemcacheSetProto | train | function makeMemcacheSetProto(key, value) {
var memcacheSetRequest = new apphosting.MemcacheSetRequest();
var item = new apphosting.MemcacheSetRequest.Item();
item.setKey(key);
item.setValue(value);
item.setSetPolicy(apphosting.MemcacheSetRequest.SetPolicy.SET);
memcacheSetRequest.addItem(item);
return me... | javascript | {
"resource": ""
} |
q5507 | makeTaskqueueAddProto | train | function makeTaskqueueAddProto(taskOptions) {
var taskqueueAddRequest = new apphosting.TaskQueueAddRequest();
taskqueueAddRequest.setUrl(taskOptions.url);
taskqueueAddRequest.setQueueName(goog.isDefAndNotNull(taskOptions.queueName) ?
taskOptions.queueName : 'default');
taskqueueAddRequest.setTaskName(goog.i... | javascript | {
"resource": ""
} |
q5508 | makeBackgroundRequest | train | function makeBackgroundRequest(req, appId, moduleName, moduleVersion, moduleInstance, appengine) {
var escapedAppId = appId.replace(/[:.]/g, '_');
var token = escapedAppId + '/' + moduleName + '.' + moduleVersion + '.' + moduleInstance;
var result = {
appengine: {
devappserver: req.appengine.devappserve... | javascript | {
"resource": ""
} |
q5509 | makeModulesGetHostnameProto | train | function makeModulesGetHostnameProto(module, version, instance) {
var getHostnameRequest = new apphosting.GetHostnameRequest();
getHostnameRequest.setModule(module);
getHostnameRequest.setVersion(version);
getHostnameRequest.setInstance(instance);
return getHostnameRequest;
} | javascript | {
"resource": ""
} |
q5510 | servoLoop | train | function servoLoop() {
timer = setTimeout(servoLoop, 500);
pwm.setPulseLength(steeringChannel, pulseLengths[nextPulse]);
nextPulse = (nextPulse + 1) % pulseLengths.length;
} | javascript | {
"resource": ""
} |
q5511 | numberArrayToString | train | function numberArrayToString(a) {
var s = '';
for (var i in a) {
s += String.fromCharCode(a[i]);
}
return s;
} | javascript | {
"resource": ""
} |
q5512 | stringToUint8Array | train | function stringToUint8Array(s) {
var a = new Uint8Array(s.length);
for(var i = 0, j = s.length; i < j; ++i) {
a[i] = s.charCodeAt(i);
}
return a;
} | javascript | {
"resource": ""
} |
q5513 | Server | train | function Server(clientListener) {
net.Server.call(this);
this._services = [];
if (clientListener) { this.addListener('client', clientListener); }
var self = this;
this.addListener('connection', function(socket) {
var connection = new Connection(socket);
connection.once('connect', function(remote... | javascript | {
"resource": ""
} |
q5514 | synthesizeUrl | train | function synthesizeUrl(serviceConfig, req, res) {
const parameters = _.map(serviceConfig.getParameters(req, res), (value, key) => {
return `${key}=${value}`;
}).join('&');
if (parameters) {
return encodeURI(`${serviceConfig.getUrl(req)}?${parameters}`);
} else {
return serviceConfig.getUrl(req);
... | javascript | {
"resource": ""
} |
q5515 | parse | train | function parse(string) {
var buffer = newBufferFromSize(16);
var j = 0;
for (var i = 0; i < 16; i++) {
buffer[i] = hex2byte[string[j++] + string[j++]];
if (i === 3 || i === 5 || i === 7 || i === 9) {
j += 1;
}
}
return buffer;
} | javascript | {
"resource": ""
} |
q5516 | uuidNamed | train | function uuidNamed(hashFunc, version, arg1, arg2) {
var options = arg1 || {};
var callback = typeof arg1 === "function" ? arg1 : arg2;
var namespace = options.namespace;
var name = options.name;
var hash = crypto.createHash(hashFunc);
if (typeof namespace === "string") {
if (!check(n... | javascript | {
"resource": ""
} |
q5517 | train | async function( req, res, next ) {
try {
var csrfToken = 'default'
if ( req.cookies && req.cookies[ 'pong-security' ] ) {
var token = req.cookies[ 'pong-security' ]
if ( gui.getCsrfTokenForUser ) {
csrfToken = await gui.getCsrfTokenForUser( token )
} else if ( gui.user... | javascript | {
"resource": ""
} | |
q5518 | ensureAuthenticated | train | function ensureAuthenticated(req, res, next) {
if (req.isAuthenticated()) {
req.authClient = new googleapis.auth.OAuth2(GOOGLE_CLIENT_ID, GOOGLE_CLIENT_SECRET);
req.authClient.credentials = req.session.googleCredentials;
return next();
}
res.redirect('/');
} | javascript | {
"resource": ""
} |
q5519 | hasEmberVersion | train | function hasEmberVersion(major, minor) {
const numbers = VERSION.split('-')[0].split('.');
const actualMajor = parseInt(numbers[0], 10);
const actualMinor = parseInt(numbers[1], 10);
return actualMajor > major || (actualMajor === major && actualMinor >= minor);
} | javascript | {
"resource": ""
} |
q5520 | chain_requests | train | function chain_requests(ml, url) {
return (batches) => {
let promise = new Promise((resolve, reject) => resolve(new MonkeyLearnResponse()));
// attach requests for all the batches sequentially to the original promise and return _that_
return batches.reduce((promise, batch) =>
promise.then((response... | javascript | {
"resource": ""
} |
q5521 | generator | train | function generator(n) {
if (!n) return Date.now().toString(36).toUpperCase();
return Math.random().toString(36).substring(2, 10).toUpperCase();
} | javascript | {
"resource": ""
} |
q5522 | Pagelet | train | function Pagelet(options) {
if (!this) return new Pagelet(options);
this.fuse();
options = options || {};
//
// Use the temper instance on Pipe if available.
//
if (options.bigpipe && options.bigpipe._temper) {
options.temper = options.bigpipe._temper;
}
this.writable('_enabled', []); ... | javascript | {
"resource": ""
} |
q5523 | fragment | train | function fragment(content) {
var active = pagelet.active;
if (!active) content = '';
if (mode === 'sync') return fn.call(context, undefined, content);
data.id = data.id || pagelet.id; // Pagelet id.
data.path = data.path || pagelet.path; // Reference to the path.
data... | javascript | {
"resource": ""
} |
q5524 | optimizer | train | function optimizer(Pagelet, next) {
var prototype = Pagelet.prototype
, method = prototype.method
, status = prototype.status
, router = prototype.path
, name = prototype.name
, view = prototype.view
, log = debug('pagelet:'+ name);
//
// Generate a unique ID used for re... | javascript | {
"resource": ""
} |
q5525 | worldDebug | train | function worldDebug() {
Crafty.e( RenderingMode + ', Color' )
.attr( {
x: engine.world.bounds.min.x,
y: engine.world.bounds.min.y,
w: engine.world.bounds.max.x - engine.world.bounds.min.x,
h: engine.world.bounds.max.y - engine.world.bounds.min.y,
alpha: 0.5
} )
.color( 'green' );
} | javascript | {
"resource": ""
} |
q5526 | train | function( options, part, isSleeping ) {
var entity = part.entity;
if ( options.showSleeping && isSleeping ) {
entity.alpha = 0.5;
}
if ( entity._x !== part.position.x - ( entity._w / 2 ) ) {
entity.matterMoved = true;
entity.x = part.position.... | javascript | {
"resource": ""
} | |
q5527 | train | function( entity, angle ) {
var angleFixed = Crafty.math.radToDeg( angle ).toFixed( 3 );
if ( angle === 0 || entity._rotation === angleFixed ) {
return;
}
entity.matterMoved = true;
entity.rotation = angleFixed;
debug.rotateEntity( [ entity, angleFi... | javascript | {
"resource": ""
} | |
q5528 | train | function( pointA, pointB ) {
var vector = _getVector( pointA, pointB );
return -Crafty.math.radToDeg( Math.atan2( vector.y, vector.x ) ).toFixed( 3 );
} | javascript | {
"resource": ""
} | |
q5529 | train | function( pointA, pointB ) {
return { x: pointB.x - pointA.x, y: -( pointB.y - pointA.y ) };
} | javascript | {
"resource": ""
} | |
q5530 | Models | train | function Models(ml, base_url) {
this.ml = ml;
this.base_url = base_url;
if (includes(base_url, 'classifiers')) {
this.run_action = 'classify';
} else if (includes(base_url, 'extractors')) {
this.run_action = 'extract';
} else {
this.run_action = undefined;
}
} | javascript | {
"resource": ""
} |
q5531 | ReconnectingWebSocket | train | function ReconnectingWebSocket (url, options) {
var me = this;
this.id = options && options.id || randomUUID();
this.url = url + '/?id=' + this.id;
this.socket = null;
this.opened = false;
this.closed = false;
this.options = {
reconnectTimeout: Infinity, // ms
reconnectInterval: 5000 // ms
... | javascript | {
"resource": ""
} |
q5532 | train | function(jwt) {
try {
var segments = jwt.split('.');
this.signature = segments.pop();
this.signatureBase = segments.join('.');
this.header = decodeSegment(segments.shift());
this.payload = decodeSegment(segments.shift());
} catch (e) {
throw new Error("Unable to parse JWT");
}
} | javascript | {
"resource": ""
} | |
q5533 | gulpBower | train | function gulpBower(opts, cmdArguments) {
opts = parseOptions(opts);
log.info('Using cwd: ' + opts.cwd);
log.info('Using bower dir: ' + opts.directory);
cmdArguments = createCmdArguments(cmdArguments, opts);
var bowerCommand = getBowerCommand(cmd);
var stream = through.obj(function (file, enc,... | javascript | {
"resource": ""
} |
q5534 | parseOptions | train | function parseOptions(opts) {
opts = opts || {};
if (toString.call(opts) === '[object String]') {
opts = {
directory: opts
};
}
opts.cwd = opts.cwd || process.cwd();
log.verbosity = toString.call(opts.verbosity) === '[object Number]' ? opts.verbosity : DEFAULT_VERBOSITY... | javascript | {
"resource": ""
} |
q5535 | getDirectoryFromBowerRc | train | function getDirectoryFromBowerRc(cwd) {
var bowerrc = path.join(cwd, '.bowerrc');
if (!fs.existsSync(bowerrc)) {
return '';
}
var bower_config = {};
try {
bower_config = JSON.parse(fs.readFileSync(bowerrc));
} catch (err) {
return '';
}
return bower_config.dire... | javascript | {
"resource": ""
} |
q5536 | createCmdArguments | train | function createCmdArguments(cmdArguments, opts) {
if (toString.call(cmdArguments) !== '[object Array]') {
cmdArguments = [];
}
if (toString.call(cmdArguments[0]) !== '[object Array]') {
cmdArguments[0] = [];
}
cmdArguments[1] = cmdArguments[1] || {};
cmdArguments[2] = opts;
... | javascript | {
"resource": ""
} |
q5537 | getBowerCommand | train | function getBowerCommand(cmd) {
// bower has some commands that are provided in a nested object structure, e.g. `bower cache clean`.
var bowerCommand;
// clean up the command given, to avoid unnecessary errors
cmd = cmd.trim();
var nestedCommand = cmd.split(' ');
if (nestedCommand.length > 1)... | javascript | {
"resource": ""
} |
q5538 | writeStreamToFs | train | function writeStreamToFs(opts, stream) {
var baseDir = path.join(opts.cwd, opts.directory);
var walker = walk.walk(baseDir);
walker.on('errors', function (root, stats, next) {
stream.emit('error', new PluginError(PLUGIN_NAME, stats.error));
next();
});
walker.on('directory', functio... | javascript | {
"resource": ""
} |
q5539 | train | function(options, authorizationCode, idToken, accessToken) {
this.options = options;
this.authorizationCode = authorizationCode;
this.profile = {};
this.credentials = {
id_token: idToken,
access_token: accessToken
};
this.now = Date.now();
this.apiKey = options.apiKey;
this.clientId = options.cl... | javascript | {
"resource": ""
} | |
q5540 | train | function(location) {
var found = false;
while(!found) {
if (exists(location + '/package.json')) {
found = location;
} else if (location !== '/') {
location = path.dirname(location);
} else {
return false;
}
}
return location;
} | javascript | {
"resource": ""
} | |
q5541 | train | function(name) {
// Walk up the module call tree until we find a module containing name in its peerOptionalDependencies
var currentModule = module;
var found = false;
while (currentModule) {
// Check currentModule has a package.json
location = currentModule.filename;
var location = find_package_json... | javascript | {
"resource": ""
} | |
q5542 | ReconnectingConnection | train | function ReconnectingConnection(id, connection) {
this.id = id;
this.connection = null;
this.closed = false;
this.queue = [];
this.setConnection(connection);
} | javascript | {
"resource": ""
} |
q5543 | ReconnectingWebSocketServer | train | function ReconnectingWebSocketServer (options, callback) {
var me = this;
this.port = options && options.port || null;
this.server = new WebSocketServer({port: this.port}, callback);
this.connections = {};
this.server.on('connection', function (conn) {
var urlParts = url.parse(conn.upgradeReq.url, true)... | javascript | {
"resource": ""
} |
q5544 | extract | train | function extract(str, options) {
const defaults = { tolerant: true, comment: true, tokens: true, range: true, loc: true };
const tokens = esprima.tokenize(str, Object.assign({}, defaults, options));
const comments = [];
for (let i = 0; i < tokens.length; i++) {
let n = i + 1;
const token = tokens[i];
... | javascript | {
"resource": ""
} |
q5545 | train | function (count, fn) { // 55
var self = this; // 56
var timeout = self._timeout(count); // 57
if (self.retryTimer) // 58
clea... | javascript | {
"resource": ""
} | |
q5546 | train | function (isSignaled, options) {
this.queue = [];
this.isSignaled = Boolean(isSignaled);
this.options = _.extend({}, ResetEvent.defaultOptions, options);
} | javascript | {
"resource": ""
} | |
q5547 | onClientPostRequestHandler | train | function onClientPostRequestHandler (ctx, err) {
// extension error
if (err) {
let error = null;
if (err instanceof SuperError) {
error = err.rootCause || err.cause || err;
} else {
error = err;
}
const internalError = new Errors.MostlyError(Constants.EXTENSION_ERROR, ctx.errorDetail... | javascript | {
"resource": ""
} |
q5548 | onClientTimeoutPostRequestHandler | train | function onClientTimeoutPostRequestHandler (ctx, err) {
if (err) {
let error = null;
if (err instanceof SuperError) {
error = err.rootCause || err.cause || err;
} else {
error = err;
}
let internalError = new Errors.MostlyError(Constants.EXTENSION_ERROR).causedBy(err);
ctx.log.err... | javascript | {
"resource": ""
} |
q5549 | onPreRequestHandler | train | function onPreRequestHandler (ctx, err) {
let m = ctx._encoderPipeline.run(ctx._message, ctx);
// encoding issue
if (m.error) {
let error = new Errors.ParseError(Constants.PAYLOAD_PARSING_ERROR).causedBy(m.error);
ctx.log.error(error);
ctx.emit('clientResponseError', error);
ctx._execute(error);... | javascript | {
"resource": ""
} |
q5550 | onServerPreHandler | train | function onServerPreHandler (ctx, err, value) {
if (err) {
if (err instanceof SuperError) {
ctx._response.error = err.rootCause || err.cause || err;
} else {
ctx._response.error = err;
}
const internalError = new Errors.MostlyError(
Constants.EXTENSION_ERROR, ctx.errorDetails).cau... | javascript | {
"resource": ""
} |
q5551 | onServerPreRequestHandler | train | function onServerPreRequestHandler (ctx, err, value) {
if (err) {
if (err instanceof SuperError) {
ctx._response.error = err.rootCause || err.cause || err;
} else {
ctx._response.error = err;
}
return ctx.finish();
}
// reply value from extension
if (value) {
ctx._response.payl... | javascript | {
"resource": ""
} |
q5552 | onServerPreResponseHandler | train | function onServerPreResponseHandler (ctx, err, value) {
// check if an error was already wrapped
if (ctx._response.error) {
ctx.emit('serverResponseError', ctx._response.error);
ctx.log.error(ctx._response.error);
} else if (err) { // check for an extension error
if (err instanceof SuperError) {
... | javascript | {
"resource": ""
} |
q5553 | onClose | train | function onClose (ctx, err, val, cb) {
// no callback no queue processing
if (!_.isFunction(cb)) {
ctx._heavy.stop();
ctx._transport.close();
if (err) {
ctx.log.fatal(err);
ctx.emit('error', err);
}
return;
}
// unsubscribe all active subscriptions
ctx.removeAll();
// wait ... | javascript | {
"resource": ""
} |
q5554 | checkPlugin | train | function checkPlugin (fn, version) {
if (typeof fn !== 'function') {
throw new TypeError(`mostly-plugin expects a function, instead got a '${typeof fn}'`);
}
if (version) {
if (typeof version !== 'string') {
throw new TypeError(`mostly-plugin expects a version string as second parameter, instead go... | javascript | {
"resource": ""
} |
q5555 | getControllerDir | train | function getControllerDir(isInstall) {
// Find the js-controller location
const possibilities = ["iobroker.js-controller", "ioBroker.js-controller"];
let controllerPath;
for (const pkg of possibilities) {
try {
const possiblePath = require.resolve(pkg);
if (fs.existsSync(... | javascript | {
"resource": ""
} |
q5556 | train | function (cb) {
Model.findById(parentPk, { include: [{ all : true }]}).then(function(parentRecord) {
if (!parentRecord) return cb({status: 404});
if (!parentRecord[relation]) { return cb({status: 404}); }
cb(null, parentRecord);
}).catch(function(err){
return cb(err);
}... | javascript | {
"resource": ""
} | |
q5557 | createChild | train | function createChild(customCb) {
ChildModel.create(child).then(function(newChildRecord){
if (req._sails.hooks.pubsub) {
if (req.isSocket) {
ChildModel.subscribe(req, newChildRecord);
ChildModel.introduce(newChildRecord);
}
ChildModel.pu... | javascript | {
"resource": ""
} |
q5558 | train | function () {
if (_uniq(matchup, true).length < 2) return 1
return matchup.indexOf(Math.max.apply(Math, matchup))
} | javascript | {
"resource": ""
} | |
q5559 | train | function () {
if (_uniq(matchup, true).length < 2) return 0
return matchup.indexOf(Math.min.apply(Math, matchup))
} | javascript | {
"resource": ""
} | |
q5560 | isIrrelevant | train | function isIrrelevant(tile) {
return !tile
|| !tile.physics
|| !tile.physics.matterBody
|| !tile.physics.matterBody.body
|| !tile.physics.matterBody.body.vertices
|| !tile.physics.slopes
|| !tile.physics.slopes.neighbours
|| !tile.physics.slopes.edges;
} | javascript | {
"resource": ""
} |
q5561 | containsNormal | train | function containsNormal(normal, normals) {
let n;
for (n = 0; n < normals.length; n++) {
if (!normals[n].ignore && Vector.dot(normal, normals[n]) === 1) {
return true;
}
}
return false;
} | javascript | {
"resource": ""
} |
q5562 | buildEdgeVertex | train | function buildEdgeVertex(index, x, y, tileBody, isGhost) {
let vertex = {
x: x,
y: y,
index: index,
body: tileBody,
isInternal: false,
isGhost: isGhost,
contact: null
};
vertex.contact = {
vertex: vertex,
normalImpulse: 0,
tangentImpulse: 0
};
return vertex;
} | javascript | {
"resource": ""
} |
q5563 | buildEdge | train | function buildEdge(vertex1, vertex2, tileBody, vertex0, vertex3) {
vertex0 = vertex0 || null;
vertex3 = vertex3 || null;
let vertices = [];
// Build the vertices
vertices.push(
vertex0 ? buildEdgeVertex(0, vertex0.x, vertex0.y, tileBody, true) : null,
buildEdgeVertex(1, vertex1.x, vertex1.y, tileBody),
bu... | javascript | {
"resource": ""
} |
q5564 | isAxisAligned | train | function isAxisAligned(vector) {
for (let d in Constants.Directions) {
let direction = Constants.Directions[d];
if (Vector.dot(direction, vector) === 1) {
return true;
}
}
return false;
} | javascript | {
"resource": ""
} |
q5565 | train | function (tilemapLayer, tiles) {
let i, layerData = tilemapLayer.layer;
// Pre-process the tiles
for (i in tiles) {
let tile = tiles[i];
tile.physics.slopes = tile.physics.slopes || {};
tile.physics.slopes = {
neighbours: {
up: GetTileAt(tile.x, tile.y - 1, true, layerData),
down... | javascript | {
"resource": ""
} | |
q5566 | train | function (firstEdge, secondEdge) {
if (firstEdge === Constants.SOLID && secondEdge === Constants.SOLID) {
return Constants.EMPTY;
}
if (firstEdge === Constants.SOLID && secondEdge === Constants.EMPTY) {
return Constants.EMPTY;
}
return firstEdge;
} | javascript | {
"resource": ""
} | |
q5567 | train | function (tiles) {
const maxDist = 5;
const directNeighbours = ['up', 'down', 'left', 'right'];
let t, tile, n, neighbour, i, j, tv, nv, tn, nn;
for (t = 0; t < tiles.length; t++) {
tile = tiles[t];
// Skip over irrelevant tiles
if (isIrrelevant(tile)) {
continue;
}
// Grab the ... | javascript | {
"resource": ""
} | |
q5568 | onClientPreRequestCircuitBreaker | train | function onClientPreRequestCircuitBreaker (ctx, next) {
if (ctx._config.circuitBreaker.enabled) {
// any pattern represent an own circuit breaker
const circuitBreaker = ctx._circuitBreakerMap.get(ctx.trace$.method);
if (!circuitBreaker) {
const cb = new CircuitBreaker(ctx._config.circuitBreaker);
... | javascript | {
"resource": ""
} |
q5569 | train | function (namespace) {
if (namespace) {
if (!this.namespaces[namespace]) {
return []
}
return _.keys(this.namespaces[namespace].services)
} else {
const r = []
_.forOwn(this.namespaces, n => r.push(..._.keys(n.services)))
return r
}
} | javascript | {
"resource": ""
} | |
q5570 | train | function (service) {
let s
const ns = _.values(this.namespaces)
if (!ns || !ns.length) {
return s
}
for (let i = 0; i < ns.length; i++) {
const n = ns[i]
if (n.services[service]) {
s = n.services[service]
break
}
}
return s
... | javascript | {
"resource": ""
} | |
q5571 | hasKey | train | function hasKey(key) {
return data.meta[key] !== undefined
&& (self.lookup[key] === null ||
self.lookup[key] === data.meta[key]);
} | javascript | {
"resource": ""
} |
q5572 | render | train | function render(file, data, outputDir) {
if (!argv.unsafe && path.extname(file) === '.html')
return console.error(chalk.red(file + ': To use .html as source files, add --unsafe/-u flag'))
env.render(file, data, function(err, res) {
if (err) return console.error(chalk.red(err))
var outputFile = file.rep... | javascript | {
"resource": ""
} |
q5573 | renderAll | train | function renderAll(files, data, outputDir) {
for (var i = 0; i < files.length; i++) {
render(files[i], data, outputDir)
}
} | javascript | {
"resource": ""
} |
q5574 | yarn | train | function yarn(cmds, args, cb) {
if (typeof args === 'function') {
return yarn(cmds, [], args);
}
args = arrayify(cmds).concat(arrayify(args));
spawn('yarn', args, {cwd: cwd, stdio: 'inherit'})
.on('error', cb)
.on('close', function(code, err) {
cb(err, code);
});
} | javascript | {
"resource": ""
} |
q5575 | deps | train | function deps(type, flags, names, cb) {
names = flatten([].slice.call(arguments, 2));
cb = names.pop();
if (type && names.length === 0) {
names = keys(type);
}
if (!names.length) {
cb();
return;
}
yarn.add(arrayify(flags).concat(names), cb);
} | javascript | {
"resource": ""
} |
q5576 | train | function (options) {
this.queue = [];
this.ownerTokenId = null;
this.options = _.extend({}, AsyncLock.defaultOptions, options);
} | javascript | {
"resource": ""
} | |
q5577 | applyGroupBy | train | function applyGroupBy(images, options) {
return Promise.reduce(options.groupBy, function (images, group) {
return Promise.map(images, function (image) {
return Promise.resolve(group(image)).then(function (group) {
if (group) {
image.groups.push(group);
}
return image;
}).catch(function (image)... | javascript | {
"resource": ""
} |
q5578 | setTokens | train | function setTokens(images, options, css) {
return new Promise(function (resolve) {
css.walkAtRules('lazysprite', function (atRule) {
// Get the directory of images from atRule value
var params = space(atRule.params);
var atRuleValue = getAtRuleValue(params);
var sliceDir = atRuleValue[0];
var sliceDir... | javascript | {
"resource": ""
} |
q5579 | saveSprites | train | function saveSprites(images, options, sprites) {
return new Promise(function (resolve, reject) {
if (!fs.existsSync(options.spritePath)) {
mkdirp.sync(options.spritePath);
}
var all = _
.chain(sprites)
.map(function (sprite) {
sprite.path = makeSpritePath(options, sprite.groups);
var deferred =... | javascript | {
"resource": ""
} |
q5580 | mapSpritesProperties | train | function mapSpritesProperties(images, options, sprites) {
return new Promise(function (resolve) {
sprites = _.map(sprites, function (sprite) {
return _.map(sprite.coordinates, function (coordinates, imagePath) {
return _.merge(_.find(images, {path: imagePath}), {
coordinates: coordinates,
spritePath... | javascript | {
"resource": ""
} |
q5581 | updateReferences | train | function updateReferences(images, options, sprites, css) {
return new Promise(function (resolve) {
css.walkComments(function (comment) {
var rule, image, backgroundImage, backgroundPosition, backgroundSize;
// Manipulate only token comments
if (isToken(comment)) {
// Match from the path with the tokens ... | javascript | {
"resource": ""
} |
q5582 | makeSpritePath | train | function makeSpritePath(options, groups) {
var base = options.spritePath;
var file;
// If is svg, do st
if (groups.indexOf('GROUP_SVG_FLAG') > -1) {
groups = _.filter(groups, function (item) {
return item !== 'GROUP_SVG_FLAG';
});
file = path.resolve(base, groups.join('.') + '.svg');
} else {
file = pa... | javascript | {
"resource": ""
} |
q5583 | getBackgroundPosition | train | function getBackgroundPosition(image) {
var logicValue = image.isSVG ? 1 : -1;
var x = logicValue * (image.ratio > 1 ? image.coordinates.x / image.ratio : image.coordinates.x);
var y = logicValue * (image.ratio > 1 ? image.coordinates.y / image.ratio : image.coordinates.y);
var template = _.template('<%= (x ? x + "... | javascript | {
"resource": ""
} |
q5584 | getBackgroundPositionInPercent | train | function getBackgroundPositionInPercent(image) {
var x = 100 * (image.coordinates.x) / (image.properties.width - image.coordinates.width);
var y = 100 * (image.coordinates.y) / (image.properties.height - image.coordinates.height);
var template = _.template('<%= (x ? x + "%" : x) %> <%= (y ? y + "%" : y) %>');
retur... | javascript | {
"resource": ""
} |
q5585 | getBackgroundSize | train | function getBackgroundSize(image) {
var x = image.properties.width / image.ratio;
var y = image.properties.height / image.ratio;
var template = _.template('<%= x %>px <%= y %>px');
return template({x: x, y: y});
} | javascript | {
"resource": ""
} |
q5586 | getRetinaRatio | train | function getRetinaRatio(url) {
var matches = /[@_](\d)x\.[a-z]{3,4}$/gi.exec(url);
if (!matches) {
return 1;
}
var ratio = _.parseInt(matches[1]);
return ratio;
} | javascript | {
"resource": ""
} |
q5587 | log | train | function log(logLevel, level, content) {
var output = true;
switch (logLevel) {
case 'slient':
if (level !== 'lv1') {
output = false;
}
break;
case 'info':
if (level === 'lv3') {
output = false;
}
break;
default:
output = true;
}
if (output) {
var data = Array.prototype.slice.call(content)... | javascript | {
"resource": ""
} |
q5588 | debug | train | function debug() {
var data = Array.prototype.slice.call(arguments);
fancyLog.apply(false, data);
} | javascript | {
"resource": ""
} |
q5589 | Gmsmith | train | function Gmsmith(options) {
options = options || {};
this.gm = _gm;
var useImageMagick = options.hasOwnProperty('imagemagick') ? options.imagemagick : !gmExists;
if (useImageMagick) {
this.gm = _gm.subClass({imageMagick: true});
}
} | javascript | {
"resource": ""
} |
q5590 | setItem | train | function setItem(key, value) {
storage[key] = typeof value === 'string' ? value : JSON.stringify(value);
} | javascript | {
"resource": ""
} |
q5591 | log | train | function log(text) {
var type = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'success';
var debug$$1 = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
if (!debug$$1) {
return;
}
var success = 'padding: 2px; background: #219621; color: #ffffff';
var war... | javascript | {
"resource": ""
} |
q5592 | parse | train | function parse(data) {
try {
return JSON.parse(data);
} catch (e) {
log('Oops! Some problems parsing this ' + (typeof data === 'undefined' ? 'undefined' : _typeof(data)) + '.', 'error', debug);
}
return null;
} | javascript | {
"resource": ""
} |
q5593 | setItem | train | function setItem(key, value) {
var expires = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 1;
if (!isCookieEnabled) {
session.setItem(key, value);
log('I\'ve saved "' + key + '" in a plain object :)', 'warning', debug);
return;
}
cookie.set(key, value, { expires: expires });
... | javascript | {
"resource": ""
} |
q5594 | clear | train | function clear() {
var cookies = isBrowser && document.cookie.split(';');
if (!cookies.length) {
return;
}
for (var i = 0, l = cookies.length; i < l; i++) {
var item = cookies[i];
var key = item.split('=')[0];
cookie.remove(key);
}
} | javascript | {
"resource": ""
} |
q5595 | hasLocalStorage | train | function hasLocalStorage() {
if (!localstorage) {
return false;
}
try {
localstorage.setItem('0', '');
localstorage.removeItem('0');
return true;
} catch (error) {
return false;
}
} | javascript | {
"resource": ""
} |
q5596 | getItem | train | function getItem(key) {
var parsed = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
var fallbackValue = arguments[2];
var result = void 0;
var cookieItem = cookie$1.getItem(key);
var sessionItem = session.getItem(key);
if (!hasLocalStorage()) {
result = cookieItem || sessi... | javascript | {
"resource": ""
} |
q5597 | removeItem | train | function removeItem(key) {
cookie$1.removeItem(key);
session.removeItem(key);
if (!hasLocalStorage()) {
return;
}
localstorage.removeItem(key);
} | javascript | {
"resource": ""
} |
q5598 | off | train | function off(type, handler) {
if (all[type]) {
all[type].splice(all[type].indexOf(handler) >>> 0, 1);
}
} | javascript | {
"resource": ""
} |
q5599 | defaultify | train | function defaultify (obj) {
return Object.keys(self.defaults).reduce(function (acc, key) {
if (!acc[key]) { acc[key] = self.defaults[key] }
return acc;
}, obj);
} | javascript | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.