projkt 0.2.1

Generate project related stuffs such as .gitignore, license, readme and more 
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

use std::{fs::OpenOptions, path::PathBuf};

use crate::plugins::{
    types::{Plugin, ProjktResult},
    utils::{fuzzy, write_or_create, FuzzyItemType},
};

pub struct ReadmeOptions {
    pub name: Option<String>,
    pub overwrite: bool,
}

pub struct Readme;

impl From<FuzzyItemType> for clap::PossibleValue<'_> {
    fn from(t: FuzzyItemType) -> Self {
        clap::PossibleValue::new(Box::leak(Box::from(t.0.as_str())))
    }
}

pub fn templates() -> Vec<FuzzyItemType> {
    vec![
        FuzzyItemType(
            "makeareadme".into(),
            include_str!("templates/makeareadme.md").into(),
        ),
        FuzzyItemType(
            "othneildrew".into(),
            include_str!("templates/othneildrew.md").into(),
        ),
        FuzzyItemType(
            "readmeso".into(),
            include_str!("templates/readmeso.md").into(),
        ),
        FuzzyItemType(
            "embarkstudios".into(),
            include_str!("templates/embarkstudios.md").into(),
        ),
        FuzzyItemType("simple".into(), include_str!("templates/simple.md").into()),
    ]
}

impl Plugin for Readme {
    type Opts = ReadmeOptions;
    type Fetch = Vec<FuzzyItemType>;

    fn fetch(_: &Self::Opts) -> ProjktResult<Self::Fetch> {
        Ok(templates())
    }

    fn exec(opts: Self::Opts) -> ProjktResult<()> {
        let templates = Self::fetch(&opts)?;

        let Self::Opts {
            ref name,
            overwrite,
        } = opts;

        let write = |data| -> ProjktResult<()> {
            write_or_create(
                OpenOptions::new().write(true).create(true),
                PathBuf::from("README.md"),
                data,
                overwrite,
            )?;

            Ok(())
        };

        if let Some(ref name) = name {
            let item = templates.iter().find(|item| item.0 == *name).unwrap();

            write(item.1.as_bytes())?;
        } else {
            let selection = fuzzy(templates, false)?;

            if !selection.is_empty() {
                let item = &selection[0];

                write(item.output().as_bytes())?;
            }
        }

        Ok(())
    }
}