_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];
if (handler) { handler.call(self, res.error, res.result); }
delete 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)) {
result.error = true;
result.message = 'The following values must be passed: ' + required.join(', ');
}
})
}
return result;
}
|
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 memcacheSetRequest;
}
|
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.isDefAndNotNull(taskOptions.taskName) ?
taskOptions.taskName : '');
taskqueueAddRequest.setEtaUsec(goog.isDefAndNotNull(taskOptions.etaUsec) ?
taskOptions.etaUsec : '0');
var method = 'post';
if (goog.isDefAndNotNull(taskOptions.method)) {
method = taskOptions.method;
}
taskqueueAddRequest.setMethod(methodToProtoMethod[method]);
if (goog.isDefAndNotNull(taskOptions.body)) {
taskqueueAddRequest.setBody(taskOptions.body);
}
if (goog.isDefAndNotNull(taskOptions.headers)) {
goog.object.forEach(taskOptions.headers, function(value, key) {
var header = new apphosting.TaskQueueAddRequest.Header();
header.setKey(key);
header.setValue(value);
taskqueueAddRequest.addHeader(header);
});
}
return taskqueueAddRequest;
}
|
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.devappserver,
appId: appId,
moduleName: moduleName,
moduleVersion: moduleVersion,
moduleInstance: moduleInstance,
logBuffer_: appengine.newLogBuffer_()
}
};
if (req.appengine.devappserver) {
result.appengine.devRequestId = token;
} else {
result.appengine.apiTicket = token;
}
return result;
}
|
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) {
self.emit('client', connection, remote);
});
connection.on('error', function(err) {
self.emit('clientError', err, this);
});
// Services exposed on the server as a whole are propagated to each
// connection. Flexibility exists to expose services on a per-connection
// basis as well.
self._services.forEach(function(service) {
connection.expose(service.name, service.service)
});
});
}
|
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(namespace)) {
return error(invalidNamespace, callback);
}
namespace = parse(namespace);
} else if (namespace instanceof UUID) {
namespace = namespace.toBuffer();
} else if (!(namespace instanceof Buffer) || namespace.length !== 16) {
return error(invalidNamespace, callback);
}
var nameIsNotAString = typeof name !== "string";
if (nameIsNotAString && !(name instanceof Buffer)) {
return error(invalidName, callback);
}
hash.update(namespace);
hash.update(options.name, nameIsNotAString ? "binary" : "utf8");
var buffer = hash.digest();
var result;
switch (options.encoding && options.encoding[0]) {
case "b":
case "B":
buffer[6] = (buffer[6] & 0x0f) | version;
buffer[8] = (buffer[8] & 0x3f) | 0x80;
result = buffer;
break;
case "o":
case "U":
buffer[6] = (buffer[6] & 0x0f) | version;
buffer[8] = (buffer[8] & 0x3f) | 0x80;
result = new UUID(buffer);
break;
default:
result = byte2hex[buffer[0]] + byte2hex[buffer[1]] +
byte2hex[buffer[2]] + byte2hex[buffer[3]] + "-" +
byte2hex[buffer[4]] + byte2hex[buffer[5]] + "-" +
byte2hex[(buffer[6] & 0x0f) | version] +
byte2hex[buffer[7]] + "-" +
byte2hex[(buffer[8] & 0x3f) | 0x80] +
byte2hex[buffer[9]] + "-" +
byte2hex[buffer[10]] + byte2hex[buffer[11]] +
byte2hex[buffer[12]] + byte2hex[buffer[13]] +
byte2hex[buffer[14]] + byte2hex[buffer[15]];
break;
}
if (callback) {
setImmediate(function () {
callback(null, result);
});
} else {
return result;
}
}
|
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.userTokens[ token ] && gui.userTokens[ token ].csrfToken ) {
csrfToken = gui.userTokens[ token ].csrfToken
}
}
} catch ( exc ) { log.warn('easy-web-app CSRF token, exc') }
res.header( 'X-Protect', csrfToken );
next();
}
|
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) =>
request(ml, {
url: url,
method: 'POST',
body: batch,
parse_response: false
})
.then(raw_response => {
response._add_raw_response(raw_response);
return response;
})
.catch(error => {
if (error.hasOwnProperty('response')) {
response._add_raw_response(error.response);
error.response = response;
} else {
// if it's not a MonkeyLearn Error (so, some other js runtime error),
// return as-is but add the response
// not the cleanest solution but I don't want the error to lose the context
error.response = response;
error.error_code = '';
}
throw error;
})
)
, promise)
}
}
|
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', []); // Contains all enabled pagelets.
this.writable('_disabled', []); // Contains all disable pagelets.
this.writable('_active', null); // Are we active.
this.writable('_req', options.req); // Incoming HTTP request.
this.writable('_res', options.res); // Incoming HTTP response.
this.writable('_params', options.params); // Params extracted from the route.
this.writable('_temper', options.temper); // Attach the Temper instance.
this.writable('_bigpipe', options.bigpipe); // Actual pipe instance.
this.writable('_bootstrap', options.bootstrap); // Reference to bootstrap Pagelet.
this.writable('_append', options.append || false); // Append content client-side.
this.writable('debug', debug('pagelet:'+ this.name)); // Namespaced debug method
//
// Allow overriding the reference to parent pagelet.
// A reference to the parent is normally set on the
// constructor prototype by optimize.
//
if (options.parent) this.writable('_parent', options.parent);
}
|
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.mode = data.mode || pagelet.mode; // Pagelet render mode.
data.remove = active ? false : pagelet.remove; // Remove from DOM.
data.parent = pagelet._parent; // Send parent name along.
data.append = pagelet._append; // Content should be appended.
data.remaining = pagelet.bootstrap.length; // Remaining pagelets number.
data.hash = { // Temper md5's for template ref
error: temper.fetch(pagelet.error).hash.client,
client: temper.fetch(pagelet.view).hash.client
};
fn.call(context, undefined, framework.get('fragment', {
template: content.replace(/<!--(.|\s)*?-->/, ''),
name: pagelet.name,
id: pagelet.id,
state: state,
data: data
}));
return pagelet;
}
|
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 real time connection lookups.
//
prototype.id = options.id || [0, 1, 1, 1].map(generator).join('-');
//
// Parse the methods to an array of accepted HTTP methods. We'll only accept
// these requests and should deny every other possible method.
//
log('Optimizing pagelet');
if (!Array.isArray(method)) method = method.split(/[\s\,]+?/);
Pagelet.method = method.filter(Boolean).map(function transformation(method) {
return method.toUpperCase();
});
//
// Add the actual HTTP route and available HTTP methods.
//
if (router) {
log('Instantiating router for path %s', router);
Pagelet.router = new Route(router);
}
//
// Prefetch the template if a view is available. The view property is
// mandatory for all pagelets except the bootstrap Pagelet or if the
// Pagelet is just doing a redirect. We can resolve this edge case by
// checking if statusCode is in the 300~ range.
//
if (!view && name !== 'bootstrap' && !(status >= 300 && status < 400)) return next(
new Error('The '+ name +' pagelet should have a .view property.')
);
//
// Resolve the view to ensure the path is correct and prefetch
// the template through Temper.
//
if (view) {
prototype.view = view = path.resolve(prototype.directory, view);
temper.prefetch(view, prototype.engine);
}
//
// Ensure we have a custom error pagelet when we fail to render this fragment.
//
if (prototype.error) {
temper.prefetch(prototype.error, path.extname(prototype.error).slice(1));
}
//
// Map all dependencies to an absolute path or URL.
//
helpers.resolve(Pagelet, ['css', 'js', 'dependencies']);
//
// Find all child pagelets and optimize the found children.
//
async.map(Pagelet.children(name), function map(Child, step) {
if (Array.isArray(Child)) return async.map(Child, map, step);
Child.optimize({
temper: temper,
bigpipe: bigpipe,
transform: {
before: bigpipe.emits && bigpipe.emits('transform:pagelet:before'),
after: bigpipe.emits && bigpipe.emits('transform:pagelet:after')
}
}, step);
}, function optimized(error, children) {
log('optimized all %d child pagelets', children.length);
if (error) return next(error);
//
// Store the optimized children on the prototype, wrapping the Pagelet
// in an array makes it a lot easier to work with conditional Pagelets.
//
prototype._children = children.map(function map(Pagelet) {
return Array.isArray(Pagelet) ? Pagelet : [Pagelet];
});
//
// Always return a reference to the parent Pagelet.
// Otherwise the stack of parents would be infested
// with children returned by this async.map.
//
next(null, Pagelet);
});
}
|
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.x - ( entity._w / 2 );
}
if ( entity._y !== part.position.y - ( entity._h / 2 ) ) {
entity.matterMoved = true;
entity.y = part.position.y - ( entity._h / 2 );
}
debug.moveEntity( entity );
_rotateEntity( entity, part.angle );
}
|
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, angleFixed ] );
}
|
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
//reconnectDecay: 2 // TODO: reconnect decay
};
// copy the options
if (options) {
if ('reconnectTimeout' in options) this.options.reconnectTimeout = options.reconnectTimeout;
if ('reconnectInterval' in options) this.options.reconnectInterval = options.reconnectInterval;
}
this.queue = [];
this.attempts = 0;
this.reconnectTimer = null;
function connect() {
me.socket = new WebSocket(me.url);
me.socket.onmessage = function (event) {
me.onmessage(event);
};
me.socket.onerror = function (error) {
if (me.socket.readyState === WebSocket.OPEN) {
me.onerror(error);
}
else {
reconnect();
}
};
me.socket.onopen = function (event) {
// reset the number of connection attempts
me.attempts = 0;
// emit events
if (!me.opened) {
me.onopen(event);
me.opened = true;
}
else {
me.onreconnect(event);
}
// flush all messages in the queue (if any)
//console.log('flush messages ' + me.queue);
while (me.queue.length > 0) {
var data = me.queue.shift();
me.socket.send(data);
}
};
me.socket.onclose = function (event) {
if (me.closed) {
me.onclose(event);
}
else {
// start auto-reconnect attempts
reconnect();
}
}
}
function reconnect() {
// check whether already reconnecting
if (me.reconnectTimer) {
return;
}
me.attempts++;
if (me.attempts < me.options.reconnectTimeout / me.options.reconnectInterval) {
me.reconnectTimer = setTimeout(function () {
me.reconnectTimer = null;
connect();
}, me.options.reconnectInterval);
}
else {
// no luck, let's give up...
me.close();
}
}
connect();
}
|
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, callback) {
this.push(file);
callback();
});
bowerCommand.apply(bower.commands, cmdArguments)
.on('log', function (result) {
log.info(['bower', colors.cyan(result.id), result.message].join(' '));
})
.on('prompt', function (prompts, callback) {
if (enablePrompt === true) {
inquirer.prompt(prompts, callback);
} else {
var error = 'Can\'t resolve suitable dependency version.';
log.error(error);
log.error('Set option { interactive: true } to select.');
throw new PluginError(PLUGIN_NAME, error);
}
})
.on('error', function (error) {
stream.emit('error', new PluginError(PLUGIN_NAME, error));
stream.emit('end');
})
.on('end', function () {
writeStreamToFs(opts, stream);
});
return stream;
}
|
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;
delete (opts.verbosity);
cmd = opts.cmd || DEFAULT_CMD;
delete (opts.cmd);
// enable bower prompting but ignore the actual prompt if interactive == false
enablePrompt = opts.interactive || DEFAULT_INTERACTIVE;
opts.interactive = true;
if (!opts.directory) {
opts.directory = getDirectoryFromBowerRc(opts.cwd) || DEFAULT_DIRECTORY;
}
return opts;
}
|
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.directory;
}
|
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;
return cmdArguments;
}
|
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) {
// To enable that kind of nested commands, we try to resolve those commands, before passing them to bower.
for (var commandPos = 0; commandPos < nestedCommand.length; commandPos++) {
if (bowerCommand) {
// when the root command is already there, walk into the depth.
bowerCommand = bowerCommand[nestedCommand[commandPos]];
} else {
// the first time we look for the "root" commands available in bower
bowerCommand = bower.commands[nestedCommand[commandPos]];
}
}
} else {
// if the command isn't nested, just go ahead as usual
bowerCommand = bower.commands[cmd];
}
// try to give a good error description to the user when a bad command was passed
if (bowerCommand === undefined) {
throw new PluginError(PLUGIN_NAME, 'The command \'' + cmd + '\' is not available in the bower commands');
}
return bowerCommand;
}
|
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', function (root, stats, next) {
next();
});
walker.on('file', function (root, stats, next) {
var filePath = path.resolve(root, stats.name);
fs.readFile(filePath, function (error, data) {
if (error) {
stream.emit('error', new PluginError(PLUGIN_NAME, error));
} else {
stream.write(new Vinyl({
path: path.relative(baseDir, filePath),
contents: data
}));
}
next();
});
});
walker.on('end', function () {
stream.emit('end');
stream.emit('finish');
});
}
|
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.clientId;
this.clientSecret = options.clientSecret;
this.redirectUri = options.redirectUri;
this.fetchProfile = !options.skipProfile;
this.authorizedPresenters = options.presenters;
this.passReqToCallback = options.passReqToCallback;
if (options.noRedirectUri) {
this.redirectUri = undefined;
}
}
|
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(location)
if (!location) {
currentModule = get_parent_module(currentModule);
continue;
}
// Read the package.json file
var object = JSON.parse(fs.readFileSync(f('%s/package.json', location)));
// Is the name defined by interal file references
var parts = name.split(/\//);
// Check whether this package.json contains peerOptionalDependencies containing the name we're searching for
if (!object.peerOptionalDependencies || (object.peerOptionalDependencies && !object.peerOptionalDependencies[parts[0]])) {
currentModule = get_parent_module(currentModule);
continue;
}
found = true;
break;
}
// Check whether name has been found in currentModule's peerOptionalDependencies
if (!found) {
throw new Error(f('no optional dependency [%s] defined in peerOptionalDependencies in any package.json', parts[0]));
}
return {
object: object,
parts: parts
}
}
|
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);
var id = urlParts.query.id;
if (id) {
// create a connection with id
var rConn = me.connections[id];
if (rConn) {
// update existing connection
// TODO: test for conflicts, if the connection or rConn is still opened by another client with the same id
rConn.setConnection(conn);
}
else {
// create a new connection
rConn = new Connection(id, conn);
me.connections[id] = rConn;
me.emit('connection', rConn);
}
}
else {
// create an anonymous connection (no support for restoring client connection)
// TODO: create an option anonymousConnections=true|false
rConn = new Connection(null, conn);
me.emit('connection', rConn);
}
});
this.server.on('error', function (err) {
me.onerror(err);
});
}
|
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];
let next = tokens[n];
if (isComment(token)) {
if (token.type === 'BlockComment') {
while (next && /comment/i.test(next.type)) next = tokens[++n];
token.codeStart = next && !/(comment|punc)/i.test(next.type) ? next.range[0] : null;
}
comments.push(token);
}
}
return comments;
}
|
javascript
|
{
"resource": ""
}
|
q5545
|
train
|
function (count, fn) { // 55
var self = this; // 56
var timeout = self._timeout(count); // 57
if (self.retryTimer) // 58
clearTimeout(self.retryTimer); // 59
self.retryTimer = Meteor.setTimeout(fn, timeout); // 60
return timeout; // 61
}
|
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.errorDetails).causedBy(err);
ctx.log.error(internalError);
ctx.emit('clientResponseError', error);
ctx._execute(error);
return;
}
if (ctx._response.payload.error) {
debug('act:response.payload.error', ctx._response.payload.error);
let error = Errio.fromObject(ctx._response.payload.error);
const internalError = new Errors.BusinessError(Constants.BUSINESS_ERROR, ctx.errorDetails).causedBy(error);
ctx.log.error(internalError);
ctx.emit('clientResponseError', error);
ctx._execute(error);
return;
}
ctx._execute(null, ctx._response.payload.result);
}
|
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.error(internalError);
ctx._response.error = error;
ctx.emit('clientResponseError', error);
}
try {
ctx._execute(ctx._response.error);
} catch(err) {
let error = null;
if (err instanceof SuperError) {
error = err.rootCause || err.cause || err;
} else {
error = err;
}
let internalError = new Errors.FatalError(Constants.FATAL_ERROR, ctx.errorDetails).causedBy(err);
ctx.log.fatal(internalError);
ctx.emit('clientResponseError', error);
// let it crash
if (ctx._config.crashOnFatal) {
ctx.fatal();
}
}
}
|
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);
return;
}
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).causedBy(err);
ctx.log.error(internalError);
ctx.emit('clientResponseError', error);
ctx._execute(error);
return;
}
ctx._request.payload = m.value;
ctx._request.error = m.error;
// use simple publish mechanism instead of request/reply
if (ctx._pattern.pubsub$ === true) {
if (ctx._actCallback) {
ctx.log.info(Constants.PUB_CALLBACK_REDUNDANT);
}
ctx._transport.send(ctx._pattern.topic, ctx._request.payload);
} else {
const optOptions = {};
// limit on the number of responses the requestor may receive
if (ctx._pattern.maxMessages$ > 0) {
optOptions.max = ctx._pattern.maxMessages$;
} else if (ctx._pattern.maxMessages$ !== -1) {
optOptions.max = 1;
} // else unlimited messages
// send request
ctx._sid = ctx._transport.sendRequest(ctx._pattern.topic,
ctx._request.payload, optOptions, ctx._sendRequestHandler.bind(ctx));
// handle timeout
ctx.handleTimeout();
}
}
|
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).causedBy(err);
ctx.log.error(internalError);
return ctx.finish();
}
// reply value from extension
if (value) {
ctx._response.payload = value;
return ctx.finish();
}
try {
let action = ctx._actMeta.action.bind(ctx);
// execute add middlewares
ctx._actMeta.dispatch(ctx._request, ctx._response, (err) => {
// middleware error
if (err) {
if (err instanceof SuperError) {
ctx._response.error = err.rootCause || err.cause || err;
} else {
ctx._response.error = err;
}
let internalError = new Errors.MostlyError(
Constants.ADD_MIDDLEWARE_ERROR, ctx.errorDetails).causedBy(err);
ctx.log.error(internalError);
return ctx.finish();
}
// if request type is 'pubsub' we dont have to reply back
if (ctx._request.payload.request.type === Constants.REQUEST_TYPE_PUBSUB) {
action(ctx._request.payload.pattern);
return ctx.finish();
}
// execute RPC action
if (ctx._actMeta.isPromisable) {
action(ctx._request.payload.pattern)
.then(x => ctx._actionHandler(null, x))
.catch(e => ctx._actionHandler(e));
} else {
action(ctx._request.payload.pattern, ctx._actionHandler.bind(ctx));
}
});
} catch (err) {
if (err instanceof SuperError) {
ctx._response.error = err.rootCause || err.cause || err;
} else {
ctx._response.error = err;
}
// service should exit
ctx._shouldCrash = true;
ctx.finish();
}
}
|
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.payload = value;
return ctx.finish();
}
// check if a handler is registered with this pattern
if (ctx._actMeta) {
ctx._extensions.onServerPreHandler.dispatch(ctx, (err, val) => {
return onServerPreHandler(ctx, err, val);
});
} else {
const internalError = new Errors.PatternNotFound(Constants.PATTERN_NOT_FOUND, ctx.errorDetails);
ctx.log.error(internalError);
ctx._response.error = internalError;
// send error back to callee
ctx.finish();
}
}
|
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) {
ctx._response.error = err.rootCause || err.cause || err;
} else {
ctx._response.error = err;
}
const internalError = new Errors.MostlyError(
Constants.EXTENSION_ERROR, ctx.errorDetails).causedBy(err);
ctx.log.error(internalError);
ctx.emit('serverResponseError', ctx._response.error);
}
// reply value from extension
if (value) {
ctx._response.payload = value;
}
// create message payload
ctx._buildMessage();
// indicates that an error occurs and that the program should exit
if (ctx._shouldCrash) {
// only when we have an inbox othwerwise exit the service immediately
if (ctx._replyTo) {
// send error back to callee
return ctx._transport.send(ctx._replyTo, ctx._message, () => {
// let it crash
if (ctx._config.crashOnFatal) {
ctx.fatal();
}
});
} else if (ctx._config.crashOnFatal) {
return ctx.fatal();
}
}
// reply only when we have an inbox
if (ctx._replyTo) {
return ctx._transport.send(ctx._replyTo, ctx._message);
}
}
|
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 until the client has flush all messages to nats
ctx._transport.flush(() => {
ctx._heavy.stop();
// close NATS
ctx._transport.close();
if (err) {
ctx.log.error(err);
ctx.emit('error', err);
if (_.isFunction(cb)) {
cb(err);
}
} else {
ctx.log.info(Constants.GRACEFULLY_SHUTDOWN);
if (_.isFunction(cb)) {
cb(null, val);
}
}
});
}
|
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 got '${typeof version}'`);
}
const mostlyVersion = require('mostly-node/package.json').version;
if (!semver.satisfies(mostlyVersion, version)) {
throw new Error(`mostly-plugin - expected '${version}' mostly-node version, '${mostlyVersion}' is installed`);
}
}
return fn;
}
|
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(possiblePath)) {
controllerPath = possiblePath;
break;
}
}
catch (_a) {
/* not found */
}
}
// Apparently, checking vs null/undefined may miss the odd case of controllerPath being ""
// Thus we check for falsyness, which includes failing on an empty path
if (!controllerPath) {
if (!isInstall) {
console.log("Cannot find js-controller");
return process.exit(10);
}
else {
return process.exit();
}
}
// we found the controller
return path.dirname(controllerPath);
}
|
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.publishCreate(newChildRecord, !req.options.mirror && req);
}
// in case we have to create a child and link it to parent(M-M through scenario)
// createChild function should return the instance to be linked
// in the through model => customCb
return (typeof customCb === 'function') ?
customCb(null, newChildRecord[childPkAttr]) : cb(null, newChildRecord[childPkAttr]);
}).catch(function(err){
return cb(err);
});
}
|
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),
buildEdgeVertex(2, vertex2.x, vertex2.y, tileBody),
vertex3 ? buildEdgeVertex(3, vertex3.x, vertex3.y, tileBody, true) : null
);
// Build the edge
let edge = {
vertices: vertices,
normals: null
};
// Calculate normals
edge.normals = Axes.fromVertices(edge.vertices);
// Calculate position
edge.position = Vector.create(
(vertex1.x + vertex2.x) / 2,
(vertex1.y + vertex2.y) / 2
);
edge.index = vertex1.index;
return edge;
}
|
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: GetTileAt(tile.x, tile.y + 1, true, layerData),
left: GetTileAt(tile.x - 1, tile.y, true, layerData),
right: GetTileAt(tile.x + 1, tile.y, true, layerData),
topLeft: GetTileAt(tile.x - 1, tile.y - 1, true, layerData),
topRight: GetTileAt(tile.x + 1, tile.y - 1, true, layerData),
bottomLeft: GetTileAt(tile.x - 1, tile.y + 1, true, layerData),
bottomRight: GetTileAt(tile.x + 1, tile.y + 1, true, layerData),
},
edges: {
top: Constants.INTERESTING,
bottom: Constants.INTERESTING,
left: Constants.INTERESTING,
right: Constants.INTERESTING
}
};
}
// Calculate boundary edges
this.calculateBoundaryEdges(tiles);
// Flag internal edges
this.flagInternalEdges(tiles);
// Build ghost edges and flag ignormals
this.flagIgnormals(tiles);
}
|
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 tile's body and vertices to compare with its neighbours
let tileBody = tile.physics.matterBody.body;
let tileVertices = tileBody.vertices;
// Iterate over each direct neighbour
for (n in directNeighbours) {
neighbour = tile.physics.slopes.neighbours[directNeighbours[n]];
// Skip over irrelevant neighbouring tiles
if (isIrrelevant(neighbour)) {
continue;
}
// Grab the neighbour's body and vertices
let neighbourBody = neighbour.physics.matterBody.body;
let neighbourVertices = neighbourBody.vertices;
// Skip over tile-neighbour pairs that don't overlap
if (!Bounds.overlaps(tileBody.bounds, neighbourBody.bounds)) {
continue;
}
tv = tileVertices;
nv = neighbourVertices;
tn = tileBody.axes;
nn = neighbourBody.axes;
// Iterate over the vertices of both the tile and its neighbour
for (i = 0; i < tv.length; i++) {
for (j = 0; j < nv.length; j++) {
// Find distances between the vertices
let da = Vector.magnitudeSquared(Vector.sub(tv[(i + 1) % tv.length], nv[j])),
db = Vector.magnitudeSquared(Vector.sub(tv[i], nv[(j + 1) % nv.length]));
// If both vertices are very close, consider the edge coincident (internal)
if (da < maxDist && db < maxDist) {
tv[i].isInternal = true;
nv[j].isInternal = true;
tn[i].ignore = true;
nn[j].ignore = true;
}
}
}
}
}
}
|
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);
ctx._circuitBreakerMap.set(ctx.trace$.method, cb);
} else {
if (!circuitBreaker.available()) {
// trigger half-open timer
circuitBreaker.record();
return next(new Errors.CircuitBreakerError(
`Circuit breaker is ${circuitBreaker.state}`,
{ state: circuitBreaker.state, method: ctx.trace$.method, service: ctx.trace$.service }));
}
}
next();
} else {
next();
}
}
|
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.replace(/\.\w+$/, '') + '.html'
if (outputDir) {
outputFile = path.resolve(outputDir, outputFile)
mkdirp.sync(path.dirname(outputFile))
}
console.log(chalk.blue('Rendering: ' + file))
fs.writeFileSync(outputFile, res)
})
}
|
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) {
return image;
});
});
}, images).then(function (images) {
return [images, options];
});
}
|
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 sliceDirname = sliceDir.split(path.sep).pop();
var atRuleParent = atRule.parent;
var mediaAtRule2x = postcss.atRule({name: 'media', params: resolutions2x.join(', ')});
var mediaAtRule3x = postcss.atRule({name: 'media', params: resolutions3x.join(', ')});
// Tag flag
var has2x = false;
var has3x = false;
if (options.outputExtralCSS) {
var outputExtralCSSRule = postcss.rule({
selector: '.' + options.nameSpace + (atRuleValue[1] ? atRuleValue[1] : sliceDirname),
source: atRule.source
});
outputExtralCSSRule.append({prop: 'display', value: 'inline-block'});
outputExtralCSSRule.append({prop: 'overflow', value: 'hidden'});
outputExtralCSSRule.append({prop: 'font-size', value: '0'});
outputExtralCSSRule.append({prop: 'line-height', value: '0'});
atRule.before(outputExtralCSSRule);
}
// Foreach every image object
_.forEach(images, function (image) {
// Only work when equal to directory name
if (sliceDirname === image.dir) {
image.token = postcss.comment({
text: image.path,
raws: {
between: options.cloneRaws.between,
after: options.cloneRaws.after,
left: '@replace|',
right: ''
}
});
// Add `source` argument for source map create.
var singleRule = postcss.rule({
selector: '.' + options.nameSpace + image.selector,
source: atRule.source
});
singleRule.append(image.token);
switch (image.ratio) {
// @1x
case 1:
atRuleParent.insertBefore(atRule, singleRule);
break;
// @2x
case 2:
mediaAtRule2x.append(singleRule);
has2x = true;
break;
// @3x
case 3:
mediaAtRule3x.append(singleRule);
has3x = true;
break;
default:
break;
}
}
});
// @2x @3x media rule are last.
if (has2x) {
atRuleParent.insertBefore(atRule, mediaAtRule2x);
}
if (has3x) {
atRuleParent.insertBefore(atRule, mediaAtRule3x);
}
atRule.remove();
});
resolve([images, options]);
});
}
|
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 = Promise.pending();
// If this file is up to date
if (sprite.isFromCache) {
log(options.logLevel, 'lv3', ['Lazysprite:', colors.yellow(path.relative(process.cwd(), sprite.path)), 'unchanged.']);
deferred.resolve(sprite);
return deferred.promise;
}
// Save new file version
return fs.writeFileAsync(sprite.path, Buffer.from(sprite.image, 'binary'))
.then(function () {
log(options.logLevel, 'lv2', ['Lazysprite:', colors.green(path.relative(process.cwd(), sprite.path)), 'generated.']);
return sprite;
});
})
.value();
Promise.all(all)
.then(function (sprites) {
resolve([images, options, sprites]);
})
.catch(function (err) {
if (err) {
reject(err);
}
});
});
}
|
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: sprite.path,
properties: sprite.properties
});
});
});
resolve([images, options, sprites]);
});
}
|
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 comments
image = _.find(images, {path: comment.text});
if (image) {
// 2x check even dimensions.
if (image.ratio === 2 && (image.coordinates.width % 2 !== 0 || image.coordinates.height % 2 !== 0)) {
throw log(options.logLevel, 'lv1', ['Lazysprite:', colors.red(path.relative(process.cwd(), image.path)), '`2x` image should have' +
' even dimensions.']);
}
// 3x check dimensions.
if (image.ratio === 3 && (image.coordinates.width % 3 !== 0 || image.coordinates.height % 3 !== 0)) {
throw log(options.logLevel, 'lv1', ['Lazysprite:', colors.red(path.relative(process.cwd(), image.path)), '`3x` image should have' +
' correct dimensions.']);
}
// Generate correct ref to the sprite
image.spriteRef = path.relative(image.stylesheetRelative, image.spritePath);
image.spriteRef = image.spriteRef.split(path.sep).join('/');
backgroundImage = postcss.decl({
prop: 'background-image',
value: getBackgroundImageUrl(image)
});
backgroundPosition = postcss.decl({
prop: 'background-position',
value: getBackgroundPosition(image)
});
// Replace the comment and append necessary properties.
comment.replaceWith(backgroundImage);
// Output the dimensions (only with 1x)
if (options.outputDimensions && image.ratio === 1) {
['height', 'width'].forEach(function (prop) {
backgroundImage.after(
postcss.decl({
prop: prop,
value: (image.ratio > 1 ? image.coordinates[prop] / image.ratio : image.coordinates[prop]) + 'px'
})
);
});
}
backgroundImage.after(backgroundPosition);
if (image.ratio > 1) {
backgroundSize = postcss.decl({
prop: 'background-size',
value: getBackgroundSize(image)
});
backgroundPosition.after(backgroundSize);
}
}
}
});
resolve([images, options, sprites, css]);
});
}
|
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 = path.resolve(base, groups.join('.') + '.png');
}
return file.replace('.@', options.retinaInfix);
}
|
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 + "px" : x) %> <%= (y ? y + "px" : y) %>');
return template({x: x, y: y});
}
|
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) %>');
return template({x: x, y: y});
}
|
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);
fancyLog.apply(false, data);
}
}
|
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 warning = 'padding: 2px; background: #f1e05a; color: #333333';
var error = 'padding: 2px; background: #b9090b; color: #ffffff';
var types = { error: error, success: success, warning: warning };
console.log('%c [Storage Helper] ' + text + ' ', types[type]);
}
|
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 });
log('I\'ve saved "' + key + '" in a cookie :)', 'warning', debug);
}
|
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 || sessionItem;
} else {
result = localstorage.getItem(key) || cookieItem || sessionItem;
}
var item = parsed ? parse(result) : result;
if ((typeof item === 'undefined' || item === null) && typeof fallbackValue !== 'undefined') {
return fallbackValue;
}
return item;
}
|
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.