text: /**
   * @fileoverview Rule to flag adding properties to native object's prototypes.
   * @author David Nelson
   */
  
  "use strict";
  
  //------------------------------------------------------------------------------
  // Requirements
  //------------------------------------------------------------------------------
  
  const globals = require("globals");
  
  //------------------------------------------------------------------------------
  // Rule Definition
  //------------------------------------------------------------------------------
  
  module.exports = {
      meta: {
          docs: {
              description: "disallow extending native types",
              category: "Best Practices",
              recommended: false
          },
  
          schema: [
              {
                  type: "object",
                  properties: {
                      exceptions: {
                          type: "array",
                          items: {
                              type: "string"
                          },
                          uniqueItems: true
                      }
                  },
                  additionalProperties: false
              }
          ]
      },
  
      create(context) {
  
          const config = context.options[0] || {};
          const exceptions = config.exceptions || [];
          let modifiedBuiltins = Object.keys(globals.builtin).filter(builtin => builtin[0].toUpperCase() === builtin[0]);
  
          if (exceptions.length) {
              modifiedBuiltins = modifiedBuiltins.filter(builtIn => exceptions.indexOf(builtIn) === -1);
          }
  
          return {
  
              // handle the Array.prototype.extra style case
              AssignmentExpression(node) {
                  const lhs = node.left;
  
                  if (lhs.type !== "MemberExpression" || lhs.object.type !== "MemberExpression") {
                      return;
                  }
  
                  const affectsProto = lhs.object.computed ?
                      lhs.object.property.type === "Literal" && lhs.object.property.value === "prototype" :
                      lhs.object.property.name === "prototype";
  
                  if (!affectsProto) {
                      return;
                  }
  
                  modifiedBuiltins.forEach(builtin => {
                      if (lhs.object.object.name === builtin) {
                          context.report({
                              node,
                              message: "{{builtin}} prototype is read only, properties should not be added.",
                              data: {
                                  builtin
                              }
                          });
                      }
                  });
              },
  
              // handle the Object.definePropert[y|ies](Array.prototype) case
              CallExpression(node) {
  
                  const callee = node.callee;
  
                  // only worry about Object.definePropert[y|ies]
                  if (callee.type === "MemberExpression" &&
                      callee.object.name === "Object" &&
                      (callee.property.name === "defineProperty" || callee.property.name === "defineProperties")) {
  
                      // verify the object being added to is a native prototype
                      const subject = node.arguments[0];
                      const object = subject && subject.object;
  
                      if (object &&
                          object.type === "Identifier" &&
                          (modifiedBuiltins.indexOf(object.name) > -1) &&
                          subject.property.name === "prototype") {
  
                          context.report({
                              node,
                              message: "{{objectName}} prototype is read only, properties should not be added.",
                              data: {
                                  objectName: object.name
                              }
                          });
                      }
                  }
  
              }
          };
  
      }
  };
  