mk 0.7.13

Yet another simple task runner 🦀
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

use hashbrown::HashMap;
use schemars::JsonSchema;
use serde::Deserialize;

use crate::utils::resolve_path;

use super::{
  CommandRunner,
  LocalRun,
  Task,
  TaskArgs,
};

#[derive(Debug, Deserialize, JsonSchema)]
pub struct UseCargoArgs {
  /// The working directory to run the command in
  #[serde(default)]
  pub work_dir: Option<String>,
}

#[derive(Debug, Deserialize, JsonSchema)]
#[serde(untagged)]
/// Enable cargo commands as tasks. Either `true` or an object with optional settings.
pub enum UseCargo {
  Bool(bool),
  UseCargo(Box<UseCargoArgs>),
}

impl UseCargo {
  pub fn capture(&self) -> anyhow::Result<HashMap<String, Task>> {
    self.capture_in_dir(std::path::Path::new("."))
  }

  pub fn capture_in_dir(&self, base_dir: &std::path::Path) -> anyhow::Result<HashMap<String, Task>> {
    match self {
      UseCargo::Bool(true) => self.capture_tasks_in_dir(base_dir),
      UseCargo::UseCargo(args) => args.capture_tasks_in_dir(base_dir),
      _ => Ok(HashMap::new()),
    }
  }

  fn capture_tasks_in_dir(&self, base_dir: &std::path::Path) -> anyhow::Result<HashMap<String, Task>> {
    UseCargoArgs { work_dir: None }.capture_tasks_in_dir(base_dir)
  }
}

impl UseCargoArgs {
  pub fn capture_tasks(&self) -> anyhow::Result<HashMap<String, Task>> {
    self.capture_tasks_in_dir(std::path::Path::new("."))
  }

  pub fn capture_tasks_in_dir(&self, base_dir: &std::path::Path) -> anyhow::Result<HashMap<String, Task>> {
    let resolved_work_dir = self
      .work_dir
      .as_ref()
      .map(|work_dir| resolve_path(base_dir, work_dir));
    let cargo_commands = [
      "add",
      "bench",
      "build",
      "check",
      "clean",
      "clippy",
      "doc",
      "fix",
      "fmt",
      "init",
      "install",
      "miri",
      "new",
      "publish",
      "remove",
      "report",
      "run",
      "search",
      "test",
      "uninstall",
      "update",
    ];

    let hm: HashMap<String, Task> = cargo_commands
      .iter()
      .map(|cmd| {
        let command = format!("cargo {}", cmd);
        let task = Task::Task(Box::new(TaskArgs {
          commands: vec![CommandRunner::LocalRun(LocalRun {
            command,
            shell: None,
            test: None,
            work_dir: resolved_work_dir
              .as_ref()
              .map(|work_dir| work_dir.to_string_lossy().into_owned()),
            interactive: Some(true),
            retrigger: None,
            ignore_errors: None,
            save_output_as: None,
            verbose: None,
          })],
          ..Default::default()
        }));
        (cmd.to_string(), task)
      })
      .collect();
    Ok(hm)
  }
}