modality 0.1.6

CLI for Modality, an evolving temporal modal logic
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

mod cmds;

use anyhow::Result;
use clap::{Parser, Subcommand};

#[derive(Parser)]
#[command(name = "modality")]
#[command(version = "0.1.4")]
#[command(about = "Modality language and network CLI", long_about = None)]
struct Cli {
    #[command(subcommand)]
    command: Commands,
}

#[derive(Subcommand)]
enum Commands {
    #[command(alias = "identity")]
    #[command(about = "ID related commands")]
    Id {
        #[command(subcommand)]
        command: IdCommands,
    },

    #[command(about = "Passfile related commands")]
    Passfile {
        #[command(subcommand)]
        command: PassfileCommands,
    },

    #[command(alias = "network")]
    #[command(about = "Network related commands")]
    Net {
        #[command(subcommand)]
        command: NetworkCommands,
    },

    #[command(about = "Model related commands")]
    Model {
        #[command(subcommand)]
        command: ModelCommands,
    },
}

#[derive(Subcommand)]
enum IdCommands {
    Create(cmds::id::create::Opts),
}

#[derive(Subcommand)]
enum PassfileCommands {
    Decrypt(cmds::passfile::decrypt::Opts),

    Encrypt(cmds::passfile::encrypt::Opts),
}

#[derive(Subcommand)]
enum NetworkCommands {
    #[command(alias = "run_node")]
    RunNode(cmds::net::run_node::Opts),

    #[clap(name = "ping")]
    Ping(cmds::net::ping::Opts),

    // #[clap(name = "request")]
    // Request(cmds::node::request::Opts)
}

#[derive(Subcommand)]
enum ModelCommands {
    #[command(about = "Generate a Mermaid diagram from a Modality file")]
    Mermaid(cmds::mermaid::Opts),
    
    #[command(about = "Check a formula against a model")]
    Check(cmds::check::Opts),
}

#[tokio::main]
async fn main() -> Result<()> {
    env_logger::Builder::from_env(env_logger::Env::default().default_filter_or("info")).init();

    let cli = Cli::parse();
    match &cli.command {
        Commands::Id { command } => {
            match command {
                IdCommands::Create(opts) => cmds::id::create::run(opts).await?,
            }
        }
        Commands::Passfile { command } => {
            match command {
                PassfileCommands::Decrypt(opts) => cmds::passfile::decrypt::run(opts).await?,
                PassfileCommands::Encrypt(opts) => cmds::passfile::encrypt::run(opts).await?,
            }
        }
        Commands::Net { command } => {
            match command {
                NetworkCommands::RunNode(opts) => cmds::net::run_node::run(opts).await?,
                NetworkCommands::Ping(opts) => cmds::net::ping::run(opts).await?,
            }
        }
        Commands::Model { command } => {
            match command {
                ModelCommands::Mermaid(opts) => cmds::mermaid::run(opts).await?,
                ModelCommands::Check(opts) => cmds::check::run(opts).await?,
            }
        }
    }

    Ok(())
}