_id
stringlengths 2
6
| title
stringlengths 0
58
| partition
stringclasses 3
values | text
stringlengths 52
373k
| language
stringclasses 1
value | meta_information
dict |
|---|---|---|---|---|---|
q0 | train | function (state, action) {
return _.defaults({
isValidating: action.isValidating,
lastAction: IS_VALIDATING
}, state)
} | javascript | {
"resource": ""
} |
|
q1 | addWidgetForFilter | train | function addWidgetForFilter (view, filter, editModeHint) {
var gridster = view._widgetsGridster;
var row = filter.row || 1;
var col = filter.col || 1;
var sizeX = filter.size_x || 3;
var sizeY = filter.size_y || 3;
var el = gridster.add_widget('<div class="widgetOuterFrame"></div>', sizeX, sizeY, col, row);
var frameView = new WidgetFrameView({
model: filter
});
// render, and render content of widget frame
view.renderSubview(frameView, el[0]);
frameView.renderContent();
// link element and view so we can:
// a) on remove, get to the HTMLElement from the WidgetFrameView
// b) on resize, get to the WidgetFrameView from the HTMLElement
frameView.gridsterHook = el[0];
$(el[0]).data('spotWidgetFrameView', frameView);
// try to initialize and render possibly present data
// only follow editModeHint when the widget is configured, default to true
var chartView = frameView.widget;
chartView.model.updateConfiguration();
if (chartView.model.isConfigured) {
if (!filter.isInitialized) {
filter.initDataFilter();
}
if (!chartView.isInitialized) {
chartView.initChart();
}
chartView.update();
frameView.editMode = editModeHint;
} else {
// widget is not configured, ignore editModeHint
// and always go to edit mode
frameView.editMode = true;
}
filter.on('newData', function () {
chartView.update();
});
} | javascript | {
"resource": ""
} |
q2 | inRange | train | function inRange (value, min, max) {
const int = parseInt(value, 10)
return (
`${int}` === `${value.replace(/^0/, '')}` &&
int >= min &&
int <= max
)
} | javascript | {
"resource": ""
} |
q3 | markdown | train | function markdown(options) {
return new Remarkable(extend({
breaks: false,
html: true,
langPrefix: 'lang-',
linkify: true,
typographer: false,
xhtmlOut: false
}, options));
} | javascript | {
"resource": ""
} |
q4 | partitionValueToIndex | train | function partitionValueToIndex (partition, value) {
var group;
if (!partition) {
// no(sub)partitioning return first element
return 0;
}
// with (sub)partitioning
group = partition.groups.get(value, 'value');
if (group) {
// string in partition
return group.groupIndex;
} else {
// string not in partition
return -1;
}
} | javascript | {
"resource": ""
} |
q5 | _validateArray | train | function _validateArray (path, model, validateModelType) {
const results = []
let subPath = `${path}/items`
if (_.isPlainObject(model.items)) {
if (model.items.type === 'object') {
results.push(validateSubModel(subPath, model.items, validateModelType))
}
} else if (Array.isArray(model.items)) {
_.forEach(model.items, (item, index) => {
const itemSubPath = `${subPath}/${index}`
results.push(validateSubModel(itemSubPath, item, validateModelType))
})
}
return aggregateResults(results)
} | javascript | {
"resource": ""
} |
q6 | getDefaults | train | function getDefaults (value, path, model, resolveRef) {
const schema = findSchema(model, path, resolveRef)
const schemaDefault = _.clone(schema.default)
if (model.type === 'object') {
const subSchemaDefaults = {}
_.forIn(schema.properties, function (subSchema, propName) {
const defaults = getDefaults(
value && value[propName],
null,
subSchema,
resolveRef
)
if (defaults !== undefined) {
subSchemaDefaults[propName] = defaults
}
})
if (Object.keys(subSchemaDefaults).length > 0) {
return _.defaults({}, schemaDefault, subSchemaDefaults)
}
return schemaDefault
} else if (value !== undefined) {
return value
}
return schemaDefault
} | javascript | {
"resource": ""
} |
q7 | getDefaultedValue | train | function getDefaultedValue ({inputValue, previousValue, bunsenId, renderModel, mergeDefaults}) {
const isInputValueEmpty = isEmptyValue(inputValue)
if (previousValue !== undefined) {
return inputValue
}
const resolveRef = schemaFromRef(renderModel.definitions)
const defaultValue = getDefaults(inputValue, bunsenId, renderModel, resolveRef)
const hasDefaults = defaultValue !== undefined
const isUpdatingAll = bunsenId === null
const shouldApplyDefaults = isInputValueEmpty && hasDefaults ||
!isInputValueEmpty && hasDefaults && isUpdatingAll && mergeDefaults
const shouldClear = isInputValueEmpty && isUpdatingAll && !hasDefaults
if (shouldApplyDefaults) {
const schema = findSchema(renderModel, bunsenId, resolveRef)
return schema.type === 'object' ? _.defaults({}, inputValue, defaultValue) : defaultValue
} else if (shouldClear) {
return {}
}
return inputValue
} | javascript | {
"resource": ""
} |
q8 | fieldValidation | train | function fieldValidation (dispatch, getState, fieldValidators, formValue, initialFormValue, all) {
let fieldsBeingValidated = []
const allValidationPromises = []
fieldValidators.forEach(validator => {
/**
* Field validator definition
* @property {String} field field to validate
* @property {String[]} fields fields to validate
* @property {Function} validator validation function to validate field/fields. Must return field within error/warning
* @property {Function[]} validators validation functions to validate field/fields. Must return field within error/warning
*/
const {field, fields, validator: validatorFunc, validators: validatorFuncs} = validator
const fieldsToValidate = fields || [field]
fieldsBeingValidated = fieldsBeingValidated.concat(fieldsToValidate)
fieldsToValidate.forEach((field) => {
let fieldValidationPromises = []
const newValue = _.get(formValue, field)
const oldValue = _.get(initialFormValue, field)
// Check if field value has changed
if (!_.isEqual(newValue, oldValue) || !initialFormValue) {
dispatchFieldIsValidating(dispatch, field, true)
const validations = validatorFuncs || [validatorFunc]
// Send validator formValue, the field we're validating against, and the field's value
validations.forEach((validatorFunc, index) => {
const fieldValidationPromise = validatorFunc(formValue, field, newValue)
.then((result) => {
const {
fieldValidationResult: {
errors: currentErrors = [],
warnings: currentWarnings = []
} = {}
} = getState()
const validationId = `${field}-${index}`
const filterOutValidationId = (item) => item.validationId !== validationId
const filteredOutErrors = currentErrors.filter(filterOutValidationId)
const filteredOutWarnings = currentWarnings.filter(filterOutValidationId)
// No need to use `aggregateResults as we should never have isRequired
const {
errors = [], warnings = []
} = result.value
const attachValidationId = (item) => {
return _.assign({
validationId,
field
}, item)
}
const newErrors = filteredOutErrors.concat(errors.map(attachValidationId))
const errorsMappedToDotNotation = mapErrorsFromValidation(newErrors)
dispatch({
fieldErrors: errorsMappedToDotNotation,
type: VALIDATION_RESOLVED,
fieldValidationResult: {
errors: newErrors,
warnings: filteredOutWarnings.concat(warnings.map(attachValidationId))
}
})
return result
})
allValidationPromises.push(fieldValidationPromise)
fieldValidationPromises.push(fieldValidationPromise)
})
}
if (fieldValidationPromises.length >= 1) {
all(fieldValidationPromises).then(() => {
dispatchFieldIsValidating(dispatch, field, false)
})
}
})
})
return allValidationPromises
} | javascript | {
"resource": ""
} |
q9 | _guardPromiseAll | train | function _guardPromiseAll (promises, all, callback) {
if (promises.length === 0) {
callback()
} else {
all(promises).then(() => {
callback()
})
}
} | javascript | {
"resource": ""
} |
q10 | getPropertyOrder | train | function getPropertyOrder (properties) {
const primitiveProps = []
const complexProps = []
_.forIn(properties, (prop, propName) => {
if (prop.type === 'object' || prop.type === 'array') {
complexProps.push(propName)
} else {
primitiveProps.push(propName)
}
})
return primitiveProps.concat(complexProps)
} | javascript | {
"resource": ""
} |
q11 | addModelCell | train | function addModelCell (propertyName, model, cellDefinitions) {
const cell = {}
var defName = propertyName
var counter = 1
while (defName in cellDefinitions) {
defName = `${propertyName}${counter}`
counter++
}
cellDefinitions[defName] = cell
const props = getPropertyOrder(model.properties)
const children = props.map((propName) => {
// we have a circular dependency
/* eslint-disable no-use-before-define */
return addModel(propName, model.properties[propName], cellDefinitions)
/* eslint-enable no-use-before-define */
})
if (model.dependencies) {
_.forIn(model.dependencies, (dep, depName) => {
const depProps = getPropertyOrder(dep.properties)
const depChildren = depProps.map((propName) => {
// we have a circular dependency
/* eslint-disable no-use-before-define */
return addDependentModel(propName, depName, dep.properties[propName], cellDefinitions)
/* eslint-enable no-use-before-define */
})
children.push.apply(children, depChildren)
})
}
cell.children = children
return defName
} | javascript | {
"resource": ""
} |
q12 | run | train | async function run() {
// Read the records
const records = await BB.all(process.argv.slice(2).map(f => readAsync(f)))
// Write them to Kinesis
return BB.map(records, record => kinesis.putRecord({
Data: JSON.stringify(yaml.safeLoad(record)),
PartitionKey: '0',
StreamName: process.env.LAMBDA_KINESIS_STREAM_NAME
}).promise())
} | javascript | {
"resource": ""
} |
q13 | appendModelPath | train | function appendModelPath (modelPath, id, internal) {
const addedModelPath = getModelPath(id)
if (internal) {
if (modelPath === '') {
return `properties._internal.${addedModelPath}`
}
return `${modelPath}.properties._internal.${addedModelPath}`
}
if (modelPath === '') {
return addedModelPath
}
return `${modelPath}.${addedModelPath}`
} | javascript | {
"resource": ""
} |
q14 | extendCell | train | function extendCell (cell, cellDefinitions) {
cell = _.clone(cell)
while (cell.extends) {
const extendedCell = cellDefinitions[cell.extends]
if (!_.isObject(extendedCell)) {
throw new Error(`'${cell.extends}' is not a valid model definition`)
}
delete cell.extends
cell = _.defaults(cell, extendedCell)
}
return cell
} | javascript | {
"resource": ""
} |
q15 | normalizeArrayOptions | train | function normalizeArrayOptions (cell, cellDefinitions) {
const arrayOptions = _.clone(cell.arrayOptions)
if (arrayOptions.itemCell) {
if (Array.isArray(arrayOptions.itemCell)) {
arrayOptions.itemCell = arrayOptions.itemCell.map(cell => normalizeCell(cell, cellDefinitions))
} else {
arrayOptions.itemCell = normalizeCell(arrayOptions.itemCell, cellDefinitions)
}
}
if (arrayOptions.tupleCells) {
arrayOptions.tupleCells = arrayOptions.tupleCells.map(cell => normalizeCell(cell, cellDefinitions))
}
return arrayOptions
} | javascript | {
"resource": ""
} |
q16 | pluckFromArrayOptions | train | function pluckFromArrayOptions (cell, modelPath, models, cellDefinitions) {
if (cell.arrayOptions.tupleCells) {
cell.arrayOptions.tupleCells.forEach(function (cell, index) {
pluckModels(cell, modelPath.concat(index), models, cellDefinitions)
})
}
if (cell.arrayOptions.itemCell) {
const itemCell = cell.arrayOptions.itemCell
if (Array.isArray(itemCell)) {
itemCell.forEach(function (cell, index) {
pluckModels(cell, modelPath.concat(index), models, cellDefinitions)
})
} else {
pluckModels(itemCell, modelPath.concat('0'), models, cellDefinitions)
}
}
} | javascript | {
"resource": ""
} |
q17 | pluckModels | train | function pluckModels (cell, modelPath, models, cellDefinitions) {
cell = extendCell(cell, cellDefinitions)
if (_.isObject(cell.model)) {
const addedPath = appendModelPath(modelPath.modelPath(), cell.id, cell.internal)
models[addedPath] = cell.model
} else if (cell.children) { // recurse on objects
cell.children.forEach((cell) => {
const newPath = typeof cell.model === 'string' ? modelPath.concat(cell.model) : modelPath
pluckModels(cell, newPath, models, cellDefinitions)
})
} else if (cell.arrayOptions) { // recurse on arrays
pluckFromArrayOptions(cell, modelPath, models, cellDefinitions)
}
} | javascript | {
"resource": ""
} |
q18 | aggregateModels | train | function aggregateModels (view, modelPath) {
const models = {}
view.cells.forEach(function (cell) {
const newPath = typeof cell.model === 'string' ? modelPath.concat(cell.model) : modelPath
pluckModels(cell, newPath, models, view.cellDefinitions)
})
return models
} | javascript | {
"resource": ""
} |
q19 | expandModel | train | function expandModel (model, view) {
const modelPath = new BunsenModelPath(model)
const modelExpansions = aggregateModels(view, modelPath)
let newModel = model
_.forEach(modelExpansions, (propertyModel, path) => {
newModel = addBunsenModelProperty(newModel, propertyModel, path)
})
return newModel
} | javascript | {
"resource": ""
} |
q20 | svgs | train | function svgs(req, res) {
const bundle = new Bundle(
req.url.slice(1, -5).split('-').map(function map(name) {
return assets[name];
})
);
bundle.run(function (err, output) {
if (err) throw err;
res.setHeader('Content-Length', Buffer(output).length);
res.writeHead(200, { 'Content-Type': 'text/plain' });
res.end(output);
});
} | javascript | {
"resource": ""
} |
q21 | html | train | function html(req, res) {
fs.readFile(path.join(__dirname, 'index.html'), function read(err, file) {
if (err) throw err;
res.setHeader('Content-Length', file.length);
res.writeHead(200, { 'Content-Type': 'text/html' });
res.end(file);
});
} | javascript | {
"resource": ""
} |
q22 | client | train | function client(req, res) {
const compiler = webpack(config);
compiler.outputFileSystem = fsys;
compiler.run((err, stats) => {
const file = fsys.readFileSync(path.join(__dirname, 'dist', 'client.js'));
res.setHeader('Content-Length', file.length);
res.writeHead(200, { 'Content-Type': 'text/javascript' });
res.end(file);
});
} | javascript | {
"resource": ""
} |
q23 | convertObjectCell | train | function convertObjectCell (cell) {
return _.chain(cell.rows)
.map(rowsToCells)
.assign(_.pick(cell, CARRY_OVER_PROPERTIES))
.value()
} | javascript | {
"resource": ""
} |
q24 | convertArrayCell | train | function convertArrayCell (cell) {
const {item} = cell
const arrayOptions = _.chain(item)
.pick(ARRAY_CELL_PROPERTIES)
.assign({
itemCell: convertCell(item)
})
.value()
return {
arrayOptions,
model: cell.model
}
} | javascript | {
"resource": ""
} |
q25 | convertRenderer | train | function convertRenderer (cell) {
const {renderer} = cell
if (renderer === undefined) {
return
}
const basicRenderers = [
'boolean',
'string',
'number'
]
if (basicRenderers.indexOf(renderer) >= 0) {
return {name: renderer}
}
return customRenderer(renderer, cell.properties)
} | javascript | {
"resource": ""
} |
q26 | grabClassNames | train | function grabClassNames (cell) {
const classNames = _.pickBy({
cell: cell.className,
value: cell.inputClassName,
label: cell.labelClassName
})
if (_.size(classNames) > 0) {
return classNames
}
} | javascript | {
"resource": ""
} |
q27 | rowsToCells | train | function rowsToCells (rows) {
if (!rows) {
return {}
}
const children = rows
.map((row) => {
return {
children: _.map(row, convertCell)
}
})
return {
children
}
} | javascript | {
"resource": ""
} |
q28 | warning | train | function warning(lines) {
lines.unshift(''); // Extra whitespace at the start.
lines.push(''); // Extra whitespace at the end.
lines.forEach(function each(line) {
console.error('asset-bundle:warning', line);
});
} | javascript | {
"resource": ""
} |
q29 | viewBox | train | function viewBox(details) {
svg.viewBox = `${details.x || 0} ${details.y || 0} ${details.width} ${details.height}`;
fn(null, svg);
} | javascript | {
"resource": ""
} |
q30 | train | function () {
var filter = this.collection.parent.filter;
if (!filter || !this.isFilled) {
return false;
}
filter.releaseDataFilter();
if (this.type === 'partition') {
var partition = filter.partitions.get(this.rank, 'rank');
filter.partitions.remove(partition);
} else if (this.type === 'aggregate') {
var aggregate = filter.aggregates.get(this.rank, 'rank');
filter.aggregates.remove(aggregate);
}
this.isFilled = false;
return true;
} | javascript | {
"resource": ""
} |
|
q31 | getWebpackRunnableLambda | train | function getWebpackRunnableLambda(slsWebpack, stats, functionName) {
const handler = slsWebpack.loadHandler(stats, functionName, true)
const context = slsWebpack.getContext(functionName)
return wrapHandler(handler, context)
} | javascript | {
"resource": ""
} |
q32 | onClick | train | function onClick (ev, elements) {
var model = this._Ampersandview.model;
var partition = model.filter.partitions.get(1, 'rank');
if (elements.length > 0) {
partition.updateSelection(partition.groups.models[elements[0]._index]);
model.filter.updateDataFilter();
app.me.dataview.getData();
}
} | javascript | {
"resource": ""
} |
q33 | getColor | train | function getColor (i) {
i = parseInt(i);
if (i < 0 || i >= colors.length) {
// pick a color from the scale defined above
return scale(((i - colors.length) * (211 / 971)) % 1);
} else {
return chroma(colors[i]);
}
} | javascript | {
"resource": ""
} |
q34 | init | train | function init(loader) {
var loaderConfig = loaderUtils.getLoaderConfig(loader, 'web3Loader');
web3 = require('./lib/web3')(loaderConfig.provider);
config = mergeConfig(loaderConfig);
isDebug = loader.debug;
} | javascript | {
"resource": ""
} |
q35 | mergeConfig | train | function mergeConfig(loaderConfig) {
var defaultConfig = {
// Web3
provider: 'http://localhost:8545',
// For deployment
from: web3.eth.accounts[0],
gasLimit: web3.eth.getBlock(web3.eth.defaultBlock).gasLimit,
// Specify contract constructor parameters, if any.
// constructorParams: {
// ContractOne: [ 'param1_value', 'param2_value' ]
// }
constructorParams: {},
// To use deployed contracts instead of redeploying, include contract addresses in config
// deployedContracts: {
// ContractOne: '0x...........',
// ContractTwo: '0x...........',
// }
deployedContracts: {}
};
var mergedConfig = loaderConfig;
for (var key in defaultConfig) {
if (!mergedConfig.hasOwnProperty(key)) {
mergedConfig[key] = defaultConfig[key];
}
}
return mergedConfig;
} | javascript | {
"resource": ""
} |
q36 | deploy | train | function deploy(contract, callback, contractMap) {
// Reuse existing contract address
if (config.deployedContracts.hasOwnProperty(contract.name)) {
contract.address = config.deployedContracts[contract.name];
return callback(null, contract);
}
linkBytecode(contract, contractMap);
// Deploy a new one
var params = resolveConstructorParams(contract, contractMap);
logDebug('Constructor params ' + contract.name + ':', params);
if(contract.bytecode && !contract.bytecode.startsWith('0x')) {
contract.bytecode = '0x' + contract.bytecode;
}
params.push({
from: config.from,
data: contract.bytecode,
gas: config.gasLimit,
});
params.push(function (err, deployed) {
if (err) {
return callback(err);
}
if (typeof deployed.address !== 'undefined') {
contract.address = deployed.address;
return callback(null, contract);
}
});
var web3Contract = web3.eth.contract(contract.abi);
web3Contract.new.apply(web3Contract, params);
} | javascript | {
"resource": ""
} |
q37 | _validateRootAttributes | train | function _validateRootAttributes (view, model, cellValidator) {
const results = [
_validateCells(view, model, cellValidator)
]
const knownAttributes = ['version', 'type', 'cells', 'cellDefinitions']
const unknownAttributes = _.difference(Object.keys(view), knownAttributes)
results.push({
errors: [],
warnings: _.map(unknownAttributes, (attr) => {
return {
path: '#',
message: `Unrecognized attribute "${attr}"`
}
})
})
return aggregateResults(results)
} | javascript | {
"resource": ""
} |
q38 | train | function () {
// Create and attach our main view
this.mainView = new MainView({
model: this.me,
el: document.body
});
// this kicks off our backbutton tracking (browser history)
// and will cause the first matching handler in the router
// to fire.
this.router.history.start({
root: '/',
pushState: true
});
} | javascript | {
"resource": ""
} |
|
q39 | train | function (i) {
if (i >= columns.length) {
insertIntoDB();
return;
}
var dbField = columns[i];
var field = dbField.Field;
//Check required fields
if (dbField.Null === 'NO' &&
dbField.Default === '' &&
dbField.Extra !== 'auto_increment' &&
dbField.Extra.search('on update')===-1) {
//Check if field not set
if (undefOrEmpty(req.body[field])) {
return sendError(res,"Field " + field + " is NOT NULL but not specified in this request");
} else {
//Check if the set values are roughly okay
value = checkIfSentvaluesAreSufficient(req,dbField);
console.log(value);
if(value !== false) {
//Value seems okay, go to the next field
insertJson[field] = value;
iterator(i + 1);
} else {
return sendError(res,'Value for field ' + field + ' is not sufficient. Expecting ' + dbField.Type + ' but got ' + typeof req.body[field] );
}
}
} else {
//Check for not required fields
//Skip auto_incremented fields
if(dbField.Extra === 'auto_increment') {
iterator(i + 1);
} else {
//Check if the field was provided by the client
var defined = false;
if(dbField.Default == "FILE") {
if(req.files.hasOwnProperty(dbField.Field)) {
defined = true;
}
} else {
if(typeof req.body[field] !== "undefined") {
defined = true;
}
}
//If it was provided, check if the values are okay
if(defined) {
value = checkIfSentvaluesAreSufficient(req,dbField);
if(value !== false) {
insertJson[field] = value;
iterator(i + 1);
} else {
if(dbField.Default == "FILE") {
return sendError(res, 'Value for field ' + field + ' is not sufficient. Either the file is to large or an other error occured');
} else {
return sendError(res, 'Value for field ' + field + ' is not sufficient. Expecting ' + dbField.Type + ' but got ' + typeof req.body[field]);
}
}
} else {
//If not, don't mind
iterator(i + 1);
}
}
}
} | javascript | {
"resource": ""
} |
|
q40 | insertIntoDB | train | function insertIntoDB() {
lastQry = connection.query('INSERT INTO ?? SET ?', [req.params.table , insertJson] , function (err, rows) {
if (err) {
console.error(err);
res.statusCode = 500;
res.send({
result: 'error',
err: err.code
});
} else {
sendSuccessAnswer(req.params.table , res, rows.insertId);
}
});
} | javascript | {
"resource": ""
} |
q41 | updateIntoDB | train | function updateIntoDB() {
//Yaaay, alle Tests bestanden gogo, insert!
lastQry = connection.query('UPDATE ?? SET ? WHERE ?? = ?', [req.params.table , updateJson, updateSelector.field, updateSelector.value] , function (err) {
if (err) return sendError(res,err.code);
sendSuccessAnswer(req.params.table , res, req.params.id, updateSelector.field);
});
} | javascript | {
"resource": ""
} |
q42 | sendSuccessAnswer | train | function sendSuccessAnswer(table, res, id, field) {
if(typeof field === "undefined") {
if(id === 0) {
//Just assume that everything went okay. It looks like a non numeric primary key.
res.send({
result: 'success',
table: table
});
return;
} else {
field = "id";
}
}
lastQry = connection.query('SELECT * FROM ?? WHERE ?? = ?', [table, field, id] , function (err, rows) {
if (err) {
sendError(res, err.code)
} else {
res.send({
result: 'success',
json: rows,
table: table
});
}
});
} | javascript | {
"resource": ""
} |
q43 | checkIfSentvaluesAreSufficient | train | function checkIfSentvaluesAreSufficient(req,dbField) {
if(dbField.Default == 'FILE') {
//For 'File' fields just return the link ot the file
if(req.files.hasOwnProperty(dbField.Field)) {
var file = req.files[dbField.Field].hasOwnProperty('name') ? req.files[dbField.Field] : req.files[dbField.Field][0];
if(settings.maxFileSize !== -1 && file.size > settings.maxFileSize) {
return false;
}
return file.name;
} else {
return false;
}
} else {
if (req.body[dbField.Field] === null || typeof req.body[dbField.Field] == "undefined") {
return dbField.Null == "YES" ? null : false;
}
//Normle Werte
if((dbField.Type.indexOf("int") != -1 || dbField.Type.indexOf("float") != -1 || dbField.Type.indexOf("double") != -1 )) {
return !isNaN(req.body[dbField.Field]) ? req.body[dbField.Field] : false;
} else if(typeof req.body[dbField.Field] === 'string') {
return escape(req.body[dbField.Field]);
}
return false;
}
} | javascript | {
"resource": ""
} |
q44 | sendError | train | function sendError(res,err) {
console.error(err);
// also log last executed query, for easier debugging
console.error(lastQry.sql);
res.statusCode = 500;
res.send({
result: 'error',
err: err
});
} | javascript | {
"resource": ""
} |
q45 | findPrim | train | function findPrim(columns,field) {
var primary_keys = columns.filter(function (r) {return r.Key === 'PRI';});
//for multiple primary keys, just take the first
if(primary_keys.length > 0) {
return primary_keys[0].Field;
}
//If the provided field is a string, we might have a chance
if(typeof field === "string") {
if(checkIfFieldsExist(field,columns)) {
return escape(field);
}
}
//FALLBACK
return "id";
} | javascript | {
"resource": ""
} |
q46 | checkRateRange | train | function checkRateRange(num) {
var numString = num.substring(0, num.length - 1);
var parseNum = parseInt(numString);
if (parseNum < 20) {
throw new Error("The minimum rate is twenty percentage. Received: " + parseNum);
}
} | javascript | {
"resource": ""
} |
q47 | isInList | train | function isInList(value, listOfValues, msg) {
value = value.toLowerCase().trim();
if (listOfValues.indexOf(value) === -1) {
throw new Error(msg);
}
} | javascript | {
"resource": ""
} |
q48 | equals | train | function equals(x, y) {
var a = isFunction(x) ? x() : x;
var b = isFunction(y) ? y() : y;
var aKeys;
if (a == b)
return true;
else if (a == _null || b == _null)
return false;
else if (isValue(a) || isValue(b))
return isDate(a) && isDate(b) && +a==+b;
else if (isList(a)) {
return (a.length == b.length) &&
!find(a, function(val, index) {
if (!equals(val, b[index]))
return true;
});
}
else {
return !isList(b) &&
((aKeys = keys(a)).length == keyCount(b)) &&
!find(aKeys, function(key) {
if (!equals(a[key],b[key]))
return true;
});
}
} | javascript | {
"resource": ""
} |
q49 | parseDate | train | function parseDate(fmt, date) {
var indexMap = {}; // contains reGroupPosition -> typeLetter or [typeLetter, value array]
var reIndex = 1;
var timezoneOffsetMatch;
var timezoneIndex;
var match;
var format = replace(fmt, /^\?/);
if (format!=fmt && !trim(date))
return _null;
if (match = /^\[([+-])(\d\d)(\d\d)\]\s*(.*)/.exec(format)) {
timezoneOffsetMatch = match;
format = match[4];
}
var parser = new RegExp(format.replace(/(.)(\1*)(?:\[([^\]]*)\])?/g, function(wholeMatch, placeholderChar, placeholderDigits, param) {
if (/[dmhkyhs]/i.test(placeholderChar)) {
indexMap[reIndex++] = placeholderChar;
var plen = placeholderDigits.length+1;
return "(\\d"+(plen<2?"+":("{1,"+plen+"}"))+")";
}
else if (placeholderChar == 'z') {
timezoneIndex = reIndex;
reIndex += 3;
return "([+-])(\\d\\d)(\\d\\d)";
}
else if (/[Nna]/.test(placeholderChar)) {
indexMap[reIndex++] = [placeholderChar, param && param.split(',')];
return "([a-zA-Z\\u0080-\\u1fff]+)";
}
else if (/w/i.test(placeholderChar))
return "[a-zA-Z\\u0080-\\u1fff]+";
else if (/\s/.test(placeholderChar))
return "\\s+";
else
return escapeRegExp(wholeMatch);
}));
if (!(match = parser.exec(date)))
return undef;
var ctorArgs = [0, 0, 0, 0, 0, 0, 0];
for (var i = 1; i < reIndex; i++) {
var matchVal = match[i];
var indexEntry = indexMap[i];
if (isList(indexEntry)) { // for a, n or N
var placeholderChar = indexEntry[0];
var mapEntry = PARSE_DATE_MAP[placeholderChar];
var ctorIndex = mapEntry[0];
var valList = indexEntry[1] || mapEntry[1];
var listValue = find(valList, function(v, index) { if (startsWith(matchVal.toLowerCase(), v.toLowerCase())) return index; });
if (listValue == _null)
return undef;
if (placeholderChar == 'a')
ctorArgs[ctorIndex] += listValue * 12;
else
ctorArgs[ctorIndex] = listValue;
}
else if (indexEntry) { // for numeric values (yHmMs)
var value = parseFloat(matchVal);
var mapEntry = PARSE_DATE_MAP[indexEntry];
if (isList(mapEntry))
ctorArgs[mapEntry[0]] += value - mapEntry[1];
else
ctorArgs[mapEntry] += value;
}
}
var d = new Date(ctorArgs[0], ctorArgs[1], ctorArgs[2], ctorArgs[3], ctorArgs[4], ctorArgs[5], ctorArgs[6]);
return dateAdd(d, 'minutes', -getTimezone(timezoneOffsetMatch, 1, d) - getTimezone(match, timezoneIndex, d));
} | javascript | {
"resource": ""
} |
q50 | collectUniqNodes | train | function collectUniqNodes(list, func) {
var result = [];
var nodeIds = {};
var currentNodeId;
flexiEach(list, function(value) {
flexiEach(func(value), function(node) {
if (!nodeIds[currentNodeId = getNodeId(node)]) {
result.push(node);
nodeIds[currentNodeId] = true;
}
});
});
return result;
} | javascript | {
"resource": ""
} |
q51 | triggerHandler | train | function triggerHandler(eventName, event, target) {
var match = !bubbleSelector;
var el = bubbleSelector ? target : registeredOn;
if (bubbleSelector) {
var selectorFilter = getFilterFunc(bubbleSelector, registeredOn);
while (el && el != registeredOn && !(match = selectorFilter(el)))
el = el['parentNode'];
}
return (!match) || (name != eventName) || ((handler.apply($(el), args || [event, index]) && prefix=='?') || prefix == '|');
} | javascript | {
"resource": ""
} |
q52 | enrichMethodNode | train | function enrichMethodNode(methodNode, method) {
method.description && (methodNode.description = method.description)
if (method.tags.route) {
let httpPath = method.tags.route
let httpMethod = 'GET'
const sepPos = httpPath.indexOf(' ')
if (sepPos !== -1) {
httpMethod = httpPath.substr(0, sepPos).toUpperCase()
httpPath = httpPath.substr(sepPos + 1)
if (!isValidHttpMethod(httpMethod)) {
throw new Error(`Unsupported HTTP method [${httpMethod}] for ${method.name} method`)
}
}
methodNode.method = httpMethod
methodNode.path = httpPath
}
return methodNode
} | javascript | {
"resource": ""
} |
q53 | refract | train | function refract(value) {
if (value instanceof Element) {
return value;
}
if (typeof value === 'string') {
return new StringElement(value);
}
if (typeof value === 'number') {
return new NumberElement(value);
}
if (typeof value === 'boolean') {
return new BooleanElement(value);
}
if (value === null) {
return new NullElement();
}
if (Array.isArray(value)) {
return new ArrayElement(value.map(refract));
}
if (typeof value === 'object') {
const element = new ObjectElement(value);
return element;
}
return value;
} | javascript | {
"resource": ""
} |
q54 | statusLog | train | function statusLog(file, data, time) {
var msg = '';
var diff = (process.hrtime(time)[1] / 1000000000).toFixed(2);
var adapters = Object.keys(data._adapterData).join(', ');
msg += format('Supercollider: processed %s in %s', chalk.cyan(file), chalk.magenta(diff + ' s'));
if (adapters.length) {
msg += format(' with %s', chalk.yellow(adapters));
}
log(msg);
} | javascript | {
"resource": ""
} |
q55 | CodeMirror | train | function CodeMirror(place, options) {
if (!(this instanceof CodeMirror)) return new CodeMirror(place, options);
this.options = options = options ? copyObj(options) : {};
// Determine effective options based on given values and defaults.
copyObj(defaults, options, false);
setGuttersForLineNumbers(options);
var doc = options.value;
if (typeof doc == "string") doc = new Doc(doc, options.mode);
this.doc = doc;
var display = this.display = new Display(place, doc);
display.wrapper.CodeMirror = this;
updateGutters(this);
themeChanged(this);
if (options.lineWrapping)
this.display.wrapper.className += " CodeMirror-wrap";
if (options.autofocus && !mobile) focusInput(this);
initScrollbars(this);
this.state = {
keyMaps: [], // stores maps added by addKeyMap
overlays: [], // highlighting overlays, as added by addOverlay
modeGen: 0, // bumped when mode/overlay changes, used to invalidate highlighting info
overwrite: false, focused: false,
suppressEdits: false, // used to disable editing during key handlers when in readOnly mode
pasteIncoming: false, cutIncoming: false, // help recognize paste/cut edits in readInput
draggingText: false,
highlight: new Delayed(), // stores highlight worker timeout
keySeq: null // Unfinished key sequence
};
// Override magic textarea content restore that IE sometimes does
// on our hidden textarea on reload
if (ie && ie_version < 11) setTimeout(bind(resetInput, this, true), 20);
registerEventHandlers(this);
ensureGlobalHandlers();
startOperation(this);
this.curOp.forceUpdate = true;
attachDoc(this, doc);
if ((options.autofocus && !mobile) || activeElt() == display.input)
setTimeout(bind(onFocus, this), 20);
else
onBlur(this);
for (var opt in optionHandlers) if (optionHandlers.hasOwnProperty(opt))
optionHandlers[opt](this, options[opt], Init);
maybeUpdateLineNumberWidth(this);
if (options.finishInit) options.finishInit(this);
for (var i = 0; i < initHooks.length; ++i) initHooks[i](this);
endOperation(this);
// Suppress optimizelegibility in Webkit, since it breaks text
// measuring on line wrapping boundaries.
if (webkit && options.lineWrapping &&
getComputedStyle(display.lineDiv).textRendering == "optimizelegibility")
display.lineDiv.style.textRendering = "auto";
} | javascript | {
"resource": ""
} |
q56 | updateWidgetHeight | train | function updateWidgetHeight(line) {
if (line.widgets) for (var i = 0; i < line.widgets.length; ++i)
line.widgets[i].height = line.widgets[i].node.offsetHeight;
} | javascript | {
"resource": ""
} |
q57 | ensureLineWrapped | train | function ensureLineWrapped(lineView) {
if (lineView.node == lineView.text) {
lineView.node = elt("div", null, null, "position: relative");
if (lineView.text.parentNode)
lineView.text.parentNode.replaceChild(lineView.node, lineView.text);
lineView.node.appendChild(lineView.text);
if (ie && ie_version < 8) lineView.node.style.zIndex = 2;
}
return lineView.node;
} | javascript | {
"resource": ""
} |
q58 | extendSelection | train | function extendSelection(doc, head, other, options) {
setSelection(doc, new Selection([extendRange(doc, doc.sel.primary(), head, other)], 0), options);
} | javascript | {
"resource": ""
} |
q59 | skipAtomic | train | function skipAtomic(doc, pos, bias, mayClear) {
var flipped = false, curPos = pos;
var dir = bias || 1;
doc.cantEdit = false;
search: for (;;) {
var line = getLine(doc, curPos.line);
if (line.markedSpans) {
for (var i = 0; i < line.markedSpans.length; ++i) {
var sp = line.markedSpans[i], m = sp.marker;
if ((sp.from == null || (m.inclusiveLeft ? sp.from <= curPos.ch : sp.from < curPos.ch)) &&
(sp.to == null || (m.inclusiveRight ? sp.to >= curPos.ch : sp.to > curPos.ch))) {
if (mayClear) {
signal(m, "beforeCursorEnter");
if (m.explicitlyCleared) {
if (!line.markedSpans) break;
else {--i; continue;}
}
}
if (!m.atomic) continue;
var newPos = m.find(dir < 0 ? -1 : 1);
if (cmp(newPos, curPos) == 0) {
newPos.ch += dir;
if (newPos.ch < 0) {
if (newPos.line > doc.first) newPos = clipPos(doc, Pos(newPos.line - 1));
else newPos = null;
} else if (newPos.ch > line.text.length) {
if (newPos.line < doc.first + doc.size - 1) newPos = Pos(newPos.line + 1, 0);
else newPos = null;
}
if (!newPos) {
if (flipped) {
// Driven in a corner -- no valid cursor position found at all
// -- try again *with* clearing, if we didn't already
if (!mayClear) return skipAtomic(doc, pos, bias, true);
// Otherwise, turn off editing until further notice, and return the start of the doc
doc.cantEdit = true;
return Pos(doc.first, 0);
}
flipped = true; newPos = pos; dir = -dir;
}
}
curPos = newPos;
continue search;
}
}
}
return curPos;
}
} | javascript | {
"resource": ""
} |
q60 | drawSelectionCursor | train | function drawSelectionCursor(cm, range, output) {
var pos = cursorCoords(cm, range.head, "div", null, null, !cm.options.singleCursorHeightPerLine);
var cursor = output.appendChild(elt("div", "\u00a0", "CodeMirror-cursor"));
cursor.style.left = pos.left + "px";
cursor.style.top = pos.top + "px";
cursor.style.height = Math.max(0, pos.bottom - pos.top) * cm.options.cursorHeight + "px";
if (pos.other) {
// Secondary cursor, shown when on a 'jump' in bi-directional text
var otherCursor = output.appendChild(elt("div", "\u00a0", "CodeMirror-cursor CodeMirror-secondarycursor"));
otherCursor.style.display = "";
otherCursor.style.left = pos.other.left + "px";
otherCursor.style.top = pos.other.top + "px";
otherCursor.style.height = (pos.other.bottom - pos.other.top) * .85 + "px";
}
} | javascript | {
"resource": ""
} |
q61 | findViewForLine | train | function findViewForLine(cm, lineN) {
if (lineN >= cm.display.viewFrom && lineN < cm.display.viewTo)
return cm.display.view[findViewIndex(cm, lineN)];
var ext = cm.display.externalMeasured;
if (ext && lineN >= ext.lineN && lineN < ext.lineN + ext.size)
return ext;
} | javascript | {
"resource": ""
} |
q62 | prepareMeasureForLine | train | function prepareMeasureForLine(cm, line) {
var lineN = lineNo(line);
var view = findViewForLine(cm, lineN);
if (view && !view.text)
view = null;
else if (view && view.changes)
updateLineForChanges(cm, view, lineN, getDimensions(cm));
if (!view)
view = updateExternalMeasurement(cm, line);
var info = mapFromLineView(view, line, lineN);
return {
line: line, view: view, rect: null,
map: info.map, cache: info.cache, before: info.before,
hasHeights: false
};
} | javascript | {
"resource": ""
} |
q63 | charWidth | train | function charWidth(display) {
if (display.cachedCharWidth != null) return display.cachedCharWidth;
var anchor = elt("span", "xxxxxxxxxx");
var pre = elt("pre", [anchor]);
removeChildrenAndAdd(display.measure, pre);
var rect = anchor.getBoundingClientRect(), width = (rect.right - rect.left) / 10;
if (width > 2) display.cachedCharWidth = width;
return width || 10;
} | javascript | {
"resource": ""
} |
q64 | endOperation | train | function endOperation(cm) {
var op = cm.curOp, group = op.ownsGroup;
if (!group) return;
try { fireCallbacksForOps(group); }
finally {
operationGroup = null;
for (var i = 0; i < group.ops.length; i++)
group.ops[i].cm.curOp = null;
endOperations(group);
}
} | javascript | {
"resource": ""
} |
q65 | setScrollTop | train | function setScrollTop(cm, val) {
if (Math.abs(cm.doc.scrollTop - val) < 2) return;
cm.doc.scrollTop = val;
if (!gecko) updateDisplaySimple(cm, {top: val});
if (cm.display.scroller.scrollTop != val) cm.display.scroller.scrollTop = val;
cm.display.scrollbars.setScrollTop(val);
if (gecko) updateDisplaySimple(cm);
startWorker(cm, 100);
} | javascript | {
"resource": ""
} |
q66 | ensureCursorVisible | train | function ensureCursorVisible(cm) {
resolveScrollToPos(cm);
var cur = cm.getCursor(), from = cur, to = cur;
if (!cm.options.lineWrapping) {
from = cur.ch ? Pos(cur.line, cur.ch - 1) : cur;
to = Pos(cur.line, cur.ch + 1);
}
cm.curOp.scrollToPos = {from: from, to: to, margin: cm.options.cursorScrollMargin, isCursor: true};
} | javascript | {
"resource": ""
} |
q67 | takeToken | train | function takeToken(cm, pos, precise, asArray) {
function getObj(copy) {
return {start: stream.start, end: stream.pos,
string: stream.current(),
type: style || null,
state: copy ? copyState(doc.mode, state) : state};
}
var doc = cm.doc, mode = doc.mode, style;
pos = clipPos(doc, pos);
var line = getLine(doc, pos.line), state = getStateBefore(cm, pos.line, precise);
var stream = new StringStream(line.text, cm.options.tabSize), tokens;
if (asArray) tokens = [];
while ((asArray || stream.pos < pos.ch) && !stream.eol()) {
stream.start = stream.pos;
style = readToken(mode, stream, state);
if (asArray) tokens.push(getObj(true));
}
return asArray ? tokens : getObj();
} | javascript | {
"resource": ""
} |
q68 | buildLineContent | train | function buildLineContent(cm, lineView) {
// The padding-right forces the element to have a 'border', which
// is needed on Webkit to be able to get line-level bounding
// rectangles for it (in measureChar).
var content = elt("span", null, null, webkit ? "padding-right: .1px" : null);
var builder = {pre: elt("pre", [content]), content: content, col: 0, pos: 0, cm: cm};
lineView.measure = {};
// Iterate over the logical lines that make up this visual line.
for (var i = 0; i <= (lineView.rest ? lineView.rest.length : 0); i++) {
var line = i ? lineView.rest[i - 1] : lineView.line, order;
builder.pos = 0;
builder.addToken = buildToken;
// Optionally wire in some hacks into the token-rendering
// algorithm, to deal with browser quirks.
if ((ie || webkit) && cm.getOption("lineWrapping"))
builder.addToken = buildTokenSplitSpaces(builder.addToken);
if (hasBadBidiRects(cm.display.measure) && (order = getOrder(line)))
builder.addToken = buildTokenBadBidi(builder.addToken, order);
builder.map = [];
var allowFrontierUpdate = lineView != cm.display.externalMeasured && lineNo(line);
insertLineContent(line, builder, getLineStyles(cm, line, allowFrontierUpdate));
if (line.styleClasses) {
if (line.styleClasses.bgClass)
builder.bgClass = joinClasses(line.styleClasses.bgClass, builder.bgClass || "");
if (line.styleClasses.textClass)
builder.textClass = joinClasses(line.styleClasses.textClass, builder.textClass || "");
}
// Ensure at least a single node is present, for measuring.
if (builder.map.length == 0)
builder.map.push(0, 0, builder.content.appendChild(zeroWidthElement(cm.display.measure)));
// Store the map and a cache object for the current logical line
if (i == 0) {
lineView.measure.map = builder.map;
lineView.measure.cache = {};
} else {
(lineView.measure.maps || (lineView.measure.maps = [])).push(builder.map);
(lineView.measure.caches || (lineView.measure.caches = [])).push({});
}
}
// See issue #2901
if (webkit && /\bcm-tab\b/.test(builder.content.lastChild.className))
builder.content.className = "cm-tab-wrap-hack";
signal(cm, "renderLine", cm, lineView.line, builder.pre);
if (builder.pre.className)
builder.textClass = joinClasses(builder.pre.className, builder.textClass || "");
return builder;
} | javascript | {
"resource": ""
} |
q69 | buildToken | train | function buildToken(builder, text, style, startStyle, endStyle, title, css) {
if (!text) return;
var special = builder.cm.options.specialChars, mustWrap = false;
if (!special.test(text)) {
builder.col += text.length;
var content = document.createTextNode(text);
builder.map.push(builder.pos, builder.pos + text.length, content);
if (ie && ie_version < 9) mustWrap = true;
builder.pos += text.length;
} else {
var content = document.createDocumentFragment(), pos = 0;
while (true) {
special.lastIndex = pos;
var m = special.exec(text);
var skipped = m ? m.index - pos : text.length - pos;
if (skipped) {
var txt = document.createTextNode(text.slice(pos, pos + skipped));
if (ie && ie_version < 9) content.appendChild(elt("span", [txt]));
else content.appendChild(txt);
builder.map.push(builder.pos, builder.pos + skipped, txt);
builder.col += skipped;
builder.pos += skipped;
}
if (!m) break;
pos += skipped + 1;
if (m[0] == "\t") {
var tabSize = builder.cm.options.tabSize, tabWidth = tabSize - builder.col % tabSize;
var txt = content.appendChild(elt("span", spaceStr(tabWidth), "cm-tab"));
txt.setAttribute("role", "presentation");
builder.col += tabWidth;
} else {
var txt = builder.cm.options.specialCharPlaceholder(m[0]);
if (ie && ie_version < 9) content.appendChild(elt("span", [txt]));
else content.appendChild(txt);
builder.col += 1;
}
builder.map.push(builder.pos, builder.pos + 1, txt);
builder.pos++;
}
}
if (style || startStyle || endStyle || mustWrap || css) {
var fullStyle = style || "";
if (startStyle) fullStyle += startStyle;
if (endStyle) fullStyle += endStyle;
var token = elt("span", [content], fullStyle, css);
if (title) token.title = title;
return builder.content.appendChild(token);
}
builder.content.appendChild(content);
} | javascript | {
"resource": ""
} |
q70 | train | function(at, lines, height) {
this.height += height;
this.lines = this.lines.slice(0, at).concat(lines).concat(this.lines.slice(at));
for (var i = 0; i < lines.length; ++i) lines[i].parent = this;
} | javascript | {
"resource": ""
} |
|
q71 | clearSelectionEvents | train | function clearSelectionEvents(array) {
while (array.length) {
var last = lst(array);
if (last.ranges) array.pop();
else break;
}
} | javascript | {
"resource": ""
} |
q72 | train | function() {
// don't create more object URLs than needed
if (blob_changed || !object_url) {
object_url = get_URL().createObjectURL(blob);
}
if (target_view) {
target_view.location.href = object_url;
} else {
var new_tab = view.open(object_url, "_blank");
if (new_tab == undefined && typeof safari !== "undefined") {
//Apple do not allow window.open, see http://bit.ly/1kZffRI
view.location.href = object_url
}
}
filesaver.readyState = filesaver.DONE;
dispatch_all();
revoke(object_url);
} | javascript | {
"resource": ""
} |
|
q73 | DOMMouseMoveTracker | train | function DOMMouseMoveTracker(
onMove,
/*function*/ onMoveEnd,
/*DOMElement*/ domNode) {
this.$DOMMouseMoveTracker_isDragging = false;
this.$DOMMouseMoveTracker_animationFrameID = null;
this.$DOMMouseMoveTracker_domNode = domNode;
this.$DOMMouseMoveTracker_onMove = onMove;
this.$DOMMouseMoveTracker_onMoveEnd = onMoveEnd;
this.$DOMMouseMoveTracker_onMouseMove = this.$DOMMouseMoveTracker_onMouseMove.bind(this);
this.$DOMMouseMoveTracker_onMouseUp = this.$DOMMouseMoveTracker_onMouseUp.bind(this);
this.$DOMMouseMoveTracker_didMouseMove = this.$DOMMouseMoveTracker_didMouseMove.bind(this);
} | javascript | {
"resource": ""
} |
q74 | train | function(target, eventType, callback) {
if (target.addEventListener) {
target.addEventListener(eventType, callback, false);
return {
remove: function() {
target.removeEventListener(eventType, callback, false);
}
};
} else if (target.attachEvent) {
target.attachEvent('on' + eventType, callback);
return {
remove: function() {
target.detachEvent('on' + eventType, callback);
}
};
}
} | javascript | {
"resource": ""
} |
|
q75 | train | function(
/*number*/ combinedWidth,
/*number*/ leftOffset,
/*number*/ cellWidth,
/*?number*/ cellMinWidth,
/*?number*/ cellMaxWidth,
/*number|string*/ columnKey,
/*object*/ event) {
if (Locale.isRTL()) {
leftOffset = -leftOffset;
}
this.setState({
isColumnResizing: true,
columnResizingData: {
left: leftOffset + combinedWidth - cellWidth,
width: cellWidth,
minWidth: cellMinWidth,
maxWidth: cellMaxWidth,
initialEvent: {
clientX: event.clientX,
clientY: event.clientY,
preventDefault: emptyFunction
},
key: columnKey
}
});
} | javascript | {
"resource": ""
} |
|
q76 | forEachColumn | train | function forEachColumn(children, callback) {
React.Children.forEach(children, function(child) {
if (child.type === FixedDataTableColumnGroup.type) {
forEachColumn(child.props.children, callback);
} else if (child.type === FixedDataTableColumn.type) {
callback(child);
}
});
} | javascript | {
"resource": ""
} |
q77 | mapColumns | train | function mapColumns(children, callback) {
var newChildren = [];
React.Children.forEach(children, function(originalChild) {
var newChild = originalChild;
// The child is either a column group or a column. If it is a column group
// we need to iterate over its columns and then potentially generate a
// new column group
if (originalChild.type === FixedDataTableColumnGroup.type) {
var haveColumnsChanged = false;
var newColumns = [];
forEachColumn(originalChild.props.children, function(originalcolumn) {
var newColumn = callback(originalcolumn);
if (newColumn !== originalcolumn) {
haveColumnsChanged = true;
}
newColumns.push(newColumn);
});
// If the column groups columns have changed clone the group and supply
// new children
if (haveColumnsChanged) {
newChild = cloneWithProps(originalChild, {children: newColumns});
}
} else if (originalChild.type === FixedDataTableColumn.type) {
newChild = callback(originalChild);
}
newChildren.push(newChild);
});
return newChildren;
} | javascript | {
"resource": ""
} |
q78 | FixedDataTableRowBuffer | train | function FixedDataTableRowBuffer(
rowsCount,
/*number*/ defaultRowHeight,
/*number*/ viewportHeight,
/*?function*/ rowHeightGetter)
{
invariant(
defaultRowHeight !== 0,
"defaultRowHeight musn't be equal 0 in FixedDataTableRowBuffer"
);
this.$FixedDataTableRowBuffer_bufferSet = new IntegerBufferSet();
this.$FixedDataTableRowBuffer_defaultRowHeight = defaultRowHeight;
this.$FixedDataTableRowBuffer_viewportRowsBegin = 0;
this.$FixedDataTableRowBuffer_viewportRowsEnd = 0;
this.$FixedDataTableRowBuffer_maxVisibleRowCount = Math.ceil(viewportHeight / defaultRowHeight) + 1;
this.$FixedDataTableRowBuffer_bufferRowsCount = clamp(
MIN_BUFFER_ROWS,
Math.floor(this.$FixedDataTableRowBuffer_maxVisibleRowCount/2),
MAX_BUFFER_ROWS
);
this.$FixedDataTableRowBuffer_rowsCount = rowsCount;
this.$FixedDataTableRowBuffer_rowHeightGetter = rowHeightGetter;
this.$FixedDataTableRowBuffer_rows = [];
this.$FixedDataTableRowBuffer_viewportHeight = viewportHeight;
this.getRows = this.getRows.bind(this);
this.getRowsWithUpdatedBuffer = this.getRowsWithUpdatedBuffer.bind(this);
} | javascript | {
"resource": ""
} |
q79 | cx | train | function cx(classNames) {
var classNamesArray;
if (typeof classNames == 'object') {
classNamesArray = Object.keys(classNames).filter(function(className) {
return classNames[className];
});
} else {
classNamesArray = Array.prototype.slice.call(arguments);
}
return classNamesArray.map(getClassName).join(' ');
} | javascript | {
"resource": ""
} |
q80 | train | function(obj) {
var ret = {};
var key;
invariant(
obj instanceof Object && !Array.isArray(obj),
'keyMirror(...): Argument must be an object.'
);
for (key in obj) {
if (!obj.hasOwnProperty(key)) {
continue;
}
ret[key] = key;
}
return ret;
} | javascript | {
"resource": ""
} |
|
q81 | shallowEqual | train | function shallowEqual(objA, objB) {
if (objA === objB) {
return true;
}
var key;
// Test for A's keys different from B.
for (key in objA) {
if (objA.hasOwnProperty(key) &&
(!objB.hasOwnProperty(key) || objA[key] !== objB[key])) {
return false;
}
}
// Test for B's keys missing from A.
for (key in objB) {
if (objB.hasOwnProperty(key) && !objA.hasOwnProperty(key)) {
return false;
}
}
return true;
} | javascript | {
"resource": ""
} |
q82 | train | function(a){var b;
// the final two arguments are the length, and the entire string itself;
// we don't care about those.
if(arguments.length<7)throw new Error("markup() must be called from String.prototype.replace()");return b=e.apply(null,arguments),'<span class="'+d[b]+'">'+a+"</span>"} | javascript | {
"resource": ""
} |
|
q83 | FakeEvent | train | function FakeEvent(type, bubbles, cancelable, target) {
this.initEvent(type, bubbles, cancelable, target);
} | javascript | {
"resource": ""
} |
q84 | padcomments | train | function padcomments(str, num) {
var nl = _str.repeat('\n', (num || 1));
return str.replace(/(\s*)(<!--.+)\s*(===.+)?/g, nl + '$1$2$1$3');
} | javascript | {
"resource": ""
} |
q85 | train | function(obj, cache) {
cache[obj.cid] = obj;
this.listenToOnce(obj, 'before-dispose', function() {
delete cache[obj.cid];
});
} | javascript | {
"resource": ""
} |
|
q86 | hotswap | train | function hotswap(currentNode, newNode, ignoreElements) {
var newNodeType = newNode.nodeType,
currentNodeType = currentNode.nodeType,
swapMethod;
if(newNodeType !== currentNodeType) {
$(currentNode).replaceWith(newNode);
} else {
swapMethod = swapMethods[newNodeType] || swapMethods['default'];
swapMethod(currentNode, newNode, ignoreElements);
}
} | javascript | {
"resource": ""
} |
q87 | cleanupStickitData | train | function cleanupStickitData(node) {
var $node = $(node);
var stickitValue = $node.data('stickit-bind-val');
if (node.tagName === 'OPTION' && node.value !== undefined && stickitValue !== node.value) {
$node.removeData('stickit-bind-val');
}
} | javascript | {
"resource": ""
} |
q88 | train | function($el, template, context, opts) {
var newDOM, newHTML,
el = $el.get(0);
opts = opts || {};
newHTML = opts.newHTML || template(context);
if (opts.force) {
$el.html(newHTML);
} else {
newDOM = this.copyTopElement(el);
$(newDOM).html(newHTML);
this.hotswapKeepCaret(el, newDOM, opts.ignoreElements);
}
} | javascript | {
"resource": ""
} |
|
q89 | train | function(currentNode, newNode, ignoreElements) {
var currentCaret, activeElement,
currentNodeContainsActiveElement = false;
try {
activeElement = document.activeElement;
} catch (error) {
activeElement = null;
}
if (activeElement && currentNode && $.contains(activeElement, currentNode)) {
currentNodeContainsActiveElement = true;
}
if (currentNodeContainsActiveElement && this.supportsSelection(activeElement)) {
currentCaret = this.getCaretPosition(activeElement);
}
this.hotswap(currentNode, newNode, ignoreElements);
if (currentNodeContainsActiveElement && this.supportsSelection(activeElement)) {
this.setCaretPosition(activeElement, currentCaret);
}
} | javascript | {
"resource": ""
} |
|
q90 | train | function(el) {
var newDOM = document.createElement(el.tagName);
_.each(el.attributes, function(attrib) {
newDOM.setAttribute(attrib.name, attrib.value);
});
return newDOM;
} | javascript | {
"resource": ""
} |
|
q91 | train | function(options) {
options = options || {};
options.idsToFetch = options.idsToFetch || this.trackedIds;
options.setOptions = options.setOptions || {remove: false};
return this.__loadWrapper(function() {
if (options.idsToFetch && options.idsToFetch.length) {
return parentInstance.fetchByIds(options);
} else {
return $.Deferred().resolve().promise();
}
});
} | javascript | {
"resource": ""
} |
|
q92 | train | function(ids, options) {
options = options || {};
options.idsToFetch = _.intersection(ids, this.getTrackedIds());
return this.fetch(options);
} | javascript | {
"resource": ""
} |
|
q93 | train | function(ids) {
this.remove(_.difference(this.trackedIds, ids));
parentInstance.registerIds(ids, ownerKey);
this.trackedIds = ids;
} | javascript | {
"resource": ""
} |
|
q94 | train | function(options) {
options = options || {};
//find ids that we don't have in cache and aren't already in the process of being fetched.
var idsNotInCache = _.difference(this.getTrackedIds(), _.pluck(parentInstance.models, 'id'));
var idsWithPromises = _.pick(parentInstance.idPromises, idsNotInCache);
// Determine which ids are already being fetched and the associated promises for those ids.
options.idsToFetch = _.difference(idsNotInCache, _.uniq(_.flatten(_.keys(idsWithPromises))));
var thisFetchPromise = this.fetch(options);
// Return a promise that resolves when all ids are fetched (including pending ids).
var allPromisesToWaitFor = _.flatten(_.values(idsWithPromises));
allPromisesToWaitFor.push(thisFetchPromise);
var allUniquePromisesToWaitFor = _.uniq(allPromisesToWaitFor);
return $.when.apply($, allUniquePromisesToWaitFor)
// Make it look like the multiple promises was performed by a single request.
.then(function() {
// collects the parts of each ajax call into arrays: result = { [data1, data2, ...], [textStatus1, textStatus2, ...], [jqXHR1, jqXHR2, ...] };
var result = _.zip(arguments);
// Flatten the data so it looks like the result of a single request.
var resultData = result[0];
var flattenedResultData = _.flatten(resultData);
return flattenedResultData;
});
} | javascript | {
"resource": ""
} |
|
q95 | train | function(modelIdentifier) {
var model = this.get(modelIdentifier);
parentClass.remove.apply(this, arguments);
if (model) {
var trackedIdsWithoutModel = this.getTrackedIds();
trackedIdsWithoutModel = _.without(trackedIdsWithoutModel, model.id);
this.trackIds(trackedIdsWithoutModel);
}
} | javascript | {
"resource": ""
} |
|
q96 | train | function(args) {
base.call(this, args);
this.loadedOnceDeferred = new $.Deferred();
this.loadedOnce = false;
this.loadingCount = 0;
// Loading is a convenience flag that is the equivalent of loadingCount > 0
this.loading = false;
} | javascript | {
"resource": ""
} |
|
q97 | train | function(fetchMethod, options) {
var object = this;
this.loadingCount++;
this.loading = true;
this.trigger('load-begin');
return $.when(fetchMethod.call(object, options)).always(function() {
if (!object.loadedOnce) {
object.loadedOnce = true;
object.loadedOnceDeferred.resolve();
}
object.loadingCount--;
if (object.loadingCount <= 0) {
object.loadingCount = 0; // prevent going negative.
object.loading = false;
}
}).done(function(data, textStatus, jqXHR) {
object.trigger('load-complete', {success: true, data: data, textStatus: textStatus, jqXHR: jqXHR});
}).fail(function(jqXHR, textStatus, errorThrown) {
object.trigger('load-complete', {success: false, jqXHR: jqXHR, textStatus: textStatus, errorThrown: errorThrown});
});
} | javascript | {
"resource": ""
} |
|
q98 | train | function(viewPrepare) {
var viewContext = viewPrepare() || {};
var behaviorContext = _.omit(this.toJSON(), 'view');
_.extend(behaviorContext, this.prepare());
viewContext[this.alias] = behaviorContext;
return viewContext;
} | javascript | {
"resource": ""
} |
|
q99 | train | function() {
this.listenTo(this.view, 'initialize:complete', this.__augmentViewPrepare);
this.listenTo(this.view, 'before-dispose-callback', this.__dispose);
_.each(eventMap, function(callback, event) {
this.listenTo(this.view, event, this[callback]);
}, this);
} | javascript | {
"resource": ""
} |