_id
stringlengths 2
6
| title
stringlengths 0
58
| partition
stringclasses 3
values | text
stringlengths 52
373k
| language
stringclasses 1
value | meta_information
dict |
|---|---|---|---|---|---|
q3900
|
getOperationForUpdatingLog
|
train
|
function getOperationForUpdatingLog(operationId, tableName, action, item) {
return api.getMetadata(tableName, action, item).then(function(metadata) {
return {
tableName: operationTableName,
action: 'upsert',
data: {
id: operationId,
action: action,
metadata: metadata
}
};
});
}
|
javascript
|
{
"resource": ""
}
|
q3901
|
getMetadata
|
train
|
function getMetadata(tableName, action, item) {
return Platform.async(function(callback) {
callback();
})().then(function() {
var metadata = {};
// If action is update and item defines version property OR if action is insert / update,
// define metadata.version to be the item's version property
if (action === 'upsert' ||
action === 'insert' ||
(action === 'update' && item.hasOwnProperty(versionColumnName))) {
metadata[versionColumnName] = item[versionColumnName];
return metadata;
} else if (action == 'update' || action === 'delete') { // Read item's version property from the table
return store.lookup(tableName, item[idPropertyName], true /* suppressRecordNotFoundError */).then(function(result) {
if (result) {
metadata[versionColumnName] = result[versionColumnName];
}
return metadata;
});
} else {
throw new Error('Invalid action ' + action);
}
});
}
|
javascript
|
{
"resource": ""
}
|
q3902
|
getMaxOperationId
|
train
|
function getMaxOperationId() {
var query = new Query(operationTableName);
return store.read(query.orderByDescending('id').take(1)).then(function(result) {
Validate.isArray(result);
if (result.length === 0) {
return 0;
} else if (result.length === 1) {
return result[0].id;
} else {
throw new Error('something is wrong!');
}
});
}
|
javascript
|
{
"resource": ""
}
|
q3903
|
push
|
train
|
function push(handler) {
return pushTaskRunner.run(function() {
reset();
pushHandler = handler;
return pushAllOperations().then(function() {
return pushConflicts;
});
});
}
|
javascript
|
{
"resource": ""
}
|
q3904
|
pushAllOperations
|
train
|
function pushAllOperations() {
var currentOperation,
pushError;
return readAndLockFirstPendingOperation().then(function(pendingOperation) {
if (!pendingOperation) {
return; // No more pending operations. Push is complete
}
var currentOperation = pendingOperation;
return pushOperation(currentOperation).then(function() {
return removeLockedOperation();
}, function(error) {
// failed to push
return unlockPendingOperation().then(function() {
pushError = createPushError(store, operationTableManager, storeTaskRunner, currentOperation, error);
//TODO: If the conflict isn't resolved but the error is marked as handled by the user,
//we can end up in an infinite loop. Guard against this by capping the max number of
//times handlePushError can be called for the same record.
// We want to reset the retryCount when we move on to the next record
if (lastFailedOperationId !== currentOperation.logRecord.id) {
lastFailedOperationId = currentOperation.logRecord.id;
retryCount = 0;
}
// Cap the number of times error handling logic is invoked for the same record
if (retryCount < maxRetryCount) {
++retryCount;
return handlePushError(pushError, pushHandler);
}
});
}).then(function() {
if (!pushError) { // no push error
lastProcessedOperationId = currentOperation.logRecord.id;
} else if (pushError && !pushError.isHandled) { // push failed and not handled
// For conflict errors, we add the error to the list of errors and continue pushing other records
// For other errors, we abort push.
if (pushError.isConflict()) {
lastProcessedOperationId = currentOperation.logRecord.id;
pushConflicts.push(pushError);
} else {
throw new verror.VError(pushError.getError(), 'Push failed while pushing operation for tableName : ' + currentOperation.logRecord.tableName +
', action: ' + currentOperation.logRecord.action +
', and record ID: ' + currentOperation.logRecord.itemId);
}
} else { // push error handled
// No action needed - We want the operation to be re-pushed.
// No special handling is needed even if the operation was cancelled by the user as part of error handling
}
}).then(function() {
return pushAllOperations(); // push remaining operations
});
});
}
|
javascript
|
{
"resource": ""
}
|
q3905
|
train
|
function (err) {
if (_.isNull(err)) {
// Call complete with all the args except for err
complete.apply(null, Array.prototype.slice.call(arguments, 1));
} else {
error(err);
}
}
|
javascript
|
{
"resource": ""
}
|
|
q3906
|
handlePushError
|
train
|
function handlePushError(pushError, pushHandler) {
return Platform.async(function(callback) {
callback();
})().then(function() {
if (pushError.isConflict()) {
if (pushHandler && pushHandler.onConflict) {
// NOTE: value of server record will not be available in case of 409.
return pushHandler.onConflict(pushError);
}
} else if (pushHandler && pushHandler.onError) {
return pushHandler.onError(pushError);
}
}).then(undefined, function(error) {
// Set isHandled to false even if the user has set it to handled if the onConflict / onError failed
pushError.isHandled = false;
});
}
|
javascript
|
{
"resource": ""
}
|
q3907
|
removeSystemProperties
|
train
|
function removeSystemProperties(instance) {
var copy = {};
for (var property in instance) {
if ((property != MobileServiceSystemColumns.Version) &&
(property != MobileServiceSystemColumns.UpdatedAt) &&
(property != MobileServiceSystemColumns.CreatedAt) &&
(property != MobileServiceSystemColumns.Deleted))
{
copy[property] = instance[property];
}
}
return copy;
}
|
javascript
|
{
"resource": ""
}
|
q3908
|
getItemFromResponse
|
train
|
function getItemFromResponse(response) {
var result = _.fromJson(response.responseText);
if (response.getResponseHeader) {
var eTag = response.getResponseHeader('ETag');
if (!_.isNullOrEmpty(eTag)) {
result[MobileServiceSystemColumns.Version] = getVersionFromEtag(eTag);
}
}
return result;
}
|
javascript
|
{
"resource": ""
}
|
q3909
|
setServerItemIfPreconditionFailed
|
train
|
function setServerItemIfPreconditionFailed(error) {
if (error.request && error.request.status === 412) {
error.serverInstance = _.fromJson(error.request.responseText);
}
}
|
javascript
|
{
"resource": ""
}
|
q3910
|
getVersionFromEtag
|
train
|
function getVersionFromEtag(etag) {
var len = etag.length,
result = etag;
if (len > 1 && etag[0] === '"' && etag[len - 1] === '"') {
result = etag.substr(1, len - 2);
}
return result.replace(/\\\"/g, '"');
}
|
javascript
|
{
"resource": ""
}
|
q3911
|
addQueryParametersFeaturesIfApplicable
|
train
|
function addQueryParametersFeaturesIfApplicable(features, userQueryParameters) {
var hasQueryParameters = false;
if (userQueryParameters) {
if (Array.isArray(userQueryParameters)) {
hasQueryParameters = userQueryParameters.length > 0;
} else if (_.isObject(userQueryParameters)) {
for (var k in userQueryParameters) {
hasQueryParameters = true;
break;
}
}
}
if (hasQueryParameters) {
features.push(constants.features.AdditionalQueryParameters);
}
return features;
}
|
javascript
|
{
"resource": ""
}
|
q3912
|
train
|
function(gpsRefPos) {
if(gpsRefPos === undefined ||
gpsRefPos.length < 4) {
this._gpsRefPos = undefined;
}
else if(gpsRefPos[0] === 0 &&
gpsRefPos[1] === 0 &&
gpsRefPos[2] === 0 &&
gpsRefPos[3] === 0) {
this._gpsRefPos = undefined;
}
else {
this._gpsRefPos = gpsRefPos;
}
return this.redraw();
}
|
javascript
|
{
"resource": ""
}
|
|
q3913
|
train
|
function () {
var lngSize = this._getLngSize() / 2.0;
var latSize = this._getLatSize() / 2.0;
var latlng = this._latlng;
return new L.LatLngBounds(
[latlng.lat - latSize, latlng.lng - lngSize],
[latlng.lat + latSize, latlng.lng + lngSize]);
}
|
javascript
|
{
"resource": ""
}
|
|
q3914
|
train
|
function(point, angle) {
var x = point[0];
var y = point[1];
var si_z = Math.sin(angle);
var co_z = Math.cos(angle);
var newX = x * co_z - y * si_z;
var newY = x * si_z + y * co_z;
return [newX, newY];
}
|
javascript
|
{
"resource": ""
}
|
|
q3915
|
train
|
function(points, angle) {
var result = [];
for(var i=0;i<points.length;i+=2) {
var x = points[i + 0] * this._size;
var y = points[i + 1] * this._size;
var pt = this._rotate([x, y], angle);
result.push(pt[0]);
result.push(pt[1]);
}
return result;
}
|
javascript
|
{
"resource": ""
}
|
|
q3916
|
train
|
function () {
if(this._heading === undefined) {
return this._createNoHeadingSymbolPathString();
}
else {
if(this._gpsRefPos === undefined || this._map.getZoom() <= this._minSilouetteZoom ) {
return this._createWithHeadingSymbolPathString();
}
else {
return this._createSilouetteSymbolPathString();
}
}
}
|
javascript
|
{
"resource": ""
}
|
|
q3917
|
train
|
function(message, originalError) {
var stack;
this.message = message;
this.originalError = originalError;
if (Error.captureStackTrace) {
Error.captureStackTrace(this, this.constructor);
stack = this.stack;
} else {
stack = new Error(message).stack;
}
if (Object.defineProperty) {
Object.defineProperty(this, "stack", {
configurable: true, // required for Bluebird long stack traces
get: function() {
if (this.originalError) {
return stack + "\nCaused by: " + this.originalError.stack;
}
return stack;
},
set: function(value) {
stack = value;
}
});
}
}
|
javascript
|
{
"resource": ""
}
|
|
q3918
|
getInternetExplorerExe
|
train
|
function getInternetExplorerExe () {
var suffix = path.join('Internet Explorer', PROCESS_NAME)
var locations = _.map(_.compact([
process.env['PROGRAMW6432'],
process.env['PROGRAMFILES(X86)'],
process.env['PROGRAMFILES']
]), function (prefix) {
return path.join(prefix, suffix)
})
return _.find(locations, function (location) {
return fs.existsSync(location)
})
}
|
javascript
|
{
"resource": ""
}
|
q3919
|
merge
|
train
|
function merge( a, l, m, r ) {
const n1 = m - l + 1;
const n2 = r - m;
const L = a.slice( l, m + 1 );
const R = a.slice( m + 1, 1 + r );
let i = 0, j = 0, k = l;
while( i < n1 && j < n2 ) {
if( L[ i ][ 0 ] <= R[ j ][ 0 ] ) {
a[ k ] = L[ i ];
i++;
} else {
a[ k ] = R[ j ];
j++;
}
k++;
}
while( i < n1 ) {
a[ k ] = L[ i ];
i++;
k++;
}
while( j < n2 ) {
a[ k ] = R[ j ];
j++;
k++;
}
}
|
javascript
|
{
"resource": ""
}
|
q3920
|
findHost
|
train
|
function findHost() {
var current = this;
var app;
// Keep iterating upward until we don't have a grandparent.
// Has to do this grandparent check because at some point we hit the project.
// Stop at lazy engine boundaries.
do {
if (current.lazyLoading === true) { return current; }
app = current.app || app;
} while (current.parent && current.parent.parent && (current = current.parent));
return app;
}
|
javascript
|
{
"resource": ""
}
|
q3921
|
train
|
function(path) {
return (path && path.match(/^[a-z]:\\/i)) ? path.charAt(0).toLowerCase() + path.slice(1) : path;
}
|
javascript
|
{
"resource": ""
}
|
|
q3922
|
Player
|
train
|
function Player(opts) {
if (!(this instanceof Player)) {
return new Player(opts);
}
events.EventEmitter.call(this);
this.name = opts.name;
this.supportedInterfaces = opts.supportedInterfaces || ['player'];
this._tracks = [];
this.init(opts);
}
|
javascript
|
{
"resource": ""
}
|
q3923
|
TokenRequest
|
train
|
function TokenRequest(authenticate, options) {
var self = this;
this.status = 'expired';
this.pendingCallbacks = [];
// execute accumulated callbacks during the 'pending' state
function fireCallbacks(err, token) {
self.pendingCallbacks.forEach(function (callback) {
callback(err, token);
});
self.pendingCallbacks = [];
}
TokenRequest.prototype.get = function (callback) {
if (this.status == 'expired') {
this.status = 'pending';
this.pendingCallbacks.push(callback);
authenticate(options, function (err, token) {
if (err) {
self.status = 'expired';
return fireCallbacks(err, null);
}
self.issued = Date.now();
self.duration = options.expiration || 60 * 60 * 1000;
self.token = token;
self.status = 'completed';
return fireCallbacks(null, token);
});
} else if (this.status == 'pending') {
// wait for the pending request instead of issuing a new one
this.pendingCallbacks.push(callback);
} else if (this.status == 'completed') {
if (this.issued + this.duration < Date.now()) {
this.status = 'expired';
debug('token is expired, a new token will be requested');
this.get(callback);
} else {
callback(null, this.token);
}
}
};
}
|
javascript
|
{
"resource": ""
}
|
q3924
|
fireCallbacks
|
train
|
function fireCallbacks(err, token) {
self.pendingCallbacks.forEach(function (callback) {
callback(err, token);
});
self.pendingCallbacks = [];
}
|
javascript
|
{
"resource": ""
}
|
q3925
|
parseLines
|
train
|
function parseLines (src) {
const lines = []
for (i = 0; i < src.length; ++i) {
if (src[i] === '\n' && src[i - 1] === '\r') i += 1
if (!src[i]) break
const keyStart = endOfIndent(src, i)
if (atLineEnd(src, keyStart)) {
lines.push('')
i = keyStart
continue
}
if (atComment(src, keyStart)) {
const commentEnd = endOfComment(src, keyStart)
lines.push(src.slice(keyStart, commentEnd))
i = commentEnd
continue
}
const keyEnd = endOfKey(src, keyStart)
const key = unescape(src.slice(keyStart, keyEnd))
const valueStart = endOfSeparator(src, keyEnd)
if (atLineEnd(src, valueStart)) {
lines.push([key, ''])
i = valueStart
continue
}
const valueEnd = endOfValue(src, valueStart)
const value = unescape(src.slice(valueStart, valueEnd))
lines.push([key, value])
i = valueEnd
}
return lines
}
|
javascript
|
{
"resource": ""
}
|
q3926
|
parse
|
train
|
function parse (src, path) {
const pathSep = typeof path === 'string' ? path : '.'
return parseLines(src).reduce((res, line) => {
if (Array.isArray(line)) {
const [key, value] = line
if (path) {
const keyPath = key.split(pathSep)
let parent = res
while (keyPath.length >= 2) {
const p = keyPath.shift()
if (!parent[p]) {
parent[p] = {}
} else if (typeof parent[p] !== 'object') {
parent[p] = { '': parent[p] }
}
parent = parent[p]
}
const leaf = keyPath[0]
if (typeof parent[leaf] === 'object') {
parent[leaf][''] = value
} else {
parent[leaf] = value
}
} else {
res[key] = value
}
}
return res
}, {})
}
|
javascript
|
{
"resource": ""
}
|
q3927
|
stringify
|
train
|
function stringify (input, {
commentPrefix = '# ',
defaultKey = '',
indent = ' ',
keySep = ' = ',
latin1 = true,
lineWidth = 80,
newline = '\n',
pathSep = '.'
} = {}) {
if (!input) return ''
if (!Array.isArray(input)) input = toLines(input, pathSep, defaultKey)
const foldLine = getFold({ indent, latin1, lineWidth, newline: '\\' + newline })
const foldComment = getFold({ indent: commentPrefix, latin1, lineWidth, newline })
return input
.map(line => {
switch (true) {
case !line:
return ''
case Array.isArray(line):
const key = escapeKey(line[0])
const value = escapeValue(line[1])
return foldLine(key + keySep + value)
default:
const cc = String(line).replace(/^\s*([#!][ \t\f]*)?/g, commentPrefix)
return foldComment(cc)
}
})
.join(newline)
}
|
javascript
|
{
"resource": ""
}
|
q3928
|
mapVariablesToObject
|
train
|
function mapVariablesToObject(variables) {
var plugmanConsumableVariables = {};
for (var i in variables) {
var t = variables[i].split('=');
if (t[0] && t[1]) {
plugmanConsumableVariables[t[0]] = t[1];
}
}
return plugmanConsumableVariables;
}
|
javascript
|
{
"resource": ""
}
|
q3929
|
TidalAPI
|
train
|
function TidalAPI(authData) {
if(typeof authData !== 'object')
{
throw new Error('You must pass auth data into the TidalAPI object correctly');
} else {
if(typeof authData.username !== 'string') {
throw new Error('Username invalid or missing');
}
if(typeof authData.password !== 'string') {
throw new Error('Password invalid or missing');
}
if(typeof authData.token !== 'string') {
throw new Error('Token invalid or missing');
}
if(typeof authData.quality !== 'string') {
throw new Error('Stream quality invalid or missing');
}
}
this.authData = authData;
/* try log in */
// tryLogin(authData);
}
|
javascript
|
{
"resource": ""
}
|
q3930
|
tryLogin
|
train
|
function tryLogin(authInfo, cb) {
/**
* Logging?
* @type {boolean}
*/
var loggingIn = true;
request({
method: 'POST',
uri: '/login/username',
headers: {
'X-Tidal-Token': authInfo.token
},
form: {
username: authInfo.username,
password: authInfo.password,
clientUniqueKey: "vjknfvjbnjhbgjhbbg"
}
}, function(err, res, data) {
if(!err){
if (data && res && res.statusCode !== 200 || err) {
throw new Error(data)
}
data = JSON.parse(data);
_sessionID = data.sessionId;
_userID = data.userId;
_countryCode = data.countryCode;
_streamQuality = authInfo.quality;
loggingIn = false;
loggedIn = true;
if (cb) {
cb();
}
}
});
}
|
javascript
|
{
"resource": ""
}
|
q3931
|
resize
|
train
|
function resize () {
if (!running) {
running = true
if (window.requestAnimationFrame) {
window.requestAnimationFrame(runCallbacks)
} else {
setTimeout(runCallbacks, 66)
}
}
}
|
javascript
|
{
"resource": ""
}
|
q3932
|
train
|
function (value) {
assertErr(value instanceof Date, TypeError, 'Field error: value is not an instance of Date')
assertErr(!isNaN(value.getTime()), TypeError, 'Field error: value is an invalid Date')
return value.toJSON()
}
|
javascript
|
{
"resource": ""
}
|
|
q3933
|
train
|
function (value) {
var date = new Date(value)
assertErr(!isNaN(date.getTime()), TypeError, 'Field error: value is an invalid Date')
return date
}
|
javascript
|
{
"resource": ""
}
|
|
q3934
|
train
|
function (ast) {
assertErr(ast.kind === Kind.STRING,
GraphQLError, 'Query error: Can only parse strings to dates but got a: ' + ast.kind, [ast])
var result = new Date(ast.value)
assertErr(!isNaN(result.getTime()),
GraphQLError, 'Query error: Invalid date', [ast])
assertErr(ast.value === result.toJSON(),
GraphQLError, 'Query error: Invalid date format, only accepts: YYYY-MM-DDTHH:MM:SS.SSSZ', [ast])
return result
}
|
javascript
|
{
"resource": ""
}
|
|
q3935
|
push
|
train
|
function push (chunk) {
if (!isAudioBuffer(chunk)) {
chunk = util.create(chunk, channels)
}
data.append(chunk)
isEmpty = false;
}
|
javascript
|
{
"resource": ""
}
|
q3936
|
createNodeUI
|
train
|
function createNodeUI(node) {
var nodeMaterial = new THREE.MeshBasicMaterial({ color: 0xfefefe });
var nodeGeometry = new THREE.BoxGeometry(NODE_SIZE, NODE_SIZE, NODE_SIZE);
return new THREE.Mesh(nodeGeometry, nodeMaterial);
}
|
javascript
|
{
"resource": ""
}
|
q3937
|
train
|
function () {
$('<table class="jqs-table"><tr></tr></table>').appendTo($(this.element));
for (var i = 0; i < this.settings.days; i++) {
$('<td><div class="jqs-day"></div></td>').
appendTo($('.jqs-table tr', this.element));
}
$('<div class="jqs-grid"><div class="jqs-grid-head"></div></div>').appendTo($(this.element));
for (var j = 0; j < 25; j++) {
$('<div class="jqs-grid-line"><div class="jqs-grid-hour">' + this.formatHour(j) + '</div></div>').
appendTo($('.jqs-grid', this.element));
}
var dayRemove = '';
var dayDuplicate = '';
if (this.settings.mode === 'edit') {
dayRemove = '<div class="jqs-day-remove" title="' + this.settings.periodRemoveButton + '"></div>';
dayDuplicate = '<div class="jqs-day-duplicate" title="' + this.settings.periodDuplicateButton +
'"></div>';
}
for (var k = 0; k < this.settings.days; k++) {
$('<div class="jqs-grid-day">' + this.settings.daysList[k] + dayRemove + dayDuplicate + '</div>').
appendTo($('.jqs-grid-head', this.element));
}
}
|
javascript
|
{
"resource": ""
}
|
|
q3938
|
train
|
function (period) {
if (!this.settings.onDuplicatePeriod.call(this, period, this.element)) {
var options = this.periodData(period);
var position = Math.round(period.position().top / this.periodPosition);
var height = Math.round(period.height() / this.periodPosition);
var $this = this;
$('.jqs-day', this.element).each(function (index, parent) {
$this.add(parent, position, height, options);
});
this.closeOptions();
}
}
|
javascript
|
{
"resource": ""
}
|
|
q3939
|
train
|
function (ui) {
var start = Math.round(ui.position.top / this.periodPosition);
var end = Math.round(($(ui.helper).height() + ui.position.top) / this.periodPosition);
return this.periodFormat(start) + ' - ' + this.periodFormat(end);
}
|
javascript
|
{
"resource": ""
}
|
|
q3940
|
train
|
function (period) {
var start = Math.round(period.position().top / this.periodPosition);
var end = Math.round((period.height() + period.position().top) / this.periodPosition);
return {
start: this.periodFormat(start),
end: this.periodFormat(end),
title: $('.jqs-period-title', period).text(),
backgroundColor: $('.jqs-period-container', period).css('background-color'),
borderColor: $('.jqs-period-container', period).css('border-top-color'),
textColor: $('.jqs-period-container', period).css('color')
};
}
|
javascript
|
{
"resource": ""
}
|
|
q3941
|
train
|
function (position) {
if (position >= this.periodHeight) {
position = 0;
}
if (position < 0) {
position = 0;
}
var hour = Math.floor(position / this.periodInterval);
var mn = (position / this.periodInterval - hour) * 60;
if (this.settings.hour === 12) {
var time = hour;
var ind = '';
if (hour >= 12) {
ind = 'p';
}
if (hour > 12) {
time = hour - 12;
}
if (hour === 0 || hour === 24) {
ind = '';
time = 12;
}
if (mn !== 0) {
time += ':' + mn;
}
return time + ind;
}
if (hour < 10) {
hour = '0' + hour;
}
if (mn < 10) {
mn = '0' + mn;
}
return hour + ':' + mn;
}
|
javascript
|
{
"resource": ""
}
|
|
q3942
|
train
|
function (time) {
var split = time.split(':');
var hour = parseInt(split[0]);
var mn = parseInt(split[1]);
if (this.settings.hour === 12) {
var matches = time.match(/([0-1]?[0-9]):?([0-5][0-9])?\s?(am|pm|p)?/);
var ind = matches[3];
if (!ind) {
ind = 'am';
}
hour = parseInt(matches[1]);
mn = parseInt(matches[2]);
if (!mn) {
mn = 0;
}
if (hour === 12 && ind === 'am') {
hour = 0;
}
if (hour === 12 && (ind === 'pm' || ind === 'p')) {
ind = 'am';
}
if (ind === 'pm' || ind === 'p') {
hour += 12;
}
}
var position = 0;
position += hour * this.periodInterval;
position += mn / 60 * this.periodInterval;
if (Math.floor(position) !== position) {
return -1;
}
return position;
}
|
javascript
|
{
"resource": ""
}
|
|
q3943
|
train
|
function (current) {
var currentStart = Math.round(current.position().top);
var currentEnd = Math.round(current.position().top + current.height());
var start = 0;
var end = 0;
var check = true;
$('.jqs-period', $(current).parent()).each(function (index, period) {
if (current.attr('id') !== $(period).attr('id')) {
start = Math.round($(period).position().top);
end = Math.round($(period).position().top + $(period).height());
if (start > currentStart && start < currentEnd) {
check = false;
}
if (end > currentStart && end < currentEnd) {
check = false;
}
if (start < currentStart && end > currentEnd) {
check = false;
}
if (start === currentStart || end === currentEnd) {
check = false;
}
}
});
return check;
}
|
javascript
|
{
"resource": ""
}
|
|
q3944
|
train
|
function () {
var $this = this;
var data = [];
$('.jqs-day', $this.element).each(function (index, day) {
var periods = [];
$('.jqs-period', day).each(function (index, period) {
periods.push($this.periodData($(period)));
});
data.push({
day: index,
periods: periods
});
});
return JSON.stringify(data);
}
|
javascript
|
{
"resource": ""
}
|
|
q3945
|
train
|
function (args) {
var $this = this;
var dataImport = args[1];
var ret = [];
$.each(dataImport, function (index, data) {
$.each(data.periods, function (index, period) {
var parent = $('.jqs-day', $this.element).eq(data.day);
var options = {};
var height, position;
if ($.isArray(period)) {
position = $this.positionFormat(period[0]);
height = $this.positionFormat(period[1]);
} else {
position = $this.positionFormat(period.start);
height = $this.positionFormat(period.end);
options = period;
}
if (height === 0) {
height = $this.periodHeight;
}
var status = true;
if (!$this.add(parent, position, height - position, options)) {
status = false;
}
ret.push({
day: data.day,
period: [
$this.periodFormat(position),
$this.periodFormat(height)
],
status: status
});
});
});
return JSON.stringify(ret);
}
|
javascript
|
{
"resource": ""
}
|
|
q3946
|
train
|
function (d, msgctxt, msgid, msgid_plural, n, category) {
if (! msgid) {
return '';
}
var msg_ctxt_id = msgctxt ? msgctxt + this.context_glue + msgid : msgid;
var domainname = d || this.domain || 'messages';
var lang = this.lang;
// category is always LC_MESSAGES. We ignore all else
var category_name = 'LC_MESSAGES';
category = 5;
var locale_data = [];
if (typeof(this.data[lang]) != 'undefined' &&
this.data[lang][domainname]) {
locale_data.push(this.data[lang][domainname] );
} else if (typeof(this.data[lang]) != 'undefined') {
// didn't find domain we're looking for. Search all of them.
for (var dom in this.data[lang]) {
locale_data.push(this.data[lang][dom] );
}
}
var trans = [];
var found = false;
var domain_used; // so we can find plural-forms if needed
if (locale_data.length) {
for (var i=0; i<locale_data.length; i++) {
var locale = locale_data[i];
if (locale.msgs[msg_ctxt_id]) {
var msg_ctxt_str = locale.msgs[msg_ctxt_id].msgstr;
trans = msg_ctxt_str.concat(trans.slice(msg_ctxt_str.length));
domain_used = locale;
found = true;
// only break if found translation actually has a translation.
if ( trans.length > 0 && trans[0].length !== 0 ) {
break;
}
}
}
}
// default to english if we lack a match, or match has zero length
if ( trans.length === 0 || trans[0].length === 0 ) {
trans = [ msgid, msgid_plural ];
}
var translation = trans[0];
if (msgid_plural) {
var p;
if (found && domain_used.head.plural_func) {
var rv = domain_used.head.plural_func(n);
if (! rv.plural) {
rv.plural = 0;
}
if (! rv.nplural) {
rv.nplural = 0;
}
// if plurals returned is out of bound for total plural forms
if (rv.nplural <= rv.plural) {
rv.plural = 0;
}
p = rv.plural;
} else {
p = (n != 1) ? 1 : 0;
}
if (trans[p]) {
translation = trans[p];
}
}
return translation;
}
|
javascript
|
{
"resource": ""
}
|
|
q3947
|
train
|
function(mustache, program, inverse) {
var params = mustache.params;
this.pushParams(params);
this.opcode('pushProgram', program);
this.opcode('pushProgram', inverse);
if(mustache.hash) {
this.hash(mustache.hash);
} else {
this.opcode('pushLiteral', '{}');
}
return params;
}
|
javascript
|
{
"resource": ""
}
|
|
q3948
|
parseCoffeeDocs
|
train
|
function parseCoffeeDocs(file, fn) {
fs.readFile(file, function(err, data) {
if (err) {
fn(err);
}
var js = coffee.compile(data.toString());
var regex = /\/\**([\s\S]*?)\*\//gm;
var fragments = js.match(regex);
var docs = [];
for (var i = 0; i < fragments.length; i++) {
var fragment = fragments[i];
var doc = doctrine.parse(fragment, {unwrap: true});
docs.push(doc);
if (i === fragments.length - 1) {
fn(null, docs);
}
}
});
}
|
javascript
|
{
"resource": ""
}
|
q3949
|
getSwagger
|
train
|
function getSwagger(fragment, fn) {
for (var i = 0; i < fragment.tags.length; i++) {
var tag = fragment.tags[i];
if ('swagger' === tag.title) {
return yaml.safeLoadAll(tag.description, fn);
}
}
return fn(false);
}
|
javascript
|
{
"resource": ""
}
|
q3950
|
readApi
|
train
|
function readApi(file, fn) {
var ext = path.extname(file);
if ('.js' === ext || '.ts' === ext) {
readJsDoc(file, fn);
} else if ('.yml' === ext) {
readYml(file, fn);
} else if ('.coffee' === ext) {
readCoffee(file, fn);
} else {
throw new Error('Unsupported extension \'' + ext + '\'');
}
}
|
javascript
|
{
"resource": ""
}
|
q3951
|
train
|
function(x){
var pqify = (proxyquireifyName != null) && cache[proxyquireifyName];
// Only try to use the proxyquireify version if it has been `require`d
if (pqify && pqify.exports._proxy) {
return pqify.exports._proxy(req, x);
} else {
return req(x);
}
}
|
javascript
|
{
"resource": ""
}
|
|
q3952
|
pointIsInsideBounds
|
train
|
function pointIsInsideBounds(x, y, bounds) {
return x >= bounds.left &&
y >= bounds.top &&
x <= bounds.left + bounds.width &&
y <= bounds.top + bounds.height;
}
|
javascript
|
{
"resource": ""
}
|
q3953
|
add
|
train
|
function add(scope, element) {
updateDelayed();
items.push({
element: element,
scope: scope
});
}
|
javascript
|
{
"resource": ""
}
|
q3954
|
_fnCheck
|
train
|
function _fnCheck(callback, data) {
if (angular.isUndefinedOrNull(data) || angular.isArray(data)) {
return; // jmp out
}
if (angular.isFunction(callback)) {
return callback(data, $filter);
} else {
if (typeof callback === 'boolean') {
data = !!data;
return data === callback;
} else if (angular.isDefined(callback)) {
try {
var _regex = new RegExp(callback);
return _regex.test(data);
}
catch (err) {
if (typeof data === 'string') {
return data.indexOf(callback) > -1;
} else {
return; // jmp out
}
}
} else {
return; // jmp out
}
}
}
|
javascript
|
{
"resource": ""
}
|
q3955
|
_fnAfter
|
train
|
function _fnAfter(options, node, isNodePassed, isChildPassed, isParentPassed) {
if (isNodePassed === true) {
node.__filtered__ = true;
node.__filtered_visible__ = true;
node.__filtered_index__ = options.filter_index++;
return; //jmp
} else if (isChildPassed === true && options.showParent === true
|| isParentPassed === true && options.showChild === true) {
node.__filtered__ = false;
node.__filtered_visible__ = true;
node.__filtered_index__ = options.filter_index++;
return; //jmp
}
// remove attr __filtered__
delete node.__filtered__;
delete node.__filtered_visible__;
delete node.__filtered_index__;
}
|
javascript
|
{
"resource": ""
}
|
q3956
|
_fnConvert
|
train
|
function _fnConvert(filters) {
var _iF, _lenF, _keysF,
_filter,
_state;
// convert filter object to array filter
if (angular.isObject(filters) && !angular.isArray(filters)) {
_keysF = Object.keys(filters);
_lenF = _keysF.length;
_filter = [];
if (_lenF > 0) {
for (_iF = 0; _iF < _lenF; _iF++) {
if (typeof filters[_keysF[_iF]] === 'string' && filters[_keysF[_iF]].length === 0) {
continue;
} else if (angular.isArray(filters[_keysF[_iF]])) {
_state = filters[_keysF[_iF]];
} else if (angular.isObject(filters[_keysF[_iF]])) {
_state = _fnConvert(filters[_keysF[_iF]]);
} else {
_state = {
field: _keysF[_iF],
callback: filters[_keysF[_iF]]
};
}
_filter.push(_state);
}
}
return _filter;
}
else {
return filters;
}
}
|
javascript
|
{
"resource": ""
}
|
q3957
|
train
|
function (e) {
var patternName;
var state = e.state;
if (state === null) {
this.skipBack = false;
return;
} else if (state !== null) {
patternName = state.pattern;
}
var iFramePath = "";
iFramePath = this.getFileName(patternName);
if (iFramePath === "") {
iFramePath = "styleguide/html/styleguide.html";
}
var obj = JSON.stringify({
"event": "patternLab.updatePath",
"path": iFramePath
});
document.querySelector('.pl-js-iframe').contentWindow.postMessage(obj, urlHandler.targetOrigin);
document.getElementById("title").innerHTML = "Pattern Lab - " + patternName;
document.querySelector('.pl-js-open-new-window').setAttribute("href", urlHandler.getFileName(patternName));
}
|
javascript
|
{
"resource": ""
}
|
|
q3958
|
train
|
function () {
// make sure the listener for checkpanels is set-up
Dispatcher.addListener('insertPanels', modalViewer.insert);
// add the info/code panel onclick handler
$('.pl-js-pattern-info-toggle').click(function (e) {
modalViewer.toggle();
});
// make sure the close button handles the click
$('.pl-js-modal-close-btn').on('click', function (e) {
// hide any open annotations
obj = JSON.stringify({
'event': 'patternLab.annotationsHighlightHide'
});
document.querySelector('.pl-js-iframe').contentWindow.postMessage(obj, modalViewer.targetOrigin);
// hide the viewer
modalViewer.close();
});
// see if the modal is already active, if so update attributes as appropriate
if (DataSaver.findValue('modalActive') === 'true') {
modalViewer.active = true;
$('.pl-js-pattern-info-toggle').html("Hide Pattern Info");
}
// make sure the modal viewer is not viewable, it's always hidden by default. the pageLoad event determines when it actually opens
modalViewer.hide();
// review the query strings in case there is something the modal viewer is supposed to handle by default
var queryStringVars = urlHandler.getRequestVars();
// show the modal if code view is called via query string
if ((queryStringVars.view !== undefined) && ((queryStringVars.view === 'code') || (queryStringVars.view === 'c'))) {
modalViewer.queryPattern();
}
// show the modal if the old annotations view is called via query string
if ((queryStringVars.view !== undefined) && ((queryStringVars.view === 'annotations') || (queryStringVars.view === 'a'))) {
modalViewer.queryPattern();
}
}
|
javascript
|
{
"resource": ""
}
|
|
q3959
|
train
|
function (templateRendered, patternPartial, iframePassback, switchText) {
if (iframePassback) {
// send a message to the pattern
var obj = JSON.stringify({
'event': 'patternLab.patternModalInsert',
'patternPartial': patternPartial,
'modalContent': templateRendered.outerHTML
});
document.querySelector('.pl-js-iframe').contentWindow.postMessage(obj, modalViewer.targetOrigin);
} else {
// insert the panels and open the viewer
$('.pl-js-modal-content').html(templateRendered);
modalViewer.open();
}
// update the wording unless this is a default viewall opening
if (switchText === true) {
$('.pl-js-pattern-info-toggle').html("Hide Pattern Info");
}
}
|
javascript
|
{
"resource": ""
}
|
|
q3960
|
train
|
function (patternPartial, panelID) {
var els;
// turn off all of the active tabs
els = document.querySelectorAll('#pl-' + patternPartial + '-tabs .pl-js-tab-link');
for (i = 0; i < els.length; ++i) {
els[i].classList.remove('pl-is-active-tab');
}
// hide all of the panels
els = document.querySelectorAll('#pl-' + patternPartial + '-panels .pl-js-tab-panel');
for (i = 0; i < els.length; ++i) {
els[i].classList.remove('pl-is-active-tab');
}
// add active tab class
document.getElementById('pl-' + patternPartial + '-' + panelID + '-tab').classList.add('pl-is-active-tab');
// show the panel
document.getElementById('pl-' + patternPartial + '-' + panelID + '-panel').classList.add('pl-is-active-tab');
}
|
javascript
|
{
"resource": ""
}
|
|
q3961
|
train
|
function (patternData, iframePassback, switchText) {
Dispatcher.addListener('checkPanels', panelsViewer.checkPanels);
// set-up defaults
var template, templateCompiled, templateRendered, panel;
// get the base panels
var panels = Panels.get();
// evaluate panels array and create content
for (var i = 0; i < panels.length; ++i) {
panel = panels[i];
// catch pattern panel since it doesn't have a name defined by default
if (panel.name === undefined) {
panel.name = patternData.patternEngineName || patternData.patternExtension;
panel.language = patternData.patternExtension;
}
// if httpRequestReplace has not been set, use the extension. this is likely for the raw template
if (panel.httpRequestReplace === '') {
panel.httpRequestReplace = panel.httpRequestReplace + '.' + patternData.patternExtension;
}
if ((panel.templateID !== undefined) && (panel.templateID)) {
if ((panel.httpRequest !== undefined) && (panel.httpRequest)) {
// need a file and then render
var fileBase = urlHandler.getFileName(patternData.patternPartial, false);
var e = new XMLHttpRequest();
e.onload = (function (i, panels, patternData, iframeRequest) {
return function () {
prismedContent = Prism.highlight(this.responseText, Prism.languages['html']);
template = document.getElementById(panels[i].templateID);
templateCompiled = Hogan.compile(template.innerHTML);
templateRendered = templateCompiled.render({
'language': 'html',
'code': prismedContent
});
panels[i].content = templateRendered;
Dispatcher.trigger('checkPanels', [panels, patternData, iframePassback, switchText]);
};
})(i, panels, patternData, iframePassback);
e.open('GET', fileBase + panel.httpRequestReplace + '?' + (new Date()).getTime(), true);
e.send();
} else {
// vanilla render of pattern data
template = document.getElementById(panel.templateID);
templateCompiled = Hogan.compile(template.innerHTML);
templateRendered = templateCompiled.render(patternData);
panels[i].content = templateRendered;
Dispatcher.trigger('checkPanels', [panels, patternData, iframePassback, switchText]);
}
}
}
}
|
javascript
|
{
"resource": ""
}
|
|
q3962
|
goMedium
|
train
|
function goMedium() {
killDisco();
killHay();
fullMode = false;
sizeiframe(getRandom(
minViewportWidth,
config.ishViewportRange !== undefined ? parseInt(config.ishViewportRange.s[1]) : 500
));
}
|
javascript
|
{
"resource": ""
}
|
q3963
|
goLarge
|
train
|
function goLarge() {
killDisco();
killHay();
fullMode = false;
sizeiframe(getRandom(
config.ishViewportRange !== undefined ? parseInt(config.ishViewportRange.l[0]) : 800,
config.ishViewportRange !== undefined ? parseInt(config.ishViewportRange.l[1]) : 1200
));
}
|
javascript
|
{
"resource": ""
}
|
q3964
|
killHay
|
train
|
function killHay() {
var currentWidth = $sgIframe.width();
hayMode = false;
$sgIframe.removeClass('hay-mode');
$('.pl-js-vp-iframe-container').removeClass('hay-mode');
sizeiframe(Math.floor(currentWidth));
}
|
javascript
|
{
"resource": ""
}
|
q3965
|
startHay
|
train
|
function startHay() {
hayMode = true;
$('.pl-js-vp-iframe-container').removeClass("vp-animate").width(minViewportWidth + viewportResizeHandleWidth);
$sgIframe.removeClass("vp-animate").width(minViewportWidth);
var timeoutID = window.setTimeout(function () {
$('.pl-js-vp-iframe-container').addClass('hay-mode').width(maxViewportWidth + viewportResizeHandleWidth);
$sgIframe.addClass('hay-mode').width(maxViewportWidth);
setInterval(function () {
var vpSize = $sgIframe.width();
updateSizeReading(vpSize);
}, 100);
}, 200);
}
|
javascript
|
{
"resource": ""
}
|
q3966
|
create_hint
|
train
|
function create_hint(value, match, type, title, description, link) {
var $hint = $(document.createElement('span'));
$hint.addClass('brackets-js-hints brackets-js-hints-with-type-details');
$hint.attr('title', title);
if (match) {
value = value.replace(match, '');
$hint.append($(document.createElement('span')).text(match).addClass('matched-hint'));
$hint.append($(document.createElement('span')).text(value).addClass('require-hint-value'));
}
else {
$hint.append($(document.createElement('span')).text(value).addClass('require-hint-value'));
}
if (link) {
$hint.append($(document.createElement('a')).addClass('jshint-link').attr('href', link));
}
$hint.append($(document.createElement('span')).text(type).addClass('brackets-js-hints-type-details'));
$hint.append($(document.createElement('span')).text(type).addClass('jshint-description'));
if (description) {
$hint.append($(document.createElement('span')).text(description).addClass('jshint-jsdoc'));
}
return $hint;
}
|
javascript
|
{
"resource": ""
}
|
q3967
|
findExecutable
|
train
|
function findExecutable(opt_exe) {
var exe = opt_exe || io.findInPath(PHANTOMJS_EXE, true);
if (!exe) {
throw Error(
'The PhantomJS executable could not be found on the current PATH. ' +
'Please download the latest version from ' +
'http://phantomjs.org/download.html and ensure it can be found on ' +
'your PATH. For more information, see ' +
'https://github.com/ariya/phantomjs/wiki');
}
if (!fs.existsSync(exe)) {
throw Error('File does not exist: ' + exe);
}
return exe;
}
|
javascript
|
{
"resource": ""
}
|
q3968
|
train
|
function(opt_capabilities, opt_flow) {
var capabilities = opt_capabilities || webdriver.Capabilities.phantomjs();
var exe = findExecutable(capabilities.get(BINARY_PATH_CAPABILITY));
var args = ['--webdriver-logfile=' + DEFAULT_LOG_FILE];
var logPrefs = capabilities.get(webdriver.Capability.LOGGING_PREFS);
if (logPrefs instanceof webdriver.logging.Preferences) {
logPrefs = logPrefs.toJSON();
}
if (logPrefs && logPrefs[webdriver.logging.Type.DRIVER]) {
var level = WEBDRIVER_TO_PHANTOMJS_LEVEL[
logPrefs[webdriver.logging.Type.DRIVER]];
if (level) {
args.push('--webdriver-loglevel=' + level);
}
}
var proxy = capabilities.get(webdriver.Capability.PROXY);
if (proxy) {
switch (proxy.proxyType) {
case 'manual':
if (proxy.httpProxy) {
args.push(
'--proxy-type=http',
'--proxy=http://' + proxy.httpProxy);
}
break;
case 'pac':
throw Error('PhantomJS does not support Proxy PAC files');
case 'system':
args.push('--proxy-type=system');
break;
case 'direct':
args.push('--proxy-type=none');
break;
}
}
args = args.concat(capabilities.get(CLI_ARGS_CAPABILITY) || []);
var port = portprober.findFreePort();
var service = new remote.DriverService(exe, {
port: port,
args: webdriver.promise.when(port, function(port) {
args.push('--webdriver=' + port);
return args;
})
});
var executor = executors.createExecutor(service.start());
var driver = webdriver.WebDriver.createSession(
executor, capabilities, opt_flow);
webdriver.WebDriver.call(
this, driver.getSession(), executor, driver.controlFlow());
var boundQuit = this.quit.bind(this);
/** @override */
this.quit = function() {
return boundQuit().thenFinally(service.kill.bind(service));
};
return driver;
}
|
javascript
|
{
"resource": ""
}
|
|
q3969
|
train
|
function(opt_config, opt_flow) {
var caps;
if (opt_config instanceof Options) {
caps = opt_config.toCapabilities();
} else {
caps = new webdriver.Capabilities(opt_config);
}
var binary = caps.get('firefox_binary') || new Binary();
if (typeof binary === 'string') {
binary = new Binary(binary);
}
var profile = caps.get('firefox_profile') || new Profile();
caps.set('firefox_binary', null);
caps.set('firefox_profile', null);
var serverUrl = portprober.findFreePort().then(function(port) {
var prepareProfile;
if (typeof profile === 'string') {
prepareProfile = decodeProfile(profile).then(function(dir) {
var profile = new Profile(dir);
profile.setPreference('webdriver_firefox_port', port);
return profile.writeToDisk();
});
} else {
profile.setPreference('webdriver_firefox_port', port);
prepareProfile = profile.writeToDisk();
}
return prepareProfile.then(function(dir) {
return binary.launch(dir);
}).then(function() {
var serverUrl = url.format({
protocol: 'http',
hostname: net.getLoopbackAddress(),
port: port,
pathname: '/hub'
});
return httpUtil.waitForServer(serverUrl, 45 * 1000).then(function() {
return serverUrl;
});
});
});
var executor = executors.createExecutor(serverUrl);
var driver = webdriver.WebDriver.createSession(executor, caps, opt_flow);
webdriver.WebDriver.call(this, driver.getSession(), executor, opt_flow);
}
|
javascript
|
{
"resource": ""
}
|
|
q3970
|
DriverService
|
train
|
function DriverService(executable, options) {
/** @private {string} */
this.executable_ = executable;
/** @private {boolean} */
this.loopbackOnly_ = !!options.loopback;
/** @private {(number|!webdriver.promise.Promise.<number>)} */
this.port_ = options.port;
/**
* @private {!(Array.<string>|webdriver.promise.Promise.<!Array.<string>>)}
*/
this.args_ = options.args;
/** @private {string} */
this.path_ = options.path || '/';
/** @private {!Object.<string, string>} */
this.env_ = options.env || process.env;
/** @private {(string|!Array.<string|number|!Stream|null|undefined>)} */
this.stdio_ = options.stdio || 'ignore';
/**
* A promise for the managed subprocess, or null if the server has not been
* started yet. This promise will never be rejected.
* @private {promise.Promise.<!exec.Command>}
*/
this.command_ = null;
/**
* Promise that resolves to the server's address or null if the server has
* not been started. This promise will be rejected if the server terminates
* before it starts accepting WebDriver requests.
* @private {promise.Promise.<string>}
*/
this.address_ = null;
}
|
javascript
|
{
"resource": ""
}
|
q3971
|
defaultWindowsLocation
|
train
|
function defaultWindowsLocation() {
var files = [
process.env['PROGRAMFILES'] || 'C:\\Program Files',
process.env['PROGRAMFILES(X86)'] || 'C:\\Program Files (x86)'
].map(function(prefix) {
return path.join(prefix, 'Mozilla Firefox\\firefox.exe');
});
return io.exists(files[0]).then(function(exists) {
return exists ? files[0] : io.exists(files[1]).then(function(exists) {
return exists ? files[1] : null;
});
});
}
|
javascript
|
{
"resource": ""
}
|
q3972
|
findFirefox
|
train
|
function findFirefox() {
if (foundBinary) {
return foundBinary;
}
if (process.platform === 'darwin') {
var osxExe = '/Applications/Firefox.app/Contents/MacOS/firefox-bin';
foundBinary = io.exists(osxExe).then(function(exists) {
return exists ? osxExe : null;
});
} else if (process.platform === 'win32') {
foundBinary = defaultWindowsLocation();
} else {
foundBinary = promise.fulfilled(io.findInPath('firefox'));
}
return foundBinary = foundBinary.then(function(found) {
if (found) {
return found;
}
throw Error('Could not locate Firefox on the current system');
});
}
|
javascript
|
{
"resource": ""
}
|
q3973
|
installNoFocusLibs
|
train
|
function installNoFocusLibs(profileDir) {
var x86 = path.join(profileDir, 'x86');
var amd64 = path.join(profileDir, 'amd64');
return mkdir(x86)
.then(copyLib.bind(null, NO_FOCUS_LIB_X86, x86))
.then(mkdir.bind(null, amd64))
.then(copyLib.bind(null, NO_FOCUS_LIB_AMD64, amd64))
.then(function() {
return x86 + ':' + amd64;
});
function mkdir(dir) {
return io.exists(dir).then(function(exists) {
if (!exists) {
return promise.checkedNodeCall(fs.mkdir, dir);
}
});
}
function copyLib(src, dir) {
return io.copy(src, path.join(dir, X_IGNORE_NO_FOCUS_LIB));
}
}
|
javascript
|
{
"resource": ""
}
|
q3974
|
train
|
function(opt_exe) {
/** @private {(string|undefined)} */
this.exe_ = opt_exe;
/** @private {!Array.<string>} */
this.args_ = [];
/** @private {!Object.<string, string>} */
this.env_ = {};
Object.keys(process.env).forEach(function(key) {
this.env_[key] = process.env[key];
}.bind(this));
this.env_['MOZ_CRASHREPORTER_DISABLE'] = '1';
this.env_['MOZ_NO_REMOTE'] = '1';
this.env_['NO_EM_RESTART'] = '1';
/** @private {promise.Promise.<!exec.Command>} */
this.command_ = null;
}
|
javascript
|
{
"resource": ""
}
|
|
q3975
|
getDefaultPreferences
|
train
|
function getDefaultPreferences() {
if (!defaultPreferences) {
var contents = fs.readFileSync(WEBDRIVER_PREFERENCES_PATH, 'utf8');
defaultPreferences = JSON.parse(contents);
}
return defaultPreferences;
}
|
javascript
|
{
"resource": ""
}
|
q3976
|
loadUserPrefs
|
train
|
function loadUserPrefs(f) {
var done = promise.defer();
fs.readFile(f, function(err, contents) {
if (err && err.code === 'ENOENT') {
done.fulfill({});
return;
}
if (err) {
done.reject(err);
return;
}
var prefs = {};
var context = vm.createContext({
'user_pref': function(key, value) {
prefs[key] = value;
}
});
vm.runInContext(contents, context, f);
done.fulfill(prefs);
});
return done.promise;
}
|
javascript
|
{
"resource": ""
}
|
q3977
|
mixin
|
train
|
function mixin(a, b) {
Object.keys(b).forEach(function(key) {
a[key] = b[key];
});
}
|
javascript
|
{
"resource": ""
}
|
q3978
|
installExtensions
|
train
|
function installExtensions(extensions, dir, opt_excludeWebDriverExt) {
var hasWebDriver = !!opt_excludeWebDriverExt;
var next = 0;
var extensionDir = path.join(dir, 'extensions');
var done = promise.defer();
return io.exists(extensionDir).then(function(exists) {
if (!exists) {
return promise.checkedNodeCall(fs.mkdir, extensionDir);
}
}).then(function() {
installNext();
return done.promise;
});
function installNext() {
if (!done.isPending()) {
return;
}
if (next >= extensions.length) {
if (hasWebDriver) {
done.fulfill(dir);
} else {
install(WEBDRIVER_EXTENSION_PATH);
}
} else {
install(extensions[next++]);
}
}
function install(ext) {
extension.install(ext, extensionDir).then(function(id) {
hasWebDriver = hasWebDriver || (id === WEBDRIVER_EXTENSION_NAME);
installNext();
}, done.reject);
}
}
|
javascript
|
{
"resource": ""
}
|
q3979
|
decode
|
train
|
function decode(data) {
return io.tmpFile().then(function(file) {
var buf = new Buffer(data, 'base64');
return promise.checkedNodeCall(fs.writeFile, file, buf).then(function() {
return io.tmpDir();
}).then(function(dir) {
var zip = new AdmZip(file);
zip.extractAllTo(dir); // Sync only? Why?? :-(
return dir;
});
});
}
|
javascript
|
{
"resource": ""
}
|
q3980
|
Context
|
train
|
function Context(opt_configureForTesting) {
var closure = this.closure = vm.createContext({
console: console,
setTimeout: setTimeout,
setInterval: setInterval,
clearTimeout: clearTimeout,
clearInterval: clearInterval,
process: process,
require: require,
Buffer: Buffer,
Error: Error,
CLOSURE_BASE_PATH: path.dirname(CLOSURE_BASE_FILE_PATH) + '/',
CLOSURE_IMPORT_SCRIPT: function(src) {
loadScript(src);
return true;
},
CLOSURE_NO_DEPS: !isDevMode(),
goog: {}
});
closure.window = closure.top = closure;
if (opt_configureForTesting) {
closure.document = {
body: {},
createElement: function() { return {}; },
getElementsByTagName: function() { return []; }
};
closure.document.body.ownerDocument = closure.document;
}
loadScript(CLOSURE_BASE_FILE_PATH);
loadScript(DEPS_FILE_PATH);
/**
* Synchronously loads a script into the protected Closure context.
* @param {string} src Path to the file to load.
*/
function loadScript(src) {
src = path.normalize(src);
var contents = fs.readFileSync(src, 'utf8');
vm.runInContext(contents, closure, src);
}
}
|
javascript
|
{
"resource": ""
}
|
q3981
|
loadScript
|
train
|
function loadScript(src) {
src = path.normalize(src);
var contents = fs.readFileSync(src, 'utf8');
vm.runInContext(contents, closure, src);
}
|
javascript
|
{
"resource": ""
}
|
q3982
|
train
|
function(result, onKill) {
/** @return {boolean} Whether this command is still running. */
this.isRunning = function() {
return result.isPending();
};
/**
* @return {!promise.Promise.<!Result>} A promise for the result of this
* command.
*/
this.result = function() {
return result;
};
/**
* Sends a signal to the underlying process.
* @param {string=} opt_signal The signal to send; defaults to
* {@code SIGTERM}.
*/
this.kill = function(opt_signal) {
onKill(opt_signal || 'SIGTERM');
};
}
|
javascript
|
{
"resource": ""
}
|
|
q3983
|
resolve
|
train
|
function resolve(newState, newValue) {
if (webdriver.promise.Deferred.State_.PENDING !== state) {
return;
}
if (newValue === self) {
// See promise a+, 2.3.1
// http://promises-aplus.github.io/promises-spec/#point-48
throw TypeError('A promise may not resolve to itself');
}
state = webdriver.promise.Deferred.State_.BLOCKED;
if (webdriver.promise.isPromise(newValue)) {
var onFulfill = goog.partial(notifyAll, newState);
var onReject = goog.partial(
notifyAll, webdriver.promise.Deferred.State_.REJECTED);
if (newValue instanceof webdriver.promise.Deferred) {
newValue.then(onFulfill, onReject);
} else {
webdriver.promise.asap(newValue, onFulfill, onReject);
}
} else {
notifyAll(newState, newValue);
}
}
|
javascript
|
{
"resource": ""
}
|
q3984
|
notify
|
train
|
function notify(listener) {
var func = state == webdriver.promise.Deferred.State_.RESOLVED ?
listener.callback : listener.errback;
if (func) {
flow.runInNewFrame_(goog.partial(func, value),
listener.fulfill, listener.reject);
} else if (state == webdriver.promise.Deferred.State_.REJECTED) {
listener.reject(value);
} else {
listener.fulfill(value);
}
}
|
javascript
|
{
"resource": ""
}
|
q3985
|
cancel
|
train
|
function cancel(opt_reason) {
if (!isPending()) {
return;
}
if (opt_canceller) {
opt_reason = opt_canceller(opt_reason) || opt_reason;
}
reject(opt_reason);
}
|
javascript
|
{
"resource": ""
}
|
q3986
|
AddonFormatError
|
train
|
function AddonFormatError(msg) {
Error.call(this);
Error.captureStackTrace(this, AddonFormatError);
/** @override */
this.name = AddonFormatError.name;
/** @override */
this.message = msg;
}
|
javascript
|
{
"resource": ""
}
|
q3987
|
getDetails
|
train
|
function getDetails(addonPath) {
return readManifest(addonPath).then(function(doc) {
var em = getNamespaceId(doc, 'http://www.mozilla.org/2004/em-rdf#');
var rdf = getNamespaceId(
doc, 'http://www.w3.org/1999/02/22-rdf-syntax-ns#');
var description = doc[rdf + 'RDF'][rdf + 'Description'][0];
var details = {
id: getNodeText(description, em + 'id'),
name: getNodeText(description, em + 'name'),
version: getNodeText(description, em + 'version'),
unpack: getNodeText(description, em + 'unpack') || false
};
if (typeof details.unpack === 'string') {
details.unpack = details.unpack.toLowerCase() === 'true';
}
if (!details.id) {
throw new AddonFormatError('Could not find add-on ID for ' + addonPath);
}
return details;
});
function getNodeText(node, name) {
return node[name] && node[name][0] || '';
}
function getNamespaceId(doc, url) {
var keys = Object.keys(doc);
if (keys.length !== 1) {
throw new AddonFormatError('Malformed manifest for add-on ' + addonPath);
}
var namespaces = doc[keys[0]].$;
var id = '';
Object.keys(namespaces).some(function(ns) {
if (namespaces[ns] !== url) {
return false;
}
if (ns.indexOf(':') != -1) {
id = ns.split(':')[1] + ':';
}
return true;
});
return id;
}
}
|
javascript
|
{
"resource": ""
}
|
q3988
|
readManifest
|
train
|
function readManifest(addonPath) {
var manifest;
if (addonPath.slice(-4) === '.xpi') {
manifest = checkedCall(fs.readFile, addonPath).then(function(buff) {
var zip = new AdmZip(buff);
if (!zip.getEntry('install.rdf')) {
throw new AddonFormatError(
'Could not find install.rdf in ' + addonPath);
}
var done = promise.defer();
zip.readAsTextAsync('install.rdf', done.fulfill);
return done.promise;
});
} else {
manifest = checkedCall(fs.stat, addonPath).then(function(stats) {
if (!stats.isDirectory()) {
throw Error(
'Add-on path is niether a xpi nor a directory: ' + addonPath);
}
return checkedCall(fs.readFile, path.join(addonPath, 'install.rdf'));
});
}
return manifest.then(function(content) {
return checkedCall(xml.parseString, content);
});
}
|
javascript
|
{
"resource": ""
}
|
q3989
|
train
|
function(opt_config, opt_service, opt_flow) {
var service = opt_service || getDefaultService();
var executor = executors.createExecutor(service.start());
var capabilities =
opt_config instanceof Options ? opt_config.toCapabilities() :
(opt_config || webdriver.Capabilities.chrome());
var driver = webdriver.WebDriver.createSession(
executor, capabilities, opt_flow);
webdriver.WebDriver.call(
this, driver.getSession(), executor, driver.controlFlow());
}
|
javascript
|
{
"resource": ""
}
|
|
q3990
|
findUnixPortRange
|
train
|
function findUnixPortRange() {
var cmd;
if (process.platform === 'sunos') {
cmd =
'/usr/sbin/ndd /dev/tcp tcp_smallest_anon_port tcp_largest_anon_port';
} else if (fs.existsSync('/proc/sys/net/ipv4/ip_local_port_range')) {
// Linux
cmd = 'cat /proc/sys/net/ipv4/ip_local_port_range';
} else {
cmd = 'sysctl net.inet.ip.portrange.first net.inet.ip.portrange.last' +
' | sed -e "s/.*:\\s*//"';
}
return execute(cmd).then(function(stdout) {
if (!stdout || !stdout.length) return DEFAULT_IANA_RANGE;
var range = stdout.trim().split(/\s+/).map(Number);
if (range.some(isNaN)) return DEFAULT_IANA_RANGE;
return {min: range[0], max: range[1]};
});
}
|
javascript
|
{
"resource": ""
}
|
q3991
|
train
|
function (fontName) {
var testFontName = fontName === 'Comic Sans MS' ? 'Courier New' : 'Comic Sans MS';
var $tester = $('<div>').css({
position: 'absolute',
left: '-9999px',
top: '-9999px',
fontSize: '200px'
}).text('mmmmmmmmmwwwwwww').appendTo(document.body);
var originalWidth = $tester.css('fontFamily', testFontName).width();
var width = $tester.css('fontFamily', fontName + ',' + testFontName).width();
$tester.remove();
return originalWidth !== width;
}
|
javascript
|
{
"resource": ""
}
|
|
q3992
|
train
|
function (sc, so, ec, eo) {
if (arguments.length === 4) {
return new WrappedRange(sc, so, ec, eo);
} else if (arguments.length === 2) { //collapsed
ec = sc;
eo = so;
return new WrappedRange(sc, so, ec, eo);
} else {
var wrappedRange = this.createFromSelection();
if (!wrappedRange && arguments.length === 1) {
wrappedRange = this.createFromNode(arguments[0]);
return wrappedRange.collapse(dom.emptyPara === arguments[0].innerHTML);
}
return wrappedRange;
}
}
|
javascript
|
{
"resource": ""
}
|
|
q3993
|
returnToOriginal
|
train
|
function returnToOriginal() {
doneAnimating = false;
var placeholder = origin.parent('.material-placeholder');
var windowWidth = window.innerWidth;
var windowHeight = window.innerHeight;
var originalWidth = origin.data('width');
var originalHeight = origin.data('height');
origin.velocity("stop", true);
$('#materialbox-overlay').velocity("stop", true);
$('.materialbox-caption').velocity("stop", true);
$('#materialbox-overlay').velocity({opacity: 0}, {
duration: outDuration, // Delay prevents animation overlapping
queue: false, easing: 'easeOutQuad',
complete: function(){
// Remove Overlay
overlayActive = false;
$(this).remove();
}
});
// Resize Image
origin.velocity(
{
width: originalWidth,
height: originalHeight,
left: 0,
top: 0
},
{
duration: outDuration,
queue: false, easing: 'easeOutQuad',
complete: function() {
placeholder.css({
height: '',
width: '',
position: '',
top: '',
left: ''
});
origin.removeAttr('style');
origin.attr('style', originInlineStyles);
// Remove class
origin.removeClass('active');
doneAnimating = true;
// Remove overflow overrides on ancestors
if (ancestorsChanged) {
ancestorsChanged.css('overflow', '');
}
}
}
);
// Remove Caption + reset css settings on image
$('.materialbox-caption').velocity({opacity: 0}, {
duration: outDuration, // Delay prevents animation overlapping
queue: false, easing: 'easeOutQuad',
complete: function(){
$(this).remove();
}
});
}
|
javascript
|
{
"resource": ""
}
|
q3994
|
train
|
function(string, $el) {
var img = $el.find('img');
var matchStart = $el.text().toLowerCase().indexOf("" + string.toLowerCase() + ""),
matchEnd = matchStart + string.length - 1,
beforeMatch = $el.text().slice(0, matchStart),
matchText = $el.text().slice(matchStart, matchEnd + 1),
afterMatch = $el.text().slice(matchEnd + 1);
$el.html("<span>" + beforeMatch + "<span class='highlight'>" + matchText + "</span>" + afterMatch + "</span>");
if (img.length) {
$el.prepend(img);
}
}
|
javascript
|
{
"resource": ""
}
|
|
q3995
|
train
|
function(collection, newOption, firstActivation) {
if (newOption) {
collection.find('li.selected').removeClass('selected');
var option = $(newOption);
option.addClass('selected');
if (!multiple || !!firstActivation) {
options.scrollTo(option);
}
}
}
|
javascript
|
{
"resource": ""
}
|
|
q3996
|
train
|
function(btn) {
if (btn.attr('data-open') === "true") {
return;
}
var offsetX, offsetY, scaleFactor;
var windowWidth = window.innerWidth;
var windowHeight = window.innerHeight;
var btnRect = btn[0].getBoundingClientRect();
var anchor = btn.find('> a').first();
var menu = btn.find('> ul').first();
var backdrop = $('<div class="fab-backdrop"></div>');
var fabColor = anchor.css('background-color');
anchor.append(backdrop);
offsetX = btnRect.left - (windowWidth / 2) + (btnRect.width / 2);
offsetY = windowHeight - btnRect.bottom;
scaleFactor = windowWidth / backdrop.width();
btn.attr('data-origin-bottom', btnRect.bottom);
btn.attr('data-origin-left', btnRect.left);
btn.attr('data-origin-width', btnRect.width);
// Set initial state
btn.addClass('active');
btn.attr('data-open', true);
btn.css({
'text-align': 'center',
width: '100%',
bottom: 0,
left: 0,
transform: 'translateX(' + offsetX + 'px)',
transition: 'none'
});
anchor.css({
transform: 'translateY(' + -offsetY + 'px)',
transition: 'none'
});
backdrop.css({
'background-color': fabColor
});
setTimeout(function() {
btn.css({
transform: '',
transition: 'transform .2s cubic-bezier(0.550, 0.085, 0.680, 0.530), background-color 0s linear .2s'
});
anchor.css({
overflow: 'visible',
transform: '',
transition: 'transform .2s'
});
setTimeout(function() {
btn.css({
overflow: 'hidden',
'background-color': fabColor
});
backdrop.css({
transform: 'scale(' + scaleFactor + ')',
transition: 'transform .2s cubic-bezier(0.550, 0.055, 0.675, 0.190)'
});
menu.find('> li > a').css({
opacity: 1
});
// Scroll to close.
$(window).on('scroll.fabToolbarClose', function() {
toolbarToFAB(btn);
$(window).off('scroll.fabToolbarClose');
$(document).off('click.fabToolbarClose');
});
$(document).on('click.fabToolbarClose', function(e) {
if (!$(e.target).closest(menu).length) {
toolbarToFAB(btn);
$(window).off('scroll.fabToolbarClose');
$(document).off('click.fabToolbarClose');
}
});
}, 100);
}, 0);
}
|
javascript
|
{
"resource": ""
}
|
|
q3997
|
train
|
function(btn) {
if (btn.attr('data-open') !== "true") {
return;
}
var offsetX, offsetY, scaleFactor;
var windowWidth = window.innerWidth;
var windowHeight = window.innerHeight;
var btnWidth = btn.attr('data-origin-width');
var btnBottom = btn.attr('data-origin-bottom');
var btnLeft = btn.attr('data-origin-left');
var anchor = btn.find('> .btn-floating').first();
var menu = btn.find('> ul').first();
var backdrop = btn.find('.fab-backdrop');
var fabColor = anchor.css('background-color');
offsetX = btnLeft - (windowWidth / 2) + (btnWidth / 2);
offsetY = windowHeight - btnBottom;
scaleFactor = windowWidth / backdrop.width();
// Hide backdrop
btn.removeClass('active');
btn.attr('data-open', false);
btn.css({
'background-color': 'transparent',
transition: 'none'
});
anchor.css({
transition: 'none'
});
backdrop.css({
transform: 'scale(0)',
'background-color': fabColor
});
menu.find('> li > a').css({
opacity: ''
});
setTimeout(function() {
backdrop.remove();
// Set initial state.
btn.css({
'text-align': '',
width: '',
bottom: '',
left: '',
overflow: '',
'background-color': '',
transform: 'translate3d(' + -offsetX + 'px,0,0)'
});
anchor.css({
overflow: '',
transform: 'translate3d(0,' + offsetY + 'px,0)'
});
setTimeout(function() {
btn.css({
transform: 'translate3d(0,0,0)',
transition: 'transform .2s'
});
anchor.css({
transform: 'translate3d(0,0,0)',
transition: 'transform .2s cubic-bezier(0.550, 0.055, 0.675, 0.190)'
});
}, 20);
}, 200);
}
|
javascript
|
{
"resource": ""
}
|
|
q3998
|
train
|
function( giveFocus ) {
// If we need to give focus, do it before changing states.
if ( giveFocus ) {
// ....ah yes! It would’ve been incomplete without a crazy workaround for IE :|
// The focus is triggered *after* the close has completed - causing it
// to open again. So unbind and rebind the event at the next tick.
P.$root.off( 'focus.toOpen' ).eq(0).focus()
setTimeout( function() {
P.$root.on( 'focus.toOpen', handleFocusToOpenEvent )
}, 0 )
}
// Remove the “active” class.
$ELEMENT.removeClass( CLASSES.active )
aria( ELEMENT, 'expanded', false )
// * A Firefox bug, when `html` has `overflow:hidden`, results in
// killing transitions :(. So remove the “opened” state on the next tick.
// Bug: https://bugzilla.mozilla.org/show_bug.cgi?id=625289
setTimeout( function() {
// Remove the “opened” and “focused” class from the picker root.
P.$root.removeClass( CLASSES.opened + ' ' + CLASSES.focused )
aria( P.$root[0], 'hidden', true )
}, 0 )
// If it’s already closed, do nothing more.
if ( !STATE.open ) return P
// Set it as closed.
STATE.open = false
// Allow the page to scroll.
if ( IS_DEFAULT_THEME ) {
$html.
css( 'overflow', '' ).
css( 'padding-right', '-=' + getScrollbarWidth() )
}
// Unbind the document events.
$document.off( '.' + STATE.id )
// Trigger the queued “close” events.
return P.trigger( 'close' )
}
|
javascript
|
{
"resource": ""
}
|
|
q3999
|
train
|
function (obj) {
var inverted = {};
for (var key in obj) {
if (obj.hasOwnProperty(key)) {
inverted[obj[key]] = key;
}
}
return inverted;
}
|
javascript
|
{
"resource": ""
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.