///|
/// 按 Bun 的规则展开一份已解析的键值映射。
///
/// 作用域是「`lookup`(进程环境)+ 本文件」,不跨文件;只展开一层,被引用的值不再
/// 递归展开;未定义展开成空串;`${NAME:-默认}` 只在名字**未定义**时用默认值。
///
/// 自引用与循环引用天然得到 Bun 的结果:`A=${A}` 引用到自己时取到的原文就是
/// `${A}`,原样写回,不需要额外的环检测。
pub fn expand_map(
raw : Map[String, String],
lookup : (String) -> String?,
) -> Map[String, String] {
let out : Map[String, String] = Map([])
for pair in raw.iter() {
let (key, value) = pair
out[key] = expand_value(value, raw, lookup)
}
out
}
///|
/// 展开一个值。`\$` 转成字面 `$` 并就此打住,后面的字符不再参与引用解析。
fn expand_value(
text : String,
raw : Map[String, String],
lookup : (String) -> String?,
) -> String {
let n = text.length()
let buf = StringBuilder()
let mut i = 0
let mut run = 0
while i < n {
let c = text[i]
if c == '\\' && i + 1 < n && text[i + 1] == '$' {
buf.write_string(text[run:i].to_owned())
buf.write_string("$")
i += 2
run = i
continue
}
if c == '$' {
match read_ref(text, i) {
Some((name, default, end)) => {
buf.write_string(text[run:i].to_owned())
match resolve(name, raw, lookup) {
Some(value) => buf.write_string(value)
None =>
match default {
Some(fallback) =>
buf.write_string(expand_value(fallback, raw, lookup))
None => ()
}
}
i = end
run = i
continue
}
// 不是合法引用:`$` 当普通字符,留在片段里一起输出。
None => {
i += 1
continue
}
}
}
i += 1
}
buf.write_string(text[run:n].to_owned())
buf.to_string()
}
///|
/// 在指向 `$` 的位置解析一个引用,返回(名字, 默认值, 结束下标)。
/// `None` 表示这个 `$` 后面不是引用,按普通字符处理。
fn read_ref(text : String, at : Int32) -> (String, String?, Int32)? {
let n = text.length()
let i = at + 1
if i < n && text[i] == '{' {
let start = i + 1
let mut j = start
// 允许默认值里再嵌一层引用:`${A:-${B}}` 要找到外层那个 `}`。
let mut depth = 0
while j < n {
let cj = text[j]
if cj == '{' {
depth += 1
} else if cj == '}' {
if depth == 0 {
break
}
depth -= 1
}
j += 1
}
if j >= n {
return None
}
let inner = text[start:j].to_owned()
let end = j + 1
match split_default(inner) {
Some((name, fallback)) => Some((name, Some(fallback), end))
None => Some((inner, None, end))
}
} else {
let mut j = i
while j < n && is_name_char(text[j]) {
j += 1
}
if j == i {
return None
}
Some((text[i:j].to_owned(), None, j))
}
}
///|
/// `${NAME:-默认}` 的切分。只有 `:-` 受支持;`-`、`?` 之类保持原样(Bun 也不支持)。
fn split_default(inner : String) -> (String, String)? {
let n = inner.length()
let mut i = 0
while i + 1 < n {
if inner[i] == ':' && inner[i + 1] == '-' {
return Some((inner[0:i].to_owned(), inner[i + 2:n].to_owned()))
}
i += 1
}
None
}
///|
/// 名字的解析顺序:进程环境优先,其次本文件。文件名里没有的返回 `None`。
fn resolve(
name : String,
raw : Map[String, String],
lookup : (String) -> String?,
) -> String? {
match lookup(name) {
Some(value) => Some(value)
None => raw.get(name)
}
}
///|
/// 变量名允许的字符,与解析阶段保持同一套。
fn is_name_char(c : UInt16) -> Bool {
let v = c.to_int()
(v >= 65 && v <= 90) ||
(v >= 97 && v <= 122) ||
(v >= 48 && v <= 57) ||
v == 95
}