gen_plugin 0.1.0

GenUI plugin analyzer and generator
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

mod category;
mod repo;

pub use category::*;
pub use repo::*;
use toml_edit::{value, Array, Table};

use super::PluginError;

#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct Plugin {
    /// The name of the plugin (must be unique)
    pub name: String,
    /// the category of the plugin
    pub category: Category,
    /// repo of the plugin
    pub repo: Repo,
    pub authors: Option<Vec<String>>,
    pub version: String,
    pub description: Option<String>,
    pub license: Option<String>,
}

impl From<Plugin> for Table {
    fn from(plugin: Plugin) -> Self {
        let mut table = Table::new();
        table.insert("name", value(&plugin.name));
        if let Some(author) = plugin.authors {
            let mut arr = Array::new();
            for a in author {
                arr.push(&a);
            }
            table.insert("authors", value(arr));
        }
        table.insert("version", value(&plugin.version));
        if let Some(description) = plugin.description {
            table.insert("description", value(&description));
        }
        if let Some(license) = plugin.license {
            table.insert("license", value(&license));
        }
        table.insert("category", plugin.category.into());
        table.insert("repo", plugin.repo.into());

        table
    }
}

impl TryFrom<&Table> for Plugin {
    type Error = PluginError;

    fn try_from(value: &Table) -> Result<Self, Self::Error> {
        let name = value
            .get("name")
            .and_then(|v| v.as_str())
            .ok_or_else(|| PluginError::from("Invalid name [plugin.name]"))?;
        let category = value
            .get("category")
            .ok_or_else(|| PluginError::from("Invalid category [plugin.category]"))?;
        let repo = value
            .get("repo")
            .ok_or_else(|| PluginError::from("Invalid repo [plugin.repo]"))?;
        let authors = value
            .get("authors")
            .and_then(|v| v.as_array())
            .map_or_else(
                || Ok(None),
                |v| {
                    let mut authors = vec![];
                    for a in v.iter() {
                        if let Some(a) = a.as_str() {
                            authors.push(a.to_string());
                        } else {
                            return Err(PluginError::from("Invalid authors [plugin.authors]"));
                        }
                    }
                    Ok(Some(authors))
                },
            )?;

        let version = value
            .get("version")
            .and_then(|v| v.as_str())
            .ok_or_else(|| PluginError::from("Invalid version [plugin.version]"))?
            .to_string();
        let description = value
            .get("description")
            .and_then(|v| v.as_str())
            .map(|v| v.to_string());
        let license = value
            .get("license")
            .and_then(|v| v.as_str())
            .map(|v| v.to_string());

        Ok(Plugin {
            name: name.to_string(),
            category: Category::try_from(category)?,
            repo: Repo::try_from(repo)?,
            authors,
            version,
            description,
            license,
        })
    }
}

impl From<Plugin> for toml_edit::Item {
    fn from(value: Plugin) -> Self {
        toml_edit::Item::Table(value.into())
    }
}