From 98393f3a8ecab594225dd0f344e32ee7adfd3c06 Mon Sep 17 00:00:00 2001 From: tor Date: Sun, 29 Dec 2024 14:02:19 +0100 Subject: [PATCH] remove cardtype generic it seemed like a good idea at the time --- speki-cli/src/main.rs | 10 +- speki-cli/src/review.rs | 30 ++-- speki-cli/src/utils.rs | 14 +- speki-core/src/card/card_types.rs | 18 +- speki-core/src/card/mod.rs | 224 ++++++++++++------------ speki-core/src/card/serializing.rs | 44 ++--- speki-core/src/card_provider.rs | 30 ++-- speki-core/src/lib.rs | 20 +-- speki-web/src/components/backside.rs | 6 +- speki-web/src/components/cardref.rs | 18 +- speki-web/src/components/graph/mod.rs | 8 +- speki-web/src/lib.rs | 4 +- speki-web/src/overlays/card_selector.rs | 20 +-- speki-web/src/overlays/cardviewer.rs | 94 +++++----- speki-web/src/pages/browse.rs | 6 +- speki-web/src/pages/review.rs | 10 +- speki-web/src/utils.rs | 12 +- 17 files changed, 279 insertions(+), 289 deletions(-) diff --git a/speki-cli/src/main.rs b/speki-cli/src/main.rs index b0ebe5c3..6b943b6c 100644 --- a/speki-cli/src/main.rs +++ b/speki-cli/src/main.rs @@ -6,7 +6,7 @@ use incread::inc_path; use review::{review_menu, view_card}; use speki_core::{current_time, App, TimeProvider}; use speki_core::{ - AnyType, Attribute, AttributeCard, BackSide, CType, Card, CardId, ClassCard, EventCard, + CardType, Attribute, AttributeCard, BackSide, CType, Card, CardId, ClassCard, EventCard, InstanceCard, NormalCard, SimpleRecall, StatementCard, TimeStamp, UnfinishedCard, }; use utils::{ @@ -142,13 +142,13 @@ pub fn get_timestamp(front: &str) -> TimeStamp { } } -pub async fn create_card(ty: CType, app: &App) -> Option> { +pub async fn create_card(ty: CType, app: &App) -> Option { let ty = create_type(ty, app).await?; Some(app.new_any(ty).await) } -pub async fn create_type(ty: CType, app: &App) -> Option { - let any: AnyType = match ty { +pub async fn create_type(ty: CType, app: &App) -> Option { + let any: CardType = match ty { CType::Instance => new_instance(app).await?.into(), CType::Normal => new_normal()?.into(), CType::Unfinished => new_unfinished()?.into(), @@ -255,7 +255,7 @@ async fn print_card_info(app: &App, id: CardId) { let card = app.load_card(id).await.unwrap(); let dependencies = card.dependency_ids().await; - if let AnyType::Instance(ty) = card.card_type() { + if let CardType::Instance(ty) = card.card_type() { let concept = app.load_card(ty.class).await.unwrap().print().await; println!("concept: {}", concept); } diff --git a/speki-cli/src/review.rs b/speki-cli/src/review.rs index 4602b2dd..05937a29 100644 --- a/speki-cli/src/review.rs +++ b/speki-cli/src/review.rs @@ -9,7 +9,7 @@ use crate::{ use dialoguer::{theme::ColorfulTheme, Input, Select}; use rand::prelude::*; use speki_core::{ - AnyType, Attribute, AttributeCard, BackSide, Card, CardId, ClassCard, EventCard, InstanceCard, + CardType, Attribute, AttributeCard, BackSide, Card, CardId, ClassCard, EventCard, InstanceCard, StatementCard, }; use speki_dto::Recall; @@ -173,7 +173,7 @@ async fn handle_review_action(app: &App, card: CardId, action: ReviewAction) -> } } -async fn create_attribute_card(card: &Card, app: &App) -> Option { +async fn create_attribute_card(card: &Card, app: &App) -> Option { notify(format!("Which instance ?")); let instance_id = select_from_all_instance_cards(app).await?; let instance = app.load_card(instance_id).await.unwrap(); @@ -224,16 +224,16 @@ async fn handle_action(app: &App, card: CardId, action: CardAction) -> ControlFl match action { CardAction::IntoAttribute => match card.card_type() { - AnyType::Normal(_) | AnyType::Unfinished(_) => { + CardType::Normal(_) | CardType::Unfinished(_) => { if let Some(attr) = create_attribute_card(&card, app).await { card.into_type(attr).await; } } - AnyType::Attribute(_) => {} - AnyType::Instance(_) => {} - AnyType::Class(_) => {} - AnyType::Statement(_) => {} - AnyType::Event(_) => {} + CardType::Attribute(_) => {} + CardType::Instance(_) => {} + CardType::Class(_) => {} + CardType::Statement(_) => {} + CardType::Event(_) => {} }, CardAction::IntoInstance => { @@ -370,7 +370,7 @@ async fn handle_action(app: &App, card: CardId, action: CardAction) -> ControlFl } CardAction::ParentClass => { - if let AnyType::Class(class) = card.card_type() { + if let CardType::Class(class) = card.card_type() { if let Some(parent_class) = select_from_all_class_cards(app).await { if parent_class != card.id() { let mut class = class.clone(); @@ -464,7 +464,7 @@ async fn print_card(app: &App, card: CardId, mut show_backside: bool) -> Control let card = app.load_card(card).await.unwrap(); let var_name = match card.card_type() { - AnyType::Instance(instance) => match card.back_side() { + CardType::Instance(instance) => match card.back_side() { Some(_) => { let parent_class = app.load_card(instance.class).await.unwrap(); let front = format!( @@ -482,28 +482,28 @@ async fn print_card(app: &App, card: CardId, mut show_backside: bool) -> Control } }, - AnyType::Normal(_) => { + CardType::Normal(_) => { let front = card.print().await; let back = card.display_backside().await.unwrap_or_default(); (front, back) } - AnyType::Unfinished(_) => { + CardType::Unfinished(_) => { show_backside = true; let front = card.print().await; let back = String::from("card has no answer yet"); (front, back) } - AnyType::Attribute(_) => { + CardType::Attribute(_) => { let front = card.print().await; let back = card.display_backside().await.unwrap_or_default(); (front, back) } - AnyType::Class(_) => { + CardType::Class(_) => { let front = card.print().await; let back = card.display_backside().await.unwrap_or_default(); (front, back) } - AnyType::Statement(_) | AnyType::Event(_) => { + CardType::Statement(_) | CardType::Event(_) => { show_backside = true; let front = card.print().await; let back = String::default(); diff --git a/speki-cli/src/utils.rs b/speki-cli/src/utils.rs index 69719f35..9c9e1a6b 100644 --- a/speki-cli/src/utils.rs +++ b/speki-cli/src/utils.rs @@ -1,5 +1,5 @@ use dialoguer::{theme::ColorfulTheme, Input, Select}; -use speki_core::{AnyType, App, Attribute, Card, CardId}; +use speki_core::{CardType, App, Attribute, Card, CardId}; use speki_dto::AttributeId; use speki_provider::paths; use std::path::Path; @@ -17,14 +17,14 @@ pub fn notify(msg: impl Into) { } pub async fn select_from_subclass_cards(app: &App, class: CardId) -> Option { - let cards: Vec>> = app + let cards: Vec> = app .load_all_cards() .await .into_iter() .filter(|card| block_on(card.load_ancestor_classes()).contains(&class)) .collect(); - enumselector::select_item_with_formatter(cards, |card: &Arc>| { + enumselector::select_item_with_formatter(cards, |card: &Arc| { block_on(card.print()) })? .id() @@ -32,13 +32,13 @@ pub async fn select_from_subclass_cards(app: &App, class: CardId) -> Option Option { - let cards: Vec>> = app + let cards: Vec> = app .load_all_cards() .await .into_iter() .filter(|card| card.is_instance()) .collect(); - enumselector::select_item_with_formatter(cards, |card: &Arc>| { + enumselector::select_item_with_formatter(cards, |card: &Arc| { block_on(card.print()) })? .id() @@ -50,7 +50,7 @@ use std::sync::Arc; pub async fn select_from_all_class_cards(app: &App) -> Option { let cards = app.load_all_cards().await; - enumselector::select_item_with_formatter(cards, |card: &Arc>| { + enumselector::select_item_with_formatter(cards, |card: &Arc| { block_on(card.print()) })? .id() @@ -77,7 +77,7 @@ pub fn select_from_attributes(attributes: Vec) -> Option pub async fn select_from_all_cards(app: &App) -> Option { enumselector::select_item_with_formatter( app.load_all_cards().await, - |card: &Arc>| block_on(card.print()).to_owned(), + |card: &Arc| block_on(card.print()).to_owned(), )? .id() .into() diff --git a/speki-core/src/card/card_types.rs b/speki-core/src/card/card_types.rs index 0465eda8..9f267556 100644 --- a/speki-core/src/card/card_types.rs +++ b/speki-core/src/card/card_types.rs @@ -60,33 +60,33 @@ impl CardTrait for UnfinishedCard { } } -impl From for AnyType { +impl From for CardType { fn from(value: StatementCard) -> Self { Self::Statement(value) } } -impl From for AnyType { +impl From for CardType { fn from(value: NormalCard) -> Self { Self::Normal(value) } } -impl From for AnyType { +impl From for CardType { fn from(value: UnfinishedCard) -> Self { Self::Unfinished(value) } } -impl From for AnyType { +impl From for CardType { fn from(value: AttributeCard) -> Self { Self::Attribute(value) } } -impl From for AnyType { +impl From for CardType { fn from(value: InstanceCard) -> Self { Self::Instance(value) } } -impl From for AnyType { +impl From for CardType { fn from(value: ClassCard) -> Self { Self::Class(value) } @@ -204,7 +204,7 @@ impl EventCard { pub async fn valid_sub_event(&self, other: CardId, app: &App) -> bool { let other = app.load_card(other).await.unwrap(); - let AnyType::Event(other) = other.data else { + let CardType::Event(other) = other.ty else { panic!("wrong type"); }; @@ -213,7 +213,7 @@ impl EventCard { pub async fn valid_parent_event(&self, parent: CardId, app: &App) -> bool { let parent = app.load_card(parent).await.unwrap(); - let AnyType::Event(parent) = parent.data else { + let CardType::Event(parent) = parent.ty else { panic!("wrong type"); }; @@ -221,7 +221,7 @@ impl EventCard { } } -impl From for AnyType { +impl From for CardType { fn from(value: EventCard) -> Self { Self::Event(value) } diff --git a/speki-core/src/card/mod.rs b/speki-core/src/card/mod.rs index 03610685..ffd07190 100644 --- a/speki-core/src/card/mod.rs +++ b/speki-core/src/card/mod.rs @@ -80,7 +80,7 @@ impl IsSuspended { } #[derive(Debug, Clone)] -pub enum AnyType { +pub enum CardType { Instance(InstanceCard), Normal(NormalCard), Unfinished(UnfinishedCard), @@ -90,16 +90,40 @@ pub enum AnyType { Event(EventCard), } -impl AnyType { +impl CardType { + pub async fn get_dependencies(&self) -> BTreeSet { + match self { + CardType::Instance(card) => card.get_dependencies().await, + CardType::Normal(card) => card.get_dependencies().await, + CardType::Unfinished(card) => card.get_dependencies().await, + CardType::Attribute(card) => card.get_dependencies().await, + CardType::Class(card) => card.get_dependencies().await, + CardType::Statement(card) => card.get_dependencies().await, + CardType::Event(card) => card.get_dependencies().await, + } + } + + pub async fn display_front(&self) -> String { + match self { + CardType::Instance(card) => card.display_front().await, + CardType::Normal(card) => card.display_front().await, + CardType::Unfinished(card) => card.display_front().await, + CardType::Attribute(card) => card.display_front().await, + CardType::Class(card) => card.display_front().await, + CardType::Statement(card) => card.display_front().await, + CardType::Event(card) => card.display_front().await, + } + } + fn invalidate_backside(&mut self, id: CardId) { let backside = match self { - AnyType::Instance(InstanceCard { back, .. }) => back.as_mut(), - AnyType::Normal(NormalCard { back, .. }) => Some(back), - AnyType::Unfinished(_) => None, - AnyType::Attribute(AttributeCard { back, .. }) => Some(back), - AnyType::Class(ClassCard { back, .. }) => Some(back), - AnyType::Statement(_) => None, - AnyType::Event(_) => None, + CardType::Instance(InstanceCard { back, .. }) => back.as_mut(), + CardType::Normal(NormalCard { back, .. }) => Some(back), + CardType::Unfinished(_) => None, + CardType::Attribute(AttributeCard { back, .. }) => Some(back), + CardType::Class(ClassCard { back, .. }) => Some(back), + CardType::Statement(_) => None, + CardType::Event(_) => None, }; if let Some(back) = backside { @@ -112,7 +136,7 @@ impl AnyType { self.invalidate_backside(id); match self { - AnyType::Instance(InstanceCard { + CardType::Instance(InstanceCard { ref name, ref back, class, @@ -133,10 +157,10 @@ impl AnyType { } } } - AnyType::Normal(_) => {} - AnyType::Unfinished(_) => {} - AnyType::Attribute(_) => {} - AnyType::Class(ClassCard { + CardType::Normal(_) => {} + CardType::Unfinished(_) => {} + CardType::Attribute(_) => {} + CardType::Class(ClassCard { name, back, parent_class, @@ -149,33 +173,33 @@ impl AnyType { }); } } - AnyType::Statement(_) => {} - AnyType::Event(_) => {} + CardType::Statement(_) => {} + CardType::Event(_) => {} }; } pub fn type_name(&self) -> &str { match self { - AnyType::Unfinished(_) => "unfinished", - AnyType::Statement(_) => "statement", - AnyType::Attribute(_) => "attribute", - AnyType::Instance(_) => "instance", - AnyType::Normal(_) => "normal", - AnyType::Class(_) => "class", - AnyType::Event(_) => "event", + CardType::Unfinished(_) => "unfinished", + CardType::Statement(_) => "statement", + CardType::Attribute(_) => "attribute", + CardType::Instance(_) => "instance", + CardType::Normal(_) => "normal", + CardType::Class(_) => "class", + CardType::Event(_) => "event", } } /// This is mainly just so i dont forget to update the CType when the AnyType changes pub fn fieldless(&self) -> CType { match self { - AnyType::Instance(_) => CType::Instance, - AnyType::Normal(_) => CType::Normal, - AnyType::Unfinished(_) => CType::Unfinished, - AnyType::Attribute(_) => CType::Attribute, - AnyType::Class(_) => CType::Class, - AnyType::Statement(_) => CType::Statement, - AnyType::Event(_) => CType::Event, + CardType::Instance(_) => CType::Instance, + CardType::Normal(_) => CType::Normal, + CardType::Unfinished(_) => CType::Unfinished, + CardType::Attribute(_) => CType::Attribute, + CardType::Class(_) => CType::Class, + CardType::Statement(_) => CType::Statement, + CardType::Event(_) => CType::Event, } } @@ -191,20 +215,20 @@ impl AnyType { pub fn set_backside(self, new_back: BackSide, card_provider: &CardProvider) -> Self { match self { - x @ AnyType::Event(_) => x, - x @ AnyType::Instance(_) => x, - x @ AnyType::Statement(_) => x, - AnyType::Normal(NormalCard { front, .. }) => NormalCard { + x @ CardType::Event(_) => x, + x @ CardType::Instance(_) => x, + x @ CardType::Statement(_) => x, + CardType::Normal(NormalCard { front, .. }) => NormalCard { front, back: new_back, } .into(), - AnyType::Unfinished(UnfinishedCard { front }) => NormalCard { + CardType::Unfinished(UnfinishedCard { front }) => NormalCard { front, back: new_back, } .into(), - AnyType::Attribute(AttributeCard { + CardType::Attribute(AttributeCard { attribute, instance: concept_card, .. @@ -225,41 +249,13 @@ impl AnyType { } } -#[async_trait::async_trait(?Send)] -impl CardTrait for AnyType { - async fn get_dependencies(&self) -> BTreeSet { - match self { - AnyType::Instance(card) => card.get_dependencies().await, - AnyType::Normal(card) => card.get_dependencies().await, - AnyType::Unfinished(card) => card.get_dependencies().await, - AnyType::Attribute(card) => card.get_dependencies().await, - AnyType::Class(card) => card.get_dependencies().await, - AnyType::Statement(card) => card.get_dependencies().await, - AnyType::Event(card) => card.get_dependencies().await, - } - } - - async fn display_front(&self) -> String { - match self { - AnyType::Instance(card) => card.display_front().await, - AnyType::Normal(card) => card.display_front().await, - AnyType::Unfinished(card) => card.display_front().await, - AnyType::Attribute(card) => card.display_front().await, - AnyType::Class(card) => card.display_front().await, - AnyType::Statement(card) => card.display_front().await, - AnyType::Event(card) => card.display_front().await, - } - } -} - /// Represents a card that has been saved as a toml file, which is basically anywhere in the codebase /// except for when youre constructing a new card. -/// Don't save this in containers or pass to functions, rather use the Id, and get new instances of SavedCard from the cache. -/// Also, every time you mutate it, call the persist() method. +/// Every time you mutate it, call the persist() method. #[derive(Clone)] -pub struct Card { +pub struct Card { id: CardId, - data: T, + ty: CardType, dependencies: BTreeSet, tags: BTreeMap, history: Reviews, @@ -269,7 +265,7 @@ pub struct Card { last_modified: Duration, } -impl PartialEq for Card { +impl PartialEq for Card { fn eq(&self, other: &Self) -> bool { self.id == other.id } @@ -277,25 +273,25 @@ impl PartialEq for Card { use std::cmp::Ordering; -impl Ord for Card { +impl Ord for Card { fn cmp(&self, other: &Self) -> Ordering { self.id.cmp(&other.id) } } -impl PartialOrd for Card { +impl PartialOrd for Card { fn partial_cmp(&self, other: &Self) -> Option { self.id.partial_cmp(&other.id) } } -impl Eq for Card {} +impl Eq for Card {} -impl Debug for Card { +impl Debug for Card { fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { let mut s = String::new(); s.push_str(&format!("{:?}\n", self.id)); - s.push_str(&format!("{:?}\n", self.data)); + s.push_str(&format!("{:?}\n", self.ty)); write!(f, "{}", s) } @@ -303,21 +299,21 @@ impl Debug for Card { use futures::executor::block_on; -impl std::fmt::Display for Card { +impl std::fmt::Display for Card { fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - write!(f, "{}", block_on(self.data.display_front())) + write!(f, "{}", block_on(self.ty.display_front())) } } -impl AsRef for Card { +impl AsRef for Card { fn as_ref(&self) -> &CardId { &self.id } } -impl Card { - pub fn get_ty(&self) -> AnyType { - self.data.clone() +impl Card { + pub fn get_ty(&self) -> CardType { + self.ty.clone() } /// Loads all the ancestor ancestor classes @@ -422,12 +418,12 @@ impl Card { card_provider: CardProvider, recaller: Recaller, reviews: Vec, - ) -> Card { + ) -> Card { let id = CardId(raw_card.id); - Card:: { + Self { id, - data: into_any(raw_card.data, &card_provider), + ty: into_any(raw_card.data, &card_provider), dependencies: raw_card.dependencies.into_iter().map(CardId).collect(), tags: raw_card.tags, history: Reviews(reviews), @@ -442,52 +438,52 @@ impl Card { raw_card: RawCard, card_provider: CardProvider, recaller: Recaller, - ) -> Card { + ) -> Card { let id = CardId(raw_card.id); let reviews = card_provider.load_reviews(id).await; Self::from_raw_with_reviews(raw_card, card_provider, recaller, reviews.0) } - pub fn card_type(&self) -> &AnyType { - &self.data + pub fn card_type(&self) -> &CardType { + &self.ty } /// Returns the class this card belongs to (if any) pub fn parent_class(&self) -> Option { - match &self.data { - AnyType::Instance(instance) => Some(instance.class), - AnyType::Class(class) => class.parent_class, - AnyType::Normal(_) => None, - AnyType::Unfinished(_) => None, - AnyType::Attribute(_) => None, - AnyType::Statement(_) => None, - AnyType::Event(_) => None, + match &self.ty { + CardType::Instance(instance) => Some(instance.class), + CardType::Class(class) => class.parent_class, + CardType::Normal(_) => None, + CardType::Unfinished(_) => None, + CardType::Attribute(_) => None, + CardType::Statement(_) => None, + CardType::Event(_) => None, } } pub fn is_finished(&self) -> bool { - self.data.is_finished() + self.ty.is_finished() } pub fn is_class(&self) -> bool { - self.data.is_class() + self.ty.is_class() } pub fn is_instance(&self) -> bool { - self.data.is_instance() + self.ty.is_instance() } - pub async fn set_ref(mut self, reff: CardId) -> Card { + pub async fn set_ref(mut self, reff: CardId) -> Card { let backside = BackSide::Card(reff); - self.data = self.data.set_backside(backside, &self.card_provider); + self.ty = self.ty.set_backside(backside, &self.card_provider); self.persist().await; self } pub async fn rm_dependency(&mut self, dependency: CardId) -> bool { let res = self.dependencies.remove(&dependency); - self.data.remove_dep(dependency); + self.ty.remove_dep(dependency); self.persist().await; res } @@ -515,13 +511,13 @@ impl Card { pub fn back_side(&self) -> Option<&BackSide> { match self.card_type() { - AnyType::Instance(instance) => instance.back.as_ref(), - AnyType::Attribute(card) => Some(&card.back), - AnyType::Normal(card) => Some(&card.back), - AnyType::Class(card) => Some(&card.back), - AnyType::Unfinished(_) => None?, - AnyType::Statement(_) => None?, - AnyType::Event(_) => None?, + CardType::Instance(instance) => instance.back.as_ref(), + CardType::Attribute(card) => Some(&card.back), + CardType::Normal(card) => Some(&card.back), + CardType::Class(card) => Some(&card.back), + CardType::Unfinished(_) => None?, + CardType::Statement(_) => None?, + CardType::Event(_) => None?, } } @@ -529,7 +525,7 @@ impl Card { self.card_provider.remove_card(self.id).await; } - pub async fn into_type(self, data: impl Into) -> Card { + pub async fn into_type(self, data: impl Into) -> Card { let id = self.id(); let mut raw: RawCard = self.clone().into(); raw.data = from_any(data.into()); @@ -635,7 +631,7 @@ impl Card { } } -impl Card { +impl Card { pub fn history(&self) -> &Reviews { &self.history } @@ -706,7 +702,7 @@ impl Card { } pub async fn print(&self) -> String { - self.data.display_front().await + self.ty.display_front().await } pub fn reviews(&self) -> &Vec { @@ -731,7 +727,7 @@ impl Card { pub async fn dependency_ids(&self) -> BTreeSet { let mut deps = self.dependencies.clone(); - deps.extend(self.data.get_dependencies().await); + deps.extend(self.ty.get_dependencies().await); deps } @@ -741,11 +737,11 @@ impl Card { } #[async_trait(?Send)] -impl Matcher for Card { +impl Matcher for Card { #[instrument] async fn get_val(&self, key: &str) -> Option { match key { - "front" => json!(self.data.display_front().await), + "front" => json!(self.ty.display_front().await), "pending" => json!(self.is_pending()), "back" => json!(self.display_backside().await.unwrap_or_default()), "suspended" => json!(&self.is_suspended()), @@ -789,7 +785,7 @@ impl Matcher for Card { #[cfg(test)] mod tests { - use super::{AnyType, Card}; + use super::Card; use crate::{ card_provider::CardProvider, Provider, Recaller, SimpleRecall, TimeGetter, TimeProvider, }; @@ -942,7 +938,7 @@ mod tests { self.time_provider.inc(inc); } - async fn insert_card(&self) -> Card { + async fn insert_card(&self) -> Card { let raw = raw_dummy().await; let card = Card::from_raw(raw, self.card_provider.clone(), self.recaller.clone()).await; let id = card.id; diff --git a/speki-core/src/card/serializing.rs b/speki-core/src/card/serializing.rs index a5963a57..4619d72b 100644 --- a/speki-core/src/card/serializing.rs +++ b/speki-core/src/card/serializing.rs @@ -10,12 +10,12 @@ use toml::Value; use uuid::Uuid; use super::{ - AnyType, AttributeCard, Card, ClassCard, EventCard, InstanceCard, IsSuspended, NormalCard, + CardType, AttributeCard, Card, ClassCard, EventCard, InstanceCard, IsSuspended, NormalCard, StatementCard, UnfinishedCard, }; use crate::card_provider::CardProvider; -pub fn into_any(raw: RawType, card_provider: &CardProvider) -> AnyType { +pub fn into_any(raw: RawType, card_provider: &CardProvider) -> CardType { match raw.ty { CType::Instance => InstanceCard { name: raw.front.unwrap(), @@ -64,25 +64,25 @@ pub fn into_any(raw: RawType, card_provider: &CardProvider) -> AnyType { } } -pub fn from_any(ty: AnyType) -> RawType { +pub fn from_any(ty: CardType) -> RawType { let mut raw = RawType::default(); let fieldless = ty.fieldless(); raw.ty = fieldless; match ty { - AnyType::Instance(InstanceCard { name, class, back }) => { + CardType::Instance(InstanceCard { name, class, back }) => { raw.class = Some(class.into_inner()); raw.front = Some(name); raw.back = back; } - AnyType::Normal(NormalCard { front, back }) => { + CardType::Normal(NormalCard { front, back }) => { raw.front = Some(front); raw.back = Some(back); } - AnyType::Unfinished(UnfinishedCard { front }) => { + CardType::Unfinished(UnfinishedCard { front }) => { raw.front = Some(front); } - AnyType::Attribute(AttributeCard { + CardType::Attribute(AttributeCard { attribute, back, instance, @@ -92,7 +92,7 @@ pub fn from_any(ty: AnyType) -> RawType { raw.back = Some(back); raw.instance = Some(instance.into_inner()); } - AnyType::Class(ClassCard { + CardType::Class(ClassCard { name, back, parent_class, @@ -101,10 +101,10 @@ pub fn from_any(ty: AnyType) -> RawType { raw.back = Some(back); raw.class = parent_class.map(CardId::into_inner); } - AnyType::Statement(StatementCard { front }) => { + CardType::Statement(StatementCard { front }) => { raw.front = Some(front); } - AnyType::Event(EventCard { + CardType::Event(EventCard { front, start_time, end_time, @@ -120,16 +120,16 @@ pub fn from_any(ty: AnyType) -> RawType { raw } -pub fn new_raw_card(card: impl Into) -> RawCard { - let card: AnyType = card.into(); +pub fn new_raw_card(card: impl Into) -> RawCard { + let card: CardType = card.into(); match card { - AnyType::Instance(concept) => new_concept(concept), - AnyType::Normal(normal) => new_normal(normal), - AnyType::Unfinished(unfinished) => new_unfinished(unfinished), - AnyType::Attribute(attribute) => new_attribute(attribute), - AnyType::Class(class) => new_class(class), - AnyType::Statement(statement) => new_statement(statement), - AnyType::Event(event) => new_event(event), + CardType::Instance(concept) => new_concept(concept), + CardType::Normal(normal) => new_normal(normal), + CardType::Unfinished(unfinished) => new_unfinished(unfinished), + CardType::Attribute(attribute) => new_attribute(attribute), + CardType::Class(class) => new_class(class), + CardType::Statement(statement) => new_statement(statement), + CardType::Event(event) => new_event(event), } } @@ -186,11 +186,11 @@ pub fn new_normal(normal: NormalCard) -> RawCard { } } -impl From> for RawCard { - fn from(card: Card) -> Self { +impl From for RawCard { + fn from(card: Card) -> Self { RawCard { id: card.id.into_inner(), - data: from_any(card.data), + data: from_any(card.ty), dependencies: card .dependencies .into_iter() diff --git a/speki-core/src/card_provider.rs b/speki-core/src/card_provider.rs index 3c4646a4..814eb2c3 100644 --- a/speki-core/src/card_provider.rs +++ b/speki-core/src/card_provider.rs @@ -1,6 +1,4 @@ -use crate::{ - card::RecallRate, reviews::Reviews, AnyType, Attribute, Card, Provider, Recaller, TimeGetter, -}; +use crate::{card::RecallRate, reviews::Reviews, Attribute, Card, Provider, Recaller, TimeGetter}; use dioxus_logger::tracing::{info, trace}; use speki_dto::{AttributeId, CardId, RawCard, Review}; use std::future::Future; @@ -156,9 +154,9 @@ impl CardProvider { guard.reviews = rev_caches; } - pub async fn filtered_load(&self, filter: F) -> Vec>> + pub async fn filtered_load(&self, filter: F) -> Vec> where - F: Fn(Arc>) -> Fut + Send + Sync, + F: Fn(Arc) -> Fut + Send + Sync, Fut: std::future::Future, { info!("loading card ids"); @@ -185,12 +183,12 @@ impl CardProvider { filtered_cards.into_iter().filter_map(|card| card).collect() } - pub async fn load_all(&self) -> Vec>> { - let filter = |_: Arc>| async move { true }; + pub async fn load_all(&self) -> Vec> { + let filter = |_: Arc| async move { true }; self.filtered_load(filter).await } - pub async fn dependents(&self, id: CardId) -> BTreeSet>> { + pub async fn dependents(&self, id: CardId) -> BTreeSet> { trace!("dependents of: {}", id); let mut out = BTreeSet::default(); let deps = self @@ -211,7 +209,7 @@ impl CardProvider { out } - pub async fn load(&self, id: CardId) -> Option>> { + pub async fn load(&self, id: CardId) -> Option> { trace!("loading card for id: {}", id); if let (Some(card), Some(_)) = ( self.load_cached_card(id).await, @@ -248,7 +246,7 @@ impl CardProvider { self.provider.delete_card(id).await; } - pub async fn save_card(&self, card: Card) { + pub async fn save_card(&self, card: Card) { self.update_cache(Arc::new(card.clone())); let raw: RawCard = card.into(); self.provider.save_card(raw).await; @@ -272,7 +270,7 @@ impl CardProvider { } } - async fn load_uncached(&self, id: CardId) -> Option> { + async fn load_uncached(&self, id: CardId) -> Option { trace!("load uncached"); let raw_card = self.provider.load_card(id).await?; @@ -309,7 +307,7 @@ impl CardProvider { } } - async fn update_dependents(&self, card: Arc>) { + async fn update_dependents(&self, card: Arc) { trace!("updating cache dependents"); let mut guard = self.inner.write().unwrap(); for dep in card.dependency_ids().await { @@ -330,7 +328,7 @@ impl CardProvider { } } - async fn load_cached_card(&self, id: CardId) -> Option>> { + async fn load_cached_card(&self, id: CardId) -> Option> { let cached = self.load_cached_entry(id).await?; if self.check_modified { @@ -347,7 +345,7 @@ impl CardProvider { } } - fn update_cache(&self, card: Arc>) { + fn update_cache(&self, card: Arc) { trace!("updating cache for card: {}", card.id()); let now = self.time_provider.current_time(); let mut guard = self.inner.write().unwrap(); @@ -367,7 +365,7 @@ impl CardProvider { guard.reviews.insert(id, cached_reviews); } - async fn fresh_load(&self, id: CardId) -> Option>> { + async fn fresh_load(&self, id: CardId) -> Option> { let uncached = self.load_uncached(id).await?; let uncached = Arc::new(uncached); self.update_dependents(uncached.clone()).await; @@ -385,7 +383,7 @@ struct Inner { #[derive(Clone, Debug)] struct CardCache { fetched: Duration, - card: Arc>, + card: Arc, min_rec_recall: Option, } diff --git a/speki-core/src/lib.rs b/speki-core/src/lib.rs index c6af7975..8f37ded8 100644 --- a/speki-core/src/lib.rs +++ b/speki-core/src/lib.rs @@ -27,7 +27,7 @@ pub mod reviews; pub use attribute::Attribute; pub use card::Card; pub use card::{ - AnyType, AttributeCard, CardTrait, ClassCard, EventCard, InstanceCard, NormalCard, + CardType, AttributeCard, CardTrait, ClassCard, EventCard, InstanceCard, NormalCard, StatementCard, UnfinishedCard, }; pub use common::current_time; @@ -96,15 +96,15 @@ impl App { info!("cache filled in {:.4} seconds!", elapsed.as_secs_f32()); } - pub async fn load_all_cards(&self) -> Vec>> { + pub async fn load_all_cards(&self) -> Vec> { self.card_provider.load_all().await } - pub async fn save_card_not_reviews(&self, card: Card) { + pub async fn save_card_not_reviews(&self, card: Card) { self.card_provider.save_card(card).await; } - pub async fn save_card(&self, card: Card) { + pub async fn save_card(&self, card: Card) { self.card_provider .save_reviews(card.id(), card.history().clone()) .await; @@ -112,7 +112,7 @@ impl App { self.card_provider.save_card(card).await; } - pub async fn load_card(&self, id: CardId) -> Option> { + pub async fn load_card(&self, id: CardId) -> Option { trace!("loading card: {id}"); let card = self.card_provider.load(id).await; trace!("card loaded i guess: {card:?}"); @@ -150,7 +150,7 @@ impl App { } } - pub async fn cards_filtered(&self, filter: String) -> Vec>> { + pub async fn cards_filtered(&self, filter: String) -> Vec> { let cards = self.load_all_cards().await; let mut ids = vec![]; @@ -216,7 +216,7 @@ impl App { Ok(()) } - pub async fn load_class_cards(&self) -> Vec>> { + pub async fn load_class_cards(&self) -> Vec> { self.load_all_cards() .await .into_iter() @@ -233,7 +233,7 @@ impl App { let filter = { let schema = schema.clone(); - move |card: Arc>| { + move |card: Arc| { let schema = schema.clone(); async move { match &*schema { @@ -276,13 +276,13 @@ impl App { ids } - pub async fn new_from_raw(&self, raw: RawCard) -> Arc> { + pub async fn new_from_raw(&self, raw: RawCard) -> Arc { let mut card = Card::from_raw(raw, self.card_provider.clone(), self.recaller.clone()).await; card.persist().await; self.card_provider.load(card.id()).await.unwrap() } - pub async fn new_any(&self, any: impl Into) -> Card { + pub async fn new_any(&self, any: impl Into) -> Card { let raw_card = new_raw_card(any); let id = raw_card.id; let card = diff --git a/speki-web/src/components/backside.rs b/speki-web/src/components/backside.rs index 61f92af6..a636e73b 100644 --- a/speki-web/src/components/backside.rs +++ b/speki-web/src/components/backside.rs @@ -5,7 +5,7 @@ use std::{ use dioxus::prelude::*; use serde::{Deserialize, Serialize}; -use speki_core::{AnyType, Card}; +use speki_core::{CardType, Card}; use speki_dto::BackSide; use strum::{EnumIter, IntoEnumIterator}; use tracing::info; @@ -80,12 +80,12 @@ impl BackPut { } } - pub fn with_deselect(mut self, f: Arc>)>>) -> Self { + pub fn with_deselect(mut self, f: Arc)>>) -> Self { self.ref_card = self.ref_card.with_deselect(f); self } - pub fn with_closure(mut self, f: Arc>)>>) -> Self { + pub fn with_closure(mut self, f: Arc)>>) -> Self { self.ref_card = self.ref_card.with_closure(f); self } diff --git a/speki-web/src/components/cardref.rs b/speki-web/src/components/cardref.rs index 7375641e..1620c29d 100644 --- a/speki-web/src/components/cardref.rs +++ b/speki-web/src/components/cardref.rs @@ -1,7 +1,7 @@ use std::{fmt::Debug, sync::Arc}; use dioxus::prelude::*; -use speki_core::{AnyType, Card}; +use speki_core::{Card, CardType}; use speki_dto::CardId; use tracing::info; @@ -17,11 +17,11 @@ const PLACEHOLDER: &'static str = "pick card..."; pub struct CardRef { card: Signal>, display: Signal, - filter: Option bool>>>, + filter: Option bool>>>, dependent: Option, allowed: Vec, - on_select: Option>)>>>, - on_deselect: Option>)>>>, + on_select: Option)>>>, + on_deselect: Option)>>>, placeholder: Signal<&'static str>, } @@ -101,12 +101,12 @@ impl CardRef { self } - pub fn with_deselect(mut self, f: Arc>)>>) -> Self { + pub fn with_deselect(mut self, f: Arc)>>) -> Self { self.on_deselect = Some(f); self } - pub fn with_closure(mut self, f: Arc>)>>) -> Self { + pub fn with_closure(mut self, f: Arc)>>) -> Self { self.on_select = Some(f); self } @@ -121,7 +121,7 @@ impl CardRef { self } - pub fn with_filter(mut self, filter: Arc bool>>) -> Self { + pub fn with_filter(mut self, filter: Arc bool>>) -> Self { self.filter = Some(filter); self } @@ -135,7 +135,7 @@ impl CardRef { self.card.clone() } - pub async fn set_ref(&self, card: Arc>) { + pub async fn set_ref(&self, card: Arc) { let id = card.id(); self.card.clone().set(Some(id)); let display = card.print().await; @@ -146,7 +146,7 @@ impl CardRef { let _selv = self.clone(); let f = self.on_select.clone(); - let fun = move |card: Arc>| { + let fun = move |card: Arc| { let selv = _selv.clone(); if let Some(fun) = f.clone() { fun(card.clone()); diff --git a/speki-web/src/components/graph/mod.rs b/speki-web/src/components/graph/mod.rs index a3f2422f..3d3d7704 100644 --- a/speki-web/src/components/graph/mod.rs +++ b/speki-web/src/components/graph/mod.rs @@ -8,7 +8,7 @@ use std::{ use digraph::RustGraph; use dioxus::prelude::*; -use speki_core::{AnyType, Card}; +use speki_core::{CardType, Card}; use speki_dto::CardId; use speki_web::{Node, NodeMetadata}; use tracing::info; @@ -36,7 +36,7 @@ pub struct GraphRep { inner: RustGraph, is_init: Arc, cyto_id: Arc, - new_card_hook: Option>)>>>, + new_card_hook: Option)>>>, label: Option>, scope: Arc, } @@ -64,7 +64,7 @@ impl GraphRep { utils::rect(&self.cyto_id) } - pub fn with_hook(mut self, hook: Arc>)>>) -> Self { + pub fn with_hook(mut self, hook: Arc)>>) -> Self { self.new_card_hook = Some(hook); self } @@ -98,7 +98,7 @@ impl GraphRep { ); } - pub fn new_set_card(&self, card: Arc>) { + pub fn new_set_card(&self, card: Arc) { self.new_set_card_id(card.id()); } diff --git a/speki-web/src/lib.rs b/speki-web/src/lib.rs index b7b9d039..8eaa2696 100644 --- a/speki-web/src/lib.rs +++ b/speki-web/src/lib.rs @@ -1,7 +1,7 @@ use std::{cell::RefCell, collections::HashMap, sync::Arc}; use dioxus::prelude::*; -use speki_core::{AnyType, App, Card}; +use speki_core::{CardType, App, Card}; use speki_dto::{CType, CardId}; use tracing::info; use uuid::Uuid; @@ -128,7 +128,7 @@ pub struct NodeMetadata { } impl NodeMetadata { - pub async fn from_card(card: Arc>, is_origin: bool) -> Self { + pub async fn from_card(card: Arc, is_origin: bool) -> Self { let label = card.print().await; let color = match card.recall_rate() { Some(rate) => rate_to_color(rate as f64 * 100.), diff --git a/speki-web/src/overlays/card_selector.rs b/speki-web/src/overlays/card_selector.rs index d6376c95..ebd2ed4b 100644 --- a/speki-web/src/overlays/card_selector.rs +++ b/speki-web/src/overlays/card_selector.rs @@ -1,7 +1,7 @@ use std::sync::Arc; use dioxus::prelude::*; -use speki_core::{AnyType, Card}; +use speki_core::{CardType, Card}; use speki_web::Node; use tracing::info; @@ -12,8 +12,8 @@ use crate::{ APP, OVERLAY, }; -pub fn overlay_card_viewer() -> Arc>)>> { - Arc::new(Box::new(move |card: Arc>| { +pub fn overlay_card_viewer() -> Arc)>> { + Arc::new(Box::new(move |card: Arc| { spawn(async move { let graph = GraphRep::new().with_hook(overlay_card_viewer()); let viewer = CardViewer::new_from_card(card, graph).await; @@ -26,11 +26,11 @@ pub fn overlay_card_viewer() -> Arc>)>> { pub struct CardSelector { title: String, search: Signal, - on_card_selected: Arc>)>>, + on_card_selected: Arc)>>, cards: Signal>, allow_new: bool, done: Signal, - filter: Option bool>>>, + filter: Option bool>>>, dependents: Signal>, allowed_cards: Vec, } @@ -57,9 +57,9 @@ impl CardSelector { } pub async fn ref_picker( - fun: Arc>)>>, + fun: Arc)>>, dependents: Vec, - filter: Option bool>>>, + filter: Option bool>>>, ) -> Self { let selv = Self { title: "choose reference".to_string(), @@ -78,7 +78,7 @@ impl CardSelector { selv } - pub async fn dependency_picker(f: Box>)>) -> Self { + pub async fn dependency_picker(f: Box)>) -> Self { info!("3 scope is ! {:?}", current_scope_id().unwrap()); let selv = Self { title: "set dependency".to_string(), @@ -110,7 +110,7 @@ impl CardSelector { self } - pub fn with_filter(mut self, filter: Arc bool>>) -> Self { + pub fn with_filter(mut self, filter: Arc bool>>) -> Self { self.filter = Some(filter); self } @@ -214,7 +214,7 @@ impl Komponent for CardSelector { let done = selv.is_done().clone(); let closure = closure.clone(); - let hook = move |card: Arc>| { + let hook = move |card: Arc| { done.clone().set(true); (closure)(card); }; diff --git a/speki-web/src/overlays/cardviewer.rs b/speki-web/src/overlays/cardviewer.rs index a8b17f14..93997532 100644 --- a/speki-web/src/overlays/cardviewer.rs +++ b/speki-web/src/overlays/cardviewer.rs @@ -1,7 +1,7 @@ use std::sync::Arc; use dioxus::prelude::*; -use speki_core::{AnyType, Card, ClassCard, InstanceCard, NormalCard, UnfinishedCard}; +use speki_core::{CardType, Card, ClassCard, InstanceCard, NormalCard, UnfinishedCard}; use speki_dto::CardId; use speki_web::{Node, NodeId, NodeMetadata}; use tracing::info; @@ -77,7 +77,7 @@ fn refresh_graph( } pub struct CardRep { - ty: AnyType, + ty: CardType, deps: Vec, } @@ -90,17 +90,17 @@ pub struct CardViewer { dependencies: Signal>, dependents: Signal>, graph: GraphRep, - save_hook: Option>)>>>, + save_hook: Option)>>>, is_done: Signal, - old_card: Signal>>>, + old_card: Signal>>, old_meta: Signal>, - filter: Option bool>>>, + filter: Option bool>>>, tempnode: TempNode, allowed_cards: Vec, } impl CardViewer { - pub fn with_hook(mut self, hook: Arc>)>>) -> Self { + pub fn with_hook(mut self, hook: Arc)>>) -> Self { self.save_hook = Some(hook); self } @@ -115,7 +115,7 @@ impl CardViewer { self } - pub fn with_filter(mut self, filter: Arc bool>>) -> Self { + pub fn with_filter(mut self, filter: Arc bool>>) -> Self { self.filter = Some(filter); self } @@ -134,11 +134,11 @@ impl CardViewer { self } - pub async fn new_from_card(card: Arc>, graph: GraphRep) -> Self { + pub async fn new_from_card(card: Arc, graph: GraphRep) -> Self { let meta = NodeMetadata::from_card(card.clone(), true).await; let tempnode = TempNode::Old(card.id()); - let filter = move |ty: AnyType| ty.is_class(); + let filter = move |ty: CardType| ty.is_class(); let raw = card.to_raw(); let concept = CardRef::new() @@ -169,27 +169,25 @@ impl CardViewer { let _front = frnt.clone(); let _graph = graph.clone(); let _meta = meta.clone(); - let f: Arc>)>> = - Arc::new(Box::new(move |card: Arc>| { - let graph = _graph.clone(); - let front = _front.clone(); - let meta = _meta.clone(); - let deps = dependencies.clone(); - deps.clone().write().push(card.id()); - refresh_graph(graph, front, deps, dependents.clone(), Some(meta)); - })); + let f: Arc)>> = Arc::new(Box::new(move |card: Arc| { + let graph = _graph.clone(); + let front = _front.clone(); + let meta = _meta.clone(); + let deps = dependencies.clone(); + deps.clone().write().push(card.id()); + refresh_graph(graph, front, deps, dependents.clone(), Some(meta)); + })); let _front = frnt.clone(); let _graph = graph.clone(); let _meta = meta.clone(); - let af: Arc>)>> = - Arc::new(Box::new(move |card: Arc>| { - let graph = _graph.clone(); - let front = _front.clone(); - let deps = dependencies.clone(); - let meta = _meta.clone(); - deps.clone().write().retain(|dep| *dep != card.id()); - refresh_graph(graph, front, deps, dependents.clone(), Some(meta)); - })); + let af: Arc)>> = Arc::new(Box::new(move |card: Arc| { + let graph = _graph.clone(); + let front = _front.clone(); + let deps = dependencies.clone(); + let meta = _meta.clone(); + deps.clone().write().retain(|dep| *dep != card.id()); + refresh_graph(graph, front, deps, dependents.clone(), Some(meta)); + })); let bck = bck.with_closure(f.clone()).with_deselect(af.clone()); let concept = concept.with_closure(f.clone()).with_deselect(af.clone()); @@ -222,25 +220,23 @@ impl CardViewer { let _graph = graph.clone(); let _front = front.clone(); - let f: Arc>)>> = - Arc::new(Box::new(move |card: Arc>| { - let graph = _graph.clone(); - let front = _front.clone(); - let deps = dependencies.clone(); - deps.clone().write().push(card.id()); - refresh_graph(graph, front, deps, dependents.clone(), None); - })); + let f: Arc)>> = Arc::new(Box::new(move |card: Arc| { + let graph = _graph.clone(); + let front = _front.clone(); + let deps = dependencies.clone(); + deps.clone().write().push(card.id()); + refresh_graph(graph, front, deps, dependents.clone(), None); + })); let _front = front.clone(); let _graph = graph.clone(); - let af: Arc>)>> = - Arc::new(Box::new(move |card: Arc>| { - let graph = _graph.clone(); - let front = _front.clone(); - let deps = dependencies.clone(); - deps.clone().write().retain(|dep| *dep != card.id()); - refresh_graph(graph, front, deps, dependents.clone(), None); - })); + let af: Arc)>> = Arc::new(Box::new(move |card: Arc| { + let graph = _graph.clone(); + let front = _front.clone(); + let deps = dependencies.clone(); + deps.clone().write().retain(|dep| *dep != card.id()); + refresh_graph(graph, front, deps, dependents.clone(), None); + })); let tempnode = TempNode::New { id: NodeId::new_temp(), @@ -254,7 +250,7 @@ impl CardViewer { .with_closure(f.clone()) .with_deselect(af.clone()); - let filter = move |ty: AnyType| ty.is_class(); + let filter = move |ty: CardType| ty.is_class(); let concept = CardRef::new() .with_filter(Arc::new(Box::new(filter))) @@ -311,13 +307,13 @@ impl CardViewer { return None; } - AnyType::Normal(NormalCard { front, back }) + CardType::Normal(NormalCard { front, back }) } CardTy::Class => { let parent_class = self.concept.selected_card().cloned(); let back = backside.to_backside()?; - AnyType::Class(ClassCard { + CardType::Class(ClassCard { name: front, back, parent_class, @@ -327,13 +323,13 @@ impl CardViewer { let class = self.concept.selected_card().cloned()?; let back = backside.to_backside(); - AnyType::Instance(InstanceCard { + CardType::Instance(InstanceCard { name: front, back, class, }) } - CardTy::Unfinished => AnyType::Unfinished(UnfinishedCard { front }), + CardTy::Unfinished => CardType::Unfinished(UnfinishedCard { front }), }; Some(CardRep { @@ -386,7 +382,7 @@ impl CardViewer { let selv = selv.clone(); let selv2 = selv.clone(); - let fun = move |card: Arc>| { + let fun = move |card: Arc| { selv.dependencies.clone().write().push(card.id()); selv.set_graph(); let old_card = selv.old_card.cloned(); diff --git a/speki-web/src/pages/browse.rs b/speki-web/src/pages/browse.rs index 264ed97e..a51cb8c2 100644 --- a/speki-web/src/pages/browse.rs +++ b/speki-web/src/pages/browse.rs @@ -1,7 +1,7 @@ use std::sync::Arc; use dioxus::prelude::*; -use speki_core::{AnyType, Card}; +use speki_core::{CardType, Card}; use tracing::info; use crate::{components::Komponent, overlays::card_selector::CardSelector}; @@ -25,11 +25,11 @@ pub fn Browse() -> Element { #[derive(Clone)] pub struct CardEntry { pub front: String, - pub card: Arc>, + pub card: Arc, } impl CardEntry { - pub async fn new(card: Arc>) -> Self { + pub async fn new(card: Arc) -> Self { Self { front: card.print().await, card, diff --git a/speki-web/src/pages/review.rs b/speki-web/src/pages/review.rs index 30de3eb7..a88c4545 100644 --- a/speki-web/src/pages/review.rs +++ b/speki-web/src/pages/review.rs @@ -3,7 +3,7 @@ use std::rc::Rc; use std::sync::{Arc, Mutex}; use dioxus::prelude::*; -use speki_core::{AnyType, Card}; +use speki_core::{CardType, Card}; use speki_dto::CardId; use speki_dto::Recall; use tracing::info; @@ -169,7 +169,7 @@ fn review_buttons(mut show_backside: Signal) -> Element { #[derive(Clone, Debug)] pub struct ReviewState { - pub card: Signal>>, + pub card: Signal>, pub queue: Arc>>, pub tot_len: Signal, pub pos: Signal, @@ -179,7 +179,7 @@ pub struct ReviewState { pub filter: Signal, pub graph: GraphRep, pub show_graph: Signal, - pub dependencies: Signal>, Self)>>, + pub dependencies: Signal, Self)>>, pub dependents: CardRef, } @@ -225,7 +225,7 @@ impl ReviewState { let front = front.clone(); let back = back.clone(); - let fun = move |card: Arc>| { + let fun = move |card: Arc| { spawn(async move{ let f = card.print().await; let b = card @@ -359,7 +359,7 @@ impl ReviewState { let selv = selv.clone(); let card = card.clone(); spawn(async move{ - let fun: Box>)> = Box::new(move |_: Arc>| { + let fun: Box)> = Box::new(move |_: Arc| { let selv = selv.clone(); spawn(async move{ selv.refresh().await; diff --git a/speki-web/src/utils.rs b/speki-web/src/utils.rs index b5704d5e..b641321f 100644 --- a/speki-web/src/utils.rs +++ b/speki-web/src/utils.rs @@ -1,7 +1,7 @@ use std::{fmt::Debug, sync::Arc, time::Duration}; use dioxus::prelude::*; -use speki_core::{AnyType, Card, TimeProvider}; +use speki_core::{Card, CardType, TimeProvider}; use speki_dto::{CardId, RawCard}; use speki_provider::DexieProvider; use speki_web::{Node, NodeMetadata}; @@ -29,18 +29,18 @@ impl App { self.0.fill_cache().await; } - pub async fn load_all(&self, filter: Option) -> Vec>> { + pub async fn load_all(&self, filter: Option) -> Vec> { match filter { Some(filter) => self.0.cards_filtered(filter).await, None => self.0.load_all_cards().await, } } - pub async fn load_card(&self, id: CardId) -> Arc> { + pub async fn load_card(&self, id: CardId) -> Arc { Arc::new(self.0.load_card(id).await.unwrap()) } - pub async fn new_from_raw(&self, raw: RawCard) -> Arc> { + pub async fn new_from_raw(&self, raw: RawCard) -> Arc { info!("new from raw"); let card = self.0.new_from_raw(raw).await; card @@ -51,14 +51,14 @@ impl App { front: String, back: Option, class: CardId, - ) -> Arc> { + ) -> Arc { info!("new simple"); let id = self.0.add_instance(front, back, class).await; let card = Arc::new(self.0.load_card(id).await.unwrap()); card } - pub async fn new_simple(&self, front: String, back: String) -> Arc> { + pub async fn new_simple(&self, front: String, back: String) -> Arc { info!("new simple"); let id = self.0.add_card(front, back).await; let card = Arc::new(self.0.load_card(id).await.unwrap());