assert: move AssertionError into own file

This moves the `assert` parts from `internal/errors` into an own
file. `internal/errors` got bigger and bigger and it was difficult
to keep a good overview of what was going on. While doing so it
also removes the `internalAssert` function and just lazy loads
`assert`.
PR-URL: #20486
Reviewed-By: James M Snell <jasnell@gmail.com>
Reviewed-By: Joyee Cheung <joyeec9h3@gmail.com>
Reviewed-By: Trivikram Kamat <trivikr.dev@gmail.com>

Author: BridgeAR

lib/assert.js

@@ -25,15 +25,12 @@ const {
  isDeepEqual,
  isDeepStrictEqual
 }=require('internal/util/comparisons');
-const{
- AssertionError,
- errorCache,
-codes: {
-ERR_AMBIGUOUS_ARGUMENT,
-ERR_INVALID_ARG_TYPE,
-ERR_INVALID_RETURN_VALUE
-}
-}=require('internal/errors');
+const{codes: {
+ERR_AMBIGUOUS_ARGUMENT,
+ERR_INVALID_ARG_TYPE,
+ERR_INVALID_RETURN_VALUE
+}}=require('internal/errors');
+const{ AssertionError, errorCache }=require('internal/assert');
 const{ openSync, closeSync, readSync }=require('fs');
 const{ inspect,types: { isPromise, isRegExp }}=require('util');
 const{EOL}=require('os');

lib/internal/assert.js

@@ -0,0 +1,275 @@
+'use strict';
+
+const{ inspect }=require('util');
+const{codes: {
+ERR_INVALID_ARG_TYPE
+}}=require('internal/errors');
+
+letblue='';
+letgreen='';
+letred='';
+letwhite='';
+
+constREADABLE_OPERATOR={
+deepStrictEqual: 'Input A expected to strictly deep-equal input B',
+notDeepStrictEqual: 'Input A expected to strictly not deep-equal input B',
+strictEqual: 'Input A expected to strictly equal input B',
+notStrictEqual: 'Input A expected to strictly not equal input B'
+};
+
+functioncopyError(source){
+constkeys=Object.keys(source);
+consttarget=Object.create(Object.getPrototypeOf(source));
+for(constkeyofkeys){
+target[key]=source[key];
+}
+Object.defineProperty(target,'message',{value: source.message});
+returntarget;
+}
+
+functioninspectValue(val){
+// The util.inspect default values could be changed. This makes sure the
+// error messages contain the necessary information nevertheless.
+returninspect(
+val,
+{
+compact: false,
+customInspect: false,
+depth: 1000,
+maxArrayLength: Infinity,
+// Assert compares only enumerable properties (with a few exceptions).
+showHidden: false,
+// Having a long line as error is better than wrapping the line for
+// comparison.
+breakLength: Infinity,
+// Assert does not detect proxies currently.
+showProxy: false
+}
+).split('\n');
+}
+
+functioncreateErrDiff(actual,expected,operator){
+varother='';
+varres='';
+varlastPos=0;
+varend='';
+varskipped=false;
+constactualLines=inspectValue(actual);
+constexpectedLines=inspectValue(expected);
+constmsg=READABLE_OPERATOR[operator]+
+`:\n${green}+ expected${white}${red}- actual${white}`;
+constskippedMsg=` ${blue}...${white} Lines skipped`;
+
+// Remove all ending lines that match (this optimizes the output for
+// readability by reducing the number of total changed lines).
+vara=actualLines[actualLines.length-1];
+varb=expectedLines[expectedLines.length-1];
+vari=0;
+while(a===b){
+if(i++<2){
+end=`\n ${a}${end}`;
+}else{
+other=a;
+}
+actualLines.pop();
+expectedLines.pop();
+if(actualLines.length===0||expectedLines.length===0)
+break;
+a=actualLines[actualLines.length-1];
+b=expectedLines[expectedLines.length-1];
+}
+if(i>3){
+end=`\n${blue}...${white}${end}`;
+skipped=true;
+}
+if(other!==''){
+end=`\n ${other}${end}`;
+other='';
+}
+
+constmaxLines=Math.max(actualLines.length,expectedLines.length);
+varprintedLines=0;
+varidentical=0;
+for(i=0;i<maxLines;i++){
+// Only extra expected lines exist
+constcur=i-lastPos;
+if(actualLines.length<i+1){
+if(cur>1&&i>2){
+if(cur>4){
+res+=`\n${blue}...${white}`;
+skipped=true;
+}elseif(cur>3){
+res+=`\n ${expectedLines[i-2]}`;
+printedLines++;
+}
+res+=`\n ${expectedLines[i-1]}`;
+printedLines++;
+}
+lastPos=i;
+other+=`\n${green}+${white}${expectedLines[i]}`;
+printedLines++;
+// Only extra actual lines exist
+}elseif(expectedLines.length<i+1){
+if(cur>1&&i>2){
+if(cur>4){
+res+=`\n${blue}...${white}`;
+skipped=true;
+}elseif(cur>3){
+res+=`\n ${actualLines[i-2]}`;
+printedLines++;
+}
+res+=`\n ${actualLines[i-1]}`;
+printedLines++;
+}
+lastPos=i;
+res+=`\n${red}-${white}${actualLines[i]}`;
+printedLines++;
+// Lines diverge
+}elseif(actualLines[i]!==expectedLines[i]){
+if(cur>1&&i>2){
+if(cur>4){
+res+=`\n${blue}...${white}`;
+skipped=true;
+}elseif(cur>3){
+res+=`\n ${actualLines[i-2]}`;
+printedLines++;
+}
+res+=`\n ${actualLines[i-1]}`;
+printedLines++;
+}
+lastPos=i;
+res+=`\n${red}-${white}${actualLines[i]}`;
+other+=`\n${green}+${white}${expectedLines[i]}`;
+printedLines+=2;
+// Lines are identical
+}else{
+res+=other;
+other='';
+if(cur===1||i===0){
+res+=`\n ${actualLines[i]}`;
+printedLines++;
+}
+identical++;
+}
+// Inspected object to big (Show ~20 rows max)
+if(printedLines>20&&i<maxLines-2){
+return`${msg}${skippedMsg}\n${res}\n${blue}...${white}${other}\n`+
+`${blue}...${white}`;
+}
+}
+
+// Strict equal with identical objects that are not identical by reference.
+if(identical===maxLines){
+// E.g., assert.deepStrictEqual(Symbol(), Symbol())
+constbase=operator==='strictEqual' ?
+'Input objects identical but not reference equal:' :
+'Input objects not identical:';
+
+// We have to get the result again. The lines were all removed before.
+constactualLines=inspectValue(actual);
+
+// Only remove lines in case it makes sense to collapse those.
+// TODO: Accept env to always show the full error.
+if(actualLines.length>30){
+actualLines[26]=`${blue}...${white}`;
+while(actualLines.length>27){
+actualLines.pop();
+}
+}
+
+return`${base}\n\n${actualLines.join('\n')}\n`;
+}
+return`${msg}${skipped ? skippedMsg : ''}\n${res}${other}${end}`;
+}
+
+classAssertionErrorextendsError{
+constructor(options){
+if(typeofoptions!=='object'||options===null){
+thrownewERR_INVALID_ARG_TYPE('options','Object',options);
+}
+var{
+ actual,
+ expected,
+ message,
+ operator,
+ stackStartFn
+}=options;
+
+if(message!=null){
+super(message);
+}else{
+if(process.stdout.isTTY){
+// Reset on each call to make sure we handle dynamically set environment
+// variables correct.
+if(process.stdout.getColorDepth()!==1){
+blue='\u001b[34m';
+green='\u001b[32m';
+white='\u001b[39m';
+red='\u001b[31m';
+}else{
+blue='';
+green='';
+white='';
+red='';
+}
+}
+// Prevent the error stack from being visible by duplicating the error
+// in a very close way to the original in case both sides are actually
+// instances of Error.
+if(typeofactual==='object'&&actual!==null&&
+typeofexpected==='object'&&expected!==null&&
+'stack'inactual&&actualinstanceofError&&
+'stack'inexpected&&expectedinstanceofError){
+actual=copyError(actual);
+expected=copyError(expected);
+}
+
+if(operator==='deepStrictEqual'||operator==='strictEqual'){
+super(createErrDiff(actual,expected,operator));
+}elseif(operator==='notDeepStrictEqual'||
+operator==='notStrictEqual'){
+// In case the objects are equal but the operator requires unequal, show
+// the first object and say A equals B
+constres=inspectValue(actual);
+constbase=`Identical input passed to ${operator}:`;
+
+// Only remove lines in case it makes sense to collapse those.
+// TODO: Accept env to always show the full error.
+if(res.length>30){
+res[26]=`${blue}...${white}`;
+while(res.length>27){
+res.pop();
+}
+}
+
+// Only print a single input.
+if(res.length===1){
+super(`${base}${res[0]}`);
+}else{
+super(`${base}\n\n${res.join('\n')}\n`);
+}
+}else{
+letres=inspect(actual);
+letother=inspect(expected);
+if(res.length>128)
+res=`${res.slice(0,125)}...`;
+if(other.length>128)
+other=`${other.slice(0,125)}...`;
+super(`${res}${operator}${other}`);
+}
+}
+
+this.generatedMessage=!message;
+this.name='AssertionError [ERR_ASSERTION]';
+this.code='ERR_ASSERTION';
+this.actual=actual;
+this.expected=expected;
+this.operator=operator;
+Error.captureStackTrace(this,stackStartFn);
+}
+}
+
+module.exports={
+ AssertionError,
+errorCache: newMap()
+};