Help with Parsing Issue in Custom Diagramming DSL

[zekenie]

I'm working a "hello world" type project as part of my evaluation of ohm for something bigger. I'm getting a little tripped up with some newline behavior and I wonder if anyone has any insight.

Here's my grammar:

DiagramDSL {
  Program   = (NodeDefinition | EdgeDefinition)*
  NodeDefinition = "node" ident NodeListOptional
  NodeListOptional = ("{" NodeList "}")?
  NodeList  = NodeDefinition*
  EdgeDefinition = FullIdent "->" FullIdent

  FullIdent = identPart+
  identPart = ident | "."  // Allows any combination of letters and dots
  ident     = letter (letter | digit | ".")*  // A simple identifier for nodes

  ws        = (~endOfLine any)*  // Define whitespace to include any non-newline characters
  endOfLine = "\\n"    
}

The following program works

node sports {
  node baseball
  node football
  node soccer
}

node ball

node shapes {
  node sphere
}

sports.baseball -> ball

I get the following json

[
  {
    "type": "node",
    "name": "sports",
    "children": [
      [
        {
          "type": "node",
          "name": "baseball",
          "children": []
        },
        {
          "type": "node",
          "name": "football",
          "children": []
        },
        {
          "type": "node",
          "name": "soccer",
          "children": []
        }
      ]
    ]
  },
  {
    "type": "node",
    "name": "ball",
    "children": []
  },
  {
    "type": "node",
    "name": "shapes",
    "children": [
      [
        {
          "type": "node",
          "name": "sphere",
          "children": []
        }
      ]
    ]
  },
  {
    "type": "edge",
    "from": "sports.baseball",
    "to": "ball"
  }
]

But when I add a few more edges to my example

sports.football -> ball
sports.soccer -> ball

ball -> shapes.sphere

I get the following error

Parsing failed: Line 15, col 17:
  14 | sports.baseball -> ball
> 15 | sports.football -> ball
                       ^
  16 | sports.soccer -> ball
Expected end of input, ".", a letter, or "node"

Apologies if this is a simple problem! My full program is below.

Program

import * as ohm from "ohm-js";

const grammar = ohm.grammar(`
DiagramDSL {
  Program   = (NodeDefinition | EdgeDefinition)*
  NodeDefinition = "node" ident NodeListOptional
  NodeListOptional = ("{" NodeList "}")?
  NodeList  = NodeDefinition*
  EdgeDefinition = FullIdent "->" FullIdent

  FullIdent = identPart+
  identPart = ident | "."  // Allows any combination of letters and dots
  ident     = letter (letter | digit | ".")*  // A simple identifier for nodes

  ws        = (~endOfLine any)*  // Define whitespace to include any non-newline characters
  endOfLine = "\\n"    
}
`);

const semantics = grammar.createSemantics().addOperation("toAST", {
  Program(statements) {
    return statements.children.map((s) => s.toAST());
  },
  NodeDefinition(_node, ident, nodeListOptional) {
    return {
      type: "node",
      name: ident.sourceString,
      children: nodeListOptional ? nodeListOptional.toAST() : [],
    };
  },
  NodeListOptional(bracket, content, endBracket) {
    return content.children.map((n) => n.toAST()); // Ensuring it processes the contents within curly braces
  },
  NodeList(nodeDefinitions) {
    return nodeDefinitions.children.map((nd) => nd.toAST());
  },
  EdgeDefinition(source, _arrow, target) {
    return {
      type: "edge",
      from: source.toAST(),
      to: target.toAST(),
    };
  },
  FullIdent(parts) {
    return parts.children.map((p) => p.sourceString).join("");
  },
  ident(_first, _rest) {
    return this.sourceString;
  },
  _iter(...nodes) {
    return nodes.map((node) => node.toAST());
  },
  _terminal() {
    return this.sourceString;
  },
});

const input = `
node sports {
  node baseball
  node football
  node soccer
}

node ball

node shapes {
  node sphere
}

sports.baseball -> ball
sports.football -> ball
sports.soccer -> ball

ball -> shapes.sphere
`;

const match = grammar.match(input);
if (match.succeeded()) {
  const ast = semantics(match).toAST();
  console.log(JSON.stringify(ast, null, 2));
} else {
  console.error("Parsing failed:", match.message);
}

[evilguest]

The problem is in casing of the name of the rule FullIdent. The capital "F" instructs Ohm to ignore the whitespace when concatenating the identPart fragments. Therefore when it parses this fragment:

sports.football -> ball
sports.soccer -> ball

it sees it as an EdgeDefinition consisting of sports.football, ->, and ball\r\nsports.soccer. Then it tries to parse the rest, -> ball, and fails since neither NodeDefinition nor EdgeDefinition can start with ->.
Simple solution is to rename the rule into fullIdent. It will cause Ohm to stop grabbing the identParts after the first whitespace.
However, this will break parsing of the following program (if it was expected to succeed) (note the whitespace):

sports. baseball -> ball

If you want to permit arbitrary whitespace within the compound identifiers, then you would have to disambiguate this. The most straightforward way to resolve this would be to prohibit sequential dots (sports..baseball):

FullIdent = ListOf<identPart, ".">

P.S. https://ohmjs.org/editor is a great tool to debug your grammar