wsdl 0.1.3

Idiomatic Rust wrapper for WSDL
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

use clap::{Arg, Command};
use wsdl::WsDefinitions;

fn main() -> anyhow::Result<()> {
    let matches = Command::new("WSDL tree traversal example")
        .args(&[Arg::new("input")
            .num_args(1)
            .required(true)
            .help("Input wsdl file")])
        .get_matches();

    let input = matches.get_one::<String>("input").unwrap();

    let input = std::fs::read_to_string(&input)?;
    let document = roxmltree::Document::parse(&input)?;

    let wsdef = WsDefinitions::from_document(&document)?;
    for service in wsdef.services()? {
        println!("Service: {}", service.name()?);
    }

    for binding in wsdef.bindings()? {
        println!(
            "Binding: {} -> {}",
            binding.name()?,
            binding.port_type()?.name()?
        );
    }

    for port_type in wsdef.port_types()? {
        println!("Port: {}", port_type.name()?);

        for operation in port_type.operations()? {
            println!(
                "  {}({}) -> {}",
                operation.name()?,
                if let Some(input) = operation.input()? {
                    let mut s = String::new();

                    for part in input.parts() {
                        let tn = part.typename()?;
                        let tn = if let Some(ns) = tn.namespace() {
                            format!("`{}:{}`", ns, tn.name())
                        } else {
                            format!("{}", tn.name())
                        };

                        s.push_str(&format!("{}: {}", part.name()?, tn));
                    }

                    s
                } else {
                    "".to_string()
                },
                if let Some(output) = operation.output()? {
                    let part = output.parts().next().ok_or(anyhow::anyhow!(
                        "message {} output had no parameters!",
                        operation.name().unwrap()
                    ))?;

                    let tn = part.typename()?;
                    if let Some(ns) = tn.namespace() {
                        format!("`{}:{}`", ns, tn.name())
                    } else {
                        format!("{}", tn.name())
                    }
                } else {
                    "()".to_string()
                }
            );
        }
    }

    Ok(())
}