lux-cli 0.33.0

A luxurious package manager for Lua
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

use eyre::Result;
use git2::Repository;
use lux_lib::git::url::RemoteGitUrl;
use path_absolutize::Absolutize as _;
use std::io;
use std::path::Path;
use std::path::PathBuf;

#[derive(Debug)]
pub struct RepoMetadata {
    pub name: String,
    pub description: Option<String>,
    pub license: Option<String>,
    pub labels: Option<Vec<String>>,
    pub contributors: Vec<String>,
}

impl RepoMetadata {
    pub fn default(path: &Path) -> io::Result<Self> {
        Ok(RepoMetadata {
            name: path
                .absolutize()?
                .file_name()
                .unwrap_or_default()
                .to_string_lossy()
                .to_string(),
            description: None,
            license: None,
            contributors: whoami::realname()
                .map(|realname| vec![realname])
                .unwrap_or_default(),
            labels: None,
        })
    }
}

/// Retrieves metadata for a given directory
pub async fn get_metadata_for(directory: Option<&PathBuf>) -> Result<Option<RepoMetadata>> {
    let repo = match directory {
        Some(path) => Repository::open(path)?,
        None => Repository::open_from_env()?,
    };

    // NOTE(vhyrro): Temporary value is required. Thank the borrow checker.
    let ret = if let Ok(remote) = repo.find_remote("origin")?.url() {
        let parsed_url: RemoteGitUrl = remote.parse()?;

        let owner = match parsed_url.owner() {
            Some(owner) => owner.to_owned(),
            None => return Ok(None),
        };

        let repo = parsed_url.repo().to_string();

        let octocrab = octocrab::instance();
        let repo_handler = octocrab.repos(owner, repo);

        let contributors = repo_handler.list_contributors().send().await?;
        let repo_data = repo_handler.get().await?;

        Ok(Some(RepoMetadata {
            name: repo_data.name,
            description: repo_data.description,
            license: repo_data.license.map(|license| license.name),
            labels: repo_data.topics,
            contributors: contributors
                .items
                .into_iter()
                .map(|contributor| contributor.author.login)
                .collect(),
        }))
    } else {
        Ok(None)
    };

    ret
}