pickle-jar 1.0.0 → 1.0.2

package/src/grammar/GherkinParserVisitor.ts

@@ -1,176 +0,0 @@
-// Generated from ./src/grammar/GherkinParser.g4 by ANTLR 4.9.0-SNAPSHOT
-
-
-import { ParseTreeVisitor } from "antlr4ts/tree/ParseTreeVisitor";
-
-import { FeatureFileContext } from "./GherkinParser";
-import { FeatureContext } from "./GherkinParser";
-import { BackgroundContext } from "./GherkinParser";
-import { ScenarioContext } from "./GherkinParser";
-import { ScenarioOutlineContext } from "./GherkinParser";
-import { ExamplesBlockContext } from "./GherkinParser";
-import { TableHeaderContext } from "./GherkinParser";
-import { TableRowContext } from "./GherkinParser";
-import { CellContext } from "./GherkinParser";
-import { StepContext } from "./GherkinParser";
-import { GivenStepContext } from "./GherkinParser";
-import { AndGivenStepContext } from "./GherkinParser";
-import { WhenStepContext } from "./GherkinParser";
-import { AndWhenStepContext } from "./GherkinParser";
-import { ThenStepContext } from "./GherkinParser";
-import { AndStepContext } from "./GherkinParser";
-import { ButStepContext } from "./GherkinParser";
-import { DocStringContext } from "./GherkinParser";
-import { TagsContext } from "./GherkinParser";
-import { ContentTextContext } from "./GherkinParser";
-
-
-/**
- * This interface defines a complete generic visitor for a parse tree produced
- * by `GherkinParser`.
- *
- * @param <Result> The return type of the visit operation. Use `void` for
- * operations with no return type.
- */
-export interface GherkinParserVisitor<Result> extends ParseTreeVisitor<Result> {
-	/**
-	 * Visit a parse tree produced by `GherkinParser.featureFile`.
-	 * @param ctx the parse tree
-	 * @return the visitor result
-	 */
-	visitFeatureFile?: (ctx: FeatureFileContext) => Result;
-
-	/**
-	 * Visit a parse tree produced by `GherkinParser.feature`.
-	 * @param ctx the parse tree
-	 * @return the visitor result
-	 */
-	visitFeature?: (ctx: FeatureContext) => Result;
-
-	/**
-	 * Visit a parse tree produced by `GherkinParser.background`.
-	 * @param ctx the parse tree
-	 * @return the visitor result
-	 */
-	visitBackground?: (ctx: BackgroundContext) => Result;
-
-	/**
-	 * Visit a parse tree produced by `GherkinParser.scenario`.
-	 * @param ctx the parse tree
-	 * @return the visitor result
-	 */
-	visitScenario?: (ctx: ScenarioContext) => Result;
-
-	/**
-	 * Visit a parse tree produced by `GherkinParser.scenarioOutline`.
-	 * @param ctx the parse tree
-	 * @return the visitor result
-	 */
-	visitScenarioOutline?: (ctx: ScenarioOutlineContext) => Result;
-
-	/**
-	 * Visit a parse tree produced by `GherkinParser.examplesBlock`.
-	 * @param ctx the parse tree
-	 * @return the visitor result
-	 */
-	visitExamplesBlock?: (ctx: ExamplesBlockContext) => Result;
-
-	/**
-	 * Visit a parse tree produced by `GherkinParser.tableHeader`.
-	 * @param ctx the parse tree
-	 * @return the visitor result
-	 */
-	visitTableHeader?: (ctx: TableHeaderContext) => Result;
-
-	/**
-	 * Visit a parse tree produced by `GherkinParser.tableRow`.
-	 * @param ctx the parse tree
-	 * @return the visitor result
-	 */
-	visitTableRow?: (ctx: TableRowContext) => Result;
-
-	/**
-	 * Visit a parse tree produced by `GherkinParser.cell`.
-	 * @param ctx the parse tree
-	 * @return the visitor result
-	 */
-	visitCell?: (ctx: CellContext) => Result;
-
-	/**
-	 * Visit a parse tree produced by `GherkinParser.step`.
-	 * @param ctx the parse tree
-	 * @return the visitor result
-	 */
-	visitStep?: (ctx: StepContext) => Result;
-
-	/**
-	 * Visit a parse tree produced by `GherkinParser.givenStep`.
-	 * @param ctx the parse tree
-	 * @return the visitor result
-	 */
-	visitGivenStep?: (ctx: GivenStepContext) => Result;
-
-	/**
-	 * Visit a parse tree produced by `GherkinParser.andGivenStep`.
-	 * @param ctx the parse tree
-	 * @return the visitor result
-	 */
-	visitAndGivenStep?: (ctx: AndGivenStepContext) => Result;
-
-	/**
-	 * Visit a parse tree produced by `GherkinParser.whenStep`.
-	 * @param ctx the parse tree
-	 * @return the visitor result
-	 */
-	visitWhenStep?: (ctx: WhenStepContext) => Result;
-
-	/**
-	 * Visit a parse tree produced by `GherkinParser.andWhenStep`.
-	 * @param ctx the parse tree
-	 * @return the visitor result
-	 */
-	visitAndWhenStep?: (ctx: AndWhenStepContext) => Result;
-
-	/**
-	 * Visit a parse tree produced by `GherkinParser.thenStep`.
-	 * @param ctx the parse tree
-	 * @return the visitor result
-	 */
-	visitThenStep?: (ctx: ThenStepContext) => Result;
-
-	/**
-	 * Visit a parse tree produced by `GherkinParser.andStep`.
-	 * @param ctx the parse tree
-	 * @return the visitor result
-	 */
-	visitAndStep?: (ctx: AndStepContext) => Result;
-
-	/**
-	 * Visit a parse tree produced by `GherkinParser.butStep`.
-	 * @param ctx the parse tree
-	 * @return the visitor result
-	 */
-	visitButStep?: (ctx: ButStepContext) => Result;
-
-	/**
-	 * Visit a parse tree produced by `GherkinParser.docString`.
-	 * @param ctx the parse tree
-	 * @return the visitor result
-	 */
-	visitDocString?: (ctx: DocStringContext) => Result;
-
-	/**
-	 * Visit a parse tree produced by `GherkinParser.tags`.
-	 * @param ctx the parse tree
-	 * @return the visitor result
-	 */
-	visitTags?: (ctx: TagsContext) => Result;
-
-	/**
-	 * Visit a parse tree produced by `GherkinParser.contentText`.
-	 * @param ctx the parse tree
-	 * @return the visitor result
-	 */
-	visitContentText?: (ctx: ContentTextContext) => Result;
-}
-

package/src/grammar/tsconfig.json

@@ -1,9 +0,0 @@
-{
-  "extends": "../../tsconfig.json",
-  "compilerOptions": {
-    "composite": true,
-    "noUnusedLocals": false,
-    "noUnusedParameters": false
-  },
-  "include": []
-}

package/src/index.ts

@@ -1,3 +0,0 @@
-export * from "./test-runner";
-export * from "./step-definition";
-export * from "./step";

package/src/step-definition.ts

@@ -1,6 +0,0 @@
-import {Step} from "./step";
-
-export interface StepDefinition<TWorld> {
-    match: RegExp,
-    step: Step<TWorld>;
-}

package/src/step.ts

@@ -1 +0,0 @@
-export type Step<TWorld> = (world: TWorld,...params: string[]) => void;

package/src/test-runner.ts

@@ -1,34 +0,0 @@
-import {BufferedTokenStream, CharStreams} from "antlr4ts";
-import * as fs from "fs";
-import {glob} from "glob";
-import * as path from "path";
-import {FeatureFileVisitor} from "./feature-file-visitor";
-import {getCallSites} from "./get-call-sites";
-import {GherkinLexer} from "./grammar/GherkinLexer";
-import {GherkinParser} from "./grammar/GherkinParser";
-import {StepDefinition} from "./step-definition";
-
-export function testRunner<TWorld>(globPattern: string, stepDefinitions: StepDefinition<TWorld>[], world: TWorld) {
-
-    const featureFiles = glob.sync(globPattern);
-    for (const featureFile of featureFiles) {
-        const callSite = getCallSites()[1];
-        const file = callSite?.getFileName() ?? "";
-        const dir = path.dirname(file);
-        const absoluteFeaturePath = path.resolve(dir, featureFile);
-
-        const featureText = fs.readFileSync(absoluteFeaturePath, "utf-8")
-        const input = CharStreams.fromString(featureText);
-        const lexer = new GherkinLexer(input);
-
-        const lexerStream = new BufferedTokenStream(lexer);
-        const parser = new GherkinParser(lexerStream);
-
-        const parsedFeatureFile = parser.featureFile();
-
-        const visitor = new FeatureFileVisitor<TWorld>(world, stepDefinitions);
-        parsedFeatureFile.accept(visitor);
-    }
-
-
-}

package/test/features/ScenarioOutlines.feature

@@ -1,15 +0,0 @@
-Feature: Scenario outlines
-
-  Scenario Outline: Using example values in steps
-    Given a scenario outline named '<name>'
-    When the outline parameter is '<parameter>'
-    Then the world stores the '<name>' '<parameter>'
-    And it can also be used as a docstring
-    """
-    <name> <parameter>
-    """
-
-    Examples:
-      | name                  | parameter              |
-      | scenario name         | parameter name         |
-      | another scenario name | another parameter name |

package/test/features/Scenarios.feature

@@ -1,41 +0,0 @@
-Feature: Running scenarios
-
-  Scenario: Simple scenario execution
-    Given a simple text
-    When running the test framework
-    Then no error should be reported
-
-    Scenario: Extracting arguments from the step
-      Given the foo word
-      When running the test framework
-      Then the given argument should be 'foo'
-
-    Scenario: Using arguments and doc string arguments
-      Given the 'input.txt' file with contents:
-      """
-      contents
-      """
-      When running the test framework
-      Then the 'input.txt' file should contain 'contents'
-
-    Scenario: Using multiline docstrings
-      Given the input string:
-      """
-      first line
-      second line
-      """
-      When running the test framework
-      Then the output string is:
-      """
-      first line
-      second line
-      """
-
-    Scenario: Using multiple steps
-      Given a first step
-      And given a second step
-      When running the test framework
-      And when using two steps
-      Then the first step ran
-      And the second step ran
-      But the third step didn't run

package/test/runner.ts

@@ -1,90 +0,0 @@
-import {StepDefinition, testRunner} from "../src";
-
-type World = Record<string, string>;
-
-const stepDefinitions: StepDefinition<World>[] = [{
-    match: /^Given a simple text$/, step: (world) => {
-        world['Simple text'];
-    }
-}, {
-    match: /^Given the (\w+) word$/, step: (world, word) => {
-        world['given argument'] = word;
-    }
-}, {
-    match: /^Given the '([\w.]+)' file with contents:$/, step: (world, file, contents) => {
-        world[file] = contents;
-    }
-}, {
-    match: /^Given the input string:$/, step: (world, input) => {
-        world["input string"] = input;
-    }
-}, {
-    match: /^Given a first step$/, step: (world) => {
-        world["first step"] = "true";
-    }
-}, {
-    match: /^Given a second step$/, step: (world) => {
-        world["second step"] = "true";
-    }
-}, {
-    match: /^Given a scenario outline named '(.+)'$/, step: (world, name) => {
-        world["outline-name"] = name;
-    }
-}, {
-    match: /^When running the test framework$/, step: world => {
-        /*nop*/
-    }
-}, {
-    match: /^When using two steps/, step: world => {
-        /*nop*/
-    }
-}, {
-    match: /^When the outline parameter is '(.+)'$/, step: (world, param) => {
-        world["outline-param"] = param;
-    }
-}, {
-    match: /^Then no error should be reported$/, step: world => {
-        /*nop*/
-    }
-}, {
-    match: /^Then the given argument should be '(.*)'$/, step: (world, arg) => {
-        expect(world['given argument']).toBe(arg);
-    }
-}, {
-    match: /^Then the '([\w.]+)' file should contain '([^']+)'$/, step(world, file, contents) {
-        expect(world[file]).not.toBeUndefined();
-        expect(world[file]).toBe(contents);
-    }
-}, {
-    match: /^Then the output string is:$/, step: (world, text) => {
-        expect(world['input string']).not.toBeUndefined();
-        expect(world['input string']).toBe(text);
-    }
-}, {
-    match: /^Then the first step ran$/, step: world => {
-        expect(world['first step']).toBe("true");
-    }
-}, {
-    match: /^Then the second step ran$/, step: world => {
-        expect(world['second step']).toBe("true");
-    }
-}, {
-    match: /^Then the world stores the '([^']+)' '([^']+)'/, step: (world, name, parameter) => {
-        expect(world['outline-name']).not.toBeUndefined();
-        expect(world['outline-name']).toBe(name);
-
-        expect(world['outline-param']).not.toBeUndefined();
-        expect(world['outline-param']).toBe(parameter);
-    }
-}, {
-    match: /^Then it can also be used as a docstring$/, step: (world, docstring) => {
-        expect(docstring).toBe(`${world['outline-name']} ${world['outline-param']}`)
-    }
-}, {
-    match: /^But the third step didn't run$/, step: world => {
-        expect(world['third step']).toBeUndefined();
-    }
-}]
-
-
-testRunner<World>(`${__dirname}/features/**/*.feature`, stepDefinitions, {});

package/tsconfig.json

@@ -1,47 +0,0 @@
-{
-  "compilerOptions": {
-    "baseUrl": ".",
-    "outDir": "dist",
-    "module": "commonjs",
-    "target": "es6",
-    "sourceMap": true,
-    "jsx": "react",
-    "moduleResolution": "node",
-    "rootDir": ".",
-    "forceConsistentCasingInFileNames": true,
-    "noImplicitReturns": true,
-    "noImplicitThis": true,
-    "noImplicitAny": true,
-    "importHelpers": true,
-    "strictNullChecks": true,
-    "noUnusedLocals": true,
-    "resolveJsonModule": true,
-    "allowSyntheticDefaultImports": true,
-    "alwaysStrict": true,
-    "declaration": true,
-    "declarationDir": "dist/types",
-    "typeRoots": [
-      "node_modules/@types"
-    ],
-    "esModuleInterop": true
-  },
-  "exclude": [
-    "node_modules",
-    "build",
-    "scripts",
-    "acceptance-tests",
-    "webpack",
-    "jest",
-    "public",
-    "secure",
-    "bin",
-    "dist",
-    "docs",
-    "coverage"
-  ],
-  "references": [{
-    "path": "./src/grammar"
-  }, {
-    "path": "./tsconfig.spec.json"
-  }]
-}

package/tsconfig.spec.json

@@ -1,14 +0,0 @@
-{
-  "extends": "./tsconfig.json",
-  "compilerOptions": {
-    "composite": true,
-    "outDir": "../../dist/out-tsc",
-    "module": "commonjs",
-    "types": ["jest", "node"]
-  },
-  "include": [
-    "**/*.spec.ts",
-    "**/*.d.ts",
-    "test/**/*.ts"
-  ]
-}

package/typedoc.json

@@ -1,8 +0,0 @@
-{
-  "plugin": [
-    "typedoc-plugin-markdown"
-  ],
-  "excludeProtected": true,
-  "excludeInternal": true,
-  "excludePrivate": true
-}