From 849c87a8784495fcbd4c4b9da67bdc14d3a934d7 Mon Sep 17 00:00:00 2001 From: Martin Berg Alstad Date: Sun, 16 Jun 2024 20:19:03 +0200 Subject: [PATCH] Fixed bug with deserializing of bool --- http/simplify.http | 4 ++++ src/expressions/simplify.rs | 10 ++++------ src/routing/simplify.rs | 19 ++++++++++--------- src/routing/table.rs | 3 ++- src/utils/mod.rs | 3 ++- src/utils/serialize.rs | 16 ++++++++++++++++ 6 files changed, 38 insertions(+), 17 deletions(-) create mode 100644 src/utils/serialize.rs diff --git a/http/simplify.http b/http/simplify.http index 5768e67..956046f 100644 --- a/http/simplify.http +++ b/http/simplify.http @@ -127,3 +127,7 @@ GET {{url}}/simplify/{{expression}} client.assert(operations[0].law === "ABSORPTION_LAW", `The law field does not match the expected value, was ${operations[0].law} but expected ABSORPTION_LAW`) }); %} + +### GET with simplify="true" + +GET {{url}}/simplify/A?simplify=true&hide=NONE&sort=DEFAULT&caseSensitive=false&hideIntermediate=false diff --git a/src/expressions/simplify.rs b/src/expressions/simplify.rs index a0130a8..0e000f0 100644 --- a/src/expressions/simplify.rs +++ b/src/expressions/simplify.rs @@ -87,7 +87,6 @@ impl Expression { Expression::Not(expr) => { match expr.deref() { Expression::Binary { left, operator: BinaryOperator::And, right } => { - // TODO unnecessary cloning calls to de_morgans_laws? let left = not(left.de_morgans_laws(operations)); let right = not(right.de_morgans_laws(operations)); or(left, right).de_morgans_laws(operations) @@ -115,7 +114,7 @@ impl Expression { fn absorption_law(&self, operations: &mut Vec) -> Self { let result = match self { - Expression::Binary { left, operator: BinaryOperator::And | BinaryOperator::Or, right } if left == right => { + Expression::Binary { left, operator: BinaryOperator::And | BinaryOperator::Or, right } if *left == *right => { left.absorption_law(operations) } Expression::Binary { left, operator: BinaryOperator::And, right } => { @@ -135,15 +134,14 @@ impl Expression { } } Expression::Binary { left, operator: BinaryOperator::Or, right } => { - let (left_ref, right_ref) = (left.as_ref(), right.as_ref()); - match (left_ref, right_ref) { + match (left.as_ref(), right.as_ref()) { (_, Expression::Binary { left: right_left, operator: BinaryOperator::And, right: right_right }) => { - evaluate_equals_or_opposites(left_ref, right_left, right_right, or, operations).unwrap_or( + evaluate_equals_or_opposites(left.as_ref(), right_left, right_right, or, operations).unwrap_or( or(left.absorption_law(operations), right.absorption_law(operations)) ) } (Expression::Binary { left: left_left, operator: BinaryOperator::And, right: left_right }, _) => { - evaluate_equals_or_opposites(right_ref, left_left, left_right, or, operations).unwrap_or( + evaluate_equals_or_opposites(right.as_ref(), left_left, left_right, or, operations).unwrap_or( or(left.absorption_law(operations), right.absorption_law(operations)) ) } diff --git a/src/routing/simplify.rs b/src/routing/simplify.rs index 15cee76..507977e 100644 --- a/src/routing/simplify.rs +++ b/src/routing/simplify.rs @@ -2,12 +2,13 @@ use axum::{Router, routing::get}; use axum::extract::{Path, Query}; use axum::http::StatusCode; use axum::response::{IntoResponse, Response}; -use serde::Deserialize; +use serde::{Deserialize}; use crate::expressions::expression::Expression; use crate::expressions::truth_table::{Hide, Sort, TruthTable, TruthTableOptions}; use crate::routing::error::{Error, ErrorKind}; use crate::routing::response::SimplifyResponse; +use crate::utils::serialize::{ret_true, deserialize_bool}; pub fn router() -> Router<()> { Router::new() @@ -18,19 +19,17 @@ pub fn router() -> Router<()> { ) } -const fn default_true() -> bool { - true -} - #[derive(Deserialize)] struct SimplifyOptions { - #[serde(default = "default_true")] + #[serde( + default = "ret_true", + deserialize_with = "deserialize_bool" + )] simplify: bool, - #[serde(default = "default_true")] - case_sensitive: bool, + #[serde(default = "ret_true")] + case_sensitive: bool, // TODO: Implement case sensitivity } -// TODO async fn simplify(Path(path): Path, Query(query): Query) -> Response { match Expression::try_from(path.as_str()) { Ok(mut expression) => { @@ -62,6 +61,8 @@ struct SimplifyAndTableQuery { sort: Sort, #[serde(default)] hide: Hide, + #[serde(default)] + hide_intermediate_steps: bool, // TODO } async fn simplify_and_table(Path(path): Path, Query(query): Query) -> Response { diff --git a/src/routing/table.rs b/src/routing/table.rs index 2ddd867..a213290 100644 --- a/src/routing/table.rs +++ b/src/routing/table.rs @@ -1,3 +1,4 @@ +use axum::response::Response; use axum::Router; use axum::routing::post; @@ -8,6 +9,6 @@ pub fn router() -> Router<()> { ) } -async fn table() { +async fn table() -> Response { unimplemented!() } diff --git a/src/utils/mod.rs b/src/utils/mod.rs index 615880a..a81c6df 100644 --- a/src/utils/mod.rs +++ b/src/utils/mod.rs @@ -1 +1,2 @@ -pub mod array; \ No newline at end of file +pub mod array; +pub mod serialize; \ No newline at end of file diff --git a/src/utils/serialize.rs b/src/utils/serialize.rs new file mode 100644 index 0000000..9364dd7 --- /dev/null +++ b/src/utils/serialize.rs @@ -0,0 +1,16 @@ +use serde::{de, Deserialize, Deserializer}; + +pub(crate) const fn ret_true() -> bool { + true +} + + +pub(crate) fn deserialize_bool<'de, D: Deserializer<'de>>(deserializer: D) -> Result { + let s: &str = Deserialize::deserialize(deserializer)?; + + match s { + "true" => Ok(true), + "false" => Ok(false), + _ => Err(de::Error::unknown_variant(s, &["true", "false"])), + } +} \ No newline at end of file