use crate::ast::{Expr, Stmt, StrPart};
use crate::builtins::{is_builtin_lib, resolve_in, resolve_require_in};
use std::collections::HashSet;
use std::path::{Path, PathBuf};
pub struct BundleReport {
pub files: Vec<PathBuf>,
pub dynamic: usize,
}
pub fn bundle(entry: &Path) -> Result<(Vec<Stmt>, BundleReport), String> {
let abs = std::fs::canonicalize(entry)
.map_err(|e| format!("cannot read {}: {e}", entry.display()))?;
let dir = abs
.parent()
.map(Path::to_path_buf)
.unwrap_or_else(|| PathBuf::from("."));
let cwd = std::env::current_dir().unwrap_or_else(|_| PathBuf::from("."));
let mut load_dirs = vec![dir.clone()];
if cwd != dir {
load_dirs.push(cwd);
}
let mut stmts = crate::parser::parse(&read(&abs)?)?;
let mut b = Bundler {
seen: HashSet::new(),
files: vec![abs.clone()],
dynamic: 0,
load_dirs,
};
b.seen.insert(abs);
b.walk_body(&mut stmts, &dir)?;
Ok((
stmts,
BundleReport {
files: b.files,
dynamic: b.dynamic,
},
))
}
struct Bundler {
seen: HashSet<PathBuf>,
files: Vec<PathBuf>,
dynamic: usize,
load_dirs: Vec<PathBuf>,
}
impl Bundler {
fn walk_body(&mut self, body: &mut [Stmt], base: &Path) -> Result<(), String> {
for s in body {
self.walk_expr(&mut s.expr, base)?;
}
Ok(())
}
fn walk_expr(&mut self, e: &mut Expr, base: &Path) -> Result<(), String> {
if self.try_require(e, base)? {
return Ok(());
}
match e {
Expr::Str(parts) => {
for p in parts {
if let StrPart::Interp(x) = p {
self.walk_expr(x, base)?;
}
}
}
Expr::Array(xs) => self.walk_exprs(xs, base)?,
Expr::Hash(pairs) => {
for (k, v) in pairs {
self.walk_expr(k, base)?;
self.walk_expr(v, base)?;
}
}
Expr::Range { lo, hi, .. } => {
self.walk_opt(lo, base)?;
self.walk_opt(hi, base)?;
}
Expr::Assign(t, v) => {
self.walk_expr(t, base)?;
self.walk_expr(v, base)?;
}
Expr::MultiAssign { targets, values } => {
self.walk_exprs(targets, base)?;
self.walk_exprs(values, base)?;
}
Expr::Unary(_, x) => self.walk_expr(x, base)?,
Expr::Binary(_, a, b) => {
self.walk_expr(a, base)?;
self.walk_expr(b, base)?;
}
Expr::If {
cond,
then,
elifs,
els,
} => {
self.walk_expr(cond, base)?;
self.walk_body(then, base)?;
for (c, body) in elifs {
self.walk_expr(c, base)?;
self.walk_body(body, base)?;
}
if let Some(body) = els {
self.walk_body(body, base)?;
}
}
Expr::While { cond, body } | Expr::DoWhile { cond, body } => {
self.walk_expr(cond, base)?;
self.walk_body(body, base)?;
}
Expr::For { iter, body, .. } => {
self.walk_expr(iter, base)?;
self.walk_body(body, base)?;
}
Expr::Case {
subject,
whens,
els,
} => {
self.walk_expr(subject, base)?;
for (conds, body) in whens {
self.walk_exprs(conds, base)?;
self.walk_body(body, base)?;
}
if let Some(body) = els {
self.walk_body(body, base)?;
}
}
Expr::CaseIn {
subject,
clauses,
els,
} => {
self.walk_expr(subject, base)?;
for cl in clauses {
if let Some(g) = &mut cl.guard {
self.walk_expr(g, base)?;
}
self.walk_body(&mut cl.body, base)?;
}
if let Some(body) = els {
self.walk_body(body, base)?;
}
}
Expr::Call { recv, args, .. } => {
self.walk_opt(recv, base)?;
self.walk_exprs(args, base)?;
}
Expr::Index(recv, idxs) => {
self.walk_expr(recv, base)?;
self.walk_exprs(idxs, base)?;
}
Expr::Class { body, .. } | Expr::Module { body, .. } => self.walk_body(body, base)?,
Expr::SingletonClass { body, .. } => self.walk_body(body, base)?,
Expr::Begin {
body,
rescues,
ensure,
} => {
self.walk_body(body, base)?;
for r in rescues {
self.walk_body(&mut r.body, base)?;
}
if let Some(body) = ensure {
self.walk_body(body, base)?;
}
}
Expr::Return(x) | Expr::Break(x) | Expr::Next(x) => self.walk_opt(x, base)?,
Expr::Yield(xs) => self.walk_exprs(xs, base)?,
Expr::Super { args: Some(xs), .. } => self.walk_exprs(xs, base)?,
Expr::Splat(x) => self.walk_expr(x, base)?,
Expr::Defined(x) => self.walk_expr(x, base)?,
_ => {}
}
Ok(())
}
fn walk_exprs(&mut self, xs: &mut [Expr], base: &Path) -> Result<(), String> {
for x in xs {
self.walk_expr(x, base)?;
}
Ok(())
}
fn walk_opt(&mut self, x: &mut Option<Box<Expr>>, base: &Path) -> Result<(), String> {
if let Some(x) = x {
self.walk_expr(x, base)?;
}
Ok(())
}
fn try_require(&mut self, e: &mut Expr, base: &Path) -> Result<bool, String> {
let (relative, raw) = match e {
Expr::Call {
recv: None,
name,
args,
block: None,
} => {
let relative = match name.as_str() {
"require" => false,
"require_relative" => true,
_ => return Ok(false),
};
match args.as_slice() {
[arg] => match literal_str(arg) {
Some(s) => (relative, s),
None => {
self.dynamic += 1;
return Ok(false);
}
},
_ => return Ok(false),
}
}
_ => return Ok(false),
};
if !relative && is_builtin_lib(&raw) {
self.dynamic += 1;
return Ok(false);
}
let resolved = if relative {
resolve_in(base, &raw)
} else {
resolve_require_in(&self.load_dirs, &raw)
};
let Some(target) = resolved else {
self.dynamic += 1;
return Ok(false);
};
if self.seen.contains(&target) {
*e = Expr::False; return Ok(true);
}
self.seen.insert(target.clone());
self.files.push(target.clone());
let src = read(&target)?;
let mut stmts = crate::parser::parse(&src)?;
let child_dir = target
.parent()
.map(Path::to_path_buf)
.unwrap_or_else(|| PathBuf::from("."));
self.walk_body(&mut stmts, &child_dir)?;
*e = Expr::Begin {
body: stmts,
rescues: vec![],
ensure: None,
};
Ok(true)
}
}
fn literal_str(e: &Expr) -> Option<String> {
match e {
Expr::Str(parts) => {
let mut s = String::new();
for p in parts {
match p {
StrPart::Lit(t) => s.push_str(t),
StrPart::Interp(_) => return None,
StrPart::Bytes(_) => return None,
}
}
Some(s)
}
_ => None,
}
}
fn read(p: &Path) -> Result<String, String> {
std::fs::read_to_string(p).map_err(|e| format!("cannot read {}: {e}", p.display()))
}