vitest-cucumber-plugin 0.1.5 → 0.1.7

package/README.md

@@ -22,7 +22,10 @@ import vitestCucumberPlugin from 'vitest-cucumber-plugin';
 export default defineConfig({
     plugins: [vitestCucumberPlugin()],
     test: {
-        include : [ '**/*.feature' ]
+        include : [ '**/*.feature' ],
+        cucumber : {
+           tags : "<tags boolean expression>"
+        }
     },
 })
 ```
@@ -46,8 +49,9 @@ there are a few differences in how step definitions are written.
 
 The function signatures for Given, When and Then callbacks have been modified in order to make the step definitions
 more friendly for functional programming.  Specifically, the callback functions differ in that they
-now have two parameters, a state object and array of parameters.  The callback functions then return a new state
-object which is passed to the next step definition in the chain.
+now have three parameters.  The first parameter is a state object which was returned by the previous step.  The
+second is an array of parameters values.  The third is a data table or a doc string.  The callback functions then
+return a new state object which is passed to the next step definition in the chain.
 
 For example, here is how you'd write step definitions in Cucumber:
 ```
@@ -70,7 +74,7 @@ When('I ask whether it\'s Friday yet', function () {
   this.actualAnswer = isItFriday(this.today);
 });
 
-Then('I should be told {string}', function (expectedAnswer) {
+Then('I should be told {string}', function (expectedAnswer, dataTable) {
   assert.strictEqual(this.actualAnswer, expectedAnswer);
 });
 ```
@@ -93,7 +97,7 @@ When('I ask whether it\'s Friday yet', function (state) {
     return _.set('answer',(state.today === 'Friday') ? 'TGIF' : 'Nope',state);
 });
 
-Then('I should be told {string}', function (state,[ answer ]) {
+Then('I should be told {string}', function (state,[ answer ], dataTable) {
     expect(state.answer).toBe(answer);
 });
 ```
@@ -109,4 +113,3 @@ work, but this configuration isn't tested.
 This plugin is not yet feature complete.  Here is the list of features from Cucumber which aren't yet implemented:
 * Rule keyword
 * Doc strings
-* Boolean expression support for tags

package/RELEASE_NOTES.md

@@ -1,3 +1,5 @@
+* v0.1.7 : Implemented Hooks API
+* v0.1.6 : Implemented tags boolean expression support
 * v0.1.5 : Implemented escape characters for Data Tables
 * v0.1.4 : Changed README to point to RPM registry
 * v0.1.3 : Import modules from generated code to make sure they are processed correctly

package/generate-parsers

@@ -0,0 +1,6 @@
+#!/bin/bash
+
+nearleyc src/gherkin.ne -o src/gherkin.umd.js || exit 1
+nearleyc src/tags-expression.ne -o src/tags-expression.umd.js || exit 1
+rollup -c rollup-gherkin.js || exit 1
+rollup -c rollup-tags-expression.js || exit 1

package/package.json

@@ -1,21 +1,21 @@
 {
     "name": "vitest-cucumber-plugin",
-    "version": "0.1.5",
+    "version": "0.1.7",
     "description": "Plugin for Vitest which allows for tests to be written in Cucumber format.",
     "keywords": [
         "vite",
         "vitest",
         "cucumber"
     ],
-    "homepage": "https://github.com/SamZiegler/vitest-cucumber-plugin#readme",
+    "homepage": "https://github.com/samuel-ziegler/vitest-cucumber-plugin#readme",
     "bugs": {
-        "url": "https://github.com/SamZiegler/vitest-cucumber-plugin/issues"
+        "url": "https://github.com/samuel-ziegler/vitest-cucumber-plugin/issues"
     },
     "license": "MIT",
     "main": "src/index.js",
     "type": "module",
     "scripts": {
-        "nearley": "nearleyc src/gherkin.ne -o src/gherkin.umd.js && rollup -c rollup-nearley.js",
+        "nearley": "./generate-parsers",
         "test": "./run-tests"
     },
     "dependencies": {
@@ -30,5 +30,5 @@
         "@types/lodash": "^4.14.194",
         "rollup": "^3.20.7"
     },
-    "repository": "https://github.com/SamZiegler/vitest-cucumber-plugin.git"
+    "repository": "https://github.com/samuel-ziegler/vitest-cucumber-plugin.git"
 }

package/rollup-tags-expression.js

@@ -0,0 +1,10 @@
+import commonjs from "@rollup/plugin-commonjs";
+
+export default {
+    input: "src/tags-expression.umd.js",
+    output: {
+        file: "src/tags-expression.js",
+        format: "es",
+    },
+    plugins: [commonjs()],
+};

package/run-tests

@@ -1,8 +1,9 @@
 #!/usr/bin/bash
 
 for i in `ls tests`; do
+    echo $i
     pushd tests/$i
-    npm install || exit
-    npm test || exit
+    npm install || exit 1
+    npm test || exit 1
     popd
 done

package/src/generate/example.js

@@ -9,11 +9,12 @@ export const generateExample = (config,example) => {
 
     const steps = _.has('background.steps',example) ? _.concat(example.background.steps,example.steps) : example.steps;
 
-    tests += generateTests(steps);
+    tests += generateTests(steps,{},example.tags);
     
     const skip = shouldSkip(config,example.tags) ? '.skip' : '';
 
-    const code = `  describe${skip}('${escape(example.type.name)}: ${escape(example.name)}', () => {${tests}
+    const code = `  // tags : ${JSON.stringify(example.tags)}
+  describe${skip}('${escape(example.type.name)}: ${escape(example.name)}', () => {${tests}
   });
 `;
     return code;

package/src/generate/examples.js

@@ -14,12 +14,12 @@ const createParameterMap = (parameters,values) => {
     return parameterMap.map;
 }
 
-const generateAllTests = (steps,parameters,parameterValues) => {
+const generateAllTests = (steps,parameters,parameterValues,tags) => {
     const allTests = _.reduce((allTests,values) => {
         const parameterMap = createParameterMap(parameters,values);
         log.debug('parameterMap : '+JSON.stringify(parameterMap));
 
-        const tests = generateTests(steps,parameterMap,'    ');
+        const tests = generateTests(steps,parameterMap,tags,'    ');
 
         return { tests : allTests.tests + `
       describe('${allTests.index}',() => {${tests}
@@ -40,8 +40,10 @@ export const generateExamples = (config,steps,examplesStatement) => {
 
     const skip = shouldSkip(config,examplesStatement.tags) ? '.skip' : '';
 
-    const allTests = generateAllTests(steps,parameters,parameterValues);
-    const code = `    describe${skip}('${escape(examplesStatement.type.name)}: ${escape(examplesStatement.name)}', () => {${allTests}
+    const allTests = generateAllTests(steps,parameters,parameterValues,examplesStatement.tags);
+    const code = `
+    // tags : ${JSON.stringify(examplesStatement.tags)}
+    describe${skip}('${escape(examplesStatement.type.name)}: ${escape(examplesStatement.name)}', () => {${allTests}
     });`;
     return code;
 }

package/src/generate/feature.js

@@ -11,6 +11,9 @@ export const generateFeature = (config,feature) => {
         if (feature.background) {
             statement = _.set('background',feature.background,statement);
         }
+
+        statement = _.set('tags',_.concat(feature.tags,statement.tags),statement);
+        
         if (statement.type.type === 'example') {
             return testStatements + generateExample(config,statement);
         } else if (statement.type.type === 'scenarioOutline') {
@@ -20,26 +23,60 @@ export const generateFeature = (config,feature) => {
 
     const skip = shouldSkip(config,feature.tags) ? '.skip' : '';
     const configStr = JSON.stringify(config);
+    const tagsStr = JSON.stringify(feature.tags);
 
-    const code = `import { expect, test, describe } from 'vitest';
-import { Test } from 'vitest-cucumber-plugin';
+    const code = `import { expect, test, describe, beforeAll, afterAll, beforeEach, afterEach } from 'vitest';
+import {
+    Test,
+    applyBeforeAllHooks,
+    applyBeforeHooks,
+    applyBeforeStepHooks,
+    applyAfterAllHooks,
+    applyAfterHooks,
+    applyAfterStepHooks,
+} from 'vitest-cucumber-plugin';
 import { readdir } from 'node:fs/promises';
+import { log, setLogLevel } from 'vitest-cucumber-plugin';
+
+setLogLevel('${config.logLevel}');
+
+const importDirectory = async (directory) => {
+    log.debug('importDirectory directory: '+directory);
+    try {
+        const files = await readdir(directory);
 
-const importStepDefinitions = async (config) => {
-    const stepDefinitionDirectory = config.root+'/features/step_definitions';
-    const files = await readdir(stepDefinitionDirectory);
-    for (const file of files) {
-        const stepDefinition = stepDefinitionDirectory+'/'+file;
-        await import(stepDefinition);
+        for (const file of files) {
+            const filename = directory+'/'+file;
+            log.debug('importDirectory import: '+filename);
+            await import(filename);
+        }
+    } catch (e) {
+        log.debug('importDirectory error: '+e);
     }
 };
 
+const importSupportFiles = async (config) => importDirectory(config.root+'/features/support');
+
+await importSupportFiles(${configStr});
+
+const importStepDefinitions = async (config) => importDirectory(config.root+'/features/step_definitions');
+
 await importStepDefinitions(${configStr});
 
+var state = {};
+
+beforeAll(async () => {
+    state = await applyBeforeAllHooks(state,${tagsStr});
+});
+
+afterAll(async () => {
+    state = await applyAfterAllHooks(state,${tagsStr});
+});
+
+// tags : ${tagsStr}
 describe${skip}('${escape(feature.type.name)}: ${escape(name)}', () => {
 ${testStatements}});
 `;
-    log.debug(code);
 
     return code;
 }

package/src/generate/index.js

@@ -1,7 +1,7 @@
 import { generateTests } from './tests.js';
 import { generateExample } from './example.js';
 import { generateExamples } from './examples.js';
-import { generateScenarioOutline } from './scenarioOutline.js';
+import { generateScenarioOutline } from './scenario-outline.js';
 import { generateFeature } from './feature.js';
 
 export {

package/src/generate/{scenarioOutline.js → scenario-outline.js}

@@ -4,12 +4,15 @@ import { escape, shouldSkip } from './util.js';
 
 export const generateScenarioOutline = (config,scenarioOutline) => {
     const examplesStatements = _.reduce((examplesStatements,examplesStatement) => {
+        examplesStatement = _.set('tags',_.concat(scenarioOutline.tags,examplesStatement.tags),examplesStatement);
+        
         return examplesStatements + generateExamples(config,scenarioOutline.steps,examplesStatement);
     },'')(scenarioOutline.examples);
 
     const skip = shouldSkip(config,scenarioOutline.tags) ? '.skip' : '';
 
-    const code = `  describe${skip}('${escape(scenarioOutline.type.name)}: ${escape(scenarioOutline.name)}', () => {
+    const code = `  // tags : ${JSON.stringify(scenarioOutline.tags)}
+  describe${skip}('${escape(scenarioOutline.type.name)}: ${escape(scenarioOutline.name)}', () => {
 ${examplesStatements}
   });
 `;

package/src/generate/tests.js

@@ -3,11 +3,16 @@ import { escape } from './util.js';
 import { parameterizeText } from '../parameterize.js';
 import { log } from '../logger.js';
 
-export const generateTests = (steps,parameterMap,extraIndent) => {
+export const generateTests = (steps,parameterMap,tags,extraIndent) => {
     log.debug('generateTests steps : '+JSON.stringify(steps));
+    const tagsStr = JSON.stringify(tags);
     const indent = extraIndent ? extraIndent : '';
     let tests = `
-${indent}    var state = {};`;
+${indent}    beforeAll(async () => { state = await applyBeforeHooks(state,${tagsStr}); });
+${indent}    beforeEach(async () => { state = await applyBeforeStepHooks(state,${tagsStr}); });
+${indent}    afterAll(async () => { state = await applyAfterHooks(state,${tagsStr}); });
+${indent}    afterEach(async () => { state = await applyAfterStepHooks(state,${tagsStr}); });
+`;
     
     _.forEach((step) => {
         const parameterizedText = ( parameterMap ? parameterizeText(step.text,parameterMap) : step.text);

package/src/generate/util.js

@@ -3,8 +3,7 @@ import { log } from '../logger.js';
 
 export const escape = (str) => str.replace(/'/g,"\\'");
 export const shouldSkip = (config,tags) => {
-    const exclude = _.getOr([],'tags.exclude',config);
-    const intersection = _.intersection(exclude,tags);
-    log.debug('shouldSkip config: '+JSON.stringify(config)+' tags: '+JSON.stringify(tags)+' intersection: '+JSON.stringify(intersection));
-    return intersection.length > 0;
+    const result = !config.tagsFunction(tags);
+    log.debug('shouldSkip? '+result+' tags: '+JSON.stringify(tags));
+    return result;
 }

package/src/gherkin.js

@@ -1,55 +1,12 @@
 import require$$0 from 'lodash/fp.js';
 import require$$1 from 'moo';
-import pino from 'pino';
 
 function getDefaultExportFromCjs (x) {
 	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
 }
 
-function getAugmentedNamespace(n) {
-  if (n.__esModule) return n;
-  var f = n.default;
-	if (typeof f == "function") {
-		var a = function a () {
-			if (this instanceof a) {
-				var args = [null];
-				args.push.apply(args, arguments);
-				var Ctor = Function.bind.apply(f, args);
-				return new Ctor();
-			}
-			return f.apply(this, arguments);
-		};
-		a.prototype = f.prototype;
-  } else a = {};
-  Object.defineProperty(a, '__esModule', {value: true});
-	Object.keys(n).forEach(function (k) {
-		var d = Object.getOwnPropertyDescriptor(n, k);
-		Object.defineProperty(a, k, d.get ? d : {
-			enumerable: true,
-			get: function () {
-				return n[k];
-			}
-		});
-	});
-	return a;
-}
-
 var gherkin_umd$1 = {exports: {}};
 
-const log = pino();
-
-log.level = 'warn';
-
-const setLogLevel = (logLevel) => { log.level = logLevel; };
-
-var logger = /*#__PURE__*/Object.freeze({
-	__proto__: null,
-	log: log,
-	setLogLevel: setLogLevel
-});
-
-var require$$2 = /*@__PURE__*/getAugmentedNamespace(logger);
-
 (function (module) {
 	// Generated automatically by nearley, version 2.20.1
 	// http://github.com/Hardmath123/nearley
@@ -57,7 +14,6 @@ var require$$2 = /*@__PURE__*/getAugmentedNamespace(logger);
 
 	const fp = require$$0;
 	const moo = require$$1;
-	require$$2.log;
 	const lexer = moo.compile({
 	  emptyLine : { match: /^[ \t]*(?:\#[^\n]+)?\n/, lineBreaks : true },
 	  newline : { match : '\n', lineBreaks : true },

package/src/gherkin.ne

@@ -1,7 +1,6 @@
 @{%
 const fp = require('lodash/fp.js');
 const moo = require('moo');
-const log = require('./logger.js').log;
 const lexer = moo.compile({
   emptyLine : { match: /^[ \t]*(?:\#[^\n]+)?\n/, lineBreaks : true },
   newline : { match : '\n', lineBreaks : true },

package/src/gherkin.umd.js

@@ -5,7 +5,6 @@ function id(x) { return x[0]; }
 
 const fp = require('lodash/fp.js');
 const moo = require('moo');
-const log = require('./logger.js').log;
 const lexer = moo.compile({
   emptyLine : { match: /^[ \t]*(?:\#[^\n]+)?\n/, lineBreaks : true },
   newline : { match : '\n', lineBreaks : true },

package/src/hooks.js

@@ -0,0 +1,66 @@
+import { log } from './logger.js';
+import _ from 'lodash/fp.js';
+import { tagsFunction } from './tags.js';
+
+const allHooks = {
+    beforeAll : [],
+    before : [],
+    beforeStep : [],
+    afterAll : [],
+    after : [],
+    afterStep : [],
+};
+
+const applyHooks = async (hooksName,state,tags) => {
+    const hooks = allHooks[hooksName];
+    log.debug('applyHooks: '+hooksName+' state: '+JSON.stringify(state));
+    for (let i = 0; i < hooks.length; i++) {
+        let hook = hooks[i];
+        
+        log.debug('applyHooks name: '+hook.name+' state: '+JSON.stringify(state));
+        
+        const result = hook.tagsFunction(tags);
+        
+        log.debug('applyHooks match? '+result+' tags: '+JSON.stringify(tags));
+        if (result) {
+            state = await hook.f(state);
+            log.debug('applyHooks name: '+hook.name+' new state: '+JSON.stringify(state));
+        }
+    }
+    return state;
+};
+
+const addHook = (hooksName,opts,f) => {
+    if (_.isFunction(opts)) {
+        opts = { name : '', f : opts };
+    } else if (_.isString(opts)) {
+        opts = { name : opts, f };
+    } else if (_.isObject(opts)) {
+        opts.f = f;
+    } else {
+        throw new Error('Unknown options argument: '+JSON.stringify(opts));
+    }
+
+    opts = _.set('tagsFunction',tagsFunction(opts.tags),opts);
+    
+    log.debug('addHook hooksName: '+hooksName+' name: '+opts.name);
+    allHooks[hooksName] = _.concat(allHooks[hooksName],opts);
+};
+
+export const BeforeAll = (opts,f) => { addHook('beforeAll',opts,f) };
+export const applyBeforeAllHooks = (state,tags) => applyHooks('beforeAll',state,tags);
+
+export const Before = (opts,f) => { addHook('before',opts,f) };
+export const applyBeforeHooks = (state,tags) => applyHooks('before',state,tags);
+
+export const BeforeStep = (opts,f) => { addHook('beforeStep',opts,f) };
+export const applyBeforeStepHooks = (state,tags) => applyHooks('beforeStep',state,tags);
+
+export const AfterAll = (opts,f) => { addHook('afterAll',opts,f) };
+export const applyAfterAllHooks = (state,tags) => applyHooks('afterAll',state,tags);
+
+export const After = (opts,f) => { addHook('after',opts,f) };
+export const applyAfterHooks = (state,tags) => applyHooks('after',state,tags);
+
+export const AfterStep = (opts,f) => { addHook('afterStep',opts,f) };
+export const applyAfterStepHooks = (state,tags) => applyHooks('afterStep',state,tags);

package/src/index.js

@@ -4,6 +4,15 @@ import { parameterizeText } from './parameterize.js';
 import { generateFeature } from './generate/index.js';
 import { log, setLogLevel } from './logger.js';
 import { parse } from './parse.js';
+import { tagsFunction } from './tags.js';
+import {
+    BeforeAll, applyBeforeAllHooks,
+    Before, applyBeforeHooks,
+    AfterAll, applyAfterAllHooks,
+    After, applyAfterHooks,
+    BeforeStep, applyBeforeStepHooks,
+    AfterStep, applyAfterStepHooks,
+} from './hooks.js';
 
 const featureRegex = /\.feature$/;
 
@@ -12,11 +21,22 @@ const compileFeatureToJS = (config,featureSrc) => {
 
     const code = generateFeature(config,feature);
 
-    log.debug(code);
-
     return code;
 }
 
+export { BeforeAll, Before, AfterAll, After, BeforeStep, AfterStep };
+
+export {
+    applyBeforeAllHooks,
+    applyBeforeHooks,
+    applyAfterAllHooks,
+    applyAfterHooks,
+    applyBeforeStepHooks,
+    applyAfterStepHooks,
+};
+
+export { setLogLevel, log };
+
 export const Given = addStepDefinition;
 export const When = addStepDefinition;
 export const Then = addStepDefinition;
@@ -44,18 +64,19 @@ export default function vitestCucumberPlugin() {
     return {
         name : 'vitest-cucumber-transform',
         configResolved : (resolvedConfig) => {
-            if (_.has('test.cucumber.logLevel',resolvedConfig)) {
-                setLogLevel(resolvedConfig.test.cucumber.logLevel);
-            }
-            log.debug('config: resolvedConfig:'+JSON.stringify(resolvedConfig,null,2));
-            config = _.get('test.cucumber',resolvedConfig);
-            config = _.set('root',resolvedConfig.root,config);
+            config = _.defaults({ root : resolvedConfig.root, logLevel : 'warn' },_.get('test.cucumber',resolvedConfig))
+            setLogLevel(config.logLevel);
+
+            config = _.set('tagsFunction',tagsFunction(_.get('tags',config)),config);
+
             log.debug('config: '+JSON.stringify(config));
         },
         transform : async (src,id) => {
             if (featureRegex.test(id)) {
                 const code = compileFeatureToJS(config,src);
 
+                log.debug('transform '+id+' -> '+code);
+
                 return {
                     code
                 }

package/src/parse.js

@@ -11,7 +11,7 @@ export const parse = (src) => {
     if (parser.results.length == 0) {
         throw new Error('Unexpected end of file');
     }
-    log.debug('parsing result: '+JSON.stringify(parser.results,null,2));
+    log.debug('parsing result: '+JSON.stringify(parser.results));
     if (parser.results.length > 1) {
         throw new Error('Ambiguous parsing: '+parser.results.length);
     }

package/src/tags-expression.js

@@ -0,0 +1,58 @@
+import 'lodash/fp.js';
+import require$$1 from 'moo';
+
+function getDefaultExportFromCjs (x) {
+	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
+}
+
+var tagsExpression_umd$1 = {exports: {}};
+
+(function (module) {
+	// Generated automatically by nearley, version 2.20.1
+	// http://github.com/Hardmath123/nearley
+	(function () {
+	function id(x) { return x[0]; }
+	const moo = require$$1;
+	const lexer = moo.compile({
+	  and : 'and',
+	  or : 'or',
+	  not : 'not',
+	  openParen : '(',
+	  closeParen : ')',
+	  newline : { match : '\n', lineBreaks : true },
+	  ws : /[ \t]+/,
+	  tag : /\@[\w\.]+/,
+	});
+	var grammar = {
+	    Lexer: lexer,
+	    ParserRules: [
+	    {"name": "main", "symbols": ["expression", (lexer.has("newline") ? {type: "newline"} : newline)], "postprocess": data => data[0]},
+	    {"name": "expression", "symbols": ["tag"], "postprocess": data => data[0]},
+	    {"name": "expression", "symbols": ["unaryOperation"], "postprocess": data => data[0]},
+	    {"name": "expression", "symbols": ["binaryOperation"], "postprocess": data => data[0]},
+	    {"name": "expression", "symbols": ["parenOperation"], "postprocess": data => data[0]},
+	    {"name": "parenOperation", "symbols": [(lexer.has("openParen") ? {type: "openParen"} : openParen), "_", "expression", "_", (lexer.has("closeParen") ? {type: "closeParen"} : closeParen)], "postprocess": data => data[2]},
+	    {"name": "unaryOperation", "symbols": [(lexer.has("not") ? {type: "not"} : not), (lexer.has("ws") ? {type: "ws"} : ws), "unaryExpression"], "postprocess": data => { return { operator : 'not', expression : data[2] } }},
+	    {"name": "unaryExpression", "symbols": ["tag"], "postprocess": id},
+	    {"name": "unaryExpression", "symbols": ["parenOperation"], "postprocess": id},
+	    {"name": "binaryOperation", "symbols": ["expression", "_", "binaryOperator", "_", "expression"], "postprocess": 
+	        data => { return { operator : data[2], left : data[0], right : data[4] } }
+	        },
+	    {"name": "binaryOperator", "symbols": [(lexer.has("and") ? {type: "and"} : and)], "postprocess": data => data[0].value},
+	    {"name": "binaryOperator", "symbols": [(lexer.has("or") ? {type: "or"} : or)], "postprocess": data => data[0].value},
+	    {"name": "tag", "symbols": [(lexer.has("tag") ? {type: "tag"} : tag)], "postprocess": data => data[0].value.slice(1)},
+	    {"name": "_", "symbols": []},
+	    {"name": "_", "symbols": [(lexer.has("ws") ? {type: "ws"} : ws)]}
+	]
+	  , ParserStart: "main"
+	};
+	{
+	   module.exports = grammar;
+	}
+	})(); 
+} (tagsExpression_umd$1));
+
+var tagsExpression_umdExports = tagsExpression_umd$1.exports;
+var tagsExpression_umd = /*@__PURE__*/getDefaultExportFromCjs(tagsExpression_umdExports);
+
+export { tagsExpression_umd as default };

package/src/tags-expression.ne

@@ -0,0 +1,43 @@
+@{%
+const fp = require('lodash/fp.js');
+const moo = require('moo');
+const lexer = moo.compile({
+  and : 'and',
+  or : 'or',
+  not : 'not',
+  openParen : '(',
+  closeParen : ')',
+  newline : { match : '\n', lineBreaks : true },
+  ws : /[ \t]+/,
+  tag : /\@[\w\.]+/,
+});
+%}
+
+@lexer lexer
+
+main -> expression %newline {% data => data[0] %}
+
+expression -> tag {% data => data[0] %}
+  | unaryOperation {% data => data[0] %}
+  | binaryOperation {% data => data[0] %}
+  | parenOperation {% data => data[0] %}
+
+parenOperation -> %openParen _ expression _ %closeParen {% data => data[2] %}
+
+unaryOperation -> %not %ws unaryExpression {% data => { return { operator : 'not', expression : data[2] } } %}
+
+unaryExpression -> tag {% id %}
+  | parenOperation {% id %}
+
+binaryOperation -> expression _ binaryOperator _ expression {%
+  data => { return { operator : data[2], left : data[0], right : data[4] } }
+%}
+
+binaryOperator -> %and {% data => data[0].value %}
+  | %or {% data => data[0].value %}
+
+tag -> %tag {% data => data[0].value.slice(1) %}
+
+_ -> null
+  | %ws
+