eslint-plugin-boundaries 2.10.2 → 3.1.0

package/README.md

@@ -308,10 +308,17 @@ Remember that:
 
 Elements matchers used in the rules options can have the next formats:
 
-* __`<string>`__: Will return `true` when the element type matches with this [`micromatch` pattern](https://github.com/micromatch/micromatch).
-* __`[<string>, <capturedValuesObject>]`__: Will return `true` whe when the element type matches with the first element in the array, and all of the captured values also match. <br/>The `<capturedValuesObject>` has to be an object containing `capture` keys from the [`boundaries/element-types` setting](#boundarieselement-types) of the element as keys, and [`micromatch` patterns](https://github.com/micromatch/micromatch) as values.<br/>For example, for an element of type "helpers" with settings as `{ type: "helpers", pattern": "helpers/*/*.js", "capture": ["category", "elementName"]}`, you could write element matchers as:
+* __`<string>`__: Will return `true` when the element type matches with this [`micromatch` pattern](https://github.com/micromatch/micromatch). It [supports templating](#templating) for using values from captured values.
+* __`[<string>, <capturedValuesObject>]`__: Will return `true` whe when the element type matches with the first element in the array, and all of the captured values also match. <br/>The `<capturedValuesObject>` has to be an object containing `capture` keys from the [`boundaries/element-types` setting](#boundarieselement-types) of the element as keys, and [`micromatch` patterns](https://github.com/micromatch/micromatch) as values. (values also support [templating](#templating)) <br/>For example, for an element of type "helpers" with settings as `{ type: "helpers", pattern": "helpers/*/*.js", "capture": ["category", "elementName"]}`, you could write element matchers as:
   * `["helpers", { category: "data", elementName: "parsers"}]`: Will only match with helpers with category "data" and elementName "parsers" (`helpers/data/parsers.js`).
   * `["helpers", { category: "data" }]`: Will match with all helpers with category "data" (`helpers/data/*.js`)
+  * `["data-${from.elementName}", { category: "${from.category}" }]`: Will only match with helpers with the type equals to the `elementName` of the file importing plus a `data-` prefix, and the category being equal to the `category` of the file importing the dependency.
+
+##### Templating
+
+When defining [__Element matchers__](#elements-matchers), the values captured both from the element importing ("from") and from the imported element ("target") are available to be replaced. They are replaced both in the main string and in the `<capturedValuesObject>`.
+
+Templates must be defined with the format `${from.CAPTURED_PROPERTY}` or `${target.CAPTURED_PROPERTY}`.
 
 ##### Error messages
 
@@ -366,7 +373,7 @@ Just to illustrate the high level of customization that the plugin supports, her
           "from": ["components"],
           "allow": [
             // allow importing components of the same family
-            ["components", { "family": "${family}" }],
+            ["components", { "family": "${from.family}" }],
             // allow importing helpers with captured category "data"
             ["helpers", { "category": "data" }],
           ]
@@ -403,10 +410,10 @@ Just to illustrate the high level of customization that the plugin supports, her
           "from": [["modules", { "elementName": "page-*" }]],
           "disallow": [
             // disallow importing any type of component not being of family layout
-            ["components", { "family": "!layout" }]
+            ["components", { "family": "!layout" }],
           ],
           // Custom message only for this specific error
-          "message": "Modules with name starting by 'page-' can't import not layout components. You tried to import a component of family ${dependency.family} from a module with name ${file.elementName}"
+          "message": "Modules with name starting by 'page-' can't import not layout components. You tried to import a component of family ${target.family} from a module with name ${from.elementName}"
         }
       ]
     }]

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint-plugin-boundaries",
-  "version": "2.10.2",
+  "version": "3.1.0",
   "description": "Eslint plugin checking architecture boundaries between elements",
   "keywords": [
     "eslint",
@@ -34,19 +34,19 @@
     "chalk": "4.1.2",
     "eslint-import-resolver-node": "0.3.6",
     "eslint-module-utils": "2.7.4",
-    "is-core-module": "2.10.0",
+    "is-core-module": "2.11.0",
     "micromatch": "4.0.5"
   },
   "devDependencies": {
     "cross-env": "7.0.3",
-    "eslint": "8.23.0",
+    "eslint": "8.29.0",
     "eslint-config-prettier": "8.5.0",
     "eslint-plugin-prettier": "4.2.1",
-    "husky": "8.0.1",
+    "husky": "8.0.2",
     "is-ci": "3.0.1",
-    "jest": "29.0.1",
-    "lint-staged": "13.0.3",
-    "prettier": "2.7.1"
+    "jest": "29.3.1",
+    "lint-staged": "13.0.4",
+    "prettier": "2.8.0"
   },
   "lint-staged": {
     "test/**/*.js": "eslint",
@@ -54,6 +54,6 @@
     "*.js": "eslint"
   },
   "engines": {
-    "node": ">=12.0.0"
+    "node": ">=14.0.0"
   }
 }

package/src/core/elementsInfo.js

@@ -195,7 +195,8 @@ function projectPath(absolutePath) {
 
 function importInfo(source, context) {
   const path = projectPath(resolve(source, context));
-  const resultCache = importsCache.load(path, context.settings);
+  const isExternalModule = isExternal(source, path);
+  const resultCache = importsCache.load(isExternalModule ? source : path, context.settings);
   let elementCache;
   let result;
   let elementResult;
@@ -205,7 +206,6 @@ function importInfo(source, context) {
   } else {
     elementCache = elementsCache.load(path, context.settings);
     const isBuiltInModule = isBuiltIn(source, path);
-    const isExternalModule = isExternal(source, path);
     const pathToUse = isExternalModule ? null : path;
     if (elementCache) {
       elementResult = elementCache;

package/src/helpers/messages.js

@@ -1,5 +1,5 @@
 const { isString, isArray, replaceObjectValuesInTemplates } = require("./utils");
-const { micromatchPatternReplacingObjectValues } = require("./rules");
+const { micromatchPatternReplacingObjectsValues } = require("./rules");
 
 function quote(str) {
   return `'${str}'`;
@@ -20,9 +20,9 @@ function propertiesConcater(properties, index) {
 }
 
 function micromatchPatternMessage(micromatchPatterns, elementCapturedValues) {
-  const micromatchPatternsWithValues = micromatchPatternReplacingObjectValues(
+  const micromatchPatternsWithValues = micromatchPatternReplacingObjectsValues(
     micromatchPatterns,
-    elementCapturedValues
+    { from: elementCapturedValues }
   );
   if (isArray(micromatchPatternsWithValues)) {
     if (micromatchPatternsWithValues.length === 1) {
@@ -94,12 +94,26 @@ function customErrorMessage(message, file, dependency, report = {}) {
     elementPropertiesToReplaceInTemplate(dependency),
     "dependency"
   );
+  replacedMessage = replaceObjectValuesInTemplates(
+    replaceObjectValuesInTemplates(
+      replacedMessage,
+      elementPropertiesToReplaceInTemplate(file),
+      "from"
+    ),
+    elementPropertiesToReplaceInTemplate(dependency),
+    "target"
+  );
   if (file.parents[0]) {
     replacedMessage = replaceObjectValuesInTemplates(
       replacedMessage,
       elementPropertiesToReplaceInTemplate(file.parents[0]),
       "file.parent"
     );
+    replacedMessage = replaceObjectValuesInTemplates(
+      replacedMessage,
+      elementPropertiesToReplaceInTemplate(file.parents[0]),
+      "from.parent"
+    );
   }
   if (dependency.parents[0]) {
     replacedMessage = replaceObjectValuesInTemplates(
@@ -107,6 +121,11 @@ function customErrorMessage(message, file, dependency, report = {}) {
       elementPropertiesToReplaceInTemplate(dependency.parents[0]),
       "dependency.parent"
     );
+    replacedMessage = replaceObjectValuesInTemplates(
+      replacedMessage,
+      elementPropertiesToReplaceInTemplate(dependency.parents[0]),
+      "target.parent"
+    );
   }
   return replaceObjectValuesInTemplates(replacedMessage, report, "report");
 }

package/src/helpers/rules.js

@@ -3,6 +3,7 @@ const micromatch = require("micromatch");
 const { isArray, replaceObjectValuesInTemplates } = require("./utils");
 
 const REPO_URL = "https://github.com/javierbrea/eslint-plugin-boundaries";
+const FROM = "from";
 
 function removePluginNamespace(ruleName) {
   return ruleName.replace("boundaries/", "");
@@ -44,39 +45,58 @@ function dependencyLocation(node, context) {
   };
 }
 
-function micromatchPatternReplacingObjectValues(pattern, object) {
-  return replaceObjectValuesInTemplates(pattern, object);
+function micromatchPatternReplacingObjectsValues(pattern, object) {
+  let patternToReplace = pattern;
+  // Backward compatibility
+  if (object.from) {
+    patternToReplace = replaceObjectValuesInTemplates(patternToReplace, object.from);
+  }
+  return Object.keys(object).reduce((replacedPattern, namespace) => {
+    if (!object[namespace]) {
+      return replacedPattern;
+    }
+    return replaceObjectValuesInTemplates(replacedPattern, object[namespace], namespace);
+  }, patternToReplace);
 }
 
-function isObjectMatch(objectWithMatchers, object, objectWithValuesToReplace) {
+function isObjectMatch(objectWithMatchers, object, objectsWithValuesToReplace) {
   return Object.keys(objectWithMatchers).reduce((isMatch, key) => {
-    if (isMatch || isMatch === null) {
-      const micromatchPattern = objectWithValuesToReplace
-        ? micromatchPatternReplacingObjectValues(
-            objectWithMatchers[key],
-            objectWithValuesToReplace
-          )
-        : objectWithMatchers[key];
+    if (isMatch) {
+      const micromatchPattern = micromatchPatternReplacingObjectsValues(
+        objectWithMatchers[key],
+        objectsWithValuesToReplace
+      );
       return micromatch.isMatch(object[key], micromatchPattern);
     }
     return isMatch;
-  }, null);
+  }, true);
 }
 
 function rulesMainKey(key) {
-  return key || "from";
+  return key || FROM;
 }
 
-function ruleMatch(ruleMatchers, elementInfo, isMatch, elementToCompare = {}) {
+function ruleMatch(ruleMatchers, targetElement, isMatch, fromElement) {
   let match = { result: false, report: null };
   const matchers = !isArray(ruleMatchers) ? [ruleMatchers] : ruleMatchers;
   matchers.forEach((matcher) => {
     if (!match.result) {
       if (isArray(matcher)) {
         const [value, captures] = matcher;
-        match = isMatch(elementInfo, value, captures, elementToCompare.capturedValues);
+        match = isMatch(targetElement, value, captures, {
+          from: fromElement.capturedValues,
+          target: targetElement.capturedValues,
+        });
       } else {
-        match = isMatch(elementInfo, matcher);
+        match = isMatch(
+          targetElement,
+          matcher,
+          {},
+          {
+            from: fromElement.capturedValues,
+            target: targetElement.capturedValues,
+          }
+        );
       }
     }
   });
@@ -88,12 +108,15 @@ function isMatchElementKey(
   matcher,
   options,
   elementKey,
-  elementToCompareCapturedValues
+  elementsToCompareCapturedValues
 ) {
-  const isMatch = micromatch.isMatch(elementInfo[elementKey], matcher);
+  const isMatch = micromatch.isMatch(
+    elementInfo[elementKey],
+    micromatchPatternReplacingObjectsValues(matcher, elementsToCompareCapturedValues)
+  );
   if (isMatch && options) {
     return {
-      result: isObjectMatch(options, elementInfo.capturedValues, elementToCompareCapturedValues),
+      result: isObjectMatch(options, elementInfo.capturedValues, elementsToCompareCapturedValues),
     };
   }
   return {
@@ -101,8 +124,8 @@ function isMatchElementKey(
   };
 }
 
-function isMatchElementType(elementInfo, matcher, options, elementToCompareCapturedValues) {
-  return isMatchElementKey(elementInfo, matcher, options, "type", elementToCompareCapturedValues);
+function isMatchElementType(elementInfo, matcher, options, elementsToCompareCapturedValues) {
+  return isMatchElementKey(elementInfo, matcher, options, "type", elementsToCompareCapturedValues);
 }
 
 function getElementRules(elementInfo, options, mainKey) {
@@ -118,10 +141,21 @@ function getElementRules(elementInfo, options, mainKey) {
       };
     })
     .filter((rule) => {
-      return ruleMatch(rule[key], elementInfo, isMatchElementType).result;
+      return ruleMatch(rule[key], elementInfo, isMatchElementType, elementInfo).result;
     });
 }
 
+function isFromRule(mainKey) {
+  return rulesMainKey(mainKey) === FROM;
+}
+
+function elementToGetRulesFrom(element, dependency, mainKey) {
+  if (!isFromRule(mainKey)) {
+    return dependency;
+  }
+  return element;
+}
+
 function elementRulesAllowDependency({
   element,
   dependency,
@@ -129,7 +163,11 @@ function elementRulesAllowDependency({
   isMatch,
   rulesMainKey: mainKey,
 }) {
-  const [result, report, ruleReport] = getElementRules(element, options, mainKey).reduce(
+  const [result, report, ruleReport] = getElementRules(
+    elementToGetRulesFrom(element, dependency, mainKey),
+    options,
+    mainKey
+  ).reduce(
     (allowed, rule) => {
       if (rule.disallow) {
         const match = ruleMatch(rule.disallow, dependency, isMatch, element);
@@ -179,5 +217,5 @@ module.exports = {
   elementRulesAllowDependency,
   getElementRules,
   rulesMainKey,
-  micromatchPatternReplacingObjectValues,
+  micromatchPatternReplacingObjectsValues,
 };

package/src/rules/entry-point.js

@@ -10,13 +10,13 @@ const {
 } = require("../helpers/rules");
 const { customErrorMessage, ruleElementMessage, elementMessage } = require("../helpers/messages");
 
-function isMatchElementInternalPath(elementInfo, matcher, options) {
-  return isMatchElementKey(elementInfo, matcher, options, "internalPath");
+function isMatchElementInternalPath(elementInfo, matcher, options, elementsCapturedValues) {
+  return isMatchElementKey(elementInfo, matcher, options, "internalPath", elementsCapturedValues);
 }
 
-function elementRulesAllowEntryPoint(_element, dependency, options) {
+function elementRulesAllowEntryPoint(element, dependency, options) {
   return elementRulesAllowDependency({
-    element: dependency,
+    element,
     dependency,
     options,
     isMatch: isMatchElementInternalPath,

package/src/rules/external.js

@@ -5,27 +5,43 @@ const { RULE_EXTERNAL } = require("../constants/settings");
 const dependencyRule = require("../rules-factories/dependency-rule");
 
 const { rulesOptionsSchema } = require("../helpers/validations");
-const { dependencyLocation, elementRulesAllowDependency } = require("../helpers/rules");
+const {
+  dependencyLocation,
+  elementRulesAllowDependency,
+  micromatchPatternReplacingObjectsValues,
+} = require("../helpers/rules");
 const { customErrorMessage, ruleElementMessage, elementMessage } = require("../helpers/messages");
 
-function specifiersMatch(specifiers, options) {
+function specifiersMatch(specifiers, options, elementsCapturedValues) {
   const importedSpecifiersNames = specifiers
     .filter((specifier) => {
       return specifier.type === "ImportSpecifier" && specifier.imported.name;
     })
     .map((specifier) => specifier.imported.name);
   return options.reduce((found, option) => {
-    if (micromatch.some(importedSpecifiersNames, option)) {
+    const matcherWithTemplateReplaced = micromatchPatternReplacingObjectsValues(
+      option,
+      elementsCapturedValues
+    );
+    if (micromatch.some(importedSpecifiersNames, matcherWithTemplateReplaced)) {
       found.push(option);
     }
     return found;
   }, []);
 }
 
-function isMatchExternalDependency(dependency, matcher, options) {
-  const isMatch = micromatch.isMatch(dependency.baseModule, matcher);
-  if (isMatch && options) {
-    const specifiersResult = specifiersMatch(dependency.specifiers, options.specifiers);
+function isMatchExternalDependency(dependency, matcher, options, elementsCapturedValues) {
+  const matcherWithTemplatesReplaced = micromatchPatternReplacingObjectsValues(
+    matcher,
+    elementsCapturedValues
+  );
+  const isMatch = micromatch.isMatch(dependency.baseModule, matcherWithTemplatesReplaced);
+  if (isMatch && options && Object.keys(options).length) {
+    const specifiersResult = specifiersMatch(
+      dependency.specifiers,
+      options.specifiers,
+      elementsCapturedValues
+    );
     return {
       result: specifiersResult.length > 0,
       report: specifiersResult,