_id stringlengths 2 6 | title stringlengths 0 58 | partition stringclasses 3
values | text stringlengths 27 233k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q10100 | train | function (alphaCoordinates) {
var coordinateLabels = 'abcdefghijklmnopqrst';
var intersection = [];
intersection[0] | javascript | {
"resource": ""
} | |
q10101 | train | function (input, outputType, verbose) {
var output;
// If no output type has been specified, try to set it to the
// opposite of the input
if (typeof outputType === 'undefined') {
outputType = (typeof input === 'string') ? 'object' : 'string';
}
/**
* Turn a path object into a string.
*/... | javascript | {
"resource": ""
} | |
q10102 | stringify | train | function stringify(input) {
if (typeof input === 'string') {
return input;
}
if (!input) {
return '';
}
output = input.m;
var variations = [];
for (var key in input) {
if (input.hasOwnProperty(key) && key !== 'm') {
// Only show variations that are not the primary one... | javascript | {
"resource": ""
} |
q10103 | parse | train | function parse(input) {
if (typeof input === 'object') {
input = stringify(input);
}
if (!input) {
return { m: 0 };
}
var path = input.split('-');
output = {
m: Number(path.shift())
};
if (path.length) {
path.forEach(function (variation, i) { | javascript | {
"resource": ""
} |
q10104 | processArray | train | function processArray(req, res, nextarray) {
if (!nextarray || !nextarray.length)
return;
var proc = nextarray.shift();
| javascript | {
"resource": ""
} |
q10105 | path | train | function path(req) {
var oUrl = req.originalUrl || req.url; | javascript | {
"resource": ""
} |
q10106 | train | function(json){
// Protect against forgetting the new keyword when calling the constructor
if(!(this instanceof AtomCommon)){
return new AtomCommon(json);
}
// If the given object | javascript | {
"resource": ""
} | |
q10107 | findPort | train | function findPort(cb) {
var port = tryPort;
tryPort += 1;
var server = net.createServer();
server.listen(port, function(err) {
server.once('close', function() {
cb(port);
});
| javascript | {
"resource": ""
} |
q10108 | startServlet | train | function startServlet(cb) {
startingServer = true;
servletReady = false;
debugger;
findPort(function(port) {
servletPort = global._servletPort = '' + port;
servlet = global._servlet = cp.spawn('java', ['-cp', '.:../lib/servlet-api-2.5.jar:../lib/jetty-all-7.0.2.v20100331.jar', 'Runn... | javascript | {
"resource": ""
} |
q10109 | Partyflock | train | function Partyflock(consumerKey, consumerSecret, endpoint, debug) {
this.endpoint = 'partyflock.nl';
// Check instance arguments
this.endpoint = (endpoint ? endpoint : this.endpoint);
this.consumerKey = (consumerKey ? consumerKey : false);
this.consumerSecret = (consumerSecret ? consumerSecret : false);
thi... | javascript | {
"resource": ""
} |
q10110 | train | function(json){
// Protect against forgetting the new keyword when calling the constructor
if(!(this instanceof Coverage)){
return new Coverage(json);
}
// If the given object | javascript | {
"resource": ""
} | |
q10111 | train | function(resolution, latitude) {
var degs = metersToLongitudeDegrees(resolution, latitude);
return | javascript | {
"resource": ""
} | |
q10112 | train | function(coordinate,size) {
var latDeltaDegrees = size/g_METERS_PER_DEGREE_LATITUDE;
var latitudeNorth = Math.min(90, coordinate[0] + latDeltaDegrees);
var latitudeSouth = Math.max(-90, coordinate[0] - latDeltaDegrees);
| javascript | {
"resource": ""
} | |
q10113 | train | function(center, radius) {
var latDegrees = radius/g_METERS_PER_DEGREE_LATITUDE;
var latitudeNorth = Math.min(90, center[0] + latDegrees);
var latitudeSouth = Math.max(-90, center[0] - latDegrees);
var longDegsNorth = metersToLongitudeDegrees(radius, latitudeNorth);
var longDegsSouth = metersToLongitudeDegree... | javascript | {
"resource": ""
} | |
q10114 | train | function(geohash, bits) {
validateGeohash(geohash);
var precision = Math.ceil(bits/g_BITS_PER_CHAR);
if (geohash.length < precision) {
return [geohash, geohash+"~"];
}
geohash = geohash.substring(0, precision);
var base = geohash.substring(0, geohash.length - 1);
var lastValue = g_BASE32.indexOf(geoha... | javascript | {
"resource": ""
} | |
q10115 | reducer | train | function reducer(props, map, key) {
return Object.assign({}, map, {
| javascript | {
"resource": ""
} |
q10116 | Markdown | train | function Markdown(props) {
const tagProps = Object.keys(props).filter(filter).reduce(reducer.bind(null, props), {});
const parser = createParser(props.parser); | javascript | {
"resource": ""
} |
q10117 | HttpManager | train | function HttpManager(options) {
if (!(this instanceof HttpManager)) {
return new HttpManager(options);
}
options = options || {};
Manager.call(this, options);
debug('New HttpManager: %j', options);
this.hostname = options.hostname || null;
this.port | javascript | {
"resource": ""
} |
q10118 | train | function (newFilters, oldFilters) {
var self = this;
if (!oldFilters) {
oldFilters = this._filters;
} else if (!isArray(oldFilters)) {
oldFilters = [oldFilters];
}
if (!newFilters) {
| javascript | {
"resource": ""
} | |
q10119 | train | function (query, indexName) {
var model = this.collection.get(query, indexName);
| javascript | {
"resource": ""
} | |
q10120 | train | function (query, indexName) {
if (!query) return;
var index = this._indexes[indexName || this.mainIndex];
| javascript | {
"resource": ""
} | |
q10121 | train | function (model, options, eventName) {
var newModels = slice.call(this.models);
var comparator = this.comparator || this.collection.comparator;
//Whether or not we are to expect a sort event from our collection later
var sortable = eventName === 'add' && this.collection.comparator && (op... | javascript | {
"resource": ""
} | |
q10122 | train | function (model) {
var newModels = slice.call(this.models);
var modelIndex = newModels.indexOf(model);
if (modelIndex > -1) {
newModels.splice(modelIndex, 1);
this.models = newModels;
| javascript | {
"resource": ""
} | |
q10123 | train | function () {
// make a copy of the array for comparisons
var existingModels = slice.call(this.models);
var rootModels = slice.call(this.collection.models);
var newIndexes = {};
var newModels, toAdd, toRemove;
this._resetIndexes(newIndexes);
// reduce base model... | javascript | {
"resource": ""
} | |
q10124 | train | function(json){
// Protect against forgetting the new keyword when calling the constructor
if(!(this instanceof NameForm)){
return new NameForm(json);
}
// If the given object | javascript | {
"resource": ""
} | |
q10125 | train | function(callback){
ubeacon.getMeshSettingsRegisterObject( function(data, error){
if( error === null ){
meshSettings.setFrom( data );
console.log( 'meshSettings: ', meshSettings );
if( meshSettings.enabled !== true && program.enableMesh !== true ){
return callbac... | javascript | {
"resource": ""
} | |
q10126 | train | function(callback){
ubeacon.getMeshDeviceId( function( deviceAddress ){
console.log( '[ubeacon] Device address is: ' + deviceAddress + ' | javascript | {
"resource": ""
} | |
q10127 | train | function(callback){
console.log( 'Start sending messages... ');
setInterval(function(){
var msg = '';
if( program.message != null ){
msg = program.message;
}else{
msgCounter++;
msg = 'Hello #' + msgCounter + ' | javascript | {
"resource": ""
} | |
q10128 | columns | train | function columns(column) {
if (!column) {
return this;
}
this._statements.push({
| javascript | {
"resource": ""
} |
q10129 | distinct | train | function distinct() {
this._statements.push({
grouping: 'columns', | javascript | {
"resource": ""
} |
q10130 | _objectWhere | train | function _objectWhere(obj) {
var boolVal = this._bool();
var notVal = this._not() ? 'Not' : '';
for (var key in obj) {
| javascript | {
"resource": ""
} |
q10131 | havingWrapped | train | function havingWrapped(callback) {
this._statements.push({
grouping: 'having', | javascript | {
"resource": ""
} |
q10132 | whereExists | train | function whereExists(callback) {
this._statements.push({
grouping: 'where',
type: 'whereExists',
value: callback,
| javascript | {
"resource": ""
} |
q10133 | whereIn | train | function whereIn(column, values) {
if (Array.isArray(values) && isEmpty(values)) {
return this.where(this._not());
}
this._statements.push({
grouping: 'where',
| javascript | {
"resource": ""
} |
q10134 | whereNull | train | function whereNull(column) {
this._statements.push({
grouping: 'where',
type: 'whereNull',
column: column,
| javascript | {
"resource": ""
} |
q10135 | whereBetween | train | function whereBetween(column, values) {
assert(Array.isArray(values), 'The second argument to whereBetween must be an array.');
assert(values.length === 2, 'You must specify 2 values for the whereBetween clause');
this._statements.push({
| javascript | {
"resource": ""
} |
q10136 | groupBy | train | function groupBy(item) {
if (item instanceof Raw) {
return this.groupByRaw.apply(this, arguments);
}
this._statements.push({
grouping: 'group',
| javascript | {
"resource": ""
} |
q10137 | groupByRaw | train | function groupByRaw(sql, bindings) {
var raw = sql instanceof Raw ? sql : this.client.raw(sql, bindings); | javascript | {
"resource": ""
} |
q10138 | orderBy | train | function orderBy(column, direction) {
this._statements.push({
grouping: 'order', | javascript | {
"resource": ""
} |
q10139 | union | train | function union(callbacks, wrap) {
if (arguments.length === 1 || arguments.length === 2 && typeof wrap === 'boolean') {
if (!Array.isArray(callbacks)) {
callbacks = [callbacks];
}
for (var i = 0, l = callbacks.length; i < l; i++) {
this._statements.push({
grouping: 'union'... | javascript | {
"resource": ""
} |
q10140 | unionAll | train | function unionAll(callback, wrap) {
this._statements.push({
grouping: 'union', | javascript | {
"resource": ""
} |
q10141 | having | train | function having(column, operator, value) {
if (column instanceof Raw && arguments.length === 1) {
return this._havingRaw(column);
}
// Check if the column is a function, in which case it's
// a having statement wrapped in parens.
if (typeof column === 'function') {
return this.havingWra... | javascript | {
"resource": ""
} |
q10142 | _havingRaw | train | function _havingRaw(sql, bindings) {
var raw = sql instanceof Raw ? sql : this.client.raw(sql, bindings);
this._statements.push({
grouping: 'having',
| javascript | {
"resource": ""
} |
q10143 | limit | train | function limit(value) {
var val = parseInt(value, 10);
if (isNaN(val)) {
| javascript | {
"resource": ""
} |
q10144 | pluck | train | function pluck(column) {
this._method = 'pluck';
this._single.pluck = column;
this._statements.push({
grouping: 'columns',
| javascript | {
"resource": ""
} |
q10145 | fromJS | train | function fromJS(obj) {
Object.keys(obj).forEach(function (key) {
var val = obj[key];
if (typeof this[key] !== 'function') {
debug('Knex Error: unknown key ' + key);
}
if (Array.isArray(val)) {
| javascript | {
"resource": ""
} |
q10146 | _bool | train | function _bool(val) {
if (arguments.length === 1) {
this._boolFlag = val;
return this;
}
| javascript | {
"resource": ""
} |
q10147 | _not | train | function _not(val) {
if (arguments.length === 1) {
this._notFlag = val;
return this;
}
| javascript | {
"resource": ""
} |
q10148 | _joinType | train | function _joinType(val) {
if (arguments.length === 1) {
this._joinFlag = val;
return this;
}
| javascript | {
"resource": ""
} |
q10149 | _aggregate | train | function _aggregate(method, column) {
this._statements.push({
grouping: 'columns', | javascript | {
"resource": ""
} |
q10150 | train | function(json){
// Protect against forgetting the new keyword when calling the constructor
if(!(this instanceof ExtensibleData)){
return new ExtensibleData(json);
}
// If the given object is | javascript | {
"resource": ""
} | |
q10151 | generateKeyPairs | train | function generateKeyPairs () {
AnvilConnectKeys.generateKeyPair(this.sig.pub, | javascript | {
"resource": ""
} |
q10152 | generateKeyPair | train | function generateKeyPair (pub, prv) {
try {
mkdirp.sync(path.dirname(pub))
mkdirp.sync(path.dirname(prv))
childProcess.execFileSync('openssl', [
'genrsa',
'-out',
prv,
'4096'
], {
stdio: 'ignore'
})
childProcess.execFileSync('openssl', [
'rsa',
'-pub... | javascript | {
"resource": ""
} |
q10153 | loadKeyPairs | train | function loadKeyPairs () {
var sig = AnvilConnectKeys.loadKeyPair(this.sig.pub, this.sig.prv, 'sig')
var enc = AnvilConnectKeys.loadKeyPair(this.enc.pub, this.enc.prv, 'enc')
var jwkKeys = [] | javascript | {
"resource": ""
} |
q10154 | loadKeyPair | train | function loadKeyPair (pub, prv, use) {
var pubPEM, prvPEM, pubJWK
try {
pubPEM = fs.readFileSync(pub).toString('ascii')
} catch (e) {
throw new Error('Unable to read the public key from ' + pub)
}
try {
prvPEM = fs.readFileSync(prv).toString('ascii')
} catch (e) {
throw new Error('Unable t... | javascript | {
"resource": ""
} |
q10155 | generateSetupToken | train | function generateSetupToken (tokenPath) {
mkdirp.sync(path.dirname(tokenPath))
var token = crypto.randomBytes(256).toString('hex')
| javascript | {
"resource": ""
} |
q10156 | Transformer | train | function Transformer( file, res ) {
stream.Transform.call( this );
this.file = file; | javascript | {
"resource": ""
} |
q10157 | train | function(src, skipBlanck) {
var tokens = [],
cells, cap;
while (src) {
cells = [];
while (cap = cellDelimitter.exec(src)) {
src = src.substring(cap[0].length);
cells.push(cap[1]);
}
if (cells.length || !skipBlanck) | javascript | {
"resource": ""
} | |
q10158 | defaultInstructions | train | function defaultInstructions (format) {
// start with empty instructions
let instructions = emptyInstructions('_defaults', format);
// extend with the default recipe, if it exists for the target extension
| javascript | {
"resource": ""
} |
q10159 | isTemplate | train | function isTemplate (file, format) {
const { prefix, ext } = splitFormat(format);
return formatMap[ext]
.map(e | javascript | {
"resource": ""
} |
q10160 | LinkedInTokenStrategy | train | function LinkedInTokenStrategy(options, verify) {
options = options || {};
options.requestTokenURL = options.requestTokenURL || 'https://api.linkedin.com/uas/oauth/requestToken';
options.accessTokenURL = options.accessTokenURL || 'https://api.linkedin.com/uas/oauth/accessToken';
options.userAuthorizationURL = o... | javascript | {
"resource": ""
} |
q10161 | train | function(json){
// Protect against forgetting the new keyword when calling the constructor
if(!(this instanceof PlaceDescription)){
return new PlaceDescription(json);
}
// If the given object is | javascript | {
"resource": ""
} | |
q10162 | createImportError | train | function createImportError(rule) {
var url = rule.import ? rule.import.replace(/\r?\n/g, '\\n') : '<no url>';
var err = ['Bad import url: @import ' + url];
if (rule.position) {
err.push(' starting at line ' + rule.position.start.line + ' column ' + rule.position.start.column);
err.push(' ending | javascript | {
"resource": ""
} |
q10163 | read | train | function read(file, opts) {
var encoding = opts.encoding || 'utf8';
var | javascript | {
"resource": ""
} |
q10164 | train | function (attributes, options) {
var AttrCollection = Backgrid.Extension.AdvancedFilter.AttributeFilterCollection;
if (attributes.attributeFilters !== undefined && !(attributes.attributeFilters instanceof AttrCollection)) {
| javascript | {
"resource": ""
} | |
q10165 | train | function (style, exportAsString) {
var self = this;
var result;
switch (style) {
case "mongo":
case "mongodb":
default:
var mongoParser = new Backgrid.Extension.AdvancedFilter.FilterParsers.MongoParser();
| javascript | {
"resource": ""
} | |
q10166 | train | function() {
var self = this;
self.newFilterCount += 1;
if (self.length === 0) {
return self.newFilterCount;
}
else {
var newFilterName = self.newFilterName.replace(self.filterNamePartial, "");
var results = self.filter(function(fm) {
return fm.get("name").indexOf(newFilte... | javascript | {
"resource": ""
} | |
q10167 | train | function (username, password, callback) {
var request;
var promise;
// Preemptively validate username and password
if (!username) {
throw new Error('Invalid credentials. Missing username.');
}
if (!password) {
throw new Error('Invalid credentials. Missing password.');
}
/... | javascript | {
"resource": ""
} | |
q10168 | train | function (callback) {
var promise = this.request({
method: 'delete',
url: 'users/authenticate'
}).then(this.authorize.bind(this));
if (callback) {
| javascript | {
"resource": ""
} | |
q10169 | train | function (settings) {
this.key = settings && settings.key;
this.userId | javascript | {
"resource": ""
} | |
q10170 | generateFileHashes | train | function generateFileHashes(options, files) {
if (options.verbose) {
_utils.logger.info('Generating files hash...');
}
if (files.length === 0) _utils.logger.info('No files found!');else if (options.verbose) {
_utils.logger.info('Files found: ');
var _iteratorNormalCompletion = true;
... | javascript | {
"resource": ""
} |
q10171 | makeHttpRequests | train | function makeHttpRequests(options, fileHashes) {
if (options.verbose) {
_utils.logger.info('Performing HTTP requests...');
}
var promises = [];
var _iteratorNormalCompletion4 = true;
var _didIteratorError4 = false;
var _iteratorError4 = undefined;
try {
for (var _iterator4 =... | javascript | {
"resource": ""
} |
q10172 | parseHttpResponse | train | function parseHttpResponse(options, filesWithHash) {
if (options.verbose) {
_utils.logger.info('Parsing HTTP responses...');
}
var promises = [];
var _iteratorNormalCompletion5 = true;
var _didIteratorError5 = false;
var _iteratorError5 = undefined;
try {
for (var _iterator5... | javascript | {
"resource": ""
} |
q10173 | parseObjectArrayField | train | function parseObjectArrayField(row, key, value) {
var obj_array = [];
if (value) {
if (value.indexOf(',') !== -1) {
obj_array = value.split(',');
} else {
obj_array.push(value.toString());
};
};
// if (typeof(value) === 'string' && value.indexOf(',') !=... | javascript | {
"resource": ""
} |
q10174 | parseBasicArrayField | train | function parseBasicArrayField(field, key, array) {
var basic_array;
if (typeof array === "string") {
basic_array = array.split(arraySeparator);
} else {
basic_array = [];
basic_array.push(array);
};
var result = [];
if (isNumberArray(basic_array)) {
basic_array.... | javascript | {
"resource": ""
} |
q10175 | isBoolean | train | function isBoolean(value) {
if (typeof(value) == "undefined") {
return false;
}
if (typeof value === 'boolean') {
return true;
| javascript | {
"resource": ""
} |
q10176 | isDateType | train | function isDateType(value) {
if (value) {
var str = value.toString();
return moment(new Date(value), "YYYY-M-D", true).isValid() || moment(value, "YYYY-M-D H:m:s", true).isValid() || moment(value, "YYYY/M/D | javascript | {
"resource": ""
} |
q10177 | domator | train | function domator() {
for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {
| javascript | {
"resource": ""
} |
q10178 | train | function(json){
// Protect against forgetting the new keyword when calling the constructor
if(!(this instanceof Subject)){
return new Subject(json);
}
// If the given | javascript | {
"resource": ""
} | |
q10179 | train | function(json){
// Protect against forgetting the new keyword when calling the constructor
if(!(this instanceof Document)){
return new Document(json);
}
// If the given object | javascript | {
"resource": ""
} | |
q10180 | train | function(json){
// Protect against forgetting the new keyword when calling the constructor
if(!(this instanceof FieldValue)){
return new FieldValue(json);
}
// | javascript | {
"resource": ""
} | |
q10181 | train | function(json){
// Protect against forgetting the new keyword when calling the constructor
if(!(this instanceof Name)){
return new Name(json);
}
// If the given | javascript | {
"resource": ""
} | |
q10182 | train | function(handler) {
if (typeof accessToken == 'undefined') {
var body = {
client_id: clientId,
client_secret: clientSecret,
username: username,
password: password,
grant_type: 'password'
};
if (t... | javascript | {
"resource": ""
} | |
q10183 | parse | train | function parse (argv, opts, target) {
if ('string' === typeof argv) argv = argv.split(rSplit).filter(ignore);
if (!opts) opts = {};
opts[don] = true;
var parsed = parseArray(argv, opts);
opts[don] = false;
var through = parsed[don].length ? parseArray(parsed[don], opts) : null;
if (!target) target ... | javascript | {
"resource": ""
} |
q10184 | train | function(json){
// Protect against forgetting the new keyword when calling the constructor
if(!(this instanceof Link)){
return new Link(json);
}
| javascript | {
"resource": ""
} | |
q10185 | train | function(category, name, desc) {
if(used[name]) return;
used[name]= 1;
if(!items[category]) items[category] = [];
| javascript | {
"resource": ""
} | |
q10186 | train | function(json){
// Protect against forgetting the new keyword when calling the constructor
if(!(this instanceof FamilyView)){
return new FamilyView(json);
}
// | javascript | {
"resource": ""
} | |
q10187 | repeat | train | function repeat(string, times) {
var result = ""
// Optimized repeat function concatenates concatenated
// strings.
while (times > 0) {
| javascript | {
"resource": ""
} |
q10188 | endpointWithAlias | train | function endpointWithAlias(path, aliasPath) {
return function () {
endpoint(path)();
| javascript | {
"resource": ""
} |
q10189 | extendingEndpoints | train | function extendingEndpoints() {
var segments = Array.prototype.slice.call(arguments, 0);
return function () {
var path = '';
segments.forEach(function (pathSegment) {
path = path | javascript | {
"resource": ""
} |
q10190 | subEndpoints | train | function subEndpoints(prefix, suffixes) {
return function () {
Array.prototype.forEach.call(suffixes, function (suffix) {
var path = prefix + suffix;
| javascript | {
"resource": ""
} |
q10191 | badRequestEndpoint | train | function badRequestEndpoint(path, query, body) {
return function () {
body = body || | javascript | {
"resource": ""
} |
q10192 | createEndpointFromPath | train | function createEndpointFromPath(path, query, filePath) {
filePath | javascript | {
"resource": ""
} |
q10193 | createEndpointFromObject | train | function createEndpointFromObject(path, query, body) {
// OPTIONS gives server permission to use CORS
server.createRoute({
request: {
url: path,
query: query || {},
method: 'options',
},
response: {
code: 200,
delay: config.latency,
body: {},
heade... | javascript | {
"resource": ""
} |
q10194 | train | function(json){
// Protect against forgetting the new keyword when calling the constructor
if(!(this instanceof OnlineAccount)){
return new OnlineAccount(json);
}
// If the given object is | javascript | {
"resource": ""
} | |
q10195 | toSQL | train | function toSQL(method) {
method = method || this.method;
var val = this[method]();
var defaults = {
method: method,
options: assign({}, this.options),
bindings: this.formatter.bindings
};
if (typeof val === 'string') {
val = { sql: val };
}
| javascript | {
"resource": ""
} |
q10196 | select | train | function select() {
var i = -1,
statements = [];
while (++i < components.length) {
statements.push(this[components[i]](this));
}
return | javascript | {
"resource": ""
} |
q10197 | update | train | function update() {
var updateData = this._prepUpdate(this.single.update);
var wheres = this.where();
var returning = this.single.returning;
return {
sql: 'update ' + this.tableName + | javascript | {
"resource": ""
} |
q10198 | _columns | train | function _columns() {
var distinct = false;
if (this.onlyUnions()) {
return '';
}
var columns = this.grouped.columns || [];
var i = -1,
sql = [];
if (columns) {
while (++i < columns.length) {
var stmt = columns[i];
if (stmt.distinct) {
distinct = tru... | javascript | {
"resource": ""
} |
q10199 | _join | train | function _join() {
var sql = '',
i = -1,
joins = this.grouped.join;
if (!joins) {
return '';
}
while (++i < joins.length) {
var join = joins[i];
if (i > 0) {
sql += ' ';
}
if (join.joinType === 'raw') {
sql += this.formatter.unwrapRaw(join.ta... | javascript | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.