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

pass clippy

Browse Source
This commit is contained in:
Evan Almloff committed 2022-04-17 08:43:15 -05:00
1 parent e9da4c0fb7
commit b79a58cc66
8 files changed
+73 -81
Download Patch File Download Diff File Expand all files Collapse all files

No files matched your search

packages/native-core-macro/src/lib.rs
+42 -48
View File
@@ -21,9 +21,9 @@ pub fn sorted_str_slice(input: TokenStream) -> TokenStream {
#[derive(PartialEq, Debug, Clone)] #[derive(PartialEq, Debug, Clone)]
enum DepKind { enum DepKind {
NodeDepState, Node,
ChildDepState, Child,
ParentDepState, Parent,
} }
#[proc_macro_derive(State, attributes(node_dep_state, child_dep_state, parent_dep_state))] #[proc_macro_derive(State, attributes(node_dep_state, child_dep_state, parent_dep_state))]
@@ -50,23 +50,23 @@ fn impl_derive_macro(ast: &syn::DeriveInput) -> TokenStream {
let node_dep_state_fields = state_strct let node_dep_state_fields = state_strct
.state_members .state_members
.iter() .iter()
.filter(|f| f.dep_kind == DepKind::NodeDepState) .filter(|f| f.dep_kind == DepKind::Node)
.map(|f| f.reduce_self()); .map(|f| f.reduce_self());
let child_dep_state_fields = state_strct let child_dep_state_fields = state_strct
.state_members .state_members
.iter() .iter()
.filter(|f| f.dep_kind == DepKind::ChildDepState) .filter(|f| f.dep_kind == DepKind::Child)
.map(|f| f.reduce_self()); .map(|f| f.reduce_self());
let parent_dep_state_fields = state_strct let parent_dep_state_fields = state_strct
.state_members .state_members
.iter() .iter()
.filter(|f| f.dep_kind == DepKind::ParentDepState) .filter(|f| f.dep_kind == DepKind::Parent)
.map(|f| f.reduce_self()); .map(|f| f.reduce_self());
let node_iter = state_strct let node_iter = state_strct
.state_members .state_members
.iter() .iter()
.filter(|m| m.dep_kind == DepKind::NodeDepState); .filter(|m| m.dep_kind == DepKind::Node);
let node_ids = node_iter.clone().map(|m| m.member_id.0); let node_ids = node_iter.clone().map(|m| m.member_id.0);
let node_ids_clone = node_ids.clone(); let node_ids_clone = node_ids.clone();
let node_types = node_iter.map(|f| &f.mem.ty); let node_types = node_iter.map(|f| &f.mem.ty);
@@ -74,7 +74,7 @@ fn impl_derive_macro(ast: &syn::DeriveInput) -> TokenStream {
let child_iter = state_strct let child_iter = state_strct
.state_members .state_members
.iter() .iter()
.filter(|m| m.dep_kind == DepKind::ChildDepState); .filter(|m| m.dep_kind == DepKind::Child);
let child_ids = child_iter.clone().map(|m| m.member_id.0); let child_ids = child_iter.clone().map(|m| m.member_id.0);
let child_ids_clone = child_ids.clone(); let child_ids_clone = child_ids.clone();
let child_types = child_iter.map(|f| &f.mem.ty); let child_types = child_iter.map(|f| &f.mem.ty);
@@ -82,7 +82,7 @@ fn impl_derive_macro(ast: &syn::DeriveInput) -> TokenStream {
let parent_iter = state_strct let parent_iter = state_strct
.state_members .state_members
.iter() .iter()
.filter(|m| m.dep_kind == DepKind::ParentDepState); .filter(|m| m.dep_kind == DepKind::Parent);
let parent_ids = parent_iter.clone().map(|m| m.member_id.0); let parent_ids = parent_iter.clone().map(|m| m.member_id.0);
let parent_ids_clone = parent_ids.clone(); let parent_ids_clone = parent_ids.clone();
let parent_types = parent_iter.map(|f| &f.mem.ty); let parent_types = parent_iter.map(|f| &f.mem.ty);
@@ -191,24 +191,22 @@ struct StateStruct<'a> {
impl<'a> StateStruct<'a> { impl<'a> StateStruct<'a> {
fn parse(fields: &[&'a Field], strct: &'a Struct) -> Result<Self> { fn parse(fields: &[&'a Field], strct: &'a Struct) -> Result<Self> {
let mut parse_err = Ok(()); let mut parse_err = Ok(());
let state_members: Vec<_> = strct let state_members = strct
.members .members
.iter() .iter()
.zip(fields.iter()) .zip(fields.iter())
.filter_map(|(m, f)| match StateMember::parse(f, m, &strct) { .filter_map(|(m, f)| match StateMember::parse(f, m, strct) {
Ok(m) => m, Ok(m) => m,
Err(err) => { Err(err) => {
parse_err = Err(err); parse_err = Err(err);
None None
} }
}) });
.collect();
parse_err?;
#[derive(Debug, Clone)] #[derive(Debug, Clone)]
struct DepNode<'a> { struct DepNode<'a> {
state_mem: StateMember<'a>, state_mem: StateMember<'a>,
depandants: Vec<Box<DepNode<'a>>>, depandants: Vec<DepNode<'a>>,
} }
impl<'a> DepNode<'a> { impl<'a> DepNode<'a> {
fn new(state_mem: StateMember<'a>) -> Self { fn new(state_mem: StateMember<'a>) -> Self {
@@ -266,15 +264,14 @@ impl<'a> StateStruct<'a> {
fn kind(&self) -> Result<&DepKind> { fn kind(&self) -> Result<&DepKind> {
fn reduce_kind<'a>(dk1: &'a DepKind, dk2: &'a DepKind) -> Result<&'a DepKind> { fn reduce_kind<'a>(dk1: &'a DepKind, dk2: &'a DepKind) -> Result<&'a DepKind> {
match (dk1, dk2) { match (dk1, dk2) {
(DepKind::ChildDepState, DepKind::ParentDepState) (DepKind::Child, DepKind::Parent) | (DepKind::Parent, DepKind::Child) => {
| (DepKind::ParentDepState, DepKind::ChildDepState) => Err(Error::new( Err(Error::new(
Span::call_site(), Span::call_site(),
"There is a ChildDepState that depends on a ParentDepState", "There is a ChildDepState that depends on a ParentDepState",
)), ))
// node dep state takes the lowest priority
(DepKind::NodeDepState, important) | (important, DepKind::NodeDepState) => {
Ok(important)
} }
// node dep state takes the lowest priority
(DepKind::Node, important) | (important, DepKind::Node) => Ok(important),
// they are the same // they are the same
(fst, _) => Ok(fst), (fst, _) => Ok(fst),
} }
@@ -282,9 +279,7 @@ impl<'a> StateStruct<'a> {
reduce_kind( reduce_kind(
self.depandants self.depandants
.iter() .iter()
.try_fold(&DepKind::NodeDepState, |dk1, dk2| { .try_fold(&DepKind::Node, |dk1, dk2| reduce_kind(dk1, dk2.kind()?))?,
reduce_kind(dk1, dk2.kind()?)
})?,
&self.state_mem.dep_kind, &self.state_mem.dep_kind,
) )
} }
@@ -293,7 +288,7 @@ impl<'a> StateStruct<'a> {
let dep = other.state_mem.dep_mem.unwrap(); let dep = other.state_mem.dep_mem.unwrap();
if self.contains_member(dep) { if self.contains_member(dep) {
if self.state_mem.mem == dep { if self.state_mem.mem == dep {
self.depandants.push(Box::new(other)); self.depandants.push(other);
true true
} else { } else {
self.depandants self.depandants
@@ -310,7 +305,7 @@ impl<'a> StateStruct<'a> {
// members need to be sorted so that members are updated after the members they depend on // members need to be sorted so that members are updated after the members they depend on
let mut roots: Vec<DepNode> = vec![]; let mut roots: Vec<DepNode> = vec![];
for m in state_members.into_iter() { for m in state_members {
if let Some(dep) = m.dep_mem { if let Some(dep) = m.dep_mem {
let root_depends_on = roots let root_depends_on = roots
.iter() .iter()
@@ -342,6 +337,7 @@ impl<'a> StateStruct<'a> {
} }
roots.push(new); roots.push(new);
} }
parse_err?;
let mut current_id = 0; let mut current_id = 0;
for r in &mut roots { for r in &mut roots {
r.set_ids(&mut current_id); r.set_ids(&mut current_id);
@@ -351,8 +347,7 @@ impl<'a> StateStruct<'a> {
} else { } else {
let state_members: Vec<_> = roots let state_members: Vec<_> = roots
.into_iter() .into_iter()
.map(|r| r.flatten().into_iter()) .flat_map(|r| r.flatten().into_iter())
.flatten()
.collect(); .collect();
Ok(Self { state_members }) Ok(Self { state_members })
@@ -417,13 +412,12 @@ impl<'a> StateMember<'a> {
let dep_kind = a let dep_kind = a
.path .path
.get_ident() .get_ident()
.map(|i| match i.to_string().as_str() { .and_then(|i| match i.to_string().as_str() {
"node_dep_state" => Some(DepKind::NodeDepState), "node_dep_state" => Some(DepKind::Node),
"child_dep_state" => Some(DepKind::ChildDepState), "child_dep_state" => Some(DepKind::Child),
"parent_dep_state" => Some(DepKind::ParentDepState), "parent_dep_state" => Some(DepKind::Parent),
_ => None, _ => None,
}) })?;
.flatten()?;
match a.parse_args::<Dependancy>() { match a.parse_args::<Dependancy>() {
Ok(dependancy) => { Ok(dependancy) => {
let dep_mem = if let Some(name) = &dependancy.dep { let dep_mem = if let Some(name) = &dependancy.dep {
@@ -474,27 +468,27 @@ impl<'a> StateMember<'a> {
let child_dep = self let child_dep = self
.dependants .dependants
.iter() .iter()
.filter(|(_, kind)| kind == &DepKind::ChildDepState) .filter(|(_, kind)| kind == &DepKind::Child)
.map(|(id, _)| id.0); .map(|(id, _)| id.0);
let parent_dep = self let parent_dep = self
.dependants .dependants
.iter() .iter()
.filter(|(_, kind)| kind == &DepKind::ParentDepState) .filter(|(_, kind)| kind == &DepKind::Parent)
.map(|(id, _)| id.0); .map(|(id, _)| id.0);
let node_dep = self let node_dep = self
.dependants .dependants
.iter() .iter()
.filter(|(_, kind)| kind == &DepKind::NodeDepState) .filter(|(_, kind)| kind == &DepKind::Node)
.map(|(id, _)| id.0); .map(|(id, _)| id.0);
match self.dep_kind { match self.dep_kind {
DepKind::NodeDepState => { DepKind::Node => {
quote! { quote! {
dioxus_native_core::state::NodeStatesChanged{ dioxus_native_core::state::NodeStatesChanged{
node_dep: &[#(dioxus_native_core::state::MemberId(#node_dep), )*], node_dep: &[#(dioxus_native_core::state::MemberId(#node_dep), )*],
} }
} }
} }
DepKind::ChildDepState => { DepKind::Child => {
quote! { quote! {
dioxus_native_core::state::ChildStatesChanged{ dioxus_native_core::state::ChildStatesChanged{
node_dep: &[#(dioxus_native_core::state::MemberId(#node_dep), )*], node_dep: &[#(dioxus_native_core::state::MemberId(#node_dep), )*],
@@ -502,7 +496,7 @@ impl<'a> StateMember<'a> {
} }
} }
} }
DepKind::ParentDepState => { DepKind::Parent => {
quote! { quote! {
dioxus_native_core::state::ParentStatesChanged{ dioxus_native_core::state::ParentStatesChanged{
node_dep: &[#(dioxus_native_core::state::MemberId(#node_dep), )*], node_dep: &[#(dioxus_native_core::state::MemberId(#node_dep), )*],
@@ -519,7 +513,7 @@ impl<'a> StateMember<'a> {
let id = self.member_id.0; let id = self.member_id.0;
if let Some(dep_ident) = &self.dep_mem.map(|m| &m.ident) { if let Some(dep_ident) = &self.dep_mem.map(|m| &m.ident) {
match self.dep_kind { match self.dep_kind {
DepKind::NodeDepState => { DepKind::Node => {
quote!({ quote!({
// println!("node: {:?} {:?} {:?}", self.#ident, #id, #node_view.id()); // println!("node: {:?} {:?} {:?}", self.#ident, #id, #node_view.id());
if self.#ident.reduce(#node_view, &self.#dep_ident, #get_ctx){ if self.#ident.reduce(#node_view, &self.#dep_ident, #get_ctx){
@@ -529,7 +523,7 @@ impl<'a> StateMember<'a> {
} }
}) })
} }
DepKind::ChildDepState => { DepKind::Child => {
quote!({ quote!({
// println!("child: {:?} {:?} {:?}", self.#ident, #id, #node_view.id()); // println!("child: {:?} {:?} {:?}", self.#ident, #id, #node_view.id());
if self.#ident.reduce(#node_view, children.iter().map(|s| &s.#dep_ident), #get_ctx){ if self.#ident.reduce(#node_view, children.iter().map(|s| &s.#dep_ident), #get_ctx){
@@ -539,7 +533,7 @@ impl<'a> StateMember<'a> {
} }
}) })
} }
DepKind::ParentDepState => { DepKind::Parent => {
quote!({ quote!({
// println!("parent: {:?} {:?} {:?}", self.#ident, #id, #node_view.id()); // println!("parent: {:?} {:?} {:?}", self.#ident, #id, #node_view.id());
if self.#ident.reduce(#node_view, parent.as_ref().map(|p| &p.#dep_ident), #get_ctx){ if self.#ident.reduce(#node_view, parent.as_ref().map(|p| &p.#dep_ident), #get_ctx){
@@ -552,7 +546,7 @@ impl<'a> StateMember<'a> {
} }
} else { } else {
match self.dep_kind { match self.dep_kind {
DepKind::NodeDepState => { DepKind::Node => {
quote!({ quote!({
// println!("node: {:?} {:?} {:?}", self.#ident, #id, #node_view.id()); // println!("node: {:?} {:?} {:?}", self.#ident, #id, #node_view.id());
if self.#ident.reduce(#node_view, &(), #get_ctx){ if self.#ident.reduce(#node_view, &(), #get_ctx){
@@ -562,7 +556,7 @@ impl<'a> StateMember<'a> {
} }
}) })
} }
DepKind::ChildDepState => { DepKind::Child => {
quote!({ quote!({
// println!("child: {:?} {:?} {:?}", self.#ident, #id, #node_view.id()); // println!("child: {:?} {:?} {:?}", self.#ident, #id, #node_view.id());
if self.#ident.reduce(#node_view, std::iter::empty(), #get_ctx){ if self.#ident.reduce(#node_view, std::iter::empty(), #get_ctx){
@@ -572,7 +566,7 @@ impl<'a> StateMember<'a> {
} }
}) })
} }
DepKind::ParentDepState => { DepKind::Parent => {
quote!({ quote!({
println!("parent: {:?} {:?} {:?}", self.#ident, #id, #node_view.id()); println!("parent: {:?} {:?} {:?}", self.#ident, #id, #node_view.id());
if self.#ident.reduce(#node_view, Some(&()), #get_ctx){ if self.#ident.reduce(#node_view, Some(&()), #get_ctx){
packages/native-core/src/node_ref.rs
+4 -4
View File
@@ -30,7 +30,7 @@ impl<'a> NodeView<'a> {
pub fn namespace(&self) -> Option<&'a str> { pub fn namespace(&self) -> Option<&'a str> {
self.mask self.mask
.namespace .namespace
.then(|| self.el().map(|el| el.namespace).flatten()) .then(|| self.el().and_then(|el| el.namespace))
.flatten() .flatten()
} }
@@ -39,7 +39,7 @@ impl<'a> NodeView<'a> {
.map(|el| el.attributes) .map(|el| el.attributes)
.unwrap_or_default() .unwrap_or_default()
.iter() .iter()
.filter(|a| self.mask.attritutes.contains_attribute(&a.name)) .filter(|a| self.mask.attritutes.contains_attribute(a.name))
} }
pub fn text(&self) -> Option<&str> { pub fn text(&self) -> Option<&str> {
@@ -124,11 +124,11 @@ impl AttributeMask {
fn overlaps(&self, other: &Self) -> bool { fn overlaps(&self, other: &Self) -> bool {
fn overlaps_iter( fn overlaps_iter(
mut self_iter: impl Iterator<Item = &'static str>, self_iter: impl Iterator<Item = &'static str>,
mut other_iter: impl Iterator<Item = &'static str>, mut other_iter: impl Iterator<Item = &'static str>,
) -> bool { ) -> bool {
if let Some(mut other_attr) = other_iter.next() { if let Some(mut other_attr) = other_iter.next() {
while let Some(self_attr) = self_iter.next() { for self_attr in self_iter {
while other_attr < self_attr { while other_attr < self_attr {
if let Some(attr) = other_iter.next() { if let Some(attr) = other_iter.next() {
other_attr = attr; other_attr = attr;
packages/native-core/src/real_dom.rs
+14 -16
View File
@@ -390,7 +390,7 @@ impl<S: State> RealDom<S> {
} }
// push down state. To avoid calling reduce more times than nessisary start from the top and go down. // push down state. To avoid calling reduce more times than nessisary start from the top and go down.
let mut to_push = nodes_updated.clone(); let mut to_push = nodes_updated;
while let Some(node_ref) = to_push.pop_front() { while let Some(node_ref) = to_push.pop_front() {
let NodeRef { let NodeRef {
id, id,
@@ -528,10 +528,10 @@ impl<S: State> RealDom<S> {
} }
// this is safe because no node will have itself as a child // this is safe because no node will have itself as a child
pub fn get_node_children_mut<'a>( pub fn get_node_children_mut(
&'a mut self, &mut self,
id: usize, id: usize,
) -> Option<(&'a mut Node<S>, Vec<&'a mut Node<S>>)> { ) -> Option<(&mut Node<S>, Vec<&mut Node<S>>)> {
let ptr = self.nodes.as_mut_ptr(); let ptr = self.nodes.as_mut_ptr();
unsafe { unsafe {
if id >= self.nodes.len() { if id >= self.nodes.len() {
@@ -546,7 +546,7 @@ impl<S: State> RealDom<S> {
.collect(), .collect(),
_ => Vec::new(), _ => Vec::new(),
}; };
return Some((node, children)); Some((node, children))
} else { } else {
None None
} }
@@ -555,24 +555,22 @@ impl<S: State> RealDom<S> {
} }
// this is safe because no node will have itself as a parent // this is safe because no node will have itself as a parent
pub fn get_node_parent_mut<'a>( pub fn get_node_parent_mut(
&'a mut self, &mut self,
id: usize, id: usize,
) -> Option<(&'a mut Node<S>, Option<&'a mut Node<S>>)> { ) -> Option<(&mut Node<S>, Option<&mut Node<S>>)> {
let ptr = self.nodes.as_mut_ptr(); let ptr = self.nodes.as_mut_ptr();
unsafe { unsafe {
let node = &mut *ptr.add(id); let node = &mut *ptr.add(id);
if id >= self.nodes.len() { if id >= self.nodes.len() {
None None
} else if let Some(node) = node.as_mut() {
let parent = node
.parent
.map(|id| (&mut *ptr.add(id.0)).as_mut().unwrap());
Some((node, parent))
} else { } else {
if let Some(node) = node.as_mut() { None
let parent = node
.parent
.map(|id| (&mut *ptr.add(id.0)).as_mut().unwrap());
return Some((node, parent));
} else {
None
}
} }
} }
} }
packages/native-core/src/state.rs
+8 -8
View File
@@ -1,4 +1,4 @@
use std::fmt::Debug; use std::{cmp::Ordering, fmt::Debug};
use anymap::AnyMap; use anymap::AnyMap;
use dioxus_core::VNode; use dioxus_core::VNode;
@@ -14,20 +14,20 @@ pub(crate) fn union_ordered_iter<T: Ord + Debug>(
let mut o_peekable = o_iter.peekable(); let mut o_peekable = o_iter.peekable();
let mut v = Vec::with_capacity(new_len_guess); let mut v = Vec::with_capacity(new_len_guess);
while let Some(s_i) = s_peekable.peek() { while let Some(s_i) = s_peekable.peek() {
loop { while let Some(o_i) = o_peekable.peek() {
if let Some(o_i) = o_peekable.peek() { match o_i.cmp(s_i) {
if o_i > s_i { Ordering::Greater => {
break; break;
} else if o_i < s_i { }
Ordering::Less => {
v.push(o_peekable.next().unwrap()); v.push(o_peekable.next().unwrap());
} }
} else { Ordering::Equal => (),
break;
} }
} }
v.push(s_peekable.next().unwrap()); v.push(s_peekable.next().unwrap());
} }
while let Some(o_i) = o_peekable.next() { for o_i in o_peekable {
v.push(o_i); v.push(o_i);
} }
for w in v.windows(2) { for w in v.windows(2) {
packages/tui/src/hooks.rs
+1 -1
View File
@@ -161,7 +161,7 @@ impl InnerInputState {
fn update( fn update(
&mut self, &mut self,
evts: &mut Vec<EventCore>, evts: &mut [EventCore],
resolved_events: &mut Vec<UserEvent>, resolved_events: &mut Vec<UserEvent>,
layout: &Stretch, layout: &Stretch,
dom: &mut Dom, dom: &mut Dom,
packages/tui/src/layout.rs
+1 -1
View File
@@ -115,7 +115,7 @@ impl ChildDepState for StretchLayout {
} }
// these are the attributes in layout_attiributes in native-core // these are the attributes in layout_attiributes in native-core
const SORTED_LAYOUT_ATTRS: &'static [&'static str] = &sorted_str_slice!([ const SORTED_LAYOUT_ATTRS: &[&str] = &sorted_str_slice!([
"align-content", "align-content",
"align-items", "align-items",
"align-self", "align-self",
packages/tui/src/lib.rs
+2 -2
View File
@@ -166,7 +166,7 @@ fn render_vdom(
// size is guaranteed to not change when rendering // size is guaranteed to not change when rendering
resize(frame.size(), &mut stretch.borrow_mut(), &rdom); resize(frame.size(), &mut stretch.borrow_mut(), &rdom);
let root = &rdom[0]; let root = &rdom[0];
render::render_vnode(frame, &stretch.borrow(), &rdom, &root, cfg); render::render_vnode(frame, &stretch.borrow(), &rdom, root, cfg);
})?; })?;
} else { } else {
resize( resize(
@@ -226,7 +226,7 @@ fn render_vdom(
// update the style and layout // update the style and layout
let mut any_map = AnyMap::new(); let mut any_map = AnyMap::new();
any_map.insert(stretch.clone()); any_map.insert(stretch.clone());
let _to_rerender = rdom.update_state(&vdom, to_update, any_map).unwrap(); let _to_rerender = rdom.update_state(vdom, to_update, any_map).unwrap();
} }
} }
packages/tui/src/style_attributes.rs
+1 -1
View File
@@ -590,7 +590,7 @@ fn apply_transition(_name: &str, _value: &str, _style: &mut StyleModifier) {
todo!() todo!()
} }
const SORTED_STYLE_ATTRS: &'static [&'static str] = &sorted_str_slice!([ const SORTED_STYLE_ATTRS: &[&str] = &sorted_str_slice!([
"animation", "animation",
"animation-delay", "animation-delay",
"animation-direction", "animation-direction",