on master help sign in
Bump-Scoped rendering and SVG class attribute fix (#136)

* Removed special-cased set_class to support class attribute on SVG * Changed Render trait to allow bump-scoped lifetimes in components * Fixed examples after change to Render trait * Fixed minor warning about unused cx in test * Fixed some targets that weren't getting built before * Plumbed is_namespaced through to the set_attribute function to preserve set_class optimization while fixing SVG elems * Fixed tests and benches after checking Travis CI logs * Added regression test for SVG 'class' attribute * Fixed typo * Added render test for bump-scoped nodes

commitf482bda3ced13c5b82e6ee6919018f01c54bc1ed authorAndrew J Westlake <kelixes@gmail.com> dateMon 24 Feb 2020, 11:27 (7 years ago) parent6744a0c
23 files changed+192−77
benches/benches.rs+4−4 crates/js-api/src/lib.rs+4−4 examples/counter/src/lib.rs+2−2 examples/game-of-life/src/lib.rs+2−2 examples/hello-world/src/lib.rs+2−2 examples/input-form/src/lib.rs+2−2 examples/js-component/src/lib.rs+2−2 examples/moire/src/lib.rs+2−2 examples/sierpinski-triangle/src/lib.rs+2−2 examples/todomvc/src/todo.rs+2−2 examples/todomvc/src/todos.rs+2−2 src/cached.rs+7−7 src/change_list/mod.rs+2−2 src/diff.rs+6−6 src/lib.rs+2−2 src/render.rs+39−12 src/render_context.rs+1−1 tests/web/cached.rs+4−4 tests/web/events.rs+4−4 tests/web/js_api.rs+2−2 tests/web/keyed.rs+4−4 tests/web/main.rs+6−6 tests/web/render.rs+89−1
benches/benches.rs+4−4
@@ -17,16 +17,16 @@ use std::convert::TryInto;
1717
1818/// The simplest thing we can render: `<div/>`.
1919struct Empty;
20−impl Render for Empty {
21− fn render<'a>(&self, cx: &mut RenderContext<'a>) -> Node<'a> {
20+impl<'a> Render<'a> for Empty {
21+ fn render(&self, cx: &mut RenderContext<'a>) -> Node<'a> {
2222 div(&cx).finish()
2323 }
2424}
2525
2626/// Render a list that is `self.0` items long, has attributes and listeners.
2727struct SimpleList(usize);
28−impl Render for SimpleList {
29− fn render<'a>(&self, cx: &mut RenderContext<'a>) -> Node<'a> {
28+impl<'a> Render<'a> for SimpleList {
29+ fn render(&self, cx: &mut RenderContext<'a>) -> Node<'a> {
3030 let mut children = bumpalo::collections::Vec::with_capacity_in(self.0, cx.bump);
3131 children.extend((0..self.0).map(|_| {
3232 li(&cx)
crates/js-api/src/lib.rs+4−4
@@ -99,8 +99,8 @@ impl GreetingViaJs {
9999
100100/// And finally the `Render` implementation! This adds a `<p>` element and some
101101/// text around whatever the inner JS `Greeting` component renders.
102−impl Render for GreetingViaJs {
103− fn render<'a>(&self, cx: &mut RenderContext<'a>) -> Node<'a> {
102+impl<'a> Render<'a> for GreetingViaJs {
103+ fn render(&self, cx: &mut RenderContext<'a>) -> Node<'a> {
104104 use dodrio::builder::*;
105105 p(&cx)
106106 .children([
@@ -216,8 +216,8 @@ impl JsRender {
216216 }
217217}
218218
219−impl Render for JsRender {
220− fn render<'a>(&self, cx: &mut RenderContext<'a>) -> Node<'a> {
219+impl<'a> Render<'a> for JsRender {
220+ fn render(&self, cx: &mut RenderContext<'a>) -> Node<'a> {
221221 create(cx, self.render())
222222 }
223223}
examples/counter/src/lib.rs+2−2
@@ -26,8 +26,8 @@ impl Counter {
2626
2727// The `Render` implementation for `Counter`s displays the current count and has
2828// buttons to increment and decrement the count.
29−impl Render for Counter {
30− fn render<'a>(&self, cx: &mut RenderContext<'a>) -> Node<'a> {
29+impl<'a> Render<'a> for Counter {
30+ fn render(&self, cx: &mut RenderContext<'a>) -> Node<'a> {
3131 use dodrio::builder::*;
3232
3333 // Stringify the count as a bump-allocated string.
examples/game-of-life/src/lib.rs+2−2
@@ -126,8 +126,8 @@ impl Universe {
126126}
127127
128128/// The rendering implementation for our Game of Life.
129−impl Render for Universe {
130− fn render<'a>(&self, cx: &mut RenderContext<'a>) -> Node<'a> {
129+impl<'a> Render<'a> for Universe {
130+ fn render(&self, cx: &mut RenderContext<'a>) -> Node<'a> {
131131 use dodrio::builder::*;
132132
133133 let mut rows = bumpalo::collections::Vec::with_capacity_in(self.height as usize, cx.bump);
examples/hello-world/src/lib.rs+2−2
@@ -10,8 +10,8 @@ struct Hello {
1010
1111// The `Render` implementation describes how to render a `Hello` component into
1212// HTML.
13−impl Render for Hello {
14− fn render<'a>(&self, cx: &mut RenderContext<'a>) -> Node<'a> {
13+impl<'a> Render<'a> for Hello {
14+ fn render(&self, cx: &mut RenderContext<'a>) -> Node<'a> {
1515 let msg = bumpalo::format!(in cx.bump, "Hello, {}!", self.who);
1616 let msg = msg.into_bump_str();
1717 p(&cx).children([text(msg)]).finish()
examples/input-form/src/lib.rs+2−2
@@ -23,8 +23,8 @@ impl SayHelloTo {
2323
2424// The `Render` implementation has a text `<input>` and a `<div>` that shows a
2525// greeting to the `<input>`'s value.
26−impl Render for SayHelloTo {
27− fn render<'a>(&self, cx: &mut RenderContext<'a>) -> Node<'a> {
26+impl<'a> Render<'a> for SayHelloTo {
27+ fn render(&self, cx: &mut RenderContext<'a>) -> Node<'a> {
2828 use dodrio::builder::*;
2929
3030 div(&cx)
examples/js-component/src/lib.rs+2−2
@@ -31,8 +31,8 @@ impl GreetingViaJs {
3131
3232/// Here's the `Render` implementation! This adds a `<p>` element and some text
3333/// around whatever the inner JS `Greeting` component renders.
34−impl Render for GreetingViaJs {
35− fn render<'a>(&self, cx: &mut RenderContext<'a>) -> Node<'a> {
34+impl<'a> Render<'a> for GreetingViaJs {
35+ fn render(&self, cx: &mut RenderContext<'a>) -> Node<'a> {
3636 use dodrio::builder::*;
3737 p(&cx)
3838 .children([text("JavaScript says: "), self.js.render(cx)])
examples/moire/src/lib.rs+2−2
@@ -104,8 +104,8 @@ impl Moire {
104104 }
105105}
106106
107−impl Render for Moire {
108− fn render<'a>(&self, cx: &mut RenderContext<'a>) -> Node<'a> {
107+impl<'a> Render<'a> for Moire {
108+ fn render(&self, cx: &mut RenderContext<'a>) -> Node<'a> {
109109 use dodrio::builder::*;
110110
111111 let elapsed = web_sys::window()
examples/sierpinski-triangle/src/lib.rs+2−2
@@ -85,8 +85,8 @@ impl Container {
8585 }
8686}
8787
88−impl Render for Container {
89− fn render<'a>(&self, cx: &mut RenderContext<'a>) -> Node<'a> {
88+impl<'a> Render<'a> for Container {
89+ fn render(&self, cx: &mut RenderContext<'a>) -> Node<'a> {
9090 use dodrio::builder::div;
9191
9292 let elapsed = web_sys::window()
examples/todomvc/src/todo.rs+2−2
@@ -116,8 +116,8 @@ impl<C> Todo<C> {
116116 }
117117}
118118
119−impl<C: TodoActions> Render for Todo<C> {
120− fn render<'a>(&self, cx: &mut RenderContext<'a>) -> Node<'a> {
119+impl<'a, C: TodoActions> Render<'a> for Todo<C> {
120+ fn render(&self, cx: &mut RenderContext<'a>) -> Node<'a> {
121121 use dodrio::{
122122 builder::*,
123123 bumpalo::{self, collections::String},
examples/todomvc/src/todos.rs+2−2
@@ -289,8 +289,8 @@ impl<C: TodosActions> Todos<C> {
289289 }
290290}
291291
292−impl<C: TodosActions> Render for Todos<C> {
293− fn render<'a>(&self, cx: &mut RenderContext<'a>) -> Node<'a> {
292+impl<'a, C: TodosActions> Render<'a> for Todos<C> {
293+ fn render(&self, cx: &mut RenderContext<'a>) -> Node<'a> {
294294 use dodrio::builder::*;
295295
296296 div(&cx)
src/cached.rs+7−7
@@ -45,8 +45,8 @@ where
4545 /// count: u32,
4646 /// }
4747 ///
48− /// impl Render for Counter {
49− /// fn render<'a>(&self, cx: &mut RenderContext<'a>) -> Node<'a> {
48+ /// impl<'a> Render<'a> for Counter {
49+ /// fn render(&self, cx: &mut RenderContext<'a>) -> Node<'a> {
5050 /// // ...
5151 /// # unimplemented!()
5252 /// }
@@ -85,8 +85,8 @@ where
8585 /// who: String
8686 /// }
8787 ///
88− /// impl Render for Hello {
89− /// fn render<'a>(&self, cx: &mut RenderContext<'a>) -> Node<'a> {
88+ /// impl<'a> Render<'a> for Hello {
89+ /// fn render(&self, cx: &mut RenderContext<'a>) -> Node<'a> {
9090 /// use dodrio::builder::*;
9191 /// let greeting = bumpalo::format!(in cx.bump, "Hello, {}!", self.who);
9292 /// p(&cx)
@@ -143,11 +143,11 @@ where
143143 }
144144}
145145
146−impl<R> Render for Cached<R>
146+impl<'a, R> Render<'a> for Cached<R>
147147where
148− R: 'static + Default + Render,
148+ R: 'static + Default + for<'b> Render<'b>,
149149{
150− fn render<'a>(&self, cx: &mut RenderContext<'a>) -> Node<'a> {
150+ fn render(&self, cx: &mut RenderContext<'a>) -> Node<'a> {
151151 let template = cx.template::<R>();
152152 let cached = match self.cached.get() {
153153 // This does-the-cache-contain-this-id check is necessary because
src/change_list/mod.rs+2−2
@@ -233,9 +233,9 @@ impl ChangeListBuilder<'_> {
233233 self.state.emitter.replace_with();
234234 }
235235
236− pub fn set_attribute(&mut self, name: &str, value: &str) {
236+ pub fn set_attribute(&mut self, name: &str, value: &str, is_namespaced: bool) {
237237 debug_assert!(self.traversal_is_committed());
238− if name == "class" {
238+ if name == "class" && !is_namespaced {
239239 let class_id = self.ensure_string(value);
240240 debug!("emit: set_class({:?})", value);
241241 self.state.emitter.set_class(class_id.into());
src/diff.rs+6−6
@@ -78,7 +78,7 @@ pub(crate) fn diff(
7878 return;
7979 }
8080 diff_listeners(change_list, registry, old_listeners, new_listeners);
81− diff_attributes(change_list, old_attributes, new_attributes);
81+ diff_attributes(change_list, old_attributes, new_attributes, new_namespace.is_some());
8282 diff_children(
8383 cached_set,
8484 change_list,
@@ -204,26 +204,26 @@ fn diff_listeners(
204204// [... node]
205205//
206206// The change list stack is left unchanged.
207−fn diff_attributes(change_list: &mut ChangeListBuilder, old: &[Attribute], new: &[Attribute]) {
207+fn diff_attributes(change_list: &mut ChangeListBuilder, old: &[Attribute], new: &[Attribute], is_namespaced: bool) {
208208 // Do O(n^2) passes to add/update and remove attributes, since
209209 // there are almost always very few attributes.
210210 'outer: for new_attr in new {
211211 if new_attr.is_volatile() {
212212 change_list.commit_traversal();
213− change_list.set_attribute(new_attr.name, new_attr.value);
213+ change_list.set_attribute(new_attr.name, new_attr.value, is_namespaced);
214214 } else {
215215 for old_attr in old {
216216 if old_attr.name == new_attr.name {
217217 if old_attr.value != new_attr.value {
218218 change_list.commit_traversal();
219− change_list.set_attribute(new_attr.name, new_attr.value);
219+ change_list.set_attribute(new_attr.name, new_attr.value, is_namespaced);
220220 }
221221 continue 'outer;
222222 }
223223 }
224224
225225 change_list.commit_traversal();
226− change_list.set_attribute(new_attr.name, new_attr.value);
226+ change_list.set_attribute(new_attr.name, new_attr.value, is_namespaced);
227227 }
228228 }
229229
@@ -953,7 +953,7 @@ fn create(
953953 }
954954
955955 for attr in attributes {
956− change_list.set_attribute(&attr.name, &attr.value);
956+ change_list.set_attribute(&attr.name, &attr.value, namespace.is_some());
957957 }
958958
959959 // Fast path: if there is a single text child, it is faster to
src/lib.rs+2−2
@@ -18,8 +18,8 @@
1818//! }
1919//! }
2020//!
21−//! impl<'who> Render for Hello<'who> {
22−//! fn render<'a>(&self, cx: &mut RenderContext<'a>) -> Node<'a> {
21+//! impl<'a, 'who> Render<'a> for Hello<'who> {
22+//! fn render(&self, cx: &mut RenderContext<'a>) -> Node<'a> {
2323//! use dodrio::builder::*;
2424//!
2525//! let id = bumpalo::format!(in cx.bump, "hello-{}", self.who);
src/render.rs+39−12
@@ -21,8 +21,8 @@ use wasm_bindgen::UnwrapThrowExt;
2121///
2222/// pub struct MyComponent;
2323///
24−/// impl Render for MyComponent {
25−/// fn render<'a>(&self, cx: &mut RenderContext<'a>) -> Node<'a> {
24+/// impl<'a> Render<'a> for MyComponent {
25+/// fn render(&self, cx: &mut RenderContext<'a>) -> Node<'a> {
2626/// use dodrio::builder::*;
2727///
2828/// p(&cx)
@@ -35,26 +35,26 @@ use wasm_bindgen::UnwrapThrowExt;
3535/// }
3636/// }
3737/// ```
38−pub trait Render {
38+pub trait Render<'a> {
3939 /// Render `self` as a virtual DOM. Use the given context's `Bump` for
4040 /// temporary allocations.
41− fn render<'a>(&self, cx: &mut RenderContext<'a>) -> Node<'a>;
41+ fn render(&self, cx: &mut RenderContext<'a>) -> Node<'a>;
4242}
4343
44−impl<'r, R> Render for &'r R
44+impl<'a, 'r, R> Render<'a> for &'r R
4545where
46− R: Render,
46+ R: Render<'a>,
4747{
48− fn render<'a>(&self, cx: &mut RenderContext<'a>) -> Node<'a> {
48+ fn render(&self, cx: &mut RenderContext<'a>) -> Node<'a> {
4949 (**self).render(cx)
5050 }
5151}
5252
53−impl<R> Render for Rc<R>
53+impl<'a, R> Render<'a> for Rc<R>
5454where
55− R: Render,
55+ R: Render<'a>,
5656{
57− fn render<'a>(&self, cx: &mut RenderContext<'a>) -> Node<'a> {
57+ fn render(&self, cx: &mut RenderContext<'a>) -> Node<'a> {
5858 (**self).render(cx)
5959 }
6060}
@@ -69,7 +69,7 @@ where
6969/// You do not need to implement this trait by hand: there is a blanket
7070/// implementation for all `Render` types that fulfill the `RootRender`
7171/// requirements.
72−pub trait RootRender: Any + Render {
72+pub trait RootRender: Any + for<'a> Render<'a> {
7373 /// Get this `&RootRender` trait object as an `&Any` trait object reference.
7474 fn as_any(&self) -> &dyn Any;
7575
@@ -80,7 +80,7 @@ pub trait RootRender: Any + Render {
8080
8181impl<T> RootRender for T
8282where
83− T: Any + Render,
83+ T: Any + for<'a> Render<'a>,
8484{
8585 fn as_any(&self) -> &dyn Any {
8686 self
@@ -138,4 +138,31 @@ mod tests {
138138 #[allow(dead_code)]
139139 fn takes_dyn_render(_: &dyn super::RootRender) {}
140140 }
141+
142+ #[test]
143+ fn render_bump_scoped_child() {
144+ use crate::{builder::*, bumpalo::collections::String, Node, Render, RenderContext};
145+
146+ struct Child<'a> {
147+ name: &'a str,
148+ }
149+
150+ impl<'a> Render<'a> for Child<'a> {
151+ fn render(&self, _cx: &mut RenderContext<'a>) -> Node<'a> {
152+ text(self.name)
153+ }
154+ }
155+
156+ struct Parent;
157+
158+ impl<'a> Render<'a> for Parent {
159+ fn render(&self, cx: &mut RenderContext<'a>) -> Node<'a> {
160+ let child_name = String::from_str_in("child", cx.bump).into_bump_str();
161+
162+ div(&cx)
163+ .children([Child { name: child_name }.render(cx)])
164+ .finish()
165+ }
166+ }
167+ }
141168}
src/render_context.rs+1−1
@@ -69,7 +69,7 @@ impl<'a> RenderContext<'a> {
6969 /// Get or create the cached template for `Cached<R>`.
7070 pub(crate) fn template<R>(&mut self) -> Option<CacheId>
7171 where
72− R: 'static + Default + Render,
72+ R: 'static + Default + for<'b> Render<'b>,
7373 {
7474 let template_id = Cached::<R>::template_id();
7575 if let Some(cache_id) = self.templates.get(&template_id).cloned() {
tests/web/cached.rs+4−4
@@ -18,8 +18,8 @@ impl CountRenders {
1818 }
1919}
2020
21−impl Render for CountRenders {
22− fn render<'a>(&self, cx: &mut RenderContext<'a>) -> Node<'a> {
21+impl<'a> Render<'a> for CountRenders {
22+ fn render(&self, cx: &mut RenderContext<'a>) -> Node<'a> {
2323 let count = self.render_count.get() + 1;
2424 self.render_count.set(count);
2525
@@ -153,8 +153,8 @@ impl Default for Id {
153153 }
154154}
155155
156−impl Render for Id {
157− fn render<'a>(&self, _cx: &mut RenderContext<'a>) -> Node<'a> {
156+impl<'a> Render<'a> for Id {
157+ fn render(&self, _cx: &mut RenderContext<'a>) -> Node<'a> {
158158 text(self.0)
159159 }
160160}
tests/web/events.rs+4−4
@@ -24,8 +24,8 @@ impl EventContainer {
2424 }
2525}
2626
27−impl Render for EventContainer {
28− fn render<'a>(&self, cx: &mut RenderContext<'a>) -> Node<'a> {
27+impl<'a> Render<'a> for EventContainer {
28+ fn render(&self, cx: &mut RenderContext<'a>) -> Node<'a> {
2929 use dodrio::builder::*;
3030 div(&cx)
3131 .attr("id", "target")
@@ -126,8 +126,8 @@ impl ListensOnlyOnFirstRender {
126126 }
127127}
128128
129−impl Render for ListensOnlyOnFirstRender {
130− fn render<'a>(&self, cx: &mut RenderContext<'a>) -> Node<'a> {
129+impl<'a> Render<'a> for ListensOnlyOnFirstRender {
130+ fn render(&self, cx: &mut RenderContext<'a>) -> Node<'a> {
131131 use dodrio::builder::*;
132132
133133 let count = self.count.get();
tests/web/js_api.rs+2−2
@@ -35,8 +35,8 @@ impl WrapJs {
3535 }
3636}
3737
38−impl Render for WrapJs {
39− fn render<'a>(&self, cx: &mut RenderContext<'a>) -> Node<'a> {
38+impl<'a> Render<'a> for WrapJs {
39+ fn render(&self, cx: &mut RenderContext<'a>) -> Node<'a> {
4040 div(&cx)
4141 .attr("class", "wrap-js")
4242 .children([self.inner.render(cx)])
tests/web/keyed.rs+4−4
@@ -7,8 +7,8 @@ use wasm_bindgen_test::*;
77
88struct Keyed(u16);
99
10−impl Render for Keyed {
11− fn render<'a>(&self, cx: &mut RenderContext<'a>) -> Node<'a> {
10+impl<'a> Render<'a> for Keyed {
11+ fn render(&self, cx: &mut RenderContext<'a>) -> Node<'a> {
1212 let key = bumpalo::format!(in cx.bump, "{}", self.0).into_bump_str();
1313 div(&cx)
1414 .attr("class", "keyed")
@@ -33,8 +33,8 @@ where
3333
3434async fn assert_keyed<Before, After>(before: Before, after: After) -> Result<(), JsValue>
3535where
36− Before: 'static + Render,
37− After: 'static + Render,
36+ Before: 'static + for<'a> Render<'a>,
37+ After: 'static + for<'a> Render<'a>,
3838{
3939 #[wasm_bindgen(module = "/tests/web/keyed.js")]
4040 extern "C" {
tests/web/main.rs+6−6
@@ -50,7 +50,7 @@ pub fn init_logging() {
5050
5151/// Assert that the `container` contains the physical DOM tree that matches
5252/// `r`'s rendered virtual DOM.
53−pub fn assert_rendered<R: Render>(container: &web_sys::Element, r: &R) {
53+pub fn assert_rendered<R: for<'a> Render<'a>>(container: &web_sys::Element, r: &R) {
5454 init_logging();
5555
5656 let cached_set = &RefCell::new(CachedSet::default());
@@ -155,11 +155,11 @@ pub struct RenderFn<F>(F)
155155where
156156 F: for<'a> Fn(&mut RenderContext<'a>) -> Node<'a>;
157157
158−impl<F> Render for RenderFn<F>
158+impl<'a, F> Render<'a> for RenderFn<F>
159159where
160− F: for<'a> Fn(&mut RenderContext<'a>) -> Node<'a>,
160+ F: for<'b> Fn(&mut RenderContext<'b>) -> Node<'b>,
161161{
162− fn render<'a>(&self, cx: &mut RenderContext<'a>) -> Node<'a> {
162+ fn render(&self, cx: &mut RenderContext<'a>) -> Node<'a> {
163163 (self.0)(cx)
164164 }
165165}
@@ -169,8 +169,8 @@ where
169169/// the physical DOM tree correctly matches `after`.
170170pub async fn assert_before_after<R, S>(before: R, after: S) -> Result<(), JsValue>
171171where
172− R: 'static + Render,
173− S: 'static + Render,
172+ R: 'static + for<'a> Render<'a>,
173+ S: 'static + for<'a> Render<'a>,
174174{
175175 let container = create_element("div");
176176
tests/web/render.rs+89−1
@@ -1,6 +1,7 @@
11use super::{assert_rendered, before_after, create_element, RenderFn};
2−use dodrio::{builder::*, Vdom};
2+use dodrio::{builder::*, bumpalo::collections::String, Node, Render, RenderContext, Vdom};
33use std::rc::Rc;
4+use wasm_bindgen::{ JsCast};
45use wasm_bindgen_test::*;
56
67#[wasm_bindgen_test]
@@ -34,6 +35,93 @@ fn container_is_emptied_upon_drop() {
3435 assert!(container.first_child().is_none());
3536}
3637
38+/// Renders a child with a lifetime scoped to the RenderContext bump arena.
39+#[wasm_bindgen_test]
40+fn render_bump_scoped_node() {
41+ struct Child<'a> {
42+ name: &'a str,
43+ }
44+
45+ impl<'a> Render<'a> for Child<'a> {
46+ fn render(&self, _cx: &mut RenderContext<'a>) -> Node<'a> {
47+ text(self.name)
48+ }
49+ }
50+
51+ struct Parent;
52+
53+ impl<'a> Render<'a> for Parent {
54+ fn render(&self, cx: &mut RenderContext<'a>) -> Node<'a> {
55+ let child_name = String::from_str_in("child", cx.bump).into_bump_str();
56+
57+ div(&cx)
58+ .children([Child { name: child_name }.render(cx)])
59+ .finish()
60+ }
61+ }
62+
63+ let parent = Rc::new(RenderFn(|cx| {
64+ Parent.render(cx)
65+ }));
66+
67+ let container = create_element("div");
68+ let _vdom = Vdom::new(&container, parent.clone());
69+
70+ assert_rendered(&container, &parent);
71+}
72+
73+/// Originally, dodrio would use the className property for SVGs.
74+///
75+/// This is problematic because when SVG elements are created, the className is flagged as a read
76+/// only property, so setting it causes an exception to be thrown. Here's an example of how this
77+/// happens:
78+///
79+/// let elem = web_sys::window()
80+/// .unwrap()
81+/// .document()
82+/// .unwrap()
83+/// .create_element_ns(Some("http://www.w3.org/2000/svg"), "svg")
84+/// .unwrap();
85+///
86+/// elem.set_class_name("does-not-work");
87+///
88+/// -----------------------------------------------------------------------------------------------
89+///
90+/// wasm-bindgen: imported JS function that was not marked as `catch` threw an error:
91+/// setting getter-only property "className"
92+///
93+/// -----------------------------------------------------------------------------------------------
94+///
95+/// Now, dodrio passes the 'class' attribute of all namespaced elements into set_attribute. This
96+/// satisfies the restrictions on SVG and keeps the optimized path for non-namespaced elements
97+#[wasm_bindgen_test(async)]
98+async fn test_svg_set_class() {
99+ let container = create_element("div");
100+
101+
102+ let valid_svg = Rc::new(RenderFn(|cx| {
103+ ElementBuilder::new(cx.bump, "svg")
104+ .namespace(Some("http://www.w3.org/2000/svg"))
105+ .attr("class", "works")
106+ .finish()
107+ }));
108+
109+ let vdom = Vdom::new(&container, valid_svg.clone());
110+ let weak = vdom.weak();
111+
112+ weak.render().await.unwrap();
113+
114+ assert_eq!(
115+ "works",
116+ container.first_child()
117+ .expect("unable to get svg")
118+ .dyn_ref::<web_sys::Element>()
119+ .expect("svg should be an element")
120+ .get_attribute("class")
121+ .expect("unable to get 'class' of svg")
122+ );
123+}
124+
37125before_after! {
38126 same_text {
39127 before(_cx) {