_id
stringlengths 2
6
| title
stringlengths 0
58
| partition
stringclasses 3
values | text
stringlengths 27
233k
| language
stringclasses 1
value | meta_information
dict |
|---|---|---|---|---|---|
q65000 | test | function (expected, expectedIndex, value) {
var i = expectedIndex - 1;
var matchingRequires = 0
while (i >= 0) {
| javascript | {
"resource": ""
} |
|
q65001 | test | function (expected, actual) {
var argNames = [];
var expectedNames = [];
for (var i = 0; i < actual.length; i++) {
argNames.push(getNameForValue(actual[i]));
| javascript | {
"resource": ""
} |
|
q65002 | test | function (value, type) {
if (!isValidType(type)) {
throw Error('Invalid type supplied.');
}
if (!isOfType(value, type)) {
argName = getNameForValue(value);
typeName | javascript | {
"resource": ""
} |
|
q65003 | test | function (type) {
if (type === null) return true;
if (type === undefined) return true;
if (type instanceof AnyType) return true;
if (type instanceof Array) {
// An array is only valid if it contains one or more valid types.
if (!type.length) return false;
for (var i = 0; i < type.length; i++) {
| javascript | {
"resource": ""
} |
|
q65004 | test | function (value) {
if (value === undefined) return 'undefined';
if (value === null) return 'null';
// Look inside the array to determine the inner type.
if (value instanceof Array) {
if (!value.length) return 'Array(empty)';
var innerType = undefined;
for (var i = 0; i < value.length; i++) {
type = getNameForValue(value[i]);
if (innerType !== undefined && innerType !== type) {
return 'Array(mixed)';
}
innerType = type;
};
return 'Array<' + innerType + '>';
}
if (value instanceof Function) {
| javascript | {
"resource": ""
} |
|
q65005 | test | function (type) {
if (type === undefined) return 'undefined';
if (type === null) return 'null';
// Create a list of all the possible types.
if (type instanceof Array) {
if (!type.length) return 'None';
var possibleTypes = [];
for (var i = 0; i < type.length; i++) {
possibleTypes.push(getNameForType(type[i]));
};
return possibleTypes.join(' or ');
} | javascript | {
"resource": ""
} |
|
q65006 | test | function(request) {
var me = this,
url = me.callParent(arguments),
params = Ext.apply({}, request.getParams()),
filters = params.filters,
filter, i, value;
delete params.filters;
if (me.getAutoAppendParams()) {
url = Ext.urlAppend(url, Ext.Object.toQueryString(params));
}
if (filters && filters.length) {
for (i = 0; i < filters.length; i++) {
| javascript | {
"resource": ""
} |
|
q65007 | getStateFromOptions | test | function getStateFromOptions (options, propertyName) {
propertyName = propertyName || 'state';
const stateName = options[propertyName] | javascript | {
"resource": ""
} |
q65008 | validate | test | function validate (resource, doc, doValidate) {
return new Promise((resolve, reject) => {
if (doValidate !== true) {
return resolve();
| javascript | {
"resource": ""
} |
q65009 | prune | test | function prune(str, max, nice, suf) {
max = max || 140
nice = _.isBoolean(nice) ? nice : false
if (!str || max <= 0 || str.length <= max) return str
suf = suf || "..."
str | javascript | {
"resource": ""
} |
q65010 | attemptRender | test | function attemptRender(reporter, filename, src, resolve, reject, globals) {
globals = globals || {};
less.render(src, {
// Specify search paths for @import directives
paths : [
"public/static/less"
],
// Specify a filename, for better error messages
filename : filename,
modifyVars : globals,
compress : false
}, function(e, css) {
if (e) {
if ((/^variable @(.+?) is undefined$/).test(e.message)) {
// ignore undef variable
| javascript | {
"resource": ""
} |
q65011 | validateArray | test | function validateArray(indexes) {
var valid = false;
if (typeof indexes | javascript | {
"resource": ""
} |
q65012 | addRoutes | test | function addRoutes( pies, pie, routes, app ) {
// Add the GET routes
if ( 'get' in routes ) {
routes.get.forEach( function( route ) {
Object.keys( route ).forEach( function( r ) {
var middlewares = true;
if ( typeof route[ r ] === 'string' ) {
middlewares = false;
}
loadRoute( app, 'get', r, pies[ pie ].path, route[ r ], middlewares );
});
});
}
// Add the POST routes
if ( 'post' in routes ) {
| javascript | {
"resource": ""
} |
q65013 | generateUUID | test | function generateUUID() {
let dat = new Date().getTime();
return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, (cha) => | javascript | {
"resource": ""
} |
q65014 | randomString | test | function randomString(length, charSet = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789') {
let str = '',
isAllNumeric = false,
isNegative = false,
useCharSet = charSet;
if (+length) {
if (!isString(charSet)) {
if (isNumber(charSet)) {
if (+charSet) {
isAllNumeric = true;
isNegative = +charSet < 0;
useCharSet = `${Math.abs(+charSet)}`;
} else {
useCharSet = ALPHANUMERIC_CHARS;
}
} else {
useCharSet = ALPHANUMERIC_CHARS;
}
}
const generateChar = function gc(len) {
return Math.round(Math.random() * (len - 1));
}.bind(null, useCharSet.length);
str = Array(+length).fill().map((v, index) => | javascript | {
"resource": ""
} |
q65015 | toUint | test | function toUint(str) {
const string = window.btoa(unescape(encodeURIComponent(str))),
chars = string.split(''),
len = chars.length,
| javascript | {
"resource": ""
} |
q65016 | toArrayBuffer | test | function toArrayBuffer(str) {
/* eslint no-bitwise: "off" */
const len = isString(str) ? str.length : 0,
buf = new ArrayBuffer(len),
| javascript | {
"resource": ""
} |
q65017 | test | function() {
if (!this.$backButtonContainer) {
return;
}
var i = 0,
backButtonContainer = this.$backButtonContainer,
items = backButtonContainer.items,
item;
for(;i < items.length; i++) {
| javascript | {
"resource": ""
} |
|
q65018 | test | function(message, priority, callerId) {
if (!this.getEnabled()) {
return this;
}
var statics = Logger,
priorities = statics.priorities,
priorityValue = priorities[priority],
caller = this.log.caller,
callerDisplayName = '',
writers = this.getWriters(),
event, i, originalCaller;
if (!priority) {
priority = 'info';
}
if (priorities[this.getMinPriority()] > priorityValue) {
return this;
}
if (!callerId) {
callerId = 1;
}
if (Ext.isArray(message)) {
message = message.join(" ");
}
else {
message = String(message);
}
if (typeof callerId == 'number') {
i = callerId;
do {
i--;
caller = caller.caller;
if (!caller) {
break;
}
if (!originalCaller) {
originalCaller = caller.caller;
}
if (i <= 0 && caller.displayName) {
break;
}
}
| javascript | {
"resource": ""
} |
|
q65019 | copyFileSync | test | function copyFileSync(source, destination) {
if (validateFileSync(source)) {
| javascript | {
"resource": ""
} |
q65020 | copyFilesMatchSync | test | function copyFilesMatchSync(match, source, destination) {
fs.readdirSync(source).forEach(function eachTemplate(filename) {
var sourceFile = path.join(source, filename); | javascript | {
"resource": ""
} |
q65021 | replaceMatchFilesSync | test | function replaceMatchFilesSync(match, source, destination) {
unlinkFilesMatchSync(match, destination);
| javascript | {
"resource": ""
} |
q65022 | unlinkFilesMatchSync | test | function unlinkFilesMatchSync(match, location) {
fs.readdirSync(location).forEach(function eachTemplate(filename) {
if (match.test(path.basename(filename))) {
var | javascript | {
"resource": ""
} |
q65023 | validateDirectorySync | test | function validateDirectorySync(path, errorMessage) {
errorMessage = errorMessage || 'Error validateDirectorySync() the directory path is not valid ' + path; | javascript | {
"resource": ""
} |
q65024 | validateFileSync | test | function validateFileSync(path, errorMessage) {
errorMessage = errorMessage || 'Error validateFileSync() the file path is not valid ' + path; | javascript | {
"resource": ""
} |
q65025 | subDirectoriesWithFile | test | function subDirectoriesWithFile(base, filename) {
var result = [];
if (fs.existsSync(base) && fs.statSync(base).isDirectory()) {
if (fs.existsSync(path.join(base, filename))) { | javascript | {
"resource": ""
} |
q65026 | maximisePath | test | function maximisePath() {
// Ensure each element in the path exists,
// where it is a regex, match it and replace the element with a string
var elements = Array.prototype.slice.call(arguments);
for (var i = 1; i < elements.length; i++) {
// the directory is elements 0 .. i-1 joined
var directory = path.resolve(path.join.apply(path, elements.slice(0, i)));
// no directory implies failure
if (!fs.existsSync(directory)) {
return null;
}
// regex element is matched
else if ((typeof elements[i] !== 'string') && ('test' in elements[i])) {
var matches = resolveDirMatches(directory, elements[i]);
// no match implies failure, else use the item with the highest numeric index
| javascript | {
"resource": ""
} |
q65027 | resolveDirMatches | test | function resolveDirMatches(directory, match) {
if (validateDirectorySync(directory)) {
return fs.readdirSync(directory)
.filter(function eachDirectoryItem(item) {
var resolved = path.resolve(path.join(directory, item));
| javascript | {
"resource": ""
} |
q65028 | compareHigher | test | function compareHigher(a, b) {
var numA = parseFloat(/[\d\.]+$/.exec(a)[0]);
var numB = parseFloat(/[\d\.]+$/.exec(b)[0]);
if (isNaN(numA) || (numB > numA)) {
return +1;
} | javascript | {
"resource": ""
} |
q65029 | reduceDirectories | test | function reduceDirectories() {
return Array.prototype.slice.call(arguments)
.map(function (candidate) {
return path.normalize(candidate);
})
.filter(function (candidate) {
| javascript | {
"resource": ""
} |
q65030 | test | function(side) {
var menus = this.getMenus() || {},
menu = menus[side]; | javascript | {
"resource": ""
} |
|
q65031 | test | function(side) {
var menus = this.getMenus(),
menu = menus[side],
before, after,
viewportBefore, viewportAfter;
if (!menu || menu.isAnimating) {
return;
}
this.hideOtherMenus(side);
before = {
translateX: 0,
translateY: 0
};
after = {
translateX: 0,
translateY: 0
};
viewportBefore = {
translateX: 0,
translateY: 0
};
viewportAfter = {
translateX: 0,
translateY: 0
};
if (menu.$reveal) {
Ext.getBody().insertFirst(menu.element);
}
else {
Ext.Viewport.add(menu);
}
menu.show();
menu.addCls('x-' + side);
var size = (side == 'left' || side == 'right') ? menu.element.getWidth() : menu.element.getHeight();
if (side == 'left') {
before.translateX = -size;
viewportAfter.translateX = size;
}
else if (side == 'right') {
before.translateX = size;
viewportAfter.translateX = -size;
}
else if (side == 'top') {
before.translateY = -size;
viewportAfter.translateY = size;
}
else if (side == 'bottom') {
before.translateY = size;
viewportAfter.translateY = -size;
}
if (menu.$reveal) {
if (Ext.browser.getPreferredTranslationMethod() != 'scrollposition') {
menu.translate(0, 0);
}
}
else {
menu.translate(before.translateX, before.translateY);
}
if (menu.$cover) {
| javascript | {
"resource": ""
} |
|
q65032 | test | function(side, animate) {
var menus = this.getMenus(),
menu = menus[side],
after, viewportAfter,
size;
animate = (animate === false) ? false : true;
if (!menu || (menu.isHidden() || menu.isAnimating)) {
return;
}
after = {
translateX: 0,
translateY: 0
};
viewportAfter = {
translateX: 0,
translateY: 0
};
size = (side == 'left' || side == 'right') ? menu.element.getWidth() : menu.element.getHeight();
if (side == 'left') {
after.translateX = -size;
}
else if (side == 'right') {
after.translateX = size;
}
else if (side == 'top') {
after.translateY = -size;
}
else if (side == 'bottom') {
after.translateY = size;
}
if (menu.$cover) {
if (animate) {
menu.getTranslatable().on('animationend', function() {
menu.isAnimating = false;
menu.hide();
}, this, {
single: true
});
menu.translate(after.translateX, after.translateY, {
preserveEndState: true,
duration: 200
});
}
else {
| javascript | {
"resource": ""
} |
|
q65033 | test | function(side, animation){
var menus = this.getMenus();
for (var menu in menus) | javascript | {
"resource": ""
} |
|
q65034 | test | function(side) {
var menus = this.getMenus(), menu;
if (menus[side]) {
menu = menus[side];
if (menu.isHidden()) {
this.showMenu(side);
| javascript | {
"resource": ""
} |
|
q65035 | init | test | function init(adapter, config) {
if (!fs) {
var Adapter = require('./adapters/' + | javascript | {
"resource": ""
} |
q65036 | getHierarchy | test | function getHierarchy(cb) {
getConfig(function (err, config) {
if (err) {
cb(err);
| javascript | {
"resource": ""
} |
q65037 | getBackends | test | function getBackends(cb) {
getConfig(function (err, config) {
if (err) {
cb(err);
| javascript | {
"resource": ""
} |
q65038 | getBackendConfig | test | function getBackendConfig(backend, cb) {
getConfig(function (err, config) {
if (err) {
cb(err);
| javascript | {
"resource": ""
} |
q65039 | getFile | test | function getFile(backend, file, cb) {
getBackendConfig(backend, function (err, config) {
file = | javascript | {
"resource": ""
} |
q65040 | saveFile | test | function saveFile(backend, file, data, cb) {
cb = typeof(cb) === 'function' ? cb : function () {};
getBackendConfig(backend, function (err, config) {
var | javascript | {
"resource": ""
} |
q65041 | getOverrides | test | function getOverrides(backend, file, cb) {
async.parallel([
function hierarchy(cb) {
getHierarchy(cb);
},
function backendConfig(cb) {
getBackendConfig(backend, cb);
}
], function (err, results) {
var hierarchy, datadir, filename, tasks,
pos, searchHierarchy, tasks;
hierarchy = results[0];
datadir = results[1][':datadir'];
filename = file.remove('.' + backend);
tasks = [];
// remove the file's matching hierarchy
pos = hierarchy.findIndex(filename);
searchHierarchy = hierarchy.to(pos);
getFile(backend, file, function (err, data) {
var sourceData;
if (err) {
cb(err);
return;
}
sourceData = yaml.safeLoad(data);
// setup hierarchy search tasks
_.each(searchHierarchy, function (hierarchy) {
tasks.push(hierarchy + '.' + backend);
});
async.map(tasks, function (f, cb) {
// get data for each file in the hierarchy
// TODO: support magic hiera vars
getFile(backend, f, function (err, data) {
cb(null, {
file : f,
data : yaml.safeLoad(data)
| javascript | {
"resource": ""
} |
q65042 | done | test | function done(result, callback) {
if (!_.isFunction(callback)) | javascript | {
"resource": ""
} |
q65043 | fail | test | function fail(err, callback) {
if (!_.isFunction(callback)) return
let uError = new Error('Unknown Error')
err = err ? _.isError(err) ? | javascript | {
"resource": ""
} |
q65044 | test | function(data) {
var fieldsCollection = this.getModel().getFields();
/*
* We check here whether the fields are dirty since the last read.
* This works around an issue when a Model is used for both a Tree and another
* source, because the tree decorates the model with extra fields and it causes
* issues because the readers aren't notified.
| javascript | {
"resource": ""
} |
|
q65045 | arrIncludes | test | function arrIncludes (arr, values) {
if (!Array.isArray(values)) { return inArray(arr, values) }
var len = values.length;
var i = -1;
while (i++ < len) {
| javascript | {
"resource": ""
} |
q65046 | clean | test | function clean(src) {
let pidx = src.indexOf('http')
if(pidx > 0) src = src.substr(pidx)
return src ? pidx | javascript | {
"resource": ""
} |
q65047 | jquery | test | function jquery(src) {
src = clean(src);
let params = {}
let match = null
if (!url || !_.isString(src)) return params
while (match = | javascript | {
"resource": ""
} |
q65048 | test | function (el, options) {
events.EventEmitter.call(this);
this.el = el;
this.options = extend({}, this.options);
| javascript | {
"resource": ""
} |
|
q65049 | toParam | test | function toParam(obj, dontEncode) {
const arr = [];
let vals;
if (isObject(obj) && !isArray(obj)) {
Object.keys(obj).forEach((val) => {
if (isArray(obj[val])) {
vals = `[${
obj[val].map(v => (isNaN(v) ? `"${v}"` : v)).join(',')
}]`;
} else {
vals = isNaN(obj[val]) ? `"${obj[val]}"` : obj[val];
| javascript | {
"resource": ""
} |
q65050 | test | function(anchor, local, size) {
//<debug warn>
Ext.Logger.deprecate("getAnchorXY() is no longer available for Ext.Element. Please see Ext.Component#showBy() " +
"to do anchoring at Component level instead", this);
//</debug>
//Passing a different size is useful for pre-calculating anchors,
//especially for anchored animations that change the el size.
anchor = (anchor || "tl").toLowerCase();
size = size || {};
var me = this,
vp = me.dom == document.body || me.dom == document,
width = size.width || vp ? window.innerWidth: me.getWidth(),
height = size.height || vp ? window.innerHeight: me.getHeight(),
xy,
rnd = Math.round,
myXY = me.getXY(),
extraX = vp ? 0: !local ? myXY[0] : 0,
extraY = vp ? 0: !local ? myXY[1] : 0,
hash = {
| javascript | {
"resource": ""
} |
|
q65051 | test | function(fn, scope){
var items = [].concat(this.items), // each safe for removal
i = 0,
len = items.length,
item;
for (; i < len; i++) {
| javascript | {
"resource": ""
} |
|
q65052 | test | function(config) {
if (config.path == null) {
Ext.Logger.error('Ext.device.filesystem.DirectoryEntry#getFile: You must specify a `path` of the file.');
return null;
}
if (config.options == null) {
config.options = {};
}
var me = this;
Ext.device.Communicator.send({
command: 'FileSystem#getEntry',
path: this.path,
fileSystemId: this.fileSystem.id,
newPath: config.path,
directory: config.directory,
create: config.options.create,
exclusive: config.options.exclusive,
callbacks: {
success: function(path) {
if (config.success) {
| javascript | {
"resource": ""
} |
|
q65053 | toHaveText | test | function toHaveText() {
return {
compare: function compare(element, text) {
var regexp = text instanceof RegExp ? text : new RegExp(text, 'ig');
var pass = element.getDOMNode().textContent.match(regexp);
var message = pass ? | javascript | {
"resource": ""
} |
q65054 | test | function() {
var me = this,
container = me.container,
baseCls = me.getBaseCls(),
scrollable, scrollViewElement, pinnedHeader;
Ext.apply(me, {
listItems: [],
headerItems: [],
updatedItems: [],
headerMap: [],
scrollDockItems: {
top: [],
bottom: []
}
});
// We determine the translation methods for headers and items within this List based
// on the best strategy for the device
this.translationMethod = Ext.browser.is.AndroidStock2 ? 'cssposition' : 'csstransform';
// Create the inner container that will actually hold all the list items
if (!container) {
container = me.container = Ext.factory({
xtype: 'container',
scrollable: {
scroller: {
autoRefresh: !me.getInfinite(),
direction: 'vertical'
}
}
});
}
// We add the container after creating it manually because when you add the container,
// the items config is initialized. When this happens, any scrollDock items will be added,
// which in turn tries to add these items to the container
me.add(container);
// | javascript | {
"resource": ""
} |
|
q65055 | test | function() {
var me = this,
container = me.container,
scrollViewElement = me.scrollViewElement,
indexBar = me.getIndexBar(),
triggerEvent = me.getTriggerEvent(),
triggerCtEvent = me.getTriggerCtEvent();
if (indexBar) {
scrollViewElement.appendChild(indexBar.renderElement);
}
if (triggerEvent) {
me.on(triggerEvent, me.onItemTrigger, me);
}
if (triggerCtEvent) {
me.on(triggerCtEvent, me.onContainerTrigger, me);
}
container.element.on({
delegate: '.' + me.getBaseCls() + '-disclosure',
tap: 'handleItemDisclosure',
scope: me
});
container.element.on({
resize: 'onContainerResize',
scope: me
});
// Android 2.x not a direct child
| javascript | {
"resource": ""
} |
|
q65056 | test | function(index) {
var listItems = this.listItems,
ln = listItems.length,
i, listItem;
for (i = 0; i < ln; i++) {
listItem = listItems[i];
| javascript | {
"resource": ""
} |
|
q65057 | test | function(url, onLoad, onError, scope, charset) {
var script = document.createElement('script'),
me = this,
onLoadFn = function() {
me.cleanupScriptElement(script);
onLoad.call(scope);
},
onErrorFn = function() {
me.cleanupScriptElement(script);
onError.call(scope);
};
script.type = 'text/javascript';
script.src = url;
script.onload = onLoadFn;
| javascript | {
"resource": ""
} |
|
q65058 | test | function(url, onLoad, onError, scope, synchronous) {
var me = this,
isFileLoaded = this.isFileLoaded,
scriptElements = this.scriptElements,
noCacheUrl = url + (this.getConfig('disableCaching') ? ('?' + this.getConfig('disableCachingParam') + '=' + Ext.Date.now()) : ''),
xhr, status, content, onScriptError;
if (isFileLoaded[url]) {
return this;
}
scope = scope || this;
this.isLoading = true;
if (!synchronous) {
onScriptError = function() {
//<debug error>
onError.call(scope, "Failed loading '" + url + "', please verify that the file exists", synchronous);
//</debug>
};
if (!Ext.isReady && Ext.onDocumentReady) {
Ext.onDocumentReady(function() {
if (!isFileLoaded[url]) {
scriptElements[url] = me.injectScriptElement(noCacheUrl, onLoad, onScriptError, scope);
}
});
}
else {
scriptElements[url] = this.injectScriptElement(noCacheUrl, onLoad, onScriptError, scope);
}
}
else {
if (typeof XMLHttpRequest != 'undefined') {
xhr = new XMLHttpRequest();
} else {
xhr = new ActiveXObject('Microsoft.XMLHTTP');
}
try {
xhr.open('GET', noCacheUrl, false);
xhr.send(null);
}
catch (e) {
//<debug error>
onError.call(this, "Failed loading synchronously via XHR: '" + url + "'; It's likely | javascript | {
"resource": ""
} |
|
q65059 | test | async function (fname, attrs) {
let partialDirs;
if (typeof module.exports.configuration.partialDirs === 'undefined'
|| !module.exports.configuration.partialDirs
|| module.exports.configuration.partialDirs.length <= 0) {
partialDirs = [ __dirname ];
} else {
partialDirs = module.exports.configuration.partialDirs;
}
var partialFound = await globfs.findAsync(partialDirs, fname);
if (!partialFound) throw new Error(`No partial found for ${fname} in ${util.inspect(partialDirs)}`);
// Pick the first partial found
partialFound = partialFound[0];
// console.log(`module.exports.configuration renderPartial ${partialFound}`);
if (!partialFound) throw new Error(`No partial found for ${fname} in ${util.inspect(partialDirs)}`);
var partialFname = path.join(partialFound.basedir, partialFound.path);
var stats = await fs.stat(partialFname);
if (!stats.isFile()) {
throw new Error(`doPartialAsync non-file found for ${fname} - ${partialFname}`);
}
var partialText = await fs.readFile(partialFname, 'utf8');
if (/\.ejs$/i.test(partialFname)) {
try { return ejs.render(partialText, attrs); } catch (e) {
throw new Error(`EJS | javascript | {
"resource": ""
} |
|
q65060 | test | function (record) {
var me = this,
fields = record.getFields(),
idProperty = record.getIdProperty(),
uniqueIdStrategy = me.getUniqueIdStrategy(),
data = {},
name, value;
fields.each(function (field) {
if (field.getPersist()) {
name = field.getName();
if (name === idProperty && !uniqueIdStrategy) {
return;
| javascript | {
"resource": ""
} |
|
q65061 | test | function(provider) {
var me = this,
args = Ext.toArray(arguments),
i = 0, ln;
if (args.length > 1) {
for (ln = args.length; i < ln; ++i) {
me.addProvider(args[i]);
}
return;
| javascript | {
"resource": ""
} |
|
q65062 | test | function(provider) {
var me = this,
providers = me.providers;
provider = provider.isProvider ? provider : providers.get(provider);
if (provider) {
| javascript | {
"resource": ""
} |
|
q65063 | test | function(config) {
config = config || {};
Ext.applyIf(config, {
application: this
});
this.initConfig(config);
//it's common to pass in functions to an application but because they are not predictable config names they
//aren't ordinarily placed onto this so we need to do it manually
for (var key in config) {
this[key] = config[key];
}
// <deprecated product=touch since=2.0>
if (config.autoCreateViewport) {
Ext.Logger.deprecate(
'[Ext.app.Application] autoCreateViewport has been deprecated in Sencha Touch 2. Please implement a ' +
'launch function | javascript | {
"resource": ""
} |
|
q65064 | test | function(name, profileName) {
var instances = this.getControllerInstances(),
appName = this.getName(),
format = Ext.String.format,
topLevelName;
if (name instanceof Ext.app.Controller) {
return name;
}
if (instances[name]) {
return instances[name];
} else {
topLevelName | javascript | {
"resource": ""
} |
|
q65065 | test | function() {
delete this.onItemAdd;
if (this.innerHtmlElement && !this.getHtml()) {
this.innerHtmlElement.destroy();
delete this.innerHtmlElement;
} | javascript | {
"resource": ""
} |
|
q65066 | test | function(item, destroy) {
var me = this,
index = me.indexOf(item),
innerItems = me.getInnerItems();
if (destroy === undefined) {
destroy = me.getAutoDestroy();
}
if (index !== -1) {
if (!me.removingAll && innerItems.length > 1 && item === me.getActiveItem()) {
me.on({
activeitemchange: 'doRemove',
scope: me,
single: true,
order: 'after',
args: [item, index, destroy]
});
| javascript | {
"resource": ""
} |
|
q65067 | test | function(destroy, everything) {
var items = this.items,
ln = items.length,
i = 0,
item;
if (typeof destroy != 'boolean') {
destroy = this.getAutoDestroy();
}
everything = Boolean(everything);
// removingAll flag is used so we | javascript | {
"resource": ""
} |
|
q65068 | test | function(activeItem, animation) {
var layout = this.getLayout(),
defaultAnimation;
if (this.activeItemAnimation) {
this.activeItemAnimation.destroy();
}
this.activeItemAnimation = animation = new Ext.fx.layout.Card(animation);
if (animation && layout.isCard) {
animation.setLayout(layout);
defaultAnimation = layout.getAnimation();
if (defaultAnimation) {
defaultAnimation.disable();
| javascript | {
"resource": ""
} |
|
q65069 | test | function(deep) {
var items = this.getItems().items.slice(),
ln = items.length,
i, item;
if (deep) {
for (i = 0; i | javascript | {
"resource": ""
} |
|
q65070 | test | function(e) {
var srcElement = e.srcElement.nodeName.toUpperCase(),
selectableElements = | javascript | {
"resource": ""
} |
|
q65071 | test | function(number, min, max) {
number = parseFloat(number);
if (!isNaN(min)) {
| javascript | {
"resource": ""
} |
|
q65072 | test | function(value, increment, minValue, maxValue) {
var newValue = value,
m;
if (!(increment && value)) {
return value;
}
m = value % increment;
if (m !== 0) {
newValue -= m;
if (m * 2 >= increment) {
newValue += increment;
| javascript | {
"resource": ""
} |
|
q65073 | test | function(value, precision) {
if (isToFixedBroken) {
precision = precision || 0;
var pow = Math.pow(10, precision);
| javascript | {
"resource": ""
} |
|
q65074 | logger | test | function logger(req, res, next) {
if (req.url.substr(0, 2) === "/r") {
| javascript | {
"resource": ""
} |
q65075 | typeConvert | test | function typeConvert(obj, onlyDate) {
var i, res;
if (typeof obj === "object") {
for (i in obj) {
if (obj.hasOwnProperty(i)) {
obj[i] = typeConvert(obj[i], onlyDate);
}
}
} else if (typeof obj === "string") {
if (!onlyDate && obj.match(/^([0-9.]+|true|false|undefined|null)$/)) {
obj = eval(obj);
} else {
| javascript | {
"resource": ""
} |
q65076 | typeConvertMiddleware | test | function typeConvertMiddleware(req, res, next) {
typeConvert(req.params);
| javascript | {
"resource": ""
} |
q65077 | defineRoute | test | function defineRoute(method, route, handler) {
server[method](route, function (req, res) {
var store = stores.get(req.params.resource);
delete req.params.resource;
handler(req, store, function (error, docs) {
if (error) {
res.status(500);
| javascript | {
"resource": ""
} |
q65078 | routeURL | test | function routeURL() {
var prefix = options.prefix || "",
args = ["/" + prefix, | javascript | {
"resource": ""
} |
q65079 | createPasswordHash | test | function createPasswordHash(object) {
if (!object) return object;
var password = object.password;
if (password) {
delete | javascript | {
"resource": ""
} |
q65080 | test | function( json, typeSpecification, array ) {
var keys,
current = json,
nested = [],
nestedKeys = [],
levels = [],
query = 'COLUMN_CREATE(',
root = true,
curNest = '',
curItem,
item = 0,
level = 0;
while( current ) {
keys = Object.keys( current );
var len = keys.length;
var _l;
var deepestLevel = 1;
for( var i = 0; i < len; ++i ) {
if( ( _l = current[ keys[ i ] ] ) === null || _l === undefined ) {
continue;
}
if( typeof( _l ) === 'object' ) {
// skip empty objects, we do not store them,
// this needs us to set NULL instead
if( !Object.keys( _l ).length ) {
_l = null;
if( !typeSpecification ) {
query += '\'' + keys[ i ].replace(/\\/g, '\\\\')
.replace(/\u0008/g, '\\b')
.replace(/'/g, '\\\'')
.replace(/\u0000/g, '\\0') + '\', NULL, ';
}
else {
query += '?, NULL, ';
array.push( keys[ i ] );
}
continue;
}
nested.push( _l );
nestedKeys.push( keys[ i ] );
if ( curItem !== item ) {
curItem = item;
++level;
levels.push( { level: level - 1, nestSep: curNest + ')' } );
}
else {
| javascript | {
"resource": ""
} |
|
q65081 | test | function(node) {
if (Ext.isObject(node) && !node.isModel) {
node = Ext.data.ModelManager.create(node, this.modelName);
}
| javascript | {
"resource": ""
} |
|
q65082 | test | function(silent) {
var me = this,
parentNode = me.parentNode,
isFirst = (!parentNode ? true : parentNode.firstChild == me),
isLast = (!parentNode ? true : parentNode.lastChild == me),
depth = 0,
parent = me,
children = me.childNodes,
ln = children.length,
i;
while (parent.parentNode) {
++depth;
parent = parent.parentNode;
}
me.beginEdit();
me.set({
isFirst: isFirst,
| javascript | {
"resource": ""
} |
|
q65083 | test | function(node, destroy, suppressEvents, suppressNodeUpdate) {
var me = this,
index = me.indexOf(node);
if (index == -1 || (suppressEvents !== true && me.fireEvent("beforeremove", me, node) === false)) {
return false;
}
// remove it from childNodes collection
Ext.Array.erase(me.childNodes, index, 1);
// update child refs
if (me.firstChild == node) {
me.setFirstChild(node.nextSibling);
}
if (me.lastChild == node) {
me.setLastChild(node.previousSibling);
| javascript | {
"resource": ""
} |
|
q65084 | test | function(destroy) {
var me = this;
// clear any references from the node
| javascript | {
"resource": ""
} |
|
q65085 | test | function(silent) {
/*
* Silent is to be used in a number of cases
* 1) When setRoot is called.
* 2) When destroy on the tree is called
* 3) For destroying child nodes on a node
*/
var me = this,
options = me.destroyOptions;
if (silent === true) {
me.clear(true);
Ext.each(me.childNodes, function(n) {
n.destroy(true);
});
me.childNodes = null;
| javascript | {
"resource": ""
} |
|
q65086 | test | function(node, refNode, suppressEvents) {
var me = this,
index = me.indexOf(refNode),
oldParent = node.parentNode,
refIndex = index,
ps;
if (!refNode) { // like standard Dom, refNode can be null for append
return me.appendChild(node);
}
// nothing to do
if (node == refNode) {
return false;
}
// Make sure it is a record with the NodeInterface
node = me.createNode(node);
if (suppressEvents !== true && me.fireEvent("beforeinsert", me, node, refNode) === false) {
return false;
}
// when moving internally, indexes will change after remove
if (oldParent == me && me.indexOf(node) < index) {
refIndex--;
}
// it's a move, make sure we move it cleanly
if (oldParent) {
if (suppressEvents !== true && node.fireEvent("beforemove", node, oldParent, me, index, refNode) === false) {
return false;
}
oldParent.removeChild(node);
}
if (refIndex === 0) {
me.setFirstChild(node);
}
Ext.Array.splice(me.childNodes, refIndex, 0, node);
node.parentNode = me;
| javascript | {
"resource": ""
} |
|
q65087 | test | function(destroy, suppressEvents) {
var parentNode = this.parentNode;
if (parentNode) {
| javascript | {
"resource": ""
} |
|
q65088 | test | function(destroy, suppressEvents) {
var cn = this.childNodes,
n;
while ((n = cn[0])) {
| javascript | {
"resource": ""
} |
|
q65089 | test | function(sortFn, recursive, suppressEvent) {
var cs = this.childNodes,
ln = cs.length,
i, n;
if (ln > 0) {
Ext.Array.sort(cs, sortFn);
for (i = 0; i < ln; i++) {
n = cs[i];
n.previousSibling = cs[i-1];
n.nextSibling = cs[i+1];
if (i === 0) {
this.setFirstChild(n);
}
if (i == ln - 1) {
this.setLastChild(n);
| javascript | {
"resource": ""
} |
|
q65090 | test | function(recursive, callback, scope) {
var me = this;
if (!me.isLeaf()) {
if (me.isLoading()) {
me.on('expand', function() {
me.expand(recursive, callback, scope);
}, me, {single: true});
}
else {
if (!me.isExpanded()) {
// The TreeStore actually listens for the beforeexpand method and checks
// whether we have to asynchronously load the children from the server
// first. Thats why we pass a callback function to the event that the
// store can call once it has loaded and parsed all the children.
me.fireAction('expand', [this], function() {
| javascript | {
"resource": ""
} |
|
q65091 | test | function(recursive, callback, scope) {
var me = this;
// First we start by checking if this node is a parent
if (!me.isLeaf() && me.isExpanded()) {
this.fireAction('collapse', [me], function() {
| javascript | {
"resource": ""
} |
|
q65092 | test | function (nextTargetFn, fnOpt) {
tail.next = {
fns: [nextTargetFn],
opts: [fnOpt]
};
| javascript | {
"resource": ""
} |
|
q65093 | test | function() {
var mask = Ext.getBody().createChild({
cls: Ext.baseCSSPrefix + 'mask ' + Ext.baseCSSPrefix + 'mask-transparent'
});
| javascript | {
"resource": ""
} |
|
q65094 | test | function(el, prefix) {
if (el && el.id) {
return el.id;
}
el = Ext.getDom(el) || {};
if (el === document || el === document.documentElement) {
| javascript | {
"resource": ""
} |
|
q65095 | test | function(dest, source, names, usePrototypeKeys) {
if (typeof names == 'string') {
names = names.split(/[,;\s]/);
}
Ext.each (names, function(name) {
| javascript | {
"resource": ""
} |
|
q65096 | test | function(node) {
if (node && node.parentNode && node.tagName != 'BODY') {
| javascript | {
"resource": ""
} |
|
q65097 | addAction | test | function addAction(name, fn) {
if (typeof name === "object" && fn == null) {
_.each(name, function(fn, n) { this.addAction(n, fn); }, this);
return this;
}
if (typeof name !== "string" || name === "") throw new Error("Expecting non-empty string for action name.");
if (typeof fn !== "function") throw new Error("Expecting function for action.");
| javascript | {
"resource": ""
} |
q65098 | test | function(property, obj, newProperty) {
if (config.hasOwnProperty(property)) {
if (obj) {
config[obj] = config[obj] || {};
config[obj][(newProperty) ? newProperty : property] = config[obj][(newProperty) ? newProperty : property] || config[property];
| javascript | {
"resource": ""
} |
|
q65099 | Store | test | function Store(name, items) {
if (!name) {
throw new Error('Please give the store a name!');
}
this.name = name;
| javascript | {
"resource": ""
} |