haskal
/
skhtml
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Merge pull request #29 from adrianheine/readme_links_name 

Update README, more renaming
This commit is contained in:
ashley williams 2023-03-29 11:46:13 -05:00 committed by GitHub
parent ee6743b559 2c417a0a5b
commit 7435274cf4
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
9 changed files with 45 additions and 70 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

14
README.md
View File

@ -34,7 +34,7 @@ let mut doc: DOMTree<String> = html!(
</p>
)) }
<p class="citation-needed">
"Every company should be a developer experience company"
"Every company should be a developer experience company."
</p>
</body>
</html>
@ -95,14 +95,14 @@ conversion will panic at runtime if the string is invalid.
### Example
```rust
let classList: SpacedSet<Class> = ["foo", "bar", "baz"].into();
let classList: SpacedSet<Class> = ["foo", "bar", "baz"].try_into()?;
html!(
<div>
<div class="foo bar baz" /> // parses a string literal
<div class=["foo", "bar", "baz"] /> // uses From<[&str, &str, &str]>
<div class=classList /> // uses a variable in scope
<div class={ // evaluates a code block
SpacedSet::from(["foo", "bar", "baz"])
SpacedSet::try_from(["foo", "bar", "baz"])?
} />
</div>
)
@ -151,7 +151,7 @@ assert_eq!("<p>Hello Axo</p>", doc_str);
### Render to a virtual DOM
The DOM tree structure also implements a method called `vnode()`, which renders
the tree to a tree of [`Node`][Node]s, which is a mirror of the generated tree
the tree to a tree of [`VNode`][VNode]s, which is a mirror of the generated tree
with every attribute value rendered into `String`s. You can walk this virtual
DOM tree and pass it on to your favourite virtual DOM system.
@ -168,10 +168,10 @@ Copyright 2018 Bodil Stokke, 2022 Axo Developer Co.
[Display]: https://doc.rust-lang.org/std/fmt/trait.Display.html
[String]: https://doc.rust-lang.org/std/string/struct.String.html
[to_string]: https://doc.rust-lang.org/std/string/trait.ToString.html#tymethod.to_string
[Node]: dom/trait.Node.html
[VNode]: https://docs.rs/axohtml/latest/axohtml/dom/enum.VNode.html
[FromStr]: https://doc.rust-lang.org/std/str/trait.FromStr.html
[SpacedSet]: types/struct.SpacedSet.html
[SpacedSet]: https://docs.rs/axohtml/latest/axohtml/types/struct.SpacedSet.html
[IntoIterator]: https://doc.rust-lang.org/std/iter/trait.IntoIterator.html
[Into]: https://doc.rust-lang.org/std/convert/trait.Into.html
[Into::into]: https://doc.rust-lang.org/std/convert/trait.Into.html#method.into
[DOMTree]: dom/type.DOMTree.html
[DOMTree]: https://docs.rs/axohtml/latest/axohtml/dom/type.DOMTree.html

4
macros/Cargo.toml
View File

@ -6,8 +6,8 @@ authors = ["Axo Developer Co <hello@axo.dev>", "Bodil Stokke <bodil@bodil.org>"]
build = "build.rs"
license = "MPL-2.0+"
description = "Type checked JSX for Rust (proc_macro crate)"
repository = "https://github.com/bodil/typed-html"
documentation = "http://docs.rs/typed-html/"
repository = "https://github.com/axodotdev/axohtml"
documentation = "http://docs.rs/axohtml/"
readme = "../README.md"
categories = ["template-engine", "web-programming"]
keywords = ["jsx", "html"]

10
macros/src/lib.rs
View File

@ -17,9 +17,9 @@ mod span;
/// Construct a DOM tree.
///
/// See the crate documentation for [`typed_html`][typed_html].
/// See the crate documentation for [`axohtml`][axohtml].
///
/// [typed_html]: ../typed_html/index.html
/// [axohtml]: https://docs.rs/axohtml/
#[proc_macro]
pub fn html(input: TokenStream) -> TokenStream {
let stream = lexer::unroll_stream(input.into(), false);
@ -35,9 +35,9 @@ pub fn html(input: TokenStream) -> TokenStream {
/// Construct a Dodrio node.
///
/// See the crate documentation for [`typed_html`][typed_html].
/// See the crate documentation for [`axohtml`][axohtml].
///
/// [typed_html]: ../typed_html/index.html
/// [axohtml]: https://docs.rs/axohtml/
#[cfg(feature = "dodrio")]
#[proc_macro]
pub fn dodrio(input: TokenStream) -> TokenStream {
@ -53,7 +53,7 @@ pub fn dodrio(input: TokenStream) -> TokenStream {
})
}
/// This macro is used by `typed_html` internally to generate types and
/// This macro is used by `axohtml` internally to generate types and
/// implementations for HTML elements.
#[proc_macro]
pub fn declare_elements(input: TokenStream) -> TokenStream {

2
tests/Cargo.toml
View File

@ -6,7 +6,7 @@ authors = ["Bodil Stokke <bodil@bodil.org>"]
publish = false
[[bin]]
name = "typed-html-tests"
name = "axohtml-tests"
path = "main.rs"
[dev-dependencies]

35
typed-html/src/dom.rs
View File

@ -29,7 +29,7 @@ pub type DOMTree<T> = Box<dyn Node<T>>;
///
/// This structure is designed to be easily walked in order to render a DOM tree
/// or diff against an existing tree. It's the stringly typed version of
/// [`Node`][Node].
/// [`Node`].
///
/// It can be constructed from any ['Node'][Node]:
///
@ -38,8 +38,6 @@ pub type DOMTree<T> = Box<dyn Node<T>>;
/// <p>"But how does she "<em>"eat?"</em></p>
/// ).vnode()
/// ```
///
/// [Node]: trait.Node.html
pub enum VNode<'a, T: OutputType + 'a> {
Text(&'a str),
UnsafeText(&'a str),
@ -56,20 +54,13 @@ pub struct VElement<'a, T: OutputType + 'a> {
/// Trait for rendering a typed HTML node.
///
/// All [HTML elements][elements] implement this, in addition to
/// [`TextNode`][TextNode].
/// All [HTML elements][crate::elements] implement this, in addition to
/// [`TextNode`].
///
/// It implements [`Display`][Display] for rendering to strings, and the
/// [`vnode()`][vnode] method can be used to render a virtual DOM structure.
///
/// [Display]: https://doc.rust-lang.org/std/fmt/trait.Display.html
/// [TextNode]: struct.TextNode.html
/// [elements]: ../elements/index.html
/// [vnode]: #tymethod.vnode
/// It implements [`Display`] for rendering to strings, and the
/// [`vnode()`][Self::vnode] method can be used to render a virtual DOM structure.
pub trait Node<T: OutputType + Send>: Display + Send {
/// Render the node into a [`VNode`][VNode] tree.
///
/// [VNode]: enum.VNode.html
/// Render the node into a [`VNode`] tree.
fn vnode(&mut self) -> VNode<T>;
}
@ -87,9 +78,7 @@ where
/// Trait for querying a typed HTML element.
///
/// All [HTML elements][elements] implement this.
///
/// [elements]: ../elements/index.html
/// All [HTML elements][crate::elements] implement this.
pub trait Element<T: OutputType + Send>: Node<T> {
/// Get the name of the element.
fn name() -> &'static str;
@ -154,7 +143,7 @@ pub struct UnsafeTextNode<T: OutputType + Send>(String, PhantomData<T>);
///
/// This macro is useful for creating text macros inside code blocks that contain HTML
/// that you do not want to be escaped. For example, if some other process renders Markdown
/// to an HTML string and you want embed that HTML string in a typed-html template,
/// to an HTML string and you want embed that HTML string in an axohtml template,
/// you may want to avoid escaping the tags in that HTML string.
///
/// # Examples
@ -189,10 +178,8 @@ macro_rules! unsafe_text {
impl<T: OutputType + Send> TextNode<T> {
/// Construct a text node.
///
/// The preferred way to construct a text node is with the [`text!()`][text]
/// The preferred way to construct a text node is with the [`text!()`][crate::text]
/// macro.
///
/// [text]: ../macro.text.html
pub fn new<S: Into<String>>(s: S) -> Self {
TextNode(s.into(), PhantomData)
}
@ -234,10 +221,8 @@ impl<T: OutputType + Send> PhrasingContent<T> for TextNode<T> {}
impl<T: OutputType + Send> UnsafeTextNode<T> {
/// Construct a unsafe text node.
///
/// The preferred way to construct a unsafe text node is with the [`unsafe_text!()`][unsafe_text]
/// The preferred way to construct a unsafe text node is with the [`unsafe_text!()`][crate::unsafe_text]
/// macro.
///
/// [unsafe_text]: ../macro.unsafe_text.html
pub fn new<S: Into<String>>(s: S) -> Self {
UnsafeTextNode(s.into(), PhantomData)
}

38
typed-html/src/lib.rs
View File

@ -1,6 +1,13 @@
#![recursion_limit = "128"]
//! This crate provides the `html!` macro for building HTML documents inside your
//! Rust code using roughly [JSX] compatible syntax.
//! This crate provides the `html!` macro for building fully type checked HTML
//! documents inside your Rust code using roughly [JSX] compatible syntax.
//!
//! This crate is a fork of the great [Bodil Stokke's] [typed-html] crate. Opted
//! for a fork instead of maintainership because not currently intending to use or
//! maintain the Wasm compatibility (for now).
//!
//! [Bodil Stokke's]: https://github.com/bodil
//! [typed-html]: https://github.com/bodil/typed-html
//!
//! # Quick Preview
//!
@ -75,14 +82,14 @@
//! (see the Syntax section above).
//!
//! The `html!` macro will add an [`.into()`][Into::into] call to the value
//! expression, so that you can use any type that has an [`Into<A>`][Into] trait
//! expression, so that you can use any type that has an [`Into<A>`] trait
//! defined for the actual attribute type `A`.
//!
//! As a special case, if you use a string literal, the macro will instead use the
//! [`FromStr<A>`][FromStr] trait to try and parse the string literal into the
//! [`FromStr<A>`][std::str::FromStr] trait to try and parse the string literal into the
//! expected type. This is extremely useful for eg. CSS classes, letting you type
//! `class="css-class-1 css-class-2"` instead of going to the trouble of
//! constructing a [`SpacedSet<Class>`][SpacedSet]. The big caveat for this:
//! constructing a [`SpacedSet<Class>`][types::SpacedSet]. The big caveat for this:
//! currently, the macro is not able to validate the string at compile time, and the
//! conversion will panic at runtime if the string is invalid.
//!
@ -112,7 +119,7 @@
//! # Generated Nodes
//!
//! Brace blocks in the child node position are expected to return an
//! [`IntoIterator`][IntoIterator] of [`DOMTree`][DOMTree]s. You can return single
//! [`IntoIterator`] of [`DOMTree`][dom::DOMTree]s. You can return single
//! elements or text nodes, as they both implement `IntoIterator` for themselves.
//! The macro will consume this iterator at runtime and insert the generated nodes
//! as children in the expected position.
@ -141,9 +148,9 @@
//!
//! ## Render to a string
//!
//! The DOM tree data structure implements [`Display`][Display], so you can call
//! [`to_string()`][to_string] on it to render it to a [`String`][String]. If you
//! plan to do this, the type of the tree should be [`DOMTree<String>`][DOMTree] to
//! The DOM tree data structure implements [`Display`], so you can call
//! [`to_string()`][std::string::ToString::to_string] on it to render it to a [`String`]. If you
//! plan to do this, the type of the tree should be [`DOMTree<String>`][dom::DOMTree] to
//! ensure you're not using any event handlers that can't be printed.
//!
//! ```
@ -161,7 +168,7 @@
//! ## Render to a virtual DOM
//!
//! The DOM tree structure also implements a method called `vnode()`, which renders
//! the tree to a tree of [`VNode`][VNode]s, which is a mirror of the generated tree
//! the tree to a tree of [`VNode`][dom::VNode]s, which is a mirror of the generated tree
//! with every attribute value rendered into `String`s. You can walk this virtual
//! DOM tree and pass it on to your favourite virtual DOM system.
//!
@ -174,17 +181,6 @@
//! <http://mozilla.org/MPL/2.0/>.
//!
//! [JSX]: https://reactjs.org/docs/introducing-jsx.html
//! [Display]: https://doc.rust-lang.org/std/fmt/trait.Display.html
//! [String]: https://doc.rust-lang.org/std/string/struct.String.html
//! [to_string]: https://doc.rust-lang.org/std/string/trait.ToString.html#tymethod.to_string
//! [Node]: dom/trait.Node.html
//! [VNode]: dom/enum.VNode.html
//! [FromStr]: https://doc.rust-lang.org/std/str/trait.FromStr.html
//! [SpacedSet]: types/struct.SpacedSet.html
//! [IntoIterator]: https://doc.rust-lang.org/std/iter/trait.IntoIterator.html
//! [Into]: https://doc.rust-lang.org/std/convert/trait.Into.html
//! [Into::into]: https://doc.rust-lang.org/std/convert/trait.Into.html#method.into
//! [DOMTree]: dom/type.DOMTree.html
pub extern crate htmlescape;

4
typed-html/src/types/class.rs
View File

@ -12,9 +12,7 @@ use super::Id;
/// and is followed by any number of alphanumeric characters and the
/// `_`, `-` and `.` characters.
///
/// See also [`Id`][Id].
///
/// [Id]: struct.Id.html
/// See also [`Id`].
#[derive(Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Debug)]
pub struct Class(String);

4
typed-html/src/types/id.rs
View File

@ -12,9 +12,7 @@ use super::Class;
/// and is followed by any number of alphanumeric characters and the
/// `_`, `-` and `.` characters.
///
/// See also [`Class`][Class].
///
/// [Class]: struct.Class.html
/// See also [`Class`].
#[derive(Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Debug)]
pub struct Id(String);

4
typed-html/src/types/spacedlist.rs
View File

@ -8,9 +8,7 @@ use std::str::FromStr;
///
/// This type represents a list of non-unique values represented as a string of
/// values separated by spaces in HTML attributes. This is rarely used; a
/// [`SpacedSet`][SpacedSet] of unique values is much more common.
///
/// [SpacedSet]: struct.SpacedSet.html
/// [`SpacedSet`][super::SpacedSet] of unique values is much more common.
#[derive(Clone, PartialEq, Eq, Hash)]
pub struct SpacedList<A>(Vec<A>);