limp 0.2.1

effortless project initialization and dependency management
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

use std::{
    fs::{self, File},
    io::Write,
    path::{Path, PathBuf},
    process::Stdio,
};

use crate::{error::LimpError, parser::load_from_deps, storage::JsonDependency};

const MAIN_SNIP: &str = r#"fn main() {
    println!("Hello, limp!");
}"#;

pub fn username() -> String {
    std::env::var("USER").unwrap_or(std::env::var("USERNAME").unwrap_or("unknown".to_string()))
}

pub fn storage_path() -> PathBuf {
    let uname = username();

    match std::env::consts::OS {
        "windows" => PathBuf::from(format!("C:\\Users\\{}\\AppData\\Roaming\\limp", &uname)),
        _ => PathBuf::from(format!("/home/{}/.config/limp/", &uname)),
    }
}

pub fn config_path() -> PathBuf {
    storage_path().join("dependencies.json")
}

pub fn snippets_dir() -> PathBuf {
    storage_path().join("snippets")
}

pub fn find_toml() -> Option<PathBuf> {
    if let Ok(mut path) = std::env::current_dir() {
        let pre_toml = path.join("Cargo.toml");
        if pre_toml.exists() {
            return Some(pre_toml);
        }
        while path.pop() {
            let pre_toml = path.join("Cargo.toml");
            if pre_toml.exists() {
                return Some(pre_toml);
            }
        }
        return None;
    }
    None
}

pub fn open<P: AsRef<Path>>(path: P) -> Result<File, LimpError> {
    let path = path.as_ref();
    fs::create_dir_all(path.parent().unwrap_or(Path::new("./")))?;
    let file = File::options()
        .read(true)
        .append(true)
        .create(true)
        .open(path)?;
    Ok(file)
}

pub fn add_to_snippets_dir(name: &str, content: &str) -> Result<String, LimpError> {
    let path = snippets_dir().join(format!("{name}.rs"));
    if path.exists() {
        return Err(LimpError::SnippetExists(name.to_string()));
    }
    let mut file = open(&path)?;
    file.write_all(content.as_bytes())?;
    Ok(path.display().to_string())
}

pub fn remove_from_snippets_dir(name: &str) -> Result<(), LimpError> {
    let path = snippets_dir().join(format!("{name}.rs"));
    if !path.exists() {
        // This means the snippet doesn't provided by the user and nothing to remove
        return Ok(());
    }
    fs::remove_file(path)?;
    Ok(())
}

pub fn create_project(name: &str, deps: Option<&[JsonDependency]>) -> Result<(), LimpError> {
    let project = PathBuf::from(format!("./{}", name));
    if project.exists() && project.read_dir()?.count() > 0 {
        return Err(LimpError::CrateExistsNotEmpty(name.to_string()));
    }

    let mut main_snippet = MAIN_SNIP.to_string();
    let mut toml = open(project.join("Cargo.toml"))?;
    writeln!(toml, "[package]")?;
    writeln!(toml, "name = \"{}\"", name)?;
    writeln!(toml, "version = \"0.1.0\"")?;
    writeln!(toml, "edition = \"2021\"")?;
    writeln!(toml)?;
    writeln!(toml, "[dependencies]")?;
    if let Some(deps) = deps {
        for dep in deps.iter() {
            writeln!(toml, "{}", dep)?
        }
        main_snippet = load_from_deps(deps).unwrap_or(MAIN_SNIP.to_string());
    }

    let mut main = open(project.join("src").join("main.rs"))?;
    main.write_all(main_snippet.as_bytes())?;

    if !std::process::Command::new("git")
        .args(["init", name])
        .stdout(Stdio::null())
        .stderr(Stdio::null())
        .spawn()?
        .wait()?
        .success()
    {
        return Err(LimpError::GitError(name.to_string()));
    }
    let mut gitignore = open(project.join(".gitignore"))?;
    gitignore.write_all(b"/target")?;

    Ok(())
}