_id
stringlengths 2
6
| title
stringlengths 0
58
| partition
stringclasses 3
values | text
stringlengths 52
373k
| language
stringclasses 1
value | meta_information
dict |
|---|---|---|---|---|---|
q4000
|
train
|
function (node, pred) {
pred = pred || func.ok;
var siblings = [];
if (node.previousSibling && pred(node.previousSibling)) {
siblings.push(node.previousSibling);
}
siblings.push(node);
if (node.nextSibling && pred(node.nextSibling)) {
siblings.push(node.nextSibling);
}
return siblings;
}
|
javascript
|
{
"resource": ""
}
|
|
q4001
|
train
|
function (node, pred) {
node = node.parentNode;
while (node) {
if (nodeLength(node) !== 1) { break; }
if (pred(node)) { return node; }
if (isEditable(node)) { break; }
node = node.parentNode;
}
return null;
}
|
javascript
|
{
"resource": ""
}
|
|
q4002
|
train
|
function (node, wrapperName) {
var parent = node.parentNode;
var wrapper = $('<' + wrapperName + '>')[0];
parent.insertBefore(wrapper, node);
wrapper.appendChild(node);
return wrapper;
}
|
javascript
|
{
"resource": ""
}
|
|
q4003
|
train
|
function (node, preceding) {
var next = preceding.nextSibling, parent = preceding.parentNode;
if (next) {
parent.insertBefore(node, next);
} else {
parent.appendChild(node);
}
return node;
}
|
javascript
|
{
"resource": ""
}
|
|
q4004
|
train
|
function (node, aChild) {
$.each(aChild, function (idx, child) {
node.appendChild(child);
});
return node;
}
|
javascript
|
{
"resource": ""
}
|
|
q4005
|
train
|
function (point) {
if (!isText(point.node)) {
return false;
}
var ch = point.node.nodeValue.charAt(point.offset - 1);
return ch && (ch !== ' ' && ch !== NBSP_CHAR);
}
|
javascript
|
{
"resource": ""
}
|
|
q4006
|
setVirtualTablePosition
|
train
|
function setVirtualTablePosition(rowIndex, cellIndex, baseRow, baseCell, isRowSpan, isColSpan, isVirtualCell) {
var objPosition = {
'baseRow': baseRow,
'baseCell': baseCell,
'isRowSpan': isRowSpan,
'isColSpan': isColSpan,
'isVirtual': isVirtualCell
};
if (!_virtualTable[rowIndex]) {
_virtualTable[rowIndex] = [];
}
_virtualTable[rowIndex][cellIndex] = objPosition;
}
|
javascript
|
{
"resource": ""
}
|
q4007
|
getActionCell
|
train
|
function getActionCell(virtualTableCellObj, resultAction, virtualRowPosition, virtualColPosition) {
return {
'baseCell': virtualTableCellObj.baseCell,
'action': resultAction,
'virtualTable': {
'rowIndex': virtualRowPosition,
'cellIndex': virtualColPosition
}
};
}
|
javascript
|
{
"resource": ""
}
|
q4008
|
recoverCellIndex
|
train
|
function recoverCellIndex(rowIndex, cellIndex) {
if (!_virtualTable[rowIndex]) {
return cellIndex;
}
if (!_virtualTable[rowIndex][cellIndex]) {
return cellIndex;
}
var newCellIndex = cellIndex;
while (_virtualTable[rowIndex][newCellIndex]) {
newCellIndex++;
if (!_virtualTable[rowIndex][newCellIndex]) {
return newCellIndex;
}
}
}
|
javascript
|
{
"resource": ""
}
|
q4009
|
addCellInfoToVirtual
|
train
|
function addCellInfoToVirtual(row, cell) {
var cellIndex = recoverCellIndex(row.rowIndex, cell.cellIndex);
var cellHasColspan = (cell.colSpan > 1);
var cellHasRowspan = (cell.rowSpan > 1);
var isThisSelectedCell = (row.rowIndex === _startPoint.rowPos && cell.cellIndex === _startPoint.colPos);
setVirtualTablePosition(row.rowIndex, cellIndex, row, cell, cellHasRowspan, cellHasColspan, false);
// Add span rows to virtual Table.
var rowspanNumber = cell.attributes.rowSpan ? parseInt(cell.attributes.rowSpan.value, 10) : 0;
if (rowspanNumber > 1) {
for (var rp = 1; rp < rowspanNumber; rp++) {
var rowspanIndex = row.rowIndex + rp;
adjustStartPoint(rowspanIndex, cellIndex, cell, isThisSelectedCell);
setVirtualTablePosition(rowspanIndex, cellIndex, row, cell, true, cellHasColspan, true);
}
}
// Add span cols to virtual table.
var colspanNumber = cell.attributes.colSpan ? parseInt(cell.attributes.colSpan.value, 10) : 0;
if (colspanNumber > 1) {
for (var cp = 1; cp < colspanNumber; cp++) {
var cellspanIndex = recoverCellIndex(row.rowIndex, (cellIndex + cp));
adjustStartPoint(row.rowIndex, cellspanIndex, cell, isThisSelectedCell);
setVirtualTablePosition(row.rowIndex, cellspanIndex, row, cell, cellHasRowspan, true, true);
}
}
}
|
javascript
|
{
"resource": ""
}
|
q4010
|
adjustStartPoint
|
train
|
function adjustStartPoint(rowIndex, cellIndex, cell, isSelectedCell) {
if (rowIndex === _startPoint.rowPos && _startPoint.colPos >= cell.cellIndex && cell.cellIndex <= cellIndex && !isSelectedCell) {
_startPoint.colPos++;
}
}
|
javascript
|
{
"resource": ""
}
|
q4011
|
createVirtualTable
|
train
|
function createVirtualTable() {
var rows = domTable.rows;
for (var rowIndex = 0; rowIndex < rows.length; rowIndex++) {
var cells = rows[rowIndex].cells;
for (var cellIndex = 0; cellIndex < cells.length; cellIndex++) {
addCellInfoToVirtual(rows[rowIndex], cells[cellIndex]);
}
}
}
|
javascript
|
{
"resource": ""
}
|
q4012
|
train
|
function (compiled) {
// 01. Embed version
var version = grunt.config('pkg.version');
compiled = compiled.replace(/@VERSION/g, version);
// 02. Embed Date
var date = (new Date()).toISOString().replace(/:\d+\.\d+Z$/, 'Z');
compiled = compiled.replace(/@DATE/g, date);
grunt.file.write(self.data.outFile, compiled);
}
|
javascript
|
{
"resource": ""
}
|
|
q4013
|
train
|
function (name, path, contents) {
contents = contents.replace(rDefineStart, '');
if (rDefineEndWithReturn.test(contents)) {
contents = contents.replace(rDefineEndWithReturn, '');
} else {
contents = contents.replace(rDefineEnd, '');
}
return contents;
}
|
javascript
|
{
"resource": ""
}
|
|
q4014
|
train
|
function (array, pred) {
for (var idx = 0, len = array.length; idx < len; idx ++) {
var item = array[idx];
if (pred(item)) {
return item;
}
}
}
|
javascript
|
{
"resource": ""
}
|
|
q4015
|
train
|
function (array, fn) {
if (!array.length) { return []; }
var aTail = tail(array);
return aTail.reduce(function (memo, v) {
var aLast = last(memo);
if (fn(last(aLast), v)) {
aLast[aLast.length] = v;
} else {
memo[memo.length] = [v];
}
return memo;
}, [[head(array)]]);
}
|
javascript
|
{
"resource": ""
}
|
|
q4016
|
train
|
function (filepath) {
var data = {};
try {
data = grunt.file.readJSON(filepath);
// The concatenated file won't pass onevar
// But our modules can
delete data.onever;
} catch (e) { }
return data;
}
|
javascript
|
{
"resource": ""
}
|
|
q4017
|
StatsPlugin
|
train
|
function StatsPlugin (output, options, cache) {
this.output = output
this.options = options
this.cache = cache
}
|
javascript
|
{
"resource": ""
}
|
q4018
|
train
|
function() {
var listWidth = 0;
// The plugin must be visible for a correct calculation
pgwSlideshow.plugin.show();
pgwSlideshow.plugin.find('.ps-list > ul > li').show().each(function() {
listWidth += $(this).width();
});
pgwSlideshow.plugin.find('.ps-list > ul').width(listWidth);
return true;
}
|
javascript
|
{
"resource": ""
}
|
|
q4019
|
train
|
function(element) {
var elementContainer = pgwSlideshow.plugin.find('.ps-current > ul');
elementContainer.find('li').not('.elt_' + pgwSlideshow.currentSlide).not('.elt_' + element.id).each(function(){
if (typeof $(this).stop == 'function') {
$(this).stop();
}
$(this).css('position', '').css('z-index', 1).hide();
});
// Current element
if (pgwSlideshow.currentSlide > 0) {
var currentElement = elementContainer.find('.elt_' + pgwSlideshow.currentSlide);
if (typeof currentElement.animate != 'function') {
currentElement.animate = function(css, duration, callback) {
currentElement.css(css);
if (callback) {
callback();
}
};
}
if (typeof currentElement.stop == 'function') {
currentElement.stop();
}
currentElement.css('position', 'absolute').animate({
opacity : 0,
}, pgwSlideshow.config.transitionDuration, function() {
currentElement.css('position', '').css('z-index', 1).hide();
});
}
// Update current id
pgwSlideshow.currentSlide = element.id;
// Next element
var nextElement = elementContainer.find('.elt_' + element.id);
if (typeof nextElement.animate != 'function') {
nextElement.animate = function(css, duration, callback) {
nextElement.css(css);
if (callback) {
callback();
}
};
}
if (typeof nextElement.stop == 'function') {
nextElement.stop();
}
nextElement.css('position', 'absolute').show().animate({
opacity : 1,
}, pgwSlideshow.config.transitionDuration, function() {
nextElement.css('position', '').css('z-index', 2).css('display', 'block');
finishElement(element);
});
return true;
}
|
javascript
|
{
"resource": ""
}
|
|
q4020
|
train
|
function(element, direction) {
var elementContainer = pgwSlideshow.plugin.find('.ps-current > ul');
if (typeof direction == 'undefined') {
direction = 'left';
}
if (pgwSlideshow.currentSlide == 0) {
elementContainer.find('.elt_1').css({
position : '',
left : '',
opacity : 1,
'z-index' : 2
}).show();
pgwSlideshow.plugin.find('.ps-list > li.elt_1').css('opacity', '1');
finishElement(element);
} else {
if (pgwSlideshow.transitionInProgress) {
return false;
}
pgwSlideshow.transitionInProgress = true;
// Get direction details
var elementWidth = elementContainer.width();
if (direction == 'left') {
var elementDest = -elementWidth;
var nextOrigin = elementWidth;
} else {
var elementDest = elementWidth;
var nextOrigin = -elementWidth;
}
var currentElement = elementContainer.find('.elt_' + pgwSlideshow.currentSlide);
if (typeof currentElement.animate != 'function') {
currentElement.animate = function(css, duration, callback) {
currentElement.css(css);
if (callback) {
callback();
}
};
}
currentElement.css('position', 'absolute').animate({
left : elementDest,
}, pgwSlideshow.config.transitionDuration, function() {
currentElement.css('position', '').css('z-index', 1).css('left', '').css('opacity', 0).hide();
});
// Next element
var nextElement = elementContainer.find('.elt_' + element.id);
if (typeof nextElement.animate != 'function') {
nextElement.animate = function(css, duration, callback) {
nextElement.css(css);
if (callback) {
callback();
}
};
}
nextElement.css('position', 'absolute').css('left', nextOrigin).css('opacity', 1).show().animate({
left : 0,
}, pgwSlideshow.config.transitionDuration, function() {
nextElement.css('position', '').css('left', '').css('z-index', 2).show();
pgwSlideshow.transitionInProgress = false;
finishElement(element);
});
}
// Update current id
pgwSlideshow.currentSlide = element.id;
return true;
}
|
javascript
|
{
"resource": ""
}
|
|
q4021
|
train
|
function(elementId, apiController, direction) {
if (elementId == pgwSlideshow.currentSlide) {
return false;
}
var element = pgwSlideshow.data[elementId - 1];
if (typeof element == 'undefined') {
throw new Error('pgwSlideshow - The element ' + elementId + ' is undefined');
return false;
}
if (typeof direction == 'undefined') {
direction = 'left';
}
// Before slide
if (typeof pgwSlideshow.config.beforeSlide == 'function') {
pgwSlideshow.config.beforeSlide(elementId);
}
if (typeof pgwSlideshow.plugin.find('.ps-caption').fadeOut == 'function') {
pgwSlideshow.plugin.find('.ps-caption, .ps-prev, .ps-next').fadeOut(pgwSlideshow.config.transitionDuration / 2);
} else {
pgwSlideshow.plugin.find('.ps-caption, .ps-prev, .ps-next').hide();
}
// Choose the transition effect
if (pgwSlideshow.config.transitionEffect == 'sliding') {
slideElement(element, direction);
} else {
fadeElement(element);
}
// Reset interval to avoid a half interval after an API control
if (typeof apiController != 'undefined' && pgwSlideshow.config.autoSlide) {
activateInterval();
}
return true;
}
|
javascript
|
{
"resource": ""
}
|
|
q4022
|
train
|
function() {
var containerWidth = pgwSlideshow.plugin.find('.ps-list').width();
var listObject = pgwSlideshow.plugin.find('.ps-list > ul');
var listWidth = listObject.width();
var marginLeft = parseInt(listObject.css('margin-left'));
var marginRight = parseInt(listObject.css('margin-right'));
containerWidth -= (marginLeft + marginRight);
var visibleZoneStart = Math.abs(parseInt(listObject.css('left')));
var visibleZoneEnd = visibleZoneStart + containerWidth;
var elementZoneStart = pgwSlideshow.plugin.find('.ps-list .ps-selected').position().left;
var elementZoneEnd = elementZoneStart + pgwSlideshow.plugin.find('.ps-list .ps-selected').width();
if ((elementZoneStart < visibleZoneStart) || (elementZoneEnd > visibleZoneEnd) || (listWidth > containerWidth && visibleZoneEnd > elementZoneEnd)) {
var maxPosition = -(listWidth - containerWidth);
if (-elementZoneStart < maxPosition) {
listObject.css('left', maxPosition);
} else {
listObject.css('left', -elementZoneStart);
}
}
return true;
}
|
javascript
|
{
"resource": ""
}
|
|
q4023
|
splitPagesPromise
|
train
|
function splitPagesPromise (content) {
var pages = content.split(/\f/)
if (!pages) {
var ex = {
message: 'pdf-text-extract failed',
error: 'no text returned from the pdftotext command',
filePath: this.filePath,
stack: new Error().stack
}
throw ex
}
// sometimes there can be an extract blank page on the end
var lastPage = pages[pages.length - 1]
if (!lastPage) {
pages.pop()
}
resolve(pages)
}
|
javascript
|
{
"resource": ""
}
|
q4024
|
streamResultsPromise
|
train
|
function streamResultsPromise (command, args, options, cb) {
var output = ''
var stderr = ''
var child = spawn(command, args, options)
child.stdout.setEncoding('utf8')
child.stderr.setEncoding('utf8')
child.stdout.on('data', stdoutHandler)
child.stderr.on('data', stderrHandler)
child.on('close', closeHandler)
function stdoutHandler (data) {
output += data
}
function stderrHandler (data) {
stderr += data
}
function closeHandler (code) {
if (code !== 0) {
var ex = new Error('pdf-text-extract command failed: ' + stderr)
throw ex
}
cb(output)
}
}
|
javascript
|
{
"resource": ""
}
|
q4025
|
train
|
function (graph, opts, params) {
var self = this;
var savedNodes = graph.allNodes.filter(function(node) {
return node.props[self.db.options.id] != null
&& !(node.model.uniqueness && node.model.uniqueness.returnOld);
});
if (!savedNodes.length) return '';
var statements = savedNodes.map(function(node) {
params[node.name + 'id'] = getId(self.db, node.props);
return node.name + '=node({' + node.name + 'id})';
});
return 'START ' + statements.join(',');
}
|
javascript
|
{
"resource": ""
}
|
|
q4026
|
train
|
function (graph, opts, params) {
var self = this;
var newNodes = graph.allNodes.filter(function(node) {
return node.props[self.db.options.id] == null
&& !(node.model.uniqueness && node.model.uniqueness.returnOld);
});
if (!newNodes.length) return '';
var statements = newNodes.map(function(node) {
var label = node.model.type;
return '(' + node.name + ':' + label + ')';
});
return 'CREATE ' + statements.join(',');
}
|
javascript
|
{
"resource": ""
}
|
|
q4027
|
train
|
function (graph, opts, params) {
var self = this;
var updatedNodes = graph.allNodes;
if (opts.restrictToComp) {
updatedNodes = graph.allNodes.filter(function(node) {
return node.comp && node.comp.name == opts.restrictToComp;
});
}
function assign(statements, varName, hash) {
params[varName] = hash;
if (opts.additive) {
_.forEach(hash, function(val, key) {
statements.push(varName + '.`' + key + '`={' + varName + '}.`' + key + '`');
});
} else {
statements.push(varName + '={' + varName + '}');
}
}
return 'SET ' + updatedNodes.reduce(function(statements, node) {
// set props
var props = node.props;
if (props[self.db.options.id]) props = _.omit(props, self.db.options.id);
if (node.comp) assign(statements, '__rel_' + node.name, props._rel || {});
props = _.omit(props, '_rel');
assign(statements, node.name, props);
// set timestamps
if (!node.model.usingTimestamps) return statements;
statements.push(getSetCreatedTimestampStatement(node));
statements.push(node.name + '.' + node.model.updatedField + ' = timestamp()');
return statements;
}, []).join(',');
}
|
javascript
|
{
"resource": ""
}
|
|
q4028
|
train
|
function (graph, opts, params) {
if (graph.children.length == 0) return '';
function getRels(node) {
var rels = [];
node.children.forEach(function(childNode) {
rels.push('(' + node.name + ')-[__rel_' + childNode.name + ':' + childNode.comp.rel + ']->(' + childNode.name + ')');
rels.push.apply(rels, getRels(childNode));
});
return rels;
}
return 'CREATE UNIQUE ' + getRels(graph).join(',');
}
|
javascript
|
{
"resource": ""
}
|
|
q4029
|
beforeCommit
|
train
|
function beforeCommit(object, callback) {
var self = this;
async.waterfall([
this.triggerTransformEvent.bind(this, 'prepare', object),
this.triggerProgressionEvent.bind(this, 'validate'),
this.triggerEvent.bind(this, 'beforeSave')
], function(err, object) {
if (err) return callback(err);
// run beforeCommit on all composed objects as well.
transformComps.call(self, object, object, function(comp, object, i, cb) {
if (comp.transient) return cb();
beforeCommit.call(comp.model, object, cb);
}, callback);
});
}
|
javascript
|
{
"resource": ""
}
|
q4030
|
Cacher
|
train
|
function Cacher(seq, red) {
if (!(this instanceof Cacher)) {
return new Cacher(seq, red);
}
this.method = 'find';
this.options = {};
this.seconds = 0;
this.cacheHit = false;
this.cachePrefix = 'cacher';
this.sequelize = seq;
this.redis = red;
}
|
javascript
|
{
"resource": ""
}
|
q4031
|
jsonReplacer
|
train
|
function jsonReplacer(key, value) {
if (value && (value.DAO || value.sequelize)) {
return value.name || '';
}
return value;
}
|
javascript
|
{
"resource": ""
}
|
q4032
|
addMethod
|
train
|
function addMethod(key) {
Cacher.prototype[key] = function() {
if (!this.md) {
return Promise.reject(new Error('Model not set'));
}
this.method = key;
return this.run.apply(this, arguments);
};
}
|
javascript
|
{
"resource": ""
}
|
q4033
|
getPlace
|
train
|
function getPlace() {
var place = 0;
while (takenPlaces.indexOf(place) !== -1) {
place++;
}
takenPlaces.push(place);
return place;
}
|
javascript
|
{
"resource": ""
}
|
q4034
|
hideCreateLinkOnEventItemHover
|
train
|
function hideCreateLinkOnEventItemHover() {
element.on('mouseenter', function () {
element.on('mousemove', checkForEventItemRAF);
});
element.on('mouseleave', function () {
element.off('mousemove', checkForEventItemRAF);
element.removeClass('md-event-hover');
});
var lastHoverItem;
var checkForEventItemRAF = $$rAF.throttle(checkForEventItem);
function checkForEventItem(e) {
if (mdEventCalendarCtrl.isCreateDisabled() === true) { return; }
if (lastHoverItem === e.target) { return; }
lastHoverItem = e.target;
var targetIsEvent = !!e.target.getAttribute('md-event-id');
element.toggleClass('md-event-hover', targetIsEvent);
}
}
|
javascript
|
{
"resource": ""
}
|
q4035
|
Account
|
train
|
function Account(name) { //TODO doc vars
this.name = name; //debug name
this.token = null; //token after requestFBToken()
this.token_expire = 0; //timestamp after requestFBToken()
this.token_provider = 1; //provider ID after requester
this.c_user = null; //cookie from www.facebook.com
this.datr = null; //cookie from www.facebook.com
this.xs = null; //cookie from www.facebook.com
this.agent = null; //connection agent
this.debug = 1;
this.server = 'wss://web-live-v3-0.agario.miniclippt.com/ws'; //TODO doc
this.ws = null;
}
|
javascript
|
{
"resource": ""
}
|
q4036
|
train
|
function(client, packet) {
var x = packet.readFloat32LE();
var y = packet.readFloat32LE();
var zoom = packet.readFloat32LE();
if(client.debug >= 4)
client.log('spectate FOV update: x=' + x + ' y=' + y + ' zoom=' + zoom);
client.emitEvent('spectateFieldUpdate', x, y, zoom);
}
|
javascript
|
{
"resource": ""
}
|
|
q4037
|
train
|
function (client, packet) {
var line_x = packet.readSInt16LE();
var line_y = packet.readSInt16LE();
if (client.debug >= 4)
client.log('debug line drawn from x=' + line_x + ' y=' + line_y);
client.emitEvent('debugLine', line_x, line_y);
}
|
javascript
|
{
"resource": ""
}
|
|
q4038
|
train
|
function(client, packet) {
var highlights = [];
var names = [];
var count = packet.readUInt32LE();
for(var i=0;i<count;i++) {
var highlight = packet.readUInt32LE();
var name = '';
while(1) {
var char = packet.readUInt16LE();
if(char == 0) break;
name += String.fromCharCode(char);
}
highlights.push(highlight);
names.push(name);
}
if(JSON.stringify(client.leaderHighlights) == JSON.stringify(highlights) &&
JSON.stringify(client.leaderNames) == JSON.stringify(names)) {
return;
}
var old_highlights = client.leaderHighlights;
var old_leaderNames = client.leaderNames;
client.leaderHighlights = highlights;
client.leaderNames = names;
if(client.debug >= 3)
client.log('leaders update: ' + JSON.stringify(highlights) + ',' + JSON.stringify(names));
client.emitEvent('leaderBoardUpdate', old_highlights, highlights, old_leaderNames, names);
}
|
javascript
|
{
"resource": ""
}
|
|
q4039
|
train
|
function(client, packet) {
var teams_count = packet.readUInt32LE();
var teams_scores = [];
for (var i=0;i<teams_count;++i) {
teams_scores.push(packet.readFloat32LE());
}
if(JSON.stringify(client.teams_scores) == JSON.stringify(teams_scores)) return;
var old_scores = client.teams_scores;
if(client.debug >= 3)
client.log('teams scores update: ' + JSON.stringify(teams_scores));
client.teams_scores = teams_scores;
client.emitEvent('teamsScoresUpdate', old_scores, teams_scores);
}
|
javascript
|
{
"resource": ""
}
|
|
q4040
|
train
|
function(client, packet) {
var min_x = packet.readFloat64LE();
var min_y = packet.readFloat64LE();
var max_x = packet.readFloat64LE();
var max_y = packet.readFloat64LE();
if(client.debug >= 2)
client.log('map size: ' + [min_x, min_y, max_x, max_y].join(','));
client.emitEvent('mapSizeLoad', min_x, min_y, max_x, max_y);
}
|
javascript
|
{
"resource": ""
}
|
|
q4041
|
train
|
function(name) {
if(this.debug >= 3)
this.log('spawn() called, name=' + name);
if(!this.ws || this.ws.readyState !== WebSocket.OPEN) {
if(this.debug >= 1)
this.log('[warning] spawn() was called when connection was not established, packet will be dropped');
return false;
}
var buf = new Buffer(1 + 2*name.length);
buf.writeUInt8(0, 0);
for (var i=0;i<name.length;i++) {
buf.writeUInt16LE(name.charCodeAt(i), 1 + i*2);
}
this.send(buf);
//fix for unstable spawn on official servers
if(!this.spawn_attempt && this.spawn_interval) {
if(this.debug >= 4)
this.log('Starting spawn() interval');
var that = this;
this.spawn_attempt = 1;
this.spawn_interval_id = setInterval(function() {
if(that.debug >= 4)
that.log('spawn() interval tick, attempt ' + that.spawn_attempt + '/' + that.spawn_attempts);
if(that.spawn_attempt >= that.spawn_attempts) {
if(that.debug >= 1)
that.log('[warning] spawn() interval gave up! Disconnecting from server!');
that.spawn_attempt = 0;
clearInterval(that.spawn_interval_id);
that.spawn_interval_id = 0;
that.disconnect();
return;
}
that.spawn_attempt++;
that.spawn(name);
}, that.spawn_interval);
}
return true;
}
|
javascript
|
{
"resource": ""
}
|
|
q4042
|
train
|
function() {
if(!this.ws || this.ws.readyState !== WebSocket.OPEN) {
if(this.debug >= 1)
this.log('[warning] spectate() was called when connection was not established, packet will be dropped');
return false;
}
var buf = new Buffer([1]);
this.send(buf);
return true;
}
|
javascript
|
{
"resource": ""
}
|
|
q4043
|
Packet
|
train
|
function Packet(e) {
if(e instanceof Buffer) {
this.data = e;
this.length = this.data.length;
}else if((typeof Buffer) != 'undefined' && e.data instanceof Buffer) {
this.data = e.data;
this.length = this.data.length;
}else{
this.data = new DataView(e.data);
this.length = this.data.byteLength;
}
this.offset = 0;
}
|
javascript
|
{
"resource": ""
}
|
q4044
|
forKeys
|
train
|
function forKeys(obj, f) {
for (var key in obj) {
if (obj.hasOwnProperty(key) && typeof obj[key] !== 'function') {
if (f(key, obj[key])) {
break;
}
}
}
}
|
javascript
|
{
"resource": ""
}
|
q4045
|
processFile
|
train
|
function processFile(autogenContext, commentInfo, callback) {
fs.readFile(path.resolve(__dirname, "..", autogenContext.filePath), function (readError, sourceFileContentsBuffer) {
if (readError) {
callback(autogenContext.filePath, readError);
return;
}
processNextAutogenBlock(autogenContext, sourceFileContentsBuffer.toString(), commentInfo, 0, function (result, autogenError) {
//Write results if the content was changed (don't need to re-write the same content)
if (sourceFileContentsBuffer.toString() != result)
fs.writeFile(path.resolve(__dirname, "..", autogenContext.filePath), result, {}, function (writeError) {
callback(autogenContext.filePath, writeError);
});
else
callback(autogenContext.filePath, autogenError);
});
});
}
|
javascript
|
{
"resource": ""
}
|
q4046
|
processNextAutogenBlock
|
train
|
function processNextAutogenBlock(autogenContext, allData, commentInfo, pos, callback) {
//Update the position of the next block. If there isn't one, call the callback and break the recursion.
pos = utils.regexIndexOf(allData, commentInfo.start, pos);
if (pos == -1) {
callback(allData);
return;
}
//Extract the information from the autogen definition
var matchInfo = commentInfo.start.exec(allData.substring(pos));
//Skip over the start tag
pos += matchInfo[0].length;
//Get the data from the autogen tag
var tagContent = matchInfo[1];
var autogenTagData = utils.parseAutogenTag(tagContent);
//Make file name in to a full path
var filename = path.resolve(autogenContext.templateDir, autogenTagData.templateFileName + ".liquid");
//Find the end of the line (and the start of content)
// Handle both styles of line endings
var endOfAutogenLine = utils.regexIndexOf(allData, /[\r|\n]/, pos);
var startBlock = utils.regexIndexOf(allData, /[\n]/, endOfAutogenLine) + 1;
var endBlock = allData.indexOf(commentInfo.end, startBlock);
//Prepare and load the required data
var loadedLiquid = fs.readFileSync(filename);
//Deep-copy the spec data so that we can add context
var dataContext = utils.extend({}, autogenContext.specData);
//Populate the autogen data context with property mappings from autogen tag
for (var mappingIndex in autogenTagData.propertyMappings) {
var propertyMapping = autogenTagData.propertyMappings[mappingIndex];
var propValue = utils.getProp(dataContext, propertyMapping.sourceString);
utils.setProp(dataContext, propertyMapping.destString, propValue);
}
//Populate the autogen data context with value mappings from autogen tag
for (var mappingIndex in autogenTagData.valueMappings) {
var valueMapping = autogenTagData.valueMappings[mappingIndex];
utils.setProp(dataContext, valueMapping.destString, valueMapping.sourceString);
}
function insertTemplatedAndContinue(result) {
//Replace the old contents of the output block with the result from the liquid engine
var newData =
allData.substring(0, startBlock)
+ result
+ os.EOL
+ allData.substring(endBlock);
//Start/continue the recursion, and update the position for the next iteration
processNextAutogenBlock(autogenContext, newData, commentInfo,
startBlock
+ result.length
+ os.EOL.length
+ commentInfo.end.length, callback);
}
if (autogenContext.clearTemplatedSections)
insertTemplatedAndContinue('');
else {
//Parse and render the liquid using the spec data
autogenContext.liquidEngine
.parseAndRender(loadedLiquid, dataContext)
.then(insertTemplatedAndContinue);
}
}
|
javascript
|
{
"resource": ""
}
|
q4047
|
train
|
function (input) {
function camelCaseSingle(input) {
return String(input).toLowerCase().replace(/[-|\s](.)/g, function (match, group1) {
return group1.toUpperCase();
});
}
if(typeof input == 'string')
return camelCaseSingle(input);
else
return input.map(camelCaseSingle);
}
|
javascript
|
{
"resource": ""
}
|
|
q4048
|
train
|
function (object, property) {
return utils.getProp(object, Array.prototype.slice.call(arguments, 1).join("."));
}
|
javascript
|
{
"resource": ""
}
|
|
q4049
|
synthesize
|
train
|
function synthesize ({ name, composition, ast, version: composer, annotations = [] }) {
const code = `// generated by composer v${composer} and conductor v${version}\n\nconst composition = ${JSON.stringify(composition, null, 4)}\n\n// do not edit below this point\n\n` +
minify(`const main=(${main})(composition)`, { output: { max_line_len: 127 } }).code
annotations = annotations.concat([{ key: 'conductor', value: ast }, { key: 'composerVersion', value: composer }, { key: 'conductorVersion', value: version }])
return { name, action: { exec: { kind: 'nodejs:default', code }, annotations } }
}
|
javascript
|
{
"resource": ""
}
|
q4050
|
inspect
|
train
|
function inspect (p) {
if (!isObject(p.params)) p.params = { value: p.params }
if (p.params.error !== undefined) {
p.params = { error: p.params.error } // discard all fields but the error field
p.s.state = -1 // abort unless there is a handler in the stack
while (p.s.stack.length > 0 && !p.s.stack[0].marker) {
if ((p.s.state = p.s.stack.shift().catch || -1) >= 0) break
}
}
}
|
javascript
|
{
"resource": ""
}
|
q4051
|
run
|
train
|
function run (f, p) {
// handle let/mask pairs
const view = []
let n = 0
for (let frame of p.s.stack) {
if (frame.let === null) {
n++
} else if (frame.let !== undefined) {
if (n === 0) {
view.push(frame)
} else {
n--
}
}
}
// update value of topmost matching symbol on stack if any
function set (symbol, value) {
const element = view.find(element => element.let !== undefined && element.let[symbol] !== undefined)
if (element !== undefined) element.let[symbol] = JSON.parse(JSON.stringify(value))
}
// collapse stack for invocation
const env = view.reduceRight((acc, cur) => cur.let ? Object.assign(acc, cur.let) : acc, {})
let main = '(function(){try{const require=arguments[2];'
for (const name in env) main += `var ${name}=arguments[1]['${name}'];`
main += `return eval((function(){return(${f})})())(arguments[0])}finally{`
for (const name in env) main += `arguments[1]['${name}']=${name};`
main += '}})'
try {
return (1, eval)(main)(p.params, env, require)
} finally {
for (const name in env) set(name, env[name])
}
}
|
javascript
|
{
"resource": ""
}
|
q4052
|
set
|
train
|
function set (symbol, value) {
const element = view.find(element => element.let !== undefined && element.let[symbol] !== undefined)
if (element !== undefined) element.let[symbol] = JSON.parse(JSON.stringify(value))
}
|
javascript
|
{
"resource": ""
}
|
q4053
|
visit
|
train
|
function visit (composition, f) {
composition = Object.assign({}, composition) // copy
const combinator = composition['.combinator']()
if (combinator.components) {
composition.components = composition.components.map(f)
}
for (let arg of combinator.args || []) {
if (arg.type === undefined && composition[arg.name] !== undefined) {
composition[arg.name] = f(composition[arg.name], arg.name)
}
}
return new Composition(composition)
}
|
javascript
|
{
"resource": ""
}
|
q4054
|
label
|
train
|
function label (composition) {
const label = path => (composition, name, array) => {
const p = path + (name !== undefined ? (array === undefined ? `.${name}` : `[${name}]`) : '')
composition = visit(composition, label(p)) // copy
composition.path = p
return composition
}
return label('')(composition)
}
|
javascript
|
{
"resource": ""
}
|
q4055
|
declare
|
train
|
function declare (combinators, prefix) {
if (arguments.length > 2) throw new ComposerError('Too many arguments in "declare"')
if (!isObject(combinators)) throw new ComposerError('Invalid argument "combinators" in "declare"', combinators)
if (prefix !== undefined && typeof prefix !== 'string') throw new ComposerError('Invalid argument "prefix" in "declare"', prefix)
const composer = {}
for (let key in combinators) {
const type = prefix ? prefix + '.' + key : key
const combinator = combinators[key]
if (!isObject(combinator) || (combinator.args !== undefined && !Array.isArray(combinator.args))) {
throw new ComposerError(`Invalid "${type}" combinator specification in "declare"`, combinator)
}
for (let arg of combinator.args || []) {
if (typeof arg.name !== 'string') throw new ComposerError(`Invalid "${type}" combinator specification in "declare"`, combinator)
}
composer[key] = function () {
const composition = { type, '.combinator': () => combinator }
const skip = (combinator.args && combinator.args.length) || 0
if (!combinator.components && (arguments.length > skip)) {
throw new ComposerError(`Too many arguments in "${type}" combinator`)
}
for (let i = 0; i < skip; ++i) {
composition[combinator.args[i].name] = arguments[i]
}
if (combinator.components) {
composition.components = Array.prototype.slice.call(arguments, skip)
}
return new Composition(composition)
}
}
return composer
}
|
javascript
|
{
"resource": ""
}
|
q4056
|
train
|
function(e) {
for (var i=0, ii=touches.length; i<ii; ++i) {
if (touches[i].pointerId == e.pointerId) {
touches.splice(i, 1);
break;
}
}
}
|
javascript
|
{
"resource": ""
}
|
|
q4057
|
train
|
function(points, firstPoint, lastPoint, tolerance){
var maxDistance = 0;
var indexFarthest = 0;
for (var index = firstPoint, distance; index < lastPoint; index++) {
distance = perpendicularDistance(points[firstPoint], points[lastPoint], points[index]);
if (distance > maxDistance) {
maxDistance = distance;
indexFarthest = index;
}
}
if (maxDistance > tolerance && indexFarthest != firstPoint) {
//Add the largest point that exceeds the tolerance
pointIndexsToKeep.push(indexFarthest);
douglasPeuckerReduction(points, firstPoint, indexFarthest, tolerance);
douglasPeuckerReduction(points, indexFarthest, lastPoint, tolerance);
}
}
|
javascript
|
{
"resource": ""
}
|
|
q4058
|
train
|
function() {
var tileWidth = this.extent.getWidth() / this.map.getResolution();
var tileHeight = this.extent.getHeight() / this.map.getResolution();
this.tileSize = new OpenLayers.Size(tileWidth, tileHeight);
}
|
javascript
|
{
"resource": ""
}
|
|
q4059
|
train
|
function(x, y) {
OpenLayers.Geometry.Point.prototype.move.apply(this, arguments);
this._rotationHandle && this._rotationHandle.geometry.move(x, y);
this._handle.geometry.move(x, y);
}
|
javascript
|
{
"resource": ""
}
|
|
q4060
|
train
|
function(x, y){
var oldX = this.x, oldY = this.y;
OpenLayers.Geometry.Point.prototype.move.call(this, x, y);
if(control._moving) {
return;
}
var evt = control.dragControl.handlers.drag.evt;
var constrain = (evt && evt.shiftKey) ? 45 : 1;
var centerGeometry = control.center;
var dx1 = this.x - centerGeometry.x;
var dy1 = this.y - centerGeometry.y;
var dx0 = dx1 - x;
var dy0 = dy1 - y;
this.x = oldX;
this.y = oldY;
var a0 = Math.atan2(dy0, dx0);
var a1 = Math.atan2(dy1, dx1);
var angle = a1 - a0;
angle *= 180 / Math.PI;
control._angle = (control._angle + angle) % 360;
var diff = control.rotation % constrain;
if(Math.abs(control._angle) >= constrain || diff !== 0) {
angle = Math.round(control._angle / constrain) * constrain -
diff;
control._angle = 0;
control.box.geometry.rotate(angle, centerGeometry);
control.transformFeature({rotation: angle});
}
}
|
javascript
|
{
"resource": ""
}
|
|
q4061
|
train
|
function(pixel) {
if(this.feature === control.feature) {
this.feature = control.box;
}
OpenLayers.Control.DragFeature.prototype.moveFeature.apply(this,
arguments);
}
|
javascript
|
{
"resource": ""
}
|
|
q4062
|
train
|
function(feature, pixel) {
if(feature === control.box) {
control.transformFeature({center: control.center});
}
}
|
javascript
|
{
"resource": ""
}
|
|
q4063
|
train
|
function(feature, pixel) {
var eligible = !control.geometryTypes ||
OpenLayers.Util.indexOf(control.geometryTypes,
feature.geometry.CLASS_NAME) !== -1;
var i = OpenLayers.Util.indexOf(control.handles, feature);
i += OpenLayers.Util.indexOf(control.rotationHandles,
feature);
if(feature !== control.feature && feature !== control.box &&
i == -2 && eligible) {
control.setFeature(feature);
}
}
|
javascript
|
{
"resource": ""
}
|
|
q4064
|
train
|
function(str) {
var coords = OpenLayers.String.trim(str).split(this.regExes.spaces);
return new OpenLayers.Feature.Vector(
new OpenLayers.Geometry.Point(coords[0], coords[1])
);
}
|
javascript
|
{
"resource": ""
}
|
|
q4065
|
train
|
function(str) {
var point;
var points = OpenLayers.String.trim(str).split(',');
var components = [];
for(var i=0, len=points.length; i<len; ++i) {
point = points[i].replace(this.regExes.trimParens, '$1');
components.push(this.parse.point.apply(this, [point]).geometry);
}
return new OpenLayers.Feature.Vector(
new OpenLayers.Geometry.MultiPoint(components)
);
}
|
javascript
|
{
"resource": ""
}
|
|
q4066
|
train
|
function(str) {
var points = OpenLayers.String.trim(str).split(',');
var components = [];
for(var i=0, len=points.length; i<len; ++i) {
components.push(this.parse.point.apply(this, [points[i]]).geometry);
}
return new OpenLayers.Feature.Vector(
new OpenLayers.Geometry.LineString(components)
);
}
|
javascript
|
{
"resource": ""
}
|
|
q4067
|
train
|
function(str) {
var line;
var lines = OpenLayers.String.trim(str).split(this.regExes.parenComma);
var components = [];
for(var i=0, len=lines.length; i<len; ++i) {
line = lines[i].replace(this.regExes.trimParens, '$1');
components.push(this.parse.linestring.apply(this, [line]).geometry);
}
return new OpenLayers.Feature.Vector(
new OpenLayers.Geometry.MultiLineString(components)
);
}
|
javascript
|
{
"resource": ""
}
|
|
q4068
|
train
|
function(str) {
var ring, linestring, linearring;
var rings = OpenLayers.String.trim(str).split(this.regExes.parenComma);
var components = [];
for(var i=0, len=rings.length; i<len; ++i) {
ring = rings[i].replace(this.regExes.trimParens, '$1');
linestring = this.parse.linestring.apply(this, [ring]).geometry;
linearring = new OpenLayers.Geometry.LinearRing(linestring.components);
components.push(linearring);
}
return new OpenLayers.Feature.Vector(
new OpenLayers.Geometry.Polygon(components)
);
}
|
javascript
|
{
"resource": ""
}
|
|
q4069
|
train
|
function(str) {
var polygon;
var polygons = OpenLayers.String.trim(str).split(this.regExes.doubleParenComma);
var components = [];
for(var i=0, len=polygons.length; i<len; ++i) {
polygon = polygons[i].replace(this.regExes.trimParens, '$1');
components.push(this.parse.polygon.apply(this, [polygon]).geometry);
}
return new OpenLayers.Feature.Vector(
new OpenLayers.Geometry.MultiPolygon(components)
);
}
|
javascript
|
{
"resource": ""
}
|
|
q4070
|
train
|
function(str) {
// separate components of the collection with |
str = str.replace(/,\s*([A-Za-z])/g, '|$1');
var wktArray = OpenLayers.String.trim(str).split('|');
var components = [];
for(var i=0, len=wktArray.length; i<len; ++i) {
components.push(OpenLayers.Format.WKT.prototype.read.apply(this,[wktArray[i]]));
}
return components;
}
|
javascript
|
{
"resource": ""
}
|
|
q4071
|
train
|
function(node, obj) {
var name = node.localName || node.nodeName.split(":").pop();
if (!(OpenLayers.Util.isArray(obj[name]))) {
obj[name] = [];
}
var dc_element = {};
var attrs = node.attributes;
for(var i=0, len=attrs.length; i<len; ++i) {
dc_element[attrs[i].name] = attrs[i].nodeValue;
}
dc_element.value = this.getChildValue(node);
if (dc_element.value != "") {
obj[name].push(dc_element);
}
}
|
javascript
|
{
"resource": ""
}
|
|
q4072
|
train
|
function(node, obj) {
var name = node.localName || node.nodeName.split(":").pop();
if (!(OpenLayers.Util.isArray(obj[name]))) {
obj[name] = [];
}
obj[name].push(this.getChildValue(node));
}
|
javascript
|
{
"resource": ""
}
|
|
q4073
|
train
|
function(theDiv, options) {
var topRico = theDiv.parentNode.childNodes[0];
//theDiv would be theDiv.parentNode.childNodes[1]
var bottomRico = theDiv.parentNode.childNodes[2];
theDiv.parentNode.removeChild(topRico);
theDiv.parentNode.removeChild(bottomRico);
this.round(theDiv.parentNode, options);
}
|
javascript
|
{
"resource": ""
}
|
|
q4074
|
train
|
function (image, old) {
var data1 = old.data,
data2 = image.data,
w1 = old.width,
w2 = image.width,
px1 = old.globalOffset.x,
py1 = old.globalOffset.y,
px2 = image.globalOffset.x,
py2 = image.globalOffset.y,
b1 = old.bounds,
b2 = image.bounds,
px = Math.min(b1.minX + px1, b2.minX + px2), // global offset for new image (by min in bounds)
py = Math.min(b1.minY + py1, b2.minY + py2),
b = { // bounds for new image include all of the pixels [0,0,width,height] (reduce to bounds)
minX: 0,
minY: 0,
maxX: Math.max(b1.maxX + px1, b2.maxX + px2) - px,
maxY: Math.max(b1.maxY + py1, b2.maxY + py2) - py,
},
w = b.maxX + 1, // size for new image
h = b.maxY + 1,
i, j, k, k1, k2, len;
var result = new Uint8Array(w * h);
// copy all old image
len = b1.maxX - b1.minX + 1;
i = (py1 - py + b1.minY) * w + (px1 - px + b1.minX);
k1 = b1.minY * w1 + b1.minX;
k2 = b1.maxY * w1 + b1.minX + 1;
// walk through rows (Y)
for (k = k1; k < k2; k += w1) {
result.set(data1.subarray(k, k + len), i); // copy row
i += w;
}
// copy new image (only "black" pixels)
len = b2.maxX - b2.minX + 1;
i = (py2 - py + b2.minY) * w + (px2 - px + b2.minX);
k1 = b2.minY * w2 + b2.minX;
k2 = b2.maxY * w2 + b2.minX + 1;
// walk through rows (Y)
for (k = k1; k < k2; k += w2) {
// walk through cols (X)
for (j = 0; j < len; j++) {
if (data2[k + j] === 1) result[i + j] = 1;
}
i += w;
}
return {
data: result,
width: w,
height: h,
bounds: b,
globalOffset: {
x: px,
y: py,
}
};
}
|
javascript
|
{
"resource": ""
}
|
|
q4075
|
setupGeometry
|
train
|
function setupGeometry(regionsData, options) {
options = options || {};
var regions = regionsData.regions,
dataset = [],
postFilter =
options.postFilter ||
(regionsData.meta && regionsData.meta.postFilter
? new Function("region", regionsData.meta.postFilter)
: 0),
scheme = options.scheme || (regionsData.meta && regionsData.meta.scheme),
disputedBorders =
(regionsData.meta && regionsData.meta.disputedBorders) || {},
useSetup = options.recombine || options.lang || "en",
disputedBorder =
typeof useSetup == "string" ? disputedBorders[useSetup] : useSetup,
geometry = 0;
for (const i in disputedBorders) {
var setup = disputedBorders[i];
for (const j in setup) {
var regionSet = setup[j];
if (typeof regionSet == "string") {
setup[j] = new Function("region", regionSet);
}
}
}
for (const i in regions) {
if (regions.hasOwnProperty(i)) {
if (!postFilter || postFilter(wrapRegion(i, regionsData))) {
if (disputedBorder && disputedBorder[+i]) {
geometry = recombineRegion(regionsData, {
filter: disputedBorder[+i]
});
} else if (scheme && scheme[+i]) {
var sch = scheme[+i];
geometry = recombineRegion(regionsData, {
filter: typeof sch == "string" ? new Function("region", sch) : sch
});
} else {
geometry = getGeometry(+i, regionsData);
}
if (geometry) {
dataset[regions[i].index] = {
type: "Feature",
geometry: geometry,
properties: {
osmId: i,
level: regions[i].level,
properties: regions[i].property || {},
parents: regions[i].parents,
hintContent: regions[i].name,
name: regions[i].name,
title: regions[i].name,
wikipedia: regions[i].wikipedia,
orderIndex: regions[i].index,
square: regions[i].square
}
};
}
}
}
}
var result = [];
for (var i = 0, l = dataset.length; i < l; ++i) {
if (dataset[i]) {
result.push(dataset[i]);
}
}
return result;
}
|
javascript
|
{
"resource": ""
}
|
q4076
|
decodeByteVector
|
train
|
function decodeByteVector(x, N) {
var point = 0;
for (var i = 0; i < N; ++i) {
point |= x.charCodeAt(i) << (i * 8);
}
return point;
}
|
javascript
|
{
"resource": ""
}
|
q4077
|
wrapRegion
|
train
|
function wrapRegion(rid, data) {
var meta = data.regions[rid],
prop = meta.property || {};
return new RegionObject(rid, meta, prop, data);
}
|
javascript
|
{
"resource": ""
}
|
q4078
|
load
|
train
|
function load(path, callback, errorCallback) {
try {
var xhr = new XMLHttpRequest();
xhr.open("GET", path, true);
xhr.onreadystatechange = function() {
if (xhr.readyState === 4) {
if (xhr.status === 200 || xhr.status === 304) {
try {
var response = JSON.parse(xhr.responseText);
callback(response);
} catch (e) {
errorCallback(e);
}
} else {
errorCallback(xhr);
}
}
};
xhr.setRequestHeader("Content-Type", "application/json");
xhr.setRequestHeader("X-Requested-With", "XMLHttpRequest");
xhr.send();
} catch (e) {
errorCallback(e);
}
}
|
javascript
|
{
"resource": ""
}
|
q4079
|
getDatumValue
|
train
|
function getDatumValue(datum) {
for (var i in datasets) {
var dataset = datasets[i];
var displayKey = dataset.displayKey || 'value';
var value = (angular.isFunction(displayKey) ? displayKey(datum) : datum[displayKey]) || '';
return value;
}
}
|
javascript
|
{
"resource": ""
}
|
q4080
|
parseFrameUID
|
train
|
function parseFrameUID(device, data, win, fail)
{
if(data[0] != 0x00) return false;
// The UID frame has 18 bytes + 2 bytes reserved for future use
// https://github.com/google/eddystone/tree/master/eddystone-uid
// Check that we got at least 18 bytes.
if(data.byteLength < 18)
{
fail("UID frame: invalid byteLength: "+data.byteLength);
return true;
}
device.txPower = evothings.util.littleEndianToInt8(data, 1);
device.nid = data.subarray(2, 12); // Namespace ID.
device.bid = data.subarray(12, 18); // Beacon ID.
win(device);
return true;
}
|
javascript
|
{
"resource": ""
}
|
q4081
|
train
|
function () {
var shrinkWrapPath = path.resolve(process.cwd(), 'npm-shrinkwrap.json');
if (fs.existsSync(shrinkWrapPath)) {
logger.logInfo('[npm] using npm-shrinkwrap.json instead of package.json');
return shrinkWrapPath;
}
if (getNpmMajorVersion() >= 5) {
var packageLockPath = path.resolve(process.cwd(), 'package-lock.json');
if (fs.existsSync(packageLockPath)) {
logger.logInfo('[npm] using package-lock.json instead of package.json');
return packageLockPath;
}
}
var packagePath = path.resolve(process.cwd(), 'package.json');
return packagePath;
}
|
javascript
|
{
"resource": ""
}
|
|
q4082
|
train
|
function () {
var composerLockPath = path.resolve(process.cwd(), 'composer.lock');
var composerJsonPath = path.resolve(process.cwd(), 'composer.json');
if (isUsingComposerLock === null) {
if (fs.existsSync(composerLockPath)) {
logger.logInfo('[composer] using composer.lock instead of composer.json');
isUsingComposerLock = true;
} else {
isUsingComposerLock = false;
}
}
return isUsingComposerLock ? composerLockPath : composerJsonPath;
}
|
javascript
|
{
"resource": ""
}
|
|
q4083
|
train
|
function () {
var composerInstallDirectory = 'vendor';
var exists = null;
try {
exists = fs.statSync(getComposerConfigPath());
} catch (e) {}
if (exists !== null) {
var composerConfig = JSON.parse(fs.readFileSync(getComposerConfigPath()));
if ('config' in composerConfig && 'vendor-dir' in composerConfig.config) {
composerInstallDirectory = composerConfig.config['vendor-dir'];
}
}
return composerInstallDirectory;
}
|
javascript
|
{
"resource": ""
}
|
|
q4084
|
train
|
function () {
var version = 'UnknownComposer';
var versionString = shell.exec('composer --version', {silent: true}).output;
// Example below:
// Composer version 1.0.0-alpha9 2014-12-07 17:15:20
var versionRegex = /Composer version (\S+)/;
var result = versionRegex.exec(versionString);
if (result !== null) {
version = result[1];
} else {
logger.logInfo('Could not find composer version from version string: ' + versionString);
}
return version;
}
|
javascript
|
{
"resource": ""
}
|
|
q4085
|
train
|
function(elem, name) {
if (!elem.attribs || !hasOwn.call(elem.attribs, name))
return;
delete elem.attribs[name];
}
|
javascript
|
{
"resource": ""
}
|
|
q4086
|
setCss
|
train
|
function setCss(el, prop, val, idx) {
if ('string' == typeof prop) {
var styles = getCss(el);
if (typeof val === 'function') {
val = val.call(el, idx, styles[prop]);
}
if (val === '') {
delete styles[prop];
} else if (val != null) {
styles[prop] = val;
}
el.attribs.style = stringify(styles);
} else if ('object' == typeof prop) {
Object.keys(prop).forEach(function(k){
setCss(el, k, prop[k]);
});
}
}
|
javascript
|
{
"resource": ""
}
|
q4087
|
getCss
|
train
|
function getCss(el, prop) {
var styles = parse(el.attribs.style);
if (typeof prop === 'string') {
return styles[prop];
} else if (Array.isArray(prop)) {
return _.pick(styles, prop);
} else {
return styles;
}
}
|
javascript
|
{
"resource": ""
}
|
q4088
|
stringify
|
train
|
function stringify(obj) {
return Object.keys(obj || {})
.reduce(function(str, prop){
return str += ''
+ (str ? ' ' : '')
+ prop
+ ': '
+ obj[prop]
+ ';';
}, '');
}
|
javascript
|
{
"resource": ""
}
|
q4089
|
parse
|
train
|
function parse(styles) {
styles = (styles || '').trim();
if (!styles) return {};
return styles
.split(';')
.reduce(function(obj, str){
var n = str.indexOf(':');
// skip if there is no :, or if it is the first/last character
if (n < 1 || n === str.length-1) return obj;
obj[str.slice(0,n).trim()] = str.slice(n+1).trim();
return obj;
}, {});
}
|
javascript
|
{
"resource": ""
}
|
q4090
|
train
|
function( e, elem, $pane, $items, pos ){
$prev.add($next).show();
if( pos == 0 )
$prev.hide();
else if( pos == $items.length-1 )
$next.hide();
}
|
javascript
|
{
"resource": ""
}
|
|
q4091
|
Action
|
train
|
function Action(name) {
Action.super_.call(this);
this.id = ActionUniqueId();
this.set('ActionID', this.id);
this.set('Action', name);
}
|
javascript
|
{
"resource": ""
}
|
q4092
|
Login
|
train
|
function Login(username, secret) {
Login.super_.call(this, 'Login');
this.set('Username', username);
this.set('Secret', secret );
}
|
javascript
|
{
"resource": ""
}
|
q4093
|
QueueReload
|
train
|
function QueueReload(queue, members, rules, parameters) {
QueueReload.super_.call(this, 'QueueReload');
if (undefined !== queue) {
this.set('queue', queue);
}
if (undefined !== members) {
this.set('members', members);
}
if (undefined !== rules) {
this.set('rules', rules);
}
if (undefined !== parameters) {
this.set('parameters', parameters);
}
}
|
javascript
|
{
"resource": ""
}
|
q4094
|
QueueStatus
|
train
|
function QueueStatus(queue, member) {
QueueStatus.super_.call(this, 'QueueStatus');
if (undefined !== queue) {
this.set('Queue', queue);
}
if (undefined !== member) {
this.set('Member', member);
}
}
|
javascript
|
{
"resource": ""
}
|
q4095
|
QueueRemove
|
train
|
function QueueRemove(asteriskInterface, queue) {
QueueRemove.super_.call(this, 'QueueRemove');
this.set('interface', asteriskInterface);
this.set('queue', queue);
}
|
javascript
|
{
"resource": ""
}
|
q4096
|
QueueAdd
|
train
|
function QueueAdd(asteriskInterface, queue, paused, memberName, penalty) {
QueueAdd.super_.call(this, 'QueueAdd');
this.set('interface', asteriskInterface);
this.set('queue', queue);
if (undefined !== paused) {
this.set('paused', paused);
}
if (undefined !== memberName) {
this.set('membername', memberName);
}
if (undefined !== penalty) {
this.set('penalty', penalty);
}
}
|
javascript
|
{
"resource": ""
}
|
q4097
|
MeetmeMute
|
train
|
function MeetmeMute(meetme, usernum) {
MeetmeMute.super_.call(this, 'MeetmeMute');
this.set('Meetme', meetme);
this.set('Usernum', usernum);
}
|
javascript
|
{
"resource": ""
}
|
q4098
|
MeetmeUnmute
|
train
|
function MeetmeUnmute(meetme, usernum) {
MeetmeUnmute.super_.call(this, 'MeetmeUnmute');
this.set('Meetme', meetme);
this.set('Usernum', usernum);
}
|
javascript
|
{
"resource": ""
}
|
q4099
|
ConfbridgeKick
|
train
|
function ConfbridgeKick(conference, channel) {
ConfbridgeKick.super_.call(this, 'ConfbridgeKick');
this.set('Conference', conference);
this.set('Channel', channel);
}
|
javascript
|
{
"resource": ""
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.