test-grammar

Test grammar

Utility for testing grammar files, used with vscode.

Usage example

import { TestGrammar } from 'test-grammar';
new TestGrammar(
  JSON.stringify({
    scopeName: 'source.test',
    name: 'test',
    patterns: [
      {
        begin: '@',
        end: '$\\n?|(?=\\s|,|\\(|\\)|\\[|>)',
        name: 'at',
        patterns: [
          {
            match: '.*',
            name: 'name'
          }
        ]
      },
      {
        begin: '\\*\\*',
        end: '\\*\\*',
        name: 'bold',
        patterns: [
          {
            match: '[A-z]+',
            name: 'text'
          },
          {
            match: '\\d+',
            name: 'number'
          },
          {
            match: ' *',
            name: 'whitespace'
          }
        ]
      }
    ]
  }),
  { useSourceAsFile: true },
  run => {
    run(
      'test',
      `@syler
**text 0**`,
      `at|at name
bold|bold text|bold whitespace|bold number|bold`
    );
  }
);

Docs

• index

  • TestGrammar

• interfaces

  • Expect
  • Text
  • Options
  • Run
  • RunOptions

• logger

  • Stats
  • logger

index

TestGrammar

class TestGrammar {
    protected initFunc: (run: Run) => void;
    private registry;
    private grammar;
    private scope;
    private stats;
    private options;
    constructor(source: string, options: Partial<Options> | null, initFunc: (run: Run) => void);
    private SetOptions;
    private getOption;
    private Init;
    private transformText;
    private transformExpect;
    private run;
}

interfaces

Expect

type Expect = string[][][] | string;

Text

type Text = string[] | string;

Options

interface Options {
    /** Also Logs Tokens that passed the test. */
    logAllTokens: boolean;
    /** Calls `process.exit(1)` when tests failed or if there is an error. */
    exitProcess: boolean;
    /** Uses the source parameter as input file, the input string is expected to be valid json textmate grammar. */
    useSourceAsFile: boolean;
}

Run

type Run = (name: string, text: Text, expect: Expect, options?: Partial<RunOptions>) => void;

RunOptions

type RunOptions = Pick<Options, 'logAllTokens'>;

logger

Stats

interface Stats {
    cases: number;
    errors: number;
    failedCases: number;
    passedCases: number;
    tokens: number;
    failedTokens: number;
    passedTokens: number;
    lines: number;
    failedLines: number;
    passedLines: number;
}

logger

const logger: Logger<{
    invalid: LoggerType;
    failed: LoggerType;
    passed: LoggerType;
    stats: LoggerType;
}

Generated with suf-cli

Copyright (c) 2020 Leonard Grosoli Licensed under the MIT license.