README
- ::match_Expression::match_
- ::parseExpression::parse
- ::parse_with_registryExpression::parse_with_registry
- ::sourceExpression::source
T
Match
T
Node
T
Param
T
ParamType
T
ParamTypeEntry
- ::defaultParamTypeRegistry::default
- ::entries_viewParamTypeRegistry::entries_view
- ::getParamTypeRegistry::get
- ::newParamTypeRegistry::new
- ::registerParamTypeRegistry::register
T
ParamValue
- ::to_stringRegexPattern::to_string
T
Token
- ::callTransformer::call
- ::newTransformer::new
V
compile
V
compile_expression
V
parse_expression
V
tokenize
V
validate
V
version

cucumber-expressions

Cucumber Expressions parser and matcher for MoonBit

cucumber

expressions

bdd

testing

gherkin

Download zip

Author

moonrockz

Version

0.3.2

License

Apache-2.0

Repository

github.com/moonrockz/cucumber-expressions

Last updated

7 months ago

Downloads

Dependencies

#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()
// m.params[0].value => IntVal(42), m.params[0].raw => "42"
// m.params[1].value => WordVal("basket"), m.params[1].raw => "basket"

#Built-in Parameter Types

All 11 types from the Cucumber Expressions specification:

Parameter	Description	Example match	Value type
{int}	Integers, optionally negative	42, -1	IntVal(Int)
{float}	Decimal and scientific notation	3.14, -1.5e10	FloatVal(Double)
{double}	Same as float	3.14, 1.5e10	DoubleVal(Double)
{long}	64-bit integers	9223372036854775807	LongVal(Int64)
{byte}	Byte-range integers	127, 255	ByteVal(Byte)
{short}	Short integers	8080	ShortVal(Int)
{bigdecimal}	Arbitrary-precision decimals	99.99	BigDecimalVal(Decimal)
{biginteger}	Arbitrary-precision integers	12345678901234567890	BigIntegerVal(BigInt)
{string}	Single- or double-quoted strings	"hello", 'hi'	StringVal(String)
{word}	A single word (no whitespace)	banana	WordVal(String)
{}	Anonymous — matches anything	whatever you want	AnonymousVal(String)

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

#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

Register your own named parameter types with ParamTypeRegistry. An optional transformer converts matched text into a typed value:

let registry = @cucumber-expressions.ParamTypeRegistry::default()
registry.register(
  "color",
  @cucumber-expressions.ParamType::Custom("color"),
  [@cucumber-expressions.RegexPattern("red|green|blue")],
  transformer=@cucumber-expressions.Transformer::new(fn(groups) {
    @cucumber-expressions.ParamValue::CustomVal(@any.of(groups[0]))
  }),
)
let expr = @cucumber-expressions.Expression::parse_with_registry!(
  "the {color} ball",
  registry,
)
let m = expr.match_("the red ball").unwrap()
// m.params[0].value => CustomVal(<Any>), m.params[0].raw => "red"

#Match Result

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

value — typed ParamValue (pattern-matchable enum)
type_ — which ParamType matched
raw — original matched text as String

let expr = @cucumber-expressions.Expression::parse!("{word} is {int}")
match expr.match_("MoonBit is 1") {
  Some(m) => {
    let name = m.params[0]  // { value: WordVal("MoonBit"), type_: Word, raw: "MoonBit" }
    let num  = m.params[1]  // { value: IntVal(1), type_: Int, raw: "1" }
  }
  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 : ParamValue
  type_ : ParamType
  raw : String
}

An extracted parameter value.

impl Eq for Param

impl Show for Param

ParamType

source

pub(all) enum ParamType {
  Int
  Float
  String_
  Word
  Anonymous
  Double_
  Long
  Byte
  Short
  BigDecimal
  BigInteger
  Custom(String)
}

Parameter types supported by cucumber expressions.

impl Eq for ParamType

impl Show for ParamType

impl ToJson for ParamType

impl FromJson for ParamType

ParamTypeEntry

source

pub(all) struct ParamTypeEntry {
  name : String
  type_ : ParamType
  patterns : Array[RegexPattern]
  transformer : Transformer
}

A registered parameter type entry with name, type, regex patterns, and transformer.

ParamTypeRegistry

source

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

Registry mapping parameter type names to their regex patterns.

ParamTypeRegistry::default

source

fn ParamTypeRegistry::default() -> ParamTypeRegistry

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

ParamTypeRegistry::entries_view

source

fn ParamTypeRegistry::entries_view(self : ParamTypeRegistry) -> ArrayView[ParamTypeEntry]

Read-only view of all registered parameter type entries.

ParamTypeRegistry::get

source

fn ParamTypeRegistry::get(self : ParamTypeRegistry, name : String) -> ParamTypeEntry?

ParamTypeRegistry::new

source

fn ParamTypeRegistry::new() -> ParamTypeRegistry

ParamTypeRegistry::register

source

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

ParamValue

source

pub(all) enum ParamValue {
  IntVal(Int)
  FloatVal(Double)
  DoubleVal(Double)
  LongVal(Int64)
  ByteVal(Byte)
  ShortVal(Int)
  StringVal(String)
  WordVal(String)
  AnonymousVal(String)
  BigDecimalVal(@moonbitlang/x/decimal.Decimal
Decimal)
  BigIntegerVal(@moonbitlang/core/bigint.BigInt
BigInt)
  CustomVal(@tonyfettes/any.Any
Any)
}

A typed value produced by a transformer function. Built-in types have concrete variants for compile-time pattern matching. Custom types use CustomVal(@any.Any) for type-erased transformer results.

RegexPattern

source

pub(all) struct RegexPattern {
  // private fields

  fn new(value : String) -> RegexPattern
}

A regex pattern used for matching parameter types in cucumber expressions.

impl Eq for RegexPattern

impl Show for RegexPattern

RegexPattern::to_string

source

fn RegexPattern::to_string(self : RegexPattern) -> String

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

Transformer

source

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

A transformer function that converts captured regex group strings into a typed ParamValue. Receives an array of captured group strings (arity matches capture groups in the regex).

Transformer::call

source

fn Transformer::call(self : Transformer, groups : Array[String]) -> ParamValue raise

Transformer::new

source

fn Transformer::new(f : (Array[String]) -> ParamValue raise) -> Transformer

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

#ParamTypeEntry

#ParamTypeRegistry

#ParamTypeRegistry::default

#ParamTypeRegistry::entries_view

#ParamTypeRegistry::get

#ParamTypeRegistry::new

#ParamTypeRegistry::register

#ParamValue

#RegexPattern

#RegexPattern::to_string

#Token

#Transformer

#Transformer::call

#Transformer::new

#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

ParamTypeEntry

ParamTypeRegistry

ParamTypeRegistry::default

ParamTypeRegistry::entries_view

ParamTypeRegistry::get

ParamTypeRegistry::new

ParamTypeRegistry::register

ParamValue

RegexPattern

RegexPattern::to_string

Token

Transformer

Transformer::call

Transformer::new

compile

compile_expression

parse_expression

tokenize

validate

version