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

fix typo varient -> variant (#2056)

Browse Source
This commit is contained in:
Konstantin Kostiuk authored and GitHub committed 2024-03-11 17:03:34 -05:00
1 parent 29b9375fbd
commit a4de322821
4 files changed
+46 -46
Download Patch File Download Diff File Expand all files Collapse all files

No files matched your search

packages/native-core/src/real_dom.rs
+1 -1
View File
@@ -108,7 +108,7 @@ type AttributeWatchers<V> = Arc<RwLock<Vec<Box<dyn AttributeWatcher<V> + Send +
/// 4) Call [RealDom::update_state] to update the state of incrementally computed values on each node /// 4) Call [RealDom::update_state] to update the state of incrementally computed values on each node
/// ///
/// # Custom attribute values /// # Custom attribute values
/// To allow custom values to be passed into attributes implement FromAnyValue on a type that can represent your custom value and specify the V generic to be that type. If you have many different custom values, it can be useful to use a enum type to represent the varients. /// To allow custom values to be passed into attributes implement FromAnyValue on a type that can represent your custom value and specify the V generic to be that type. If you have many different custom values, it can be useful to use a enum type to represent the variants.
pub struct RealDom<V: FromAnyValue + Send + Sync = ()> { pub struct RealDom<V: FromAnyValue + Send + Sync = ()> {
pub(crate) world: World, pub(crate) world: World,
nodes_listening: FxHashMap<String, FxHashSet<NodeId>>, nodes_listening: FxHashMap<String, FxHashSet<NodeId>>,
packages/router-macro/src/route_tree.rs
+35 -35
View File
@@ -153,8 +153,8 @@ impl<'a> RouteTree<'a> {
segment, segment,
children: Vec::new(), children: Vec::new(),
error_variant: StaticErrorVariant { error_variant: StaticErrorVariant {
varient_parse_error: nest.error_ident(), variant_parse_error: nest.error_ident(),
enum_varient: nest.error_variant(), enum_variant: nest.error_variant(),
}, },
index, index,
}; };
@@ -254,8 +254,8 @@ impl<'a> RouteTree<'a> {
#[derive(Debug, Clone)] #[derive(Debug, Clone)]
pub struct StaticErrorVariant { pub struct StaticErrorVariant {
varient_parse_error: Ident, variant_parse_error: Ident,
enum_varient: Ident, enum_variant: Ident,
} }
// First deduplicate the routes by the static part of the route // First deduplicate the routes by the static part of the route
@@ -290,8 +290,8 @@ impl<'a> RouteTreeSegmentData<'a> {
index, index,
error_variant: error_variant:
StaticErrorVariant { StaticErrorVariant {
varient_parse_error, variant_parse_error,
enum_varient, enum_variant,
}, },
} => { } => {
let children = children.iter().map(|child| { let children = children.iter().map(|child| {
@@ -318,7 +318,7 @@ impl<'a> RouteTreeSegmentData<'a> {
#(#children)* #(#children)*
} }
else { else {
errors.push(#error_enum_name::#enum_varient(#varient_parse_error::#error_ident(segment.to_string()))) errors.push(#error_enum_name::#enum_variant(#variant_parse_error::#error_ident(segment.to_string())))
} }
} }
} }
@@ -326,8 +326,8 @@ impl<'a> RouteTreeSegmentData<'a> {
} }
RouteTreeSegmentData::Route(route) => { RouteTreeSegmentData::Route(route) => {
// At this point, we have matched all static segments, so we can just check if the remaining segments match the route // At this point, we have matched all static segments, so we can just check if the remaining segments match the route
let varient_parse_error = route.error_ident(); let variant_parse_error = route.error_ident();
let enum_varient = &route.route_name; let enum_variant = &route.route_name;
let route_segments = route let route_segments = route
.segments .segments
@@ -353,13 +353,13 @@ impl<'a> RouteTreeSegmentData<'a> {
insure_not_trailing, insure_not_trailing,
construct_variant, construct_variant,
&error_enum_name, &error_enum_name,
enum_varient, enum_variant,
&varient_parse_error, &variant_parse_error,
parse_query, parse_query,
), ),
&error_enum_name, &error_enum_name,
enum_varient, enum_variant,
&varient_parse_error, &variant_parse_error,
); );
match &route.ty { match &route.ty {
@@ -374,7 +374,7 @@ impl<'a> RouteTreeSegmentData<'a> {
trailing += "/"; trailing += "/";
} }
trailing.pop(); trailing.pop();
match #ty::from_str(&trailing).map_err(|err| #error_enum_name::#enum_varient(#varient_parse_error::ChildRoute(err))) { match #ty::from_str(&trailing).map_err(|err| #error_enum_name::#enum_variant(#variant_parse_error::ChildRoute(err))) {
Ok(#child_name) => { Ok(#child_name) => {
#print_route_segment #print_route_segment
} }
@@ -389,8 +389,8 @@ impl<'a> RouteTreeSegmentData<'a> {
} }
Self::Nest { nest, children } => { Self::Nest { nest, children } => {
// At this point, we have matched all static segments, so we can just check if the remaining segments match the route // At this point, we have matched all static segments, so we can just check if the remaining segments match the route
let varient_parse_error: Ident = nest.error_ident(); let variant_parse_error: Ident = nest.error_ident();
let enum_varient = nest.error_variant(); let enum_variant = nest.error_variant();
let route_segments = nest let route_segments = nest
.segments .segments
@@ -410,14 +410,14 @@ impl<'a> RouteTreeSegmentData<'a> {
route_segments.peekable(), route_segments.peekable(),
parse_children, parse_children,
&error_enum_name, &error_enum_name,
&enum_varient, &enum_variant,
&varient_parse_error, &variant_parse_error,
) )
} }
Self::Redirect(redirect) => { Self::Redirect(redirect) => {
// At this point, we have matched all static segments, so we can just check if the remaining segments match the route // At this point, we have matched all static segments, so we can just check if the remaining segments match the route
let varient_parse_error = redirect.error_ident(); let variant_parse_error = redirect.error_ident();
let enum_varient = &redirect.error_variant(); let enum_variant = &redirect.error_variant();
let route_segments = redirect let route_segments = redirect
.segments .segments
@@ -451,13 +451,13 @@ impl<'a> RouteTreeSegmentData<'a> {
insure_not_trailing, insure_not_trailing,
return_redirect, return_redirect,
&error_enum_name, &error_enum_name,
enum_varient, enum_variant,
&varient_parse_error, &variant_parse_error,
parse_query, parse_query,
), ),
&error_enum_name, &error_enum_name,
enum_varient, enum_variant,
&varient_parse_error, &variant_parse_error,
) )
} }
} }
@@ -468,23 +468,23 @@ fn print_route_segment<'a, I: Iterator<Item = (usize, &'a RouteSegment)>>(
mut s: std::iter::Peekable<I>, mut s: std::iter::Peekable<I>,
sucess_tokens: TokenStream, sucess_tokens: TokenStream,
error_enum_name: &Ident, error_enum_name: &Ident,
enum_varient: &Ident, enum_variant: &Ident,
varient_parse_error: &Ident, variant_parse_error: &Ident,
) -> TokenStream { ) -> TokenStream {
if let Some((i, route)) = s.next() { if let Some((i, route)) = s.next() {
let children = print_route_segment( let children = print_route_segment(
s, s,
sucess_tokens, sucess_tokens,
error_enum_name, error_enum_name,
enum_varient, enum_variant,
varient_parse_error, variant_parse_error,
); );
route.try_parse( route.try_parse(
i, i,
error_enum_name, error_enum_name,
enum_varient, enum_variant,
varient_parse_error, variant_parse_error,
children, children,
) )
} else { } else {
@@ -498,8 +498,8 @@ fn return_constructed(
insure_not_trailing: bool, insure_not_trailing: bool,
construct_variant: TokenStream, construct_variant: TokenStream,
error_enum_name: &Ident, error_enum_name: &Ident,
enum_varient: &Ident, enum_variant: &Ident,
varient_parse_error: &Ident, variant_parse_error: &Ident,
parse_query: TokenStream, parse_query: TokenStream,
) -> TokenStream { ) -> TokenStream {
if insure_not_trailing { if insure_not_trailing {
@@ -523,7 +523,7 @@ fn return_constructed(
trailing += "/"; trailing += "/";
} }
trailing.pop(); trailing.pop();
errors.push(#error_enum_name::#enum_varient(#varient_parse_error::ExtraSegments(trailing))) errors.push(#error_enum_name::#enum_variant(#variant_parse_error::ExtraSegments(trailing)))
} }
} }
} }
@@ -595,8 +595,8 @@ impl<'a> PathIter<'a> {
fn error_variant(&self) -> StaticErrorVariant { fn error_variant(&self) -> StaticErrorVariant {
StaticErrorVariant { StaticErrorVariant {
varient_parse_error: self.error_ident.clone(), variant_parse_error: self.error_ident.clone(),
enum_varient: self.error_variant.clone(), enum_variant: self.error_variant.clone(),
} }
} }
} }
packages/router-macro/src/segment.rs
+5 -5
View File
@@ -48,7 +48,7 @@ impl RouteSegment {
&self, &self,
idx: usize, idx: usize,
error_enum_name: &Ident, error_enum_name: &Ident,
error_enum_varient: &Ident, error_enum_variant: &Ident,
inner_parse_enum: &Ident, inner_parse_enum: &Ident,
parse_children: TokenStream2, parse_children: TokenStream2,
) -> TokenStream2 { ) -> TokenStream2 {
@@ -63,7 +63,7 @@ impl RouteSegment {
let parsed = if let Some(#segment) = segment { let parsed = if let Some(#segment) = segment {
Ok(()) Ok(())
} else { } else {
Err(#error_enum_name::#error_enum_varient(#inner_parse_enum::#error_name(segment.map(|s|s.to_string()).unwrap_or_default()))) Err(#error_enum_name::#error_enum_variant(#inner_parse_enum::#error_name(segment.map(|s|s.to_string()).unwrap_or_default())))
}; };
match parsed { match parsed {
Ok(_) => { Ok(_) => {
@@ -83,9 +83,9 @@ impl RouteSegment {
let mut segments = segments.clone(); let mut segments = segments.clone();
let segment = segments.next(); let segment = segments.next();
let parsed = if let Some(segment) = segment.as_deref() { let parsed = if let Some(segment) = segment.as_deref() {
<#ty as dioxus_router::routable::FromRouteSegment>::from_route_segment(segment).map_err(|err| #error_enum_name::#error_enum_varient(#inner_parse_enum::#error_name(err))) <#ty as dioxus_router::routable::FromRouteSegment>::from_route_segment(segment).map_err(|err| #error_enum_name::#error_enum_variant(#inner_parse_enum::#error_name(err)))
} else { } else {
Err(#error_enum_name::#error_enum_varient(#inner_parse_enum::#missing_error_name)) Err(#error_enum_name::#error_enum_variant(#inner_parse_enum::#missing_error_name))
}; };
match parsed { match parsed {
Ok(#name) => { Ok(#name) => {
@@ -107,7 +107,7 @@ impl RouteSegment {
for segment in &remaining_segments { for segment in &remaining_segments {
new_segments.push(&*segment); new_segments.push(&*segment);
} }
<#ty as dioxus_router::routable::FromRouteSegments>::from_route_segments(&new_segments).map_err(|err| #error_enum_name::#error_enum_varient(#inner_parse_enum::#error_name(err))) <#ty as dioxus_router::routable::FromRouteSegments>::from_route_segments(&new_segments).map_err(|err| #error_enum_name::#error_enum_variant(#inner_parse_enum::#error_name(err)))
}; };
match parsed { match parsed {
Ok(#name) => { Ok(#name) => {
packages/rsx/src/hot_reload/hot_reload_diff.rs
+5 -5
View File
@@ -59,9 +59,9 @@ fn find_rsx_item(
if new_item.variants.len() != old_item.variants.len() { if new_item.variants.len() != old_item.variants.len() {
return true; return true;
} }
for (new_varient, old_varient) in new_item.variants.iter().zip(old_item.variants.iter()) for (new_variant, old_variant) in new_item.variants.iter().zip(old_item.variants.iter())
{ {
match (&new_varient.discriminant, &old_varient.discriminant) { match (&new_variant.discriminant, &old_variant.discriminant) {
(Some((new_eq, new_expr)), Some((old_eq, old_expr))) => { (Some((new_eq, new_expr)), Some((old_eq, old_expr))) => {
if find_rsx_expr(new_expr, old_expr, rsx_calls) || new_eq != old_eq { if find_rsx_expr(new_expr, old_expr, rsx_calls) || new_eq != old_eq {
return true; return true;
@@ -70,9 +70,9 @@ fn find_rsx_item(
(None, None) => (), (None, None) => (),
_ => return true, _ => return true,
} }
if new_varient.attrs != old_varient.attrs if new_variant.attrs != old_variant.attrs
|| new_varient.ident != old_varient.ident || new_variant.ident != old_variant.ident
|| new_varient.fields != old_varient.fields || new_variant.fields != old_variant.fields
{ {
return true; return true;
} }