Formating with fmt

src/data_provider/card_stats.rs

@@ -1,5 +1,5 @@
 use crate::lang::{CardStatistics, DeckSettings};
-use rusqlite::{params, Connection};
+use rusqlite::{Connection, params};
 use std::time::Instant;
 
 pub fn load_stats_of_deck(set: &DeckSettings, connection: &Connection) -> Vec<CardStatistics> {
@@ -78,5 +78,6 @@ pub fn delete_stat(stat: &CardStatistics, connection: &Connection) {
         return;
     }
     connection
-        .execute("DELETE FROM card_stats WHERE id = ?1", (&stat.id,)).unwrap();
+        .execute("DELETE FROM card_stats WHERE id = ?1", (&stat.id,))
+        .unwrap();
 }

src/data_provider/history.rs

@@ -31,7 +31,7 @@ fn parse_history_items(strings: Vec<String>) -> Vec<HistoryItem> {
     for string in strings {
         if let [time, word, mode, before, after] = string.split(';').collect::<Vec<&str>>()[..] {
             let id = word.parse::<Id>();
-            if id.is_err(){
+            if id.is_err() {
                 continue;
             }
             let id = id.unwrap();

src/data_provider/words.rs

@@ -1,5 +1,5 @@
 use crate::lang::{WordData, WordGroup};
-use rusqlite::{params, Connection};
+use rusqlite::{Connection, params};
 use std::collections::HashMap;
 
 pub fn add_word(word: &mut WordData, connection: &Connection) {
@@ -45,7 +45,6 @@ pub fn add_words(words: &mut [WordData], connection: &mut Connection) {
     let last_index: u32 = tx.last_insert_rowid() as u32;
     tx.commit().unwrap();
 
-
     let start_index = last_index - (count as u32) + 1;
 
     for (index, id) in (start_index..=last_index).enumerate() {
@@ -129,7 +128,7 @@ pub fn load_word_groups(connection: &Connection) -> Vec<WordGroup> {
 }
 
 pub fn add_group(group: &mut WordGroup, connection: &Connection) {
-    let index : u32 = connection
+    let index: u32 = connection
         .query_row(
             "INSERT INTO word_group (name) VALUES (?1) RETURNING id",
             (&group.name,),

src/dictionary.rs

@@ -600,13 +600,10 @@ impl DictionaryState {
     fn add_word_button(&self) -> iced::Element<'_, DictionaryMessage> {
         let state = self.state.lock().unwrap();
         let group_id = state.word_groups[self.selected_group_index].id;
-        let button = button("Добавить слово")
+        let button = button("Добавить слово").style(jl_button);
-            .style(jl_button);
 
         if group_id.is_valid() {
-            return
+            return button.on_press(NewWord).into();
-                button.on_press(NewWord)
-                .into();
         }
 
         button.into()

src/dictionary_test.rs

@@ -171,11 +171,8 @@ impl DictionaryQuizState {
         self.is_help = false;
         self.answer = String::new();
 
-        let next : WordData =
+        let next: WordData = match self.current_set.pop() {
-        match self.current_set.pop() {
+            Some(word) => word,
-            Some(word) => {
-                word
-            }
             None => {
                 self.update_set();
                 self.current_set.pop().expect("Empty set")

src/import.rs

@@ -1,15 +1,15 @@
-use crate::data_provider::import::{get_words_of_group, load_groups, ImportData, ImportGroup};
+use crate::AppState;
+use crate::data_provider::import::{ImportData, ImportGroup, get_words_of_group, load_groups};
 use crate::data_provider::words::{add_group, add_words};
 use crate::dictionary::app_data_dir;
 use crate::import::ImportMessage::*;
 use crate::lang::{WordData, WordGroup};
 use crate::navigation::{NavigatedPage, Page, RootMessage};
 use crate::styling::*;
-use crate::AppState;
 use iced::widget::button::danger;
 use iced::widget::container::success;
 use iced::widget::{
-    button, checkbox, column, container, progress_bar, row, rule, text, text_input, Row,
+    Row, button, checkbox, column, container, progress_bar, row, rule, text, text_input,
 };
 use iced::widget::{scrollable, space};
 use iced::{Element, Task};
@@ -512,7 +512,11 @@ impl ImportState {
             .map(|name| (name.clone(), Vec::<usize>::with_capacity(1)))
             .collect::<Vec<_>>();
         for (key, endpoint) in &group.mapping {
-            let property_index = group.fields.iter().position(|f| f == key).expect("Unknown property");
+            let property_index = group
+                .fields
+                .iter()
+                .position(|f| f == key)
+                .expect("Unknown property");
             let group_index = result
                 .iter()
                 .position(|(name, _)| name == endpoint)

src/lang.rs

@@ -588,9 +588,7 @@ impl SRSModule for WorstWordsSRSModule {
         }
 
         match self.queue.pop() {
-            Some(index) => {
+            Some(index) => index,
-                index
-            }
             None => {
                 self.queue.append(&mut self.pool.clone());
                 self.rounds_remaining -= 1;

src/main.rs

@@ -31,10 +31,10 @@ use iced::{Font, window};
 use iced::{Subscription, Theme, keyboard};
 use iced_core::Size;
 use iced_core::window::Position;
-use mimalloc::MiMalloc;
-use rusqlite::Connection;
 #[cfg(target_os = "linux")]
 use iced_core::window::settings::PlatformSpecific;
+use mimalloc::MiMalloc;
+use rusqlite::Connection;
 #[global_allocator]
 static GLOBAL: MiMalloc = MiMalloc;
 

src/navigation.rs

@@ -3,7 +3,7 @@ use crate::data_provider::sqlite::{create_db, default_connection};
 use crate::data_provider::web_api::{
     get_local_version, get_web_version, load_data, set_local_version,
 };
-use crate::dictionary::{app_data_dir, DictionaryMessage, DictionaryState};
+use crate::dictionary::{DictionaryMessage, DictionaryState, app_data_dir};
 use crate::dictionary_test::{DictionaryQuizMessage, DictionaryQuizState};
 use crate::history::{HistoryMessage, HistoryState};
 use crate::import::{ImportMessage, ImportState};
@@ -23,7 +23,7 @@ use crate::sync::{SyncMessage, SyncState};
 use crate::view_navigation;
 use crate::word::{WordMessage, WordState};
 use crate::writing::{WritingMessage, WritingState};
-use crate::{fill_state, AppState};
+use crate::{AppState, fill_state};
 use chrono::NaiveDate;
 use hashbrown::HashMap;
 use iced::keyboard::Event;

src/quiz.rs

@@ -54,7 +54,7 @@ impl NavigatedPage<QuizMessage> for QuizState {
                     self.update_showed()
                 }
             }
-            Back => {},
+            Back => {}
         }
         Task::none()
     }

src/repetition_settings.rs

@@ -6,13 +6,13 @@ use crate::navigation::{NavigatedPage, Page, RootMessage};
 use crate::repetition_settings::RepetitionSettingsMessage::*;
 use crate::styling::*;
 use iced::widget::button::danger;
+use iced::widget::text_input::Catalog;
 use iced::widget::{button, column, row, scrollable, space, text, text_input};
 use iced::{Element, Task};
 use iced_core::Length::Fill;
-use iced_core::{color, Padding, Theme};
+use iced_core::{Padding, Theme, color};
 use std::sync::{Arc, Mutex};
 use std::time::Duration;
-use iced::widget::text_input::Catalog;
 
 pub struct RepetitionSettingsState {
     set: DeckSettings,
@@ -117,13 +117,15 @@ impl NavigatedPage<RepetitionSettingsMessage> for RepetitionSettingsState {
                         .spacing(QUARTER_SPACING),
                         column![
                             text!("Фильтр"),
-                            text_input("", &self.set.filter).style(|x, status| {
+                            text_input("", &self.set.filter)
+                                .style(|x, status| {
                                     let mut primary = Theme::default()(x, status);
                                     if !self.correct_filter {
                                         primary.border.color = color!(255, 255, 0);
                                     }
                                     primary
-                            }).on_input(SetFilter),
+                                })
+                                .on_input(SetFilter),
                             button("Проверить фильтр")
                                 .style(jl_button)
                                 .on_press(TryFilter),

src/repetitions.rs

@@ -577,7 +577,11 @@ impl RepetitionsState {
             .cloned();
         Self::append_words(state, deck, required);
     }
-    fn append_words(state: &mut AppState, deck: &DeckSettings, indices: impl Iterator<Item = usize>) {
+    fn append_words(
+        state: &mut AppState,
+        deck: &DeckSettings,
+        indices: impl Iterator<Item = usize>,
+    ) {
         let words = &state.dictionary;
         let stats = &mut indices
             .map(|i| {

src/writing.rs

@@ -30,7 +30,7 @@ impl NavigatedPage<WritingMessage> for WritingState {
     fn navigated(&mut self) {}
     fn update(&mut self, message: WritingMessage) -> Task<RootMessage> {
         match message {
-            WritingMessage::Back => {},
+            WritingMessage::Back => {}
             WritingMessage::Next => self.next(),
             WritingMessage::SwitchShowMode(b) => self.show_all = b,
         }