_id stringlengths 2 6 | title stringlengths 0 58 | partition stringclasses 3 values | text stringlengths 52 373k | language stringclasses 1 value | meta_information dict |
|---|---|---|---|---|---|
q42300 | processElement | train | function processElement( that, element, toBeRemoved, opts ) {
var status,
retVal = 0,
callbacksRetVal;
// Unprotect elements names previously protected by htmlDataProcessor
// (see protectElementNames and protectSelfClosingElements functions).
// Note: body, title, etc. are not protected by htmlDataP (or are protected and then unprotected).
if ( opts.toHtml )
element.name = element.name.replace( unprotectElementsNamesRegexp, '$1' );
// Execute element callbacks and return if one of them returned any value.
if ( opts.doCallbacks && that.elementCallbacks ) {
// For now we only support here FILTER_SKIP_TREE, so we can early return if retVal is truly value.
if ( ( callbacksRetVal = executeElementCallbacks( element, that.elementCallbacks ) ) )
return callbacksRetVal;
}
// If transformations are set apply all groups.
if ( opts.doTransform )
transformElement( that, element );
if ( opts.doFilter ) {
// Apply all filters.
status = filterElement( that, element, opts );
// Handle early return from filterElement.
if ( !status ) {
toBeRemoved.push( element );
return FILTER_ELEMENT_MODIFIED;
}
// Finally, if after running all filter rules it still hasn't been allowed - remove it.
if ( !status.valid ) {
toBeRemoved.push( element );
return FILTER_ELEMENT_MODIFIED;
}
// Update element's attributes based on status of filtering.
if ( updateElement( element, status ) )
retVal = FILTER_ELEMENT_MODIFIED;
if ( !opts.skipFinalValidation && !validateElement( element ) ) {
toBeRemoved.push( element );
return FILTER_ELEMENT_MODIFIED;
}
}
// Protect previously unprotected elements.
if ( opts.toHtml )
element.name = element.name.replace( protectElementsNamesRegexp, 'cke:$1' );
return retVal;
} | javascript | {
"resource": ""
} |
q42301 | regexifyPropertiesWithWildcards | train | function regexifyPropertiesWithWildcards( validators ) {
var patterns = [],
i;
for ( i in validators ) {
if ( i.indexOf( '*' ) > -1 )
patterns.push( i.replace( /\*/g, '.*' ) );
}
if ( patterns.length )
return new RegExp( '^(?:' + patterns.join( '|' ) + ')$' );
else
return null;
} | javascript | {
"resource": ""
} |
q42302 | standardizeRule | train | function standardizeRule( rule ) {
rule.elements = convertValidatorToHash( rule.elements, /\s+/ ) || null;
rule.propertiesOnly = rule.propertiesOnly || ( rule.elements === true );
var delim = /\s*,\s*/,
i;
for ( i in validators ) {
rule[ i ] = convertValidatorToHash( rule[ i ], delim ) || null;
rule[ validatorsRequired[ i ] ] = extractRequired( convertValidatorToHash(
rule[ validatorsRequired[ i ] ], delim ), rule[ i ] ) || null;
}
rule.match = rule.match || null;
} | javascript | {
"resource": ""
} |
q42303 | transformElement | train | function transformElement( that, element ) {
var transformations = that._.transformations[ element.name ],
i;
if ( !transformations )
return;
populateProperties( element );
for ( i = 0; i < transformations.length; ++i )
applyTransformationsGroup( that, element, transformations[ i ] );
// Do not count on updateElement() which is called in processElement, because it:
// * may not be called,
// * may skip some properties when all are marked as valid.
updateAttributes( element );
} | javascript | {
"resource": ""
} |
q42304 | updateAttributes | train | function updateAttributes( element ) {
var attrs = element.attributes,
styles;
// Will be recreated later if any of styles/classes exists.
delete attrs.style;
delete attrs[ 'class' ];
if ( ( styles = CKEDITOR.tools.writeCssText( element.styles, true ) ) )
attrs.style = styles;
if ( element.classes.length )
attrs[ 'class' ] = element.classes.sort().join( ' ' );
} | javascript | {
"resource": ""
} |
q42305 | updateElement | train | function updateElement( element, status ) {
var validAttrs = status.validAttributes,
validStyles = status.validStyles,
validClasses = status.validClasses,
attrs = element.attributes,
styles = element.styles,
classes = element.classes,
origClasses = element.classBackup,
origStyles = element.styleBackup,
name, origName, i,
stylesArr = [],
classesArr = [],
internalAttr = /^data-cke-/,
isModified = false;
// Will be recreated later if any of styles/classes were passed.
delete attrs.style;
delete attrs[ 'class' ];
// Clean up.
delete element.classBackup;
delete element.styleBackup;
if ( !status.allAttributes ) {
for ( name in attrs ) {
// If not valid and not internal attribute delete it.
if ( !validAttrs[ name ] ) {
// Allow all internal attibutes...
if ( internalAttr.test( name ) ) {
// ... unless this is a saved attribute and the original one isn't allowed.
if ( name != ( origName = name.replace( /^data-cke-saved-/, '' ) ) &&
!validAttrs[ origName ]
) {
delete attrs[ name ];
isModified = true;
}
} else {
delete attrs[ name ];
isModified = true;
}
}
}
}
if ( !status.allStyles || status.hadInvalidStyle ) {
for ( name in styles ) {
// We check status.allStyles because when there was a '*' ACR and some
// DACR we have now both properties true - status.allStyles and status.hadInvalidStyle.
// However unlike in the case when we only have '*' ACR, in which we can just copy original
// styles, in this case we must copy only those styles which were not removed by DACRs.
if ( status.allStyles || validStyles[ name ] )
stylesArr.push( name + ':' + styles[ name ] );
else
isModified = true;
}
if ( stylesArr.length )
attrs.style = stylesArr.sort().join( '; ' );
}
else if ( origStyles ) {
attrs.style = origStyles;
}
if ( !status.allClasses || status.hadInvalidClass ) {
for ( i = 0; i < classes.length; ++i ) {
// See comment for styles.
if ( status.allClasses || validClasses[ classes[ i ] ] )
classesArr.push( classes[ i ] );
}
if ( classesArr.length )
attrs[ 'class' ] = classesArr.sort().join( ' ' );
if ( origClasses && classesArr.length < origClasses.split( /\s+/ ).length )
isModified = true;
}
else if ( origClasses ) {
attrs[ 'class' ] = origClasses;
}
return isModified;
} | javascript | {
"resource": ""
} |
q42306 | inlineNode | train | function inlineNode( node ) {
return node.type == CKEDITOR.NODE_TEXT ||
node.type == CKEDITOR.NODE_ELEMENT && DTD.$inline[ node.name ];
} | javascript | {
"resource": ""
} |
q42307 | removeElement | train | function removeElement( element, enterTag, toBeChecked ) {
var name = element.name;
if ( DTD.$empty[ name ] || !element.children.length ) {
// Special case - hr in br mode should be replaced with br, not removed.
if ( name == 'hr' && enterTag == 'br' )
element.replaceWith( createBr() );
else {
// Parent might become an empty inline specified in $removeEmpty or empty a[href].
if ( element.parent )
toBeChecked.push( { check: 'it', el: element.parent } );
element.remove();
}
} else if ( DTD.$block[ name ] || name == 'tr' ) {
if ( enterTag == 'br' )
stripBlockBr( element, toBeChecked );
else
stripBlock( element, enterTag, toBeChecked );
}
// Special case - elements that may contain CDATA
// should be removed completely. <script> is handled
// by processProtectedElement().
else if ( name == 'style' )
element.remove();
// The rest of inline elements. May also be the last resort
// for some special elements.
else {
// Parent might become an empty inline specified in $removeEmpty or empty a[href].
if ( element.parent )
toBeChecked.push( { check: 'it', el: element.parent } );
element.replaceWithChildren();
}
} | javascript | {
"resource": ""
} |
q42308 | stripBlock | train | function stripBlock( element, enterTag, toBeChecked ) {
var children = element.children;
// First, check if element's children may be wrapped with <p/div>.
// Ignore that <p/div> may not be allowed in element.parent.
// This will be fixed when removing parent or by toBeChecked rule.
if ( checkChildren( children, enterTag ) ) {
element.name = enterTag;
element.attributes = {};
// Check if this p/div was put in correct context.
// If not - strip parent.
toBeChecked.push( { check: 'parent-down', el: element } );
return;
}
var parent = element.parent,
shouldAutoP = parent.type == CKEDITOR.NODE_DOCUMENT_FRAGMENT || parent.name == 'body',
i, child, p;
for ( i = children.length; i > 0; ) {
child = children[ --i ];
// If parent requires auto paragraphing and child is inline node,
// insert this child into newly created paragraph.
if ( shouldAutoP && inlineNode( child ) ) {
if ( !p ) {
p = new CKEDITOR.htmlParser.element( enterTag );
p.insertAfter( element );
// Check if this p/div was put in correct context.
// If not - strip parent.
toBeChecked.push( { check: 'parent-down', el: p } );
}
p.add( child, 0 );
}
// Child which doesn't need to be auto paragraphed.
else {
p = null;
child.insertAfter( element );
// If inserted into invalid context, mark it and check
// after removing all elements.
if ( parent.type != CKEDITOR.NODE_DOCUMENT_FRAGMENT &&
child.type == CKEDITOR.NODE_ELEMENT &&
!DTD[ parent.name ][ child.name ]
)
toBeChecked.push( { check: 'el-up', el: child } );
}
}
// All children have been moved to element's parent, so remove it.
element.remove();
} | javascript | {
"resource": ""
} |
q42309 | getContentFormTransformationGroup | train | function getContentFormTransformationGroup( form, preferredForm ) {
var element, left;
if ( typeof form == 'string' )
element = form;
else if ( form instanceof CKEDITOR.style )
left = form;
else {
element = form[ 0 ];
left = form[ 1 ];
}
return [ {
element: element,
left: left,
right: function( el, tools ) {
tools.transform( el, preferredForm );
}
} ];
} | javascript | {
"resource": ""
} |
q42310 | train | function( element ) {
if ( !( 'float' in element.styles ) ) {
var value = element.attributes.align;
if ( value == 'left' || value == 'right' )
element.styles[ 'float' ] = value; // Uh... GCC doesn't like the 'float' prop name.
}
delete element.attributes.align;
} | javascript | {
"resource": ""
} | |
q42311 | train | function( el, form ) {
if ( typeof form == 'string' )
el.name = form;
// Form is an instance of CKEDITOR.style.
else {
var def = form.getDefinition(),
defStyles = def.styles,
defAttrs = def.attributes,
attrName, styleName,
existingClassesPattern, defClasses, cl;
el.name = def.element;
for ( attrName in defAttrs ) {
if ( attrName == 'class' ) {
existingClassesPattern = el.classes.join( '|' );
defClasses = defAttrs[ attrName ].split( /\s+/ );
while ( ( cl = defClasses.pop() ) ) {
if ( existingClassesPattern.indexOf( cl ) == -1 )
el.classes.push( cl );
}
} else {
el.attributes[ attrName ] = defAttrs[ attrName ];
}
}
for ( styleName in defStyles ) {
el.styles[ styleName ] = defStyles[ styleName ];
}
}
} | javascript | {
"resource": ""
} | |
q42312 | RouteManager | train | function RouteManager(opts) {
var defaultActions = {
// Encapsulation of the next callback in express routes
next: function(req, res, next) {
next();
},
// Render view
render: function (req, res, next, data) {
res.render(data.render.viewPath, data.render.viewData);
},
// Send back json
json: function (req, res, next, data) {
res.send(data.json);
},
// Redirect to URL
redirect: function (req, res, next, data) {
res.redirect(data.redirect);
}
};
// Default authenticated function
var defaultAuthenticated = function (req, res, next) {
console.warn('No authentication function setup');
next();
};
// This function should return a express route function.
var defaultCheckRole = function (role) {
return function (req, res, next) {
console.warn('No check role function setup');
next();
};
};
opts = opts || {};
this._app = opts.app;
this._customActions = defaultActions;
this._authenticated = opts.authenticated || defaultAuthenticated;
this._checkRole = opts.checkRole || defaultCheckRole;
if(opts.actions) {
_.merge(this._customActions, opts.actions);
}
} | javascript | {
"resource": ""
} |
q42313 | train | function(message) {
var identifier = _makeIdentifier(message);
if (typeof _filter[identifier] !== 'undefined' && _filter[identifier] < ((+new Date()) + 10 * 60000)) {
console.error('duplicated error', identifier, message);
return _filter[identifier];
}
_filter[identifier] = +new Date();
return false;
} | javascript | {
"resource": ""
} | |
q42314 | findWriteStream | train | function findWriteStream(arg, copy) {
if (copy.proto !== 'ReadableState') return null
if (copy.pipes != null && copy.pipes.proto !== 'WriteStream') return null
return arg.pipes
} | javascript | {
"resource": ""
} |
q42315 | parse | train | function parse(str, arr) {
return str.replace(/\.\w+|"[^"]*"|'[^']*'|\/([^/]+)\/|[a-zA-Z_]\w*/g, function(expr) {
if(forbidden.indexOf(expr[0]) > -1) return expr;
if(!~arr.indexOf(expr)) arr.push(expr);
return 'model.' + expr;
});
} | javascript | {
"resource": ""
} |
q42316 | handleYield | train | function handleYield(forms) {
var yieldType = sl.valueOf(forms[0]); // "yield" or "yield*"
if (forms.length != 2) {
forms.error(yieldType + " expects a single expression");
}
this.indent += this.indentSize;
this.transpileSubExpressions(forms);
var generated = sl.generated();
generated.push([yieldType, " ", forms[1]]);
this.indent -= this.indentSize;
return generated;
} | javascript | {
"resource": ""
} |
q42317 | train | function(forms) {
if (forms.length < 2) {
forms.error("missing argument for operator");
}
if(forms.length > 2) {
// it's a normal binary (or more) minus
return handleArithOperator.call(this, forms);
}
// it's a unary minus
this.transpileSubExpressions(forms)
var generated = sl.generated()
generated.push(["-", sl.valueOf(forms[1])]);
generated.callable = false;
return generated;
} | javascript | {
"resource": ""
} | |
q42318 | startService | train | function startService() {
let me = this;
return server.start(me, function(err) {
if (err) {
return out.error("service failed to start: %j", err);
}
return server.ping(me, function() {
out.success("service started");
});
});
} | javascript | {
"resource": ""
} |
q42319 | stopService | train | function stopService() {
return server.stop(this, function(err) {
if (err) {
return out.error("service did not respond well: %j", err);
}
return out.success("service stopped");
});
} | javascript | {
"resource": ""
} |
q42320 | checkStatus | train | function checkStatus() {
return server.ping(this, function(err, res) {
if (err) {
return out.error("error occurred: %j", err);
}
if (res.running) {
return out.success("service running");
}
return out.error("service not running");
});
} | javascript | {
"resource": ""
} |
q42321 | commonDir | train | function commonDir (files) {
return files
.map(path.dirname)
.map(function (dir) {
return dir.split(path.sep)
})
.reduce(commonSequence)
.concat([''])
.join(path.sep)
} | javascript | {
"resource": ""
} |
q42322 | train | function (fn, context) {
var obj = this,
keys = Object.keys(obj),
l = keys.length,
i = -1,
key;
while (++i < l) {
key = keys[i];
fn.call(context || obj, obj[key], key, obj);
}
return obj;
} | javascript | {
"resource": ""
} | |
q42323 | train | function (descriptors) {
var instance = this,
m = Object.create(Object.getPrototypeOf(instance)),
keys = Object.getOwnPropertyNames(instance),
l = keys.length,
i = -1,
key, propDescriptor;
while (++i < l) {
key = keys[i];
if (descriptors) {
propDescriptor = Object.getOwnPropertyDescriptor(instance, key);
if (!propDescriptor.writable) {
m[key] = instance[key];
}
else {
Object.defineProperty(m, key, propDescriptor);
}
}
else {
m[key] = instance[key];
}
}
return m;
} | javascript | {
"resource": ""
} | |
q42324 | train | function(refObj) {
var instance = this,
keys = Object.getOwnPropertyNames(instance),
l = keys.length,
i = -1,
same, key;
same = (l===refObj.itsa_size(true));
// loop through the members:
while (same && (++i < l)) {
key = keys[i];
same = refObj.hasOwnProperty(key) ? valuesAreTheSame(instance[key], refObj[key]) : false;
}
return same;
} | javascript | {
"resource": ""
} | |
q42325 | train | function (obj, options) {
var instance = this,
i = -1,
deepForce, keys, l, key, force, replace, descriptors, propDescriptor;
if (!Object.itsa_isObject(obj)) {
return instance;
}
options || (options={});
keys = options.full ? Object.getOwnPropertyNames(obj) : Object.keys(obj);
l = keys.length;
force = options.force;
deepForce = (force==="deep");
replace = options.replace;
descriptors = options.descriptors;
// we cannot use obj.each --> obj might be an object defined through Object.create(null) and missing Object.prototype!
while (++i < l) {
key = keys[i];
if ((force && !replace) || (!replace && !(key in instance)) || (replace && (key in instance))) {
if (deepForce && Object.itsa_isObject(instance[key]) && Object.itsa_isObject(obj[key])) {
instance[key].itsa_merge(obj[key], options);
}
else {
if (descriptors) {
propDescriptor = Object.getOwnPropertyDescriptor(obj, key);
if (!propDescriptor.writable) {
instance[key] = obj[key];
}
else {
Object.defineProperty(instance, key, propDescriptor);
}
}
else {
instance[key] = obj[key];
}
}
}
}
return instance;
} | javascript | {
"resource": ""
} | |
q42326 | train | function(obj, clone) {
var thisObj = this;
thisObj.itsa_emptyObject();
if (clone) {
deepCloneObj(obj, thisObj, true);
}
else {
thisObj.itsa_merge(obj);
}
return thisObj;
} | javascript | {
"resource": ""
} | |
q42327 | train | function (method, model, options) {
options = options ? _.clone(options) : {};
var jsonPayload;
var promise;
// Ensure that we have a hoodie object type.
if (!model.HOODIE_TYPE) {
throw new Error('A HOODIE_TYPE property must be specified');
}
// Ensure that we have the appropriate request data.
if (options.data == null && model && (method === 'create' || method === 'update' || method === 'patch')) {
jsonPayload = options.attrs || model.toJSON(options) || options.data;
}
switch(method) {
case 'read':
if (options && options.id) {
promise = window.hoodie.store.find(model.HOODIE_TYPE, options.id);
} else {
promise = window.hoodie.store.findAll(model.HOODIE_TYPE);
}
break;
case 'create':
if (!jsonPayload) {
throw new Error('Trying to add a model, but no data provided');
} else {
promise = window.hoodie.store.add(model.HOODIE_TYPE, jsonPayload, options.silent);
}
break;
case 'update':
case 'patch':
if (! jsonPayload) {
throw new Error('Trying to update a model, but no data provided');
} else if (!model.id) {
throw new Error('Cannot update model - no id provided');
} else {
promise = window.hoodie.store.update(model.HOODIE_TYPE, model.id, jsonPayload, options.silent);
}
break;
case 'delete':
if (!model.id) {
throw new Error('Cannot delete model - no id provided');
} else {
promise = window.hoodie.store.remove(model.HOODIE_TYPE, model.id, options.silent);
}
break;
default:
throw new Error('Undefined hoodie method requested: ' + methodMap[method] + ' original: ' + method);
break
}
promise.done(function(body) {
if (options.success) return options.success(body, 'success');
});
promise.fail(function(error) {
if (options.error) return options.error({}, 'error', error);
});
} | javascript | {
"resource": ""
} | |
q42328 | processLine | train | function processLine (line, callback) {
var trigger = line[0];
// Required to drop the args to callback so async doesn't think we're throwing an error.
function cb () {
callback();
}
if (trigger === 'alias') {
bot.db.schemas.factTrigger.saveAlias(line[1], line[2]).then(cb);
} else {
bot.db.schemas.factTrigger.saveFactoid(trigger, line[1], line[2]).then(cb);
}
} | javascript | {
"resource": ""
} |
q42329 | randomString | train | function randomString(options) {
var set = '0123456789ABCDEFGHIJKLMNOPQRSTUVWXTZabcdefghiklmnopqrstuvwxyz';
if (options.symbols === true) {
set += '!@#$%^&*()<>?/[]{},.:;';
}
var key = '';
for (var i = 0; i < options.length; i++) {
key += set.charAt(Math.floor(Math.random() * set.length));
}
return key;
} | javascript | {
"resource": ""
} |
q42330 | otpauth | train | function otpauth(key, name) {
var code = 'otpauth://totp/' + encodeURIComponent(name);
code += '?secret=' + encodeURIComponent(key);
code += '&issuer=' + encodeURIComponent('One Sony');
return code;
} | javascript | {
"resource": ""
} |
q42331 | link | train | function link(key, options) {
if (options.google && options.name) {
return 'https://chart.googleapis.com/chart?chs=166x166&chld=L|0&cht=qr&chl=' + otpauth(key, options.name);
} else {
return 'https://chart.googleapis.com/chart?chs=166x166&chld=L|0&cht=qr&chl=' + encodeURIComponent(key);
}
} | javascript | {
"resource": ""
} |
q42332 | qrcode | train | function qrcode(key, name, options) {
// Options
options = _.extend({
type: 'svg',
sync: false
}, options || {});
var link = otpauth(key, name);
if (options.sync) {
return qr.imageSync(link, {
type: options.type,
margin: 0
});
} else {
return qr.image(link, {
type: options.type,
margin: 0
});
}
} | javascript | {
"resource": ""
} |
q42333 | generateKey | train | function generateKey(options) {
// Options
options = _.extend({
length: 32,
name: '',
symbols: false,
google: false,
qrCode: false,
type: 'base32'
}, options || {});
// Generate the random string
var key = randomString(options);
if (options.type === 'ascii') {
return key;
} else if (options.type === 'base32') {
// Encode the ascii string into base32 and remove any `=` signs which google
// doesn't like
key = base32.encode(key).toString().replace(/=/g, '');
return key;
} else {
throw new Error('InvalidKeyType');
}
} | javascript | {
"resource": ""
} |
q42334 | Model | train | function Model(io, name, itemDef, modelDef, filter) {
EventEmitter.call(this);
//name = name.toLowerCase();
this.io = io;
this.name = name;
this.url = utils.resolveName(name);
this.itemDef = itemDef || {};
this.modelDef = modelDef || {};
this.filter = filter || {};
this.children = [];
this.eventHandlers = {};
this.bindings = [];
this.value = publicModel(this, new Promise(function(resolve, reject) {
this.on('ready', resolve());
}.bind(this)));
this.on('created', this._onCreated.bind(this));
this.on('updated', this._onUpdated.bind(this));
this.on('destroyed', this._onDestroyed.bind(this));
io.socket.on(name, function(message) {
this.emit(message.verb, message);
}.bind(this));
this.refresh().then(function() {
this.emit('ready');
}.bind(this));
} | javascript | {
"resource": ""
} |
q42335 | train | function(callback) {
if (Object.keys(templateDependencies).indexOf(args['<template>']) === -1) {
return callback(new Error(format('Unknown template "%s". Run '
+ '`mj help create` for list of valid templates.', args['<template>'])));
}
return callback(null);
} | javascript | {
"resource": ""
} | |
q42336 | train | function(callback) {
fs.readdir(args['<directory>'], function(err, files) {
// error here means it does not exist, which is good.
if (err || args['--force']) {
return callback(null, args['<directory>']);
}
if (files.length > 0) {
return callback(new Error(format('destination '
+ 'directory %s is not empty.', path.resolve(args['<directory>']))));
}
return callback(null, args['<directory>']);
});
} | javascript | {
"resource": ""
} | |
q42337 | train | function(template, parent) {
var templateLocation;
if (templateNameToRepo[template].startsWith('file://')) {
templateLocation = templateNameToRepo[template].slice(7);
} else {
templateLocation = path.join(path.homedir(), '.khaos', 'templates', template);
}
return function(callback, results) {
var processTemplate = function(location, cb) {
var khaos = new Khaos(path.join(templateLocation, 'template'));
khaos.read(function(err, files) {
if (err) return cb(err);
khaos.parse(files, function(err2, schema) {
if (err2) return cb(err2);
// only prompt for new variables
var newVars = _.omit(schema, _.keys(results[parent] || args.answers));
khaos.prompt(newVars, function(err3, answers) {
if (err3) return cb(err3);
// merge new answers with existing ones and pass to next template
answers = _.merge(answers, results[parent] || args.answers || {});
khaos.write(results.destination, files, answers, function(err4) {
cb(err4, answers);
});
});
});
});
};
// download from github if not yet locally cached
if (!exists(templateLocation)) {
download(templateNameToRepo[template], templateLocation, function(err) {
if (err) return callback(err);
processTemplate(templateLocation, callback);
});
} else {
processTemplate(templateLocation, callback);
}
};
} | javascript | {
"resource": ""
} | |
q42338 | insert | train | function insert(arr, index, values) {
[].splice.apply(arr, [index, 0].concat(values));
} | javascript | {
"resource": ""
} |
q42339 | train | function(objectId, options) {
var self = this;
self.equalTo('objectId', objectId);
var firstOptions = {};
if (options && _.has(options, 'useMasterKey')) {
firstOptions = { useMasterKey: options.useMasterKey };
}
return self.first(firstOptions).then(function(response) {
if (response) {
return response;
}
var errorObject = new Parse.Error(Parse.Error.OBJECT_NOT_FOUND,
"Object not found.");
return Parse.Promise.error(errorObject);
})._thenRunCallbacks(options, null);
} | javascript | {
"resource": ""
} | |
q42340 | train | function(options) {
var self = this;
options = options || {};
var request = Parse._request({
route: "classes",
className: this.className,
method: "GET",
useMasterKey: options.useMasterKey,
data: this.toJSON()
});
return request.then(function(response) {
return _.map(response.results, function(json) {
var obj;
if (response.className) {
obj = new Parse.Object(response.className);
} else {
obj = new self.objectClass();
}
obj._finishFetch(json, true);
return obj;
});
})._thenRunCallbacks(options);
} | javascript | {
"resource": ""
} | |
q42341 | train | function(options) {
var self = this;
options = options || {};
var params = this.toJSON();
params.limit = 0;
params.count = 1;
var request = Parse._request({
route: "classes",
className: self.className,
method: "GET",
useMasterKey: options.useMasterKey,
data: params
});
return request.then(function(response) {
return response.count;
})._thenRunCallbacks(options);
} | javascript | {
"resource": ""
} | |
q42342 | train | function(items, options) {
options = options || {};
return new Parse.Collection(items, _.extend(options, {
model: this.objectClass,
query: this
}));
} | javascript | {
"resource": ""
} | |
q42343 | train | function(key) {
var self = this;
if (!this._order) {
this._order = [];
}
Parse._arrayEach(arguments, function(key) {
if (Array.isArray(key)) {
key = key.join();
}
self._order = self._order.concat(key.replace(/\s/g, "").split(","));
});
return this;
} | javascript | {
"resource": ""
} | |
q42344 | train | function() {
var self = this;
Parse._arrayEach(arguments, function(key) {
if (_.isArray(key)) {
self._include = self._include.concat(key);
} else {
self._include.push(key);
}
});
return this;
} | javascript | {
"resource": ""
} | |
q42345 | train | function() {
var self = this;
this._select = this._select || [];
Parse._arrayEach(arguments, function(key) {
if (_.isArray(key)) {
self._select = self._select.concat(key);
} else {
self._select.push(key);
}
});
return this;
} | javascript | {
"resource": ""
} | |
q42346 | LogstashStream | train | function LogstashStream(options) {
EventEmitter.call(this);
options = options || {};
this.name = 'bunyan';
this.level = options.level || 'info';
this.server = options.server || os.hostname();
this.host = options.host || '127.0.0.1';
this.port = options.port || 9999;
this.application = options.appName || process.title;
this.pid = options.pid || process.pid;
this.tags = options.tags || ['bunyan'];
this.type = options.type;
this.client = null;
// ssl
this.ssl_enable = options.ssl_enable || false;
this.ssl_key = options.ssl_key || '';
this.ssl_cert = options.ssl_cert || '';
this.ca = options.ca || '';
this.ssl_passphrase = options.ssl_passphrase || '';
this.cbuffer_size = options.cbuffer_size || 10;
// Connection state
this.log_queue = new CBuffer(this.cbuffer_size);
this.connected = false;
this.socket = null;
this.retries = -1;
this.max_connect_retries = (typeof options.max_connect_retries === 'number') ? options.max_connect_retries : 4;
this.retry_interval = options.retry_interval || 100;
this.connect();
} | javascript | {
"resource": ""
} |
q42347 | npmInstall | train | function npmInstall(packages, callback) {
callback = utils.defineCallback(callback);
if (_.isString(packages)) {
packages = [ packages ];
}
return npm.load({
loglevel: "silent",
prefix: tmpDir,
}, function(loadErr) {
if (loadErr) {
return callback(new errors.NpmLoadError(loadErr));
}
npm.commands.install(packages, function(installErr) {
if (installErr) {
return callback(new errors.NpmInstallError(installErr));
}
ncp(tmpDir + "/node_modules/", pluginsDir, function(copyError) {
if (copyError) {
return callback(new errors.PluginsMoveFromTempError(copyError));
}
return callback(null);
}); // ncp
}); // npm.commands.install
}); // npm.load
} | javascript | {
"resource": ""
} |
q42348 | dirInstall | train | function dirInstall(dirpath, callback) {
callback = utils.defineCallback(callback);
return fs.exists(dirpath, function(exists) {
if (!exists) {
return callback(new errors.DirectoryNotExistingError());
}
var pluginName = path.basename(dirpath);
var destPath = path.join(pluginsDir, pluginName);
return ncp(dirpath, destPath, function(copyError) {
if (copyError) {
return callback(new errors.PluginsMoveFromTempError(copyError));
}
return callback(null);
});
});
} | javascript | {
"resource": ""
} |
q42349 | listPlugins | train | function listPlugins(callback) {
callback = utils.defineCallback(callback);
return fs.readdir(pluginsDir, function(readdirErr, files) {
if (readdirErr) {
return callback(new errors.PluginsListingError(readdirErr));
}
var fullpath, pkg;
var descriptors = [ ];
files.forEach(function (file) {
fullpath = path.join(pluginsDir, file, "package.json");
try {
pkg = require(fullpath);
descriptors.push({
name: pkg.name,
version: pkg.version || "",
description: pkg.description || "",
author: pkg.author || "",
icon: pkg.icon || "",
homepage: pkg.homepage || "",
});
} catch (requireErr) {
/*
* we shall ignore this error and only list those plugins
* we can load
*/
}
});
return callback(null, descriptors);
});
} | javascript | {
"resource": ""
} |
q42350 | inheirtInlineStyles | train | function inheirtInlineStyles( parent, el ) {
var style = parent.getAttribute( 'style' );
// Put parent styles before child styles.
style && el.setAttribute( 'style', style.replace( /([^;])$/, '$1;' ) + ( el.getAttribute( 'style' ) || '' ) );
} | javascript | {
"resource": ""
} |
q42351 | mergeListSiblings | train | function mergeListSiblings( listNode )
{
var mergeSibling;
( mergeSibling = function( rtl )
{
var sibling = listNode[ rtl ? 'getPrevious' : 'getNext' ]( nonEmpty );
if ( sibling &&
sibling.type == CKEDITOR.NODE_ELEMENT &&
sibling.is( listNode.getName() ) )
{
// Move children order by merge direction.(#3820)
mergeChildren( listNode, sibling, null, !rtl );
listNode.remove();
listNode = sibling;
}
} )();
mergeSibling( 1 );
} | javascript | {
"resource": ""
} |
q42352 | isTextBlock | train | function isTextBlock( node ) {
return node.type == CKEDITOR.NODE_ELEMENT && ( node.getName() in CKEDITOR.dtd.$block || node.getName() in CKEDITOR.dtd.$listItem ) && CKEDITOR.dtd[ node.getName() ][ '#' ];
} | javascript | {
"resource": ""
} |
q42353 | train | function (req, res, options) {
if (!options) {
options = {};
}
options.operation = 'SAVE';
options.res = res;
if (req.params.model) {
options.model = req.params.model;
}
if (req.body) {
options.item = req.body;
}
if (req.params.data) {
options.data = req.params.data;
}
exports.save.before(req, res, options);
var userId = req.session['user-id'];
vulpejs.models.save({
model: options.model,
item: options.item,
data: options.data,
validate: options.validate || false,
userId: userId,
callback: {
success: function (item) {
if (!vulpejs.utils.execute(options.callback, {
item: item,
postedItem: options.item,
res: res,
})) {
exports.save.after(req, res, item);
res.json({
item: item,
postedItem: options.item,
});
}
},
error: function (error) {
exports.response.error(options, error);
},
validate: function (validate) {
exports.response.validate(options, validate);
},
},
});
} | javascript | {
"resource": ""
} | |
q42354 | train | function (req, res, options) {
if (!options) {
options = {};
}
options.operation = 'REMOVE';
options.res = res;
if (!options) {
options = {};
}
if (req.params.model) {
options.model = req.params.model;
}
if (req.params.query) {
options.query = req.params.query;
}
if (req.params.id) {
options.query = {
_id: req.params.id,
};
}
exports.remove.before(req, res, options);
var userId = req.session['user-id'];
vulpejs.models.remove({
model: options.model,
item: {
_id: req.params.id,
},
query: options.query,
validate: options.validate || false,
userId: userId,
callback: {
success: function (item) {
if (!vulpejs.utils.execute(options.callback, {
item: item,
res: res,
})) {
exports.remove.after(req, res, item);
res.json({
item: item,
});
}
},
error: function (error) {
exports.response.error(options, error);
},
validate: function (validate) {
exports.response.validate(options, validate);
},
},
});
} | javascript | {
"resource": ""
} | |
q42355 | train | function (req, res) {
var options = {
operation: 'LIST',
res: res,
};
exports.list.before(req, res, options);
vulpejs.models.list({
model: req.params.model,
query: req.params.query || {},
populate: req.params.populate || '',
sort: req.params.sort || {},
userId: req.session['user-id'],
callback: {
success: function (items) {
exports.list.after(req, res, items);
res.json({
items: items,
});
},
error: function (error) {
exports.response.error(options, error);
},
},
});
} | javascript | {
"resource": ""
} | |
q42356 | train | function (req, res) {
var options = {
operation: 'PAGINATE',
res: res,
};
exports.paginate.before(req, res, options);
vulpejs.models.paginate({
model: req.params.model,
query: req.params.query || {},
populate: req.params.populate || '',
sort: req.params.sort || {},
page: req.params.page || 1,
userId: req.session['user-id'],
callback: {
success: function (data) {
exports.paginate.after(req, res, data);
res.json({
items: data.items,
pageCount: data.pageCount,
itemCount: data.itemCount,
});
},
error: function (error) {
exports.response.error(options, error);
},
},
});
} | javascript | {
"resource": ""
} | |
q42357 | train | function (req, res) {
var options = {
operation: 'DISTINCT',
res: res,
};
exports.distinct.before(req, res, options);
vulpejs.models.distinct({
model: req.params.model,
query: req.params.query || {},
sort: req.params.sort || false,
array: req.params.array || false,
callback: {
success: function (items) {
exports.distinct.after(req, res, items);
res.json(items);
},
error: function (error) {
vulpejs.log.error('DISTINCT', error);
res.status(500).end();
},
},
});
} | javascript | {
"resource": ""
} | |
q42358 | train | function (req, res, options) {
if (!options) {
options = {};
}
options.operation = 'FIND';
options.res = res;
exports.find.before(req, res, options);
vulpejs.models.find({
model: req.params.model,
populate: req.params.populate,
history: true,
id: req.params.id || false,
query: req.params.query || {
_id: req.params.id,
},
callback: {
success: function (data) {
exports.find.after(req, res, data);
if (options && options.callback) {
vulpejs.utils.execute(options.callback, {
item: data.item,
history: data.history,
res: res,
});
} else {
res.json(data);
}
},
error: function (error) {
exports.response.error(options, error);
},
},
})
} | javascript | {
"resource": ""
} | |
q42359 | train | function (req, res, options) {
if (!options) {
options = {};
}
options.operation = 'STATUS';
options.res = res;
exports.status.before(req, res, options);
vulpejs.models.status({
model: req.params.model,
data: req.body,
callback: {
success: function (item) {
exports.status.after(req, res, item);
if (options && options.callback) {
vulpejs.utils.execute(options.callback, item);
} else {
exports.response.success(options);
}
},
error: function (error) {
exports.response.error(options, error);
},
},
});
} | javascript | {
"resource": ""
} | |
q42360 | train | function (configObject) {
if (typeof configObject !== 'undefined') {
configuration.directory = configObject.directory || configuration.directory;
configuration.extension = configObject.extension || configuration.extension;
configuration.objectNotation = configObject.objectNotation || configuration.objectNotation;
}
// Register routes
var uri = vulpejs.app.root.context + '/i18n/:locale';
vulpejs.express.app.get(uri, i18nRoutes.i18n);
vulpejs.express.app.get(uri + '/:phrase', i18nRoutes.translate);
} | javascript | {
"resource": ""
} | |
q42361 | train | function (request, response, next) {
response.locals.i18n = {
getLocale: function () {
return request.cookies.appLanguage || vulpejs.i18n.getLocale.apply(request, arguments);
},
};
// For backwards compatibility, also define 'acceptedLanguage'.
response.locals.acceptedLanguage = response.locals.i18n.getLocale;
if (typeof next !== 'undefined') {
next();
}
} | javascript | {
"resource": ""
} | |
q42362 | train | function (request, response) {
var locale = request.params.locale;
var sendFile = response.sendFile || response.sendfile;
sendFile.apply(response, [path.join(configuration.directory, locale + configuration.extension)]);
} | javascript | {
"resource": ""
} | |
q42363 | train | function (request, response) {
var locale = request.params.locale;
var phrase = request.params.phrase;
var result;
if (request.query.plural) {
var singular = phrase;
var plural = request.query.plural;
// Make sure the information is added to the catalog if it doesn't exist yet.
var translated = vulpejs.i18n.__n({
singular: singular,
plural: plural,
count: request.query.count,
locale: locale,
});
// Retrieve the translation object from the catalog and return it.
var catalog = vulpejs.i18n.getCatalog(locale);
result = singular.split(configuration.objectNotation).reduce(function (object, index) {
return object[index];
}, catalog);
} else {
result = vulpejs.i18n.__({
phrase: phrase,
locale: locale,
});
}
response.send(result);
} | javascript | {
"resource": ""
} | |
q42364 | subscribe | train | function subscribe(topicArn) {
// validate the topic arn
if (!rxTopicArn.test(topicArn)) throw Error('Cannot subscribe to an invalid AWS Topic Arn: ' + topicArn);
// if already subscribed then return now
if (subscriptions[topicArn]) return subscriptions[topicArn].promise;
// create and store the deferred promise
const deferred = defer();
subscriptions[topicArn] = deferred;
// make the sns subscribe request
const params = {
Protocol: /^(https?):/.exec(config.endpoint)[1],
TopicArn: topicArn,
Endpoint: config.endpoint
};
config.sns.subscribe(params, function(err) {
debug('Subscription request for ' + topicArn + (err ? ' failed : ' + err.message : ' sent.'));
if (err) return deferred.reject(err);
});
return deferred.promise;
} | javascript | {
"resource": ""
} |
q42365 | unsubscribe | train | function unsubscribe(topicArn) {
// if not subscribed then return now
if (!subscriptions[topicArn]) {
debug('Not subscribed to ' + topicArn);
return Promise.resolve();
}
return new Promise(function(resolve, reject) {
const params = { SubscriptionArn: topicArn };
config.sns.unsubscribe(params, function (err) {
debug('Unsubscribe from ' + topicArn + (err ? ' failed: ' + err.message : 'succeeded'));
if (err) return reject(err);
delete subscriptions[topicArn];
resolve();
});
});
} | javascript | {
"resource": ""
} |
q42366 | parseBody | train | function parseBody(req) {
return extractBody(req)
.then(() => {
if (req.body && typeof req.body === 'object') return req.body;
try {
return JSON.parse(req.body);
} catch (err) {
throw Error('Unexpected body format received. Expected application/json, received: ' + req.body);
}
});
} | javascript | {
"resource": ""
} |
q42367 | train | function (version, semverIndex)
{
const splittedVersion = version.split('.');
splittedVersion[ semverIndex ] = parseInt(splittedVersion[ semverIndex ], 10) + 1;
while (semverIndex < 2)
{
splittedVersion[ ++semverIndex ] = '0';
}
return splittedVersion.join('.');
} | javascript | {
"resource": ""
} | |
q42368 | train | function (packagePath, semverIndex)
{
// Check if package file exists
if ( !fs.existsSync(packagePath) )
{
throw new Error(`Package file ${packagePath} is not found.`, 1);
}
// Read package file content
const packageData = JSON.parse( fs.readFileSync( packagePath ) );
// Increment version according to semver increment index
packageData.version = module.exports.semverIncrement(packageData.version, semverIndex);
// Write new package.json
fs.writeFileSync(packagePath, JSON.stringify( packageData, null, 2));
// Return incremented version
return packageData.version;
} | javascript | {
"resource": ""
} | |
q42369 | multiproject | train | function multiproject (pointer, target, path) {
var pointerType = getTypeStr (pointer);
var mainTarget;
if (target)
mainTarget = target;
else
if (pointerType == 'object')
target = {};
else if (pointerType == 'array') {
target = [];
var remainingPath = path.slice (i);
for (var i in pointer) {
var found = multiproject (pointer[i], target[i], remainingPath);
if (found !== undefined)
target[i] = found;
}
return target;
} else
return;
for (var i=0,j=path.length-1; i<j; i++) {
var pathStep = path[i];
if (pathStep == '$')
throw new Error (
'cannot use the positional operator inside another Array'
);
if (pointerType == 'array') {
if (!mainTarget) mainTarget = target;
var remainingPath = path.slice (i);
for (var k in pointer) {
var found = multiproject (pointer[k], target[k], remainingPath);
if (found !== undefined)
target[k] = found;
}
return mainTarget;
} else if (pointerType != 'object')
return mainTarget; // if there's path left, we must be a container type
if (!Object.hasOwnProperty.call (pointer, pathStep))
return mainTarget; // not found
if (!mainTarget) mainTarget = target;
pointer = pointer[pathStep];
pointerType = getTypeStr (pointer);
if (Object.hasOwnProperty.call (target, pathStep))
target = target[pathStep];
else
if (pointerType == 'object')
target = target[pathStep] = {};
else
target = target[pathStep] = [];
}
var finalStep = path[path.length-1];
if (!mainTarget) mainTarget = target;
if (pointerType == 'array') {
for (var k in pointer) {
var found = multiproject (pointer[k], target[k], [ finalStep ]);
if (found !== undefined)
target[k] = found;
}
return mainTarget;
} else if (pointerType != 'object')
return mainTarget;
if (Object.hasOwnProperty.call (pointer, finalStep)) {
target[finalStep] = pointer[finalStep];
if (!mainTarget) mainTarget = target;
}
return mainTarget;
} | javascript | {
"resource": ""
} |
q42370 | origin | train | function origin(fn) {
'use strict';
exec('git config --local --get remote.origin.url', function (errors, stdout, stderr) {
var url = "";
if (errors) return fn(errors.stack, url);
if (stderr) return fn(stderr, url);
url = trim.call(stdout);
if (!url) return fn('Unable to find remote origin URL!', url);
fn(null, url);
});
} | javascript | {
"resource": ""
} |
q42371 | srcStream | train | function srcStream(stream) {
var pass = through.obj();
pass.setMaxListeners(0);
var outputstream = duplexify.obj(pass, ms(stream, pass));
outputstream.setMaxListeners(0);
var isReading = false;
outputstream.on('pipe', function (src) {
isReading = true;
src.on('end', function () {
isReading = false;
outputstream.end();
});
});
stream.on('end', function () {
if (!isReading) {
outputstream.end();
}
});
return outputstream;
} | javascript | {
"resource": ""
} |
q42372 | createIHDRChunk | train | function createIHDRChunk(width, height) {
const data = buffer.Buffer.alloc(13);
// Width
data.writeUInt32BE(width);
// Height
data.writeUInt32BE(height, 4);
// Bit depth
data.writeUInt8(8, 8);
// RGBA mode
data.writeUInt8(6, 9);
// No compression
data.writeUInt8(0, 10);
// No filter
data.writeUInt8(0, 11);
// No interlacing
data.writeUInt8(0, 12);
return createChunk('IHDR', data);
} | javascript | {
"resource": ""
} |
q42373 | createPng | train | function createPng(pixelData) {
const length = pixelData.length + 4 - (pixelData.length % 4);
const pixels = Math.ceil(length / 4);
const width = Math.min(pixels, MAX_WIDTH);
const height = Math.ceil(pixels / MAX_WIDTH);
const bytesPerRow = width * 4;
const buffer$$1 = buffer.Buffer.alloc((bytesPerRow + 1) * height);
// Write pixel data to buffer
for (let y = 0; y < height; y += 1) {
const offset = y * bytesPerRow;
const rowData = pixelData.slice(offset, offset + bytesPerRow);
const rowStartX = offset + y + 1;
const rowEndX = rowStartX + bytesPerRow;
buffer$$1.writeUInt8(0, offset + y);
buffer$$1.fill(rowData, rowStartX, rowEndX);
}
return new Promise((resolve, reject) => {
zlib.deflate(buffer$$1, (error, deflated) => {
if (error) {
reject(error);
return;
}
resolve(buffer.Buffer.concat([
PNG_HEADER,
createIHDRChunk(width, height),
createIDATChunk(deflated),
createIENDChunk(),
]));
});
});
} | javascript | {
"resource": ""
} |
q42374 | prependLength | train | function prependLength(data) {
const lengthAsBytes = buffer.Buffer.alloc(4);
lengthAsBytes.writeUInt32BE(data.length);
return buffer.Buffer.concat([lengthAsBytes, data]);
} | javascript | {
"resource": ""
} |
q42375 | encode | train | function encode(data) {
const bytes = buffer.Buffer.from(data, 'utf8');
const pixelData = prependLength(bytes);
return createPng(pixelData);
} | javascript | {
"resource": ""
} |
q42376 | train | function (increment) {
increment = increment || Semver.PATCH; // default is patch
switch (increment) {
/* jshint indent: false */
case Semver.MAJOR:
this.major++;
this.minor = this.patch = 0;
break;
case Semver.MINOR:
this.minor++;
this.patch = 0;
break;
case Semver.PATCH:
this.patch++;
break;
}
return this;
} | javascript | {
"resource": ""
} | |
q42377 | isMyTurn | train | function isMyTurn(game, from) {
if (game.score.ended)
return false;
from = Board.getPositionFromBoard(game.board, from);
return isWhiteTurn(game) ? Position.hasWhitePiece(from) : Position.hasBlackPiece(from);
} | javascript | {
"resource": ""
} |
q42378 | getTurnPieces | train | function getTurnPieces(game) {
const isBlack = isBlackTurn(game);
return game.board.reduce((piecesRow, row) => {
return piecesRow.concat(row.reduce((pieces, position) => (isBlack !== position.isBlack)
? pieces
: pieces.concat({ x: position.x, y: position.y, isBlack }), []));
}, []);
} | javascript | {
"resource": ""
} |
q42379 | prefix | train | function prefix(pattern) {
if (!pattern) {
pattern = 'grunt-available-tasks';
}
pattern = pattern.replace(/^node_modules\//, '');
var ret;
if (grunt.file.expand('node_modules/' + pattern).length) {
ret = 'node_modules/';
} else if (grunt.file.expand('../../node_modules/' + pattern).length) {
ret = '../../node_modules/';
} else if (grunt.file.expand('node_modules/chronicles_of_grunt/node_modules/' + pattern).length) {
ret = 'node_modules/chronicles_of_grunt/node_modules/';
} else {
grunt.fail.fatal("Cannot find module path for " + pattern);
}
return ret;
} | javascript | {
"resource": ""
} |
q42380 | getConfig | train | function getConfig(name, def) {
var i, j;
// Load initital config.
if (!config) {
var external;
config = grunt.config.get('cog') || {options: {}};
// Expand general external definitions to category specific definitions.
if (config.options.external instanceof Array) {
external = config.options.external;
config.options.external = {lib: [], css: [], fonts: []};
for (i=0; i < external.length; i++) {
if (!db.categories[external[i]]) {
grunt.fail.fatal("Cannot figure out applicaple categories for external dependency: " + external[i]);
}
for(j = 0; j < db.categories[external[i]].length; j++) {
config.options.external[db.categories[external[i]][j]].push(external[i]);
}
}
}
// Expand also for unit tests.
if (config.options.test && config.options.test.unit && config.options.test.unit.external instanceof Array) {
external = config.options.test.unit.external;
config.options.test.unit.lib = [];
config.options.test.unit.css = [];
for (i=0; i < external.length; i++) {
if (!db.categories[external[i]]) {
grunt.fail.fatal("Cannot figure out applicaple categories for external dependency: " + external[i]);
continue;
}
for(j = 0; j < db.categories[external[i]].length; j++) {
config.options.test.unit[db.categories[external[i]][j]].push(external[i]);
}
}
}
}
var ret = config.options;
if (!name) {
return ret;
}
var parts = name.split('.');
for (i=0; i < parts.length; i++) {
if (!ret) {
return def;
}
ret = ret[parts[i]];
}
return ret || def;
} | javascript | {
"resource": ""
} |
q42381 | configuredFramework | train | function configuredFramework() {
var lib = getConfig('external.lib');
if (!lib) {
return null;
}
if (typeof(lib) === 'string') {
lib = [lib];
}
if (lib.indexOf('ember') >= 0) {
return 'ember';
}
if (lib.indexOf('angular') >= 0 || lib.indexOf('coa') >= 0) {
return 'angular';
}
return null;
} | javascript | {
"resource": ""
} |
q42382 | getOption | train | function getOption(name) {
var ret = getConfig('options.' + name);
if (ret === undefined) {
var framework = configuredFramework();
if (db.frameworks.options[framework] && (name in db.frameworks.options[framework])) {
ret = db.frameworks.options[framework][name];
} else if (name in db.frameworks.options.all) {
ret = db.frameworks.options.all[name];
}
}
if (typeof(ret) === 'function') {
ret = ret();
}
return ret;
} | javascript | {
"resource": ""
} |
q42383 | train | function (inst) {
if (inst.isDirty()) {
inst.save();
ngModel.$setViewValue(elm.val());
if (!scope.$$phase)
scope.$apply();
}
} | javascript | {
"resource": ""
} | |
q42384 | train | function(event, jsEvent, view) {
if (view.name !== 'agendaDay') {
$(jsEvent.target).attr('title', event.title);
}
} | javascript | {
"resource": ""
} | |
q42385 | CFG | train | function CFG(rules) {
let arr = [];
arr.__proto__ = CFG.prototype;
if (Array.isArray(rules)) {
rules.forEach(arr.rule.bind(arr));
}
return arr;
} | javascript | {
"resource": ""
} |
q42386 | reapply | train | function reapply (parameters) {
return (arguments.length > 1)
? reapplyer(parameters, arguments[1])
: reapplyer.bind(null, parameters)
} | javascript | {
"resource": ""
} |
q42387 | handlePush | train | function handlePush(key, req, log, fn) {
var body = req.body;
var repo = body.repository;
if (!body || !repo) return fn(new Error('missing body'));
var url = repo.url;
var name = repo.name;
var ref = body.ref;
var branch = ref.replace('refs/heads/', '');
var sha = body.after;
var info = {
repo: repo.organization + '/' + repo.name,
url: repo.url,
name: repo.name,
ref: ref,
branch: branch,
sha: sha,
body: body
};
var event = body.deleted ? 'branch-deleted' : 'gh:parsed';
fn(null, info, event);
} | javascript | {
"resource": ""
} |
q42388 | clone | train | function clone(url, target, ref, key, log, fn) {
var urlObj = parseurl(url);
urlObj.auth = key + ':x-oauth-basic';
var authurl = formaturl(urlObj) + '.git';
var dir = target + '/.git';
log('creating dir ' + dir);
mkdirp(dir, function(err) {
if (err) return fn(err);
var remote = git.remote(authurl);
var repo = git.repo(dir);
var opts = {};
opts.want = ref;
log('fetching ' + url);
repo.fetch(remote, opts, function(err) {
if (err) return fn(err);
log('checking out ' + ref);
repo.resolveHashish(ref, function(err, hash) {
if (err) return fn(err);
log('updating head to ' + hash);
repo.updateHead(hash, function(err) {
if (err) return fn(err);
exec('git checkout ' + hash, {cwd: target}, function(err, stdout, stderr) {
fn(err);
});
});
});
});
});
} | javascript | {
"resource": ""
} |
q42389 | basePackageJson | train | function basePackageJson (opts) {
opts = opts || {}
const _name = opts.name || '<name>'
const _version = opts.version || '1.0.0'
const _private = opts.private || false
var called = false
return from({ objectMode: true }, function (size, next) {
if (called) return next(null, null)
const res = { name: _name, version: _version }
if (_private) res.private = true
res.scripts = {}
res.dependencies = {}
res.devDependencies = {}
called = true
next(null, res)
})
} | javascript | {
"resource": ""
} |
q42390 | padLeft | train | function padLeft(width, string, padding) {
return (width <= string.length) ? string : padLeft(width, string + padding, padding);
} | javascript | {
"resource": ""
} |
q42391 | writeLogFile | train | function writeLogFile(file, line) {
if (file === undefined || file === null) {
return;
}
fs.appendFile(file, line + os.EOL, {}, function() {
//
});
} | javascript | {
"resource": ""
} |
q42392 | Stash | train | function Stash(nlz) {
if (!(this instanceof Stash)) return new Stash(nlz);
nlz = nlz || function(val) {return val};
assert.equal(typeof nlz, 'function', 'linkstash: nlz should be a function');
this._prev = null;
this._next = null;
this._nlz = nlz;
return this;
} | javascript | {
"resource": ""
} |
q42393 | checkMocksCalled | train | function checkMocksCalled(createResult) {
expect(createResult).to.deep.equal(createResult);
sinon.assert.calledOnce(mockDatasetManager.create);
sinon.assert.calledWith(mockDatasetManager.create, sinon.match(mockDataToCreate));
} | javascript | {
"resource": ""
} |
q42394 | nav | train | function nav(path, query, hash, forceReload) {
var reload = forceReload || !path;
path = path || location.pathname;
query = query || (reload && location.search) || '';
hash = hash || (reload && location.hash) || '';
var newpage = generator.findPage(path);
if (!newpage) return generator.emit('notify', 'Oops, jqueryview cannot find new page object ' + path);
var oldpath = u.unPrefix(location.pathname, opts.staticRoot);
var oldpage = generator.findPage(oldpath);
if (!oldpage) return generator.emit('notify', 'Oops, jqueryview cannot find current page object ' + oldpath);
if (!reload && newpage === oldpage) return; // hash navigation doesn't require repaint
// simulate server-side request
generator.req = { query: query ? require('querystring').parse(query.slice(1)) : {} };
if ($layout.length && (reload || layoutChanged(oldpage, newpage))) {
updateLayout();
return;
}
// else just update page
updatePage();
///// helper functions /////
function updateLayout() {
var layout = generator.layoutTemplate(newpage);
$layout.html(generator.renderLayout(newpage));
$layout.attr('data-render-layout', layout);
log('jqueryview updateLayout', path, query, hash);
generator.emit('update-view', path, query, hash, window, $layout);
}
function updatePage() {
var $page = $('[data-render-page]');
if (!$page.length) return generator.emit('notify', 'Oops, jqueryview cannot update page ' + path);
$page.html(generator.renderPage(newpage));
$page.attr('data-render-page', newpage._href);
log('jqueryview updatePage:', path, query, hash)
generator.emit('update-view', path, query, hash, window, $page);
}
// return true if newpage layout is different from current layout
function layoutChanged(oldpage, newpage) {
if (oldpage && oldpage.fixlayout) return true;
if (lang(oldpage) !== lang(newpage)) return true;
var currentlayout = $layout.attr('data-render-layout') || 'main-layout';
var newlayout = generator.layoutTemplate(newpage);
return (newlayout !== currentlayout);
}
} | javascript | {
"resource": ""
} |
q42395 | layoutChanged | train | function layoutChanged(oldpage, newpage) {
if (oldpage && oldpage.fixlayout) return true;
if (lang(oldpage) !== lang(newpage)) return true;
var currentlayout = $layout.attr('data-render-layout') || 'main-layout';
var newlayout = generator.layoutTemplate(newpage);
return (newlayout !== currentlayout);
} | javascript | {
"resource": ""
} |
q42396 | updateHtml | train | function updateHtml(href) {
var fragment = generator.fragment$[href];
if (!fragment) return generator.emit('notify', 'Oops, jqueryview cannot find fragment: ' + href);
var $html = $('[data-render-html="' + href + '"]');
if (!$html.length) return generator.emit('notify', 'Oops, jqueryview cannot update html for fragment: ' + href);
$html.html(generator.renderHtml(fragment));
log('jqueryview updateHtml', location.pathname, location.search, location.hash);
generator.emit('update-view', location.pathname, location.search, location.hash, window, $html);
} | javascript | {
"resource": ""
} |
q42397 | appendModel | train | function appendModel(url, model, done){
var list = utils.flatten_tree(JSON.parse(JSON.stringify(model)))
var errormodel = null
list = list.filter(function(model){
if(!model._digger.path || !model._digger.inode){
errormodel = model;
return false;
}
return true
})
if(errormodel){
return done('no path or inode in level-append: ' + JSON.stringify(model))
}
var batch = list.map(function(model){
return {
type:'put',
key:model._digger.path + '/' + model._digger.inode,
value:model
}
})
tree.batch(batch, function(err){
if(err) return done(err)
done(null, model)
})
} | javascript | {
"resource": ""
} |
q42398 | prepend | train | function prepend(pre) {
function prepender(string) { return pre + string; }
return arguments.length > 1
? prepender(arguments[1])
: prepender;
} | javascript | {
"resource": ""
} |
q42399 | train | function(value, compareFunction) {
var low = 0;
var high = this.length;
var mid;
if (compareFunction) {
while (low < high) {
mid = low + high >>> 1;
var direction = compareFunction(this[mid], value);
if (!direction) {
return mid;
}
if (direction < 0) {
low = mid + 1;
} else {
high = mid;
}
}
} else {
while (low < high) {
mid = low + high >>> 1;
if (this[mid] === value) {
return mid;
}
if (this[mid] < value) {
low = mid + 1;
} else {
high = mid;
}
}
}
return -1;
} | javascript | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.