From 9431eb2fa9f4cfc14f8ccc16da07308e9905850a Mon Sep 17 00:00:00 2001
From: Martin Berg Alstad <emberal+github@pm.me>
Date: Sun, 16 Jun 2024 00:36:59 +0200
Subject: [PATCH] Option to hide false or true values in truthTable

---
 http/simplify.http             | 18 ++++++++++
 src/expressions/truth_table.rs | 61 ++++++++++++++++++++++++++++++----
 2 files changed, 73 insertions(+), 6 deletions(-)

diff --git a/http/simplify.http b/http/simplify.http
index ac6d602..babc457 100644
--- a/http/simplify.http
+++ b/http/simplify.http
@@ -82,3 +82,21 @@ GET {{url}}/simplify/table/{{expression}}?sort=TRUE_FIRST
         }
     });
 %}
+
+### GET with table and hide false values
+< {%
+    import {expression} from "./common";
+
+    expression("A & B | C")
+%}
+GET {{url}}/simplify/table/{{expression}}?hide=FALSE
+
+> {%
+    client.test("Response body does not contain false values", () => {
+        const table = response.body.truthTable;
+        const results = table.truthMatrix.map(arr => arr[arr.length - 1])
+        for (let i = 0; i < results.length; i++) {
+            client.assert(results[i] === true, "Response body contains false values")
+        }
+    });
+%}
diff --git a/src/expressions/truth_table.rs b/src/expressions/truth_table.rs
index 25a117c..5f49bb7 100644
--- a/src/expressions/truth_table.rs
+++ b/src/expressions/truth_table.rs
@@ -41,10 +41,9 @@ pub struct TruthTableOptions {
 }
 
 impl TruthTable {
-    // TODO hide option
     pub fn new(expression: &Expression, options: TruthTableOptions) -> Self {
         let header = Self::extract_header(expression);
-        let mut truth_matrix = Self::generate_truth_matrix(expression, &header);
+        let mut truth_matrix = Self::generate_truth_matrix(expression, &header, options.hide);
         if !matches!(options.sort, Sort::Default) {
             Self::sort_matrix(&mut truth_matrix, options.sort);
         }
@@ -91,7 +90,7 @@ impl TruthTable {
         }
     }
 
-    fn generate_truth_matrix(expression: &Expression, header: &[String]) -> TruthMatrix {
+    fn generate_truth_matrix(expression: &Expression, header: &[String], hide: Hide) -> TruthMatrix {
         let mut atomics = expression.get_atomic_values()
             .into_iter().collect::<Vec<String>>();
         if atomics.is_empty() {
@@ -99,11 +98,17 @@ impl TruthTable {
         }
         atomics.sort();
         Self::truth_combinations(atomics.len()).iter()
-            .map(|combo| {
-                Self::resolve_expression(expression, &atomics.iter()
+            .filter_map(|combo| {
+                let expression = Self::resolve_expression(expression, &atomics.iter()
                     .enumerate()
                     .map(|(index, value)| (value.clone(), combo[index]))
-                    .collect(), header)
+                    .collect(), header);
+                match (hide, expression.last()) {
+                    (Hide::True, Some(false)) => Some(expression),
+                    (Hide::False, Some(true)) => Some(expression),
+                    (Hide::None, _) => Some(expression),
+                    _ => None,
+                }
             }).collect()
     }
 
@@ -269,6 +274,50 @@ mod tests {
         ]);
     }
 
+    #[test]
+    fn test_hide_true_values() {
+        let expected = matrix![
+            true, false, false;
+            false, true, false;
+            false, false, false
+        ];
+        let matrix = TruthTable::generate_truth_matrix(
+            &and(atomic("A"), atomic("B")),
+            &["A".into(), "B".into(), "A ⋀ B".into()],
+            Hide::True,
+        );
+        assert_eq!(expected, matrix);
+    }
+
+    #[test]
+    fn test_hide_false_values() {
+        let expected = matrix![
+            true, true, true
+        ];
+        let matrix = TruthTable::generate_truth_matrix(
+            &and(atomic("A"), atomic("B")),
+            &["A".into(), "B".into(), "A ⋀ B".into()],
+            Hide::False,
+        );
+        assert_eq!(expected, matrix);
+    }
+
+    #[test]
+    fn test_hide_none() {
+        let expected = matrix![
+            true, true, true;
+            true, false, false;
+            false, true, false;
+            false, false, false
+        ];
+        let matrix = TruthTable::generate_truth_matrix(
+            &and(atomic("A"), atomic("B")),
+            &["A".into(), "B".into(), "A ⋀ B".into()],
+            Hide::None,
+        );
+        assert_eq!(expected, matrix);
+    }
+
     #[test]
     fn test_truth_combinations_2() {
         let combinations = TruthTable::truth_combinations(2);