use std::net::IpAddr;
use std::path::{Path, PathBuf};
use std::process::exit;
use clap::Parser;
use tokio::sync::broadcast::{self, Sender, error::RecvError};
use bundla::{
BuildCause, BuildOptions, Minify, ReloadType, Server, ServerConfig, WatchLog, build, serve,
watch, watch_serve,
};
#[derive(Parser)]
#[command(
about = "bundle src into dist; -d dev build, -w watch, -s serve — all combinable",
version
)]
struct Args {
#[arg(long, default_value = "src", value_name = "DIR")]
src: PathBuf,
#[arg(long, value_name = "DIR")]
dist: Option<PathBuf>,
#[arg(long, value_parser = base_parse, value_name = "PREFIX")]
base: Option<String>,
#[arg(short, long)]
dev: bool,
#[arg(long, value_name = "TARGETS")]
minify: Option<Minify>,
#[arg(short, long)]
watch: bool,
#[arg(long, value_name = "SUFFIXES", requires = "watch")]
filter: Vec<String>,
#[arg(short, long)]
serve: bool,
#[arg(
short,
long,
default_value = "0",
hide_default_value = true,
requires = "serve"
)]
port: u16,
#[arg(short, long, default_value = "127.0.0.1", requires = "serve")]
ip: IpAddr,
#[arg(short, long, requires = "serve")]
open: bool,
#[arg(long, default_value = "index.html", requires = "serve")]
index: String,
#[arg(long = "header", value_name = "NAME: VALUE", requires = "serve")]
headers: Vec<String>,
}
#[tokio::main]
async fn main() {
let args = Args::parse();
if let Err(err) = run(&args).await {
eprintln!("{err}");
exit(1);
}
}
async fn run(args: &Args) -> Result<(), String> {
let dist = output_dir(args);
let options = options_build(args);
let filter: Vec<&str> = args.filter.iter().map(String::as_str).collect();
match (args.watch, args.serve) {
(false, false) => build_once(&args.src, &dist, &options).await,
(true, false) => {
let tx_log = watch_log_channel();
let watcher = watch(&args.src, &dist, &options, tx_log, &filter).await?;
println!(
"watching {}, rebuilding into {}",
args.src.display(),
dist.display()
);
watcher.run().await
}
(false, true) => {
build_once(&args.src, &dist, &options).await?;
let server = serve(&server_config_build(args, dist)).await?;
start(server, args.open).await
}
(true, true) => {
let tx_log = watch_log_channel();
let server = watch_serve(
&args.src,
&server_config_build(args, dist.clone()),
&options,
tx_log,
&filter,
)
.await?;
start(server, args.open).await
}
}
}
fn options_build(args: &Args) -> BuildOptions {
let profile = if args.dev {
BuildOptions::DEV
} else {
BuildOptions::PROD
};
BuildOptions {
base: args.base.clone(),
minify: args.minify.unwrap_or(profile.minify),
..profile
}
}
async fn build_once(src: &Path, dist: &Path, options: &BuildOptions) -> Result<(), String> {
let warnings = build(src, dist, options).await?;
warnings_print(&warnings);
println!("bundled {}", dist.display());
Ok(())
}
fn watch_log_channel() -> Sender<WatchLog> {
let (tx_log, mut rx_log) = broadcast::channel::<WatchLog>(100);
tokio::spawn(async move {
loop {
match rx_log.recv().await {
Ok(log) => watch_log_print(&log),
Err(RecvError::Lagged(_)) => {
eprintln!("warning: watch log lagged; some messages dropped");
println!("built {}", ReloadType::Page.as_str());
}
Err(RecvError::Closed) => break,
}
}
});
tx_log
}
fn server_config_build(args: &Args, dist: PathBuf) -> ServerConfig {
ServerConfig {
dir: dist,
ip: args.ip,
port: args.port,
headers: args.headers.clone(),
index: args.index.clone(),
base: args.base.clone().unwrap_or_default(),
}
}
fn output_dir(args: &Args) -> PathBuf {
if let Some(dist) = &args.dist {
return dist.clone();
}
if args.dev {
PathBuf::from("dev")
} else {
PathBuf::from("dist")
}
}
fn base_parse(value: &str) -> Result<String, String> {
let value = value.trim();
if value.is_empty() {
return Err("must not be empty".into());
}
webadev::base_normalize(value)
}
async fn start(server: Server, open: bool) -> Result<(), String> {
println!("serving {}", server.url);
if open && let Err(err) = open::that(&server.url) {
eprintln!("failed to open browser: {err}");
}
server.run().await
}
fn warnings_print(warnings: &[String]) {
for warning in warnings {
eprintln!("warning: {warning}");
}
}
fn watch_log_print(log: &WatchLog) {
match log {
WatchLog::Built {
cause,
reload_type,
paths,
} => {
let cwd = std::env::current_dir().unwrap_or_default();
let files = paths
.iter()
.map(|path| {
path.strip_prefix(&cwd)
.unwrap_or(path)
.display()
.to_string()
})
.collect::<Vec<_>>()
.join(", ");
match cause {
BuildCause::Startup => println!("built {}: startup", reload_type.as_str()),
BuildCause::Lagged => println!("built {}", reload_type.as_str()),
BuildCause::Change if files.is_empty() => {
println!("built {}", reload_type.as_str())
}
BuildCause::Change => println!("built {}: {files}", reload_type.as_str()),
}
}
WatchLog::Warn(warning) => eprintln!("warning: {warning}"),
WatchLog::Error(err) => eprintln!("error: {err}"),
}
}
#[cfg(test)]
mod tests {
use std::net::{IpAddr, Ipv4Addr};
use super::*;
fn args(
dev: bool,
watch: bool,
serve: bool,
dist: Option<PathBuf>,
headers: Vec<String>,
) -> Args {
Args {
src: PathBuf::from("src"),
dist,
base: None,
dev,
minify: None,
watch,
filter: Vec::new(),
serve,
port: 8080,
ip: IpAddr::V4(Ipv4Addr::LOCALHOST),
open: false,
index: "index.html".to_string(),
headers,
}
}
#[test]
fn bare_parses_as_prod_build() {
let parsed = Args::try_parse_from(["bundla"]).unwrap();
assert!(!parsed.dev && !parsed.watch && !parsed.serve);
}
#[test]
fn flags_parse_shorts() {
let parsed = Args::try_parse_from(["bundla", "-dws"]).unwrap();
assert!(parsed.dev && parsed.watch && parsed.serve);
let parsed = Args::try_parse_from(["bundla", "-dw"]).unwrap();
assert!(parsed.dev && parsed.watch && !parsed.serve);
let parsed = Args::try_parse_from(["bundla", "-w"]).unwrap();
assert!(!parsed.dev && parsed.watch && !parsed.serve);
let parsed = Args::try_parse_from(["bundla", "-s"]).unwrap();
assert!(!parsed.dev && !parsed.watch && parsed.serve);
}
#[test]
fn flags_parse_longs() {
let parsed = Args::try_parse_from(["bundla", "--dev", "--watch", "--serve"]).unwrap();
assert!(parsed.dev && parsed.watch && parsed.serve);
}
#[test]
fn minify_parses_targets() {
let parsed = Args::try_parse_from(["bundla", "--minify", "css,js"]).unwrap();
assert_eq!(parsed.minify, Some(Minify::CSS | Minify::JS));
let parsed = Args::try_parse_from(["bundla", "--minify=all"]).unwrap();
assert_eq!(parsed.minify, Some(Minify::ALL));
let parsed = Args::try_parse_from(["bundla", "--minify", "none"]).unwrap();
assert_eq!(parsed.minify, Some(Minify::NONE));
let parsed = Args::try_parse_from(["bundla", "--minify", " JS , css "]).unwrap();
assert_eq!(parsed.minify, Some(Minify::CSS | Minify::JS));
}
#[test]
fn minify_rejects_invalid_targets() {
for value in ["", "htlm", "none,js", "all,css", "css,,js"] {
let err = Args::try_parse_from(["bundla", "--minify", value])
.err()
.expect("expected an invalid minify target to be rejected");
assert_eq!(
err.kind(),
clap::error::ErrorKind::ValueValidation,
"value: {value:?}"
);
}
}
#[test]
fn filter_is_collected_raw() {
let parsed = Args::try_parse_from(["bundla", "-w", "--filter", "html,css"]).unwrap();
assert_eq!(parsed.filter, ["html,css"]);
let parsed = Args::try_parse_from(["bundla", "-w", "--filter", " .HTML , js "]).unwrap();
assert_eq!(parsed.filter, [" .HTML , js "]);
let parsed = Args::try_parse_from(["bundla", "-w", "--filter", ""]).unwrap();
assert_eq!(parsed.filter, [""]);
}
#[test]
fn filter_requires_watch() {
let err = Args::try_parse_from(["bundla", "--filter", "html"])
.err()
.expect("expected --filter without --watch to be rejected");
assert_eq!(err.kind(), clap::error::ErrorKind::MissingRequiredArgument);
}
#[test]
fn base_parses_root_relative() {
let parsed = Args::try_parse_from(["bundla", "--base", "/app"]).unwrap();
assert_eq!(parsed.base.as_deref(), Some("/app"));
let parsed = Args::try_parse_from(["bundla", "--base", "/"]).unwrap();
assert_eq!(parsed.base.as_deref(), Some(""));
}
#[test]
fn base_normalizes_values() {
for (value, expected) in [("/app/", "/app"), (" /app/ ", "/app"), ("/a/b", "/a/b")] {
let parsed = Args::try_parse_from(["bundla", "--base", value]).unwrap();
assert_eq!(parsed.base.as_deref(), Some(expected), "value: {value:?}");
}
}
#[test]
fn base_without_serve_parses() {
let parsed = Args::try_parse_from(["bundla", "--base", "/app"]).unwrap();
assert!(!parsed.serve);
}
#[test]
fn base_rejects_relative_or_empty_values() {
for value in ["app", "app/", "./app", "", " "] {
let err = Args::try_parse_from(["bundla", "--base", value])
.err()
.expect("expected a relative or empty base to be rejected");
assert_eq!(err.kind(), clap::error::ErrorKind::ValueValidation);
}
}
#[test]
fn base_rejects_invalid_values() {
for value in [
"//app",
"/app//x",
"/app/../x",
"/app/./x",
"/app/*",
"/a b",
"/a%20b",
] {
let err = Args::try_parse_from(["bundla", "--base", value])
.err()
.expect("expected an invalid base to be rejected");
assert_eq!(err.kind(), clap::error::ErrorKind::ValueValidation);
}
}
#[test]
fn watch_and_serve_combine() {
let parsed = Args::try_parse_from(["bundla", "--watch", "--serve"]).unwrap();
assert!(parsed.watch && parsed.serve);
}
#[test]
fn port_defaults_to_random() {
let parsed = Args::try_parse_from(["bundla"]).unwrap();
assert_eq!(parsed.port, 0);
assert_eq!(parsed.index, "index.html");
}
#[test]
fn port_accepts_explicit_value() {
let parsed = Args::try_parse_from(["bundla", "-s", "--port", "9000"]).unwrap();
assert_eq!(parsed.port, 9000);
}
#[test]
fn server_flags_require_serve() {
for flag in [
vec!["--open"],
vec!["--header", "X: Y"],
vec!["--port", "9000"],
vec!["--ip", "0.0.0.0"],
vec!["--index", "home.html"],
] {
let mut argv = vec!["bundla"];
argv.extend(&flag);
let err = Args::try_parse_from(argv)
.err()
.expect("expected a server flag without --serve to be rejected");
assert_eq!(
err.kind(),
clap::error::ErrorKind::MissingRequiredArgument,
"flag: {flag:?}"
);
}
}
#[test]
fn output_dir_explicit_overrides() {
let prod = args(false, false, false, Some(PathBuf::from("custom")), vec![]);
assert_eq!(output_dir(&prod), PathBuf::from("custom"));
let dev = args(true, true, true, Some(PathBuf::from("custom")), vec![]);
assert_eq!(output_dir(&dev), PathBuf::from("custom"));
}
#[test]
fn output_dir_follows_profile() {
let prod = args(false, false, false, None, vec![]);
assert_eq!(output_dir(&prod), PathBuf::from("dist"));
let dev = args(true, false, false, None, vec![]);
assert_eq!(output_dir(&dev), PathBuf::from("dev"));
}
#[test]
fn build_options_default_minify_follows_profile() {
let prod = options_build(&args(false, false, false, None, vec![]));
assert_eq!(prod.minify, Minify::ALL);
let dev = options_build(&args(true, false, false, None, vec![]));
assert_eq!(dev.minify, Minify::NONE);
}
#[test]
fn build_options_minify_overrides_profile() {
let mut parsed = args(false, false, false, None, vec![]);
parsed.minify = Some(Minify::CSS | Minify::JS);
assert_eq!(options_build(&parsed).minify, Minify::CSS | Minify::JS);
let mut parsed = args(true, false, false, None, vec![]);
parsed.minify = Some(Minify::HTML);
let options = options_build(&parsed);
assert_eq!(options.minify, Minify::HTML);
assert!(options.sourcemap);
assert!(!options.hash);
}
#[test]
fn output_dir_ignores_watch_and_serve() {
let watch = args(false, true, false, None, vec![]);
assert_eq!(output_dir(&watch), PathBuf::from("dist"));
let watch_serve = args(false, true, true, None, vec![]);
assert_eq!(output_dir(&watch_serve), PathBuf::from("dist"));
let dev_watch_serve = args(true, true, true, None, vec![]);
assert_eq!(output_dir(&dev_watch_serve), PathBuf::from("dev"));
}
#[test]
fn server_config_build_maps_fields() {
let parsed = args(
false,
false,
true,
Some(PathBuf::from("out")),
vec!["X: Y".into()],
);
let config = server_config_build(&parsed, PathBuf::from("final"));
assert_eq!(config.dir, PathBuf::from("final"));
assert_eq!(config.ip, parsed.ip);
assert_eq!(config.port, 8080);
assert_eq!(config.headers, vec!["X: Y"]);
assert_eq!(config.index, "index.html");
assert_eq!(config.base, "");
}
#[test]
fn server_config_build_maps_base() {
let mut parsed = args(false, false, true, None, vec![]);
parsed.base = Some("/app".into());
let config = server_config_build(&parsed, PathBuf::from("dist"));
assert_eq!(config.base, "/app");
}
}