_id
stringlengths 2
6
| title
stringlengths 0
58
| partition
stringclasses 3
values | text
stringlengths 27
233k
| language
stringclasses 1
value | meta_information
dict |
|---|---|---|---|---|---|
q1700
|
resolveConfig
|
train
|
function resolveConfig(conf, version = '') {
conf['siteroot'] = conf.baseurl || '/';
if (version) {
conf['baseurl'] =
|
javascript
|
{
"resource": ""
}
|
q1701
|
resolve
|
train
|
function resolve(value, conf, ring = []) {
value.match(CONFIG_VAR_REGEX).forEach((variable) => {
const key = variable.substring(variable.lastIndexOf('${') + 2, variable.lastIndexOf('}'));
if (ring.includes(key)) {
throw `Circular dependency error: cannot resolve variable(s) ${ring}.`;
}
ring.push(key);
let resolved = conf[key];
if (!resolved) {
throw `Could not resolve ${key} - make sure this key
|
javascript
|
{
"resource": ""
}
|
q1702
|
timeAndLog
|
train
|
function timeAndLog(text) {
if (active) {
var spaces = space.substring(0, currentIndentation);
|
javascript
|
{
"resource": ""
}
|
q1703
|
processModules
|
train
|
function processModules(item) {
if (item.exports && !item._traced) {
bootstrap(item, 'exports', item.filename);
item._traced = true;
|
javascript
|
{
"resource": ""
}
|
q1704
|
bootstrap
|
train
|
function bootstrap(item, prop, path) {
if ( (path.split('node_modules').length > 2) || (path.slice(-4) == 'emit') || (item == require('util') && (prop=='format')) ) return;
if (!item.hasOwnProperty(prop) || Object.getOwnPropertyDescriptor(item, prop).get) return;
var original = item[prop];
if (allFuncs.indexOf(original) !== -1) return;
allFuncs.push(original);
if (item[prop] instanceof Function) {
infect(item, prop, path);
if (item[prop].prototype) {
bootstrap(item[prop], 'prototype', path+'.prototype');
|
javascript
|
{
"resource": ""
}
|
q1705
|
timeDiff
|
train
|
function timeDiff(newest, oldest) {
var diff = (parseFloat(newest) - parseFloat(oldest));
|
javascript
|
{
"resource": ""
}
|
q1706
|
meaningfulTime
|
train
|
function meaningfulTime() {
if (moduleRef) {
var parts = processRef.hrtime();
return (((parts[0]*1000)+(parts[1]/1000000))%10000).toFixed(2) +
|
javascript
|
{
"resource": ""
}
|
q1707
|
measureTracerOverhead
|
train
|
function measureTracerOverhead() {
var time1 = meaningfulTime();
var time2 = meaningfulTime();
|
javascript
|
{
"resource": ""
}
|
q1708
|
processLogs
|
train
|
function processLogs() {
var calcs = 0;
for (var i in stats) {
stats[i].average = stats[i].totalTime / stats[i].count;
calcs += stats[i].calcs;
}
var time1 = meaningfulTime();
var time2 = meaningfulTime();
console.error("TRACER TOTAL OVERHEAD", (calcs*timeDiff(time2, time1)).toFixed(2)+'ms');
while (Object.keys(stats).length > 0) {
var biggest = 0;
var biggestPath = Object.keys(stats)[0];
for (var path in stats) {
if (stats[path].average >= biggest) {
biggestPath = path;
biggest = stats[path].average;
}
}
console.error("TRACER TOTAL",
|
javascript
|
{
"resource": ""
}
|
q1709
|
debug
|
train
|
function debug(message) {
if (enplug.debug) {
arguments[0] = TAG + arguments[0];
|
javascript
|
{
"resource": ""
}
|
q1710
|
validateCallbacks
|
train
|
function validateCallbacks(options) {
if (options.successCallback && typeof options.successCallback !== 'function') {
throw new Error(TAG + 'Success callback must be a function.');
} else {
options.successCallback = options.successCallback || enplug.noop;
}
if (options.errorCallback && typeof options.errorCallback
|
javascript
|
{
"resource": ""
}
|
q1711
|
parseResponse
|
train
|
function parseResponse(event) {
try {
var response = JSON.parse(event.data);
// Check for success key to ignore messages being sent
if (response.namespace === namespace && typeof response.success === 'boolean') {
|
javascript
|
{
"resource": ""
}
|
q1712
|
train
|
function (options) {
if (typeof options === 'object') {
// Add implementation-specific method prefix (dashboard or app)
options.name = this.prefix + '.' + options.name;
return this.transport.send(options);
|
javascript
|
{
"resource": ""
}
|
|
q1713
|
decorateSend
|
train
|
function decorateSend(q, scope, transport) {
var original = transport.send;
transport.send = function (options) {
// Store originals
var defer = q.defer(),
onSuccess = options.successCallback || angular.noop,
onError = options.errorCallback || angular.noop;
options.successCallback = function (result) {
scope.$apply(function () {
defer.resolve(result);
onSuccess(result);
});
};
options.errorCallback = function (result) {
scope.$apply(function () {
|
javascript
|
{
"resource": ""
}
|
q1714
|
train
|
function (hash) {
return new Promise((resolve, reject) => {
request(`${ ipfsProtocol }://${ ipfsHost }/ipfs/${hash}`, function (err, response, body) {
if (err) {
|
javascript
|
{
"resource": ""
}
|
|
q1715
|
deleteDeploymentFolder
|
train
|
async function deleteDeploymentFolder() {
del.sync(deploymentTmpFolder, { force: true });
|
javascript
|
{
"resource": ""
}
|
q1716
|
deploy
|
train
|
async function deploy() {
try {
await browserifyDBCP();
await uglify();
const ipfsHash = await deployToIPFS(`${ deploymentFolder}/${ browserifyName}`);
await pinToIPFS(ipfsHash);
const ipnsHash = await deployToIpns(ipfsHash);
deleteDeploymentFolder();
|
javascript
|
{
"resource": ""
}
|
q1717
|
getPointDistance
|
train
|
function getPointDistance(x0, x1, y0, y1) {
return (Math.sqrt(((x1 - x0) *
|
javascript
|
{
"resource": ""
}
|
q1718
|
getAngle
|
train
|
function getAngle(originX, originY, projectionX, projectionY) {
const angle = Math.atan2(projectionY
|
javascript
|
{
"resource": ""
}
|
q1719
|
add
|
train
|
function add(className) {
if (typeof className === 'function') {
className = className.name;
}
|
javascript
|
{
"resource": ""
}
|
q1720
|
applyTags
|
train
|
function applyTags(Class, addTags, fieldName, descriptor) {
var tags = (Array.isArray(addTags) && addTags || []).map(function (tag) {
return typeof tag === 'string' && Symbol.for(tag) || tag;
}).filter(function (tag) {
return (0, _typeof2.default)(tag) === 'symbol';
|
javascript
|
{
"resource": ""
}
|
q1721
|
csvWrapForExcel
|
train
|
function csvWrapForExcel(encoder) {
// Pipe the CSV encoder to the ucs2 converter
var converter = new Stream.Transform();
var csvStream = new Stream.PassThrough();
converter._transform = function(chunk, encoding, cb) {
this.push(new Buffer(chunk.toString(), 'ucs2'));
cb();
|
javascript
|
{
"resource": ""
}
|
q1722
|
createJsonPreprocessor
|
train
|
function createJsonPreprocessor(logger, basePath, config) {
const log = logger.create('preprocessor.json');
const conf = config || {};
const stripPrefix = new RegExp(`^${(conf.stripPrefix || '')}`);
return function(content, file, done) {
log.debug('Processing "%s".', file.originalPath);
// Build json path file.
const jsonPath = file.originalPath
.replace(`${basePath}/`, '')
.replace(stripPrefix, '');
const template =
|
javascript
|
{
"resource": ""
}
|
q1723
|
createGetAlias
|
train
|
function createGetAlias(aliases) {
if (isPlainObject(aliases) && !Array.isArray(aliases)) {
aliases = Object.keys(aliases).map((key) => { // eslint-disable-line
let onlyModule = false;
let obj = aliases[key];
if (/\$$/.test(key)) {
onlyModule = true;
key = key.substr(0, key.length - 1); // eslint-disable-line
}
if (isString(obj)) {
obj = {
alias: obj,
};
}
return {
name: key,
onlyModule,
...obj,
|
javascript
|
{
"resource": ""
}
|
q1724
|
setChecklist
|
train
|
function setChecklist(Class, item) {
var value = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true;
var checklist =
|
javascript
|
{
"resource": ""
}
|
q1725
|
hasChecklist
|
train
|
function hasChecklist(Class) {
var checklist = getChecklist(Class);
for (var _len2 = arguments.length, items = new Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) {
items[_key2 - 1] = arguments[_key2];
}
if (checklist && items.length) {
for (var _i2 = 0; _i2 < items.length; _i2++) {
|
javascript
|
{
"resource": ""
}
|
q1726
|
newChecklist
|
train
|
function newChecklist(Class) {
if (Class) {
var _keys, _complete, _Class$META_KEY$CHECK, _mutatorMap;
// $FlowFixMe
Class[_GQLBase.META_KEY][CHECKLIST] = (_Class$META_KEY$CHECK = {}, (0, _defineProperty2.default)(_Class$META_KEY$CHECK, CHECK_SCHEMA, false), (0, _defineProperty2.default)(_Class$META_KEY$CHECK, CHECK_RESOLVERS, false), (0, _defineProperty2.default)(_Class$META_KEY$CHECK, CHECK_API_DOCS, false), _keys = "keys", _mutatorMap = {}, _mutatorMap[_keys] = _mutatorMap[_keys] || {}, _mutatorMap[_keys].get = function () {
return [CHECK_SCHEMA, CHECK_RESOLVERS, CHECK_API_DOCS];
}, _complete = "complete", _mutatorMap[_complete] = _mutatorMap[_complete] || {}, _mutatorMap[_complete].get
|
javascript
|
{
"resource": ""
}
|
q1727
|
validateTemplate
|
train
|
function validateTemplate(template) {
var hide = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
var results = new ValidationResults();
var indent = function indent(string) {
var count = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 4;
var space = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : ' ';
return string.split('\n').map(function (s) {
return s.trim().replace(/(^)/gm, "$1".concat(space.repeat(count)));
}).join('\n');
};
if (typeof template.name === 'undefined') {
results.errors.push(new Error((0, _neTagFns.customDedent)({
dropLowest: true
})(_templateObject2())));
}
if (!(0, _neTypes.extendsFrom)(template.name, String)) {
results.errors.push(new Error((0, _neTagFns.customDedent)({
dropLowest: true
})(_templateObject3())));
}
if (typeof template.schema === 'undefined') {
results.errors.push(new Error((0, _neTagFns.customDedent)({
dropLowest: true
})(_templateObject4())));
}
if (!(0, _neTypes.extendsFrom)(template.schema, String)) {
results.errors.push(new Error((0, _neTagFns.customDedent)({
dropLowest: true
})(_templateObject5())));
}
if (!(0, _neTypes.extendsFrom)(template.resolvers, Object) // Supports 95% of objects
|| (0, _typeof2.default)(template.resolvers) !== 'object' // Supports Object.create(null)
) {
results.errors.push(new Error((0, _neTagFns.customDedent)({
dropLowest: true
})(_templateObject6())));
}
if (typeof template.docs === 'undefined') {
results.errors.push(new Error((0, _neTagFns.customDedent)({
dropLowest: true
})(_templateObject7())));
}
if (!(0, _neTypes.extendsFrom)(template.docs, Object) // Supports 95% of objects
|| (0, _typeof2.default)(template.docs) !== 'object' // Supports Object.create(null)
) {
var dr = '\x1b[31m',
br = '\x1b[91m';
var b1 = '\x1b[1m',
b0 = '\x1b[22m';
var bb = '\x1b[90m';
var dg = '\x1b[37m',
bg = '\x1b[97m';
var a0 = '\x1b[0m';
var gr = '\x1b[32m',
bgr = '\x1b[92m';
results.errors.push(new Error((0, _neTagFns.customDedent)({
dropLowest: true
})(_templateObject8(), bb, dg, b1,
|
javascript
|
{
"resource": ""
}
|
q1728
|
train
|
function(hook, context){
var hs = $('#heading-selection');
hs.on('change', function(){
var value = $(this).val();
var intValue = parseInt(value,10);
if(!_.isNaN(intValue)){
context.ace.callWithAce(function(ace){
|
javascript
|
{
"resource": ""
}
|
|
q1729
|
aceInitialized
|
train
|
function aceInitialized(hook, context){
var editorInfo = context.editorInfo;
|
javascript
|
{
"resource": ""
}
|
q1730
|
argMapper
|
train
|
function argMapper(arg, index, array) {
var isError = (0, _neTypes.typeOf)(arg) === Error.name;
var showStack = /\bSTACK\b/i.test(process.env.LATTICE_ERRORS || '');
|
javascript
|
{
"resource": ""
}
|
q1731
|
failFast
|
train
|
function failFast(logLevel, lessThan) {
var ll = LatticeLogs;
if (logLevel) {
var compareTo = lessThan || process.env.LATTICE_LOGLEVEL || ll.ERROR;
if
|
javascript
|
{
"resource": ""
}
|
q1732
|
log
|
train
|
function log() {
var _console;
if (LatticeLogs.failFast(LatticeLogs.LOG)) return;
for (var _len3 = arguments.length, args = new Array(_len3), _key3 = 0; _key3 < _len3; _key3++) {
args[_key3] = arguments[_key3];
|
javascript
|
{
"resource": ""
}
|
q1733
|
warn
|
train
|
function warn() {
var _console2;
if (LatticeLogs.failFast(LatticeLogs.WARN)) return;
for (var _len4 = arguments.length, args = new Array(_len4), _key4 = 0; _key4 < _len4; _key4++) {
args[_key4] = arguments[_key4];
|
javascript
|
{
"resource": ""
}
|
q1734
|
error
|
train
|
function error() {
var _console3;
if (LatticeLogs.failFast(LatticeLogs.ERROR)) return;
for (var _len5 = arguments.length, args = new Array(_len5), _key5 = 0; _key5 < _len5; _key5++) {
args[_key5] = arguments[_key5];
|
javascript
|
{
"resource": ""
}
|
q1735
|
info
|
train
|
function info() {
var _console4;
if (LatticeLogs.failFast(LatticeLogs.INFO)) return;
for (var _len6 = arguments.length, args = new Array(_len6), _key6 = 0; _key6 < _len6; _key6++) {
args[_key6] = arguments[_key6];
|
javascript
|
{
"resource": ""
}
|
q1736
|
trace
|
train
|
function trace() {
var _console5;
if (LatticeLogs.failFast(LatticeLogs.TRACE)) return;
for (var _len7 = arguments.length, args = new Array(_len7), _key7 = 0; _key7 < _len7; _key7++) {
args[_key7] = arguments[_key7];
|
javascript
|
{
"resource": ""
}
|
q1737
|
notDefined
|
train
|
function notDefined(keyToTest, keySupplied, instance) {
return new RegExp("^" + keyToTest +
|
javascript
|
{
"resource": ""
}
|
q1738
|
getProp
|
train
|
function getProp(propName) {
var bindGetters = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
var bindTo = arguments.length > 2 ? arguments[2] : undefined;
// $FlowFixMe
var proto = Object.getPrototypeOf(this);
var descriptor = Object.getOwnPropertyDescriptor(proto, propName);
var result;
if (!descriptor) {
return null;
}
if (descriptor) {
if (descriptor.initializer || descriptor.get) {
var what = descriptor.initializer
|
javascript
|
{
"resource": ""
}
|
q1739
|
IDLFilePath
|
train
|
function IDLFilePath(path) {
var extension = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : '.graphql';
|
javascript
|
{
"resource": ""
}
|
q1740
|
nodeToString
|
train
|
function nodeToString(node) {
switch (node.type) {
case ("BinaryExpression"): {
return nodeToString(node.left) + node.operator.toString() + nodeToString(node.right);
}
case ("CallExpression"): {
var args = node.arguments.map(function(arg) {
return nodeToString(arg);
}).toString();
return nodeToString(node.callee) + "(" + args + ")";
}
case ("ConditionalExpression"): {
return nodeToString(node.test) + "?" + nodeToString(node.consequent) + ":" + nodeToString(node.alternate);
}
case ("Identifier"): {
return node.name.toString();
}
case ("Literal"): {
return node.value.toString();
}
case ("MemberExpression"): {
return nodeToString(node.object) + "[" + nodeToString(node.property) + "]";
}
case ("TemplateElement"): {
return node.value.raw.toString();
}
case ("TemplateLiteral"): {
|
javascript
|
{
"resource": ""
}
|
q1741
|
train
|
function(positions) {
var xs = [], ys = [], zs = [];
var xi = {}, yi = {}, zi = {};
for (var i=0; i<positions.length; i++) {
var p = positions[i];
var x = p[0], y = p[1], z = p[2];
// Split the positions array into arrays of unique component values.
//
// Why go through the trouble of using a uniqueness hash table vs
// sort and uniq:
//
// Suppose you've got a million positions in a 100x100x100 grid.
//
// Using a uniqueness hash table, you're doing 1M array reads,
// 3M hash table lookups from 100-element hashes, 300 hash table inserts, then
// sorting three 100-element arrays and iterating over them.
// Roughly, 1M + 3M * ln(100) + 300 * ln(100/2) + 3 * 100 * ln(100) + 3 * 100 =
// 1M + 13.8M + 0.0012M + 0.0014M + 0.0003M
// =~ 15M
//
// Sort and uniq solution would do 1M array reads, 3M array inserts,
// sort three 1M-element arrays and iterate over them.
// Roughly, 1M + 3M + 3 * 1M * ln(1M) + 3 * 1M =
// 1M + 3M + 41.4M + 3M
// =~ 48.4M
//
// Guessing that a hard-coded sort & uniq would be faster due to not having
// to run a hashing function on everything. More memory usage though
// (bunch of small hash tables vs. duplicating the input array.)
//
// In JS-land, who knows. Maybe xi[x] casts x to string and destroys perf,
// maybe numeric
|
javascript
|
{
"resource": ""
}
|
|
q1742
|
encryptAndHash
|
train
|
function encryptAndHash (state, ciphertext, plaintext) {
assert(state.byteLength === STATELEN)
assert(ciphertext.byteLength != null)
assert(plaintext.byteLength != null)
var cstate = state.subarray(CIPHER_BEGIN, CIPHER_END)
var h = state.subarray(HASH_BEGIN, HASH_END)
cipherState.encryptWithAd(cstate, ciphertext, h, plaintext)
encryptAndHash.bytesRead
|
javascript
|
{
"resource": ""
}
|
q1743
|
mapStateToProps
|
train
|
function mapStateToProps(state) {
return {
clicker: state.clicker,
repoUser: state.repoUser,
|
javascript
|
{
"resource": ""
}
|
q1744
|
computeRateBetweenSubunitAmounts
|
train
|
function computeRateBetweenSubunitAmounts(fromCurrency, fromAmount, toCurrency, toAmount) {
/*
* If currencies are equal, rate is 1
*/
if (fromCurrency === toCurrency) {
return 1;
}
/*
* If toAmount is 0, we don't want to divide by zero.
* In this case, return NaN
*/
if (toAmount === 0) {
return NaN;
}
/*
|
javascript
|
{
"resource": ""
}
|
q1745
|
train
|
function(context, keys){
// If nothing can be found with the keys we are looking for, save the
// first possible match. This is where we will write to.
if(firstSearchedContext === undefined && !(context instanceof LetContext)) {
firstSearchedContext = context;
}
// If we have multiple keys ...
if(keys.length > 1) {
// see if we can find the parent ...
var parentKeys = keys.slice(0, keys.length-1);
var parent = stacheKey.read(context, parentKeys, options).value;
// If there is a parent, see if it has the last key
if( parent != null && canReflect.hasKey(parent, keys[keys.length-1].key ) ) {
return {
parent: parent,
parentHasKey: true,
value: undefined
|
javascript
|
{
"resource": ""
}
|
|
q1746
|
train
|
function() {
var top;
this.getScope(function(scope) {
if (scope._meta.viewModel) {
top = scope;
}
// walk
|
javascript
|
{
"resource": ""
}
|
|
q1747
|
toArray
|
train
|
function toArray(x, delimiter)
{
if ( x instanceof Array )
{
return x;
}
if ( isString( x ) )
{
return x.split( delimiter );
|
javascript
|
{
"resource": ""
}
|
q1748
|
indexOf
|
train
|
function indexOf(arr, x, comparator)
{
var cmp = comparator || equalsStrict;
for (var i = 0, n = arr.length; i < n; i++)
{
|
javascript
|
{
"resource": ""
}
|
q1749
|
isRekord
|
train
|
function isRekord(x)
{
return !!(x && x.Database && isFunction( x )
|
javascript
|
{
"resource": ""
}
|
q1750
|
createComparator
|
train
|
function createComparator(comparator, nullsFirst)
{
if ( isFunction( comparator ) )
{
return comparator;
}
else if ( isString( comparator ) )
{
if ( comparator in Comparators )
{
return Comparators[ comparator ];
}
if ( comparator.charAt(0) === '-' )
{
var parsed = createComparator( comparator.substring( 1 ), !nullsFirst );
return function compareObjectsReversed(a, b)
{
return -parsed( a, b );
};
}
else if ( isFormatInput( comparator ) )
{
var formatter = createFormatter( comparator );
return function compareFormatted(a, b)
{
var af = formatter( a );
var bf = formatter( b );
return af.localeCompare( bf );
};
}
else if ( isParseInput( comparator ) )
{
var parser = createParser( comparator );
return function compareExpression(a, b)
{
var ap = parser( a );
var bp = parser( b );
return compare( ap, bp, nullsFirst );
};
}
else
{
|
javascript
|
{
"resource": ""
}
|
q1751
|
on
|
train
|
function on(events, callback, context)
{
return onListeners( this, events, callback,
|
javascript
|
{
"resource": ""
}
|
q1752
|
once
|
train
|
function once(events, callback, context)
{
return
|
javascript
|
{
"resource": ""
}
|
q1753
|
offListeners
|
train
|
function offListeners(listeners, event, callback)
{
if (listeners && event in listeners)
{
var eventListeners = listeners[ event ];
var next, node = eventListeners.next;
while (node !== eventListeners)
{
next = node.next;
|
javascript
|
{
"resource": ""
}
|
q1754
|
off
|
train
|
function off(eventsInput, callback)
{
// Remove ALL listeners
if ( !isDefined( eventsInput ) )
{
deleteProperty( this, '$$on' );
}
else
{
var events = toArray( eventsInput, ' ' );
// Remove listeners for given events
if ( !isFunction( callback ) )
{
for (var i = 0; i < events.length; i++)
{
deleteProperty( this.$$on, events[i] );
}
|
javascript
|
{
"resource": ""
}
|
q1755
|
triggerListeners
|
train
|
function triggerListeners(listeners, event, args)
{
if (listeners && event in listeners)
{
var eventListeners = listeners[ event ];
var triggerGroup = ++triggerId;
var next, node = eventListeners.next;
|
javascript
|
{
"resource": ""
}
|
q1756
|
trigger
|
train
|
function trigger(eventsInput, args)
{
try
{
var events = toArray( eventsInput, ' ' );
for (var i = 0; i < events.length; i++)
{
triggerListeners( this.$$on, events[ i ], args );
}
}
|
javascript
|
{
"resource": ""
}
|
q1757
|
merge
|
train
|
function merge(dst, src, ignoreMap)
{
if (isObject( dst ) && isObject( src ))
{
for (var prop in src)
{
if (!ignoreMap || !ignoreMap[ prop ])
{
var adding = src[ prop ];
if (prop in dst)
{
var existing = dst[ prop ];
if (isArray( existing ))
{
if (isArray( adding ))
{
existing.push.apply( existing, adding );
}
else
{
existing.push( adding );
}
}
else if (isObject( existing ))
{
|
javascript
|
{
"resource": ""
}
|
q1758
|
propsMatch
|
train
|
function propsMatch(test, testFields, expected, expectedFields, equals)
{
var equality = equals || Rekord.equals;
if ( isString( testFields ) ) // && isString( expectedFields )
{
return equality( test[ testFields ], expected[ expectedFields ] );
}
else // if ( isArray( testFields ) && isArray( expectedFields ) )
{
for (var i = 0; i < testFields.length; i++)
|
javascript
|
{
"resource": ""
}
|
q1759
|
hasFields
|
train
|
function hasFields(model, fields, exists)
{
if ( isArray( fields ) )
{
for (var i = 0; i < fields.length; i++)
{
if ( !exists( model[ fields[ i ] ] ) )
{
return false;
|
javascript
|
{
"resource": ""
}
|
q1760
|
createPropertyResolver
|
train
|
function createPropertyResolver(properties)
{
if ( isFunction( properties ) )
{
return properties;
}
else if ( isString( properties ) )
{
if ( properties in PropertyResolvers )
{
return PropertyResolvers[ properties ];
}
if ( isFormatInput( properties ) )
{
return createFormatter( properties );
}
else if ( isParseInput( properties ) )
{
return createParser( properties );
}
else
{
return function resolveProperty(model)
{
return model ? model[ properties ] : undefined;
};
}
}
else if ( isArray( properties ) )
{
return function resolveProperties(model)
{
return pull( model, properties );
};
}
else if ( isObject( properties ) )
|
javascript
|
{
"resource": ""
}
|
q1761
|
createWhere
|
train
|
function createWhere(properties, value, equals)
{
var equality = equals || equalsStrict;
if ( isFunction( properties ) )
{
return properties;
}
else if ( isArray( properties ) )
{
var parsed = [];
for (var i = 0; i < properties.length; i++)
{
var where = properties[ i ];
parsed.push( isArray( where ) ? createWhere.apply( this, where ) : createWhere( where ) );
}
return function whereMultiple(model)
{
for (var i = 0; i < parsed.length; i++)
{
if ( !parsed[ i ]( model ) )
{
return false;
}
}
return true;
};
}
else if ( isObject( properties ) )
{
var props = [];
for (var prop in properties)
{
props.push({
tester: exprEqualsTester( properties[ prop ], equality ),
resolver: createPropertyResolver( prop )
});
}
return function whereEqualsObject(model)
{
for (var i = 0; i < props.length; i++)
{
var prop = props[ i ];
if ( !prop.tester( prop.resolver( model ) ) )
{
return false;
|
javascript
|
{
"resource": ""
}
|
q1762
|
Rekord
|
train
|
function Rekord(options)
{
var promise = Rekord.get( options.name );
if ( promise.isComplete() )
{
return promise.results[0];
}
Rekord.trigger( Rekord.Events.Options, [options] );
var database = new Database( options );
var model = Class.dynamic(
Model,
new Model( database ),
database.className,
'(props, remoteData) { this.$init( props, remoteData ) }'
);
|
javascript
|
{
"resource": ""
}
|
q1763
|
train
|
function(saving)
{
if ( !isObject( saving ) )
{
return false;
}
for (var prop in saving)
{
if ( !this.ignoredFields[
|
javascript
|
{
"resource": ""
}
|
|
q1764
|
train
|
function(input, callback, context, remoteData)
{
var db = this;
var promise = new Promise();
promise.success( callback, context || db );
function checkModel()
{
var result = db.parseModel( input, remoteData );
if ( result !== false && !promise.isComplete() && db.initialized )
{
var remoteLoaded = db.remoteLoaded || !db.hasLoad( Load.All );
var missingModel = (result === null || !result.$isSaved());
var lazyLoad = db.hasLoad( Load.Lazy );
if ( lazyLoad && remoteLoaded && missingModel )
{
if ( !result )
{
result = db.keyHandler.buildObjectFromKey( db.keyHandler.buildKeyFromInput( input ) );
}
result.$once( Model.Events.RemoteGets, function()
{
if ( !promise.isComplete() )
{
if ( isObject( input ) )
|
javascript
|
{
"resource": ""
}
|
|
q1765
|
train
|
function(revision)
{
if ( isFunction( revision ) )
{
this.revisionFunction = revision;
}
else if ( isString( revision ) )
{
this.revisionFunction = function(a, b)
{
var ar = isObject( a ) && revision in a ? a[ revision ] : undefined;
var br = isObject( b ) && revision in b ? b[ revision ] : undefined;
|
javascript
|
{
"resource": ""
}
|
|
q1766
|
train
|
function(key)
{
var db = this;
var model = db.all[ key ];
if ( db.cache === Cache.All )
{
return db.destroyLocalCachedModel( model, key );
|
javascript
|
{
"resource": ""
}
|
|
q1767
|
train
|
function(callback, context)
{
var db = this;
var promise = new Promise();
var success = this.handleRefreshSuccess( promise );
var failure = this.handleRefreshFailure( promise );
promise.complete( callback, context || db );
|
javascript
|
{
"resource": ""
}
|
|
q1768
|
train
|
function(model, cascade, options)
{
var db = this;
if ( model.$isDeleted() )
{
Rekord.debug( Rekord.Debugs.SAVE_DELETED, db, model );
return;
}
var key = model.$key();
var existing = db.models.has( key );
if ( existing )
{
db.trigger( Database.Events.ModelUpdated, [model] );
model.$trigger( Model.Events.UpdateAndSave );
}
else
|
javascript
|
{
"resource": ""
}
|
|
q1769
|
train
|
function(model, cascade, options)
{
var db = this;
// If we have it in the models, remove it!
this.removeFromModels( model );
// If we're offline and we have a pending save - cancel the pending save.
if ( model.$status === Model.Status.SavePending )
|
javascript
|
{
"resource": ""
}
|
|
q1770
|
train
|
function(key, value)
{
if ( key in this.indices )
{
this.values[ this.indices[ key ] ] = value;
}
else
{
this.indices[
|
javascript
|
{
"resource": ""
}
|
|
q1771
|
train
|
function(index)
{
var key = this.keys[ index ];
var lastValue = AP.pop.apply( this.values );
var lastKey = AP.pop.apply( this.keys );
if ( index < this.values.length )
{
this.values[ index ] = lastValue;
this.keys[ index ]
|
javascript
|
{
"resource": ""
}
|
|
q1772
|
train
|
function(callback, dest)
{
var out = dest || new Map();
var n = this.size();
var values = this.values;
var keys = this.keys;
for (var i = 0; i < n; i++)
{
var v = values[ i ];
|
javascript
|
{
"resource": ""
}
|
|
q1773
|
train
|
function(comparator)
{
var map = this;
// Sort this partition!
function partition(left, right)
{
var pivot = map.values[ Math.floor((right + left) / 2) ];
var i = left;
var j = right;
while (i <= j)
{
while (comparator( map.values[i], pivot ) < 0)
{
i++;
}
while (comparator( map.values[j], pivot ) > 0)
{
j--;
}
if (i <= j)
{
swap( map.values, i, j );
swap( map.keys, i, j );
i++;
j--;
}
}
return i;
}
// Quicksort
function qsort(left, right)
{
var index = partition( left, right );
|
javascript
|
{
"resource": ""
}
|
|
q1774
|
partition
|
train
|
function partition(left, right)
{
var pivot = map.values[ Math.floor((right + left) / 2) ];
var i = left;
var j = right;
while (i <= j)
{
while (comparator( map.values[i], pivot ) < 0)
{
i++;
}
while (comparator( map.values[j], pivot ) > 0)
{
j--;
|
javascript
|
{
"resource": ""
}
|
q1775
|
train
|
function()
{
this.indices = {};
for (var i = 0, l = this.keys.length; i
|
javascript
|
{
"resource": ""
}
|
|
q1776
|
train
|
function(out)
{
var target = out || {};
var keys = this.keys;
var values = this.values;
for (var i = 0; i < keys.length; i++)
|
javascript
|
{
"resource": ""
}
|
|
q1777
|
train
|
function(comparator, nullsFirst)
{
var cmp = comparator ? createComparator( comparator, nullsFirst ) :
|
javascript
|
{
"resource": ""
}
|
|
q1778
|
train
|
function(comparator, nullsFirst, ignorePrimitive)
{
var cmp = comparator ? createComparator( comparator, nullsFirst ) : this.comparator;
|
javascript
|
{
"resource": ""
}
|
|
q1779
|
train
|
function(values)
{
this.length = 0;
if ( isArray( values ) )
{
AP.push.apply( this, values );
}
else if (
|
javascript
|
{
"resource": ""
}
|
|
q1780
|
train
|
function(collection, out, equals)
{
var target = out || this.cloneEmpty();
var equality = equals || equalsStrict;
for (var i = 0; i < this.length; i++)
{
var a = this[ i ];
var exists = false;
for (var j = 0; j < collection.length && !exists; j++)
|
javascript
|
{
"resource": ""
}
|
|
q1781
|
train
|
function()
{
var values = arguments;
AP.unshift.apply( this, values );
this.trigger( Collection.Events.Adds, [this, AP.slice.apply(values), 0] );
|
javascript
|
{
"resource": ""
}
|
|
q1782
|
train
|
function(values, delaySort)
{
if ( isArray( values ) && values.length )
{
var i = this.length;
AP.push.apply( this, values );
this.trigger( Collection.Events.Adds, [this, values, i] );
|
javascript
|
{
"resource": ""
}
|
|
q1783
|
train
|
function(i, value, delaySort)
{
AP.splice.call( this, i, 0, value );
this.trigger( Collection.Events.Add, [this, value, i] );
if ( !delaySort )
{
|
javascript
|
{
"resource": ""
}
|
|
q1784
|
train
|
function(delaySort)
{
var removed = AP.pop.apply( this );
var i = this.length;
this.trigger( Collection.Events.Remove, [this, removed, i] );
if ( !delaySort )
|
javascript
|
{
"resource": ""
}
|
|
q1785
|
train
|
function(delaySort)
{
var removed = AP.shift.apply( this );
this.trigger( Collection.Events.Remove, [this, removed, 0] );
if ( !delaySort )
{
|
javascript
|
{
"resource": ""
}
|
|
q1786
|
train
|
function(i, delaySort)
{
var removing;
if (i >= 0 && i < this.length)
{
removing = this[ i ];
AP.splice.call( this, i, 1 );
this.trigger( Collection.Events.Remove, [this, removing, i] );
|
javascript
|
{
"resource": ""
}
|
|
q1787
|
train
|
function(value, delaySort, equals)
{
var i = this.indexOf( value, equals );
|
javascript
|
{
"resource": ""
}
|
|
q1788
|
train
|
function(values, delaySort, equals)
{
var removed = [];
var removedIndices = [];
if ( isArray( values ) && values.length )
{
for (var i = 0; i < values.length; i++)
{
var value = values[ i ];
var k = this.indexOf( value, equals );
if ( k !== -1 )
{
removedIndices.push( k );
removed.push( value );
}
}
removedIndices.sort();
for (var i = removedIndices.length - 1; i >= 0; i--)
|
javascript
|
{
"resource": ""
}
|
|
q1789
|
train
|
function()
{
if ( AP.reverse )
{
AP.reverse.apply( this );
}
else
{
reverse( this
|
javascript
|
{
"resource": ""
}
|
|
q1790
|
train
|
function(value, equals)
{
var equality = equals || equalsStrict;
for (var i = 0; i < this.length; i++)
{
if (
|
javascript
|
{
"resource": ""
}
|
|
q1791
|
train
|
function(comparator, startingValue)
{
var cmp = createComparator( comparator || this.comparator, false );
var min = startingValue;
for (var i = 0; i < this.length; i++)
|
javascript
|
{
"resource": ""
}
|
|
q1792
|
train
|
function(comparator, startingValue)
{
var cmp = createComparator( comparator || this.comparator, true );
var max = startingValue;
for (var i = 0; i < this.length; i++)
|
javascript
|
{
"resource": ""
}
|
|
q1793
|
train
|
function(properties, startingValue, compareFunction)
{
var comparator = compareFunction || compare;
var resolver = createPropertyResolver( properties );
var min = startingValue;
for (var i = 0; i < this.length; i++)
{
var resolved =
|
javascript
|
{
"resource": ""
}
|
|
q1794
|
train
|
function(properties, startingValue, compareFunction)
{
var comparator = compareFunction || compare;
var resolver = createPropertyResolver( properties );
var max = startingValue;
for (var i = 0; i < this.length; i++)
{
var resolved =
|
javascript
|
{
"resource": ""
}
|
|
q1795
|
train
|
function(whereProperties, whereValue, whereEquals)
{
var where = createWhere( whereProperties, whereValue, whereEquals );
for (var i = 0; i < this.length; i++)
{
var model = this[ i ];
|
javascript
|
{
"resource": ""
}
|
|
q1796
|
train
|
function(properties)
{
var resolver = createPropertyResolver( properties );
for (var i = 0; i < this.length; i++)
{
var resolved = resolver(
|
javascript
|
{
"resource": ""
}
|
|
q1797
|
train
|
function(properties, value, equals)
{
var where = createWhere( properties, value, equals );
for (var i =
|
javascript
|
{
"resource": ""
}
|
|
q1798
|
train
|
function(resolver, validator, process, getResult)
{
for (var i = 0; i < this.length; i++)
{
var resolved = resolver( this[ i ] );
|
javascript
|
{
"resource": ""
}
|
|
q1799
|
train
|
function(numbers)
{
var resolver = createNumberResolver( numbers );
var result = 0;
var total = 0;
function process(x)
{
result += x;
total++;
}
function getResult()
|
javascript
|
{
"resource": ""
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.