Support cargo aliases.

CHANGELOG.md

@@ -7,6 +7,10 @@ This project adheres to [Semantic Versioning](http://semver.org/).
 
 ## [Unreleased] - ReleaseDate
 
+## Added
+
+- #931 - add support for cargo aliases.
+
 ## Fixed
 
 - #930 - fix any parsing of 1-character subcommands

src/cargo_toml.rs

@@ -0,0 +1,246 @@
+use std::collections::{BTreeMap, BTreeSet};
+use std::env;
+use std::path::Path;
+
+use crate::errors::*;
+use crate::file;
+
+type Table = toml::value::Table;
+type Value = toml::value::Value;
+
+// the strategy is to merge, with arrays merging together
+// and the deeper the config file is, the higher its priority.
+// arrays merge, numbers/strings get replaced, objects merge in.
+// we don't want to make any assumptions about the cargo
+// config data, in case we need to use it later.
+#[derive(Debug, Clone, Default)]
+pub struct CargoConfig(Table);
+
+impl CargoConfig {
+ fn merge(&mut self, parent: &CargoConfig) -> Result<()> {
+ // can error on mismatched-data
+
+ fn validate_types(x: &Value, y: &Value) -> Option<()> {
+ match x.same_type(y) {
+ true => Some(()),
+ false => None,
+ }
+ }
+
+ // merge 2 tables. x has precedence over y.
+ fn merge_tables(x: &mut Table, y: &Table) -> Option<()> {
+ // we need to iterate over both keys, so we need a full deduplication
+ let keys: BTreeSet<String> = x.keys().chain(y.keys()).cloned().collect();
+ for key in keys {
+ let in_x = x.contains_key(&key);
+ let in_y = y.contains_key(&key);
+ match (in_x, in_y) {
+ (true, true) => {
+ // need to do our merge strategy
+ let xk = x.get_mut(&key)?;
+ let yk = y.get(&key)?;
+ validate_types(xk, yk)?;
+
+ // now we've filtered out missing keys and optional values
+ // all key/value pairs should be same type.
+ if xk.is_table() {
+ merge_tables(xk.as_table_mut()?, yk.as_table()?)?;
+ } else if xk.is_array() {
+ xk.as_array_mut()?.extend_from_slice(yk.as_array()?);
+ }
+ }
+ (false, true) => {
+ // key in y is not in x: copy it over
+ let yk = y[&key].clone();
+ x.insert(key, yk);
+ }
+ // key isn't present in y: can ignore it
+ (_, false) => (),
+ }
+ }
+
+ Some(())
+ }
+
+ merge_tables(&mut self.0, &parent.0).ok_or_else(|| eyre::eyre!("could not merge"))
+ }
+
+ // get all the aliases from the map
+ pub fn alias<'a>(&'a self) -> Option<BTreeMap<&'a str, Vec<&'a str>>> {
+ let parse_alias = |v: &'a Value| -> Option<Vec<&'a str>> {
+ if let Some(s) = v.as_str() {
+ Some(s.split_whitespace().collect())
+ } else if let Some(a) = v.as_array() {
+ a.iter().map(|i| i.as_str()).collect()
+ } else {
+ None
+ }
+ };
+
+ self.0
+ .get("alias")?
+ .as_table()?
+ .iter()
+ .map(|(k, v)| Some((k.as_str(), parse_alias(v)?)))
+ .collect()
+ }
+}
+
+fn parse_config_file(path: &Path) -> Result<CargoConfig> {
+ let contents = file::read(&path)
+ .wrap_err_with(|| format!("could not read cargo config file `{path:?}`"))?;
+ Ok(CargoConfig(toml::from_str(&contents)?))
+}
+
+// finding cargo config files actually runs from the
+// current working directory the command is invoked,
+// not from the project root. same is true with work
+// spaces: the project layout does not matter.
+pub fn read_config_files() -> Result<CargoConfig> {
+ // note: cargo supports both `config` and `config.toml`
+ // `config` exists for compatibility reasons, but if
+ // present, only it will be read.
+ let read_and_merge = |result: &mut CargoConfig, dir: &Path| -> Result<()> {
+ let noext = dir.join("config");
+ let ext = dir.join("config.toml");
+ if noext.exists() {
+ let parent = parse_config_file(&noext)?;
+ result.merge(&parent)?;
+ } else if ext.exists() {
+ let parent = parse_config_file(&ext)?;
+ result.merge(&parent)?;
+ }
+
+ Ok(())
+ };
+
+ let mut result = CargoConfig::default();
+ let cwd = env::current_dir()?;
+ let mut dir: &Path = &cwd;
+ loop {
+ read_and_merge(&mut result, &dir.join(".cargo"))?;
+ let parent_dir = dir.parent();
+ match parent_dir {
+ Some(path) => dir = path,
+ None => break,
+ }
+ }
+
+ read_and_merge(&mut result, &home::cargo_home()?)?;
+
+ Ok(result)
+}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+
+ #[test]
+ fn test_parse() -> Result<()> {
+ let config1 = CargoConfig(toml::from_str(CARGO_TOML1)?);
+ let config2 = CargoConfig(toml::from_str(CARGO_TOML2)?);
+ let alias1 = config1.alias().expect("unable to get aliases.");
+ let alias2 = config2.alias().expect("unable to get aliases.");
+ assert_eq!(
+ alias1,
+ BTreeMap::from([("foo", vec!["build", "foo"]), ("bar", vec!["check", "bar"]),])
+ );
+ assert_eq!(
+ alias2,
+ BTreeMap::from([("baz", vec!["test", "baz"]), ("bar", vec!["init", "bar"]),])
+ );
+ let mut merged = config1.clone();
+ merged.merge(&config2)?;
+ let alias_merge = merged.alias().expect("unable to get aliases.");
+ assert_eq!(
+ alias_merge,
+ BTreeMap::from([
+ ("foo", vec!["build", "foo"]),
+ ("baz", vec!["test", "baz"]),
+ ("bar", vec!["check", "bar"]),
+ ])
+ );
+
+ // check our merge went well
+ assert_eq!(
+ merged
+ .0
+ .get("build")
+ .and_then(|x| x.get("jobs"))
+ .and_then(|x| x.as_integer()),
+ Some(2),
+ );
+ assert_eq!(
+ merged
+ .0
+ .get("build")
+ .and_then(|x| x.get("rustflags"))
+ .and_then(|x| x.as_array())
+ .and_then(|x| x.iter().map(|i| i.as_str()).collect()),
+ Some(vec!["-C lto", "-Zbuild-std", "-Zdoctest-xcompile"]),
+ );
+
+ Ok(())
+ }
+
+ #[test]
+ fn test_read_config() -> Result<()> {
+ // cross contains a few aliases, so test those
+ let config = read_config_files()?;
+ let aliases = config.alias().expect("must have aliases");
+ assert_eq!(
+ aliases.get("build-docker-image"),
+ Some(&vec!["xtask", "build-docker-image"]),
+ );
+ assert_eq!(
+ aliases.get("xtask"),
+ Some(&vec!["run", "-p", "xtask", "--"]),
+ );
+
+ Ok(())
+ }
+
+ const CARGO_TOML1: &str = r#"
+[alias]
+foo = "build foo"
+bar = "check bar"
+
+[build]
+jobs = 2
+rustc-wrapper = "sccache"
+target = "x86_64-unknown-linux-gnu"
+rustflags = ["-C lto", "-Zbuild-std"]
+incremental = true
+
+[doc]
+browser = "firefox"
+
+[env]
+VAR1 = "VAL1"
+VAR2 = { value = "VAL2", force = true }
+VAR3 = { value = "relative/path", relative = true }
+"#;
+
+ const CARGO_TOML2: &str = r#"
+# want to check tables merge
+# want to check arrays concat
+# want to check rest override
+[alias]
+baz = "test baz"
+bar = "init bar"
+
+[build]
+jobs = 4
+rustc-wrapper = "sccache"
+target = "x86_64-unknown-linux-gnu"
+rustflags = ["-Zdoctest-xcompile"]
+incremental = true
+
+[doc]
+browser = "chromium"
+
+[env]
+VAR1 = "NEW1"
+VAR2 = { value = "VAL2", force = false }
+"#;
+}