www.aleph1.co.uk Git - yaffs-website/blob - node_modules/verror/lib/verror.js

   1 /*
   2  * verror.js: richer JavaScript errors
   3  */
   4
   5 var mod_assert = require('assert');
   6 var mod_util = require('util');
   7
   8 var mod_extsprintf = require('extsprintf');
   9
  10 /*
  11  * Public interface
  12  */
  13 exports.VError = VError;
  14 exports.WError = WError;
  15 exports.MultiError = MultiError;
  16
  17 /*
  18  * Like JavaScript's built-in Error class, but supports a "cause" argument and a
  19  * printf-style message.  The cause argument can be null.
  20  */
  21 function VError(options)
  22 {
  23         var args, causedBy, ctor, tailmsg;
  24
  25         if (options instanceof Error || typeof (options) === 'object') {
  26                 args = Array.prototype.slice.call(arguments, 1);
  27         } else {
  28                 args = Array.prototype.slice.call(arguments, 0);
  29                 options = undefined;
  30         }
  31
  32         tailmsg = args.length > 0 ?
  33             mod_extsprintf.sprintf.apply(null, args) : '';
  34         this.jse_shortmsg = tailmsg;
  35         this.jse_summary = tailmsg;
  36
  37         if (options) {
  38                 causedBy = options.cause;
  39
  40                 if (!causedBy || !(options.cause instanceof Error))
  41                         causedBy = options;
  42
  43                 if (causedBy && (causedBy instanceof Error)) {
  44                         this.jse_cause = causedBy;
  45                         this.jse_summary += ': ' + causedBy.message;
  46                 }
  47         }
  48
  49         this.message = this.jse_summary;
  50         Error.call(this, this.jse_summary);
  51
  52         if (Error.captureStackTrace) {
  53                 ctor = options ? options.constructorOpt : undefined;
  54                 ctor = ctor || arguments.callee;
  55                 Error.captureStackTrace(this, ctor);
  56         }
  57 }
  58
  59 mod_util.inherits(VError, Error);
  60 VError.prototype.name = 'VError';
  61
  62 VError.prototype.toString = function ve_toString()
  63 {
  64         var str = (this.hasOwnProperty('name') && this.name ||
  65                 this.constructor.name || this.constructor.prototype.name);
  66         if (this.message)
  67                 str += ': ' + this.message;
  68
  69         return (str);
  70 };
  71
  72 VError.prototype.cause = function ve_cause()
  73 {
  74         return (this.jse_cause);
  75 };
  76
  77
  78 /*
  79  * Represents a collection of errors for the purpose of consumers that generally
  80  * only deal with one error.  Callers can extract the individual errors
  81  * contained in this object, but may also just treat it as a normal single
  82  * error, in which case a summary message will be printed.
  83  */
  84 function MultiError(errors)
  85 {
  86         mod_assert.ok(errors.length > 0);
  87         this.ase_errors = errors;
  88
  89         VError.call(this, errors[0], 'first of %d error%s',
  90             errors.length, errors.length == 1 ? '' : 's');
  91 }
  92
  93 mod_util.inherits(MultiError, VError);
  94
  95
  96
  97 /*
  98  * Like JavaScript's built-in Error class, but supports a "cause" argument which
  99  * is wrapped, not "folded in" as with VError.  Accepts a printf-style message.
 100  * The cause argument can be null.
 101  */
 102 function WError(options)
 103 {
 104         Error.call(this);
 105
 106         var args, cause, ctor;
 107         if (typeof (options) === 'object') {
 108                 args = Array.prototype.slice.call(arguments, 1);
 109         } else {
 110                 args = Array.prototype.slice.call(arguments, 0);
 111                 options = undefined;
 112         }
 113
 114         if (args.length > 0) {
 115                 this.message = mod_extsprintf.sprintf.apply(null, args);
 116         } else {
 117                 this.message = '';
 118         }
 119
 120         if (options) {
 121                 if (options instanceof Error) {
 122                         cause = options;
 123                 } else {
 124                         cause = options.cause;
 125                         ctor = options.constructorOpt;
 126                 }
 127         }
 128
 129         Error.captureStackTrace(this, ctor || this.constructor);
 130         if (cause)
 131                 this.cause(cause);
 132
 133 }
 134
 135 mod_util.inherits(WError, Error);
 136 WError.prototype.name = 'WError';
 137
 138
 139 WError.prototype.toString = function we_toString()
 140 {
 141         var str = (this.hasOwnProperty('name') && this.name ||
 142                 this.constructor.name || this.constructor.prototype.name);
 143         if (this.message)
 144                 str += ': ' + this.message;
 145         if (this.we_cause && this.we_cause.message)
 146                 str += '; caused by ' + this.we_cause.toString();
 147
 148         return (str);
 149 };
 150
 151 WError.prototype.cause = function we_cause(c)
 152 {
 153         if (c instanceof Error)
 154                 this.we_cause = c;
 155
 156         return (this.we_cause);
 157 };