From 25b708a6fd52e19e1b0cb0b85a4cc5b1c370be74 Mon Sep 17 00:00:00 2001 From: Martin Berg Alstad Date: Thu, 5 Sep 2024 21:57:50 +0200 Subject: [PATCH] fmt. Removed some usage of macros --- Dockerfile | 2 +- src/expressions/helpers.rs | 8 +- src/expressions/mod.rs | 4 +- src/expressions/operator.rs | 3 + src/expressions/simplify.rs | 179 +++++++++++----- src/expressions/truth_table.rs | 353 +++++++++++++++++++++---------- src/main.rs | 2 +- src/parsing/expression_parser.rs | 2 +- src/parsing/mod.rs | 2 +- src/routing/error.rs | 2 +- src/routing/mod.rs | 4 +- src/routing/options.rs | 9 +- src/routing/routes/index.rs | 4 +- src/routing/routes/mod.rs | 2 - src/routing/routes/simplify.rs | 38 ++-- src/routing/routes/table.rs | 20 +- src/utils/axum.rs | 6 +- src/utils/mod.rs | 2 +- src/utils/serialize.rs | 7 +- 19 files changed, 442 insertions(+), 207 deletions(-) diff --git a/Dockerfile b/Dockerfile index a4b297c..d1b6e25 100644 --- a/Dockerfile +++ b/Dockerfile @@ -12,7 +12,7 @@ RUN npm install RUN USER=root npm install -g @typespec/compiler && npm install -g @redocly/cli RUN npm run tsp-compile && npm run redoc-build -FROM rust:1.79 as build +FROM rust:1.80.1 as build COPY --from=static ./src/resources/static ./static diff --git a/src/expressions/helpers.rs b/src/expressions/helpers.rs index 05451ac..4e3f2d9 100644 --- a/src/expressions/helpers.rs +++ b/src/expressions/helpers.rs @@ -1,6 +1,6 @@ -use std::rc::Rc; use crate::expressions::expression::Expression; use crate::expressions::operator::BinaryOperator; +use std::rc::Rc; impl Expression { #[inline] @@ -65,7 +65,11 @@ where L: Into>, R: Into>, { - Expression::Binary { left: left.into(), operator, right: right.into() } + Expression::Binary { + left: left.into(), + operator, + right: right.into(), + } } #[inline] diff --git a/src/expressions/mod.rs b/src/expressions/mod.rs index 5fe10e8..db1edc8 100644 --- a/src/expressions/mod.rs +++ b/src/expressions/mod.rs @@ -1,5 +1,5 @@ pub mod expression; -pub mod operator; pub mod helpers; +pub mod operator; pub mod simplify; -pub mod truth_table; \ No newline at end of file +pub mod truth_table; diff --git a/src/expressions/operator.rs b/src/expressions/operator.rs index a09018a..84d328e 100644 --- a/src/expressions/operator.rs +++ b/src/expressions/operator.rs @@ -9,6 +9,7 @@ pub enum BinaryOperator { } impl BinaryOperator { + #[must_use] pub fn eval(&self, left: bool, right: bool) -> bool { match self { BinaryOperator::And => left && right, @@ -17,10 +18,12 @@ impl BinaryOperator { } } + #[must_use] pub fn is_and(&self) -> bool { matches!(self, BinaryOperator::And) } + #[must_use] pub fn is_or(&self) -> bool { matches!(self, BinaryOperator::Or) } diff --git a/src/expressions/simplify.rs b/src/expressions/simplify.rs index 32cc552..9ad369c 100644 --- a/src/expressions/simplify.rs +++ b/src/expressions/simplify.rs @@ -146,7 +146,8 @@ macro_rules! absorption_law_opposites { #[macro_export] macro_rules! distributive_law_atomic_vs_binary { - ($left:expr, $right:expr, $operations:expr, $op:pat, $func1:expr, $func2:expr) => { + ($left:expr, $right:expr, $operations:expr, $op:pat, $func1:expr, $func2:expr) => {{ + let before = $func2($left.clone(), $right.clone()); match ($left.as_ref(), $right.as_ref()) { ( Expression::Atomic(_), @@ -155,19 +156,13 @@ macro_rules! distributive_law_atomic_vs_binary { operator: $op, right: right_right, }, - ) => { - let right_left = right_left.distributive_law($operations); - let right_right = right_right.distributive_law($operations); - let before = $func2($left.clone(), $right.clone()); - let after = $func1( - $func2($left.clone(), right_left), - $func2($left.clone(), right_right), - ); - if let Some(operation) = Operation::new(&before, &after, Law::DistributiveLaw) { - $operations.push(operation); - } - after - } + ) => do_it( + &before, + &right_left, + &right_right, + |left, right| $func1($func2($left.clone(), left), $func2($left.clone(), right)), + $operations, + ), ( Expression::Binary { left: left_left, @@ -175,25 +170,36 @@ macro_rules! distributive_law_atomic_vs_binary { right: left_right, }, Expression::Atomic(_), - ) => { - let left_left = left_left.distributive_law($operations); - let left_right = left_right.distributive_law($operations); - let before = $func2($left.clone(), $right.clone()); - let after = $func1( - $func2(left_left, $right.clone()), - $func2(left_right, $right.clone()), - ); - if let Some(operation) = Operation::new(&before, &after, Law::DistributiveLaw) { - $operations.push(operation); - } - after - } + ) => do_it( + &before, + &left_left, + &left_right, + |left, right| $func1($func2(left, $right.clone()), $func2(right, $right.clone())), + $operations, + ), (left, right) => $func2( left.distributive_law($operations), right.distributive_law($operations), ), } - }; + }}; +} + +// TODO name it +fn do_it( + before: &Expression, + left: &Expression, + right: &Expression, + after_callback: impl Fn(Expression, Expression) -> Expression, + operations: &mut Vec, +) -> Expression { + let right_left = left.distributive_law(operations); + let right_right = right.distributive_law(operations); + let after = after_callback(right_left, right_right); + if let Some(operation) = Operation::new(before, &after, Law::DistributiveLaw) { + operations.push(operation); + } + after } #[derive(Debug, Default)] @@ -330,13 +336,13 @@ impl Expression { } => { #[rustfmt::skip] // TODO refactor let after = if Expression::eq(left, right, ignore_case) - || (operator.is_and() && (left.is_and() && right.is_in(left) || right.is_or() && left.is_in(right))) - || (operator.is_or() && (left.is_or() && right.is_in(left) || right.is_and() && left.is_in(right))) + || (operator.is_and() && (left.is_and() && right.is_in(left) || right.is_or() && left.is_in(right))) + || (operator.is_or() && (left.is_or() && right.is_in(left) || right.is_and() && left.is_in(right))) { left } else if - (operator.is_and() && (left.is_or() && right.is_in(left) || right.is_and() && left.is_in(right))) - || (operator.is_or() && (left.is_and() && right.is_in(left) || right.is_or() && left.is_in(right))) + (operator.is_and() && (left.is_or() && right.is_in(left) || right.is_and() && left.is_in(right))) + || (operator.is_or() && (left.is_and() && right.is_in(left) || right.is_or() && left.is_in(right))) { right } else { @@ -411,7 +417,7 @@ impl Expression { } // A ⋀ (B ⋀ C) <=> (A ⋀ B) ⋀ C - fn associative_law(&self, operations: &mut Vec) -> Self { + fn _associative_law(&self, _operations: &mut Vec) -> Self { todo!("? | Associative law: (a ⋀ b) ⋀ c == a ⋀ (b ⋀ c) and (a ⋁ b) ⋁ c == a ⋁ (b ⋁ c)") } @@ -423,28 +429,99 @@ impl Expression { operator: BinaryOperator::And, right, } => { - distributive_law_atomic_vs_binary!( - left, - right, - operations, - BinaryOperator::Or, - or, - and - ) + let before = and(left.clone(), right.clone()); + match (left.as_ref(), right.as_ref()) { + ( + Expression::Atomic(_), + Expression::Binary { + left: right_left, + operator: BinaryOperator::Or, + right: right_right, + }, + ) => do_it( + &before, + right_left, + right_right, + |inner_left, inner_right| { + or( + and(left.clone(), inner_left), + and(left.clone(), inner_right), + ) + }, + operations, + ), + ( + Expression::Binary { + left: left_left, + operator: BinaryOperator::Or, + right: left_right, + }, + Expression::Atomic(_), + ) => do_it( + &before, + left_left, + left_right, + |inner_left, inner_right| { + or( + and(inner_left, right.clone()), + and(inner_right, right.clone()), + ) + }, + operations, + ), + (left, right) => and( + left.distributive_law(operations), + right.distributive_law(operations), + ), + } } Expression::Binary { left, operator: BinaryOperator::Or, right, } => { - distributive_law_atomic_vs_binary!( - left, - right, - operations, - BinaryOperator::And, - and, - or - ) + let before = or(left.clone(), right.clone()); + match (left.as_ref(), right.as_ref()) { + ( + Expression::Atomic(_), + Expression::Binary { + left: right_left, + operator: BinaryOperator::And, + right: right_right, + }, + ) => do_it( + &before, + right_left, + right_right, + |inner_left, inner_right| { + and(or(left.clone(), inner_left), or(left.clone(), inner_right)) + }, + operations, + ), + ( + Expression::Binary { + left: left_left, + operator: BinaryOperator::And, + right: left_right, + }, + Expression::Atomic(_), + ) => do_it( + &before, + left_left, + left_right, + |inner_left, inner_right| { + and( + or(inner_left, right.clone()), + or(inner_right, right.clone()), + ) + }, + operations, + ), + (left, right) => or( + left.distributive_law(operations), + right.distributive_law(operations), + ), + } } Expression::Binary { left, @@ -460,7 +537,7 @@ impl Expression { } } - fn commutative_law(&self, operations: &mut Vec) -> Self { + fn commutative_law(&self, _operations: &mut Vec) -> Self { todo!("? | Order of operands does not matter in AND and OR operations.") } } @@ -705,7 +782,7 @@ mod tests { expression, or( and(not(atomic("a")), not(atomic("b"))), - and(not(atomic("c")), not(atomic("d"))) + and(not(atomic("c")), not(atomic("d"))), ) ); // ¬(a ⋁ b) ⋀ ¬(c ⋁ d) == (¬a ⋀ ¬b) ⋁ (¬c ⋀ ¬d) assert_eq!(operations.len(), 3); diff --git a/src/expressions/truth_table.rs b/src/expressions/truth_table.rs index 74e3afc..8cede3e 100644 --- a/src/expressions/truth_table.rs +++ b/src/expressions/truth_table.rs @@ -36,16 +36,27 @@ pub enum Sort { } impl TruthTable { - pub fn new(expression: &Expression, options: TruthTableOptions) -> Self { + pub fn new( + expression: &Expression, + TruthTableOptions { + hide, + hide_intermediate_steps, + sort, + }: TruthTableOptions, + ) -> Self { let mut header = Self::extract_header(expression); - let mut truth_matrix = Self::generate_truth_matrix(expression, &header, options.hide, options.hide_intermediate_steps); - if !matches!(options.sort, Sort::Default) { - Self::sort_matrix(&mut truth_matrix, options.sort); + let mut truth_matrix = + Self::generate_truth_matrix(expression, &header, hide, hide_intermediate_steps); + if !matches!(sort, Sort::Default) { + Self::sort_matrix(&mut truth_matrix, sort); } - if options.hide_intermediate_steps { + if hide_intermediate_steps { header = Self::remove_non_atomic_from_header(&header); } - Self { header, truth_matrix } + Self { + header, + truth_matrix, + } } fn sort_matrix(truth_matrix: &mut TruthMatrix, sort: Sort) { @@ -57,7 +68,8 @@ impl TruthTable { } fn remove_non_atomic_from_header(header: &[String]) -> Vec { - header.iter() + header + .iter() .enumerate() .filter_map(|(index, s)| { if !Self::contains_operator(s) || index == header.len() - 1 { @@ -105,38 +117,62 @@ impl TruthTable { } } - fn generate_truth_matrix(expression: &Expression, header: &[String], hide: Hide, hide_intermediate: bool) -> TruthMatrix { - let mut atomics = expression.get_atomic_values() - .into_iter().collect::>(); + fn generate_truth_matrix( + expression: &Expression, + header: &[String], + hide: Hide, + hide_intermediate: bool, + ) -> TruthMatrix { + let mut atomics = expression + .get_atomic_values() + .into_iter() + .collect::>(); if atomics.is_empty() { return vec![]; } atomics.sort(); - Self::truth_combinations(atomics.len() as u32).iter() + Self::truth_combinations(atomics.len() as u32) + .iter() .filter_map(|combo| { - let expression = Self::resolve_expression(expression, &atomics.iter() - .enumerate() - .map(|(index, value)| (value.clone(), combo[index])) - .collect(), header, hide_intermediate); + let expression = Self::resolve_expression( + expression, + &atomics + .iter() + .enumerate() + .map(|(index, value)| (value.clone(), combo[index])) + .collect(), + header, + hide_intermediate, + ); match (hide, expression.last()) { (Hide::True, Some(false)) => Some(expression), (Hide::False, Some(true)) => Some(expression), (Hide::None, _) => Some(expression), _ => None, } - }).collect() + }) + .collect() } fn truth_combinations(count: u32) -> TruthMatrix { let row_len = 2usize.pow(count); let rows = 0..row_len; - rows.map(|index| (0..count).rev() - // Just trust me bro - .map(|shift| (index >> shift) & 1 == 0).collect() - ).collect() + rows.map(|index| { + (0..count) + .rev() + // Just trust me bro + .map(|shift| (index >> shift) & 1 == 0) + .collect() + }) + .collect() } - fn resolve_expression(expression: &Expression, booleans: &HashMap, header: &[String], hide_intermediate: bool) -> Vec { + fn resolve_expression( + expression: &Expression, + booleans: &HashMap, + header: &[String], + hide_intermediate: bool, + ) -> Vec { let Some(last_expression) = header.last() else { return vec![]; }; @@ -145,17 +181,23 @@ impl TruthTable { if hide_intermediate { expression_map = Self::remove_intermediate_steps(expression_map, last_expression); } - let string_map = expression_map.into_iter() + let string_map = expression_map + .into_iter() .map(|(key, value)| (key.to_string(), value)) .collect::>(); - header.iter() + header + .iter() .filter_map(|s_expr| string_map.get(s_expr).copied()) .collect() } - fn remove_intermediate_steps<'a>(expression_map: HashMap<&'a Expression, bool>, top_level_expression: &'a str) -> HashMap<&'a Expression, bool> { - expression_map.into_iter() + fn remove_intermediate_steps<'a>( + expression_map: HashMap<&'a Expression, bool>, + top_level_expression: &'a str, + ) -> HashMap<&'a Expression, bool> { + expression_map + .into_iter() .filter_map(|(key, value)| { if key.is_atomic() || key.to_string() == top_level_expression { Some((key, value)) @@ -166,7 +208,10 @@ impl TruthTable { .collect() } - fn _resolve_expression<'a>(expression: &'a Expression, booleans: &HashMap) -> HashMap<&'a Expression, bool> { + fn _resolve_expression<'a>( + expression: &'a Expression, + booleans: &HashMap, + ) -> HashMap<&'a Expression, bool> { match expression { Expression::Not(expr) => { let mut map = Self::_resolve_expression(expr, booleans); @@ -175,12 +220,18 @@ impl TruthTable { } map } - Expression::Binary { left, right, operator } => { + Expression::Binary { + left, + right, + operator, + } => { let left_map = Self::_resolve_expression(left, booleans); let right_map = Self::_resolve_expression(right, booleans); let mut map = left_map; map.extend(right_map); - if let (Some(left_value), Some(right_value)) = (map.get(left.as_ref()), map.get(right.as_ref())) { + if let (Some(left_value), Some(right_value)) = + (map.get(left.as_ref()), map.get(right.as_ref())) + { map.insert(expression, operator.eval(*left_value, *right_value)); } map @@ -209,18 +260,24 @@ mod tests { let expression = and(atomic("A"), atomic("B")); let truth_table = TruthTable::new(&expression, Default::default()); assert_eq!(truth_table.header, vec!["A", "B", "A ⋀ B"]); - assert_ne!(truth_table.truth_matrix, matrix![ - true, true, true; - false, true, false; - true, false, false; - false, false, false - ]); - assert_eq!(truth_table.truth_matrix, matrix![ - true, true, true; - true, false, false; - false, true, false; - false, false, false - ]); + assert_ne!( + truth_table.truth_matrix, + matrix![ + true, true, true; + false, true, false; + true, false, false; + false, false, false + ] + ); + assert_eq!( + truth_table.truth_matrix, + matrix![ + true, true, true; + true, false, false; + false, true, false; + false, false, false + ] + ); } #[test] @@ -229,26 +286,56 @@ mod tests { let truth_table = TruthTable::new(&expression, Default::default()); let atomics = 3; - assert_eq!(truth_table.header, vec!["A", "C", "A ⋁ C", "B", "B ⋁ C", "(A ⋁ C) ⋀ (B ⋁ C)"]); + assert_eq!( + truth_table.header, + vec!["A", "C", "A ⋁ C", "B", "B ⋁ C", "(A ⋁ C) ⋀ (B ⋁ C)"] + ); assert_eq!(truth_table.truth_matrix.len(), 2usize.pow(atomics as u32)); assert_eq!(truth_table.truth_matrix[0].len(), 6); - assert_eq!(truth_table.truth_matrix[0], vec![true, true, true, true, true, true]); - assert_eq!(truth_table.truth_matrix[1], vec![true, false, true, true, true, true]); - assert_eq!(truth_table.truth_matrix[2], vec![true, true, true, false, true, true]); - assert_eq!(truth_table.truth_matrix[3], vec![true, false, true, false, false, false]); - assert_eq!(truth_table.truth_matrix[4], vec![false, true, true, true, true, true]); - assert_eq!(truth_table.truth_matrix[5], vec![false, false, false, true, true, false]); - assert_eq!(truth_table.truth_matrix[6], vec![false, true, true, false, true, true]); - assert_eq!(truth_table.truth_matrix[7], vec![false, false, false, false, false, false]); + assert_eq!( + truth_table.truth_matrix[0], + vec![true, true, true, true, true, true] + ); + assert_eq!( + truth_table.truth_matrix[1], + vec![true, false, true, true, true, true] + ); + assert_eq!( + truth_table.truth_matrix[2], + vec![true, true, true, false, true, true] + ); + assert_eq!( + truth_table.truth_matrix[3], + vec![true, false, true, false, false, false] + ); + assert_eq!( + truth_table.truth_matrix[4], + vec![false, true, true, true, true, true] + ); + assert_eq!( + truth_table.truth_matrix[5], + vec![false, false, false, true, true, false] + ); + assert_eq!( + truth_table.truth_matrix[6], + vec![false, true, true, false, true, true] + ); + assert_eq!( + truth_table.truth_matrix[7], + vec![false, false, false, false, false, false] + ); } #[test] fn test_new_truth_table_and_hide_intermediate_steps() { let expression = and(atomic("A"), or(atomic("B"), atomic("C"))); - let truth_table = TruthTable::new(&expression, TruthTableOptions { - hide_intermediate_steps: true, - ..Default::default() - }); + let truth_table = TruthTable::new( + &expression, + TruthTableOptions { + hide_intermediate_steps: true, + ..Default::default() + }, + ); assert_eq!(truth_table.header, vec!["A", "B", "C", "A ⋀ (B ⋁ C)"]); for (index, row) in truth_table.truth_matrix.iter().enumerate() { assert_eq!(row.len(), 4, "Row at {index}: {:?}", row); @@ -264,12 +351,15 @@ mod tests { false, false, false ]; TruthTable::sort_matrix(&mut matrix, Sort::TrueFirst); - assert_eq!(matrix, matrix![ - true, true, true; - false, true, true; - true, false, false; - false, false, false - ]); + assert_eq!( + matrix, + matrix![ + true, true, true; + false, true, true; + true, false, false; + false, false, false + ] + ); } #[test] @@ -281,12 +371,15 @@ mod tests { true, false, false ]; TruthTable::sort_matrix(&mut matrix, Sort::TrueFirst); - assert_eq!(matrix, matrix![ - false, true, false; - false, true, false; - true, false, false; - true, false, false - ]); + assert_eq!( + matrix, + matrix![ + false, true, false; + false, true, false; + true, false, false; + true, false, false + ] + ); } #[test] @@ -298,12 +391,15 @@ mod tests { false, false, false ]; TruthTable::sort_matrix(&mut matrix, Sort::Default); - assert_eq!(matrix, matrix![ - true, true, true; - true, false, false; - false, true, true; - false, false, false - ]); + assert_eq!( + matrix, + matrix![ + true, true, true; + true, false, false; + false, true, true; + false, false, false + ] + ); } #[test] @@ -315,12 +411,15 @@ mod tests { false, false, false ]; TruthTable::sort_matrix(&mut matrix, Sort::FalseFirst); - assert_eq!(matrix, matrix![ - true, false, false; - false, false, false; - true, true, true; - false, true, true - ]); + assert_eq!( + matrix, + matrix![ + true, false, false; + false, false, false; + true, true, true; + false, true, true + ] + ); } #[test] @@ -333,20 +432,20 @@ mod tests { let matrix = TruthTable::generate_truth_matrix( &and(atomic("A"), atomic("B")), &["A".into(), "B".into(), "A ⋀ B".into()], - Hide::True, false, + Hide::True, + false, ); assert_eq!(expected, matrix); } #[test] fn test_hide_false_values() { - let expected = matrix![ - true, true, true - ]; + 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, false, + Hide::False, + false, ); assert_eq!(expected, matrix); } @@ -362,7 +461,8 @@ mod tests { let matrix = TruthTable::generate_truth_matrix( &and(atomic("A"), atomic("B")), &["A".into(), "B".into(), "A ⋀ B".into()], - Hide::None, false, + Hide::None, + false, ); assert_eq!(expected, matrix); } @@ -370,34 +470,46 @@ mod tests { #[test] fn test_truth_combinations_2() { let combinations = TruthTable::truth_combinations(2); - assert_eq!(combinations, matrix![ - true, true; - true, false; - false, true; - false, false - ]); + assert_eq!( + combinations, + matrix![ + true, true; + true, false; + false, true; + false, false + ] + ); } #[test] fn test_truth_combinations_3() { let combinations = TruthTable::truth_combinations(3); - assert_eq!(combinations, matrix![ - true, true, true; - true, true, false; - true, false, true; - true, false, false; - false, true, true; - false, true, false; - false, false, true; - false, false, false - ]); + assert_eq!( + combinations, + matrix![ + true, true, true; + true, true, false; + true, false, true; + true, false, false; + false, true, true; + false, true, false; + false, false, true; + false, false, false + ] + ); } #[test] fn test_resolve_expression_hide_intermediate_steps() { let expression = and(atomic("A"), or(atomic("B"), atomic("C"))); let booleans = map!["A".into() => true, "B".into() => false, "C".into() => true]; - let header = vec!["A".into(), "B".into(), "C".into(), "B ⋁ C".into(), "A ⋀ (B ⋁ C)".into()]; + let header = vec![ + "A".into(), + "B".into(), + "C".into(), + "B ⋁ C".into(), + "A ⋀ (B ⋁ C)".into(), + ]; let values = TruthTable::resolve_expression(&expression, &booleans, &header, true); assert_eq!(values.len(), 4); assert_eq!(values, vec![true, false, true, true]); @@ -443,7 +555,12 @@ mod tests { fn test_resolve_expression_even_more_duplicates() { let expression = and(atomic("A"), and(atomic("A"), and(atomic("A"), atomic("A")))); let booleans = HashMap::from([("A".into(), true)]); - let header = vec!["A".into(), "A ⋀ A".into(), "A ⋀ A ⋀ A".into(), "A ⋀ A ⋀ A ⋀ A".into()]; + let header = vec![ + "A".into(), + "A ⋀ A".into(), + "A ⋀ A ⋀ A".into(), + "A ⋀ A ⋀ A ⋀ A".into(), + ]; let values = TruthTable::resolve_expression(&expression, &booleans, &header, false); assert_eq!(values, vec![true, true, true, true]); } @@ -453,15 +570,20 @@ mod tests { let expression = and(atomic("A"), and(atomic("A"), and(atomic("A"), atomic("A")))); let booleans = HashMap::from([("A".into(), true)]); let values = TruthTable::_resolve_expression(&expression, &booleans); - assert_eq!(values, HashMap::from([ - (&atomic("A"), true), - (&and(atomic("A"), atomic("A")), true), - (&and(atomic("A"), and(atomic("A"), atomic("A"))), true), - (&and(atomic("A"), and(atomic("A"), and(atomic("A"), atomic("A")))), true), - ])); + assert_eq!( + values, + HashMap::from([ + (&atomic("A"), true), + (&and(atomic("A"), atomic("A")), true), + (&and(atomic("A"), and(atomic("A"), atomic("A"))), true), + ( + &and(atomic("A"), and(atomic("A"), and(atomic("A"), atomic("A")))), + true + ), + ]) + ); } - #[test] fn test_atomic_expression() { let expression = atomic("A"); @@ -501,7 +623,10 @@ mod tests { fn test_complex_expression() { let expression = implies(and(atomic("A"), atomic("B")), or(atomic("C"), atomic("D"))); let header = TruthTable::extract_header(&expression); - assert_eq!(header, vec!["A", "B", "A ⋀ B", "C", "D", "C ⋁ D", "A ⋀ B ➔ C ⋁ D"]); + assert_eq!( + header, + vec!["A", "B", "A ⋀ B", "C", "D", "C ⋁ D", "A ⋀ B ➔ C ⋁ D"] + ); } #[test] @@ -513,8 +638,14 @@ mod tests { #[test] fn test_somewhat_equal() { - let expression = and(atomic("A"), and(or(not(atomic("A")), atomic("B")), atomic("A"))); + let expression = and( + atomic("A"), + and(or(not(atomic("A")), atomic("B")), atomic("A")), + ); let header = TruthTable::extract_header(&expression); - assert_eq!(header, vec!["A", "¬A", "B", "¬A ⋁ B", "(¬A ⋁ B) ⋀ A", "A ⋀ (¬A ⋁ B) ⋀ A"]); + assert_eq!( + header, + vec!["A", "¬A", "B", "¬A ⋁ B", "(¬A ⋁ B) ⋀ A", "A ⋀ (¬A ⋁ B) ⋀ A"] + ); } } diff --git a/src/main.rs b/src/main.rs index 512b537..914e3ce 100644 --- a/src/main.rs +++ b/src/main.rs @@ -1,8 +1,8 @@ use lib::axum::app::AppBuilder; use tower_http::cors::CorsLayer; -use crate::routing::routes::*; use crate::routing::routes::index::not_found; +use crate::routing::routes::*; mod config; mod expressions; diff --git a/src/parsing/expression_parser.rs b/src/parsing/expression_parser.rs index ec7ecd6..c77ea03 100644 --- a/src/parsing/expression_parser.rs +++ b/src/parsing/expression_parser.rs @@ -100,7 +100,7 @@ fn implication_expression<'a>( } fn not_expression(input: &str) -> IResult<&str, Expression> { - preceded(char('!'), left_hand_side)(input).map(|(remaining, right)| (remaining, right.not())) + map(preceded(char('!'), left_hand_side), Expression::not)(input) } fn value(input: &str) -> IResult<&str, Expression> { diff --git a/src/parsing/mod.rs b/src/parsing/mod.rs index 74eee6a..bb6aafc 100644 --- a/src/parsing/mod.rs +++ b/src/parsing/mod.rs @@ -1 +1 @@ -pub(crate) mod expression_parser; \ No newline at end of file +pub(crate) mod expression_parser; diff --git a/src/routing/error.rs b/src/routing/error.rs index b41a17f..d55decd 100644 --- a/src/routing/error.rs +++ b/src/routing/error.rs @@ -1,5 +1,5 @@ -use axum::Json; use axum::response::{IntoResponse, Response}; +use axum::Json; use serde::Serialize; #[derive(Serialize, Default)] diff --git a/src/routing/mod.rs b/src/routing/mod.rs index c9223aa..f4ac353 100644 --- a/src/routing/mod.rs +++ b/src/routing/mod.rs @@ -1,4 +1,4 @@ -pub(crate) mod response; pub(crate) mod error; +pub(crate) mod options; +pub(crate) mod response; pub(crate) mod routes; -pub(crate) mod options; \ No newline at end of file diff --git a/src/routing/options.rs b/src/routing/options.rs index ba1a07c..be772ce 100644 --- a/src/routing/options.rs +++ b/src/routing/options.rs @@ -1,15 +1,12 @@ -use serde::Deserialize; use crate::expressions::truth_table::{Hide, Sort}; -use crate::utils::serialize::{ret_true, deserialize_bool}; +use crate::utils::serialize::{deserialize_bool, ret_true}; +use serde::Deserialize; // TODO deserialize_bool should not be necessary #[derive(Deserialize)] #[serde(rename_all = "camelCase")] pub struct SimplifyOptions { - #[serde( - default = "ret_true", - deserialize_with = "deserialize_bool" - )] + #[serde(default = "ret_true", deserialize_with = "deserialize_bool")] pub simplify: bool, #[serde(default, deserialize_with = "deserialize_bool")] pub ignore_case: bool, diff --git a/src/routing/routes/index.rs b/src/routing/routes/index.rs index 677acae..c2d6367 100644 --- a/src/routing/routes/index.rs +++ b/src/routing/routes/index.rs @@ -1,7 +1,7 @@ use axum::extract::Path; use axum::http::StatusCode; -use axum::Json; use axum::response::{IntoResponse, Response}; +use axum::Json; use lib::router; use serde::Serialize; @@ -40,7 +40,7 @@ async fn open_api() -> impl IntoResponse { async fn is_valid(Path(path): Path) -> Response { match Expression::try_from(path.as_str()) { Ok(_) => IsValidResponse::valid().into_response(), - Err(error) => Error::new(error.to_string(), ErrorKind::InvalidExpression).into_response() + Err(error) => Error::new(error.to_string(), ErrorKind::InvalidExpression).into_response(), } } diff --git a/src/routing/routes/mod.rs b/src/routing/routes/mod.rs index 46e0b20..7528876 100644 --- a/src/routing/routes/mod.rs +++ b/src/routing/routes/mod.rs @@ -1,5 +1,3 @@ pub(crate) mod index; - pub(crate) mod simplify; - pub(crate) mod table; diff --git a/src/routing/routes/simplify.rs b/src/routing/routes/simplify.rs index ab2d73c..a2c7b79 100644 --- a/src/routing/routes/simplify.rs +++ b/src/routing/routes/simplify.rs @@ -9,10 +9,13 @@ use crate::routing::error::{Error, ErrorKind}; use crate::routing::options::{SimplifyAndTableOptions, SimplifyOptions}; use crate::routing::response::SimplifyResponse; -router!("/simplify", routes!( - get "/:exp" => simplify, - get "/table/:exp" => simplify_and_table -)); +router!( + "/simplify", + routes!( + get "/:exp" => simplify, + get "/table/:exp" => simplify_and_table + ) +); async fn simplify(Path(path): Path, Query(query): Query) -> Response { match Expression::try_from(path.as_str()) { @@ -28,15 +31,21 @@ async fn simplify(Path(path): Path, Query(query): Query operations, expression, truth_table: None, - }.into_response() - } - Err(error) => { - (StatusCode::BAD_REQUEST, Error::new(error.to_string(), ErrorKind::InvalidExpression)).into_response() + } + .into_response() } + Err(error) => ( + StatusCode::BAD_REQUEST, + Error::new(error.to_string(), ErrorKind::InvalidExpression), + ) + .into_response(), } } -async fn simplify_and_table(Path(path): Path, Query(query): Query) -> Response { +async fn simplify_and_table( + Path(path): Path, + Query(query): Query, +) -> Response { match Expression::try_from(path.as_str()) { Ok(mut expression) => { let before = expression.to_string(); @@ -51,10 +60,13 @@ async fn simplify_and_table(Path(path): Path, Query(query): Query { - (StatusCode::BAD_REQUEST, Error::new(error.to_string(), ErrorKind::InvalidExpression)).into_response() + } + .into_response() } + Err(error) => ( + StatusCode::BAD_REQUEST, + Error::new(error.to_string(), ErrorKind::InvalidExpression), + ) + .into_response(), } } diff --git a/src/routing/routes/table.rs b/src/routing/routes/table.rs index 17cda97..3481a53 100644 --- a/src/routing/routes/table.rs +++ b/src/routing/routes/table.rs @@ -9,16 +9,24 @@ use crate::routing::error::{Error, ErrorKind}; use crate::routing::options::TruthTableOptions; use crate::routing::response::TruthTableResponse; -router!("/table", routes!( - get "/:exp" => table -)); +router!( + "/table", + routes!( + get "/:exp" => table + ) +); // TODO Expression as input in body async fn table(Path(value): Path, Query(query): Query) -> Response { match Expression::try_from(value) { - Ok(expression) => { - TruthTableResponse { truth_table: TruthTable::new(&expression, query) }.into_response() + Ok(expression) => TruthTableResponse { + truth_table: TruthTable::new(&expression, query), } - Err(e) => (StatusCode::BAD_REQUEST, Error::new(e.to_string(), ErrorKind::InvalidExpression)).into_response(), + .into_response(), + Err(e) => ( + StatusCode::BAD_REQUEST, + Error::new(e.to_string(), ErrorKind::InvalidExpression), + ) + .into_response(), } } diff --git a/src/utils/axum.rs b/src/utils/axum.rs index f0e2798..9fcb824 100644 --- a/src/utils/axum.rs +++ b/src/utils/axum.rs @@ -19,7 +19,11 @@ macro_rules! load_html { #[cfg(debug_assertions)] macro_rules! absolute_path { ($filename:literal) => { - concat!(env!("CARGO_MANIFEST_DIR"), "/src/resources/static/", $filename) + concat!( + env!("CARGO_MANIFEST_DIR"), + "/src/resources/static/", + $filename + ) }; } diff --git a/src/utils/mod.rs b/src/utils/mod.rs index d7435b3..e071d85 100644 --- a/src/utils/mod.rs +++ b/src/utils/mod.rs @@ -1,2 +1,2 @@ +pub mod axum; pub mod serialize; -pub mod axum; \ No newline at end of file diff --git a/src/utils/serialize.rs b/src/utils/serialize.rs index 9364dd7..faac02d 100644 --- a/src/utils/serialize.rs +++ b/src/utils/serialize.rs @@ -4,8 +4,9 @@ pub(crate) const fn ret_true() -> bool { true } - -pub(crate) fn deserialize_bool<'de, D: Deserializer<'de>>(deserializer: D) -> Result { +pub(crate) fn deserialize_bool<'de, D: Deserializer<'de>>( + deserializer: D, +) -> Result { let s: &str = Deserialize::deserialize(deserializer)?; match s { @@ -13,4 +14,4 @@ pub(crate) fn deserialize_bool<'de, D: Deserializer<'de>>(deserializer: D) -> Re "false" => Ok(false), _ => Err(de::Error::unknown_variant(s, &["true", "false"])), } -} \ No newline at end of file +}