mahdijnt/AImoney
Updated
•
1
Dataset Viewer
_id
stringlengths 2
6
| title
stringlengths 0
58
| partition
stringclasses 3
values | text
stringlengths 27
233k
| language
stringclasses 1
value | meta_information
dict |
|---|---|---|---|---|---|
q0
|
train
|
function (state, action) {
return _.defaults({
|
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
|
javascript
|
{
"resource": ""
}
|
q2
|
inRange
|
train
|
function inRange (value, min, max) {
const int = parseInt(value, 10)
return (
|
javascript
|
{
"resource": ""
}
|
q3
|
markdown
|
train
|
function markdown(options) {
return new Remarkable(extend({
breaks: false,
html: true,
langPrefix: 'lang-',
linkify: true,
|
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');
|
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)) {
|
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
|
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
|
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 {
|
javascript
|
{
"resource": ""
}
|
q9
|
_guardPromiseAll
|
train
|
function _guardPromiseAll (promises, all, callback) {
if (promises.length ===
|
javascript
|
{
"resource": ""
}
|
q10
|
getPropertyOrder
|
train
|
function getPropertyOrder (properties) {
const primitiveProps = []
const complexProps = []
_.forIn(properties, (prop, propName) => {
if (prop.type === 'object' || prop.type === 'array') {
|
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
|
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({
|
javascript
|
{
"resource": ""
}
|
q13
|
appendModelPath
|
train
|
function appendModelPath (modelPath, id, internal) {
const addedModelPath = getModelPath(id)
if (internal) {
if (modelPath === '') {
return `properties._internal.${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
|
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 =
|
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,
|
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
|
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) :
|
javascript
|
{
"resource": ""
}
|
q19
|
expandModel
|
train
|
function expandModel (model, view) {
const modelPath = new BunsenModelPath(model)
const modelExpansions = aggregateModels(view, modelPath)
let newModel = model
|
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
|
javascript
|
{
"resource": ""
}
|
q21
|
html
|
train
|
function html(req, res) {
fs.readFile(path.join(__dirname, 'index.html'), function read(err, 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'));
|
javascript
|
{
"resource": ""
}
|
q23
|
convertObjectCell
|
train
|
function convertObjectCell (cell) {
return _.chain(cell.rows)
.map(rowsToCells)
|
javascript
|
{
"resource": ""
}
|
q24
|
convertArrayCell
|
train
|
function convertArrayCell (cell) {
const {item} = cell
const arrayOptions = _.chain(item)
.pick(ARRAY_CELL_PROPERTIES)
.assign({
itemCell: convertCell(item)
|
javascript
|
{
"resource": ""
}
|
q25
|
convertRenderer
|
train
|
function convertRenderer (cell) {
const {renderer} = cell
if (renderer === undefined) {
return
}
const basicRenderers = [
'boolean',
'string',
'number'
|
javascript
|
{
"resource": ""
}
|
q26
|
grabClassNames
|
train
|
function grabClassNames (cell) {
const classNames = _.pickBy({
cell: cell.className,
value: cell.inputClassName,
|
javascript
|
{
"resource": ""
}
|
q27
|
rowsToCells
|
train
|
function rowsToCells (rows) {
if (!rows) {
return {}
}
const children = rows
.map((row) => {
return {
|
javascript
|
{
"resource": ""
}
|
q28
|
warning
|
train
|
function warning(lines) {
lines.unshift(''); // Extra whitespace at the start.
lines.push('');
|
javascript
|
{
"resource": ""
}
|
q29
|
viewBox
|
train
|
function viewBox(details) {
svg.viewBox = `${details.x || 0} ${details.y ||
|
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
|
javascript
|
{
"resource": ""
}
|
|
q31
|
getWebpackRunnableLambda
|
train
|
function getWebpackRunnableLambda(slsWebpack, stats, functionName) {
const handler = slsWebpack.loadHandler(stats,
|
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) {
|
javascript
|
{
"resource": ""
}
|
q33
|
getColor
|
train
|
function getColor (i) {
i = parseInt(i);
if (i < 0 || i >= colors.length) {
// pick a color from
|
javascript
|
{
"resource": ""
}
|
q34
|
init
|
train
|
function init(loader) {
var loaderConfig = loaderUtils.getLoaderConfig(loader, 'web3Loader');
web3 =
|
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
|
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,
|
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: [],
|
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
|
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;
}
|
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);
|
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);
|
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 =
|
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;
|
javascript
|
{
"resource": ""
}
|
q44
|
sendError
|
train
|
function sendError(res,err) {
console.error(err);
// also log last executed query, for easier debugging
console.error(lastQry.sql);
|
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
|
javascript
|
{
"resource": ""
}
|
q46
|
checkRateRange
|
train
|
function checkRateRange(num) {
var numString = num.substring(0, num.length - 1);
var parseNum = parseInt(numString);
if (parseNum < 20) {
|
javascript
|
{
"resource": ""
}
|
q47
|
isInList
|
train
|
function isInList(value, listOfValues, msg) {
value = value.toLowerCase().trim();
|
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;
|
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];
|
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)])
|
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)))
|
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)
|
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();
|
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
|
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);
|
javascript
|
{
"resource": ""
}
|
q56
|
updateWidgetHeight
|
train
|
function updateWidgetHeight(line) {
if (line.widgets) for (var i = 0; i < line.widgets.length; ++i)
|
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)
|
javascript
|
{
"resource": ""
}
|
q58
|
extendSelection
|
train
|
function extendSelection(doc, head, other, options) {
setSelection(doc, new Selection([extendRange(doc,
|
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 =
|
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
|
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 =
|
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,
|
javascript
|
{
"resource": ""
}
|
q63
|
charWidth
|
train
|
function charWidth(display) {
if (display.cachedCharWidth != null) return display.cachedCharWidth;
var anchor = elt("span", "xxxxxxxxxx");
var pre =
|
javascript
|
{
"resource": ""
}
|
q64
|
endOperation
|
train
|
function endOperation(cm) {
var op = cm.curOp, group = op.ownsGroup;
if (!group) return;
try { fireCallbacksForOps(group); }
finally {
operationGroup = null;
|
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:
|
javascript
|
{
"resource": ""
}
|
q66
|
ensureCursorVisible
|
train
|
function ensureCursorVisible(cm) {
resolveScrollToPos(cm);
var cur = cm.getCursor(), from = cur, to = cur;
if (!cm.options.lineWrapping) {
|
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;
|
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)
|
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"));
|
javascript
|
{
"resource": ""
}
|
q70
|
train
|
function(at, lines, height) {
this.height += height;
this.lines = this.lines.slice(0,
|
javascript
|
{
"resource": ""
}
|
|
q71
|
clearSelectionEvents
|
train
|
function clearSelectionEvents(array) {
while (array.length) {
var last = lst(array);
if
|
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") {
|
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
|
javascript
|
{
"resource": ""
}
|
q74
|
train
|
function(target, eventType, callback) {
if (target.addEventListener) {
target.addEventListener(eventType, callback, false);
return {
remove: function() {
target.removeEventListener(eventType, callback, false);
|
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;
}
|
javascript
|
{
"resource": ""
}
|
|
q76
|
forEachColumn
|
train
|
function forEachColumn(children, callback) {
React.Children.forEach(children, function(child) {
if (child.type === FixedDataTableColumnGroup.type) {
forEachColumn(child.props.children,
|
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);
|
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,
|
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
|
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) {
|
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
|
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.
|
javascript
|
{
"resource": ""
}
|
|
q83
|
FakeEvent
|
train
|
function FakeEvent(type, bubbles, cancelable, target) {
|
javascript
|
{
"resource": ""
}
|
q84
|
padcomments
|
train
|
function padcomments(str, num) {
var nl = _str.repeat('\n',
|
javascript
|
{
"resource": ""
}
|
q85
|
train
|
function(obj, cache) {
cache[obj.cid] = obj;
this.listenToOnce(obj, 'before-dispose', function()
|
javascript
|
{
"resource": ""
}
|
|
q86
|
hotswap
|
train
|
function hotswap(currentNode, newNode, ignoreElements) {
var newNodeType = newNode.nodeType,
currentNodeType = currentNode.nodeType,
swapMethod;
if(newNodeType !== currentNodeType) {
$(currentNode).replaceWith(newNode);
|
javascript
|
{
"resource": ""
}
|
q87
|
cleanupStickitData
|
train
|
function cleanupStickitData(node) {
var $node = $(node);
var stickitValue = $node.data('stickit-bind-val');
if (node.tagName === 'OPTION' &&
|
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
|
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)) {
|
javascript
|
{
"resource": ""
}
|
|
q90
|
train
|
function(el) {
var newDOM = document.createElement(el.tagName);
_.each(el.attributes, function(attrib) {
|
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) {
|
javascript
|
{
"resource": ""
}
|
|
q92
|
train
|
function(ids, options) {
options = options || {};
options.idsToFetch = _.intersection(ids,
|
javascript
|
{
"resource": ""
}
|
|
q93
|
train
|
function(ids) {
this.remove(_.difference(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)
|
javascript
|
{
"resource": ""
}
|
|
q95
|
train
|
function(modelIdentifier) {
var model = this.get(modelIdentifier);
parentClass.remove.apply(this, arguments);
if (model) {
|
javascript
|
{
"resource": ""
}
|
|
q96
|
train
|
function(args) {
base.call(this, args);
this.loadedOnceDeferred = new $.Deferred();
this.loadedOnce = false;
this.loadingCount = 0;
|
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;
}
|
javascript
|
{
"resource": ""
}
|
|
q98
|
train
|
function(viewPrepare) {
var viewContext = viewPrepare() || {};
var behaviorContext = _.omit(this.toJSON(), 'view');
_.extend(behaviorContext, this.prepare());
|
javascript
|
{
"resource": ""
}
|
|
q99
|
train
|
function() {
this.listenTo(this.view, 'initialize:complete', this.__augmentViewPrepare);
this.listenTo(this.view, 'before-dispose-callback', this.__dispose);
_.each(eventMap,
|
javascript
|
{
"resource": ""
}
|
End of preview. Expand
in Data Studio
- Downloads last month
- 177
Size of downloaded dataset files:
21.3 MB
Size of the auto-converted Parquet files:
21.3 MB
Number of rows:
130,402
Models trained or fine-tuned on CoIR-Retrieval/CodeSearchNet-ccr-javascript-queries-corpus