grace/htmlua
1
0
Fork 0
Code Issues Pull requests Projects Releases 2 Packages Wiki Activity Actions

added full request and tests

Browse source
This commit is contained in:
gyoder 2025-07-12 21:51:05 -06:00
parent 4144fa2cba
commit 085aa5a1f5
7 changed files with 392 additions and 38 deletions
Download patch file Download diff file Expand all files Collapse all files

1
htmlua-parser/Cargo.toml
View file

@ -6,6 +6,7 @@ edition = "2024"
[dependencies]
anyhow = "1.0.98"
html5ever = "0.35.0"
httptest = "0.16.3"
kuchikiki = "0.8.2"
markup5ever = "0.11.0"
mlua = { version = "0.10.5", features = ["lua54", "vendored", "serialize", "anyhow"] }

7
htmlua-parser/src/helpers.rs
View file

@ -1,4 +1,8 @@
use std::{fs::File, io::{BufRead, BufReader, Read, Seek, SeekFrom}, path::PathBuf};
use std::{
fs::File,
io::{BufRead, BufReader, Read, Seek, SeekFrom},
path::PathBuf,
};
use anyhow::Result;
use kuchikiki::NodeRef;
@ -9,7 +13,6 @@ use tendril::TendrilSink;
pub fn read_doc_from_file(path: PathBuf) -> Result<NodeRef> {
let mut file = File::open(path)?;
let mut reader = BufReader::new(&mut file);

119
htmlua-parser/src/htmlua_stdlib.rs
View file

@ -1,10 +1,19 @@
use std::{cell::{LazyCell, RefCell}, collections::HashMap, fmt::Write, rc::Rc};
use std::{
cell::{LazyCell, RefCell},
collections::HashMap,
fmt::Write,
rc::Rc,
str::FromStr,
time::Duration,
};
use anyhow::anyhow;
use mlua::{prelude::*, Error, Lua, Table};
use reqwest::{blocking::{Client, Response}, header::HeaderMap};
use mlua::{Error, Lua, Table, prelude::*};
use reqwest::{
Method, Url,
blocking::{Client, Response},
header::HeaderMap,
};
use serde::{Deserialize, Serialize};
use serde_json::to_value;
pub fn create_htmlua_stdlib(l: &Lua, stdout: &Rc<RefCell<String>>) -> mlua::Result<Table> {
@ -34,13 +43,16 @@ pub fn create_htmlua_stdlib(l: &Lua, stdout: &Rc<RefCell<String>>) -> mlua::Resu
Ok(t)
}
#[allow(clippy::too_many_lines)]
fn create_http_lib(l: &Lua) -> mlua::Result<Table> {
let t = l.create_table()?;
let http_client: Rc<LazyCell<Client>> = Rc::new(LazyCell::new(|| Client::builder()
let http_client: Rc<LazyCell<Client>> = Rc::new(LazyCell::new(|| {
Client::builder()
.timeout(std::time::Duration::from_secs(3))
.user_agent("htmlua/0.1.0")
.build().unwrap()
));
.build()
.unwrap()
}));
let client = http_client.clone();
@ -50,56 +62,116 @@ fn create_http_lib(l: &Lua) -> mlua::Result<Table> {
let res = client.get(url).send().map_err(|e| Error::RuntimeError(e.to_string()))?;
let lua_res: LuaHttpResponse = TryFrom::try_from(res)?;
Ok(lua_res)
})?
})?,
)?;
let client = http_client.clone();
t.set(
"post",
l.create_function(move |_, url: String| {
let res = client.post(url).send().map_err(|e| Error::RuntimeError(e.to_string()))?;
let res = client
.post(url)
.send()
.map_err(|e| Error::RuntimeError(e.to_string()))?;
let lua_res: LuaHttpResponse = TryFrom::try_from(res)?;
Ok(lua_res)
})?
})?,
)?;
let client = http_client.clone();
t.set(
"get_with_data",
l.create_function(move |_, (url, data): (String, HashMap<String, String>)| {
let res = client.get(url).query(&data).send().map_err(|e| Error::RuntimeError(e.to_string()))?;
let res = client
.get(url)
.query(&data)
.send()
.map_err(|e| Error::RuntimeError(e.to_string()))?;
let lua_res: LuaHttpResponse = TryFrom::try_from(res)?;
Ok(lua_res)
})?
})?,
)?;
let client = http_client.clone();
t.set(
"post_with_data_form",
l.create_function(move |_, (url, data): (String, HashMap<String, String>)| {
let res = client.post(url).form(&data).send().map_err(|e| Error::RuntimeError(e.to_string()))?;
let res = client
.post(url)
.form(&data)
.send()
.map_err(|e| Error::RuntimeError(e.to_string()))?;
let lua_res: LuaHttpResponse = TryFrom::try_from(res)?;
Ok(lua_res)
})?
})?,
)?;
let client = http_client.clone();
t.set(
"post_with_data_json",
l.create_function(move |_, (url, data): (String, HashMap<String, String>)| {
let res = client.post(url).json(&data).send().map_err(|e| Error::RuntimeError(e.to_string()))?;
let res = client
.post(url)
.json(&data)
.send()
.map_err(|e| Error::RuntimeError(e.to_string()))?;
let lua_res: LuaHttpResponse = TryFrom::try_from(res)?;
Ok(lua_res)
})?
})?,
)?;
let client = http_client.clone();
t.set(
"request",
l.create_function(move |_, table: mlua::Table| {
let mut request = client.request(
Method::from_bytes(table.get::<String>("method")?.as_bytes())
.map_err(|e| Error::RuntimeError(e.to_string()))?,
Url::from_str(table.get::<String>("url")?.as_str()).map_err(|e| Error::RuntimeError(e.to_string()))?,
);
if let Ok(header_tbl) = table.get::<mlua::Table>("headers") {
request = header_tbl
.pairs::<String, String>()
.filter_map(std::result::Result::ok)
.fold(request, |req, (k, v)| req.header(k, v));
}
if let Ok(basic_auth) = table.get::<mlua::Table>("basic_auth") {
request = request
.basic_auth(basic_auth.get::<String>("username")?, basic_auth.get::<String>("password").ok());
}
if let Ok(bearer_auth) = table.get::<mlua::Table>("bearer_auth") {
request = request.bearer_auth(bearer_auth.get::<String>("token")?);
}
if let Ok(body) = table.get::<String>("body") {
request = request.body(body);
}
if let Ok(json) = table.get::<String>("json") {
request = request.json(&json);
}
if let Ok(timeout) = table.get::<u64>("timeout") {
request = request.timeout(Duration::from_secs(timeout));
}
let res = request.send().map_err(|e| Error::RuntimeError(e.to_string()))?;
let lua_res: LuaHttpResponse = TryFrom::try_from(res)?;
Ok(lua_res)
})?,
)?;
//TODO: all http
t.set(
"decode_json",
l.create_function(move |l, text: String| {
let table: serde_json::Value = serde_json::from_str(&text).map_err(|e| Error::RuntimeError(e.to_string()))?;
let table: serde_json::Value =
serde_json::from_str(&text).map_err(|e| Error::RuntimeError(e.to_string()))?;
Ok(l.to_value(&table))
})?
})?,
)?;
Ok(t)
@ -115,7 +187,11 @@ struct LuaHttpResponse {
impl TryFrom<Response> for LuaHttpResponse {
fn try_from(value: Response) -> Result<Self, Self::Error> {
Ok(LuaHttpResponse { headers: headermap_to_hashmap(value.headers()), status: value.status().as_u16(), body: value.text().map_err(|e| Error::RuntimeError(e.to_string()))?, })
Ok(LuaHttpResponse {
headers: headermap_to_hashmap(value.headers()),
status: value.status().as_u16(),
body: value.text().map_err(|e| Error::RuntimeError(e.to_string()))?,
})
}
type Error = Error;
@ -133,6 +209,7 @@ fn headermap_to_hashmap(headers: &HeaderMap) -> HashMap<String, String> {
map
}
impl IntoLua for LuaHttpResponse {
fn into_lua(self, lua: &Lua) -> LuaResult<LuaValue> {
let table = lua.create_table()?;

4
htmlua-parser/src/lib.rs
View file

@ -1,4 +1,4 @@
pub mod render;
pub mod serve;
pub mod helpers;
pub mod htmlua_stdlib;
pub mod render;
pub mod serve;

177
htmlua-parser/src/render.rs
View file

@ -1,8 +1,13 @@
use std::{cell::RefCell, fmt::Write, fs::read_to_string, path::PathBuf, rc::Rc};
use std::{
cell::{LazyCell, RefCell},
fmt::Write,
path::PathBuf,
rc::Rc,
};
use anyhow::{Result, anyhow};
use kuchikiki::{NodeRef, traits::TendrilSink};
use mlua::{Lua, Table};
use mlua::Lua;
use pulldown_cmark::{Options, Parser, html};
use syntect::{
easy::HighlightLines,
@ -15,20 +20,22 @@ use syntect::{
use crate::{helpers::read_doc_from_file, htmlua_stdlib::create_htmlua_stdlib};
pub fn execute_lua(document: NodeRef) -> Result<NodeRef> {
fn build_lua_with_stdout(stdout: &Rc<RefCell<String>>) -> Result<Lua> {
let lua = Lua::new();
let globals = lua.globals();
let stdout: Rc<RefCell<String>> = Rc::new(RefCell::new(String::new()));
let htmlua_table =
create_htmlua_stdlib(&lua, &stdout).map_err(|e| anyhow!("Failed to create Lua stdlib: {}", e))?;
let htmlua_table = create_htmlua_stdlib(&lua, stdout).map_err(|e| anyhow!("Failed to create Lua stdlib: {}", e))?;
globals
.set("htmlua", htmlua_table)
.map_err(|e| anyhow!("Failed to set global: {}", e))?;
Ok(lua)
}
pub fn execute_lua(document: NodeRef) -> Result<NodeRef> {
let stdout: Rc<RefCell<String>> = Rc::new(RefCell::new(String::new()));
let lua = LazyCell::new(|| build_lua_with_stdout(&stdout).unwrap_or_default());
let lua_elements: Vec<_> = match document.select("lua") {
Ok(e) => e.collect(),
Err(()) => return Err(anyhow!("Unable to find Lua")),
@ -85,7 +92,11 @@ pub fn expand_template(document: NodeRef, component_path: &PathBuf, include_from
let exported = from_node
.select_first(format!("exportelement.{name}").as_str())
.map_err(|()| anyhow!("Error finding exportelement"))?;
exported.as_node().children().rev().for_each(|c| i.as_node().insert_after(c));
exported
.as_node()
.children()
.rev()
.for_each(|c| i.as_node().insert_after(c));
}
}
while let Ok(i) = document.select_first("includeelement") {
@ -107,8 +118,13 @@ pub fn expand_template(document: NodeRef, component_path: &PathBuf, include_from
item_path.push(include_path);
let new_node = read_doc_from_file(item_path)?;
let replaced_node = expand_template(new_node, component_path, Some(i.as_node()))?;
replaced_node.select_first("html").map_err(|()| anyhow!("Error finding html"))?.as_node().children().rev().for_each(|c| i.as_node().insert_after(c));
replaced_node
.select_first("html")
.map_err(|()| anyhow!("Error finding html"))?
.as_node()
.children()
.rev()
.for_each(|c| i.as_node().insert_after(c));
}
}
while let Ok(i) = document.select_first("include") {
@ -167,6 +183,8 @@ pub fn process_syntax_highlighting(document: NodeRef) -> Result<NodeRef> {
#[cfg(test)]
mod tests {
use httptest::{Expectation, ServerPool, matchers::*, responders::*};
use super::*;
#[test]
@ -413,4 +431,141 @@ fn main() {
assert_eq!(attrs.get("data-lang"), Some("rust"));
assert!(attrs.get("class").unwrap().contains("syntax-highlight"));
}
static SERVER_POOL: ServerPool = ServerPool::new(2);
#[test]
fn basic_get() {
let server = SERVER_POOL.get_server();
server.expect(
Expectation::matching(request::method_path("GET", "/test/1")).respond_with(status_code(200).body("ret")),
);
let stdout = Rc::new(RefCell::new(String::new()));
let lua = build_lua_with_stdout(&stdout).unwrap();
let code = format!("htmlua.print(htmlua.http.get(\"{}\").body)", server.url("/test/1"));
lua.load(code).exec().unwrap();
assert_eq!(stdout.borrow().as_str(), "ret");
}
#[test]
fn basic_post() {
let server = SERVER_POOL.get_server();
server.expect(
Expectation::matching(request::method_path("POST", "/test/1")).respond_with(status_code(200).body("ret")),
);
let stdout = Rc::new(RefCell::new(String::new()));
let lua = build_lua_with_stdout(&stdout).unwrap();
let code = format!("htmlua.print(htmlua.http.post(\"{}\").body)", server.url("/test/1"));
lua.load(code).exec().unwrap();
assert_eq!(stdout.borrow().as_str(), "ret");
}
#[test]
fn get_with_data() {
let server = SERVER_POOL.get_server();
server.expect(
Expectation::matching(request::query(url_decoded(contains(("a", "b")))))
.respond_with(status_code(200).body("ret")),
);
let stdout = Rc::new(RefCell::new(String::new()));
let lua = build_lua_with_stdout(&stdout).unwrap();
let code = format!(
"
data = {{}}
data.a = \"b\"
htmlua.print(htmlua.http.get_with_data(\"{}\", data).body)
",
server.url("/test/1")
);
lua.load(code).exec().unwrap();
assert_eq!(stdout.borrow().as_str(), "ret");
}
#[test]
fn post_with_data_form() {
let server = SERVER_POOL.get_server();
server.expect(
Expectation::matching(all_of![request::method_path("POST", "/test/1"), request::body("a=b")])
.respond_with(status_code(200).body("ret")),
);
let stdout = Rc::new(RefCell::new(String::new()));
let lua = build_lua_with_stdout(&stdout).unwrap();
let code = format!(
"
data = {{}}
data.a = \"b\"
htmlua.print(htmlua.http.post_with_data_form(\"{}\", data).body)
",
server.url("/test/1")
);
lua.load(code).exec().unwrap();
assert_eq!(stdout.borrow().as_str(), "ret");
}
#[test]
fn post_with_data_json() {
let server = SERVER_POOL.get_server();
server.expect(
Expectation::matching(all_of![request::method_path("POST", "/test/1"), request::body(r#"{"a":"b"}"#)])
.respond_with(status_code(200).body("ret")),
);
let stdout = Rc::new(RefCell::new(String::new()));
let lua = build_lua_with_stdout(&stdout).unwrap();
let code = format!(
"
data = {{}}
data.a = \"b\"
htmlua.print(htmlua.http.post_with_data_json(\"{}\", data).body)
",
server.url("/test/1")
);
lua.load(code).exec().unwrap();
assert_eq!(stdout.borrow().as_str(), "ret");
}
#[test]
fn table_request() {
let server = SERVER_POOL.get_server();
server.expect(
Expectation::matching(all_of![
request::method_path("GET", "/test/1"),
request::body("cool"),
request::headers(contains(("testhdr", "val"))),
request::headers(contains(("authorization", "Basic dXNlcjpwYXNz"))),
])
.respond_with(status_code(200).body("ret")),
);
let stdout = Rc::new(RefCell::new(String::new()));
let lua = build_lua_with_stdout(&stdout).unwrap();
let code = format!(
"
req = {{}}
req.url = \"{}\"
req.method = \"GET\"
req.headers = {{}}
req.headers.testhdr = \"val\"
req.basic_auth = {{}}
req.basic_auth.username = \"user\"
req.basic_auth.password = \"pass\"
req.body = \"cool\"
htmlua.print(htmlua.http.request(req).body)
",
server.url("/test/1")
);
lua.load(code).exec().unwrap();
assert_eq!(stdout.borrow().as_str(), "ret");
}
}

3
htmlua-parser/src/serve.rs
View file

@ -2,8 +2,7 @@ use crate::helpers::read_doc_from_file;
use super::render::{execute_lua, expand_template, process_markdown, process_syntax_highlighting};
use anyhow::Result;
use std::path::{Path, PathBuf}
;
use std::path::{Path, PathBuf};
pub fn serve_content(request_uri: &str) -> Result<String> {
// TODO: read from config