Mirrors/dioxus
2
0
Fork 0
mirror of https://github.com/DioxusLabs/dioxus synced 2024-11-23 12:43:08 +00:00
Code Issues Projects Releases Packages Wiki Activity

feat: core tests passing

Browse source
This commit is contained in:
Jonathan Kelley 2022-12-05 14:16:54 -08:00
parent b0cccce60a
commit e22923eb2d
15 changed files with 107 additions and 122 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

6
packages/core/README.md
View file

@ -41,7 +41,7 @@ fn app(cx: Scope) -> Element {
Then, we'll want to create a new VirtualDom using this app as the root component.
```rust, ingore
```rust, ignore
let mut dom = VirtualDom::new(app);
```
@ -65,9 +65,9 @@ dom.render_with_deadline(tokio::time::sleep(Duration::from_millis(16)));
If an event occurs from outside the virtualdom while waiting for work, then we can cancel the wait using a `select!` block and inject the event.
```rust
```rust, ignore
loop {
tokio::select! {
select! {
evt = real_dom.event() => dom.handle_event("click", evt.data, evt.element, evt.bubbles),
_ = dom.wait_for_work() => {}
}

35
packages/core/src/arena.rs
View file

@ -34,21 +34,22 @@ impl ElementRef {
impl VirtualDom {
pub(crate) fn next_element(&mut self, template: &VNode, path: &'static [u8]) -> ElementId {
let entry = self.elements.vacant_entry();
let id = entry.key();
entry.insert(ElementRef {
template: template as *const _ as *mut _,
path: ElementPath::Deep(path),
});
ElementId(id)
self.next(template, ElementPath::Deep(path))
}
pub(crate) fn next_root(&mut self, template: &VNode, path: usize) -> ElementId {
self.next(template, ElementPath::Root(path))
}
fn next(&mut self, template: &VNode, path: ElementPath) -> ElementId {
let entry = self.elements.vacant_entry();
let id = entry.key();
println!("claiming {:?}", id);
entry.insert(ElementRef {
template: template as *const _ as *mut _,
path: ElementPath::Root(path),
path,
});
ElementId(id)
}
@ -66,6 +67,8 @@ impl VirtualDom {
);
}
println!("Reclaiming {:?}", el.0);
self.elements.try_remove(el.0)
}
@ -100,8 +103,20 @@ impl VirtualDom {
DynamicNode::Fragment(nodes) => nodes
.into_iter()
.for_each(|node| self.drop_scope_inner(node)),
_ => {}
})
DynamicNode::Placeholder(t) => {
self.try_reclaim(t.get());
}
DynamicNode::Text(t) => {
self.try_reclaim(t.id.get());
}
});
for root in node.root_ids {
let id = root.get();
if id.0 != 0 {
self.try_reclaim(id);
}
}
}
/// Descend through the tree, removing any borrowed props and listeners

7
packages/core/src/create.rs
View file

@ -341,7 +341,7 @@ impl<'b> VirtualDom {
// If running the scope has collected some leaves and *this* component is a boundary, then handle the suspense
let boundary = match self.scopes[scope.0].has_context::<SuspenseContext>() {
Some(boundary) => unsafe { &*(boundary as *const SuspenseContext) },
Some(boundary) => boundary,
_ => return created,
};
@ -388,11 +388,6 @@ impl<'b> VirtualDom {
// Set the placeholder of the scope
self.scopes[scope.0].placeholder.set(Some(new_id));
println!(
"assigning id {:?} to path {:?}, template: {:?}",
new_id, &template.template.node_paths, template.template
);
// Since the placeholder is already in the DOM, we don't create any new nodes
self.mutations.push(AssignId {
id: new_id,

74
packages/core/src/diff.rs
View file

@ -25,53 +25,45 @@ impl<'b> VirtualDom {
.previous_frame()
.try_load_node()
.expect("Call rebuild before diffing");
let new = scope_state
.current_frame()
.try_load_node()
.expect("Call rebuild before diffing");
self.diff_maybe_node(old, new);
use RenderReturn::{Async, Sync};
match (old, new) {
(Sync(Ok(l)), Sync(Ok(r))) => self.diff_node(l, r),
// Err cases
(Sync(Ok(l)), Sync(Err(e))) => self.diff_ok_to_err(l, e),
(Sync(Err(e)), Sync(Ok(r))) => self.diff_err_to_ok(e, r),
(Sync(Err(_eo)), Sync(Err(_en))) => { /* nothing */ }
// Async
(Sync(Ok(_l)), Async(_)) => todo!(),
(Sync(Err(_e)), Async(_)) => todo!(),
(Async(_), Sync(Ok(_r))) => todo!(),
(Async(_), Sync(Err(_e))) => { /* nothing */ }
(Async(_), Async(_)) => { /* nothing */ }
};
}
self.scope_stack.pop();
}
fn diff_maybe_node(&mut self, old: &'b RenderReturn<'b>, new: &'b RenderReturn<'b>) {
use RenderReturn::{Async, Sync};
match (old, new) {
(Sync(Ok(l)), Sync(Ok(r))) => self.diff_node(l, r),
// Err cases
(Sync(Ok(l)), Sync(Err(e))) => self.diff_ok_to_err(l, e),
(Sync(Err(e)), Sync(Ok(r))) => self.diff_err_to_ok(e, r),
(Sync(Err(_eo)), Sync(Err(_en))) => { /* nothing */ }
// Async
(Sync(Ok(_l)), Async(_)) => todo!(),
(Sync(Err(_e)), Async(_)) => todo!(),
(Async(_), Sync(Ok(_r))) => todo!(),
(Async(_), Sync(Err(_e))) => { /* nothing */ }
(Async(_), Async(_)) => { /* nothing */ }
}
}
fn diff_ok_to_err(&mut self, _l: &'b VNode<'b>, _e: &anyhow::Error) {
todo!("Not yet handling error rollover")
return;
}
fn diff_err_to_ok(&mut self, _e: &anyhow::Error, _l: &'b VNode<'b>) {
todo!("Not yet handling error rollover")
return;
}
fn diff_node(&mut self, left_template: &'b VNode<'b>, right_template: &'b VNode<'b>) {
println!(
"diffing node {:#?},\n\n{:#?}",
left_template.template.name, right_template.template.name
);
if left_template.template.name != right_template.template.name {
return self.light_diff_templates(left_template, right_template);
}
println!("diffing attributs...");
for (left_attr, right_attr) in left_template
.dynamic_attrs
.iter()
@ -106,8 +98,6 @@ impl<'b> VirtualDom {
}
}
println!("diffing dyn nodes...");
for (idx, (left_node, right_node)) in left_template
.dynamic_nodes
.iter()
@ -133,8 +123,6 @@ impl<'b> VirtualDom {
};
}
println!("applying roots...");
// Make sure the roots get transferred over
for (left, right) in left_template
.root_ids
@ -153,16 +141,18 @@ impl<'b> VirtualDom {
}
fn replace_nodes_with_placeholder(&mut self, l: &'b [VNode<'b>], r: &'b Cell<ElementId>) {
// Remove the old nodes, except for one
self.remove_nodes(&l[1..]);
// Now create the new one
let first = self.replace_inner(&l[0]);
// Create the placeholder first, ensuring we get a dedicated ID for the placeholder
let placeholder = self.next_element(&l[0], &[]);
r.set(placeholder);
self.mutations
.push(Mutation::CreatePlaceholder { id: placeholder });
// Remove the old nodes, except for onea
let first = self.replace_inner(&l[0]);
self.remove_nodes(&l[1..]);
self.mutations
.push(Mutation::ReplaceWith { id: first, m: 1 });
@ -178,7 +168,6 @@ impl<'b> VirtualDom {
) {
// Replace components that have different render fns
if left.render_fn != right.render_fn {
dbg!(&left, &right);
let created = self.create_component_node(right_template, right, idx);
let head = unsafe {
self.scopes[left.scope.get().unwrap().0]
@ -396,8 +385,6 @@ impl<'b> VirtualDom {
"all siblings must be keyed or all siblings must be non-keyed"
);
println!("Diffing fragment {:?}, {:?}", old.len(), new.len());
if new_is_keyed && old_is_keyed {
self.diff_keyed_children(old, new);
} else {
@ -420,9 +407,7 @@ impl<'b> VirtualDom {
debug_assert!(!new.is_empty());
debug_assert!(!old.is_empty());
println!("Diffing non keyed children");
match dbg!(old.len().cmp(&new.len())) {
match old.len().cmp(&new.len()) {
Ordering::Greater => self.remove_nodes(&old[new.len()..]),
Ordering::Less => self.create_and_insert_after(&new[old.len()..], old.last().unwrap()),
Ordering::Equal => {}
@ -760,7 +745,8 @@ impl<'b> VirtualDom {
/// Remove these nodes from the dom
/// Wont generate mutations for the inner nodes
fn remove_nodes(&mut self, nodes: &'b [VNode<'b>]) {
nodes.iter().for_each(|node| self.remove_node(node));
// note that we iterate in reverse to unlink lists of nodes in their rough index order
nodes.iter().rev().for_each(|node| self.remove_node(node));
}
fn remove_node(&mut self, node: &'b VNode<'b>) {

2
packages/core/src/nodes.rs
View file

@ -424,6 +424,8 @@ impl<'a> IntoDynNode<'a> for VNode<'a> {
DynamicNode::Fragment(_cx.bump().alloc([self]))
}
}
// An element that's an error is currently lost into the ether
impl<'a> IntoDynNode<'a> for Element<'a> {
fn into_vnode(self, _cx: &'a ScopeState) -> DynamicNode<'a> {
match self {

15
packages/core/src/scheduler/wait.rs
View file

@ -1,5 +1,8 @@
use futures_util::FutureExt;
use std::task::{Context, Poll};
use std::{
rc::Rc,
task::{Context, Poll},
};
use crate::{
innerlude::{Mutation, Mutations, SuspenseContext},
@ -31,17 +34,13 @@ impl VirtualDom {
}
}
pub(crate) fn acquire_suspense_boundary<'a>(&self, id: ScopeId) -> &'a SuspenseContext {
let ct = self.scopes[id.0]
pub(crate) fn acquire_suspense_boundary<'a>(&self, id: ScopeId) -> Rc<SuspenseContext> {
self.scopes[id.0]
.consume_context::<SuspenseContext>()
.unwrap();
unsafe { &*(ct as *const SuspenseContext) }
.unwrap()
}
pub(crate) fn handle_suspense_wakeup(&mut self, id: SuspenseId) {
println!("suspense notified");
let leaf = self
.scheduler
.leaves

38
packages/core/src/scopes.rs
View file

@ -81,7 +81,7 @@ pub struct ScopeState {
pub(crate) hook_list: RefCell<Vec<*mut dyn Any>>,
pub(crate) hook_idx: Cell<usize>,
pub(crate) shared_contexts: RefCell<HashMap<TypeId, Box<dyn Any>>>,
pub(crate) shared_contexts: RefCell<HashMap<TypeId, Rc<dyn Any>>>,
pub(crate) tasks: Rc<Scheduler>,
pub(crate) spawned_tasks: HashSet<TaskId>,
@ -250,15 +250,17 @@ impl<'src> ScopeState {
}
/// Return any context of type T if it exists on this scope
pub fn has_context<T: 'static>(&self) -> Option<&T> {
let contextex = self.shared_contexts.borrow();
let val = contextex.get(&TypeId::of::<T>())?;
let as_concrete = val.downcast_ref::<T>()? as *const T;
Some(unsafe { &*as_concrete })
pub fn has_context<T: 'static>(&self) -> Option<Rc<T>> {
self.shared_contexts
.borrow()
.get(&TypeId::of::<T>())?
.clone()
.downcast()
.ok()
}
/// Try to retrieve a shared state with type `T` from any parent scope.
pub fn consume_context<T: 'static>(&self) -> Option<&T> {
pub fn consume_context<T: 'static>(&self) -> Option<Rc<T>> {
if let Some(this_ctx) = self.has_context() {
return Some(this_ctx);
}
@ -268,8 +270,7 @@ impl<'src> ScopeState {
// safety: all parent pointers are valid thanks to the bump arena
let parent = unsafe { &*parent_ptr };
if let Some(shared) = parent.shared_contexts.borrow().get(&TypeId::of::<T>()) {
let as_concrete = shared.downcast_ref::<T>()? as *const T;
return Some(unsafe { &*as_concrete });
return shared.clone().downcast().ok();
}
search_parent = parent.parent;
}
@ -281,7 +282,7 @@ impl<'src> ScopeState {
///
/// This is a "fundamental" operation and should only be called during initialization of a hook.
///
/// For a hook that provides the same functionality, use `use_provide_context` and `use_consume_context` instead.
/// For a hook that provides the same functionality, use `use_provide_context` and `use_context` instead.
///
/// If a state is provided that already exists, the new value will not be inserted. Instead, this method will
/// return the existing value. This behavior is chosen so shared values do not need to be `Clone`. This particular
@ -302,20 +303,15 @@ impl<'src> ScopeState {
/// render!(div { "hello {state.0}" })
/// }
/// ```
pub fn provide_context<T: 'static>(&self, value: T) -> &T {
pub fn provide_context<T: 'static>(&self, value: T) -> Rc<T> {
let mut contexts = self.shared_contexts.borrow_mut();
if !contexts.contains_key(&TypeId::of::<T>()) {
contexts.insert(TypeId::of::<T>(), Box::new(value));
}
let out = contexts
contexts.insert(TypeId::of::<T>(), Rc::new(value));
contexts
.get(&TypeId::of::<T>())
.unwrap()
.downcast_ref::<T>()
.unwrap() as *const T;
unsafe { &*out }
.clone()
.downcast()
.unwrap()
}
/// Pushes the future onto the poll queue to be polled after the component renders.

9
packages/core/src/virtual_dom.rs
View file

@ -362,8 +362,6 @@ impl VirtualDom {
let target_path = el_ref.path;
for (idx, attr) in template.dynamic_attrs.iter().enumerate() {
println!("{:?} \n {:?} \n {:?}", attr, name, element);
let this_path = template.template.attr_paths[idx];
// listeners are required to be prefixed with "on", but they come back to the virtualdom with that missing
@ -385,8 +383,6 @@ impl VirtualDom {
}
}
println!("calling listeners: {:?}", listeners);
// Now that we've accumulated all the parent attributes for the target element, call them in reverse order
// We check the bubble state between each call to see if the event has been stopped from bubbling
for listener in listeners.drain(..).rev() {
@ -403,8 +399,6 @@ impl VirtualDom {
parent_path = template.parent.and_then(|id| self.elements.get(id.0));
}
println!("all listeners exhausted");
}
/// Wait for the scheduler to have any work.
@ -527,7 +521,6 @@ impl VirtualDom {
///
/// If no suspense trees are present
pub async fn render_with_deadline(&mut self, deadline: impl Future<Output = ()>) -> Mutations {
println!("render with deadline");
pin_mut!(deadline);
loop {
@ -629,8 +622,6 @@ impl VirtualDom {
impl Drop for VirtualDom {
fn drop(&mut self) {
println!("Dropping virtualdom");
// Simply drop this scope which drops all of its children
self.drop_scope(ScopeId(0));
}

2
packages/core/tests/bubble_error.rs
View file

@ -17,7 +17,7 @@ fn app(cx: Scope) -> Element {
}
#[test]
fn it_goes() {
fn bubbles_error() {
let mut dom = VirtualDom::new(app);
let _edits = dom.rebuild().santize();

10
packages/core/tests/context_api.rs
View file

@ -29,11 +29,17 @@ fn state_shares() {
dom.mark_dirty(ScopeId(0));
_ = dom.render_immediate();
assert_eq!(dom.base_scope().consume_context::<i32>().unwrap(), &1);
assert_eq!(
dom.base_scope().consume_context::<i32>().unwrap().as_ref(),
&1
);
dom.mark_dirty(ScopeId(0));
_ = dom.render_immediate();
assert_eq!(dom.base_scope().consume_context::<i32>().unwrap(), &2);
assert_eq!(
dom.base_scope().consume_context::<i32>().unwrap().as_ref(),
&2
);
dom.mark_dirty(ScopeId(2));
assert_eq!(

8
packages/core/tests/diff_keyed_list.rs
View file

@ -320,9 +320,9 @@ fn remove_list() {
assert_eq!(
dom.render_immediate().santize().edits,
[
Remove { id: ElementId(3) },
Remove { id: ElementId(5) },
Remove { id: ElementId(4) },
Remove { id: ElementId(5) }
Remove { id: ElementId(3) },
]
);
}
@ -345,10 +345,10 @@ fn no_common_keys() {
assert_eq!(
dom.render_immediate().santize().edits,
[
Remove { id: ElementId(2) },
Remove { id: ElementId(3) },
LoadTemplate { name: "template", index: 0, id: ElementId(3) },
Remove { id: ElementId(2) },
LoadTemplate { name: "template", index: 0, id: ElementId(2) },
LoadTemplate { name: "template", index: 0, id: ElementId(3) },
LoadTemplate { name: "template", index: 0, id: ElementId(4) },
ReplaceWith { id: ElementId(1), m: 3 }
]

12
packages/core/tests/diff_unkeyed_list.rs
View file

@ -357,11 +357,11 @@ fn remove_many() {
assert_eq!(
edits.edits,
[
Remove { id: ElementId(1,) },
Remove { id: ElementId(5,) },
Remove { id: ElementId(7,) },
Remove { id: ElementId(9,) },
CreatePlaceholder { id: ElementId(9,) },
Remove { id: ElementId(7,) },
Remove { id: ElementId(5,) },
Remove { id: ElementId(1,) },
CreatePlaceholder { id: ElementId(3,) },
ReplaceWith { id: ElementId(2,), m: 1 },
]
);
@ -372,8 +372,8 @@ fn remove_many() {
edits.edits,
[
LoadTemplate { name: "template", index: 0, id: ElementId(2,) },
HydrateText { path: &[0,], value: "hello 0", id: ElementId(10,) },
ReplaceWith { id: ElementId(9,), m: 1 },
HydrateText { path: &[0,], value: "hello 0", id: ElementId(1,) },
ReplaceWith { id: ElementId(3,), m: 1 },
]
)
}

2
packages/core/tests/miri_stress.rs
View file

@ -98,7 +98,7 @@ fn memo_works_properly() {
let mut dom = VirtualDom::new(app);
_ = dom.rebuild();
todo!()
// todo!()
// dom.hard_diff(ScopeId(0));
// dom.hard_diff(ScopeId(0));
// dom.hard_diff(ScopeId(0));

1
packages/core/tests/suspense.rs
View file

@ -73,7 +73,6 @@ async fn async_text(cx: Scope<'_>) -> Element {
let age = use_future!(cx, || async {
tokio::time::sleep(std::time::Duration::from_secs(2)).await;
println!("long future completed");
1234
});

8
packages/hooks/src/usecontext.rs
View file

@ -2,16 +2,12 @@ use dioxus_core::ScopeState;
/// Consume some context in the tree
pub fn use_context<T: 'static>(cx: &ScopeState) -> Option<&T> {
match *cx.use_hook(|| cx.consume_context::<T>().map(|t| t as *const T)) {
Some(res) => Some(unsafe { &*res }),
None => None,
}
cx.use_hook(|| cx.consume_context::<T>()).as_deref()
}
/// Provide some context via the tree and return a reference to it
///
/// Once the context has been provided, it is immutable. Mutations should be done via interior mutability.
pub fn use_context_provider<T: 'static>(cx: &ScopeState, f: impl FnOnce() -> T) -> &T {
let ptr = *cx.use_hook(|| cx.provide_context(f()) as *const T);
unsafe { &*ptr }
cx.use_hook(|| cx.provide_context(f()))
}