_id stringlengths 2 6 | title stringlengths 0 58 | partition stringclasses 3 values | text stringlengths 52 373k | language stringclasses 1 value | meta_information dict |
|---|---|---|---|---|---|
q37900 | clear | train | function clear(options, cb) {
if (typeof options === 'function') { cb = options; options = {}; }
debug('clear ' + key);
connect();
redis.del(key, cb);
} | javascript | {
"resource": ""
} |
q37901 | runHelp | train | function runHelp(){
var messageHelp = "Usage: titanium-jsduck [command] [parameters]\n\n";
messageHelp += "Commands:\n\tinstall \n\t\t- Installs JSDuck inside a Titanium Mobile Project.";
messageHelp += "\n\topen \n\t\t- Opens Documentation in Safari Browser";
messageHelp += "\n\topen firefox \n\t\t- Opens Documentation in Firefox Browser";
messageHelp += "\n\topen chrome \n\t\t- Opens Documentation in Google Chrome Browser";
messageHelp += "\n\trun \n\t\t- Runs jsduck to generate Documentation without compiling Mobile Project";
console.log(messageHelp);
console.log();
console.log();
process.exit();
} | javascript | {
"resource": ""
} |
q37902 | file | train | function file( path, content ) {
try {
if ( typeof content === 'undefined' ) {
if ( !FS.existsSync( path ) ) return null;
return FS.readFileSync( path );
}
const dir = Path.dirname( path );
mkdir( dir );
FS.writeFileSync( path, content );
return content;
} catch ( ex ) {
console.warn( "content:", content );
throw new Error( `${ex}\n...in pathutils/file("${path}", ${typeof content})` );
}
} | javascript | {
"resource": ""
} |
q37903 | touch | train | function touch( path ) {
if ( FS.existsSync( path ) ) {
const content = FS.readFileSync( path );
FS.writeFileSync( path, content );
console.log( `File has been touched: ${path.yellow} (${(size(path) * BYTES_TO_KB).toFixed(1)} kb)` );
return true;
}
return false;
} | javascript | {
"resource": ""
} |
q37904 | invokeArrayArg | train | function invokeArrayArg(arg, fn, context) {
if (Array.isArray(arg)) {
arg.forEach(context[fn], context);
return true;
}
return false;
} | javascript | {
"resource": ""
} |
q37905 | prefixed | train | function prefixed(obj, property) {
var prefix;
var prop;
var camelProp = property[0].toUpperCase() + property.slice(1);
var i = 0;
while (i < VENDOR_PREFIXES.length) {
prefix = VENDOR_PREFIXES[i];
prop = (prefix) ? prefix + camelProp : property;
if (prop in obj) {
return prop;
}
i++;
}
return undefined;
} | javascript | {
"resource": ""
} |
q37906 | computeInputData | train | function computeInputData(manager, input) {
var session = manager.session;
var pointers = input.pointers;
var pointersLength = pointers.length;
// store the first input to calculate the distance and direction
if (!session.firstInput) {
session.firstInput = simpleCloneInputData(input);
}
// to compute scale and rotation we need to store the multiple touches
if (pointersLength > 1 && !session.firstMultiple) {
session.firstMultiple = simpleCloneInputData(input);
} else if (pointersLength === 1) {
session.firstMultiple = false;
}
var firstInput = session.firstInput;
var firstMultiple = session.firstMultiple;
var offsetCenter = firstMultiple ? firstMultiple.center : firstInput.center;
var center = input.center = getCenter(pointers);
input.timeStamp = now();
input.deltaTime = input.timeStamp - firstInput.timeStamp;
input.angle = getAngle(offsetCenter, center);
input.distance = getDistance(offsetCenter, center);
computeDeltaXY(session, input);
input.offsetDirection = getDirection(input.deltaX, input.deltaY);
input.scale = firstMultiple ? getScale(firstMultiple.pointers, pointers) : 1;
input.rotation = firstMultiple ? getRotation(firstMultiple.pointers, pointers) : 0;
computeIntervalInputData(session, input);
// find the correct target
var target = manager.element;
if (hasParent(input.srcEvent.target, target)) {
target = input.srcEvent.target;
}
input.target = target;
} | javascript | {
"resource": ""
} |
q37907 | getDirection | train | function getDirection(x, y) {
if (x === y) {
return DIRECTION_NONE;
}
if (abs(x) >= abs(y)) {
return x > 0 ? DIRECTION_LEFT : DIRECTION_RIGHT;
}
return y > 0 ? DIRECTION_UP : DIRECTION_DOWN;
} | javascript | {
"resource": ""
} |
q37908 | getDistance | train | function getDistance(p1, p2, props) {
if (!props) {
props = PROPS_XY;
}
var x = p2[props[0]] - p1[props[0]];
var y = p2[props[1]] - p1[props[1]];
return Math.sqrt((x * x) + (y * y));
} | javascript | {
"resource": ""
} |
q37909 | getRotation | train | function getRotation(start, end) {
return getAngle(end[1], end[0], PROPS_CLIENT_XY) - getAngle(start[1], start[0], PROPS_CLIENT_XY);
} | javascript | {
"resource": ""
} |
q37910 | TouchMouseInput | train | function TouchMouseInput() {
Input.apply(this, arguments);
var handler = this.handler.bind(this);
this.touch = new TouchInput(this.manager, handler);
this.mouse = new MouseInput(this.manager, handler);
} | javascript | {
"resource": ""
} |
q37911 | TMEhandler | train | function TMEhandler(manager, inputEvent, inputData) {
var isTouch = (inputData.pointerType == INPUT_TYPE_TOUCH);
var isMouse = (inputData.pointerType == INPUT_TYPE_MOUSE);
// when we're in a touch event, so block all upcoming mouse events
// most mobile browser also emit mouseevents, right after touchstart
if (isTouch) {
this.mouse.allow = false;
} else if (isMouse && !this.mouse.allow) {
return;
}
// reset the allowMouse when we're done
if (inputEvent & (INPUT_END | INPUT_CANCEL)) {
this.mouse.allow = true;
}
this.callback(manager, inputEvent, inputData);
} | javascript | {
"resource": ""
} |
q37912 | train | function (value) {
// find out the touch-action by the event handlers
if (value == TOUCH_ACTION_COMPUTE) {
value = this.compute();
}
if (NATIVE_TOUCH_ACTION) {
this.manager.element.style[PREFIXED_TOUCH_ACTION] = value;
}
this.actions = value.toLowerCase().trim();
} | javascript | {
"resource": ""
} | |
q37913 | train | function () {
var actions = [];
this.manager.recognizers.forEach(function (recognizer) {
if (boolOrFn(recognizer.options.enable, [recognizer])) {
actions = actions.concat(recognizer.getTouchAction());
}
});
return cleanTouchActions(actions.join(' '));
} | javascript | {
"resource": ""
} | |
q37914 | train | function (input) {
// not needed with native support for the touchAction property
if (NATIVE_TOUCH_ACTION) {
return;
}
var srcEvent = input.srcEvent;
var direction = input.offsetDirection;
// if the touch action did prevented once this session
if (this.manager.session.prevented) {
srcEvent.preventDefault();
return;
}
var actions = this.actions;
var hasNone = inStr(actions, TOUCH_ACTION_NONE);
var hasPanY = inStr(actions, TOUCH_ACTION_PAN_Y);
var hasPanX = inStr(actions, TOUCH_ACTION_PAN_X);
if (hasNone ||
(hasPanY && direction & DIRECTION_HORIZONTAL) ||
(hasPanX && direction & DIRECTION_VERTICAL)) {
return this.preventSrc(srcEvent);
}
} | javascript | {
"resource": ""
} | |
q37915 | Mallet | train | function Mallet(element, options) {
options = options || {};
options.recognizers = ifUndefined(options.recognizers, Mallet.defaults.preset);
return new Manager(element, options);
} | javascript | {
"resource": ""
} |
q37916 | train | function () {
'use strict';
// default options for pattern-importer
var options = {
environment: {
config: {
server: {
baseDir: './app'
},
host: 'localhost',
port: 8001,
debugInfo: false,
open: true
}
},
showConsoleLog: true,
dependencies: [] // gulp tasks which should be run before this task
};
return options;
} | javascript | {
"resource": ""
} | |
q37917 | BloomFilter | train | function BloomFilter()
{
core.AbstractFilter.call(this);
this.blurXFilter = new BlurXFilter();
this.blurYFilter = new BlurYFilter();
this.defaultFilter = new core.AbstractFilter();
} | javascript | {
"resource": ""
} |
q37918 | on | train | function on(ev, fn, context){
var arg = arguments;
var slice = [].slice;
var evs = ev.split(',');
var i = 0;
var evt = '';
var __fn = fn;
fn = function wrapOn(e){
context = context || this;
__fn.apply(context, [e].concat(slice.call(arg, 3)));
};
while(evs[i]){
evt = evs[i].replace(TRIM_REG, '');
if (evt) Events.prototype.on.call(this, evt, fn);
i++;
}
return fn;
} | javascript | {
"resource": ""
} |
q37919 | isSandhanganWyanjana | train | function isSandhanganWyanjana(position, input) {
var chr = input.charAt(position),
length = input.length,
prevChr = input.charAt(position - 1),
nextChr;
// pacar = false
if (position == length - 1) {
return false;
}
// paras = false
if (isSwara(prevChr)) {
return false;
}
// pra = true
// prahara = true
if (chr == 'r') {
nextChr = input.charAt(position + 1);
if (nextChr == 'a' || nextChr == 'e') {
return true;
}
return false;
} else if (chr == 'y') {
if (input.charAt(position + 1) == 'a') {
return true;
}
return false;
}
return false;
} | javascript | {
"resource": ""
} |
q37920 | isMovedError | train | function isMovedError(error) {
// Check if error message contains something like: "MOVED 14190 127.0.0.1:6379"
return !!isInstanceOf(error, ReplyError) && error.message && error.message.startsWith('MOVED ');
} | javascript | {
"resource": ""
} |
q37921 | resolveHostAndPortFromMovedError | train | function resolveHostAndPortFromMovedError(movedError) {
// Attempt to resolve the new host & port from the error message
if (isMovedError(movedError)) {
return movedError.message.substring(movedError.message.lastIndexOf(' ') + 1).split(':');
}
throw new Error(`Unexpected ioredis client "moved" ReplyError - ${movedError}`);
} | javascript | {
"resource": ""
} |
q37922 | train | function(name){
for (var i = 0, len = _pluginList.length ; i < len ; i++){
var plugin = _pluginList[i];
if (name === plugin.name) {
return true;
}
}
return false;
} | javascript | {
"resource": ""
} | |
q37923 | train | function(name, pa){
var pa = pa || name;
if (!this.isExist(name)){
var realPath = path.join(_pluginBase, pa, 'main.js');
var pluginReg;
if (!fs.existsSync(realPath)) {
pluginReg = require(pa);
} else {
pluginReg = require(fs.realpathSync(realPath));
}
_pluginList.push(new Plugin(name, pa, pluginReg));
pluginReg(PluginAPI);
}
} | javascript | {
"resource": ""
} | |
q37924 | train | function(name){
for (var i = 0, len = _pluginList.length ; i < len ; i++){
var plugin = _pluginList[i];
if (name === plugin.name) {
_pluginList.splice(i, 1);
return;
}
}
} | javascript | {
"resource": ""
} | |
q37925 | train | function(plugins, pluginBase){
var _this = this;
if (typeof pluginBase === 'string') {
_pluginBase = pluginBase;
}
plugins.forEach(function(plugin, index){
var name;
var path;
if (typeof plugin === 'string'){
name = plugin;
} else {
name = plugin.name;
path = plugin.path;
}
_this.register(name, plugin);
});
} | javascript | {
"resource": ""
} | |
q37926 | callbackOnce | train | function callbackOnce(err, arg) {
var cb = callback;
callback = null;
if (cb) { cb(err, arg); }
} | javascript | {
"resource": ""
} |
q37927 | createErrorHandler | train | function createErrorHandler(verb) {
return function(err) {
if (!callback) { return; }
grunt.verbose.error();
grunt.fail.warn("Failed to " + verb + ": " + err.message);
callbackOnce(err);
};
} | javascript | {
"resource": ""
} |
q37928 | getStyle | train | function getStyle(element, key, isComputed, isolateUnits) {
assertType(element, Node, false, 'Invalid element specified');
if (typeof isComputed !== 'boolean') isComputed = false;
if (typeof isolateUnits !== 'boolean') isolateUnits = false;
let value = (isComputed) ? window.getComputedStyle(element, null).getPropertyValue(key) : element.style[key];
let regex = new RegExp('^[+-]?[0-9]+.?([0-9]+)?(px|em|ex|%|in|cm|mm|pt|pc)$', 'i');
if (value === '') return (isolateUnits ? { value: null, unit: null } : null);
if (!isNaN(Number(value))) return (isolateUnits ? { value: Number(value), unit: null } : Number(value));
if (regex.test(value)) {
if (isolateUnits) {
if (value.charAt(value.length-1) === '%') return { value: Number(value.substr(0, value.length-1)), unit: value.slice(-1) };
return { value: Number(value.substr(0, value.length-2)), unit: value.slice(-2) };
}
else {
return value;
}
}
return (isolateUnits ? { value: value, units: null } : value);
} | javascript | {
"resource": ""
} |
q37929 | Embdr | train | function Embdr(key) {
if (!(this instanceof Embdr)) {
return new Embdr(key);
}
this._api = {
'auth': null,
'host': Embdr.DEFAULT_HOST,
'port': Embdr.DEFAULT_PORT,
'basePath': Embdr.DEFAULT_BASE_PATH,
'protocol': Embdr.DEFAULT_PROTOCOL
};
this.setApiKey(key);
this._exposeApis();
} | javascript | {
"resource": ""
} |
q37930 | train | function (a, b, c, d, e, ...args) {
return [a, b, c, d, e].concat(args);
} | javascript | {
"resource": ""
} | |
q37931 | flat | train | function flat(current, name, object, separator) {
var data = {}
// iterate object
for (var x in object) {
var key = [name, x].join(separator)
data[key] = object[x]
}
// iterate through data
for (var i in data) {
if (typeof data[i] !== "object") {
current[i] = data[i]
} else {
current = flat(current, i, data[i], separator)
}
}
// returning current value
return current
} | javascript | {
"resource": ""
} |
q37932 | train | function(data, pattern) {
var result = {}
// iterate thorough data
for (var i in data) {
// create context data
var _data = data[i]
// if key match with pattern
if (i.match(pattern)) {
// add matched data
result[i] = _data
}
// if value match with pattern
if (_data.toString().match(pattern)) {
result[i] = _data
}
}
// result
return result
} | javascript | {
"resource": ""
} | |
q37933 | VersionIterable | train | function VersionIterable(task) {
var _ref = arguments.length <= 1 || arguments[1] === undefined ? {} : arguments[1];
var name = _ref.name;
var _ref$range = _ref.range;
var range = _ref$range === undefined ? '*' : _ref$range;
var _ref$dir = _ref.dir;
var dir = _ref$dir === undefined ? '.' : _ref$dir;
var _ref$restore = _ref.restore;
var restore = _ref$restore === undefined ? true : _ref$restore;
_classCallCheck(this, VersionIterable);
_get(Object.getPrototypeOf(VersionIterable.prototype), 'constructor', this).call(this);
if (typeof task !== 'function') throw new TypeError('expects task as a function');
var versionFilter = typeof range === 'function' ? range : function (v) {
return (0, _semver.satisfies)(v, range);
};
var _url$parse = _url2['default'].parse(name);
var pathname = _url$parse.pathname;
if (_path2['default'].extname(pathname) == '.git') {
// check the name is kind of git repo url
var repoName = _path2['default'].basename(pathname, '.git');
this.name = repoName;
this.source = makeGitSource(repoName, name, /* passing url */versionFilter, dir, restore);
this.sourceName = 'git';
} else {
this.name = pathname;
this.source = makeNPMPackageSource(pathname, versionFilter, dir, restore);
this.sourceName = 'npm';
}
this.task = task;
} | javascript | {
"resource": ""
} |
q37934 | splatPoints | train | function splatPoints(out, points, weights, radius) {
doSplat(
points.hi(points.shape[0], 1),
ndarray(weights.data,
[weights.shape[0], 1],
[weights.stride[0], 0],
weights.offset),
out,
radius,
dirichlet)
} | javascript | {
"resource": ""
} |
q37935 | functionWrapperFunction | train | function functionWrapperFunction () {
// call original function - catching errors for logging
try {
var res = functionObj.apply(this, arguments)
}
catch (error) {
var err = error
}
// if log client then do logging
if (options.logClient) {
// get number of arguments
var argsLength = arguments.length
// copy of arguments
var args = []
// create copy of arguments
for (var i=0; i < argsLength; i++) {
args[i] = arguments[i]
}
// log call
options.logClient.log('functionCall', {
functionName: functionName,
args: args,
res: err || res,
isError: (err ? true : false),
moduleCallId: (this ? this.moduleCallId : undefined),
requestId: (this ? this.requestId : undefined),
})
}
// if result was an error then throw original error
if (err) {
throw err
}
// otherwise return original result
else {
return res
}
} | javascript | {
"resource": ""
} |
q37936 | train | function () {
'use strict';
// default options for doxx gulp task
var options = {
config: {
title: 'Project Title',
urlPrefix: null,
template: path.join(__dirname, '../templates/doxx.template.jade')
},
src: [
'!./node_modules/**/*',
'./**/*.js'
],
dest: './docs',
dependencies: [] // gulp tasks which should be run before this task
};
return options;
} | javascript | {
"resource": ""
} | |
q37937 | train | function(v, o) {
if (re.test(v)) {
o[k] = v; // Set params to be returned when matching
return true;
} else {
return false;
}
} | javascript | {
"resource": ""
} | |
q37938 | Widget | train | function Widget(options) {
this.__data = {};
try {
var e;
if (typeof options === 'undefined') options = {};
if (typeof options.innerHTML !== 'undefined' && typeof options.childNodes !== 'undefined') {
// On passe directement un élément.
options = {element: options};
}
if (typeof options.tag === 'undefined') options.tag = "div";
if (options.element) {
this.element(options.element);
} else if (typeof options.id !== 'undefined') {
e = window.document.getElementById(options.id);
if (!e) {
throw Error("Can't find element with id: \"" + options.id + "\"!");
}
this.element(e);
} else {
this.element(window.document.createElement(options.tag));
this.addClass("wdg", "custom");
}
}
catch (ex) {
console.error("[widget] ", ex);
console.error("[Widget] ", JSON.stringify(options));
throw Error(ex);
}
} | javascript | {
"resource": ""
} |
q37939 | train | function(v) {
if (v === undefined) return this._element;
if (typeof v === 'string') {
v = window.document.querySelector(v);
}
this._element = v;
return this;
} | javascript | {
"resource": ""
} | |
q37940 | train | function() {
var e = this._element;
if (e) {
var p = e.parentNode;
if (p) {
p.removeChild(e);
}
}
return this;
} | javascript | {
"resource": ""
} | |
q37941 | train | function() {
var i, arg;
for (i = 0 ; i < arguments.length ; i++) {
arg = arguments[i];
if (typeof arg === 'number') arg = "" + arg;
if (typeof arg === 'undefined' || typeof arg === 'null'
|| (typeof arg !== 'object' && typeof arg !== 'string')) {
console.error("[Widget.append] Argument #" + i + " is invalid!", arguments);
console.error("[Widget.append] Is type is: " + (typeof arg));
continue;
};
if (typeof arg === 'string') {
if (arg.length < 1) arg = " ";
arg = window.document.createTextNode(arg);
if (!arg) {
console.error(
"[Widget.append] Unable to create a text node with this text: ", arg
);
console.error("[wdg] arguments=...", arguments);
throw Error(
"[Widget.append] Unable to create a text node with this text: "
+ JSON.stringify(arg)
);
}
}
if (Array.isArray(arg)) {
arg.forEach(
function(item) {
this.append(item);
}, this
);
}
else {
var e = arg;
if( !(e instanceof Node) ) {
if( e.$ instanceof Node ) e = e.$;
else if( typeof e.element === 'function' ) e = e.element();
else if( e.element ) e = e.element;
}
this._element.appendChild(e);
}
}
return this;
} | javascript | {
"resource": ""
} | |
q37942 | train | function(parent) {
if (!parent) return this;
if (typeof parent.append === 'function') {
parent.append(this);
} else if (typeof parent.appendChild === 'function') {
parent.appendChild(this._element);
this.onAppend();
}
return this;
} | javascript | {
"resource": ""
} | |
q37943 | train | function() {
// (!) On préfère retirer les éléments un par un du DOM plutôt que d'utiliser simplement
// this.html("").
// En effet, le code simplifié a des conséquences inattendues dans IE9 et IE10 au moins.
// Le bug des markers qui disparaissaients sur les cartes de Trail-Passion 4 a été corrigé
// avec cette modification.
var e = this.element();
while(e.firstChild){
e.removeChild(e.firstChild);
}
var i, arg;
for (i = 0 ; i < arguments.length ; i++) {
arg = arguments[i];
this.append(arg);
}
return this;
} | javascript | {
"resource": ""
} | |
q37944 | train | function() {
var e = this._element;
if (!e) return null;
if (typeof e.getBoundingClientRect !== 'function') {
console.error("[wdg.rect] This element has non `getBoundingClientRect` function:", e);
}
var r = e.getBoundingClientRect();
if( typeof r.width === 'undefined' ) r.width = r.right - r.left;
if( typeof r.height === 'undefined' ) r.height = r.bottom - r.top;
return r;
} | javascript | {
"resource": ""
} | |
q37945 | revert | train | function revert(h, node) {
var subtype = node.referenceType
var suffix = ']'
var contents
var head
var tail
if (subtype === 'collapsed') {
suffix += '[]'
} else if (subtype === 'full') {
suffix += '[' + node.identifier + ']'
}
if (node.type === 'imageReference') {
return u('text', '![' + node.alt + suffix)
}
contents = all(h, node)
head = contents[0]
if (head && head.type === 'text') {
head.value = '[' + head.value
} else {
contents.unshift(u('text', '['))
}
tail = contents[contents.length - 1]
if (tail && tail.type === 'text') {
tail.value += suffix
} else {
contents.push(u('text', suffix))
}
return contents
} | javascript | {
"resource": ""
} |
q37946 | train | function(callback) {
// TODO: don't wait until the end. Instead, emit immediately upon finding the template
if (!templateFile) throw new Error('template not found in stream');
templateFile.data = templateFile.data || {};
files.forEach(function(file) {
var newFile = templateFile.clone();
newFile.data.file = file;
newFile.path = file.path;
this.push(newFile);
}, this);
callback();
} | javascript | {
"resource": ""
} | |
q37947 | registerSpecification | train | function registerSpecification(specification, remoteDN , options , callback){
// Serialize the capability Object
var post_data = {};
post_data[remoteDN] = JSON.parse(specification.to_dict());
post_data = JSON.stringify(post_data);
var proto = https;
var post_options = {
path: SUPERVISOR_PATH_REGISTER_SPECIFICATION,
method: 'POST',
host: options.host,
port: options.port,
followRedirect:false,
headers: {
'Content-Type': MIME_TYPE,
'Content-Length': Buffer.byteLength(post_data)
} ,
key: ssl_files.readFileContent(options.keyFile)
,cert: ssl_files.readFileContent(options.certFile)
,ca: ssl_files.readCaChain(options.caFile)
};
// Set up the request
var post_req = proto.request(post_options, function(res) {
var body = "";
res.setEncoding('utf8');
res.on('data', function (chunk) {
if (chunk)
body +=chunk;
});
res.on('end', function (chunk) {
if (chunk)
body +=chunk;
if (res.statusCode == 200){
// Send back the receipt
callback(null, body);
}else{
callback(new Error(res.statusCode), null);
}
});
});
// post the data
post_req.write(post_data);
post_req.end();
} | javascript | {
"resource": ""
} |
q37948 | showResults | train | function showResults(redeem , options , callback){
if (typeof redeem !== 'object')
redeem = new mplane.Redemption(redeem);
var post_data = redeem.to_dict();
var post_options = {
path: SUPERVISOR_PATH_SHOW_RESULT,
method: 'POST',
host: options.host,
port: options.port,
followRedirect:false,
headers: {
'Content-Type': MIME_TYPE,
'Content-Length': Buffer.byteLength(post_data)
}
};
post_options.ca = ssl_files.readCaChain(options.ca);
post_options.key = ssl_files.readFileContent(options.key);
post_options.cert = ssl_files.readFileContent(options.cert);
// Try to redeem the specification
var post_req = https.request(post_options, function(res) {
var bodyChunks=[];
res.on('data', function (chunk) {
bodyChunks.push(chunk);
}).on('end', function () {
body = Buffer.concat(bodyChunks);
if (res.statusCode != 200){
if (res.statusCode == 403){
callback(new Error(403),null);
return;
}else{
callback(new Error("Error from server"),null);//Wrong answer
return;
}
}
var result = mplane.from_dict(body);
callback(null,result);
});
});
post_req.on("error", function(err){
callback(err,null)
});
post_req.write(post_data);
post_req.end();
} | javascript | {
"resource": ""
} |
q37949 | showCapabilities | train | function showCapabilities( options, callback){
options.url = 'https://'+options.host+':'+options.port+SUPERVISOR_PATH_SHOW_CAPABILITY;
options.ca = ssl_files.readCaChain(options.caFile);
options.key = ssl_files.readFileContent(options.keyFile);
options.cert = ssl_files.readFileContent(options.certFile);
request(options, function (error, response, body) {
if (!error && (response.statusCode = 200)) {
var caps = (JSON.parse(body));
callback(null, caps);
}else{
console.log(error);
callback(new Error("Error connecting to the supervisor"), null);
}
});
} | javascript | {
"resource": ""
} |
q37950 | info | train | function info(options , callback){
options.url = 'https://'+options.host+':'+options.port+SUPERVISOR_PATH_INFO;
options.key = ssl_files.readFileContent(options.keyFile);
options.cert = ssl_files.readFileContent(options.certFile);
options.ca = ssl_files.readCaChain(options.ca);
request(options, function (error, response, body) {
if (!error && response.statusCode == 200) {
callback(null, JSON.parse(body));
}else{
callback(new Error("Error connecting to the supervisor:"+error.toString()) , null);
}
});
} | javascript | {
"resource": ""
} |
q37951 | genReq | train | function genReq (options,cb) {
log(options.verbose,"Starting twitreq ...");
if ( typeof options.protocol === "undefined" ) {
options.protocol = PROTOCOL;
}
if ( typeof options.host === "undefined" ) {
options.host = HOST;
}
if ( typeof options.oAuthSignatureMethod === "undefined" ) {
options.oAuthSignatureMethod = OAUTH_SIGNATURE_METHOD;
}
if ( options.oAuthSignatureMethod !== OAUTH_SIGNATURE_METHOD ) {
cb(new Error("HMAC-SHA1 is the only supported signature signing method at present."));
return;
}
if ( typeof options.oAuthVersion === "undefined" ) {
options.oAuthVersion = OAUTH_VERSION;
}
log(options.verbose,"Using options:");
log(options.verbose,options);
options.baseURL = options.protocol+"://"+options.host+options.path;
options.oAuthTimestamp = getTimestamp();
log(options.verbose,"Generated timestamp: "+options.oAuthTimestamp);
options.oAuthNonce = getNonce();
log(options.verbose,"Generated nonce: "+options.oAuthNonce);
options.oAuthSignature = genOAuthSig(options);
options.authHeaderValue = genAuthorizationHeaderValue(options);
options.queryString = genQueryString(options);
var headers = {};
headers["Authorization"] = options.authHeaderValue;
headers["Accept"] = "*/*";
headers["Connection"] = "close";
headers["User-Agent"] = "Node.js/twitreq v"+TWITREQ_VERSION;
headers["Content-Type"] = "application/x-www-form-urlencoded";
headers["Host"] = options.host;
var reqOptions = {
method: options.method,
path: options.path+options.queryString,
hostname: options.host,
headers: headers,
};
log(options.verbose,"Complete! Generated request object is:");
log(options.verbose,reqOptions);
cb(null,reqOptions);
} | javascript | {
"resource": ""
} |
q37952 | genQueryString | train | function genQueryString (options) {
if ( !options.queryParams ) {
return "";
}
log(options.verbose,"Now generating query string value ...");
var queryStringParams = [];
Object.keys(options.queryParams).forEach(function (key) {
queryStringParams.push(createEncodedParam(key,options.queryParams[key]));
});
var queryString = "?";
log(options.verbose,"Query string key/value pairs are:");
for ( var i=0; i<queryStringParams.length; i++ ) {
log(options.verbose," "+queryStringParams[i].key+"="+queryStringParams[i].value);
queryString += queryStringParams[i].key+"="+queryStringParams[i].value;
if ( queryStringParams[i+1] ) {
queryString += "&";
}
}
log(options.verbose,"Query string value is: "+queryString);
return queryString;
} | javascript | {
"resource": ""
} |
q37953 | percentEncode | train | function percentEncode (value) {
var result = encodeURIComponent(value);
return result.replace(/\!/g, "%21")
.replace(/\'/g, "%27")
.replace(/\(/g, "%28")
.replace(/\)/g, "%29")
.replace(/\*/g, "%2A");
} | javascript | {
"resource": ""
} |
q37954 | error | train | function error(err) {
this.log(`${chalk.red(`${err.name.toLowerCase()}:`)} ${err.message}`);
} | javascript | {
"resource": ""
} |
q37955 | status | train | function status(url, code, mod) {
return this.get(url, mod).then(req => req.statusCode === code);
} | javascript | {
"resource": ""
} |
q37956 | Config | train | function Config( defaults, extend, envName )
{
// Constants
// -------------
// test instance uniqueness
this._UID = _.uniqueId('config_')
this._DEFAULTENV = 'default'
// CORE's settings
// ------------------------
// default app configuration
var confDefault = this.getConfigParam( defaults )
, confExtend = ( !_.isUndefined( extend ) )
? this.getConfigParam( extend )
: {}
this._ENV = envName || this._DEFAULTENV
this._CONFIG = _.merge(
{}
, confDefault
, confExtend
)
return this
} | javascript | {
"resource": ""
} |
q37957 | AsyncRunner | train | function AsyncRunner(times, fn) {
Runner.apply(this, arguments);
this.pause = 0;
this.end = noop;
this.times = times;
} | javascript | {
"resource": ""
} |
q37958 | printMatrix2 | train | function printMatrix2 (m) {
const tStr = m.elements.map(formatPrintNumber);
const matrixString = `
+- -+
| ${tStr[0]} ${tStr[2]} |
| ${tStr[1]} ${tStr[3]} |
+- -+`;
return matrixString;
} | javascript | {
"resource": ""
} |
q37959 | printMatrix3 | train | function printMatrix3 (m) {
const tStr = m.elements.map(formatPrintNumber);
const matrixString = `
+- -+
| ${tStr[0]} ${tStr[3]} ${tStr[6]} |
| ${tStr[1]} ${tStr[4]} ${tStr[7]} |
| ${tStr[2]} ${tStr[5]} ${tStr[8]} |
+- -+`;
return matrixString;
} | javascript | {
"resource": ""
} |
q37960 | xpathFn | train | function xpathFn(token, rootEl, ns) {
var split = token.trim().split('@');
var retVal = rootEl;
var path = split[0].replace(/\/$/, "") || null;
var attr = split[1] || null;
if(path)
retVal = retVal.get(path, ns);
if(attr) {
retVal = retVal ? retVal.attr(attr) : "";
retVal = retVal ? retVal.value() : "";
} else {
retVal = retVal ? retVal.text() : "";
}
return retVal;
} | javascript | {
"resource": ""
} |
q37961 | evalFn | train | function evalFn(token, format_lib) {
var splited = token.trim().split(/[\(\)]/g);
if (splited.length < 3)
return token;
if (!format_lib)
return token
var fnstring = splited[0];
var fnparams = splited.slice(1, splited.length - 1);
var fn = format_lib[fnstring];
if (typeof fn !== "function")
return "";
return fn.apply(null, fnparams);
} | javascript | {
"resource": ""
} |
q37962 | generateClassNameSubstitutions | train | function generateClassNameSubstitutions(tokens, substitutionPattern, substitutions) {
tokens.forEach((tokenList)=> {
var token = tokenList[0];
generateSubstitution(token, substitutionPattern, substitutions);
});
} | javascript | {
"resource": ""
} |
q37963 | generateSubstitution | train | function generateSubstitution(token, substitutionPattern, substitutions) {
var substitution = substitutionPattern.replace(/{([^}]+)}/ig, (all, group)=> {
switch (group) {
case 'namespace':
return token.namespace;
case 'name':
return token.className;
case 'random':
return 'r' + Math.random().toString(36).substring(7);
case 'hash':
return 'h' + (token.hash + 0.0).toString(36);
case 'unique':
return 'u' + (++uniqueCounter);
}
});
substitutions[token.className] = [];
substitutions[token.className].push(substitution);
return substitution;
} | javascript | {
"resource": ""
} |
q37964 | Timestamp | train | function Timestamp(message, code_id) {
Error.call(this);
this.message = message || "timestamp out of date";
this.code_id = code_id || null;
this.statusCode = 409;
} | javascript | {
"resource": ""
} |
q37965 | NotReady | train | function NotReady(message, code_id) {
Error.call(this);
this.message = message || "resource is not ready yet";
this.code_id = code_id || null;
this.statusCode = 423;
} | javascript | {
"resource": ""
} |
q37966 | Locked | train | function Locked(message, code_id) {
Error.call(this);
this.message = message || "resource is locked"
this.code_id = code_id || null;
this.statusCode = 423;
} | javascript | {
"resource": ""
} |
q37967 | NeverImplemented | train | function NeverImplemented(message, code_id) {
Error.call(this);
this.message = message || "never will be implemented";
this.code_id = code_id || null;
this.statusCode = 501;
} | javascript | {
"resource": ""
} |
q37968 | SetupRequired | train | function SetupRequired(message, code_id) {
Error.call(this);
this.message = message || "setup required";
this.code_id = code_id || null;
this.statusCode = 500;
} | javascript | {
"resource": ""
} |
q37969 | Internal | train | function Internal(message, code_id) {
Error.call(this);
this.message = message || "internal error";
this.code_id = code_id || null;
this.statusCode = 500;
} | javascript | {
"resource": ""
} |
q37970 | Unavailable | train | function Unavailable(message, code_id) {
Error.call(this);
this.message = message || "temporarily unavailable";
this.code_id = code_id || null;
this.statusCode = 503;
} | javascript | {
"resource": ""
} |
q37971 | train | function() {
var that = this;
var boundEmitComplete = emitComplete.bind(this);
EventEmitter.call(this);
this.middleware = [];
this.server = net.createServer(function(conn) {
var buffer = '';
var info = null;
conn.on('data', function(data) {
buffer += data;
if(!info) {
if(buffer.indexOf('\f') !== -1) {
var split = buffer.split('\f');
try {
info = JSON.parse(split[0]);
buffer = split[1];
} catch(e) {
that.emit('error', e);
}
}
}
if(buffer && info) {
handleEntries(buffer, info, that.middleware, boundEmitComplete);
buffer = '';
}
});
conn.on('end', function() {
that.emit('end');
});
conn.on('error', function(err) {
that.emit('error', err);
});
});
} | javascript | {
"resource": ""
} | |
q37972 | train | function (ppunit, writer) {
writer.useColors = false
BaseReporter.call(this, ppunit, writer)
var self = this
ppunit.on('finish', function () {
writer.write(
self.tag(
'testsuite'
, {
name: 'PPUnit Tests'
, tests: ppunit.stats.tests
, failures: ppunit.stats.failures
, errors: ppunit.stats.failures
, timestamp: (new Date).toUTCString()
, time: (ppunit.stats.duration > 0) ? (ppunit.stats.duration / 1000) : 0
}
, false
)
)
ppunit.allTests.forEach(function (test) {
if (test.type === Test.TYPE.ROOT) {
return
}
self.printTest(test)
})
writer.write('</testsuite>')
})
} | javascript | {
"resource": ""
} | |
q37973 | CouchDB | train | function CouchDB(config, nano) {
if (!config) {
throw new Error("Expected a CouchDB configuration");
}
if (!config.url) {
throw new Error("Expected a url in the CouchDB configuration");
}
if (!config.database) {
throw new Error("Expected a database name in the CouchDB configuration");
}
if (!config.design) {
throw new Error("Expected a design document name in the CouchDB configuration");
}
if (!config.view) {
throw new Error("Expected a view name in the CouchDB configuration");
}
if (!/\/$/.test(config.url)) {
config.url += "/";
}
this.url = config.url;
this.database = config.database;
this.design = config.design;
this.view = config.view;
this.name = config.name;
this.type = "CouchDB Provider";
this.config = config;
this.__nano = nano || _nano;
this.__provider = config.provider || this.__nano(this.url).db.use(this.database);
} | javascript | {
"resource": ""
} |
q37974 | train | function (path) {
var foundPath = self.PathTool.findLibScript(path);
if (foundPath) {
self.scriptList.push(foundPath);
} else {
self.logger.warn('script:%s not found!', path);
}
} | javascript | {
"resource": ""
} | |
q37975 | arrayize | train | function arrayize(values) {
// return empty array if values is empty
if (typeof values === 'undefined' || values === null ) {
return [];
}
// return array of values, converting to array if necessary
return util.isArray(values) ? values : [values];
} | javascript | {
"resource": ""
} |
q37976 | train | function() {
// Combine random and case-specific factors into a base string
var factors = {
creationDate: (new Date()).getTime(),
random: Math.random() * (Math.random() * 1000),
nodeVersion: process.version
};
var basestring = '';
_.each(factors, function (val) {
basestring += val;
});
// Build hash
var hash = crypto.
createHash('md5').
update(basestring).
digest('hex');
return hash;
} | javascript | {
"resource": ""
} | |
q37977 | train | function (id, options, cb) {
if (arguments.length !== 3) {
cb = options;
options = {};
}
var self = this;
var model = this.get(id);
if (model){
return cb(null, model);
}
function done() {
var model = self.get(id);
if (model) {
if (cb){
cb(null, model);
}
} else {
cb(new Error('not found'));
}
}
if (options.all) {
this.fetch({
callback: done
});
} else {
this.fetchById(id, cb);
}
} | javascript | {
"resource": ""
} | |
q37978 | train | function(err, model, response, options){
if (options.cb){
options.cb(err, model, response);
}
if (err){
model.trigger('error', err, model, options);
}
} | javascript | {
"resource": ""
} | |
q37979 | train | function(fileName) {
//Grab the path package here locally for clarity
var _path = require('path');
//'yada/yada/multi1.html' -> 'multi1'
var name = _path
.basename(
fileName,
_path.extname(fileName));
//'multi1' -> 'name_1'
return 'name_'+name[5];
} | javascript | {
"resource": ""
} | |
q37980 | train | function(name, transformations) {
var synonyms = [];
if (typeof name === 'string' && name) {
transformations = transformations || this.transformations;
if (!Array.isArray(transformations)) {
transformations = Object.keys(transformations);
}
transformations.forEach(function(key) {
if (typeof transformers[key] !== 'function') {
throw new ReferenceError('Unknown transformer "' + key + '"');
}
var synonym = transformers[key](name);
if (synonym !== '' && !(synonym in synonyms)) {
synonyms.push(synonym);
}
});
}
return synonyms;
} | javascript | {
"resource": ""
} | |
q37981 | train | function(req, rsp, cb){
fs.readFile(path.resolve(routerPath), function(err, buff){
if (buff) {
var arrs = buff2arrs(buff)
return cb(arrs)
} else {
return cb(null)
}
})
} | javascript | {
"resource": ""
} | |
q37982 | discardIfOverAttempted | train | function discardIfOverAttempted(tasksByName, count) {
if (tasksByName) {
taskUtils.getTasks(tasksByName).forEach(task => {
const n = task.discardIfOverAttempted(maxNumberOfAttempts, true);
if (count) overAttempted += n;
});
}
} | javascript | {
"resource": ""
} |
q37983 | Client | train | function Client (id, apiKey) {
if (!(this instanceof Client)) {
return new Client(id, apiKey);
}
this.endpoint = 'https://www.googleapis.com';
this.apiKey = apiKey;
this.id = id;
} | javascript | {
"resource": ""
} |
q37984 | is_https | train | function is_https(req) {
if(req.headers && req.headers['x-forwarded-proto'] && req.headers['x-forwarded-proto'] === 'https') { return true; }
return (req && req.connection && req.connection.encrypted) ? true : false;
} | javascript | {
"resource": ""
} |
q37985 | train | function(message) {
if (!_.isObject(message)) {
message = {
message: message
};
}
try {
message = JSON.stringify(_.defaultsDeep({}, message, this.config.defaultProps));
} catch (e) {
return this.logger.error('Logmatic - error while parsing log message. Not sending', e);
}
if (this.isConnected) {
this.sendMessage(message);
} else {
this.messageBuffer.push(message);
}
} | javascript | {
"resource": ""
} | |
q37986 | train | function (script, args, hash) {
this.actionQueue.push(this.webdriverClient.execute.bind(this.webdriverClient, {script: script.toString(), arguments: args}));
this.actionQueue.push(this._setExecuteCb.bind(this, script.toString(), args, hash));
return this;
} | javascript | {
"resource": ""
} | |
q37987 | train | function (script, args, hash, data) {
var deferred = Q.defer();
this.events.emit('driver:message', {key: 'execute', value: JSON.parse(data).value, uuid: hash, hash: hash});
deferred.resolve();
return deferred.promise;
} | javascript | {
"resource": ""
} | |
q37988 | train | function (script, args, timeout, hash) {
this.actionQueue.push(this.webdriverClient.execute.bind(this.webdriverClient, {script: script.toString(), arguments: args}));
this.actionQueue.push(this._waitForCb.bind(this, script.toString(), args, timeout, hash));
return this;
} | javascript | {
"resource": ""
} | |
q37989 | train | function (script, args, timeout, hash, data) {
var deferred = Q.defer();
var ret = JSON.parse(data);
var checker = function (yData) {
if (JSON.parse(yData).value.userRet === true) {
this.events.emit('driver:message', {key: 'waitFor', value: '', uuid: hash, hash: hash});
deferred.resolve();
} else {
Q.when(this.webdriverClient.execute.bind(this.webdriverClient, {script: script, arguments: args})())
.then(checker);
}
}.bind(this);
setTimeout(function () {
this.events.emit('driver:message', {key: 'waitFor', value: 'Interrupted by timeout', uuid: hash, hash: hash});
deferred.resolve();
}.bind(this), timeout);
if (ret.value.userRet === true) {
this.events.emit('driver:message', {key: 'waitFor', value: '', uuid: hash, hash: hash});
deferred.resolve();
} else {
Q.when(this.webdriverClient.execute.bind(this.webdriverClient, {script: script, arguments: args})())
.then(checker);
}
return deferred.promise;
} | javascript | {
"resource": ""
} | |
q37990 | onUpgrade | train | function onUpgrade (reverseProxy, proxySocket) {
if (!reverseProxy) {
proxySocket.end();
socket.end();
return;
}
//
// Any incoming data on this WebSocket to the proxy target
// will be written to the `reverseProxy` socket.
//
proxySocket.on('data', listeners.onIncoming = function (data) {
if (reverseProxy.incoming.socket.writable) {
try {
self.emit('websocket:outgoing', req, socket, head, data);
var flushed = reverseProxy.incoming.socket.write(data);
if (!flushed) {
proxySocket.pause();
reverseProxy.incoming.socket.once('drain', function () {
try { proxySocket.resume() }
catch (er) { console.error("proxySocket.resume error: %s", er.message) }
});
//
// Force the `drain` event in 100ms if it hasn't
// happened on its own.
//
setTimeout(function () {
reverseProxy.incoming.socket.emit('drain');
}, 100);
}
}
catch (ex) {
detach();
}
}
});
//
// Any outgoing data on this Websocket from the proxy target
// will be written to the `proxySocket` socket.
//
reverseProxy.incoming.socket.on('data', listeners.onOutgoing = function (data) {
try {
self.emit('websocket:incoming', reverseProxy, reverseProxy.incoming, head, data);
var flushed = proxySocket.write(data);
if (!flushed) {
reverseProxy.incoming.socket.pause();
proxySocket.once('drain', function () {
try { reverseProxy.incoming.socket.resume() }
catch (er) { console.error("reverseProxy.incoming.socket.resume error: %s", er.message) }
});
//
// Force the `drain` event in 100ms if it hasn't
// happened on its own.
//
setTimeout(function () {
proxySocket.emit('drain');
}, 100);
}
}
catch (ex) {
detach();
}
});
//
// Helper function to detach all event listeners
// from `reverseProxy` and `proxySocket`.
//
function detach() {
proxySocket.destroySoon();
proxySocket.removeListener('end', listeners.onIncomingClose);
proxySocket.removeListener('data', listeners.onIncoming);
reverseProxy.incoming.socket.destroySoon();
reverseProxy.incoming.socket.removeListener('end', listeners.onOutgoingClose);
reverseProxy.incoming.socket.removeListener('data', listeners.onOutgoing);
}
//
// If the incoming `proxySocket` socket closes, then
// detach all event listeners.
//
proxySocket.on('end', listeners.onIncomingClose = function() {
detach();
// Emit the `end` event now that we have completed proxying
self.emit('websocket:end', req, socket, head);
});
//
// If the `reverseProxy` socket closes, then detach all
// event listeners.
//
reverseProxy.incoming.socket.on('end', listeners.onOutgoingClose = function() {
detach();
});
} | javascript | {
"resource": ""
} |
q37991 | detach | train | function detach() {
proxySocket.destroySoon();
proxySocket.removeListener('end', listeners.onIncomingClose);
proxySocket.removeListener('data', listeners.onIncoming);
reverseProxy.incoming.socket.destroySoon();
reverseProxy.incoming.socket.removeListener('end', listeners.onOutgoingClose);
reverseProxy.incoming.socket.removeListener('data', listeners.onOutgoing);
} | javascript | {
"resource": ""
} |
q37992 | proxyError | train | function proxyError (err) {
reverseProxy.destroy();
process.nextTick(function () {
//
// Destroy the incoming socket in the next tick, in case the error handler
// wants to write to it.
//
socket.destroy();
});
self.emit('webSocketProxyError', req, socket, head);
} | javascript | {
"resource": ""
} |
q37993 | Broker | train | function Broker(options) {
EventEmitter.call(this);
this._exchange = null;
this._queues = {};
this._ctags = {};
this._options = options;
} | javascript | {
"resource": ""
} |
q37994 | ErrorSave | train | function ErrorSave (message) {
Error.call(this);
// Add Information
this.name = 'ErrorSave';
this.type = 'server';
this.status = 500;
if (message) {
this.message = message;
}
} | javascript | {
"resource": ""
} |
q37995 | isRealDirectory | train | function isRealDirectory(p) {
var stats;
try {
stats = fs.statSync(p);
} catch (error) {
// Not a valid path if stat fails.
return false;
}
return (stats.isDirectory());
} | javascript | {
"resource": ""
} |
q37996 | generatePolygon | train | function generatePolygon() {
var coordNumber = getRandomNumber(3, options.maxCoordCount);
var feature = rawFeature();
feature.geometry.type = 'Polygon';
feature.geometry.coordinates = [
[]
];
var firstCoordinate = generateLonLat();
feature.geometry.coordinates[0].push(firstCoordinate);
addCoordinates(feature.geometry.coordinates[0], coordNumber - 2);
feature.geometry.coordinates[0].push(firstCoordinate);
return feature;
} | javascript | {
"resource": ""
} |
q37997 | generateLineString | train | function generateLineString() {
var coordNumber = getRandomNumber(3, options.maxCoordCount);
var feature = rawFeature();
feature.geometry.type = 'LineString';
addCoordinates(feature.geometry.coordinates, coordNumber);
return feature;
} | javascript | {
"resource": ""
} |
q37998 | generateFeatures | train | function generateFeatures() {
var collection = {
type: 'FeatureCollection',
features: []
};
for (var i = 0; i < options.number; i++) {
collection.features.push(generateFeature(randomType()));
}
return collection;
} | javascript | {
"resource": ""
} |
q37999 | addCoordinates | train | function addCoordinates(coordArray, number) {
for (var i = 0; i < number; i++) {
coordArray.push(generateLonLat());
}
} | javascript | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.