regast-cli 0.1.0

Command-line interface for regast
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118

# regast

`regast` is a regular-expression analysis engine for Rust. It exposes a lossless pattern AST and
a complete parse tree for each match, including groups, alternation choices, and repetition
boundaries.

## Features

- Whole-input parsing and leftmost-longest substring search
- Lossless pattern AST with JSON, S-expression, and Graphviz DOT output
- Match parse trees with UTF-8 byte spans and capture-compatible views
- POSIX and greedy/lazy disambiguation
- Brzozowski derivative, Antimirov partial-derivative, and tagged Thompson NFA backends
- Unicode scalar-value literals, dot, character classes, and Perl character classes
- Capturing, named, and non-capturing groups
- Optional, Kleene, plus, and counted repetitions
- Start (`^`) and end (`$`) anchors
- Configurable matching-state limits

Backreferences and lookaround are intentionally unsupported because they are outside the regular
language model used by the engine.

## Requirements

- Rust 1.85 or later
- Rust 2024 edition

## Installation

Until the crates are published on crates.io, add the library from the Git repository:

```toml
[dependencies]
regast = { git = "https://github.com/ydah/regast" }
```

Install the command-line application directly from the repository:

```console
cargo install --git https://github.com/ydah/regast regast-cli
```

## Library usage

```rust
use regast::{Backend, Regast, Span};

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let regex = Regast::builder("(a|b)*c")
        .backend(Backend::TaggedNfa)
        .build()?;

    let tree = regex.parse("abac")?;
    assert_eq!(tree.flatten(), "abac");
    assert_eq!(tree.match_span(), Span::new(0, 4));
    assert_eq!(tree.group_all(1).len(), 3);

    let found = regex.find_parse("zzabac")?.expect("a match");
    assert_eq!(found.flatten(), "abac");
    assert_eq!(found.match_span(), Span::new(2, 6));

    Ok(())
}
```

`parse` requires the complete input to match. `find_parse` returns the leftmost-longest match and
reports spans relative to the original input.

## Matching backends

Select a backend with `Regast::builder(...).backend(...)`:

| Backend | Description |
| --- | --- |
| `Backend::Derivative` | Brzozowski derivatives; the default backend |
| `Backend::Antimirov` | Antimirov partial derivatives |
| `Backend::TaggedNfa` | Provenance-tagged Thompson NFA |

All backends preserve the same public parse-tree and disambiguation semantics. Antimirov and
tagged-NFA parsing reconstruct typed values through a bounded IR chart without falling back to
Brzozowski derivatives.

## Command-line usage

```console
regast ast '(a|b)*c' --format json --shape tree
regast parse '(a|b)*c' abac --format sexpr --posix
regast find '^a|ab+$' zabbb --backend antimirov
regast parse '^([ab]+)$' abba --backend tagged-nfa
regast check 'a+' aaa
regast trace 'a+b' aaab
```

Run `regast --help` or `regast <command> --help` for the complete option reference.

## Workspace

| Crate | Purpose |
| --- | --- |
| `regast` | Public facade and builder API |
| `regast-syntax` | Lossless AST, parser, visitors, and serializers |
| `regast-core` | IR, matching backends, value reconstruction, and parse trees |
| `regast-cli` | Command-line interface |

## Development

```console
cargo test --workspace
cargo test --workspace --release
cargo clippy --workspace --all-targets --all-features -- -D warnings
cargo fmt --all -- --check
```

## License

Licensed under either the
[Apache License, Version 2.0](https://github.com/ydah/regast/blob/main/LICENSE-APACHE) or the
[MIT License](https://github.com/ydah/regast/blob/main/LICENSE-MIT), at your option.