Cucumber Expressions parser and matcher for MoonBit

cucumber

expressions

bdd

testing

gherkin

Download zip

Author

moonrockz

Version

0.1.0

License

Apache-2.0

Repository

github.com/moonrockz/cucumber-expressions

Last updated

8 months ago

Downloads

#moonrockz/cucumber-expressions

A Cucumber Expressions parser and matcher for MoonBit. The simpler alternative to regular expressions used in BDD step definitions.

#Installation

moon add moonrockz/cucumber-expressions

#Quick Start

let expr = @cucumber-expressions.Expression::parse!("I have {int} cucumber(s) in my {word}")
let m = expr.match_("I have 42 cucumbers in my basket").unwrap()
let count = m.params[0].value // "42"
let place = m.params[1].value // "basket"

#Built-in Parameter Types

Parameter	Description	Example match
{int}	Integers, optionally negative	42, -1
{float}	Decimal and scientific notation	3.14, -1.5e10
{string}	Single- or double-quoted strings	"hello", 'hi'
{word}	A single word (no whitespace)	banana
{}	Anonymous — matches anything	whatever you want

let expr = @cucumber-expressions.Expression::parse!("{word} costs {float} dollars")
let m = expr.match_("coffee costs 4.50 dollars").unwrap()
// m.params[0] => { value: "coffee", type_: Word }
// m.params[1] => { value: "4.50", type_: Float }

#Optional Text

Parentheses mark text as optional. This is useful for plurals:

let expr = @cucumber-expressions.Expression::parse!("I have {int} cucumber(s)")
expr.match_("I have 1 cucumber")   // matches
expr.match_("I have 5 cucumbers")  // matches

#Alternation

Use / to match one of several alternatives:

let expr = @cucumber-expressions.Expression::parse!("I have a cat/dog")
expr.match_("I have a cat") // matches
expr.match_("I have a dog") // matches

#Custom Parameter Types

let registry = @cucumber-expressions.ParamTypeRegistry::default()
registry.register(
  "color",
  @cucumber-expressions.ParamType::Custom("color"),
  ["red", "green", "blue"],
)
let expr = @cucumber-expressions.Expression::parse_with_registry!(
  "the {color} ball",
  registry,
)
let m = expr.match_("the red ball").unwrap()
// m.params[0] => { value: "red", type_: Custom("color") }

#Match Result

Expression::match_ returns a Match?. A successful match contains an array of Param values in order:

let expr = @cucumber-expressions.Expression::parse!("{word} is {int}")
match expr.match_("MoonBit is 1") {
  Some(m) => {
    let name = m.params[0]  // { value: "MoonBit", type_: Word }
    let num  = m.params[1]  // { value: "1", type_: Int }
  }
  None => println("no match")
}

#Error Handling

Expression::parse raises ExpressionError, a suberror with these variants:

Variant	Cause
UnmatchedBrace	Missing closing }
UnmatchedParen	Missing closing )
CannotEscape	Invalid escape sequence
UnexpectedEscapeEnd	Backslash at end of expression
ValidationError	Structural errors (empty alternation, nested optionals, etc.)
UnknownParameterType	Unregistered {name} in expression

try {
  let _ = @cucumber-expressions.Expression::parse!("{unknown}")
} catch {
  @cucumber-expressions.ExpressionError::UnknownParameterType(name=name, ..) =>
    println("Unknown parameter: " + name)
}

#License

Apache-2.0

ExpressionError

source

pub suberror ExpressionError {
  UnmatchedBrace(Int, String)
  UnmatchedParen(Int, String)
  CannotEscape(Int, Char, String)
  UnexpectedEscapeEnd(Int, String)
  ValidationError(Int, String)
  UnknownParameterType(String, String)
}

Errors that can occur during cucumber expression parsing.

impl Show for ExpressionError

Expression

source

pub(all) struct Expression {
  // private fields
}

A parsed and compiled cucumber expression, ready for matching.

Expression::match_

source

fn Expression::match_(self : Expression, text : String) -> Match?

Match this expression against a text string. Returns Some(Match) with extracted parameters, or None if no match.

Expression::parse

source

fn Expression::parse(expression : String) -> Expression raise ExpressionError

Parse a cucumber expression with the default parameter type registry.

Expression::parse_with_registry

source

fn Expression::parse_with_registry(expression : String, registry : ParamTypeRegistry) -> Expression raise ExpressionError

Parse a cucumber expression with a custom parameter type registry.

Expression::source

source

fn Expression::source(self : Expression) -> String

Get the original expression source string.

Match

source

pub(all) struct Match {
  params : Array[Param]
}

A successful match result with extracted parameters.

impl Eq for Match

impl Show for Match

Node

source

pub(all) enum Node {
  TextNode(String)
  ParameterNode(String)
  OptionalNode(Array[Node])
  AlternationNode(Array[Array[Node]])
  ExpressionNode(Array[Node])
}

A single node in a cucumber expression AST.

impl Eq for Node

impl Show for Node

impl ToJson for Node

impl FromJson for Node

Param

source

pub(all) struct Param {
  value : String
  type_ : ParamType
}

An extracted parameter value.

impl Eq for Param

impl Show for Param

ParamType

source

pub(all) enum ParamType {
  Int
  Float
  String_
  Word
  Anonymous
  Custom(String)
}

Parameter types supported by cucumber expressions.

impl Eq for ParamType

impl Show for ParamType

impl ToJson for ParamType

impl FromJson for ParamType

ParamTypeRegistry

source

pub(all) struct ParamTypeRegistry {
  entries : Array[(String, ParamType, Array[String])]
}

Registry mapping parameter type names to their regex patterns.

ParamTypeRegistry::default

source

fn ParamTypeRegistry::default() -> ParamTypeRegistry

Create a registry with the 5 built-in parameter types pre-registered.

ParamTypeRegistry::get

source

fn ParamTypeRegistry::get(self : ParamTypeRegistry, name : String) -> (ParamType, Array[String])?

ParamTypeRegistry::new

source

fn ParamTypeRegistry::new() -> ParamTypeRegistry

ParamTypeRegistry::register

source

fn ParamTypeRegistry::register(self : ParamTypeRegistry, name : String, type_ : ParamType, patterns : Array[String]) -> Unit

Token

source

pub(all) enum Token {
  Text(String)
  BeginParameter
  EndParameter
  BeginOptional
  EndOptional
  Alternation
  WhiteSpace(String)
}

Tokens produced by the cucumber expression tokenizer.

impl Eq for Token

impl Show for Token

compile

source

fn compile(node : Node, registry : ParamTypeRegistry) -> String raise ExpressionError

Compile a cucumber expression AST to a regex pattern string.

compile_expression

source

fn compile_expression(expression : String, registry? : ParamTypeRegistry) -> String raise ExpressionError

Parse a cucumber expression and compile it to a regex pattern string.

parse_expression

source

fn parse_expression(expression : String) -> Node raise ExpressionError

Parse a cucumber expression string into an AST.

tokenize

source

fn tokenize(expression : String) -> Array[Token] raise ExpressionError

Tokenize a cucumber expression string into an array of tokens.

Converts the raw expression into a flat token stream. Does not validate matching braces or parentheses — that is the parser's responsibility.

validate

source

fn validate(node : Node) -> Unit raise ExpressionError

Validate a parsed cucumber expression AST. Raises ValidationError for invalid expression structures.

version

source

fn version() -> String

Cucumber Expressions for MoonBit.

A parser and matcher for Cucumber Expressions, the simpler alternative to regular expressions used in BDD step definitions.

Source Files

Site source Report issue Packages Build queue Skills Statistics

cucumber-expressions

#moonrockz/cucumber-expressions

#Installation

#Quick Start

#Built-in Parameter Types

#Optional Text

#Alternation

#Custom Parameter Types

#Match Result

#Error Handling

#License

#ExpressionError

#Expression

#Expression::match_

#Expression::parse

#Expression::parse_with_registry

#Expression::source

#Match

#Node

#Param

#ParamType

#ParamTypeRegistry

#ParamTypeRegistry::default

#ParamTypeRegistry::get

#ParamTypeRegistry::new

#ParamTypeRegistry::register

#Token

#compile

#compile_expression

#parse_expression

#tokenize

#validate

#version

Source Files

ExpressionError

Expression

Expression::match_

Expression::parse

Expression::parse_with_registry

Expression::source

Match

Node

Param

ParamType

ParamTypeRegistry

ParamTypeRegistry::default

ParamTypeRegistry::get

ParamTypeRegistry::new

ParamTypeRegistry::register

Token

compile

compile_expression

parse_expression

tokenize

validate

version