UPDATE: basics working

fileformat · fileformat · commit d143ebe9e214 · 2024-09-03T20:15:30.000-04:00
diff --git a/Cargo.lock b/Cargo.lock
diff --git a/Cargo.toml b/Cargo.toml
@@ -5,8 +5,11 @@ edition = "2021"
 
 [dependencies]
 axum = "0.7.5"
+axum-extra = { version = "0.9.3", features = ["form"] }
 base64 = "0.22.1"
 chrono = "0.4.38"
+html-escape = "0.2.13"
+regex = "1.10.6"
 rustc_version_runtime = "0.3.0"
 serde = { version = "1.0.208", features = ["derive"] }
 serde_json = "1.0.125"
diff --git a/bin/test.sh b/bin/test.sh
@@ -0,0 +1,14 @@
+#!/usr/bin/env bash
+#
+# test locally running instance
+#
+
+set -o errexit
+set -o pipefail
+set -o nounset
+
+curl \
+	--data 'callback=cb&regex=^([a-z]*)$&replacement=X&input=ab&input=ab1' \
+	--request POST \
+	--verbose \
+	http://localhost:4000/test.json
diff --git a/src/main.rs b/src/main.rs
@@ -1,31 +1,28 @@
 
 use axum::{
-    body::Body,
-    extract::{DefaultBodyLimit, Query},
-    response::{IntoResponse, Redirect, Response},
-    routing::get,
-    Json, Router,
+    body::Body, extract::{DefaultBodyLimit, Query}, response::{IntoResponse, Response}, routing::{get, post}, Json, Router
 };
+use axum_extra::extract::Form;
 
 use rustc_version_runtime::version;
 use serde::{Deserialize, Serialize};
 use tower_http::{limit::RequestBodyLimitLayer, services::ServeFile};
+use html_escape::encode_text;
 
 #[tokio::main]
 async fn main() {
     // build our application with a single route
     let app = Router::new()
-        //.route_service("/", get(|| async { Redirect::temporary("https://www.regexplanet.com/advanced/rust/index.html") }))
+        //.route_service("/", get(|| async { axum::Redirect::temporary("https://www.regexplanet.com/advanced/rust/index.html") }))
         .route_service("/", get(root_handler))
+        .route_service("/test.json", post(test_handler))
         .route_service("/favicon.ico", ServeFile::new("static/favicon.ico"))
         .route_service("/favicon.svg", ServeFile::new("static/favicon.svg"))
         .route_service("/robots.txt", ServeFile::new("static/robots.txt"))
         .route_service("/status.json", get(get_status))
         .layer(DefaultBodyLimit::disable())
         .layer(RequestBodyLimitLayer::new(10 * 1024 * 1024 /* 10mb */));
 
-    // run our app with hyper, listening globally on port 3000
-
     // get address from environment variable
     let address = std::env::var("ADDRESS").unwrap_or_else(|_| "0.0.0.0".to_string());
 
@@ -89,4 +86,121 @@ async fn root_handler() -> Response<Body> {
         .header("Content-Type", "text/plain; charset=utf-8")
         .body(Body::from("Dev server running!"))
         .unwrap();
+}
+
+#[derive(Deserialize, Serialize, Debug)]
+struct TestInput {
+    regex: String,
+    #[serde(default)]
+    replacement: String,
+    #[serde(default)]
+    callback: String,
+    #[serde(default)]
+    options: Vec<String>,
+    #[serde(default)]
+    #[serde(rename(deserialize = "input"))]
+    inputs: Vec<String>,
+}
+
+#[derive(Serialize)]
+struct TestOutput {
+    success: bool,
+    message: String,
+    html: String,
+}
+
+async fn test_handler(Form(test_input): Form<TestInput>) -> Response<Body> {
+    
+    let mut html = String::new();
+
+    html.push_str("<table class=\"table table-bordered table-striped\" style=\"width: auto;\">\n");
+    html.push_str("\t<tbody>\n");
+    html.push_str("\t\t<tr>\n");
+    html.push_str("\t\t\t<td>Regular Expression</td>\n");
+    html.push_str(&format!("\t\t\t<td><code>{}</code></td>\n", encode_text(&test_input.regex)));
+    html.push_str("\t\t</tr>\n");
+
+    if test_input.replacement != "" {
+        html.push_str("\t\t<tr>\n");
+        html.push_str("\t\t\t<td>Replacement</td>\n");
+        html.push_str(&format!("\t\t\t<td><code>{}</code></td>\n", encode_text(&test_input.replacement)));
+        html.push_str("\t\t</tr>\n");
+    }
+
+    html.push_str("\t</tbody>\n");
+    html.push_str("</table>");
+
+    let the_regex = regex::RegexBuilder::new(&test_input.regex)
+        .case_insensitive(test_input.options.contains(&"i".to_string()))
+        .multi_line(test_input.options.contains(&"m".to_string()))
+        .dot_matches_new_line(test_input.options.contains(&"s".to_string()))
+        .build();
+
+    if the_regex.is_err() {
+        let err_msg = the_regex.unwrap_err().to_string();
+
+        html.push_str("<div class=\"alert alert-danger\" role=\"alert\">\n");   
+        html.push_str(&format!("<strong>Error:</strong> {}<br>\n", encode_text(&err_msg)));
+        html.push_str("</div>\n");
+
+        return handle_jsonp(&test_input.callback, html);
+    } 
+
+    if test_input.inputs.len() == 0 {
+        html.push_str("<div class=\"alert alert-danger\" role=\"alert\">\n");   
+        html.push_str("No inputs to test!\n");
+        html.push_str("</div>\n");
+
+        return handle_jsonp(&test_input.callback, html);
+    }
+
+    let the_regex = the_regex.unwrap();
+
+    html.push_str("<table class=\"table table-bordered table-striped\" style=\"width: auto;\">\n");
+    html.push_str("\t<thead>\n");
+    html.push_str("\t\t<tr>\n");
+    html.push_str("\t\t\t<th>Input</th>\n");
+    html.push_str("\t\t\t<th>is_match</th>\n");
+    html.push_str("\t\t</tr>\n");
+    html.push_str("\t</thead>\n");
+    html.push_str("\t<tbody>\n");
+
+    for input in test_input.inputs {
+        //let output = the_regex.as_ref().unwrap().replace_all(&input, &test_input.replacement);
+        html.push_str("\t\t<tr>\n");
+        html.push_str(&format!("\t\t\t<td>{}</td>\n", encode_text(&input)));
+        let is_match = if the_regex.is_match(&input) { "true" } else { "false" };
+        html.push_str(&format!("\t\t\t<td>{}</td>\n", is_match));
+        html.push_str("\t\t</tr>\n");
+    }
+
+    html.push_str("\t</tbody>\n");
+    html.push_str("</table>");
+
+    return handle_jsonp(&test_input.callback, html);
+}
+
+fn handle_jsonp(callback: &str, html: String) -> Response<Body> {
+
+
+    let test_output = TestOutput {
+        success: true,
+        message: "OK".to_string(),
+        html: html,
+    };
+
+    let json_output = serde_json::to_string(&test_output).unwrap();
+
+    if callback == "" {
+        return Response::builder()
+            .header("Content-Type", "application/json; charset=utf-8")
+            .body(Body::from(json_output))
+            .unwrap();
+    } else {
+        let jsonp = format!("{}({})", callback, json_output);
+        return Response::builder()
+            .header("Content-Type", "text/html; charset=utf-8")
+            .body(Body::from(jsonp))
+            .unwrap();
+    }
 }
