documentation

ModProg · Sep 16, 2023 · 06c36e1 · 06c36e1
1 parent a4eb1b6
commit 06c36e1
Show file tree

Hide file tree

Showing 10 changed files with 335 additions and 153 deletions.
diff --git a/Cargo.lock b/Cargo.lock
diff --git a/Cargo.toml b/Cargo.toml
@@ -14,7 +14,7 @@ repository = "https://github.com/ModProg/htmx"
 documentation = "https://docs.rs/htmx"
 
 [features]
-# default = ["axum"]
+default = ["axum", "actix-web"]
 sorted_attributes = []
 axum = ["dep:axum-core"]
 
@@ -36,13 +36,15 @@ actix-web = { version = "4.4.0", default-features = false, optional = true }
 axum-core = { version = "0.3.4", optional = true }
 serde = "1.0.188"
 serde_json = "1.0.107"
+typed-builder = "0.16.0"
 
 [dev-dependencies]
 insta = "1.31.0"
 # Enables `sorted_attributes` for tests, to make assertions stable.
 htmx = { path = ".", default-features = false, features = [
     "sorted_attributes",
 ] }
+serde = { version = "1.0.188", features = ["derive"] }
 
 [profile.dev.package.insta]
 opt-level = 3

diff --git a/example/actix.rs b/example/actix.rs
@@ -13,7 +13,7 @@ async fn index() -> impl Responder {
     let rust_str = ["hello", "world", "!"];
     htmx! {
         <head>
-            <HtmxSrc/>
+            <script src="/htmx"/>
             <script>
                 fn hello_function() {
                     console.log($rust_str);
@@ -40,10 +40,15 @@ async fn greet(Form(form): Form<HashMap<String, String>>) -> impl Responder {
     }
 }
 
+#[get("/htmx")]
+async fn htmx_src() -> impl Responder {
+    HtmxSrc
+}
+
 #[actix_web::main]
 async fn main() -> std::io::Result<()> {
     println!("http://localhost:8080");
-    HttpServer::new(|| App::new().service(index).service(greet))
+    HttpServer::new(|| App::new().service(index).service(greet).service(htmx_src))
         .bind(("127.0.0.1", 8080))?
         .run()
         .await

diff --git a/htmx-macros/src/lib.rs b/htmx-macros/src/lib.rs
@@ -53,9 +53,7 @@ pub fn htmx(input: TokenStream) -> Result {
             use #htmx::native::*;
             let mut $htmx = Html::new();
             #(
-                for $elem in IntoHtmlElements::into_elements(#nodes) {
-                    ToHtml::write_to_html(&$elem, &mut $htmx);
-                }
+                ToHtml::write_to_html(&#nodes, &mut $htmx);
             )*
             $htmx
         }}
@@ -97,7 +95,9 @@ fn expand_node(node: Node) -> Result {
                     },
                 })
                 .collect::<Result<Vec<_>>>()?;
-            let children = if script {
+            let children = if children.is_empty() {
+                quote!()
+            } else if script {
                 let Some(Node::RawText(script)) = children.first() else {
                     unreachable!("script always raw text")
                 };
@@ -116,7 +116,7 @@ fn expand_node(node: Node) -> Result {
                     .into_iter()
                     .map(expand_node)
                     .collect::<Result<Vec<_>>>()?;
-                quote!(#(.child(#children))*)
+                quote!(#(.child(&#children))*)
             };
             let main = quote!(#name::builder() #(.#attributes)* #children .build());
             match close_tag.map(|tag| name_to_struct(tag.name)) {
@@ -171,3 +171,51 @@ fn attribute_key_to_fn(name: NodeName, value: impl ToTokens) -> Result {
         }
     }
 }
+
+// todo derive macro
+// #[component]
+// fn MyFnComponent(a: bool, b: String) -> Html {
+//     htmx! {crate
+//         <button disabled=a> {b} </button>
+//     }
+// }
+//
+// // Generates
+//
+// #[derive(typed_builder::TypedBuilder)]
+// #[builder(crate_module_path=::typed_builder)]
+// #[builder(build_method(into = Html))]
+// struct MyFnComponent {
+//     a: bool,
+//     b: String,
+// }
+//
+// impl Into<Html> for MyFnComponent {
+//     fn into(self) -> Html {
+//         let Self { a, b } = self;
+//         htmx! {crate
+//             <button disabled=a> {b} </button>
+//         }
+//     }
+// }
+//
+// // Using only struct
+// #[derive(Component)]
+// struct MyStructComponent {
+//     a: bool,
+//     b: String,
+// }
+// impl Into<Html> for MyStructComponent {
+//     fn into(self) -> Html {
+//         let Self { a, b } = self;
+//         htmx! {crate
+//             <button disabled=a> {b} </button>
+//         }
+//     }
+// }
+//
+// // Generate
+// #[derive(typed_builder::TypedBuilder)]
+// #[builder(crate_module_path=::typed_builder)]
+// #[builder(build_method(into = Html))]
+//
diff --git a/src/actix.rs b/src/actix.rs
@@ -0,0 +1,56 @@
+use std::mem;
+use std::task::Poll;
+
+use actix_web::body::{BoxBody, MessageBody};
+use actix_web::http::header::ContentType;
+use actix_web::web::Bytes;
+use actix_web::{HttpResponse, Responder};
+
+use crate::{Html, HtmxSrc};
+
+impl Responder for Html {
+    type Body = BoxBody;
+
+    fn respond_to(self, _req: &actix_web::HttpRequest) -> HttpResponse<Self::Body> {
+        HttpResponse::Ok()
+            .content_type(ContentType::html())
+            .body(self)
+    }
+}
+
+impl MessageBody for Html {
+    type Error = <String as MessageBody>::Error;
+
+    fn size(&self) -> actix_web::body::BodySize {
+        self.0.size()
+    }
+
+    fn poll_next(
+        mut self: std::pin::Pin<&mut Self>,
+        _cx: &mut std::task::Context<'_>,
+    ) -> std::task::Poll<Option<Result<actix_web::web::Bytes, Self::Error>>> {
+        if self.0.is_empty() {
+            Poll::Ready(None)
+        } else {
+            let string = mem::take(&mut self.0);
+            Poll::Ready(Some(Ok(Bytes::from(string))))
+        }
+    }
+
+    fn try_into_bytes(self) -> Result<Bytes, Self>
+    where
+        Self: Sized,
+    {
+        Ok(Bytes::from(self.0))
+    }
+}
+
+impl Responder for HtmxSrc {
+    type Body = BoxBody;
+
+    fn respond_to(self, _req: &actix_web::HttpRequest) -> HttpResponse<Self::Body> {
+        HttpResponse::Ok()
+            .content_type("text/javascript; charset=utf-8")
+            .body(Self::HTMX_SRC)
+    }
+}
diff --git a/src/attributes.rs b/src/attributes.rs
@@ -1,17 +1,27 @@
+//! Details on conversion for Attribute values.
 use std::borrow::Cow;
 
 use forr::forr;
 
+/// An attribute that accepts a numeric value.
 pub struct Number;
 
+/// An attribute that can be just set or set to a value.
 pub enum ValueOrFlag {
+    /// Attribute is set to a value.
     Value(String),
+    /// Attribute is set without a value.
     Flag,
+    /// Attribute is not set.
     Unset,
 }
 
+/// Converts to an Attribute that accepts type [`Self::Target`], e.g.,
+/// [`Number`].
 pub trait IntoAttribute {
+    /// Target value of the attribute.
     type Target;
+    /// Converts into an attribute value.
     fn into_attribute(self) -> ValueOrFlag;
 }
 
@@ -69,7 +79,9 @@ forr! { $type:ty in [&str, String, Cow<'_, str>] $*
     }
 }
 
+/// Trait accepted by an attribute that allows both values and flags.
 pub trait FlagOrAttributeValue {
+    /// Converts into value.
     fn into_attribute(self) -> ValueOrFlag;
 }
 
@@ -85,7 +97,9 @@ impl<A: IntoAttribute<Target = String>> FlagOrAttributeValue for A {
     }
 }
 
+/// Trait accepted by an attribute that accepts any value
 pub trait AnyAttributeValue {
+    /// Converts into value.
     fn into_attribute(self) -> ValueOrFlag;
 }
 

diff --git a/src/axum.rs b/src/axum.rs
@@ -0,0 +1,23 @@
+use axum_core::response::IntoResponse;
+
+use crate::{Html, HtmxSrc};
+
+impl IntoResponse for Html {
+    fn into_response(self) -> axum_core::response::Response {
+        (
+            [("Content-Type", "text/html; charset=utf-8")],
+            self.to_string(),
+        )
+            .into_response()
+    }
+}
+
+impl IntoResponse for HtmxSrc {
+    fn into_response(self) -> axum_core::response::Response {
+        (
+            [("Content-Type", "text/javascript; charset=utf-8")],
+            Self::HTMX_SRC,
+        )
+            .into_response()
+    }
+}
diff --git a/src/htmx_utils.rs b/src/htmx_utils.rs
@@ -2,17 +2,29 @@ use htmx_macros::htmx;
 
 use crate::Html;
 
+/// Embed [HTMX script](https://htmx.org/).
+///
+/// Can either be embeded into [`Html`] as component or be returned from
+/// endpoints.
+///
+/// [v1.9.5](https://github.com/bigskysoftware/htmx/releases/tag/v1.9.5)
 #[must_use]
 pub struct HtmxSrc;
 
 impl HtmxSrc {
+    /// HTMX source.
+    pub const HTMX_SRC: &str = include_str!("htmx.min.js");
+
+    // Only exist because I'm lazy
+    #[doc(hidden)]
     pub fn builder() -> Self {
         Self
     }
 
+    #[doc(hidden)]
     pub fn build(self) -> Html {
         htmx! {crate
-            <script>{include_str!("htmx.min.js")}</script>
+            <script>{Self::HTMX_SRC}</script>
         }
     }
 }