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
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
|
//! This crate generates HTML templates for crates.rs
//!
//! Most template require their own type of struct that does
//! some lightweight conversion from data model/APIs,
//! because the template engine Ructe doesn't support
//! complex expressions in the templates.
mod cat_page;
mod crate_page;
mod download_graph;
mod home_page;
mod iter;
mod not_found_page;
mod search_page;
mod urler;
use render_readme::Markup;
pub use crate::not_found_page::*;
pub use crate::search_page::*;
use crate::crate_page::*;
use crate::urler::Urler;
use categories::Category;
use chrono::prelude::*;
use failure;
use failure::ResultExt;
use kitchen_sink::KitchenSink;
use kitchen_sink::{stopped, KitchenSinkErr};
use render_readme::Renderer;
use rich_crate::RichCrate;
use rich_crate::RichCrateVersion;
use std::io::Write;
include!(concat!(env!("OUT_DIR"), "/templates.rs"));
/// Metadata used in the base template, mostly for `<meta>`
pub struct Page {
title: String,
description: Option<String>,
item_name: Option<String>,
item_description: Option<String>,
keywords: Option<String>,
created: Option<String>,
alternate: Option<String>,
alternate_type: Option<&'static str>,
canonical: Option<String>,
noindex: bool,
search_meta: bool,
critical_css_data: Option<&'static str>,
}
impl Page {
pub fn site_twitter_handle(&self) -> &str {
"@CratesRS"
}
pub fn critical_css(&self) -> templates::Html<&'static str> {
let data = self.critical_css_data.unwrap_or(include_str!("../../style/public/critical.css"));
templates::Html(data)
}
}
/// See `cat_page.rs.html`
pub fn render_category(out: &mut dyn Write, cat: &Category, crates: &KitchenSink, renderer: &Renderer) -> Result<(), failure::Error> {
let urler = Urler::new(None);
let page = cat_page::CatPage::new(cat, crates, renderer).context("can't prepare rendering of category page")?;
templates::cat_page(out, &page, &urler)?;
Ok(())
}
/// See `homepage.rs.html`
pub fn render_homepage(out: &mut dyn Write, crates: &KitchenSink) -> Result<(), failure::Error> {
let urler = Urler::new(None);
templates::homepage(out, &home_page::HomePage::new(crates)?, &urler)?;
Ok(())
}
/// See `atom.rs.html`
pub fn render_feed(out: &mut dyn Write, crates: &KitchenSink) -> Result<(), failure::Error> {
let urler = Urler::new(None);
templates::atom(out, &home_page::HomePage::new(crates)?, &urler)?;
Ok(())
}
pub fn render_sitemap(sitemap: &mut impl Write, crates: &KitchenSink) -> Result<(), failure::Error> {
let all_crates = crates.sitemap_crates()?;
sitemap.write_all(br#"<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">"#)?;
let now = Utc::now().timestamp();
for (origin, rank, lastmod) in all_crates {
let age = now - lastmod;
write!(
sitemap,
r#"
<url><changefreq>{freq}</changefreq><priority>{pri:0.1}</priority><lastmod>{date}</lastmod><loc>https://lib.rs/crates/{name}</loc></url>"#,
name = origin.short_crate_name(),
date = Utc.timestamp(lastmod, 0).to_rfc3339(),
pri = (rank * 2.).min(1.),
freq = match age {
x if x > 3600 * 24 * 30 * 18 => "yearly",
x if x > 3600 * 24 * 60 => "monthly",
x if x > 3600 * 24 * 7 => "weekly",
_ => "daily",
},
)?;
}
sitemap.write_all(b"\n</urlset>\n")?;
Ok(())
}
/// See `crate_page.rs.html`
pub fn render_crate_page(out: &mut dyn Write, all: &RichCrate, ver: &RichCrateVersion, kitchen_sink: &KitchenSink, renderer: &Renderer) -> Result<String, failure::Error> {
if stopped() {
Err(KitchenSinkErr::Stopped)?;
}
let urler = Urler::new(Some(ver.origin().clone()));
let c = CratePage::new(all, ver, kitchen_sink, renderer).context("New crate page")?;
templates::crate_page(out, &urler, &c).context("crate page io")?;
Ok(c.page_title())
}
/// See `crate_page.rs.html`
pub fn render_static_page(out: &mut dyn Write, title: String, page: &Markup, renderer: &Renderer) -> Result<(), failure::Error> {
if stopped() {
Err(KitchenSinkErr::Stopped)?;
}
let (html, warnings) = renderer.page(page, Some(("https://lib.rs", "https://lib.rs")), false, None);
if !warnings.is_empty() {
eprintln!("static: {:?}", warnings);
}
templates::static_page(out, &Page {
title,
alternate: None,
alternate_type: None,
canonical: None,
critical_css_data: None,
created: None,
description: None,
item_description: None,
item_name: None,
keywords: None,
noindex: false,
search_meta: true,
}, templates::Html(html))?;
Ok(())
}
/// Ructe doesn't like complex expressions…
trait MyAsStr {
fn as_str(&self) -> Option<&str>;
}
impl<S: AsRef<str>> MyAsStr for Option<S> {
fn as_str(&self) -> Option<&str> {
self.as_ref().map(|s| s.as_ref())
}
}
pub(crate) fn date_now() -> String {
Utc::now().format("%Y-%m-%d").to_string()
}
|
