2599143908

Build Type

push

github

Committed by GitHub

Commit Message

chore!: Normalize repository, dropping node <10.13 support (#22)

Run Details

33 of 34 branches covered (97.06%)

Branch coverage included in aggregate %.

14 of 14 new or added lines in 1 file covered. (100.0%)

1 existing line in 1 file now uncovered.

80 of 81 relevant lines covered (98.77%)

242.37 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

98.26

/index.js

var util = require('util');
var colors = require('ansi-colors');

var nonEnum = ['message', 'name', 'stack'];
var ignored = new Set(
  nonEnum.concat([
    '__safety',
    '_stack',
    'plugin',
    'showProperties',
    'showStack',
  ])
);
var props = [
  'fileName',
  'lineNumber',
  'message',
  'name',
  'plugin',
  'showProperties',
  'showStack',
  'stack',
];

function PluginError(plugin, message, options) {
  if (!(this instanceof PluginError)) {
    return new PluginError(plugin, message, options);
  }

  Error.call(this);
  var opts = setDefaults(plugin, message, options);
  var self = this;

  // If opts has an error, get details from it
  if (typeof opts.error === 'object') {
    var keys = new Set(Object.keys(opts.error).concat(nonEnum));

    // These properties are not enumerable, so we have to add them explicitly.
    keys.forEach(function (prop) {
      self[prop] = opts.error[prop];
    });
  }

  // Opts object can override
  props.forEach(function (prop) {
    if (prop in opts) {
      this[prop] = opts[prop];
    }
  }, this);

  // Defaults
  if (!this.stack) {
    /**
     * `Error.captureStackTrace` appends a stack property which
     * relies on the toString method of the object it is applied to.
     *
     * Since we are using our own toString method which controls when
     * to display the stack trace, if we don't go through this safety
     * object we'll get stack overflow problems.
     */

    var safety = {};
    safety.toString = function () {
      return this._messageWithDetails() + '\nStack:';
    }.bind(this);

    Error.captureStackTrace(safety, arguments.callee || this.constructor);
    this.__safety = safety;
  }
  if (!this.plugin) {
    throw new Error('Missing plugin name');
  }
  if (!this.message) {
    throw new Error('Missing error message');
  }
}

util.inherits(PluginError, Error);

/**
 * Output a formatted message with details
 */

PluginError.prototype._messageWithDetails = function () {
  var msg = 'Message:\n    ' + this.message;
  var details = this._messageDetails();
  if (details !== '') {
    msg += '\n' + details;
  }
  return msg;
};

/**
 * Output actual message details
 */

PluginError.prototype._messageDetails = function () {
  if (!this.showProperties) {
    return '';
  }

  var props = Object.keys(this).filter(function (key) {
    return !ignored.has(key);
  });
  var len = props.length;

  if (len === 0) {
    return '';
  }

  var res = '';
  var i = 0;
  while (len--) {
    var prop = props[i++];
    res += '    ';
    res += prop + ': ' + this[prop];
    res += '\n';
  }
  return 'Details:\n' + res;
};

/**
 * Override the `toString` method
 */

PluginError.prototype.toString = function () {
  var detailsWithStack = function (stack) {
    return this._messageWithDetails() + '\nStack:\n' + stack;
  }.bind(this);

  var msg = '';
  if (this.showStack) {
    // If there is no wrapped error, use the stack captured in the PluginError ctor
    if (this.__safety) {
      msg = this.__safety.stack;
    } else if (this._stack) {
      msg = detailsWithStack(this._stack);
    } else {
      // Stack from wrapped error
      msg = detailsWithStack(this.stack);
    }
    return message(msg, this);
  }

  msg = this._messageWithDetails();
  return message(msg, this);
};

// Format the output message
function message(msg, thisArg) {
  var sig = colors.red(thisArg.name);
  sig += ' in plugin ';
  sig += '"' + colors.cyan(thisArg.plugin) + '"';
  sig += '\n';
  sig += msg;
  return sig;
}

/**
 * Set default options based on arguments.
 */

function setDefaults(plugin, message, opts) {
  if (typeof plugin === 'object') {
    return defaults(plugin);
  }
  opts = opts || {};
  if (message instanceof Error) {
    opts.error = message;
  } else if (typeof message === 'object') {
    opts = message;
  } else {
    opts.message = message;
  }
  opts.plugin = plugin;
  return defaults(opts);
}

/**
 * Extend default options with:
 *
 *  - `showStack`: default=false
 *  - `showProperties`: default=true
 *
 * @param  {Object} `opts` Options to extend
 * @return {Object}
 */

function defaults(opts) {
  return Object.assign(
    {
      showStack: false,
      showProperties: true,
    },
    opts
  );
}

/**
 * Expose `PluginError`
 */

module.exports = PluginError;

1	var util = require('util');	12✔
2	var colors = require('ansi-colors');	12✔
3
4	var nonEnum = ['message', 'name', 'stack'];	12✔
5	var ignored = new Set(	12✔
6	nonEnum.concat([
7	'__safety',
8	'_stack',
9	'plugin',
10	'showProperties',
11	'showStack',
12	])
13	);
14	var props = [	12✔
15	'fileName',
16	'lineNumber',
17	'message',
18	'name',
19	'plugin',
20	'showProperties',
21	'showStack',
22	'stack',
23	];
24
25	function PluginError(plugin, message, options) {
26	if (!(this instanceof PluginError)) {	336✔
27	return new PluginError(plugin, message, options);	12✔
28	}
29
30	Error.call(this);	324✔
31	var opts = setDefaults(plugin, message, options);	324✔
32	var self = this;	324✔
33
34	// If opts has an error, get details from it
35	if (typeof opts.error === 'object') {	324✔
36	var keys = new Set(Object.keys(opts.error).concat(nonEnum));	108✔
37
38	// These properties are not enumerable, so we have to add them explicitly.
39	keys.forEach(function (prop) {	108✔
40	self[prop] = opts.error[prop];	468✔
41	});
42	}
43
44	// Opts object can override
45	props.forEach(function (prop) {	324✔
46	if (prop in opts) {	2,592✔
47	this[prop] = opts[prop];	1,224✔
48	}
49	}, this);
50
51	// Defaults
52	if (!this.stack) {	324✔
53	/**
54	* `Error.captureStackTrace` appends a stack property which
55	* relies on the toString method of the object it is applied to.
56	*
57	* Since we are using our own toString method which controls when
58	* to display the stack trace, if we don't go through this safety
59	* object we'll get stack overflow problems.
60	*/
61
62	var safety = {};	192✔
63	safety.toString = function () {	192✔
UNCOV 64	return this._messageWithDetails() + '\nStack:';	×
65	}.bind(this);
66
67	Error.captureStackTrace(safety, arguments.callee \|\| this.constructor);	192!
68	this.__safety = safety;	192✔
69	}
70	if (!this.plugin) {	324✔
71	throw new Error('Missing plugin name');	12✔
72	}
73	if (!this.message) {	312✔
74	throw new Error('Missing error message');	12✔
75	}
76	}
77
78	util.inherits(PluginError, Error);	12✔
79
80	/**
81	* Output a formatted message with details
82	*/
83
84	PluginError.prototype._messageWithDetails = function () {	12✔
85	var msg = 'Message:\n ' + this.message;	312✔
86	var details = this._messageDetails();	312✔
87	if (details !== '') {	312✔
88	msg += '\n' + details;	120✔
89	}
90	return msg;	312✔
91	};
92
93	/**
94	* Output actual message details
95	*/
96
97	PluginError.prototype._messageDetails = function () {	12✔
98	if (!this.showProperties) {	312✔
99	return '';	132✔
100	}
101
102	var props = Object.keys(this).filter(function (key) {	180✔
103	return !ignored.has(key);	1,176✔
104	});
105	var len = props.length;	180✔
106
107	if (len === 0) {	180✔
108	return '';	60✔
109	}
110
111	var res = '';	120✔
112	var i = 0;	120✔
113	while (len--) {	120✔
114	var prop = props[i++];	180✔
115	res += ' ';	180✔
116	res += prop + ': ' + this[prop];	180✔
117	res += '\n';	180✔
118	}
119	return 'Details:\n' + res;	120✔
120	};
121
122	/**
123	* Override the `toString` method
124	*/
125
126	PluginError.prototype.toString = function () {	12✔
127	var detailsWithStack = function (stack) {	324✔
128	return this._messageWithDetails() + '\nStack:\n' + stack;	168✔
129	}.bind(this);
130
131	var msg = '';	324✔
132	if (this.showStack) {	324✔
133	// If there is no wrapped error, use the stack captured in the PluginError ctor
134	if (this.__safety) {	180✔
135	msg = this.__safety.stack;	12✔
136	} else if (this._stack) {	168✔
137	msg = detailsWithStack(this._stack);	36✔
138	} else {
139	// Stack from wrapped error
140	msg = detailsWithStack(this.stack);	132✔
141	}
142	return message(msg, this);	180✔
143	}
144
145	msg = this._messageWithDetails();	144✔
146	return message(msg, this);	144✔
147	};
148
149	// Format the output message
150	function message(msg, thisArg) {
151	var sig = colors.red(thisArg.name);	324✔
152	sig += ' in plugin ';	324✔
153	sig += '"' + colors.cyan(thisArg.plugin) + '"';	324✔
154	sig += '\n';	324✔
155	sig += msg;	324✔
156	return sig;	324✔
157	}
158
159	/**
160	* Set default options based on arguments.
161	*/
162
163	function setDefaults(plugin, message, opts) {
164	if (typeof plugin === 'object') {	324✔
165	return defaults(plugin);	12✔
166	}
167	opts = opts \|\| {};	312✔
168	if (message instanceof Error) {	312✔
169	opts.error = message;	108✔
170	} else if (typeof message === 'object') {	204✔
171	opts = message;	24✔
172	} else {
173	opts.message = message;	180✔
174	}
175	opts.plugin = plugin;	312✔
176	return defaults(opts);	312✔
177	}
178
179	/**
180	* Extend default options with:
181	*
182	* - `showStack`: default=false
183	* - `showProperties`: default=true
184	*
185	* @param {Object} `opts` Options to extend
186	* @return {Object}
187	*/
188
189	function defaults(opts) {
190	return Object.assign(	324✔
191	{
192	showStack: false,
193	showProperties: true,
194	},
195	opts
196	);
197	}
198
199	/**
200	* Expose `PluginError`
201	*/
202
203	module.exports = PluginError;	12✔

gulpjs / plugin-error / 2599143908

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous