_id
stringlengths 2
6
| title
stringlengths 0
58
| partition
stringclasses 3
values | text
stringlengths 52
373k
| language
stringclasses 1
value | meta_information
dict |
|---|---|---|---|---|---|
q4200
|
toYaml
|
train
|
function toYaml(data, options) {
var defaults = {indent: 2, skipInvalid: false, flowLevel: -1};
var opts = extend(defaults, options);
var fn = opts.safe ? yaml.safeDump : yaml.dump;
return fn(data, opts);
}
|
javascript
|
{
"resource": ""
}
|
q4201
|
codegen
|
train
|
function codegen(compiled, options) {
const { code } = generate(t.file(t.program(compiled)), Object.assign({}, defaults, options));
return code;
}
|
javascript
|
{
"resource": ""
}
|
q4202
|
getBlocks
|
train
|
function getBlocks(ast) {
ast = Array.isArray(ast) ? ast : [ast];
return ast.map((node) => {
if (t.isReturnStatement(node)) {
return getBlocks(node.argument);
}
if (t.isConditionalExpression(node)) {
return node.alternate ? [
...getBlocks(node.consequent),
...getBlocks(node.alternate),
] : getBlocks(node.consequent);
}
if (t.isBinaryExpression(node)) {
return handleBinaryExpression(node);
}
return null;
}).filter(Boolean).reduce((prev, arr) => prev.concat(arr), []);
}
|
javascript
|
{
"resource": ""
}
|
q4203
|
blocks
|
train
|
function blocks(ast) {
const body = [ast];
// start with body of function
const nodes = getBlocks(ast.body.body);
if (nodes.length) {
const { props } = nodes.reduce(everyBlock, { keysUsed: [], props: [] });
body.push(t.expressionStatement(t.assignmentExpression(
'=',
c.BLOCKS,
t.objectExpression(props)
)));
}
return body;
}
|
javascript
|
{
"resource": ""
}
|
q4204
|
evaluate
|
train
|
function evaluate(code) {
const context = {
module: {
exports: {},
},
};
// eslint-disable-next-line no-new-func
const renderFunction = new Function('module', code);
renderFunction(context.module);
const template = context.module.exports;
return template;
}
|
javascript
|
{
"resource": ""
}
|
q4205
|
PathExpression
|
train
|
function PathExpression(path) {
const iterPattern = /^(.*)\[(\d+)]$/;
const paths = path.split('.').reduce((prev, key) => {
const matches = key.match(iterPattern);
if (matches) {
const [, rest, index] = matches;
return [...prev, t.stringLiteral(rest), c.KEY_I(index)];
}
return [...prev, t.stringLiteral(key)];
}, []);
return paths;
}
|
javascript
|
{
"resource": ""
}
|
q4206
|
ConcatStringList
|
train
|
function ConcatStringList(outputs) {
return outputs.length ? outputs.reduce(
(prev, next) => t.binaryExpression('+', prev, next)
) : t.stringLiteral('');
}
|
javascript
|
{
"resource": ""
}
|
q4207
|
UnsafeIter
|
train
|
function UnsafeIter(branch) {
const key = c.KEY_I(branch.iterSuffix);
const arr = t.identifier('arr');
const output = t.identifier('output');
return t.callExpression(t.functionExpression(null, [], t.blockStatement([
t.variableDeclaration('var', [
t.variableDeclarator(arr, Guard(branch.subject.path)),
t.variableDeclarator(output, t.stringLiteral('')),
t.variableDeclarator(c.LENGTH, t.memberExpression(arr, c.LENGTH)),
t.variableDeclarator(c.INDEX, t.numericLiteral(0)),
t.variableDeclarator(key),
t.variableDeclarator(c.KEY),
]),
t.forStatement(
null,
t.binaryExpression('<', c.INDEX, c.LENGTH),
t.updateExpression('++', c.INDEX),
t.blockStatement([
t.expressionStatement(t.assignmentExpression('=', key, c.INDEX)),
t.expressionStatement(t.assignmentExpression('=', c.KEY, c.INDEX)),
t.expressionStatement(t.assignmentExpression('+=', output, ConcatStringList(compile(branch.body)))),
]),
),
t.returnStatement(output),
])), []);
}
|
javascript
|
{
"resource": ""
}
|
q4208
|
tokenizer
|
train
|
function tokenizer(input) {
const topLevelTokens = getTopLevelTokens();
const length = input.length;
const output = [];
let cursor = 0;
let lastBreak = 0;
while (cursor < length) {
const slice = input.slice(cursor);
const found = matchPattern(topLevelTokens, slice, false);
if (found && input[cursor - 1] === '\\') {
const text = input.slice(lastBreak, cursor - 1);
if (text) {
output.push(new Text(text));
}
const escapedText = found[1][0];
output.push(new Text(escapedText));
cursor += escapedText.length;
lastBreak = cursor;
} else if (found) {
const [Tok, matches] = found;
const text = input.slice(lastBreak, cursor);
if (text) {
output.push(new Text(text));
}
output.push(new Tok(...matches));
cursor += matches[0].length;
lastBreak = cursor;
} else {
cursor += 1;
}
}
const text = input.slice(lastBreak, cursor);
if (text) {
output.push(new Text(text));
}
// if there are more closes than opens
// intelligently remove extra ones
return removeExtraCloses(output);
}
|
javascript
|
{
"resource": ""
}
|
q4209
|
_buildDependencyTreeOf
|
train
|
function _buildDependencyTreeOf(node) {
var requireStatements = getRequireStatements(getCode(node.path))
if (requireStatements.length == 0) {
return leaves.push(node)
}
each(requireStatements, function(requireStatement) {
var childNode = []
childNode.path = resolve.requireStatement(requireStatement, node.path)
childNode.parent = node
node.push(childNode)
_buildDependencyTreeOf(childNode)
})
node.waitingForNumChildren = node.length
}
|
javascript
|
{
"resource": ""
}
|
q4210
|
_buildLevel
|
train
|
function _buildLevel(nodes) {
var level = []
levels.push(level)
var parents = []
each(nodes, function(node) {
if (!seenPaths[node.path]) {
seenPaths[node.path] = true
level.push(node.path)
}
if (node.isRoot) { return }
node.parent.waitingForNumChildren -= 1
if (node.parent.waitingForNumChildren == 0) {
parents.push(node.parent)
}
})
if (!parents.length) { return }
_buildLevel(parents)
}
|
javascript
|
{
"resource": ""
}
|
q4211
|
train
|
function(n) {
// If number given, swap endian
if (n.constructor == Number) {
return crypt.rotl(n, 8) & 0x00FF00FF | crypt.rotl(n, 24) & 0xFF00FF00;
}
// Else, assume array and swap all items
for (var i = 0; i < n.length; i++)
n[i] = crypt.endian(n[i]);
return n;
}
|
javascript
|
{
"resource": ""
}
|
|
q4212
|
train
|
function(n) {
for (var bytes = []; n > 0; n--)
bytes.push(Math.floor(Math.random() * 256));
return bytes;
}
|
javascript
|
{
"resource": ""
}
|
|
q4213
|
train
|
function(words) {
for (var bytes = [], b = 0; b < words.length * 32; b += 8)
bytes.push((words[b >>> 5] >>> (24 - b % 32)) & 0xFF);
return bytes;
}
|
javascript
|
{
"resource": ""
}
|
|
q4214
|
train
|
function(bytes) {
for (var hex = [], i = 0; i < bytes.length; i++) {
hex.push((bytes[i] >>> 4).toString(16));
hex.push((bytes[i] & 0xF).toString(16));
}
return hex.join('');
}
|
javascript
|
{
"resource": ""
}
|
|
q4215
|
train
|
function(bytes) {
for (var base64 = [], i = 0; i < bytes.length; i += 3) {
var triplet = (bytes[i] << 16) | (bytes[i + 1] << 8) | bytes[i + 2];
for (var j = 0; j < 4; j++)
if (i * 8 + j * 6 <= bytes.length * 8)
base64.push(base64map.charAt((triplet >>> 6 * (3 - j)) & 0x3F));
else
base64.push('=');
}
return base64.join('');
}
|
javascript
|
{
"resource": ""
}
|
|
q4216
|
train
|
function(base64) {
// Remove non-base-64 characters
base64 = base64.replace(/[^A-Z0-9+\/]/ig, '');
for (var bytes = [], i = 0, imod4 = 0; i < base64.length;
imod4 = ++i % 4) {
if (imod4 == 0) continue;
bytes.push(((base64map.indexOf(base64.charAt(i - 1))
& (Math.pow(2, -2 * imod4 + 8) - 1)) << (imod4 * 2))
| (base64map.indexOf(base64.charAt(i)) >>> (6 - imod4 * 2)));
}
return bytes;
}
|
javascript
|
{
"resource": ""
}
|
|
q4217
|
FtdiDevice
|
train
|
function FtdiDevice(settings) {
if (typeof(settings) === 'number') {
settings = { index: settings };
}
EventEmitter.call(this);
this.deviceSettings = settings;
this.FTDIDevice = new FTDIDevice(settings);
}
|
javascript
|
{
"resource": ""
}
|
q4218
|
train
|
function(vid, pid, callback) {
if (arguments.length === 2) {
callback = pid;
pid = null;
} else if (arguments.length === 1) {
callback = vid;
vid = null;
pid = null;
}
FTDIDriver.findAll(vid, pid, callback);
}
|
javascript
|
{
"resource": ""
}
|
|
q4219
|
matrixFunction
|
train
|
function matrixFunction(data, evaluatedData) {
const m = data.x.length;
var ans = new Array(m);
for (var point = 0; point < m; point++) {
ans[point] = [data.y[point] - evaluatedData[point]];
}
return new Matrix(ans);
}
|
javascript
|
{
"resource": ""
}
|
q4220
|
getLocation
|
train
|
function getLocation (node, sourceCode) {
if (node.type === 'ArrowFunctionExpression') {
return sourceCode.getTokenBefore(node.body)
}
return node.id || node
}
|
javascript
|
{
"resource": ""
}
|
q4221
|
train
|
function (codePath, node) {
funcInfo = {
upper: funcInfo,
codePath: codePath,
hasReturn: false,
shouldCheck: TARGET_NODE_TYPE.test(node.type) &&
node.body.type === 'BlockStatement' &&
isCallbackOfArrayMethod(node)
}
}
|
javascript
|
{
"resource": ""
}
|
|
q4222
|
train
|
function (node) {
if (funcInfo.shouldCheck) {
funcInfo.hasReturn = true
if (!node.argument) {
context.report({
node: node,
message: 'Expected a return value'
})
}
}
}
|
javascript
|
{
"resource": ""
}
|
|
q4223
|
hasPromise
|
train
|
function hasPromise (node, inBooleanPosition) {
switch (node.type) {
case 'CallExpression':
return hasPromiseMethod(node)
case 'UnaryExpression':
return hasPromise(node.argument, true)
case 'BinaryExpression':
return hasPromise(node.left, false) || hasPromise(node.right, false)
case 'LogicalExpression':
var leftHasPromise = hasPromise(node.left, inBooleanPosition)
var rightHasPromise = hasPromise(node.right, inBooleanPosition)
return leftHasPromise || rightHasPromise
case 'AssignmentExpression':
return (node.operator === '=') && hasPromise(node.right, inBooleanPosition)
case 'SequenceExpression':
return hasPromise(node.expressions[node.expressions.length - 1], inBooleanPosition)
}
return false
}
|
javascript
|
{
"resource": ""
}
|
q4224
|
isArgumentLiteral
|
train
|
function isArgumentLiteral (node) {
return node.arguments && node.arguments.length && node.arguments[0].type === 'Literal'
}
|
javascript
|
{
"resource": ""
}
|
q4225
|
isArgumentByLocator
|
train
|
function isArgumentByLocator (node) {
if (node.arguments && node.arguments.length && node.arguments[0].type === 'CallExpression') {
var argument = node.arguments[0]
if (argument.callee && argument.callee.object && argument.callee.object.name === 'by') {
return true
}
}
return false
}
|
javascript
|
{
"resource": ""
}
|
q4226
|
_proxy
|
train
|
function _proxy(rule, metas) {
var opts = _getRequestOpts(metas.req, rule);
var request = httpsSyntax.test(rule.replace) ? httpsReq : httpReq;
var pipe = request(opts, function (res) {
res.headers.via = opts.headers.via;
metas.res.writeHead(res.statusCode, res.headers);
res.on('error', function (err) {
metas.next(err);
});
res.pipe(metas.res);
});
pipe.on('error', function (err) {
metas.next(err);
});
if(!metas.req.readable) {
pipe.end();
} else {
metas.req.pipe(pipe);
}
}
|
javascript
|
{
"resource": ""
}
|
q4227
|
_getRequestOpts
|
train
|
function _getRequestOpts(req, rule) {
var opts = url.parse(req.url.replace(rule.regexp, rule.replace), true);
var query = (opts.search != null) ? opts.search : '';
if(query) {
opts.path = opts.pathname + query;
}
opts.method = req.method;
opts.headers = req.headers;
opts.agent = false;
opts.rejectUnauthorized = false;
opts.requestCert = false;
var via = defaultVia;
if(req.headers.via) {
via = req.headers.via + ', ' + via;
}
opts.headers.via = via;
delete opts.headers['host'];
return opts;
}
|
javascript
|
{
"resource": ""
}
|
q4228
|
argvPlugin
|
train
|
function argvPlugin(dynamicConfig, options) {
var self = this;
var separator;
var whitelist;
if (options && typeof options === "object") {
separator = options.separator;
whitelist = options.whitelist;
}
this(dynamicConfig).after("loadConfigFile", function (result) {
self.override.result = merge(result, minimist(process.argv.slice(2)), separator, whitelist);
});
}
|
javascript
|
{
"resource": ""
}
|
q4229
|
envPlugin
|
train
|
function envPlugin(dynamicConfig, options) {
var self = this;
var separator;
var whitelist;
if (options && typeof options === "object") {
separator = options.separator;
whitelist = options.whitelist;
}
this(dynamicConfig).after("loadConfigFile", function (result) {
self.override.result = merge(result, process.env, separator, whitelist);
});
}
|
javascript
|
{
"resource": ""
}
|
q4230
|
open
|
train
|
function open (path, delimiter = '\r\n') {
const self = this;
const flags = 'r+';
return new Promise((resolve, reject) => {
// Open file for reading and writing. An exception occurs if the file does not exist.
fs.open(path, flags, (error, fd) => {
if (error) {
reject(error);
return;
}
try {
let promise = self.term(path, delimiter, fd);
resolve(promise);
} catch (termError) {
reject(termError);
}
});
});
}
|
javascript
|
{
"resource": ""
}
|
q4231
|
isValidRecord
|
train
|
function isValidRecord(rec) {
if (rec.v === null ||
rec.level === null ||
rec.name === null ||
rec.hostname === null ||
rec.pid === null ||
rec.time === null ||
rec.msg === null) {
// Not valid Bunyan log.
return false;
} else {
return true;
}
}
|
javascript
|
{
"resource": ""
}
|
q4232
|
term
|
train
|
function term (portPath, delimiter, fd) {
return new Promise((resolve, reject) => {
let out = '',
event = new events.EventEmitter();
try {
const _fd = { fd: fd };
// Open a write stream
Duplex.Writable = fs.createWriteStream(null, _fd);
// Open a read stream
Duplex.Readable = fs.createReadStream(null, _fd);
Duplex.Readable.setEncoding('utf8');
} catch (error) {
reject(error);
return;
}
/**
* Serial data receiver; emits the data when received.
* @param {String} data - The received data
*/
Duplex.Readable.on('data', function (data) {
if (!data) return;
out += data;
if (delimiter) {
// Check if he data contains the delimiter
if (out.indexOf(delimiter) < 0) {
return;
}
// Replace the delimiter in the output data
out = out.replace(delimiter, '');
}
// Emit the output
event.emit('data', out);
// Reset the output
out = '';
});
/**
* Eventhandler that will close the communication.
* @param {String} data - The last received data
*/
const onend = (data) => {
if (!event.isOpen) return;
event.isOpen = false;
event.emit('closed', data);
};
/**
* Sends data to the serialport.
* @param {String} data - The data to send
*/
const onsend = (data) => {
if (!event.isOpen) return;
Duplex.Writable.write(data + delimiter);
};
/**
* Closes the read- and writeable stream.
*/
const onclose = () => {
// end will call `closed()`
Duplex.Readable.destroy();
Duplex.Writable.destroy();
};
// Readable error handler
Duplex.Readable.on('error', function (error) {
process.nextTick(() => event.emit('error', error));
});
// Writable error handler
Duplex.Writable.on('error', function (error) {
process.nextTick(() => event.emit('error', error));
});
// Readable end handler
Duplex.Readable.on('end', onend);
event.serialPort = portPath;
event.send = onsend;
event.close = onclose;
event.isOpen = true;
resolve(event);
});
}
|
javascript
|
{
"resource": ""
}
|
q4233
|
compileMappings
|
train
|
function compileMappings(oldMappings) {
var mappings = oldMappings.slice(0);
mappings.sort(function(map1, map2) {
if (!map1.attribute) return 1;
if (!map2.attribute) return -1;
if (map1.attribute !== map2.attribute) {
return map1.attribute < map2.attribute ? -1 : 1;
}
if (map1.value !== map2.value) {
return map1.value < map2.value ? -1 : 1;
}
if (! ('replace' in map1) && ! ('replace' in map2)) {
throw new Error('Conflicting mappings for attribute ' + map1.attribute + ' and value ' + map1.value);
}
if (map1.replace) {
return 1;
}
return -1;
});
return mappings;
}
|
javascript
|
{
"resource": ""
}
|
q4234
|
matchClosing
|
train
|
function matchClosing(input, tagname, html) {
var closeTag = '</' + tagname + '>',
openTag = new RegExp('< *' + tagname + '( *|>)', 'g'),
closeCount = 0,
openCount = -1,
from, to, chunk
;
from = html.search(input);
to = from;
while(to > -1 && closeCount !== openCount) {
to = html.indexOf(closeTag, to);
if (to > -1) {
to += tagname.length + 3;
closeCount ++;
chunk = html.slice(from, to);
openCount = chunk.match(openTag).length;
}
}
if (to === -1) {
throw new Error('Unmatched tag ' + tagname + ' in ' + html)
}
return chunk;
}
|
javascript
|
{
"resource": ""
}
|
q4235
|
BunyanFormatWritable
|
train
|
function BunyanFormatWritable (opts, out) {
if (!(this instanceof BunyanFormatWritable)) return new BunyanFormatWritable(opts, out);
opts = opts || {};
opts.objectMode = true;
Writable.call(this, opts);
this.opts = xtend({
outputMode: 'short',
color: true,
colorFromLevel: {
10: 'brightBlack', // TRACE
20: 'brightBlack', // DEBUG
30: 'green', // INFO
40: 'magenta', // WARN
50: 'red', // ERROR
60: 'brightRed', // FATAL
}
}, opts);
this.out = out || process.stdout;
}
|
javascript
|
{
"resource": ""
}
|
q4236
|
_parseWithXml2js
|
train
|
function _parseWithXml2js(xmlContent) {
return new Promise(function(resolve, reject) {
// parse the pom, erasing all
xml2js.parseString(xmlContent, XML2JS_OPTS, function(err, pomObject) {
if (err) {
// Reject with the error
reject(err);
}
// Replace the arrays with single elements with strings
removeSingleArrays(pomObject);
// Response to the call
resolve({
pomXml: xmlContent, // Only add the pomXml when loaded from the file-system.
pomObject: pomObject // Always add the object
});
});
});
}
|
javascript
|
{
"resource": ""
}
|
q4237
|
removeSingleArrays
|
train
|
function removeSingleArrays(obj) {
// Traverse all the elements of the object
traverse(obj).forEach(function traversing(value) {
// As the XML parser returns single fields as arrays.
if (value instanceof Array && value.length === 1) {
this.update(value[0]);
}
});
}
|
javascript
|
{
"resource": ""
}
|
q4238
|
joinNodeModules
|
train
|
function joinNodeModules(jsPaths){
_.each(jsPaths, function(jsPath){
var libPath = path.join(nodeModules, jsPath),
flattenedLibPath = path.join(flattenedNodeModules, jsPath);
if (fs.existsSync(libPath)) {
defaultScripts.push(libPath);
} else if (fs.existsSync(flattenedLibPath)) {
defaultScripts.push(flattenedLibPath);
} else {
console.error('Could not find ' + jsPath);
}
});
}
|
javascript
|
{
"resource": ""
}
|
q4239
|
find
|
train
|
function find () {
const serialPath = this.paths.linux.serial;
const readLink = (file, filePath) => (
new Promise((resolve, reject) => {
fs.readlink(filePath, (error, link) => {
if (error) {
reject(error);
} else {
resolve({
'info': file.replace(/\_/g, ' '),
'port': path.resolve(serialPath, link)
});
}
});
})
);
const readDir = (directory) => (
new Promise((resolve, reject) => {
fs.readdir(directory, (error, files) => {
if (error) {
reject(error);
} else {
resolve(files);
}
});
})
);
return new Promise(async (resolve, reject) => {
try {
const files = await readDir(this.paths.linux.serial);
if (!files.length) {
// Resolve if the directory is empty
resolve([]);
}
let promises = [];
files.forEach((file) => {
const filePath = path.join(serialPath, file);
promises.push(readLink(file, filePath));
});
// Wait for all promisses to be resolved
this.ports = await Promise.all(promises);
resolve(this.ports);
} catch (error) {
reject(error);
}
});
}
|
javascript
|
{
"resource": ""
}
|
q4240
|
findById
|
train
|
function findById (id) {
return new Promise(async (resolve, reject) => {
try {
if (!id || !id.length) {
throw new Error('Undefined parameter id!');
}
const ports = await this.find();
const result = ports.filter(port => port.info.includes(id));
if (!result.length) {
resolve(null);
} else {
resolve(result[0]);
}
} catch (error) {
reject(error);
}
});
}
|
javascript
|
{
"resource": ""
}
|
q4241
|
sliceInit
|
train
|
function sliceInit(opt) {
var defer = $.Deferred();
var file = opt.file;
var that = this;
var url = this.getCgiUrl(opt.path, opt.sign);
var formData = new FormData();
var uploadparts = opt.uploadparts;
formData.append('uploadparts', JSON.stringify(uploadparts));
formData.append('sha', opt.sha);
formData.append('op', 'upload_slice_init');
formData.append('filesize', file.size);
formData.append('slice_size', opt.sliceSize);
formData.append('biz_attr', opt.biz_attr);
formData.append('insertOnly', opt.insertOnly);
$.ajax({
type: 'POST',
dataType: "JSON",
url: url,
data: formData,
success: function (res) {
if (opt.globalTask.state === 'cancel') return;
res = res || {};
if (res.code == 0) {
if (res.data.access_url) {//如果秒传命中则直接返回
defer.resolve(res);
return;
}
var session = res.data.session;
var sliceSize = parseInt(res.data.slice_size);
var offset = res.data.offset || 0;
opt.session = session;
opt.slice_size = sliceSize;
opt.offset = offset;
sliceUpload.call(that, opt).done(function (r) {
defer.resolve(r);
}).fail(function (r) {
defer.reject(r);
});
// 保存正在上传的 session 文件分片 sha1，用于下一次续传优化判断是否不一样的文件
var sItem, sha1Samples = {};
for (var i = 1; i < opt.uploadparts.length; i *= 2) {
sItem = opt.uploadparts[i - 1];
sha1Samples[sItem.offset + '-' + sItem.datalen] = sItem.datasha;
}
sItem = opt.uploadparts[opt.uploadparts.length - 1];
sha1Samples[sItem.offset + '-' + sItem.datalen] = sItem.datasha;
rememberSha1(opt.session, sha1Samples, that.sha1CacheExpired);
} else {
defer.reject(res);
}
},
error: function () {
defer.reject();
},
processData: false,
contentType: false
});
return defer.promise();
}
|
javascript
|
{
"resource": ""
}
|
q4242
|
AttributionControl
|
train
|
function AttributionControl(controlDiv) {
// Set CSS for the control border.
let controlUI = document.createElement('div');
controlUI.style.backgroundColor = '#fff';
controlUI.style.opacity = '0.7';
controlUI.style.border = '2px solid #fff';
controlUI.style.cursor = 'pointer';
controlDiv.appendChild(controlUI);
// Set CSS for the control interior.
let controlText = document.createElement('div');
controlText.style.color = 'rgb(25,25,25)';
controlText.style.fontFamily = 'Roboto,Arial,sans-serif';
controlText.style.fontSize = '10px';
controlText.innerHTML = ATTR;
controlUI.appendChild(controlText);
return controlDiv;
}
|
javascript
|
{
"resource": ""
}
|
q4243
|
RequestError
|
train
|
function RequestError(message, url, error, statusCode, body) {
this.name = 'RequestError';
this.stack = (new Error()).stack;
/** @member {String} error message */
this.message = message;
/** @member {String} request URL */
this.url = url;
/** @member optional error cause */
this.error = error;
/** @member {Integer} response status code, if received */
this.statusCode = statusCode;
/** @member {String} response body, if received */
this.body = body;
}
|
javascript
|
{
"resource": ""
}
|
q4244
|
train
|
function(source, baseUrl, requestFormatter, responseFormatter) {
const querier = pointToQuery(baseUrl, requestFormatter, responseFormatter)(source);
querier.subscribe = function(callback) {
querier(0, callback)
}
return querier;
}
|
javascript
|
{
"resource": ""
}
|
|
q4245
|
baseRequest
|
train
|
function baseRequest(uri, cb) {
var url = `${BASE_URL}${uri}`;
request(url, function (error, response, body) {
debug(`Url: ${url} statusCode: ${response && response.statusCode}`);
if(error || (response && response.statusCode === 404)) {
cb(error || response);
}
cb(null, JSON.parse(body));
});
}
|
javascript
|
{
"resource": ""
}
|
q4246
|
getServerStatus
|
train
|
function getServerStatus(cb) {
async.parallel({
live: (cb) => {
request('http://live.albiononline.com/status.txt', (error, response, body) => {
if(error) {
return cb(error);
}
cb(null, JSON.parse(body.trim()));
});
},
staging: (cb) => {
request('http://staging.albiononline.com/status.txt', (error, response, body) => {
if(error) {
return cb(error);
}
cb(null, JSON.parse(body.trim()));
});
}
}, (e, rs) => {
if(e) {
return cb(e);
}
cb(null, {
live: {
status: rs.live.status,
message: rs.live.message,
},
staging: {
status: rs.staging.status,
message: rs.staging.message,
}
});
});
}
|
javascript
|
{
"resource": ""
}
|
q4247
|
getGuildTopKills
|
train
|
function getGuildTopKills(guildId, opts, cb) {
opts = opts || {};
query = "?";
if(opts.limit) {
query += `limit=${opts.limit}`;
}
if(opts.offset) {
query += `offset=${opts.offset}`;
}
if(opts.range) { // week, lastWeek, month, lastMonth
query += `range=${opts.range}`;
}
// https://gameinfo.albiononline.com/api/gameinfo/guilds/vFUVDtWgQwK-4NNwf0xo_w/data
baseRequest(`/guilds/${guildId}/top${query}`, cb);
}
|
javascript
|
{
"resource": ""
}
|
q4248
|
getPlayerTopKills
|
train
|
function getPlayerTopKills(playerId, opts, cb) {
// https://gameinfo.albiononline.com/api/gameinfo/players/Nubya8P6QWGhI6hDLQHIQQ
opts = opts || {};
query = "?";
if(opts.limit) {
query += `limit=${opts.limit}`;
}
if(opts.offset) {
query += `offset=${opts.offset}`;
}
if(opts.range) { // week, lastWeek, month, lastMonth
query += `range=${opts.range}`;
}
baseRequest(`/players/${playerId}/topkills${query}`, cb);
}
|
javascript
|
{
"resource": ""
}
|
q4249
|
_enumKeys
|
train
|
function _enumKeys(it) {
var result = _objectKeys(it);
var getSymbols = _objectGops.f;
if (getSymbols) {
var symbols = getSymbols(it);
var isEnum = _objectPie.f;
var i = 0;
var key;
while (symbols.length > i) {
if (isEnum.call(it, key = symbols[i++])) result.push(key);
}
}return result;
}
|
javascript
|
{
"resource": ""
}
|
q4250
|
_flags
|
train
|
function _flags() {
var that = _anObject(this);
var result = '';
if (that.global) result += 'g';
if (that.ignoreCase) result += 'i';
if (that.multiline) result += 'm';
if (that.unicode) result += 'u';
if (that.sticky) result += 'y';
return result;
}
|
javascript
|
{
"resource": ""
}
|
q4251
|
determineTaskList
|
train
|
function determineTaskList(packages, server=false) {
if ( packages === null ) {
return server ? conf.live_server_packages : conf.packages;
} else if (typeof packages === 'string'){
return packages.split(',')
} else {
throw 'problem reading list of packages. It is neither empty nor a comma-separated list.'
}
}
|
javascript
|
{
"resource": ""
}
|
q4252
|
isRegisteredTask
|
train
|
function isRegisteredTask(arg) {
const flag = this.server ? conf.live_server_packages.includes(arg) : conf.packages.includes(arg);
if (!flag) {
console.log('WARNING: a package name (' + arg +') was provided which is not specified in scripts/conf.json. Ignoring it.')
}
return flag;
}
|
javascript
|
{
"resource": ""
}
|
q4253
|
setMapLoc
|
train
|
function setMapLoc(lib, opts, map) {
let oldZoom;
let view;
switch (lib) {
case 'leaflet':
map.panTo([opts.lat,opts.lon]);
if (opts.zoom){map.setZoom(opts.zoom)}
break;
case 'googlemaps':
map.setCenter({lat: opts.lat,lng:opts.lon});
if (opts.zoom) {map.setZoom(opts.zoom)}
break;
case 'openlayers':
oldZoom = map.getView().getZoom();
view = new ol.View({
center: ol.proj.fromLonLat([opts.lon,opts.lat]),
zoom: opts.zoom? opts.zoom: oldZoom
});
map.setView(view);
}
}
|
javascript
|
{
"resource": ""
}
|
q4254
|
wrap1
|
train
|
function wrap1(val, opts, key) {
switch(getType(val, opts, key)) {
case 'B': return {'B': val};
case 'BS': return {'BS': val};
case 'N': return {'N': val.toString()};
case 'NS': return {'NS': eachToString(val)};
case 'S': return {'S': val.toString()};
case 'SS': return {'SS': eachToString(val)};
case 'BOOL': return {'BOOL': val ? true: false};
case 'L': return {'L': val.map(function(obj){ return wrap1(obj, opts); })};
case 'M': return {'M': wrap(val, opts)};
case 'NULL': return {'NULL': true};
default: return;
}
}
|
javascript
|
{
"resource": ""
}
|
q4255
|
wrap
|
train
|
function wrap(obj, opts) {
var result = {};
for (var key in obj) {
if(obj.hasOwnProperty(key)) {
var wrapped = wrap1(obj[key], opts, key);
if (typeof wrapped !== 'undefined')
result[key] = wrapped;
}
}
return result;
}
|
javascript
|
{
"resource": ""
}
|
q4256
|
unwrap1
|
train
|
function unwrap1(dynamoData) {
var keys = Object.keys(dynamoData);
if (keys.length !== 1)
throw new Error('Unexpected DynamoDB AttributeValue');
var typeStr = keys[0];
if (!unwrapFns.hasOwnProperty(typeStr))
throw errs.NoDatatype;
var val = dynamoData[typeStr];
return unwrapFns[typeStr] ? unwrapFns[typeStr](val) : val;
}
|
javascript
|
{
"resource": ""
}
|
q4257
|
unwrap
|
train
|
function unwrap(attrVal) {
var result = {};
for (var key in attrVal) {
if(attrVal.hasOwnProperty(key)) {
var value = attrVal[key];
if (value !== null && typeof value !== 'undefined')
result[key] = unwrap1(attrVal[key]);
}
}
return result;
}
|
javascript
|
{
"resource": ""
}
|
q4258
|
marshalList
|
train
|
function marshalList(item, marshal) {
return transform(_.isArray, _.compose(objOf('L'), _.map(marshal)), item);
}
|
javascript
|
{
"resource": ""
}
|
q4259
|
marshalMap
|
train
|
function marshalMap(item, marshal) {
return transform(_.isPlainObject, _.compose(objOf('M'), _.mapValues(marshal)), item);
}
|
javascript
|
{
"resource": ""
}
|
q4260
|
train
|
function(str, tagInner) {
tagInner = tagInner
.replace(/^ +| +$/g, '') // Not .trim() that removes \f.
.replace(/(?: *\/ +| +\/ *)/g, '/') // Remove whitespaces in </ p> or <br />
.replace(/ *= */g, '=');
return '<' + tagInner + '>';
}
|
javascript
|
{
"resource": ""
}
|
|
q4261
|
unmarshalList
|
train
|
function unmarshalList(item, unmarshal) {
return transform(_.has('L'), _.compose(_.map(unmarshal), _.property('L')), item);
}
|
javascript
|
{
"resource": ""
}
|
q4262
|
unmarshalMap
|
train
|
function unmarshalMap(item, unmarshal) {
return transform(_.has('M'), _.compose(_.mapValues(unmarshal), _.property('M')), item);
}
|
javascript
|
{
"resource": ""
}
|
q4263
|
unmarshalPassThrough
|
train
|
function unmarshalPassThrough(item) {
var key = _.find(function(type) {
return _.has(type, item);
}, ['S', 'B', 'BS', 'BOOL']);
return !key ? void 0 : item[key];
}
|
javascript
|
{
"resource": ""
}
|
q4264
|
StylingAttributeDefinition
|
train
|
function StylingAttributeDefinition(ns, name, initialValue, appliesTo, isInherit, isAnimatable, parseFunc, computeFunc) {
this.name = name;
this.ns = ns;
this.qname = ns + " " + name;
this.inherit = isInherit;
this.animatable = isAnimatable;
this.initial = initialValue;
this.applies = appliesTo;
this.parse = parseFunc;
this.compute = computeFunc;
}
|
javascript
|
{
"resource": ""
}
|
q4265
|
parseWaypoint
|
train
|
function parseWaypoint(qualifiedWaypoint) {
var parts;
if (!parsedWaypoints[qualifiedWaypoint]) {
parts = qualifiedWaypoint.split('.');
if (parts.length === 1) {
parts.unshift('globals');
}
parsedWaypoints[qualifiedWaypoint] = {
namespace : parts.shift(),
waypoint : parts.join('.')
};
}
return parsedWaypoints[qualifiedWaypoint];
}
|
javascript
|
{
"resource": ""
}
|
q4266
|
setWaypoint
|
train
|
function setWaypoint(collection, waypoint) {
angular.forEach(collection, function (value, waypoint) {
collection[waypoint] = false;
});
collection[waypoint] = true;
}
|
javascript
|
{
"resource": ""
}
|
q4267
|
eagerSlice
|
train
|
function eagerSlice (list, start, end) {
const sliced = []
for (let i = start; i < end; i++) {
sliced.push(list[i])
}
return sliced
}
|
javascript
|
{
"resource": ""
}
|
q4268
|
train
|
function(elem, other_elems) {
// Pairwise overlap detection
var overlapping = function(a, b) {
if (Math.abs(2.0*a.offsetLeft + a.offsetWidth - 2.0*b.offsetLeft - b.offsetWidth) < a.offsetWidth + b.offsetWidth) {
if (Math.abs(2.0*a.offsetTop + a.offsetHeight - 2.0*b.offsetTop - b.offsetHeight) < a.offsetHeight + b.offsetHeight) {
return true;
}
}
return false;
};
var i = 0;
// Check elements for overlap one by one, stop and return false as soon as an overlap is found
for(i = 0; i < other_elems.length; i++) {
if (overlapping(elem, other_elems[i])) {
return true;
}
}
return false;
}
|
javascript
|
{
"resource": ""
}
|
|
q4269
|
train
|
function(a, b) {
if (Math.abs(2.0*a.offsetLeft + a.offsetWidth - 2.0*b.offsetLeft - b.offsetWidth) < a.offsetWidth + b.offsetWidth) {
if (Math.abs(2.0*a.offsetTop + a.offsetHeight - 2.0*b.offsetTop - b.offsetHeight) < a.offsetHeight + b.offsetHeight) {
return true;
}
}
return false;
}
|
javascript
|
{
"resource": ""
}
|
|
q4270
|
istanbulCoberturaBadger
|
train
|
function istanbulCoberturaBadger(opts, callback) {
// Resolve the options
opts = extend({
// Setting the default coverage file generated by istanbul cobertura report.
istanbulReportFile: "./coverage/cobertura-coverage.xml",
// The default location for the destination being the coverage directory from istanbul.
destinationDir: null,
// The shields host to be used for retrieving the badge. https://github.com/badges/shields
shieldsHost: process.env.SHIELDS_HOST || "https://img.shields.io",
// The style of shield icon to generate (plastic, flat-square, flat)
shieldStyle: "flat",
// The name of the badge file to be generated
badgeFileName: "coverage",
// The thresholds to be used to give colors to the badge.
thresholds: defaultThresholds
}, opts);
opts.badgeFormat = opts.badgeFormat || "svg";
reportParser(opts.istanbulReportFile, function(err, report) {
if (err) {
return callback(err);
}
// The color depends on the fixed thresholds (RED: 0 >= % < 60) (YELLOW: 60 >= % < 90) (GREEN: % >= 90)
var color = report.overallPercent >= opts.thresholds.excellent ? "brightgreen" :
(report.overallPercent >= opts.thresholds.good ? "yellow" : "red");
// The shields service that will give badges.
var url = opts.shieldsHost + "/badge/coverage-" + report.overallPercent;
url += "%25-" + color + "." + opts.badgeFormat + "?style=" + opts.shieldStyle;
// Save always as coverage image.
var badgeFileName = path.join(opts.destinationDir, opts.badgeFileName + "." + opts.badgeFormat);
downloader(url, badgeFileName, function(err, downloadResult) {
if (err) {
return callback(err);
}
report.url = url;
report.badgeFile = downloadResult;
report.color = color;
return callback(null, report);
});
});
}
|
javascript
|
{
"resource": ""
}
|
q4271
|
processReport
|
train
|
function processReport(xml, computation) {
if (xml.packages.package instanceof Array) {
// Process all the packages
xml.packages.package.forEach(function(packageObject) {
processPackage(packageObject, computation);
});
} else {
processPackage(xml.packages.package, computation);
}
}
|
javascript
|
{
"resource": ""
}
|
q4272
|
processPackage
|
train
|
function processPackage(packageObject, computation) {
if (packageObject.classes.class instanceof Array) {
// Process each individual class
packageObject.classes.class.forEach(function(clazz) {
processClass(clazz, computation);
});
} else {
// Single class to be processed
processClass(packageObject.classes.class, computation);
}
}
|
javascript
|
{
"resource": ""
}
|
q4273
|
processClass
|
train
|
function processClass(clazz, computation) {
if (!clazz.methods.method) {
return;
}
if (clazz.methods.method instanceof Array) {
clazz.methods.method.forEach(function(method) {
++computation.total;
// Incremente the total number of methods if there were hits. Don't increment for no hit
computation.passed = parseInt(method.hits) > 0 ? ++computation.passed : computation.passed;
});
} else { // That's the method object itself.
++computation.total;
computation.passed = parseInt(clazz.methods.method.hits) > 0 ? ++computation.passed : computation.passed;
}
}
|
javascript
|
{
"resource": ""
}
|
q4274
|
HarmonyClient
|
train
|
function HarmonyClient (xmppClient) {
debug('create new harmony client')
var self = this
self._xmppClient = xmppClient
self._responseHandlerQueue = []
self._availableCommandsCache = null
function handleStanza (stanza) {
debug('handleStanza(' + stanza.toString() + ')')
// Check for state digest:
var event = stanza.getChild('event')
if (event && event.attr('type') === 'connect.stateDigest?notify') {
onStateDigest.call(self, JSON.parse(event.getText()))
}
// Check for queued response handlers:
self._responseHandlerQueue.forEach(function (responseHandler, index, array) {
if (responseHandler.canHandleStanza(stanza)) {
debug('received response stanza for queued response handler')
var response = stanza.getChildText('oa')
var decodedResponse
if (responseHandler.responseType === 'json') {
decodedResponse = JSON.parse(response)
} else {
decodedResponse = xmppUtil.decodeColonSeparatedResponse(response)
}
responseHandler.deferred.resolve(decodedResponse)
array.splice(index, 1)
}
})
}
xmppClient.on('stanza', handleStanza.bind(self))
xmppClient.on('error', function (error) {
debug('XMPP Error: ' + error.message)
})
EventEmitter.call(this)
}
|
javascript
|
{
"resource": ""
}
|
q4275
|
startActivity
|
train
|
function startActivity (activityId) {
var timestamp = new Date().getTime()
var body = 'activityId=' + activityId + ':timestamp=' + timestamp
return this.request('startactivity', body, 'encoded', function (stanza) {
// This canHandleStanzaFn waits for a stanza that confirms starting the activity.
var event = stanza.getChild('event')
var canHandleStanza = false
if (event && event.attr('type') === 'connect.stateDigest?notify') {
var digest = JSON.parse(event.getText())
if (activityId === '-1' && digest.activityId === activityId && digest.activityStatus === 0) {
canHandleStanza = true
} else if (activityId !== '-1' && digest.activityId === activityId && digest.activityStatus === 2) {
canHandleStanza = true
}
}
return canHandleStanza
})
}
|
javascript
|
{
"resource": ""
}
|
q4276
|
isOff
|
train
|
function isOff () {
debug('check if turned off')
return this.getCurrentActivity()
.then(function (activityId) {
var off = (activityId === '-1')
debug(off ? 'system is currently off' : 'system is currently on with activity ' + activityId)
return off
})
}
|
javascript
|
{
"resource": ""
}
|
q4277
|
getAvailableCommands
|
train
|
function getAvailableCommands () {
debug('retrieve available commands')
if (this._availableCommandsCache) {
debug('using cached config')
var deferred = Q.defer()
deferred.resolve(this._availableCommandsCache)
return deferred.promise
}
var self = this
return this.request('config', undefined, 'json')
.then(function (response) {
self._availableCommandsCache = response
return response
})
}
|
javascript
|
{
"resource": ""
}
|
q4278
|
buildCommandIqStanza
|
train
|
function buildCommandIqStanza (command, body) {
debug('buildCommandIqStanza for command "' + command + '" with body ' + body)
return xmppUtil.buildIqStanza(
'get'
, 'connect.logitech.com'
, 'vnd.logitech.harmony/vnd.logitech.harmony.engine?' + command
, body
)
}
|
javascript
|
{
"resource": ""
}
|
q4279
|
request
|
train
|
function request (command, body, expectedResponseType, canHandleStanzaPredicate) {
debug('request with command "' + command + '" with body ' + body)
var deferred = Q.defer()
var iq = buildCommandIqStanza(command, body)
var id = iq.attr('id')
expectedResponseType = expectedResponseType || 'encoded'
canHandleStanzaPredicate = canHandleStanzaPredicate || defaultCanHandleStanzaPredicate.bind(null, id)
this._responseHandlerQueue.push({
canHandleStanza: canHandleStanzaPredicate, deferred: deferred, responseType: expectedResponseType
})
this._xmppClient.send(iq)
return deferred.promise
}
|
javascript
|
{
"resource": ""
}
|
q4280
|
send
|
train
|
function send (command, body) {
debug('send command "' + command + '" with body ' + body)
this._xmppClient.send(buildCommandIqStanza(command, body))
return Q()
}
|
javascript
|
{
"resource": ""
}
|
q4281
|
train
|
function (table) {
var mt;
if (table instanceof shine.Table) {
if ((mt = table.__shine.metatable) && (mt = mt.__metatable)) return mt;
return table.__shine.metatable;
} else if (typeof table == 'string') {
return stringMetatable;
}
}
|
javascript
|
{
"resource": ""
}
|
|
q4282
|
train
|
function (table, index) {
// SLOOOOOOOW...
var found = (index === undefined),
numValues = table.__shine.numValues,
keys,
key, value,
i, l;
if (found || (typeof index == 'number' && index > 0 && index == index >> 0)) {
if ('keys' in Object) {
// Use Object.keys, if available.
keys = Object['keys'](numValues);
if (found) {
// First pass
i = 1;
} else if (i = keys.indexOf('' + index) + 1) {
found = true;
}
if (found) {
while ((key = keys[i]) !== void 0 && (value = numValues[key]) === void 0) i++;
if (value !== void 0) return [key >>= 0, value];
}
} else {
// Else use for-in (faster than for loop on tables with large holes)
for (l in numValues) {
i = l >> 0;
if (!found) {
if (i === index) found = true;
} else if (numValues[i] !== undefined) {
return [i, numValues[i]];
}
}
}
}
for (i in table) {
if (table.hasOwnProperty(i) && !(i in shine.Table.prototype) && i !== '__shine') {
if (!found) {
if (i == index) found = true;
} else if (table.hasOwnProperty(i) && table[i] !== undefined && ('' + i).substr(0, 2) != '__') {
return [i, table[i]];
}
}
}
for (i in table.__shine.keys) {
if (table.__shine.keys.hasOwnProperty(i)) {
var key = table.__shine.keys[i];
if (!found) {
if (key === index) found = true;
} else if (table.__shine.values[i] !== undefined) {
return [key, table.__shine.values[i]];
}
}
}
return shine.gc.createArray();
}
|
javascript
|
{
"resource": ""
}
|
|
q4283
|
train
|
function (table) {
if (!((table || shine.EMPTY_OBJ) instanceof shine.Table)) throw new shine.Error('Bad argument #1 in pairs(). Table expected');
return [shine.lib.next, table];
}
|
javascript
|
{
"resource": ""
}
|
|
q4284
|
train
|
function (table, metatable) {
var mt;
if (!((table || shine.EMPTY_OBJ) instanceof shine.Table)) throw new shine.Error('Bad argument #1 in setmetatable(). Table expected');
if (!(metatable === undefined || (metatable || shine.EMPTY_OBJ) instanceof shine.Table)) throw new shine.Error('Bad argument #2 in setmetatable(). Nil or table expected');
if ((mt = table.__shine.metatable) && (mt = mt.__metatable)) throw new shine.Error('cannot change a protected metatable');
shine.gc.incrRef(metatable);
shine.gc.decrRef(table.__shine.metatable);
table.__shine.metatable = metatable;
return table;
}
|
javascript
|
{
"resource": ""
}
|
|
q4285
|
train
|
function (min, max) {
if (min === undefined && max === undefined) return getRandom();
if (typeof min !== 'number') throw new shine.Error("bad argument #1 to 'random' (number expected)");
if (max === undefined) {
max = min;
min = 1;
} else if (typeof max !== 'number') {
throw new shine.Error("bad argument #2 to 'random' (number expected)");
}
if (min > max) throw new shine.Error("bad argument #2 to 'random' (interval is empty)");
return Math.floor(getRandom() * (max - min + 1) + min);
}
|
javascript
|
{
"resource": ""
}
|
|
q4286
|
train
|
function (table) {
var time;
if (!table) {
time = Date['now']? Date['now']() : new Date().getTime();
} else {
var day, month, year, hour, min, sec;
if (!(day = table.getMember('day'))) throw new shine.Error("Field 'day' missing in date table");
if (!(month = table.getMember('month'))) throw new shine.Error("Field 'month' missing in date table");
if (!(year = table.getMember('year'))) throw new shine.Error("Field 'year' missing in date table");
hour = table.getMember('hour') || 12;
min = table.getMember('min') || 0;
sec = table.getMember('sec') || 0;
if (table.getMember('isdst')) hour--;
time = new Date(year, month - 1, day, hour, min, sec).getTime();
}
return Math.floor(time / 1000);
}
|
javascript
|
{
"resource": ""
}
|
|
q4287
|
train
|
function (table, index, obj) {
if (!((table || shine.EMPTY_OBJ) instanceof shine.Table)) throw new shine.Error('Bad argument #1 in table.insert(). Table expected');
if (obj == undefined) {
obj = index;
index = table.__shine.numValues.length;
} else {
index = shine.utils.coerceToNumber(index, "Bad argument #2 to 'insert' (number expected)");
}
table.__shine.numValues.splice(index, 0, undefined);
table.setMember(index, obj);
}
|
javascript
|
{
"resource": ""
}
|
|
q4288
|
train
|
function (table, index) {
if (!((table || shine.EMPTY_OBJ) instanceof shine.Table)) throw new shine.Error('Bad argument #1 in table.remove(). Table expected');
var max = shine.lib.table.getn(table),
vals = table.__shine.numValues,
result;
if (index > max) return;
if (index == undefined) index = max;
result = vals.splice(index, 1);
while (index < max && vals[index] === undefined) delete vals[index++];
return result;
}
|
javascript
|
{
"resource": ""
}
|
|
q4289
|
train
|
function (obj) {
for (var i in obj) if (obj.hasOwnProperty(i)) delete obj[i];
this.objects.push(obj);
// this.collected++;
}
|
javascript
|
{
"resource": ""
}
|
|
q4290
|
train
|
function (val) {
if (!val || !(val instanceof shine.Table) || val.__shine.refCount === undefined) return;
if (--val.__shine.refCount == 0) this.collect(val);
}
|
javascript
|
{
"resource": ""
}
|
|
q4291
|
train
|
function (val) {
if (val === undefined || val === null) return;
if (val instanceof Array) return this.cacheArray(val);
if (typeof val == 'object' && val.constructor == Object) return this.cacheObject(val);
if (!(val instanceof shine.Table) || val.__shine.refCount === undefined) return;
var i, l,
meta = val.__shine;
for (i = 0, l = meta.keys.length; i < l; i++) this.decrRef(meta.keys[i]);
for (i = 0, l = meta.values.length; i < l; i++) this.decrRef(meta.values[i]);
for (i = 0, l = meta.numValues.length; i < l; i++) this.decrRef(meta.numValues[i]);
this.cacheArray(meta.keys);
this.cacheArray(meta.values);
delete meta.keys;
delete meta.values;
this.cacheObject(meta);
delete val.__shine;
for (i in val) if (val.hasOwnProperty(i)) this.decrRef(val[i]);
}
|
javascript
|
{
"resource": ""
}
|
|
q4292
|
formatValue
|
train
|
function formatValue (value) {
if (typeof value == 'string') {
value = value.replace(NEWLINE_PATTERN, '\\n');
value = value.replace(APOS_PATTERN, '\\\'');
return "'" + value + "'";
}
return value;
}
|
javascript
|
{
"resource": ""
}
|
q4293
|
train
|
function (val, errorMessage) {
switch(true) {
case typeof val == 'string':
return val;
case val === undefined:
case val === null:
return 'nil';
case val === Infinity:
return 'inf';
case val === -Infinity:
return '-inf';
case typeof val == 'number':
case typeof val == 'boolean':
return window.isNaN(val)? 'nan' : '' + val;
default:
return throwCoerceError(val, errorMessage) || '';
}
}
|
javascript
|
{
"resource": ""
}
|
|
q4294
|
train
|
function (table) {
var isArr = shine.lib.table.getn (table) > 0,
result = shine.gc['create' + (isArr? 'Array' : 'Object')](),
numValues = table.__shine.numValues,
i,
l = numValues.length;
for (i = 1; i < l; i++) {
result[i - 1] = ((numValues[i] || shine.EMPTY_OBJ) instanceof shine.Table)? shine.utils.toObject(numValues[i]) : numValues[i];
}
for (i in table) {
if (table.hasOwnProperty(i) && !(i in shine.Table.prototype) && i !== '__shine') {
result[i] = ((table[i] || shine.EMPTY_OBJ) instanceof shine.Table)? shine.utils.toObject(table[i]) : table[i];
}
}
return result;
}
|
javascript
|
{
"resource": ""
}
|
|
q4295
|
train
|
function (url, success, error) {
var xhr = new XMLHttpRequest(),
parse;
xhr.open('GET', url, true);
// Use ArrayBuffer where possible. Luac files do not load properly with 'text'.
if ('ArrayBuffer' in window) {
xhr.responseType = 'arraybuffer';
parse = function (data) {
// There is a limit on the number of arguments one can pass to a function. So far iPad is the lowest, and 10000 is safe.
// If safe number of arguments to pass to fromCharCode:
if (data.byteLength <= 10000) return String.fromCharCode.apply(String, Array.prototype.slice.call(new Uint8Array(data)));
// otherwise break up bytearray:
var i, l,
arr = new Uint8Array(data),
result = '';
for (i = 0, l = data.byteLength; i < l; i += 10000) {
result += String.fromCharCode.apply(String, Array.prototype.slice.call(arr.subarray(i, Math.min(i + 10000, l))));
}
return result;
};
} else {
xhr.responseType = 'text';
parse = function (data) { return data; };
}
xhr.onload = function (e) {
if (this.status == 200) {
if (success) success(parse(this.response));
} else {
if (error) error(this.status);
}
}
xhr.send(shine.EMPTY_OBJ);
}
|
javascript
|
{
"resource": ""
}
|
|
q4296
|
defaults
|
train
|
function defaults(options) {
options || (options = {});
options.apiKey || (options.apiKey = 'YOUR_API_KEY');
options.host || (options.host = 'cdn.segment.com');
if (!has.call(options, 'page')) options.page = true;
if (!has.call(options, 'load')) options.load = true;
return options;
}
|
javascript
|
{
"resource": ""
}
|
q4297
|
renderPage
|
train
|
function renderPage(page) {
if (!page) return '';
var args = [];
if (page.category) args.push(page.category);
if (page.name) args.push(page.name);
if (page.properties) args.push(page.properties);
// eslint-disable-next-line no-restricted-globals
var res = 'analytics.page(' + map(JSON.stringify, args).join(', ') + ');';
return res;
}
|
javascript
|
{
"resource": ""
}
|
q4298
|
getValidInterval
|
train
|
function getValidInterval([min, max]) {
let [validMin, validMax] = [min, max];
// exchange
if (min > max) {
[validMin, validMax] = [max, min];
}
return [validMin, validMax];
}
|
javascript
|
{
"resource": ""
}
|
q4299
|
getFormatStep
|
train
|
function getFormatStep(roughStep, allowDecimals, correctionFactor) {
if (roughStep.lte(0)) { return new Decimal(0); }
const digitCount = Arithmetic.getDigitCount(roughStep.toNumber());
// The ratio between the rough step and the smallest number which has a bigger
// order of magnitudes than the rough step
const digitCountValue = new Decimal(10).pow(digitCount);
const stepRatio = roughStep.div(digitCountValue);
// When an integer and a float multiplied, the accuracy of result may be wrong
const stepRatioScale = digitCount !== 1 ? 0.05 : 0.1;
const amendStepRatio = new Decimal(
Math.ceil(stepRatio.div(stepRatioScale).toNumber()),
).add(correctionFactor).mul(stepRatioScale);
const formatStep = amendStepRatio.mul(digitCountValue);
return allowDecimals ? formatStep : new Decimal(Math.ceil(formatStep));
}
|
javascript
|
{
"resource": ""
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.