oranda 0.6.5

🎁 generate beautiful landing pages for your projects
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
125
126
127
128
129
130
131
132
133

use crate::errors::*;

use axoproject::GithubRepo;
use gazenot::{Gazenot, PublicRelease, ReleaseAsset};
use serde::{Deserialize, Serialize};

use super::artifacts::{File, ReleaseArtifacts};

#[derive(Clone, Debug, Serialize, Deserialize)]
pub struct AxoResponse {
    pub success: bool,
    pub result: Vec<AxoRelease>,
}

#[derive(Clone, Debug, Serialize, Deserialize)]
pub struct AxoRelease {
    pub tag_name: String,
    pub name: String,
    pub body: String,
    pub version: String,
    pub prerelease: bool,
    pub created_at: String,
    pub assets: Vec<AxoReleaseAsset>,
}

#[derive(Clone, Debug, Serialize, Deserialize)]
pub struct AxoReleaseAsset {
    pub browser_download_url: String,
    pub name: String,
    pub uploaded_at: String,
}

impl AxoRelease {
    pub async fn fetch_all(package_name: &str, repo: &GithubRepo) -> Result<Vec<AxoRelease>> {
        let abyss = Gazenot::new_unauthed("github".to_string(), repo.owner.clone())?;
        let list = abyss
            .list_releases_many(vec![package_name.to_string()])
            .await?;
        let list = list
            .into_iter()
            .find(|r| r.package_name == package_name)
            .ok_or(OrandaError::AxoReleasesFetchError)?;

        Ok(list.releases.into_iter().map(|r| r.into()).collect())
    }

    pub fn has_dist_manifest(&self) -> bool {
        self.assets.iter().any(|a| a.name == "dist-manifest.json")
    }

    pub fn asset_url<'a>(&'a self, asset_name: &'a str) -> Option<&'a str> {
        for asset in &self.assets {
            if asset.name == asset_name {
                return Some(&asset.browser_download_url);
            }
        }
        None
    }

    pub fn repo_has_releases(name: &str, repo: &GithubRepo) -> Result<bool> {
        if let Ok(releases) =
            tokio::runtime::Handle::current().block_on(AxoRelease::fetch_all(name, repo))
        {
            if releases.is_empty() {
                Ok(false)
            } else {
                Ok(true)
            }
        } else {
            let warning = OrandaError::ReleasesCheckFailed {
                repo: repo.to_string(),
            };
            eprintln!("{:?}", miette::Report::new(warning));
            Ok(false)
        }
    }
}

impl ReleaseArtifacts {
    pub fn add_axodotdev(&mut self, release: &AxoRelease) {
        for asset in &release.assets {
            let file = File {
                name: asset.name.clone(),
                download_url: asset.browser_download_url.clone(),
                view_path: None,
                checksum_file: None,
                infer: true,
            };
            self.add_file(file);
        }
    }
}

impl From<ReleaseAsset> for AxoReleaseAsset {
    fn from(value: ReleaseAsset) -> Self {
        let ReleaseAsset {
            browser_download_url,
            name,
            uploaded_at,
        } = value;

        Self {
            browser_download_url,
            name,
            uploaded_at,
        }
    }
}
impl From<PublicRelease> for AxoRelease {
    fn from(value: PublicRelease) -> Self {
        let PublicRelease {
            tag_name,
            version,
            name,
            body,
            prerelease,
            created_at,
            assets,
        } = value;

        let assets: Vec<AxoReleaseAsset> = assets.into_iter().map(|a| a.into()).collect();

        Self {
            tag_name,
            version,
            name,
            body,
            prerelease,
            created_at,
            assets,
        }
    }
}