Started implementing Axum

src/language.rs

@@ -0,0 +1,34 @@
+use axum::async_trait;
+use axum::extract::FromRequestParts;
+use axum::http::{HeaderValue, StatusCode};
+use axum::http::header::ACCEPT_LANGUAGE;
+use axum::http::request::Parts;
+use serde::Deserialize;
+
+#[derive(Deserialize, Debug, Default)]
+pub enum Language {
+    #[default]
+    #[serde(rename = "en")]
+    En,
+    #[serde(rename = "nb")]
+    Nb,
+}
+
+#[derive(Debug)]
+pub(crate) struct AcceptLanguage(HeaderValue);
+
+#[async_trait]
+impl<S> FromRequestParts<S> for AcceptLanguage
+    where
+        S: Send + Sync,
+{
+    type Rejection = (StatusCode, &'static str);
+
+    async fn from_request_parts(parts: &mut Parts, _state: &S) -> Result<Self, Self::Rejection> {
+        if let Some(accept_language) = parts.headers.get(ACCEPT_LANGUAGE) {
+            Ok(AcceptLanguage(accept_language.clone()))
+        } else {
+            Err((StatusCode::BAD_REQUEST, "`Accept-language` header is missing"))
+        }
+    }
+}

src/main.rs

@@ -1,6 +1,21 @@
+use tokio::net::TcpListener;
+use crate::routing::{simplify, table};
+
 mod expressions;
 mod parsing;
+mod routing;
+mod language;
 
-fn main() {
-    println!("Hello, world!");
+#[tokio::main]
+async fn main() {
+    let listener = TcpListener::bind("127.0.0.1:8000")
+        .await
+        .unwrap();
+
+    println!("Listening on: {}", listener.local_addr().unwrap());
+
+    let routes = simplify::router()
+        .merge(table::router());
+
+    axum::serve(listener, routes).await.unwrap();
 }

src/routing/mod.rs

@@ -0,0 +1,2 @@
+pub(crate) mod simplify;
+pub(crate) mod table;

src/routing/simplify.rs

@@ -0,0 +1,37 @@
+use axum::{Router, routing::get};
+use axum::extract::{Path, Query};
+use serde::Deserialize;
+
+use crate::language::{AcceptLanguage, Language};
+
+pub fn router() -> Router<()> {
+    Router::new()
+        .nest("/simplify",
+              Router::new()
+                  .route("/:exp", get(simplify))
+                  .route("/table/:exp", get(simplify_and_table)),
+        )
+}
+
+const fn default_true() -> bool {
+    true
+}
+
+#[derive(Deserialize, Debug)]
+struct QueryOptions {
+    #[serde(default)]
+    lang: Language,
+    #[serde(default = "default_true")]
+    simplify: bool,
+    #[serde(default)]
+    case_sensitive: bool,
+}
+
+// TODO
+async fn simplify(Path(path): Path<String>, query: Query<QueryOptions>, accept_language: Option<AcceptLanguage>) -> String {
+    format!("Path: {}, Query: {:?}, Accept-language header: {:?}", path, query, accept_language)
+}
+
+async fn simplify_and_table() {
+    unimplemented!("Not yet implemented")
+}

src/routing/table.rs

@@ -0,0 +1,13 @@
+use axum::Router;
+use axum::routing::post;
+
+pub fn router() -> Router<()> {
+    Router::new()
+        .nest("/table", Router::new()
+            .route("/", post(table)),
+        )
+}
+
+async fn table() {
+    unimplemented!("Not yet implemented")
+}