bpmnlint 7.5.0 → 7.8.0

package/CHANGELOG.md

@@ -6,6 +6,20 @@ All notable changes to [bpmnlint](https://github.com/bpmn-io/bpmnlint) are docum
 
 ___Note:__ Yet to be released changes appear here._
 
+## 7.8.0
+
+* `FEAT`: be able to configure rules ([#82](https://github.com/bpmn-io/bpmnlint/pull/82))
+* `FEAT`: be able to configure rules when testing ([#83](https://github.com/bpmn-io/bpmnlint/pull/83))
+
+## 7.7.0
+
+* `FEAT`: fuzzy test for equality of nodes when using `RuleTester#verify` ([#79](https://github.com/bpmn-io/bpmnlint/pull/79/files))
+
+## 7.6.0
+
+* `FEAT`: allow passing object as third parameter to `Reporter#report` ([#75](https://github.com/bpmn-io/bpmnlint/pull/75))
+
+
 ## 7.5.0
 
 * `FEAT`: add optional `path` parameter to `Reporter#report` ([#73](https://github.com/bpmn-io/bpmnlint/pull/73))

package/lib/linter.js

@@ -77,7 +77,7 @@ Linter.prototype.applyRule = function applyRule(moddleRoot, ruleDefinition) {
 };
 
 
-Linter.prototype.resolveRule = function(name) {
+Linter.prototype.resolveRule = function(name, config) {
 
   const {
     pkg,
@@ -98,7 +98,7 @@ Linter.prototype.resolveRule = function(name) {
       throw new Error(`unknown rule <${name}>`);
     }
 
-    const rule = this.cachedRules[id] = ruleFactory();
+    const rule = this.cachedRules[id] = ruleFactory(config);
 
     return rule;
   });
@@ -163,10 +163,11 @@ Linter.prototype.resolveRules = function(config) {
     const loaders = enabledRules.map((definition) => {
 
       const {
-        name
+        name,
+        config
       } = definition;
 
-      return this.resolveRule(name).then(function(rule) {
+      return this.resolveRule(name, config).then(function(rule) {
         return {
           ...definition,
           rule

package/lib/test-rule.js

@@ -1,5 +1,11 @@
 const traverse = require('./traverse');
 
+const {
+  isArray,
+  isObject
+} = require('min-dash');
+
+
 class Reporter {
   constructor({ moddleRoot, rule }) {
     this.rule = rule;
@@ -8,19 +14,42 @@ class Reporter {
     this.report = this.report.bind(this);
   }
 
+  /**
+   * @param {string} id
+   * @param {string} message
+   * @param {string[]|Object} path
+   *
+   * @example
+   *
+   * Reporter.report('foo', 'Foo error', [ 'foo', 'bar', 'baz' ]);
+   *
+   * @example
+   *
+   * Reporter.report('foo', 'Foo error', {
+   *  path: [ 'foo', 'bar', 'baz' ],
+   *  foo: 'foo'
+   * });
+   */
   report(id, message, path) {
     let report = {
       id,
       message
     };
 
-    if (path) {
+    if (path && isArray(path)) {
       report = {
         ...report,
         path
       };
     }
 
+    if (path && isObject(path)) {
+      report = {
+        ...report,
+        ...path
+      };
+    }
+
     this.messages.push(report);
   }
 }

package/lib/testers/rule-tester.js

@@ -11,14 +11,15 @@ function createResolver(rule) {
 }
 
 function expectEqual(a, b) {
-  assert.deepStrictEqual(a, b);
+  assert.deepStrictEqual(JSON.stringify(a, replacer, 2), JSON.stringify(b, replacer, 2));
 }
 
-
 function verify(ruleName, rule, testCases) {
-  const linterConfig = {
-    rules: { [ruleName]: 2 }
-  };
+  function createLinterConfig(config = {}) {
+    return {
+      rules: { [ruleName]: [ 2, config ] }
+    };
+  }
 
   describe(`rules/${ruleName}`, function() {
 
@@ -33,13 +34,13 @@ function verify(ruleName, rule, testCases) {
 
     describe('should lint valid', function() {
 
-      testCases.valid.forEach(({ moddleElement, name, it: _it }, idx) => (
+      testCases.valid.forEach(({ config = {}, it: _it, moddleElement, name }, idx) => (
 
         (_it || it)(getTitle(idx, name), function() {
           return (
             Promise.resolve(moddleElement)
               .then(moddleRoot => {
-                return linter.lint(moddleRoot.root, linterConfig);
+                return linter.lint(moddleRoot.root, createLinterConfig(config));
               })
               .then(lintResults => {
                 expectEqual(lintResults, {});
@@ -54,7 +55,7 @@ function verify(ruleName, rule, testCases) {
 
     describe('should lint invalid', function() {
 
-      testCases.invalid.forEach(({ moddleElement, name, report, it: _it }, idx) => (
+      testCases.invalid.forEach(({ config = {}, it: _it, moddleElement, name, report }, idx) => (
 
         (_it || it)(getTitle(idx, name), function() {
 
@@ -78,7 +79,7 @@ function verify(ruleName, rule, testCases) {
           return (
             Promise.resolve(moddleElement)
               .then(moddleRoot => {
-                return linter.lint(moddleRoot.root, linterConfig);
+                return linter.lint(moddleRoot.root, createLinterConfig(config));
               })
               .then(lintResults => {
                 expectEqual(lintResults, expectedLintResults);
@@ -98,7 +99,39 @@ function getTitle(idx, name) {
   return `test case #${ idx + 1 }${ name ? ` ${ name }`: '' }`;
 }
 
+function replacer(_, value) {
+  if (!value) {
+    return value;
+  }
+
+  const { $type } = value;
+
+  if ($type) {
+    const { $descriptor } = value;
+
+    const { idProperty } = $descriptor;
+
+    if (idProperty) {
+      const { name } = idProperty;
+
+      const id = value.get(name);
+
+      if (id) {
+        return id;
+      } else {
+        return $type;
+      }
+    } else {
+      return $type;
+    }
+  }
+
+  return value;
+}
+
 module.exports = {
+  expectEqual,
   verify,
-  getTitle
+  getTitle,
+  replacer
 };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "bpmnlint",
   "description": "Validate your BPMN diagrams based on configurable lint rules",
-  "version": "7.5.0",
+  "version": "7.8.0",
   "main": "lib/index.js",
   "keywords": [
     "bpmnlint",