chore: rename event-reference to global

config/all.js

@@ -1,9 +1,9 @@
 const allRules = [
   'conditional-flows',
   'end-event-required',
-  'event-reference',
   'event-sub-process-typed-start-event',
   'fake-join',
+  'global',
   'label-required',
   'link-event',
   'no-bpmndi',

config/recommended.js

@@ -2,9 +2,9 @@ module.exports = {
   rules: {
     'conditional-flows': 'error',
     'end-event-required': 'error',
-    'event-reference': 'warn',
     'event-sub-process-typed-start-event': 'error',
     'fake-join': 'warn',
+    'global': 'warn',
     'label-required': 'error',
     'link-event': 'error',
     'no-bpmndi': 'error',

rules/event-reference.js → rules/global.js

@@ -4,15 +4,20 @@ const {
 
 
 /**
- * A rule that verifies that event references are properly used.
+ * A rule that verifies that global elements are properly used.
  *
- * This implies:
+ * Currently recognized global elements are:
  *
- *   * event references have a name
- *   * event references are in use
- *   * there exists only a single event reference
- *     with a given name, per scope, per type
+ *   * `bpmn:Error`
+ *   * `bpmn:Escalation`
+ *   * `bpmn:Signal`
+ *   * `bpmn:Message`
  *
+ * For each of these elements proper usage implies:
+ *
+ *   * element must have a name
+ *   * element is used (referenced) from event definitions
+ *   * there exists only a single element per type with a given name
  */
 module.exports = function() {
 
@@ -27,15 +32,15 @@ module.exports = function() {
 
     events.forEach(event => {
       if (!hasName(event)) {
-        reporter.report(event.id, 'Event reference is missing name');
+        reporter.report(event.id, 'Element is missing name');
       }
 
       if (!isReferenced(event, eventDefinitions)) {
-        reporter.report(event.id, 'Event reference is unused');
+        reporter.report(event.id, 'Element is unused');
       }
 
       if (!isUnique(event, events)) {
-        reporter.report(event.id, 'Event reference name is not unique');
+        reporter.report(event.id, 'Element name is not unique');
       }
     });
 

test/integration/compilation/test/bpmnlintrc.expected.js

@@ -31,9 +31,9 @@ const resolver = new Resolver();
 const rules = {
   "conditional-flows": "error",
   "end-event-required": "error",
-  "event-reference": "warn",
   "event-sub-process-typed-start-event": "error",
   "fake-join": "warn",
+  "global": "warn",
   "label-required": "error",
   "link-event": "error",
   "no-bpmndi": "error",
@@ -80,17 +80,17 @@ import rule_1 from 'bpmnlint/rules/end-event-required';
 
 cache['bpmnlint/end-event-required'] = rule_1;
 
-import rule_2 from 'bpmnlint/rules/event-reference';
+import rule_2 from 'bpmnlint/rules/event-sub-process-typed-start-event';
 
-cache['bpmnlint/event-reference'] = rule_2;
+cache['bpmnlint/event-sub-process-typed-start-event'] = rule_2;
 
-import rule_3 from 'bpmnlint/rules/event-sub-process-typed-start-event';
+import rule_3 from 'bpmnlint/rules/fake-join';
 
-cache['bpmnlint/event-sub-process-typed-start-event'] = rule_3;
+cache['bpmnlint/fake-join'] = rule_3;
 
-import rule_4 from 'bpmnlint/rules/fake-join';
+import rule_4 from 'bpmnlint/rules/global';
 
-cache['bpmnlint/fake-join'] = rule_4;
+cache['bpmnlint/global'] = rule_4;
 
 import rule_5 from 'bpmnlint/rules/label-required';
 

test/rules/global.mjs

@@ -0,0 +1,133 @@
+import RuleTester from '../../lib/testers/rule-tester.js';
+
+import rule from '../../rules/global.js';
+
+import {
+  readModdle
+} from '../../lib/testers/helper.js';
+
+import { stubCJS } from '../helper.mjs';
+
+const {
+  __dirname
+} = stubCJS(import.meta.url);
+
+
+RuleTester.verify('global', rule, {
+  valid: [
+    {
+      moddleElement: readModdle(__dirname + '/global/valid-error.bpmn')
+    },
+    {
+      moddleElement: readModdle(__dirname + '/global/valid-escalation.bpmn')
+    },
+    {
+      moddleElement: readModdle(__dirname + '/global/valid-message.bpmn')
+    },
+    {
+      moddleElement: readModdle(__dirname + '/global/valid-no-ref.bpmn')
+    }
+  ],
+  invalid: [
+    {
+      moddleElement: readModdle(__dirname + '/global/invalid-error-missing-name.bpmn'),
+      report: {
+        id: 'Error',
+        message: 'Element is missing name'
+      }
+    },
+    {
+      moddleElement: readModdle(__dirname + '/global/invalid-escalation-missing-name.bpmn'),
+      report: {
+        id: 'Escalation',
+        message: 'Element is missing name'
+      }
+    },
+    {
+      moddleElement: readModdle(__dirname + '/global/invalid-message-missing-name.bpmn'),
+      report: {
+        id: 'Message',
+        message: 'Element is missing name'
+      }
+    },
+    {
+      moddleElement: readModdle(__dirname + '/global/invalid-signal-missing-name.bpmn'),
+      report: {
+        id: 'Signal',
+        message: 'Element is missing name'
+      }
+    },
+    {
+      moddleElement: readModdle(__dirname + '/global/invalid-error-missing-reference.bpmn'),
+      report: {
+        id: 'Error',
+        message: 'Element is unused'
+      }
+    },
+    {
+      moddleElement: readModdle(__dirname + '/global/invalid-escalation-missing-reference.bpmn'),
+      report: {
+        id: 'Escalation',
+        message: 'Element is unused'
+      }
+    },
+    {
+      moddleElement: readModdle(__dirname + '/global/invalid-message-missing-reference.bpmn'),
+      report: {
+        id: 'Message',
+        message: 'Element is unused'
+      }
+    },
+    {
+      moddleElement: readModdle(__dirname + '/global/invalid-signal-missing-reference.bpmn'),
+      report: {
+        id: 'Signal',
+        message: 'Element is unused'
+      }
+    },
+    {
+      moddleElement: readModdle(__dirname + '/global/invalid-error-duplicate-name.bpmn'),
+      report: [ {
+        id: 'Error_1',
+        message: 'Element name is not unique'
+      },
+      {
+        id: 'Error_2',
+        message: 'Element name is not unique'
+      } ]
+    },
+    {
+      moddleElement: readModdle(__dirname + '/global/invalid-escalation-duplicate-name.bpmn'),
+      report: [ {
+        id: 'Escalation_1',
+        message: 'Element name is not unique'
+      },
+      {
+        id: 'Escalation_2',
+        message: 'Element name is not unique'
+      } ]
+    },
+    {
+      moddleElement: readModdle(__dirname + '/global/invalid-message-duplicate-name.bpmn'),
+      report: [ {
+        id: 'Message_1',
+        message: 'Element name is not unique'
+      },
+      {
+        id: 'Message_2',
+        message: 'Element name is not unique'
+      } ]
+    },
+    {
+      moddleElement: readModdle(__dirname + '/global/invalid-signal-duplicate-name.bpmn'),
+      report: [ {
+        id: 'Signal_1',
+        message: 'Element name is not unique'
+      },
+      {
+        id: 'Signal_2',
+        message: 'Element name is not unique'
+      } ]
+    }
+  ]
+});