vitest-cucumber-plugin 0.1.7 → 0.5.0

package/README.md

@@ -106,10 +106,3 @@ Then('I should be told {string}', function (state,[ answer ], dataTable) {
 
 Currently, all step definition files must be in ECMAScript module format.  CommonJS files might
 work, but this configuration isn't tested.
-
-
-### Not yet implemented
-
-This plugin is not yet feature complete.  Here is the list of features from Cucumber which aren't yet implemented:
-* Rule keyword
-* Doc strings

package/RELEASE_NOTES.md

@@ -1,3 +1,5 @@
+* v0.5.0 : Implemented Doc Strings.  Plugin is now feature complete.
+* v0.1.8 : Implemented Rule keyword
 * v0.1.7 : Implemented Hooks API
 * v0.1.6 : Implemented tags boolean expression support
 * v0.1.5 : Implemented escape characters for Data Tables

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "vitest-cucumber-plugin",
-    "version": "0.1.7",
+    "version": "0.5.0",
     "description": "Plugin for Vitest which allows for tests to be written in Cucumber format.",
     "keywords": [
         "vite",

package/src/generate/feature.js

@@ -1,6 +1,6 @@
 import _ from 'lodash/fp.js';
 import { log } from '../logger.js';
-import { generateExample, generateScenarioOutline } from './index.js';
+import { generateExample, generateScenarioOutline, generateRule } from './index.js';
 import { escape, shouldSkip } from './util.js';
 
 export const generateFeature = (config,feature) => {
@@ -18,6 +18,8 @@ export const generateFeature = (config,feature) => {
             return testStatements + generateExample(config,statement);
         } else if (statement.type.type === 'scenarioOutline') {
             return testStatements + generateScenarioOutline(config,statement);
+        } else if (statement.type.type === 'rule') {
+            return testStatements + generateRule(config,statement);
         }
     },'')(statements);
 

package/src/generate/index.js

@@ -3,11 +3,13 @@ import { generateExample } from './example.js';
 import { generateExamples } from './examples.js';
 import { generateScenarioOutline } from './scenario-outline.js';
 import { generateFeature } from './feature.js';
+import { generateRule } from './rule.js';
 
 export {
     generateTests,
     generateExample,
     generateExamples,
     generateScenarioOutline,
-    generateFeature
+    generateFeature,
+    generateRule,
 };

package/src/generate/rule.js

@@ -0,0 +1,22 @@
+import _ from 'lodash/fp.js';
+import { generateExample } from './index.js';
+import { escape, shouldSkip } from './util.js';
+import { log } from '../logger.js';
+
+export const generateRule = (config,rule) => {
+    log.debug('generateRule config: '+JSON.stringify(config)+' rule: '+JSON.stringify(rule));
+    
+    const examplesCode = _.reduce((examplesCode,example) => {
+        return examplesCode + generateExample(config,example);
+    },'')(rule.examples);
+
+    const skip = shouldSkip(config,rule.tags) ? '.skip' : '';
+    const tagsStr = JSON.stringify(rule.tags);
+
+    const code = `  // tags : ${tagsStr}
+  describe${skip}('${escape(rule.type.name)}: ${escape(rule.name)}', () => {
+${examplesCode}});
+`;
+
+    return code;
+}

package/src/gherkin.js

@@ -26,6 +26,7 @@ var gherkin_umd$1 = {exports: {}};
 	  escapedNewline : '\\n',
 	  escapedBackSlash : '\\\\',
 	  scenarioOutline : ['Scenario Outline','Scenario Template'],
+	  docString : ['```','"""'],
 	  word : {
 	    match : /[^ \t\n\:\|\@\*]+/,
 	    type : moo.keywords({
@@ -34,9 +35,17 @@ var gherkin_umd$1 = {exports: {}};
 	      step : ['Given','When','Then','And','But'],
 	      example : ['Example','Scenario'],
 	      background : 'Background',
+	      rule : 'Rule',
 	    }),
 	  },
 	});
+
+	const trimWhitespace = (cols,str) => {
+	  const lines = str.split('\n').slice(0,-1);
+	  return fp.reduce((s,line) => {
+	    return s+line.slice(cols)+'\n'
+	},'')(lines);
+	};
 	var grammar = {
 	    Lexer: lexer,
 	    ParserRules: [
@@ -61,6 +70,7 @@ var gherkin_umd$1 = {exports: {}};
 	        },
 	    {"name": "statement", "symbols": ["example"], "postprocess": data => data[0]},
 	    {"name": "statement", "symbols": ["scenarioOutline"], "postprocess": data => data[0]},
+	    {"name": "statement", "symbols": ["rule"], "postprocess": data => data[0]},
 	    {"name": "statements", "symbols": [], "postprocess": data => []},
 	    {"name": "statements", "symbols": ["statements", "statement"], "postprocess": data => fp.concat(data[0],data[1])},
 	    {"name": "example", "symbols": ["tags", "exampleStatement", "steps"], "postprocess": (data) => fp.assign(data[1],{ tags : data[0], steps : data[2] })},
@@ -68,6 +78,8 @@ var gherkin_umd$1 = {exports: {}};
 	        (data) => { return { type : { type : 'example', name : data[1] }, name : data[4].trim() } }
 	        },
 	    {"name": "exampleKeyword", "symbols": [(lexer.has("example") ? {type: "example"} : example)], "postprocess": data => data[0].value},
+	    {"name": "exampleList", "symbols": [], "postprocess": data => []},
+	    {"name": "exampleList", "symbols": ["exampleList", "example"], "postprocess": data => fp.concat(data[0],data[1])},
 	    {"name": "scenarioOutline", "symbols": ["tags", "scenarioOutlineStatement", "steps", "examplesList"], "postprocess": 
 	        data => fp.assign(data[1],{ tags : data[0], steps : data[2], examples : data[3] })
 	        },
@@ -75,6 +87,13 @@ var gherkin_umd$1 = {exports: {}};
 	        (data) => { return { type : { type : 'scenarioOutline', name : data[1] }, name : data[4].trim() } }
 	        },
 	    {"name": "scenarioOutlineKeyword", "symbols": [(lexer.has("scenarioOutline") ? {type: "scenarioOutline"} : scenarioOutline)], "postprocess": data => data[0].value},
+	    {"name": "rule", "symbols": ["tags", "ruleStatement", "example", "exampleList"], "postprocess": 
+	        data => fp.assign(data[1],{ tags : data[0], examples : fp.concat(data[2],data[3]) })
+	        },
+	    {"name": "ruleStatement", "symbols": ["_", "ruleKeyword", "_", (lexer.has("colon") ? {type: "colon"} : colon), "text", (lexer.has("newline") ? {type: "newline"} : newline)], "postprocess": 
+	        (data) => { return { type : { type : 'rule', name : data[1] }, name : data[4].trim() } }
+	        },
+	    {"name": "ruleKeyword", "symbols": [(lexer.has("rule") ? {type: "rule"} : rule)], "postprocess": data => data[0].value},
 	    {"name": "examplesList", "symbols": [], "postprocess": data => []},
 	    {"name": "examplesList", "symbols": ["examplesList", "examples"], "postprocess": data => fp.concat(data[0],data[1])},
 	    {"name": "examples", "symbols": ["tags", "examplesStatement", "dataTable", "emptyLines"], "postprocess": 
@@ -84,7 +103,7 @@ var gherkin_umd$1 = {exports: {}};
 	        (data) => { return { type : { type : 'examples', name : data[1] }, name : data[4] } }
 	        },
 	    {"name": "examplesKeyword", "symbols": [(lexer.has("examples") ? {type: "examples"} : examples)], "postprocess": data => data[0].value},
-	    {"name": "dataTable", "symbols": [], "postprocess": data => []},
+	    {"name": "dataTable", "symbols": ["dataTableRow"], "postprocess": data => [data[0]]},
 	    {"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 => []},
@@ -97,12 +116,14 @@ var gherkin_umd$1 = {exports: {}};
 	    {"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": "steps", "symbols": ["step", "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])},
+	    {"name": "moreSteps", "symbols": ["moreSteps", "step"], "postprocess": data => fp.concat(data[0],data[1])},
 	    {"name": "moreSteps", "symbols": ["moreSteps", (lexer.has("emptyLine") ? {type: "emptyLine"} : emptyLine)], "postprocess": data => data[0]},
-	    {"name": "step", "symbols": ["_", "stepKeyword", "text", (lexer.has("newline") ? {type: "newline"} : newline)], "postprocess": data => { return { type : data[1], text : data[2].trim() } }},
-	    {"name": "stepAndTable", "symbols": ["step", "dataTable"], "postprocess": data => fp.set('dataTable',data[1],data[0])},
+	    {"name": "step", "symbols": ["stepStatement"]},
+	    {"name": "step", "symbols": ["stepStatement", "dataTable"], "postprocess": data => fp.set('dataTable',data[1],data[0])},
+	    {"name": "step", "symbols": ["stepStatement", "docString"], "postprocess": data => fp.set('docString',data[1],data[0])},
+	    {"name": "stepStatement", "symbols": ["_", "stepKeyword", "text", (lexer.has("newline") ? {type: "newline"} : newline)], "postprocess": data => { return { type : data[1], text : data[2].trim() } }},
 	    {"name": "stepKeyword", "symbols": [(lexer.has("step") ? {type: "step"} : step)], "postprocess": (data) => { return { type : 'step', name : data[0].value } }},
 	    {"name": "text", "symbols": [], "postprocess": data => ''},
 	    {"name": "text", "symbols": ["text", (lexer.has("word") ? {type: "word"} : word)], "postprocess": data => data[0]+data[1].value},
@@ -126,6 +147,18 @@ var gherkin_umd$1 = {exports: {}};
 	        }
 	        },
 	    {"name": "freeform", "symbols": ["freeform", (lexer.has("emptyLine") ? {type: "emptyLine"} : emptyLine)], "postprocess": data => data[0]+'\n'},
+	    {"name": "docString", "symbols": ["docStringStatement", "docText", "docStringStatement"], "postprocess": 
+	        data => fp.set('text',trimWhitespace(data[0].ws.length,data[1]),data[0])
+	        },
+	    {"name": "docStringStatement", "symbols": ["_", (lexer.has("docString") ? {type: "docString"} : docString), "contentType", (lexer.has("newline") ? {type: "newline"} : newline)], "postprocess": 
+	        (data) => { return { type : { type : 'docString', name : data[1].value }, ws : data[0], contentType : data[2] } }
+	        },
+	    {"name": "contentType", "symbols": [], "postprocess": data => null},
+	    {"name": "contentType", "symbols": [(lexer.has("ws") ? {type: "ws"} : ws)], "postprocess": data => null},
+	    {"name": "contentType", "symbols": [(lexer.has("word") ? {type: "word"} : word)], "postprocess": data => data[0].value},
+	    {"name": "docText", "symbols": [], "postprocess": data => ''},
+	    {"name": "docText", "symbols": ["docText", "text", (lexer.has("newline") ? {type: "newline"} : newline)], "postprocess": data => data[0]+data[1]+data[2].value},
+	    {"name": "docText", "symbols": ["docText", (lexer.has("emptyLine") ? {type: "emptyLine"} : emptyLine)], "postprocess": data => data[0]+data[1].value},
 	    {"name": "_", "symbols": [], "postprocess": data => ''},
 	    {"name": "_", "symbols": [(lexer.has("ws") ? {type: "ws"} : ws)], "postprocess": data => data[0].value},
 	    {"name": "emptyLines", "symbols": [], "postprocess": data => ''},

package/src/gherkin.ne

@@ -13,6 +13,7 @@ const lexer = moo.compile({
   escapedNewline : '\\n',
   escapedBackSlash : '\\\\',
   scenarioOutline : ['Scenario Outline','Scenario Template'],
+  docString : ['```','"""'],
   word : {
     match : /[^ \t\n\:\|\@\*]+/,
     type : moo.keywords({
@@ -21,9 +22,17 @@ const lexer = moo.compile({
       step : ['Given','When','Then','And','But'],
       example : ['Example','Scenario'],
       background : 'Background',
+      rule : 'Rule',
     }),
   },
 });
+
+const trimWhitespace = (cols,str) => {
+  const lines = str.split('\n').slice(0,-1);
+  return fp.reduce((s,line) => {
+    return s+line.slice(cols)+'\n'
+},'')(lines);
+};
 %}
 
 @lexer lexer
@@ -56,6 +65,7 @@ backgroundStatement -> _ %background _ %colon text %newline {%
 
 statement -> example {% data => data[0] %}
   | scenarioOutline {% data => data[0] %}
+  | rule {% data => data[0] %}
 
 statements -> null {% data => [] %}
   | statements statement {% data => fp.concat(data[0],data[1]) %}
@@ -66,6 +76,9 @@ exampleStatement -> _ exampleKeyword _ %colon text %newline {%
 %}
 exampleKeyword -> %example {% data => data[0].value %}
 
+exampleList -> null {% data => [] %}
+  | exampleList example {% data => fp.concat(data[0],data[1]) %}
+
 scenarioOutline -> tags scenarioOutlineStatement steps examplesList {%
   data => fp.assign(data[1],{ tags : data[0], steps : data[2], examples : data[3] })
 %}
@@ -74,6 +87,14 @@ scenarioOutlineStatement -> _ scenarioOutlineKeyword _ %colon text %newline {%
 %}
 scenarioOutlineKeyword -> %scenarioOutline {% data => data[0].value %}
 
+rule -> tags ruleStatement example exampleList {%
+  data => fp.assign(data[1],{ tags : data[0], examples : fp.concat(data[2],data[3]) })
+%}
+ruleStatement -> _ ruleKeyword  _ %colon text %newline {%
+  (data) => { return { type : { type : 'rule', name : data[1] }, name : data[4].trim() } }
+%}
+ruleKeyword -> %rule {% data => data[0].value %}
+
 examplesList -> null {% data => [] %}
   | examplesList examples {% data => fp.concat(data[0],data[1]) %}
 
@@ -85,7 +106,7 @@ examplesStatement -> _ examplesKeyword _ %colon text %newline {%
 %}
 examplesKeyword -> %examples {% data => data[0].value %}
 
-dataTable -> null {% data => [] %}
+dataTable -> dataTableRow {% data => [data[0]] %}
   | dataTable dataTableRow {% data => fp.concat(data[0],[data[1]]) %}
 
 dataTableRow -> _ %pipe dataTableColumns %newline {% data => data[2] %}
@@ -103,14 +124,17 @@ escapedColumnCharaters -> %escapedPipe {% data => '|' %}
   | %escapedBackSlash {% data => '\\' %}
   | %escapedNewline {% data => '\n' %}
 
-steps -> stepAndTable moreSteps {% data => fp.concat(data[0],data[1]) %}
+steps -> step moreSteps {% data => fp.concat(data[0],data[1]) %}
 
 moreSteps -> null {% data => [] %}
-  | moreSteps stepAndTable {% data => fp.concat(data[0],data[1]) %}
+  | moreSteps step {% data => fp.concat(data[0],data[1]) %}
   | moreSteps %emptyLine {% data => data[0] %}
 
-step -> _ stepKeyword text %newline {% data => { return { type : data[1], text : data[2].trim() } } %}
-stepAndTable -> step dataTable {% data => fp.set('dataTable',data[1],data[0]) %}
+step -> stepStatement
+  | stepStatement dataTable {% data => fp.set('dataTable',data[1],data[0]) %}
+  | stepStatement docString {% data => fp.set('docString',data[1],data[0]) %}
+
+stepStatement -> _ stepKeyword text %newline {% data => { return { type : data[1], text : data[2].trim() } } %}
 
 stepKeyword -> %step {% (data) => { return { type : 'step', name : data[0].value } } %}
 
@@ -140,6 +164,21 @@ freeform -> null {% data => '' %}
 %}
   | freeform %emptyLine {% data => data[0]+'\n' %}
 
+docString -> docStringStatement docText docStringStatement {%
+  data => fp.set('text',trimWhitespace(data[0].ws.length,data[1]),data[0])
+%}
+docStringStatement -> _ %docString contentType %newline {%
+  (data) => { return { type : { type : 'docString', name : data[1].value }, ws : data[0], contentType : data[2] } }
+%}
+
+contentType -> null {% data => null %}
+  | %ws {% data => null %}
+  | %word {% data => data[0].value %}
+
+docText -> null {% data => '' %}
+  | docText text %newline {% data => data[0]+data[1]+data[2].value %}
+  | docText %emptyLine {% data => data[0]+data[1].value %}
+
 _ -> null {% data => '' %}
   | %ws {% data => data[0].value %}
 

package/src/gherkin.umd.js

@@ -17,6 +17,7 @@ const lexer = moo.compile({
   escapedNewline : '\\n',
   escapedBackSlash : '\\\\',
   scenarioOutline : ['Scenario Outline','Scenario Template'],
+  docString : ['```','"""'],
   word : {
     match : /[^ \t\n\:\|\@\*]+/,
     type : moo.keywords({
@@ -25,9 +26,17 @@ const lexer = moo.compile({
       step : ['Given','When','Then','And','But'],
       example : ['Example','Scenario'],
       background : 'Background',
+      rule : 'Rule',
     }),
   },
 });
+
+const trimWhitespace = (cols,str) => {
+  const lines = str.split('\n').slice(0,-1);
+  return fp.reduce((s,line) => {
+    return s+line.slice(cols)+'\n'
+},'')(lines);
+};
 var grammar = {
     Lexer: lexer,
     ParserRules: [
@@ -52,6 +61,7 @@ var grammar = {
         },
     {"name": "statement", "symbols": ["example"], "postprocess": data => data[0]},
     {"name": "statement", "symbols": ["scenarioOutline"], "postprocess": data => data[0]},
+    {"name": "statement", "symbols": ["rule"], "postprocess": data => data[0]},
     {"name": "statements", "symbols": [], "postprocess": data => []},
     {"name": "statements", "symbols": ["statements", "statement"], "postprocess": data => fp.concat(data[0],data[1])},
     {"name": "example", "symbols": ["tags", "exampleStatement", "steps"], "postprocess": (data) => fp.assign(data[1],{ tags : data[0], steps : data[2] })},
@@ -59,6 +69,8 @@ var grammar = {
         (data) => { return { type : { type : 'example', name : data[1] }, name : data[4].trim() } }
         },
     {"name": "exampleKeyword", "symbols": [(lexer.has("example") ? {type: "example"} : example)], "postprocess": data => data[0].value},
+    {"name": "exampleList", "symbols": [], "postprocess": data => []},
+    {"name": "exampleList", "symbols": ["exampleList", "example"], "postprocess": data => fp.concat(data[0],data[1])},
     {"name": "scenarioOutline", "symbols": ["tags", "scenarioOutlineStatement", "steps", "examplesList"], "postprocess": 
         data => fp.assign(data[1],{ tags : data[0], steps : data[2], examples : data[3] })
         },
@@ -66,6 +78,13 @@ var grammar = {
         (data) => { return { type : { type : 'scenarioOutline', name : data[1] }, name : data[4].trim() } }
         },
     {"name": "scenarioOutlineKeyword", "symbols": [(lexer.has("scenarioOutline") ? {type: "scenarioOutline"} : scenarioOutline)], "postprocess": data => data[0].value},
+    {"name": "rule", "symbols": ["tags", "ruleStatement", "example", "exampleList"], "postprocess": 
+        data => fp.assign(data[1],{ tags : data[0], examples : fp.concat(data[2],data[3]) })
+        },
+    {"name": "ruleStatement", "symbols": ["_", "ruleKeyword", "_", (lexer.has("colon") ? {type: "colon"} : colon), "text", (lexer.has("newline") ? {type: "newline"} : newline)], "postprocess": 
+        (data) => { return { type : { type : 'rule', name : data[1] }, name : data[4].trim() } }
+        },
+    {"name": "ruleKeyword", "symbols": [(lexer.has("rule") ? {type: "rule"} : rule)], "postprocess": data => data[0].value},
     {"name": "examplesList", "symbols": [], "postprocess": data => []},
     {"name": "examplesList", "symbols": ["examplesList", "examples"], "postprocess": data => fp.concat(data[0],data[1])},
     {"name": "examples", "symbols": ["tags", "examplesStatement", "dataTable", "emptyLines"], "postprocess": 
@@ -75,7 +94,7 @@ var grammar = {
         (data) => { return { type : { type : 'examples', name : data[1] }, name : data[4] } }
         },
     {"name": "examplesKeyword", "symbols": [(lexer.has("examples") ? {type: "examples"} : examples)], "postprocess": data => data[0].value},
-    {"name": "dataTable", "symbols": [], "postprocess": data => []},
+    {"name": "dataTable", "symbols": ["dataTableRow"], "postprocess": data => [data[0]]},
     {"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 => []},
@@ -88,12 +107,14 @@ var grammar = {
     {"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": "steps", "symbols": ["step", "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])},
+    {"name": "moreSteps", "symbols": ["moreSteps", "step"], "postprocess": data => fp.concat(data[0],data[1])},
     {"name": "moreSteps", "symbols": ["moreSteps", (lexer.has("emptyLine") ? {type: "emptyLine"} : emptyLine)], "postprocess": data => data[0]},
-    {"name": "step", "symbols": ["_", "stepKeyword", "text", (lexer.has("newline") ? {type: "newline"} : newline)], "postprocess": data => { return { type : data[1], text : data[2].trim() } }},
-    {"name": "stepAndTable", "symbols": ["step", "dataTable"], "postprocess": data => fp.set('dataTable',data[1],data[0])},
+    {"name": "step", "symbols": ["stepStatement"]},
+    {"name": "step", "symbols": ["stepStatement", "dataTable"], "postprocess": data => fp.set('dataTable',data[1],data[0])},
+    {"name": "step", "symbols": ["stepStatement", "docString"], "postprocess": data => fp.set('docString',data[1],data[0])},
+    {"name": "stepStatement", "symbols": ["_", "stepKeyword", "text", (lexer.has("newline") ? {type: "newline"} : newline)], "postprocess": data => { return { type : data[1], text : data[2].trim() } }},
     {"name": "stepKeyword", "symbols": [(lexer.has("step") ? {type: "step"} : step)], "postprocess": (data) => { return { type : 'step', name : data[0].value } }},
     {"name": "text", "symbols": [], "postprocess": data => ''},
     {"name": "text", "symbols": ["text", (lexer.has("word") ? {type: "word"} : word)], "postprocess": data => data[0]+data[1].value},
@@ -117,6 +138,18 @@ var grammar = {
         }
         },
     {"name": "freeform", "symbols": ["freeform", (lexer.has("emptyLine") ? {type: "emptyLine"} : emptyLine)], "postprocess": data => data[0]+'\n'},
+    {"name": "docString", "symbols": ["docStringStatement", "docText", "docStringStatement"], "postprocess": 
+        data => fp.set('text',trimWhitespace(data[0].ws.length,data[1]),data[0])
+        },
+    {"name": "docStringStatement", "symbols": ["_", (lexer.has("docString") ? {type: "docString"} : docString), "contentType", (lexer.has("newline") ? {type: "newline"} : newline)], "postprocess": 
+        (data) => { return { type : { type : 'docString', name : data[1].value }, ws : data[0], contentType : data[2] } }
+        },
+    {"name": "contentType", "symbols": [], "postprocess": data => null},
+    {"name": "contentType", "symbols": [(lexer.has("ws") ? {type: "ws"} : ws)], "postprocess": data => null},
+    {"name": "contentType", "symbols": [(lexer.has("word") ? {type: "word"} : word)], "postprocess": data => data[0].value},
+    {"name": "docText", "symbols": [], "postprocess": data => ''},
+    {"name": "docText", "symbols": ["docText", "text", (lexer.has("newline") ? {type: "newline"} : newline)], "postprocess": data => data[0]+data[1]+data[2].value},
+    {"name": "docText", "symbols": ["docText", (lexer.has("emptyLine") ? {type: "emptyLine"} : emptyLine)], "postprocess": data => data[0]+data[1].value},
     {"name": "_", "symbols": [], "postprocess": data => ''},
     {"name": "_", "symbols": [(lexer.has("ws") ? {type: "ws"} : ws)], "postprocess": data => data[0].value},
     {"name": "emptyLines", "symbols": [], "postprocess": data => ''},

package/src/index.js

@@ -45,7 +45,9 @@ export const Test = (state,step) => {
     log.debug('Test step: '+JSON.stringify(step)+' state:'+JSON.stringify(state));
     const stepDefinitionMatch = findStepDefinitionMatch(step);
 
-    const newState = stepDefinitionMatch.stepDefinition.f(state,stepDefinitionMatch.parameters,step.dataTable);
+    const extraData = step.dataTable ? step.dataTable : (step.docString ? step.docString.text : null );
+
+    const newState = stepDefinitionMatch.stepDefinition.f(state,stepDefinitionMatch.parameters,extraData);
     log.debug('Test newState: '+JSON.stringify(newState));
 
     return newState;

package/tests/doc-strings/features/doc-strings.feature

@@ -0,0 +1,21 @@
+Feature: Doc Strings
+  Scenario: You should be able to use Doc Strings with Given, When and Then statements
+    Given the following doc string:
+      """markdown
+      This is some cool text.
+
+        It is fun.
+      """
+      
+    When the following doc string is appended:
+          ```
+          This is more fun.
+          ```
+
+    Then final doc string will look like this:
+   """
+   This is some cool text.
+
+     It is fun.
+   This is more fun.
+   """

package/tests/doc-strings/features/step_definitions/doc-strings.js

@@ -0,0 +1,15 @@
+import { Given, When, Then, DataTable } from 'vitest-cucumber-plugin';
+import { expect } from 'vitest'
+import _ from 'lodash/fp';
+
+Given('the following doc string:',(state,params,docString) => {
+    return _.set('docString',docString,state);
+});
+
+When('the following doc string is appended:',(state,params,docString) => {
+    return _.set('docString',_.getOr('','docString',state)+docString,state);
+});
+
+Then('final doc string will look like this:',(state,params,docString) => {
+    expect(docString).toEqual(_.get('docString',state));
+});