no-namespace.js

'use strict';




var _docsUrl = require('../docsUrl');var _docsUrl2 = _interopRequireDefault(_docsUrl);function _interopRequireDefault(obj) {return obj && obj.__esModule ? obj : { default: obj };}function _toConsumableArray(arr) {if (Array.isArray(arr)) {for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) arr2[i] = arr[i];return arr2;} else {return Array.from(arr);}} /**
                                                                                                                                                                                                                                                                                                                                                                             * @fileoverview Rule to disallow namespace import
                                                                                                                                                                                                                                                                                                                                                                             * @author Radek Benkel
                                                                                                                                                                                                                                                                                                                                                                             */ //------------------------------------------------------------------------------
// Rule Definition
//------------------------------------------------------------------------------

module.exports = {
  meta: {
    type: 'suggestion',
    docs: {
      url: (0, _docsUrl2.default)('no-namespace') },

    fixable: 'code',
    schema: [] },


  create: function (context) {
    return {
      'ImportNamespaceSpecifier': function (node) {
        const scopeVariables = context.getScope().variables;
        const namespaceVariable = scopeVariables.find(variable =>
        variable.defs[0].node === node);

        const namespaceReferences = namespaceVariable.references;
        const namespaceIdentifiers = namespaceReferences.map(reference => reference.identifier);
        const canFix = namespaceIdentifiers.length > 0 && !usesNamespaceAsObject(namespaceIdentifiers);

        context.report({
          node,
          message: `Unexpected namespace import.`,
          fix: canFix && (fixer => {
            const scopeManager = context.getSourceCode().scopeManager;
            const fixes = [];

            // Pass 1: Collect variable names that are already in scope for each reference we want
            // to transform, so that we can be sure that we choose non-conflicting import names
            const importNameConflicts = {};
            namespaceIdentifiers.forEach(identifier => {
              const parent = identifier.parent;
              if (parent && parent.type === 'MemberExpression') {
                const importName = getMemberPropertyName(parent);
                const localConflicts = getVariableNamesInScope(scopeManager, parent);
                if (!importNameConflicts[importName]) {
                  importNameConflicts[importName] = localConflicts;
                } else {
                  localConflicts.forEach(c => importNameConflicts[importName].add(c));
                }
              }
            });

            // Choose new names for each import
            const importNames = Object.keys(importNameConflicts);
            const importLocalNames = generateLocalNames(
            importNames,
            importNameConflicts,
            namespaceVariable.name);


            // Replace the ImportNamespaceSpecifier with a list of ImportSpecifiers
            const namedImportSpecifiers = importNames.map(importName =>
            importName === importLocalNames[importName] ?
            importName :
            `${importName} as ${importLocalNames[importName]}`);

            fixes.push(fixer.replaceText(node, `{ ${namedImportSpecifiers.join(', ')} }`));

            // Pass 2: Replace references to the namespace with references to the named imports
            namespaceIdentifiers.forEach(identifier => {
              const parent = identifier.parent;
              if (parent && parent.type === 'MemberExpression') {
                const importName = getMemberPropertyName(parent);
                fixes.push(fixer.replaceText(parent, importLocalNames[importName]));
              }
            });

            return fixes;
          }) });

      } };

  } };


/**
        * @param {Identifier[]} namespaceIdentifiers
        * @returns {boolean} `true` if the namespace variable is more than just a glorified constant
        */
function usesNamespaceAsObject(namespaceIdentifiers) {
  return !namespaceIdentifiers.every(identifier => {
    const parent = identifier.parent;

    // `namespace.x` or `namespace['x']`
    return (
      parent && parent.type === 'MemberExpression' && (
      parent.property.type === 'Identifier' || parent.property.type === 'Literal'));

  });
}

/**
   * @param {MemberExpression} memberExpression
   * @returns {string} the name of the member in the object expression, e.g. the `x` in `namespace.x`
   */
function getMemberPropertyName(memberExpression) {
  return memberExpression.property.type === 'Identifier' ?
  memberExpression.property.name :
  memberExpression.property.value;
}

/**
   * @param {ScopeManager} scopeManager
   * @param {ASTNode} node
   * @return {Set<string>}
   */
function getVariableNamesInScope(scopeManager, node) {
  let currentNode = node;
  let scope = scopeManager.acquire(currentNode);
  while (scope == null) {
    currentNode = currentNode.parent;
    scope = scopeManager.acquire(currentNode, true);
  }
  return new Set([].concat(_toConsumableArray(
  scope.variables.map(variable => variable.name)), _toConsumableArray(
  scope.upper.variables.map(variable => variable.name))));

}

/**
   *
   * @param {*} names
   * @param {*} nameConflicts
   * @param {*} namespaceName
   */
function generateLocalNames(names, nameConflicts, namespaceName) {
  const localNames = {};
  names.forEach(name => {
    let localName;
    if (!nameConflicts[name].has(name)) {
      localName = name;
    } else if (!nameConflicts[name].has(`${namespaceName}_${name}`)) {
      localName = `${namespaceName}_${name}`;
    } else {
      for (let i = 1; i < Infinity; i++) {
        if (!nameConflicts[name].has(`${namespaceName}_${name}_${i}`)) {
          localName = `${namespaceName}_${name}_${i}`;
          break;
        }
      }
    }
    localNames[name] = localName;
  });
  return localNames;
}
//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../src/rules/no-namespace.js"],"names":["module","exports","meta","type","docs","url","fixable","schema","create","context","node","scopeVariables","getScope","variables","namespaceVariable","find","variable","defs","namespaceReferences","references","namespaceIdentifiers","map","reference","identifier","canFix","length","usesNamespaceAsObject","report","message","fix","fixer","scopeManager","getSourceCode","fixes","importNameConflicts","forEach","parent","importName","getMemberPropertyName","localConflicts","getVariableNamesInScope","c","add","importNames","Object","keys","importLocalNames","generateLocalNames","name","namedImportSpecifiers","push","replaceText","join","every","property","memberExpression","value","currentNode","scope","acquire","Set","upper","names","nameConflicts","namespaceName","localNames","localName","has","i","Infinity"],"mappings":";;;;;AAKA,qC,uUALA;;;gXAOA;AACA;AACA;;AAGAA,OAAOC,OAAP,GAAiB;AACfC,QAAM;AACJC,UAAM,YADF;AAEJC,UAAM;AACJC,WAAK,uBAAQ,cAAR,CADD,EAFF;;AAKJC,aAAS,MALL;AAMJC,YAAQ,EANJ,EADS;;;AAUfC,UAAQ,UAAUC,OAAV,EAAmB;AACzB,WAAO;AACL,kCAA4B,UAAUC,IAAV,EAAgB;AAC1C,cAAMC,iBAAiBF,QAAQG,QAAR,GAAmBC,SAA1C;AACA,cAAMC,oBAAoBH,eAAeI,IAAf,CAAqBC,QAAD;AAC5CA,iBAASC,IAAT,CAAc,CAAd,EAAiBP,IAAjB,KAA0BA,IADF,CAA1B;;AAGA,cAAMQ,sBAAsBJ,kBAAkBK,UAA9C;AACA,cAAMC,uBAAuBF,oBAAoBG,GAApB,CAAwBC,aAAaA,UAAUC,UAA/C,CAA7B;AACA,cAAMC,SAASJ,qBAAqBK,MAArB,GAA8B,CAA9B,IAAmC,CAACC,sBAAsBN,oBAAtB,CAAnD;;AAEAX,gBAAQkB,MAAR,CAAe;AACbjB,cADa;AAEbkB,mBAAU,8BAFG;AAGbC,eAAKL,WAAWM,SAAS;AACvB,kBAAMC,eAAetB,QAAQuB,aAAR,GAAwBD,YAA7C;AACA,kBAAME,QAAQ,EAAd;;AAEA;AACA;AACA,kBAAMC,sBAAsB,EAA5B;AACAd,iCAAqBe,OAArB,CAA8BZ,UAAD,IAAgB;AAC3C,oBAAMa,SAASb,WAAWa,MAA1B;AACA,kBAAIA,UAAUA,OAAOjC,IAAP,KAAgB,kBAA9B,EAAkD;AAChD,sBAAMkC,aAAaC,sBAAsBF,MAAtB,CAAnB;AACA,sBAAMG,iBAAiBC,wBAAwBT,YAAxB,EAAsCK,MAAtC,CAAvB;AACA,oBAAI,CAACF,oBAAoBG,UAApB,CAAL,EAAsC;AACpCH,sCAAoBG,UAApB,IAAkCE,cAAlC;AACD,iBAFD,MAEO;AACLA,iCAAeJ,OAAf,CAAwBM,CAAD,IAAOP,oBAAoBG,UAApB,EAAgCK,GAAhC,CAAoCD,CAApC,CAA9B;AACD;AACF;AACF,aAXD;;AAaA;AACA,kBAAME,cAAcC,OAAOC,IAAP,CAAYX,mBAAZ,CAApB;AACA,kBAAMY,mBAAmBC;AACvBJ,uBADuB;AAEvBT,+BAFuB;AAGvBpB,8BAAkBkC,IAHK,CAAzB;;;AAMA;AACA,kBAAMC,wBAAwBN,YAAYtB,GAAZ,CAAiBgB,UAAD;AAC5CA,2BAAeS,iBAAiBT,UAAjB,CAAf;AACIA,sBADJ;AAEK,eAAEA,UAAW,OAAMS,iBAAiBT,UAAjB,CAA6B,EAHzB,CAA9B;;AAKAJ,kBAAMiB,IAAN,CAAWpB,MAAMqB,WAAN,CAAkBzC,IAAlB,EAAyB,KAAIuC,sBAAsBG,IAAtB,CAA2B,IAA3B,CAAiC,IAA9D,CAAX;;AAEA;AACAhC,iCAAqBe,OAArB,CAA8BZ,UAAD,IAAgB;AAC3C,oBAAMa,SAASb,WAAWa,MAA1B;AACA,kBAAIA,UAAUA,OAAOjC,IAAP,KAAgB,kBAA9B,EAAkD;AAChD,sBAAMkC,aAAaC,sBAAsBF,MAAtB,CAAnB;AACAH,sBAAMiB,IAAN,CAAWpB,MAAMqB,WAAN,CAAkBf,MAAlB,EAA0BU,iBAAiBT,UAAjB,CAA1B,CAAX;AACD;AACF,aAND;;AAQA,mBAAOJ,KAAP;AACD,WA9CI,CAHQ,EAAf;;AAmDD,OA7DI,EAAP;;AA+DD,GA1Ec,EAAjB;;;AA6EA;;;;AAIA,SAASP,qBAAT,CAA+BN,oBAA/B,EAAqD;AACnD,SAAO,CAACA,qBAAqBiC,KAArB,CAA4B9B,UAAD,IAAgB;AACjD,UAAMa,SAASb,WAAWa,MAA1B;;AAEA;AACA;AACEA,gBAAUA,OAAOjC,IAAP,KAAgB,kBAA1B;AACCiC,aAAOkB,QAAP,CAAgBnD,IAAhB,KAAyB,YAAzB,IAAyCiC,OAAOkB,QAAP,CAAgBnD,IAAhB,KAAyB,SADnE,CADF;;AAID,GARO,CAAR;AASD;;AAED;;;;AAIA,SAASmC,qBAAT,CAA+BiB,gBAA/B,EAAiD;AAC/C,SAAOA,iBAAiBD,QAAjB,CAA0BnD,IAA1B,KAAmC,YAAnC;AACHoD,mBAAiBD,QAAjB,CAA0BN,IADvB;AAEHO,mBAAiBD,QAAjB,CAA0BE,KAF9B;AAGD;;AAED;;;;;AAKA,SAAShB,uBAAT,CAAiCT,YAAjC,EAA+CrB,IAA/C,EAAqD;AACnD,MAAI+C,cAAc/C,IAAlB;AACA,MAAIgD,QAAQ3B,aAAa4B,OAAb,CAAqBF,WAArB,CAAZ;AACA,SAAOC,SAAS,IAAhB,EAAsB;AACpBD,kBAAcA,YAAYrB,MAA1B;AACAsB,YAAQ3B,aAAa4B,OAAb,CAAqBF,WAArB,EAAkC,IAAlC,CAAR;AACD;AACD,SAAO,IAAIG,GAAJ;AACFF,QAAM7C,SAAN,CAAgBQ,GAAhB,CAAoBL,YAAYA,SAASgC,IAAzC,CADE;AAEFU,QAAMG,KAAN,CAAYhD,SAAZ,CAAsBQ,GAAtB,CAA0BL,YAAYA,SAASgC,IAA/C,CAFE,GAAP;;AAID;;AAED;;;;;;AAMA,SAASD,kBAAT,CAA4Be,KAA5B,EAAmCC,aAAnC,EAAkDC,aAAlD,EAAiE;AAC/D,QAAMC,aAAa,EAAnB;AACAH,QAAM3B,OAAN,CAAea,IAAD,IAAU;AACtB,QAAIkB,SAAJ;AACA,QAAI,CAACH,cAAcf,IAAd,EAAoBmB,GAApB,CAAwBnB,IAAxB,CAAL,EAAoC;AAClCkB,kBAAYlB,IAAZ;AACD,KAFD,MAEO,IAAI,CAACe,cAAcf,IAAd,EAAoBmB,GAApB,CAAyB,GAAEH,aAAc,IAAGhB,IAAK,EAAjD,CAAL,EAA0D;AAC/DkB,kBAAa,GAAEF,aAAc,IAAGhB,IAAK,EAArC;AACD,KAFM,MAEA;AACL,WAAK,IAAIoB,IAAI,CAAb,EAAgBA,IAAIC,QAApB,EAA8BD,GAA9B,EAAmC;AACjC,YAAI,CAACL,cAAcf,IAAd,EAAoBmB,GAApB,CAAyB,GAAEH,aAAc,IAAGhB,IAAK,IAAGoB,CAAE,EAAtD,CAAL,EAA+D;AAC7DF,sBAAa,GAAEF,aAAc,IAAGhB,IAAK,IAAGoB,CAAE,EAA1C;AACA;AACD;AACF;AACF;AACDH,eAAWjB,IAAX,IAAmBkB,SAAnB;AACD,GAfD;AAgBA,SAAOD,UAAP;AACD","file":"no-namespace.js","sourcesContent":["/**\n * @fileoverview Rule to disallow namespace import\n * @author Radek Benkel\n */\n\nimport docsUrl from '../docsUrl';\n\n//------------------------------------------------------------------------------\n// Rule Definition\n//------------------------------------------------------------------------------\n\n\nmodule.exports = {\n  meta: {\n    type: 'suggestion',\n    docs: {\n      url: docsUrl('no-namespace'),\n    },\n    fixable: 'code',\n    schema: [],\n  },\n\n  create: function (context) {\n    return {\n      'ImportNamespaceSpecifier': function (node) {\n        const scopeVariables = context.getScope().variables;\n        const namespaceVariable = scopeVariables.find((variable) =>\n          variable.defs[0].node === node\n        );\n        const namespaceReferences = namespaceVariable.references;\n        const namespaceIdentifiers = namespaceReferences.map(reference => reference.identifier);\n        const canFix = namespaceIdentifiers.length > 0 && !usesNamespaceAsObject(namespaceIdentifiers);\n\n        context.report({\n          node,\n          message: `Unexpected namespace import.`,\n          fix: canFix && (fixer => {\n            const scopeManager = context.getSourceCode().scopeManager;\n            const fixes = [];\n\n            // Pass 1: Collect variable names that are already in scope for each reference we want\n            // to transform, so that we can be sure that we choose non-conflicting import names\n            const importNameConflicts = {};\n            namespaceIdentifiers.forEach((identifier) => {\n              const parent = identifier.parent;\n              if (parent && parent.type === 'MemberExpression') {\n                const importName = getMemberPropertyName(parent);\n                const localConflicts = getVariableNamesInScope(scopeManager, parent);\n                if (!importNameConflicts[importName]) {\n                  importNameConflicts[importName] = localConflicts;\n                } else {\n                  localConflicts.forEach((c) => importNameConflicts[importName].add(c));\n                }\n              }\n            });\n\n            // Choose new names for each import\n            const importNames = Object.keys(importNameConflicts);\n            const importLocalNames = generateLocalNames(\n              importNames,\n              importNameConflicts,\n              namespaceVariable.name\n            );\n\n            // Replace the ImportNamespaceSpecifier with a list of ImportSpecifiers\n            const namedImportSpecifiers = importNames.map((importName) =>\n              importName === importLocalNames[importName]\n                ? importName\n                : `${importName} as ${importLocalNames[importName]}`\n            );\n            fixes.push(fixer.replaceText(node, `{ ${namedImportSpecifiers.join(', ')} }`));\n\n            // Pass 2: Replace references to the namespace with references to the named imports\n            namespaceIdentifiers.forEach((identifier) => {\n              const parent = identifier.parent;\n              if (parent && parent.type === 'MemberExpression') {\n                const importName = getMemberPropertyName(parent);\n                fixes.push(fixer.replaceText(parent, importLocalNames[importName]));\n              }\n            });\n\n            return fixes;\n          }),\n        });\n      },\n    };\n  },\n};\n\n/**\n * @param {Identifier[]} namespaceIdentifiers\n * @returns {boolean} `true` if the namespace variable is more than just a glorified constant\n */\nfunction usesNamespaceAsObject(namespaceIdentifiers) {\n  return !namespaceIdentifiers.every((identifier) => {\n    const parent = identifier.parent;\n\n    // `namespace.x` or `namespace['x']`\n    return (\n      parent && parent.type === 'MemberExpression' &&\n      (parent.property.type === 'Identifier' || parent.property.type === 'Literal')\n    );\n  });\n}\n\n/**\n * @param {MemberExpression} memberExpression\n * @returns {string} the name of the member in the object expression, e.g. the `x` in `namespace.x`\n */\nfunction getMemberPropertyName(memberExpression) {\n  return memberExpression.property.type === 'Identifier'\n    ? memberExpression.property.name\n    : memberExpression.property.value;\n}\n\n/**\n * @param {ScopeManager} scopeManager\n * @param {ASTNode} node\n * @return {Set<string>}\n */\nfunction getVariableNamesInScope(scopeManager, node) {\n  let currentNode = node;\n  let scope = scopeManager.acquire(currentNode);\n  while (scope == null) {\n    currentNode = currentNode.parent;\n    scope = scopeManager.acquire(currentNode, true);\n  }\n  return new Set([\n    ...scope.variables.map(variable => variable.name),\n    ...scope.upper.variables.map(variable => variable.name),\n  ]);\n}\n\n/**\n *\n * @param {*} names\n * @param {*} nameConflicts\n * @param {*} namespaceName\n */\nfunction generateLocalNames(names, nameConflicts, namespaceName) {\n  const localNames = {};\n  names.forEach((name) => {\n    let localName;\n    if (!nameConflicts[name].has(name)) {\n      localName = name;\n    } else if (!nameConflicts[name].has(`${namespaceName}_${name}`)) {\n      localName = `${namespaceName}_${name}`;\n    } else {\n      for (let i = 1; i < Infinity; i++) {\n        if (!nameConflicts[name].has(`${namespaceName}_${name}_${i}`)) {\n          localName = `${namespaceName}_${name}_${i}`;\n          break;\n        }\n      }\n    }\n    localNames[name] = localName;\n  });\n  return localNames;\n}\n"]}