orphist 0.3.0

a command-line interface for orphism
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

mod analyze;
mod caff;
mod load;

#[derive(Debug, Clone, clap::Parser)]
#[remain::sorted]
pub struct Command {
  #[arg(long, value_name = "LEVEL", default_value = "info")]
  pub log_level: LogLevel,
  #[command(subcommand)]
  subcommand: Subcommand,
}

#[derive(Debug, Clone, clap::Subcommand)]
enum Subcommand {
  Analyze(analyze::Analyze),
  Caff(caff::Caff),
  Load(load::Load),
}

impl Command {
  pub fn execute(self) -> anyhow::Result<()> {
    let Self { subcommand, .. } = self;

    match subcommand {
      Subcommand::Analyze(command) => command.execute(),
      Subcommand::Caff(command) => command.execute(),
      Subcommand::Load(command) => command.execute(),
    }
  }
}

#[derive(Debug, Clone, Copy, clap::ValueEnum)]
#[remain::sorted]
pub enum LogLevel {
  Debug,
  Error,
  Info,
  Trace,
  Warn,
}

impl From<LogLevel> for log::Level {
  #[remain::check]
  fn from(level: LogLevel) -> Self {
    #[remain::sorted]
    match level {
      LogLevel::Debug => Self::Debug,
      LogLevel::Error => Self::Error,
      LogLevel::Info => Self::Info,
      LogLevel::Trace => Self::Trace,
      LogLevel::Warn => Self::Warn,
    }
  }
}

impl From<LogLevel> for log::LevelFilter {
  fn from(level: LogLevel) -> Self {
    log::Level::from(level).to_level_filter()
  }
}

impl From<LogLevel> for simple_logger::SimpleLogger {
  fn from(level: LogLevel) -> Self {
    let level = level.into();
    Self::new().with_level(level)
  }
}