Support dialects

README.md

@@ -14,7 +14,16 @@ const editor = new FeelEditor({
 });
 ```
 
-Optionally, you can provide a starting document and listen for changes:
+Configure the FEEL dialect (expression or unary tests):
+
+```JavaScript
+const editor = new FeelEditor({
+  container,
+  dialect: 'unaryTests' // defaults to 'expression'
+});
+```
+
+You can provide a starting document and listen for changes:
 
 ```JavaScript
 const editor = new FeelEditor({

src/index.js

@@ -32,6 +32,7 @@ const placeholderConf = new Compartment();
  * @param {Object} config
  * @param {DOMNode} config.container
  * @param {Extension[]} [config.extensions]
+ * @param {'expression' | 'unaryTests'} [config.dialect='expression']
  * @param {DOMNode|String} [config.tooltipContainer]
  * @param {Function} [config.onChange]
  * @param {Function} [config.onKeyDown]
@@ -44,6 +45,7 @@ const placeholderConf = new Compartment();
  */
 export default function FeelEditor({
   extensions: editorExtensions = [],
+  dialect = 'expression',
   container,
   contentAttributes = {},
   tooltipContainer,
@@ -104,7 +106,9 @@ export default function FeelEditor({
     keymap.of([
       ...defaultKeymap,
     ]),
-    language(),
+    language({
+      dialect
+    }),
     linter,
     lintHandler,
     placeholderConf.of(placeholderExt(placeholder)),

src/language/index.js

@@ -1,6 +1,10 @@
-import { LanguageSupport } from '@codemirror/language';
-import { feelLanguage } from 'lang-feel';
+import { feel } from 'lang-feel';
 
-export function language() {
-  return new LanguageSupport(feelLanguage, [ ]);
+/**
+ * @param {'expression' | 'unaryTests'} dialect
+ *
+ * @return {LanguageSupport}
+ */
+export function language(dialect) {
+  return feel(dialect);
 }

test/spec/CodeEditor.spec.js

@@ -133,6 +133,22 @@ return
   });
 
 
+  it('should configure <unaryTests> dialect', async function() {
+
+    // when
+    const initialValue = '"Hello", "World"';
+    const editor = new FeelEditor({
+      container,
+      value: initialValue,
+      dialect: 'unaryTests'
+    });
+
+    // then
+    expect(editor).to.exist;
+    expect(editor._cmEditor.state.doc.toString()).to.equal('"Hello", "World"');
+  });
+
+
   it('should allow for extensions', async function() {
 
     // when
@@ -497,129 +513,124 @@ return
 
   describe('lint', function() {
 
-    it('should not highlight empty document', function(done) {
+    it('should not highlight empty document', async function() {
       const initalValue = '';
 
       const editor = new FeelEditor({
         container,
         value: initalValue
       });
 
-      const cm = getCm(editor);
-
       // when
-      forceLinting(cm);
+      const diagnostics = await lint(editor);
 
       // then
-      // update done async
-      setTimeout(() => {
-        expect(diagnosticCount(cm.state)).to.eql(0);
-        done();
-      }, 0);
+      expect(diagnostics).to.eql(0);
+    });
+
+
+    describe('should not highlight valid', function() {
+
+      [
+        { dialect: 'expression', value: 'Mike < 10' },
+        { dialect: 'unaryTests', value: '12, now(), "STRING"' }
+      ].forEach(({ dialect, value }) => {
+
+        it(`<${dialect}>`, async function() {
+
+          // given
+          const editor = new FeelEditor({
+            container,
+            value,
+            dialect
+          });
+
+          // when
+          const diagnostics = await lint(editor);
+
+          // then
+          expect(diagnostics).to.eql(0);
+        });
+
+      });
 
     });
 
 
-    it('should highlight unexpected operations', function(done) {
+    it('should highlight unexpected operations', async function() {
       const initalValue = '= 15';
 
       const editor = new FeelEditor({
         container,
         value: initalValue
       });
 
-      const cm = getCm(editor);
-
       // when
-      forceLinting(cm);
+      const diagnostics = await lint(editor);
 
       // then
-      // update done async
-      setTimeout(() => {
-        expect(diagnosticCount(cm.state)).to.eql(1);
-        done();
-      }, 0);
-
+      expect(diagnostics).to.eql(1);
     });
 
 
-    it('should highlight missing operations', function(done) {
+    it('should highlight missing operations', async function() {
       const initalValue = '15 == 15';
 
       const editor = new FeelEditor({
         container,
         value: initalValue
       });
 
-      const cm = getCm(editor);
-
       // when
-      forceLinting(cm);
+      const diagnostics = await lint(editor);
 
       // then
-      // update done async
-      setTimeout(() => {
-        expect(diagnosticCount(cm.state)).to.eql(1);
-        done();
-      }, 0);
-
+      expect(diagnostics).to.eql(1);
     });
 
 
-    it('should call onLint with errors', function(done) {
-      const initalValue = '= 15';
-      const onLint = sinon.spy();
+    describe('should call onLint', function() {
 
-      const editor = new FeelEditor({
-        container,
-        value: initalValue,
-        onLint
-      });
+      it('with errors', async function() {
 
-      const cm = getCm(editor);
+        const initalValue = '= 15';
+        const onLint = sinon.spy();
 
-      // when
-      forceLinting(cm);
+        const editor = new FeelEditor({
+          container,
+          value: initalValue,
+          onLint
+        });
 
-      // then
-      // update done async
-      setTimeout(() => {
+        // when
+        await lint(editor);
 
+        // then
         expect(onLint).to.have.been.calledOnce;
         expect(onLint).to.have.been.calledWith(sinon.match.array);
         expect(onLint.args[0][0]).to.have.length(1);
-
-        done();
-      }, 0);
-
-    });
-
-
-    it('should call onLint without errors', function(done) {
-      const initalValue = '15';
-      const onLint = sinon.spy();
-
-      const editor = new FeelEditor({
-        container,
-        value: initalValue,
-        onLint
       });
 
-      const cm = getCm(editor);
 
-      // when
-      forceLinting(cm);
+      it('without errors', async function() {
+        const initalValue = '15';
+        const onLint = sinon.spy();
 
-      // then
-      // update done async
-      setTimeout(() => {
+        const editor = new FeelEditor({
+          container,
+          value: initalValue,
+          onLint
+        });
+
+        // when
+        await lint(editor);
 
+        // then
+        // update done async
         expect(onLint).to.have.been.calledOnce;
         expect(onLint).to.have.been.calledWith(sinon.match.array);
         expect(onLint.args[0][0]).to.have.length(0);
-
-        done();
-      }, 0);
+      });
 
     });
 
@@ -884,6 +895,11 @@ function select(editor, anchor, head = anchor) {
   });
 }
 
+/**
+ * @param {FeelEditor} editor
+ *
+ * @return {import('@codemirror/view').EditorView}
+ */
 function getCm(editor) {
   return editor._cmEditor || editor;
 }
@@ -906,3 +922,23 @@ async function expectEventually(fn) {
 
   throw e;
 }
+
+function wait(ms = 0) {
+  return new Promise(resolve => setTimeout(resolve, ms));
+}
+
+/**
+ * @param {FeelEditor} editor
+ *
+ * @return {Promise<number>}
+ */
+async function lint(editor) {
+  const cm = getCm(editor);
+
+  // when
+  forceLinting(cm);
+
+  await wait();
+
+  return diagnosticCount(cm.state);
+}