#moonrockz/gherkin

#Installation

moon add moonrockz/gherkin

#Quick Start

let source = @gherkin.Source::from_string(
  "Feature: Login\n  Scenario: Success\n    Given a user\n    When they log in\n    Then they see the dashboard",
)
let doc = @gherkin.parse!(source)
let feature = doc.feature.unwrap()
// feature.name == "Login"

#Four Parsing APIs

#DOM-Based

let doc = @gherkin.parse!(source)
// doc.feature, doc.comments — full tree

#Visitor Pattern

doc.accept(my_visitor)

#Functional Fold

let count = doc.fold(0, {
  ..@gherkin.GherkinFold::default(),
  visit_step: @gherkin.continuing(fn(n, _) { n + 1 }),
})

#SAX-Style Handler

@gherkin.parse_with_handler!(source, my_handler)

#WASM Component

mise run build:component    # produces _build/gherkin.component.wasm

#CLI

moon run src/cmd/main -- path/to/file.feature

echo "Feature: Test" | moon run src/cmd/main -- -

#License

#moonrockz/gherkin

#Source

///|
test "create a source from a string" {
  let src = @gherkin.Source::from_string(
    "Feature: Hello\n  Scenario: World",
    uri="test.feature",
  )
  @debug.debug_inspect(src.uri(), content="Some(\"test.feature\")")
  @debug.debug_inspect(src.line_count(), content="2")
  @debug.debug_inspect(src.line(1), content="Some(\"Feature: Hello\")")
}

#DOM Parsing

///|
test "parse a feature with scenarios and steps" {
  let input =
    #|Feature: Calculator
    #|  Scenario: Addition
    #|    Given two numbers
    #|    When I add them
    #|    Then I get the sum
  let doc = @gherkin.parse(@gherkin.Source::from_string(input))
  let feature = doc.feature.unwrap()
  @debug.debug_inspect(
    feature.name,
    content=(
      #|"Calculator"
    ),
  )
  @debug.debug_inspect(
    feature.language,
    content=(
      #|"en"
    ),
  )
   feature.children[0] is Scenario(s)
  @debug.debug_inspect(
    s.name,
    content=(
      #|"Addition"
    ),
  )
  @debug.debug_inspect(s.steps.length(), content="3")
  @debug.debug_inspect(s.steps[0].keyword_type, content="Context")
  @debug.debug_inspect(s.steps[1].keyword_type, content="Action")
  @debug.debug_inspect(s.steps[2].keyword_type, content="Outcome")
}

#Data Tables

///|
test "parse a step with a data table" {
  let input =
    #|Feature: Users
    #|  Scenario: List users
    #|    Given users:
    #|      | name  | age |
    #|      | Alice | 30  |
    #|      | Bob   | 25  |
  let doc = @gherkin.parse(@gherkin.Source::from_string(input))
   doc.feature.unwrap().children[0] is Scenario(s)
   s.steps[0].argument is Some(DataTable(table))
  @debug.debug_inspect(table.rows.length(), content="3")
  @debug.debug_inspect(
    table.rows[0].cells[0].value,
    content=(
      #|"name"
    ),
  )
  @debug.debug_inspect(
    table.rows[1].cells[0].value,
    content=(
      #|"Alice"
    ),
  )
  @debug.debug_inspect(
    table.rows[2].cells[1].value,
    content=(
      #|"25"
    ),
  )
}

#Doc Strings

///|
test "parse a step with a doc string" {
  let input =
    #|Feature: Payloads
    #|  Scenario: JSON body
    #|    Given a request body:
    #|      ```json
    #|      {"key": "value"}
    #|      ```
  let doc = @gherkin.parse(@gherkin.Source::from_string(input))
   doc.feature.unwrap().children[0] is Scenario(s)
   s.steps[0].argument is Some(DocString(ds))
  @debug.debug_inspect(ds.media_type, content="Some(\"json\")")
  assert_true(ds.content.contains("key"))
}

#Tags

///|
test "parse tags on features and scenarios" {
  let input =
    #|@smoke @regression
    #|Feature: Tagged
    #|  @critical
    #|  Scenario: Important
    #|    Given a step
  let doc = @gherkin.parse(@gherkin.Source::from_string(input))
  let feature = doc.feature.unwrap()
  @debug.debug_inspect(feature.tags.length(), content="2")
  @debug.debug_inspect(
    feature.tags[0].name,
    content=(
      #|"@smoke"
    ),
  )
   feature.children[0] is Scenario(s)
  @debug.debug_inspect(
    s.tags[0].name,
    content=(
      #|"@critical"
    ),
  )
}

#JSON Serialization

///|
test "serialize a document to JSON" {
  let doc = @gherkin.parse(
    @gherkin.Source::from_string(
      "Feature: JSON\n  Scenario: Test\n    Given a step",
    ),
  )
  let text = doc.to_json().stringify()
  assert_true(text.contains("JSON"))
  assert_true(text.contains("Test"))
}

#Visitor Pattern

///|
struct ScenarioCounter {
  mut count : Int
}

///|
impl GherkinVisitor for ScenarioCounter with fn visit_scenario(self, _scenario) {
  self.count  1
}

///|
test "count scenarios with a visitor" {
  let input =
    #|Feature: Counter
    #|  Scenario: First
    #|    Given a
    #|  Scenario: Second
    #|    Given b
  let doc = @gherkin.parse(@gherkin.Source::from_string(input))
  let counter : ScenarioCounter = { count: 0, }
  doc.accept(counter)
  @debug.debug_inspect(counter.count, content="2")
}

#Functional Fold

///|
test "count steps with fold" {
  let input =
    #|Feature: Fold
    #|  Scenario: One
    #|    Given step 1
    #|    When step 2
    #|  Scenario: Two
    #|    Then step 3
  let doc = @gherkin.parse(@gherkin.Source::from_string(input))
  let step_count = doc.fold(0, {
    ..@gherkin.GherkinFold::default(),
    visit_step: @gherkin.continuing(fn(n, _step) { n + 1 }),
  })
  @debug.debug_inspect(step_count, content="3")
}

#Flow Control

///|
let step_count = doc.fold(0, {
  ..GherkinFold::default(),
  visit_scenario: fn(n, scenario) {
    if scenario.tags.iter().any(fn(t) { t.name == "@skip" }) {
      SkipChildren(n) // skip steps inside @skip scenarios
    } else {
      Continue(n)
    }
  },
  visit_step: continuing(fn(n, _) { n + 1 }),
})

#SAX-Style Handler

///|
struct EventLog {
  events : Array[String]
}

///|
impl GherkinHandler for EventLog with fn on_feature(self, event) {
  self.events.push("feature:\{event.name}")
}

///|
impl GherkinHandler for EventLog with fn on_scenario(self, event) {
  self.events.push("scenario:\{event.name}")
}

///|
impl GherkinHandler for EventLog with fn on_step(self, event) {
  self.events.push("step:\{event.text}")
}

///|
test "log events with a handler" {
  let input =
    #|Feature: Events
    #|  Scenario: Example
    #|    Given a step
    #|    When an action
  let logger : EventLog = { events: [], }
  @gherkin.parse_with_handler(@gherkin.Source::from_string(input), logger)
  @debug.debug_inspect(
    logger.events[0],
    content=(
      #|"feature:Events"
    ),
  )
  @debug.debug_inspect(
    logger.events[1],
    content=(
      #|"scenario:Example"
    ),
  )
  @debug.debug_inspect(
    logger.events[2],
    content=(
      #|"step:a step"
    ),
  )
  @debug.debug_inspect(
    logger.events[3],
    content=(
      #|"step:an action"
    ),
  )
}

#Lexer

///|
test "tokenize a source" {
  let tokens = @gherkin.tokenize(
    @gherkin.Source::from_string("Feature: Test\n  Given a step"),
  )
   tokens[0] is FeatureLine(_, kw, name)
  @debug.debug_inspect(
    kw,
    content=(
      #|"Feature"
    ),
  )
  @debug.debug_inspect(
    name,
    content=(
      #|"Test"
    ),
  )
   tokens[1] is StepLine(_, _, kt, text)
  @debug.debug_inspect(kt, content="Context")
  @debug.debug_inspect(
    text,
    content=(
      #|"a step"
    ),
  )
}

///|
test "lazy iteration with Lexer" {
  let lexer = @gherkin.Lexer::new(
    @gherkin.Source::from_string("Given a\nWhen b\nThen c"),
  )
  let mut count = 0
  for tok in lexer.iter() {
    match tok {
      StepLine(_, _, _, _) => count  1
      _ => ()
    }
  }
  @debug.debug_inspect(count, content="3")
}

#Error Handling

///|
test "handle parse errors" {
  let input =
    #|Feature: Tables
    #|  Scenario: Bad
    #|    Given a table:
    #|      | a | b |
    #|      | 1 | 2 | 3 |
  let result = try {
    let _ = @gherkin.parse(@gherkin.Source::from_string(input))
    "ok"
  } catch {
    InconsistentTableCells(message~, ..) => message
    _ => "other"
  }
  assert_true(result.contains("inconsistent cell count"))
}

#i18n

///|
test "parse French Gherkin" {
  let input =
    #|# language: fr
    #|Fonctionnalité: Connexion
    #|  Scénario: Succès
    #|    Soit un utilisateur
  let doc = @gherkin.parse(@gherkin.Source::from_string(input))
  let feature = doc.feature.unwrap()
  @debug.debug_inspect(
    feature.language,
    content=(
      #|"fr"
    ),
  )
  @debug.debug_inspect(
    feature.keyword,
    content=(
      #|"Fonctionnalité"
    ),
  )
}