vitest-cucumber-plugin 0.1.8 → 0.5.0

package/README.md

@@ -106,9 +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:
-* Doc strings

package/RELEASE_NOTES.md

@@ -1,3 +1,4 @@
+* 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

package/package.json

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

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({
@@ -38,6 +39,13 @@ var gherkin_umd$1 = {exports: {}};
 	    }),
 	  },
 	});
+
+	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: [
@@ -95,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 => []},
@@ -108,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},
@@ -137,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({
@@ -25,6 +26,13 @@ const lexer = moo.compile({
     }),
   },
 });
+
+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
@@ -98,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] %}
@@ -116,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 } } %}
 
@@ -153,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({
@@ -29,6 +30,13 @@ const lexer = moo.compile({
     }),
   },
 });
+
+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: [
@@ -86,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 => []},
@@ -99,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},
@@ -128,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));
+});