bpmnlint 7.0.1 → 7.3.0

package/CHANGELOG.md

@@ -6,6 +6,25 @@ All notable changes to [bpmnlint](https://github.com/bpmn-io/bpmnlint) are docum
 
 ___Note:__ Yet to be released changes appear here._
 
+## 7.3.0
+
+* `FEAT`: support `--version` command line flag ([#65](https://github.com/bpmn-io/bpmnlint/pull/65))
+* `FEAT`: allow rule testers to provide custom `it`
+* `FIX`: make `no-bpmndi` handle missing `LaneSet#lanes` gracefully ([#63](https://github.com/bpmn-io/bpmnlint/issues/63), [#66](https://github.com/bpmn-io/bpmnlint/pull/66))
+
+## 7.2.1
+
+* `FIX`: exclude compensation boundary and activity in `no-disconnected` check ([#60](https://github.com/bpmn-io/bpmnlint/pull/60))
+
+## 7.2.0
+
+* `FEAT`: add `no-bpmndi` rule ([#55](https://github.com/bpmn-io/bpmnlint/issues/55))
+
+## 7.1.0
+
+* `FEAT`: allow rules to skip sub-tree traversal ([#53](https://github.com/bpmn-io/bpmnlint/issues/53))
+* `FEAT`: allow rules to hook into node `enter` and `leave` ([#52](https://github.com/bpmn-io/bpmnlint/issues/52))
+
 ## 7.0.1
 
 * `CHORE`: drop debug log statement

package/README.md

@@ -1,11 +1,11 @@
 # bpmnlint
 
-[![Build Status](https://travis-ci.com/bpmn-io/bpmnlint.svg?branch=master)](https://travis-ci.com/bpmn-io/bpmnlint)
+[![CI](https://github.com/bpmn-io/bpmnlint/workflows/CI/badge.svg)](https://github.com/bpmn-io/bpmnlint/actions?query=workflow%3ACI)
 
 Validate your BPMN diagrams based on configurable lint rules.
 
 
-## Usage
+## Installation
 
 Install the utility via [npm](https://www.npmjs.com/package/bpmnlint):
 
@@ -13,6 +13,9 @@ Install the utility via [npm](https://www.npmjs.com/package/bpmnlint):
 npm install -g bpmnlint
 ```
 
+
+## Usage
+
 Validate your diagrams via the commandline:
 
 ```sh

package/bin/bpmnlint.js

@@ -146,6 +146,12 @@ function errorAndExit(...args) {
   process.exit(1);
 }
 
+function showVersionAndExit() {
+  console.log(require('../package.json').version);
+
+  process.exit(0);
+}
+
 function infoAndExit(...args) {
   console.log(...args);
 
@@ -314,6 +320,7 @@ async function run() {
   const {
     help,
     init,
+    version,
     config: configOverridePath,
     _: files
   } = mri(process.argv.slice(2), {
@@ -323,6 +330,10 @@ async function run() {
     }
   });
 
+  if (version) {
+    return showVersionAndExit();
+  }
+
   if (help) {
     return infoAndExit(HELP_STRING);
   }

package/config/all.js

@@ -4,6 +4,7 @@ const allRules = [
   'event-sub-process-typed-start-event',
   'fake-join',
   'label-required',
+  'no-bpmndi',
   'no-complex-gateway',
   'no-disconnected',
   'no-duplicate-sequence-flows',
@@ -24,4 +25,4 @@ module.exports = {
 
     return rules;
   }, {})
-};
+};

package/config/recommended.js

@@ -5,6 +5,7 @@ module.exports = {
     'event-sub-process-typed-start-event': 'error',
     'fake-join': 'warn',
     'label-required': 'error',
+    'no-bpmndi': 'error',
     'no-complex-gateway': 'error',
     'no-disconnected': 'error',
     'no-duplicate-sequence-flows': 'error',
@@ -17,4 +18,4 @@ module.exports = {
     'sub-process-blank-start-event': 'error',
     'superfluous-gateway': 'warning'
   }
-};
+};

package/lib/support/compile-config.js

@@ -34,7 +34,7 @@ async function compileConfig(config) {
   const serializedRules = JSON.stringify(enabledRules, null, '  ');
 
   const preambleCode = `
-var cache = {};
+const cache = {};
 
 /**
  * A resolver that caches rules and configuration as part of the bundle,
@@ -61,15 +61,15 @@ Resolver.prototype.resolveConfig = function(pkg, configName) {
   );
 };
 
-var resolver = new Resolver();
+const resolver = new Resolver();
 
-var rules = ${serializedRules};
+const rules = ${serializedRules};
 
-var config = {
+const config = {
   rules: rules
 };
 
-var bundle = {
+const bundle = {
   resolver: resolver,
   config: config
 };

package/lib/test-rule.js

@@ -15,6 +15,20 @@ class Reporter {
 
 module.exports = function testRule({ moddleRoot, rule }) {
   const reporter = new Reporter({ rule, moddleRoot });
-  traverse(moddleRoot, node => rule.check(node, reporter));
+
+  const check = rule.check;
+
+  const enter = check && check.enter || check;
+  const leave = check && check.leave;
+
+  if (!enter && !leave) {
+    throw new Error('no check implemented');
+  }
+
+  traverse(moddleRoot, {
+    enter: enter ? (node) => enter(node, reporter) : null,
+    leave: leave ? (node) => leave(node, reporter) : null
+  });
+
   return reporter.messages;
 };

package/lib/testers/rule-tester.js

@@ -33,9 +33,9 @@ function verify(ruleName, rule, testCases) {
 
     describe('should lint valid', function() {
 
-      testCases.valid.forEach(({ moddleElement }, idx) => (
+      testCases.valid.forEach(({ moddleElement, it: _it }, idx) => (
 
-        it(`test case #${idx + 1}`, function() {
+        (_it || it)(`test case #${idx + 1}`, function() {
           return (
             Promise.resolve(moddleElement)
               .then(moddleRoot => {
@@ -54,9 +54,9 @@ function verify(ruleName, rule, testCases) {
 
     describe('should lint invalid', function() {
 
-      testCases.invalid.forEach(({ moddleElement, report }, idx) => (
+      testCases.invalid.forEach(({ moddleElement, report, it: _it }, idx) => (
 
-        it(`test case #${idx}`, function() {
+        (_it || it)(`test case #${idx}`, function() {
 
           if (!Array.isArray(report)) {
             report = [

package/lib/traverse.js

@@ -3,32 +3,37 @@
  * and call the passed visitor fn.
  *
  * @param {ModdleElement} element
- * @param {Function} fn
+ * @param {{ enter?: Function; leave?: Function }} options
  */
-module.exports = function traverse(element, fn) {
-  fn(element);
+module.exports = function traverse(element, options) {
 
-  var descriptor = element.$descriptor;
+  const enter = options.enter || null;
+  const leave = options.leave || null;
 
-  if (descriptor.isGeneric) {
-    return;
-  }
+  const enterSubTree = enter && enter(element);
+
+  const descriptor = element.$descriptor;
+
+  if (enterSubTree !== false && !descriptor.isGeneric) {
 
-  var containedProperties = descriptor.properties.filter(p => {
-    return !p.isAttr && !p.isReference && p.type !== 'String';
-  });
+    const containedProperties = descriptor.properties.filter(p => {
+      return !p.isAttr && !p.isReference && p.type !== 'String';
+    });
 
-  containedProperties.forEach(p => {
-    if (p.name in element) {
-      const propertyValue = element[p.name];
+    containedProperties.forEach(p => {
+      if (p.name in element) {
+        const propertyValue = element[p.name];
 
-      if (p.isMany) {
-        propertyValue.forEach(child => {
-          traverse(child, fn);
-        });
-      } else {
-        traverse(propertyValue, fn);
+        if (p.isMany) {
+          propertyValue.forEach(child => {
+            traverse(child, options);
+          });
+        } else {
+          traverse(propertyValue, options);
+        }
       }
-    }
-  });
+    });
+  }
+
+  leave && leave(element);
 };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "bpmnlint",
   "description": "Validate your BPMN diagrams based on configurable lint rules",
-  "version": "7.0.1",
+  "version": "7.3.0",
   "main": "lib/index.js",
   "keywords": [
     "bpmnlint",
@@ -42,6 +42,7 @@
     "bpmnlint-utils": "^1.0.2",
     "cli-table": "^0.3.1",
     "color-support": "^1.1.3",
+    "min-dash": "^3.5.2",
     "mri": "^1.1.6",
     "pluralize": "^7.0.0",
     "tiny-glob": "^0.2.8"

package/rules/no-bpmndi.js

@@ -0,0 +1,129 @@
+const {
+  is
+} = require('bpmnlint-utils');
+
+const {
+  flatten
+} = require('min-dash');
+
+/**
+ * A rule that checks that there is no BPMNDI information missing for elements,
+ * which require BPMNDI.
+ */
+module.exports = function() {
+
+  function check(node, reporter) {
+
+    if (!is(node, 'bpmn:Definitions')) {
+      return false;
+    }
+
+    // (1) Construct array of all BPMN elements
+    const bpmnElements = getAllBpmnElements(node.rootElements);
+
+    // (2) Filter BPMN elements without visual representation
+    const visualBpmnElements = bpmnElements.filter(hasVisualRepresentation);
+
+    // (3) Construct array of BPMNDI references
+    const diBpmnReferences = getAllDiBpmnReferences(node);
+
+    // (4) Report elements without BPMNDI
+    visualBpmnElements.forEach((element) => {
+      if (diBpmnReferences.indexOf(element.id) === -1) {
+        reporter.report(element.id, 'Element is missing bpmndi');
+      }
+    });
+  }
+
+  return {
+    check
+  };
+
+};
+
+
+// helpers /////////////////////////////
+
+/**
+ * Get all BPMN elements within a bpmn:Definitions node
+ *
+ * @param {array<ModdleElement>} rootElements - An array of Moddle rootElements
+ * @return {array<Object>} A flat array with all BPMN elements, each represented with { id: elementId, $type: elementType }
+ *
+ */
+function getAllBpmnElements(rootElements) {
+  return flatten(rootElements.map((rootElement) => {
+
+    const laneSet =
+      rootElement.laneSets && rootElement.laneSets[0] || rootElement.childLaneSet;
+
+    // Include
+    // * flowElements (e.g., tasks, sequenceFlows),
+    // * nested flowElements,
+    // * participants,
+    // * artifacts (groups),
+    // * laneSets
+    // * nested laneSets
+    // * childLaneSets
+    // * nested childLaneSets
+    const elements = flatten([].concat(
+      rootElement.flowElements || [],
+      (rootElement.flowElements && getAllBpmnElements(rootElement.flowElements.filter(hasFlowElements))) || [],
+      rootElement.participants || [],
+      rootElement.artifacts || [],
+      laneSet && laneSet.lanes || [],
+      laneSet && laneSet.lanes && getAllBpmnElements(laneSet.lanes.filter(hasChildLaneSet)) || []
+    ));
+
+    if (elements.length > 0) {
+      return elements.map((element) => {
+
+        return {
+          id: element.id,
+          $type: element.$type
+        };
+      });
+    } else {
+
+      // We are not interested in the rest here (DI)
+      return [];
+    }
+  }));
+}
+
+/**
+ * Get all BPMN elements within a bpmn:Definitions node
+ *
+ * @param {ModdleElement} definitionsNode - A moddleElement representing the
+ * bpmn:Definitions element
+ * @return {array<String>} A flat array with all BPMNDI element ids part of
+ * this bpmn:Definitions node
+ *
+ */
+function getAllDiBpmnReferences(definitionsNode) {
+  return flatten(
+    definitionsNode.diagrams.map((diagram) => {
+
+      const diElements = diagram.plane.planeElement || [];
+
+      return diElements.map((element) => {
+
+        return element.bpmnElement.id;
+      });
+    })
+  );
+}
+
+function hasVisualRepresentation(element) {
+  const noVisRepresentation = ['bpmn:DataObject'];
+
+  return noVisRepresentation.includes(element.$type) ? false : true;
+}
+
+function hasFlowElements(element) {
+  return element.flowElements ? true : false;
+}
+
+function hasChildLaneSet(element) {
+  return element.childLaneSet ? true : false;
+}

package/rules/no-disconnected.js

@@ -1,5 +1,6 @@
 const {
-  isAny
+  isAny,
+  is
 } = require('bpmnlint-utils');
 
 
@@ -21,6 +22,13 @@ module.exports = function() {
       return;
     }
 
+    // compensation activity and boundary events are
+    // linked visually via associations. If these associations
+    // exist we are fine, too
+    if (isCompensationLinked(node)) {
+      return;
+    }
+
     const incoming = node.incoming || [];
     const outgoing = node.outgoing || [];
 
@@ -32,5 +40,34 @@ module.exports = function() {
   return {
     check
   };
-
 };
+
+
+// helpers /////////////////
+
+function isCompensationBoundary(node) {
+
+  var eventDefinitions = node.eventDefinitions;
+
+  if (!is(node, 'bpmn:BoundaryEvent')) {
+    return false;
+  }
+
+  if (!eventDefinitions || eventDefinitions.length !== 1) {
+    return false;
+  }
+
+  return is(eventDefinitions[0], 'bpmn:CompensateEventDefinition');
+}
+
+function isCompensationActivity(node) {
+  return node.isForCompensation;
+}
+
+function isCompensationLinked(node) {
+  var source = isCompensationBoundary(node);
+  var target = isCompensationActivity(node);
+
+  // TODO(nikku): check, whether compensation association exists
+  return source || target;
+}