From afb25c613c29808f6459a950838daa5e9e88ec4d Mon Sep 17 00:00:00 2001 From: Ed Page Date: Mon, 22 Nov 2021 10:50:52 -0600 Subject: [PATCH 1/3] fix: Remove redundant result We were showing the child predicate twice, one underneath the other, because we both forwarded its `Display` *and* added `self` to the case tree. --- src/path/fc.rs | 5 +---- 1 file changed, 1 insertion(+), 4 deletions(-) diff --git a/src/path/fc.rs b/src/path/fc.rs index 952d2ec..3b8dea4 100644 --- a/src/path/fc.rs +++ b/src/path/fc.rs @@ -75,10 +75,7 @@ where ) -> Option> { let buffer = read_file(variable); match (expected, buffer) { - (_, Ok(buffer)) => self - .p - .find_case(expected, &buffer) - .map(|child| reflection::Case::new(Some(self), expected).add_child(child)), + (_, Ok(buffer)) => self.p.find_case(expected, &buffer), (true, Err(_)) => None, (false, Err(err)) => Some( reflection::Case::new(Some(self), false) From 7bf46b84fd7ef325f0b40fa81f69478dc5c1b0fb Mon Sep 17 00:00:00 2001 From: Ed Page Date: Mon, 22 Nov 2021 11:01:35 -0600 Subject: [PATCH 2/3] fix: Clarify var vs expected --- src/ord.rs | 12 ++++++++---- 1 file changed, 8 insertions(+), 4 deletions(-) diff --git a/src/ord.rs b/src/ord.rs index d475c2f..8bee2b7 100644 --- a/src/ord.rs +++ b/src/ord.rs @@ -85,10 +85,12 @@ where let palette = crate::Palette::current(); write!( f, - "{} {} {:?}", + "{} {} {}", palette.var.paint("var"), palette.description.paint(self.op), - self.constant + palette + .expected + .paint(utils::DebugAdapter::new(&self.constant)), ) } } @@ -220,10 +222,12 @@ where let palette = crate::Palette::current(); write!( f, - "{} {} {:?}", + "{} {} {}", palette.var.paint("var"), palette.description.paint(self.op), - self.constant + palette + .expected + .paint(utils::DebugAdapter::new(&self.constant)), ) } } From beaf80857359cad62ab8a24f5b132d86e9ca4faf Mon Sep 17 00:00:00 2001 From: Ed Page Date: Mon, 22 Nov 2021 12:45:31 -0600 Subject: [PATCH 3/3] fix: Report user value With some predicates, we show the user value (diff) but others do not. This makes it more consistent. We aim to show the user value in leaf predicates and in major adapters. - Some leaf predicates can't show a value (function) - Some defer to a file on disk, so we leave it at that, in case the file is too big or ugly to shoe - Simple adapters, like `trim` don't show. So far, the only worthwhile one is `eq_file`. By leaving things to the leaves, we are able to show the value after its gone through transforms, like UTF-8, or loading a file path. Fixes #116 --- src/iter.rs | 42 ++++++++++++++++++++++++++++++++++++------ src/ord.rs | 28 ++++++++++++++++++++++++---- src/path/existence.rs | 7 ++++++- src/path/fc.rs | 11 ++++++++++- src/str/basics.rs | 5 +++++ src/str/regex.rs | 2 ++ 6 files changed, 83 insertions(+), 12 deletions(-) diff --git a/src/iter.rs b/src/iter.rs index 1210fc0..c8c97fc 100644 --- a/src/iter.rs +++ b/src/iter.rs @@ -79,7 +79,12 @@ where } fn find_case<'a>(&'a self, expected: bool, variable: &T) -> Option> { - utils::default_find_case(self, expected, variable) + utils::default_find_case(self, expected, variable).map(|case| { + case.add_product(reflection::Product::new( + "var", + utils::DebugAdapter::new(variable).to_string(), + )) + }) } } @@ -92,7 +97,12 @@ where } fn find_case<'b>(&'b self, expected: bool, variable: &T) -> Option> { - utils::default_find_case(self, expected, variable) + utils::default_find_case(self, expected, variable).map(|case| { + case.add_product(reflection::Product::new( + "var", + utils::DebugAdapter::new(variable).to_string(), + )) + }) } } @@ -187,7 +197,12 @@ where } fn find_case<'a>(&'a self, expected: bool, variable: &T) -> Option> { - utils::default_find_case(self, expected, variable) + utils::default_find_case(self, expected, variable).map(|case| { + case.add_product(reflection::Product::new( + "var", + utils::DebugAdapter::new(variable).to_string(), + )) + }) } } @@ -200,7 +215,12 @@ where } fn find_case<'b>(&'b self, expected: bool, variable: &T) -> Option> { - utils::default_find_case(self, expected, variable) + utils::default_find_case(self, expected, variable).map(|case| { + case.add_product(reflection::Product::new( + "var", + utils::DebugAdapter::new(variable).to_string(), + )) + }) } } @@ -256,7 +276,12 @@ where } fn find_case<'a>(&'a self, expected: bool, variable: &T) -> Option> { - utils::default_find_case(self, expected, variable) + utils::default_find_case(self, expected, variable).map(|case| { + case.add_product(reflection::Product::new( + "var", + utils::DebugAdapter::new(variable).to_string(), + )) + }) } } @@ -269,7 +294,12 @@ where } fn find_case<'b>(&'b self, expected: bool, variable: &T) -> Option> { - utils::default_find_case(self, expected, variable) + utils::default_find_case(self, expected, variable).map(|case| { + case.add_product(reflection::Product::new( + "var", + utils::DebugAdapter::new(variable).to_string(), + )) + }) } } diff --git a/src/ord.rs b/src/ord.rs index 8bee2b7..aa768cb 100644 --- a/src/ord.rs +++ b/src/ord.rs @@ -55,7 +55,12 @@ where } fn find_case<'a>(&'a self, expected: bool, variable: &T) -> Option> { - utils::default_find_case(self, expected, variable) + utils::default_find_case(self, expected, variable).map(|case| { + case.add_product(reflection::Product::new( + "var", + utils::DebugAdapter::new(variable).to_string(), + )) + }) } } @@ -71,7 +76,12 @@ where } fn find_case<'b>(&'b self, expected: bool, variable: &T) -> Option> { - utils::default_find_case(self, expected, variable) + utils::default_find_case(self, expected, variable).map(|case| { + case.add_product(reflection::Product::new( + "var", + utils::DebugAdapter::new(variable).to_string(), + )) + }) } } @@ -190,7 +200,12 @@ where } fn find_case<'a>(&'a self, expected: bool, variable: &T) -> Option> { - utils::default_find_case(self, expected, variable) + utils::default_find_case(self, expected, variable).map(|case| { + case.add_product(reflection::Product::new( + "var", + utils::DebugAdapter::new(variable).to_string(), + )) + }) } } @@ -208,7 +223,12 @@ where } fn find_case<'b>(&'b self, expected: bool, variable: &T) -> Option> { - utils::default_find_case(self, expected, variable) + utils::default_find_case(self, expected, variable).map(|case| { + case.add_product(reflection::Product::new( + "var", + utils::DebugAdapter::new(variable).to_string(), + )) + }) } } diff --git a/src/path/existence.rs b/src/path/existence.rs index 5580abb..c16d362 100644 --- a/src/path/existence.rs +++ b/src/path/existence.rs @@ -31,7 +31,12 @@ impl Predicate for ExistencePredicate { expected: bool, variable: &path::Path, ) -> Option> { - utils::default_find_case(self, expected, variable) + utils::default_find_case(self, expected, variable).map(|case| { + case.add_product(reflection::Product::new( + "var", + variable.display().to_string(), + )) + }) } } diff --git a/src/path/fc.rs b/src/path/fc.rs index 3b8dea4..f16c156 100644 --- a/src/path/fc.rs +++ b/src/path/fc.rs @@ -75,10 +75,19 @@ where ) -> Option> { let buffer = read_file(variable); match (expected, buffer) { - (_, Ok(buffer)) => self.p.find_case(expected, &buffer), + (_, Ok(buffer)) => self.p.find_case(expected, &buffer).map(|case| { + case.add_product(reflection::Product::new( + "var", + variable.display().to_string(), + )) + }), (true, Err(_)) => None, (false, Err(err)) => Some( reflection::Case::new(Some(self), false) + .add_product(reflection::Product::new( + "var", + variable.display().to_string(), + )) .add_product(reflection::Product::new("error", err)), ), } diff --git a/src/str/basics.rs b/src/str/basics.rs index 4d3171b..f7c19a2 100644 --- a/src/str/basics.rs +++ b/src/str/basics.rs @@ -25,6 +25,7 @@ impl Predicate for IsEmptyPredicate { fn find_case<'a>(&'a self, expected: bool, variable: &str) -> Option> { utils::default_find_case(self, expected, variable) + .map(|case| case.add_product(reflection::Product::new("var", variable.to_owned()))) } } @@ -72,6 +73,7 @@ impl Predicate for StartsWithPredicate { fn find_case<'a>(&'a self, expected: bool, variable: &str) -> Option> { utils::default_find_case(self, expected, variable) + .map(|case| case.add_product(reflection::Product::new("var", variable.to_owned()))) } } @@ -125,6 +127,7 @@ impl Predicate for EndsWithPredicate { fn find_case<'a>(&'a self, expected: bool, variable: &str) -> Option> { utils::default_find_case(self, expected, variable) + .map(|case| case.add_product(reflection::Product::new("var", variable.to_owned()))) } } @@ -198,6 +201,7 @@ impl Predicate for ContainsPredicate { fn find_case<'a>(&'a self, expected: bool, variable: &str) -> Option> { utils::default_find_case(self, expected, variable) + .map(|case| case.add_product(reflection::Product::new("var", variable.to_owned()))) } } @@ -236,6 +240,7 @@ impl Predicate for MatchesPredicate { if result == expected { Some( reflection::Case::new(Some(self), result) + .add_product(reflection::Product::new("var", variable.to_owned())) .add_product(reflection::Product::new("actual count", actual_count)), ) } else { diff --git a/src/str/regex.rs b/src/str/regex.rs index 5657b8f..5341b30 100644 --- a/src/str/regex.rs +++ b/src/str/regex.rs @@ -47,6 +47,7 @@ impl Predicate for RegexPredicate { fn find_case<'a>(&'a self, expected: bool, variable: &str) -> Option> { utils::default_find_case(self, expected, variable) + .map(|case| case.add_product(reflection::Product::new("var", variable.to_owned()))) } } @@ -85,6 +86,7 @@ impl Predicate for RegexMatchesPredicate { if result == expected { Some( reflection::Case::new(Some(self), result) + .add_product(reflection::Product::new("var", variable.to_owned())) .add_product(reflection::Product::new("actual count", actual_count)), ) } else {