,
}
impl StaticFilesBundle {
/// Crea el paquete de recursos con los archivos del directorio indicado.
///
/// # Argumentos
///
/// * `dir` - Ruta al directorio con los archivos a incluir, normalmente `static/` o un
/// directorio dentro de este.
/// * `filter` - Función opcional para seleccionar qué archivos incluir en el paquete.
///
/// # Ejemplo
///
/// ```rust,no_run
/// use pagetop_build::StaticFilesBundle;
/// use std::path::Path;
///
/// fn main() -> std::io::Result<()> {
/// StaticFilesBundle::from_dir("./static", Some(only_images))
/// .with_name("images")
/// .build()
/// }
///
/// fn only_images(path: &Path) -> bool {
/// matches!(
/// path.extension().and_then(|ext| ext.to_str()),
/// Some("jpg" | "png" | "gif")
/// )
/// }
/// ```
pub fn from_dir(dir: P, filter: Option bool>) -> Self
where
P: AsRef,
{
Self {
dir: dir.as_ref().to_path_buf(),
filter,
name: None,
}
}
/// Asigna un nombre al paquete de recursos.
///
/// El nombre debe ser un identificador Rust válido que se convertirá en nombre del módulo y de
/// la función del archivo `.rs` generado en `OUT_DIR`. Si no se llama a este método, el nombre
/// por defecto será `"bundle"`.
///
/// Este nombre es el que hay que declarar en
/// [`serve_static_files!`](https://docs.rs/pagetop/latest/pagetop/macro.serve_static_files.html)
/// para configurar la ruta del servicio:
///
/// ```rust,ignore
/// serve_static_files!(router, ["./static/css", app_css] => "/public/css");
/// // ^^^^^^^
/// // debe coincidir con .with_name("app_css")
/// ```
pub fn with_name(mut self, name: impl AsRef) -> Self {
self.name = Some(name.as_ref().to_string());
self
}
/// Genera el archivo `.rs` en `OUT_DIR` para incluir los recursos del directorio en el binario.
pub fn build(self) -> std::io::Result<()> {
let out_dir = std::env::var("OUT_DIR").unwrap();
let name = self.name.as_deref().unwrap_or("bundle");
let mut rd = resource_dir(&self.dir);
if let Some(f) = self.filter {
rd.with_filter(f);
}
let generated_filename = PathBuf::from(&out_dir).join(format!("{name}.rs"));
rd.with_generated_filename(generated_filename);
rd.with_module_name(format!("bundle_{name}"));
rd.with_generated_fn(name);
rd.build()
}
}
// **< compile_scss / copy_dir / copy_file / copy_file_replacing / minify_js >**********************
/// Compila un archivo SCSS a CSS minificado y lo escribe en la ruta de destino.
///
/// Crea el directorio padre del destino si no existe.
///
/// # Ejemplo
///
/// ```rust,no_run
/// fn main() -> std::io::Result<()> {
/// pagetop_build::compile_scss("assets/main.scss", "static/css/main.min.css")
/// }
/// ```
pub fn compile_scss(src: P, dst: Q) -> io::Result<()>
where
P: AsRef,
Q: AsRef,
{
let src = src.as_ref();
let dst = dst.as_ref();
if let Some(parent) = dst.parent() {
create_dir_all(parent)?;
}
let options = Options::default().style(OutputStyle::Compressed);
let css = from_path(src, &options)
.map_err(|e| io::Error::other(format!("failed to compile `{}`: {e}", src.display())))?;
File::create(dst)?.write_all(css.as_bytes())
}
/// Copia recursivamente el contenido de un directorio a otro destino.
///
/// Crea el directorio destino y todos los subdirectorios necesarios.
///
/// # Ejemplo
///
/// ```rust,no_run
/// fn main() -> std::io::Result<()> {
/// pagetop_build::copy_dir("assets", "static")
/// }
/// ```
pub fn copy_dir(src: P, dst: Q) -> io::Result<()>
where
P: AsRef,
Q: AsRef,
{
let src = src.as_ref();
let dst = dst.as_ref();
create_dir_all(dst)?;
for entry in read_dir(src)? {
let entry = entry?;
let src_path = entry.path();
let dst_path = dst.join(entry.file_name());
if src_path.is_dir() {
copy_dir(&src_path, &dst_path)?;
} else {
fs_copy(&src_path, &dst_path)?;
}
}
Ok(())
}
/// Copia un archivo a su destino.
///
/// Crea el directorio padre del destino si no existe.
///
/// # Ejemplo
///
/// ```rust,no_run
/// fn main() -> std::io::Result<()> {
/// pagetop_build::copy_file("assets/fonts/icon.woff2", "static/fonts/icon.woff2")
/// }
/// ```
pub fn copy_file(src: P, dst: Q) -> io::Result<()>
where
P: AsRef,
Q: AsRef,
{
let src = src.as_ref();
let dst = dst.as_ref();
if let Some(parent) = dst.parent() {
create_dir_all(parent)?;
}
fs_copy(src, dst)?;
Ok(())
}
/// Copia un archivo a su destino con una lista de sustituciones de texto en su contenido.
///
/// El archivo fuente se lee como texto UTF-8; no debe usarse con archivos binarios. Las
/// sustituciones de texto se aplican en orden y de forma encadenada: el resultado de cada
/// sustitución puede ser entrada de la siguiente.
///
/// Crea el directorio padre del destino si no existe.
///
/// # Ejemplo
///
/// ```rust,no_run
/// fn main() -> std::io::Result<()> {
/// pagetop_build::copy_file_replacing(
/// "assets/adminlte.min.js",
/// "static/js/myapp.min.js",
/// &[("adminlte.min.js.map", "myapp.min.js.map")],
/// )
/// }
/// ```
pub fn copy_file_replacing(src: P, dst: Q, replacements: &[(&str, &str)]) -> io::Result<()>
where
P: AsRef,
Q: AsRef,
{
let src = src.as_ref();
let dst = dst.as_ref();
if let Some(parent) = dst.parent() {
create_dir_all(parent)?;
}
let content = std::fs::read_to_string(src)?;
let patched = replacements
.iter()
.fold(content, |acc, (old, new)| acc.replace(old, new));
File::create(dst)?.write_all(patched.as_bytes())
}
/// Minifica un archivo JavaScript y lo escribe en la ruta de destino.
///
/// El archivo se procesa en modo de ámbito global (`TopLevelMode::Global`), adecuado para scripts
/// sin `import`/`export`. Los archivos con sintaxis de módulo ES deben procesarse con
/// `TopLevelMode::Module`, que el *crate* subyacente (`minify-js`) también soporta pero esta
/// función no expone actualmente.
///
/// Crea el directorio padre del destino si no existe.
///
/// # Ejemplo
///
/// ```rust,no_run
/// fn main() -> std::io::Result<()> {
/// pagetop_build::minify_js("assets/shell.js", "static/js/shell.min.js")
/// }
/// ```
pub fn minify_js(src: P, dst: Q) -> io::Result<()>
where
P: AsRef,
Q: AsRef,
{
let src = src.as_ref();
let dst = dst.as_ref();
if let Some(parent) = dst.parent() {
create_dir_all(parent)?;
}
let source = std::fs::read(src)?;
let session = Session::new();
let mut output = Vec::new();
minify(&session, TopLevelMode::Global, &source, &mut output)
.map_err(|e| io::Error::other(format!("failed to minify `{}`: {e:?}", src.display())))?;
File::create(dst)?.write_all(&output)
}