_id
stringlengths 2
6
| title
stringlengths 0
58
| partition
stringclasses 3
values | text
stringlengths 52
373k
| language
stringclasses 1
value | meta_information
dict |
|---|---|---|---|---|---|
q13900
|
train
|
function() {
var events;
var button;
if (window.kelmu.data[id].settings.step && !stepButtonInitialized) {
button = element.find(window.kelmu.data[id].settings.step);
if (button.length > 0) {
events = $._data(button[0], 'events');
stepButtonInitialized = true;
if (events && events.click && events.click.length > 0) {
originalStep = events.click[0].handler;
events.click[0].handler = forwardAndSkip;
} else {
button.click(forwardAndSkip);
}
}
}
if (window.kelmu.data[id].settings.redo && !redoButtonInitialized) {
button = element.find(window.kelmu.data[id].settings.redo);
if (button.length > 0) {
events = $._data(button[0], 'events');
redoButtonInitialized = true;
if (events && events.click && events.click.length > 0) {
originalRedo = events.click[0].handler;
events.click[0].handler = redo;
} else {
button.click(redo);
}
}
}
if (window.kelmu.data[id].settings.undo && !undoButtonInitialized) {
button = element.find(window.kelmu.data[id].settings.undo);
if (button.length > 0) {
events = $._data(button[0], 'events');
undoButtonInitialized = true;
if (events && events.click && events.click.length > 0) {
originalUndo = events.click[0].handler;
events.click[0].handler = undo;
} else {
button.click(undo);
}
}
}
if (window.kelmu.data[id].settings.begin && !beginButtonInitialized) {
button = element.find(window.kelmu.data[id].settings.begin);
if (button.length > 0) {
events = $._data(button[0], 'events');
beginButtonInitialized = true;
if (events && events.click && events.click.length > 0) {
originalBegin = events.click[0].handler;
events.click[0].handler = begin;
} else {
button.click(begin);
}
}
}
}
|
javascript
|
{
"resource": ""
}
|
|
q13901
|
train
|
function(event, action) {
var data = window.kelmu.data[id];
var stepsLeft = Math.max(+(action.parameter || 1), 1);
var stepsToRun = 0;
var proceed = function() {
this('skip', stepsToRun);
};
while (stepsLeft > 0) {
var subSteps = (data.definitions['step' + data.stepNumber] || [null]).length - 1;
var currentSub = data.subStepNumber;
var canIncrease = subSteps - currentSub;
if (canIncrease < stepsLeft) {
data.stepNumber += 1;
data.subStepNumber = 0;
stepsToRun += 1;
stepsLeft -= canIncrease + 1;
} else if (canIncrease > 0) {
if (stepsToRun > 0) {
$.each(window.kelmu.callbacks[id], proceed);
stepsToRun = 0;
clearAnnotations();
originalStep(event);
}
stepsLeft -= canIncrease;
data.subStepNumber = data.subStepNumber + canIncrease;
} else {
data.stepNumber += 1;
stepsToRun += 1;
stepsLeft -= 1;
}
}
if (stepsToRun > 0) {
$.each(window.kelmu.callbacks[id], proceed);
stepsToRun = 0;
clearAnnotations();
originalStep(event);
if (!window.kelmu.data[id].animationReadyAvailable) {
setTimeout(function() {
createAnnotations();
if (window.kelmu.data[id].actions.updateEditor) {
window.kelmu.data[id].actions.updateEditor();
}
}, window.kelmu.data[id].settings.animationLength);
}
} else {
createAnnotations();
}
window.kelmu.data[id].undoStack.splice(window.kelmu.data[id].undoStackPointer + 1, window.kelmu.data[id].undoStack.length);
window.kelmu.data[id].undoStack.push([window.kelmu.data[id].stepNumber, window.kelmu.data[id].subStepNumber]);
window.kelmu.data[id].undoStackPointer += 1;
}
|
javascript
|
{
"resource": ""
}
|
|
q13902
|
blockResizeStart
|
train
|
function blockResizeStart() {
var lastListeningElement;
// We'll attach only one listener at a time, instead of adding it to every img, input, hr etc.
// Listener will be attached upon selectionChange, we'll also check if there was any element that
// got listener before (lastListeningElement) - if so we need to remove previous listener.
editor.editable().attachListener( editor, 'selectionChange', function() {
var selectedElement = editor.getSelection().getSelectedElement();
if ( selectedElement ) {
if ( lastListeningElement ) {
lastListeningElement.detachEvent( 'onresizestart', resizeStartListener );
lastListeningElement = null;
}
// IE requires using attachEvent, because it does not work using W3C compilant addEventListener,
// tested with IE10.
selectedElement.$.attachEvent( 'onresizestart', resizeStartListener );
lastListeningElement = selectedElement.$;
}
} );
}
|
javascript
|
{
"resource": ""
}
|
q13903
|
expressGetHandler
|
train
|
function expressGetHandler(endpoint) {
return function(req, res) {
// We have to handle request parameters differently since they're not in the
// request body.
rpc.getMethod(endpoint.name)({request: req.params}, function(err, doc) {
res.send(doc);
res.end();
});
};
}
|
javascript
|
{
"resource": ""
}
|
q13904
|
req
|
train
|
function req (name, opts) {
if (opts && opts.require) {
return opts.require(name, opts)
}
var fp = require.resolve(name)
return require(fp)
}
|
javascript
|
{
"resource": ""
}
|
q13905
|
renameKey
|
train
|
function renameKey (name, opts) {
if (opts && opts.renameKey) {
return opts.renameKey(name, opts)
}
return name
}
|
javascript
|
{
"resource": ""
}
|
q13906
|
cleanup
|
train
|
function cleanup(e2) {
// if it's the same event as the origin,
// then don't actually cleanup.
// hit issues with this - don't remember
if (e1 === e2) return
clearTimeout(timeout_id)
el.removeEventListener('touchmove', cleanup)
endEvents.forEach(function (event) {
el.removeEventListener(event, done)
})
}
|
javascript
|
{
"resource": ""
}
|
q13907
|
asyncerr
|
train
|
function asyncerr(err, cb) {
if (!util.isError(err, Error))
return debug(BAD_ERR_ERR);
if (typeof err.message === 'string' && err.message.length)
debug(err.message);
if (typeof err.stack === 'object')
debug(err.stack);
if (!is.func(cb))
return debug(BAD_CB_ERR+util.inspect(cb));
// call the callback on the next tick of the event loop
process.nextTick(function() {
cb(err);
});
}
|
javascript
|
{
"resource": ""
}
|
q13908
|
DocCommentParser
|
train
|
function DocCommentParser(text) {
this.lines = text.split(END_OF_LINE);
this.lineNumber = 0;
this.length = this.lines.length;
this.line = '';
this.match = [];
this.tagDef = {};
this.mode = this._extractLine;
this.data = {};
}
|
javascript
|
{
"resource": ""
}
|
q13909
|
Diable
|
train
|
function Diable(opts) {
// The process is a daemon
if (Diable.isDaemon()) {
return false
}
opts = opts || {}
const args = [].concat(process.argv)
args.shift()
const script = args.shift()
, env = opts.env || process.env
Diable.daemonize(script, args, opts)
return process.exit()
}
|
javascript
|
{
"resource": ""
}
|
q13910
|
markdown
|
train
|
function markdown(preset, options) {
var stream = through(transform, flush)
var parser = new Remarkable(preset, options)
var buffer = []
function transform(chunk, encoding, done) {
buffer.push(chunk)
done()
}
function flush(done) {
this.push(parser.render(buffer.join('\n')))
done()
}
return stream
}
|
javascript
|
{
"resource": ""
}
|
q13911
|
getFileContent
|
train
|
function getFileContent(ext, file) {
var conf = {};
switch (ext) {
case '.js':
conf = require(file);
break;
case '.json':
conf = JSON.parse(fs.readFileSync(file, {
encoding: 'utf-8'
}));
break;
case '.yml':
conf = yaml.safeLoad(fs.readFileSync(file, {
encoding: 'utf-8'
}));
break;
}
return conf;
}
|
javascript
|
{
"resource": ""
}
|
q13912
|
depugger
|
train
|
function depugger(pDebug, pName) {
var debug, name, backend;
if (typeof pDebug === 'object') {
debug = !!pDebug.debug;
name = pDebug.name || '';
backend = pDebug.backend || stdBackend;
} else {
debug = !!pDebug;
name = pName || '';
backend = stdBackend;
}
var prefix = name ? util.format('[%s] ', name) : '';
var logFunction = function() {
var args = Array.prototype.splice.call(arguments, 0);
var message = util.format.apply(null, args);
message = prefix + message;
backend.write(message);
};
if(!debug) {
logFunction = noop;
}
logFunction.child = function(childName) {
var newName = name ? name + '.' + childName : childName;
return depugger({debug: debug, name: newName, backend: backend});
};
return logFunction;
}
|
javascript
|
{
"resource": ""
}
|
q13913
|
traverse
|
train
|
function traverse(ast) {
var visitors = flatten(slice.call(arguments, 1));
estraverse.traverse(ast, {
enter: function(node) {
var type = node.type;
var methodName = type + 'Enter';
visitorsCall('enter', this, arguments);
visitorsCall(methodName, this, arguments);
},
leave: function(node) {
var type = node.type;
var methodName = type + 'Leave';
visitorsCall('leave', this, arguments);
visitorsCall(methodName, this, arguments);
}
});
function visitorsCall(methodName, context, args) {
var callArgs = slice.call(args);
var callBreak;
var visitorContext = Object.assign(
Object.create(context),
{
skip: function() {
callBreak = true;
context.skip();
},
break: function() {
callBreak = true;
context.break();
}
}
);
visitors.some(function(visitor) {
var method = visitor[methodName];
if (method) {
method.apply(visitorContext, callArgs);
}
return callBreak;
});
}
}
|
javascript
|
{
"resource": ""
}
|
q13914
|
fix
|
train
|
function fix(fn, path) {
if (!running) return;
if (path !== location.hash) {
fn();
path = location.hash;
}
setTimeout(function() {
fix(fn, path);
}, 500);
}
|
javascript
|
{
"resource": ""
}
|
q13915
|
parseContinueStatement
|
train
|
function parseContinueStatement() {
var token, label = null;
expectKeyword('continue');
// Optimize the most common form: 'continue;'.
if (source[index] === ';') {
lex();
if (!inIteration) {
throwError({}, Messages.IllegalContinue);
}
return {
type: Syntax.ContinueStatement,
label: null
};
}
if (peekLineTerminator()) {
if (!inIteration) {
throwError({}, Messages.IllegalContinue);
}
return {
type: Syntax.ContinueStatement,
label: null
};
}
token = lookahead();
if (token.type === Token.Identifier) {
label = parseVariableIdentifier();
if (!Object.prototype.hasOwnProperty.call(labelSet, label.name)) {
throwError({}, Messages.UnknownLabel, label.name);
}
}
consumeSemicolon();
if (label === null && !inIteration) {
throwError({}, Messages.IllegalContinue);
}
return {
type: Syntax.ContinueStatement,
label: label
};
}
|
javascript
|
{
"resource": ""
}
|
q13916
|
parseReturnStatement
|
train
|
function parseReturnStatement() {
var token, argument = null;
expectKeyword('return');
if (!inFunctionBody) {
throwErrorTolerant({}, Messages.IllegalReturn);
}
// 'return' followed by a space and an identifier is very common.
if (source[index] === ' ') {
if (isIdentifierStart(source[index + 1])) {
argument = parseExpression();
consumeSemicolon();
return {
type: Syntax.ReturnStatement,
argument: argument
};
}
}
if (peekLineTerminator()) {
return {
type: Syntax.ReturnStatement,
argument: null
};
}
if (!match(';')) {
token = lookahead();
if (!match('}') && token.type !== Token.EOF) {
argument = parseExpression();
}
}
consumeSemicolon();
return {
type: Syntax.ReturnStatement,
argument: argument
};
}
|
javascript
|
{
"resource": ""
}
|
q13917
|
SourceNodeMock
|
train
|
function SourceNodeMock(line, column, filename, chunk) {
var result = [];
function flatten(input) {
var i, iz;
if (isArray(input)) {
for (i = 0, iz = input.length; i < iz; ++i) {
flatten(input[i]);
}
} else if (input instanceof SourceNodeMock) {
result.push(input);
} else if (typeof input === 'string' && input) {
result.push(input);
}
}
flatten(chunk);
this.children = result;
}
|
javascript
|
{
"resource": ""
}
|
q13918
|
trimExtension
|
train
|
function trimExtension(filePath) {
const ext = path.extname(filePath);
return filePath.slice(0, filePath.length - ext.length);
}
|
javascript
|
{
"resource": ""
}
|
q13919
|
asDataMap
|
train
|
function asDataMap(files, mapping, callback) {
try {
const out = files.reduce((obj, file) => {
let key;
switch (mapping) {
case Mapping.DIR:
key = path.dirname(file.path);
break;
case Mapping.MODULE:
key = trimExtension(file.path).replace(PATH_SEP_RE, '.');
break;
default:
key = file.path;
break;
}
return Object.assign(obj, { [key]: file.data });
}, {});
async.nextTick(callback, null, out);
} catch (error) {
async.nextTick(callback, error);
}
}
|
javascript
|
{
"resource": ""
}
|
q13920
|
mkdir
|
train
|
function mkdir(dirPath, callback) {
// Credits: https://github.com/substack/node-mkdirp
// Recursively go through the parents.
const recurse = () => {
mkdir(path.dirname(dirPath), (error) => {
if (error) {
async.nextTick(callback, error);
return;
}
// Try again.
mkdir(dirPath, callback);
});
};
// Plan B for when things seem to go wrong.
const fallBack = () => {
fs.stat(dirPath, (error, stat) => {
if (error || !stat.isDirectory()) {
async.nextTick(
callback,
new Error(`${dirPath}: Could not create the directory`)
);
return;
}
async.nextTick(callback, null);
});
};
fs.mkdir(dirPath, (error) => {
if (!error) {
async.nextTick(callback, null);
return;
}
switch (error.code) {
case 'ENOENT':
recurse();
break;
default:
fallBack();
break;
}
});
}
|
javascript
|
{
"resource": ""
}
|
q13921
|
write
|
train
|
function write(filePath, data, mode, callback) {
async.series([
cb => mkdir(path.dirname(filePath), cb),
(cb) => {
if (mode === WriteMode.UTF8) {
fs.writeFile(filePath, data, 'utf8', (error) => {
if (error) {
console.error(`${filePath}: Could not write the file`);
}
async.nextTick(cb, error);
});
} else if (mode === WriteMode.STREAM) {
try {
data.pipe(fs.createWriteStream(filePath));
async.nextTick(cb, null);
} catch (error) {
console.error(`${filePath}: Could not create the write stream`);
async.nextTick(cb, error);
}
}
},
], error => async.nextTick(callback, error));
}
|
javascript
|
{
"resource": ""
}
|
q13922
|
shear
|
train
|
function shear(shx, shy) {
return {
a: 1, c: shx, e: 0,
b: shy, d: 1, f: 0
};
}
|
javascript
|
{
"resource": ""
}
|
q13923
|
apiUrlFor
|
train
|
function apiUrlFor (shortcode, size) {
if (!shortcode) throw new Error('shortcode parameter is required')
size = size || 'l'
var api = 'http://instagram.com/p/%s/media/?size=%s'
return util.format(api, shortcode, size)
}
|
javascript
|
{
"resource": ""
}
|
q13924
|
filenameFor
|
train
|
function filenameFor(shortcode, size) {
if (!shortcode) throw new Error('shortcode parameter is required')
size = size || 'l'
return [shortcode, size, 'jpg'].join('.')
}
|
javascript
|
{
"resource": ""
}
|
q13925
|
resolvedUrlFor
|
train
|
function resolvedUrlFor (shortcode, size, cb) {
if (typeof size === 'function') {
cb = size
size = 'l'
}
cb = cb || function () {}
var apiUrl = apiUrlFor(shortcode, size)
var opts = url.parse(apiUrl)
// http requests use the global Agent (connection pool) and defaults to `Connection: keep-alive`
// This causes the test suite to hang, so we explicitly set it to close.
// Alternatively, set `opts.agent: false` to opt out of connection pool and default to `Connection: close`
// see: http://nodejs.org/api/http.html#http_http_request_options_callback
opts.headers = {
Connection:'close'
}
http.get(opts, function (res) {
var url = res && res.headers && res.headers.location
if (!url) return cb(new Error('Couldn\'t get url; no `location` header on response'), res)
cb(null, url)
}).on('error', cb)
}
|
javascript
|
{
"resource": ""
}
|
q13926
|
binder
|
train
|
function binder(taskID) {
expected++;
return function(ret) {
expected--;
if(!returned && taskID !== 'false') {
if (typeof taskID == 'number') returned=[];
else if (typeof taskID == 'string') returned={};
};
taskID !== false ? returned[taskID]=ret : returned = ret;
// Timeout needed to increment expected, if next item exists.
// If it run without timeout, expected always be 0 and only
// the first function of the group will be executed.
setTimeout(function(){if (! expected) runQueue();},1);
}
}
|
javascript
|
{
"resource": ""
}
|
q13927
|
argumentFilter
|
train
|
function argumentFilter(args){
var ret;
if (typeof args[0] == 'object') {
args=args[0];
ret={};
for (var i in args) if (args.hasOwnProperty(i) && typeof args[i] == 'function') {
ret[i]=args[i];
}
return ret;
}
ret=[];
for (var i=0,ii=args.length;i<ii;i++) if (typeof args[i] == 'function') {
ret.push(args[i]);
}
return ret;
}
|
javascript
|
{
"resource": ""
}
|
q13928
|
runQueue
|
train
|
function runQueue() {
var lastReturned = returned instanceof Array ? returned : [returned]
, tasks = queued.shift();
if (tasks) tasks = tasks.tasks;
returned = undefined;
if (tasks instanceof Array) {
for (var t=0,tt=tasks.length; t<tt; t++) {
tasks[t].apply(taskObject(t),lastReturned);
};
return;
}
if (typeof tasks == 'object') {
for (var t in tasks) if (tasks.hasOwnProperty(t)) {
tasks[t].apply(taskObject(t),lastReturned);
}
return;
}
}
|
javascript
|
{
"resource": ""
}
|
q13929
|
enqueue
|
train
|
function enqueue(){
var tasks = argumentFilter(arguments);
queued.push({ tasks:tasks });
// Timeout needed to increment expected, if next item exists.
// If it run without timeout, expected always be 0 and the functions
// will be executed immediately obtaining undefined as parameter.
setTimeout(function(){if (! expected) runQueue();},1);
return enqueue;
}
|
javascript
|
{
"resource": ""
}
|
q13930
|
readableStream
|
train
|
function readableStream(stream) {
return new Promise(function(resolve, reject) {
var chunks = {
data: []
};
function onData(chunk) {
if (!chunks.type) {
chunks.type = chunkTypes[typeof chunk];
}
chunks.data.push(chunk);
}
function onEnd() {
if (chunks.type === chunkTypes.object) {
resolve(Buffer.concat(chunks.data));
}
else {
resolve(chunks.data.join(""));
}
}
function onError(error) {
reject(error);
}
stream
.on("error", onError)
.on("data", onData)
.on("end", onEnd);
});
}
|
javascript
|
{
"resource": ""
}
|
q13931
|
train
|
function( version ){
//lowercase
version = version.toLowerCase();
//Remove spaces;
version = version.replace( ' ', '' );
//Make delimiters all the same
version = version.replace( '-', '.' );
version = version.replace( '_', '.' );
version = version.replace( '+', '.' );
var length = version.length;
var newVersion = false;
newVersion = version[0];
for( var i=1; i < length; i++ ){
var a = version[i-1];
var b = version[i];
if( '.' === a || '.' === b ){
newVersion += b;
continue;
}
var sameType = ( isNaN( a ) === isNaN( b ) );
if( sameType ){
newVersion += b;
}else{
newVersion += "."+b;
}
}
//Split at delimiter
var versionArray = newVersion.split( '.' );
//Filter empty parts
versionArray = versionArray.filter( function(e){ return ( e !== "" ); } );
//Convert special text into character form.
versionArray = versionArray.map( function( e ){
switch( e ){
case 'alpha':
return 'a';
case 'beta':
return 'b';
case 'pl':
return 'p';
default:
return e;
}
} );
return versionArray.join('.');
}
|
javascript
|
{
"resource": ""
}
|
|
q13932
|
train
|
function ( version, options ){
var matches;
//First if version is 'readme' or 'plugin' version values
if( version === 'readme' ){
var readme = grunt.file.read( options.readme );
matches = readme.match( new RegExp("^Stable tag:\\s*(\\S+)","im") );
if( matches.length <= 1 ){
grunt.fail.fatal( 'Could not find version in "' + options.readme + '"' );
}
version = matches[1];
}else if( version === 'plugin' ){
var plugin = grunt.file.read( options.plugin );
matches = plugin.match( new RegExp("^[\* ]*Version:\\s*(\\S+)","im") );
if( matches.length <= 1 ){
grunt.fail.fatal( 'Could not find version in "' + options.readme + '"' );
}
version = matches[1];
}
return version;
}
|
javascript
|
{
"resource": ""
}
|
|
q13933
|
register
|
train
|
function register(app) {
//Check if registered twice
if (applicationCurrent === app) {
return;
}
//Only one application can be registered
if (applicationCurrent) {
throw new core.Error({
code: 'application-registered',
message: 'An application was already registered'
});
}
//Set all handlers
Interface.ensure(app, IApplication);
applicationCurrent = app;
currentHandlers.SIGINT = function () {
console.log('Application interrupted');
app.exit();
};
/*
FIXME: Eclipse bug
currentHandlers.SIGTERM = function () {
console.log('Killing in the name of!');
unregister();
process.exit();
};*/
currentHandlers.uncaughtException = function (error) {
app.handleError(error);
};
currentHandlers.exit = function () {
exports.unregister();
};
EVENTS.forEach(function (event) {
if (currentHandlers[event]) {
process.on(event, currentHandlers[event]);
}
});
//Start application
applicationCurrent.start();
}
|
javascript
|
{
"resource": ""
}
|
q13934
|
unregister
|
train
|
function unregister() {
if (!applicationCurrent) {
return;
}
applicationCurrent.stop();
EVENTS.forEach(function (event) {
process.removeListener(event, currentHandlers[event]);
});
applicationCurrent = null;
currentHandlers = {};
}
|
javascript
|
{
"resource": ""
}
|
q13935
|
train
|
function (config) {
config = config || {};
if (config.onStart !== undefined) {
if (!isFunction(config.onStart)) {
throw new core.TypeError({
code: 'application-configure',
message: "config.onStart must be a function"
});
}
this.onStart = config.onStart;
}
if (config.onStop !== undefined) {
if (!isFunction(config.onStop)) {
throw new core.TypeError({
code: 'application-configure',
message: "config.onStop must be a function"
});
}
this.onStop = config.onStop;
}
return this;
}
|
javascript
|
{
"resource": ""
}
|
|
q13936
|
train
|
function (error) {
if (!this.started) {
return;
}
var errorHandlers = this.errorHandlers,
length = errorHandlers.length,
errorHandler,
errorHandled = false,
errorString,
i;
//Exit handling
if (error instanceof SystemExit) {
this._exit(error.code);
return;
}
try {
for (i = 0; i < length; i += 1) {
errorHandler = errorHandlers[i];
errorHandled = !!errorHandler(error);
if (errorHandled) {
return;
}
}
} catch (e) {
this._printError(e);
this._exit(1);
}
//Default error handling
errorString = '' + (error.stack || error);
this._printError(errorString);
this._exit(1);
}
|
javascript
|
{
"resource": ""
}
|
|
q13937
|
train
|
function(name, data, options) {
options = options || {};
var request = Parse._request({
route: "functions",
className: name,
method: 'POST',
useMasterKey: options.useMasterKey,
data: Parse._encode(data, null, true)
});
return request.then(function(resp) {
return Parse._decode(null, resp).result;
})._thenRunCallbacks(options);
}
|
javascript
|
{
"resource": ""
}
|
|
q13938
|
train
|
function (/**Array|Object*/tmpl, /**Object*/data) /**String*/{
var res= "";
// there are thre possible declarations array of functions, string and function
// array case
if (franky.isArray(tmpl)) {
res = franky.map(tmpl, function (item) {
return typeof item === "string" ?
item:
item(data);
}).join("");
// function case
} else if (franky.isFunction(tmpl)) {
res = tmpl(data);
// default string case
} else {
res = tmpl.toString();
}
return res;
}
|
javascript
|
{
"resource": ""
}
|
|
q13939
|
train
|
function (/**String*/name, /**Object*/data) /**String*/ {
var self = this;
var template = data && data.views ?
data.views.templates[name] : this.templates[name];
if(!template){
return '';
}
return self.getContent(template, data);
}
|
javascript
|
{
"resource": ""
}
|
|
q13940
|
fixInitialSelection
|
train
|
function fixInitialSelection( root, nativeSel, doFocus ) {
// It may happen that setting proper selection will
// cause focus to be fired (even without actually focusing root).
// Cancel it because focus shouldn't be fired when retriving selection. (#10115)
var listener = root.on( 'focus', function( evt ) {
evt.cancel();
}, null, null, -100 );
// FF && Webkit.
if ( !CKEDITOR.env.ie ) {
var range = new CKEDITOR.dom.range( root );
range.moveToElementEditStart( root );
var nativeRange = root.getDocument().$.createRange();
nativeRange.setStart( range.startContainer.$, range.startOffset );
nativeRange.collapse( 1 );
nativeSel.removeAllRanges();
nativeSel.addRange( nativeRange );
}
else {
// IE in specific case may also fire selectionchange.
// We cannot block bubbling selectionchange, so at least we
// can prevent from falling into inf recursion caused by fix for #9699
// (see wysiwygarea plugin).
// http://dev.ckeditor.com/ticket/10438#comment:13
var listener2 = root.getDocument().on( 'selectionchange', function( evt ) {
evt.cancel();
}, null, null, -100 );
}
doFocus && root.focus();
listener.removeListener();
listener2 && listener2.removeListener();
}
|
javascript
|
{
"resource": ""
}
|
q13941
|
hideSelection
|
train
|
function hideSelection( editor ) {
var style = CKEDITOR.env.ie ? 'display:none' : 'position:fixed;top:0;left:-1000px',
hiddenEl = CKEDITOR.dom.element.createFromHtml(
'<div data-cke-hidden-sel="1" data-cke-temp="1" style="' + style + '"> </div>',
editor.document );
editor.fire( 'lockSnapshot' );
editor.editable().append( hiddenEl );
// Always use real selection to avoid overriding locked one (http://dev.ckeditor.com/ticket/11104#comment:13).
var sel = editor.getSelection( 1 ),
range = editor.createRange(),
// Cancel selectionchange fired by selectRanges - prevent from firing selectionChange.
listener = sel.root.on( 'selectionchange', function( evt ) {
evt.cancel();
}, null, null, 0 );
range.setStartAt( hiddenEl, CKEDITOR.POSITION_AFTER_START );
range.setEndAt( hiddenEl, CKEDITOR.POSITION_BEFORE_END );
sel.selectRanges( [ range ] );
listener.removeListener();
editor.fire( 'unlockSnapshot' );
// Set this value at the end, so reset() executed by selectRanges()
// will clean up old hidden selection container.
editor._.hiddenSelectionContainer = hiddenEl;
}
|
javascript
|
{
"resource": ""
}
|
q13942
|
getOnKeyDownListener
|
train
|
function getOnKeyDownListener( editor ) {
var keystrokes = { 37: 1, 39: 1, 8: 1, 46: 1 };
return function( evt ) {
var keystroke = evt.data.getKeystroke();
// Handle only left/right/del/bspace keys.
if ( !keystrokes[ keystroke ] )
return;
var sel = editor.getSelection(),
ranges = sel.getRanges(),
range = ranges[ 0 ];
// Handle only single range and it has to be collapsed.
if ( ranges.length != 1 || !range.collapsed )
return;
var next = range[ keystroke < 38 ? 'getPreviousEditableNode' : 'getNextEditableNode' ]();
if ( next && next.type == CKEDITOR.NODE_ELEMENT && next.getAttribute( 'contenteditable' ) == 'false' ) {
editor.getSelection().fake( next );
evt.data.preventDefault();
evt.cancel();
}
};
}
|
javascript
|
{
"resource": ""
}
|
q13943
|
getNonEditableFakeSelectionReceiver
|
train
|
function getNonEditableFakeSelectionReceiver( ranges ) {
var enclosedNode, shrinkedNode, clone, range;
if ( ranges.length == 1 && !( range = ranges[ 0 ] ).collapsed &&
( enclosedNode = range.getEnclosedNode() ) && enclosedNode.type == CKEDITOR.NODE_ELEMENT ) {
// So far we can't say that enclosed element is non-editable. Before checking,
// we'll shrink range (clone). Shrinking will stop on non-editable range, or
// innermost element (#11114).
clone = range.clone();
clone.shrink( CKEDITOR.SHRINK_ELEMENT, true );
// If shrinked range still encloses an element, check this one (shrink stops only on non-editable elements).
if ( ( shrinkedNode = clone.getEnclosedNode() ) && shrinkedNode.type == CKEDITOR.NODE_ELEMENT )
enclosedNode = shrinkedNode;
if ( enclosedNode.getAttribute( 'contenteditable' ) == 'false' )
return enclosedNode;
}
}
|
javascript
|
{
"resource": ""
}
|
q13944
|
onHover
|
train
|
function onHover( evt ) {
evt = evt.data.$;
if ( textRng ) {
// Read the current cursor.
var rngEnd = body.$.createTextRange();
moveRangeToPoint( rngEnd, evt.clientX, evt.clientY );
// Handle drag directions.
textRng.setEndPoint(
startRng.compareEndPoints( 'StartToStart', rngEnd ) < 0 ?
'EndToEnd' : 'StartToStart', rngEnd );
// Update selection with new range.
textRng.select();
}
}
|
javascript
|
{
"resource": ""
}
|
q13945
|
train
|
function() {
if ( this._.cache.nativeSel !== undefined )
return this._.cache.nativeSel;
return ( this._.cache.nativeSel = isMSSelection ? this.document.$.selection : this.document.getWindow().$.getSelection() );
}
|
javascript
|
{
"resource": ""
}
|
|
q13946
|
train
|
function() {
var range = self.getRanges()[ 0 ].clone(),
enclosed, selected;
// Check first any enclosed element, e.g. <ul>[<li><a href="#">item</a></li>]</ul>
for ( var i = 2; i && !( ( enclosed = range.getEnclosedNode() ) && ( enclosed.type == CKEDITOR.NODE_ELEMENT ) && styleObjectElements[ enclosed.getName() ] && ( selected = enclosed ) ); i-- ) {
// Then check any deep wrapped element, e.g. [<b><i><img /></i></b>]
range.shrink( CKEDITOR.SHRINK_ELEMENT );
}
return selected && selected.$;
}
|
javascript
|
{
"resource": ""
}
|
|
q13947
|
train
|
function() {
this._.cache = {};
this.isFake = 0;
var editor = this.root.editor;
// Invalidate any fake selection available in the editor.
if ( editor && editor._.fakeSelection ) {
// Test whether this selection is the one that was
// faked or its clone.
if ( this.rev == editor._.fakeSelection.rev ) {
delete editor._.fakeSelection;
removeHiddenSelectionContainer( editor );
}
// jshint ignore:start
// TODO after #9786 use commented out lines instead of console.log.
else { // %REMOVE_LINE%
window.console && console.log( 'Wrong selection instance resets fake selection.' ); // %REMOVE_LINE%
} // %REMOVE_LINE%
// else // %REMOVE_LINE%
// CKEDITOR.debug.error( 'Wrong selection instance resets fake selection.', CKEDITOR.DEBUG_CRITICAL ); // %REMOVE_LINE%
// jshint ignore:end
}
this.rev = nextRev++;
}
|
javascript
|
{
"resource": ""
}
|
|
q13948
|
train
|
function( element ) {
var editor = this.root.editor;
// Cleanup after previous selection - e.g. remove hidden sel container.
this.reset();
hideSelection( editor );
// Set this value after executing hiseSelection, because it may
// cause reset() which overwrites cache.
var cache = this._.cache;
// Caches a range than holds the element.
var range = new CKEDITOR.dom.range( this.root );
range.setStartBefore( element );
range.setEndAfter( element );
cache.ranges = new CKEDITOR.dom.rangeList( range );
// Put this element in the cache.
cache.selectedElement = cache.startElement = element;
cache.type = CKEDITOR.SELECTION_ELEMENT;
// Properties that will not be available when isFake.
cache.selectedText = cache.nativeSel = null;
this.isFake = 1;
this.rev = nextRev++;
// Save this selection, so it can be returned by editor.getSelection().
editor._.fakeSelection = this;
// Fire selectionchange, just like a normal selection.
this.root.fire( 'selectionchange' );
}
|
javascript
|
{
"resource": ""
}
|
|
q13949
|
train
|
function() {
var el = this.getCommonAncestor();
if ( el && el.type == CKEDITOR.NODE_TEXT )
el = el.getParent();
return !!( el && el.data( 'cke-hidden-sel' ) );
}
|
javascript
|
{
"resource": ""
}
|
|
q13950
|
train
|
function() {
// Don't clear selection outside this selection's root (#11500).
if ( this.getType() == CKEDITOR.SELECTION_NONE )
return;
var nativ = this.getNative();
try {
nativ && nativ[ isMSSelection ? 'empty' : 'removeAllRanges' ]();
} catch ( er ) {}
this.reset();
}
|
javascript
|
{
"resource": ""
}
|
|
q13951
|
_multiCallback
|
train
|
function _multiCallback(serverError, serverResponse, callback, interleave, requestedIds){
var clientResponse = {};
// Handle response errors
_.each(serverResponse, function(data, id){
var thisError = serverError;
if(serverError && data.status.code !== 200){
thisError = new Error(data.status.msgs.join('. '));
thisError.code = data.status.code;
}
clientResponse[id] = {
error: thisError,
data: data.data
};
});
// Handle request level errors
if(serverError && !serverResponse){
_.each(requestedIds, function(id){
if(_.isUndefined(clientResponse[id])){
clientResponse[id] = {
error: serverError,
data: null
};
}
});
}
// Interleave validation errors
if(interleave){
_.extend(clientResponse, interleave);
}
callback(clientResponse);
}
|
javascript
|
{
"resource": ""
}
|
q13952
|
Providence
|
train
|
function Providence(options = NOT_SET, skipDataCheck = false, skipProcessOptions = false) {
if(options === NOT_SET) {
throw new Error('Expected options to be a plain object or an Immutable Map');
}
// This will not support constructors that are extending Providence.
// They should provide their own setup in their constructor function.
if(!(this instanceof Providence)) {
return new Providence(options, skipDataCheck, skipProcessOptions);
}
this._options = skipProcessOptions ? options : processOptions(options);
// Used for caching value of the Providence object.
// When the unboxed root data and this._refUnboxedRootData are equal,
// then unboxed root data hasn't changed since the previous look up, and thus
// this._cachedValue and value at path also hasn't changed.
this._refUnboxedRootData = NOT_SET;
this._cachedValue = NOT_SET;
if(!skipDataCheck && this._options.getIn(DATA_PATH, NOT_SET) === NOT_SET) {
throw new Error("value at path ['root', 'data'] is required!")
}
}
|
javascript
|
{
"resource": ""
}
|
q13953
|
_set
|
train
|
function _set (data, keys, value) {
var i = 0;
var prop;
var length = keys.length;
for(; i < length; i ++){
prop = keys[i];
if (i === length - 1) {
// if the last key, set value
data[prop] = value;
return;
}
if (
!(prop in data)
// If the current value is not an object, we will override it.
// The logic who invoke `.set()` method should make sure `data[prop]` is an object,
// which `.set()` doesn't concern
|| !is_object(data[prop])
) {
data[prop] = {};
}
data = data[prop];
}
}
|
javascript
|
{
"resource": ""
}
|
q13954
|
pull
|
train
|
function pull(xs, x) {
const idx = xs.indexOf(x);
if (idx > -1) {
xs.splice(idx, 1);
}
}
|
javascript
|
{
"resource": ""
}
|
q13955
|
exec
|
train
|
function exec() {
var actions = {
commands: {
'list-dependencies': { action: _listDependencies },
'list-devdependencies': { action: _listDevDependencies },
'list-peerdependencies': { action: _listPeerDependencies },
'list-optdependencies': { action: _listOptDependencies },
'list-alldependencies': { action: _listAllDependencies },
'set-node-engine': { action: _setNodeEngine },
'sort-dependencies': { action: _sortDependencies },
'sort-devdependencies': { action: _sortDevDependencies },
'sort-peerdependencies': { action: _sortPeerDependencies },
'sort-optdependencies': { action: _sortOptDependencies },
'sort-alldependencies': { action: _sortAllDependencies },
'traverse-dependencies': { action: _traverseDependencies },
'upgrade-version-patch': { action: _upgradeVersionPatch },
'upgrade-version-minor': { action: _upgradeVersionMinor },
'upgrade-version-major': { action: _upgradeVersionMajor },
'upgrade-version': { action: _upgradeVersionPatch },
'upgrade-dependencies': { action: _upgradeDependencies },
}
};
cli.command(__dirname, actions);
}
|
javascript
|
{
"resource": ""
}
|
q13956
|
cached
|
train
|
function cached(grammar_file) {
var fs = require('fs'),
path = require('path'),
change = fs.statSync(grammar_file).mtime.valueOf(),
cache = [cache_path,'/', path.basename(grammar_file), '.', change, '.js'].join('');
if(!fs.existsSync(cache_path))
fs.mkdirSync(cache_path);
if(fs.existsSync(cache))
return fs.readFileSync(cache, 'utf8');
var result = load(grammar_file);
fs.writeFileSync(cache, result);
return result;
}
|
javascript
|
{
"resource": ""
}
|
q13957
|
load
|
train
|
function load(grammar_file) {
var fs = require('fs'),
grammar = fs.readFileSync(grammar_file, 'utf-8');
return compile(grammar)
}
|
javascript
|
{
"resource": ""
}
|
q13958
|
run
|
train
|
function run(grammar, module, filename) {
// this is used to bind OMeta to runtime. It can be used also (lateron) to dynamically
// inject other environment-variables.
// {a:1,b:2,c:3,d:4} -> function(a,b,c,d) {...}.call(1,2,3,4)
// this is better than `with`, since it offers full control
var source = [
"module.grammar = (function(OMeta) {",
grammar,
"});"
].join('');
module._compile(source, filename);
module.grammar.call(module, ometa);
return module.exports;
}
|
javascript
|
{
"resource": ""
}
|
q13959
|
_apply
|
train
|
function _apply(func, thisArg, promisedArgs) {
return well.all(promisedArgs || []).then(function(args) {
return func.apply(thisArg, args);
});
}
|
javascript
|
{
"resource": ""
}
|
q13960
|
lift
|
train
|
function lift(func /*, args... */) {
var args = slice.call(arguments, 1);
return function() {
return _apply(func, this, args.concat(slice.call(arguments)));
};
}
|
javascript
|
{
"resource": ""
}
|
q13961
|
createStack
|
train
|
function createStack(app) {
if (!app) {
throw new Error("Pack-n-stack requires an express/connect app");
};
app = utils.merge(app, proto);
Object.defineProperty(app, "count", {
get: function() {
return app.stack.length;
}
});
return app;
}
|
javascript
|
{
"resource": ""
}
|
q13962
|
loadConfig
|
train
|
function loadConfig(filename) {
//Does our consumer have a valid .mitto?
var mittoObject = _loadMitto();
//Is it in a valid format?
mittoObject = _validateMitto(mittoObject);
//Does our consumer's consumer have a config of 'filename'?
var configObject = _findFile(filename);
//Is it in a valid format as prescribed by our consumer's .mitto?
return _validateConfig(configObject, mittoObject);
}
|
javascript
|
{
"resource": ""
}
|
q13963
|
_findFile
|
train
|
function _findFile(filename) {
var cwd = process.cwd();
var parts = cwd.split(_path2.default.sep);
do {
var loc = parts.join(_path2.default.sep);
if (!loc) break;
var file = _path2.default.join(loc, filename);
if (_fs2.default.existsSync(file)) {
var fileObj = undefined;
try {
fileObj = require(file);
} catch (e) {
fileObj = _loadJSON(file);
}
return fileObj;
}
parts.pop();
} while (parts.length);
return null;
}
|
javascript
|
{
"resource": ""
}
|
q13964
|
_validateMitto
|
train
|
function _validateMitto(mittoObject) {
if (!mittoObject) {
return null;
}
if (!mittoObject.hasOwnProperty("name")) {
throw new Error("\"name\" property is missing from your .mitto and is required.");
}
if (mittoObject.hasOwnProperty("required")) {
for (var key in mittoObject.required) {
if (mittoObject.required[key].hasOwnProperty("type")) {
if (DATA_TYPES.indexOf(mittoObject.required[key].type) === -1) {
throw new Error(mittoObject.required[key].type + " is not a valid data type. Expected: \"undefined\", \"object\", \"boolean\", \"number\", \"string\", \"symbol\", or \"function\"");
}
} else {
throw new Error("\"type\" property is missing from your .mitto's required parameter \"" + key + "\"");
}
if (mittoObject.required[key].hasOwnProperty("description") && typeof mittoObject.required[key].description !== "string") {
throw new Error("\"description\" property of your .mitto's required parameter " + key + " must be of type \"string\"");
}
}
}
if (mittoObject.hasOwnProperty("optional")) {
for (var key in mittoObject.optional) {
if (mittoObject.optional[key].hasOwnProperty("type")) {
if (DATA_TYPES.indexOf(mittoObject.optional[key].type) === -1) {
throw new Error(mittoObject.optional[key].type + " is not a valid data type. Expected: \"undefined\", \"object\", \"boolean\", \"number\", \"string\", \"symbol\", or \"function\"");
}
} else {
throw new Error("\"type\" property is missing from your .mitto's optional parameter " + key);
}
if (mittoObject.optional[key].hasOwnProperty("description") && typeof mittoObject.optional[key].description !== "string") {
throw new Error("\"description\" property of your .mitto's optional parameter " + key + " must be of type \"string\"");
}
if (mittoObject.optional[key].hasOwnProperty("default") && _typeof(mittoObject.optional[key].default) !== mittoObject.optional[key].type) {
throw new Error("\"default\" property of your .mitto's optional parameter " + key + " must be a " + mittoObject.optional[key].type + ", as specified by \"type\"");
} else if (mittoObject.optional[key].hasOwnProperty("default")) {
mittoObject.hasDefault = true;
}
}
}
return mittoObject;
}
|
javascript
|
{
"resource": ""
}
|
q13965
|
_validateConfig
|
train
|
function _validateConfig(configObject, mittoObject) {
var packageObject = _findFile('package.json');
if (!mittoObject) {
return configObject;
}
if (!configObject && mittoObject.required && Object.keys(mittoObject.required).length) {
throw new Error(mittoObject.name + " configuration file not found, and is required by " + packageObject.name);
} else if (!configObject && mittoObject.hasDefault) {
return _addOnDefaults({}, mittoObject);
} else if (!configObject) {
return configObject;
}
for (var key in mittoObject.required) {
if (!configObject.hasOwnProperty(key)) {
throw new Error("Required property " + key + " not found in " + mittoObject.name);
} else if (_typeof(configObject[key]) !== mittoObject.required[key].type) {
throw new Error("Required property " + key + " expected to be of type " + mittoObject.required[key].type);
}
}
for (var key in mittoObject.optional) {
if (configObject[key] && _typeof(configObject[key]) !== mittoObject.optional[key].type) {
throw new Error("Optional property " + key + " is type " + _typeof(configObject[key]) + " and expected to be of type " + mittoObject.optional[key].type);
}
}
if (mittoObject.hasDefault) {
return _addOnDefaults(configObject, mittoObject);
}
return configObject;
}
|
javascript
|
{
"resource": ""
}
|
q13966
|
parse
|
train
|
function parse (tmpl) {
tmpl = tmpl || ''
const parser = uritemplate.parse(tmpl)
return function expand (params) {
params = params || {}
return parser.expand(params)
}
}
|
javascript
|
{
"resource": ""
}
|
q13967
|
prostrate
|
train
|
function prostrate(source){
return function(method, transform){
transform = transform || {};
return function(){
var args = Array.prototype.slice.call(arguments, 0),
fn = args.pop(),
res,
last;
if(args[0] && ['removeItem', 'getItem', 'setItem'].indexOf(method) > -1){
var id = args[0];
id = id.toString();
if(id.indexOf(module.exports.ns) === -1){
id = module.exports.ns + id;
}
args[0] = id;
}
if(args.length == 2 && transform.before){
args[1] = transform.before(args[1]);
}
if(method === 'key'){
assert(typeof args[0] === 'number', args[0] + ' must be a number');
}
if(!source[method]){
throw new Error('Unknown localstorage method ' + method);
}
else{
if(source[method].apply){
res = source[method].apply(source, args);
debug('result for ' + method, '(', args, ')', res);
}
else {
res = source[method];
}
}
try{
if(transform.after){
res = transform.after(res);
}
}
catch(e){}
fn(null, res);
};
};
}
|
javascript
|
{
"resource": ""
}
|
q13968
|
train
|
function(args){
return forEach(args,function(_,item){
var messages = this.result,
type = typeof item;
if (type == 'string') {
messages.push('%s');
} else if (type == 'number') {
messages.push('%d');
} else if (type == 'boolean') {
messages.push('%s');
} else {
messages.push('%O');
}
},[]);
}
|
javascript
|
{
"resource": ""
}
|
|
q13969
|
train
|
function(context,args,error,color){
var me = this,
base = context.getCalledKlass(),
contextName = base ? base.getName() : CONSTANTS.LOGGER.UNKNOWN_NAME,
methodName = context.getCalledName() || CONSTANTS.LOGGER.ANONYMOUS_NAME,
messages = me.toMessages(args);
color = color || (error ? CONSTANTS.LOGGER.EXCEPTION_COLOR : CONSTANTS.LOGGER.SUCCESS_COLOR);
if (context) {
if (context.deepLoggingLevel || methodName == CONSTANTS.LOGGER.ANONYMOUS_NAME) {
var deepTrace = me.analyze(context);
console.groupCollapsed.apply(console,[('[node-klass-logger] ' + contextName + '.' + methodName + messages.join(' '))[color]].concat(args));
console.log(('[node-klass-logger] ' + deepTrace)[color]);
console.groupEnd();
} else {
console.log.apply(console,[('[node-klass-logger] ' + contextName + '.' + methodName + messages.join(' '))[color]].concat(args));
}
} else {
console.log.apply(console,[('[node-klass-logger]' + messages.join(' '))[color]].concat(args));
}
}
|
javascript
|
{
"resource": ""
}
|
|
q13970
|
resetWorker
|
train
|
function resetWorker() {
sigqueue = [];
mastersigs.forEach(process.removeAllListeners.bind(process));
process.removeAllListeners('exit');
process.env.TIAMAT = '1';
}
|
javascript
|
{
"resource": ""
}
|
q13971
|
train
|
function (res, name, version) {
//Options
var imgPath, width;
//RegExp
var re = /^\d\.\d.\d$/;
//Test version
if (re.test(version)) {
imgPath = path.join(dir, name + '.png');
width = 76;
} else if (version.length === 6) {
imgPath = path.join(dir, name + '-larger.png');
width = 80;
} else if (version.length === 7) {
imgPath = path.join(dir, name + '-larger.png');
width = 77;
} else {
imgPath = path.join(dir, name + '-larger.png');
width = 74;
}
//Create Image
var base = gm(imgPath)
.font(path.join(__dirname, 'fonts', 'Arial.ttf'))
.fontSize(10)
.fill('#ffffff')
.drawText(width, 12, version);
//Write Stream and send to client
write(base, res);
}
|
javascript
|
{
"resource": ""
}
|
|
q13972
|
train
|
function (service, name, user) {
//
var services = [];
//
services['gh'] = 'https://api.github.com/repos/:user/:name/releases';
services['npm'] = 'http://registry.npmjs.org/:name/latest';
services['gem'] = 'https://rubygems.org/api/v1/gems/:name.json';
services['bower'] = 'https://api.github.com/repos/:user/:name/releases';
var str = services[service].replace(':name', name).replace(':user', user);
//
return str;
}
|
javascript
|
{
"resource": ""
}
|
|
q13973
|
train
|
function (service, data) {
switch (service) {
case 'gh':
return data[0].tag_name.replace(/^v/, '');
case 'npm':
return data.version;
case 'gem':
return data.version;
case 'bower':
return data[0].tag_name.replace(/^v/, '');
default:
console.log(service + 'not found!');
break;
}
}
|
javascript
|
{
"resource": ""
}
|
|
q13974
|
train
|
function( names, callback, scope ) {
// Ensure that we have an array of names.
if ( !CKEDITOR.tools.isArray( names ) )
names = names ? [ names ] : [];
var loaded = this.loaded,
registered = this.registered,
urls = [],
urlsNames = {},
resources = {};
// Loop through all names.
for ( var i = 0; i < names.length; i++ ) {
var name = names[ i ];
if ( !name )
continue;
// If not available yet.
if ( !loaded[ name ] && !registered[ name ] ) {
var url = this.getFilePath( name );
urls.push( url );
if ( !( url in urlsNames ) )
urlsNames[ url ] = [];
urlsNames[ url ].push( name );
} else {
resources[ name ] = this.get( name );
}
}
CKEDITOR.scriptLoader.load( urls, function( completed, failed ) {
if ( failed.length ) {
throw '[CKEDITOR.resourceManager.load] Resource name "' + urlsNames[ failed[ 0 ] ].join( ',' ) +
'" was not found at "' + failed[ 0 ] + '".';
}
for ( var i = 0; i < completed.length; i++ ) {
var nameList = urlsNames[ completed[ i ] ];
for ( var j = 0; j < nameList.length; j++ ) {
var name = nameList[ j ];
resources[ name ] = this.get( name );
loaded[ name ] = 1;
}
}
callback.call( scope, resources );
}, this );
}
|
javascript
|
{
"resource": ""
}
|
|
q13975
|
load
|
train
|
function load(file) {
if (path.extname(file) === ".yaml" || path.extname(file) === ".yml") {
return yaml.safeLoad(fs.readFileSync(file));
} else if (path.extname(file) === ".json") {
var r = JSON.parse(fs.readFileSync(file));
return r;
} else if (path.extname(file) === ".js") {
var obj = require(file);
if (typeof(obj) !== "object") {
throw {error: "needs to export object, not "+typeof(obj), file: file};
} else {
return clone(obj);
}
} else {
throw {error: path+" has invalid extension: "+path.extname(file)};
}
}
|
javascript
|
{
"resource": ""
}
|
q13976
|
addOffset
|
train
|
function addOffset(element, event) {
event.offsetX = Math.round(event.pageX - element.offset().left);
event.offsetY = Math.round(event.pageY - element.offset().top);
return event;
}
|
javascript
|
{
"resource": ""
}
|
q13977
|
getRoute
|
train
|
function getRoute(id, params, callback) {
params = params || {};
core.callApiWithPathSegment('/TravelTimesService/v1.0/Routes', id, params, callback);
}
|
javascript
|
{
"resource": ""
}
|
q13978
|
readTasks
|
train
|
function readTasks(err, data, callback) {
this.tasks = JSON.parse(data);
var sortedTasks = _.sortBy(this.tasks, function(task) { return parseInt(task.id, 10); });
largestID = sortedTasks[sortedTasks.length-1].id;
if(callback) {
callback(err, this);
}
}
|
javascript
|
{
"resource": ""
}
|
q13979
|
addTask
|
train
|
function addTask(taskData, subTaskData) {
var subTaskList,
parsedData,
subTask = false;
if(taskData !== undefined) {
if(parseInt(taskData,10) > -1) {
subTaskList = this.getTaskByID(parseInt(taskData,10)).subTasks;
parsedData = this.parseInputData(subTaskData);
subTask = true;
}
else {
parsedData = this.parseInputData(taskData);
}
var newTask = _.clone(defaultTask)
_.extend(newTask, parsedData);
newTask.dateAdded = Date.now();
newTask.id = largestID + 1;
newTask.subTask = subTask;
this.tasks.unshift( newTask );
if(subTask) {
subTaskList.push(newTask.id);
}
console.log('Added:');
return newTask;
}
else {
console.log('no task name given');
return false;
}
}
|
javascript
|
{
"resource": ""
}
|
q13980
|
closeTask
|
train
|
function closeTask(taskID) {
taskID = parseInt(taskID, 10);
var task = this.getTaskByID(taskID);
if(task) {
task.open = false;
console.log('closing:');
return task;
}
else {
return false;
}
}
|
javascript
|
{
"resource": ""
}
|
q13981
|
getExample
|
train
|
function getExample(countryCode, numberType, national) {
try {
var phoneUtil = i18n.phonenumbers.PhoneNumberUtil.getInstance();
var numberObj = phoneUtil.getExampleNumberForType(countryCode, numberType);
var format = (national) ? i18n.phonenumbers.PhoneNumberFormat.NATIONAL : i18n.phonenumbers.PhoneNumberFormat.INTERNATIONAL;
return phoneUtil.format(numberObj, format);
} catch (e) {
return "";
}
}
|
javascript
|
{
"resource": ""
}
|
q13982
|
format
|
train
|
function format(number, countryCode, type) {
try {
var phoneUtil = i18n.phonenumbers.PhoneNumberUtil.getInstance();
var numberObj = phoneUtil.parseAndKeepRawInput(number, countryCode || '');
type = (typeof type == "undefined") ? i18n.phonenumbers.PhoneNumberFormat.INTERNATIONAL : type;
if (type == 0) {
return phoneUtil.format(numberObj, i18n.phonenumbers.PhoneNumberFormat.INTERNATIONAL).replace(/[\-\(\)\s\.]/g, '').replace('ext', ',');
}
return phoneUtil.format(numberObj, type);
} catch (e) {
return "";
}
}
|
javascript
|
{
"resource": ""
}
|
q13983
|
isValid
|
train
|
function isValid(number, countryCode) {
try {
var phoneUtil = i18n.phonenumbers.PhoneNumberUtil.getInstance();
var numberObj = phoneUtil.parseAndKeepRawInput(number, countryCode);
return phoneUtil.isValidNumber(numberObj);
} catch (e) {
return false;
}
}
|
javascript
|
{
"resource": ""
}
|
q13984
|
create
|
train
|
function create(fileToCreate) {
//Creating a unique channel to get the response
var topicUid = shortid.generate();
var topicParams = {topicUid: topicUid, itemToCreate: fileToCreate};
var donePromise = mediator.promise(fileSubscribers.getTopic(CONSTANTS.TOPICS.CREATE, CONSTANTS.DONE_PREFIX, topicUid));
var errorPromise = mediator.promise(fileSubscribers.getTopic(CONSTANTS.TOPICS.CREATE, CONSTANTS.ERROR_PREFIX, topicUid));
mediator.publish(fileSubscribers.getTopic(CONSTANTS.TOPICS.CREATE), topicParams);
return getTopicPromises(donePromise, errorPromise);
}
|
javascript
|
{
"resource": ""
}
|
q13985
|
list
|
train
|
function list() {
var donePromise = mediator.promise(fileSubscribers.getTopic(CONSTANTS.TOPICS.LIST, CONSTANTS.DONE_PREFIX));
var errorPromise = mediator.promise(fileSubscribers.getTopic(CONSTANTS.TOPICS.LIST, CONSTANTS.ERROR_PREFIX));
mediator.publish(fileSubscribers.getTopic(CONSTANTS.TOPICS.LIST));
return getTopicPromises(donePromise, errorPromise);
}
|
javascript
|
{
"resource": ""
}
|
q13986
|
addTrack
|
train
|
function addTrack(options) {
return new Promise(function (resolve, reject) {
var form = new FormData();
form.append('format', 'json');
if (!options.title) {
reject('Error while addTrack track options.title is required but is null');
} else {
form.append('track[title]', options.title);
}
if (!options.description) {
reject('Error while addTrack track options.description is required but is null');
} else {
form.append('track[description]', options.description);
}
if (!options.genre) {
reject('Error while addTrack track options.genre is required but is null');
} else {
form.append('track[genre]', options.genre);
}
var exist_artwork_data = fs.existsSync(options.artwork_data);
if (exist_artwork_data) {
form.append('track[artwork_data]', fs.createReadStream(options.artwork_data));
}
if (options.tag_list) {
form.append('track[tag_list]', options.tag_list);
}
form.append('track[sharing]', options.sharing);
if (!options.oauth_token) {
reject('Error while addTrack track oauth_token is required but is null');
} else {
form.append('oauth_token', options.oauth_token);
}
if (!options.asset_data) {
reject('Error while addTrack track options.asset_data is required but is null');
} else {
var exist_asset_data = fs.existsSync(options.asset_data);
if (DEBUG_MODE_ON) {
console.log("addTrack, exist_asset_data, ", exist_asset_data);
}
if (exist_asset_data) {
form.append('track[asset_data]', fs.createReadStream(options.asset_data));
} else {
reject('Error addTrack could not find options.asset_data --> fs.createReadStream(options.asset_data): ' + exist_asset_data);
}
}
form.getLength(function (err, length) {
fetch('https://api.soundcloud.com/tracks', {
method: 'POST',
body: form,
headers: {'content-length': length}
}).then(function (res) {
return res.json();
}).then(function (json) {
if (DEBUG_MODE_ON) {
console.log('addTrack successful');
}
resolve(json);
}).catch(function (e) {
reject(e);
});
});
});
}
|
javascript
|
{
"resource": ""
}
|
q13987
|
removeAllTracks
|
train
|
function removeAllTracks(tracks, token, count, callback) {
var track = tracks[count];
if (!track) {
return callback('done');
}
var options = {
id: track.id,
oauth_token: token.oauth_token
};
removeTrack(options).then(function (track) {
if (DEBUG_MODE_ON) {
console.log('removeTrack, ', track);
}
count = count + 1;
removeAllTracks(tracks, token, count, callback)
}).catch(function (err) {
console.log('ERROR: removeTrack, ', err);
count = count + 1;
removeAllTracks(tracks, token, count, callback)
})
}
|
javascript
|
{
"resource": ""
}
|
q13988
|
searchTrack_q
|
train
|
function searchTrack_q(options) {
return new Promise(function (resolve, reject) {
if (!options.oauth_token) {
reject(new Error('Error searchTrack_q oauth_token is required and is null '));
} else {
if (!options.q) {
reject(new Error('Error searchTrack_q options.q is required and is null'));
} else {
var uri = 'https://api.soundcloud.com/me/tracks?format=json&oauth_token=' + options.oauth_token + '&q=' + options.q;
if (DEBUG_MODE_ON) {
console.log("searchTrack_q URI, ", uri);
}
request.getAsync(uri, {timeout: 10000}).spread(function (response, body) {
//console.log('searchTrack_q successful',body);
try {
//console.log(body.toString('utf8'))
resolve(JSON.parse(body.toString('utf8')));
} catch (e) {
if (DEBUG_MODE_ON) {
console.log('Error while searchTrack_q track: ', e);
}
reject(e);
}
}).catch(function (e) {
if (DEBUG_MODE_ON) {
console.log('Error while searchTrack_q track: ', e);
}
reject(e);
});
}
}
});
}
|
javascript
|
{
"resource": ""
}
|
q13989
|
resolveUri
|
train
|
function resolveUri(options) {
return new Promise(function (resolve, reject) {
if (!options.client_id) {
reject(new Error('Error resolveUri options.client_id is required but is null'));
} else {
if (!options.uri) {
throw new Error('Error resolveUri options.uri is required and is: ' + options.uri);
} else {
var uri = 'http://api.soundcloud.com/resolve.json?url=' + options.uri + '&client_id=' + options.client_id;
request.getAsync(uri, {timeout: 10000}).spread(function (response) {
if (!response.body || response.body.indexOf('404') !== -1) {
if (DEBUG_MODE_ON) {
console.log('Error while resolveUri track: ');
}
reject(new Error('Error while resolveUri track: '));
} else {
if (DEBUG_MODE_ON) {
console.log('resolveUri successful');
}
try {
resolve(JSON.parse(response.body.toString('utf8')));
} catch (e) {
if (DEBUG_MODE_ON) {
console.log('Error while resolveUri track: ' + e);
}
reject(new Error('Error while resolveUri track: ' + e));
}
}
}).catch(function (e) {
if (DEBUG_MODE_ON) {
console.log('Error while resolveUri track: ', e);
}
reject(e);
});
}
}
});
}
|
javascript
|
{
"resource": ""
}
|
q13990
|
addTrackToNewPlaylist
|
train
|
function addTrackToNewPlaylist(options) {
return new Promise(function (resolve, reject) {
var form = new FormData();
form.append('format', 'json');
if (!options.tracks) {
return reject('Error while addTrackToNewPlaylist options.tracks is null');
} else {
_.each(options.tracks, function (track) {
form.append('playlist[tracks][][id]', track.id);
});
}
if (!options.title) {
return reject('Error while addTrackToNewPlaylist options.title is null');
} else {
form.append('playlist[title]', options.title);
}
if (!options.sharing) {
return reject('Error while addTrackToNewPlaylist options.sharing is null');
} else {
form.append('playlist[sharing]', options.sharing);
}
if (!options.oauth_token) {
return reject('Error while addTrackToNewPlaylist options.oauth_token is null');
} else {
form.append('oauth_token', options.oauth_token);
}
form.getLength(function (err, length) {
fetch(`https://api.soundcloud.com/playlists?oauth_token=${options.oauth_token}`, {
method: 'POST',
body: form,
headers: {'content-length': length}
}).then(function (res) {
if (res.status === 201) {
if (DEBUG_MODE_ON) {
console.log(`INFO: addTrackToNewPlaylist, OK -> ${res.statusCode}.`);
}
return res.json();
} else {
return null;
}
}).then(function (json) {
if (!json) {
reject();
} else {
if (DEBUG_MODE_ON) {
console.log('INFO: addTrack successful');
}
resolve(json);
}
}).catch(function (e) {
reject(e);
});
});
});
}
|
javascript
|
{
"resource": ""
}
|
q13991
|
getPlaylist
|
train
|
function getPlaylist(options) {
return new Promise(function (resolve, reject) {
if (!options.oauth_token) {
reject(new Error('Error oauth_token is required, but is null'));
} else {
var uri = 'https://api.soundcloud.com/me/playlists?format=json&oauth_token=' + options.oauth_token;
request.getAsync(uri, {timeout: 10000}).spread(function (response, body) {
try {
var tracks = _.map(JSON.parse(body.toString('utf8')), function (track) {
return track;
});
if (DEBUG_MODE_ON) {
console.log('getPlaylist successful');
}
resolve(tracks);
} catch (e) {
if (DEBUG_MODE_ON) {
console.log('Error while getPlaylist track: ', e);
}
reject(e);
}
}).catch(function (e) {
if (DEBUG_MODE_ON) {
console.log('Error while getPlaylist track: ' + e);
}
reject(e);
})
}
});
}
|
javascript
|
{
"resource": ""
}
|
q13992
|
getToken
|
train
|
function getToken(options) {
return new Promise(function (resolve) {
var curl_options = {
'url': 'https://api.soundcloud.com/oauth2/token',
'method': 'POST',
verbose: true,
encoding: 'utf8',
data: options,
timeout: 10000
};
curlrequest.request(curl_options, function (err, data, meta) {
if (err) {
if (DEBUG_MODE_ON) {
console.log("Error: getToken, ", err, data, meta);
}
resolve(null);
} else if (!data) {
if (DEBUG_MODE_ON) {
console.log("Error: getToken, data is null ", data, meta);
}
resolve(null);
} else {
try {
resolve(JSON.parse(data), meta);
} catch (e) {
if (DEBUG_MODE_ON) {
console.log("Error: getToken, catch, ", e, data, meta);
}
resolve(null);
}
}
});
});
}
|
javascript
|
{
"resource": ""
}
|
q13993
|
DropdownHover
|
train
|
function DropdownHover($elem, options) {
var args = arguments;
// Is the first parameter an object (options), or was omitted,
// instantiate a new instance of the plugin.
if (options === undefined || typeof options === 'object') {
// This allows the plugin to be called with $.fn.bootstrapDropdownHover();
if (!$.contains(document, $($elem)[0])) {
$('[data-toggle="dropdown"]').each(function (index, item) {
// For each nested select, instantiate the plugin
console.log(item, $elem);
$(item).bootstrapDropdownHover(options);
});
}
return $elem.each(function () {
// If this is not a select
if (!$(this).hasClass('dropdown-toggle') || $(this).data('toggle') !== 'dropdown') {
$('[data-toggle="dropdown"]', this).each(function (index, item) {
// For each nested select, instantiate the plugin
DropdownHover($(item), options);
});
} else if (!$.data(this, 'plugin_' + pluginName)) {
// Only allow the plugin to be instantiated once so we check
// that the element has no plugin instantiation yet
// if it has no instance, create a new one, pass options to our
// plugin constructor,
// and store the plugin instance in the elements jQuery data object.
$.data(this, 'plugin_' + pluginName, new BootstrapDropdownHover(this, options));
}
});
// If the first parameter is a string and it doesn't start
// with an underscore or "contains" the `init`-function,
// treat this as a call to a public method.
} else if (typeof options === 'string' && options[0] !== '_' && options !== 'init') {
// Cache the method call to make it possible to return a value
var returns;
$elem.each(function () {
var instance = $.data(this, 'plugin_' + pluginName);
// Tests that there's already a plugin-instance and checks that
// the requested public method exists
if (instance instanceof BootstrapDropdownHover && typeof instance[options] === 'function') {
// Call the method of our plugin instance, and pass
// it the supplied arguments.
returns = instance[options]
.apply(instance, Array.prototype.slice.call(args, 1));
}
});
// If the earlier cached method gives a value back return the value,
// otherwise return this to preserve chainability.
return returns !== undefined ? returns : this;
}
return undefined;
}
|
javascript
|
{
"resource": ""
}
|
q13994
|
init
|
train
|
function init(collection) {
switch (true) {
case isImplemented(collection, 'init'):
return collection[p.init];
case isString(collection):
return () => '';
case isArray(collection):
return () => [];
case isObject(collection):
return () => ({});
case isFunction(collection):
return () => {
throw Error('init not available');
};
default:
return null;
}
}
|
javascript
|
{
"resource": ""
}
|
q13995
|
step
|
train
|
function step(collection) {
switch (true) {
case isImplemented(collection, 'step'):
return collection[p.step];
case isString(collection):
return (acc, input) => {
const value = isKvFormObject(input) ? input.v : input;
return acc + value;
};
case isArray(collection):
return (acc, input) => {
const value = isKvFormObject(input) ? { [input.k]: input.v } : input;
acc.push(value);
return acc;
};
case isObject(collection):
return (acc, input) => {
let value = input;
if (isKvFormObject(input)) {
// if the object is kv-form, change the object from { k: key, v: value } to { key: value }
value = { [input.k]: input.v };
} else if (!isObject(input)) {
// if the input isn't an object at all, turn it into an object with a key based on what's already in the
// accumulator
let max = -1;
for (const k1 in acc) {
const knum = parseInt(k1);
if (knum > max) {
max = knum;
}
}
value = { [max + 1]: input };
}
for (const k2 in value) {
if (value.hasOwnProperty(k2)) {
acc[k2] = value[k2];
}
}
return acc;
};
case isFunction(collection):
return (acc, input) => collection(acc, input);
default:
return null;
}
}
|
javascript
|
{
"resource": ""
}
|
q13996
|
result
|
train
|
function result(collection) {
switch (true) {
case isImplemented(collection, 'result'):
return collection[p.result];
case isString(collection):
case isArray(collection):
case isObject(collection):
case isFunction(collection):
return value => value;
default:
return null;
}
}
|
javascript
|
{
"resource": ""
}
|
q13997
|
quickCheckMethods
|
train
|
function quickCheckMethods(tokens, JQAPI) {
var JQMethods = _.pluck(JQAPI, 'method');
var identifiers = _.where(tokens, {type: 'Identifier'});
return !!_.intersection(JQMethods, _.pluck(identifiers, 'value')).length;
}
|
javascript
|
{
"resource": ""
}
|
q13998
|
checkFinished
|
train
|
function checkFinished() {
if ((import_count + dupe_count) % 100 === 0) {
console.log('Imported', import_count + dupe_count, '/', quote_count);
}
// Once we're done, show the stats and tell the bot to shutdown.
// Since the bot is fully async-aware itself, it won't shut down unless explicitly told to.
if (finished_reading && quote_count === import_count + dupe_count) {
console.log('\nQuotes in file:', quote_count);
console.log('Quotes imported:', import_count);
console.log('Duplicate quotes:', dupe_count);
bot.shutdown();
}
}
|
javascript
|
{
"resource": ""
}
|
q13999
|
absoluteURI
|
train
|
function absoluteURI(uri, base) {
if (uri.substr(0, 2) == './')
uri = uri.substr(2);
// absolute urls are left in tact
if (uri.match(absUrlRegEx) || uri.match(protocolRegEx))
return uri;
var baseParts = base.split('/');
var uriParts = uri.split('/');
baseParts.pop();
while (curPart = uriParts.shift())
if (curPart == '..')
baseParts.pop();
else
baseParts.push(curPart);
return baseParts.join('/');
}
|
javascript
|
{
"resource": ""
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.