How to round-trip zero or more newlines?

[danthorpe]

This is probably a stupid and/or rookie question, but I've spent quite a bit of time trying to figure it out, and getting nowhere...

I'm trying to create a Gherkin / Cucumber / BDD parser. For those unfamiliar, that means I have input which looks like...

# Some feature comments
# which can go on multiple lines
Feature: This is a feature

  These are some notes about the feature
  which can also go on multiple lines

  # The first scenario has two steps
  # also multiple lines
  Scenario: This is the first scenario

  These are notes about the scenario
  also multiple lines, although notes are
  optional

    Given some condition is already met
    Then some ability is possible

  # There can be multiple scenarios
  Scenario: This is another scenario
    Given some condition is already met
    When something happens
    Then we expect some change to happen

There can be multiple Steps in a scenario, and multiple Scenarios in a Feature. Oh, and the keywords (feature, scenario, given etc) can be localised.

I am trying to figure out how to parse the steps, and in particular, how to deal with cases where:

1. there is a single newline, because there is another step.
2. there are multiple newlines, because it's the end of the current scenario, but a new scenario starts.
3. there isn't a newline, because it's the end of the input.

I have this KeywordParser,

struct KeywordParser: ParserPrinter {
  private let kind: Keyword.Kind

  init(for kind: Keyword.Kind) {
    self.kind = kind
  }

  var reservedWord: some ParserPrinter<Substring, Substring> {
    OneOf {
      for name in kind.localizedNames.styles {
        OneOf {
          PrefixThrough("\(name)")
        }
      }
    }
  }

  var body: some ParserPrinter<Substring, Keyword> {
    ParsePrint {
      Whitespace(.horizontal)
      reservedWord.map(.string)
      if kind.expectsSuffix {
        ParsePrint { ":" }
      }
      Whitespace(1, .horizontal)
      Prefix { false == $0.isNewline }.map(.string)
      Optionally {
        Prefix { $0.isNewline }.map(.string)
      }
    }
    .map(.keyword(kind)) // there is a conversion for this
  }
}

This can be used to parse input such as:

FEATURE: Some feature title
feature: A different feature title
Scenario: A scenario title
GIVEN some phrase
when some phrase

etc.

What I can't seem to figure out, is how to parse the input after the keyword delimiter to the end of the line which is retained in the model, and then any number of new line characters, or possibly the end of the input.

I tried all sorts combinations of Optionally { } either inside this parser, or inside the separator of a Many { } parser (inside the Scenario Parser). But it seems that it just becomes greedy, and I end up with two steps where the 2nd one parses to the end of input.

Any ideas? Feels like parsing to the end of the line should be a fairly easy and common task, and composing that into a Many should be just as straightforward, no?

Feel like I'm missing something...

[kamcma]

The discussion in #206 may be helpful. Also #341.