_id
stringlengths 2
6
| title
stringlengths 0
58
| partition
stringclasses 3
values | text
stringlengths 27
233k
| language
stringclasses 1
value | meta_information
dict |
|---|---|---|---|---|---|
q4100
|
ConfbridgeMute
|
train
|
function ConfbridgeMute(conference, channel) {
ConfbridgeMute.super_.call(this,
|
javascript
|
{
"resource": ""
}
|
q4101
|
ConfbridgeUnmute
|
train
|
function ConfbridgeUnmute(conference, channel) {
ConfbridgeUnmute.super_.call(this,
|
javascript
|
{
"resource": ""
}
|
q4102
|
AGI
|
train
|
function AGI(channel, command, commandId) {
AGI.super_.call(this, 'AGI');
this.set('Channel', channel);
|
javascript
|
{
"resource": ""
}
|
q4103
|
BlindTransfer
|
train
|
function BlindTransfer(channel, context, extension) {
BlindTransfer.super_.call(this,
|
javascript
|
{
"resource": ""
}
|
q4104
|
Filter
|
train
|
function Filter(operation, filter) {
Filter.super_.call(this,
|
javascript
|
{
"resource": ""
}
|
q4105
|
Nami
|
train
|
function Nami(amiData) {
var self = this;
Nami.super_.call(this);
this.logLevel = 3; // debug level by default.
var genericLog = function(minLevel, fun, msg) {
if(self.logLevel >= minLevel) {
fun(msg);
}
};
this.logger = amiData.logger || {
error: function(msg) { genericLog(0, console.error, msg)},
warn: function(msg) { genericLog(1, console.warn, msg)},
|
javascript
|
{
"resource": ""
}
|
q4106
|
simpleIntersection
|
train
|
function simpleIntersection(array1, array2) {
return array1
// Remove falsy elements
.filter(el => el)
//
|
javascript
|
{
"resource": ""
}
|
q4107
|
generate
|
train
|
function generate(bind, el, param, value) {
var div = element('div', {'class': BindClass});
div.appendChild(element('span',
{'class': NameClass},
(param.name || param.signal)
));
|
javascript
|
{
"resource": ""
}
|
q4108
|
form
|
train
|
function form(bind, el, param, value) {
var node = element('input');
for (var key in param) {
if (key !== 'signal' && key !== 'element') {
node.setAttribute(key === 'input' ? 'type' : key, param[key]);
}
}
node.setAttribute('name', param.signal);
node.value
|
javascript
|
{
"resource": ""
}
|
q4109
|
checkbox
|
train
|
function checkbox(bind, el, param, value) {
var attr = {type: 'checkbox', name: param.signal};
if (value) attr.checked = true;
var node = element('input', attr);
|
javascript
|
{
"resource": ""
}
|
q4110
|
select
|
train
|
function select(bind, el, param, value) {
var node = element('select', {name: param.signal});
param.options.forEach(function(option) {
var attr = {value: option};
if (valuesEqual(option, value)) attr.selected = true;
node.appendChild(element('option', attr, option+''));
});
el.appendChild(node);
node.addEventListener('change', function() {
|
javascript
|
{
"resource": ""
}
|
q4111
|
radio
|
train
|
function radio(bind, el, param, value) {
var group = element('span', {'class': RadioClass});
el.appendChild(group);
bind.elements = param.options.map(function(option) {
var id = OptionClass + param.signal + '-' + option;
var attr = {
id: id,
type: 'radio',
name: param.signal,
value: option
};
if (valuesEqual(option, value)) attr.checked = true;
var input = element('input', attr);
input.addEventListener('change', function() {
bind.update(option);
|
javascript
|
{
"resource": ""
}
|
q4112
|
range
|
train
|
function range(bind, el, param, value) {
value = value !== undefined ? value : ((+param.max) + (+param.min)) / 2;
var min = param.min || Math.min(0, +value) || 0,
max = param.max || Math.max(100, +value) || 100,
step = param.step || tickStep(min, max, 100);
var node = element('input', {
type: 'range',
name: param.signal,
|
javascript
|
{
"resource": ""
}
|
q4113
|
randCol
|
train
|
function randCol (r, g, b, a) {
return "rgba(" + Math.floor(Math.random() * r).toString() + "," +
|
javascript
|
{
"resource": ""
}
|
q4114
|
render
|
train
|
function render (callback) {
if (effectAttrs.speed !== undefined) {
setTimeout(function () {
id = requestAnimationFrame(callback);
|
javascript
|
{
"resource": ""
}
|
q4115
|
xmlparser
|
train
|
function xmlparser(options) {
var parserOptions = util._extend({
async: false,
explicitArray: true,
normalize: true,
normalizeTags: true,
trim: true
}, options || {});
return xmlbodyparser;
/**
* Provide connect/express-style middleware
*
* @param {IncomingMessage} req
* @param {ServerResponse} res
* @param {Function} next
* @return {*}
*/
function xmlbodyparser(req, res, next) {
var data = '';
var parser = new xml2js.Parser(parserOptions);
/**
* @param {Error} err
* @param {Object} [xml]
*/
var responseHandler = function (err, xml) {
if (err) {
err.status = 400;
return next(err);
}
req.body = xml || req.body;
req.rawBody = data;
next();
};
if (req._body) {
return next();
}
req.body = req.body || {};
if (!hasBody(req) || !module.exports.regexp.test(mime(req))) {
return next();
}
req._body =
|
javascript
|
{
"resource": ""
}
|
q4116
|
hasBody
|
train
|
function hasBody(req) {
var encoding = 'transfer-encoding' in req.headers;
|
javascript
|
{
"resource": ""
}
|
q4117
|
_processOnKeyUp__noWords
|
train
|
function _processOnKeyUp__noWords(evt) {
let key = evt.keyCode || evt.which;
let char = String.fromCharCode(key);
if (key == 13) {
|
javascript
|
{
"resource": ""
}
|
q4118
|
_processOnKeyUp
|
train
|
function _processOnKeyUp(evt) {
let key = evt.keyCode || evt.which;
let char = String.fromCharCode(key);
let self = this;
if (key === 38) {
if (self._idx > 0) {
_unselectWord(self._words[self._idx]);
self._idx--;
}
self._words[self._idx].className += ' ac__word--selected';
} else if (key == 40) {
if (self._idx < self._words.length - 1) {
_unselectWord(self._words[self._idx]);
self._idx++;
}
self._words[self._idx].className += ' ac__word--selected';
} else if (key == 13) {
|
javascript
|
{
"resource": ""
}
|
q4119
|
_buildScriptContainer
|
train
|
function _buildScriptContainer(){
let parent = document.getElementById('ac__script');
if (parent == null){
parent = document.createElement('div');
parent.id = 'ac__script';
|
javascript
|
{
"resource": ""
}
|
q4120
|
_paintWords
|
train
|
function _paintWords(prefix, words){
_flushWordsContainer.call(this);
this._words = [];
let docFrag = document.createDocumentFragment();
for (let i = 0; i < words.length; i++){
let wordElement = document.createElement('p');
wordElement.className = 'ac__word';
wordElement.style.cursor = 'pointer';
let prefixElement
|
javascript
|
{
"resource": ""
}
|
q4121
|
_getSuggestions
|
train
|
function _getSuggestions(prefix) {
let scriptContainer = document.getElementById('ac__script');
let newScript = document.createElement('script');
newScript.src
|
javascript
|
{
"resource": ""
}
|
q4122
|
layoutInit
|
train
|
function layoutInit() {
IBMChat.subscribe('layout:choose', function(data) {
var widget = new Choose(data);
widgets[data.uuid] = widget;
|
javascript
|
{
"resource": ""
}
|
q4123
|
requireExtended
|
train
|
function requireExtended(name) {
var module = require(name);
if (module && module.__esModule === true && typeof module.default !== 'undefined') {
if (typeof module.__module !== 'undefined') {
// if __module is specified as a named
|
javascript
|
{
"resource": ""
}
|
q4124
|
CloudRequest
|
train
|
function CloudRequest(options) {
if (!(this instanceof CloudRequest)) return new CloudRequest(options);
merge(this, defaultOptions, options);
if (this.debug) debug.enabled = true;
if (typeof this.request === 'undefined') {
this.jar = request.jar();
this.request = request.defaults({ jar: this.jar });
|
javascript
|
{
"resource": ""
}
|
q4125
|
UnifiAPI
|
train
|
function UnifiAPI(options) {
if (!(this instanceof UnifiAPI)) return new UnifiAPI(options);
merge(this, defaultOptions, options);
this.debugging(this.debug);
if (typeof this.net === 'undefined') {
|
javascript
|
{
"resource": ""
}
|
q4126
|
run
|
train
|
function run(cmd) {
try {
if (isWindows)
cmd = 'cmd /C ' + cmd;
var code = shell.exec(cmd);
return code;
} catch (err) {
|
javascript
|
{
"resource": ""
}
|
q4127
|
exec
|
train
|
function exec(command) {
var tempName = temp.path({suffix: '.exec'});
var cmd;
if (isWindows)
cmd = command + ' > ' + tempName + ' 2>&1';
else
cmd = '(' + command + ') > ' + tempName + ' 2>&1';
var code = run(cmd);
var text;
if (fs.existsSync(tempName)) {
try {
text = fs.readFileSync(tempName, 'utf8');
fs.unlink(tempName);
|
javascript
|
{
"resource": ""
}
|
q4128
|
resolvePastAndFuture
|
train
|
function resolvePastAndFuture(past, future, future5) {
return function(d, millis) {
var isFuture = millis < 0;
if (!isFuture) {
return past;
} else {
|
javascript
|
{
"resource": ""
}
|
q4129
|
onData
|
train
|
function onData(data) {
data = data.toString("ascii");
bufferedData += data;
if (debug) console.log("Server: " + util.inspect(data));
if (checkResp === true) {
if (bufferedData.substr(0, 3) === "+OK") {
checkResp = false;
response = true;
} else if (bufferedData.substr(0, 4) === "-ERR") {
checkResp = false;
response = false;
// The following is only used for SASL
} else if (multiline === false) {
checkResp = false;
response = true;
}
}
if (checkResp === false) {
if (multiline === true && (response === false || bufferedData.substr(bufferedData.length-5) === "\r\n.\r\n")) {
// Make a copy to avoid race conditions
var responseCopy = response;
var bufferedDataCopy = bufferedData;
response = null;
|
javascript
|
{
"resource": ""
}
|
q4130
|
loadStyles
|
train
|
function loadStyles(css, doc) {
// default to the global `document` object
if (!doc) doc = document;
var head = doc.head || doc.getElementsByTagName('head')[0];
// no <head> node? create one...
if (!head) {
head = doc.createElement('head');
var body = doc.body || doc.getElementsByTagName('body')[0];
|
javascript
|
{
"resource": ""
}
|
q4131
|
Engine
|
train
|
function Engine(options) {
Options.call(this, options);
this.views = {};
this.defaultTemplates();
|
javascript
|
{
"resource": ""
}
|
q4132
|
normalize
|
train
|
function normalize (obj) {
if (!obj.dtype) {
obj.dtype = defaultDtype[obj.type] || 'array'
}
//provide limits
switch (obj.dtype) {
case 'float32':
case 'float64':
case 'audiobuffer':
case 'ndsamples':
case 'ndarray':
obj.min = -1
obj.max = 1
break;
case 'uint8':
obj.min =
|
javascript
|
{
"resource": ""
}
|
q4133
|
tracker
|
train
|
function tracker(emitters, namespace, appId, encodeBase64) {
if (!(emitters instanceof Array)) {
emitters = [emitters];
}
encodeBase64 = encodeBase64 !== false;
var trackerCore = core(encodeBase64, sendPayload);
trackerCore.setPlatform('srv'); // default platform
trackerCore.setTrackerVersion('node-' + version);
trackerCore.setTrackerNamespace(namespace);
trackerCore.setAppId(appId);
/**
* Send the payload for an event to the endpoint
*
* @param object payload Dictionary of name-value pairs for the querystring
*/
function sendPayload(payload) {
var builtPayload = payload.build();
for (var i=0; i<emitters.length; i++) {
emitters[i].input(builtPayload);
}
}
var trackEcommerceTransaction = trackerCore.trackEcommerceTransaction;
/**
* Track an ecommerce transaction and all items in that transaction
* Each item is represented by a dictionary which may have the following fields:
* 1. string sku Required. SKU code of the item.
* 2. string name Optional. Name of the item.
* 3. string category Optional. Category of the item.
* 4. string price Required. Price of the item.
* 5. string quantity Required. Purchase quantity.
* 6. array context Optional. Custom context relating to the item.
* 7. number tstamp Optional. Timestamp for the item.
*
* @param string orderId Required. Internal unique order id number for this transaction.
* @param string affiliation Optional. Partner or store affiliation.
* @param string total Required. Total amount of the transaction.
* @param string tax Optional. Tax amount of the transaction.
* @param string shipping Optional. Shipping charge for the transaction.
* @param string city Optional. City to associate with transaction.
* @param string state Optional. State to associate with transaction.
* @param string country Optional. Country to associate with transaction.
* @param string currency Optional. Currency to associate with
|
javascript
|
{
"resource": ""
}
|
q4134
|
sendPayload
|
train
|
function sendPayload(payload) {
var builtPayload = payload.build();
for (var
|
javascript
|
{
"resource": ""
}
|
q4135
|
emitter
|
train
|
function emitter(endpoint, protocol, port, method, bufferSize, callback, agentOptions) {
protocol = (protocol || 'http').toLowerCase();
method = (method || 'get').toLowerCase();
if (bufferSize === null || typeof bufferSize === 'undefined') {
bufferSize = method === 'get' ? 0 : 10;
}
var portString = port ? ':' + port : '';
var path = method === 'get' ? '/i' : '/com.snowplowanalytics.snowplow/tp2';
var targetUrl = protocol + '://' + endpoint + portString + path;
var buffer = [];
/**
* Send all events queued in the buffer to the collector
*/
function flush() {
var temp = buffer;
buffer = [];
if (method === 'post') {
var postJson = {
schema: 'iglu:com.snowplowanalytics.snowplow/payload_data/jsonschema/1-0-0',
data: temp.map(valuesToStrings)
};
request.post({
url: targetUrl,
json: postJson,
|
javascript
|
{
"resource": ""
}
|
q4136
|
flush
|
train
|
function flush() {
var temp = buffer;
buffer = [];
if (method === 'post') {
var postJson = {
schema: 'iglu:com.snowplowanalytics.snowplow/payload_data/jsonschema/1-0-0',
data: temp.map(valuesToStrings)
};
request.post({
url: targetUrl,
json: postJson,
agentOptions: agentOptions,
headers: {
'content-type': 'application/json; charset=utf-8'
|
javascript
|
{
"resource": ""
}
|
q4137
|
valuesToStrings
|
train
|
function valuesToStrings(payload) {
var stringifiedPayload = {};
for (var key in payload) {
if (payload.hasOwnProperty(key)) {
|
javascript
|
{
"resource": ""
}
|
q4138
|
train
|
function(entity, options) {
options = options || {};
options.checkext = options.checkext || checkext;
options.extlist = options.extlist || extlist;
options.logFormat = options.logFormat || '%s: %s';
options.logger = options.logger || console;
options.ignore = options.ignore || false;
options.cwd = options.cwd || '';
this.options = options;
this.scripts = [];
if (!(options.extlist instanceof RegExp) && options.extlist instanceof Array){
this.__log('Converting extension list to regular
|
javascript
|
{
"resource": ""
}
|
|
q4139
|
createNamespace
|
train
|
function createNamespace(parent, parts) {
var part = getName(parts.shift());
if (!parent[part]) {
parent[part] = {};
}
if (parts.length) {
|
javascript
|
{
"resource": ""
}
|
q4140
|
getName
|
train
|
function getName(script) {
var script = path.basename(script, path.extname(script)).replace(/[^a-zA-Z0-9]/g, '.')
, parts = script.split('.')
|
javascript
|
{
"resource": ""
}
|
q4141
|
assertValidFieldType
|
train
|
function assertValidFieldType(pojoName, fieldName, pojo, expectedType) {
var value = pojo[fieldName];
var actualType = typeof value;
if (value === undefined || value === null) {
return;
}
switch (expectedType) {
case BOOLEAN_TYPE:
if (actualType !== BOOLEAN_TYPE && actualType !== NUMBER_TYPE) {
err();
}
pojo[fieldName] = Boolean(value);
return;
case NUMBER_TYPE:
if (actualType === NUMBER_TYPE) {
return;
}
if (actualType === STRING_TYPE) {
var newValue = parseFloat(value);
if (isNaN(newValue)) {
err();
}
pojo[fieldName] = newValue;
}
return;
case STRING_TYPE:
if (actualType !== STRING_TYPE) {
pojo[fieldName] = value.toString();
}
return;
case DATE_EXPECTED_TYPE:
var getTime = value.getTime;
if (typeof getTime === FUNCTION_TYPE) {
var timeValue = value.getTime();
if (isNaN(timeValue)) {
err();
}
if (!(value instanceof Date)) {
pojo[fieldName] = new Date(timeValue);
}
return;
}
if (actualType === STRING_TYPE) {
var newDate = new Date(value);
if (!isNaN(newDate.getTime())) {
pojo[fieldName] = newDate;
return;
}
}
err();
return;
case BUFFER_EXPECTED_TYPE:
if (!BUFFER_EXISTS) {
return;
}
if (!(value instanceof Buffer)) {
err();
}
|
javascript
|
{
"resource": ""
}
|
q4142
|
getCORSRequest
|
train
|
function getCORSRequest() {
var xhr = new root.XMLHttpRequest();
if ('withCredentials' in xhr) {
return xhr;
} else if (!!root.XDomainRequest) {
|
javascript
|
{
"resource": ""
}
|
q4143
|
toBase64URL
|
train
|
function toBase64URL(data) {
if (typeof data === 'string') {
data = new Buffer(data);
}
return data.toString('base64')
.replace(/=+/g, '') // remove '='s
|
javascript
|
{
"resource": ""
}
|
q4144
|
ping
|
train
|
function ping() {
result = fn.apply(context || this, args || []);
|
javascript
|
{
"resource": ""
}
|
q4145
|
wrapper
|
train
|
function wrapper() {
context = this;
args = arguments;
if (!no_postpone) {
cancel();
|
javascript
|
{
"resource": ""
}
|
q4146
|
set
|
train
|
function set(props, req, language) {
if(language) {
req.language = language;
}
else {
language = req.language = acceptLanguage.get(req.headers['accept-language']);
}
if(typeof
|
javascript
|
{
"resource": ""
}
|
q4147
|
enable
|
train
|
function enable(app, route, repoDir){
expressApp = app;
routePfx = route;
if(repoDir){
reader.setRepoDir(repoDir);
}
app.post(route, androidUpdate.updater);
|
javascript
|
{
"resource": ""
}
|
q4148
|
DragDropTouch
|
train
|
function DragDropTouch() {
this._lastClick = 0;
// enforce singleton pattern
if (DragDropTouch._instance) {
throw 'DragDropTouch instance already created.';
}
// listen to touch events
if ('ontouchstart' in document) {
var d = document, ts = this._touchstart.bind(this), tm = this._touchmove.bind(this), te = this._touchend.bind(this);
|
javascript
|
{
"resource": ""
}
|
q4149
|
registerClass
|
train
|
function registerClass(rule, className) {
// Skip falsy values
if (!className) return true
// Support array of class names `{composes: ['foo', 'bar']}`
if (Array.isArray(className)) {
for (let index = 0; index < className.length; index++) {
const isSetted = registerClass(rule, className[index])
if (!isSetted) return false
}
return true
}
// Support space separated class names `{composes: 'foo bar'}`
if (className.indexOf(' ') > -1) {
return registerClass(rule, className.split(' '))
}
const {parent} = rule.options
// It is a ref to a local rule.
if (className[0] === '$') {
const refRule = parent.getRule(className.substr(1))
if (!refRule) {
warning(false, '[JSS] Referenced rule is not
|
javascript
|
{
"resource": ""
}
|
q4150
|
buildDependencyGraph
|
train
|
function buildDependencyGraph(module, dependencies, graph) {
if (module && !graph[module]) {
graph[module] = [];
}
var dependencyNames = Object.keys(dependencies);
dependencyNames.forEach(function(dependencyName) {
var dependency = dependencies[dependencyName];
if (module && graph[module].indexOf(dependencyName) === -1) {
graph[module].push(dependencyName);
|
javascript
|
{
"resource": ""
}
|
q4151
|
resolveDependencyGraph
|
train
|
function resolveDependencyGraph(module, resolved, unresolved, dependencies) {
var moduleDependencies;
if (module) {
moduleDependencies = dependencies[module];
if (!moduleDependencies) {
throw new Error('Component ' + module + ' not installed. Try bower install --save ' + module);
}
unresolved.push(module);
}
else {
moduleDependencies = Object.keys(dependencies);
|
javascript
|
{
"resource": ""
}
|
q4152
|
extractDestData
|
train
|
function extractDestData(data) {
if (destinationConfigExists(data)) {
if (data.dest instanceof Object) {
return extractMultiDestValues(data.dest);
|
javascript
|
{
"resource": ""
}
|
q4153
|
concatenateAndWriteFile
|
train
|
function concatenateAndWriteFile(files, destination, separator) {
if (!destination || !files || !files.length) return;
files =
|
javascript
|
{
"resource": ""
}
|
q4154
|
bowerList
|
train
|
function bowerList(kind) {
return function(done) {
var params = _.extend({}, bowerOptions);
params[kind] = true;
bower.commands.list(params, {offline:
|
javascript
|
{
"resource": ""
}
|
q4155
|
expandForAll
|
train
|
function expandForAll(array, makeMask) {
var files = [];
ensureArray(array).forEach(function(item)
|
javascript
|
{
"resource": ""
}
|
q4156
|
joinPathWith
|
train
|
function joinPathWith(prepend, append) {
return function(pathPart) {
// path.join(prepend..., pathPart, append...)
var params = ensureArray(prepend
|
javascript
|
{
"resource": ""
}
|
q4157
|
isFileExtension
|
train
|
function isFileExtension(filepath, extension) {
return typeof filepath === 'string' && path.extname(filepath) === extension
|
javascript
|
{
"resource": ""
}
|
q4158
|
getFileSize
|
train
|
function getFileSize(filepath, options) {
var stats = fs.statSync(filepath);
|
javascript
|
{
"resource": ""
}
|
q4159
|
toFileStats
|
train
|
function toFileStats(componentName, filepath) {
return {
src: path.relative(bowerDir, filepath),
|
javascript
|
{
"resource": ""
}
|
q4160
|
logGroupStats
|
train
|
function logGroupStats(groupName, groupOrder, groupDest, files) {
if (!groupDest) {
return false;
}
if (!grunt.option('no-color')) {
groupDest = groupDest.cyan;
}
grunt.verbose.subhead('%s: -> %s', groupName, groupDest);
groupOrder.forEach(function(component) {
|
javascript
|
{
"resource": ""
}
|
q4161
|
freezeAllProcessDir
|
train
|
function freezeAllProcessDir(dir, basePath, result) {
fs.readdirSync(dir).forEach(function(file) {
file = PATH.resolve(dir, file);
var stat =
|
javascript
|
{
"resource": ""
}
|
q4162
|
mkpath
|
train
|
function mkpath(path) {
var dirs = path.split(PATH.sep);
var _path = '';
var winDisk = /^\w{1}:\\$/;
dirs.forEach(function(dir) {
dir = dir || PATH.sep;
if (dir) {
_path = _path ? PATH.join(_path, dir) : dir;
// fs.mkdirSync('/') raises EISDIR (invalid operation) exception on OSX 10.8.4/node 0.10
// fs.mkdirSync('D:\\') raises EPERM (operation not permitted) exception on Windows 7/node 0.10
// not tested in other configurations
if (_path === '/' || winDisk.test(PATH.resolve(dir))) {
return;
|
javascript
|
{
"resource": ""
}
|
q4163
|
save
|
train
|
function save(filePath, content) {
mkpath(PATH.dirname(filePath));
|
javascript
|
{
"resource": ""
}
|
q4164
|
subArrayJoin
|
train
|
function subArrayJoin(a, separator, from,
|
javascript
|
{
"resource": ""
}
|
q4165
|
arraySplice
|
train
|
function arraySplice(a1, from, to, a2) {
var aL = a1.slice(0,
|
javascript
|
{
"resource": ""
}
|
q4166
|
setNestingLevel
|
train
|
function setNestingLevel(config, dir, rawValue) {
// config can have value "0", so we can't use "!config[dir]"
if ( !(dir in config) ) {
|
javascript
|
{
"resource": ""
}
|
q4167
|
train
|
function(lines, error) {
var lineNumber = error.line - 1;
var result = [
renderLine(lineNumber, lines[lineNumber]),
renderPointer(error.col)
];
var i = lineNumber - 1;
var linesAround = 2;
while (i >= 0 && i >= (lineNumber - linesAround)) {
result.unshift(renderLine(i, lines[i]));
i--;
}
i = lineNumber + 1;
while (i < lines.length && i <= (lineNumber + linesAround)) {
|
javascript
|
{
"resource": ""
}
|
|
q4168
|
parseJSON
|
train
|
function parseJSON(str) {
var result;
try {
result = $scope.options.parserFn(str);
} catch (e) {
|
javascript
|
{
"resource": ""
}
|
q4169
|
error
|
train
|
function error() {
this.httpRequest.upload.onerror = function onError() {
$scope.$apply(function apply() {
$scope.finishedUploading();
$scope.isError = true;
var response = $scope.options.parserFn(this.httpRequest.responseText);
$rootScope.$broadcast('$dropletError', response);
|
javascript
|
{
"resource": ""
}
|
q4170
|
progress
|
train
|
function progress() {
var requestLength = $scope.getRequestLength(this.files);
this.httpRequest.upload.onprogress = function onProgress(event) {
$scope.$apply(function apply() {
if (event.lengthComputable) {
// Update the progress object.
|
javascript
|
{
"resource": ""
}
|
q4171
|
walk
|
train
|
function walk(wpath, type, excludeDir, callback) {
// regex - any chars, then dash type, 's' is optional, with .js or .coffee extension, case-insensitive
// e.g. articles-MODEL.js or mypackage-routes.coffee
var rgx = new RegExp('(.*)-' + type + '(s?).(js|coffee)$', 'i');
if (!fs.existsSync(wpath)) return;
fs.readdirSync(wpath).forEach(function(file) {
var newPath = path.join(wpath, file);
var stat = fs.statSync(newPath);
if (stat.isFile() && (rgx.test(file) || (baseRgx.test(file)) && ~newPath.indexOf(type))) {
|
javascript
|
{
"resource": ""
}
|
q4172
|
preload
|
train
|
function preload(gpath, type) {
glob.sync(gpath).forEach(function(file) {
|
javascript
|
{
"resource": ""
}
|
q4173
|
findAssertionSourceInTrace
|
train
|
function findAssertionSourceInTrace(trace) {
var found = null;
for (var i = 0, l = trace.length; i < l; ++i) {
if (
trace[i].file === stSkipStart.file &&
trace[i].line >= stSkipStart.line &&
|
javascript
|
{
"resource": ""
}
|
q4174
|
prepArgs
|
train
|
function prepArgs(args, name, event, defaults) {
args = Array.from(args);
var namespace = [name];
if (!Array.isArray(event)) {
|
javascript
|
{
"resource": ""
}
|
q4175
|
train
|
function (config) {
/** @type {SplunkLogger} */
this.logger = new SplunkLogger(config);
// If using the common logger's default name, change it
if (this.logger.config.name.match("splunk-javascript-logging/\\d+\\.\\d+\\.\\d+")) {
this.logger.config.name = "splunk-bunyan-logger/0.10.1";
|
javascript
|
{
"resource": ""
}
|
|
q4176
|
train
|
function (level) {
switch(level) {
case 10:
return module.exports.levels.TRACE;
case 20:
return module.exports.levels.DEBUG;
case
|
javascript
|
{
"resource": ""
}
|
|
q4177
|
train
|
function(declarations) {
var strCss = '';
if (declarations.type === 'declaration') {
strCss += '\n\t' + processDeclaration(declarations);
} else if
|
javascript
|
{
"resource": ""
}
|
|
q4178
|
train
|
function(rule) {
var strCss = '';
strCss += rule.selectors.join(',\n') + ' {';
rule.declarations.forEach(function(rules) {
strCss +=
|
javascript
|
{
"resource": ""
}
|
|
q4179
|
train
|
function(rule) {
var strCss = '';
if (rule.type === 'rule') {
strCss += processRule(rule);
|
javascript
|
{
"resource": ""
}
|
|
q4180
|
train
|
function(frame) {
var strCss = '';
if (frame.type === 'keyframe') {
strCss += frame.values.join(',') + ' {';
frame.declarations.forEach(function(declaration) {
|
javascript
|
{
"resource": ""
}
|
|
q4181
|
train
|
function(media) {
var strCss = '';
strCss += '@media ' + media.rule + ' {\n\n';
media.rules.forEach(function(rule) {
strCss += commentOrRule(rule);
});
|
javascript
|
{
"resource": ""
}
|
|
q4182
|
train
|
function(a, b, isMax) {
var sortValA = a.sortVal,
sortValB = b.sortVal;
isMax = typeof isMax !== 'undefined' ? isMax : false;
// consider print for sorting if sortVals are equal
if (sortValA === sortValB) {
if (a.rule.match(/print/)) {
// a contains print and should be sorted after b
return 1;
}
if (b.rule.match(/print/)) {
// b contains print and should be sorted after a
|
javascript
|
{
"resource": ""
}
|
|
q4183
|
train
|
function(media) {
if (options.use_external) {
media.forEach(function(item) {
strMediaStyles += processMedia(item);
});
}
|
javascript
|
{
"resource": ""
}
|
|
q4184
|
strict
|
train
|
function strict(query) {
return foldl(function(acc, val, key)
|
javascript
|
{
"resource": ""
}
|
q4185
|
installTimers
|
train
|
function installTimers(pluginConfig, lambdaContext) {
const timeRemaining = lambdaContext.getRemainingTimeInMillis();
const memoryLimit = lambdaContext.memoryLimitInMB;
function timeoutWarningFunc(cb) {
const Raven = pluginConfig.ravenClient;
ravenInstalled && Raven.captureMessage("Function Execution Time Warning", {
level: "warning",
extra: {
TimeRemainingInMsec: lambdaContext.getRemainingTimeInMillis()
}
}, cb);
}
function timeoutErrorFunc(cb) {
const Raven = pluginConfig.ravenClient;
ravenInstalled && Raven.captureMessage("Function Timed Out", {
level: "error",
extra: {
TimeRemainingInMsec: lambdaContext.getRemainingTimeInMillis()
}
}, cb);
}
function memoryWatchFunc(cb) {
const used = process.memoryUsage().rss / 1048576;
const p = (used / memoryLimit);
if (p >= 0.75) {
const Raven = pluginConfig.ravenClient;
ravenInstalled && Raven.captureMessage("Low Memory Warning", {
level: "warning",
extra: {
MemoryLimitInMB: memoryLimit,
MemoryUsedInMB: Math.floor(used)
}
|
javascript
|
{
"resource": ""
}
|
q4186
|
clearTimers
|
train
|
function clearTimers() {
if (timeoutWarning) {
clearTimeout(timeoutWarning);
timeoutWarning = null;
|
javascript
|
{
"resource": ""
}
|
q4187
|
wrapCallback
|
train
|
function wrapCallback(pluginConfig, cb) {
return (err, data) => {
// Stop watchdog timers
clearTimers();
// If an error was thrown we'll report it to Sentry
if (err && pluginConfig.captureErrors) {
const Raven = pluginConfig.ravenClient;
|
javascript
|
{
"resource": ""
}
|
q4188
|
first
|
train
|
function first(arr, fn) {
const l = arr.length;
for (let i = 0; i < l; i += 1) {
const res = fn(arr[i], i);
|
javascript
|
{
"resource": ""
}
|
q4189
|
splitArgs
|
train
|
function splitArgs(str) {
const out = [];
let inString = false;
let currentArg = '';
for (let index = 0; index < str.length; index += 1) {
const c = str[index];
if (c === ',' && !inString) {
out.push(currentArg.trim());
currentArg = '';
} else if (currentArg.length === 0 && c === '"' && !inString) {
currentArg += c;
inString =
|
javascript
|
{
"resource": ""
}
|
q4190
|
load
|
train
|
function load(template) {
return new Promise((resolve, reject) => {
const promise = Benchpress.loader(template, (templateFunction) => {
resolve(templateFunction);
});
|
javascript
|
{
"resource": ""
}
|
q4191
|
render
|
train
|
function render(template, data, block) {
data = Benchpress.addGlobals(data || {});
return Promise.try(() => {
Benchpress.cache[template] = Benchpress.cache[template] || load(template);
return Benchpress.cache[template];
}).then((templateFunction) => {
if (block) {
|
javascript
|
{
"resource": ""
}
|
q4192
|
compileRender
|
train
|
function compileRender(templateSource, data, block) {
const hash = md5(templateSource);
return Promise.try(() => {
const cached = compileRenderCache.get(hash);
if (cached) {
compileRenderCache.ttl(hash);
return cached;
}
const templateFunction = precompile(templateSource, {})
.then(code => evaluate(code));
compileRenderCache.set(hash, templateFunction);
return templateFunction;
}).then((templateFunction) => {
if (block) {
templateFunction = templateFunction.blocks && templateFunction.blocks[block];
}
|
javascript
|
{
"resource": ""
}
|
q4193
|
expressionPaths
|
train
|
function expressionPaths(basePath, expression) {
const expr = Object.assign({}, expression);
if (expr.tokenType === 'SimpleExpression') {
if (expr.path === '@value') {
expr.path = basePath;
} else {
|
javascript
|
{
"resource": ""
}
|
q4194
|
__express
|
train
|
function __express(filepath, data, next) {
data = Benchpress.addGlobals(data);
data._locals = null;
if (Benchpress.cache[filepath]) {
render(filepath, data, Benchpress.cache[filepath], next);
return;
}
fs.readFile(filepath, 'utf-8', (err, code) => {
if (err) {
|
javascript
|
{
"resource": ""
}
|
q4195
|
resolve
|
train
|
function resolve(basePath, relPath) {
// already relative, so easy work
if (/^\.\.?\//.test(relPath)) {
return relative(basePath, relPath);
}
// otherwise we have to figure out if this is something like
// BEGIN a.b.c
// `- {a.b.c.d}
// or if it's an absolute path
const base = basePath.split('.');
const rel = relPath.split('.');
// find largest possible match in the base path
// decrease size of slice until a match is found
let found = false;
let relStart;
let baseLen;
for (let l = rel.length; l > 0 && !found; l -= 1) {
// slide through array from end to start until a match is found
for (let j = base.length - l; j >= 0 && !found; j -= 1) {
// check every element from (j) to (j + l) for equality
|
javascript
|
{
"resource": ""
}
|
q4196
|
guard
|
train
|
function guard(value) {
return value == null
|
javascript
|
{
"resource": ""
}
|
q4197
|
iter
|
train
|
function iter(obj, each) {
if (!obj || typeof obj !== 'object') { return ''; }
let output = '';
const keys = Object.keys(obj);
const length = keys.length;
for (let i = 0; i < length; i
|
javascript
|
{
"resource": ""
}
|
q4198
|
helper
|
train
|
function helper(context, helpers, helperName, args) {
if (typeof helpers[helperName] !== 'function') {
return '';
}
try {
|
javascript
|
{
"resource": ""
}
|
q4199
|
runtime
|
train
|
function runtime(helpers, context, templateFunction) {
return guard(templateFunction(helpers,
|
javascript
|
{
"resource": ""
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.