Mirrors/dioxus
2
0
Fork 0
mirror of https://github.com/DioxusLabs/dioxus synced 2024-09-21 06:41:54 +00:00
Code Issues Projects Releases Packages Wiki Activity

pass clippy

Browse source
This commit is contained in:
Evan Almloff 2022-04-17 08:43:15 -05:00
parent e9da4c0fb7
commit b79a58cc66
8 changed files with 73 additions and 81 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

90
packages/native-core-macro/src/lib.rs
View file

@ -21,9 +21,9 @@ pub fn sorted_str_slice(input: TokenStream) -> TokenStream {
#[derive(PartialEq, Debug, Clone)]
enum DepKind {
NodeDepState,
ChildDepState,
ParentDepState,
Node,
Child,
Parent,
}
#[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
.state_members
.iter()
.filter(|f| f.dep_kind == DepKind::NodeDepState)
.filter(|f| f.dep_kind == DepKind::Node)
.map(|f| f.reduce_self());
let child_dep_state_fields = state_strct
.state_members
.iter()
.filter(|f| f.dep_kind == DepKind::ChildDepState)
.filter(|f| f.dep_kind == DepKind::Child)
.map(|f| f.reduce_self());
let parent_dep_state_fields = state_strct
.state_members
.iter()
.filter(|f| f.dep_kind == DepKind::ParentDepState)
.filter(|f| f.dep_kind == DepKind::Parent)
.map(|f| f.reduce_self());
let node_iter = state_strct
.state_members
.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_clone = node_ids.clone();
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
.state_members
.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_clone = child_ids.clone();
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
.state_members
.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_clone = parent_ids.clone();
let parent_types = parent_iter.map(|f| &f.mem.ty);
@ -191,24 +191,22 @@ struct StateStruct<'a> {
impl<'a> StateStruct<'a> {
fn parse(fields: &[&'a Field], strct: &'a Struct) -> Result<Self> {
let mut parse_err = Ok(());
let state_members: Vec<_> = strct
let state_members = strct
.members
.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,
Err(err) => {
parse_err = Err(err);
None
}
})
.collect();
parse_err?;
});
#[derive(Debug, Clone)]
struct DepNode<'a> {
state_mem: StateMember<'a>,
depandants: Vec<Box<DepNode<'a>>>,
depandants: Vec<DepNode<'a>>,
}
impl<'a> DepNode<'a> {
fn new(state_mem: StateMember<'a>) -> Self {
@ -266,15 +264,14 @@ impl<'a> StateStruct<'a> {
fn kind(&self) -> Result<&DepKind> {
fn reduce_kind<'a>(dk1: &'a DepKind, dk2: &'a DepKind) -> Result<&'a DepKind> {
match (dk1, dk2) {
(DepKind::ChildDepState, DepKind::ParentDepState)
| (DepKind::ParentDepState, DepKind::ChildDepState) => Err(Error::new(
Span::call_site(),
"There is a ChildDepState that depends on a ParentDepState",
)),
// node dep state takes the lowest priority
(DepKind::NodeDepState, important) | (important, DepKind::NodeDepState) => {
Ok(important)
(DepKind::Child, DepKind::Parent) | (DepKind::Parent, DepKind::Child) => {
Err(Error::new(
Span::call_site(),
"There is a ChildDepState that depends on a ParentDepState",
))
}
// node dep state takes the lowest priority
(DepKind::Node, important) | (important, DepKind::Node) => Ok(important),
// they are the same
(fst, _) => Ok(fst),
}
@ -282,9 +279,7 @@ impl<'a> StateStruct<'a> {
reduce_kind(
self.depandants
.iter()
.try_fold(&DepKind::NodeDepState, |dk1, dk2| {
reduce_kind(dk1, dk2.kind()?)
})?,
.try_fold(&DepKind::Node, |dk1, dk2| reduce_kind(dk1, dk2.kind()?))?,
&self.state_mem.dep_kind,
)
}
@ -293,7 +288,7 @@ impl<'a> StateStruct<'a> {
let dep = other.state_mem.dep_mem.unwrap();
if self.contains_member(dep) {
if self.state_mem.mem == dep {
self.depandants.push(Box::new(other));
self.depandants.push(other);
true
} else {
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
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 {
let root_depends_on = roots
.iter()
@ -342,6 +337,7 @@ impl<'a> StateStruct<'a> {
}
roots.push(new);
}
parse_err?;
let mut current_id = 0;
for r in &mut roots {
r.set_ids(&mut current_id);
@ -351,8 +347,7 @@ impl<'a> StateStruct<'a> {
} else {
let state_members: Vec<_> = roots
.into_iter()
.map(|r| r.flatten().into_iter())
.flatten()
.flat_map(|r| r.flatten().into_iter())
.collect();
Ok(Self { state_members })
@ -417,13 +412,12 @@ impl<'a> StateMember<'a> {
let dep_kind = a
.path
.get_ident()
.map(|i| match i.to_string().as_str() {
"node_dep_state" => Some(DepKind::NodeDepState),
"child_dep_state" => Some(DepKind::ChildDepState),
"parent_dep_state" => Some(DepKind::ParentDepState),
.and_then(|i| match i.to_string().as_str() {
"node_dep_state" => Some(DepKind::Node),
"child_dep_state" => Some(DepKind::Child),
"parent_dep_state" => Some(DepKind::Parent),
_ => None,
})
.flatten()?;
})?;
match a.parse_args::<Dependancy>() {
Ok(dependancy) => {
let dep_mem = if let Some(name) = &dependancy.dep {
@ -474,27 +468,27 @@ impl<'a> StateMember<'a> {
let child_dep = self
.dependants
.iter()
.filter(|(_, kind)| kind == &DepKind::ChildDepState)
.filter(|(_, kind)| kind == &DepKind::Child)
.map(|(id, _)| id.0);
let parent_dep = self
.dependants
.iter()
.filter(|(_, kind)| kind == &DepKind::ParentDepState)
.filter(|(_, kind)| kind == &DepKind::Parent)
.map(|(id, _)| id.0);
let node_dep = self
.dependants
.iter()
.filter(|(_, kind)| kind == &DepKind::NodeDepState)
.filter(|(_, kind)| kind == &DepKind::Node)
.map(|(id, _)| id.0);
match self.dep_kind {
DepKind::NodeDepState => {
DepKind::Node => {
quote! {
dioxus_native_core::state::NodeStatesChanged{
node_dep: &[#(dioxus_native_core::state::MemberId(#node_dep), )*],
}
}
}
DepKind::ChildDepState => {
DepKind::Child => {
quote! {
dioxus_native_core::state::ChildStatesChanged{
node_dep: &[#(dioxus_native_core::state::MemberId(#node_dep), )*],
@ -502,7 +496,7 @@ impl<'a> StateMember<'a> {
}
}
}
DepKind::ParentDepState => {
DepKind::Parent => {
quote! {
dioxus_native_core::state::ParentStatesChanged{
node_dep: &[#(dioxus_native_core::state::MemberId(#node_dep), )*],
@ -519,7 +513,7 @@ impl<'a> StateMember<'a> {
let id = self.member_id.0;
if let Some(dep_ident) = &self.dep_mem.map(|m| &m.ident) {
match self.dep_kind {
DepKind::NodeDepState => {
DepKind::Node => {
quote!({
// println!("node: {:?} {:?} {:?}", self.#ident, #id, #node_view.id());
if self.#ident.reduce(#node_view, &self.#dep_ident, #get_ctx){
@ -529,7 +523,7 @@ impl<'a> StateMember<'a> {
}
})
}
DepKind::ChildDepState => {
DepKind::Child => {
quote!({
// println!("child: {:?} {:?} {:?}", self.#ident, #id, #node_view.id());
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!({
// println!("parent: {:?} {:?} {:?}", self.#ident, #id, #node_view.id());
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 {
match self.dep_kind {
DepKind::NodeDepState => {
DepKind::Node => {
quote!({
// println!("node: {:?} {:?} {:?}", self.#ident, #id, #node_view.id());
if self.#ident.reduce(#node_view, &(), #get_ctx){
@ -562,7 +556,7 @@ impl<'a> StateMember<'a> {
}
})
}
DepKind::ChildDepState => {
DepKind::Child => {
quote!({
// println!("child: {:?} {:?} {:?}", self.#ident, #id, #node_view.id());
if self.#ident.reduce(#node_view, std::iter::empty(), #get_ctx){
@ -572,7 +566,7 @@ impl<'a> StateMember<'a> {
}
})
}
DepKind::ParentDepState => {
DepKind::Parent => {
quote!({
println!("parent: {:?} {:?} {:?}", self.#ident, #id, #node_view.id());
if self.#ident.reduce(#node_view, Some(&()), #get_ctx){

8
packages/native-core/src/node_ref.rs
View file

@ -30,7 +30,7 @@ impl<'a> NodeView<'a> {
pub fn namespace(&self) -> Option<&'a str> {
self.mask
.namespace
.then(|| self.el().map(|el| el.namespace).flatten())
.then(|| self.el().and_then(|el| el.namespace))
.flatten()
}
@ -39,7 +39,7 @@ impl<'a> NodeView<'a> {
.map(|el| el.attributes)
.unwrap_or_default()
.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> {
@ -124,11 +124,11 @@ impl AttributeMask {
fn overlaps(&self, other: &Self) -> bool {
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>,
) -> bool {
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 {
if let Some(attr) = other_iter.next() {
other_attr = attr;

30
packages/native-core/src/real_dom.rs
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.
let mut to_push = nodes_updated.clone();
let mut to_push = nodes_updated;
while let Some(node_ref) = to_push.pop_front() {
let NodeRef {
id,
@ -528,10 +528,10 @@ impl<S: State> RealDom<S> {
}
// this is safe because no node will have itself as a child
pub fn get_node_children_mut<'a>(
&'a mut self,
pub fn get_node_children_mut(
&mut self,
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();
unsafe {
if id >= self.nodes.len() {
@ -546,7 +546,7 @@ impl<S: State> RealDom<S> {
.collect(),
_ => Vec::new(),
};
return Some((node, children));
Some((node, children))
} else {
None
}
@ -555,24 +555,22 @@ impl<S: State> RealDom<S> {
}
// this is safe because no node will have itself as a parent
pub fn get_node_parent_mut<'a>(
&'a mut self,
pub fn get_node_parent_mut(
&mut self,
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();
unsafe {
let node = &mut *ptr.add(id);
if id >= self.nodes.len() {
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 {
if let Some(node) = node.as_mut() {
let parent = node
.parent
.map(|id| (&mut *ptr.add(id.0)).as_mut().unwrap());
return Some((node, parent));
} else {
None
}
None
}
}
}

16
packages/native-core/src/state.rs
View file

@ -1,4 +1,4 @@
use std::fmt::Debug;
use std::{cmp::Ordering, fmt::Debug};
use anymap::AnyMap;
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 v = Vec::with_capacity(new_len_guess);
while let Some(s_i) = s_peekable.peek() {
loop {
if let Some(o_i) = o_peekable.peek() {
if o_i > s_i {
while let Some(o_i) = o_peekable.peek() {
match o_i.cmp(s_i) {
Ordering::Greater => {
break;
} else if o_i < s_i {
}
Ordering::Less => {
v.push(o_peekable.next().unwrap());
}
} else {
break;
Ordering::Equal => (),
}
}
v.push(s_peekable.next().unwrap());
}
while let Some(o_i) = o_peekable.next() {
for o_i in o_peekable {
v.push(o_i);
}
for w in v.windows(2) {

2
packages/tui/src/hooks.rs
View file

@ -161,7 +161,7 @@ impl InnerInputState {
fn update(
&mut self,
evts: &mut Vec<EventCore>,
evts: &mut [EventCore],
resolved_events: &mut Vec<UserEvent>,
layout: &Stretch,
dom: &mut Dom,

2
packages/tui/src/layout.rs
View file

@ -115,7 +115,7 @@ impl ChildDepState for StretchLayout {
}
// 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-items",
"align-self",

4
packages/tui/src/lib.rs
View file

@ -166,7 +166,7 @@ fn render_vdom(
// size is guaranteed to not change when rendering
resize(frame.size(), &mut stretch.borrow_mut(), &rdom);
let root = &rdom[0];
render::render_vnode(frame, &stretch.borrow(), &rdom, &root, cfg);
render::render_vnode(frame, &stretch.borrow(), &rdom, root, cfg);
})?;
} else {
resize(
@ -226,7 +226,7 @@ fn render_vdom(
// update the style and layout
let mut any_map = AnyMap::new();
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();
}
}

2
packages/tui/src/style_attributes.rs
View file

@ -590,7 +590,7 @@ fn apply_transition(_name: &str, _value: &str, _style: &mut StyleModifier) {
todo!()
}
const SORTED_STYLE_ATTRS: &'static [&'static str] = &sorted_str_slice!([
const SORTED_STYLE_ATTRS: &[&str] = &sorted_str_slice!([
"animation",
"animation-delay",
"animation-direction",