fsf 0.1.0

The Fast Shell Finder, find and execute simple to complex commands quickly and easily
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

use directories::ProjectDirs;
use regex::Regex;
use serde::Deserialize;
use skim::SkimItem;
use std::{
    borrow::Cow,
    fs::{self, OpenOptions},
    io::{self, Write},
    path::PathBuf,
    process::Command,
};
use tera::{Context, Tera};

use crate::download_from_url;

#[derive(Debug, Deserialize)]
pub struct LookupVec {
    pub commands: Vec<CommandLookup>,
}

#[derive(Deserialize, Clone, Debug)]
pub struct CommandLookup {
    pub keyword: String,
    pub command: Cmd,
}

#[derive(Clone, Debug)]
pub struct Cmd {
    command: String,
    params: Vec<String>,
}

impl Cmd {
    pub fn render_command(&self) -> String {
        let mut tera = Tera::default();
        println!("Rendering command: {}", self.command);
        println!("Reading params: {:?}", self.params);
        let mut context = Context::new();
        for param in self.params.iter() {
            println!("bruh");
            context.insert(param, &input_prompt(format!("{param}:")));
        }

        tera.render_str(&self.command, &context).unwrap()
    }
}

impl SkimItem for CommandLookup {
    fn text(&self) -> Cow<str> {
        Cow::Borrowed(self.keyword.as_str())
    }
}

impl From<String> for Cmd {
    fn from(command: String) -> Self {
        let re = Regex::new(r"\{\{(\s*\w+\s*)\}\}").unwrap();
        let params = re
            .captures_iter(&command)
            .map(|capture| capture[1].trim().to_string())
            .collect();

        Cmd { command, params }
    }
}

impl<'de> Deserialize<'de> for Cmd {
    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        Ok(String::deserialize(deserializer)?.into())
    }
}

fn deserialize(file: String) -> LookupVec {
    toml::from_str(file.as_str()).unwrap()
}

pub fn get_commands_filepath() -> PathBuf {
    let proj_dirs = ProjectDirs::from("com", "wolfey", "fsf").unwrap();
    let local_data = proj_dirs.data_local_dir();
    let cmds_filepath = local_data.join("default.toml");
    cmds_filepath
}

pub fn get_commands_from_local_data() -> LookupVec {
    let cmds_path = get_commands_filepath();
    let Ok(toml_content) = fs::read_to_string(cmds_path) else {
        download_from_url("https://raw.githubusercontent.com/WolfEYc/fsf/master/cmd/default.toml");
        return get_commands_from_local_data();
    };
    deserialize(toml_content)
}

pub fn write_commands_to_local_data(cmds_toml: &[u8]) {
    let cmds_path = get_commands_filepath();
    println!("{:?}", cmds_path);
    if let Some(parent) = cmds_path.parent() {
        fs::create_dir_all(parent).unwrap();
    }
    let mut file = OpenOptions::new()
        .append(true)
        .create(true)
        .open(cmds_path)
        .unwrap();
    file.write_all(b"\n").unwrap();
    file.write_all(cmds_toml).unwrap();
}

pub fn execute_shell_command(command: &str) {
    println!("Executing CMD: {}", command);
    Command::new("sh").arg("-c").arg(command).spawn().unwrap();
}

pub fn read_line() -> String {
    let mut str = String::new();
    io::stdin().read_line(&mut str).expect("!");
    str
}

pub fn input_prompt(prompt: String) -> String {
    println!("{}", prompt);
    read_line()
}