martials/simplify_truths
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

fmt. Removed some usage of macros

Browse Source
This commit is contained in:
Martin Berg Alstad 2024-09-05 21:57:50 +02:00
parent 1350e09bde
commit 25b708a6fd
19 changed files with 442 additions and 207 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
Dockerfile
View File

@ -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

8
src/expressions/helpers.rs
View File

@ -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<Rc<Expression>>,
R: Into<Rc<Expression>>,
{
Expression::Binary { left: left.into(), operator, right: right.into() }
Expression::Binary {
left: left.into(),
operator,
right: right.into(),
}
}
#[inline]

4
src/expressions/mod.rs
View File

@ -1,5 +1,5 @@
pub mod expression;
pub mod operator;
pub mod helpers;
pub mod operator;
pub mod simplify;
pub mod truth_table;
pub mod truth_table;

3
src/expressions/operator.rs
View File

@ -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)
}

179
src/expressions/simplify.rs
View File

@ -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<Operation>,
) -> 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<Operation>) -> Self {
fn _associative_law(&self, _operations: &mut Vec<Operation>) -> 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<Operation>) -> Self {
fn commutative_law(&self, _operations: &mut Vec<Operation>) -> 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);

353
src/expressions/truth_table.rs
View File

@ -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<String> {
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::<Vec<String>>();
fn generate_truth_matrix(
expression: &Expression,
header: &[String],
hide: Hide,
hide_intermediate: bool,
) -> TruthMatrix {
let mut atomics = expression
.get_atomic_values()
.into_iter()
.collect::<Vec<String>>();
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<String, bool>, header: &[String], hide_intermediate: bool) -> Vec<bool> {
fn resolve_expression(
expression: &Expression,
booleans: &HashMap<String, bool>,
header: &[String],
hide_intermediate: bool,
) -> Vec<bool> {
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::<HashMap<String, bool>>();
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<String, bool>) -> HashMap<&'a Expression, bool> {
fn _resolve_expression<'a>(
expression: &'a Expression,
booleans: &HashMap<String, bool>,
) -> 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"]
);
}
}

2
src/main.rs
View File

@ -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;

2
src/parsing/expression_parser.rs
View File

@ -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> {

2
src/parsing/mod.rs
View File

@ -1 +1 @@
pub(crate) mod expression_parser;
pub(crate) mod expression_parser;

2
src/routing/error.rs
View File

@ -1,5 +1,5 @@
use axum::Json;
use axum::response::{IntoResponse, Response};
use axum::Json;
use serde::Serialize;
#[derive(Serialize, Default)]

4
src/routing/mod.rs
View File

@ -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;

9
src/routing/options.rs
View File

@ -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,

4
src/routing/routes/index.rs
View File

@ -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<String>) -> 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(),
}
}

2
src/routing/routes/mod.rs
View File

@ -1,5 +1,3 @@
pub(crate) mod index;
pub(crate) mod simplify;
pub(crate) mod table;

38
src/routing/routes/simplify.rs
View File

@ -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<String>, Query(query): Query<SimplifyOptions>) -> Response {
match Expression::try_from(path.as_str()) {
@ -28,15 +31,21 @@ async fn simplify(Path(path): Path<String>, Query(query): Query<SimplifyOptions>
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<String>, Query(query): Query<SimplifyAndTableOptions>) -> Response {
async fn simplify_and_table(
Path(path): Path<String>,
Query(query): Query<SimplifyAndTableOptions>,
) -> 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<String>, Query(query): Query<Simpli
operations,
expression,
truth_table: Some(truth_table),
}.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(),
}
}

20
src/routing/routes/table.rs
View File

@ -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<String>, Query(query): Query<TruthTableOptions>) -> 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(),
}
}

6
src/utils/axum.rs
View File

@ -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
)
};
}

2
src/utils/mod.rs
View File

@ -1,2 +1,2 @@
pub mod axum;
pub mod serialize;
pub mod axum;

7
src/utils/serialize.rs
View File

@ -4,8 +4,9 @@ pub(crate) const fn ret_true() -> bool {
true
}
pub(crate) fn deserialize_bool<'de, D: Deserializer<'de>>(deserializer: D) -> Result<bool, D::Error> {
pub(crate) fn deserialize_bool<'de, D: Deserializer<'de>>(
deserializer: D,
) -> Result<bool, D::Error> {
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"])),
}
}
}