#moonrockz/cucumber-expressions

#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

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

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

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"),
  [@cucumber-expressions.RegexPattern("red|green|blue")],
  transformer=@cucumber-expressions.Transformer::new(fn(groups) {
    @cucumber-expressions.ParamValue::StringVal(groups[0].to_upper())
  }),
)
let expr = @cucumber-expressions.Expression::parse_with_registry!(
  "the {color} ball",
  registry,
)
let m = expr.match_("the red ball").unwrap()
// m.params[0].value => StringVal("RED"), m.params[0].raw => "red"

#Typed Parameter Types

#define1 to define8

let registry = @cucumber-expressions.ParamTypeRegistry::default()
let color = registry.define1("color", [@cucumber-expressions.RegexPattern("red|green|blue")], Color::new)
let coord = registry.define2("coord", [@cucumber-expressions.RegexPattern("(\\d+),(\\d+)")], (x, y) => {
  Coord::new(@string.parse_int(x), @string.parse_int(y))
})
let expr = @cucumber-expressions.Expression::parse_with_registry("a {color} ball at {coord}", registry)
let m = expr.match_("a red ball at 3,4").unwrap()
let c : Color = color.get(m.params[0])  // raises if params[0] is not a {color}
let p : Coord = m.get(coord)            // the only {coord} of the match
let all : Array[Color] = m.get_all(color)

#Captures: typed parts with zip and map

let seat = registry.define_with(
  "seat",
  [@cucumber-expressions.RegexPattern("(\\d+)-(\\w+)-(\\d+)")],
  @cucumber-expressions.Captures::int()
    .zip(@cucumber-expressions.Captures::string())
    .zip(@cucumber-expressions.Captures::int())
    .map((row, block, number) => Seat::new(row, block, number)),
)

let person = @cucumber-expressions.Captures::string().zip(@cucumber-expressions.Captures::string()).map((first, last) => Person::new(first, last))
let customer = person.zip(address).zip(contact).map((p, a, c) => Customer::new(p, a, c))

#Traits: ParameterTypeDef and FromGroups1 to FromGroups8

impl @cucumber-expressions.ParameterTypeDef for Color with name() { "color" }
impl @cucumber-expressions.ParameterTypeDef for Color with regexps() {
  [@cucumber-expressions.RegexPattern("red|green|blue")]
}
impl @cucumber-expressions.FromGroups1 for Color with from_groups(name) { Color::new(name) }

let color : @cucumber-expressions.ParameterType[Color] = registry.define_type1()

#Match Result

• 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")
}

#Regular Expressions

let expr = @cucumber-expressions.RegularExpression::new("^I have (\\d+) cukes? in my (.+)$")
let m = expr.match_("I have 3 cukes in my belly").unwrap()
// m.params[0].value => IntVal(3), m.params[1].value => AnonymousVal("belly")

let factory = @cucumber-expressions.ExpressionFactory::new(registry)
let expr = factory.create_expression("^I have (\\d+) cukes$") // Regular(...)
let expr = factory.create_expression("I have {int} cukes")    // Cucumber(...)

#Snippet Generation

let generator = @cucumber-expressions.CucumberExpressionGenerator::new(registry)
let generated = generator.generate_expressions("I have 2 cucumbers and 1.5 tomato")
// generated[0].source() => "I have {int} cucumbers and {float} tomato"
// generated[0].parameter_names() => ["int", "float"]

#Error Handling

This Cucumber Expression has a problem at column 3:

(a(b))
  ^-^
An optional may not contain an other optional.
If you did not mean to use an optional type you can use '\(' to escape the '('. For more complicated expressions consider using a regular expression instead.

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

#License