README
- ::outputExpressionError::output
- ::to_reprExpressionError::to_repr
- ::to_stringExpressionError::to_string
- ::match_Expression::match_
- ::parseExpression::parse
- ::parse_with_registryExpression::parse_with_registry
- ::sourceExpression::source
- ::equalMatch::equal
- ::not_equalMatch::not_equal
- ::to_reprMatch::to_repr
- ::equalNode::equal
- ::from_jsonNode::from_json
- ::not_equalNode::not_equal
- ::to_jsonNode::to_json
- ::to_reprNode::to_repr
- ::equalParam::equal
- ::not_equalParam::not_equal
- ::to_reprParam::to_repr
- ::equalParamType::equal
- ::from_jsonParamType::from_json
- ::not_equalParamType::not_equal
- ::to_jsonParamType::to_json
- ::to_reprParamType::to_repr
- ::equalParamTypeEntry::equal
- ::not_equalParamTypeEntry::not_equal
- ::to_reprParamTypeEntry::to_repr
- ::defaultParamTypeRegistry::default
- ::entries_viewParamTypeRegistry::entries_view
- ::getParamTypeRegistry::get
- ::newParamTypeRegistry::new
- ::registerParamTypeRegistry::register
- ::equalParamValue::equal
- ::not_equalParamValue::not_equal
- ::outputParamValue::output
- ::to_reprParamValue::to_repr
- ::to_stringParamValue::to_string
- ::RegexPatternRegexPattern::RegexPattern
- ::equalRegexPattern::equal
- ::not_equalRegexPattern::not_equal
- ::to_reprRegexPattern::to_repr
- ::to_stringRegexPattern::to_string
- ::equalToken::equal
- ::not_equalToken::not_equal
- ::to_reprToken::to_repr
- ::callTransformer::call
- ::newTransformer::new
- ::to_reprTransformer::to_repr
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.4.0

License

Apache-2.0

Repository

github.com/moonrockz/cucumber-expressions

Last updated

26 days 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()
// 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(position~ : Int, message~ : String)
  UnmatchedParen(position~ : Int, message~ : String)
  CannotEscape(position~ : Int, character~ : Char, message~ : String)
  UnexpectedEscapeEnd(position~ : Int, message~ : String)
  ValidationError(position~ : Int, message~ : String)
  UnknownParameterType(name~ : String, message~ : String)
} derive(@moonbitlang/core/debug.Debug
Debug)

Errors that can occur during cucumber expression parsing.

impl Show for ExpressionError

ExpressionError::output

source

fn ExpressionError::output(self : ExpressionError, logger : &Logger) -> Unit

ExpressionError::to_repr

source

#deprecated("`ExpressionError::to_repr` is deprecated, use `@moonbitlang/core/debug.Debug::to_repr` instead.")
fn ExpressionError::to_repr(ExpressionError) -> @moonbitlang/core/debug.Repr
Repr

ExpressionError::to_string

source

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

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]
} derive(Eq, @moonbitlang/core/debug.Debug
Debug)

A successful match result with extracted parameters.

Match::equal

source

#deprecated("`Match::equal` is deprecated, use `Eq::equal` instead.")
fn Match::equal(Match, Match) -> Bool

Match::not_equal

source

#deprecated("`Match::not_equal` is deprecated, use `Eq::not_equal` instead.")
fn Match::not_equal(x : Match, y : Match) -> Bool

Match::to_repr

source

#deprecated("`Match::to_repr` is deprecated, use `@moonbitlang/core/debug.Debug::to_repr` instead.")
fn Match::to_repr(Match) -> @moonbitlang/core/debug.Repr
Repr

Node

source

pub(all) enum Node {
  TextNode(String)
  ParameterNode(String)
  OptionalNode(Array[Node])
  AlternationNode(Array[Array[Node]])
  ExpressionNode(Array[Node])
} derive(Eq, ToJson, @moonbitlang/core/debug.Debug
Debug, @moonbitlang/core/json.FromJson
FromJson)

A single node in a cucumber expression AST.

Node::equal

source

#deprecated("`Node::equal` is deprecated, use `Eq::equal` instead.")
fn Node::equal(Node, Node) -> Bool

Node::from_json

source

fn Node::from_json(Json, @moonbitlang/core/json.JsonPath
JsonPath) -> Node raise @moonbitlang/core/json.JsonDecodeError
JsonDecodeError

Node::not_equal

source

#deprecated("`Node::not_equal` is deprecated, use `Eq::not_equal` instead.")
fn Node::not_equal(x : Node, y : Node) -> Bool

Node::to_json

source

fn Node::to_json(Node) -> Json

Node::to_repr

source

#deprecated("`Node::to_repr` is deprecated, use `@moonbitlang/core/debug.Debug::to_repr` instead.")
fn Node::to_repr(Node) -> @moonbitlang/core/debug.Repr
Repr

Param

source

pub(all) struct Param {
  value : ParamValue
  type_ : ParamType
  raw : String
} derive(Eq, @moonbitlang/core/debug.Debug
Debug)

An extracted parameter value.

Param::equal

source

#deprecated("`Param::equal` is deprecated, use `Eq::equal` instead.")
fn Param::equal(Param, Param) -> Bool

Param::not_equal

source

#deprecated("`Param::not_equal` is deprecated, use `Eq::not_equal` instead.")
fn Param::not_equal(x : Param, y : Param) -> Bool

Param::to_repr

source

#deprecated("`Param::to_repr` is deprecated, use `@moonbitlang/core/debug.Debug::to_repr` instead.")
fn Param::to_repr(Param) -> @moonbitlang/core/debug.Repr
Repr

ParamType

source

pub(all) enum ParamType {
  Int
  Float
  String_
  Word
  Anonymous
  Double_
  Long
  Byte
  Short
  BigDecimal
  BigInteger
  Custom(String)
} derive(Eq, ToJson, @moonbitlang/core/debug.Debug
Debug, @moonbitlang/core/json.FromJson
FromJson)

Parameter types supported by cucumber expressions.

ParamType::equal

source

#deprecated("`ParamType::equal` is deprecated, use `Eq::equal` instead.")
fn ParamType::equal(ParamType, ParamType) -> Bool

ParamType::from_json

source

fn ParamType::from_json(Json, @moonbitlang/core/json.JsonPath
JsonPath) -> ParamType raise @moonbitlang/core/json.JsonDecodeError
JsonDecodeError

ParamType::not_equal

source

#deprecated("`ParamType::not_equal` is deprecated, use `Eq::not_equal` instead.")
fn ParamType::not_equal(x : ParamType, y : ParamType) -> Bool

ParamType::to_json

source

fn ParamType::to_json(ParamType) -> Json

ParamType::to_repr

source

#deprecated("`ParamType::to_repr` is deprecated, use `@moonbitlang/core/debug.Debug::to_repr` instead.")
fn ParamType::to_repr(ParamType) -> @moonbitlang/core/debug.Repr
Repr

ParamTypeEntry

source

pub(all) struct ParamTypeEntry {
  name : String
  type_ : ParamType
  patterns : Array[RegexPattern]
  transformer : Transformer
} derive(@moonbitlang/core/debug.Debug
Debug)

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

impl Eq for ParamTypeEntry

ParamTypeEntry::equal

source

#deprecated("`ParamTypeEntry::equal` is deprecated, use `Eq::equal` instead.")
fn ParamTypeEntry::equal(self : ParamTypeEntry, other : ParamTypeEntry) -> Bool

ParamTypeEntry::not_equal

source

#deprecated("`ParamTypeEntry::not_equal` is deprecated, use `Eq::not_equal` instead.")
fn ParamTypeEntry::not_equal(x : ParamTypeEntry, y : ParamTypeEntry) -> Bool

ParamTypeEntry::to_repr

source

#deprecated("`ParamTypeEntry::to_repr` is deprecated, use `@moonbitlang/core/debug.Debug::to_repr` instead.")
fn ParamTypeEntry::to_repr(ParamTypeEntry) -> @moonbitlang/core/debug.Repr
Repr

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.

impl Eq for ParamValue

impl Show for ParamValue

impl Debug for ParamValue

ParamValue::equal

source

#deprecated("`ParamValue::equal` is deprecated, use `Eq::equal` instead.")
fn ParamValue::equal(self : ParamValue, other : ParamValue) -> Bool

ParamValue::not_equal

source

#deprecated("`ParamValue::not_equal` is deprecated, use `Eq::not_equal` instead.")
fn ParamValue::not_equal(x : ParamValue, y : ParamValue) -> Bool

ParamValue::output

source

fn ParamValue::output(self : ParamValue, logger : &Logger) -> Unit

ParamValue::to_repr

source

#deprecated("`ParamValue::to_repr` is deprecated, use `@moonbitlang/core/debug.Debug::to_repr` instead.")
fn ParamValue::to_repr(self : ParamValue) -> @moonbitlang/core/debug.Repr
Repr

ParamValue::to_string

source

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

RegexPattern

source

pub(all) struct RegexPattern {
  // private fields
} derive(Eq, @moonbitlang/core/debug.Debug
Debug)

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

RegexPattern::RegexPattern

source

fn RegexPattern::RegexPattern(value : String) -> RegexPattern

RegexPattern::equal

source

#deprecated("`RegexPattern::equal` is deprecated, use `Eq::equal` instead.")
fn RegexPattern::equal(RegexPattern, RegexPattern) -> Bool

RegexPattern::not_equal

source

#deprecated("`RegexPattern::not_equal` is deprecated, use `Eq::not_equal` instead.")
fn RegexPattern::not_equal(x : RegexPattern, y : RegexPattern) -> Bool

RegexPattern::to_repr

source

#deprecated("`RegexPattern::to_repr` is deprecated, use `@moonbitlang/core/debug.Debug::to_repr` instead.")
fn RegexPattern::to_repr(RegexPattern) -> @moonbitlang/core/debug.Repr
Repr

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)
} derive(Eq, @moonbitlang/core/debug.Debug
Debug)

Tokens produced by the cucumber expression tokenizer.

Token::equal

source

#deprecated("`Token::equal` is deprecated, use `Eq::equal` instead.")
fn Token::equal(Token, Token) -> Bool

Token::not_equal

source

#deprecated("`Token::not_equal` is deprecated, use `Eq::not_equal` instead.")
fn Token::not_equal(x : Token, y : Token) -> Bool

Token::to_repr

source

#deprecated("`Token::to_repr` is deprecated, use `@moonbitlang/core/debug.Debug::to_repr` instead.")
fn Token::to_repr(Token) -> @moonbitlang/core/debug.Repr
Repr

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).

impl Debug for Transformer

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

Transformer::to_repr

source

#deprecated("`Transformer::to_repr` is deprecated, use `@moonbitlang/core/debug.Debug::to_repr` instead.")
fn Transformer::to_repr(_self : Transformer) -> @moonbitlang/core/debug.Repr
Repr

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

#ExpressionError::output

#ExpressionError::to_repr

#ExpressionError::to_string

#Expression

#Expression::match_

#Expression::parse

#Expression::parse_with_registry

#Expression::source

#Match

#Match::equal

#Match::not_equal

#Match::to_repr

#Node

#Node::equal

#Node::from_json

#Node::not_equal

#Node::to_json

#Node::to_repr

#Param

#Param::equal

#Param::not_equal

#Param::to_repr

#ParamType

#ParamType::equal

#ParamType::from_json

#ParamType::not_equal

#ParamType::to_json

#ParamType::to_repr

#ParamTypeEntry

#ParamTypeEntry::equal

#ParamTypeEntry::not_equal

#ParamTypeEntry::to_repr

#ParamTypeRegistry

#ParamTypeRegistry::default

#ParamTypeRegistry::entries_view

#ParamTypeRegistry::get

#ParamTypeRegistry::new

#ParamTypeRegistry::register

#ParamValue

#ParamValue::equal

#ParamValue::not_equal

#ParamValue::output

#ParamValue::to_repr

#ParamValue::to_string

#RegexPattern

#RegexPattern::RegexPattern

#RegexPattern::equal

#RegexPattern::not_equal

#RegexPattern::to_repr

#RegexPattern::to_string

#Token

#Token::equal

#Token::not_equal

#Token::to_repr

#Transformer

#Transformer::call

#Transformer::new

#Transformer::to_repr

#compile

#compile_expression

#parse_expression

#tokenize

#validate

#version

Source Files

ExpressionError

ExpressionError::output

ExpressionError::to_repr

ExpressionError::to_string

Expression

Expression::match_

Expression::parse

Expression::parse_with_registry

Expression::source

Match

Match::equal

Match::not_equal

Match::to_repr

Node

Node::equal

Node::from_json

Node::not_equal

Node::to_json

Node::to_repr

Param

Param::equal

Param::not_equal

Param::to_repr

ParamType

ParamType::equal

ParamType::from_json

ParamType::not_equal

ParamType::to_json

ParamType::to_repr

ParamTypeEntry

ParamTypeEntry::equal

ParamTypeEntry::not_equal

ParamTypeEntry::to_repr

ParamTypeRegistry

ParamTypeRegistry::default

ParamTypeRegistry::entries_view

ParamTypeRegistry::get

ParamTypeRegistry::new

ParamTypeRegistry::register

ParamValue

ParamValue::equal

ParamValue::not_equal

ParamValue::output

ParamValue::to_repr

ParamValue::to_string

RegexPattern

RegexPattern::RegexPattern

RegexPattern::equal

RegexPattern::not_equal

RegexPattern::to_repr

RegexPattern::to_string

Token

Token::equal

Token::not_equal

Token::to_repr

Transformer

Transformer::call

Transformer::new

Transformer::to_repr

compile

compile_expression

parse_expression

tokenize

validate

version