288 lines
9.7 KiB
Rust
288 lines
9.7 KiB
Rust
extern crate reqwest;
|
|
|
|
use std::process::Command;
|
|
use std::env;
|
|
|
|
use std::path::{Path, PathBuf};
|
|
use std::fs::canonicalize;
|
|
use std::fs::{File, create_dir_all};
|
|
use std::io::{Write, copy};
|
|
|
|
pub fn yarn_install () {
|
|
if !Command::new("yarn").status().expect("failed to execute yarn process").success() {
|
|
panic!("Failed to execute yarn process");
|
|
}
|
|
}
|
|
|
|
pub fn browserify (infile: &str, outfile: &str) -> PathBuf {
|
|
let out_dir = env::var("OUT_DIR").unwrap();
|
|
let out_dir = Path::new(&out_dir);
|
|
let full_outfile = out_dir.join(outfile);
|
|
let status = Command::new("node_modules/.bin/browserify")
|
|
.args(&[infile, "-o", full_outfile.to_str().expect("failed to build output path")])
|
|
.status()
|
|
.expect("failed to build js bundle");
|
|
|
|
if !status.success() {
|
|
panic!("Failed to browserify input file {}", infile);
|
|
}
|
|
|
|
full_outfile
|
|
}
|
|
|
|
pub fn lessc (infile: &str, outfile: &str) -> PathBuf {
|
|
let out_dir = env::var("OUT_DIR").unwrap();
|
|
let out_dir = Path::new(&out_dir);
|
|
let full_outfile = out_dir.join(outfile);
|
|
let status = Command::new("node_modules/.bin/lessc")
|
|
.args(&[infile, full_outfile.to_str().expect("failed to build output path")])
|
|
.status()
|
|
.expect("failed to build css bundle");
|
|
|
|
if !status.success() {
|
|
panic!("Failed to lessc input file {}", infile);
|
|
}
|
|
|
|
full_outfile
|
|
}
|
|
|
|
pub fn sass (infile: &str, outfile: &str) -> PathBuf {
|
|
let out_dir = env::var("OUT_DIR").unwrap();
|
|
let out_dir = Path::new(&out_dir);
|
|
let full_outfile = out_dir.join(outfile);
|
|
let status = Command::new("node_modules/.bin/sass")
|
|
.args(&[infile, full_outfile.to_str().expect("failed to build output path")])
|
|
.status()
|
|
.expect("failed to build css bundle");
|
|
|
|
if !status.success() {
|
|
panic!("Failed to sass input file {}", infile);
|
|
}
|
|
|
|
full_outfile
|
|
}
|
|
|
|
pub struct ResourcesGenerator {
|
|
resources: Vec<Resource>
|
|
}
|
|
|
|
impl ResourcesGenerator {
|
|
pub fn new () -> ResourcesGenerator {
|
|
ResourcesGenerator {
|
|
resources: vec![]
|
|
}
|
|
}
|
|
|
|
pub fn add (&mut self, resource: Resource) -> &mut ResourcesGenerator {
|
|
self.resources.push(resource);
|
|
self
|
|
}
|
|
|
|
pub fn write (&self) {
|
|
let out_dir = env::var("OUT_DIR").unwrap();
|
|
let out_dir = Path::new(&out_dir);
|
|
let mut outfile = File::create(out_dir.join("resources.rs").to_str().expect("failed to build output path")).expect("failed to create outfile");
|
|
|
|
let mut consts = String::new();
|
|
|
|
let mut routes = String::new();
|
|
let mut routes_fn = String::from("pub fn routes() -> Vec<Route> {\n\troutes![");
|
|
|
|
let mut handlebars = String::new();
|
|
for resource in &self.resources {
|
|
let include = self.create_include(&resource);
|
|
|
|
if resource.constant.is_some() {
|
|
consts.push_str(&self.create_const(&resource, include.as_ref().expect("Expected include for constant")));
|
|
}
|
|
|
|
if resource.mount_at.is_some() {
|
|
let (function_name, route_function) = match include {
|
|
Some(ref include) => self.create_rocket_route_include(resource, &include),
|
|
None => self.create_rocket_route_link(resource)
|
|
};
|
|
routes.push_str(&route_function);
|
|
routes_fn.push_str(&function_name);
|
|
routes_fn.push(',');
|
|
}
|
|
|
|
if resource.template_name.is_some() {
|
|
handlebars.push_str(&(match include {
|
|
Some(ref include) => self.create_handlebars_template_include(resource, &include),
|
|
None => self.create_handlebars_template_link(resource)
|
|
}));
|
|
}
|
|
}
|
|
|
|
if !routes.is_empty() {
|
|
self.write_rocket_routes(&mut outfile, &routes, &routes_fn);
|
|
}
|
|
|
|
if !handlebars.is_empty () {
|
|
self.write_handlebars_templates(&mut outfile, &handlebars);
|
|
}
|
|
|
|
outfile.write(consts.as_bytes());
|
|
outfile.write(b"\n");
|
|
}
|
|
|
|
fn create_include(&self, resource: &Resource) -> Option<String> {
|
|
if resource.link {
|
|
None
|
|
} else {
|
|
let canonical_source = canonicalize(&resource.source).expect(&format!("failed to get canonical path for {:?}", resource.source));
|
|
Some(format!(
|
|
"include_{}!(\"{}\")",
|
|
if resource.raw { "bytes" } else { "str" },
|
|
canonical_source.display()
|
|
))
|
|
}
|
|
}
|
|
|
|
fn create_const(&self, resource: &Resource, include: &str) -> String {
|
|
format!(
|
|
"const {}: &'static {} = {};\n",
|
|
resource.constant.unwrap(),
|
|
if resource.raw { "[u8]" } else { "str" },
|
|
include
|
|
)
|
|
}
|
|
|
|
fn create_rocket_route_include(&self, resource: &Resource, include: &str) -> (String, String) {
|
|
let mount_at = resource.mount_at.as_ref().unwrap();
|
|
let mut function_name = String::from("route");
|
|
let mut function_return_type = "&'static str";
|
|
let mut function_return_value = String::from(resource.constant.unwrap_or(&include));
|
|
|
|
if resource.raw {
|
|
function_return_type = "RawByteResource";
|
|
function_return_value = format!("RawByteResource({})", function_return_value);
|
|
}
|
|
|
|
function_name.push_str(&mount_at.endpoint.replace("/", "_").replace(".", "_").replace("-", "_"));
|
|
(function_name.clone(), format!(
|
|
"#[get(\"{}\")]\nfn {}() -> Content<{}> {{\n\tContent(ContentType::{}, {})\n}}\n\n",
|
|
mount_at.endpoint,
|
|
function_name,
|
|
function_return_type,
|
|
mount_at.content_type,
|
|
function_return_value
|
|
))
|
|
}
|
|
|
|
fn create_rocket_route_link(&self, resource: &Resource) -> (String, String) {
|
|
let mount_at = resource.mount_at.as_ref().unwrap();
|
|
let mut function_name = String::from("route");
|
|
function_name.push_str(&mount_at.endpoint.replace("/", "_").replace(".", "_").replace("-", "_"));
|
|
(function_name.clone(), format!(
|
|
"#[get(\"{}\")]\nfn {}() -> io::Result<NamedFile> {{\n\tNamedFile::open(\"{}\")\n}}\n\n",
|
|
mount_at.endpoint,
|
|
function_name,
|
|
resource.source.display()
|
|
))
|
|
}
|
|
|
|
fn write_rocket_routes(&self, outfile: &mut File, routes: &str, routes_fn: &str) {
|
|
outfile.write(b"use rocket::{Route, Response, Request};\nuse rocket::response::{Content, Responder, NamedFile};\nuse rocket::http::{ContentType, Status};\n\n");
|
|
outfile.write(b"use std::io;\nuse std::io::Cursor;\n\n");
|
|
outfile.write(b"struct RawByteResource(&'static [u8]);\n");
|
|
outfile.write(b"impl<'r> Responder<'r> for RawByteResource {
|
|
fn respond_to(self, _: &Request) -> Result<Response<'r>, Status> {
|
|
Response::build()
|
|
.header(ContentType::Binary)
|
|
.sized_body(Cursor::new(self.0))
|
|
.ok()
|
|
}
|
|
}");
|
|
outfile.write(routes.as_bytes());
|
|
outfile.write(routes_fn.as_bytes());
|
|
outfile.write(b"]\n}");
|
|
}
|
|
|
|
fn create_handlebars_template_include(&self, resource: &Resource, include: &str) -> String {
|
|
let template_name = resource.template_name.unwrap();
|
|
format!(
|
|
"\n\thbs.register_template_string(\"{}\", {}).expect(\"Failed to register template: {}\");",
|
|
template_name,
|
|
resource.constant.unwrap_or(&include),
|
|
template_name
|
|
)
|
|
}
|
|
|
|
fn create_handlebars_template_link(&self, resource: &Resource) -> String {
|
|
let template_name = resource.template_name.unwrap();
|
|
format!(
|
|
"\n\thbs.register_template_file(\"{}\", {}).expect(\"Failed to register template: {}\");",
|
|
template_name,
|
|
resource.source.display(),
|
|
template_name
|
|
)
|
|
}
|
|
|
|
fn write_handlebars_templates(&self, outfile: &mut File, handlebars: &str) {
|
|
outfile.write(b"use handlebars::Handlebars;\n\n");
|
|
outfile.write(b"pub fn handlebars() -> Handlebars {\n");
|
|
outfile.write(b"\tlet mut hbs = Handlebars::new();");
|
|
outfile.write(handlebars.as_bytes());
|
|
outfile.write(b"hbs\n}");
|
|
}
|
|
}
|
|
|
|
#[derive(Default)]
|
|
pub struct Resource {
|
|
pub source: PathBuf,
|
|
pub mount_at: Option<ResourceMount>,
|
|
pub constant: Option<&'static str>,
|
|
pub template_name: Option<&'static str>,
|
|
pub raw: bool,
|
|
pub link: bool
|
|
}
|
|
|
|
pub struct ResourceMount {
|
|
pub endpoint: String,
|
|
pub content_type: &'static str
|
|
}
|
|
|
|
pub struct Downloader {
|
|
cache: PathBuf
|
|
}
|
|
|
|
impl Downloader {
|
|
pub fn new<P: AsRef<Path>>(cache: P) -> Downloader {
|
|
Downloader {
|
|
cache: cache.as_ref().to_path_buf()
|
|
}
|
|
}
|
|
|
|
pub fn get(&self, url: &str) -> DownloaderResult {
|
|
let filename = url.get((url.rfind('/').expect("not a valid url") + 1..)).expect("failed to parse filename");
|
|
self.get_to(url, filename)
|
|
}
|
|
|
|
pub fn get_to(&self, url: &str, filename: &str) -> DownloaderResult {
|
|
if !self.cache.exists() {
|
|
create_dir_all(self.cache.as_path()).expect("failed to create cache directory");
|
|
}
|
|
|
|
let mut out_path = self.cache.clone();
|
|
out_path.push(filename);
|
|
|
|
let was_cached = out_path.exists();
|
|
if !was_cached {
|
|
let mut result = reqwest::get(url).expect("failed to download url");
|
|
let mut file = File::create(out_path.as_path()).expect("failed to open file");
|
|
copy(&mut result, &mut file).expect("failed to write file");
|
|
}
|
|
|
|
DownloaderResult {
|
|
out_path: out_path,
|
|
was_cached: was_cached
|
|
}
|
|
}
|
|
}
|
|
|
|
pub struct DownloaderResult {
|
|
pub out_path: PathBuf,
|
|
pub was_cached: bool
|
|
}
|