Authenticator.prototype.applyRenewal = function (err, result) {
if (err != null) {
result = null;
// WebError can contain raw result
if (mt.is(err, WebError) && err.result != null) {
result = err.result;
}
}
if (result != null && result.headers != null && result.headers.renewal != null) {
this.auth = result.headers.renewal;
}
};
QueryMaker.prototype.process = function (part) {
if (part) {
if (Array.isArray(part)) {
this.processParts(part);
}
else if (mt.is(part, QueryPart)) {
part.expose(this);
}
else {
this.queryParts.push(this.replaceVars(part));
}
}
};
Result.prototype.sendError = function (ctx, err) {
var status = 500;
var result;
var isDebug = ctx.isDebug;
var provideStackTrace = ctx.appSettings.core.handlers.result.provideStackTrace;
var needStack = provideStackTrace == 'debug' ? isDebug : provideStackTrace;
if (!mt.is(err, WebError)) {
err = new ServerError(err);
}
if (err.status != null && !isSuccess(err.status)) {
status = err.status;
}
else {
try {
ctx.logError(new Error([
'Incorrect error status "', err.status+'',
'" for error "', err.name, '"'].join('')));
}
catch (exc) {
ctx.logError(exc, 'critical');
}
}
result = err.getDetails(isDebug);
if (isDebug) {
// just for convenience
result.message = err.message;
}
// must set Allowed header for '405 Method not allowed' response
// according to HTTP specs
if (status == 405 && err.httpAllowedMethods != null && err.httpAllowedMethods.length > 0 && ctx.isHttp) {
ctx.res.setHeader('Allow', err.httpAllowedMethods.join(', '));
}
if (needStack) {
result.stack = err.stack;
}
ctx.clearError();
ctx.res.statusCode = status;
this.respond(ctx, result);
};
TestPage.prototype.showError = function (err) {
if (mt.is(err, WebError)) {
var status = err.status;
var headers = JSON.stringify(err.result.headers, null, '\t');
var body = err.result.data;
try {
body = JSON.stringify(body, null, '\t');
}
catch (err) { // to be ready to non-json responses
}
this.responseHeadersField.value = headers;
this.responseBodyField.value = ['Response code is ', status, '\n', body].join('');
}
else {
this.responseHeadersField.value = '';
this.responseBodyField.value = (err.getStackTrace ? err.getStackTrace() || err.stack : err.stack) || err;
}
};
fs.readFile(srcPath, 'utf8', function (err, src) {
if (err) {
next(err);
}
else {
var compilationInfo;
try {
compilationInfo = compiler.compile(src, options);
}
catch(exc) {
if (!options.silent && mt.is(exc, compiler.CompilationFailed)) {
console.error(exc.getMessage(srcPath, src, options.tabSize));
}
next(exc);
return;
}
next(null, dstPath, compilationInfo.result);
}
});
AuthProvider.prototype.isAuthProblem = function (err) {
return mt.is(err, AuthProblem);
};
var compile = function (src, options) {
options = ops.cloneWithDefaults(options, defaultOptions);
options.tokenizer.tabSize = options.tabSize;
var errors = [];
var tokenizer = new options.tokenizer.tokenizerClass(src, options.tokenizer);
var generator = new options.generator.generatorClass(options.generator);
while(true) {
try {
var token = tokenizer.getNextToken();
if (token == null) { // we are done
break;
}
generator.onToken(token);
}
catch(err) {
var needStop = false;
if (mt.is(err, TokenizationError)) {
// continue if we can
if (!err.canContinue) {
needStop = true;
}
}
else if (!mt.is(err, GenerationError)) { // ignore generation errors here
throw err;
}
errors.push(err);
if (needStop || options.maxErrors != null && errors.length >= options.maxErrors) {
break;
}
}
}
var result = null;
if (errors.length === 0) {
try {
result = generator.getResult();
}
catch(err) {
if (mt.is(err, GenerationError)) {
errors.push(err);
}
else {
throw err;
}
}
}
if (errors.length !== 0) {
throw new CompilationFailed(errors);
}
return {
// someday we'll add here warnings... maybe
result: result
};
};
WebError.isWebError = function (err, opt_status) {
return mt.is(err, WebError) && (opt_status == null || err.status == opt_status);
};