_id
stringlengths 2
6
| title
stringlengths 0
58
| partition
stringclasses 3
values | text
stringlengths 52
373k
| language
stringclasses 1
value | meta_information
dict |
|---|---|---|---|---|---|
q50500
|
getTargetTouch
|
train
|
function getTargetTouch (touches, target) {
return Array.prototype.slice.call(touches).filter(function (t) {
return t.target === target
})[0] || touches[0]
}
|
javascript
|
{
"resource": ""
}
|
q50501
|
train
|
function () {
// Scroll or window resize
$(window).on('resize scrollstop', _updateBoxes);
// User entry
$('input[type="number"]').on('keyup change click', events.onBoundaryChange); // 'click' is for spinners on input[number] control
// Boundary toggle
$showBoundsCheck.on('change', events.onBoundaryToggle);
// Nudge controls
// Only certain combinations of browsers/OSes allow capturing arrow key strokes, unfortunately
// Windows: Firefox, Trident, Safari, Opera; Mac: Chrome, Safari, Opera; Not Firefox
if ((navigator.oscpu && /Windows/.test(navigator.oscpu) && /Firefox|Trident|Safari|Presto/.test(navigator.userAgent)) || (/Macintosh/.test(navigator.userAgent) && /Chrome|Safari|Presto/.test(navigator.userAgent))) {
$('#thresholds p').show();
$('body').on('keydown', events.onNudge);
}
// Controls toggler
$('#toggler').on('click', events.onControlsToggle);
}
|
javascript
|
{
"resource": ""
}
|
|
q50502
|
train
|
function (evt) {
var target = evt.target;
var val = parseInt(target.value, 10);
var id = target.id;
// Positive value was entered (negative values are allowed, but the boundaries would be off screen)
if (val > 0) {
if ($showBoundsCheck.is(':checked')) {
$('.boundary-' + id).show();
_drawBound(id, val);
}
else {
$('.boundary-' + id).hide();
}
}
// Hide boundaries
else {
$('.boundary-' + id).hide();
}
// Update the page
withinviewport.defaults[id] = val;
_updateBoxes();
_toggleBoundaryToggle();
}
|
javascript
|
{
"resource": ""
}
|
|
q50503
|
train
|
function (evt) {
// Ignore input fields
if ($(evt.target).is('input')) {
return true;
}
if (evt.shiftKey && 37 <= evt.keyCode && evt.keyCode <= 40) {
var key = 'key' + evt.keyCode;
var scrollVals = {
key38: [0, -1],
key37: [-1, 0],
key39: [1, 0],
key40: [0, 1]
};
window.scrollBy(scrollVals[key][0], scrollVals[key][1]);
evt.preventDefault();
}
}
|
javascript
|
{
"resource": ""
}
|
|
q50504
|
_drawBound
|
train
|
function _drawBound (side, dist) {
dist += 'px';
switch (side) {
case 'top':
$('.boundary-top').css({
top: dist,
height: dist,
marginTop: '-' + dist
});
break;
case 'right':
$('.boundary-right').css({
right: dist,
width: dist,
marginRight: '-' + dist
});
break;
case 'bottom':
$('.boundary-bottom').css({
bottom: dist,
height: dist,
marginBottom: '-' + dist
});
break;
case 'left':
$('.boundary-left').css({
left: dist,
width: dist,
marginLeft: '-' + dist
});
break;
default:
break;
}
}
|
javascript
|
{
"resource": ""
}
|
q50505
|
viewCloud
|
train
|
function viewCloud(app) {
if (!app.config || !app.config.cloud) {
jitsu.log.error('Error: The app ' + app.name.magenta + ' don\'t have any cloud config.');
jitsu.log.error('You need deploy your app before get any cloud config.');
return callback(new Error());
}
jitsu.log.info('Viewing cloud info for ' + name.magenta);
jitsu.inspect.putObject(app.config.cloud[0]);
callback(null, app);
}
|
javascript
|
{
"resource": ""
}
|
q50506
|
setCloud
|
train
|
function setCloud(app) {
drones = drones || app.maxDrones;
ram = ram || (app.config.cloud ? app.config.cloud[0].ram : 256);
var cloud = {
datacenter: datacenter,
provider: provider,
drones: drones,
ram: ram
};
if (app.state === 'started') {
jitsu.log.info('App currently deployed to the cloud with:')
jitsu.inspect.putObject(app.config.cloud[0]);
}
jitsu.log.info('Deploying application to the cloud with:')
jitsu.inspect.putObject(cloud);
async.series({
//
// 1. Fetch the endpoints so that we can properly
// tell the user what datacenter they are in later.
//
endpoints: function getEndpoints(next) {
jitsu.apps.endpoints(next);
},
//
// 2. Start the app with the specified cloud information.
//
start: function start(next) {
jitsu.apps.datacenter(name, cloud, next);
}
}, function (err, result) {
if (err) {
jitsu.log.error('Error starting ' + name.magenta);
return callback(err);
}
var endpoints = result.endpoints,
tld = result.endpoints[provider][datacenter];
jitsu.log.info('App ' + name.magenta + ' is now started');
jitsu.log.info(('http://' + app.subdomain + tld.replace('api', '')).magenta + ' on Port ' + '80'.magenta);
callback(null, app);
});
}
|
javascript
|
{
"resource": ""
}
|
q50507
|
viewApp
|
train
|
function viewApp() {
jitsu.log.info('Fetching app ' + name.magenta);
jitsu.apps.view(name, function (err, app) {
if (err) {
jitsu.log.error('App ' + name.magenta + ' doesn\'t exist on Nodejitsu yet!');
jitsu.log.help('Try running ' + 'jitsu deploy'.magenta);
return callback({});
}
return provider && datacenter
? setCloud(app)
: viewCloud(app);
});
}
|
javascript
|
{
"resource": ""
}
|
q50508
|
readApp
|
train
|
function readApp(next) {
jitsu.package.read(process.cwd(), function (err, pkg) {
if (err) {
callback(err);
}
name = pkg.name;
next();
});
}
|
javascript
|
{
"resource": ""
}
|
q50509
|
setupUserNoUsername
|
train
|
function setupUserNoUsername(callback) {
//
// Attempt to get the password three times.
//
var tries = 0;
function offerReset (username) {
jitsu.prompt.get(['reset'], function (err, res) {
if (err) {
return callback(err);
}
if (/^y[es]+/i.test(res['request password reset'])) {
return jitsu.plugins.cli.executeCommand(['users', 'forgot', username ], callback);
}
callback(new Error('Invalid username / password.'));
});
}
(function setupAuth () {
jitsu.prompt.get(['password'], function (err, result) {
if (err) {
return callback(err);
}
jitsu.config.set('username', username);
jitsu.config.set('password', result.password);
jitsu.setup(function () {
jitsu.auth(function (err) {
//
// Increment the auth attempts
//
tries += 1;
if (err) {
if (tries >= 3) {
jitsu.log.error('Three failed login attempts');
jitsu.log.info('Reset the password?');
return offerReset(username);
}
return setupAuth();
}
// once password is entered checkout a token and clear out password
jitsu.tokens.create(username, (jitsu.config.get('apiTokenName')||'jitsu'), function(err, result) {
if(!err && result) {
var token = Object.getOwnPropertyNames(result).filter(function(n){return n !== 'operation'}).pop();
jitsu.config.set('apiToken', result[token]);
jitsu.config.set('apiTokenName', token);
jitsu.config.clear('password');
jitsu.config.save(function (err) {
return err ? callback(err) : callback();
});
}
});
});
});
});
})();
}
|
javascript
|
{
"resource": ""
}
|
q50510
|
createDatabase
|
train
|
function createDatabase(database, callback) {
database.type = databases.alias(database.type);
//
// Make sure that the user is passing in a valid database type
//
if (databases.available.indexOf(database.type) === -1) {
jitsu.log.warn('Invalid database type ' + database.type.red);
database.type = null;
return promptForDatabase(callback);
}
jitsu.databases.create(database.type, database.name, function (err, a, res) {
if (err || res.statusCode >= 400) {
//
// TODO: Refactor this error handling
//
if (err && (err.statusCode === 409 || err.statusCode === 404)) {
jitsu.log.error('Database with name ' + database.name.magenta + ' already exists');
jitsu.log.info('Try again with a new database name');
database.name = null;
return promptForDatabase(callback);
}
else {
jitsu.log.error('Database could not be created');
jitsu.log.error(err || ('Unknown error code: ' + res.statusCode));
jitsu.log.error('Try again and if it still fails, please contact nodejitsu');
return callback(err);
}
}
else {
jitsu.log.info('A new ' + database.type.magenta + ' has been created');
}
databases.get(database.name, callback);
});
}
|
javascript
|
{
"resource": ""
}
|
q50511
|
isValid
|
train
|
function isValid(desc) {
if (desc.validator) {
if (desc.validator instanceof RegExp) {
return !desc.validator.test(value);
}
return !desc.validator(value);
}
return false;
}
|
javascript
|
{
"resource": ""
}
|
q50512
|
train
|
function(cmd) {
var lines = [], line
with (JavaImporter(java.lang, java.io)) {
var proccess = Runtime.getRuntime().exec(Array.prototype.slice.call(arguments))
var stream = new DataInputStream(proccess.getInputStream())
while (line = stream.readLine())
lines.push(line + '')
stream.close()
}
return lines
}
|
javascript
|
{
"resource": ""
}
|
|
q50513
|
train
|
function(path) {
return path.lastIndexOf('.') != -1 ?
path.slice(path.lastIndexOf('.') + 1, path.length) :
null
}
|
javascript
|
{
"resource": ""
}
|
|
q50514
|
train
|
function(msg, options) {
options = options || {}
var args = ['growlnotify', '-m', msg]
if (!this.binVersion()) throw new Error('growlnotify executable is required')
if (image = options.image) {
var flag, ext = this.extname(image)
flag = flag || ext == 'icns' && 'iconpath'
flag = flag || /^[A-Z]/.test(image) && 'appIcon'
flag = flag || /^png|gif|jpe?g$/.test(ext) && 'image'
flag = flag || ext && (image = ext) && 'icon'
flag = flag || 'icon'
args.push('--' + flag, image)
}
if (options.sticky) args.push('--sticky')
if (options.name) args.push('--name', options.name)
if (options.title) args.push(options.title)
this.exec.apply(this, args)
}
|
javascript
|
{
"resource": ""
}
|
|
q50515
|
train
|
function() {
for (var name in this.commands)
if (this.commands.hasOwnProperty(name))
this.commands[name][1].length ?
this.main[name] = this.commands[name][1] :
this.main.__defineGetter__(name, this.commands[name][1])
}
|
javascript
|
{
"resource": ""
}
|
|
q50516
|
createServer
|
train
|
function createServer () {
// Create server
var server = express.createServer();
// Configure Server
server.configure(function () {
// Built-in
server.use(express.methodOverride()); // Allow method override using _method form parameter
server.use(express.bodyDecoder()); // Parse application/x-www-form-urlencoded
server.use(express.staticProvider(__dirname + '/files')); // Serve client documents in local directory
// Local
server.use(setResponseHeader()); // Set default response headers for CORS
server.use(logConsole()); // Display incoming requests
// Authentication
server.use(auth([auth.Mac({ realm: "Example", // Set realm, typically a domain name or application name
getTokenAttributes: getToken, // Function used to fetch the access token record, typically from a database
// hostHeader: 'x-forwarded-host', // Needed when running behind a proxy such as Apache2
// isHTTPS: true, // Uncomment for HTTPS
checkNonce: nonceCheck, // Optional nonce checking function
bodyHashMode: "require" })])); // Require body hash validation for all non GET/HEAD/OPTIONS requests
});
// Setup generic OPTIONS route
server.options(/.+/, function (req, res) {
res.send(' ');
});
return server;
}
|
javascript
|
{
"resource": ""
}
|
q50517
|
logConsole
|
train
|
function logConsole() {
return function (req, res, next) {
console.log('Received request: ' + req.method + ' ' + req.originalUrl);
next();
};
}
|
javascript
|
{
"resource": ""
}
|
q50518
|
signRequest
|
train
|
function signRequest(method, URI, host, port, token, secret, hashMethod, timestamp, nonce, bodyHash) {
// Parse request URI
var uri = URL.parse(URI, true);
if (uri.pathname == null) {
// Error: Bad request URI
return "";
}
// Construct normalized request string
var normalized = token + '\n' +
timestamp + '\n' +
nonce + '\n' +
bodyHash + '\n' +
method.toUpperCase() + '\n' +
host.toLowerCase() + '\n' +
port + '\n' +
uri.pathname + '\n';
// Normalize parameters
var params = new Array;
if (uri.query) {
var count = 0;
for (var p in uri.query) {
if (typeof uri.query[p] == 'string') {
params[count++] = percentEscape(p) + "=" + percentEscape(uri.query[p]);
}
else {
for (var i in uri.query[p]) {
params[count++] = percentEscape(p) + "=" + percentEscape(uri.query[p][i]);
}
}
}
params.sort();
for (var i in params) {
normalized += params[i] + '\n';
}
}
// Sign normalized request string
var hmac = Crypto.createHmac(hashMethod, secret).update(normalized);
var digest = hmac.digest(encoding = "base64");
return digest;
}
|
javascript
|
{
"resource": ""
}
|
q50519
|
percentEscape
|
train
|
function percentEscape(value) {
// Percent-escape per specification
var escapedString = '';
for (var i = 0; i < value.length; i++) {
var char = value.charCodeAt(i);
if ((char >= 48 && char <= 57) || // 09
(char >= 65 && char <= 90) || // AZ
(char >= 97 && char <= 122) || // az
char == 45 || // -
char == 95 || // _
char == 46 || // .
char == 126) { // ~
escapedString += String.fromCharCode(char);
}
else {
escapedString += '%' + char.toString(16).toUpperCase();
}
}
return escapedString;
}
|
javascript
|
{
"resource": ""
}
|
q50520
|
train
|
function(requestParameters, next) {
if(self.providerProvidesValidateNotReplayClient) {
self.provider.validateNotReplayClient(requestParameters.oauth_consumer_key, requestParameters.oauth_token, requestParameters.oauth_timestamp, requestParameters.oauth_nonce, function(err, result) {
if(err) {
callback(new errors.OAuthUnauthorizedError('Invalid / used nonce'), null);
} else {
next();
}
});
} else {
self.provider.validateNotReplay(requestParameters.oauth_token, requestParameters.oauth_timestamp, requestParameters.oauth_nonce, function(err, result) {
if(err) {
callback(new errors.OAuthUnauthorizedError('Invalid / used nonce'), null);
} else {
next();
}
});
}
}
|
javascript
|
{
"resource": ""
}
|
|
q50521
|
kdtree
|
train
|
function kdtree() {
var kdtree = {},
axes = ["x", "y"],
root,
points = [];
kdtree.axes = function(x) {
if (!arguments.length) return axes;
axes = x;
return kdtree;
};
kdtree.points = function(x) {
if (!arguments.length) return points;
points = x;
root = null;
return kdtree;
};
kdtree.find = function(x) {
return find(kdtree.root(), x, root).point;
};
kdtree.root = function(x) {
return root || (root = node(points, 0));
};
function node(points, depth) {
if (!points.length) return;
var axis = axes[depth % axes.length], median = points.length >> 1;
points.sort(order(axis)); // could use random sample to speed up here
return {
axis: axis,
point: points[median],
left: node(points.slice(0, median), depth + 1),
right: node(points.slice(median + 1), depth + 1)
};
}
function distance(a, b) {
var sum = 0;
for (var i = 0; i < axes.length; i++) {
var axis = axes[i], d = a[axis] - b[axis];
sum += d * d;
}
return sum;
}
function order(axis) {
return function(a, b) {
a = a[axis];
b = b[axis];
return a < b ? -1 : a > b ? 1 : 0;
};
}
function find(node, point, best) {
if (distance(node.point, point) < distance(best.point, point)) best = node;
if (node.left) best = find(node.left, point, best);
if (node.right) {
var d = node.point[node.axis] - point[node.axis];
if (d * d < distance(best.point, point)) best = find(node.right, point, best);
}
return best;
}
return kdtree;
}
|
javascript
|
{
"resource": ""
}
|
q50522
|
train
|
function(path) {
if (JSpec.cache[path]) return JSpec.cache[path]
return JSpec.cache[path] =
JSpec.tryLoading(JSpec.options.fixturePath + '/' + path) ||
JSpec.tryLoading(JSpec.options.fixturePath + '/' + path + '.html')
}
|
javascript
|
{
"resource": ""
}
|
|
q50523
|
train
|
function(results, options) {
var uri = options.uri || 'http://' + window.location.host + '/results'
JSpec.post(uri, {
stats: JSpec.stats,
options: options,
results: map(results.allSuites, function(suite) {
if (suite.hasSpecs())
return {
description: suite.description,
specs: map(suite.specs, function(spec) {
return {
description: spec.description,
message: !spec.passed() ? spec.failure().message : null,
status: spec.requiresImplementation() ? 'pending' :
spec.passed() ? 'pass' :
'fail',
assertions: map(spec.assertions, function(assertion){
return {
passed: assertion.passed
}
})
}
})
}
})
})
if ('close' in main) main.close()
}
|
javascript
|
{
"resource": ""
}
|
|
q50524
|
train
|
function(results, options) {
var id = option('reportToId') || 'jspec'
var report = document.getElementById(id)
var failuresOnly = option('failuresOnly')
var classes = results.stats.failures ? 'has-failures' : ''
if (!report) throw 'JSpec requires the element #' + id + ' to output its reports'
function bodyContents(body) {
return JSpec.
escape(JSpec.contentsOf(body)).
replace(/^ */gm, function(a){ return (new Array(Math.round(a.length / 3))).join(' ') }).
replace(/\r\n|\r|\n/gm, '<br/>')
}
report.innerHTML = '<div id="jspec-report" class="' + classes + '"><div class="heading"> \
<span class="passes">Passes: <em>' + results.stats.passes + '</em></span> \
<span class="failures">Failures: <em>' + results.stats.failures + '</em></span> \
<span class="passes">Duration: <em>' + results.duration + '</em> ms</span> \
</div><table class="suites">' + map(results.allSuites, function(suite) {
var displaySuite = failuresOnly ? suite.ran && !suite.passed() : suite.ran
if (displaySuite && suite.hasSpecs())
return '<tr class="description"><td colspan="2">' + escape(suite.description) + '</td></tr>' +
map(suite.specs, function(i, spec) {
return '<tr class="' + (i % 2 ? 'odd' : 'even') + '">' +
(spec.requiresImplementation() ?
'<td class="requires-implementation" colspan="2">' + escape(spec.description) + '</td>' :
(spec.passed() && !failuresOnly) ?
'<td class="pass">' + escape(spec.description)+ '</td><td>' + spec.assertionsGraph() + '</td>' :
!spec.passed() ?
'<td class="fail">' + escape(spec.description) +
map(spec.failures(), function(a){ return '<em>' + escape(a.message) + '</em>' }).join('') +
'</td><td>' + spec.assertionsGraph() + '</td>' :
'') +
'<tr class="body"><td colspan="2"><pre>' + bodyContents(spec.body) + '</pre></td></tr>'
}).join('') + '</tr>'
}).join('') + '</table></div>'
}
|
javascript
|
{
"resource": ""
}
|
|
q50525
|
train
|
function(results, options) {
failuresOnly = option('failuresOnly')
print(color("\n Passes: ", 'bold') + color(results.stats.passes, 'green') +
color(" Failures: ", 'bold') + color(results.stats.failures, 'red') +
color(" Duration: ", 'bold') + color(results.duration, 'green') + " ms \n")
function indent(string) {
return string.replace(/^(.)/gm, ' $1')
}
each(results.allSuites, function(suite) {
var displaySuite = failuresOnly ? suite.ran && !suite.passed() : suite.ran
if (displaySuite && suite.hasSpecs()) {
print(color(' ' + suite.description, 'bold'))
each(suite.specs, function(spec){
var assertionsGraph = inject(spec.assertions, '', function(graph, assertion){
return graph + color('.', assertion.passed ? 'green' : 'red')
})
if (spec.requiresImplementation())
print(color(' ' + spec.description, 'blue') + assertionsGraph)
else if (spec.passed() && !failuresOnly)
print(color(' ' + spec.description, 'green') + assertionsGraph)
else if (!spec.passed())
print(color(' ' + spec.description, 'red') + assertionsGraph +
"\n" + indent(map(spec.failures(), function(a){ return a.message }).join("\n")) + "\n")
})
print("")
}
})
quit(results.stats.failures)
}
|
javascript
|
{
"resource": ""
}
|
|
q50526
|
train
|
function(results, options) {
console.log('')
console.log('Passes: ' + results.stats.passes + ' Failures: ' + results.stats.failures)
each(results.allSuites, function(suite) {
if (suite.ran) {
console.group(suite.description)
each(suite.specs, function(spec){
var assertionCount = spec.assertions.length + ':'
if (spec.requiresImplementation())
console.warn(spec.description)
else if (spec.passed())
console.log(assertionCount + ' ' + spec.description)
else
console.error(assertionCount + ' ' + spec.description + ', ' + spec.failure().message)
})
console.groupEnd()
}
})
}
|
javascript
|
{
"resource": ""
}
|
|
q50527
|
train
|
function() {
return any(this.calls, function(call){
return self.expectedResult.an_instance_of ?
call.result.constructor == self.expectedResult.an_instance_of:
equal(self.expectedResult, call.result)
})
}
|
javascript
|
{
"resource": ""
}
|
|
q50528
|
train
|
function() {
return any(this.calls, function(call){
return any(self.expectedArgs, function(i, arg){
return arg.an_instance_of ?
call.args[i].constructor == arg.an_instance_of:
equal(arg, call.args[i])
})
})
}
|
javascript
|
{
"resource": ""
}
|
|
q50529
|
train
|
function(description, body) {
var self = this
extend(this, {
body: body,
description: description,
suites: [],
specs: [],
ran: false,
hooks: { 'before' : [], 'after' : [], 'before_each' : [], 'after_each' : [] },
// Add a spec to the suite
addSpec : function(description, body) {
var spec = new JSpec.Spec(description, body)
this.specs.push(spec)
JSpec.stats.specs++ // TODO: abstract
spec.suite = this
},
// Add a hook to the suite
addHook : function(hook, body) {
this.hooks[hook].push(body)
},
// Add a nested suite
addSuite : function(description, body) {
var suite = new JSpec.Suite(description, body)
JSpec.allSuites.push(suite)
suite.name = suite.description
suite.description = this.description + ' ' + suite.description
this.suites.push(suite)
suite.suite = this
},
// Invoke a hook in context to this suite
hook : function(hook) {
if (this.suite) this.suite.hook(hook)
each(this.hooks[hook], function(body) {
JSpec.evalBody(body, "Error in hook '" + hook + "', suite '" + self.description + "': ")
})
},
// Check if nested suites are present
hasSuites : function() {
return this.suites.length
},
// Check if this suite has specs
hasSpecs : function() {
return this.specs.length
},
// Check if the entire suite passed
passed : function() {
return !any(this.specs, function(spec){
return !spec.passed()
})
}
})
}
|
javascript
|
{
"resource": ""
}
|
|
q50530
|
train
|
function(description, body) {
var spec = new JSpec.Spec(description, body)
this.specs.push(spec)
JSpec.stats.specs++ // TODO: abstract
spec.suite = this
}
|
javascript
|
{
"resource": ""
}
|
|
q50531
|
train
|
function(description, body) {
var suite = new JSpec.Suite(description, body)
JSpec.allSuites.push(suite)
suite.name = suite.description
suite.description = this.description + ' ' + suite.description
this.suites.push(suite)
suite.suite = this
}
|
javascript
|
{
"resource": ""
}
|
|
q50532
|
train
|
function(hook) {
if (this.suite) this.suite.hook(hook)
each(this.hooks[hook], function(body) {
JSpec.evalBody(body, "Error in hook '" + hook + "', suite '" + self.description + "': ")
})
}
|
javascript
|
{
"resource": ""
}
|
|
q50533
|
train
|
function(description, body) {
extend(this, {
body: body,
description: description,
assertions: [],
// Add passing assertion
pass : function(message) {
this.assertions.push({ passed: true, message: message })
if (JSpec.assert) ++JSpec.stats.passes
},
// Add failing assertion
fail : function(message) {
this.assertions.push({ passed: false, message: message })
if (JSpec.assert) ++JSpec.stats.failures
},
// Run deferred assertions
runDeferredAssertions : function() {
each(this.assertions, function(assertion){
if (assertion.defer) assertion.run().report(), hook('afterAssertion', assertion)
})
},
// Find first failing assertion
failure : function() {
return find(this.assertions, function(assertion){
return !assertion.passed
})
},
// Find all failing assertions
failures : function() {
return select(this.assertions, function(assertion){
return !assertion.passed
})
},
// Weither or not the spec passed
passed : function() {
return !this.failure()
},
// Weither or not the spec requires implementation (no assertions)
requiresImplementation : function() {
return this.assertions.length == 0
},
// Sprite based assertions graph
assertionsGraph : function() {
return map(this.assertions, function(assertion){
return '<span class="assertion ' + (assertion.passed ? 'passed' : 'failed') + '"></span>'
}).join('')
}
})
}
|
javascript
|
{
"resource": ""
}
|
|
q50534
|
train
|
function(message) {
this.assertions.push({ passed: true, message: message })
if (JSpec.assert) ++JSpec.stats.passes
}
|
javascript
|
{
"resource": ""
}
|
|
q50535
|
train
|
function(message) {
this.assertions.push({ passed: false, message: message })
if (JSpec.assert) ++JSpec.stats.failures
}
|
javascript
|
{
"resource": ""
}
|
|
q50536
|
train
|
function() {
each(this.assertions, function(assertion){
if (assertion.defer) assertion.run().report(), hook('afterAssertion', assertion)
})
}
|
javascript
|
{
"resource": ""
}
|
|
q50537
|
train
|
function(object) {
var self = this
if (object == undefined || object == null) return 'null'
if (object === true) return 'true'
if (object === false) return 'false'
switch (typeof object) {
case 'number': return object
case 'string': return this.escapable.test(object) ?
'"' + object.replace(this.escapable, function (a) {
return typeof self.meta[a] === 'string' ? self.meta[a] :
'\\u' + ('0000' + a.charCodeAt(0).toString(16)).slice(-4)
}) + '"' :
'"' + object + '"'
case 'object':
if (object.constructor == Array)
return '[' + map(object, function(val){
return self.encode(val)
}).join(', ') + ']'
else if (object)
return '{' + map(object, function(key, val){
return self.encode(key) + ':' + self.encode(val)
}).join(', ') + '}'
}
return 'null'
}
|
javascript
|
{
"resource": ""
}
|
|
q50538
|
train
|
function(object) {
var module = object.constructor == JSpec.Module ? object : new JSpec.Module(object)
this.modules.push(module)
if ('init' in module) module.init()
if ('utilities' in module) extend(this.defaultContext, module.utilities)
if ('matchers' in module) this.addMatchers(module.matchers)
if ('reporters' in module) extend(this.reporters, module.reporters)
if ('DSLs' in module)
each(module.DSLs, function(name, methods){
JSpec.DSLs[name] = JSpec.DSLs[name] || {}
extend(JSpec.DSLs[name], methods)
})
return this
}
|
javascript
|
{
"resource": ""
}
|
|
q50539
|
train
|
function(name, args) {
args = toArray(arguments, 1)
return inject(JSpec.modules, [], function(results, module){
if (typeof module[name] == 'function')
results.push(JSpec.evalHook(module, name, args))
})
}
|
javascript
|
{
"resource": ""
}
|
|
q50540
|
train
|
function(module, name, args) {
hook('evaluatingHookBody', module, name)
try { return module[name].apply(module, args) }
catch(e) { error('Error in hook ' + module.name + '.' + name + ': ', e) }
}
|
javascript
|
{
"resource": ""
}
|
|
q50541
|
train
|
function(description) {
return find(this.allSuites, function(suite){
return suite.name == description || suite.description == description
})
}
|
javascript
|
{
"resource": ""
}
|
|
q50542
|
train
|
function(fromSuite, toSuite) {
each(fromSuite.specs, function(spec){
spec.assertions = []
toSuite.specs.push(spec)
})
}
|
javascript
|
{
"resource": ""
}
|
|
q50543
|
train
|
function(string, color) {
return "\u001B[" + {
bold : 1,
black : 30,
red : 31,
green : 32,
yellow : 33,
blue : 34,
magenta : 35,
cyan : 36,
white : 37
}[color] + 'm' + string + "\u001B[0m"
}
|
javascript
|
{
"resource": ""
}
|
|
q50544
|
train
|
function(actual, expected, negate, name) {
return 'expected ' + puts(actual) + ' to ' +
(negate ? 'not ' : '') +
name.replace(/_/g, ' ') +
' ' + (expected.length > 1 ?
puts.apply(this, expected.slice(1)) :
'')
}
|
javascript
|
{
"resource": ""
}
|
|
q50545
|
train
|
function(body) {
switch (body.constructor) {
case String:
if (captures = body.match(/^alias (\w+)/)) return JSpec.matchers[last(captures)]
if (body.length < 4) body = 'actual ' + body + ' expected'
return { match: function(actual, expected) { return eval(body) }}
case Function:
return { match: body }
default:
return body
}
}
|
javascript
|
{
"resource": ""
}
|
|
q50546
|
train
|
function(key) {
return (value = query(key)) !== null ? value :
JSpec.options[key] || null
}
|
javascript
|
{
"resource": ""
}
|
|
q50547
|
train
|
function(a, b) {
if (typeof a != typeof b) return
if (a === b) return true
if (a instanceof RegExp)
return a.toString() === b.toString()
if (a instanceof Date)
return Number(a) === Number(b)
if (typeof a != 'object') return
if (a.length !== undefined)
if (a.length !== b.length) return
else
for (var i = 0, len = a.length; i < len; ++i)
if (!equal(a[i], b[i]))
return
for (var key in a)
if (!equal(a[key], b[key]))
return
return true
}
|
javascript
|
{
"resource": ""
}
|
|
q50548
|
train
|
function(html) {
return html.toString()
.replace(/&/gmi, '&')
.replace(/"/gmi, '"')
.replace(/>/gmi, '>')
.replace(/</gmi, '<')
}
|
javascript
|
{
"resource": ""
}
|
|
q50549
|
train
|
function(actual, matcher, expected) {
var assertion = new JSpec.Assertion(JSpec.matchers[matcher], actual, toArray(arguments, 2))
return assertion.run().result
}
|
javascript
|
{
"resource": ""
}
|
|
q50550
|
train
|
function(actual) {
function assert(matcher, args, negate) {
var expected = toArray(args, 1)
matcher.negate = negate
assertion = new JSpec.Assertion(matcher, actual, expected, negate)
hook('beforeAssertion', assertion)
if (matcher.defer) assertion.run()
else JSpec.currentSpec.assertions.push(assertion.run().report()), hook('afterAssertion', assertion)
return assertion.result
}
function to(matcher) {
return assert(matcher, arguments, false)
}
function not_to(matcher) {
return assert(matcher, arguments, true)
}
return {
to : to,
should : to,
not_to: not_to,
should_not : not_to
}
}
|
javascript
|
{
"resource": ""
}
|
|
q50551
|
train
|
function(callback, a, b) {
return callback.length == 1 ? callback(b) : callback(a, b)
}
|
javascript
|
{
"resource": ""
}
|
|
q50552
|
train
|
function(object, callback) {
if (object.constructor == Array)
for (var i = 0, len = object.length; i < len; ++i)
callIterator(callback, i, object[i])
else
for (var key in object)
if (object.hasOwnProperty(key))
callIterator(callback, key, object[key])
}
|
javascript
|
{
"resource": ""
}
|
|
q50553
|
train
|
function(object, memo, callback) {
each(object, function(key, value){
memo = (callback.length == 2 ?
callback(memo, value):
callback(memo, key, value)) ||
memo
})
return memo
}
|
javascript
|
{
"resource": ""
}
|
|
q50554
|
train
|
function(object, method) {
if (method) {
if (object['__prototype__' + method])
delete object[method]
else
object[method] = object['__original__' + method]
delete object['__prototype__' + method]
delete object['__original____' + method]
}
else if (object) {
for (var key in object)
if (captures = key.match(/^(?:__prototype__|__original__)(.*)/))
destub(object, captures[1])
}
else
while (JSpec.stubbed.length)
destub(JSpec.stubbed.shift())
}
|
javascript
|
{
"resource": ""
}
|
|
q50555
|
train
|
function(object, method) {
hook('stubbing', object, method)
JSpec.stubbed.push(object)
var type = object.hasOwnProperty(method) ? '__original__' : '__prototype__'
object[type + method] = object[method]
object[method] = function(){}
return {
and_return : function(value) {
if (typeof value == 'function') object[method] = value
else object[method] = function(){ return value }
}
}
}
|
javascript
|
{
"resource": ""
}
|
|
q50556
|
train
|
function(object, callback) {
return inject(object, [], function(memo, key, value){
memo.push(callIterator(callback, key, value))
})
}
|
javascript
|
{
"resource": ""
}
|
|
q50557
|
train
|
function(object, callback) {
return inject(object, null, function(state, key, value){
if (state == undefined)
return callIterator(callback, key, value) ? value : state
})
}
|
javascript
|
{
"resource": ""
}
|
|
q50558
|
train
|
function(object, callback) {
return inject(object, [], function(selected, key, value){
if (callIterator(callback, key, value))
selected.push(value)
})
}
|
javascript
|
{
"resource": ""
}
|
|
q50559
|
train
|
function(name, body) {
hook('addingMatcher', name, body)
if (name.indexOf(' ') != -1) {
var matchers = name.split(/\s+/)
var prefix = matchers.shift()
each(matchers, function(name) {
JSpec.addMatcher(prefix + '_' + name, body(name))
})
}
this.matchers[name] = this.normalizeMatcherMessage(this.normalizeMatcherBody(body))
this.matchers[name].name = name
}
|
javascript
|
{
"resource": ""
}
|
|
q50560
|
train
|
function(description, body) {
var suite = new JSpec.Suite(description, body)
hook('addingSuite', suite)
this.allSuites.push(suite)
this.suites.push(suite)
}
|
javascript
|
{
"resource": ""
}
|
|
q50561
|
train
|
function(body, errorMessage) {
var dsl = this.DSL || this.DSLs.snake
var matchers = this.matchers
var context = this.context || this.defaultContext
var contents = this.contentsOf(body)
hook('evaluatingBody', dsl, matchers, context, contents)
try { with (dsl){ with (context) { with (matchers) { eval(contents) }}} }
catch(e) { error(errorMessage, e) }
}
|
javascript
|
{
"resource": ""
}
|
|
q50562
|
train
|
function(input) {
if (typeof input != 'string') return
input = hookImmutable('preprocessing', input)
return input.
replace(/\t/g, ' ').
replace(/\r\n|\n|\r/g, '\n').
split('__END__')[0].
replace(/([\w\.]+)\.(stub|destub)\((.*?)\)$/gm, '$2($1, $3)').
replace(/describe\s+(.*?)$/gm, 'describe($1, function(){').
replace(/^\s+it\s+(.*?)$/gm, ' it($1, function(){').
replace(/^ *(before_each|after_each|before|after)(?= |\n|$)/gm, 'JSpec.currentSuite.addHook("$1", function(){').
replace(/^\s*end(?=\s|$)/gm, '});').
replace(/-\{/g, 'function(){').
replace(/(\d+)\.\.(\d+)/g, function(_, a, b){ return range(a, b) }).
replace(/\.should([_\.]not)?[_\.](\w+)(?: |;|$)(.*)$/gm, '.should$1_$2($3)').
replace(/([\/\s]*)(.+?)\.(should(?:[_\.]not)?)[_\.](\w+)\((.*)\)\s*;?$/gm, '$1 expect($2).$3($4, $5)').
replace(/, \)/g, ')').
replace(/should\.not/g, 'should_not')
}
|
javascript
|
{
"resource": ""
}
|
|
q50563
|
train
|
function(start, end) {
var current = parseInt(start), end = parseInt(end), values = [current]
if (end > current) while (++current <= end) values.push(current)
else while (--current >= end) values.push(current)
return '[' + values + ']'
}
|
javascript
|
{
"resource": ""
}
|
|
q50564
|
train
|
function() {
this.duration = Number(new Date) - this.start
hook('reporting', JSpec.options)
new (JSpec.options.reporter || JSpec.reporters.DOM)(JSpec, JSpec.options)
}
|
javascript
|
{
"resource": ""
}
|
|
q50565
|
train
|
function(options) {
if (any(hook('running'), haveStopped)) return this
if (options) extend(this.options, options)
this.start = Number(new Date)
each(this.suites, function(suite) { JSpec.runSuite(suite) })
return this
}
|
javascript
|
{
"resource": ""
}
|
|
q50566
|
train
|
function(suite) {
this.currentSuite = suite
this.evalBody(suite.body)
suite.ran = true
hook('beforeSuite', suite), suite.hook('before')
each(suite.specs, function(spec) {
hook('beforeSpec', spec)
suite.hook('before_each')
JSpec.runSpec(spec)
hook('afterSpec', spec)
suite.hook('after_each')
})
if (suite.hasSuites()) {
each(suite.suites, function(suite) {
JSpec.runSuite(suite)
})
}
hook('afterSuite', suite), suite.hook('after')
this.stats.suitesFinished++
}
|
javascript
|
{
"resource": ""
}
|
|
q50567
|
train
|
function(spec) {
this.currentSpec = spec
try { this.evalBody(spec.body) }
catch (e) { fail(e) }
spec.runDeferredAssertions()
destub()
this.stats.specsFinished++
this.stats.assertions += spec.assertions.length
}
|
javascript
|
{
"resource": ""
}
|
|
q50568
|
train
|
function(dependency, message) {
hook('requiring', dependency, message)
try { eval(dependency) }
catch (e) { throw 'JSpec depends on ' + dependency + ' ' + message }
return this
}
|
javascript
|
{
"resource": ""
}
|
|
q50569
|
train
|
function(key, queryString) {
var queryString = (queryString || (main.location ? main.location.search : null) || '').substring(1)
return inject(queryString.split('&'), null, function(value, pair){
parts = pair.split('=')
return parts[0] == key ? parts[1].replace(/%20|\+/gmi, ' ') : value
})
}
|
javascript
|
{
"resource": ""
}
|
|
q50570
|
train
|
function(message, e) {
if ('stack' in e)
require('util').puts(e.stack + '\n')
throw (message ? message : '') + e.toString() +
(e.line ? ' near line ' + e.line : '')
}
|
javascript
|
{
"resource": ""
}
|
|
q50571
|
train
|
function(uri, data) {
if (any(hook('posting', uri, data), haveStopped)) return
var request = this.xhr()
request.open('POST', uri, false)
request.setRequestHeader('Content-Type', 'application/json')
request.send(JSpec.JSON.encode(data))
}
|
javascript
|
{
"resource": ""
}
|
|
q50572
|
train
|
function(file, callback) {
if (any(hook('loading', file), haveStopped)) return
if ('readFile' in main)
return readFile(file)
else if (this.hasXhr()) {
var request = this.xhr()
request.open('GET', file, false)
request.send(null)
if (request.readyState == 4 &&
(request.status == 0 ||
request.status.toString().charAt(0) == 2))
return request.responseText
}
else
error("failed to load `" + file + "'")
}
|
javascript
|
{
"resource": ""
}
|
|
q50573
|
train
|
function(method, url, async, user, password) {
this.user = user
this.password = password
this.url = url
this.readyState = 1
this.method = method.toUpperCase()
if (async != undefined) this.async = async
if (this.async) this.onreadystatechange()
}
|
javascript
|
{
"resource": ""
}
|
|
q50574
|
train
|
function(data) {
var self = this
this.data = data
this.readyState = 4
if (this.method == 'HEAD') this.responseText = null
this.responseHeaders['content-length'] = (this.responseText || '').length
if(this.async) this.onreadystatechange()
lastRequest = function(){
return self
}
}
|
javascript
|
{
"resource": ""
}
|
|
q50575
|
mockRequest
|
train
|
function mockRequest() {
return { and_return : function(body, type, status, headers) {
XMLHttpRequest = MockXMLHttpRequest
ActiveXObject = false
status = status || 200
headers = headers || {}
headers['content-type'] = type
JSpec.extend(XMLHttpRequest.prototype, {
responseText: body,
responseHeaders: headers,
status: status,
statusText: JSpec.statusCodes[status]
})
}}
}
|
javascript
|
{
"resource": ""
}
|
q50576
|
train
|
function() {
return _.reduce(arguments, function(acc, elem) {
if (_.isArguments(elem)) {
return concat.call(acc, slice.call(elem));
}
else {
return concat.call(acc, elem);
}
}, []);
}
|
javascript
|
{
"resource": ""
}
|
|
q50577
|
train
|
function(array, n, pad) {
var p = function(array) {
if (array == null) return [];
var part = _.take(array, n);
if (n === _.size(part)) {
return _.cons(part, p(_.drop(array, n)));
}
else {
return pad ? [_.take(_.cat(part, pad), n)] : [];
}
};
return p(array);
}
|
javascript
|
{
"resource": ""
}
|
|
q50578
|
train
|
function(array, n, step) {
step = (step != null) ? step : n;
var p = function(array, n, step) {
if (_.isEmpty(array)) return [];
return _.cons(_.take(array, n),
p(_.drop(array, step), n, step));
};
return p(array, n, step);
}
|
javascript
|
{
"resource": ""
}
|
|
q50579
|
train
|
function(array, fun) {
return _.cat.apply(null, _.map(array, fun));
}
|
javascript
|
{
"resource": ""
}
|
|
q50580
|
train
|
function(array, inter) {
if (!_.isArray(array)) throw new TypeError;
var sz = _.size(array);
if (sz === 0) return array;
if (sz === 1) return array;
return slice.call(_.mapcat(array, function(elem) {
return _.cons(elem, [inter]);
}), 0, -1);
}
|
javascript
|
{
"resource": ""
}
|
|
q50581
|
train
|
function(/* args */) {
if (!_.some(arguments)) return [];
if (arguments.length == 1) return arguments[0];
return _.filter(_.flatten(_.zip.apply(null, arguments), true), function(elem) {
return elem != null;
});
}
|
javascript
|
{
"resource": ""
}
|
|
q50582
|
train
|
function(array, index) {
return [_.take(array, index), _.drop(array, index)];
}
|
javascript
|
{
"resource": ""
}
|
|
q50583
|
train
|
function(array, n) {
var ret = [];
var sz = _.size(array);
if (n <= 0) return [];
if (n === 1) return array;
for(var index = 0; index < sz; index += n) {
ret.push(array[index]);
}
return ret;
}
|
javascript
|
{
"resource": ""
}
|
|
q50584
|
train
|
function(array, fun, init) {
var ret = [];
var acc = init;
_.each(array, function(v,k) {
acc = fun(acc, array[k]);
ret.push(acc);
});
return ret;
}
|
javascript
|
{
"resource": ""
}
|
|
q50585
|
train
|
function(array, pred) {
return _.filter(_.map(_.range(_.size(array)), function(i) {
return pred(i, array[i]);
}),
existy);
}
|
javascript
|
{
"resource": ""
}
|
|
q50586
|
train
|
function(array, pred) {
if (!isSeq(array)) throw new TypeError;
var sz = _.size(array);
for (var index = 0; index < sz; index++) {
if(!truthy(pred(array[index]))) {
break;
}
}
return _.take(array, index);
}
|
javascript
|
{
"resource": ""
}
|
|
q50587
|
train
|
function(array, pred) {
return [_.takeWhile(array, pred), _.dropWhile(array, pred)];
}
|
javascript
|
{
"resource": ""
}
|
|
q50588
|
train
|
function(array, fun){
if (_.isEmpty(array) || !existy(array)) return [];
var fst = _.first(array);
var fstVal = fun(fst);
var run = concat.call([fst], _.takeWhile(_.rest(array), function(e) {
return _.isEqual(fstVal, fun(e));
}));
return concat.call([run], _.partitionBy(_.drop(array, _.size(run)), fun));
}
|
javascript
|
{
"resource": ""
}
|
|
q50589
|
train
|
function(array, fun) {
return _.reduce(array, function(x, y) {
return fun(x, y) ? x : y;
});
}
|
javascript
|
{
"resource": ""
}
|
|
q50590
|
train
|
function(array, fun) {
if (!isSeq(array)) throw new TypeError("expected an array as the first argument");
return _.filter(_.map(array, function(e) {
return fun(e);
}), existy);
}
|
javascript
|
{
"resource": ""
}
|
|
q50591
|
train
|
function(obj, visitor, context) {
var result;
this.preorder(obj, function(value, key, parent) {
if (visitor.call(context, value, key, parent)) {
result = value;
return stopWalk;
}
}, context);
return result;
}
|
javascript
|
{
"resource": ""
}
|
|
q50592
|
train
|
function(obj, strategy, visitor, context) {
return this.filter(obj, strategy, function(value, key, parent) {
return !visitor.call(context, value, key, parent);
});
}
|
javascript
|
{
"resource": ""
}
|
|
q50593
|
train
|
function(obj, visitor, context, traversalStrategy) {
traversalStrategy = traversalStrategy || this._traversalStrategy;
walkImpl(obj, traversalStrategy, null, visitor, context);
}
|
javascript
|
{
"resource": ""
}
|
|
q50594
|
train
|
function(obj, visitor, leafMemo, context) {
var reducer = function(value, key, parent, subResults) {
return visitor(subResults || leafMemo, value, key, parent);
};
return walkImpl(obj, this._traversalStrategy, null, reducer, context, true);
}
|
javascript
|
{
"resource": ""
}
|
|
q50595
|
train
|
function(fun) {
var fixArgs = _.rest(arguments);
var f = function() {
var args = fixArgs.slice();
var arg = 0;
for ( var i = 0; i < (args.length || arg < arguments.length); i++ ) {
if ( args[i] === _ ) {
args[i] = arguments[arg++];
}
}
return fun.apply(null, args);
};
f._original = fun;
return f;
}
|
javascript
|
{
"resource": ""
}
|
|
q50596
|
baseMapArgs
|
train
|
function baseMapArgs (fun, mapFun) {
return _.arity(fun.length, function () {
return fun.apply(this, __map.call(arguments, mapFun));
});
}
|
javascript
|
{
"resource": ""
}
|
q50597
|
train
|
function(/*, funs */){
var funs = (_.isArray(arguments[0])) ? arguments[0] : arguments;
return function(seed) {
return _.reduce(funs,
function(l,r) { return r(l); },
seed);
};
}
|
javascript
|
{
"resource": ""
}
|
|
q50598
|
train
|
function(/* preds */) {
var preds = arguments;
return function(array) {
return _.every(array, function(e) {
return _.every(preds, function(p) {
return p(e);
});
});
};
}
|
javascript
|
{
"resource": ""
}
|
|
q50599
|
train
|
function(/* preds */) {
var preds = arguments;
return function(array) {
return _.some(array, function(e) {
return _.some(preds, function(p) {
return p(e);
});
});
};
}
|
javascript
|
{
"resource": ""
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.