oak-delphi 0.0.0

High-performance incremental DOT language parser for the oak ecosystem with flexible configuration, optimized for graph description and visualization.
Documentation 
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
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150

# Oak DOT Language Parser


[![Crates.io](https://img.shields.io/crates/v/oak-dot.svg)](https://crates.io/crates/oak-dot)
[![Documentation](https://docs.rs/oak-dot/badge.svg)](https://docs.rs/oak-dot)

High-performance incremental DOT parser for the oak ecosystem with flexible configuration, optimized for graph description and visualization.

## 🎯 Overview


Oak DOT is a robust parser for the DOT graph description language, designed to handle complete DOT syntax including modern features. Built on the solid foundation of oak-core, it provides both high-level convenience and detailed AST generation for graph analysis and visualization.

## ✨ Features


- **Complete DOT Syntax**: Supports all DOT features including modern specifications
- **Full AST Generation**: Generates comprehensive Abstract Syntax Trees
- **Lexer Support**: Built-in tokenization with proper span information
- **Error Recovery**: Graceful handling of syntax errors with detailed diagnostics

## 🚀 Quick Start


Basic example:

```rust
use oak_dot::{Parser, DotLanguage, SourceText};

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let parser = Parser::new();
    let source = SourceText::new(r#"
digraph G {
    A -> B;
    B -> C;
    C -> A;
}
    "#);
    
    let result = parser.parse(&source);
    println!("Parsed DOT graph successfully.");
    Ok(())
}
```

## 📋 Parsing Examples


### Graph Parsing

```rust
use oak_dot::{Parser, DotLanguage, SourceText};

let parser = Parser::new();
let source = SourceText::new(r#"
graph G {
    A -- B -- C;
    A -- C;
}
"#);

let result = parser.parse(&source);
println!("Parsed DOT graph successfully.");
```

### Digraph Parsing

```rust
use oak_dot::{Parser, DotLanguage, SourceText};

let parser = Parser::new();
let source = SourceText::new(r#"
digraph workflow {
    start -> process1;
    process1 -> decision;
    decision -> process2 [label="yes"];
    decision -> end [label="no"];
}
"#);

let result = parser.parse(&source);
println!("Parsed DOT digraph successfully.");
```

## 🔧 Advanced Features


### Token-Level Parsing

```rust
use oak_dot::{Parser, DotLanguage, SourceText};

let parser = Parser::new();
let source = SourceText::new("A -> B [color=red];");
let result = parser.parse(&source);
// Token information is available in the parse result
```

### Error Handling

```rust
use oak_dot::{Parser, DotLanguage, SourceText};

let parser = Parser::new();
let source = SourceText::new(r#"
digraph G {
    A -> B
    B -> C;
    C -> A;
}
"#);

let result = parser.parse(&source);
if let Err(e) = result.result {
    println!("Parse error: {:?}", e);
}
```

## 🏗️ AST Structure


The parser generates a comprehensive AST with the following main structures:

- **Graph**: Root container for undirected graphs
- **Digraph**: Root container for directed graphs
- **Node**: Node definitions with attributes
- **Edge**: Edge definitions with attributes
- **Subgraph**: Nested graph structures
- **Attribute**: Key-value attribute pairs

## 📊 Performance


- **Streaming**: Parse large DOT files without loading entirely into memory
- **Incremental**: Re-parse only changed sections
- **Memory Efficient**: Smart AST node allocation
- **Fast Recovery**: Quick error recovery for better IDE integration

## 🔗 Integration


Oak of dot integrates seamlessly with:

- **Graph Visualization**: Parse DOT files for rendering
- **Graph Analysis**: Analyze graph structures for properties and patterns
- **Code Generation**: Generate DOT files from other data structures
- **IDE Support**: Language server protocol compatibility for DOT
- **Documentation**: Generate documentation from graph definitions

## 📚 Examples


Check out the [examples](examples/) directory for comprehensive examples:

- Complete DOT graph parsing
- Node and edge analysis
- Attribute processing
- Integration with development workflows

## 🤝 Contributing


Contributions are welcome! 

Please feel free to submit pull requests at the [project repository](https://github.com/ygg-lang/oaks/tree/dev/examples/oak-delphi) or open [issues](https://github.com/ygg-lang/oaks/issues).