automatic 0.0.4

automatic run command throw user defined scripts
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
120
121
122
123
124
125
126
127
128

//! Silent run items, no output but aborts if one fail start or fail exit
//!
//! # Example
//!```
//!use automatic::silent_list::SilentList;
//!use automatic::runitem::RunItem;
//!use automatic::run::Run;
//!let items = vec![
//!    RunItem::new("true".to_string(), vec![]),
//!    RunItem::new("true".to_string(), vec![]),
//!    RunItem::new("true".to_string(), vec![]),
//!];
//!
//!let result = SilentList::new(items)
//!    .run()
//!    .status()
//!    .expect("failed to execute process");
//!assert!(result.success());
//!```

use serde::{Deserialize, Serialize};

use crate::run::{ExitStatus, Run, RunStatus};
use crate::runitem::RunItem;

#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
pub struct SilentList {
    items: Vec<RunItem>,
}

impl SilentList {
    pub fn new(items: Vec<RunItem>) -> Self {
        Self { items }
    }

    fn run_internal(&self) -> Result<(), String> {
        for item in self.items.iter() {
            let result = match item.run().status() {
                Err(e) => {
                    return Err(e.to_string());
                }
                Ok(result) => result,
            };

            if !result.success() {
                return Err(format!(
                    "runned item return fail execution state with code: {}",
                    result.code().unwrap()
                ));
            }
        }
        Ok(())
    }
}

struct StatusHelper {}

impl ExitStatus for StatusHelper {}

struct RunItemStatus {
    status: Result<(), String>,
}

impl RunStatus for RunItemStatus {
    fn status(&self) -> Result<Box<dyn ExitStatus>, String> {
        match &self.status {
            Ok(_) => Ok(Box::new(StatusHelper {})),
            Err(e) => Err(e.to_string()),
        }
    }
}

impl Run for SilentList {
    fn run(&self) -> Box<dyn RunStatus> {
        Box::new(RunItemStatus {
            status: self.run_internal(),
        })
    }
}

#[cfg(test)]
mod tests {
    use crate::runitem::RunItem;

    use super::*;

    #[test]
    fn success_run() {
        let items = vec![
            RunItem::new("true".to_string(), vec![]),
            RunItem::new("true".to_string(), vec![]),
            RunItem::new("true".to_string(), vec![]),
        ];

        let result = SilentList::new(items)
            .run()
            .status()
            .expect("failed to execute process");
        assert!(result.success());
    }

    #[test]
    fn fail_run() {
        let items = vec![
            RunItem::new("true".to_string(), vec![]),
            RunItem::new("bla bla".to_string(), vec![]),
            RunItem::new("true".to_string(), vec![]),
        ];

        let runner = SilentList::new(items);
        assert_eq!(
            runner.run().status(),
            Err("No such file or directory (os error 2)".to_string())
        );

        let items = vec![
            RunItem::new("true".to_string(), vec![]),
            RunItem::new("false".to_string(), vec![]),
            RunItem::new("true".to_string(), vec![]),
        ];

        let runner = SilentList::new(items);
        assert_eq!(
            runner.run().status(),
            Err("runned item return fail execution state with code: 1".to_string())
        );
    }
}