Struct DAG 

pub struct DAG<'a> { /* private fields */ }

A Directed Acyclic Graph (DAG) with ASCII rendering capabilities.

Examples

use ascii_dag::graph::DAG;

let mut dag = DAG::new();
dag.add_node(1, "Start");
dag.add_node(2, "End");
dag.add_edge(1, 2);

let output = dag.render();
assert!(output.contains("Start"));
assert!(output.contains("End"));

Implementations

impl<'a> DAG<'a>

pub fn has_cycle(&self) -> bool

Check if the graph contains cycles (making it not a valid DAG).

Examples

use ascii_dag::graph::DAG;

let mut dag = DAG::new();
dag.add_node(1, "A");
dag.add_node(2, "B");
dag.add_edge(1, 2);
dag.add_edge(2, 1);  // Creates a cycle!

assert!(dag.has_cycle());

Examples found in repository

examples/error_chain.rs (line 47)

fn main() {
    println!("=== Error Chain Visualization ===\n");

    // Simulate an error dependency chain
    // FileNotFound -> ParseError -> CompilationFailed -> BuildFailed

    let mut dag = DAG::new();

    dag.add_node(1, "FileNotFound");
    dag.add_node(2, "ParseError");
    dag.add_node(3, "CompilationFailed");
    dag.add_node(4, "BuildFailed");

    dag.add_edge(1, 2); // FileNotFound caused ParseError
    dag.add_edge(2, 3); // ParseError caused CompilationFailed
    dag.add_edge(3, 4); // CompilationFailed caused BuildFailed

    println!("Error Dependency Chain:");
    println!("{}", dag.render());

    // More complex error scenario
    println!("\n=== Complex Error Scenario ===\n");

    let dag = DAG::from_edges(
        &[
            (1, "ConfigMissing"),
            (2, "DBConnFail"),
            (3, "AuthFail"),
            (4, "InitError"),
            (5, "StartupFail"),
        ],
        &[
            (1, 2), // ConfigMissing -> DBConnFail
            (1, 3), // ConfigMissing -> AuthFail
            (2, 4), // DBConnFail -> InitError
            (3, 4), // AuthFail -> InitError
            (4, 5), // InitError -> StartupFail
        ],
    );

    println!("Multiple Error Paths:");
    println!("{}", dag.render());

    // Check for cycles (should not have any)
    if dag.has_cycle() {
        println!("\n⚠️  WARNING: Circular error dependency detected!");
    } else {
        println!("\n✓ No circular dependencies");
    }
}

impl<'a> DAG<'a>

pub fn new() -> Self

Create a new empty DAG.

Examples

use ascii_dag::graph::DAG;
let dag = DAG::new();

Examples found in repository

examples/test_promotion.rs (line 4)

fn main() {
    let mut dag = DAG::new();

    println!("=== Test: Auto-created Node Promotion ===\n");

    dag.add_node(1, "Start");
    dag.add_edge(1, 2); // Auto-creates node 2

    println!("Before promotion (node 2 is auto-created):");
    println!("{}\n", dag.render());

    // Now promote node 2
    dag.add_node(2, "Promoted");

    println!("After promotion (node 2 now has label 'Promoted'):");
    println!("{}\n", dag.render());

    println!("✓ Node 2 successfully promoted from ⟨2⟩ to [Promoted]");
}

examples/basic.rs (line 21)

fn main() {
    println!("=== Basic Usage Examples ===\n");

    // Example 1: Simple chain
    println!("1. Simple Chain (A -> B -> C):");
    let dag = DAG::from_edges(&[(1, "A"), (2, "B"), (3, "C")], &[(1, 2), (2, 3)]);
    println!("{}\n", dag.render());

    // Example 2: Diamond pattern
    println!("2. Diamond Pattern:");
    let dag = DAG::from_edges(
        &[(1, "Root"), (2, "Left"), (3, "Right"), (4, "Merge")],
        &[(1, 2), (1, 3), (2, 4), (3, 4)],
    );
    println!("{}\n", dag.render());

    // Example 3: Builder API
    println!("3. Builder API:");
    let mut dag = DAG::new();
    dag.add_node(1, "Parse");
    dag.add_node(2, "Compile");
    dag.add_node(3, "Link");
    dag.add_edge(1, 2);
    dag.add_edge(2, 3);
    println!("{}\n", dag.render());

    // Example 4: Multi-convergence
    println!("4. Multi-Convergence:");
    let dag = DAG::from_edges(
        &[(1, "E1"), (2, "E2"), (3, "E3"), (4, "Final")],
        &[(1, 4), (2, 4), (3, 4)],
    );
    println!("{}\n", dag.render());
}

examples/skewed_children.rs (line 6)

fn main() {
    // Create a graph where a level's children are clustered on opposite sides
    // This tests that nodes are rendered in x-coordinate order (left-to-right)
    let mut dag = DAG::new();

    // Level 0: Root nodes
    dag.add_node(1, "LeftRoot");
    dag.add_node(2, "RightRoot");

    // Level 1: Middle nodes - initially in median order
    dag.add_node(3, "A");
    dag.add_node(4, "B");
    dag.add_node(5, "C");

    // Level 2: Children clustered on opposite sides
    // LeftRoot connects to far-right children
    dag.add_edge(1, 6);
    dag.add_edge(1, 7);

    // RightRoot connects to far-left children
    dag.add_edge(2, 8);
    dag.add_edge(2, 9);

    // Middle nodes connect normally
    dag.add_edge(3, 6);
    dag.add_edge(4, 8);
    dag.add_edge(5, 9);

    dag.add_node(6, "X");
    dag.add_node(7, "Y");
    dag.add_node(8, "P");
    dag.add_node(9, "Q");

    println!("{}", dag.render());

    println!("\n--- Analysis ---");
    println!("Level 0: LeftRoot should be on left, RightRoot on right");
    println!("Level 2: Nodes should be ordered left-to-right by their x-coordinates");
    println!("Spacing should always appear before the correct node, not after");
}

examples/test_skewed.rs (line 4)

fn main() {
    let mut dag = DAG::new();

    dag.add_node(1, "L");
    dag.add_node(2, "R");
    dag.add_node(3, "X");
    dag.add_node(4, "Y");

    // Create skewed children: L connects to rightmost, R connects to leftmost
    dag.add_edge(1, 4); // L -> Y (right child)
    dag.add_edge(2, 3); // R -> X (left child)

    let output = dag.render();
    println!("{}", output);

    // Find line positions of each node
    let lines: Vec<&str> = output.lines().collect();
    for (idx, line) in lines.iter().enumerate() {
        println!("Line {}: '{}'", idx, line);
    }

    let find_node = |name: &str| -> (usize, usize) {
        for (line_idx, line) in lines.iter().enumerate() {
            if let Some(col) = line.find(name) {
                return (line_idx, col);
            }
        }
        panic!("Node {} not found", name);
    };

    let (l_line, l_col) = find_node("[L]");
    let (r_line, r_col) = find_node("[R]");
    let (x_line, x_col) = find_node("[X]");
    let (y_line, y_col) = find_node("[Y]");

    println!("\nPositions:");
    println!("L: line {}, col {}", l_line, l_col);
    println!("R: line {}, col {}", r_line, r_col);
    println!("X: line {}, col {}", x_line, x_col);
    println!("Y: line {}, col {}", y_line, y_col);
}

examples/cycles.rs (line 8)

fn main() {
    println!("=== Cycle Detection Examples ===\n");

    // Example 1: Simple cycle A → B → C → A
    println!("1. Simple Cycle (A → B → C → A):");
    let mut dag = DAG::new();
    dag.add_node(1, "A");
    dag.add_node(2, "B");
    dag.add_node(3, "C");
    dag.add_edge(1, 2); // A → B
    dag.add_edge(2, 3); // B → C
    dag.add_edge(3, 1); // C → A (creates cycle!)

    println!("{}\n", dag.render());

    // Example 2: Self-referencing cycle
    println!("2. Self-Reference (A → A):");
    let mut dag = DAG::new();
    dag.add_node(1, "SelfRef");
    dag.add_edge(1, 1); // Points to itself

    println!("{}\n", dag.render());

    // Example 3: Longer cycle chain
    println!("3. Longer Cycle (E1 → E2 → E3 → E4 → E2):");
    let mut dag = DAG::new();
    dag.add_node(1, "Error1");
    dag.add_node(2, "Error2");
    dag.add_node(3, "Error3");
    dag.add_node(4, "Error4");
    dag.add_edge(1, 2); // E1 → E2
    dag.add_edge(2, 3); // E2 → E3
    dag.add_edge(3, 4); // E3 → E4
    dag.add_edge(4, 2); // E4 → E2 (cycle!)

    println!("{}\n", dag.render());

    // Example 4: Valid DAG (no cycle)
    println!("4. Valid DAG - No Cycle:");
    let dag = DAG::from_edges(
        &[(1, "Valid1"), (2, "Valid2"), (3, "Valid3")],
        &[(1, 2), (2, 3)],
    );

    println!("{}", dag.render());
}

examples/cross_level.rs (line 12)

fn main() {
    println!("=== Cross-Level Edge Examples ===\n");

    // Example 1: Simple cross-level edge
    println!("1. Simple cross-level (Root -> Middle -> End, plus Root -> End directly):");
    let mut dag = DAG::new();
    dag.add_node(1, "Root");
    dag.add_node(2, "Middle");
    dag.add_node(3, "End");

    dag.add_edge(1, 2); // Root -> Middle
    dag.add_edge(2, 3); // Middle -> End
    dag.add_edge(1, 3); // Root -> End (cross-level!)

    println!("{}\n", dag.render());

    // Example 2: Multiple cross-level edges
    println!("2. Multiple cross-level edges:");
    let mut dag = DAG::new();
    dag.add_node(1, "A");
    dag.add_node(2, "B");
    dag.add_node(3, "C");
    dag.add_node(4, "D");

    dag.add_edge(1, 2); // Level 0 -> 1
    dag.add_edge(2, 3); // Level 1 -> 2
    dag.add_edge(3, 4); // Level 2 -> 3
    dag.add_edge(1, 4); // Level 0 -> 3 (cross-level!)

    println!("{}\n", dag.render());

    // Example 3: Complex with multiple paths
    println!("3. Complex graph with shortcuts:");
    let mut dag = DAG::new();
    dag.add_node(1, "Start");
    dag.add_node(2, "Parse");
    dag.add_node(3, "Compile");
    dag.add_node(4, "Link");
    dag.add_node(5, "Done");

    dag.add_edge(1, 2); // Normal flow
    dag.add_edge(2, 3);
    dag.add_edge(3, 4);
    dag.add_edge(4, 5);
    dag.add_edge(1, 5); // Direct shortcut from Start to Done!

    println!("{}\n", dag.render());
}

Additional examples can be found in:

• examples/error_chain.rs
• examples/auto_creation.rs
• examples/cross_level_test.rs
• examples/performance_test.rs
• examples/dependency_analysis.rs
• examples/stress_test.rs

pub fn from_edges(nodes: &[(usize, &'a str)], edges: &[(usize, usize)]) -> Self

Create a DAG from pre-defined nodes and edges (batch construction).

This is more efficient than using the builder API for static graphs.

Examples

use ascii_dag::graph::DAG;

let dag = DAG::from_edges(
    &[(1, "A"), (2, "B"), (3, "C")],
    &[(1, 2), (2, 3)]
);

Examples found in repository

examples/minimal.rs (line 4)

fn main() {
    let dag = DAG::from_edges(&[(1, "A"), (2, "B"), (3, "C")], &[(1, 2), (2, 3)]);

    println!("{}", dag.render());
}

examples/basic.rs (line 8)

fn main() {
    println!("=== Basic Usage Examples ===\n");

    // Example 1: Simple chain
    println!("1. Simple Chain (A -> B -> C):");
    let dag = DAG::from_edges(&[(1, "A"), (2, "B"), (3, "C")], &[(1, 2), (2, 3)]);
    println!("{}\n", dag.render());

    // Example 2: Diamond pattern
    println!("2. Diamond Pattern:");
    let dag = DAG::from_edges(
        &[(1, "Root"), (2, "Left"), (3, "Right"), (4, "Merge")],
        &[(1, 2), (1, 3), (2, 4), (3, 4)],
    );
    println!("{}\n", dag.render());

    // Example 3: Builder API
    println!("3. Builder API:");
    let mut dag = DAG::new();
    dag.add_node(1, "Parse");
    dag.add_node(2, "Compile");
    dag.add_node(3, "Link");
    dag.add_edge(1, 2);
    dag.add_edge(2, 3);
    println!("{}\n", dag.render());

    // Example 4: Multi-convergence
    println!("4. Multi-Convergence:");
    let dag = DAG::from_edges(
        &[(1, "E1"), (2, "E2"), (3, "E3"), (4, "Final")],
        &[(1, 4), (2, 4), (3, 4)],
    );
    println!("{}\n", dag.render());
}

examples/parallel_test.rs (lines 7-22)

fn main() {
    println!("=== Testing Parallel Chains ===\n");

    // Two independent chains
    let dag = DAG::from_edges(
        &[
            (1, "Chain1-A"),
            (2, "Chain1-B"),
            (3, "Chain1-C"),
            (4, "Chain2-A"),
            (5, "Chain2-B"),
            (6, "Chain2-C"),
        ],
        &[
            (1, 2),
            (2, 3), // Chain 1
            (4, 5),
            (5, 6), // Chain 2 (no connection to chain 1)
        ],
    );

    println!("Two parallel chains:");
    println!("{}", dag.render());

    // Three independent chains
    let dag = DAG::from_edges(
        &[
            (1, "A1"),
            (2, "A2"),
            (3, "B1"),
            (4, "B2"),
            (5, "C1"),
            (6, "C2"),
        ],
        &[(1, 2), (3, 4), (5, 6)],
    );

    println!("\nThree parallel chains:");
    println!("{}", dag.render());

    // Single chain (control)
    let dag = DAG::from_edges(&[(1, "X"), (2, "Y"), (3, "Z")], &[(1, 2), (2, 3)]);

    println!("\nSingle chain (control):");
    println!("{}", dag.render());
}

examples/cycles.rs (lines 42-45)

fn main() {
    println!("=== Cycle Detection Examples ===\n");

    // Example 1: Simple cycle A → B → C → A
    println!("1. Simple Cycle (A → B → C → A):");
    let mut dag = DAG::new();
    dag.add_node(1, "A");
    dag.add_node(2, "B");
    dag.add_node(3, "C");
    dag.add_edge(1, 2); // A → B
    dag.add_edge(2, 3); // B → C
    dag.add_edge(3, 1); // C → A (creates cycle!)

    println!("{}\n", dag.render());

    // Example 2: Self-referencing cycle
    println!("2. Self-Reference (A → A):");
    let mut dag = DAG::new();
    dag.add_node(1, "SelfRef");
    dag.add_edge(1, 1); // Points to itself

    println!("{}\n", dag.render());

    // Example 3: Longer cycle chain
    println!("3. Longer Cycle (E1 → E2 → E3 → E4 → E2):");
    let mut dag = DAG::new();
    dag.add_node(1, "Error1");
    dag.add_node(2, "Error2");
    dag.add_node(3, "Error3");
    dag.add_node(4, "Error4");
    dag.add_edge(1, 2); // E1 → E2
    dag.add_edge(2, 3); // E2 → E3
    dag.add_edge(3, 4); // E3 → E4
    dag.add_edge(4, 2); // E4 → E2 (cycle!)

    println!("{}\n", dag.render());

    // Example 4: Valid DAG (no cycle)
    println!("4. Valid DAG - No Cycle:");
    let dag = DAG::from_edges(
        &[(1, "Valid1"), (2, "Valid2"), (3, "Valid3")],
        &[(1, 2), (2, 3)],
    );

    println!("{}", dag.render());
}

examples/error_chain.rs (lines 26-41)

fn main() {
    println!("=== Error Chain Visualization ===\n");

    // Simulate an error dependency chain
    // FileNotFound -> ParseError -> CompilationFailed -> BuildFailed

    let mut dag = DAG::new();

    dag.add_node(1, "FileNotFound");
    dag.add_node(2, "ParseError");
    dag.add_node(3, "CompilationFailed");
    dag.add_node(4, "BuildFailed");

    dag.add_edge(1, 2); // FileNotFound caused ParseError
    dag.add_edge(2, 3); // ParseError caused CompilationFailed
    dag.add_edge(3, 4); // CompilationFailed caused BuildFailed

    println!("Error Dependency Chain:");
    println!("{}", dag.render());

    // More complex error scenario
    println!("\n=== Complex Error Scenario ===\n");

    let dag = DAG::from_edges(
        &[
            (1, "ConfigMissing"),
            (2, "DBConnFail"),
            (3, "AuthFail"),
            (4, "InitError"),
            (5, "StartupFail"),
        ],
        &[
            (1, 2), // ConfigMissing -> DBConnFail
            (1, 3), // ConfigMissing -> AuthFail
            (2, 4), // DBConnFail -> InitError
            (3, 4), // AuthFail -> InitError
            (4, 5), // InitError -> StartupFail
        ],
    );

    println!("Multiple Error Paths:");
    println!("{}", dag.render());

    // Check for cycles (should not have any)
    if dag.has_cycle() {
        println!("\n⚠️  WARNING: Circular error dependency detected!");
    } else {
        println!("\n✓ No circular dependencies");
    }
}

examples/stress_test.rs (lines 8-22)

fn main() {
    println!("=== Stress Test: Breaking the Renderer ===\n");

    // Test 1: Very long vs very short labels
    println!("1. Mixed Label Lengths:");
    let dag = DAG::from_edges(
        &[
            (1, "A"),
            (2, "VeryVeryVeryLongErrorNameThatShouldBreakAlignment"),
            (3, "B"),
            (4, "AnotherExtremelyLongDiagnosticMessageHere"),
            (5, "C"),
        ],
        &[
            (1, 2), // Short -> Long
            (2, 3), // Long -> Short
            (3, 4), // Short -> Long
            (4, 5), // Long -> Short
        ],
    );
    println!("{}\n", dag.render());

    // Test 2: Extreme convergence (many -> one)
    println!("2. Extreme Convergence (10 errors -> 1):");
    let mut dag = DAG::new();
    dag.add_node(1, "E1");
    dag.add_node(2, "E2");
    dag.add_node(3, "E3");
    dag.add_node(4, "E4");
    dag.add_node(5, "E5");
    dag.add_node(6, "E6");
    dag.add_node(7, "E7");
    dag.add_node(8, "E8");
    dag.add_node(9, "E9");
    dag.add_node(10, "E10");
    dag.add_node(11, "Final");

    for i in 1..=10 {
        dag.add_edge(i, 11);
    }
    println!("{}\n", dag.render());

    // Test 3: Extreme divergence (one -> many)
    println!("3. Extreme Divergence (1 -> 8):");
    let dag = DAG::from_edges(
        &[
            (1, "Root"),
            (2, "Child1"),
            (3, "Child2"),
            (4, "Child3"),
            (5, "Child4"),
            (6, "Child5"),
            (7, "Child6"),
            (8, "Child7"),
            (9, "Child8"),
        ],
        &[
            (1, 2),
            (1, 3),
            (1, 4),
            (1, 5),
            (1, 6),
            (1, 7),
            (1, 8),
            (1, 9),
        ],
    );
    println!("{}\n", dag.render());

    // Test 4: Complex multi-layer DAG
    println!("4. Complex Multi-Layer DAG:");
    let dag = DAG::from_edges(
        &[
            (1, "L1A"),
            (2, "L1B"),
            (3, "L1C"), // Layer 1: 3 nodes
            (4, "L2A"),
            (5, "L2B"), // Layer 2: 2 nodes
            (6, "L3A"),
            (7, "L3B"),
            (8, "L3C"),   // Layer 3: 3 nodes
            (9, "Final"), // Layer 4: 1 node
        ],
        &[
            // Layer 1 -> Layer 2
            (1, 4),
            (2, 4),
            (3, 5),
            // Layer 2 -> Layer 3
            (4, 6),
            (4, 7),
            (5, 7),
            (5, 8),
            // Layer 3 -> Layer 4
            (6, 9),
            (7, 9),
            (8, 9),
        ],
    );
    println!("{}\n", dag.render());

    // Test 5: Single character labels
    println!("5. Single Character Labels:");
    let dag = DAG::from_edges(
        &[(1, "A"), (2, "B"), (3, "C"), (4, "D"), (5, "E")],
        &[(1, 3), (2, 3), (3, 4), (3, 5)],
    );
    println!("{}\n", dag.render());

    // Test 6: Empty label (edge case)
    println!("6. Empty/Minimal Labels:");
    let dag = DAG::from_edges(&[(1, ""), (2, "X"), (3, "")], &[(1, 2), (2, 3)]);
    println!("{}\n", dag.render());

    // Test 7: Unicode in labels
    println!("7. Unicode Characters in Labels:");
    let dag = DAG::from_edges(
        &[(1, "🔴 Error"), (2, "⚠️ Warning"), (3, "✓ Fixed")],
        &[(1, 2), (2, 3)],
    );
    println!("{}\n", dag.render());

    // Test 8: Mixed long and short with convergence
    println!("8. Mixed Lengths + Convergence:");
    let dag = DAG::from_edges(
        &[
            (1, "ShortError1"),
            (2, "ThisIsAnExtremelyLongErrorMessageThatGoesOnAndOn"),
            (3, "Err3"),
            (4, "AnotherVeryLongDiagnosticNameHereForTesting"),
            (5, "Result"),
        ],
        &[(1, 5), (2, 5), (3, 5), (4, 5)],
    );
    println!("{}\n", dag.render());

    // Test 9: Deep nesting
    println!("9. Deep Nesting (10 levels):");
    let dag = DAG::from_edges(
        &[
            (1, "Level1"),
            (2, "Level2"),
            (3, "Level3"),
            (4, "Level4"),
            (5, "Level5"),
            (6, "Level6"),
            (7, "Level7"),
            (8, "Level8"),
            (9, "Level9"),
            (10, "Level10"),
        ],
        &[
            (1, 2),
            (2, 3),
            (3, 4),
            (4, 5),
            (5, 6),
            (6, 7),
            (7, 8),
            (8, 9),
            (9, 10),
        ],
    );
    println!("{}\n", dag.render());

    // Test 10: Wide graph (5 parallel chains)
    println!("10. Wide Graph (5 parallel chains):");
    let dag = DAG::from_edges(
        &[
            (1, "C0L0"),
            (2, "C0L1"),
            (3, "C0L2"),
            (4, "C1L0"),
            (5, "C1L1"),
            (6, "C1L2"),
            (7, "C2L0"),
            (8, "C2L1"),
            (9, "C2L2"),
            (10, "C3L0"),
            (11, "C3L1"),
            (12, "C3L2"),
            (13, "C4L0"),
            (14, "C4L1"),
            (15, "C4L2"),
        ],
        &[
            (1, 2),
            (2, 3),
            (4, 5),
            (5, 6),
            (7, 8),
            (8, 9),
            (10, 11),
            (11, 12),
            (13, 14),
            (14, 15),
        ],
    );
    println!("{}\n", dag.render());

    // Test 11: Diamond within diamond
    println!("11. Diamond within Diamond:");
    let dag = DAG::from_edges(
        &[
            (1, "Root"),
            (2, "L1"),
            (3, "R1"),
            (4, "L2"),
            (5, "R2"),
            (6, "L3"),
            (7, "R3"),
            (8, "Merge1"),
            (9, "Merge2"),
        ],
        &[
            (1, 2),
            (1, 3), // Root splits
            (2, 4),
            (2, 5), // Left splits
            (3, 6),
            (3, 7), // Right splits
            (4, 8),
            (5, 8), // Left converges
            (6, 9),
            (7, 9), // Right converges
        ],
    );
    println!("{}\n", dag.render());

    println!("=== Stress Test Complete ===");
}

pub fn set_render_mode(&mut self, mode: RenderMode)

Set the rendering mode.

Examples

use ascii_dag::graph::{DAG, RenderMode};

let mut dag = DAG::new();
dag.set_render_mode(RenderMode::Horizontal);

pub fn with_mode(mode: RenderMode) -> Self

Create a DAG with a specific render mode.

Examples

use ascii_dag::graph::{DAG, RenderMode};

let dag = DAG::with_mode(RenderMode::Horizontal);

pub fn add_node(&mut self, id: usize, label: &'a str)

Add a node to the DAG.

If the node was previously auto-created by add_edge, this will promote it by setting its label and removing the auto-created flag.

Examples

use ascii_dag::graph::DAG;

let mut dag = DAG::new();
dag.add_node(1, "MyNode");

Examples found in repository

examples/test_promotion.rs (line 8)

fn main() {
    let mut dag = DAG::new();

    println!("=== Test: Auto-created Node Promotion ===\n");

    dag.add_node(1, "Start");
    dag.add_edge(1, 2); // Auto-creates node 2

    println!("Before promotion (node 2 is auto-created):");
    println!("{}\n", dag.render());

    // Now promote node 2
    dag.add_node(2, "Promoted");

    println!("After promotion (node 2 now has label 'Promoted'):");
    println!("{}\n", dag.render());

    println!("✓ Node 2 successfully promoted from ⟨2⟩ to [Promoted]");
}

examples/basic.rs (line 22)

fn main() {
    println!("=== Basic Usage Examples ===\n");

    // Example 1: Simple chain
    println!("1. Simple Chain (A -> B -> C):");
    let dag = DAG::from_edges(&[(1, "A"), (2, "B"), (3, "C")], &[(1, 2), (2, 3)]);
    println!("{}\n", dag.render());

    // Example 2: Diamond pattern
    println!("2. Diamond Pattern:");
    let dag = DAG::from_edges(
        &[(1, "Root"), (2, "Left"), (3, "Right"), (4, "Merge")],
        &[(1, 2), (1, 3), (2, 4), (3, 4)],
    );
    println!("{}\n", dag.render());

    // Example 3: Builder API
    println!("3. Builder API:");
    let mut dag = DAG::new();
    dag.add_node(1, "Parse");
    dag.add_node(2, "Compile");
    dag.add_node(3, "Link");
    dag.add_edge(1, 2);
    dag.add_edge(2, 3);
    println!("{}\n", dag.render());

    // Example 4: Multi-convergence
    println!("4. Multi-Convergence:");
    let dag = DAG::from_edges(
        &[(1, "E1"), (2, "E2"), (3, "E3"), (4, "Final")],
        &[(1, 4), (2, 4), (3, 4)],
    );
    println!("{}\n", dag.render());
}

examples/skewed_children.rs (line 9)

fn main() {
    // Create a graph where a level's children are clustered on opposite sides
    // This tests that nodes are rendered in x-coordinate order (left-to-right)
    let mut dag = DAG::new();

    // Level 0: Root nodes
    dag.add_node(1, "LeftRoot");
    dag.add_node(2, "RightRoot");

    // Level 1: Middle nodes - initially in median order
    dag.add_node(3, "A");
    dag.add_node(4, "B");
    dag.add_node(5, "C");

    // Level 2: Children clustered on opposite sides
    // LeftRoot connects to far-right children
    dag.add_edge(1, 6);
    dag.add_edge(1, 7);

    // RightRoot connects to far-left children
    dag.add_edge(2, 8);
    dag.add_edge(2, 9);

    // Middle nodes connect normally
    dag.add_edge(3, 6);
    dag.add_edge(4, 8);
    dag.add_edge(5, 9);

    dag.add_node(6, "X");
    dag.add_node(7, "Y");
    dag.add_node(8, "P");
    dag.add_node(9, "Q");

    println!("{}", dag.render());

    println!("\n--- Analysis ---");
    println!("Level 0: LeftRoot should be on left, RightRoot on right");
    println!("Level 2: Nodes should be ordered left-to-right by their x-coordinates");
    println!("Spacing should always appear before the correct node, not after");
}

examples/test_skewed.rs (line 6)

fn main() {
    let mut dag = DAG::new();

    dag.add_node(1, "L");
    dag.add_node(2, "R");
    dag.add_node(3, "X");
    dag.add_node(4, "Y");

    // Create skewed children: L connects to rightmost, R connects to leftmost
    dag.add_edge(1, 4); // L -> Y (right child)
    dag.add_edge(2, 3); // R -> X (left child)

    let output = dag.render();
    println!("{}", output);

    // Find line positions of each node
    let lines: Vec<&str> = output.lines().collect();
    for (idx, line) in lines.iter().enumerate() {
        println!("Line {}: '{}'", idx, line);
    }

    let find_node = |name: &str| -> (usize, usize) {
        for (line_idx, line) in lines.iter().enumerate() {
            if let Some(col) = line.find(name) {
                return (line_idx, col);
            }
        }
        panic!("Node {} not found", name);
    };

    let (l_line, l_col) = find_node("[L]");
    let (r_line, r_col) = find_node("[R]");
    let (x_line, x_col) = find_node("[X]");
    let (y_line, y_col) = find_node("[Y]");

    println!("\nPositions:");
    println!("L: line {}, col {}", l_line, l_col);
    println!("R: line {}, col {}", r_line, r_col);
    println!("X: line {}, col {}", x_line, x_col);
    println!("Y: line {}, col {}", y_line, y_col);
}

examples/cycles.rs (line 9)

fn main() {
    println!("=== Cycle Detection Examples ===\n");

    // Example 1: Simple cycle A → B → C → A
    println!("1. Simple Cycle (A → B → C → A):");
    let mut dag = DAG::new();
    dag.add_node(1, "A");
    dag.add_node(2, "B");
    dag.add_node(3, "C");
    dag.add_edge(1, 2); // A → B
    dag.add_edge(2, 3); // B → C
    dag.add_edge(3, 1); // C → A (creates cycle!)

    println!("{}\n", dag.render());

    // Example 2: Self-referencing cycle
    println!("2. Self-Reference (A → A):");
    let mut dag = DAG::new();
    dag.add_node(1, "SelfRef");
    dag.add_edge(1, 1); // Points to itself

    println!("{}\n", dag.render());

    // Example 3: Longer cycle chain
    println!("3. Longer Cycle (E1 → E2 → E3 → E4 → E2):");
    let mut dag = DAG::new();
    dag.add_node(1, "Error1");
    dag.add_node(2, "Error2");
    dag.add_node(3, "Error3");
    dag.add_node(4, "Error4");
    dag.add_edge(1, 2); // E1 → E2
    dag.add_edge(2, 3); // E2 → E3
    dag.add_edge(3, 4); // E3 → E4
    dag.add_edge(4, 2); // E4 → E2 (cycle!)

    println!("{}\n", dag.render());

    // Example 4: Valid DAG (no cycle)
    println!("4. Valid DAG - No Cycle:");
    let dag = DAG::from_edges(
        &[(1, "Valid1"), (2, "Valid2"), (3, "Valid3")],
        &[(1, 2), (2, 3)],
    );

    println!("{}", dag.render());
}

examples/cross_level.rs (line 13)

fn main() {
    println!("=== Cross-Level Edge Examples ===\n");

    // Example 1: Simple cross-level edge
    println!("1. Simple cross-level (Root -> Middle -> End, plus Root -> End directly):");
    let mut dag = DAG::new();
    dag.add_node(1, "Root");
    dag.add_node(2, "Middle");
    dag.add_node(3, "End");

    dag.add_edge(1, 2); // Root -> Middle
    dag.add_edge(2, 3); // Middle -> End
    dag.add_edge(1, 3); // Root -> End (cross-level!)

    println!("{}\n", dag.render());

    // Example 2: Multiple cross-level edges
    println!("2. Multiple cross-level edges:");
    let mut dag = DAG::new();
    dag.add_node(1, "A");
    dag.add_node(2, "B");
    dag.add_node(3, "C");
    dag.add_node(4, "D");

    dag.add_edge(1, 2); // Level 0 -> 1
    dag.add_edge(2, 3); // Level 1 -> 2
    dag.add_edge(3, 4); // Level 2 -> 3
    dag.add_edge(1, 4); // Level 0 -> 3 (cross-level!)

    println!("{}\n", dag.render());

    // Example 3: Complex with multiple paths
    println!("3. Complex graph with shortcuts:");
    let mut dag = DAG::new();
    dag.add_node(1, "Start");
    dag.add_node(2, "Parse");
    dag.add_node(3, "Compile");
    dag.add_node(4, "Link");
    dag.add_node(5, "Done");

    dag.add_edge(1, 2); // Normal flow
    dag.add_edge(2, 3);
    dag.add_edge(3, 4);
    dag.add_edge(4, 5);
    dag.add_edge(1, 5); // Direct shortcut from Start to Done!

    println!("{}\n", dag.render());
}

Additional examples can be found in:

• examples/error_chain.rs
• examples/auto_creation.rs
• examples/cross_level_test.rs
• examples/performance_test.rs
• examples/dependency_analysis.rs
• examples/stress_test.rs

pub fn add_edge(&mut self, from: usize, to: usize)

Add an edge from one node to another.

If either node doesn’t exist, it will be auto-created as a placeholder. You can later call add_node to provide a label for auto-created nodes.

Examples

use ascii_dag::graph::DAG;

let mut dag = DAG::new();
dag.add_node(1, "A");
dag.add_node(2, "B");
dag.add_edge(1, 2);  // A -> B

Examples found in repository

examples/test_promotion.rs (line 9)

fn main() {
    let mut dag = DAG::new();

    println!("=== Test: Auto-created Node Promotion ===\n");

    dag.add_node(1, "Start");
    dag.add_edge(1, 2); // Auto-creates node 2

    println!("Before promotion (node 2 is auto-created):");
    println!("{}\n", dag.render());

    // Now promote node 2
    dag.add_node(2, "Promoted");

    println!("After promotion (node 2 now has label 'Promoted'):");
    println!("{}\n", dag.render());

    println!("✓ Node 2 successfully promoted from ⟨2⟩ to [Promoted]");
}

examples/basic.rs (line 25)

fn main() {
    println!("=== Basic Usage Examples ===\n");

    // Example 1: Simple chain
    println!("1. Simple Chain (A -> B -> C):");
    let dag = DAG::from_edges(&[(1, "A"), (2, "B"), (3, "C")], &[(1, 2), (2, 3)]);
    println!("{}\n", dag.render());

    // Example 2: Diamond pattern
    println!("2. Diamond Pattern:");
    let dag = DAG::from_edges(
        &[(1, "Root"), (2, "Left"), (3, "Right"), (4, "Merge")],
        &[(1, 2), (1, 3), (2, 4), (3, 4)],
    );
    println!("{}\n", dag.render());

    // Example 3: Builder API
    println!("3. Builder API:");
    let mut dag = DAG::new();
    dag.add_node(1, "Parse");
    dag.add_node(2, "Compile");
    dag.add_node(3, "Link");
    dag.add_edge(1, 2);
    dag.add_edge(2, 3);
    println!("{}\n", dag.render());

    // Example 4: Multi-convergence
    println!("4. Multi-Convergence:");
    let dag = DAG::from_edges(
        &[(1, "E1"), (2, "E2"), (3, "E3"), (4, "Final")],
        &[(1, 4), (2, 4), (3, 4)],
    );
    println!("{}\n", dag.render());
}

examples/skewed_children.rs (line 19)

fn main() {
    // Create a graph where a level's children are clustered on opposite sides
    // This tests that nodes are rendered in x-coordinate order (left-to-right)
    let mut dag = DAG::new();

    // Level 0: Root nodes
    dag.add_node(1, "LeftRoot");
    dag.add_node(2, "RightRoot");

    // Level 1: Middle nodes - initially in median order
    dag.add_node(3, "A");
    dag.add_node(4, "B");
    dag.add_node(5, "C");

    // Level 2: Children clustered on opposite sides
    // LeftRoot connects to far-right children
    dag.add_edge(1, 6);
    dag.add_edge(1, 7);

    // RightRoot connects to far-left children
    dag.add_edge(2, 8);
    dag.add_edge(2, 9);

    // Middle nodes connect normally
    dag.add_edge(3, 6);
    dag.add_edge(4, 8);
    dag.add_edge(5, 9);

    dag.add_node(6, "X");
    dag.add_node(7, "Y");
    dag.add_node(8, "P");
    dag.add_node(9, "Q");

    println!("{}", dag.render());

    println!("\n--- Analysis ---");
    println!("Level 0: LeftRoot should be on left, RightRoot on right");
    println!("Level 2: Nodes should be ordered left-to-right by their x-coordinates");
    println!("Spacing should always appear before the correct node, not after");
}

examples/test_skewed.rs (line 12)

fn main() {
    let mut dag = DAG::new();

    dag.add_node(1, "L");
    dag.add_node(2, "R");
    dag.add_node(3, "X");
    dag.add_node(4, "Y");

    // Create skewed children: L connects to rightmost, R connects to leftmost
    dag.add_edge(1, 4); // L -> Y (right child)
    dag.add_edge(2, 3); // R -> X (left child)

    let output = dag.render();
    println!("{}", output);

    // Find line positions of each node
    let lines: Vec<&str> = output.lines().collect();
    for (idx, line) in lines.iter().enumerate() {
        println!("Line {}: '{}'", idx, line);
    }

    let find_node = |name: &str| -> (usize, usize) {
        for (line_idx, line) in lines.iter().enumerate() {
            if let Some(col) = line.find(name) {
                return (line_idx, col);
            }
        }
        panic!("Node {} not found", name);
    };

    let (l_line, l_col) = find_node("[L]");
    let (r_line, r_col) = find_node("[R]");
    let (x_line, x_col) = find_node("[X]");
    let (y_line, y_col) = find_node("[Y]");

    println!("\nPositions:");
    println!("L: line {}, col {}", l_line, l_col);
    println!("R: line {}, col {}", r_line, r_col);
    println!("X: line {}, col {}", x_line, x_col);
    println!("Y: line {}, col {}", y_line, y_col);
}

examples/cycles.rs (line 12)

fn main() {
    println!("=== Cycle Detection Examples ===\n");

    // Example 1: Simple cycle A → B → C → A
    println!("1. Simple Cycle (A → B → C → A):");
    let mut dag = DAG::new();
    dag.add_node(1, "A");
    dag.add_node(2, "B");
    dag.add_node(3, "C");
    dag.add_edge(1, 2); // A → B
    dag.add_edge(2, 3); // B → C
    dag.add_edge(3, 1); // C → A (creates cycle!)

    println!("{}\n", dag.render());

    // Example 2: Self-referencing cycle
    println!("2. Self-Reference (A → A):");
    let mut dag = DAG::new();
    dag.add_node(1, "SelfRef");
    dag.add_edge(1, 1); // Points to itself

    println!("{}\n", dag.render());

    // Example 3: Longer cycle chain
    println!("3. Longer Cycle (E1 → E2 → E3 → E4 → E2):");
    let mut dag = DAG::new();
    dag.add_node(1, "Error1");
    dag.add_node(2, "Error2");
    dag.add_node(3, "Error3");
    dag.add_node(4, "Error4");
    dag.add_edge(1, 2); // E1 → E2
    dag.add_edge(2, 3); // E2 → E3
    dag.add_edge(3, 4); // E3 → E4
    dag.add_edge(4, 2); // E4 → E2 (cycle!)

    println!("{}\n", dag.render());

    // Example 4: Valid DAG (no cycle)
    println!("4. Valid DAG - No Cycle:");
    let dag = DAG::from_edges(
        &[(1, "Valid1"), (2, "Valid2"), (3, "Valid3")],
        &[(1, 2), (2, 3)],
    );

    println!("{}", dag.render());
}

examples/cross_level.rs (line 17)

fn main() {
    println!("=== Cross-Level Edge Examples ===\n");

    // Example 1: Simple cross-level edge
    println!("1. Simple cross-level (Root -> Middle -> End, plus Root -> End directly):");
    let mut dag = DAG::new();
    dag.add_node(1, "Root");
    dag.add_node(2, "Middle");
    dag.add_node(3, "End");

    dag.add_edge(1, 2); // Root -> Middle
    dag.add_edge(2, 3); // Middle -> End
    dag.add_edge(1, 3); // Root -> End (cross-level!)

    println!("{}\n", dag.render());

    // Example 2: Multiple cross-level edges
    println!("2. Multiple cross-level edges:");
    let mut dag = DAG::new();
    dag.add_node(1, "A");
    dag.add_node(2, "B");
    dag.add_node(3, "C");
    dag.add_node(4, "D");

    dag.add_edge(1, 2); // Level 0 -> 1
    dag.add_edge(2, 3); // Level 1 -> 2
    dag.add_edge(3, 4); // Level 2 -> 3
    dag.add_edge(1, 4); // Level 0 -> 3 (cross-level!)

    println!("{}\n", dag.render());

    // Example 3: Complex with multiple paths
    println!("3. Complex graph with shortcuts:");
    let mut dag = DAG::new();
    dag.add_node(1, "Start");
    dag.add_node(2, "Parse");
    dag.add_node(3, "Compile");
    dag.add_node(4, "Link");
    dag.add_node(5, "Done");

    dag.add_edge(1, 2); // Normal flow
    dag.add_edge(2, 3);
    dag.add_edge(3, 4);
    dag.add_edge(4, 5);
    dag.add_edge(1, 5); // Direct shortcut from Start to Done!

    println!("{}\n", dag.render());
}

Additional examples can be found in:

• examples/error_chain.rs
• examples/auto_creation.rs
• examples/cross_level_test.rs
• examples/performance_test.rs
• examples/dependency_analysis.rs
• examples/stress_test.rs

pub fn estimate_size(&self) -> usize

Estimate the buffer size needed for rendering.

Use this to pre-allocate a buffer for render_to.

Examples

use ascii_dag::graph::DAG;

let dag = DAG::from_edges(
    &[(1, "A"), (2, "B")],
    &[(1, 2)]
);

let size = dag.estimate_size();
let mut buffer = String::with_capacity(size);
dag.render_to(&mut buffer);

impl<'a> DAG<'a>

pub fn render(&self) -> String

Render the DAG to an ASCII string.

Examples

use ascii_dag::graph::DAG;

let dag = DAG::from_edges(
    &[(1, "Start"), (2, "End")],
    &[(1, 2)]
);

let output = dag.render();
println!("{}", output);

Examples found in repository

examples/minimal.rs (line 6)

fn main() {
    let dag = DAG::from_edges(&[(1, "A"), (2, "B"), (3, "C")], &[(1, 2), (2, 3)]);

    println!("{}", dag.render());
}

examples/test_promotion.rs (line 12)

fn main() {
    let mut dag = DAG::new();

    println!("=== Test: Auto-created Node Promotion ===\n");

    dag.add_node(1, "Start");
    dag.add_edge(1, 2); // Auto-creates node 2

    println!("Before promotion (node 2 is auto-created):");
    println!("{}\n", dag.render());

    // Now promote node 2
    dag.add_node(2, "Promoted");

    println!("After promotion (node 2 now has label 'Promoted'):");
    println!("{}\n", dag.render());

    println!("✓ Node 2 successfully promoted from ⟨2⟩ to [Promoted]");
}

examples/basic.rs (line 9)

fn main() {
    println!("=== Basic Usage Examples ===\n");

    // Example 1: Simple chain
    println!("1. Simple Chain (A -> B -> C):");
    let dag = DAG::from_edges(&[(1, "A"), (2, "B"), (3, "C")], &[(1, 2), (2, 3)]);
    println!("{}\n", dag.render());

    // Example 2: Diamond pattern
    println!("2. Diamond Pattern:");
    let dag = DAG::from_edges(
        &[(1, "Root"), (2, "Left"), (3, "Right"), (4, "Merge")],
        &[(1, 2), (1, 3), (2, 4), (3, 4)],
    );
    println!("{}\n", dag.render());

    // Example 3: Builder API
    println!("3. Builder API:");
    let mut dag = DAG::new();
    dag.add_node(1, "Parse");
    dag.add_node(2, "Compile");
    dag.add_node(3, "Link");
    dag.add_edge(1, 2);
    dag.add_edge(2, 3);
    println!("{}\n", dag.render());

    // Example 4: Multi-convergence
    println!("4. Multi-Convergence:");
    let dag = DAG::from_edges(
        &[(1, "E1"), (2, "E2"), (3, "E3"), (4, "Final")],
        &[(1, 4), (2, 4), (3, 4)],
    );
    println!("{}\n", dag.render());
}

examples/parallel_test.rs (line 25)

fn main() {
    println!("=== Testing Parallel Chains ===\n");

    // Two independent chains
    let dag = DAG::from_edges(
        &[
            (1, "Chain1-A"),
            (2, "Chain1-B"),
            (3, "Chain1-C"),
            (4, "Chain2-A"),
            (5, "Chain2-B"),
            (6, "Chain2-C"),
        ],
        &[
            (1, 2),
            (2, 3), // Chain 1
            (4, 5),
            (5, 6), // Chain 2 (no connection to chain 1)
        ],
    );

    println!("Two parallel chains:");
    println!("{}", dag.render());

    // Three independent chains
    let dag = DAG::from_edges(
        &[
            (1, "A1"),
            (2, "A2"),
            (3, "B1"),
            (4, "B2"),
            (5, "C1"),
            (6, "C2"),
        ],
        &[(1, 2), (3, 4), (5, 6)],
    );

    println!("\nThree parallel chains:");
    println!("{}", dag.render());

    // Single chain (control)
    let dag = DAG::from_edges(&[(1, "X"), (2, "Y"), (3, "Z")], &[(1, 2), (2, 3)]);

    println!("\nSingle chain (control):");
    println!("{}", dag.render());
}

examples/skewed_children.rs (line 36)

fn main() {
    // Create a graph where a level's children are clustered on opposite sides
    // This tests that nodes are rendered in x-coordinate order (left-to-right)
    let mut dag = DAG::new();

    // Level 0: Root nodes
    dag.add_node(1, "LeftRoot");
    dag.add_node(2, "RightRoot");

    // Level 1: Middle nodes - initially in median order
    dag.add_node(3, "A");
    dag.add_node(4, "B");
    dag.add_node(5, "C");

    // Level 2: Children clustered on opposite sides
    // LeftRoot connects to far-right children
    dag.add_edge(1, 6);
    dag.add_edge(1, 7);

    // RightRoot connects to far-left children
    dag.add_edge(2, 8);
    dag.add_edge(2, 9);

    // Middle nodes connect normally
    dag.add_edge(3, 6);
    dag.add_edge(4, 8);
    dag.add_edge(5, 9);

    dag.add_node(6, "X");
    dag.add_node(7, "Y");
    dag.add_node(8, "P");
    dag.add_node(9, "Q");

    println!("{}", dag.render());

    println!("\n--- Analysis ---");
    println!("Level 0: LeftRoot should be on left, RightRoot on right");
    println!("Level 2: Nodes should be ordered left-to-right by their x-coordinates");
    println!("Spacing should always appear before the correct node, not after");
}

examples/test_skewed.rs (line 15)

fn main() {
    let mut dag = DAG::new();

    dag.add_node(1, "L");
    dag.add_node(2, "R");
    dag.add_node(3, "X");
    dag.add_node(4, "Y");

    // Create skewed children: L connects to rightmost, R connects to leftmost
    dag.add_edge(1, 4); // L -> Y (right child)
    dag.add_edge(2, 3); // R -> X (left child)

    let output = dag.render();
    println!("{}", output);

    // Find line positions of each node
    let lines: Vec<&str> = output.lines().collect();
    for (idx, line) in lines.iter().enumerate() {
        println!("Line {}: '{}'", idx, line);
    }

    let find_node = |name: &str| -> (usize, usize) {
        for (line_idx, line) in lines.iter().enumerate() {
            if let Some(col) = line.find(name) {
                return (line_idx, col);
            }
        }
        panic!("Node {} not found", name);
    };

    let (l_line, l_col) = find_node("[L]");
    let (r_line, r_col) = find_node("[R]");
    let (x_line, x_col) = find_node("[X]");
    let (y_line, y_col) = find_node("[Y]");

    println!("\nPositions:");
    println!("L: line {}, col {}", l_line, l_col);
    println!("R: line {}, col {}", r_line, r_col);
    println!("X: line {}, col {}", x_line, x_col);
    println!("Y: line {}, col {}", y_line, y_col);
}

Additional examples can be found in:

• examples/cycles.rs
• examples/cross_level.rs
• examples/error_chain.rs
• examples/auto_creation.rs
• examples/cross_level_test.rs
• examples/performance_test.rs
• examples/dependency_analysis.rs
• examples/stress_test.rs

pub fn render_to(&self, output: &mut String)

Render the DAG into a provided buffer (zero-allocation).

Examples

use ascii_dag::graph::DAG;

let dag = DAG::from_edges(
    &[(1, "A")],
    &[]
);

let mut buffer = String::new();
dag.render_to(&mut buffer);
assert!(!buffer.is_empty());

Trait Implementations

impl<'a> Clone for DAG<'a>

fn clone(&self) -> DAG<'a>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<'a> Default for DAG<'a>

fn default() -> Self

Returns the “default value” for a type.