swaits/dioxus
1
0 Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

update tests

Browse Source
This commit is contained in:
Evan Almloff committed 2022-12-05 21:36:24 -06:00
1 parent 317aed7343
commit ad33f2ce96
7 files changed
+833 -1081
Download Patch File Download Diff File Expand all files Collapse all files

No files matched your search

packages/native-core-macro/src/lib.rs
+6 -3
View File
@@ -189,7 +189,7 @@ impl Struct {
let members = fields let members = fields
.iter() .iter()
.enumerate() .enumerate()
.filter_map(|(i, f)| Member::parse(f, i as u64)) .filter_map(|(i, f)| Member::parse(&name, f, i as u64))
.collect(); .collect();
Self { name, members } Self { name, members }
} }
@@ -296,12 +296,15 @@ struct Member {
} }
impl Member { impl Member {
fn parse(field: &Field, id: u64) -> Option<Self> { fn parse(parent: &Ident, field: &Field, id: u64) -> Option<Self> {
Some(Self { Some(Self {
id, id,
ty: field.ty.clone(), ty: field.ty.clone(),
unit_type: Ident::new( unit_type: Ident::new(
("_Unit".to_string() + field.ty.to_token_stream().to_string().as_str()).as_str(), ("_Unit".to_string()
+ parent.to_token_stream().to_string().as_str()
+ field.ty.to_token_stream().to_string().as_str())
.as_str(),
Span::call_site(), Span::call_site(),
) )
.into(), .into(),
packages/native-core-macro/tests/called_minimally_on_build.rs
+125 -140
View File
@@ -71,48 +71,33 @@ macro_rules! test_state{
fn state_reduce_initally_called_minimally() { fn state_reduce_initally_called_minimally() {
#[allow(non_snake_case)] #[allow(non_snake_case)]
fn Base(cx: Scope) -> Element { fn Base(cx: Scope) -> Element {
render!(div { render!{
div{ div {
div{ div{
p{} div{
} p{}
p{ }
"hello" p{
} "hello"
div{ }
h1{} div{
} h1{}
p{ }
"world" p{
} "world"
} }
})
}
let vdom = VirtualDom::new(Base);
let mutations = vdom.create_vnodes(rsx! {
div {
div{
div{
p{}
}
p{
"hello"
}
div{
h1{}
}
p{
"world"
} }
} }
} }
}); }
let mut vdom = VirtualDom::new(Base);
let mutations = vdom.rebuild();
let mut dom: RealDom<$s> = RealDom::new(); let mut dom: RealDom<$s> = RealDom::new();
let nodes_updated = dom.apply_mutations(vec![mutations]); let (nodes_updated, _) = dom.apply_mutations(mutations);
let _to_rerender = dom.update_state(nodes_updated, SendAnyMap::new()); let _to_rerender = dom.update_state(nodes_updated, SendAnyMap::new());
dom.traverse_depth_first(|n| { dom.traverse_depth_first(|n| {
@@ -130,131 +115,131 @@ macro_rules! test_state{
} }
} }
// mod node_depends_on_child_and_parent { mod node_depends_on_child_and_parent {
// use super::*; use super::*;
// #[derive(Debug, Clone, Default, PartialEq)] #[derive(Debug, Clone, Default, PartialEq)]
// struct Node(i32); struct Node(i32);
// dep!(node(Node, (Child, Parent))); dep!(node(Node, (Child, Parent)));
// #[derive(Debug, Clone, Default, PartialEq)] #[derive(Debug, Clone, Default, PartialEq)]
// struct Child(i32); struct Child(i32);
// dep!(child(Child, (Child,))); dep!(child(Child, (Child,)));
// #[derive(Debug, Clone, Default, PartialEq)] #[derive(Debug, Clone, Default, PartialEq)]
// struct Parent(i32); struct Parent(i32);
// dep!(parent(Parent, (Parent,))); dep!(parent(Parent, (Parent,)));
// #[derive(Debug, Clone, Default, State)] #[derive(Debug, Clone, Default, State)]
// struct StateTester { struct StateTester {
// #[node_dep_state((child, parent))] #[node_dep_state((child, parent))]
// node: Node, node: Node,
// #[child_dep_state(child)] #[child_dep_state(child)]
// child: Child, child: Child,
// #[parent_dep_state(parent)] #[parent_dep_state(parent)]
// parent: Parent, parent: Parent,
// } }
// test_state!(StateTester, child: (child), node: (node), parent: (parent)); test_state!(StateTester, child: (child), node: (node), parent: (parent));
// } }
// mod child_depends_on_node_that_depends_on_parent { mod child_depends_on_node_that_depends_on_parent {
// use super::*; use super::*;
// #[derive(Debug, Clone, Default, PartialEq)] #[derive(Debug, Clone, Default, PartialEq)]
// struct Node(i32); struct Node(i32);
// dep!(node(Node, (Parent,))); dep!(node(Node, (Parent,)));
// #[derive(Debug, Clone, Default, PartialEq)] #[derive(Debug, Clone, Default, PartialEq)]
// struct Child(i32); struct Child(i32);
// dep!(child(Child, (Node,))); dep!(child(Child, (Node,)));
// #[derive(Debug, Clone, Default, PartialEq)] #[derive(Debug, Clone, Default, PartialEq)]
// struct Parent(i32); struct Parent(i32);
// dep!(parent(Parent, (Parent,))); dep!(parent(Parent, (Parent,)));
// #[derive(Debug, Clone, Default, State)] #[derive(Debug, Clone, Default, State)]
// struct StateTester { struct StateTester {
// #[node_dep_state(parent)] #[node_dep_state(parent)]
// node: Node, node: Node,
// #[child_dep_state(node)] #[child_dep_state(node)]
// child: Child, child: Child,
// #[parent_dep_state(parent)] #[parent_dep_state(parent)]
// parent: Parent, parent: Parent,
// } }
// test_state!(StateTester, child: (child), node: (node), parent: (parent)); test_state!(StateTester, child: (child), node: (node), parent: (parent));
// } }
// mod parent_depends_on_node_that_depends_on_child { mod parent_depends_on_node_that_depends_on_child {
// use super::*; use super::*;
// #[derive(Debug, Clone, Default, PartialEq)] #[derive(Debug, Clone, Default, PartialEq)]
// struct Node(i32); struct Node(i32);
// dep!(node(Node, (Child,))); dep!(node(Node, (Child,)));
// #[derive(Debug, Clone, Default, PartialEq)] #[derive(Debug, Clone, Default, PartialEq)]
// struct Child(i32); struct Child(i32);
// dep!(child(Child, (Child,))); dep!(child(Child, (Child,)));
// #[derive(Debug, Clone, Default, PartialEq)] #[derive(Debug, Clone, Default, PartialEq)]
// struct Parent(i32); struct Parent(i32);
// dep!(parent(Parent, (Node,))); dep!(parent(Parent, (Node,)));
// #[derive(Debug, Clone, Default, State)] #[derive(Debug, Clone, Default, State)]
// struct StateTester { struct StateTester {
// #[node_dep_state(child)] #[node_dep_state(child)]
// node: Node, node: Node,
// #[child_dep_state(child)] #[child_dep_state(child)]
// child: Child, child: Child,
// #[parent_dep_state(node)] #[parent_dep_state(node)]
// parent: Parent, parent: Parent,
// } }
// test_state!(StateTester, child: (child), node: (node), parent: (parent)); test_state!(StateTester, child: (child), node: (node), parent: (parent));
// } }
// mod node_depends_on_other_node_state { mod node_depends_on_other_node_state {
// use super::*; use super::*;
// #[derive(Debug, Clone, Default, PartialEq)] #[derive(Debug, Clone, Default, PartialEq)]
// struct Node1(i32); struct Node1(i32);
// dep!(node(Node1, (Node2,))); dep!(node(Node1, (Node2,)));
// #[derive(Debug, Clone, Default, PartialEq)] #[derive(Debug, Clone, Default, PartialEq)]
// struct Node2(i32); struct Node2(i32);
// dep!(node(Node2, ())); dep!(node(Node2, ()));
// #[derive(Debug, Clone, Default, State)] #[derive(Debug, Clone, Default, State)]
// struct StateTester { struct StateTester {
// #[node_dep_state((node2))] #[node_dep_state((node2))]
// node1: Node1, node1: Node1,
// #[node_dep_state()] #[node_dep_state()]
// node2: Node2, node2: Node2,
// } }
// test_state!(StateTester, child: (), node: (node1, node2), parent: ()); test_state!(StateTester, child: (), node: (node1, node2), parent: ());
// } }
// mod node_child_and_parent_state_depends_on_self { mod node_child_and_parent_state_depends_on_self {
// use super::*; use super::*;
// #[derive(Debug, Clone, Default, PartialEq)] #[derive(Debug, Clone, Default, PartialEq)]
// struct Node(i32); struct Node(i32);
// dep!(node(Node, ())); dep!(node(Node, ()));
// #[derive(Debug, Clone, Default, PartialEq)] #[derive(Debug, Clone, Default, PartialEq)]
// struct Child(i32); struct Child(i32);
// dep!(child(Child, (Child,))); dep!(child(Child, (Child,)));
// #[derive(Debug, Clone, Default, PartialEq)] #[derive(Debug, Clone, Default, PartialEq)]
// struct Parent(i32); struct Parent(i32);
// dep!(parent(Parent, (Parent,))); dep!(parent(Parent, (Parent,)));
// #[derive(Debug, Clone, Default, State)] #[derive(Debug, Clone, Default, State)]
// struct StateTester { struct StateTester {
// #[node_dep_state()] #[node_dep_state()]
// node: Node, node: Node,
// #[child_dep_state(child)] #[child_dep_state(child)]
// child: Child, child: Child,
// #[parent_dep_state(parent)] #[parent_dep_state(parent)]
// parent: Parent, parent: Parent,
// } }
// test_state!(StateTester, child: (child), node: (node), parent: (parent)); test_state!(StateTester, child: (child), node: (node), parent: (parent));
// } }
packages/native-core-macro/tests/change_nodes.rs
-79
View File
@@ -1,79 +0,0 @@
// use dioxus::core::ElementId;
// use dioxus::prelude::*;
// use dioxus_native_core::real_dom::RealDom;
// use dioxus_native_core::state::State;
// use dioxus_native_core::tree::*;
// use dioxus_native_core::NodeId;
// use dioxus_native_core_macro::State;
// #[derive(State, Default, Clone)]
// struct Empty {}
// #[test]
// fn remove_node() {
// #[allow(non_snake_case)]
// fn Base(cx: Scope) -> Element {
// render!(div {})
// }
// let vdom = VirtualDom::new(Base);
// let mut dom: RealDom<Empty> = RealDom::new();
// let (create, edit) = vdom.diff_lazynodes(
// rsx! {
// div{
// div{}
// }
// },
// rsx! {
// div{}
// },
// );
// println!("create: {:#?}", create);
// println!("edit: {:#?}", edit);
// let _to_update = dom.apply_mutations(vec![create]);
// assert_eq!(dom.tree.height(NodeId(0)), Some(0));
// assert_eq!(dom.tree.height(NodeId(1)), Some(1));
// dom.apply_mutations(vec![edit]);
// assert_eq!(dom.size(), 3);
// assert_eq!(dom.tree.height(NodeId(0)), Some(0));
// }
// #[test]
// fn add_node() {
// #[allow(non_snake_case)]
// fn Base(cx: Scope) -> Element {
// render!(div {})
// }
// let vdom = VirtualDom::new(Base);
// let (create, update) = vdom.diff_lazynodes(
// rsx! {
// div{}
// },
// rsx! {
// div{
// p{}
// }
// },
// );
// let mut dom: RealDom<Empty> = RealDom::new();
// let _to_update = dom.apply_mutations(vec![create]);
// assert_eq!(dom.size(), 2);
// assert_eq!(dom.tree.height(NodeId(2)), Some(1));
// dom.apply_mutations(vec![update]);
// assert_eq!(dom.size(), 3);
// assert_eq!(dom.tree.height(NodeId(3)), Some(0));
// assert_eq!(dom.tree.height(NodeId(0)), Some(1));
// }
packages/native-core-macro/tests/initial_build.rs
-63
View File
@@ -1,63 +0,0 @@
// use dioxus::core::ElementId;
// use dioxus::prelude::*;
// use dioxus_native_core::real_dom::RealDom;
// use dioxus_native_core::state::State;
// use dioxus_native_core::RealNodeId;
// use dioxus_native_core_macro::State;
// #[derive(Default, Clone, State)]
// struct Empty {}
// #[test]
// fn initial_build_simple() {
// #[allow(non_snake_case)]
// fn Base(cx: Scope) -> Element {
// render!(div {})
// }
// let vdom = VirtualDom::new(Base);
// let mutations = vdom.create_vnodes(rsx! {
// div{}
// });
// let mut dom: RealDom<Empty> = RealDom::new();
// let _to_update = dom.apply_mutations(vec![mutations]);
// assert_eq!(dom.size(), 2);
// assert_eq!(dom[RealNodeId::ElementId(ElementId(2))].node_data.height, 1);
// }
// #[test]
// fn initial_build_with_children() {
// #[allow(non_snake_case)]
// fn Base(cx: Scope) -> Element {
// render!(div {})
// }
// let vdom = VirtualDom::new(Base);
// let mutations = vdom.create_vnodes(rsx! {
// div{
// div{
// "hello"
// p{
// "world"
// }
// "hello world"
// }
// }
// });
// let mut dom: RealDom<Empty> = RealDom::new();
// let _to_update = dom.apply_mutations(vec![mutations]);
// assert_eq!(dom.size(), 2);
// assert_eq!(dom[RealNodeId::ElementId(ElementId(2))].node_data.height, 1);
// assert_eq!(dom[RealNodeId::UnaccessableId(6)].node_data.height, 2);
// assert_eq!(dom[RealNodeId::UnaccessableId(5)].node_data.height, 3);
// assert_eq!(dom[RealNodeId::UnaccessableId(8)].node_data.height, 3);
// assert_eq!(dom[RealNodeId::UnaccessableId(10)].node_data.height, 3);
// assert_eq!(dom[RealNodeId::UnaccessableId(9)].node_data.height, 4);
// }
packages/native-core-macro/tests/persistent_iterator.rs
+275 -310
View File
@@ -1,333 +1,298 @@
// use dioxus::core_macro::rsx_without_templates; use dioxus::prelude::*;
// use dioxus::prelude::*; use dioxus_native_core::{
// use dioxus_native_core::{ real_dom::{ RealDom},
// real_dom::{NodeType, RealDom}, node::NodeType,
// state::State, state::State,
// utils::PersistantElementIter, utils::PersistantElementIter,
// }; };
// use dioxus_native_core_macro::State; use dioxus_native_core_macro::State;
// #[derive(State, Default, Clone)] #[derive(State, Default, Clone, Debug)]
// struct Empty {} struct Empty {}
// #[test] #[test]
// #[allow(unused_variables)] #[allow(unused_variables)]
// fn traverse() { fn traverse() {
// #[allow(non_snake_case)] #[allow(non_snake_case)]
// fn Base(cx: Scope) -> Element { fn Base(cx: Scope) -> Element {
// render!(div {}) render!(
// } div{
// let vdom = VirtualDom::new(Base); div{
// let mutations = vdom.create_vnodes(rsx! { "hello"
// div{ p{
// div{ "world"
// "hello" }
// p{ "hello world"
// "world" }
// } }
// "hello world" )
// } }
// }
// });
// let mut rdom: RealDom<Empty> = RealDom::new(); let mut vdom = VirtualDom::new(Base);
let mutations = vdom.rebuild();
// let _to_update = rdom.apply_mutations(vec![mutations]); let mut rdom: RealDom<Empty> = RealDom::new();
// let mut iter = PersistantElementIter::new(); let _to_update = rdom.apply_mutations(mutations);
// let div_tag = "div".to_string();
// assert!(matches!(
// &rdom[iter.next(&rdom).id()].node_data.node_type,
// NodeType::Element { tag: div_tag, .. }
// ));
// assert!(matches!(
// &rdom[iter.next(&rdom).id()].node_data.node_type,
// NodeType::Element { tag: div_tag, .. }
// ));
// let text1 = "hello".to_string();
// assert!(matches!(
// &rdom[iter.next(&rdom).id()].node_data.node_type,
// NodeType::Text { text: text1, .. }
// ));
// let p_tag = "p".to_string();
// assert!(matches!(
// &rdom[iter.next(&rdom).id()].node_data.node_type,
// NodeType::Element { tag: p_tag, .. }
// ));
// let text2 = "world".to_string();
// assert!(matches!(
// &rdom[iter.next(&rdom).id()].node_data.node_type,
// NodeType::Text { text: text2, .. }
// ));
// let text3 = "hello world".to_string();
// assert!(matches!(
// &rdom[iter.next(&rdom).id()].node_data.node_type,
// NodeType::Text { text: text3, .. }
// ));
// assert!(matches!(
// &rdom[iter.next(&rdom).id()].node_data.node_type,
// NodeType::Element { tag: div_tag, .. }
// ));
// assert!(matches!( let mut iter = PersistantElementIter::new();
// &rdom[iter.prev(&rdom).id()].node_data.node_type, let div_tag = "div".to_string();
// NodeType::Text { text: text3, .. } assert!(matches!(
// )); &rdom[iter.next(&rdom).id()].node_data.node_type,
// assert!(matches!( NodeType::Element { tag: div_tag, .. }
// &rdom[iter.prev(&rdom).id()].node_data.node_type, ));
// NodeType::Text { text: text2, .. } assert!(matches!(
// )); &rdom[iter.next(&rdom).id()].node_data.node_type,
// assert!(matches!( NodeType::Element { tag: div_tag, .. }
// &rdom[iter.prev(&rdom).id()].node_data.node_type, ));
// NodeType::Element { tag: p_tag, .. } let text1 = "hello".to_string();
// )); assert!(matches!(
// assert!(matches!( &rdom[iter.next(&rdom).id()].node_data.node_type,
// &rdom[iter.prev(&rdom).id()].node_data.node_type, NodeType::Text { text: text1, .. }
// NodeType::Text { text: text1, .. } ));
// )); let p_tag = "p".to_string();
// assert!(matches!( assert!(matches!(
// &rdom[iter.prev(&rdom).id()].node_data.node_type, &rdom[iter.next(&rdom).id()].node_data.node_type,
// NodeType::Element { tag: div_tag, .. } NodeType::Element { tag: p_tag, .. }
// )); ));
// assert!(matches!( let text2 = "world".to_string();
// &rdom[iter.prev(&rdom).id()].node_data.node_type, assert!(matches!(
// NodeType::Element { tag: div_tag, .. } &rdom[iter.next(&rdom).id()].node_data.node_type,
// )); NodeType::Text { text: text2, .. }
// assert!(matches!( ));
// &rdom[iter.prev(&rdom).id()].node_data.node_type, let text3 = "hello world".to_string();
// NodeType::Element { tag: div_tag, .. } assert!(matches!(
// )); &rdom[iter.next(&rdom).id()].node_data.node_type,
// assert!(matches!( NodeType::Text { text: text3, .. }
// &rdom[iter.prev(&rdom).id()].node_data.node_type, ));
// NodeType::Text { text: text3, .. } assert!(matches!(
// )); &rdom[iter.next(&rdom).id()].node_data.node_type,
// } NodeType::Element { tag: div_tag, .. }
));
// #[test] assert!(matches!(
// #[allow(unused_variables)] &rdom[iter.prev(&rdom).id()].node_data.node_type,
// fn persist_removes() { NodeType::Text { text: text3, .. }
// #[allow(non_snake_case)] ));
// fn Base(cx: Scope) -> Element { assert!(matches!(
// render!(div {}) &rdom[iter.prev(&rdom).id()].node_data.node_type,
// } NodeType::Text { text: text2, .. }
// let vdom = VirtualDom::new(Base); ));
// let (build, update) = vdom.diff_lazynodes( assert!(matches!(
// rsx_without_templates! { &rdom[iter.prev(&rdom).id()].node_data.node_type,
// div{ NodeType::Element { tag: p_tag, .. }
// p{ ));
// key: "1", assert!(matches!(
// "hello" &rdom[iter.prev(&rdom).id()].node_data.node_type,
// } NodeType::Text { text: text1, .. }
// p{ ));
// key: "2", assert!(matches!(
// "world" &rdom[iter.prev(&rdom).id()].node_data.node_type,
// } NodeType::Element { tag: div_tag, .. }
// p{ ));
// key: "3", assert!(matches!(
// "hello world" &rdom[iter.prev(&rdom).id()].node_data.node_type,
// } NodeType::Element { tag: div_tag, .. }
// } ));
// }, assert!(matches!(
// rsx_without_templates! { &rdom[iter.prev(&rdom).id()].node_data.node_type,
// div{ NodeType::Element { tag: div_tag, .. }
// p{ ));
// key: "1", assert!(matches!(
// "hello" &rdom[iter.prev(&rdom).id()].node_data.node_type,
// } NodeType::Text { text: text3, .. }
// p{ ));
// key: "3", }
// "hello world"
// }
// }
// },
// );
// let mut rdom: RealDom<Empty> = RealDom::new(); #[test]
#[allow(unused_variables)]
fn persist_removes() {
#[allow(non_snake_case)]
fn Base(cx: Scope) -> Element {
let children = match cx.generation()%2{
0=>3,
1=>2,
_ => unreachable!()
};
render!(
div{
(0..children).map(|i|{
rsx!{
p{
key: "{i}",
"{i}"
}
}
})
}
)
}
let mut vdom = VirtualDom::new(Base);
// let _to_update = rdom.apply_mutations(vec![build]); let mut rdom: RealDom<Empty> = RealDom::new();
// // this will end on the node that is removed let build = vdom.rebuild();
// let mut iter1 = PersistantElementIter::new(); let _to_update = rdom.apply_mutations(build);
// // this will end on the after node that is removed
// let mut iter2 = PersistantElementIter::new();
// // div
// iter1.next(&rdom).id();
// iter2.next(&rdom).id();
// // p
// iter1.next(&rdom).id();
// iter2.next(&rdom).id();
// // "hello"
// iter1.next(&rdom).id();
// iter2.next(&rdom).id();
// // p
// iter1.next(&rdom).id();
// iter2.next(&rdom).id();
// // "world"
// iter1.next(&rdom).id();
// iter2.next(&rdom).id();
// // p
// iter2.next(&rdom).id();
// // "hello world"
// iter2.next(&rdom).id();
// iter1.prune(&update, &rdom); // this will end on the node that is removed
// iter2.prune(&update, &rdom); let mut iter1 = PersistantElementIter::new();
// let _to_update = rdom.apply_mutations(vec![update]); // this will end on the after node that is removed
let mut iter2 = PersistantElementIter::new();
// div
iter1.next(&rdom).id();
iter2.next(&rdom).id();
// p
iter1.next(&rdom).id();
iter2.next(&rdom).id();
// "1"
iter1.next(&rdom).id();
iter2.next(&rdom).id();
// p
iter1.next(&rdom).id();
iter2.next(&rdom).id();
// "2"
iter1.next(&rdom).id();
iter2.next(&rdom).id();
// p
iter2.next(&rdom).id();
// "3"
iter2.next(&rdom).id();
// let p_tag = "p".to_string(); let update = vdom.rebuild();
// let idx = iter1.next(&rdom).id(); iter1.prune(&update, &rdom);
// assert!(matches!( iter2.prune(&update, &rdom);
// &rdom[idx].node_data.node_type, let _to_update = rdom.apply_mutations(update);
// NodeType::Element { tag: p_tag, .. }
// ));
// let text = "hello world".to_string();
// let idx = iter1.next(&rdom).id();
// assert!(matches!(
// &rdom[idx].node_data.node_type,
// NodeType::Text { text, .. }
// ));
// let div_tag = "div".to_string();
// let idx = iter2.next(&rdom).id();
// assert!(matches!(
// &rdom[idx].node_data.node_type,
// NodeType::Element { tag: div_tag, .. }
// ));
// }
// #[test] let p_tag = "1".to_string();
// #[allow(unused_variables)] let idx = iter1.next(&rdom).id();
// fn persist_instertions_before() { assert!(matches!(
// #[allow(non_snake_case)] &rdom[idx].node_data.node_type,
// fn Base(cx: Scope) -> Element { NodeType::Element { tag: p_tag, .. }
// render!(div {}) ));
// } let text = "2".to_string();
// let vdom = VirtualDom::new(Base); let idx = iter1.next(&rdom).id();
// let (build, update) = vdom.diff_lazynodes( assert!(matches!(
// rsx_without_templates! { &rdom[idx].node_data.node_type,
// div{ NodeType::Text { text, .. }
// p{ ));
// key: "1", let div_tag = "div".to_string();
// "hello" let idx = iter2.next(&rdom).id();
// } assert!(matches!(
// p{ &rdom[idx].node_data.node_type,
// key: "3", NodeType::Element { tag: div_tag, .. }
// "hello world" ));
// } }
// }
// },
// rsx_without_templates! {
// div{
// p{
// key: "1",
// "hello"
// }
// p{
// key: "2",
// "world"
// }
// p{
// key: "3",
// "hello world"
// }
// }
// },
// );
// let mut rdom: RealDom<Empty> = RealDom::new(); #[test]
#[allow(unused_variables)]
fn persist_instertions_before() {
#[allow(non_snake_case)]
fn Base(cx: Scope) -> Element {
let children = match cx.generation()%2{
0=>3,
1=>2,
_ => unreachable!()
};
render!(
div{
(0..children).map(|i|{
rsx!{
p{
key: "{i}",
"{i}"
}
}
})
}
)
}
let mut vdom = VirtualDom::new(Base);
// let _to_update = rdom.apply_mutations(vec![build]); let mut rdom: RealDom<Empty> = RealDom::new();
// let mut iter = PersistantElementIter::new(); let build = vdom.rebuild();
// // div let _to_update = rdom.apply_mutations(build);
// iter.next(&rdom).id();
// // p let mut iter = PersistantElementIter::new();
// iter.next(&rdom).id(); // div
// // "hello" iter.next(&rdom).id();
// iter.next(&rdom).id(); // p
// // p iter.next(&rdom).id();
// iter.next(&rdom).id(); // "1"
// // "hello world" iter.next(&rdom).id();
// iter.next(&rdom).id(); // p
iter.next(&rdom).id();
// "2"
iter.next(&rdom).id();
let update = vdom.rebuild();
iter.prune(&update, &rdom);
let _to_update = rdom.apply_mutations(update);
// iter.prune(&update, &rdom); let p_tag = "div".to_string();
// let _to_update = rdom.apply_mutations(vec![update]); let idx = iter.next(&rdom).id();
assert!(matches!(
&rdom[idx].node_data.node_type,
NodeType::Element { tag: p_tag, .. }
));
}
// let p_tag = "div".to_string(); #[test]
// let idx = iter.next(&rdom).id(); #[allow(unused_variables)]
// assert!(matches!( fn persist_instertions_after() {
// &rdom[idx].node_data.node_type, #[allow(non_snake_case)]
// NodeType::Element { tag: p_tag, .. } fn Base(cx: Scope) -> Element {
// )); let children = match cx.generation()%2{
// } 0=>3,
1=>2,
_ => unreachable!()
};
render!(
div{
(0..children).map(|i|{
rsx!{
p{
key: "{i}",
"{i}"
}
}
})
}
)
}
let mut vdom = VirtualDom::new(Base);
// #[test] let mut rdom: RealDom<Empty> = RealDom::new();
// #[allow(unused_variables)]
// fn persist_instertions_after() {
// #[allow(non_snake_case)]
// fn Base(cx: Scope) -> Element {
// render!(div {})
// }
// let vdom = VirtualDom::new(Base);
// let (build, update) = vdom.diff_lazynodes(
// rsx_without_templates! {
// div{
// p{
// key: "1",
// "hello"
// }
// p{
// key: "2",
// "world"
// }
// }
// },
// rsx_without_templates! {
// div{
// p{
// key: "1",
// "hello"
// }
// p{
// key: "2",
// "world"
// }
// p{
// key: "3",
// "hello world"
// }
// }
// },
// );
// let mut rdom: RealDom<Empty> = RealDom::new(); let build = vdom.rebuild();
let _to_update = rdom.apply_mutations(build);
// let _to_update = rdom.apply_mutations(vec![build]); let mut iter = PersistantElementIter::new();
// div
iter.next(&rdom).id();
// p
iter.next(&rdom).id();
// "hello"
iter.next(&rdom).id();
// p
iter.next(&rdom).id();
// "world"
iter.next(&rdom).id();
// let mut iter = PersistantElementIter::new(); let update = vdom.rebuild();
// // div iter.prune(&update, &rdom);
// iter.next(&rdom).id(); let _to_update = rdom.apply_mutations(update);
// // p
// iter.next(&rdom).id();
// // "hello"
// iter.next(&rdom).id();
// // p
// iter.next(&rdom).id();
// // "world"
// iter.next(&rdom).id();
// iter.prune(&update, &rdom); let p_tag = "p".to_string();
// let _to_update = rdom.apply_mutations(vec![update]); let idx = iter.next(&rdom).id();
assert!(matches!(
// let p_tag = "p".to_string(); &rdom[idx].node_data.node_type,
// let idx = iter.next(&rdom).id(); NodeType::Element { tag: p_tag, .. }
// assert!(matches!( ));
// &rdom[idx].node_data.node_type, let text = "hello world".to_string();
// NodeType::Element { tag: p_tag, .. } let idx = iter.next(&rdom).id();
// )); assert!(matches!(
// let text = "hello world".to_string(); &rdom[idx].node_data.node_type,
// let idx = iter.next(&rdom).id(); NodeType::Text { text, .. }
// assert!(matches!( ));
// &rdom[idx].node_data.node_type, }
// NodeType::Text { text, .. }
// ));
// }
packages/native-core-macro/tests/update_state.rs
+415 -477
View File
@@ -1,516 +1,454 @@
// use anymap::AnyMap; use dioxus::core::ElementId;
// use dioxus::core::ElementId; use dioxus::core::{AttributeValue, Mutations};
// use dioxus::core::{AttributeValue, DomEdit, Mutations}; use dioxus::prelude::*;
// use dioxus::core_macro::rsx_without_templates; use dioxus_native_core::real_dom::*;
// use dioxus::prelude::*; use dioxus_native_core::state::{ChildDepState, NodeDepState, ParentDepState, State};
// use dioxus_native_core::real_dom::*; use dioxus_native_core::tree::TreeView;
// use dioxus_native_core::state::{ChildDepState, NodeDepState, ParentDepState, State}; use dioxus_native_core::{node_ref::*, NodeId, RealNodeId, SendAnyMap};
// use dioxus_native_core::{node_ref::*, RealNodeId}; use dioxus_native_core_macro::State;
// use dioxus_native_core_macro::State;
// #[derive(Debug, Clone, Default, State)] #[derive(Debug, Clone, Default, State)]
// struct CallCounterStatePart1 { struct CallCounterStatePart1 {
// #[child_dep_state(child_counter)] #[child_dep_state(child_counter)]
// child_counter: ChildDepCallCounter, child_counter: ChildDepCallCounter,
// } }
// #[derive(Debug, Clone, Default, State)] #[derive(Debug, Clone, Default, State)]
// struct CallCounterStatePart2 { struct CallCounterStatePart2 {
// #[parent_dep_state(parent_counter)] #[parent_dep_state(parent_counter)]
// parent_counter: ParentDepCallCounter, parent_counter: ParentDepCallCounter,
// } }
// #[derive(Debug, Clone, Default, State)] #[derive(Debug, Clone, Default, State)]
// struct CallCounterStatePart3 { struct CallCounterStatePart3 {
// #[node_dep_state()] #[node_dep_state()]
// node_counter: NodeDepCallCounter, node_counter: NodeDepCallCounter,
// } }
// #[derive(Debug, Clone, Default, State)] #[derive(Debug, Clone, Default, State)]
// struct CallCounterState { struct CallCounterState {
// #[child_dep_state(child_counter)] #[child_dep_state(child_counter)]
// child_counter: ChildDepCallCounter, child_counter: ChildDepCallCounter,
// #[state] #[state]
// part2: CallCounterStatePart2, part2: CallCounterStatePart2,
// #[parent_dep_state(parent_counter)] #[parent_dep_state(parent_counter)]
// parent_counter: ParentDepCallCounter, parent_counter: ParentDepCallCounter,
// #[state] #[state]
// part1: CallCounterStatePart1, part1: CallCounterStatePart1,
// #[state] #[state]
// part3: CallCounterStatePart3, part3: CallCounterStatePart3,
// #[node_dep_state()] #[node_dep_state()]
// node_counter: NodeDepCallCounter, node_counter: NodeDepCallCounter,
// } }
// #[derive(Debug, Clone, Default)] #[derive(Debug, Clone, Default)]
// struct ChildDepCallCounter(u32); struct ChildDepCallCounter(u32);
// impl ChildDepState for ChildDepCallCounter { impl ChildDepState for ChildDepCallCounter {
// type Ctx = (); type Ctx = ();
// type DepState = Self; type DepState = (Self,);
// const NODE_MASK: NodeMask = NodeMask::ALL; const NODE_MASK: NodeMask = NodeMask::ALL;
// fn reduce<'a>( fn reduce<'a>(
// &mut self, &mut self,
// _: NodeView, _: NodeView,
// _: impl Iterator<Item = &'a Self::DepState>, _: impl Iterator<Item = (&'a Self,)>,
// _: &Self::Ctx, _: &Self::Ctx,
// ) -> bool ) -> bool
// where where
// Self::DepState: 'a, Self::DepState: 'a,
// { {
// self.0 += 1; self.0 += 1;
// true true
// } }
// } }
// #[derive(Debug, Clone, Default)] #[derive(Debug, Clone, Default)]
// struct ParentDepCallCounter(u32); struct ParentDepCallCounter(u32);
// impl ParentDepState for ParentDepCallCounter { impl ParentDepState for ParentDepCallCounter {
// type Ctx = (); type Ctx = ();
// type DepState = Self; type DepState = (Self,);
// const NODE_MASK: NodeMask = NodeMask::ALL; const NODE_MASK: NodeMask = NodeMask::ALL;
// fn reduce( fn reduce(&mut self, _node: NodeView, _parent: Option<(&Self,)>, _ctx: &Self::Ctx) -> bool {
// &mut self, self.0 += 1;
// _node: NodeView, true
// _parent: Option<&Self::DepState>, }
// _ctx: &Self::Ctx, }
// ) -> bool {
// self.0 += 1;
// true
// }
// }
// #[derive(Debug, Clone, Default)] #[derive(Debug, Clone, Default)]
// struct NodeDepCallCounter(u32); struct NodeDepCallCounter(u32);
// impl NodeDepState<()> for NodeDepCallCounter { impl NodeDepState for NodeDepCallCounter {
// type Ctx = (); type Ctx = ();
// const NODE_MASK: NodeMask = NodeMask::ALL; type DepState = ();
// fn reduce(&mut self, _node: NodeView, _sibling: (), _ctx: &Self::Ctx) -> bool { const NODE_MASK: NodeMask = NodeMask::ALL;
// self.0 += 1; fn reduce(&mut self, _node: NodeView, _sibling: (), _ctx: &Self::Ctx) -> bool {
// true self.0 += 1;
// } true
// } }
}
// #[allow(clippy::vec_box)] #[allow(clippy::vec_box)]
// #[derive(Debug, Clone, PartialEq, Default)] #[derive(Debug, Clone, PartialEq, Default)]
// struct BubbledUpStateTester(Option<String>, Vec<Box<BubbledUpStateTester>>); struct BubbledUpStateTester(Option<String>, Vec<Box<BubbledUpStateTester>>);
// impl ChildDepState for BubbledUpStateTester { impl ChildDepState for BubbledUpStateTester {
// type Ctx = u32; type Ctx = u32;
// type DepState = Self; type DepState = (Self,);
// const NODE_MASK: NodeMask = NodeMask::new().with_tag(); const NODE_MASK: NodeMask = NodeMask::new().with_tag();
// fn reduce<'a>( fn reduce<'a>(
// &mut self, &mut self,
// node: NodeView, node: NodeView,
// children: impl Iterator<Item = &'a Self::DepState>, children: impl Iterator<Item = (&'a Self,)>,
// ctx: &Self::Ctx, ctx: &Self::Ctx,
// ) -> bool ) -> bool
// where where
// Self::DepState: 'a, Self::DepState: 'a,
// { {
// assert_eq!(*ctx, 42); assert_eq!(*ctx, 42);
// *self = BubbledUpStateTester( *self = BubbledUpStateTester(
// node.tag().map(|s| s.to_string()), node.tag().map(|s| s.to_string()),
// children.into_iter().map(|c| Box::new(c.clone())).collect(), children
// ); .into_iter()
// true .map(|(c,)| Box::new(c.clone()))
// } .collect(),
// } );
true
}
}
// #[derive(Debug, Clone, PartialEq, Default)] #[derive(Debug, Clone, PartialEq, Default)]
// struct PushedDownStateTester(Option<String>, Option<Box<PushedDownStateTester>>); struct PushedDownStateTester(Option<String>, Option<Box<PushedDownStateTester>>);
// impl ParentDepState for PushedDownStateTester { impl ParentDepState for PushedDownStateTester {
// type Ctx = u32; type Ctx = u32;
// type DepState = Self; type DepState = (Self,);
// const NODE_MASK: NodeMask = NodeMask::new().with_tag(); const NODE_MASK: NodeMask = NodeMask::new().with_tag();
// fn reduce(&mut self, node: NodeView, parent: Option<&Self::DepState>, ctx: &Self::Ctx) -> bool { fn reduce(&mut self, node: NodeView, parent: Option<(&Self,)>, ctx: &Self::Ctx) -> bool {
// assert_eq!(*ctx, 42); assert_eq!(*ctx, 42);
// *self = PushedDownStateTester( *self = PushedDownStateTester(
// node.tag().map(|s| s.to_string()), node.tag().map(|s| s.to_string()),
// parent.map(|c| Box::new(c.clone())), parent.map(|(c,)| Box::new(c.clone())),
// ); );
// true true
// } }
// } }
// #[derive(Debug, Clone, PartialEq, Default)] #[derive(Debug, Clone, PartialEq, Default)]
// struct NodeStateTester(Option<String>, Vec<(String, String)>); struct NodeStateTester(Option<String>, Vec<(String, String)>);
// impl NodeDepState<()> for NodeStateTester { impl NodeDepState for NodeStateTester {
// type Ctx = u32; type Ctx = u32;
// const NODE_MASK: NodeMask = NodeMask::new_with_attrs(AttributeMask::All).with_tag(); type DepState = ();
// fn reduce(&mut self, node: NodeView, _sibling: (), ctx: &Self::Ctx) -> bool { const NODE_MASK: NodeMask = NodeMask::new_with_attrs(AttributeMask::All).with_tag();
// assert_eq!(*ctx, 42); fn reduce(&mut self, node: NodeView, _sibling: (), ctx: &Self::Ctx) -> bool {
// *self = NodeStateTester( assert_eq!(*ctx, 42);
// node.tag().map(|s| s.to_string()), *self = NodeStateTester(
// node.attributes() node.tag().map(|s| s.to_string()),
// .map(|iter| { node.attributes()
// iter.map(|a| { .map(|iter| {
// ( iter.map(|a| {
// a.attribute.name.to_string(), (
// a.value.as_text().unwrap().to_string(), a.attribute.name.to_string(),
// ) a.value.as_text().unwrap().to_string(),
// }) )
// .collect() })
// }) .collect()
// .unwrap_or_default(), })
// ); .unwrap_or_default(),
// true );
// } true
// } }
}
// #[derive(State, Clone, Default, Debug)] #[derive(State, Clone, Default, Debug)]
// struct StateTester { struct StateTester {
// #[child_dep_state(bubbled, u32)] #[child_dep_state(bubbled, u32)]
// bubbled: BubbledUpStateTester, bubbled: BubbledUpStateTester,
// #[parent_dep_state(pushed, u32)] #[parent_dep_state(pushed, u32)]
// pushed: PushedDownStateTester, pushed: PushedDownStateTester,
// #[node_dep_state(NONE, u32)] #[node_dep_state(NONE, u32)]
// node: NodeStateTester, node: NodeStateTester,
// } }
// #[test] #[test]
// fn state_initial() { fn state_initial() {
// #[allow(non_snake_case)] #[allow(non_snake_case)]
// fn Base(cx: Scope) -> Element { fn Base(cx: Scope) -> Element {
// render!(div { render! {
// p{} div{
// h1{} p{}
// }) h1{}
// } div {
p{
color: "red"
}
h1{}
}
}
}
}
// let vdom = VirtualDom::new(Base); let mut vdom = VirtualDom::new(Base);
// let mutations = vdom.create_vnodes(rsx! { let mutations = vdom.rebuild();
// div {
// p{
// color: "red"
// }
// h1{}
// }
// });
// let mut dom: RealDom<StateTester> = RealDom::new(); let mut dom: RealDom<StateTester> = RealDom::new();
// let nodes_updated = dom.apply_mutations(vec![mutations]); let (nodes_updated, _) = dom.apply_mutations(mutations);
// let mut ctx = AnyMap::new(); let mut ctx = SendAnyMap::new();
// ctx.insert(42u32); ctx.insert(42u32);
// let _to_rerender = dom.update_state(nodes_updated, ctx); let _to_rerender = dom.update_state(nodes_updated, ctx);
// let root_div = &dom[RealNodeId::ElementId(ElementId(2))]; let root_div_id = dom.children_ids(NodeId(0)).unwrap()[0];
// assert_eq!(root_div.state.bubbled.0, Some("div".to_string())); let root_div = &dom.get(root_div_id).unwrap();
// assert_eq!( assert_eq!(root_div.state.bubbled.0, Some("div".to_string()));
// root_div.state.bubbled.1, assert_eq!(
// vec![ root_div.state.bubbled.1,
// Box::new(BubbledUpStateTester(Some("p".to_string()), Vec::new())), vec![
// Box::new(BubbledUpStateTester(Some("h1".to_string()), Vec::new())) Box::new(BubbledUpStateTester(Some("p".to_string()), Vec::new())),
// ] Box::new(BubbledUpStateTester(Some("h1".to_string()), Vec::new()))
// ); ]
// assert_eq!(root_div.state.pushed.0, Some("div".to_string())); );
// assert_eq!( assert_eq!(root_div.state.pushed.0, Some("div".to_string()));
// root_div.state.pushed.1, assert_eq!(
// Some(Box::new(PushedDownStateTester( root_div.state.pushed.1,
// Some("Root".to_string()), Some(Box::new(PushedDownStateTester(
// None Some("Root".to_string()),
// ))) None
// ); )))
// assert_eq!(root_div.state.node.0, Some("div".to_string())); );
// assert_eq!(root_div.state.node.1, vec![]); assert_eq!(root_div.state.node.0, Some("div".to_string()));
assert_eq!(root_div.state.node.1, vec![]);
// let child_p = &dom[RealNodeId::UnaccessableId(3)]; let child_p_id = dom.children_ids(root_div_id).unwrap()[0];
// assert_eq!(child_p.state.bubbled.0, Some("p".to_string())); let child_p = &dom[child_p_id];
// assert_eq!(child_p.state.bubbled.1, Vec::new()); assert_eq!(child_p.state.bubbled.0, Some("p".to_string()));
// assert_eq!(child_p.state.pushed.0, Some("p".to_string())); assert_eq!(child_p.state.bubbled.1, Vec::new());
// assert_eq!( assert_eq!(child_p.state.pushed.0, Some("p".to_string()));
// child_p.state.pushed.1, assert_eq!(
// Some(Box::new(PushedDownStateTester( child_p.state.pushed.1,
// Some("div".to_string()), Some(Box::new(PushedDownStateTester(
// Some(Box::new(PushedDownStateTester( Some("div".to_string()),
// Some("Root".to_string()), Some(Box::new(PushedDownStateTester(
// None Some("Root".to_string()),
// ))) None
// ))) )))
// ); )))
// assert_eq!(child_p.state.node.0, Some("p".to_string())); );
// assert_eq!( assert_eq!(child_p.state.node.0, Some("p".to_string()));
// child_p.state.node.1, assert_eq!(
// vec![("color".to_string(), "red".to_string())] child_p.state.node.1,
// ); vec![("color".to_string(), "red".to_string())]
);
// let child_h1 = &dom[RealNodeId::UnaccessableId(4)]; let child_h1_id = dom.children_ids(root_div_id).unwrap()[1];
// assert_eq!(child_h1.state.bubbled.0, Some("h1".to_string())); let child_h1 = &dom[child_h1_id];
// assert_eq!(child_h1.state.bubbled.1, Vec::new()); assert_eq!(child_h1.state.bubbled.0, Some("h1".to_string()));
// assert_eq!(child_h1.state.pushed.0, Some("h1".to_string())); assert_eq!(child_h1.state.bubbled.1, Vec::new());
// assert_eq!( assert_eq!(child_h1.state.pushed.0, Some("h1".to_string()));
// child_h1.state.pushed.1, assert_eq!(
// Some(Box::new(PushedDownStateTester( child_h1.state.pushed.1,
// Some("div".to_string()), Some(Box::new(PushedDownStateTester(
// Some(Box::new(PushedDownStateTester( Some("div".to_string()),
// Some("Root".to_string()), Some(Box::new(PushedDownStateTester(
// None Some("Root".to_string()),
// ))) None
// ))) )))
// ); )))
// assert_eq!(child_h1.state.node.0, Some("h1".to_string())); );
// assert_eq!(child_h1.state.node.1, vec![]); assert_eq!(child_h1.state.node.0, Some("h1".to_string()));
// } assert_eq!(child_h1.state.node.1, vec![]);
}
// #[test] #[test]
// fn state_reduce_parent_called_minimally_on_update() { fn state_reduce_parent_called_minimally_on_update() {
// #[allow(non_snake_case)] #[allow(non_snake_case)]
// fn Base(cx: Scope) -> Element { fn Base(cx: Scope) -> Element {
// render!(div { let width = if cx.generation() == 0 { "100%" } else { "99%" };
// width: "100%", cx.render(rsx! {
// div{ div {
// div{ div{
// p{} div{
// } p{
// p{ width: "{width}",
// "hello" }
// } }
// div{ p{
// h1{} "hello"
// } }
// p{ div{
// "world" h1{}
// } }
// } p{
// }) "world"
// } }
}
}
})
}
// let vdom = VirtualDom::new(Base); let mut vdom = VirtualDom::new(Base);
// let mutations = vdom.create_vnodes(rsx_without_templates! { let mut dom: RealDom<CallCounterState> = RealDom::new();
// div {
// width: "100%",
// div{
// div{
// p{}
// }
// p{
// "hello"
// }
// div{
// h1{}
// }
// p{
// "world"
// }
// }
// }
// });
// let mut dom: RealDom<CallCounterState> = RealDom::new(); let (nodes_updated, _) = dom.apply_mutations(vdom.rebuild());
let _to_rerender = dom.update_state(nodes_updated, SendAnyMap::new());
let (nodes_updated, _) = dom.apply_mutations(vdom.rebuild());
let _to_rerender = dom.update_state(nodes_updated, SendAnyMap::new());
// let nodes_updated = dom.apply_mutations(vec![mutations]); dom.traverse_depth_first(|n| {
// let _to_rerender = dom.update_state(nodes_updated, AnyMap::new()); assert_eq!(n.state.part2.parent_counter.0, 2);
// let nodes_updated = dom.apply_mutations(vec![Mutations { assert_eq!(n.state.parent_counter.0, 2);
// edits: vec![DomEdit::SetAttribute { });
// root: Some(1), }
// field: "width",
// value: AttributeValue::Text("99%"),
// ns: Some("style"),
// }],
// dirty_scopes: rustc_hash::FxHashSet::default(),
// refs: Vec::new(),
// }]);
// let _to_rerender = dom.update_state(nodes_updated, AnyMap::new());
// dom.traverse_depth_first(|n| { #[test]
// assert_eq!(n.state.part2.parent_counter.0, 2); fn state_reduce_child_called_minimally_on_update() {
// assert_eq!(n.state.parent_counter.0, 2); #[allow(non_snake_case)]
// }); fn Base(cx: Scope) -> Element {
// } let width = if cx.generation() == 0 { "100%" } else { "99%" };
cx.render(rsx! {
div {
div{
div{
p{
width: "{width}",
}
}
p{
"hello"
}
div{
h1{}
}
p{
"world"
}
}
}
})
}
// #[test] let mut vdom = VirtualDom::new(Base);
// fn state_reduce_child_called_minimally_on_update() {
// #[allow(non_snake_case)]
// fn Base(cx: Scope) -> Element {
// cx.render(rsx_without_templates!(div {
// div{
// div{
// p{
// width: "100%",
// }
// }
// p{
// "hello"
// }
// div{
// h1{}
// }
// p{
// "world"
// }
// }
// }))
// }
// let vdom = VirtualDom::new(Base); let mut dom: RealDom<CallCounterState> = RealDom::new();
// let mutations = vdom.create_vnodes(rsx_without_templates! { let (nodes_updated, _) = dom.apply_mutations(vdom.rebuild());
// div { let _to_rerender = dom.update_state(nodes_updated, SendAnyMap::new());
// div{ let (nodes_updated, _) = dom.apply_mutations(vdom.rebuild());
// div{ let _to_rerender = dom.update_state(nodes_updated, SendAnyMap::new());
// p{
// width: "100%",
// }
// }
// p{
// "hello"
// }
// div{
// h1{}
// }
// p{
// "world"
// }
// }
// }
// });
// let mut dom: RealDom<CallCounterState> = RealDom::new(); dom.traverse_depth_first(|n| {
assert_eq!(n.state.part1.child_counter.0, {
let id = n.node_data.node_id.0;
if id > 4 {
1
} else {
2
}
});
assert_eq!(n.state.child_counter.0, {
let id = n.node_data.node_id.0;
if id > 4 {
1
} else {
2
}
});
});
}
// let nodes_updated = dom.apply_mutations(vec![mutations]); #[derive(Debug, Clone, Default, State)]
// let _to_rerender = dom.update_state(nodes_updated, AnyMap::new()); struct UnorderedDependanciesState {
// let nodes_updated = dom.apply_mutations(vec![Mutations { #[node_dep_state(c)]
// edits: vec![DomEdit::SetAttribute { b: BDepCallCounter,
// root: Some(4), #[node_dep_state()]
// field: "width", c: CDepCallCounter,
// value: AttributeValue::Text("99%"), #[node_dep_state(b)]
// ns: Some("style"), a: ADepCallCounter,
// }], }
// dirty_scopes: rustc_hash::FxHashSet::default(),
// refs: Vec::new(),
// }]);
// let _to_rerender = dom.update_state(nodes_updated, AnyMap::new());
// dom.traverse_depth_first(|n| { #[derive(Debug, Clone, Default, PartialEq)]
// assert_eq!( struct ADepCallCounter(usize, BDepCallCounter);
// n.state.part1.child_counter.0, impl NodeDepState for ADepCallCounter {
// if let Some(RealNodeId::ElementId(ElementId(id))) = n.node_data.id { type Ctx = ();
// if id > 4 { type DepState = (BDepCallCounter,);
// 1 const NODE_MASK: NodeMask = NodeMask::NONE;
// } else { fn reduce(
// 2 &mut self,
// } _node: NodeView,
// } else { (sibling,): (&BDepCallCounter,),
// panic!() _ctx: &Self::Ctx,
// } ) -> bool {
// ); self.0 += 1;
// assert_eq!( self.1 = sibling.clone();
// n.state.child_counter.0, true
// if let Some(RealNodeId::ElementId(ElementId(id))) = n.node_data.id { }
// if id > 4 { }
// 1
// } else {
// 2
// }
// } else {
// panic!()
// }
// );
// });
// }
// #[derive(Debug, Clone, Default, State)] #[derive(Debug, Clone, Default, PartialEq)]
// struct UnorderedDependanciesState { struct BDepCallCounter(usize, CDepCallCounter);
// #[node_dep_state(c)] impl NodeDepState for BDepCallCounter {
// b: BDepCallCounter, type Ctx = ();
// #[node_dep_state()] type DepState = (CDepCallCounter,);
// c: CDepCallCounter, const NODE_MASK: NodeMask = NodeMask::NONE;
// #[node_dep_state(b)] fn reduce(
// a: ADepCallCounter, &mut self,
// } _node: NodeView,
(sibling,): (&CDepCallCounter,),
_ctx: &Self::Ctx,
) -> bool {
self.0 += 1;
self.1 = sibling.clone();
true
}
}
// #[derive(Debug, Clone, Default, PartialEq)] #[derive(Debug, Clone, Default, PartialEq)]
// struct ADepCallCounter(usize, BDepCallCounter); struct CDepCallCounter(usize);
// impl<'a> NodeDepState<(&'a BDepCallCounter,)> for ADepCallCounter { impl NodeDepState for CDepCallCounter {
// type Ctx = (); type Ctx = ();
// const NODE_MASK: NodeMask = NodeMask::NONE; type DepState = ();
// fn reduce( const NODE_MASK: NodeMask = NodeMask::ALL;
// &mut self, fn reduce(&mut self, _node: NodeView, _sibling: (), _ctx: &Self::Ctx) -> bool {
// _node: NodeView, self.0 += 1;
// (sibling,): (&'a BDepCallCounter,), true
// _ctx: &Self::Ctx, }
// ) -> bool { }
// self.0 += 1;
// self.1 = sibling.clone();
// true
// }
// }
// #[derive(Debug, Clone, Default, PartialEq)] #[test]
// struct BDepCallCounter(usize, CDepCallCounter); fn dependancies_order_independant() {
// impl<'a> NodeDepState<(&'a CDepCallCounter,)> for BDepCallCounter { #[allow(non_snake_case)]
// type Ctx = (); fn Base(cx: Scope) -> Element {
// const NODE_MASK: NodeMask = NodeMask::NONE; render!(div {
// fn reduce( width: "100%",
// &mut self, p{
// _node: NodeView, "hello"
// (sibling,): (&'a CDepCallCounter,), }
// _ctx: &Self::Ctx, })
// ) -> bool { }
// self.0 += 1;
// self.1 = sibling.clone();
// true
// }
// }
// #[derive(Debug, Clone, Default, PartialEq)] let mut vdom = VirtualDom::new(Base);
// struct CDepCallCounter(usize);
// impl NodeDepState<()> for CDepCallCounter {
// type Ctx = ();
// const NODE_MASK: NodeMask = NodeMask::ALL;
// fn reduce(&mut self, _node: NodeView, _sibling: (), _ctx: &Self::Ctx) -> bool {
// self.0 += 1;
// true
// }
// }
// #[test] let mut dom: RealDom<UnorderedDependanciesState> = RealDom::new();
// fn dependancies_order_independant() {
// #[allow(non_snake_case)]
// fn Base(cx: Scope) -> Element {
// render!(div {
// width: "100%",
// p{
// "hello"
// }
// })
// }
// let vdom = VirtualDom::new(Base); let mutations = vdom.rebuild();
let (nodes_updated, _) = dom.apply_mutations(mutations);
let _to_rerender = dom.update_state(nodes_updated, SendAnyMap::new());
// let mutations = vdom.create_vnodes(rsx! { let c = CDepCallCounter(1);
// div { let b = BDepCallCounter(1, c.clone());
// width: "100%", let a = ADepCallCounter(1, b.clone());
// p{ dom.traverse_depth_first(|n| {
// "hello" assert_eq!(&n.state.a, &a);
// } assert_eq!(&n.state.b, &b);
// } assert_eq!(&n.state.c, &c);
// }); });
}
// let mut dom: RealDom<UnorderedDependanciesState> = RealDom::new(); #[derive(Clone, Default, State)]
struct DependanciesStateTest {
// let nodes_updated = dom.apply_mutations(vec![mutations]); #[node_dep_state(c)]
// let _to_rerender = dom.update_state(nodes_updated, AnyMap::new()); b: BDepCallCounter,
#[node_dep_state()]
// let c = CDepCallCounter(1); c: CDepCallCounter,
// let b = BDepCallCounter(1, c.clone()); #[node_dep_state(b)]
// let a = ADepCallCounter(1, b.clone()); a: ADepCallCounter,
// dom.traverse_depth_first(|n| { #[state]
// assert_eq!(&n.state.a, &a); child: UnorderedDependanciesState,
// assert_eq!(&n.state.b, &b); }
// assert_eq!(&n.state.c, &c);
// });
// }
// #[derive(Clone, Default, State)]
// struct DependanciesStateTest {
// #[node_dep_state(c)]
// b: BDepCallCounter,
// #[node_dep_state()]
// c: CDepCallCounter,
// #[node_dep_state(b)]
// a: ADepCallCounter,
// #[state]
// child: UnorderedDependanciesState,
// }
packages/native-core/src/utils.rs
+12 -9
View File
@@ -2,6 +2,7 @@ use crate::{node::NodeType, real_dom::RealDom, state::State, tree::TreeView, Nod
use dioxus_core::{Mutation, Mutations}; use dioxus_core::{Mutation, Mutations};
use std::fmt::Debug; use std::fmt::Debug;
#[derive(Debug)]
pub enum ElementProduced { pub enum ElementProduced {
/// The iterator produced an element by progressing to the next node in a depth first order. /// The iterator produced an element by progressing to the next node in a depth first order.
Progressed(RealNodeId), Progressed(RealNodeId),
@@ -124,20 +125,20 @@ impl PersistantElementIter {
/// get the next element /// get the next element
pub fn next<S: State>(&mut self, rdom: &RealDom<S>) -> ElementProduced { pub fn next<S: State>(&mut self, rdom: &RealDom<S>) -> ElementProduced {
if self.stack.is_empty() { let r=if self.stack.is_empty() {
let id = NodeId(0); let id = NodeId(0);
let new = (id, NodePosition::AtNode); let new = (id, NodePosition::AtNode);
self.stack.push(new); self.stack.push(new);
ElementProduced::Looped(id) ElementProduced::Looped(id)
} else { } else {
let (last, o_child_idx) = self.stack.last_mut().unwrap(); let (last, old_child_idx) = self.stack.last_mut().unwrap();
let node = &rdom[*last]; let node = &rdom[*last];
match &node.node_data.node_type { match &node.node_data.node_type {
NodeType::Element { .. } => { NodeType::Element { .. } => {
let children = rdom.tree.children_ids(*last).unwrap(); let children = rdom.tree.children_ids(*last).unwrap();
*o_child_idx = o_child_idx.map(|i| i + 1); *old_child_idx = old_child_idx.map(|i| i + 1);
// if we have children, go to the next child // if we have children, go to the next child
let child_idx = o_child_idx.get_or_insert(0); let child_idx = old_child_idx.get_or_insert(0);
if child_idx >= children.len() { if child_idx >= children.len() {
self.pop(); self.pop();
self.next(rdom) self.next(rdom)
@@ -155,7 +156,9 @@ impl PersistantElementIter {
ElementProduced::Progressed(self.pop()) ElementProduced::Progressed(self.pop())
} }
} }
} };
println!("next: {:?}", r);
r
} }
/// get the previous element /// get the previous element
@@ -183,17 +186,17 @@ impl PersistantElementIter {
let new_node = NodeId(0); let new_node = NodeId(0);
ElementProduced::Looped(push_back(&mut self.stack, new_node, rdom)) ElementProduced::Looped(push_back(&mut self.stack, new_node, rdom))
} else { } else {
let (last, o_child_idx) = self.stack.last_mut().unwrap(); let (last, old_child_idx) = self.stack.last_mut().unwrap();
let node = &rdom[*last]; let node = &rdom[*last];
match &node.node_data.node_type { match &node.node_data.node_type {
NodeType::Element { .. } => { NodeType::Element { .. } => {
let children = rdom.tree.children_ids(*last).unwrap(); let children = rdom.tree.children_ids(*last).unwrap();
// if we have children, go to the next child // if we have children, go to the next child
if let NodePosition::InChild(0) = o_child_idx { if let NodePosition::InChild(0) = old_child_idx {
ElementProduced::Progressed(self.pop()) ElementProduced::Progressed(self.pop())
} else { } else {
*o_child_idx = o_child_idx.map(|i| i - 1); *old_child_idx = old_child_idx.map(|i| i - 1);
if let NodePosition::InChild(child_idx) = o_child_idx { if let NodePosition::InChild(child_idx) = old_child_idx {
if *child_idx >= children.len() || children.is_empty() { if *child_idx >= children.len() || children.is_empty() {
self.pop(); self.pop();
self.prev(rdom) self.prev(rdom)