120 lines
3.7 KiB
Rust
120 lines
3.7 KiB
Rust
use std::fs;
|
|
|
|
use risp::law::{Content, Heading, HeadingContent, Law, Section};
|
|
|
|
fn print_content(content: Content) -> String {
|
|
let mut ret = String::new();
|
|
|
|
match content {
|
|
Content::Text(t) => ret.push_str(&format!("<span class='content'>{t}</span>")),
|
|
Content::Item(l) | Content::List(l) => {
|
|
ret.push_str("<ul class='content list'>");
|
|
for item in l {
|
|
ret.push_str("<li>");
|
|
ret.push_str(&print_content(item));
|
|
ret.push_str("</li>");
|
|
}
|
|
ret.push_str("</ul>");
|
|
}
|
|
}
|
|
|
|
ret
|
|
}
|
|
|
|
fn print_paragraph(section: Section) -> String {
|
|
let mut ret = String::new();
|
|
ret.push_str("<div class='par'>");
|
|
ret.push_str(&format!("<span class='symb'>{}</span>", section.symb));
|
|
if let Some(par_header) = section.par_header {
|
|
ret.push_str(&format!("<span class='header'>{}</span>", par_header));
|
|
}
|
|
if let Some(note) = section.par_note {
|
|
ret.push_str(&format!("<span class='note'>Beachte: {}</span>", note));
|
|
}
|
|
ret.push_str(&print_content(section.content));
|
|
|
|
ret.push_str("</div>");
|
|
ret
|
|
}
|
|
|
|
fn print_header(header: Heading, level: usize) -> String {
|
|
let mut ret = String::new();
|
|
let mut header_title = header.name.clone();
|
|
if let Some(desc) = header.desc {
|
|
header_title.push_str(&format!(" ({desc})"))
|
|
}
|
|
|
|
ret.push_str(&format!(
|
|
"<details>\
|
|
<summary><h{0}>{1}</h{0}></summary>\n\
|
|
<div>",
|
|
level + 2,
|
|
header_title
|
|
));
|
|
|
|
match header.content {
|
|
HeadingContent::Paragraph(p) => {
|
|
for section in p {
|
|
ret.push_str(&print_paragraph(section));
|
|
}
|
|
}
|
|
HeadingContent::Heading(subheaders) => {
|
|
for subheader in subheaders {
|
|
ret.push_str(&print_header(subheader, level + 1));
|
|
}
|
|
}
|
|
}
|
|
|
|
ret.push_str("</div></details>");
|
|
|
|
ret
|
|
}
|
|
|
|
fn get_content(config_path: &str) -> (String, String) {
|
|
let law = Law::from_config(config_path).unwrap();
|
|
let lawname = law.name;
|
|
|
|
let mut ret = String::new();
|
|
for h in law.header {
|
|
ret.push_str(&print_header(h, 0));
|
|
}
|
|
(lawname, ret)
|
|
}
|
|
|
|
fn main() {
|
|
let configs = fs::read_dir("./laws").expect("No folder with config files");
|
|
|
|
let mut li_of_files = String::new();
|
|
for config in configs {
|
|
let config = config.unwrap();
|
|
let filename = config.file_name().into_string().unwrap();
|
|
//TODO: use proper logic...
|
|
let law_name = filename.replace(".toml", "");
|
|
|
|
let path = format!("{}", config.path().display());
|
|
let (lawname, content) = get_content(&path);
|
|
|
|
let template = fs::read_to_string("templates/law.html").unwrap();
|
|
let site = template
|
|
.replace("{{content}}", &content)
|
|
.replace("{{title}}", &lawname);
|
|
|
|
li_of_files.push_str(&format!(
|
|
"<li><a href='./{law_name}'>{lawname}</a></li><br />\n"
|
|
));
|
|
fs::write(&format!("output/{law_name}.html"), &site).expect("Unable to write file");
|
|
}
|
|
let style = fs::read_to_string("templates/style.css").unwrap();
|
|
fs::write(&format!("output/style.css"), &style).expect("Unable to write file");
|
|
|
|
let style = fs::read_to_string("templates/pico.min.css").unwrap();
|
|
fs::write(&format!("output/pico.min.css"), &style).expect("Unable to write file");
|
|
|
|
let js = fs::read_to_string("templates/app.js").unwrap();
|
|
fs::write(&format!("output/app.js"), &js).expect("Unable to write file");
|
|
|
|
let mut index = fs::read_to_string("templates/index.html").unwrap();
|
|
index = index.replace("{{content}}", &li_of_files);
|
|
fs::write(&format!("output/index.html"), &index).expect("Unable to write file");
|
|
}
|