refactor(utils): moving clone to helpers/clone

Since clone has some dependencies from utils, also:
- specialProperties to helpers/specialProperties;
- isMongooseObject to helpers/isMongooseObject;
- getFunctionName to helpers/getFunctionName;
- isBsonType to helpers/isBsonType;
- isObject to helpers/isObject.

I'd resisted to temptation to refactor methods, with two exception:
- util.object.vals changed by Object.values;
- utils.each changed forEach.

Updated reference from utils to helpers at:
- lib/browserDocument.js;
- lib/cast.js;
- lib/drivers/node-mongodb-native/collection.js;
- lib/helpers/common.js;
- lib/helpers/schema/getIndexes.js;
- lib/options/PopulateOptions.js;
- lib/options/SchemaTypeOptions.js;
- lib/options/removeOptions.js;
- lib/options/saveOptions.js;
- lib/queryhelpers.js;
- lib/schema/mixed.js;
- lib/types/map.js.

Author: Hugo Ribeiro

lib/browserDocument.js

@@ -11,7 +11,7 @@ const Schema = require('./schema');
 const ObjectId = require('./types/objectid');
 const ValidationError = MongooseError.ValidationError;
 const applyHooks = require('./helpers/model/applyHooks');
-const utils = require('./utils');
+const isObject = require('./helpers/isObject');
 
 /**
  * Document constructor.
@@ -30,7 +30,7 @@ function Document(obj, schema, fields, skipId, skipInit) {
     return new Document(obj, schema, fields, skipId, skipInit);
   }
 
-  if (utils.isObject(schema) && !schema.instanceOfSchema) {
+  if (isObject(schema) && !schema.instanceOfSchema) {
     schema = new Schema(schema);
   }
 
@@ -85,14 +85,12 @@ Document.events = new EventEmitter();
 
 Document.$emitter = new EventEmitter();
 
-utils.each(
-  ['on', 'once', 'emit', 'listeners', 'removeListener', 'setMaxListeners',
-    'removeAllListeners', 'addListener'],
-  function(emitterFn) {
-    Document[emitterFn] = function() {
-      return Document.$emitter[emitterFn].apply(Document.$emitter, arguments);
-    };
-  });
+['on', 'once', 'emit', 'listeners', 'removeListener', 'setMaxListeners',
+  'removeAllListeners', 'addListener'].forEach(function(emitterFn) {
+  Document[emitterFn] = function() {
+    return Document.$emitter[emitterFn].apply(Document.$emitter, arguments);
+  };
+});
 
 /*!
  * Module exports.

lib/cast.js

@@ -10,7 +10,8 @@ const castTextSearch = require('./schema/operators/text');
 const get = require('./helpers/get');
 const isOperator = require('./helpers/query/isOperator');
 const util = require('util');
-const utils = require('./utils');
+const isObject = require('./helpers/isObject');
+const isMongooseObject = require('./helpers/isMongooseObject');
 
 const ALLOWED_GEOWITHIN_GEOJSON_TYPES = ['Polygon', 'MultiPolygon'];
 
@@ -139,7 +140,7 @@ module.exports = function cast(schema, obj, options, context) {
           continue;
         }
 
-        if (utils.isObject(val)) {
+        if (isObject(val)) {
           // handle geo schemas that use object notation
           // { loc: { long: Number, lat: Number }
 
@@ -203,7 +204,7 @@ module.exports = function cast(schema, obj, options, context) {
                   context: context
                 });
               }
-              if (utils.isMongooseObject(value.$geometry)) {
+              if (isMongooseObject(value.$geometry)) {
                 value.$geometry = value.$geometry.toObject({
                   transform: false,
                   virtuals: false
@@ -212,7 +213,7 @@ module.exports = function cast(schema, obj, options, context) {
               value = value.$geometry.coordinates;
             } else if (geo === '$geoWithin') {
               if (value.$geometry) {
-                if (utils.isMongooseObject(value.$geometry)) {
+                if (isMongooseObject(value.$geometry)) {
                   value.$geometry = value.$geometry.toObject({ virtuals: false });
                 }
                 const geoWithinType = value.$geometry.type;
@@ -224,7 +225,7 @@ module.exports = function cast(schema, obj, options, context) {
               } else {
                 value = value.$box || value.$polygon || value.$center ||
                   value.$centerSphere;
-                if (utils.isMongooseObject(value)) {
+                if (isMongooseObject(value)) {
                   value = value.toObject({ virtuals: false });
                 }
               }
@@ -325,7 +326,7 @@ module.exports = function cast(schema, obj, options, context) {
 function _cast(val, numbertype, context) {
   if (Array.isArray(val)) {
     val.forEach(function(item, i) {
-      if (Array.isArray(item) || utils.isObject(item)) {
+      if (Array.isArray(item) || isObject(item)) {
         return _cast(item, numbertype, context);
       }
       val[i] = numbertype.castForQueryWrapper({ val: item, context: context });
@@ -336,7 +337,7 @@ function _cast(val, numbertype, context) {
     while (nearLen--) {
       const nkey = nearKeys[nearLen];
       const item = val[nkey];
-      if (Array.isArray(item) || utils.isObject(item)) {
+      if (Array.isArray(item) || isObject(item)) {
         _cast(item, numbertype, context);
         val[nkey] = item;
       } else {

lib/drivers/node-mongodb-native/collection.js

@@ -276,7 +276,8 @@ function format(obj, sub, color) {
     return obj;
   }
 
-  let x = require('../../utils').clone(obj, {transform: false});
+  const clone = require('../../helpers/clone');
+  let x = clone(obj, {transform: false});
 
   if (x.constructor.name === 'Binary') {
     x = 'BinData(' + x.sub_type + ', "' + x.toString('base64') + '")';

lib/helpers/clone.js

@@ -0,0 +1,135 @@
+'use strict';
+
+
+const cloneRegExp = require('regexp-clone');
+const Decimal = require('../types/decimal128');
+const ObjectId = require('../types/objectid');
+const specialProperties = require('./specialProperties');
+const isMongooseObject = require('./isMongooseObject');
+const getFunctionName = require('./getFunctionName');
+const isBsonType = require('./isBsonType');
+const isObject = require('./isObject');
+const symbols = require('./symbols');
+
+
+/*!
+ * Object clone with Mongoose natives support.
+ *
+ * If options.minimize is true, creates a minimal data object. Empty objects and undefined values will not be cloned. This makes the data payload sent to MongoDB as small as possible.
+ *
+ * Functions are never cloned.
+ *
+ * @param {Object} obj the object to clone
+ * @param {Object} options
+ * @param {Boolean} isArrayChild true if cloning immediately underneath an array. Special case for minimize.
+ * @return {Object} the cloned object
+ * @api private
+ */
+
+function clone(obj, options, isArrayChild) {
+  if (obj == null) {
+    return obj;
+  }
+
+  if (Array.isArray(obj)) {
+    return cloneArray(obj, options);
+  }
+
+  if (isMongooseObject(obj)) {
+    // Single nested subdocs should apply getters later in `applyGetters()`
+    // when calling `toObject()`. See gh-7442, gh-8295
+    if (options && options._skipSingleNestedGetters && obj.$isSingleNested) {
+      options = Object.assign({}, options, { getters: false });
+    }
+    if (options && options.json && typeof obj.toJSON === 'function') {
+      return obj.toJSON(options);
+    }
+    return obj.toObject(options);
+  }
+
+  if (obj.constructor) {
+    switch (getFunctionName(obj.constructor)) {
+      case 'Object':
+        return cloneObject(obj, options, isArrayChild);
+      case 'Date':
+        return new obj.constructor(+obj);
+      case 'RegExp':
+        return cloneRegExp(obj);
+      default:
+        // ignore
+        break;
+    }
+  }
+
+  if (obj instanceof ObjectId) {
+    return new ObjectId(obj.id);
+  }
+
+  if (isBsonType(obj, 'Decimal128')) {
+    if (options && options.flattenDecimals) {
+      return obj.toJSON();
+    }
+    return Decimal.fromString(obj.toString());
+  }
+
+  if (!obj.constructor && isObject(obj)) {
+    // object created with Object.create(null)
+    return cloneObject(obj, options, isArrayChild);
+  }
+
+  if (obj[symbols.schemaTypeSymbol]) {
+    return obj.clone();
+  }
+
+  // If we're cloning this object to go into a MongoDB command,
+  // and there's a `toBSON()` function, assume this object will be
+  // stored as a primitive in MongoDB and doesn't need to be cloned.
+  if (options && options.bson && typeof obj.toBSON === 'function') {
+    return obj;
+  }
+
+  if (obj.valueOf != null) {
+    return obj.valueOf();
+  }
+
+  return cloneObject(obj, options, isArrayChild);
+}
+module.exports = clone;
+
+/*!
+ * ignore
+ */
+
+function cloneObject(obj, options, isArrayChild) {
+  const minimize = options && options.minimize;
+  const ret = {};
+  let hasKeys;
+
+  for (const k in obj) {
+    if (specialProperties.has(k)) {
+      continue;
+    }
+
+    // Don't pass `isArrayChild` down
+    const val = clone(obj[k], options);
+
+    if (!minimize || (typeof val !== 'undefined')) {
+      if (minimize === false && typeof val === 'undefined') {
+        delete ret[k];
+      } else {
+        hasKeys || (hasKeys = true);
+        ret[k] = val;
+      }
+    }
+  }
+
+  return minimize && !isArrayChild ? hasKeys && ret : ret;
+}
+
+function cloneArray(arr, options) {
+  const ret = [];
+  for (let i = 0, l = arr.length; i < l; i++) {
+    ret.push(clone(arr[i], options, true));
+  }
+  return ret;
+}

lib/helpers/common.js

@@ -6,7 +6,7 @@
 
 const Decimal128 = require('../types/decimal128');
 const ObjectId = require('../types/objectid');
-const utils = require('../utils');
+const isMongooseObject = require('./isMongooseObject');
 
 exports.flatten = flatten;
 exports.modifiedPaths = modifiedPaths;
@@ -17,7 +17,7 @@ exports.modifiedPaths = modifiedPaths;
 
 function flatten(update, path, options, schema) {
   let keys;
-  if (update && utils.isMongooseObject(update) && !Buffer.isBuffer(update)) {
+  if (update && isMongooseObject(update) && !Buffer.isBuffer(update)) {
     keys = Object.keys(update.toObject({ transform: false, virtuals: false }));
   } else {
     keys = Object.keys(update || {});
@@ -78,7 +78,7 @@ function modifiedPaths(update, path, result) {
     let val = update[key];
 
     result[path + key] = true;
-    if (utils.isMongooseObject(val) && !Buffer.isBuffer(val)) {
+    if (isMongooseObject(val) && !Buffer.isBuffer(val)) {
       val = val.toObject({ transform: false, virtuals: false });
     }
     if (shouldFlatten(val)) {

lib/helpers/getFunctionName.js

@@ -0,0 +1,8 @@
+'use strict';
+
+module.exports = function(fn) {
+  if (fn.name) {
+    return fn.name;
+  }
+  return (fn.toString().trim().match(/^function\s*([^\s(]+)/) || [])[1];
+};

lib/helpers/isBsonType.js

@@ -0,0 +1,13 @@
+'use strict';
+
+const get = require('./get');
+
+/*!
+ * Get the bson type, if it exists
+ */
+
+function isBsonType(obj, typename) {
+  return get(obj, '_bsontype', void 0) === typename;
+}
+
+module.exports = isBsonType;

lib/helpers/isMongooseObject.js

@@ -0,0 +1,21 @@
+'use strict';
+
+/*!
+ * Returns if `v` is a mongoose object that has a `toObject()` method we can use.
+ *
+ * This is for compatibility with libs like Date.js which do foolish things to Natives.
+ *
+ * @param {any} v
+ * @api private
+ */
+
+module.exports = function(v) {
+  if (v == null) {
+    return false;
+  }
+
+  return v.$__ != null || // Document
+    v.isMongooseArray || // Array or Document Array
+    v.isMongooseBuffer || // Buffer
+    v.$isMongooseMap; // Map
+};

lib/helpers/isObject.js

@@ -0,0 +1,16 @@
+'use strict';
+
+/*!
+ * Determines if `arg` is an object.
+ *
+ * @param {Object|Array|String|Function|RegExp|any} arg
+ * @api private
+ * @return {Boolean}
+ */
+
+module.exports = function(arg) {
+  if (Buffer.isBuffer(arg)) {
+    return true;
+  }
+  return Object.prototype.toString.call(arg) === '[object Object]';
+};

lib/helpers/schema/getIndexes.js

@@ -1,7 +1,7 @@
 'use strict';
 
 const get = require('../get');
-const utils = require('../../utils');
+const helperIsObject = require('../isObject');
 
 /*!
  * Gather all indexes defined in the schema, including single nested,
@@ -62,7 +62,7 @@ module.exports = function getIndexes(schema) {
 
       if (index !== false && index !== null && index !== undefined) {
         const field = {};
-        const isObject = utils.isObject(index);
+        const isObject = helperIsObject(index);
         const options = isObject ? index : {};
         const type = typeof index === 'string' ? index :
           isObject ? index.type :

lib/helpers/specialProperties.js

@@ -0,0 +1,3 @@
+'use strict';
+
+module.exports = new Set(['__proto__', 'constructor', 'prototype']);

lib/options/PopulateOptions.js

@@ -1,6 +1,6 @@
 'use strict';
 
-const utils = require('../utils');
+const clone = require('../helpers/clone');
 
 class PopulateOptions {
   constructor(obj) {
@@ -9,7 +9,7 @@ class PopulateOptions {
     if (obj == null) {
       return;
     }
-    obj = utils.clone(obj);
+    obj = clone(obj);
     Object.assign(this, obj);
     if (typeof obj.subPopulate === 'object') {
       this.populate = obj.subPopulate;

lib/options/SchemaTypeOptions.js

@@ -1,6 +1,6 @@
 'use strict';
 
-const utils = require('../utils');
+const clone = require('../helpers/clone');
 
 /**
  * The options defined on a schematype.
@@ -19,7 +19,7 @@ class SchemaTypeOptions {
     if (obj == null) {
       return this;
     }
-    Object.assign(this, utils.clone(obj));
+    Object.assign(this, clone(obj));
   }
 }