Merge ignore and complete.

Author: Alexhuszagh

docs/cross_toml.md

@@ -21,8 +21,7 @@ For example:
 
 ```toml
 [build.env]
-complete-cargo-config = true
-ignore-cargo-config = false
+cargo-config = "complete"
 volumes = ["VOL1_ARG", "VOL2_ARG"]
 passthrough = ["IMPORTANT_ENV_VARIABLES"]
 ```
@@ -65,6 +64,7 @@ This is similar to `build.env`, but allows you to be more specific per target.
 
 ```toml
 [target.x86_64-unknown-linux-gnu.env]
+cargo-config = "ignore"
 volumes = ["VOL1_ARG", "VOL2_ARG"]
 passthrough = ["IMPORTANT_ENV_VARIABLES"]
 ```

src/cross_config.rs

@@ -1,4 +1,5 @@
 use std::collections::HashMap;
+use std::str::FromStr;
 
 use crate::config::{bool_from_envvar, split_to_cloned_by_ws, Environment};
 use crate::cross_toml::CargoConfigBehavior;
@@ -85,15 +86,18 @@ impl CrossEnvironment {
         self.get_target_var(target, "RUNNER")
     }
 
-    // TODO(ahuszagh) Need to change this.
-    //  Need to have an enum here.
-
-    fn complete_cargo_config(&self, target: &Target) -> (Option<bool>, Option<bool>) {
-        self.get_values_for("ENV_COMPLETE_CARGO_CONFIG", target, bool_from_envvar)
-    }
-
-    fn ignore_cargo_config(&self, target: &Target) -> (Option<bool>, Option<bool>) {
-        self.get_values_for("ENV_IGNORE_CARGO_CONFIG", target, bool_from_envvar)
+    fn cargo_config(
+        &self,
+        target: &Target,
+    ) -> Result<(Option<CargoConfigBehavior>, Option<CargoConfigBehavior>)> {
+        let (build, target) =
+            self.get_values_for("ENV_CARGO_CONFIG", target, CargoConfigBehavior::from_str);
+        Ok(match (build, target) {
+            (Some(b), Some(t)) => (Some(b?), Some(t?)),
+            (Some(b), None) => (Some(b?), None),
+            (None, Some(t)) => (None, Some(t?)),
+            (None, None) => (None, None),
+        })
     }
 
     fn passthrough(&self, target: &Target) -> (Option<Vec<String>>, Option<Vec<String>>) {
@@ -280,23 +284,27 @@ impl CrossConfig {
         self.env.custom_toolchain()
     }
 
-    // TODO(ahuszagh) This should actually be an enough
-    //  Ignore, default, complete.
+    pub fn env_cargo_config(&self, target: &Target) -> Result<Option<CargoConfigBehavior>> {
+        let (env_build, env_target) = self.env.cargo_config(target)?;
 
-    pub fn env_complete_cargo_config(&self, target: &Target) -> Option<bool> {
-        self.bool_from_config(
-            target,
-            CrossEnvironment::complete_cargo_config,
-            CrossToml::env_complete_cargo_config,
-        )
-    }
+        if let Some(env_target) = env_target {
+            return Ok(Some(env_target));
+        }
 
-    pub fn env_ignore_cargo_config(&self, target: &Target) -> Option<bool> {
-        self.bool_from_config(
-            target,
-            CrossEnvironment::ignore_cargo_config,
-            CrossToml::env_ignore_cargo_config,
-        )
+        let (build, target) = self
+            .toml
+            .as_ref()
+            .map(|t| t.env_cargo_config(target))
+            .unwrap_or_default();
+
+        // FIXME: let expression
+        if target.is_none() && env_build.is_some() {
+            Ok(env_build)
+        } else if target.is_none() {
+            Ok(build)
+        } else {
+            Ok(target)
+        }
     }
 
     pub fn env_passthrough(&self, target: &Target) -> Result<Option<Vec<String>>> {

src/cross_toml.rs

@@ -17,10 +17,7 @@ use serde::{Deserialize, Deserializer, Serialize};
 #[derive(Debug, Serialize, Deserialize, PartialEq, Eq, Default)]
 #[serde(rename_all = "kebab-case")]
 pub struct CrossEnvConfig {
-    // TODO(ahuszagh) Change to an enum
     cargo_config: Option<CargoConfigBehavior>,
-    complete_cargo_config: Option<bool>,
-    ignore_cargo_config: Option<bool>,
     volumes: Option<Vec<String>>,
     passthrough: Option<Vec<String>>,
 }
@@ -356,30 +353,11 @@ impl CrossToml {
     }
 
     /// Returns the cargo config behavior.
-    pub fn env_cargo_config(&self, target: &Target) -> (Option<CargoConfigBehavior>, Option<CargoConfigBehavior>) {
-        self.get_value(
-            target,
-            |b| b.env.cargo_config,
-            |t| t.env.cargo_config,
-        )
-    }
-
-    /// Returns the whether to use the complete cargo config settings.
-    pub fn env_complete_cargo_config(&self, target: &Target) -> (Option<bool>, Option<bool>) {
-        self.get_value(
-            target,
-            |b| b.env.complete_cargo_config,
-            |t| t.env.complete_cargo_config,
-        )
-    }
-
-    /// Returns the whether to ignore cargo config files.
-    pub fn env_ignore_cargo_config(&self, target: &Target) -> (Option<bool>, Option<bool>) {
-        self.get_value(
-            target,
-            |b| b.env.ignore_cargo_config,
-            |t| t.env.ignore_cargo_config,
-        )
+    pub fn env_cargo_config(
+        &self,
+        target: &Target,
+    ) -> (Option<CargoConfigBehavior>, Option<CargoConfigBehavior>) {
+        self.get_value(target, |b| b.env.cargo_config, |t| t.env.cargo_config)
     }
 
     /// Returns the list of environment variables to pass through for `build` and `target`
@@ -582,7 +560,10 @@ mod tests {
     pub fn test_toml_cargo_config_behavior() -> Result<()> {
         assert_eq!(CargoConfigBehavior::Normal, toml::from_str("\"default\"")?);
         assert_eq!(CargoConfigBehavior::Ignore, toml::from_str("\"ignore\"")?);
-        assert_eq!(CargoConfigBehavior::Complete, toml::from_str("\"complete\"")?);
+        assert_eq!(
+            CargoConfigBehavior::Complete,
+            toml::from_str("\"complete\"")?
+        );
         assert!(toml::from_str::<CargoConfigBehavior>("\"other\"").is_err());
         assert!(toml::from_str::<CargoConfigBehavior>("true").is_err());
         assert!(toml::from_str::<CargoConfigBehavior>("0").is_err());
@@ -610,10 +591,7 @@ mod tests {
             targets: HashMap::new(),
             build: CrossBuildConfig {
                 env: CrossEnvConfig {
-                    // TODO(ahuszagh) Remove
-                    cargo_config: None,
-                    complete_cargo_config: None,
-                    ignore_cargo_config: Some(false),
+                    cargo_config: Some(CargoConfigBehavior::Ignore),
                     volumes: Some(vec![s!("VOL1_ARG"), s!("VOL2_ARG")]),
                     passthrough: Some(vec![s!("VAR1"), s!("VAR2")]),
                 },
@@ -631,7 +609,7 @@ mod tests {
           pre-build = ["echo 'Hello World!'"]
 
           [build.env]
-          ignore-cargo-config = false
+          cargo-config = "ignore"
           volumes = ["VOL1_ARG", "VOL2_ARG"]
           passthrough = ["VAR1", "VAR2"]
         "#;
@@ -652,10 +630,7 @@ mod tests {
             },
             CrossTargetConfig {
                 env: CrossEnvConfig {
-                    // TODO(ahuszagh) Remove
                     cargo_config: None,
-                    complete_cargo_config: None,
-                    ignore_cargo_config: None,
                     passthrough: Some(vec![s!("VAR1"), s!("VAR2")]),
                     volumes: Some(vec![s!("VOL1_ARG"), s!("VOL2_ARG")]),
                 },
@@ -710,10 +685,7 @@ mod tests {
                 pre_build: Some(PreBuild::Lines(vec![s!("echo 'Hello'")])),
                 runner: None,
                 env: CrossEnvConfig {
-                    // TODO(ahuszagh) Remove
                     cargo_config: None,
-                    complete_cargo_config: None,
-                    ignore_cargo_config: None,
                     passthrough: None,
                     volumes: Some(vec![s!("VOL")]),
                 },
@@ -724,10 +696,7 @@ mod tests {
             targets: target_map,
             build: CrossBuildConfig {
                 env: CrossEnvConfig {
-                    // TODO(ahuszagh) Remove
-                    cargo_config: None,
-                    complete_cargo_config: None,
-                    ignore_cargo_config: Some(true),
+                    cargo_config: Some(CargoConfigBehavior::Complete),
                     volumes: None,
                     passthrough: Some(vec![]),
                 },
@@ -745,7 +714,7 @@ mod tests {
             pre-build = []
 
             [build.env]
-            ignore-cargo-config = true
+            cargo-config = "complete"
             passthrough = []
 
             [target.aarch64-unknown-linux-gnu]
@@ -787,10 +756,7 @@ mod tests {
             targets: HashMap::new(),
             build: CrossBuildConfig {
                 env: CrossEnvConfig {
-                    // TODO(ahuszagh) Remove
                     cargo_config: None,
-                    complete_cargo_config: None,
-                    ignore_cargo_config: None,
                     passthrough: None,
                     volumes: None,
                 },

src/docker/local.rs

@@ -55,7 +55,7 @@ pub(crate) fn run(
     docker
         .args(&["-v", &format!("{}:/rust:Z,ro", dirs.sysroot.to_utf8()?)])
         .args(&["-v", &format!("{}:/target:Z", dirs.target.to_utf8()?)]);
-    docker_cwd(&mut docker, &paths, options.ignore_cargo_config)?;
+    docker_cwd(&mut docker, &paths, options.cargo_config_behavior)?;
 
     // When running inside NixOS or using Nix packaging we need to add the Nix
     // Store to the running container so it can load the needed binaries.

src/docker/remote.rs

@@ -1170,7 +1170,7 @@ symlink_recurse \"${{prefix}}\"
     let mut docker = subcommand(engine, "exec");
     docker_user_id(&mut docker, engine.kind);
     docker_envvars(&mut docker, &options.config.cross, target, msg_info)?;
-    docker_cwd(&mut docker, &paths, options.ignore_cargo_config)?;
+    docker_cwd(&mut docker, &paths, options.cargo_config_behavior)?;
     docker.arg(&container);
     docker.args(&["sh", "-c", &format!("PATH=$PATH:/rust/bin {:?}", cmd)]);
     bail_container_exited!();

src/docker/shared.rs

@@ -9,6 +9,7 @@ use crate::cargo::{cargo_metadata_with_args, CargoMetadata};
 use crate::cargo_config::CARGO_NO_PREFIX_ENVVARS;
 use crate::config::{bool_from_envvar, Config};
 use crate::cross_config::CrossConfig;
+use crate::cross_toml::CargoConfigBehavior;
 use crate::errors::*;
 use crate::extensions::{CommandExt, SafeCommand};
 use crate::file::{self, write_file, PathExt, ToUtf8};
@@ -39,7 +40,7 @@ pub struct DockerOptions {
     pub target: Target,
     pub config: Config,
     pub uses_xargo: bool,
-    pub ignore_cargo_config: bool,
+    pub cargo_config_behavior: CargoConfigBehavior,
 }
 
 impl DockerOptions {
@@ -48,14 +49,14 @@ impl DockerOptions {
         target: Target,
         config: Config,
         uses_xargo: bool,
-        ignore_cargo_config: bool,
+        cargo_config_behavior: CargoConfigBehavior,
     ) -> DockerOptions {
         DockerOptions {
             engine,
             target,
             config,
             uses_xargo,
-            ignore_cargo_config,
+            cargo_config_behavior,
         }
     }
 
@@ -513,7 +514,7 @@ pub(crate) fn docker_envvars(
 fn mount_to_ignore_cargo_config(
     docker: &mut Command,
     paths: &DockerPaths,
-    ignore_cargo_config: bool,
+    cargo_config_behavior: CargoConfigBehavior,
 ) -> Result<()> {
     let check_mount =
         |cmd: &mut Command, host: &Path, mount: &Path, relpath: &Path| -> Result<()> {
@@ -525,7 +526,7 @@ fn mount_to_ignore_cargo_config(
 
             Ok(())
         };
-    if ignore_cargo_config {
+    if let CargoConfigBehavior::Ignore = cargo_config_behavior {
         let mount_root = Path::new(paths.mount_root());
         let mount_cwd = Path::new(paths.mount_cwd());
         check_mount(docker, &paths.cwd, mount_cwd, Path::new(""))?;
@@ -544,10 +545,10 @@ fn mount_to_ignore_cargo_config(
 pub(crate) fn docker_cwd(
     docker: &mut Command,
     paths: &DockerPaths,
-    ignore_cargo_config: bool,
+    cargo_config_behavior: CargoConfigBehavior,
 ) -> Result<()> {
     docker.args(&["-w", paths.mount_cwd()]);
-    mount_to_ignore_cargo_config(docker, paths, ignore_cargo_config)?;
+    mount_to_ignore_cargo_config(docker, paths, cargo_config_behavior)?;
 
     Ok(())
 }

src/lib.rs

@@ -540,16 +540,14 @@ pub fn run() -> Result<ExitStatus> {
                 }
 
                 let paths = docker::DockerPaths::create(&engine, metadata, cwd, sysroot)?;
-                let ignore_cargo_config = config
-                    .cross
-                    .env_ignore_cargo_config(&target)
-                    .unwrap_or_default();
+                let cargo_config_behavior =
+                    config.cross.env_cargo_config(&target)?.unwrap_or_default();
                 let options = docker::DockerOptions::new(
                     engine,
                     target.clone(),
                     config,
                     uses_xargo,
-                    ignore_cargo_config,
+                    cargo_config_behavior,
                 );
                 let status = docker::run(options, paths, &filtered_args, &mut msg_info)
                     .wrap_err("could not run container")?;