abnf 0.13.0

A nom-based parser for ABNF.
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

//! This example shows how to use the `abnf` crate to create a dependency graph of `Rule`s.

use std::env::args;

use abnf::{
    rulelist,
    types::{Node, Rule},
};

/// A type which implements this trait is able to report on what rules it "depends" on.
/// For simplicity, the dependencies are just a vector of strings here.
trait Dependencies {
    /// Obtain a list of all rulenames.
    fn calc_dependencies(&self) -> Vec<String>;
}

impl Dependencies for Rule {
    fn calc_dependencies(&self) -> Vec<String> {
        self.node().calc_dependencies()
    }
}

impl Dependencies for Node {
    fn calc_dependencies(&self) -> Vec<String> {
        match self {
            // If we are a set of alternatives or a concatenation,
            // collect the dependencies of all alternatives/concatenated elements.
            Node::Alternatives(nodes) | Node::Concatenation(nodes) => {
                let mut ret_val = Vec::new();
                for node in nodes {
                    for dep in node.calc_dependencies() {
                        if !ret_val.contains(&dep) {
                            ret_val.push(dep);
                        }
                    }
                }
                ret_val
            }
            Node::Group(node) | Node::Optional(node) => node.calc_dependencies(),
            Node::Repetition { node, .. } => node.calc_dependencies(),
            Node::Rulename(name) => vec![name.to_owned()],
            Node::TerminalValues(_) | Node::String(_) | Node::Prose(_) => vec![],
        }
    }
}

fn print_gml(rules: Vec<Rule>) {
    println!("graph [");

    for rule in rules.iter() {
        println!("\tnode [id \"{}\" label \"{}\"]", rule.name(), rule.name());
    }

    for rule in rules.iter() {
        for dep in rule.calc_dependencies() {
            if [
                "ALPHA", "BIT", "CHAR", "CR", "CRLF", "CTL", "DIGIT", "DQUOTE", "HEXDIG", "HTAB",
                "LF", "LWSP", "OCTET", "SP", "VCHAR", "WSP",
            ]
            .contains(&&dep[..])
            {
                continue;
            }

            println!("\tedge [source \"{}\" target \"{}\"]", rule.name(), dep);
        }
    }

    println!("]");
}

fn print_gv(rules: Vec<Rule>) {
    println!("digraph {{");
    println!("\tcompound=true;");
    println!("\toverlap=scalexy;");
    println!("\tsplines=true;");
    println!("\tlayout=neato;\n");
    for rule in rules.iter() {
        let name = rule.name().to_owned().replace("-", "_");
        let deps = rule
            .calc_dependencies()
            .iter()
            .map(|name| name.replace("-", "_"))
            .collect::<Vec<_>>();

        println!("\t{} -> {{{}}}", name, deps.join(" "));
    }
    println!("}}");
}

fn main() -> std::io::Result<()> {
    let rules = {
        let data =
            std::fs::read_to_string(args().nth(1).expect("USAGE: dependencies file [gml|gv]"))?;

        rulelist(&data).unwrap_or_else(|e| {
            println!("{}", e);
            std::process::exit(1);
        })
    };

    let format = args().nth(2).unwrap_or(String::from("gml"));

    match format.as_ref() {
        "gml" => print_gml(rules),
        "gv" => print_gv(rules),
        other => {
            eprintln!("Unknown format \"{}\". Try \"gml\" or \"gv\".", other);
            std::process::exit(1);
        }
    }

    Ok(())
}