_id
stringlengths 2
6
| title
stringlengths 0
58
| partition
stringclasses 3
values | text
stringlengths 27
233k
| language
stringclasses 1
value | meta_information
dict |
|---|---|---|---|---|---|
q4400
|
triggerDropdownAutocomplete
|
train
|
function triggerDropdownAutocomplete(){
// First check with the autocomplete words (the ones that are not objects
var autocomplete = [],
suggestions = [],
text = $scope.areaData,
position = getCharacterPosition(),
lastWord = text.substr(0, position).split(/[\s\b{}]/);
// Get the last typed word
lastWord = lastWord[lastWord.length-1];
$scope.areaConfig.autocomplete.forEach(function(autoList){
autoList.words.forEach(function(word){
if(typeof(word) === 'string' && autocomplete.indexOf(word) < 0){
if(lastWord.length > 0 || lastWord.length < 1 && autoList.autocompleteOnSpace){
autocomplete.push(word);
}
}
});
});
if ($scope.areaConfig.dropdown !== undefined){
$scope.areaConfig.dropdown.forEach(function(element){
if(typeof(element.trigger) === 'string' && autocomplete.indexOf(element.trigger) < 0){
autocomplete.push(element.trigger);
}
});
}
|
javascript
|
{
"resource": ""
}
|
q4401
|
smartEmailDetails
|
train
|
function smartEmailDetails(details, callback) {
createsend.get('transactional/smartemail/'+details.smartEmailID, null, null, function(error, results) {
|
javascript
|
{
"resource": ""
}
|
q4402
|
sendSmartEmail
|
train
|
function sendSmartEmail(details, callback) {
createsend.post('transactional/smartemail/'+details.smartEmailID+'/send', null, details, function(error, results) {
|
javascript
|
{
"resource": ""
}
|
q4403
|
sendClassicEmail
|
train
|
function sendClassicEmail(details, callback) {
deleteNullProperties(details);
createsend.post('transactional/classicEmail/send', details.clientID, details, function(error, results)
|
javascript
|
{
"resource": ""
}
|
q4404
|
classicEmailGroupList
|
train
|
function classicEmailGroupList(details, callback) {
createsend.get('transactional/classicEmail/groups', details,
|
javascript
|
{
"resource": ""
}
|
q4405
|
statistics
|
train
|
function statistics(details, callback) {
deleteNullProperties(details);
createsend.get('transactional/statistics', details, null, function(error, results) {
|
javascript
|
{
"resource": ""
}
|
q4406
|
messageDetails
|
train
|
function messageDetails(details, callback) {
createsend.get('transactional/messages/'+details.messageID, details,
|
javascript
|
{
"resource": ""
}
|
q4407
|
messageResend
|
train
|
function messageResend(details, callback) {
createsend.post('transactional/messages/'+details.messageID+'/resend', null, null, function(error, results) {
|
javascript
|
{
"resource": ""
}
|
q4408
|
diff
|
train
|
function diff(a, b, shallow, isOwn) {
if (a === b) {
return equalObj(a);
}
var diffValue = {};
var equal = true;
for (var key in a) {
if ((!isOwn && key in b) || (isOwn && typeof b != 'undefined' && b.hasOwnProperty(key))) {
if (a[key] === b[key]) {
diffValue[key] = equalObj(a[key]);
} else {
if (!shallow && isValidAttr(a[key], b[key])) {
var valueDiff = diff(a[key], b[key], shallow, isOwn);
if (valueDiff.changed == 'equal') {
diffValue[key] = equalObj(a[key]);
} else {
equal = false;
diffValue[key] = valueDiff;
}
} else {
equal = false;
diffValue[key] = {
changed: 'primitive change',
removed: a[key],
added: b[key]
}
|
javascript
|
{
"resource": ""
}
|
q4409
|
escape
|
train
|
function escape (script) {
return script.replace(/\\/g, '\\\\').replace(/\n/g, '\\n')
|
javascript
|
{
"resource": ""
}
|
q4410
|
replaceAll
|
train
|
function replaceAll(source, name, oldStr, newStr) {
const transformedSource = new ReplaceSource(source, name);
const reTester = new RegExp(oldStr, 'g');
let reResult = reTester.exec(source.source());
if (reResult == null) {
return source;
}
while (reResult != null) {
transformedSource.replace(
|
javascript
|
{
"resource": ""
}
|
q4411
|
train
|
function(promise, expectedState, opt_expectedData, opt_util, opt_customEqualityTesters) {
var info = {};
promise.then(
function(data) {
info.actualData = data;
info.actualState = PROMISE_STATE.RESOLVED;
},
function(data) {
info.actualData = data;
info.actualState = PROMISE_STATE.REJECTED;
});
$scope.$apply(); // Trigger Promise resolution
if (!info.actualState) {
// Trigger $httpBackend flush if any requests are pending
if ($httpBackend) {
try {
$httpBackend.flush();
} catch (err) {
if (err.message !== 'No pending request to flush !') {
throw err;
}
}
}
// Trigger $timeout flush if any deferred tasks are pending
if ($timeout) {
try {
$timeout.flush();
} catch (err) {
if (err.message !== 'No deferred tasks to be flushed') {
throw err;
}
}
}
// Trigger $interval flush if any deferred tasks are pending
if ($interval) {
try {
// Flushing $interval requires an amount of time, I believe this number should flush pretty much anything useful...
$interval.flush(100000);
} catch (err) {
if (err.message !== 'No deferred tasks to be flushed') {
throw err;
}
}
}
}
info.message = 'Expected ' + info.actualState + ' to be ' + expectedState;
info.pass = info.actualState === expectedState;
|
javascript
|
{
"resource": ""
}
|
|
q4412
|
listenBeforeLeavingRoute
|
train
|
function listenBeforeLeavingRoute(route, hook) {
// TODO: Warn if they register for a route that isn't currently
// active. They're probably doing something wrong, like re-creating
// route objects on every location change.
const routeID = getRouteID(route)
let hooks = RouteHooks[routeID]
if (!hooks) {
let thereWereNoRouteHooks = !hasAnyProperties(RouteHooks)
RouteHooks[routeID] = [ hook ]
if (thereWereNoRouteHooks) {
// setup transition & beforeunload hooks
unlistenBefore = history.listenBefore(transitionHook)
if (history.listenBeforeUnload)
unlistenBeforeUnload = history.listenBeforeUnload(beforeUnloadHook)
}
} else {
if (hooks.indexOf(hook) === -1) {
warning(
|
javascript
|
{
"resource": ""
}
|
q4413
|
listen
|
train
|
function listen(listener) {
// TODO: Only use a single history listener. Otherwise we'll
// end up with multiple concurrent calls to match.
return history.listen(function (location) {
if (state.location === location) {
listener(null, state)
} else {
match(location, function (error, redirectLocation, nextState) {
if (error) {
listener(error)
} else if (redirectLocation) {
history.transitionTo(redirectLocation)
} else if (nextState) {
|
javascript
|
{
"resource": ""
}
|
q4414
|
train
|
function(args) {
args.unshift("convert");
var ret = execute(args.join(" "));
if (ret.code === 127) {
return grunt.warn(
|
javascript
|
{
"resource": ""
}
|
|
q4415
|
injectModel
|
train
|
function injectModel(name, config, m) {
const modelConfig = app.think.config('model', undefined, m);
const cacheConfig = app.think.config('cache', undefined, m);
config = helper.parseAdapterConfig(modelConfig,
|
javascript
|
{
"resource": ""
}
|
q4416
|
parse
|
train
|
function parse(topic) {
var tokens = tokenize(topic).map(process_token);
var result = {
regex:
|
javascript
|
{
"resource": ""
}
|
q4417
|
exec
|
train
|
function exec(topic) {
var regex = this.regex;
var getParams = this.getParams;
var
|
javascript
|
{
"resource": ""
}
|
q4418
|
process_token
|
train
|
function process_token(token, index, tokens) {
var last = (index === (tokens.length - 1));
if (token[0] === "+") return process_single(token, last);
else if (token[0]
|
javascript
|
{
"resource": ""
}
|
q4419
|
process_raw
|
train
|
function process_raw(token) {
var token = escapeRegex(token);
return {
type: "raw",
|
javascript
|
{
"resource": ""
}
|
q4420
|
make_clean_topic
|
train
|
function make_clean_topic(tokens) {
return tokens.map(function (token) {
if (token.type === "raw") return token.piece.slice(0, -1);
else if (token.type === "single")
|
javascript
|
{
"resource": ""
}
|
q4421
|
make_regex
|
train
|
function make_regex(tokens) {
var str = tokens.reduce(function (res, token, index) {
var is_last = (index == (tokens.length - 1));
var before_multi
|
javascript
|
{
"resource": ""
}
|
q4422
|
make_pram_getter
|
train
|
function make_pram_getter(tokens) {
return function (results) {
// Get only the capturing tokens
var capture_tokens = remove_raw(tokens);
var res = {};
// If the regex didn't actually match, just return an empty object
if (!results) return res;
// Remove the first item and iterate through the capture groups
results.slice(1).forEach(function (capture, index) {
// Retreive the token description for the capture
|
javascript
|
{
"resource": ""
}
|
q4423
|
train
|
function () {
//Render the full file
return ejs.renderFile(file, data, options, function (error, content) {
if (error) {
self.emit("error", error);
return callback(-2);
}
|
javascript
|
{
"resource": ""
}
|
|
q4424
|
ParsePath
|
train
|
function ParsePath(u) {
//Parse the url
let p = url.parse(u);
//Get the path name
let pname = p.pathname;
//Check for Windows
if( process.platform === "win32") {
//Remove the first / from the path
//https://github.com/jmjuanes/electron-ejs/pull/4#issuecomment-219254028
pname = pname.substr(1);
}
//Sanitize URL. Spaces turn into `%20` symbols in the path and
//throws
|
javascript
|
{
"resource": ""
}
|
q4425
|
linearRegression
|
train
|
function linearRegression(functionValuesX, functionValuesY){
var regression = {}
, x = functionValuesX
, y = functionValuesY
, n = y.length
, sum_x = 0
, sum_y = 0
, sum_xy = 0
, sum_xx = 0
, sum_yy = 0
for (var i = 0; i < y.length; i++) {
sum_x += x[i]
sum_y += y[i]
sum_xy += (x[i]*y[i])
sum_xx += (x[i]*x[i])
sum_yy += (y[i]*y[i])
}
regression.slope = (n * sum_xy - sum_x * sum_y) / (n*sum_xx - sum_x * sum_x)
regression.intercept = (sum_y - regression.slope * sum_x)/n
regression.rSquared = Math.pow((n*sum_xy
|
javascript
|
{
"resource": ""
}
|
q4426
|
shouldProxy
|
train
|
function shouldProxy(hostname, port) {
var NO_PROXY = getEnv('no_proxy').toLowerCase();
if (!NO_PROXY) {
return true; // Always proxy if NO_PROXY is not set.
}
if (NO_PROXY === '*') {
return false; // Never proxy if wildcard is set.
}
return NO_PROXY.split(/[,\s]/).every(function(proxy) {
if (!proxy) {
return true; // Skip zero-length hosts.
}
var parsedProxy = proxy.match(/^(.+):(\d+)$/);
var parsedProxyHostname = parsedProxy ? parsedProxy[1] : proxy;
var parsedProxyPort = parsedProxy ? parseInt(parsedProxy[2]) : 0;
if (parsedProxyPort && parsedProxyPort !== port) {
return true; // Skip if ports don't match.
}
if (!/^[.*]/.test(parsedProxyHostname)) {
// No wildcards, so stop proxying if there is an
|
javascript
|
{
"resource": ""
}
|
q4427
|
getEnv
|
train
|
function getEnv(key) {
return process.env[key.toLowerCase()]
|
javascript
|
{
"resource": ""
}
|
q4428
|
step
|
train
|
function step (pointsToEvaluate, functionValuesX, functionValuesY) {
return help.makeItArrayIfItsNot(pointsToEvaluate).map(function
|
javascript
|
{
"resource": ""
}
|
q4429
|
train
|
function (template) {
var tree = this.getTree(template)
var runTimePlugins
// Copy so far runtime plugins were generated.
runTimePlugins = this.runTimePlugins
var blocks = this.blocks
var outerBlocks = this.outerBlocks
this.clear()
// Nope, we do not want to clear the cache.
// Refactor to
|
javascript
|
{
"resource": ""
}
|
|
q4430
|
train
|
function (expressionClose, expressionOpen, s) {
var sInner = ''
var closeTag = null
var openTag = null
var findIndex = 0
do {
if (closeTag) {
findIndex += closeTag[0].length
}
closeTag = this.findTag(expressionClose, s)
if (!closeTag) {
|
javascript
|
{
"resource": ""
}
|
|
q4431
|
train
|
function (s) {
var tree = []
var value = ''
var data
// TODO Refactor, to get this removed.
this.lastTreeInExpression = tree
while (true) {
data = this.lookUp(s.slice(value.length), value)
if (data) {
tree = tree.concat(data.tree)
value = data.value
this.lastTreeInExpression = tree
if (!data.ret) {
break
|
javascript
|
{
"resource": ""
}
|
|
q4432
|
train
|
function (text) {
var tree = []
if (this.parseEmbeddedVars) {
var re = /([$][\w@]+)|`([^`]*)`/
for (var found = re.exec(text); found; found = re.exec(text)) {
tree.push({type: 'text', data:
|
javascript
|
{
"resource": ""
}
|
|
q4433
|
train
|
function (tpl) {
var ldelim = new RegExp(this.ldelim + '\\*')
var rdelim = new RegExp('\\*' + this.rdelim)
var newTpl = ''
for (var openTag = tpl.match(ldelim); openTag; openTag = tpl.match(ldelim)) {
newTpl += tpl.slice(0, openTag.index)
tpl = tpl.slice(openTag.index + openTag[0].length)
var closeTag =
|
javascript
|
{
"resource": ""
}
|
|
q4434
|
findInArray
|
train
|
function findInArray (arr, val) {
if (Array.prototype.indexOf) {
return arr.indexOf(val)
}
for (var i = 0; i < arr.length; ++i)
|
javascript
|
{
"resource": ""
}
|
q4435
|
train
|
function (tree, data) {
// Process the tree and get the output.
var output = this.process(tree, data)
if (this.debugging) {
this.plugins.debug.process([], {
|
javascript
|
{
"resource": ""
}
|
|
q4436
|
train
|
function (tree, data) {
var res = ''
var s
var node
var tmp
var plugin
for (var i = 0; i < tree.length; ++i) {
node = tree[i]
s = ''
if (node.type === 'text') {
s = node.data
} else if (node.type === 'var') {
s = this.getVarValue(node, data)
} else if (node.type === 'boolean') {
s = !!node.data
} else if (node.type === 'build-in') {
tmp = this.buildInFunctions[node.name].process.call(this, node, data)
if (typeof tmp.tpl !== 'undefined') {
// If tmp is object, which means it has modified, data also
// so copy it back to data.
s = tmp.tpl
data = tmp.data
} else {
// If tmp is string means it has not modified data.
s = tmp
}
} else if (node.type === 'plugin') {
if (this.runTimePlugins[node.name]) {
// Thats call for {function}.
tmp = this.buildInFunctions['function'].process.call(this, node, data)
if (typeof tmp.tpl !== 'undefined') {
// If tmp is object, which means it has modified, data also
// so copy it back to data.
s = tmp.tpl
data = tmp.data
} else {
// If tmp is string means it has not modified data.
s = tmp
}
} else {
plugin = this.plugins[node.name]
if (plugin.type === 'block') {
var repeat = {value: true}
while (repeat.value) {
repeat.value = false
tmp = this.process(node.subTree, data)
|
javascript
|
{
"resource": ""
}
|
|
q4437
|
train
|
function (template, options) {
var parsedTemplate
if (!options) {
options = {}
}
if (options.rdelim) {
// If delimiters are passed locally take them.
this.smarty.rdelim = options.rdelim
} else if (jSmart.prototype.right_delimiter) {
// Backward compatible. Old way to set via prototype.
this.smarty.rdelim = jSmart.prototype.right_delimiter
} else {
// Otherwise default delimiters
this.smarty.rdelim = '}'
}
if (options.ldelim) {
// If delimiters are passed locally take them.
this.smarty.ldelim = options.ldelim
} else if (jSmart.prototype.left_delimiter) {
// Backward compatible. Old way to set via prototype.
this.smarty.ldelim = jSmart.prototype.left_delimiter
} else {
// Otherwise default delimiters
this.smarty.ldelim = '{'
}
if (options.autoLiteral !== undefined) {
// If autoLiteral is passed locally, take it.
this.autoLiteral = options.autoLiteral
} else if (jSmart.prototype.auto_literal !== undefined) {
// Backward compatible. Old way to set via prototype.
this.autoLiteral = jSmart.prototype.auto_literal
}
if (options.debugging !== undefined) {
// If debugging is passed locally, take it.
this.debugging = options.debugging
} else if (jSmart.prototype.debugging !== undefined) {
// Backward compatible. Old way to set via prototype.
this.debugging = jSmart.prototype.debugging
}
if (options.escapeHtml !== undefined) {
// If escapeHtml is
|
javascript
|
{
"resource": ""
}
|
|
q4438
|
train
|
function (data) {
var outputData = ''
if (!(typeof data === 'object')) {
data = {}
}
// Define smarty inside data and copy smarty vars, so one can use $smarty
// vars inside templates.
data.smarty = {}
objectMerge(data.smarty, this.smarty)
// Take default global modifiers, add with local default modifiers.
// Merge them and keep them cached.
this.globalAndDefaultModifiers = jSmart.prototype.defaultModifiersGlobal.concat(this.defaultModifiers)
// Take default global filters, add with local default filters.
// Merge them and keep them cached.
this.globalAndDefaultFilters = jSmart.prototype.filtersGlobal.variable.concat(this.filters.variable)
jSmartProcessor.clear()
jSmartProcessor.plugins = this.plugins
jSmartProcessor.modifiers = this.modifiers
jSmartProcessor.defaultModifiers = this.defaultModifiers
jSmartProcessor.escapeHtml = this.escapeHtml
jSmartProcessor.variableFilters = this.globalAndDefaultFilters
jSmartProcessor.runTimePlugins = this.runTimePlugins
jSmartProcessor.blocks = this.blocks
|
javascript
|
{
"resource": ""
}
|
|
q4439
|
train
|
function (toPrint, indent, indentEnd) {
if (!indent) {
indent = ' '
}
if (!indentEnd) {
indentEnd = ''
}
var s = ''
var name
if (toPrint instanceof Object) {
s = 'Object (\n'
for (name in toPrint) {
if (toPrint.hasOwnProperty(name)) {
s += indent + indent + '[' + name + '] => ' + this.printR(toPrint[name], indent + ' ', indent + indent)
}
}
s += indentEnd + ')\n'
return s
} else if (toPrint instanceof Array) {
s = 'Array (\n'
|
javascript
|
{
"resource": ""
}
|
|
q4440
|
train
|
function (type, name, callback) {
if (type === 'modifier') {
this.modifiers[name] = callback
} else {
|
javascript
|
{
"resource": ""
}
|
|
q4441
|
train
|
function (type, callback) {
(this.tree ? this.filters : jSmart.prototype.filtersGlobal)[((type ===
|
javascript
|
{
"resource": ""
}
|
|
q4442
|
train
|
function(el, types, handler, data, selector) {
jBone.setId(el);
var eventHandler = function(e) {
jBone.event.dispatch.call(el, e);
},
events = jBone.getData(el).events,
eventType, t, event;
types = types.split(" ");
t = types.length;
while (t--) {
event = types[t];
eventType = event.split(".")[0];
events[eventType] = events[eventType] || [];
if (events[eventType].length) {
// override with previous event handler
eventHandler =
|
javascript
|
{
"resource": ""
}
|
|
q4443
|
train
|
function(el, types, handler, selector) {
var removeListener = function(events, eventType, index, el, e) {
var callback;
// get callback
if ((handler && e.originfn === handler) || !handler) {
callback = e.fn;
}
if (events[eventType][index].fn === callback) {
// remove handler from cache
events[eventType].splice(index, 1);
if (!events[eventType].length) {
el.removeEventListener(eventType, callback);
}
}
},
events = jBone.getData(el).events,
l,
eventsByType;
if (!events) {
return;
}
// remove all events
if (!types && events) {
return keys(events).forEach(function(eventType) {
eventsByType = events[eventType];
l = eventsByType.length;
while(l--) {
removeListener(events, eventType, l, el, eventsByType[l]);
}
});
}
types.split(" ").forEach(function(eventName) {
var eventType = eventName.split(".")[0],
namespace = eventName.split(".").splice(1).join("."),
e;
// remove named events
if (events[eventType]) {
eventsByType = events[eventType];
l = eventsByType.length;
while(l--) {
e = eventsByType[l];
if ((!namespace || (namespace && e.namespace === namespace)) &&
|
javascript
|
{
"resource": ""
}
|
|
q4444
|
train
|
function(el, event) {
var events = [];
if (isString(event)) {
events = event.split(" ").map(function(event) {
return jBone.Event(event);
});
} else {
event = event instanceof Event ? event : jBone.Event(event);
|
javascript
|
{
"resource": ""
}
|
|
q4445
|
each
|
train
|
function each(cfg) {
return function(callback) {
return new Promise(function(resolve, reject) {
// create an array to store callbacks
var rl, cbs = [];
// create an interface
try {
rl = readline.createInterface(cfg);
}
catch(err) {
return reject(err);
}
// handle a new line
rl.on('line', function(line) {
|
javascript
|
{
"resource": ""
}
|
q4446
|
train
|
function (message) {
// forward the message to the local promise,
// which will return a response promise
var local = getLocal(message.to).promise;
var response = local.dispatch(message.op, decode(message.args));
var envelope;
// connect the local response promise with the
// remote response promise:
// if the value is ever resolved, send the
// fulfilled value across the wire
response.then(function (resolution) {
try {
resolution = encode(resolution);
} catch (exception) {
try {
resolution = {"!": encode(exception)};
} catch (_exception) {
resolution = {"!": null};
}
}
envelope = JSON.stringify({
"type": "resolve",
"to": message.from,
"resolution": resolution
});
connection.put(envelope);
}, function (reason) {
try {
reason = encode(reason);
} catch (exception) {
try {
reason = encode(exception);
} catch (_exception) {
reason = null;
}
}
envelope = JSON.stringify({
|
javascript
|
{
"resource": ""
}
|
|
q4447
|
makeLocal
|
train
|
function makeLocal(id) {
if (hasLocal(id)) {
return getLocal(id).promise;
} else {
var deferred = Q.defer();
|
javascript
|
{
"resource": ""
}
|
q4448
|
makeRemote
|
train
|
function makeRemote(id) {
var remotePromise = Q.makePromise({
when: function () {
return this;
}
}, function (op, args) {
var localId = makeId();
var response = makeLocal(localId);
_debug("sending:", "R" + JSON.stringify(id), JSON.stringify(op),
|
javascript
|
{
"resource": ""
}
|
q4449
|
create_oauth2_client
|
train
|
function create_oauth2_client () {
var google_client_id = (OPTIONS.GOOGLE_CLIENT_ID) ? OPTIONS.GOOGLE_CLIENT_ID : process.env.GOOGLE_CLIENT_ID;
var google_client_secret = (OPTIONS.GOOGLE_CLIENT_SECRET) ? OPTIONS.GOOGLE_CLIENT_SECRET : process.env.GOOGLE_CLIENT_SECRET;
var base_url =
|
javascript
|
{
"resource": ""
}
|
q4450
|
generate_google_oauth2_url
|
train
|
function generate_google_oauth2_url () {
var access_type = (OPTIONS.access_type) ? OPTIONS.access_type : 'offline';
var approval_prompt = (OPTIONS.approval_prompt) ? OPTIONS.approval_prompt : 'force';
var url = oauth2_client.generateAuthUrl({
access_type: access_type, // set to offline
|
javascript
|
{
"resource": ""
}
|
q4451
|
selectionRangesForHTMLNode
|
train
|
function selectionRangesForHTMLNode(node) {
const ranges = [new Range(node.start,
|
javascript
|
{
"resource": ""
}
|
q4452
|
selectionRangesForCSSNode
|
train
|
function selectionRangesForCSSNode(node) {
const ranges = [new Range(node.start, node.end)];
if (node.type === 'property' && node.valueToken) {
ranges.push(new Range(node.valueToken.start, node.valueToken.end));
} else if (node.type === 'rule'
|
javascript
|
{
"resource": ""
}
|
q4453
|
delegateDynamicValidation
|
train
|
function delegateDynamicValidation() {
if (!options.dynamic.settings.trigger) {
return false;
}
// {debug}
options.debug && window.Debug.log({
'node': node,
'function': 'delegateDynamicValidation()',
'message': 'OK - Dynamic Validation activated on ' + node.length + ' form(s)'
});
// {/debug}
if (!node.find('[' + _data.validation + '],[' + _data.regex + ']')[0]) {
// {debug}
options.debug && window.Debug.log({
'node': node,
'function': 'delegateDynamicValidation()',
'arguments': 'node.find([' + _data.validation + '],[' + _data.regex + '])',
'message': 'ERROR - [' + _data.validation + '] not found'
});
// {/debug}
return false;
}
var event = options.dynamic.settings.trigger + delegateSuffix;
if (options.dynamic.settings.trigger !== "focusout") {
event += " change" + delegateSuffix + " paste" + delegateSuffix;
}
$.each(
node.find('[' + _data.validation + '],[' + _data.regex + ']'),
function (index, input) {
$(input).unbind(event).on(event, function (e) {
if ($(this).is(':disabled')) {
return false;
}
//e.preventDefault();
|
javascript
|
{
"resource": ""
}
|
q4454
|
validateForm
|
train
|
function validateForm() {
var isValid = isEmpty(errors);
formData = {};
$.each(
node.find('input:not([type="submit"]), select, textarea').not(':disabled'),
function(index, input) {
input = $(input);
var value = _getInputValue(input[0]),
inputName = input.attr('name');
if (inputName) {
if (/\[]$/.test(inputName)) {
inputName = inputName.replace(/\[]$/, '');
if (!(formData[inputName] instanceof Array)) {
formData[inputName] = [];
}
formData[inputName].push(value)
|
javascript
|
{
"resource": ""
}
|
q4455
|
prepareFormData
|
train
|
function prepareFormData() {
var data = {},
matches,
index;
for (var i in formData) {
if (!formData.hasOwnProperty(i)) continue;
index = 0;
matches = i.split(/\[(.+?)]/g);
var tmpObject = {},
tmpArray = [];
for (var k = matches.length - 1; k >= 0; k--) {
if (matches[k] === "") {
matches.splice(k, 1);
continue;
}
if (tmpArray.length < 1) {
|
javascript
|
{
"resource": ""
}
|
q4456
|
validateInput
|
train
|
function validateInput(input, value) {
var inputName = $(input).attr('name'),
value = value || _getInputValue(input);
if (!inputName) {
// {debug}
options.debug && window.Debug.log({
'node': node,
'function': 'validateInput()',
'arguments': '$(input).attr("name")',
'message': 'ERROR - Missing input [name]'
});
// {/debug}
return false;
}
var matches = inputName.replace(/]$/, '').split(/]\[|[[\]]/g),
inputShortName = window.Validation.labels[inputName] ||
options.labels[inputName] ||
$(input).attr(_data.label) ||
matches[matches.length - 1],
validationArray = $(input).attr(_data.validation),
validationMessage = $(input).attr(_data.validationMessage),
validationRegex = $(input).attr(_data.regex),
validationRegexReverse = !($(input).attr(_data.regexReverse) === undefined),
validationRegexMessage = $(input).attr(_data.regexMessage),
validateOnce = false;
if (validationArray) {
validationArray = _api._splitValidation(validationArray);
}
// Validates the "data-validation"
if (validationArray instanceof Array && validationArray.length > 0) {
// "OPTIONAL" input will not be validated if it's empty
if ($.trim(value) === '' && ~validationArray.indexOf('OPTIONAL')) {
return true;
}
$.each(validationArray, function (i, rule) {
if (validateOnce === true) {
return true;
}
try {
|
javascript
|
{
"resource": ""
}
|
q4457
|
validateRule
|
train
|
function validateRule(value, rule, reversed) {
// Validate for "data-validation-regex" and "data-validation-regex-reverse"
if (rule instanceof RegExp) {
var isValid = rule.test(value);
if (reversed) {
isValid = !isValid;
}
if (!isValid) {
throw [options.messages['default'], ''];
}
return;
}
if (options.rules[rule]) {
if (!options.rules[rule].test(value)) {
throw [options.messages[rule], ''];
}
return;
}
// Validate for comparison "data-validation"
var comparison = rule.match(options.rules.COMPARISON);
if (!comparison || comparison.length !== 4) {
// {debug}
options.debug && window.Debug.log({
'node': node,
'function': 'validateRule()',
'arguments': 'value: ' + value + ' rule: ' + rule,
'message': 'WARNING - Invalid comparison'
});
// {/debug}
return;
}
var type = comparison[1],
operator = comparison[2],
compared = comparison[3],
comparedValue;
switch (type) {
// Compare input "Length"
case "L":
// Only numeric value for "L" are allowed
if (isNaN(compared)) {
// {debug}
options.debug && window.Debug.log({
'node': node,
'function': 'validateRule()',
'arguments': 'compare: ' + compared + ' rule: ' + rule,
'message': 'WARNING - Invalid rule, "L" compare must be numeric'
});
// {/debug}
return false;
} else {
if (!value || eval(value.length + operator + parseFloat(compared)) === false) {
throw [options.messages[operator], compared];
}
}
break;
// Compare input "Value"
case "V":
default:
// Compare Field values
if (isNaN(compared)) {
comparedValue = node.find('[name="' +
|
javascript
|
{
"resource": ""
}
|
q4458
|
registerError
|
train
|
function registerError(inputName, error) {
if (!errors[inputName]) {
errors[inputName] = [];
}
error = error.capitalize();
var hasError = false;
|
javascript
|
{
"resource": ""
}
|
q4459
|
resetOneError
|
train
|
function resetOneError(inputName, input, label, container, group) {
delete errors[inputName];
if (container) {
//window.Validation.hasScrolled = false;
if (options.submit.settings.inputContainer) {
(group ? label : input).parentsUntil(node, options.submit.settings.inputContainer).removeClass(options.submit.settings.errorClass);
}
label && label.removeClass(options.submit.settings.errorClass);
input.removeClass(options.submit.settings.errorClass);
if (options.submit.settings.display === 'inline') {
container.find('[' + _data.errorList + ']').remove();
}
} else {
if (!input) {
input = node.find('[name="' + inputName + '"]');
if (!input[0]) {
|
javascript
|
{
"resource": ""
}
|
q4460
|
destroy
|
train
|
function destroy() {
resetErrors();
node.find('[' + _data.validation + '],[' + _data.regex + ']').off(delegateSuffix + ' ' + resetSuffix);
node.find(options.submit.settings.button).off(delegateSuffix).on('click' + delegateSuffix, function () {
|
javascript
|
{
"resource": ""
}
|
q4461
|
train
|
function (node, validation) {
var self = this;
validation = self._splitValidation(validation);
if (!validation) {
return false;
}
return node.each(function () {
var $this = $(this),
validationData = $this.attr(_data.validation),
validationArray = (validationData && validationData.length) ? self._splitValidation(validationData) : [],
oneValidation,
validationIndex;
if (!validationArray.length) {
$this.removeAttr(_data.validation);
return true;
}
for (var i = 0; i < validation.length; i++) {
oneValidation = self._formatValidation(validation[i]);
|
javascript
|
{
"resource": ""
}
|
|
q4462
|
train
|
function (ruleObj) {
if (!ruleObj.rule || (!ruleObj.regex && !ruleObj.message)) {
// {debug}
window.Debug.log({
'function': '$.alterValidationRules()',
'message': 'ERROR - Missing one or multiple parameter(s) {rule, regex, message}'
});
window.Debug.print();
// {/debug}
return false;
}
ruleObj.rule = ruleObj.rule.toUpperCase();
if (ruleObj.regex) {
var regex = _buildRegexFromString(ruleObj.regex);
if (!(regex instanceof RegExp)) {
// {debug}
window.Debug.log({
'function': '$.alterValidationRules(rule)',
|
javascript
|
{
"resource": ""
}
|
|
q4463
|
findNextNonSpacePoint
|
train
|
function findNextNonSpacePoint(editor, pos) {
const stream = new
|
javascript
|
{
"resource": ""
}
|
q4464
|
findPreviousNonSpacePoint
|
train
|
function findPreviousNonSpacePoint(editor, pos) {
const stream = new BufferStreamReader(editor.getBuffer(),
|
javascript
|
{
"resource": ""
}
|
q4465
|
joinTag
|
train
|
function joinTag(editor, node, syntax) {
// Remove everything between the end of opening tag and the end of closing tag
const open = getText(editor, node.open);
|
javascript
|
{
"resource": ""
}
|
q4466
|
comment
|
train
|
function comment(editor, range, modelType) {
const commentParts = modelComments[modelType];
editor.setTextInBufferRange(new Range(range.end, range.end), ` ${commentParts.after}`);
|
javascript
|
{
"resource": ""
}
|
q4467
|
uncomment
|
train
|
function uncomment(editor, range, modelType) {
const commentParts = modelComments[modelType];
const stream = new BufferStreamReader(editor.getBuffer(), range.start, range);
// narrow down comment range till meanful content
stream.pos = range.start.translate([0, commentParts.before.length]);
stream.eatWhile(isSpace);
stream.start = stream.pos;
// Make sure comment ends with proper token
stream.pos = range.end.translate([0, -commentParts.after.length]);
if (editor.getTextInBufferRange([stream.pos, range.end]) === commentParts.after) {
while (!stream.sof()) {
if (!isSpace(stream.backUp(1))) {
stream.next();
break;
}
|
javascript
|
{
"resource": ""
}
|
q4468
|
commentsInRange
|
train
|
function commentsInRange(model, range) {
const intersects = token => getRange(token).intersectsWith(range, true);
if (model.type === 'html') {
// in html model, comments are nodes in model
return iterate(model.dom, node => node.type === 'comment' && intersects(node));
}
if (model.type === 'stylesheet') {
|
javascript
|
{
"resource": ""
}
|
q4469
|
resolveRelative
|
train
|
function resolveRelative(base, filePath) {
return getBasePath(base)
|
javascript
|
{
"resource": ""
}
|
q4470
|
getBasePath
|
train
|
function getBasePath(base) {
return new Promise((resolve, reject) => {
if (base && typeof base.getPath === 'function') {
const editorFile = base.getPath();
if (!editorFile) {
|
javascript
|
{
"resource": ""
}
|
q4471
|
isEmpty
|
train
|
function isEmpty(val) {
if (val === 0 || typeof val === 'boolean') {
return false;
}
if (val == null) {
return true;
}
if (utils.isObject(val)) {
|
javascript
|
{
"resource": ""
}
|
q4472
|
getImageSizeFromFile
|
train
|
function getImageSizeFromFile(file) {
return new Promise((resolve, reject) => {
const isDataUrl = file.match(/^data:.+?;base64,/);
if (isDataUrl) {
// NB should use sync version of `sizeOf()` for buffers
try {
const data = Buffer.from(file.slice(isDataUrl[0].length), 'base64');
return resolve(sizeForFileName('', sizeOf(data)));
|
javascript
|
{
"resource": ""
}
|
q4473
|
getImageSizeFromURL
|
train
|
function getImageSizeFromURL(url) {
return new Promise((resolve, reject) => {
url = parseUrl(url);
const transport = url.protocol === 'https:' ? https : http;
transport.get(url, resp => {
const chunks = [];
let bufSize = 0;
const trySize = chunks => {
try {
const size = sizeOf(Buffer.concat(chunks, bufSize));
resp.removeListener('data', onData);
|
javascript
|
{
"resource": ""
}
|
q4474
|
sizeForFileName
|
train
|
function sizeForFileName(fileName, size) {
const m = fileName.match(/@(\d+)x\./);
const scale = m ? +m[1] :
|
javascript
|
{
"resource": ""
}
|
q4475
|
findTokenForPoint
|
train
|
function findTokenForPoint(parent, point, type) {
if (!parent) {
return null;
}
if (parent.type === type) {
return parent;
}
for (let i = 0, il = parent.size, item; i < il; i++) {
|
javascript
|
{
"resource": ""
}
|
q4476
|
saveAsFile
|
train
|
function saveAsFile(editor, data, range) {
return new Promise((resolve, reject) => {
const fileName = atom.getCurrentWindow().showSaveDialog();
if (!fileName) {
return reject(new Error('User cancelled file dialog'));
}
fs.writeFile(fileName, Buffer.from(data, 'base64'), err => {
if (err) {
return reject(err);
}
const editorPath = editor.getPath();
let displayPath = editorPath
|
javascript
|
{
"resource": ""
}
|
q4477
|
readFile
|
train
|
function readFile(fileName) {
if (/^https?:/.test(fileName)) {
return readFileFromURL(fileName);
}
return new Promise((resolve, reject) =>
|
javascript
|
{
"resource": ""
}
|
q4478
|
hasScope
|
train
|
function hasScope(descriptor, scope) {
for (let i = 0; i < descriptor.scopes.length; i++) {
|
javascript
|
{
"resource": ""
}
|
q4479
|
insertFormattedLineBreak
|
train
|
function insertFormattedLineBreak(cursor) {
const indent = cursor.editor.getTabText();
const lineIndent = getLineIndent(cursor);
cursor.selection.insertText(`\n${lineIndent}${indent}\n${lineIndent}`, {
|
javascript
|
{
"resource": ""
}
|
q4480
|
isAtCodePoint
|
train
|
function isAtCodePoint(stream) {
const code = stream.peek();
// between quotes, looks like an empty attribute value
return (isQuote(code) && getPrevCode(stream) === code)
// between tags, e.g. > and <
|| (code === 60 /*
|
javascript
|
{
"resource": ""
}
|
q4481
|
getPrevCode
|
train
|
function getPrevCode(stream) {
if (!stream.sof())
|
javascript
|
{
"resource": ""
}
|
q4482
|
updateImageSizeHTML
|
train
|
function updateImageSizeHTML(editor, model) {
const pos = editor.getCursorBufferPosition();
const src = getImageSrcHTML( getImageHTMLNode(editor, model, pos) );
if (!src) {
return Promise.reject(new Error('No valid image source'));
}
locateFile(editor, src)
.then(getImageSize)
.then(size => {
// since this action is asynchronous, we have to ensure that editor wasn’t
// changed and user didn’t moved caret outside <img> node
const img
|
javascript
|
{
"resource": ""
}
|
q4483
|
updateImageSizeCSS
|
train
|
function updateImageSizeCSS(editor, model) {
const pos = editor.getCursorBufferPosition();
const property = getImageCSSNode(editor, model, pos);
const urlToken = findUrlToken(property, pos);
const src = urlToken && getImageSrcCSS(urlToken);
if (!src) {
return Promise.reject(new Error('No valid image source'));
}
locateFile(editor, src)
.then(getImageSize)
.then(size => {
// since this action is asynchronous, we have to ensure that editor wasn’t
// changed and user
|
javascript
|
{
"resource": ""
}
|
q4484
|
updateHTMLTag
|
train
|
function updateHTMLTag(editor, node, width, height) {
const srcAttr = getAttribute(node, 'src');
const widthAttr = getAttribute(node, 'width');
const heightAttr = getAttribute(node, 'height');
editor.transact(() => {
// apply changes from right to left, first for height, then for width
let point;
const quote = getAttributeQuote(editor, widthAttr || heightAttr || srcAttr);
if (!heightAttr) {
// no `height` attribute, add it right after `width` or `src`
point = widthAttr ? widthAttr.end : srcAttr.end;
editor.setTextInBufferRange([point, point], ` height=${quote}${height}${quote}`);
} else {
editor.setTextInBufferRange(getRange(heightAttr.value), String(height));
|
javascript
|
{
"resource": ""
}
|
q4485
|
updateCSSNode
|
train
|
function updateCSSNode(editor, srcProp, width, height) {
const rule = srcProp.parent;
const widthProp = getProperty(rule, 'width');
const heightProp = getProperty(rule, 'height');
// Detect formatting
const separator = srcProp.separator || ': ';
const before = getBefore(editor, srcProp);
const insertOpt = { autoIndent: false };
editor.transact(() => {
// Apply changes from right to left, first for height, then for width
if (!heightProp) {
// no `height` property, add it right after `width` or source property
editor.setCursorBufferPosition(widthProp ? widthProp.end : srcProp.end);
editor.insertText(`${before}height${separator}${height}px;`, insertOpt);
} else {
editor.setTextInBufferRange(getRange(heightProp.valueToken), `${height}px`);
}
if (!widthProp) {
|
javascript
|
{
"resource": ""
}
|
q4486
|
findUrlToken
|
train
|
function findUrlToken(node, pos) {
for (let i = 0, il = node.parsedValue.length, url; i < il; i++) {
iterateCSSToken(node.parsedValue[i], token => {
if (token.type ===
|
javascript
|
{
"resource": ""
}
|
q4487
|
getProperty
|
train
|
function getProperty(rule, name) {
return rule.children.find(node
|
javascript
|
{
"resource": ""
}
|
q4488
|
selectItem
|
train
|
function selectItem(editor, model, getItemRange) {
editor.transact(() => {
const selections = editor.getSelectedBufferRanges()
.map(anchor
|
javascript
|
{
"resource": ""
}
|
q4489
|
getNextItemRange
|
train
|
function getNextItemRange(model, anchor, getItemRanges) {
// Find HTML node for next selection
let node = nodeForPoint(model, anchor.start, 'next');
let range;
// We might need to narrow down node context to find best token match
|
javascript
|
{
"resource": ""
}
|
q4490
|
getPreviousItemRange
|
train
|
function getPreviousItemRange(model, anchor, getItemRanges) {
// Find HTML node for next selection
let node = nodeForPoint(model, anchor.start, 'previous');
let range;
// We might need to narrow down node context to find best token match
while
|
javascript
|
{
"resource": ""
}
|
q4491
|
getNextRange
|
train
|
function getNextRange(ranges, anchor) {
for (let i = 0; i < ranges.length; i++) {
if (anchor.isEqual(ranges[i])) {
// NB may return `undefined`, which is totally fine and
|
javascript
|
{
"resource": ""
}
|
q4492
|
getPreviousRange
|
train
|
function getPreviousRange(ranges, anchor) {
for (let i = 0; i < ranges.length; i++) {
if (anchor.isEqual(ranges[i])) {
// NB may return `undefined`, which is totally fine and
|
javascript
|
{
"resource": ""
}
|
q4493
|
getRangesFromHTMLNode
|
train
|
function getRangesFromHTMLNode(node) {
if (node.type !== 'tag') {
return [];
}
let ranges = [ getRange(node.open.name) ];
if (node.attributes) {
node.attributes.forEach(attr => {
ranges.push(getRange(attr));
if (!attr.boolean) {
// add attribute value (unquoted) range for non-boolean attributes
ranges.push(getRange(attr.value));
if (attr.name.value.toLowerCase() === 'class') {
// In case of `class` attribute, add each class item
|
javascript
|
{
"resource": ""
}
|
q4494
|
getRangesFromCSSNode
|
train
|
function getRangesFromCSSNode(node) {
let ranges;
if (node.type === 'rule') {
ranges = [ getRange(node.selectorToken) ].concat(node.parsedSelector.map(getRange));
} else if (node.type === 'at-rule') {
const nameEndToken = node.expressionToken || node.nameToken;
ranges = [
new Range(node.nameToken.start, nameEndToken.end),
getRange(node.nameToken),
getRange(node.expressionToken)
];
node.parsedExpression.forEach(token => {
ranges.push(getRange(token));
iterateCSSToken(token, t => {
if (t.type === 'argument') {
ranges.push(getRange(t));
}
});
});
} else if (node.type === 'property') {
ranges = [
getRange(node),
getRange(node.nameToken),
getRange(node.valueToken)
];
node.parsedValue.forEach(value => {
// parsed value contains a comma-separated list of sub-values,
// each of them, it turn, may contain space-separated parts
|
javascript
|
{
"resource": ""
}
|
q4495
|
nodeForPoint
|
train
|
function nodeForPoint(model, point, direction) {
const node = model.nodeForPoint(point);
if (node) {
return node;
}
// Looks like caret is outside of any top-level node.
const topLevelNodes = model.dom.children;
if (direction === 'next') {
// Find next node, which is closest top-level to given position
return topLevelNodes.find(node => node.start.isGreaterThanOrEqual(point));
|
javascript
|
{
"resource": ""
}
|
q4496
|
nextSibling
|
train
|
function nextSibling(node) {
while (node) {
if (node.nextSibling) {
|
javascript
|
{
"resource": ""
}
|
q4497
|
toggleEditorClass
|
train
|
function toggleEditorClass(editor, enabled) {
const view = atom.views.getView(editor);
if (view) {
|
javascript
|
{
"resource": ""
}
|
q4498
|
allowedForAutoActivation
|
train
|
function allowedForAutoActivation(model) {
const rootNode = model.ast.children[0];
// The very first node should start with alpha character
// Skips
|
javascript
|
{
"resource": ""
}
|
q4499
|
getExpandedAbbreviationCompletion
|
train
|
function getExpandedAbbreviationCompletion({editor, bufferPosition, prefix, activatedManually}) {
// We should expand marked abbreviation only.
// If there’s no marked abbreviation, try to mark it but only if
// user invoked automomplete popup manually
let marker = findMarker(editor, bufferPosition);
if (!marker && activatedManually) {
marker = markAbbreviation(editor, bufferPosition, activatedManually);
}
if (marker) {
const snippet = marker.model.snippet;
// For some syntaxes like Pug, it’s possible that extracted abbreviation
// matches prefix itself (e.g.
|
javascript
|
{
"resource": ""
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.