non version locked lua fucked shit over jfc

src/index/filters.rs

@@ -49,11 +49,11 @@ pub fn iconize(value: &Value, _args: &HashMap<String, Value>) -> TeraResult<Valu
     let icon = if icons.contains_key(icon) {
         &icons[icon]
     } else {
-        println!("Unknown filetype: {}", icon);
+        println!("Unknown filetype: {icon}");
         &icons["unknown"]
     };
 
-    let str = format!("<img src=\"data:image/png;base64,{}\" alt=\"\" />", icon);
+    let str = format!("<img src=\"data:image/png;base64,{icon}\" alt=\"\" />");
 
     Ok(to_value(str).unwrap())
 }
@@ -73,7 +73,7 @@ pub fn from_ico(value: &Value, _args: &HashMap<String, Value>) -> TeraResult<Val
 
     let data = BASE64_STANDARD.encode(icon);
 
-    let str = format!("<img src=\"data:image/png;base64,{}\" alt=\"\"/>", data);
+    let str = format!("<img src=\"data:image/png;base64,{data}\" alt=\"\"/>");
 
     Ok(to_value(str).unwrap())
 }

src/main.rs

@@ -79,10 +79,11 @@ async fn main() -> AResult<()> {
 }
 
 async fn file_handler(request: Request) -> impl IntoResponse {
+    println!("{}", request.uri());
     std::env::set_current_dir(&*CWD).unwrap();
 
     let base_dir = BASE_DIR.canonicalize().map_err(|e| {
-        eprintln!("{:#?}", e);
+        eprintln!("{e:#?}");
         (StatusCode::NOT_FOUND, "404: Not Found".to_string())
     })?;
 
@@ -102,18 +103,18 @@ async fn file_handler(request: Request) -> impl IntoResponse {
         let mut path = base_dir.clone();
 
         let uri = urlencoding::decode(&request_uri_path[1..]).map_err(|e| {
-            println!("{:?}", e);
+            println!("{e:?}");
             (StatusCode::INTERNAL_SERVER_ERROR, e.to_string())
         })?;
 
         path.push(&*uri);
         let full_path = fs::canonicalize(&path).map_err(|e| {
-            println!("{:?}", e);
+            println!("{e:?}");
             (StatusCode::NOT_FOUND, "404: Not Found".to_string())
         })?;
 
         let full_base_path = fs::canonicalize(&base_dir).map_err(|e| {
-            println!("{:?}", e);
+            println!("{e:?}");
             (StatusCode::NOT_FOUND, "404: Not Found".to_string())
         })?;
 
@@ -122,7 +123,7 @@ async fn file_handler(request: Request) -> impl IntoResponse {
         }
 
         let script = fs::read_to_string(&full_path).map_err(|e| {
-            eprintln!("Lua Read Error: {:?}", e);
+            eprintln!("Lua Read Error: {e:?}");
             (StatusCode::INTERNAL_SERVER_ERROR, e.to_string())
         })?;
 
@@ -151,14 +152,14 @@ async fn file_handler(request: Request) -> impl IntoResponse {
     ))
     .exec()
     .map_err(|e| {
-        eprintln!("Lua Error: {:#?}", e);
+        eprintln!("Lua Error: {e:#?}");
         render_lua_error(e)
     })?;
 
     let globals = lua.globals();
 
     let request_table = lua.create_table().map_err(|e| {
-        eprintln!("Lua Error: {:?}", e);
+        eprintln!("Lua Error: {e:?}");
         render_lua_error(e)
     })?;
 
@@ -170,7 +171,7 @@ async fn file_handler(request: Request) -> impl IntoResponse {
                 .map(|(k, v)| (k.to_string(), v.to_str().unwrap())),
         )
         .map_err(|e| {
-            eprintln!("Lua Error: {:?}", e);
+            eprintln!("Lua Error: {e:?}");
             render_lua_error(e)
         })?;
 
@@ -178,7 +179,7 @@ async fn file_handler(request: Request) -> impl IntoResponse {
 
     let query: HashMap<String, String> = serde_qs::from_str(query)
         .map_err(|e| {
-            println!("{:#?}", e);
+            println!("{e:#?}");
             (
                 StatusCode::INTERNAL_SERVER_ERROR,
                 "500: Unable to parse query string".to_string(),
@@ -187,42 +188,42 @@ async fn file_handler(request: Request) -> impl IntoResponse {
         .unwrap_or(HashMap::new());
 
     let query_table = lua.create_table_from(query).map_err(|e| {
-        eprintln!("Lua Error: {:?}", e);
+        eprintln!("Lua Error: {e:?}");
         render_lua_error(e)
     })?;
 
     request_table.set("headers", headers_table).map_err(|e| {
-        eprintln!("Lua Error: {:?}", e);
+        eprintln!("Lua Error: {e:?}");
         render_lua_error(e)
     })?;
 
     request_table
         .set("uri", request.uri().to_string())
         .map_err(|e| {
-            eprintln!("Lua Error: {:?}", e);
+            eprintln!("Lua Error: {e:?}");
             render_lua_error(e)
         })?;
 
     request_table
         .set("method", request.method().to_string())
         .map_err(|e| {
-            eprintln!("Lua Error: {:?}", e);
+            eprintln!("Lua Error: {e:?}");
             render_lua_error(e)
         })?;
 
     request_table.set("query", query_table).map_err(|e| {
-        eprintln!("Lua Error: {:?}", e);
+        eprintln!("Lua Error: {e:?}");
         render_lua_error(e)
     })?;
 
     // Inject functions to change headers and such
     globals.set("request", request_table).map_err(|e| {
-        eprintln!("Lua Error: {:?}", e);
+        eprintln!("Lua Error: {e:?}");
         render_lua_error(e)
     })?;
 
     let response_table = lua.create_table().map_err(|e| {
-        eprintln!("Lua Error: {:?}", e);
+        eprintln!("Lua Error: {e:?}");
         render_lua_error(e)
     })?;
 
@@ -230,35 +231,35 @@ async fn file_handler(request: Request) -> impl IntoResponse {
         .set(
             "headers",
             lua.create_table().map_err(|e| {
-                eprintln!("Lua Error: {:?}", e);
+                eprintln!("Lua Error: {e:?}");
                 render_lua_error(e)
             })?,
         )
         .map_err(|e| {
-            eprintln!("Lua Error: {:?}", e);
+            eprintln!("Lua Error: {e:?}");
             render_lua_error(e)
         })?;
 
     globals.set("response", response_table).map_err(|e| {
-        eprintln!("Lua Error: {:?}", e);
+        eprintln!("Lua Error: {e:?}");
         render_lua_error(e)
     })?;
 
     let mut path = base_dir.clone();
 
     let uri = urlencoding::decode(&request_uri_path[1..]).map_err(|e| {
-        println!("{:?}", e);
+        println!("{e:?}");
         (StatusCode::INTERNAL_SERVER_ERROR, e.to_string())
     })?;
 
     path.push(&*uri);
     let full_path = fs::canonicalize(&path).map_err(|e| {
-        println!("{:?}", e);
+        println!("{e:?}");
         (StatusCode::NOT_FOUND, "404: Not Found".to_string())
     })?;
 
     let full_base_path = fs::canonicalize(base_dir).map_err(|e| {
-        println!("{:?}", e);
+        println!("{e:?}");
         (StatusCode::NOT_FOUND, "404: Not Found".to_string())
     })?;
 
@@ -267,7 +268,7 @@ async fn file_handler(request: Request) -> impl IntoResponse {
     }
 
     let script = fs::read_to_string(full_path).map_err(|e| {
-        eprintln!("Lua Read Error: {:?}", e);
+        eprintln!("Lua Read Error: {e:?}");
         (StatusCode::INTERNAL_SERVER_ERROR, e.to_string())
     })?;
 
@@ -291,19 +292,19 @@ async fn file_handler(request: Request) -> impl IntoResponse {
     .exec()
     .map_err(|e| {
         std::env::set_current_dir(&*CWD).unwrap();
-        eprintln!("Lua Error: {:?}", e);
+        eprintln!("Lua Error: {e:?}");
         render_lua_error(e)
     })?;
 
     let script = lua.load(script).eval::<LuaValue>().map_err(|e| {
         std::env::set_current_dir(&*CWD).unwrap();
-        eprintln!("Lua Error: {:?}", e);
+        eprintln!("Lua Error: {e:?}");
         render_lua_error(e)
     })?;
     std::env::set_current_dir(&*CWD).unwrap();
 
     let result = lua.load("return response").eval::<Table>().map_err(|e| {
-        eprintln!("Lua Error: {:?}", e);
+        eprintln!("Lua Error: {e:?}");
         render_lua_error(e)
     })?;
 
@@ -313,10 +314,10 @@ async fn file_handler(request: Request) -> impl IntoResponse {
         script.to_string_lossy().to_string()
     } else {
         serde_json::to_string(&script).map_err(|e| {
-            eprintln!("Serde Error: {:?}", e);
+            eprintln!("Serde Error: {e:?}");
             (
                 StatusCode::INTERNAL_SERVER_ERROR,
-                format!("Serde error: {}", e),
+                format!("Serde error: {e}"),
             )
         })?
     };
@@ -334,16 +335,16 @@ async fn file_handler(request: Request) -> impl IntoResponse {
 
         for pair in pairs {
             let (k, v) = pair.map_err(|e| {
-                eprintln!("Lua Error: {:?}", e);
+                eprintln!("Lua Error: {e:?}");
                 render_lua_error(e)
             })?;
             response.headers_mut().insert(
                 HeaderName::from_str(&k).map_err(|e| {
-                    eprintln!("Response Error: {:?}", e);
+                    eprintln!("Response Error: {e:?}");
                     (StatusCode::INTERNAL_SERVER_ERROR, e.to_string())
                 })?,
                 HeaderValue::from_str(&v).map_err(|e| {
-                    eprintln!("Response Error: {:?}", e);
+                    eprintln!("Response Error: {e:?}");
                     (StatusCode::INTERNAL_SERVER_ERROR, e.to_string())
                 })?,
             );
@@ -424,17 +425,17 @@ fn render_lua_error(e: mlua::Error) -> (StatusCode, String) {
         mlua::Error::MismatchedRegistryKey => (StatusCode::INTERNAL_SERVER_ERROR, String::new()),
         mlua::Error::CallbackError { traceback, cause } => (
             StatusCode::INTERNAL_SERVER_ERROR,
-            format!("{}\n\n{:#?}", traceback, cause),
+            format!("{traceback}\n\n{cause:#?}"),
         ),
         mlua::Error::PreviouslyResumedPanic => (StatusCode::INTERNAL_SERVER_ERROR, String::new()),
         mlua::Error::SerializeError(message) => (StatusCode::INTERNAL_SERVER_ERROR, message),
         mlua::Error::DeserializeError(message) => (StatusCode::INTERNAL_SERVER_ERROR, message),
         mlua::Error::ExternalError(error) => {
-            (StatusCode::INTERNAL_SERVER_ERROR, format!("{:#?}", error))
+            (StatusCode::INTERNAL_SERVER_ERROR, format!("{error:#?}"))
         }
         mlua::Error::WithContext { context, cause } => (
             StatusCode::INTERNAL_SERVER_ERROR,
-            format!("{}\n\n{:#?}", context, cause),
+            format!("{context}\n\n{cause:#?}"),
         ),
         _ => (
             StatusCode::INTERNAL_SERVER_ERROR,
@@ -448,18 +449,18 @@ async fn handler(request: Request) -> Result<Html<String>, (StatusCode, String)>
     let mut path = BASE_DIR.clone();
 
     let uri = urlencoding::decode(&request.uri().path()[1..]).map_err(|e| {
-        println!("{:?}", e);
+        println!("{e:?}");
         (StatusCode::INTERNAL_SERVER_ERROR, e.to_string())
     })?;
 
     path.push(&*uri);
     let full_path = path.canonicalize().map_err(|e| {
-        println!("{:?}", e);
+        println!("{e:?}");
         (StatusCode::NOT_FOUND, "404: Not Found".to_string())
     })?;
 
     let full_base_path = BASE_DIR.canonicalize().map_err(|e| {
-        println!("{:?}", e);
+        println!("{e:?}");
         (StatusCode::NOT_FOUND, "404: Not Found".to_string())
     })?;
 
@@ -475,11 +476,11 @@ async fn handler(request: Request) -> Result<Html<String>, (StatusCode, String)>
                 if ioerror.kind() == ErrorKind::NotFound {
                     Err((StatusCode::NOT_FOUND, "404: Not Found".to_string()))
                 } else {
-                    println!("{:?}", ioerror);
+                    println!("{ioerror:?}");
                     Err((StatusCode::INTERNAL_SERVER_ERROR, e.to_string()))
                 }
             } else {
-                println!("{:?}", e);
+                println!("{e:?}");
                 Err((StatusCode::INTERNAL_SERVER_ERROR, e.to_string()))
             }
         }