feat(minErr): set max depth for angular error JSON stringify

Closes #15402
Closes #15433

Author: m-amr

src/Angular.js

@@ -796,6 +796,7 @@ function arrayRemove(array, value) {
  *   are deleted and then all elements/properties from the source are copied to it.
  * * If `source` is not an object or array (inc. `null` and `undefined`), `source` is returned.
  * * If `source` is identical to `destination` an exception will be thrown.
+ * * If `maxDepth`is supplied, all properties of the source will be copied until reaching the maxDepth.
  *
  * <br />
  * <div class="alert alert-warning">
@@ -807,6 +808,7 @@ function arrayRemove(array, value) {
  *                   Can be any type, including primitives, `null`, and `undefined`.
  * @param {(Object|Array)=} destination Destination into which the source is copied. If
  *     provided, must be of the same type as `source`.
+ * @param {Number} maxDepth all properties of the source will be copied until reaching the maxDepth.
  * @returns {*} The copy or updated `destination`, if `destination` was specified.
  *
  * @example
@@ -847,9 +849,13 @@ function arrayRemove(array, value) {
     </file>
   </example>
  */
-function copy(source, destination) {
+function copy(source, destination, maxDepth) {
   var stackSource = [];
   var stackDest = [];
+  var currentDepth = 0;
+  if (!isNumber(maxDepth)) {
+    maxDepth = NaN;
+  }
 
   if (destination) {
     if (isTypedArray(destination) || isArrayBuffer(destination)) {
@@ -872,43 +878,47 @@ function copy(source, destination) {
 
     stackSource.push(source);
     stackDest.push(destination);
-    return copyRecurse(source, destination);
+    return copyRecurse(source, destination, currentDepth);
   }
 
-  return copyElement(source);
+  return copyElement(source, currentDepth);
 
-  function copyRecurse(source, destination) {
+  function copyRecurse(source, destination, currentDepth) {
+    currentDepth++;
+    if (currentDepth > maxDepth) {
+      return '...';
+    }
     var h = destination.$$hashKey;
     var key;
     if (isArray(source)) {
       for (var i = 0, ii = source.length; i < ii; i++) {
-        destination.push(copyElement(source[i]));
+        destination.push(copyElement(source[i], currentDepth));
       }
     } else if (isBlankObject(source)) {
       // createMap() fast path --- Safe to avoid hasOwnProperty check because prototype chain is empty
       for (key in source) {
-        destination[key] = copyElement(source[key]);
+        destination[key] = copyElement(source[key], currentDepth);
       }
     } else if (source && typeof source.hasOwnProperty === 'function') {
       // Slow path, which must rely on hasOwnProperty
       for (key in source) {
         if (source.hasOwnProperty(key)) {
-          destination[key] = copyElement(source[key]);
+          destination[key] = copyElement(source[key], currentDepth);
         }
       }
     } else {
       // Slowest path --- hasOwnProperty can't be called as a method
       for (key in source) {
         if (hasOwnProperty.call(source, key)) {
-          destination[key] = copyElement(source[key]);
+          destination[key] = copyElement(source[key], currentDepth);
         }
       }
     }
     setHashKey(destination, h);
     return destination;
   }
 
-  function copyElement(source) {
+  function copyElement(source, currentDepth) {
     // Simple values
     if (!isObject(source)) {
       return source;
@@ -937,7 +947,7 @@ function copy(source, destination) {
     stackDest.push(destination);
 
     return needsRecurse
-      ? copyRecurse(source, destination)
+      ? copyRecurse(source, destination, currentDepth)
       : destination;
   }
 

src/minErr.js

@@ -34,19 +34,21 @@ function minErr(module, ErrorConstructor) {
   ErrorConstructor = ErrorConstructor || Error;
   return function() {
     var SKIP_INDEXES = 2;
+    var DEFAULT_MAX_DEPTH = 3;
 
     var templateArgs = arguments,
       code = templateArgs[0],
       message = '[' + (module ? module + ':' : '') + code + '] ',
       template = templateArgs[1],
       paramPrefix, i;
 
-    message += template.replace(/\{\d+\}/g, function(match) {
-      var index = +match.slice(1, -1),
-        shiftedIndex = index + SKIP_INDEXES;
+    message += template.replace(/\{(\d)+(,maxDepth=(\d))?\}/g, function(match, index, maxDepthString, maxDepth, offset, wholeString) {
+      index = Number(index);
+      maxDepth = isUndefined(maxDepth) ? DEFAULT_MAX_DEPTH : Number(maxDepth);
+      var shiftedIndex = index + SKIP_INDEXES;
 
       if (shiftedIndex < templateArgs.length) {
-        return toDebugString(templateArgs[shiftedIndex]);
+        return toDebugString(templateArgs[shiftedIndex], maxDepth);
       }
 
       return match;
@@ -57,7 +59,7 @@ function minErr(module, ErrorConstructor) {
 
     for (i = SKIP_INDEXES, paramPrefix = '?'; i < templateArgs.length; i++, paramPrefix = '&') {
       message += paramPrefix + 'p' + (i - SKIP_INDEXES) + '=' +
-        encodeURIComponent(toDebugString(templateArgs[i]));
+        encodeURIComponent(toDebugString(templateArgs[i], DEFAULT_MAX_DEPTH));
     }
 
     return new ErrorConstructor(message);

src/stringify.js

@@ -2,9 +2,11 @@
 
 /* global toDebugString: true */
 
-function serializeObject(obj) {
+function serializeObject(obj, maxDepth) {
   var seen = [];
-
+  if (maxDepth > 0) {
+    obj = copy(obj, null, maxDepth);
+  }
   return JSON.stringify(obj, function(key, val) {
     val = toJsonReplacer(key, val);
     if (isObject(val)) {
@@ -17,13 +19,13 @@ function serializeObject(obj) {
   });
 }
 
-function toDebugString(obj) {
+function toDebugString(obj, maxDepth) {
   if (typeof obj === 'function') {
     return obj.toString().replace(/ \{[\s\S]*$/, '');
   } else if (isUndefined(obj)) {
     return 'undefined';
   } else if (typeof obj !== 'string') {
-    return serializeObject(obj);
+    return serializeObject(obj, maxDepth);
   }
   return obj;
 }

test/AngularSpec.js

@@ -602,6 +602,27 @@ describe('angular', function() {
       expect(copy(new Number(NaN)).valueOf()).toBeNaN();
       /* eslint-enable */
     });
+
+    it('should copy source until reaching a given max depth', function() {
+      var destinationA = {};
+      var destinationB = {};
+
+      destinationA = copy({a:1}, destinationB, 1);
+      expect(destinationA).toEqual({a:1});
+      expect(destinationB).toEqual({a:1});
+
+      destinationA = {};
+      destinationB = {};
+      destinationA = copy({a:{b:1}}, destinationB, 1);
+      expect(destinationA).toEqual({a:'...'});
+      expect(destinationB).toEqual({a:'...'});
+
+      destinationA = {};
+      destinationB = {};
+      destinationA = copy({a:{b:{c:1}}}, destinationB, 2);
+      expect(destinationA).toEqual({a:{b:'...'}});
+      expect(destinationB).toEqual({a:{b:'...'}});
+    });
   });
 
   describe('extend', function() {

test/minErrSpec.js

@@ -68,6 +68,15 @@ describe('minErr', function() {
     expect(myError.message).toMatch(/a is {"b":{"a":"..."}}/);
   });
 
+  it('should handle arguments that are objects with max depth', function() {
+    var a = { b: {c:{d:1}} };
+    var myError = testError('26', 'a when maxDepth=1 is {0,maxDepth=1}', a);
+    expect(myError.message).toMatch(/a when maxDepth=1 is {"b":"..."}/);
+
+    myError = testError('26', 'a when maxDepth=2 is {0,maxDepth=2}', a);
+    expect(myError.message).toMatch(/a when maxDepth=2 is {"b":{"c":"..."}}/);
+  });
+
   it('should preserve interpolation markers when fewer arguments than needed are provided', function() {
     // this way we can easily see if we are passing fewer args than needed