bpmnlint 7.1.0 → 7.4.0

package/CHANGELOG.md

@@ -6,6 +6,24 @@ All notable changes to [bpmnlint](https://github.com/bpmn-io/bpmnlint) are docum
 
 ___Note:__ Yet to be released changes appear here._
 
+## 7.4.0
+
+* `FEAT`: resolve local package by name ([#64](https://github.com/bpmn-io/bpmnlint/pull/64))
+
+## 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))

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/resolver/node-resolver.js

@@ -9,6 +9,12 @@ function NodeResolver(options) {
   this.require = options && options.require || createScopedRequire(process.cwd());
 
   this.requireLocal = options && options.requireLocal || require;
+
+  try {
+    this.pkg = this.require('./package.json').name;
+  } catch (err) {
+    this.pkg = '__unknown';
+  }
 }
 
 module.exports = NodeResolver;
@@ -16,6 +22,10 @@ module.exports = NodeResolver;
 
 NodeResolver.prototype.resolveRule = function(pkg, ruleName) {
 
+  const originalPkg = pkg;
+
+  pkg = this.normalizePkg(pkg);
+
   try {
     if (pkg === 'bpmnlint') {
       return this.requireLocal(`../../rules/${ruleName}`);
@@ -23,12 +33,16 @@ NodeResolver.prototype.resolveRule = function(pkg, ruleName) {
       return this.require(`${pkg}/rules/${ruleName}`);
     }
   } catch (err) {
-    throw new Error('Cannot resolve rule <' + ruleName + '> from <' + pkg + '>');
+    throw new Error('Cannot resolve rule <' + ruleName + '> from <' + originalPkg + '>');
   }
 };
 
 NodeResolver.prototype.resolveConfig = function(pkg, configName) {
 
+  const originalPkg = pkg;
+
+  pkg = this.normalizePkg(pkg);
+
   // resolve config via $PKG/config/$NAME
   try {
     if (pkg === 'bpmnlint') {
@@ -53,10 +67,17 @@ NodeResolver.prototype.resolveConfig = function(pkg, configName) {
   }
 
   throw new Error(
-    'Cannot resolve config <' + configName + '> from <' + pkg + '>'
+    'Cannot resolve config <' + configName + '> from <' + originalPkg + '>'
   );
 };
 
+NodeResolver.prototype.normalizePkg = function(pkg) {
+  if (pkg !== 'bpmnlint' && pkg === this.pkg) {
+    pkg = '.';
+  }
+
+  return pkg;
+};
 
 // helpers ////////////////////
 

package/lib/support/compile-config.js

@@ -7,13 +7,15 @@ const NodeResolver = require('../resolver/node-resolver');
  * a { config, resolver } bundle, resolving all enabled rules.
  *
  * @param  {Object} config the parsed bpmnlint configuration
- *
+ * @param  {NodeResolver} [resolver]
  * @return {Promise<String>} the configuration compiled to a JS file
  */
-async function compileConfig(config) {
+async function compileConfig(config, resolver) {
+
+  resolver = resolver || new NodeResolver();
 
   const linter = new Linter({
-    resolver: new NodeResolver()
+    resolver
   });
 
   const resolvedRules = await linter.resolveConfiguredRules(config);
@@ -86,7 +88,7 @@ export default bundle;
     } = linter.parseRuleName(key);
 
     return `
-import rule_${idx} from '${pkg}/rules/${ruleName}';
+import rule_${idx} from '${resolver.normalizePkg(pkg)}/rules/${ruleName}';
 cache['${pkg}/${ruleName}'] = rule_${idx};`;
   }).join('\n');
 

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/package.json

@@ -1,7 +1,7 @@
 {
   "name": "bpmnlint",
   "description": "Validate your BPMN diagrams based on configurable lint rules",
-  "version": "7.1.0",
+  "version": "7.4.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;
+}