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

use crate::config::Config;
use crate::data::workspaces::WorkspaceData;
use crate::errors::{OrandaError, Result};
use crate::paths::determine_path;
use crate::site::markdown::to_html;
use axoasset::LocalAsset;
use camino::Utf8PathBuf;
use serde::Serialize;

#[derive(Serialize, Debug)]
pub struct WorkspaceIndexContext {
    pub members: Vec<WorkspaceIndexMember>,
    pub docs_content: Option<String>,
    pub preferred_members: Vec<WorkspaceIndexMember>,
}

#[derive(Serialize, Debug)]
pub struct WorkspaceIndexMember {
    pub name: String,
    pub slug: String,
    pub description: Option<String>,
    pub repository: Option<String>,
    pub logo: Option<Utf8PathBuf>,
}

impl WorkspaceIndexContext {
    pub fn new(members: &Vec<WorkspaceData>, workspace_config: &Config) -> Result<Self> {
        let mut index_members = Vec::new();
        let mut index_preferred_members = Vec::new();

        for member in members {
            let logo = if let Some(logo) = &member.config.styles.logo {
                Some(Self::find_logo_path(logo, member, workspace_config)?)
            } else {
                None
            };
            let context = WorkspaceIndexMember {
                name: member.config.project.name.clone(),
                slug: member.slug.clone(),
                description: member.config.project.description.clone(),
                repository: member.config.project.repository.clone(),
                logo,
            };
            if workspace_config
                .workspace
                .preferred_members
                .contains(&context.slug)
            {
                index_preferred_members.push(context);
            } else {
                index_members.push(context);
            }
        }

        let mut workspace = Self {
            docs_content: None,
            members: index_members,
            preferred_members: index_preferred_members,
        };

        if let Some(docs_path) = &workspace_config.workspace.docs_path {
            let res = LocalAsset::load_string(docs_path)?;
            let html = to_html(&res, &workspace_config.styles.syntax_theme)?;
            workspace.docs_content = Some(html);
        }

        Ok(workspace)
    }

    fn find_logo_path(
        logo_url: &String,
        member: &WorkspaceData,
        workspace_config: &Config,
    ) -> Result<Utf8PathBuf> {
        let root_path = Utf8PathBuf::from_path_buf(std::env::current_dir()?).unwrap_or_default();
        if logo_url.starts_with("http") {
            // Lifted from axoasset. Expose it there?
            let mut filename = url::Url::parse(logo_url)?
                .path()
                .to_string()
                .replace('/', "_");
            filename.remove(0);
            let mut path = Utf8PathBuf::from(
                workspace_config
                    .build
                    .path_prefix
                    .clone()
                    .unwrap_or_default(),
            );
            path.push(&member.slug);
            path.push(filename);
            Ok(path)
        } else if let Some(path) = determine_path(root_path, &Some(&member.slug), logo_url)? {
            Ok(path)
        } else {
            Err(OrandaError::PathDoesNotExist {
                path: logo_url.clone(),
            })
        }
    }
}