vitest-cucumber-plugin 0.1.4 → 0.1.6

package/CONTRIBUTING.md

@@ -37,10 +37,15 @@ branching model.  The 'main' branch the release branch and is only pushed to dur
 ## Doing a release
 
 1. ```$ VERSION=<version>```
-1. ```$ git flow release start $VERSION```
-1. Update version number in package.json
-1. Add the release notes to [RELEASE_NOTES.md](RELEASE_NOTES.md).
-1. ```git add . ; git commit -m $VERSION```
-1. ```git flow release finish $VERSION```
-1. ```git push origin $VERSION```
-1. npm publish
+1. ```$ git flow release start v$VERSION```
+1. ```$ npm pkg set version=$VERSION```
+1. ```$ sed -i "1s/^/* v$VERSION : \!\!\! ADD RELEASE NOTE HERE \!\!\!\n/" RELEASE_NOTES.md```
+1. ```$ emacs -nw RELEASE_NOTES.md```
+2. ```$ npm test```
+1. ```$ git add . ; git commit -m v$VERSION```
+3. ```$ git flow release finish v$VERSION```
+4. ```$ git push```
+5. ```$ git checkout main```
+6. ```$ git push```
+7. ```$ git push origin v$VERSION```
+8. ```$ npm publish```

package/README.md

@@ -109,5 +109,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
-* Data Table escape characters
-* Boolean expression support for tags

package/RELEASE_NOTES.md

@@ -1,3 +1,5 @@
+* 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
 * v0.1.2 : Set default log level to warn and make it configurable

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.4",
+    "version": "0.1.6",
     "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

@@ -13,7 +13,8 @@ export const generateExample = (config,example) => {
     
     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

@@ -41,7 +41,9 @@ 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 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') {
@@ -36,10 +39,10 @@ const importStepDefinitions = async (config) => {
 
 await importStepDefinitions(${configStr});
 
+// tags : ${JSON.stringify(feature.tags)}
 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/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,52 +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';
-
-var logger = /*#__PURE__*/Object.freeze({
-	__proto__: null,
-	log: log
-});
-
-var require$$2 = /*@__PURE__*/getAugmentedNamespace(logger);
-
 (function (module) {
 	// Generated automatically by nearley, version 2.20.1
 	// http://github.com/Hardmath123/nearley
@@ -54,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 },
@@ -63,10 +22,12 @@ var require$$2 = /*@__PURE__*/getAugmentedNamespace(logger);
 	  colon : ':',
 	  step : '*',
 	  pipe : '|',
-	  backSlash : '\\',
+	  escapedPipe : '\\|',
+	  escapedNewline : '\\n',
+	  escapedBackSlash : '\\\\',
 	  scenarioOutline : ['Scenario Outline','Scenario Template'],
 	  word : {
-	    match : /[^ \t\n:|\\]+/,
+	    match : /[^ \t\n\:\|\@\*]+/,
 	    type : moo.keywords({
 	      feature : 'Feature',
 	      examples : ['Examples','Scenarios'],
@@ -127,7 +88,15 @@ var require$$2 = /*@__PURE__*/getAugmentedNamespace(logger);
 	    {"name": "dataTable", "symbols": ["dataTable", "dataTableRow"], "postprocess": data => fp.concat(data[0],[data[1]])},
 	    {"name": "dataTableRow", "symbols": ["_", (lexer.has("pipe") ? {type: "pipe"} : pipe), "dataTableColumns", (lexer.has("newline") ? {type: "newline"} : newline)], "postprocess": data => data[2]},
 	    {"name": "dataTableColumns", "symbols": [], "postprocess": data => []},
-	    {"name": "dataTableColumns", "symbols": ["dataTableColumns", "text", (lexer.has("pipe") ? {type: "pipe"} : pipe)], "postprocess": data => fp.concat(data[0],data[1].trim())},
+	    {"name": "dataTableColumns", "symbols": ["dataTableColumns", "dataTableColumnText", (lexer.has("pipe") ? {type: "pipe"} : pipe)], "postprocess": data => fp.concat(data[0],data[1].trim())},
+	    {"name": "dataTableColumnText", "symbols": [], "postprocess": data => ''},
+	    {"name": "dataTableColumnText", "symbols": ["dataTableColumnText", "escapedColumnCharaters"], "postprocess": data => data[0]+data[1]},
+	    {"name": "dataTableColumnText", "symbols": ["dataTableColumnText", "keywords"], "postprocess": data => data[0]+data[1]},
+	    {"name": "dataTableColumnText", "symbols": ["dataTableColumnText", (lexer.has("word") ? {type: "word"} : word)], "postprocess": data => data[0]+data[1].value},
+	    {"name": "dataTableColumnText", "symbols": ["dataTableColumnText", (lexer.has("ws") ? {type: "ws"} : ws)], "postprocess": data => data[0]+data[1].value},
+	    {"name": "escapedColumnCharaters", "symbols": [(lexer.has("escapedPipe") ? {type: "escapedPipe"} : escapedPipe)], "postprocess": data => '|'},
+	    {"name": "escapedColumnCharaters", "symbols": [(lexer.has("escapedBackSlash") ? {type: "escapedBackSlash"} : escapedBackSlash)], "postprocess": data => '\\'},
+	    {"name": "escapedColumnCharaters", "symbols": [(lexer.has("escapedNewline") ? {type: "escapedNewline"} : escapedNewline)], "postprocess": data => '\n'},
 	    {"name": "steps", "symbols": ["stepAndTable", "moreSteps"], "postprocess": data => fp.concat(data[0],data[1])},
 	    {"name": "moreSteps", "symbols": [], "postprocess": data => []},
 	    {"name": "moreSteps", "symbols": ["moreSteps", "stepAndTable"], "postprocess": data => fp.concat(data[0],data[1])},
@@ -138,12 +107,17 @@ var require$$2 = /*@__PURE__*/getAugmentedNamespace(logger);
 	    {"name": "text", "symbols": [], "postprocess": data => ''},
 	    {"name": "text", "symbols": ["text", (lexer.has("word") ? {type: "word"} : word)], "postprocess": data => data[0]+data[1].value},
 	    {"name": "text", "symbols": ["text", (lexer.has("ws") ? {type: "ws"} : ws)], "postprocess": data => data[0]+data[1].value},
-	    {"name": "text", "symbols": ["text", (lexer.has("step") ? {type: "step"} : step)], "postprocess": data => data[0]+data[1].value},
-	    {"name": "text", "symbols": ["text", (lexer.has("colon") ? {type: "colon"} : colon)], "postprocess": data => data[0]+data[1].value},
-	    {"name": "text", "symbols": ["text", (lexer.has("example") ? {type: "example"} : example)], "postprocess": data => data[0]+data[1].value},
-	    {"name": "text", "symbols": ["text", (lexer.has("examples") ? {type: "examples"} : examples)], "postprocess": data => data[0]+data[1].value},
-	    {"name": "text", "symbols": ["text", (lexer.has("scenarioOutline") ? {type: "scenarioOutline"} : scenarioOutline)], "postprocess": data => data[0]+data[1].value},
-	    {"name": "text", "symbols": ["text", (lexer.has("background") ? {type: "background"} : background)], "postprocess": data => data[0]+data[1].value},
+	    {"name": "text", "symbols": ["text", "keywords"], "postprocess": data => data[0]+data[1]},
+	    {"name": "text", "symbols": ["text", (lexer.has("pipe") ? {type: "pipe"} : pipe)], "postprocess": data => data[0]+data[1].value},
+	    {"name": "text", "symbols": ["text", (lexer.has("escapedPipe") ? {type: "escapedPipe"} : escapedPipe)], "postprocess": data => data[0]+data[1].value},
+	    {"name": "text", "symbols": ["text", (lexer.has("escapedNewline") ? {type: "escapedNewline"} : escapedNewline)], "postprocess": data => data[0]+data[1].value},
+	    {"name": "text", "symbols": ["text", (lexer.has("escapedBackSlash") ? {type: "escapedBackSlash"} : escapedBackSlash)], "postprocess": data => data[0]+data[1].value},
+	    {"name": "keywords", "symbols": [(lexer.has("step") ? {type: "step"} : step)], "postprocess": data => data[0].value},
+	    {"name": "keywords", "symbols": [(lexer.has("colon") ? {type: "colon"} : colon)], "postprocess": data => data[0].value},
+	    {"name": "keywords", "symbols": [(lexer.has("example") ? {type: "example"} : example)], "postprocess": data => data[0].value},
+	    {"name": "keywords", "symbols": [(lexer.has("examples") ? {type: "examples"} : examples)], "postprocess": data => data[0].value},
+	    {"name": "keywords", "symbols": [(lexer.has("scenarioOutline") ? {type: "scenarioOutline"} : scenarioOutline)], "postprocess": data => data[0].value},
+	    {"name": "keywords", "symbols": [(lexer.has("background") ? {type: "background"} : background)], "postprocess": data => data[0].value},
 	    {"name": "bolText", "symbols": [(lexer.has("ws") ? {type: "ws"} : ws), (lexer.has("word") ? {type: "word"} : word)], "postprocess": data => data[1].value},
 	    {"name": "bolText", "symbols": [(lexer.has("word") ? {type: "word"} : word)], "postprocess": data => data[0].value},
 	    {"name": "freeform", "symbols": [], "postprocess": data => ''},

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 },
@@ -10,10 +9,12 @@ const lexer = moo.compile({
   colon : ':',
   step : '*',
   pipe : '|',
-  backSlash : '\\',
+  escapedPipe : '\\|',
+  escapedNewline : '\\n',
+  escapedBackSlash : '\\\\',
   scenarioOutline : ['Scenario Outline','Scenario Template'],
   word : {
-    match : /[^ \t\n:|\\]+/,
+    match : /[^ \t\n\:\|\@\*]+/,
     type : moo.keywords({
       feature : 'Feature',
       examples : ['Examples','Scenarios'],
@@ -90,7 +91,17 @@ dataTable -> null {% data => [] %}
 dataTableRow -> _ %pipe dataTableColumns %newline {% data => data[2] %}
 
 dataTableColumns -> null {% data => [] %}
-  | dataTableColumns text %pipe {% data => fp.concat(data[0],data[1].trim()) %}
+  | dataTableColumns dataTableColumnText %pipe {% data => fp.concat(data[0],data[1].trim()) %}
+
+dataTableColumnText -> null {% data => '' %}
+  | dataTableColumnText escapedColumnCharaters {% data => data[0]+data[1] %}
+  | dataTableColumnText keywords {% data => data[0]+data[1] %}
+  | dataTableColumnText %word {% data => data[0]+data[1].value %}
+  | dataTableColumnText %ws {% data => data[0]+data[1].value %}
+
+escapedColumnCharaters -> %escapedPipe {% data => '|' %}
+  | %escapedBackSlash {% data => '\\' %}
+  | %escapedNewline {% data => '\n' %}
 
 steps -> stepAndTable moreSteps {% data => fp.concat(data[0],data[1]) %}
 
@@ -106,12 +117,18 @@ stepKeyword -> %step {% (data) => { return { type : 'step', name : data[0].value
 text -> null {% data => '' %}
   | text %word {% data => data[0]+data[1].value %}
   | text %ws {% data => data[0]+data[1].value %}
-  | text %step {% data => data[0]+data[1].value %}
-  | text %colon {% data => data[0]+data[1].value %}
-  | text %example {% data => data[0]+data[1].value %}
-  | text %examples {% data => data[0]+data[1].value %}
-  | text %scenarioOutline {% data => data[0]+data[1].value %}
-  | text %background {% data => data[0]+data[1].value %}
+  | text keywords {% data => data[0]+data[1] %}
+  | text %pipe {% data => data[0]+data[1].value %}
+  | text %escapedPipe {% data => data[0]+data[1].value %}
+  | text %escapedNewline {% data => data[0]+data[1].value %}
+  | text %escapedBackSlash {% data => data[0]+data[1].value %}
+
+keywords -> %step {% data => data[0].value %}
+  | %colon {% data => data[0].value %}
+  | %example {% data => data[0].value %}
+  | %examples {% data => data[0].value %}
+  | %scenarioOutline {% data => data[0].value %}
+  | %background {% data => data[0].value %}
 
 bolText -> %ws %word {% data => data[1].value %}
   | %word {% data => data[0].value %}

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 },
@@ -14,10 +13,12 @@ const lexer = moo.compile({
   colon : ':',
   step : '*',
   pipe : '|',
-  backSlash : '\\',
+  escapedPipe : '\\|',
+  escapedNewline : '\\n',
+  escapedBackSlash : '\\\\',
   scenarioOutline : ['Scenario Outline','Scenario Template'],
   word : {
-    match : /[^ \t\n:|\\]+/,
+    match : /[^ \t\n\:\|\@\*]+/,
     type : moo.keywords({
       feature : 'Feature',
       examples : ['Examples','Scenarios'],
@@ -78,7 +79,15 @@ var grammar = {
     {"name": "dataTable", "symbols": ["dataTable", "dataTableRow"], "postprocess": data => fp.concat(data[0],[data[1]])},
     {"name": "dataTableRow", "symbols": ["_", (lexer.has("pipe") ? {type: "pipe"} : pipe), "dataTableColumns", (lexer.has("newline") ? {type: "newline"} : newline)], "postprocess": data => data[2]},
     {"name": "dataTableColumns", "symbols": [], "postprocess": data => []},
-    {"name": "dataTableColumns", "symbols": ["dataTableColumns", "text", (lexer.has("pipe") ? {type: "pipe"} : pipe)], "postprocess": data => fp.concat(data[0],data[1].trim())},
+    {"name": "dataTableColumns", "symbols": ["dataTableColumns", "dataTableColumnText", (lexer.has("pipe") ? {type: "pipe"} : pipe)], "postprocess": data => fp.concat(data[0],data[1].trim())},
+    {"name": "dataTableColumnText", "symbols": [], "postprocess": data => ''},
+    {"name": "dataTableColumnText", "symbols": ["dataTableColumnText", "escapedColumnCharaters"], "postprocess": data => data[0]+data[1]},
+    {"name": "dataTableColumnText", "symbols": ["dataTableColumnText", "keywords"], "postprocess": data => data[0]+data[1]},
+    {"name": "dataTableColumnText", "symbols": ["dataTableColumnText", (lexer.has("word") ? {type: "word"} : word)], "postprocess": data => data[0]+data[1].value},
+    {"name": "dataTableColumnText", "symbols": ["dataTableColumnText", (lexer.has("ws") ? {type: "ws"} : ws)], "postprocess": data => data[0]+data[1].value},
+    {"name": "escapedColumnCharaters", "symbols": [(lexer.has("escapedPipe") ? {type: "escapedPipe"} : escapedPipe)], "postprocess": data => '|'},
+    {"name": "escapedColumnCharaters", "symbols": [(lexer.has("escapedBackSlash") ? {type: "escapedBackSlash"} : escapedBackSlash)], "postprocess": data => '\\'},
+    {"name": "escapedColumnCharaters", "symbols": [(lexer.has("escapedNewline") ? {type: "escapedNewline"} : escapedNewline)], "postprocess": data => '\n'},
     {"name": "steps", "symbols": ["stepAndTable", "moreSteps"], "postprocess": data => fp.concat(data[0],data[1])},
     {"name": "moreSteps", "symbols": [], "postprocess": data => []},
     {"name": "moreSteps", "symbols": ["moreSteps", "stepAndTable"], "postprocess": data => fp.concat(data[0],data[1])},
@@ -89,12 +98,17 @@ var grammar = {
     {"name": "text", "symbols": [], "postprocess": data => ''},
     {"name": "text", "symbols": ["text", (lexer.has("word") ? {type: "word"} : word)], "postprocess": data => data[0]+data[1].value},
     {"name": "text", "symbols": ["text", (lexer.has("ws") ? {type: "ws"} : ws)], "postprocess": data => data[0]+data[1].value},
-    {"name": "text", "symbols": ["text", (lexer.has("step") ? {type: "step"} : step)], "postprocess": data => data[0]+data[1].value},
-    {"name": "text", "symbols": ["text", (lexer.has("colon") ? {type: "colon"} : colon)], "postprocess": data => data[0]+data[1].value},
-    {"name": "text", "symbols": ["text", (lexer.has("example") ? {type: "example"} : example)], "postprocess": data => data[0]+data[1].value},
-    {"name": "text", "symbols": ["text", (lexer.has("examples") ? {type: "examples"} : examples)], "postprocess": data => data[0]+data[1].value},
-    {"name": "text", "symbols": ["text", (lexer.has("scenarioOutline") ? {type: "scenarioOutline"} : scenarioOutline)], "postprocess": data => data[0]+data[1].value},
-    {"name": "text", "symbols": ["text", (lexer.has("background") ? {type: "background"} : background)], "postprocess": data => data[0]+data[1].value},
+    {"name": "text", "symbols": ["text", "keywords"], "postprocess": data => data[0]+data[1]},
+    {"name": "text", "symbols": ["text", (lexer.has("pipe") ? {type: "pipe"} : pipe)], "postprocess": data => data[0]+data[1].value},
+    {"name": "text", "symbols": ["text", (lexer.has("escapedPipe") ? {type: "escapedPipe"} : escapedPipe)], "postprocess": data => data[0]+data[1].value},
+    {"name": "text", "symbols": ["text", (lexer.has("escapedNewline") ? {type: "escapedNewline"} : escapedNewline)], "postprocess": data => data[0]+data[1].value},
+    {"name": "text", "symbols": ["text", (lexer.has("escapedBackSlash") ? {type: "escapedBackSlash"} : escapedBackSlash)], "postprocess": data => data[0]+data[1].value},
+    {"name": "keywords", "symbols": [(lexer.has("step") ? {type: "step"} : step)], "postprocess": data => data[0].value},
+    {"name": "keywords", "symbols": [(lexer.has("colon") ? {type: "colon"} : colon)], "postprocess": data => data[0].value},
+    {"name": "keywords", "symbols": [(lexer.has("example") ? {type: "example"} : example)], "postprocess": data => data[0].value},
+    {"name": "keywords", "symbols": [(lexer.has("examples") ? {type: "examples"} : examples)], "postprocess": data => data[0].value},
+    {"name": "keywords", "symbols": [(lexer.has("scenarioOutline") ? {type: "scenarioOutline"} : scenarioOutline)], "postprocess": data => data[0].value},
+    {"name": "keywords", "symbols": [(lexer.has("background") ? {type: "background"} : background)], "postprocess": data => data[0].value},
     {"name": "bolText", "symbols": [(lexer.has("ws") ? {type: "ws"} : ws), (lexer.has("word") ? {type: "word"} : word)], "postprocess": data => data[1].value},
     {"name": "bolText", "symbols": [(lexer.has("word") ? {type: "word"} : word)], "postprocess": data => data[0].value},
     {"name": "freeform", "symbols": [], "postprocess": data => ''},

package/src/index.js

@@ -4,6 +4,7 @@ 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';
 
 const featureRegex = /\.feature$/;
 
@@ -12,8 +13,6 @@ const compileFeatureToJS = (config,featureSrc) => {
 
     const code = generateFeature(config,feature);
 
-    log.debug(code);
-
     return code;
 }
 
@@ -47,15 +46,20 @@ export default function vitestCucumberPlugin() {
             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 = _.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
+