This is a small library for generating railroad diagrams (like what JSON.org uses) using SVG, with both JS and Python ports.
Railroad diagrams are a way of visually representing a grammar in a form that is more readable than using regular expressions or BNF. They can easily represent any context-free grammar, and some more powerful grammars. There are several railroad-diagram generators out there, but none of them had the visual appeal I wanted, so I wrote my own.
To use the library, just include the js and css files, and then call the Diagram() function. Its arguments are the components of the diagram (Diagram is a special form of Sequence).
Alternately, you can call ComplexDiagram(); it’s identical to Diagram(), but has slightly different start/end shapes, same as what JSON.org does to distinguish between “leaf” types like number (ordinary Diagram()) and “container” types like Array (ComplexDiagram()).
Components are either leaves or containers.
Sequence(children) - like simple concatenation in a regex.
Stack(children) - identical to a Sequence, but the items are stacked vertically rather than horizontally. Best used when a simple Sequence would be too wide; instead, you can break the items up into a Stack of Sequences of an appropriate width.
OptionalSequence(children) - a Sequence where every item is individually optional, but at least one item must be chosen
Choice(index, children) - like
| in a regex. The index argument specifies which child is the “normal” choice and should go in the middle
MultipleChoice(index, type, children) - like
&& in a CSS grammar; it’s similar to a Choice, but more than one branch can be taken. The index argument specifies which child is the “normal” choice and should go in the middle, while the type argument must be either “any” (1+ branches can be taken) or “all” (all branches must be taken).
HorizontalChoice(children) - Identical to Choice, but the items are stacked horizontally rather than vertically. There’s no “straight-line” choice, so it just takes a list of children. Best used when a simple Choice would be too tall; instead, you can break up the items into a HorizontalChoice of Choices of an appropriate height.
Optional(child, skip) - like
? in a regex. A shorthand for
Choice(1, Skip(), child). If the optional
skip parameter has the value
"skip", it instead puts the Skip() in the straight-line path, for when the “normal” behavior is to omit the item.
OneOrMore(child, repeat) - like
+ in a regex. The ‘repeat’ argument is optional, and specifies something that must go between the repetitions.
ZeroOrMore(child, repeat, skip) - like
* in a regex. A shorthand for
Optional(OneOrMore(child, repeat)). The optional
skip parameter is identical to Optional().
For convenience, each component can be called with or without
If called without
the container components become n-ary;
that is, you can say either
new Sequence([A, B]) or just
After constructing a Diagram, call
.format(...padding) on it, specifying 0-4 padding values (just like CSS) for some additional “breathing space” around the diagram (the paddings default to 20px).
The result can either be
.toString()‘d for the markup, or
.toSVG()‘d for an
<svg> element, which can then be immediately inserted to the document. As a convenience, Diagram also has an
.addTo(element) method, which immediately converts it to SVG and appends it to the referenced element with default paddings.
element defaults to
There are a few options you can tweak, with the defaults at the bottom of the file, and the live values hanging off of the
Diagram object. Just tweak either until the diagram looks like what you want.
You can also change the CSS file - feel free to tweak to your heart’s content.
Note, though, that if you change the text sizes in the CSS,
you’ll have to go adjust the metrics for the leaf nodes as well.
<svg>element of each diagram, for use in the CSS stylesheet.
SVG can’t actually respond to the sizes of content; in particular, there’s no way to make SVG adjust sizing/positioning based on the length of some text. Instead, I guess at some font metrics, which mostly work as long as you’re using a fairly standard monospace font. This works pretty well, but long text inside of a construct might eventually overflow the construct.
In addition to the canonical JS version, the library now exists as a Python library as well.
Using it is basically identical. The config variables are globals in the file, and so may be adjusted either manually or via tweaking from inside your program.
The main difference from the JS port is how you extract the string from the Diagram. You’ll find a
writeSvg(writerFunc) method on
Diagram, which takes a callback of one argument and passes it the string form of the diagram. For example, it can be used like
Diagram(...).writeSvg(sys.stdout.write) to write to stdout. Note: the callback will be called multiple times as it builds up the string, not just once with the whole thing. If you need it all at once, consider something like a
StringIO as an easy way to collect it into a single string.
As well, if you want a “complex” diagram, pass
type="complex" to the
Diagram constructor, rather than using a separate
ComplexDiagram() constructor like in the JS port.
To install the python port, clone this project and
pip install it.
~/> git clone https://github.com/tabatkins/railroad-diagrams.git ~/> cd railroad-diagrams/ ~/railroad-diagrams/> python3 -m pip install .
This document and all associated files in the github project are licensed under CC0 . This means you can reuse, remix, or otherwise appropriate this project for your own use without restriction. (The actual legal meaning can be found at the above link.) Don’t ask me for permission to use any part of this project, just use it. I would appreciate attribution, but that is not required by the license.