| domain | | name | value | |
|---|
| domain | null | | _events | | | _maxListeners | undefined | | members | | index | value | |
|---|
| 0 | | name | value | |
|---|
| _readableState | (Depth exceeded; max depth: 4) | | readable | false | | domain | (Depth exceeded; max depth: 4) | | _events | (Depth exceeded; max depth: 4) | | _maxListeners | undefined | | socket | (Depth exceeded; max depth: 4) | | connection | (Depth exceeded; max depth: 4) | | httpVersionMajor | 1 | | httpVersionMinor | 0 | | httpVersion | 1.0 | | complete | true | | headers | (Depth exceeded; max depth: 4) | | rawHeaders | (Depth exceeded; max depth: 4) | | trailers | { } | | rawTrailers | [ ] | | _pendings | [ ] | | _pendingIndex | 0 | | upgrade | false | | url | /viewtopic.php?t=132&p=19340 | | method | GET | | statusCode | null | | statusMessage | null | | client | (Depth exceeded; max depth: 4) | | _consuming | true | | _dumped | false | | EDT | { } | | next | args: 1, fn name: nextfunction next(err) {
var layerError = err === 'route'
? null
: err;
// remove added slash
if (slashAdded) {
req.url = req.url.substr(1);
slashAdded = false;
}
// restore altered req.url
if (removed.length !== 0) {
req.baseUrl = parentUrl;
req.url = protohost + removed + req.url.substr(protohost.length);
removed = '';
}
// no more matching layers
if (idx >= stack.length) {
setImmediate(done, layerError);
return;
}
// get pathname of request
var path = getPathname(req);
if (path == null) {
return done(layerError);
}
// find next matching layer
var layer;
var match;
var route;
while (match !== true && idx < stack.length) {
layer = stack[idx++];
match = matchLayer(layer, path);
route = layer.route;
if (typeof match !== 'boolean') {
// hold on to layerError
layerError = layerError || match;
}
if (match !== true) {
continue;
}
if (!route) {
// process non-route handlers normally
continue;
}
if (layerError) {
// routes do not match with a pending error
match = false;
continue;
}
var method = req.method;
var has_method = route._handles_method(method);
// build up automatic options response
if (!has_method && method === 'OPTIONS') {
appendMethods(options, route._options());
}
// don't even bother matching route
if (!has_method && method !== 'HEAD') {
match = false;
continue;
}
}
// no match
if (match !== true) {
return done(layerError);
}
// store route for dispatch on change
if (route) {
req.route = route;
}
// Capture one-time layer values
req.params = self.mergeParams
? mergeParams(layer.params, parentParams)
: layer.params;
var layerPath = layer.path;
// this should be done for the layer
self.process_params(layer, paramcalled, req, res, function (err) {
if (err) {
return next(layerError || err);
}
if (route) {
return layer.handle_request(req, res, next);
}
trim_prefix(layer, layerError, layerPath, path);
});
} | | baseUrl | /forum | | originalUrl | /forum/viewtopic.php?t=132&p=19340 | | _parsedUrl | (Depth exceeded; max depth: 4) | | params | { } | | query | (Depth exceeded; max depth: 4) | | res | (Depth exceeded; max depth: 4) | | _parsedOriginalUrl | (Depth exceeded; max depth: 4) | | rawBody | (Depth exceeded; max depth: 4) | | rawBodyDone | true | | rawBodyChip | undefined | | read | args: 1, fn name: function (n) {
debug('read', n);
var state = this._readableState;
var nOrig = n;
if (!util.isNumber(n) || n > 0)
state.emittedReadable = false;
// if we're doing read(0) to trigger a readable event, but we
// already have a bunch of data in the buffer, then just trigger
// the 'readable' event and move on.
if (n === 0 &&
state.needReadable &&
(state.length >= state.highWaterMark || state.ended)) {
debug('read: emitReadable', state.length, state.ended);
if (state.length === 0 && state.ended)
endReadable(this);
else
emitReadable(this);
return null;
}
n = howMuchToRead(n, state);
// if we've ended, and we're now clear, then finish it up.
if (n === 0 && state.ended) {
if (state.length === 0)
endReadable(this);
return null;
}
// All the actual chunk generation logic needs to be
// *below* the call to _read. The reason is that in certain
// synthetic stream cases, such as passthrough streams, _read
// may be a completely synchronous operation which may change
// the state of the read buffer, providing enough data when
// before there was *not* enough.
//
// So, the steps are:
// 1. Figure out what the state of things will be after we do
// a read from the buffer.
//
// 2. If that resulting state will trigger a _read, then call _read.
// Note that this may be asynchronous, or synchronous. Yes, it is
// deeply ugly to write APIs this way, but that still doesn't mean
// that the Readable class should behave improperly, as streams are
// designed to be sync/async agnostic.
// Take note if the _read call is sync or async (ie, if the read call
// has returned yet), so that we know whether or not it's safe to emit
// 'readable' etc.
//
// 3. Actually pull the requested chunks out of the buffer and return.
// if we need a readable event, then we need to do some reading.
var doRead = state.needReadable;
debug('need readable', doRead);
// if we currently have less than the highWaterMark, then also read some
if (state.length === 0 || state.length - n < state.highWaterMark) {
doRead = true;
debug('length less than watermark', doRead);
}
// however, if we've ended, then there's no point, and if we're already
// reading, then it's unnecessary.
if (state.ended || state.reading) {
doRead = false;
debug('reading or ended', doRead);
}
if (doRead) {
debug('do read');
state.reading = true;
state.sync = true;
// if the length is currently zero, then we *need* a readable event.
if (state.length === 0)
state.needReadable = true;
// call internal read method
this._read(state.highWaterMark);
state.sync = false;
}
// If _read pushed data synchronously, then `reading` will be false,
// and we need to re-evaluate how much data we can return to the user.
if (doRead && !state.reading)
n = howMuchToRead(nOrig, state);
var ret;
if (n > 0)
ret = fromList(n, state);
else
ret = null;
if (util.isNull(ret)) {
state.needReadable = true;
n = 0;
}
state.length -= n;
// If we have nothing in the buffer, then we want to know
// as soon as we *do* get something into the buffer.
if (state.length === 0 && !state.ended)
state.needReadable = true;
// If we tried to read() past the EOF, then emit end on the next tick.
if (nOrig !== n && state.ended && state.length === 0)
endReadable(this);
if (!util.isNull(ret))
this.emit('data', ret);
return ret;
} |
| | 1 | | name | value | |
|---|
| domain | (Depth exceeded; max depth: 4) | | _events | (Depth exceeded; max depth: 4) | | _maxListeners | undefined | | output | [ ] | | outputEncodings | [ ] | | outputCallbacks | [ ] | | writable | true | | _last | false | | chunkedEncoding | false | | shouldKeepAlive | false | | useChunkedEncodingByDefault | false | | sendDate | true | | _removedHeader | { } | | _hasBody | true | | _trailer | | | finished | false | | _hangupClose | false | | _headerSent | false | | socket | (Depth exceeded; max depth: 4) | | connection | (Depth exceeded; max depth: 4) | | _header | null | | _headers | (Depth exceeded; max depth: 4) | | _headerNames | (Depth exceeded; max depth: 4) | | req | (Depth exceeded; max depth: 4) | | locals | (Depth exceeded; max depth: 4) | | _EDT_orig_render | args: 3, fn name: renderfunction render(view, options, callback) {
var app = this.req.app;
var done = callback;
var opts = options || {};
var req = this.req;
var self = this;
// support callback function as second arg
if (typeof options === 'function') {
done = options;
opts = {};
}
// merge res.locals
opts._locals = self.locals;
// default callback to respond
done = done || function (err, str) {
if (err) return req.next(err);
self.send(str);
};
// render
app.render(view, opts, done);
} | | render | args: 3, fn name: function (view, options, fn) {
options = options || {};
var res = this,
req = this.req,
app = this.app,
accept = req.headers.accept || '';
var finalize = function (err, str) {
// keep existing callback if one was passed
if (typeof fn === 'function') {
fn(err, str);
} else if (err) {
req.next(err);
} else {
res.send(str);
}
};
panels.finalize(req);
// support callback function as second arg
if (typeof options === 'function') {
fn = options;
options = {};
}
// merge res.locals
options._locals = res.locals;
var render_toolbar = function (str, callback) {
var standalone = settings.path === req.path;
var opts = {
EDTsettings: settings,
theme: theme,
req: req,
standalone: standalone,
extra_attrs: settings.extra_attrs,
panels: panels.render({
locals: options,
app: app,
res: res,
req: req,
view: view
}, settings, standalone)
};
jade.renderFile(template, opts, function (err, toolbar) {
callback(err, err ? undefined : utils.inject_toolbar(str, toolbar));
});
};
var toolbar_callback = function (err, str) {
panels.post_render(req);
if (err) {
console.log(err);
req.next(err);
} else if (res.EDT_rendered) {
// if callback method was used, more than one template may be rendered.
// in this care, do not render another copy
// TODO: see if we can catch this on the last render, and attach it in .send instead
finalize(err, str);
} else {
res.EDT_rendered = true;
render_toolbar(str, finalize);
}
};
panels.pre_render(req);
if (req.path.indexOf(settings.path) === 0) {
// standalone mode
jade.renderFile(fullpage, function (err, str) {
toolbar_callback(err, str);
});
} else {
// inject toolbar callback into render callback
res._EDT_orig_render.call(res, view, options, toolbar_callback);
}
} | | _EDT_orig_send | args: 1, fn name: sendfunction send(body) {
var chunk = body;
var encoding;
var len;
var req = this.req;
var type;
// settings
var app = this.app;
// allow status / body
if (arguments.length === 2) {
// res.send(body, status) backwards compat
if (typeof arguments[0] !== 'number' && typeof arguments[1] === 'number') {
deprecate('res.send(body, status): Use res.status(status).send(body) instead');
this.statusCode = arguments[1];
} else {
deprecate('res.send(status, body): Use res.status(status).send(body) instead');
this.statusCode = arguments[0];
chunk = arguments[1];
}
}
// disambiguate res.send(status) and res.send(status, num)
if (typeof chunk === 'number' && arguments.length === 1) {
// res.send(status) will set status message as text string
if (!this.get('Content-Type')) {
this.type('txt');
}
deprecate('res.send(status): Use res.sendStatus(status) instead');
this.statusCode = chunk;
chunk = statusCodes[chunk];
}
switch (typeof chunk) {
// string defaulting to html
case 'string':
if (!this.get('Content-Type')) {
this.type('html');
}
break;
case 'boolean':
case 'number':
case 'object':
if (chunk === null) {
chunk = '';
} else if (Buffer.isBuffer(chunk)) {
if (!this.get('Content-Type')) {
this.type('bin');
}
} else {
return this.json(chunk);
}
break;
}
// write strings in utf-8
if (typeof chunk === 'string') {
encoding = 'utf8';
type = this.get('Content-Type');
// reflect this in content-type
if (typeof type === 'string') {
this.set('Content-Type', setCharset(type, 'utf-8'));
}
}
// populate Content-Length
if (chunk !== undefined) {
if (!Buffer.isBuffer(chunk)) {
// convert chunk to Buffer; saves later double conversions
chunk = new Buffer(chunk, encoding);
encoding = undefined;
}
len = chunk.length;
this.set('Content-Length', len);
}
// populate ETag
var etag;
var generateETag = len !== undefined && app.get('etag fn');
if (typeof generateETag === 'function' && !this.get('ETag')) {
if ((etag = generateETag(chunk, encoding))) {
this.set('ETag', etag);
}
}
// freshness
if (req.fresh) this.statusCode = 304;
// strip irrelevant headers
if (204 == this.statusCode || 304 == this.statusCode) {
this.removeHeader('Content-Type');
this.removeHeader('Content-Length');
this.removeHeader('Transfer-Encoding');
chunk = '';
}
if (req.method === 'HEAD') {
// skip body for HEAD
this.end();
} else {
// respond
this.end(chunk, encoding);
}
return this;
} | | send | args: 0, fn name: function () {
if (this.EDT_rendered !== true) {
request.add(this.req, arguments);
}
this._EDT_orig_send.apply(this, arguments);
} | | EDT_rendered | true |
|
| | id | 1563611658278 |
|
