add support for json to lisp and vice versa in the web endpoint

thiennamdinh · thiennamdinh · commit bdfee142afbb · 2026-02-22T14:01:26.000-08:00
diff --git a/src/evaluator.rs b/src/evaluator.rs
@@ -89,7 +89,7 @@ pub fn obj2str(sc: *mut s7_scheme, obj: *mut s7_cell) -> String {
     }
 }
 
-pub fn scheme2json(expression: &str) -> Result<Value, String> {
+pub fn lisp2json(expression: &str) -> Result<Value, String> {
     // <TYPE>: <JSON>
     // ------------------------------------------------------
     // symbol: "string"
@@ -122,7 +122,7 @@ pub fn scheme2json(expression: &str) -> Result<Value, String> {
     }
 }
 
-pub fn json2scheme(expression: Value) -> Result<String, String> {
+pub fn json2lisp(expression: &Value) -> Result<String, String> {
     unsafe {
         let sc: *mut s7_scheme = s7_init();
         match json_to_s7_obj(sc, &expression) {
diff --git a/src/lib.rs b/src/lib.rs
@@ -1,7 +1,7 @@
 #![doc = include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/README.md"))]
 
 pub use crate::config::Config;
-use crate::evaluator::{Evaluator, Primitive, Type, json2scheme, obj2str, scheme2json};
+use crate::evaluator::{Evaluator, Primitive, Type, json2lisp, obj2str, lisp2json};
 use crate::extensions::crypto::{
     primitive_s7_crypto_generate, primitive_s7_crypto_sign, primitive_s7_crypto_verify,
 };
@@ -139,20 +139,83 @@ impl Journal {
     }
 
     pub fn evaluate_json(&self, query: Value) -> Value {
-        match json2scheme(query) {
+        match json2lisp(&query) {
             Ok(scheme_query) => {
                 let result = self.evaluate_record(NULL, scheme_query.as_str());
-                match scheme2json(result.as_str()) {
+                match lisp2json(result.as_str()) {
                     Ok(json_result) => json_result,
-                    Err(_) => scheme2json("(error parse-error \"Failed to parse Scheme to JSON\")")
+                    Err(_) => {
+                        log::warn!(
+                            "Failed to parse Scheme to JSON. Result: {}",
+                            result
+                        );
+                        lisp2json("(error parse-error \"Failed to parse Scheme to JSON\")")
+                    }
                         .expect("Error parsing the JSON error message"),
                 }
             }
-            Err(_) => scheme2json("(error parse-error \"Failed to parse JSON to Scheme\")")
+            Err(_) => {
+                let query_str = serde_json::to_string(&query)
+                    .unwrap_or_else(|_| "<unprintable json>".to_string());
+                log::warn!(
+                    "Failed to parse JSON to Scheme. Query: {}",
+                    query_str
+                );
+                lisp2json("(error parse-error \"Failed to parse JSON to Scheme\")")
+            }
                 .expect("Error parsing the JSON error message"),
         }
     }
 
+    /// Convert a Lisp expression into its JSON representation without evaluation.
+    ///
+    /// # Examples
+    /// ```
+    /// use journal_sdk::JOURNAL;
+    /// use serde_json::json;
+    ///
+    /// let output = JOURNAL.lisp_to_json("(+ 1 2)");
+    /// assert_eq!(output, json!(["+", 1, 2]));
+    /// ```
+    pub fn lisp_to_json(&self, query: &str) -> Value {
+        match lisp2json(query) {
+            Ok(json_result) => json_result,
+            Err(_) => {
+                log::warn!(
+                    "Failed to parse Scheme to JSON. Query: {}",
+                    query
+                );
+                lisp2json("(error parse-error \"Failed to parse Scheme to JSON\")")
+            }
+            .expect("Error parsing the JSON error message"),
+        }
+    }
+
+    /// Convert a JSON expression into its Lisp representation without evaluation.
+    ///
+    /// # Examples
+    /// ```
+    /// use journal_sdk::JOURNAL;
+    /// use serde_json::json;
+    ///
+    /// let output = JOURNAL.json_to_lisp(json!(["+", 1, 2]));
+    /// assert_eq!(output, "(+ 1 2)");
+    /// ```
+    pub fn json_to_lisp(&self, query: Value) -> String {
+        match json2lisp(&query) {
+            Ok(scheme_result) => scheme_result,
+            Err(_) => {
+                let query_str = serde_json::to_string(&query)
+                    .unwrap_or_else(|_| "<unprintable json>".to_string());
+                log::warn!(
+                    "Failed to parse JSON to Scheme. Query: {}",
+                    query_str
+                );
+                "(error parse-error \"Failed to parse JSON to Scheme\")".to_string()
+            }
+        }
+    }
+
     fn evaluate_record(&self, record: Word, query: &str) -> String {
         let mut runs = 0;
         let cache = Arc::new(Mutex::new(HashMap::new()));
diff --git a/src/main.rs b/src/main.rs
@@ -2,7 +2,7 @@ use journal_sdk::{Config, JOURNAL};
 use log::info;
 use rocket::config::Config as RocketConfig;
 use rocket::data::{Limits, ToByteUnit};
-use rocket::response::content::RawHtml;
+use rocket::response::content::{RawHtml, RawText};
 use rocket::serde::json::Json;
 use rocket::{get, post, routes};
 use serde_json::Value;
@@ -20,6 +20,8 @@ const INDEX_HTML: &str = r#"<!DOCTYPE html>
  <ul>
      <li><a href="/interface">LISP Interface</a></li>
      <li><a href="/interface/json">JSON Interface</a></li>
+     <li><a href="/interface/lisp-to-json">LISP to JSON</a></li>
+     <li><a href="/interface/json-to-lisp">JSON to LISP</a></li>
  </ul>
     </body>
 </html>
@@ -28,7 +30,7 @@ const INDEX_HTML: &str = r#"<!DOCTYPE html>
 const INTERFACE_HTML: &str = r#"<!DOCTYPE html>
 <html>
     <head>
- <h2>{}</h2>
+ <h2>__TITLE__</h2>
     </head>
     <body style="padding: 0 20px; font-family: 'Consolas'">
  <textarea id="query" rows="8" cols="128" spellcheck="false"></textarea>
@@ -43,9 +45,7 @@ const INTERFACE_HTML: &str = r#"<!DOCTYPE html>
   let query = document.getElementById('query').value;
   fetch('', {
       method: 'POST',
-      headers: {
-          'Content-Type': 'application/json',
-      },
+      __HEADERS__
       body: query,
   }).then(response => {
       return response.text();
@@ -76,17 +76,43 @@ async fn index() -> RawHtml<String> {
 
 #[get("/interface", format = "text/html")]
 async fn inform_lisp() -> RawHtml<String> {
-    RawHtml(INTERFACE_HTML.replace("{}", "LISP Interface"))
+    RawHtml(
+        INTERFACE_HTML
+            .replace("__TITLE__", "LISP Interface")
+            .replace("__HEADERS__", ""),
+    )
 }
 
 #[post("/interface", data = "<query>", rank = 1)]
 async fn evaluate_lisp(query: &str) -> String {
     JOURNAL.evaluate(query)
 }
 
+#[get("/interface/lisp-to-json", format = "text/html")]
+async fn inform_lisp_to_json() -> RawHtml<String> {
+    RawHtml(
+        INTERFACE_HTML
+            .replace("__TITLE__", "LISP to JSON")
+            .replace("__HEADERS__", ""),
+    )
+}
+
+#[post("/interface/lisp-to-json", data = "<query>", rank = 1)]
+async fn lisp_to_json(query: &str) -> Json<Value> {
+    let result = JOURNAL.lisp_to_json(query);
+    Json(result)
+}
+
 #[get("/interface/json", format = "text/html")]
 async fn inform_json() -> RawHtml<String> {
-    RawHtml(INTERFACE_HTML.replace("{}", "JSON Interface"))
+    RawHtml(
+        INTERFACE_HTML
+            .replace("__TITLE__", "JSON Interface")
+            .replace(
+                "__HEADERS__",
+                "headers: { 'Content-Type': 'application/json' },",
+            ),
+    )
 }
 
 #[post("/interface/json", data = "<query>", format = "json", rank = 1)]
@@ -95,6 +121,19 @@ async fn evaluate_json(query: Json<Value>) -> Json<Value> {
     Json(result)
 }
 
+#[get("/interface/json-to-lisp", format = "text/html")]
+async fn inform_json_to_lisp() -> RawHtml<String> {
+    RawHtml(INTERFACE_HTML.replace("__TITLE__", "JSON to LISP").replace(
+        "__HEADERS__",
+        "headers: { 'Content-Type': 'application/json' },",
+    ))
+}
+
+#[post("/interface/json-to-lisp", data = "<query>", format = "json", rank = 1)]
+async fn json_to_lisp(query: Json<Value>) -> RawText<String> {
+    RawText(JOURNAL.json_to_lisp(query.into_inner()))
+}
+
 #[rocket::main]
 async fn main() {
     let config = Config::new();
@@ -156,8 +195,12 @@ async fn main() {
                 index,
                 inform_lisp,
                 evaluate_lisp,
+                inform_lisp_to_json,
+                lisp_to_json,
                 inform_json,
-                evaluate_json
+                evaluate_json,
+                inform_json_to_lisp,
+                json_to_lisp
             ],
         )
         .configure(rocket_config)
diff --git a/tests/json.rs b/tests/json.rs

Original file line number	Diff line number	Diff line change
`@@ -89,7 +89,7 @@ pub fn obj2str(sc: mut s7_scheme, obj: mut s7_cell) -> String {`
`89`	`89`	`}`
`90`	`90`	`}`
`91`	`91`
`92`		`-pub fn scheme2json(expression: &str) -> Result<Value, String> {`
	`92`	`+pub fn lisp2json(expression: &str) -> Result<Value, String> {`
`93`	`93`	`// <TYPE>: <JSON>`
`94`	`94`	`// ------------------------------------------------------`
`95`	`95`	`// symbol: "string"`
`@@ -122,7 +122,7 @@ pub fn scheme2json(expression: &str) -> Result<Value, String> {`
`122`	`122`	`}`
`123`	`123`	`}`
`124`	`124`
`125`		`-pub fn json2scheme(expression: Value) -> Result<String, String> {`
	`125`	`+pub fn json2lisp(expression: &Value) -> Result<String, String> {`
`126`	`126`	`unsafe {`
`127`	`127`	`let sc: *mut s7_scheme = s7_init();`
`128`	`128`	`match json_to_s7_obj(sc, &expression) {`