Compare commits
No commits in common. "cc4684072dd5f2027c76fc66e512bc71f10623c0" and "0eb4d383927412c3692de0fae0204ba4e595a17f" have entirely different histories.
cc4684072d
...
0eb4d38392
10 changed files with 132 additions and 469 deletions
|
|
@ -32,12 +32,6 @@ pub fn run(config_path: Option<PathBuf>, dry_run: bool, prune: bool) -> anyhow::
|
|||
// Get environment variables to expose to hook scripts
|
||||
let hook_env = evaluator.get_hook_env();
|
||||
|
||||
// Warn about likely-mistaken directory targets before expanding globs, while
|
||||
// result.dotfiles still holds only the explicit (non-glob) blocks.
|
||||
for warning in directory_target_collisions(&result.dotfiles, &result.dotfile_patterns) {
|
||||
eprintln!("warning: {warning}");
|
||||
}
|
||||
|
||||
// Expand glob patterns from dotfiles: blocks
|
||||
let glob_count =
|
||||
expand_dotfile_patterns(&mut result.dotfiles, &result.dotfile_patterns, &source_dir);
|
||||
|
|
@ -556,43 +550,16 @@ pub fn run(config_path: Option<PathBuf>, dry_run: bool, prune: bool) -> anyhow::
|
|||
}
|
||||
|
||||
// Package handling
|
||||
let has_brew_extras = !result.brew_taps.is_empty() || !result.brew_formulae.is_empty();
|
||||
if !result.packages.is_empty() || has_brew_extras {
|
||||
if !result.packages.is_empty() {
|
||||
if !dry_run {
|
||||
run_hooks(&result.hooks, HookStage::BeforePackage, &hook_env)?;
|
||||
}
|
||||
|
||||
if let Some(manager) = doot_core::package::detect_package_manager() {
|
||||
let is_brew = manager.name() == "brew";
|
||||
|
||||
// Register taps first (no-op on non-brew managers).
|
||||
if !result.brew_taps.is_empty() {
|
||||
if dry_run {
|
||||
println!("\n{}would tap:", dry_prefix);
|
||||
for t in &result.brew_taps {
|
||||
println!(" {t}");
|
||||
}
|
||||
} else {
|
||||
let _ = manager.add_taps(&result.brew_taps);
|
||||
}
|
||||
}
|
||||
|
||||
// Resolve packages into formulae (install) and casks (install_casks).
|
||||
// The `cask` channel only applies on brew; elsewhere a cask package
|
||||
// falls back to its default/apt/... name like any other package.
|
||||
let mut formulae = Vec::new();
|
||||
let mut casks = Vec::new();
|
||||
let mut to_install = Vec::new();
|
||||
let mut already_installed = Vec::new();
|
||||
|
||||
for pkg in &result.packages {
|
||||
if is_brew && pkg.cask.is_some() {
|
||||
let name = pkg.cask.clone().unwrap();
|
||||
match manager.is_installed(&name) {
|
||||
Ok(true) => already_installed.push(name),
|
||||
_ => casks.push(name),
|
||||
}
|
||||
continue;
|
||||
}
|
||||
let name = match manager.name() {
|
||||
"brew" => pkg.brew.clone().or_else(|| pkg.default.clone()),
|
||||
"apt" => pkg.apt.clone().or_else(|| pkg.default.clone()),
|
||||
|
|
@ -604,31 +571,29 @@ pub fn run(config_path: Option<PathBuf>, dry_run: bool, prune: bool) -> anyhow::
|
|||
if let Some(name) = name {
|
||||
match manager.is_installed(&name) {
|
||||
Ok(true) => already_installed.push(name),
|
||||
_ => formulae.push(name),
|
||||
_ => to_install.push(name),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Brew-only formulae from `brew:` blocks (ignored on other managers).
|
||||
if is_brew {
|
||||
for name in &result.brew_formulae {
|
||||
match manager.is_installed(name) {
|
||||
Ok(true) => already_installed.push(name.clone()),
|
||||
_ => formulae.push(name.clone()),
|
||||
if !already_installed.is_empty() {
|
||||
if dry_run {
|
||||
println!("\n{}packages already installed:", dry_prefix);
|
||||
for pkg in &already_installed {
|
||||
println!(" {}", pkg);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
let total_to_install = formulae.len() + casks.len();
|
||||
|
||||
if !already_installed.is_empty() && !dry_run {
|
||||
} else {
|
||||
tracing::debug!(
|
||||
count = already_installed.len(),
|
||||
"packages already installed"
|
||||
);
|
||||
for pkg in &already_installed {
|
||||
tracing::debug!(package = %pkg, "already installed");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if total_to_install == 0 {
|
||||
if to_install.is_empty() {
|
||||
if !dry_run {
|
||||
println!(
|
||||
"\nall {} packages already installed",
|
||||
|
|
@ -636,38 +601,26 @@ pub fn run(config_path: Option<PathBuf>, dry_run: bool, prune: bool) -> anyhow::
|
|||
);
|
||||
}
|
||||
} else if dry_run {
|
||||
println!("\n{}would install:", dry_prefix);
|
||||
for pkg in formulae.iter().chain(casks.iter()) {
|
||||
println!(" {pkg}");
|
||||
println!("\n{}would install packages:", dry_prefix);
|
||||
for pkg in &to_install {
|
||||
println!(" {}", pkg);
|
||||
}
|
||||
} else {
|
||||
println!("\ninstalling {total_to_install} packages...");
|
||||
// Resilient install: a failure for one package shouldn't abort apply.
|
||||
// Warn, then keep only the ones that actually landed so state records
|
||||
// successes (not failures).
|
||||
if !formulae.is_empty() {
|
||||
if let Err(e) = manager.install(&formulae) {
|
||||
println!("\ninstalling {} packages...", to_install.len());
|
||||
// Install is resilient: a failure for one package shouldn't abort
|
||||
// apply. Warn, then keep only the packages that actually landed so
|
||||
// state records successes (and not failures).
|
||||
if let Err(e) = manager.install(&to_install) {
|
||||
eprintln!("warning: {e}");
|
||||
}
|
||||
formulae.retain(|pkg| manager.is_installed(pkg).unwrap_or(false));
|
||||
}
|
||||
if !casks.is_empty() {
|
||||
if let Err(e) = manager.install_casks(&casks) {
|
||||
eprintln!("warning: {e}");
|
||||
}
|
||||
casks.retain(|pkg| manager.is_installed(pkg).unwrap_or(false));
|
||||
}
|
||||
println!("installed {} packages", formulae.len() + casks.len());
|
||||
to_install.retain(|pkg| manager.is_installed(pkg).unwrap_or(false));
|
||||
println!("installed {} packages", to_install.len());
|
||||
}
|
||||
|
||||
if !dry_run {
|
||||
let mut state = StateStore::new(&state_file);
|
||||
let manager_name = manager.name();
|
||||
for pkg in formulae
|
||||
.iter()
|
||||
.chain(casks.iter())
|
||||
.chain(already_installed.iter())
|
||||
{
|
||||
for pkg in to_install.iter().chain(already_installed.iter()) {
|
||||
state.record_package(pkg, manager_name);
|
||||
}
|
||||
state.save()?;
|
||||
|
|
@ -686,17 +639,11 @@ pub fn run(config_path: Option<PathBuf>, dry_run: bool, prune: bool) -> anyhow::
|
|||
let mgr_name = doot_core::package::detect_package_manager()
|
||||
.map(|m| m.name().to_string())
|
||||
.unwrap_or_default();
|
||||
let mut configured_names: std::collections::HashSet<String> = result
|
||||
let configured_names: std::collections::HashSet<String> = result
|
||||
.packages
|
||||
.iter()
|
||||
.filter_map(|p| match mgr_name.as_str() {
|
||||
// On brew a cask-only package has no brew/default name, so include
|
||||
// the cask name too — otherwise it would look "removed" and be pruned.
|
||||
"brew" => p
|
||||
.cask
|
||||
.clone()
|
||||
.or_else(|| p.brew.clone())
|
||||
.or_else(|| p.default.clone()),
|
||||
"brew" => p.brew.clone().or_else(|| p.default.clone()),
|
||||
"apt" => p.apt.clone().or_else(|| p.default.clone()),
|
||||
"pacman" => p.pacman.clone().or_else(|| p.default.clone()),
|
||||
"yay" => p.yay.clone().or_else(|| p.default.clone()),
|
||||
|
|
@ -705,11 +652,6 @@ pub fn run(config_path: Option<PathBuf>, dry_run: bool, prune: bool) -> anyhow::
|
|||
})
|
||||
.collect();
|
||||
|
||||
// Brew-only formulae from `brew:` blocks are configured packages too.
|
||||
if mgr_name == "brew" {
|
||||
configured_names.extend(result.brew_formulae.iter().cloned());
|
||||
}
|
||||
|
||||
let state_for_prune = StateStore::new(&state_file);
|
||||
let to_prune: Vec<(String, String)> = state_for_prune
|
||||
.get_all_packages()
|
||||
|
|
@ -1001,40 +943,6 @@ pub(crate) fn template_outdated(
|
|||
Ok(false)
|
||||
}
|
||||
|
||||
/// Returns warnings for explicit dotfile blocks whose target is exactly a glob
|
||||
/// pattern's directory target. For a directory target, doot appends the source
|
||||
/// filename at deploy time, so the explicit entry lands on the *same path* the
|
||||
/// glob already produces — they collide instead of the explicit block overriding
|
||||
/// the glob. Targeting the specific file (`… / "<name>"`) is what makes the
|
||||
/// override fire. (`validate_dotfile_targets` can't catch this: the raw target
|
||||
/// fields differ — `…/bin` vs `…/bin/wb` — only the deployed paths coincide.)
|
||||
fn directory_target_collisions(
|
||||
dotfiles: &[DotfileConfig],
|
||||
patterns: &[DotfilesPattern],
|
||||
) -> Vec<String> {
|
||||
let mut warnings = Vec::new();
|
||||
for df in dotfiles {
|
||||
for pat in patterns {
|
||||
if df.target == pat.target_base {
|
||||
let file = df
|
||||
.source
|
||||
.file_name()
|
||||
.map(|f| f.to_string_lossy().into_owned())
|
||||
.unwrap_or_else(|| "<name>".to_string());
|
||||
warnings.push(format!(
|
||||
"dotfile '{}' targets the directory '{}', which is also a glob target. \
|
||||
It will collide with the glob instead of overriding it. \
|
||||
Did you mean: target = ... / \"{}\"",
|
||||
df.source.display(),
|
||||
df.target.display(),
|
||||
file,
|
||||
));
|
||||
}
|
||||
}
|
||||
}
|
||||
warnings
|
||||
}
|
||||
|
||||
/// Expands dotfile patterns (from `dotfiles:` blocks) into individual DotfileConfig entries.
|
||||
/// Returns the number of entries added.
|
||||
fn expand_dotfile_patterns(
|
||||
|
|
@ -1151,56 +1059,3 @@ fn merge_specializations(dotfiles: &mut Vec<DotfileConfig>, glob_count: usize) {
|
|||
dotfiles.remove(idx);
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
use doot_lang::evaluator::{DeployMode, DotfilesSource};
|
||||
|
||||
fn explicit(source: &str, target: &str) -> DotfileConfig {
|
||||
DotfileConfig {
|
||||
source: PathBuf::from(source),
|
||||
target: PathBuf::from(target),
|
||||
template: false,
|
||||
permissions: vec![],
|
||||
owner: None,
|
||||
deploy: DeployMode::default(),
|
||||
link_patterns: vec![],
|
||||
copy_patterns: vec![],
|
||||
exclude_paths: vec![],
|
||||
exclude_sources: vec![],
|
||||
}
|
||||
}
|
||||
|
||||
fn glob_pattern(pattern: &str, target_base: &str) -> DotfilesPattern {
|
||||
DotfilesPattern {
|
||||
source: DotfilesSource::Pattern(pattern.to_string()),
|
||||
target_base: PathBuf::from(target_base),
|
||||
template: false,
|
||||
permissions: vec![],
|
||||
owner: None,
|
||||
deploy: DeployMode::default(),
|
||||
link_patterns: vec![],
|
||||
copy_patterns: vec![],
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn warns_when_explicit_target_is_glob_directory() {
|
||||
// explicit `bin/wb` -> ~/.local/bin (the directory) collides with `bin/*`.
|
||||
let dotfiles = vec![explicit("bin/wb", "/home/u/.local/bin")];
|
||||
let patterns = vec![glob_pattern("bin/*", "/home/u/.local/bin")];
|
||||
let warnings = directory_target_collisions(&dotfiles, &patterns);
|
||||
assert_eq!(warnings.len(), 1);
|
||||
assert!(warnings[0].contains("wb"));
|
||||
assert!(warnings[0].contains("collide"));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn no_warning_for_specific_file_target() {
|
||||
// explicit `bin/wb` -> ~/.local/bin/wb (a file) overrides correctly.
|
||||
let dotfiles = vec![explicit("bin/wb", "/home/u/.local/bin/wb")];
|
||||
let patterns = vec![glob_pattern("bin/*", "/home/u/.local/bin")];
|
||||
assert!(directory_target_collisions(&dotfiles, &patterns).is_empty());
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -118,57 +118,19 @@ pub fn run(config_path: Option<PathBuf>) -> anyhow::Result<()> {
|
|||
}
|
||||
}
|
||||
|
||||
let has_brew_extras = !result.brew_taps.is_empty() || !result.brew_formulae.is_empty();
|
||||
if (!result.packages.is_empty() || has_brew_extras)
|
||||
&& let Some(manager) = doot_core::package::detect_package_manager()
|
||||
{
|
||||
let is_brew = manager.name() == "brew";
|
||||
|
||||
// Resolve each package to the name/channel the active manager will use,
|
||||
// mirroring `apply` (cask channel only applies on brew).
|
||||
let mut rows: Vec<(String, bool)> = Vec::new(); // (display, is_cask)
|
||||
if !result.packages.is_empty() {
|
||||
println!("\npackages ({}):", result.packages.len());
|
||||
if let Some(manager) = doot_core::package::detect_package_manager() {
|
||||
for pkg in &result.packages {
|
||||
let (name, is_cask) = if is_brew && pkg.cask.is_some() {
|
||||
(pkg.cask.clone(), true)
|
||||
} else {
|
||||
let n = match manager.name() {
|
||||
"brew" => pkg.brew.clone().or_else(|| pkg.default.clone()),
|
||||
"apt" => pkg.apt.clone().or_else(|| pkg.default.clone()),
|
||||
"pacman" => pkg.pacman.clone().or_else(|| pkg.default.clone()),
|
||||
"yay" => pkg.yay.clone().or_else(|| pkg.default.clone()),
|
||||
"xbps" => pkg.xbps.clone().or_else(|| pkg.default.clone()),
|
||||
_ => pkg.default.clone(),
|
||||
};
|
||||
(n, false)
|
||||
};
|
||||
if let Some(name) = name {
|
||||
rows.push((name, is_cask));
|
||||
}
|
||||
}
|
||||
// Brew-only formulae from `brew:` blocks (ignored on other managers).
|
||||
if is_brew {
|
||||
for name in &result.brew_formulae {
|
||||
rows.push((name.clone(), false));
|
||||
}
|
||||
}
|
||||
|
||||
println!("\npackages ({}):", rows.len());
|
||||
for (name, is_cask) in &rows {
|
||||
if let Some(ref name) = pkg.default {
|
||||
let installed = manager.is_installed(name).unwrap_or(false);
|
||||
let marker = if installed {
|
||||
"\x1b[32m✓\x1b[0m"
|
||||
} else {
|
||||
"\x1b[33m○\x1b[0m"
|
||||
};
|
||||
let suffix = if *is_cask { " (cask)" } else { "" };
|
||||
println!(" {} {}{}", marker, name, suffix);
|
||||
println!(" {} {}", marker, name);
|
||||
}
|
||||
|
||||
// Taps (brew only).
|
||||
if is_brew && !result.brew_taps.is_empty() {
|
||||
println!("\ntaps ({}):", result.brew_taps.len());
|
||||
for tap in &result.brew_taps {
|
||||
println!(" {}", tap);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -66,70 +66,6 @@ impl Brew {
|
|||
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// Installs formulae (`cask == false`) or casks (`cask == true`), continuing
|
||||
/// past individual failures. Bottles are fetched in parallel first (`brew fetch`
|
||||
/// doesn't take the global install lock), then each is installed sequentially.
|
||||
fn install_inner(&self, packages: &[String], cask: bool) -> Result<(), PackageError> {
|
||||
if packages.is_empty() {
|
||||
return Ok(());
|
||||
}
|
||||
|
||||
let kind = if cask { "casks" } else { "formulae" };
|
||||
if self.dry_run {
|
||||
let flag = if cask { "--cask " } else { "" };
|
||||
println!("[dry-run] brew install {flag}{}", packages.join(" "));
|
||||
return Ok(());
|
||||
}
|
||||
|
||||
// Phase 1: download concurrently (output captured to avoid interleaving;
|
||||
// failures here are non-fatal — the install will surface them).
|
||||
println!("downloading {} {kind}...", packages.len());
|
||||
packages.par_iter().for_each(|pkg| {
|
||||
let mut args = vec!["fetch"];
|
||||
if cask {
|
||||
args.push("--cask");
|
||||
}
|
||||
args.push(pkg);
|
||||
let _ = Command::new("brew").args(&args).output();
|
||||
});
|
||||
|
||||
// Phase 2: install each, streaming output and collecting failures.
|
||||
let mut failed = Vec::new();
|
||||
for pkg in packages {
|
||||
println!("\n==> installing {pkg}");
|
||||
let mut args = vec!["install"];
|
||||
if cask {
|
||||
args.push("--cask");
|
||||
}
|
||||
args.push(pkg);
|
||||
let succeeded = Command::new("brew")
|
||||
.args(&args)
|
||||
.status()
|
||||
.map(|s| s.success())
|
||||
.unwrap_or(false);
|
||||
if !succeeded {
|
||||
eprintln!("✗ failed to install {pkg}");
|
||||
failed.push(pkg.clone());
|
||||
}
|
||||
}
|
||||
|
||||
self.installed_cache.invalidate();
|
||||
|
||||
if failed.is_empty() {
|
||||
Ok(())
|
||||
} else {
|
||||
Err(PackageError::InstallFailed {
|
||||
package: failed.join(", "),
|
||||
message: format!(
|
||||
"{} of {} {kind} failed: {}",
|
||||
failed.len(),
|
||||
packages.len(),
|
||||
failed.join(", ")
|
||||
),
|
||||
})
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl PackageManager for Brew {
|
||||
|
|
@ -156,34 +92,52 @@ impl PackageManager for Brew {
|
|||
/// is installed sequentially so one bad formula can't abort the rest — unlike
|
||||
/// a single batched `brew install` which fails the whole set on any error.
|
||||
fn install(&self, packages: &[String]) -> Result<(), PackageError> {
|
||||
self.install_inner(packages, false)
|
||||
}
|
||||
|
||||
fn install_casks(&self, casks: &[String]) -> Result<(), PackageError> {
|
||||
self.install_inner(casks, true)
|
||||
}
|
||||
|
||||
/// Registers taps via `brew tap`. Idempotent; failures are warned, not fatal,
|
||||
/// so a single bad tap can't block installs.
|
||||
fn add_taps(&self, taps: &[String]) -> Result<(), PackageError> {
|
||||
if self.dry_run {
|
||||
for tap in taps {
|
||||
println!("[dry-run] brew tap {tap}");
|
||||
}
|
||||
if packages.is_empty() {
|
||||
return Ok(());
|
||||
}
|
||||
for tap in taps {
|
||||
println!("==> tapping {tap}");
|
||||
let ok = Command::new("brew")
|
||||
.args(["tap", tap])
|
||||
|
||||
if self.dry_run {
|
||||
println!("[dry-run] brew install {}", packages.join(" "));
|
||||
return Ok(());
|
||||
}
|
||||
|
||||
// Phase 1: download all bottles concurrently (output captured to avoid
|
||||
// interleaving; failures here are non-fatal — the install will surface them).
|
||||
println!("downloading {} bottles...", packages.len());
|
||||
packages.par_iter().for_each(|pkg| {
|
||||
let _ = Command::new("brew").args(["fetch", pkg]).output();
|
||||
});
|
||||
|
||||
// Phase 2: install each package, streaming output and collecting failures.
|
||||
let mut failed = Vec::new();
|
||||
for pkg in packages {
|
||||
println!("\n==> installing {pkg}");
|
||||
let succeeded = Command::new("brew")
|
||||
.args(["install", pkg])
|
||||
.status()
|
||||
.map(|s| s.success())
|
||||
.unwrap_or(false);
|
||||
if !ok {
|
||||
eprintln!("✗ failed to tap {tap}");
|
||||
if !succeeded {
|
||||
eprintln!("✗ failed to install {pkg}");
|
||||
failed.push(pkg.clone());
|
||||
}
|
||||
}
|
||||
|
||||
self.installed_cache.invalidate();
|
||||
|
||||
if failed.is_empty() {
|
||||
Ok(())
|
||||
} else {
|
||||
Err(PackageError::InstallFailed {
|
||||
package: failed.join(", "),
|
||||
message: format!(
|
||||
"{} of {} packages failed: {}",
|
||||
failed.len(),
|
||||
packages.len(),
|
||||
failed.join(", ")
|
||||
),
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
fn install_with_sudo(&self, packages: &[String], _password: &str) -> Result<(), PackageError> {
|
||||
|
|
|
|||
|
|
@ -91,18 +91,6 @@ pub trait PackageManager: Send + Sync {
|
|||
|
||||
/// Upgrades installed packages.
|
||||
fn upgrade(&self) -> Result<(), PackageError>;
|
||||
|
||||
/// Registers package repositories (Homebrew taps). No-op for managers without
|
||||
/// a tap concept.
|
||||
fn add_taps(&self, _taps: &[String]) -> Result<(), PackageError> {
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// Installs GUI/cask packages (Homebrew casks). Defaults to a no-op for
|
||||
/// managers without a separate cask channel.
|
||||
fn install_casks(&self, _casks: &[String]) -> Result<(), PackageError> {
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
|
||||
/// Returns true if running in test mode (DOOT_TEST_MODE=1)
|
||||
|
|
|
|||
|
|
@ -37,7 +37,6 @@ pub enum Statement {
|
|||
Import(Import),
|
||||
Dotfile(Box<Dotfile>),
|
||||
Package(Box<Package>),
|
||||
Brew(BrewConfig),
|
||||
Secret(Secret),
|
||||
Encrypted(EncryptedVars),
|
||||
Hook(Hook),
|
||||
|
|
@ -160,8 +159,6 @@ pub struct Dotfile {
|
|||
pub struct Package {
|
||||
pub default: Option<Expr>,
|
||||
pub brew: Option<PackageSpec>,
|
||||
/// Homebrew cask (macOS GUI app); installed via `brew install --cask`.
|
||||
pub cask: Option<PackageSpec>,
|
||||
pub apt: Option<PackageSpec>,
|
||||
pub pacman: Option<PackageSpec>,
|
||||
pub yay: Option<PackageSpec>,
|
||||
|
|
@ -173,16 +170,8 @@ pub struct Package {
|
|||
#[derive(Clone, Debug, PartialEq)]
|
||||
pub struct PackageSpec {
|
||||
pub name: Expr,
|
||||
}
|
||||
|
||||
/// Homebrew-specific configuration (`brew:` block): taps and brew-only formulae.
|
||||
/// macOS-only; ignored on other platforms.
|
||||
#[derive(Clone, Debug, PartialEq, Default)]
|
||||
pub struct BrewConfig {
|
||||
/// Repositories to register via `brew tap` (list expression).
|
||||
pub taps: Option<Expr>,
|
||||
/// Brew-only formulae to install (list expression).
|
||||
pub formulae: Option<Expr>,
|
||||
pub cask: Option<bool>,
|
||||
pub tap: Option<String>,
|
||||
}
|
||||
|
||||
/// Encrypted secret file declaration.
|
||||
|
|
|
|||
|
|
@ -341,8 +341,6 @@ pub struct DotfileConfig {
|
|||
pub struct PackageConfig {
|
||||
pub default: Option<String>,
|
||||
pub brew: Option<String>,
|
||||
/// Homebrew cask name (macOS); installed via `brew install --cask`.
|
||||
pub cask: Option<String>,
|
||||
pub apt: Option<String>,
|
||||
pub pacman: Option<String>,
|
||||
pub yay: Option<String>,
|
||||
|
|
@ -370,10 +368,6 @@ pub struct EvalResult {
|
|||
pub dotfiles: Vec<DotfileConfig>,
|
||||
pub dotfile_patterns: Vec<DotfilesPattern>,
|
||||
pub packages: Vec<PackageConfig>,
|
||||
/// Homebrew taps to register (from `brew:` blocks), in declaration order.
|
||||
pub brew_taps: Vec<String>,
|
||||
/// Brew-only formulae to install (from `brew:` blocks).
|
||||
pub brew_formulae: Vec<String>,
|
||||
pub secrets: Vec<SecretConfig>,
|
||||
pub hooks: Vec<HookConfig>,
|
||||
pub encrypted_vars: HashMap<String, String>,
|
||||
|
|
@ -387,8 +381,6 @@ impl Default for EvalResult {
|
|||
dotfiles: Vec::new(),
|
||||
dotfile_patterns: Vec::new(),
|
||||
packages: Vec::new(),
|
||||
brew_taps: Vec::new(),
|
||||
brew_formulae: Vec::new(),
|
||||
secrets: Vec::new(),
|
||||
hooks: Vec::new(),
|
||||
encrypted_vars: HashMap::new(),
|
||||
|
|
@ -747,11 +739,6 @@ impl Evaluator {
|
|||
} else {
|
||||
None
|
||||
};
|
||||
let cask = if let Some(ref s) = pkg.cask {
|
||||
Some(self.eval_to_string(&s.name).await?)
|
||||
} else {
|
||||
None
|
||||
};
|
||||
let apt = if let Some(ref s) = pkg.apt {
|
||||
Some(self.eval_to_string(&s.name).await?)
|
||||
} else {
|
||||
|
|
@ -776,7 +763,6 @@ impl Evaluator {
|
|||
self.result.packages.push(PackageConfig {
|
||||
default,
|
||||
brew,
|
||||
cask,
|
||||
apt,
|
||||
pacman,
|
||||
yay,
|
||||
|
|
@ -785,19 +771,6 @@ impl Evaluator {
|
|||
Ok(None)
|
||||
}
|
||||
|
||||
Statement::Brew(cfg) => {
|
||||
tracing::trace!("eval brew block");
|
||||
if let Some(ref taps) = cfg.taps {
|
||||
let taps = self.eval_to_string_list(taps).await?;
|
||||
self.result.brew_taps.extend(taps);
|
||||
}
|
||||
if let Some(ref formulae) = cfg.formulae {
|
||||
let formulae = self.eval_to_string_list(formulae).await?;
|
||||
self.result.brew_formulae.extend(formulae);
|
||||
}
|
||||
Ok(None)
|
||||
}
|
||||
|
||||
Statement::Secret(secret) => {
|
||||
let source = self.eval_to_path(&secret.source).await?;
|
||||
let target = self.eval_to_path(&secret.target).await?;
|
||||
|
|
@ -1467,16 +1440,6 @@ impl Evaluator {
|
|||
Ok(val.to_string_repr())
|
||||
}
|
||||
|
||||
/// Evaluates an expression to a list of strings. A list yields each element's
|
||||
/// string form; a single (non-list) value yields a one-element list.
|
||||
#[tracing::instrument(level = "trace", skip_all)]
|
||||
async fn eval_to_string_list(&mut self, expr: &Expr) -> Result<Vec<String>, EvalError> {
|
||||
match self.eval_expr(expr).await? {
|
||||
Value::List(items) => Ok(items.iter().map(|v| v.to_string_repr()).collect()),
|
||||
other => Ok(vec![other.to_string_repr()]),
|
||||
}
|
||||
}
|
||||
|
||||
pub fn env(&self) -> &Env {
|
||||
&self.env
|
||||
}
|
||||
|
|
|
|||
|
|
@ -33,7 +33,6 @@ pub enum Token {
|
|||
As,
|
||||
Dotfile,
|
||||
Package,
|
||||
Brew,
|
||||
Secret,
|
||||
Encrypted,
|
||||
Hook,
|
||||
|
|
@ -116,7 +115,6 @@ impl fmt::Display for Token {
|
|||
Token::As => write!(f, "as"),
|
||||
Token::Dotfile => write!(f, "dotfile"),
|
||||
Token::Package => write!(f, "package"),
|
||||
Token::Brew => write!(f, "brew"),
|
||||
Token::Secret => write!(f, "secret"),
|
||||
Token::Encrypted => write!(f, "encrypted"),
|
||||
Token::Hook => write!(f, "hook"),
|
||||
|
|
@ -256,7 +254,6 @@ impl Lexer {
|
|||
"as" => Token::As,
|
||||
"dotfile" => Token::Dotfile,
|
||||
"package" => Token::Package,
|
||||
"brew" => Token::Brew,
|
||||
"secret" => Token::Secret,
|
||||
"encrypted" => Token::Encrypted,
|
||||
"hook" => Token::Hook,
|
||||
|
|
|
|||
|
|
@ -75,21 +75,28 @@ impl MacroExpander {
|
|||
default: pkg.default.as_ref().map(|e| self.substitute_expr(e, subs)),
|
||||
brew: pkg.brew.as_ref().map(|s| PackageSpec {
|
||||
name: self.substitute_expr(&s.name, subs),
|
||||
}),
|
||||
cask: pkg.cask.as_ref().map(|s| PackageSpec {
|
||||
name: self.substitute_expr(&s.name, subs),
|
||||
cask: s.cask,
|
||||
tap: s.tap.clone(),
|
||||
}),
|
||||
apt: pkg.apt.as_ref().map(|s| PackageSpec {
|
||||
name: self.substitute_expr(&s.name, subs),
|
||||
cask: s.cask,
|
||||
tap: s.tap.clone(),
|
||||
}),
|
||||
pacman: pkg.pacman.as_ref().map(|s| PackageSpec {
|
||||
name: self.substitute_expr(&s.name, subs),
|
||||
cask: s.cask,
|
||||
tap: s.tap.clone(),
|
||||
}),
|
||||
yay: pkg.yay.as_ref().map(|s| PackageSpec {
|
||||
name: self.substitute_expr(&s.name, subs),
|
||||
cask: s.cask,
|
||||
tap: s.tap.clone(),
|
||||
}),
|
||||
xbps: pkg.xbps.as_ref().map(|s| PackageSpec {
|
||||
name: self.substitute_expr(&s.name, subs),
|
||||
cask: s.cask,
|
||||
tap: s.tap.clone(),
|
||||
}),
|
||||
when: pkg.when.as_ref().map(|e| self.substitute_expr(e, subs)),
|
||||
})),
|
||||
|
|
|
|||
|
|
@ -44,7 +44,6 @@ impl Parser {
|
|||
let import = Self::import_parser().map(Statement::Import);
|
||||
let dotfile = Self::dotfile_parser().map(|d| Statement::Dotfile(Box::new(d)));
|
||||
let package = Self::package_parser().map(|p| Statement::Package(Box::new(p)));
|
||||
let brew = Self::brew_parser().map(Statement::Brew);
|
||||
let secret = Self::secret_parser().map(Statement::Secret);
|
||||
let encrypted = Self::encrypted_parser().map(Statement::Encrypted);
|
||||
let hook = Self::hook_parser().map(Statement::Hook);
|
||||
|
|
@ -67,7 +66,6 @@ impl Parser {
|
|||
import,
|
||||
dotfile,
|
||||
package,
|
||||
brew,
|
||||
secret,
|
||||
encrypted,
|
||||
hook,
|
||||
|
|
@ -223,11 +221,7 @@ impl Parser {
|
|||
}
|
||||
|
||||
fn field_name_parser() -> impl chumsky::Parser<Token, String, Error = Simple<Token>> + Clone {
|
||||
Self::ident_parser()
|
||||
.or(just(Token::When).to("when".to_string()))
|
||||
// `brew` is a keyword (for the `brew:` block) but is also a valid
|
||||
// package-manager field name inside `package:` blocks.
|
||||
.or(just(Token::Brew).to("brew".to_string()))
|
||||
Self::ident_parser().or(just(Token::When).to("when".to_string()))
|
||||
}
|
||||
|
||||
fn dotfile_parser() -> impl chumsky::Parser<Token, Dotfile, Error = Simple<Token>> {
|
||||
|
|
@ -317,7 +311,6 @@ impl Parser {
|
|||
.map(|name| Package {
|
||||
default: Some(name),
|
||||
brew: None,
|
||||
cask: None,
|
||||
apt: None,
|
||||
pacman: None,
|
||||
yay: None,
|
||||
|
|
@ -345,7 +338,6 @@ impl Parser {
|
|||
let mut pkg = Package {
|
||||
default: None,
|
||||
brew: None,
|
||||
cask: None,
|
||||
apt: None,
|
||||
pacman: None,
|
||||
yay: None,
|
||||
|
|
@ -355,12 +347,41 @@ impl Parser {
|
|||
for (name, value) in fields {
|
||||
match name.as_str() {
|
||||
"default" => pkg.default = Some(value),
|
||||
"brew" => pkg.brew = Some(PackageSpec { name: value }),
|
||||
"cask" => pkg.cask = Some(PackageSpec { name: value }),
|
||||
"apt" => pkg.apt = Some(PackageSpec { name: value }),
|
||||
"pacman" => pkg.pacman = Some(PackageSpec { name: value }),
|
||||
"yay" => pkg.yay = Some(PackageSpec { name: value }),
|
||||
"xbps" => pkg.xbps = Some(PackageSpec { name: value }),
|
||||
"brew" => {
|
||||
pkg.brew = Some(PackageSpec {
|
||||
name: value,
|
||||
cask: None,
|
||||
tap: None,
|
||||
})
|
||||
}
|
||||
"apt" => {
|
||||
pkg.apt = Some(PackageSpec {
|
||||
name: value,
|
||||
cask: None,
|
||||
tap: None,
|
||||
})
|
||||
}
|
||||
"pacman" => {
|
||||
pkg.pacman = Some(PackageSpec {
|
||||
name: value,
|
||||
cask: None,
|
||||
tap: None,
|
||||
})
|
||||
}
|
||||
"yay" => {
|
||||
pkg.yay = Some(PackageSpec {
|
||||
name: value,
|
||||
cask: None,
|
||||
tap: None,
|
||||
})
|
||||
}
|
||||
"xbps" => {
|
||||
pkg.xbps = Some(PackageSpec {
|
||||
name: value,
|
||||
cask: None,
|
||||
tap: None,
|
||||
})
|
||||
}
|
||||
"when" => pkg.when = Some(value),
|
||||
_ => {}
|
||||
}
|
||||
|
|
@ -371,37 +392,6 @@ impl Parser {
|
|||
inline.or(block)
|
||||
}
|
||||
|
||||
/// Parses a `brew:` block holding brew-only configuration (`taps`, `formulae`).
|
||||
fn brew_parser() -> impl chumsky::Parser<Token, BrewConfig, Error = Simple<Token>> {
|
||||
let field = Self::field_name_parser()
|
||||
.then_ignore(just(Token::Eq))
|
||||
.then(Self::expr_parser());
|
||||
|
||||
just(Token::Brew)
|
||||
.ignore_then(just(Token::Colon))
|
||||
.ignore_then(just(Token::Newline).repeated())
|
||||
.ignore_then(Self::indent_parser())
|
||||
.ignore_then(
|
||||
field
|
||||
.padded_by(Self::indent_parser())
|
||||
.padded_by(just(Token::Newline).repeated())
|
||||
.repeated()
|
||||
.at_least(1),
|
||||
)
|
||||
.then_ignore(just(Token::Dedent).or_not())
|
||||
.map(|fields| {
|
||||
let mut cfg = BrewConfig::default();
|
||||
for (name, value) in fields {
|
||||
match name.as_str() {
|
||||
"taps" => cfg.taps = Some(value),
|
||||
"formulae" => cfg.formulae = Some(value),
|
||||
_ => {}
|
||||
}
|
||||
}
|
||||
cfg
|
||||
})
|
||||
}
|
||||
|
||||
fn secret_parser() -> impl chumsky::Parser<Token, Secret, Error = Simple<Token>> {
|
||||
let field = Self::field_name_parser()
|
||||
.then_ignore(just(Token::Eq))
|
||||
|
|
@ -1067,33 +1057,6 @@ mod tests {
|
|||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_brew_block_and_cask_field() {
|
||||
// `brew:` block with taps + formulae lists.
|
||||
let program = parse_source(
|
||||
"brew:\n taps = [\"homebrew/cask-fonts\"]\n formulae = [\"mas\", \"trash\"]\n",
|
||||
);
|
||||
assert_eq!(program.statements.len(), 1);
|
||||
match &program.statements[0].node {
|
||||
Statement::Brew(cfg) => {
|
||||
assert!(cfg.taps.is_some());
|
||||
assert!(cfg.formulae.is_some());
|
||||
}
|
||||
other => panic!("expected Brew statement, got {other:?}"),
|
||||
}
|
||||
|
||||
// `cask` is a package field; `brew` still works as a field name despite
|
||||
// being a keyword now.
|
||||
let program = parse_source("package:\n brew = \"ripgrep\"\n cask = \"firefox\"\n");
|
||||
match &program.statements[0].node {
|
||||
Statement::Package(pkg) => {
|
||||
assert!(pkg.brew.is_some());
|
||||
assert!(pkg.cask.is_some());
|
||||
}
|
||||
other => panic!("expected Package statement, got {other:?}"),
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_encrypted_file_entries() {
|
||||
let src = "encrypted:\n SSH_KEY = file(\"secrets/id_rsa.age\")\n CONFIG = file(\"secrets/app.conf.age\")\n";
|
||||
|
|
|
|||
|
|
@ -181,20 +181,8 @@ pub fn validate_dotfile_targets(
|
|||
index_b: j,
|
||||
});
|
||||
} else {
|
||||
// Different source + same target = override, j depends on i.
|
||||
// Layering is supported, but two sources fighting over one file
|
||||
// is usually a mistake, so surface it as a warning (last wins).
|
||||
// Different source + same target = override, j depends on i
|
||||
graph.add_edge(&format!("dotfile_{}", i), &format!("dotfile_{}", j));
|
||||
warnings.push(DotfileWarning {
|
||||
message: format!(
|
||||
"'{}' and '{}' both deploy to '{}'; the later entry wins",
|
||||
a.source.display(),
|
||||
b.source.display(),
|
||||
target_a.display()
|
||||
),
|
||||
index_a: i,
|
||||
index_b: j,
|
||||
});
|
||||
}
|
||||
continue;
|
||||
}
|
||||
|
|
@ -346,9 +334,6 @@ mod tests {
|
|||
assert!(result.errors.is_empty());
|
||||
// Second entry should come after first
|
||||
assert_eq!(result.ordered_indices, vec![0, 1]);
|
||||
// Two different sources hitting one target is allowed (last wins) but warns.
|
||||
assert_eq!(result.warnings.len(), 1);
|
||||
assert!(result.warnings[0].message.contains("both deploy to"));
|
||||
}
|
||||
|
||||
#[test]
|
||||
|
|
|
|||
Loading…
Reference in a new issue