Skip to content

Commit 526f1f2

Browse files
varsha888varsha888
committed
Parse target and profile from out dir
1 parent 82313b4 commit 526f1f2

File tree

2 files changed

+212
-52
lines changed

2 files changed

+212
-52
lines changed

‎Cargo.toml

Lines changed: 1 addition & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -43,6 +43,7 @@ url = "2.3"
4343
walkdir = "2.3"
4444

4545
[dev-dependencies]
46+
fluent-asserter = "0.1.9"
4647
mockall = "0.11.3"
4748
mockall_double = "0.2.1"
4849
rustversion = "1.0"

‎src/env.rs

Lines changed: 211 additions & 52 deletions
Original file line numberDiff line numberDiff line change
@@ -237,20 +237,20 @@ impl Environment {
237237
let out_dir = PathBuf::from(
238238
var(ENV_OUT_DIR).map_err(|e| EnvironmentError::Var(ENV_OUT_DIR.to_owned(), e))?,
239239
);
240+
// Convert ths to path?
241+
let cargo_target_dir = PathBuf::from(
242+
var(ENV_CARGO_TARGET_DIR)
243+
.map_err(|e| EnvironmentError::Var(ENV_CARGO_TARGET_DIR.to_owned(), e))?,
244+
);
240245
let target =
241246
var(ENV_TARGET).map_err(|e| EnvironmentError::Var(ENV_TARGET.to_owned(), e))?;
242247
let profile =
243248
var(ENV_PROFILE).map_err(|e| EnvironmentError::Var(ENV_PROFILE.to_owned(), e))?;
244-
let profile_target_dir = out_dir
245-
.as_path()
246-
.ancestors()
247-
.find(|path| path.ends_with(&target) || path.ends_with(&profile))
248-
.ok_or_else(|| EnvironmentError::OutDir(out_dir.clone()))?
249-
.to_owned();
250-
let target_dir = profile_target_dir
251-
.parent()
252-
.ok_or_else(|| EnvironmentError::OutDir(out_dir.clone()))?
253-
.to_owned();
249+
250+
let (target_dir, profile_target_dir) =
251+
Self::get_target_profile_dir(&out_dir, &cargo_target_dir, target)
252+
.ok_or_else(|| EnvironmentError::OutDir(out_dir.clone()))
253+
.unwrap();
254254

255255
let target_has_atomic = var(ENV_CARGO_CFG_TARGET_HAS_ATOMIC)
256256
.unwrap_or_default()
@@ -396,6 +396,27 @@ impl Environment {
396396
})
397397
}
398398

399+
fn get_target_profile_dir(
400+
out_dir: &Path,
401+
target_dir: &PathBuf,
402+
target: String,
403+
) -> Option<(PathBuf, PathBuf)> {
404+
let mut ancestor = out_dir.ancestors().peekable();
405+
while let Some(path) = ancestor.next() {
406+
if let Some(parent) = ancestor.peek() {
407+
if !target.is_empty() && parent.ends_with(&target)
408+
|| !target_dir.as_os_str().is_empty() && parent.ends_with(target_dir)
409+
|| parent.ends_with("target")
410+
{
411+
let tuple = (PathBuf::from(parent), PathBuf::from(path));
412+
413+
return Some(tuple);
414+
}
415+
}
416+
}
417+
None
418+
}
419+
399420
/// Get the path to the cargo executables
400421
pub fn cargo(&self) -> &Path {
401422
&self.cargo_path
@@ -621,7 +642,76 @@ impl Environment {
621642
#[cfg(test)]
622643
mod tests {
623644
use super::*;
624-
use std::str::FromStr;
645+
use fluent_asserter::prelude::*;
646+
647+
fn setup_env(env_values: HashMap<&str, Option<&str>>) -> Environment {
648+
temp_env::with_vars(
649+
[
650+
(
651+
ENV_OUT_DIR,
652+
if env_values.get(ENV_OUT_DIR).is_some() {
653+
env_values.get(ENV_OUT_DIR).cloned().unwrap()
654+
} else {
655+
Some("/path_to_out_dir")
656+
},
657+
),
658+
(
659+
ENV_TARGET,
660+
if env_values.get(ENV_TARGET).is_some() {
661+
env_values.get(ENV_TARGET).cloned().unwrap()
662+
} else {
663+
Some("target")
664+
},
665+
),
666+
(
667+
ENV_PROFILE,
668+
if env_values.get(ENV_PROFILE).is_some() {
669+
env_values.get(ENV_PROFILE).cloned().unwrap()
670+
} else {
671+
Some("profile")
672+
},
673+
),
674+
(
675+
ENV_CARGO,
676+
if env_values.get(ENV_CARGO).is_some() {
677+
env_values.get(ENV_CARGO).cloned().unwrap()
678+
} else {
679+
Some("/path_to_cargo")
680+
},
681+
),
682+
(ENV_HOST, Some("host")),
683+
(ENV_NUM_JOBS, Some("11")),
684+
(ENV_OPT_LEVEL, Some("2")),
685+
(ENV_RUSTC, Some("rustc")),
686+
(ENV_RUSTDOC, Some("rustdoc")),
687+
(
688+
ENV_CARGO_TARGET_DIR,
689+
if env_values.get(ENV_CARGO_TARGET_DIR).is_some() {
690+
env_values.get(ENV_CARGO_TARGET_DIR).cloned().unwrap()
691+
} else {
692+
Some("/path_to_target_dir")
693+
},
694+
),
695+
(ENV_CARGO_PKG_VERSION, Some("2.1.0-pre0")),
696+
(ENV_CARGO_PKG_AUTHORS, Some("MobileCoin")),
697+
(ENV_CARGO_PKG_NAME, Some("mc-build-rs")),
698+
(ENV_CARGO_PKG_DESCRIPTION, Some("")),
699+
(ENV_CARGO_PKG_HOMEPAGE, Some("")),
700+
(ENV_CARGO_PKG_REPOSITORY, Some("")),
701+
(ENV_CARGO_CFG_TARGET_ARCH, Some("x86_64")),
702+
(ENV_CARGO_CFG_TARGET_ENDIAN, Some("little")),
703+
(ENV_CARGO_CFG_TARGET_ENV, Some("")),
704+
(ENV_CARGO_CFG_TARGET_FAMILY, Some("unix")),
705+
(ENV_CARGO_CFG_TARGET_FEATURE, Some("adx,aes,avx,avx2,")),
706+
(ENV_CARGO_CFG_TARGET_OS, Some("linux")),
707+
(ENV_CARGO_CFG_TARGET_POINTER_WIDTH, Some("64")),
708+
(ENV_CARGO_CFG_TARGET_VENDOR, Some("unknown")),
709+
],
710+
|| {
711+
return Environment::default();
712+
},
713+
)
714+
}
625715

626716
#[test]
627717
fn init_env() {
@@ -631,47 +721,116 @@ mod tests {
631721
let expected_profile = "debug";
632722
let expected_cargo_package_version = "2.1.0-pre0";
633723

634-
temp_env::with_vars(
635-
[
636-
("OUT_DIR", Some(expected_out_dir)),
637-
("TARGET", Some(expected_target)),
638-
("PROFILE", Some(expected_profile)),
639-
("CARGO", Some(expected_cargo_path)),
640-
("HOST", Some("host")),
641-
("NUM_JOBS", Some("11")),
642-
("OPT_LEVEL", Some("2")),
643-
("RUSTC", Some("rustc")),
644-
("RUSTDOC", Some("rustdoc")),
645-
("CARGO_PKG_VERSION", Some(expected_cargo_package_version)),
646-
("CARGO_PKG_AUTHORS", Some("MobileCoin")),
647-
("CARGO_PKG_NAME", Some("mc-build-rs")),
648-
("CARGO_PKG_DESCRIPTION", Some("")),
649-
("CARGO_PKG_HOMEPAGE", Some("")),
650-
("CARGO_PKG_REPOSITORY", Some("")),
651-
("CARGO_CFG_TARGET_ARCH", Some("x86_64")),
652-
("CARGO_CFG_TARGET_ENDIAN", Some("little")),
653-
("CARGO_CFG_TARGET_ENV", Some("")),
654-
("CARGO_CFG_TARGET_FAMILY", Some("unix")),
655-
("CARGO_CFG_TARGET_FEATURE", Some("adx,aes,avx,avx2,")),
656-
("CARGO_CFG_TARGET_OS", Some("linux")),
657-
("CARGO_CFG_TARGET_POINTER_WIDTH", Some("64")),
658-
("CARGO_CFG_TARGET_VENDOR", Some("unknown")),
659-
],
660-
|| {
661-
let env = Environment::default();
662-
663-
assert_eq!(
664-
env.out_dir(),
665-
PathBuf::from_str(expected_out_dir).expect("Fail")
666-
);
667-
assert_eq!(env.target, expected_target);
668-
assert_eq!(env.profile, expected_profile);
669-
assert_eq!(
670-
env.cargo_path,
671-
PathBuf::from_str(expected_cargo_path).expect("Fail")
672-
);
673-
assert_eq!(env.pkg_version, expected_cargo_package_version);
674-
},
724+
let mut values = HashMap::new();
725+
values.insert(ENV_OUT_DIR, Some(expected_out_dir));
726+
values.insert(ENV_TARGET, Some(expected_target));
727+
values.insert(ENV_CARGO, Some(expected_cargo_path));
728+
values.insert(ENV_PROFILE, Some(expected_profile));
729+
values.insert(ENV_CARGO_PKG_VERSION, Some(expected_cargo_package_version));
730+
731+
let env = setup_env(values);
732+
733+
assert_eq!(
734+
env.out_dir(),
735+
PathBuf::from_str(expected_out_dir).expect("Fail")
736+
);
737+
assert_eq!(env.target, expected_target);
738+
assert_eq!(env.profile, expected_profile);
739+
assert_eq!(
740+
env.cargo_path,
741+
PathBuf::from_str(expected_cargo_path).expect("Fail")
742+
);
743+
assert_eq!(env.pkg_version, expected_cargo_package_version);
744+
}
745+
746+
#[test]
747+
fn match_target_type() {
748+
let out_dir = "path_to/target/x86_64-unknown-linux-gnu/debug/path/to/out";
749+
let target = "x86_64-unknown-linux-gnu";
750+
let expected_target_dir = "path_to/target/x86_64-unknown-linux-gnu/";
751+
let expected_profile_dir = "path_to/target/x86_64-unknown-linux-gnu/debug";
752+
753+
let mut values = HashMap::new();
754+
values.insert(ENV_OUT_DIR, Some(out_dir));
755+
values.insert(ENV_TARGET, Some(target));
756+
757+
let env = setup_env(values);
758+
759+
assert_eq!(
760+
env.target_dir,
761+
PathBuf::from_str(expected_target_dir).expect("Fail")
762+
);
763+
assert_eq!(
764+
env.profile_target_dir,
765+
PathBuf::from_str(expected_profile_dir).expect("Fail")
766+
);
767+
}
768+
769+
#[test]
770+
fn match_target_dir() {
771+
let target_dir = "path_to/target";
772+
let out_dir = "path_to/target/debug/path/to/out";
773+
let target = "x86_64-unknown-linux-gnu";
774+
let expected_target_dir = "path_to/target";
775+
let expected_profile_dir = "path_to/target/debug";
776+
777+
let mut values = HashMap::new();
778+
values.insert(ENV_OUT_DIR, Some(out_dir));
779+
values.insert(ENV_CARGO_TARGET_DIR, Some(target_dir));
780+
values.insert(ENV_TARGET, Some(target));
781+
782+
let env = setup_env(values);
783+
784+
assert_eq!(
785+
env.target_dir,
786+
PathBuf::from_str(expected_target_dir).expect("Fail")
787+
);
788+
assert_eq!(
789+
env.profile_target_dir,
790+
PathBuf::from_str(expected_profile_dir).expect("Fail")
791+
);
792+
}
793+
794+
#[test]
795+
fn match_target_string() {
796+
let target_dir = "";
797+
let out_dir = "path_to/target/debug/path/to/out";
798+
let target = "x86_64-unknown-linux-gnu";
799+
let expected_target_dir = "path_to/target/";
800+
let expected_profile_dir = "path_to/target/debug";
801+
802+
let mut values = HashMap::new();
803+
values.insert(ENV_OUT_DIR, Some(out_dir));
804+
values.insert(ENV_CARGO_TARGET_DIR, Some(target_dir));
805+
values.insert(ENV_TARGET, Some(target));
806+
807+
let env = setup_env(values);
808+
809+
assert_eq!(
810+
env.target_dir,
811+
PathBuf::from_str(expected_target_dir).expect("Fail")
812+
);
813+
assert_eq!(
814+
env.profile_target_dir,
815+
PathBuf::from_str(expected_profile_dir).expect("Fail")
816+
);
817+
}
818+
819+
#[test]
820+
fn err_out_dir() {
821+
let target_dir = "different/path_to_target";
822+
let out_dir = "path_to/debug/path/to/out";
823+
let target = "x86_64-unknown-linux-gnu";
824+
825+
let mut values = HashMap::new();
826+
values.insert(ENV_OUT_DIR, Some(out_dir));
827+
values.insert(ENV_CARGO_TARGET_DIR, Some(target_dir));
828+
values.insert(ENV_TARGET, Some(target));
829+
830+
assert_that_code!(|| setup_env(values))
831+
.panics()
832+
.with_message(
833+
"called `Result::unwrap()` on an `Err` value: OutDir(\"path_to/debug/path/to/out\")",
675834
);
676835
}
677836
}

0 commit comments

Comments
 (0)