bpmnlint-plugin-camunda-compat 0.3.0 → 0.6.0

package/rules/utils/rule.js

@@ -1,7 +1,9 @@
 const {
+  every,
   isArray,
-  isNil,
+  isObject,
   isString,
+  some
 } = require('min-dash');
 
 const {
@@ -11,13 +13,31 @@ const {
 
 const { toSemverMinor } = require('./engine-profile');
 
-module.exports.createRule = function(ruleExecutionPlatform, ruleExecutionPlatformVersion, checks) {
+const { ERROR_TYPES } = require('./element');
+
+const { getTypeString } = require('./type');
+
+/**
+ * Factory function for rules. Returns a rule for a given execution platform,
+ * execution platform version and an array of checks. Must be run on
+ * bpmn:Definitions node. Returns early without traversing further if execution
+ * platform or execution platform version doesn't match. Returns early if node
+ * is not a bpmn:FlowElement or bpmn:FlowElementContainer.
+ *
+ * @param {string} ruleExecutionPlatform
+ * @param {string} ruleExecutionPlatformVersion
+ * @param {(Object|string)[]} checks
+ * @param {string} executionPlatformLabel
+ *
+ * @returns {Function}
+ */
+module.exports.createRule = function(ruleExecutionPlatform, ruleExecutionPlatformVersion, checks, executionPlatformLabel) {
   return () => {
     return {
       check: (node, reporter) => {
         if (is(node, 'bpmn:Definitions')) {
-          executionPlatform = node.get('modeler:executionPlatform');
-          executionPlatformVersion = node.get('modeler:executionPlatformVersion');
+          const executionPlatform = node.get('modeler:executionPlatform');
+          const executionPlatformVersion = node.get('modeler:executionPlatformVersion');
 
           if (!executionPlatform
             || executionPlatform !== ruleExecutionPlatform
@@ -29,20 +49,75 @@ module.exports.createRule = function(ruleExecutionPlatform, ruleExecutionPlatfor
           return;
         }
 
-        const result = checkNode(node, checks);
+        let results = checkNode(node, checks);
 
-        if (result === false) {
-          reporter.report(node.get('id') || '', `Element of type <${ node.$type }> not supported by ${ ruleExecutionPlatform } ${ toSemverMinor(ruleExecutionPlatformVersion) }`);
+        if (results === true) {
+          return;
         }
 
-        if (isString(result)) {
-          reporter.report(node.get('id') || '', `Element of type <${ result }> not supported by ${ ruleExecutionPlatform } ${ toSemverMinor(ruleExecutionPlatformVersion) }`);
+        const id = node.get('id') || '';
+
+        const label = getLabel(node);
+
+        if (results === false) {
+          const message = getMessage(node, ruleExecutionPlatform, ruleExecutionPlatformVersion, executionPlatformLabel);
+
+          let options = {
+            error: {
+              type: ERROR_TYPES.ELEMENT_TYPE,
+              element: node.$type
+            }
+          };
+
+          if (label) {
+            options = {
+              ...options,
+              label
+            };
+          }
+
+          reporter.report(id, message, options);
+        } else {
+          if (!isArray(results)) {
+            results = [ results ];
+          }
+
+          results.forEach((result) => {
+            if (isString(result)) {
+              result = { message: result };
+            }
+
+            let {
+              message,
+              ...rest
+            } = result;
+
+            message = addExecutionPlatform(message, executionPlatformLabel || `${ ruleExecutionPlatform } ${ toSemverMinor(ruleExecutionPlatformVersion) }`);
+
+            let options = {
+              ...rest
+            };
+
+            if (label) {
+              options = {
+                ...options,
+                label
+              };
+            }
+
+            reporter.report(id, message, options);
+          });
         }
       }
     };
   };
 };
 
+/**
+ * Create no-op rule that always returns false resulting in early return.
+ *
+ * @returns {Function}
+ */
 module.exports.createNoopRule = function() {
   return () => {
     return {
@@ -52,146 +127,198 @@ module.exports.createNoopRule = function() {
 };
 
 /**
+ * Run checks on a node. Return true if at least one of the checks returns true.
+ * Otherwise return all errors or false.
+ *
  * @param {ModdleElement} node
  * @param {Array<Function>} checks
  *
- * @returns boolean|String
+ * @returns {boolean|Object|Object[]|string|string[]}
  */
 function checkNode(node, checks) {
-  return checks.reduce((previousResult, check) => {
-    if (previousResult === true) {
-      return previousResult;
-    }
+  const results = checks.map((check) => {
 
     // (1) check using type only
     if (isString(check)) {
-      return is(node, check) || previousResult;
+      return isExactly(node, check);
     }
 
     const { type } = check;
 
     // (2) check using function only
     if (!type) {
-      return check.check(node) || previousResult;
+      return check.check(node);
     }
 
     // (3) check using type and function
-    if (!is(node, type)) {
-      return previousResult;
+    if (!isExactly(node, type)) {
+      return false;
     }
 
-    return check.check(node) || previousResult;
-  }, false);
+    return check.check(node);
+  });
+
+  return results.find((result) => result === true) || getErrors(results);
 }
 
+module.exports.checkNode = checkNode;
+
 /**
- * If every check returns true return true.
- * Otherwise return the first false or string returned by a check.
+ * Create function that runs checks on a node. Return true if all checks return
+ * true. Otherwise return all errors or false.
  *
  * @param  {Array<Function>} checks
  *
- * @returns {boolean|String}
+ * @returns {boolean|Object|Object[]|string|string[]}
  */
 module.exports.checkEvery = function(...checks) {
   return function(node) {
-    return checks.reduce((previousResult, check) => {
-      if (!isNil(previousResult) && previousResult !== true) {
-        return previousResult;
-      }
+    const results = checks.map((check) => check(node));
 
-      const result = check(node);
-
-      return result;
-    }, null);
+    return every(results, result => result === true) || getErrors(results);
   };
-}
+};
 
 /**
- * If some check returns true return true.
- * Otherwise return the first false or string returned by a check.
+ * Create function that runs checks on a node. Return true if at least one of
+ * the checks returns true. Otherwise return all errors or false.
  *
  * @param  {Array<Function>} checks
  *
- * @returns {boolean|String}
+ * @returns {boolean|Object|Object[]|string|string[]}
  */
 module.exports.checkSome = function(...checks) {
   return function(node) {
-    return checks.reduce((previousResult, check) => {
-      if (previousResult === true) {
-        return previousResult;
-      }
+    const results = checks.map((check) => check(node));
 
-      const result = check(node);
+    return some(results, result => result === true) || getErrors(results);
+  };
+};
+
+/**
+ * Replace check for element of type.
+ *
+ * @param {(Object|string)[]} checks
+ * @param {string} type
+ * @param {Function} check
+ *
+ * @returns {(Object|string)[]}
+ */
+module.exports.replaceCheck = function(checks, type, check) {
+  return replaceChecks(checks, [
+    {
+      type,
+      check
+    }
+  ]);
+};
 
-      if (isNil(previousResult) || result === true) {
-        return result;
+function replaceChecks(checks, replacements) {
+  return checks.map((check) => {
+    if (isString(check)) {
+      const replacement = replacements.find((replacement) => check === replacement.type);
+
+      if (replacement) {
+        return {
+          check: replacement.check,
+          type: check
+        };
       }
+    }
 
-      return previousResult;
-    }, null);
-  };
-}
+    if (check.type) {
+      const replacement = replacements.find((replacement) => check.type === replacement.type);
 
-module.exports.hasEventDefinition = function(node) {
-  const eventDefinitions = node.get('eventDefinitions');
+      if (replacement) {
+        return {
+          ...check,
+          check: replacement.check
+        };
+      }
+    }
 
-  return eventDefinitions && eventDefinitions.length === 1;
+    return check;
+  });
 }
 
-module.exports.hasNoEventDefinition = function(node) {
-  const eventDefinitions = node.get('eventDefinitions');
+module.exports.replaceChecks = replaceChecks;
 
-  return !eventDefinitions || !eventDefinitions.length || `${ node.$type} (${ eventDefinitions[ 0 ].$type })`;
+function addExecutionPlatform(string, executionPlatform) {
+  return string
+    .replace('{{ executionPlatform }}', executionPlatform);
 }
 
-module.exports.hasEventDefinitionOfType = function(types) {
-  return function(node) {
-    if (!isArray(types)) {
-      types = [ types ];
+/**
+ * Return all errors or false.
+ *
+ * @param {(boolean|Object|string)[]} result
+ *
+ * @returns {boolean|(Object|string)[]}
+ */
+function getErrors(results) {
+  const errors = results.reduce((errors, result) => {
+    if (isArray(result)) {
+      return [
+        ...errors,
+        ...result
+      ];
     }
 
-    const eventDefinitions = node.get('eventDefinitions');
-
-    if (!eventDefinitions || eventDefinitions.length !== 1) {
-      return false;
+    if (isObject(result) || isString(result)) {
+      return [
+        ...errors,
+        result
+      ];
     }
 
-    const eventDefinition = eventDefinitions[ 0 ];
-
-    return isAny(eventDefinition, types) || `${ node.$type} (${ eventDefinition.$type })`;
-  };
-}
+    return errors;
+  }, []);
 
-module.exports.hasLoopCharacteristics = function(node) {
-  const loopCharacteristics = node.get('loopCharacteristics');
+  if (errors.length === 1) {
+    return errors[ 0 ];
+  } else if (errors.length > 1) {
+    return errors;
+  }
 
-  return !!loopCharacteristics;
+  return false;
 }
 
-module.exports.hasNoLoopCharacteristics = function(node) {
-  const loopCharacteristics = node.get('loopCharacteristics');
+function isExactly(node, type) {
+  const { $model } = node;
 
-  return !loopCharacteristics || `${ node.$type} (${ loopCharacteristics.$type })`;
+  return $model.getType(node.$type) === $model.getType(type);
 }
 
-module.exports.hasNoLanes = function(node) {
-  const laneSets = node.get('laneSets');
-
-  return !laneSets || !laneSets.length || `${ node.$type} (bpmn:LaneSet)`;
+function getIndefiniteArticle(type) {
+  if ([
+    'Error',
+    'Escalation',
+    'Event',
+    'Intermediate',
+    'Undefined'
+  ].includes(type.split(' ')[ 0 ])) {
+    return 'An';
+  }
+
+  return 'A';
 }
 
-module.exports.hasLoopCharacteristicsOfType = function(type) {
-  return function(node) {
-    const loopCharacteristics = node.get('loopCharacteristics');
+function getMessage(node, executionPlatform, executionPlatformVersion, label) {
+  const type = getTypeString(node);
 
-    if (!loopCharacteristics) {
-      return false;
-    }
+  const indefiniteArticle = getIndefiniteArticle(type);
 
-    return is(loopCharacteristics, type) || `${ node.$type} (${ loopCharacteristics.$type })`;
-  };
+  return addExecutionPlatform(`${ indefiniteArticle } <${ type }> is not supported by {{ executionPlatform }}`, label || `${ executionPlatform } ${ toSemverMinor(executionPlatformVersion) }`);
 }
 
-module.exports.isNotBpmn = function(node) {
-  return !is(node, 'bpmn:BaseElement');
+function getLabel(node) {
+  if (is(node, 'bpmn:Group')) {
+    const categoryValueRef = node.get('categoryValueRef');
+
+    return categoryValueRef && categoryValueRef.get('value');
+  } else if (is(node, 'bpmn:TextAnnotation')) {
+    return node.get('text');
+  }
+
+  return node.get('name');
 }

package/rules/utils/type.js

@@ -0,0 +1,47 @@
+function getEventDefinition(node) {
+  const eventDefinitions = node.get('eventDefinitions');
+
+  return eventDefinitions && eventDefinitions[0];
+}
+
+function getEventDefinitionPrefix(eventDefinition) {
+  const localType = getLocalType(eventDefinition);
+
+  return localType.replace('EventDefinition', '');
+}
+
+function getLocalType(node) {
+  const { $descriptor } = node;
+
+  const { localName } = $descriptor.ns;
+
+  return localName;
+}
+
+function formatTypeString(string) {
+  return string.replace(/([a-z])([A-Z])/g, '$1 $2').trim();
+}
+
+module.exports.getTypeString = function(node) {
+  let type = getLocalType(node);
+
+  const eventDefinition = getEventDefinition(node);
+
+  if (eventDefinition) {
+    type = `${ getEventDefinitionPrefix(eventDefinition) }${ type }`;
+  } else if ([
+    'BoundaryEvent',
+    'EndEvent',
+    'IntermediateCatchEvent',
+    'IntermediateThrowEvent',
+    'StartEvent'
+  ].includes(type)) {
+    type = `Undefined ${ type }`;
+  }
+
+  if (type === 'Task') {
+    type = 'Undefined Task';
+  }
+
+  return formatTypeString(type);
+};

package/rules/camunda-cloud-1-4.js

@@ -1,5 +0,0 @@
-const { createRule } = require('./utils/rule');
-
-const checks = require('./camunda-cloud-1-4-checks');
-
-module.exports = createRule('Camunda Cloud', '1.4', checks);