ltrait-source-task 0.1.0

A LTrait source for user defined command
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
115
116
117
118
119

use ltrait::{
    Action, Source,
    color_eyre::eyre::Context as _,
    tokio_stream::{self, StreamExt as _},
};
use serde::Deserialize;
use std::{
    os::unix::process::CommandExt as _,
    path::PathBuf,
    process::{Command, Stdio},
};
use thiserror::Error;

#[derive(Debug, Error)]
pub enum TaskError {
    #[error("Could not find config directory")]
    ConfigDir,
    #[error("failed to read task config file: {0}")]
    ReadTaskFile(#[source] std::io::Error),
    #[error("failed to parse the toml: {0}")]
    Toml(#[source] toml::de::Error),
}

#[derive(Debug, Clone)]
pub struct TaskConfig {
    /// The list of paths to load tasks
    pub path: Vec<PathBuf>,
}

/// The default path is ~/.config/yurf/task.toml
pub fn default_path() -> Result<PathBuf, TaskError> {
    Ok(dirs::config_dir()
        .ok_or(TaskError::ConfigDir)?
        .join("yurf")
        .join("task.toml"))
}

#[derive(Debug, Clone)]
pub struct Task {
    config: TaskConfig,
}

#[derive(Deserialize, Debug, Clone)]
pub struct TaskItem {
    pub name: String,
    /// show only if this command returns 0(exit code).
    /// this command will be executed  when source is evaled.
    ///
    /// the command will be executed as shell command("sh -c")
    pub show_if: Option<String>,
    /// the action will execute this command.
    ///
    /// the command will be executed as shell command("sh -c")
    pub command: String,
}

#[derive(Deserialize, Debug)]
struct TaskFile {
    task: Vec<TaskItem>,
}

impl Task {
    pub fn new(config: TaskConfig) -> Self {
        Self { config }
    }

    pub fn create_source(&self) -> Result<Source<TaskItem>, TaskError> {
        let tasks = self
            .config
            .path
            .clone()
            .into_iter()
            .map(|p| Ok(p))
            .map(|p| p.and_then(|p| std::fs::read_to_string(p).map_err(TaskError::ReadTaskFile)))
            .map(|p| p.and_then(|p| toml::from_str::<TaskFile>(&p).map_err(TaskError::Toml)))
            .map(|p| p.map(|t| t.task))
            .collect::<Result<Vec<_>, _>>()?
            .into_iter()
            .flatten();

        let aiter = tokio_stream::iter(tasks).filter(|c| {
            let cmd = c.show_if.as_ref();
            if let Some(cmd) = cmd {
                Command::new("sh")
                    .arg("-c")
                    .arg(&cmd)
                    .stdin(Stdio::null())
                    .stdout(Stdio::null())
                    .stderr(Stdio::null())
                    .process_group(0)
                    .output()
                    .map(|o| o.status.code() == Some(0))
                    .unwrap_or(false)
            } else {
                true
            }
        });

        Ok(Box::pin(aiter))
    }
}

impl Action for Task {
    type Context = TaskItem;

    fn act(&self, ctx: &Self::Context) -> ltrait::color_eyre::eyre::Result<()> {
        Command::new("sh")
            .arg("-c")
            .arg(&ctx.command)
            .stdin(Stdio::null())
            .stdout(Stdio::null())
            .stderr(Stdio::null())
            .process_group(0)
            .spawn()
            .wrap_err("failed to start the selected app")?;

        Ok(())
    }
}