_id
stringlengths 2
6
| title
stringlengths 0
58
| partition
stringclasses 3
values | text
stringlengths 52
373k
| language
stringclasses 1
value | meta_information
dict |
|---|---|---|---|---|---|
q5200
|
removeListeners
|
train
|
function removeListeners() {
$element.unbind(START_EV, touchStart);
$element.unbind(CANCEL_EV, touchCancel);
$element.unbind(MOVE_EV, touchMove);
$element.unbind(END_EV, touchEnd);
//we only have leave events on desktop, we manually calculate leave on touch as its not supported in webkit
if(LEAVE_EV) {
$element.unbind(LEAVE_EV, touchLeave);
}
setTouchInProgress(false);
}
|
javascript
|
{
"resource": ""
}
|
q5201
|
getNextPhase
|
train
|
function getNextPhase(currentPhase) {
var nextPhase = currentPhase;
// Ensure we have valid swipe (under time and over distance and check if we are out of bound...)
var validTime = validateSwipeTime();
var validDistance = validateSwipeDistance();
var didCancel = didSwipeBackToCancel();
//If we have exceeded our time, then cancel
if(!validTime || didCancel) {
nextPhase = PHASE_CANCEL;
}
//Else if we are moving, and have reached distance then end
else if (validDistance && currentPhase == PHASE_MOVE && (!options.triggerOnTouchEnd || options.triggerOnTouchLeave) ) {
nextPhase = PHASE_END;
}
//Else if we have ended by leaving and didn't reach distance, then cancel
else if (!validDistance && currentPhase==PHASE_END && options.triggerOnTouchLeave) {
nextPhase = PHASE_CANCEL;
}
return nextPhase;
}
|
javascript
|
{
"resource": ""
}
|
q5202
|
validateSwipeDistance
|
train
|
function validateSwipeDistance() {
var valid = true;
//If we made it past the min swipe distance..
if (options.threshold !== null) {
valid = distance >= options.threshold;
}
return valid;
}
|
javascript
|
{
"resource": ""
}
|
q5203
|
didSwipeBackToCancel
|
train
|
function didSwipeBackToCancel() {
var cancelled = false;
if(options.cancelThreshold !== null && direction !==null) {
cancelled = (getMaxDistance( direction ) - distance) >= options.cancelThreshold;
}
return cancelled;
}
|
javascript
|
{
"resource": ""
}
|
q5204
|
validateDefaultEvent
|
train
|
function validateDefaultEvent(jqEvent, direction) {
//If we have no pinches, then do this
//If we have a pinch, and we we have 2 fingers or more down, then dont allow page scroll.
//If the option is set, allways allow the event to bubble up (let user handle wiredness)
if( options.preventDefaultEvents === false) {
return;
}
if (options.allowPageScroll === NONE) {
jqEvent.preventDefault();
} else {
var auto = options.allowPageScroll === AUTO;
switch (direction) {
case LEFT:
if ((options.swipeLeft && auto) || (!auto && options.allowPageScroll != HORIZONTAL)) {
jqEvent.preventDefault();
}
break;
case RIGHT:
if ((options.swipeRight && auto) || (!auto && options.allowPageScroll != HORIZONTAL)) {
jqEvent.preventDefault();
}
break;
case UP:
if ((options.swipeUp && auto) || (!auto && options.allowPageScroll != VERTICAL)) {
jqEvent.preventDefault();
}
break;
case DOWN:
if ((options.swipeDown && auto) || (!auto && options.allowPageScroll != VERTICAL)) {
jqEvent.preventDefault();
}
break;
}
}
}
|
javascript
|
{
"resource": ""
}
|
q5205
|
validatePinch
|
train
|
function validatePinch() {
var hasCorrectFingerCount = validateFingers();
var hasEndPoint = validateEndPoint();
var hasCorrectDistance = validatePinchDistance();
return hasCorrectFingerCount && hasEndPoint && hasCorrectDistance;
}
|
javascript
|
{
"resource": ""
}
|
q5206
|
validateSwipe
|
train
|
function validateSwipe() {
//Check validity of swipe
var hasValidTime = validateSwipeTime();
var hasValidDistance = validateSwipeDistance();
var hasCorrectFingerCount = validateFingers();
var hasEndPoint = validateEndPoint();
var didCancel = didSwipeBackToCancel();
// if the user swiped more than the minimum length, perform the appropriate action
// hasValidDistance is null when no distance is set
var valid = !didCancel && hasEndPoint && hasCorrectFingerCount && hasValidDistance && hasValidTime;
return valid;
}
|
javascript
|
{
"resource": ""
}
|
q5207
|
hasSwipes
|
train
|
function hasSwipes() {
//Enure we dont return 0 or null for false values
return !!(options.swipe || options.swipeStatus || options.swipeLeft || options.swipeRight || options.swipeUp || options.swipeDown);
}
|
javascript
|
{
"resource": ""
}
|
q5208
|
validateDoubleTap
|
train
|
function validateDoubleTap() {
if(doubleTapStartTime==null){
return false;
}
var now = getTimeStamp();
return (hasDoubleTap() && ((now-doubleTapStartTime) <= options.doubleTapThreshold));
}
|
javascript
|
{
"resource": ""
}
|
q5209
|
inMultiFingerRelease
|
train
|
function inMultiFingerRelease() {
var withinThreshold = false;
if(previousTouchEndTime) {
var diff = getTimeStamp() - previousTouchEndTime
if( diff<=options.fingerReleaseThreshold ) {
withinThreshold = true;
}
}
return withinThreshold;
}
|
javascript
|
{
"resource": ""
}
|
q5210
|
setTouchInProgress
|
train
|
function setTouchInProgress(val) {
//Add or remove event listeners depending on touch status
if(val===true) {
$element.bind(MOVE_EV, touchMove);
$element.bind(END_EV, touchEnd);
//we only have leave events on desktop, we manually calcuate leave on touch as its not supported in webkit
if(LEAVE_EV) {
$element.bind(LEAVE_EV, touchLeave);
}
} else {
$element.unbind(MOVE_EV, touchMove, false);
$element.unbind(END_EV, touchEnd, false);
//we only have leave events on desktop, we manually calcuate leave on touch as its not supported in webkit
if(LEAVE_EV) {
$element.unbind(LEAVE_EV, touchLeave, false);
}
}
//strict equality to ensure only true and false can update the value
$element.data(PLUGIN_NS+'_intouch', val === true);
}
|
javascript
|
{
"resource": ""
}
|
q5211
|
updateFingerData
|
train
|
function updateFingerData(evt) {
var id = evt.identifier!==undefined ? evt.identifier : 0;
var f = getFingerData( id );
f.end.x = evt.pageX||evt.clientX;
f.end.y = evt.pageY||evt.clientY;
return f;
}
|
javascript
|
{
"resource": ""
}
|
q5212
|
getFingerData
|
train
|
function getFingerData( id ) {
for(var i=0; i<fingerData.length; i++) {
if(fingerData[i].identifier == id) {
return fingerData[i];
}
}
}
|
javascript
|
{
"resource": ""
}
|
q5213
|
createAllFingerData
|
train
|
function createAllFingerData() {
var fingerData=[];
for (var i=0; i<=5; i++) {
fingerData.push({
start:{ x: 0, y: 0 },
end:{ x: 0, y: 0 },
identifier:0
});
}
return fingerData;
}
|
javascript
|
{
"resource": ""
}
|
q5214
|
setMaxDistance
|
train
|
function setMaxDistance(direction, distance) {
distance = Math.max(distance, getMaxDistance(direction) );
maximumsMap[direction].distance = distance;
}
|
javascript
|
{
"resource": ""
}
|
q5215
|
createMaximumsData
|
train
|
function createMaximumsData() {
var maxData={};
maxData[LEFT]=createMaximumVO(LEFT);
maxData[RIGHT]=createMaximumVO(RIGHT);
maxData[UP]=createMaximumVO(UP);
maxData[DOWN]=createMaximumVO(DOWN);
return maxData;
}
|
javascript
|
{
"resource": ""
}
|
q5216
|
calculateAngle
|
train
|
function calculateAngle(startPoint, endPoint) {
var x = startPoint.x - endPoint.x;
var y = endPoint.y - startPoint.y;
var r = Math.atan2(y, x); //radians
var angle = Math.round(r * 180 / Math.PI); //degrees
//ensure value is positive
if (angle < 0) {
angle = 360 - Math.abs(angle);
}
return angle;
}
|
javascript
|
{
"resource": ""
}
|
q5217
|
calculateDirection
|
train
|
function calculateDirection(startPoint, endPoint ) {
var angle = calculateAngle(startPoint, endPoint);
if ((angle <= 45) && (angle >= 0)) {
return LEFT;
} else if ((angle <= 360) && (angle >= 315)) {
return LEFT;
} else if ((angle >= 135) && (angle <= 225)) {
return RIGHT;
} else if ((angle > 45) && (angle < 135)) {
return DOWN;
} else {
return UP;
}
}
|
javascript
|
{
"resource": ""
}
|
q5218
|
getbounds
|
train
|
function getbounds( el ) {
el = $(el);
var offset = el.offset();
var bounds = {
left:offset.left,
right:offset.left+el.outerWidth(),
top:offset.top,
bottom:offset.top+el.outerHeight()
}
return bounds;
}
|
javascript
|
{
"resource": ""
}
|
q5219
|
isInBounds
|
train
|
function isInBounds(point, bounds) {
return (point.x > bounds.left && point.x < bounds.right && point.y > bounds.top && point.y < bounds.bottom);
}
|
javascript
|
{
"resource": ""
}
|
q5220
|
delayEvent
|
train
|
function delayEvent( type, instance, container ) {
return function( event ) {
container._trigger( type, event, instance._uiHash( instance ) );
};
}
|
javascript
|
{
"resource": ""
}
|
q5221
|
train
|
function (f, s, o) {
// pattern for standard and localized AM/PM markers
var getPatternAmpm = function (amNames, pmNames) {
var markers = [];
if (amNames) {
$.merge(markers, amNames);
}
if (pmNames) {
$.merge(markers, pmNames);
}
markers = $.map(markers, function (val) {
return val.replace(/[.*+?|()\[\]{}\\]/g, '\\$&');
});
return '(' + markers.join('|') + ')?';
};
// figure out position of time elements.. cause js cant do named captures
var getFormatPositions = function (timeFormat) {
var finds = timeFormat.toLowerCase().match(/(h{1,2}|m{1,2}|s{1,2}|l{1}|c{1}|t{1,2}|z|'.*?')/g),
orders = {
h: -1,
m: -1,
s: -1,
l: -1,
c: -1,
t: -1,
z: -1
};
if (finds) {
for (var i = 0; i < finds.length; i++) {
if (orders[finds[i].toString().charAt(0)] === -1) {
orders[finds[i].toString().charAt(0)] = i + 1;
}
}
}
return orders;
};
var regstr = '^' + f.toString()
.replace(/([hH]{1,2}|mm?|ss?|[tT]{1,2}|[zZ]|[lc]|'.*?')/g, function (match) {
var ml = match.length;
switch (match.charAt(0).toLowerCase()) {
case 'h':
return ml === 1 ? '(\\d?\\d)' : '(\\d{' + ml + '})';
case 'm':
return ml === 1 ? '(\\d?\\d)' : '(\\d{' + ml + '})';
case 's':
return ml === 1 ? '(\\d?\\d)' : '(\\d{' + ml + '})';
case 'l':
return '(\\d?\\d?\\d)';
case 'c':
return '(\\d?\\d?\\d)';
case 'z':
return '(z|[-+]\\d\\d:?\\d\\d|\\S+)?';
case 't':
return getPatternAmpm(o.amNames, o.pmNames);
default: // literal escaped in quotes
return '(' + match.replace(/\'/g, "").replace(/(\.|\$|\^|\\|\/|\(|\)|\[|\]|\?|\+|\*)/g, function (m) { return "\\" + m; }) + ')?';
}
})
.replace(/\s/g, '\\s?') +
o.timeSuffix + '$',
order = getFormatPositions(f),
ampm = '',
treg;
treg = s.match(new RegExp(regstr, 'i'));
var resTime = {
hour: 0,
minute: 0,
second: 0,
millisec: 0,
microsec: 0
};
if (treg) {
if (order.t !== -1) {
if (treg[order.t] === undefined || treg[order.t].length === 0) {
ampm = '';
resTime.ampm = '';
} else {
ampm = $.inArray(treg[order.t].toUpperCase(), $.map(o.amNames, function (x,i) { return x.toUpperCase(); })) !== -1 ? 'AM' : 'PM';
resTime.ampm = o[ampm === 'AM' ? 'amNames' : 'pmNames'][0];
}
}
if (order.h !== -1) {
if (ampm === 'AM' && treg[order.h] === '12') {
resTime.hour = 0; // 12am = 0 hour
} else {
if (ampm === 'PM' && treg[order.h] !== '12') {
resTime.hour = parseInt(treg[order.h], 10) + 12; // 12pm = 12 hour, any other pm = hour + 12
} else {
resTime.hour = Number(treg[order.h]);
}
}
}
if (order.m !== -1) {
resTime.minute = Number(treg[order.m]);
}
if (order.s !== -1) {
resTime.second = Number(treg[order.s]);
}
if (order.l !== -1) {
resTime.millisec = Number(treg[order.l]);
}
if (order.c !== -1) {
resTime.microsec = Number(treg[order.c]);
}
if (order.z !== -1 && treg[order.z] !== undefined) {
resTime.timezone = $.timepicker.timezoneOffsetNumber(treg[order.z]);
}
return resTime;
}
return false;
}
|
javascript
|
{
"resource": ""
}
|
|
q5222
|
train
|
function (timeFormat) {
var finds = timeFormat.toLowerCase().match(/(h{1,2}|m{1,2}|s{1,2}|l{1}|c{1}|t{1,2}|z|'.*?')/g),
orders = {
h: -1,
m: -1,
s: -1,
l: -1,
c: -1,
t: -1,
z: -1
};
if (finds) {
for (var i = 0; i < finds.length; i++) {
if (orders[finds[i].toString().charAt(0)] === -1) {
orders[finds[i].toString().charAt(0)] = i + 1;
}
}
}
return orders;
}
|
javascript
|
{
"resource": ""
}
|
|
q5223
|
train
|
function (f, s, o) {
try {
var d = new Date('2012-01-01 ' + s);
if (isNaN(d.getTime())) {
d = new Date('2012-01-01T' + s);
if (isNaN(d.getTime())) {
d = new Date('01/01/2012 ' + s);
if (isNaN(d.getTime())) {
throw "Unable to parse time with native Date: " + s;
}
}
}
return {
hour: d.getHours(),
minute: d.getMinutes(),
second: d.getSeconds(),
millisec: d.getMilliseconds(),
microsec: d.getMicroseconds(),
timezone: d.getTimezoneOffset() * -1
};
}
catch (err) {
try {
return strictParse(f, s, o);
}
catch (err2) {
$.timepicker.log("Unable to parse \ntimeString: " + s + "\ntimeFormat: " + f);
}
}
return false;
}
|
javascript
|
{
"resource": ""
}
|
|
q5224
|
train
|
function(container, item) {
var borderTop = parseFloat(container.css('borderTopWidth')) || 0,
paddingTop = parseFloat(container.css('paddingTop')) || 0,
offset = item.offset().top - container.offset().top - borderTop - paddingTop,
scroll = container.scrollTop(),
elementHeight = container.height(),
itemHeight = item.outerHeight(true);
if(offset < 0) {
container.scrollTop(scroll + offset);
}
else if((offset + itemHeight) > elementHeight) {
container.scrollTop(scroll + offset - elementHeight + itemHeight);
}
}
|
javascript
|
{
"resource": ""
}
|
|
q5225
|
train
|
function(jQuery) {
var matched, browser;
jQuery.uaMatch = function( ua ) {
ua = ua.toLowerCase();
var match = /(opr)[\/]([\w.]+)/.exec( ua ) ||
/(chrome)[ \/]([\w.]+)/.exec( ua ) ||
/(version)[ \/]([\w.]+).*(safari)[ \/]([\w.]+)/.exec( ua ) ||
/(webkit)[ \/]([\w.]+)/.exec( ua ) ||
/(opera)(?:.*version|)[ \/]([\w.]+)/.exec( ua ) ||
/(msie) ([\w.]+)/.exec( ua ) ||
ua.indexOf("trident") >= 0 && /(rv)(?::| )([\w.]+)/.exec( ua ) ||
ua.indexOf("compatible") < 0 && /(mozilla)(?:.*? rv:([\w.]+)|)/.exec( ua ) ||
[];
var platform_match = /(ipad)/.exec( ua ) ||
/(iphone)/.exec( ua ) ||
/(android)/.exec( ua ) ||
/(windows phone)/.exec( ua ) ||
/(win)/.exec( ua ) ||
/(mac)/.exec( ua ) ||
/(linux)/.exec( ua ) ||
/(cros)/i.exec( ua ) ||
[];
return {
browser: match[ 3 ] || match[ 1 ] || "",
version: match[ 2 ] || "0",
platform: platform_match[ 0 ] || ""
};
};
matched = jQuery.uaMatch( window.navigator.userAgent );
browser = {};
if ( matched.browser ) {
browser[ matched.browser ] = true;
browser.version = matched.version;
browser.versionNumber = parseInt(matched.version);
}
if ( matched.platform ) {
browser[ matched.platform ] = true;
}
// These are all considered mobile platforms, meaning they run a mobile browser
if ( browser.android || browser.ipad || browser.iphone || browser[ "windows phone" ] ) {
browser.mobile = true;
}
// These are all considered desktop platforms, meaning they run a desktop browser
if ( browser.cros || browser.mac || browser.linux || browser.win ) {
browser.desktop = true;
}
// Chrome, Opera 15+ and Safari are webkit based browsers
if ( browser.chrome || browser.opr || browser.safari ) {
browser.webkit = true;
}
// IE11 has a new token so we will assign it msie to avoid breaking changes
if ( browser.rv )
{
var ie = "msie";
matched.browser = ie;
browser[ie] = true;
}
// Opera 15+ are identified as opr
if ( browser.opr )
{
var opera = "opera";
matched.browser = opera;
browser[opera] = true;
}
// Stock Android browsers are marked as Safari on Android.
if ( browser.safari && browser.android )
{
var android = "android";
matched.browser = android;
browser[android] = true;
}
// Assign the name and platform variable
browser.name = matched.browser;
browser.platform = matched.platform;
this.browser = browser;
$.browser = browser;
}
|
javascript
|
{
"resource": ""
}
|
|
q5226
|
train
|
function(index, silent) {
var panel = this.panels.eq(index);
if(!silent) {
this._trigger('change', null, {'index': index});
}
//update state
if(this.options.multiple) {
this._addToSelection(index);
}
else {
this.options.activeIndex = index;
}
this._show(panel);
}
|
javascript
|
{
"resource": ""
}
|
|
q5227
|
train
|
function(index) {
var panel = this.panels.eq(index),
header = panel.prev();
header.attr('aria-expanded', false).children('.fa').removeClass('fa-caret-down').addClass('fa-caret-right');
header.removeClass('ui-state-active ui-corner-top').addClass('ui-corner-all');
panel.attr('aria-hidden', true).slideUp();
this._removeFromSelection(index);
}
|
javascript
|
{
"resource": ""
}
|
|
q5228
|
train
|
function(pos) {
var l = pos.left < 0 ? 0 : pos.left,
t = pos.top < 0 ? 0 : pos.top;
$(this).css({
left: l,
top: t
});
}
|
javascript
|
{
"resource": ""
}
|
|
q5229
|
apiSpecs
|
train
|
function apiSpecs(options) {
options = Options.applyDefaultSpecOptions(options)
if (options.headers) {
request.defaults.headers.common = Object.assign({}, request.defaults.headers.common, options.headers)
}
const api = swaggerSpec.getSpecSync(options.api)
const operations = swaggerSpec.getAllOperations(api)
options.fixtures = getJsonFile(options.fixtures)
describeApi(api, operations, options)
}
|
javascript
|
{
"resource": ""
}
|
q5230
|
Config
|
train
|
function Config(pathToConfigFileIn, region) {
have(arguments, {pathToConfigFile: 'str', region: 'opt str' });
debug('pathToConfigFileIn: '+pathToConfigFileIn);
// if the path has '##' and process.env.NODE_ENV is a non-empty string,
// replace '##' with the contents of process.env.NODE_ENV
var pathToConfigFile = pathToConfigFileIn;
var idx = pathToConfigFileIn.indexOf('##');
if (idx > -1 && is.nonEmptyStr(process.env.NODE_ENV)) {
pathToConfigFile = pathToConfigFileIn.substr(0, idx) +
process.env.NODE_ENV + pathToConfigFileIn.substr(idx+2);
}
// complimentary to have arg checking
if (!is.nonEmptyStr(pathToConfigFile))
throw new Error('Bad path to config file: '+pathToConfigFile);
if (!fs.existsSync(pathToConfigFile))
throw new Error('Config file is missing: '+pathToConfigFile);
if (is.defined(region)) assert.ok(is.nonEmptyStr(region));
// english is the default
if (is.undefined(region)) region = 'en';
debug('## sub: pathToConfigFileIn: '+pathToConfigFileIn);
this.pathToDefaults = path.join(path.dirname(pathToConfigFileIn),
'defaults.js');
this.pathToConfigFile = pathToConfigFile;
debug('region: '+region);
this.region = region;
var self = this;
debug('pathToDeafults: '+this.pathToDefaults);
// set a watch for when the file changes, to reload the file.
fs.watchFile(this.pathToConfigFile, function () {
self.loadConfig(self.pathToDefaults, self.pathToConfigFile, self.region);
});
// we can't wait for the file to change to re-load, so we load it now
this.loadConfig(self.pathToDefaults, self.pathToConfigFile, self.region);
var util = require('util');
debug('Config: '+util.inspect(this.configObj));
}
|
javascript
|
{
"resource": ""
}
|
q5231
|
transformFile
|
train
|
function transformFile(contents) {
var $ = cheerio.load(contents.toString());
var result = [];
$(options.selector).each(function() {
var element = $(this);
var fileName = options.getFileName(element);
result.push(fileName);
});
return result;
}
|
javascript
|
{
"resource": ""
}
|
q5232
|
train
|
function ( text ) {
var lines = text.split( "\n" );
var info = {};
var delimiter_pattern = /\s+/;
var materialsInfo = {};
for ( var i = 0; i < lines.length; i ++ ) {
var line = lines[ i ];
line = line.trim();
if ( line.length === 0 || line.charAt( 0 ) === '#' ) {
// Blank line or comment ignore
continue;
}
var pos = line.indexOf( ' ' );
var key = ( pos >= 0 ) ? line.substring( 0, pos ) : line;
key = key.toLowerCase();
var value = ( pos >= 0 ) ? line.substring( pos + 1 ) : "";
value = value.trim();
if ( key === "newmtl" ) {
// New material
info = { name: value };
materialsInfo[ value ] = info;
} else if ( info ) {
if ( key === "ka" || key === "kd" || key === "ks" ) {
var ss = value.split( delimiter_pattern, 3 );
info[ key ] = [ parseFloat( ss[ 0 ] ), parseFloat( ss[ 1 ] ), parseFloat( ss[ 2 ] ) ];
} else {
info[ key ] = value;
}
}
}
var materialCreator = new THREE.MTLLoader.MaterialCreator( this.baseUrl, this.materialOptions );
materialCreator.setCrossOrigin( this.crossOrigin );
materialCreator.setManager( this.manager );
materialCreator.setMaterials( materialsInfo );
return materialCreator;
}
|
javascript
|
{
"resource": ""
}
|
|
q5233
|
train
|
function(target, styleName) {
var styleVal = this.getComputedStyle(styleName);
if (!!styleVal) {
$(target).css(styleName, styleVal);
}
}
|
javascript
|
{
"resource": ""
}
|
|
q5234
|
train
|
function (coverage /*, testName */) {
var store = this.store;
Object.keys(coverage).forEach(function (key) {
var fileCoverage = coverage[key];
if (store.hasKey(key)) {
store.setObject(key, utils.mergeFileCoverage(fileCoverage, store.getObject(key)));
} else {
store.setObject(key, fileCoverage);
}
});
}
|
javascript
|
{
"resource": ""
}
|
|
q5235
|
getCircumCircle
|
train
|
function getCircumCircle(p1, p2, p3) {
var x1 = p1[0];
var y1 = p1[1];
var x2 = p2[0];
var y2 = p2[1];
var x3 = p3[0];
var y3 = p3[1];
//center of circle
var D = 2 * (x1 * (y2 - y3) + x2 * (y3 - y1) + x3 * (y1 - y2));
var Ux = ((x1 * x1 + y1 * y1) * (y2 - y3) + (x2 * x2 + y2 * y2) * (y3 - y1) + (x3 * x3 + y3 * y3) * (y1 - y2)) / D;
var Uy = ((x1 * x1 + y1 * y1) * (x3 - x2) + (x2 * x2 + y2 * y2) * (x1 - x3) + (x3 * x3 + y3 * y3) * (x2 - x1)) / D;
var px = Ux - x1;
var py = Uy - y1;
var r = Math.sqrt(px * px + py * py);
return {
cx: Ux,
cy: Uy,
radius: r
};
}
|
javascript
|
{
"resource": ""
}
|
q5236
|
_argArray
|
train
|
function _argArray(argObj, prefix, suffix) {
var args = Array.prototype.slice.call(argObj);
if (prefix) args.unshift(prefix);
if (suffix) args.push(suffix);
return args;
}
|
javascript
|
{
"resource": ""
}
|
q5237
|
drawPass
|
train
|
function drawPass (bindings, passIndex, passCount, outputFBO) {
var { debugFBO, gl, canvas, shader, quad, resolution, scale, offset } = bindings
var { uniforms } = shader
var { width, height } = canvas
debugFBO.bind()
shader.bind()
// update shader
var resizeResolutionX = width / passCount * (1 - MARGIN * 2)
var resizeResolutionY = height / passCount * (1 - MARGIN * 2)
resolution[0] = width
resolution[1] = height
scale[0] = width / resizeResolutionX
scale[1] = height / resizeResolutionY
var scissorOffsetX = width * passIndex / passCount + width / passCount * MARGIN
var scissorOffsetY = (height / 2) - (resizeResolutionY / 2)
offset[0] = scissorOffsetX / width
offset[1] = scissorOffsetY / height
uniforms.uOffset = offset
uniforms.uResolution = resolution
uniforms.uScale = scale
uniforms.uInput = outputFBO.color[0].bind(0)
// set scissor
gl.enable(gl.SCISSOR_TEST)
gl.scissor(
// coordinate of lower left of box, moving up and to the right
scissorOffsetX,
scissorOffsetY,
resizeResolutionX,
resizeResolutionY
)
// clear first, then draw on it
gl.clearColor(0,0,0,1)
gl.clear(gl.COLOR_BUFFER_BIT)
gl.disable(gl.DEPTH_TEST)
RenderScreen(gl)
// reset state
gl.bindFramebuffer(gl.FRAMEBUFFER, null)
gl.disable(gl.SCISSOR_TEST)
gl.enable(gl.DEPTH_TEST)
gl.scissor(0, 0, width, height)
}
|
javascript
|
{
"resource": ""
}
|
q5238
|
normalizeTranslateArguments
|
train
|
function normalizeTranslateArguments( args ) {
var original = args[ 0 ],
options = {},
i;
// warn about older deprecated syntax
if ( typeof original !== 'string' || args.length > 3 || ( args.length > 2 && typeof args[ 1 ] === 'object' && typeof args[ 2 ] === 'object' ) ) {
warn( 'Deprecated Invocation: `translate()` accepts ( string, [string], [object] ). These arguments passed:', simpleArguments( args ), '. See https://github.com/Automattic/i18n-calypso#translate-method' );
}
if ( args.length === 2 && typeof original === 'string' && typeof args[ 1 ] === 'string' ) {
warn( 'Invalid Invocation: `translate()` requires an options object for plural translations, but passed:', simpleArguments( args ) );
}
// options could be in position 0, 1, or 2
// sending options as the first object is deprecated and will raise a warning
for ( i = 0; i < args.length; i++ ) {
if ( typeof args[ i ] === 'object' ) {
options = args[ i ];
}
}
// `original` can be passed as first parameter or as part of the options object
// though passing original as part of the options is a deprecated approach and will be removed
if ( typeof original === 'string' ) {
options.original = original;
} else if ( typeof options.original === 'object' ) {
options.plural = options.original.plural;
options.count = options.original.count;
options.original = options.original.single;
}
if ( typeof args[ 1 ] === 'string' ) {
options.plural = args[ 1 ];
}
if ( typeof options.original === 'undefined' ) {
throw new Error( 'Translate called without a `string` value as first argument.' );
}
return options;
}
|
javascript
|
{
"resource": ""
}
|
q5239
|
loadDeps
|
train
|
function loadDeps(file, resource) {
file.requires.forEach(function(id) {
resource.add(id);
});
file.asyncs.forEach(function(id) {
resource.add(id, true);
});
}
|
javascript
|
{
"resource": ""
}
|
q5240
|
train
|
function(param) {
return function(el) {
var text = el.innerText || el.textContent || el.value || '';
return !!~text.indexOf(param);
};
}
|
javascript
|
{
"resource": ""
}
|
|
q5241
|
train
|
function (graph, head, where) {
var routes = [];
Graph.Visitor.Stacked(graph, head, function (node, stack, weight) {
if (where && where.length !== stack.length){
return;
}
routes.push(new Graph.Route(stack.slice(), weight));
});
return routes;
}
|
javascript
|
{
"resource": ""
}
|
|
q5242
|
train
|
function (offset) {
for (var i = beatmap.timingPoints.length - 1; i >= 0; i--) {
if (beatmap.timingPoints[i].offset <= offset) { return beatmap.timingPoints[i]; }
}
return beatmap.timingPoints[0];
}
|
javascript
|
{
"resource": ""
}
|
|
q5243
|
train
|
function (str) {
if (!str) return {};
var additions = {};
var adds = str.split(':');
if (adds[0] && adds[0] !== '0') {
var sample;
switch (adds[0]) {
case '1':
sample = 'normal';
break;
case '2':
sample = 'soft';
break;
case '3':
sample = 'drum';
break;
}
additions.sample = sample;
}
if (adds[1] && adds[1] !== '0') {
var addSample;
switch (adds[1]) {
case '1':
addSample = 'normal';
break;
case '2':
addSample = 'soft';
break;
case '3':
addSample = 'drum';
break;
}
additions.additionalSample = addSample;
}
if (adds[2] && adds[2] !== '0') { additions.customSampleIndex = parseInt(adds[2]); }
if (adds[3] && adds[3] !== '0') { additions.hitsoundVolume = parseInt(adds[3]); }
if (adds[4]) { additions.hitsound = adds[4]; }
return additions;
}
|
javascript
|
{
"resource": ""
}
|
|
q5244
|
train
|
function (line) {
members = line.split(',');
var timingPoint = {
offset: parseInt(members[0]),
beatLength: parseFloat(members[1]),
velocity: 1,
timingSignature: parseInt(members[2]),
sampleSetId: parseInt(members[3]),
customSampleIndex: parseInt(members[4]),
sampleVolume: parseInt(members[5]),
timingChange: (members[6] == 1),
kiaiTimeActive: (members[7] == 1)
};
if (!isNaN(timingPoint.beatLength) && timingPoint.beatLength !== 0) {
if (timingPoint.beatLength > 0) {
// If positive, beatLength is the length of a beat in milliseconds
var bpm = Math.round(60000 / timingPoint.beatLength);
beatmap.bpmMin = beatmap.bpmMin ? Math.min(beatmap.bpmMin, bpm) : bpm;
beatmap.bpmMax = beatmap.bpmMax ? Math.max(beatmap.bpmMax, bpm) : bpm;
timingPoint.bpm = bpm;
} else {
// If negative, beatLength is a velocity factor
timingPoint.velocity = Math.abs(100 / timingPoint.beatLength);
}
}
beatmap.timingPoints.push(timingPoint);
}
|
javascript
|
{
"resource": ""
}
|
|
q5245
|
train
|
function (line) {
/**
* Background line : 0,0,"bg.jpg"
* TODO: confirm that the second member is always zero
*
* Breaktimes lines : 2,1000,2000
* second integer is start offset
* third integer is end offset
*/
members = line.split(',');
if (members[0] == '0' && members[1] == '0' && members[2]) {
var bgName = members[2].trim();
if (bgName.charAt(0) == '"' && bgName.charAt(bgName.length - 1) == '"') {
beatmap.bgFilename = bgName.substring(1, bgName.length - 1);
} else {
beatmap.bgFilename = bgName;
}
} else if (members[0] == '2' && /^[0-9]+$/.test(members[1]) && /^[0-9]+$/.test(members[2])) {
beatmap.breakTimes.push({
startTime: parseInt(members[1]),
endTime: parseInt(members[2])
});
}
}
|
javascript
|
{
"resource": ""
}
|
|
q5246
|
train
|
function () {
var firstObject = beatmap.hitObjects[0];
var lastObject = beatmap.hitObjects[beatmap.hitObjects.length - 1];
var totalBreakTime = 0;
beatmap.breakTimes.forEach(function (breakTime) {
totalBreakTime += (breakTime.endTime - breakTime.startTime);
});
if (firstObject && lastObject) {
beatmap.totalTime = Math.floor(lastObject.startTime / 1000);
beatmap.drainingTime = Math.floor((lastObject.startTime - firstObject.startTime - totalBreakTime) / 1000);
} else {
beatmap.totalTime = 0;
beatmap.drainingTime = 0;
}
}
|
javascript
|
{
"resource": ""
}
|
|
q5247
|
train
|
function () {
if (beatmap.timingPoints.length === 0) { return; }
var maxCombo = 0;
var sliderMultiplier = parseFloat(beatmap.SliderMultiplier);
var sliderTickRate = parseInt(beatmap.SliderTickRate, 10);
var timingPoints = beatmap.timingPoints;
var currentTiming = timingPoints[0];
var nextOffset = timingPoints[1] ? timingPoints[1].offset : Infinity;
var i = 1;
beatmap.hitObjects.forEach(function (hitObject) {
if (hitObject.startTime >= nextOffset) {
currentTiming = timingPoints[i++];
nextOffset = timingPoints[i] ? timingPoints[i].offset : Infinity;
}
var osupxPerBeat = sliderMultiplier * 100 * currentTiming.velocity;
var tickLength = osupxPerBeat / sliderTickRate;
switch (hitObject.objectName) {
case 'spinner':
case 'circle':
maxCombo++;
break;
case 'slider':
var tickPerSide = Math.ceil((Math.floor(hitObject.pixelLength / tickLength * 100) / 100) - 1);
maxCombo += (hitObject.edges.length - 1) * (tickPerSide + 1) + 1; // 1 combo for each tick and endpoint
}
});
beatmap.maxCombo = maxCombo;
}
|
javascript
|
{
"resource": ""
}
|
|
q5248
|
train
|
function () {
if (beatmap.Tags) {
beatmap.tagsArray = beatmap.Tags.split(' ');
}
eventsLines.forEach(parseEvent);
beatmap.breakTimes.sort(function (a, b) { return (a.startTime > b.startTime ? 1 : -1); });
timingLines.forEach(parseTimingPoint);
beatmap.timingPoints.sort(function (a, b) { return (a.offset > b.offset ? 1 : -1); });
var timingPoints = beatmap.timingPoints;
for (var i = 1, l = timingPoints.length; i < l; i++) {
if (!timingPoints[i].hasOwnProperty('bpm')) {
timingPoints[i].beatLength = timingPoints[i - 1].beatLength;
timingPoints[i].bpm = timingPoints[i - 1].bpm;
}
}
objectLines.forEach(parseHitObject);
beatmap.hitObjects.sort(function (a, b) { return (a.startTime > b.startTime ? 1 : -1); });
computeMaxCombo();
computeDuration();
return beatmap;
}
|
javascript
|
{
"resource": ""
}
|
|
q5249
|
train
|
function(no_in) {
handle_regexp();
var start = S.token;
if (start.type == "name" && start.value == "yield") {
if (is_in_generator()) {
next();
return _yield_expression();
} else if (S.input.has_directive("use strict")) {
token_error(S.token, "Unexpected yield identifier inside strict mode");
}
}
var left = maybe_conditional(no_in);
var val = S.token.value;
if (is("operator") && ASSIGNMENT(val)) {
if (is_assignable(left) || (left = to_destructuring(left)) instanceof AST_Destructuring) {
next();
return new AST_Assign({
start : start,
left : left,
operator : val,
right : maybe_assign(no_in),
end : prev()
});
}
croak("Invalid assignment");
}
return left;
}
|
javascript
|
{
"resource": ""
}
|
|
q5250
|
is_true
|
train
|
function is_true(node) {
return node instanceof AST_True
|| in_bool
&& node instanceof AST_Constant
&& node.getValue()
|| (node instanceof AST_UnaryPrefix
&& node.operator == "!"
&& node.expression instanceof AST_Constant
&& !node.expression.getValue());
}
|
javascript
|
{
"resource": ""
}
|
q5251
|
is_false
|
train
|
function is_false(node) {
return node instanceof AST_False
|| in_bool
&& node instanceof AST_Constant
&& !node.getValue()
|| (node instanceof AST_UnaryPrefix
&& node.operator == "!"
&& node.expression instanceof AST_Constant
&& node.expression.getValue());
}
|
javascript
|
{
"resource": ""
}
|
q5252
|
train
|
function (tag) {
if (voidElements.indexOf(tag.name) < 0) {
reporter.warn(
tag.pos,
'035',
'Tag ' + tag.name + ' is not paired.'
);
}
}
|
javascript
|
{
"resource": ""
}
|
|
q5253
|
concatenateBinaryExpression
|
train
|
function concatenateBinaryExpression( ASTNode ) {
var result;
if ( ASTNode.operator !== '+' ) {
return false;
}
result = ( 'StringLiteral' === ASTNode.left.type ) ? ASTNode.left.value : concatenateBinaryExpression( ASTNode.left );
result += ( 'StringLiteral' === ASTNode.right.type ) ? ASTNode.right.value : concatenateBinaryExpression( ASTNode.right );
return result;
}
|
javascript
|
{
"resource": ""
}
|
q5254
|
language
|
train
|
function language(node) {
var className = node.properties.className || []
var length = className.length
var index = -1
var value
while (++index < length) {
value = className[index]
if (value === 'no-highlight' || value === 'nohighlight') {
return false
}
if (value.slice(0, 5) === 'lang-') {
return value.slice(5)
}
if (value.slice(0, 9) === 'language-') {
return value.slice(9)
}
}
return null
}
|
javascript
|
{
"resource": ""
}
|
q5255
|
getChildRsql
|
train
|
function getChildRsql (perhapsWrap, constraint) {
const rsql = getRsqlFromConstraint(constraint)
if (constraint.operands && constraint.operands.length === 1) {
// Skip this node, render the only child node
return getChildRsql(perhapsWrap, constraint.operands[0])
}
if (perhapsWrap && constraint.operator === 'OR') {
if (constraint.operands.length > 1) {
return `(${rsql})`
}
}
return rsql
}
|
javascript
|
{
"resource": ""
}
|
q5256
|
build
|
train
|
function build (config) {
return new Promise((resolve, reject) => {
const compiler = webpack(Object.assign(config, {
output: { filename: 'file' },
plugins: [
new webpack.DefinePlugin({
'process.env.NODE_ENV': '"production"',
'process.browser': true
})
]
}), (err, stats) => {
if (err || stats.hasErrors()) reject(err || new Error(stats.toString('errors-only')))
const compilation = stats.compilation
const compiler = compilation.compiler
const memoryFs = compiler.outputFileSystem
const outputFile = compilation.assets.file.existsAt
resolve(memoryFs.readFileSync(outputFile, 'utf8'))
})
compiler.outputFileSystem = new MemoryFs()
})
}
|
javascript
|
{
"resource": ""
}
|
q5257
|
loadPaths
|
train
|
function loadPaths (pkg) {
const name = pkg.name
const file = pkg.path
return resolveFile(tmp, path.join(name, file)).then(entry => ({
entry: entry,
package: path.join(tmp, 'node_modules', name, 'package.json')
}))
}
|
javascript
|
{
"resource": ""
}
|
q5258
|
resolveFile
|
train
|
function resolveFile (dir, file) {
return new Promise((resolve, reject) => {
resolver.resolve({}, dir, file, (err, result) => {
if (err) reject(err)
else resolve(result)
})
})
}
|
javascript
|
{
"resource": ""
}
|
q5259
|
formatNumber
|
train
|
function formatNumber(number) {
number = String(number).split('.');
return number[0].replace(/(?=(?:\d{3})+$)(?!\b)/g, ',') +
(number[1] ? '.' + number[1] : '');
}
|
javascript
|
{
"resource": ""
}
|
q5260
|
formatResult
|
train
|
function formatResult(event, times) {
var hz = event.hz * times;
var stats = event.stats;
var size = stats.sample.length;
var pm = '\xb1';
var result = " (array length " + times + ")";
result += ' x ' + chalk.cyan(formatNumber(hz.toFixed(hz < 100 ? 2 : 0))) + ' ops/sec ' + pm +
stats.rme.toFixed(2) + '% (' + size + ' run' + (size == 1 ? '' : 's') + ' sampled)';
return result;
}
|
javascript
|
{
"resource": ""
}
|
q5261
|
createAttribute
|
train
|
function createAttribute(name, value, isAttribute) {
if (properties.hasOwnProperty(name)) {
if (shouldSkip(name, value)) return '';
name = (attributeNames[name] || name).toLowerCase();
var attrType = properties[name];
// for BOOLEAN `value` only has to be truthy
// for OVERLOADED_BOOLEAN `value` has to be === true
if ((attrType === types.BOOLEAN) ||
(attrType === types.OVERLOADED_BOOLEAN && value === true)) {
return escape(name);
}
return prefixAttribute(name) + escape(value) + '"';
} else if (isAttribute) {
if (value == null) return '';
return prefixAttribute(name) + escape(value) + '"';
}
// return null if `name` is neither a valid property nor an attribute
return null;
}
|
javascript
|
{
"resource": ""
}
|
q5262
|
shouldSkip
|
train
|
function shouldSkip(name, value) {
var attrType = properties[name];
return value == null ||
(attrType === types.BOOLEAN && !value) ||
(attrType === types.OVERLOADED_BOOLEAN && value === false);
}
|
javascript
|
{
"resource": ""
}
|
q5263
|
round
|
train
|
function round() {
i++
var shasum = Crypto.createHash('sha512')
shasum.update(out, 'utf8')
out = shasum.digest('hex')
if (rounds <= i) {
return done(out)
}
if (0 === i % 88) {
return process.nextTick(round)
}
round()
}
|
javascript
|
{
"resource": ""
}
|
q5264
|
checkemail
|
train
|
function checkemail(next) {
if (user.email) {
userent.load$({ email: user.email }, function(err, userfound) {
if (err) return done(err, { ok: false, user: user })
if (userfound)
return done(null, {
ok: false,
why: 'email-exists',
nick: args.nick
})
next()
})
return
}
next()
}
|
javascript
|
{
"resource": ""
}
|
q5265
|
checknick
|
train
|
function checknick(next) {
if (args.nick) {
userent.list$({ nick: args.nick }, function(err, users) {
if (err) return done(err, { ok: false, user: user })
for (var i = 0; i < users.length; i++) {
var each = users[i]
if (each.id !== user.id) {
return done(null, {
ok: false,
why: 'nick-exists',
nick: args.nick
})
}
}
next()
})
return
}
next()
}
|
javascript
|
{
"resource": ""
}
|
q5266
|
cmd_clean
|
train
|
function cmd_clean(args, done) {
var user = args.user.data$()
delete user.pass
delete user.salt
delete user.active
delete user.$
done(null, user)
}
|
javascript
|
{
"resource": ""
}
|
q5267
|
train
|
function (namespace) {
var nsparts = namespace.split(".");
var parent = module.scope.MeadCo;
// we want to be able to include or exclude the root namespace so we strip
// it if it's in the namespace
if (nsparts[0] === "MeadCo") {
nsparts = nsparts.slice(1);
}
// loop through the parts and create a nested namespace if necessary
for (var i = 0; i < nsparts.length; i++) {
var partname = nsparts[i];
// check if the current parent already has the namespace declared
// if it isn't, then create it
if (typeof parent[partname] === "undefined") {
parent[partname] = {};
}
// get a reference to the deepest element in the hierarchy so far
parent = parent[partname];
}
// the parent is now constructed with empty namespaces and can be used.
// we return the outermost namespace
return parent;
}
|
javascript
|
{
"resource": ""
}
|
|
q5268
|
train
|
function (serverUrl, apiLocation) {
// check if given partial ...
var p = serverUrl.indexOf("/api");
if (p === -1) {
if (serverUrl.lastIndexOf("/") !== (serverUrl.length - 1)) {
serverUrl += "/";
}
serverUrl += "api/" + apiLocation;
}
else {
// given another api, chop and replace with requested api
serverUrl = serverUrl.substr(0, p) + "/api/" + apiLocation;
}
return serverUrl;
}
|
javascript
|
{
"resource": ""
}
|
|
q5269
|
showPrinterSettings
|
train
|
function showPrinterSettings() {
fillAndSetBinsList();
var $dlg = $('#dlg-printersettings');
var printer = MeadCo.ScriptX.Printing;
$dlg.find('#fld-collate').prop('checked', printer.collate);
$dlg.find('#fld-copies').val(printer.copies);
}
|
javascript
|
{
"resource": ""
}
|
q5270
|
fillPrintersList
|
train
|
function fillPrintersList() {
var printer = MeadCo.ScriptX.Printing;
var $printers = $('#fld-printerselect');
$('#fld-printerselect > option').remove();
var name;
for (var i = 0; (name = printer.EnumPrinters(i)).length > 0 ; i++) {
$printers.append("<option>" + name);
}
$printers.val(printer.currentPrinter);
if ($printers.hasClass("selectpicker")) {
$printers.selectpicker('refresh');
}
}
|
javascript
|
{
"resource": ""
}
|
q5271
|
concatMiddlewareNames
|
train
|
function concatMiddlewareNames(routes) {
var output = [];
// Concat each route's middleware names
for (var i = 0; i < routes.length; i++) {
output = output.concat(
getMiddlewareNames(routes[i])
);
}
return output;
}
|
javascript
|
{
"resource": ""
}
|
q5272
|
getMiddlewareNames
|
train
|
function getMiddlewareNames(route) {
var middleware = getRouteMiddleware(route);
// If the middleware is an array, just return it
if ( middleware instanceof Array ) {
return middleware;
}
// If there is no middleware, then return an empty array
if ( typeof middleware === 'undefined' ) {
return [];
}
// Otherwise, split the pipes & return an array
return middleware.split('|');
}
|
javascript
|
{
"resource": ""
}
|
q5273
|
nextMiddleware
|
train
|
function nextMiddleware() {
// Get the next middleware
var next = _mappings[middleware.names[middleware.index++]];
// If there is middleware, then invoke it, binding request
if ( next ) $injector.invoke(next, request);
}
|
javascript
|
{
"resource": ""
}
|
q5274
|
nextRequest
|
train
|
function nextRequest() {
// If there are no more middleware,
// then resolve the middleware resolution
if ( middleware.index == middleware.names.length ) {
middleware.resolution.resolve();
}
// Attempt to invoke the next middleware
middleware.next();
}
|
javascript
|
{
"resource": ""
}
|
q5275
|
redirectTo
|
train
|
function redirectTo(route, params, options) {
middleware.resolution.reject({
type: "redirectTo",
route: route,
params: params,
options: options
});
}
|
javascript
|
{
"resource": ""
}
|
q5276
|
train
|
function (mergeSelector) {
if (this.tag !== mergeSelector.tag) {
throw "different element selected (tag)";
}
if (this.index !== null) {
if (this.index !== mergeSelector.index) {
// use indexn only for two elements
if (this.indexn === null) {
var indexn = Math.min(mergeSelector.index, this.index);
if (indexn > 1) {
this.indexn = Math.min(mergeSelector.index, this.index);
}
}
else {
this.indexn = -1;
}
this.index = null;
}
}
if(this.isDirectChild === true) {
this.isDirectChild = mergeSelector.isDirectChild;
}
if (this.id !== null) {
if (this.id !== mergeSelector.id) {
this.id = null;
}
}
if (this.classes.length !== 0) {
var classes = new Array();
for (var i in this.classes) {
var cclass = this.classes[i];
if (mergeSelector.classes.indexOf(cclass) !== -1) {
classes.push(cclass);
}
}
this.classes = classes;
}
}
|
javascript
|
{
"resource": ""
}
|
|
q5277
|
train
|
function(element1, element2) {
while (true) {
if(element1.tagName !== element2.tagName) {
return false;
}
if(element1 === element2) {
return true;
}
// stop at body tag
if (element1 === undefined || element1.tagName === 'body'
|| element1.tagName === 'BODY') {
return false;
}
if (element2 === undefined || element2.tagName === 'body'
|| element2.tagName === 'BODY') {
return false;
}
element1 = element1.parentNode;
element2 = element2.parentNode;
}
}
|
javascript
|
{
"resource": ""
}
|
|
q5278
|
train
|
function(elements) {
// first elment is in the first group
// @TODO maybe i dont need this?
var groups = [[elements[0]]];
for(var i = 1; i < elements.length; i++) {
var elementNew = elements[i];
var addedToGroup = false;
for(var j = 0; j < groups.length; j++) {
var group = groups[j];
var elementGroup = group[0];
if(this.checkSimilarElements(elementNew, elementGroup)) {
group.push(elementNew);
addedToGroup = true;
break;
}
}
// add new group
if(!addedToGroup) {
groups.push([elementNew]);
}
}
return groups;
}
|
javascript
|
{
"resource": ""
}
|
|
q5279
|
primitive
|
train
|
function primitive (data) {
var type;
switch (data) {
case null:
case undefined:
case false:
case true:
return true;
}
type = typeof data;
return type === 'string' || type === 'number' || (haveSymbols && type === 'symbol');
}
|
javascript
|
{
"resource": ""
}
|
q5280
|
between
|
train
|
function between (data, x, y) {
if (x < y) {
return greater(data, x) && data < y;
}
return less(data, x) && data > y;
}
|
javascript
|
{
"resource": ""
}
|
q5281
|
inRange
|
train
|
function inRange (data, x, y) {
if (x < y) {
return greaterOrEqual(data, x) && data <= y;
}
return lessOrEqual(data, x) && data >= y;
}
|
javascript
|
{
"resource": ""
}
|
q5282
|
instance
|
train
|
function instance (data, prototype) {
try {
return instanceStrict(data, prototype) ||
data.constructor.name === prototype.name ||
Object.prototype.toString.call(data) === '[object ' + prototype.name + ']';
} catch (error) {
return false;
}
}
|
javascript
|
{
"resource": ""
}
|
q5283
|
like
|
train
|
function like (data, archetype) {
var name;
for (name in archetype) {
if (archetype.hasOwnProperty(name)) {
if (data.hasOwnProperty(name) === false || typeof data[name] !== typeof archetype[name]) {
return false;
}
if (object(data[name]) && like(data[name], archetype[name]) === false) {
return false;
}
}
}
return true;
}
|
javascript
|
{
"resource": ""
}
|
q5284
|
iterable
|
train
|
function iterable (data) {
if (! haveSymbols) {
// Fall back to `arrayLike` predicate in pre-ES6 environments.
return arrayLike(data);
}
return assigned(data) && isFunction(data[Symbol.iterator]);
}
|
javascript
|
{
"resource": ""
}
|
q5285
|
includes
|
train
|
function includes (data, value) {
var iterator, iteration, keys, length, i;
if (! assigned(data)) {
return false;
}
if (haveSymbols && data[Symbol.iterator] && isFunction(data.values)) {
iterator = data.values();
do {
iteration = iterator.next();
if (iteration.value === value) {
return true;
}
} while (! iteration.done);
return false;
}
keys = Object.keys(data);
length = keys.length;
for (i = 0; i < length; ++i) {
if (data[keys[i]] === value) {
return true;
}
}
return false;
}
|
javascript
|
{
"resource": ""
}
|
q5286
|
apply
|
train
|
function apply (data, predicates) {
assert.array(data);
if (isFunction(predicates)) {
return data.map(function (value) {
return predicates(value);
});
}
assert.array(predicates);
assert.hasLength(data, predicates.length);
return data.map(function (value, index) {
return predicates[index](value);
});
}
|
javascript
|
{
"resource": ""
}
|
q5287
|
map
|
train
|
function map (data, predicates) {
assert.object(data);
if (isFunction(predicates)) {
return mapSimple(data, predicates);
}
assert.object(predicates);
return mapComplex(data, predicates);
}
|
javascript
|
{
"resource": ""
}
|
q5288
|
all
|
train
|
function all (data) {
if (array(data)) {
return testArray(data, false);
}
assert.object(data);
return testObject(data, false);
}
|
javascript
|
{
"resource": ""
}
|
q5289
|
any
|
train
|
function any (data) {
if (array(data)) {
return testArray(data, true);
}
assert.object(data);
return testObject(data, true);
}
|
javascript
|
{
"resource": ""
}
|
q5290
|
notModifier
|
train
|
function notModifier (predicate) {
var modifiedPredicate = function () {
return notImpl(predicate.apply(null, arguments));
};
modifiedPredicate.l = predicate.length;
return modifiedPredicate;
}
|
javascript
|
{
"resource": ""
}
|
q5291
|
ofModifier
|
train
|
function ofModifier (target, type, predicate) {
var modifiedPredicate = function () {
var collection, args;
collection = arguments[0];
if (target === 'maybe' && not.assigned(collection)) {
return true;
}
if (!type(collection)) {
return false;
}
collection = coerceCollection(type, collection);
args = slice.call(arguments, 1);
try {
collection.forEach(function (item) {
if (
(target !== 'maybe' || assigned(item)) &&
!predicate.apply(null, [ item ].concat(args))
) {
// TODO: Replace with for...of when ES6 is required.
throw 0;
}
});
} catch (ignore) {
return false;
}
return true;
};
modifiedPredicate.l = predicate.length;
return modifiedPredicate;
}
|
javascript
|
{
"resource": ""
}
|
q5292
|
createBodystructure
|
train
|
function createBodystructure(tree, options) {
options = options || {};
var walker = function(node) {
switch((node.parsedHeader['content-type'] || {}).type) {
case 'multipart':
return processMultipartNode(node, options);
case 'text':
return processTextNode(node, options);
case 'message':
if (!options.attachmentRFC822) {
return processRFC822Node(node, options);
}
return processAttachmentNode(node, options);
default:
return processAttachmentNode(node, options);
}
};
return walker(tree);
}
|
javascript
|
{
"resource": ""
}
|
q5293
|
getBasicFields
|
train
|
function getBasicFields(node, options) {
var bodyType = node.parsedHeader['content-type'] && node.parsedHeader['content-type'].type || null,
bodySubtype = node.parsedHeader['content-type'] && node.parsedHeader['content-type'].subtype || null,
contentTransfer = node.parsedHeader['content-transfer-encoding'] || '7bit';
return [
// body type
options.upperCaseKeys ? bodyType && bodyType.toUpperCase() || null : bodyType,
// body subtype
options.upperCaseKeys ? bodySubtype && bodySubtype.toUpperCase() || null : bodySubtype,
// body parameter parenthesized list
node.parsedHeader['content-type'] &&
node.parsedHeader['content-type'].hasParams &&
flatten(Object.keys(node.parsedHeader['content-type'].params).map(function(key) {
return [
options.upperCaseKeys ? key.toUpperCase() : key,
node.parsedHeader['content-type'].params[key]];
})) || null,
// body id
node.parsedHeader['content-id'] || null,
// body description
node.parsedHeader['content-description'] || null,
// body encoding
options.upperCaseKeys ? contentTransfer && contentTransfer.toUpperCase() || '7bit' : contentTransfer,
// body size
node.size
];
}
|
javascript
|
{
"resource": ""
}
|
q5294
|
getExtensionFields
|
train
|
function getExtensionFields(node, options) {
options = options || {};
var languageString = node.parsedHeader['content-language'] &&
node.parsedHeader['content-language'].replace(/[ ,]+/g, ',').replace(/^,+|,+$/g, ''),
language = languageString && languageString.split(',') || null,
data;
// if `contentLanguageString` is true, then use a string instead of single element array
if (language && language.length == 1 && options.contentLanguageString) {
language = language[0];
}
data = [
// body MD5
node.parsedHeader['content-md5'] || null,
// body disposition
node.parsedHeader['content-disposition'] && [
options.upperCaseKeys ?
node.parsedHeader['content-disposition'].value.toUpperCase() :
node.parsedHeader['content-disposition'].value,
node.parsedHeader['content-disposition'].params &&
node.parsedHeader['content-disposition'].hasParams &&
flatten(Object.keys(node.parsedHeader['content-disposition'].params).map(function(key) {
return [
options.upperCaseKeys ? key.toUpperCase() : key,
node.parsedHeader['content-disposition'].params[key]];
})) || null
] || null,
// body language
language
];
// if `skipContentLocation` is true, do not include Content-Location in output
//
// NB! RFC3501 has an errata with content-location type, it is described as
// 'A string list' (eg. an array) in RFC but the errata page states
// that it is a string (http://www.rfc-editor.org/errata_search.php?rfc=3501)
// see note for 'Section 7.4.2, page 75'
if (!options.skipContentLocation) {
// body location
data.push(node.parsedHeader['content-location'] || null);
}
return data;
}
|
javascript
|
{
"resource": ""
}
|
q5295
|
processAttachmentNode
|
train
|
function processAttachmentNode(node, options) {
options = options || {};
var data = [].concat(getBasicFields(node, options));
if (!options.body) {
data = data.concat(getExtensionFields(node, options));
}
data.node = node;
return data;
}
|
javascript
|
{
"resource": ""
}
|
q5296
|
train
|
function (key, config) {
var props = key.split(',');
this._cfg = {
key: key,
properties: props,
name: config.name || camelize(props.join('_')),
toGoogle: config.toGoogle || null,
fromGoogle: config.fromGoogle || null,
read: config.read || null,
write: config.write || null,
event: config.event || null,
cast: config.cast || null,
readOnly: config.readOnly || false,
optionOnly: config.optionOnly || false
};
}
|
javascript
|
{
"resource": ""
}
|
|
q5297
|
train
|
function(callback) {
// If it's a webhook, delegate off
if(method.type === 'webhook') {
return RunUtil.runWebhook(grunt, options, method, callback);
}
// Otherwise, run the method
runner.run(method.slug, 'run', { input: filteredInputs }, callback);
}
|
javascript
|
{
"resource": ""
}
|
|
q5298
|
train
|
function(r, callback) {
result = r || {};
RunUtil.displayScriptData(grunt, result);
RunUtil.displayScriptOutput(grunt, outputs, result);
try {
RunUtil.checkRunScriptResult(result, method);
} catch(e) {
CommonUtil.header(grunt, 'VALIDATION:', 'red');
grunt.fail.fatal(e);
}
callback();
}
|
javascript
|
{
"resource": ""
}
|
|
q5299
|
train
|
function(userScript, callback) {
// If it's a run script, do some inputs
script = userScript;
if((userScript === 'run' || userScript === 'output') &&
(method.fields.input || method.scripts.input)) {
var inputs = (method.fields && method.fields.input) || [];
RunUtil.harvestInputs(grunt, runner, method, inputs, callback);
} else {
callback(null, []);
}
}
|
javascript
|
{
"resource": ""
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.