Rename set to deck in repetitions.rs

src/data_provider/card_sets.rs

@@ -46,7 +46,7 @@ pub fn add_set(set: &mut DeckSettings, connection: &Connection) {
     set.id = index.into();
 }
 
-pub fn update_card_set(set: &mut DeckSettings, connection: &Connection) {
+pub fn update_deck(set: &mut DeckSettings, connection: &Connection) {
     if set.id == INVALID_ID {
         add_set(set, connection);
     } else {

src/data_provider/card_stats.rs

@@ -2,7 +2,7 @@ use crate::lang::{DeckSettings, CardStatistics, INVALID_ID};
 use rusqlite::Connection;
 use std::time::Instant;
 
-pub fn load_stats_of_set(set: &DeckSettings, connection: &Connection) -> Vec<CardStatistics> {
+pub fn load_stats_of_deck(set: &DeckSettings, connection: &Connection) -> Vec<CardStatistics> {
     let mut stmt = connection
         .prepare("SELECT id, word_id, score, last_opened FROM card_stats WHERE set_id = ?1")
         .unwrap();

src/lang.rs

@@ -1,5 +1,5 @@
 use crate::AppState;
-use crate::data_provider::card_stats::{delete_stat, load_stats_of_set, update_stat_score};
+use crate::data_provider::card_stats::{delete_stat, load_stats_of_deck, update_stat_score};
 use crate::data_provider::history::{HistoryItem, push_note};
 use chrono::{DateTime, Utc};
 use rand::distr::Distribution;
@@ -351,7 +351,7 @@ impl DeckData {
         let state_for = state.clone();
         let state_locked = state.lock().unwrap();
 
-        let mut current_set = load_stats_of_set(settings, &state_locked.connection);
+        let mut current_set = load_stats_of_deck(settings, &state_locked.connection);
         let last_list: Vec<_> = settings
             .get_word_list(&state_locked)
             .iter()

src/main.rs

@@ -81,7 +81,7 @@ fn subscription(_state: &ScreenState) -> Subscription<RootMessage> {
 
 pub struct AppState {
     pub dictionary: Vec<WordData>,
-    pub card_sets: Vec<DeckSettings>,
+    pub decks: Vec<DeckSettings>,
     pub word_groups: Vec<WordGroup>,
     pub connection: Connection,
     pub sync_data: AppSettings,
@@ -98,7 +98,7 @@ impl AppState {
     pub fn new() -> Self {
         Self {
             dictionary: vec![],
-            card_sets: vec![],
+            decks: vec![],
             word_groups: vec![],
             connection: default_connection(),
             sync_data: AppSettings {
@@ -117,7 +117,7 @@ fn fill_state(state: &mut AppState) {
     let setting = load_settings(&state.connection);
 
     state.dictionary = list;
-    state.card_sets = sets;
+    state.decks = sets;
     state.word_groups = groups;
     state.sync_data = setting
 }

src/repetition_settings.rs

@@ -1,5 +1,5 @@
 use crate::AppState;
-use crate::data_provider::card_sets::{delete_set, update_card_set};
+use crate::data_provider::card_sets::{delete_set, update_deck};
 use crate::lang::DeckSettings;
 use crate::navigation::Page::PreviousPage;
 use crate::navigation::{NavigatedPage, Page, RootMessage};
@@ -25,7 +25,7 @@ impl RepetitionSettingsState {
         let set;
         {
             let local_state = p1.lock().unwrap();
-            set = local_state.card_sets[index].clone();
+            set = local_state.decks[index].clone();
         }
         RepetitionSettingsState {
             index,
@@ -51,8 +51,8 @@ impl NavigatedPage<RepetitionSettingsMessage> for RepetitionSettingsState {
             Back => {}
             Save => {
                 let mut state = self.state.lock().unwrap();
-                update_card_set(&mut self.set, &state.connection);
+                update_deck(&mut self.set, &state.connection);
-                state.card_sets[self.index] = self.set.clone();
+                state.decks[self.index] = self.set.clone();
             }
             SetName(new) => {
                 self.set.name = new;
@@ -81,7 +81,7 @@ impl NavigatedPage<RepetitionSettingsMessage> for RepetitionSettingsState {
                 }
                 let mut state = self.state.lock().unwrap();
                 delete_set(&self.set, &state.connection);
-                state.card_sets.remove(self.index);
+                state.decks.remove(self.index);
                 return Task::done(RootMessage::RepetitionSettings(Back));
             }
             RevertDeleteSet => self.real_delete = false,

src/repetitions.rs

@@ -1,5 +1,5 @@
-use crate::data_provider::card_sets::update_card_set;
+use crate::data_provider::card_sets::update_deck;
-use crate::data_provider::card_stats::{add_stat_list, load_stats_of_set};
+use crate::data_provider::card_stats::{add_stat_list, load_stats_of_deck};
 use crate::history::HistoryState;
 use crate::lang::{AppendMode, CardStatistics, DeckSettings, Id, OrderMode, INVALID_ID};
 use crate::navigation::Page::{History, PreviousPage, Repetition, RepetitionSettings};
@@ -83,7 +83,7 @@ impl NavigatedPage<RepetitionsMessage> for RepetitionsState {
     fn navigated(&mut self) {
         let index = self.selected_deck_index.unwrap();
         let state = self.state.lock().unwrap();
-        if let Some(global_deck) = state.card_sets.get(index) {
+        if let Some(global_deck) = state.decks.get(index) {
             if global_deck.id != self.selected_deck().unwrap().id {
                 drop(state);
                 self.decks.remove(index);
@@ -121,7 +121,7 @@ impl NavigatedPage<RepetitionsMessage> for RepetitionsState {
                 let deck = self.decks.remove(index);
                 if deck.id != INVALID_ID {
                     let mut state = self.state.lock().unwrap();
-                    state.card_sets.remove(index);
+                    state.decks.remove(index);
                 }
             }
             SetName(value) => {
@@ -129,11 +129,11 @@ impl NavigatedPage<RepetitionsMessage> for RepetitionsState {
                 deck.general_settings.name = value;
             }
             SelectSet(index) => {
-                self.select_set(index);
+                self.select_deck(index);
                 let deck = self.selected_deck().unwrap();
                 if deck.existing_words_indices.is_none() {
                     let state = self.state.lock().unwrap();
-                    let added: Vec<_> = load_stats_of_set(deck, &state.connection)
+                    let added: Vec<_> = load_stats_of_deck(deck, &state.connection)
                         .iter()
                         .map(|c| self.word_id_index_map[&c.word_id])
                         .collect();
@@ -148,12 +148,12 @@ impl NavigatedPage<RepetitionsMessage> for RepetitionsState {
                 let mut deck = self.selected_deck().unwrap().clone();
                 let mut state = self.state.lock().unwrap();
                 {
-                    update_card_set(&mut deck.general_settings, &state.connection);
+                    update_deck(&mut deck.general_settings, &state.connection);
                     if let Some(index) = deck.index {
-                        state.card_sets[index] = deck.general_settings.clone();
+                        state.decks[index] = deck.general_settings.clone();
                     } else {
-                        state.card_sets.push(deck.general_settings.clone());
+                        state.decks.push(deck.general_settings.clone());
-                        deck.index = Some(state.card_sets.len() - 1);
+                        deck.index = Some(state.decks.len() - 1);
                         self.decks[deck.index.unwrap()] = deck.clone();
                     }
                 }
@@ -226,7 +226,7 @@ impl NavigatedPage<RepetitionsMessage> for RepetitionsState {
         back_overlay(
             row![
                 column![
-                    scrollable(self.sets_list()).height(Fill),
+                    scrollable(self.decks_list()).height(Fill),
                     button("Добавить")
                         .style(jl_button)
                         .width(Fill)
@@ -234,7 +234,7 @@ impl NavigatedPage<RepetitionsMessage> for RepetitionsState {
                 ]
                 .spacing(DEFAULT_SPACING)
                 .width(Length::FillPortion(1)),
-                self.selected_set_view(),
+                self.selected_deck_view(),
             ]
             .align_y(Center)
             .spacing(DEFAULT_SPACING)
@@ -259,8 +259,8 @@ impl RepetitionsState {
                 map.insert(word.id, index);
             });
 
-        let decks = state_.card_sets.iter().enumerate().map(|(index, set)| {DeckViewData{
+        let decks = state_.decks.iter().enumerate().map(|(index, deck)| {DeckViewData{
-            general_settings: set.clone(),
+            general_settings: deck.clone(),
             existing_words_indices: None,
             available_words_indices: None,
             append_mode: Default::default(),
@@ -279,9 +279,9 @@ impl RepetitionsState {
 }
 
 impl RepetitionsState {
-    fn launch_delete_button(&self, set: &DeckViewData) -> Element<'_, RepetitionsMessage> {
+    fn launch_delete_button(&self, deck: &DeckViewData) -> Element<'_, RepetitionsMessage> {
-        if set.id != INVALID_ID {
+        if deck.id != INVALID_ID {
-            if set.append_mode == AppendMode::Manual && set.existing_words_indices.as_ref().unwrap().is_empty() {
+            if deck.append_mode == AppendMode::Manual && deck.existing_words_indices.as_ref().unwrap().is_empty() {
                 return text!("Добавьте карточки или измените фильтр").into();
             }
             return row![
@@ -294,15 +294,15 @@ impl RepetitionsState {
         }
         button("Удалить").style(danger).on_press(DeleteSet).into()
     }
-    fn selected_set_view(&self) -> Element<'_, RepetitionsMessage> {
+    fn selected_deck_view(&self) -> Element<'_, RepetitionsMessage> {
-        if let Some(set) = &self.selected_deck() {
+        if let Some(deck) = &self.selected_deck() {
             return column![
                 scrollable(
                     column![
                         column![
                             text!("Название набора"),
                             row![
-                                text_input("", &set.name).on_input(SetName),
+                                text_input("", &deck.name).on_input(SetName),
                                 button(svg(Handle::from_memory(SETTINGS_ICON)))
                                     .width(43)
                                     .on_press(GoToSettings),
@@ -311,49 +311,49 @@ impl RepetitionsState {
                         ]
                         .spacing(QUARTER_SPACING),
                         {
-                            if set.id == INVALID_ID {
+                            if deck.id == INVALID_ID {
                                 column![
                                     column![
                                         text!("Передняя сторона"),
-                                        text_input("", &set.forward).on_input(SetForward),
+                                        text_input("", &deck.forward).on_input(SetForward),
                                     ]
                                     .spacing(QUARTER_SPACING),
                                     column![
                                         text!("Задняя сторона"),
-                                        text_input("", &set.backward).on_input(SetBackward),
+                                        text_input("", &deck.backward).on_input(SetBackward),
                                     ]
                                     .spacing(QUARTER_SPACING),
                                     column![
                                         text!("Фильтр"),
-                                        text_input("", &set.filter).on_input(SetFilter),
+                                        text_input("", &deck.filter).on_input(SetFilter),
                                         button("Проверить фильтр")
                                             .style(jl_button)
                                             .on_press(TryFilter),
-                                        self.count_view(set),
+                                        self.count_view(deck),
                                     ]
                                     .spacing(QUARTER_SPACING),
                                 ]
                                 .spacing(DEFAULT_SPACING)
                             } else {
                                 column![
-                                    self.filled_set_data_view(set),
+                                    self.filled_deck_data_view(deck),
-                                    self.word_append_panel(set),
+                                    self.word_append_panel(deck),
                                     radio(
                                         "Обычный режим",
                                         OrderMode::Default,
-                                        Some(set.open_mode),
+                                        Some(deck.open_mode),
                                         SetOpenMode
                                     ),
                                     radio(
                                         "Начать с плохих слов",
                                         OrderMode::TrainWorstFirst,
-                                        Some(set.open_mode),
+                                        Some(deck.open_mode),
                                         SetOpenMode
                                     ),
                                     radio(
                                         "Полностью случайно",
                                         OrderMode::FullRandom,
-                                        Some(set.open_mode),
+                                        Some(deck.open_mode),
                                         SetOpenMode
                                     ),
                                     button("История").style(jl_button).on_press(GoToHistory),
@@ -374,7 +374,7 @@ impl RepetitionsState {
                 .height(Fill),
                 row![
                     button("Сохранить").style(jl_button).on_press(Save),
-                    self.launch_delete_button(set)
+                    self.launch_delete_button(deck)
                 ]
                 .spacing(DEFAULT_SPACING).align_y(Center),
             ]
@@ -384,17 +384,17 @@ impl RepetitionsState {
         }
         space().width(Length::FillPortion(2)).into()
     }
-    fn filled_set_data_view(&self, set: &DeckSettings) -> Column<'_, RepetitionsMessage> {
+    fn filled_deck_data_view(&self, deck: &DeckSettings) -> Column<'_, RepetitionsMessage> {
-        column![self.activity_bar(set), self.count_comparator_view()]
+        column![self.activity_bar(deck), self.count_comparator_view()]
             .align_x(Center)
             .width(Fill)
             .spacing(DEFAULT_SPACING)
     }
-    fn activity_bar(&self, set: &DeckSettings) -> Element<'_, RepetitionsMessage> {
+    fn activity_bar(&self, deck: &DeckSettings) -> Element<'_, RepetitionsMessage> {
         const MAX_DAY_COUNT: f32 = 128.0;
 
         let state = self.state.lock().unwrap();
-        let history = state.activity.get(&set.id);
+        let history = state.activity.get(&deck.id);
         let mut counts: Vec<u32> = vec![0; 30 * 7];
         let now = Local::now().date_naive();
 
@@ -467,31 +467,31 @@ impl RepetitionsState {
         })
         .into()
     }
-    fn word_append_panel(&self, set: &DeckViewData) -> Element<'_, RepetitionsMessage> {
+    fn word_append_panel(&self, deck: &DeckViewData) -> Element<'_, RepetitionsMessage> {
         column![
             text!("Режим добавления карточек"),
             row![
                 radio(
                     "Добавлять все доступные",
                     AppendMode::Full,
-                    Some(set.append_mode),
+                    Some(deck.append_mode),
                     SetAppendMode
                 ),
                 radio(
                     "Добавлять вручную",
                     AppendMode::Manual,
-                    Some(set.append_mode),
+                    Some(deck.append_mode),
                     SetAppendMode
                 )
             ]
             .spacing(HALF_SPACING),
-            self.adder_panel(set),
+            self.adder_panel(deck),
         ]
         .spacing(HALF_SPACING)
         .into()
     }
-    fn adder_panel(&self, set: &DeckViewData) -> Element<'_, RepetitionsMessage> {
+    fn adder_panel(&self, deck: &DeckViewData) -> Element<'_, RepetitionsMessage> {
-        match set.append_mode {
+        match deck.append_mode {
             AppendMode::Full => space().into(),
             AppendMode::Manual => row![
                 button("+5").on_press(AppendWords(5)),
@@ -514,18 +514,18 @@ impl RepetitionsState {
             .len();
         text!("{} слова добавлено из {}", now, available).into()
     }
-    fn count_view(&self, set: &DeckSettings) -> Element<'_, RepetitionsMessage> {
+    fn count_view(&self, deck: &DeckSettings) -> Element<'_, RepetitionsMessage> {
-        if let Some(count) = set.count {
+        if let Some(count) = deck.count {
             return text!("Количество слов: {}", count).into();
         }
         space().into()
     }
-    fn sets_list(&self) -> Column<'_, RepetitionsMessage> {
+    fn decks_list(&self) -> Column<'_, RepetitionsMessage> {
         let mut column = Column::new();
 
-        for (i, set) in self.decks.iter().enumerate() {
+        for (i, deck) in self.decks.iter().enumerate() {
             column = column.push(
-                button(text!("{}", &set.name))
+                button(text!("{}", &deck.name))
                     .on_press_with(move || SelectSet(i))
                     .style(move |_x: &Theme, status: Status| Style {
                         background: if status == Status::Hovered {
@@ -533,7 +533,7 @@ impl RepetitionsState {
                         } else {
                             None
                         },
-                        text_color: if set.valid_filter {
+                        text_color: if deck.valid_filter {
                             _x.palette().primary
                         } else {
                             _x.palette().warning
@@ -569,7 +569,7 @@ impl RepetitionsState {
             .cloned();
         Self::append_words(state, deck, required);
     }
-    fn append_words(state: &AppState, set: &DeckSettings, indices: impl Iterator<Item = usize>) {
+    fn append_words(state: &AppState, deck: &DeckSettings, indices: impl Iterator<Item = usize>) {
         let words = &state.dictionary;
         let stats = &mut indices
             .map(|i| {
@@ -579,7 +579,7 @@ impl RepetitionsState {
                     word_id: word.id,
                     last_open: Utc::now(),
                     score: 1,
-                    set_id: set.id,
+                    set_id: deck.id,
                 }
             })
             .collect::<Vec<_>>();
@@ -589,7 +589,7 @@ impl RepetitionsState {
         }
     }
 
-    fn select_set(&mut self, index: usize) {
+    fn select_deck(&mut self, index: usize) {
         if  self.decks.get(index).is_some() {
             self.selected_deck_index = Some(index);
         }

src/sync.rs

@@ -119,7 +119,7 @@ impl NavigatedPage<SyncMessage> for SyncState {
                 let mut state = self.state.lock().unwrap();
                 state.sync_data = updated_state.sync_data;
                 state.connection = updated_state.connection;
-                state.card_sets = updated_state.card_sets;
+                state.decks = updated_state.decks;
                 state.dictionary = updated_state.dictionary;
                 state.word_groups = updated_state.word_groups;
             }