Not sure why parser use in test is failing with unexpected end of input

[DamianReeves]

This one has been baffling me.

I am implementing this grammar:

LANGTAG	::=	'@' [a-zA-Z]+ ('-' [a-zA-Z0-9]+)*
EOL	::=	[#xD#xA]+
IRIREF	::=	'<' ([^#x00-#x20<>"{}|^`\] | UCHAR)* '>'
STRING_LITERAL_QUOTE	::=	'"' ([^#x22#x5C#xA#xD] | ECHAR | UCHAR)* '"'
BLANK_NODE_LABEL	::=	'_:' (PN_CHARS_U | [0-9]) ((PN_CHARS | '.')* PN_CHARS)?
UCHAR	::=	'\u' HEX HEX HEX HEX | '\U' HEX HEX HEX HEX HEX HEX HEX HEX
ECHAR	::=	'\' [tbnrf"'\]
PN_CHARS_BASE	::=	[A-Z] | [a-z] | [#x00C0-#x00D6] | [#x00D8-#x00F6] | [#x00F8-#x02FF] | [#x0370-#x037D] | [#x037F-#x1FFF] | [#x200C-#x200D] | [#x2070-#x218F] | [#x2C00-#x2FEF] | [#x3001-#xD7FF] | [#xF900-#xFDCF] | [#xFDF0-#xFFFD] | [#x10000-#xEFFFF]
PN_CHARS_U	::=	PN_CHARS_BASE | '_' | ':'
PN_CHARS	::=	PN_CHARS_U | '-' | [0-9] | #x00B7 | [#x0300-#x036F] | [#x203F-#x2040]
HEX	::=	[0-9] | [A-F] | [a-f]

And my implementation of BLANK_NODE_LABEL seems to not be working correctly because my test is failing saying it is reaching the unexpected end of input (I have the entire scenario as a scastie, linked below).

NOTE: I am using Scala 3

  lazy val BLANK_NODE_LABEL =
    ("_:" ~> PN_LOCAL)

  lazy val ECHAR =
    val backslash = 0x005c
    atomic(uchar(backslash) ~> oneOf('t', 'b', 'n', 'r', 'f', '"', '\'', '\\'))

  lazy val PN_LOCAL =
    val initialChar = PN_CHARS_U | unicode.digit
    val trailingChars = some(PN_CHARS | '.') ~> PN_CHARS | PN_CHARS
    ((initialChar ~> trailingChars) | initialChar).span

  // PN_CHARS_BASE	::=	[A-Z] | [a-z] | [#x00C0-#x00D6] | [#x00D8-#x00F6] | [#x00F8-#x02FF] | [#x0370-#x037D] | [#x037F-#x1FFF] | [#x200C-#x200D] | [#x2070-#x218F] | [#x2C00-#x2FEF] | [#x3001-#xD7FF] | [#xF900-#xFDCF] | [#xFDF0-#xFFFD] | [#x10000-#xEFFFF]
  lazy val PN_CHARS_BASE =
    unicode.upper | unicode.letter | oneOfUnicode(
      0x00c0 to 0x00d6
    ) | oneOfUnicode(0x00d8 to 0x00f6) | oneOfUnicode(
      0x00f8 to 0x02ff
    ) | oneOfUnicode(0x0370 to 0x037d) | oneOfUnicode(
      0x037f to 0x1fff
    ) | oneOfUnicode(0x200c to 0x200d) | oneOfUnicode(
      0x2070 to 0x218f
    ) | oneOfUnicode(0x2c00 to 0x2fef) | oneOfUnicode(
      0x3001 to 0xd7ff
    ) | oneOfUnicode(0xf900 to 0xfdcf) | oneOfUnicode(
      0xfdf0 to 0xfffd
    ) | oneOfUnicode(0x10000 to 0xeffff)

  lazy val PN_CHARS_U = PN_CHARS_BASE | unicode.underscore | unicode.colon

  lazy val PN_CHARS =
    PN_CHARS_U | unicode.minus | unicode.digit | unicode.middot | oneOfUnicode(
      0x0300 to 0x036f
    ) | oneOfUnicode(0x203f to 0x2040)

For the following test:

      test("Should parse a simple BLANK_NODE_LABEL") {
        val input = "_:example "
        val actual = lexer.BLANK_NODE_LABEL.parse(input)
        val expected = Success("example")
        assertTrue(actual == expected)
      }

I get a failure like this:

    - LexerSpec�[2m / BLANK_NODE_LABEL�[2m / Should parse a simple BLANK_NODE_LABEL
      ✗ Failure(
          �[2m = """(line 1, column 10):
            unexpected end of input
            expected \"-\"; \".\"; \":\"; \"_\"; \"·\"; one of \"0\" to \"9\"; one of \"A\" to \"Z\"; one of \"a\" to \"z\"; one of \"À\" to \"Ö\"; one of \"Ø\" to \"ö\"; one of \"ø\" to \"˿\"; one of \"̀\" to \"ͯ\"; one of \"Ͱ\" to \"ͽ\"; one of \"Ϳ\" to non-printable character (\u1fff); one of \"‿\" to \"⁀\"; one of \"⁰\" to non-printable character (\u218f); one of \"Ⰰ\" to non-printable character (\u2fef); one of \"、\" to non-printable character (\ud7ff); one of \"𐀀\" to non-printable codepoint (\udb7f\udfff, or 0x0effff); one of \"豈\" to non-printable character (\ufdcf); one of \"ﷰ\" to \"�\"; or one of non-printable character (\u200c) to non-printable character (\u200d)
            >_:example
                      ^"""
        ) was not equal to Success(�[2mx = "example")
      actual == expected
      �[2mactual = Failure(
        �[2m = """(line 1, column 10):
          unexpected end of input
          expected \"-\"; \".\"; \":\"; \"_\"; \"·\"; one of \"0\" to \"9\"; one of \"A\" to \"Z\"; one of \"a\" to \"z\"; one of \"À\" to \"Ö\"; one of \"Ø\" to \"ö\"; one of \"ø\" to \"˿\"; one of \"̀\" to \"ͯ\"; one of \"Ͱ\" to \"ͽ\"; one of \"Ϳ\" to non-printable character (\u1fff); one of \"‿\" to \"⁀\"; one of \"⁰\" to non-printable character (\u218f); one of \"Ⰰ\" to non-printable character (\u2fef); one of \"、\" to non-printable character (\ud7ff); one of \"𐀀\" to non-printable codepoint (\udb7f\udfff, or 0x0effff); one of \"豈\" to non-printable character (\ufdcf); one of \"ﷰ\" to \"�\"; or one of non-printable character (\u200c) to non-printable character (\u200d)
          >_:example
                    ^"""
      )

You can run the full scenario here: https://scastie.scala-lang.org/DamianReeves/oKZexRVKQASxOjdcXl8pLA/28

[DamianReeves]

Also note, I am trying to incorporate the lexer package and its use, and after I first hit this issue I tried seeing if using lexer.lexeme would help, but that did not work.

[j-mie6]

Recommendation is to use the debug combinator to try and track through exactly what things are getting where. I can probably take a closer look at it a bit later otherwise.

[DamianReeves]

So I was able to figure out that this production:

BLANK_NODE_LABEL	::=	'_:' (PN_CHARS_U | [0-9]) ((PN_CHARS | '.')* PN_CHARS)?

is essentially saying a start prefix followed by a . separated bunch of PN_CHARS. So I switched my implementation to use sepBy and it works now.

[DamianReeves]

Spoke too soon... that didn't fix it