Extract funcs from input-check to reduce nesting and make pedantic clippy happy

.gitignore

@@ -4,3 +4,4 @@
 /kanban.json
 /db.sqlite
 /kanban.db
+/sql/queries.sql

sql/migrations.sql

@@ -20,7 +20,8 @@ create table if not exists kb_column
 
 create table if not exists setting
 (
-    id integer primary key autoincrement,
+    key text not null primary key,
-    name text not null,
     value text not null
 );
+
+insert into kb_column(name) values ("Todo"),("InProgress"),("Done"),("Ideas");

src/app.rs

@@ -2,7 +2,7 @@
 // use int_enum::IntEnum;
 use rusqlite::Connection;
 use serde::{Deserialize, Serialize};
-use std::cmp::min;
+use std::{cmp::min, error::Error};
 use tui_textarea::TextArea;
 
 use crate::db;
@@ -29,7 +29,6 @@ pub struct Task {
 #[derive(Deserialize, Serialize, Debug)]
 pub struct Project {
     pub name: String,
-    pub filepath: String,
     pub selected_column_idx: usize,
     pub columns: Vec<Column>,
 }
@@ -145,7 +144,7 @@ impl<'a> Column {
     }
 
     pub fn select_last_task(&mut self) {
-        self.selected_task_idx = self.tasks.len() - 1;
+        self.selected_task_idx = self.tasks.len().saturating_sub(1);
     }
 
     pub fn move_task_up(&mut self) -> bool {
@@ -160,7 +159,7 @@ impl<'a> Column {
     }
 
     pub fn move_task_down(&mut self) -> bool {
-        if self.selected_task_idx < self.tasks.len() - 1 {
+        if self.selected_task_idx < self.tasks.len().saturating_sub(1) {
             self.tasks
                 .swap(self.selected_task_idx, self.selected_task_idx + 1);
             self.selected_task_idx += 1;
@@ -182,12 +181,16 @@ impl<'a> Column {
 }
 
 impl Project {
-    pub async fn load(pool: &Connection) -> Result<Self, KanbanError> {
+    /// .
-        let columns = db::get_all_columns(&pool).unwrap();
+    ///
+    /// # Errors
+    ///
+    /// This function will return an error if it has issues reading from the database
+    pub fn load(conn: &Connection) -> Result<Self, Box<dyn Error>> {
+        let columns = db::get_all_columns(conn)?;
 
         Ok(Project {
             name: String::from("Kanban Board"),
-            filepath: String::from("path"),
             columns,
             selected_column_idx: 0,
         })

src/db.rs

@@ -1,6 +1,11 @@
 use crate::{Column, Task};
 use rusqlite::{params, Connection, Result};
 
+/// .
+///
+/// # Errors
+///
+/// This function will return an error if something is wrong with the SQL
 pub fn get_tasks_by_column(conn: &Connection, column_name: &String) -> Result<Vec<Task>> {
     let mut stmt = conn.prepare(
         r#"
@@ -11,7 +16,7 @@ pub fn get_tasks_by_column(conn: &Connection, column_name: &String) -> Result<Ve
         "#,
     )?;
     let mut tasks = Vec::new();
-    let rows = stmt.query_map(&[column_name], |row| {
+    let rows = stmt.query_map([column_name], |row| {
         Ok(Task {
             id: row.get(0)?,
             title: row.get(1)?,
@@ -24,6 +29,11 @@ pub fn get_tasks_by_column(conn: &Connection, column_name: &String) -> Result<Ve
     Ok(tasks)
 }
 
+/// .
+///
+/// # Errors
+///
+/// This function will return an error if there are issues with the SQL
 pub fn get_all_columns(conn: &Connection) -> Result<Vec<Column>> {
     let mut stmt = conn.prepare("select id, name from kb_column")?;
     let query_rows = stmt.query_map((), |row| {
@@ -33,11 +43,11 @@ pub fn get_all_columns(conn: &Connection) -> Result<Vec<Column>> {
     for row in query_rows {
         let r = &row?;
         let name = &r.1;
-        let tasks = get_tasks_by_column(conn, &name).unwrap();
+        let tasks = get_tasks_by_column(conn, name)?;
         let col = Column {
             id: r.0,
             name: name.clone(),
-            tasks: tasks,
+            tasks,
             selected_task_idx: 0,
         };
         columns.push(col);
@@ -45,6 +55,11 @@ pub fn get_all_columns(conn: &Connection) -> Result<Vec<Column>> {
     Ok(columns)
 }
 
+/// .
+///
+/// # Panics
+///
+/// Panics if something goes wrong with the SQL
 pub fn insert_new_task(
     conn: &Connection,
     title: String,
@@ -64,11 +79,21 @@ pub fn insert_new_task(
     }
 }
 
+/// .
+///
+/// # Panics
+///
+/// Panics if something goes wrong with the SQL
 pub fn delete_task(conn: &Connection, task: &Task) {
     let mut stmt = conn.prepare("delete from task where id = ?1").unwrap();
     stmt.execute([task.id]).unwrap();
 }
 
+/// .
+///
+/// # Panics
+///
+/// Panics if something goes wrong with the SQL
 pub fn update_task_text(conn: &Connection, task: &Task) {
     let mut stmt = conn
         .prepare("update task set title = ?2, description = ?3 where id = ?1")
@@ -77,27 +102,38 @@ pub fn update_task_text(conn: &Connection, task: &Task) {
         .unwrap();
 }
 
+/// .
+///
+/// # Panics
+///
+/// Panics if something goes wrong with the SQL
 pub fn move_task_to_column(conn: &Connection, task: &Task, target_column: &Column) {
     let mut stmt = conn
         .prepare(
             "update task
              set
                column_id = ?2,
-               sort_order = 1 +
+               sort_order = coalesce(1 +
                  (select sort_order from task
-                  where column_id = ?2 order by sort_order desc limit 1)
+                  where column_id = ?2 order by sort_order desc limit 1),
+                  0)
              where task.id = ?1",
         )
         .unwrap();
     stmt.execute((&task.id, &target_column.id)).unwrap();
 }
 
+/// .
+///
+/// # Panics
+///
+/// Panics if something goes wrong with the SQL
 pub fn swap_task_order(conn: &mut Connection, task1: &Task, task2: &Task) {
     let tx = conn.transaction().unwrap();
 
     tx.execute(
         "create temp table temp_order as select sort_order from task where id = ?1",
-        &[&task1.id],
+        [&task1.id],
     )
     .unwrap();
 
@@ -110,7 +146,7 @@ pub fn swap_task_order(conn: &mut Connection, task1: &Task, task2: &Task) {
 
     tx.execute(
         "update task set sort_order = (select sort_order from temp_order) where id = ?1",
-        &[&task2.id],
+        [&task2.id],
     )
     .unwrap();
     tx.execute("drop table temp_order", ()).unwrap();

src/input.rs

@@ -3,16 +3,9 @@ use crate::db;
 use crossterm::event;
 use crossterm::event::{Event, KeyCode};
 
-/// # Errors
+pub fn handle_task_edit(state: &mut State<'_>, key: event::KeyEvent, mut task: TaskState<'_>) {
-///
-/// Crossterm `event::read()` might return an error
-pub fn handle(state: &mut State<'_>) -> Result<(), std::io::Error> {
     let project = &mut state.project;
     let column = project.get_selected_column_mut();
-    if let Event::Key(key) = event::read()? {
-        match &mut state.task_edit_state {
-            Some(task) => {
-                // TODO: Extract this code to a separate function to avoid nesting
     match task.focus {
         // TODO: Handle wrapping around the enum rather than doing it manually
         TaskEditFocus::Title => match key.code {
@@ -40,15 +33,10 @@ pub fn handle(state: &mut State<'_>) -> Result<(), std::io::Error> {
                     if let Some(selected_task) = column.get_selected_task_mut() {
                         selected_task.title = title;
                         selected_task.description = description;
-                                    db::update_task_text(&state.db_conn, &selected_task);
+                        db::update_task_text(&state.db_conn, selected_task);
                     }
                 } else {
-                                let task = db::insert_new_task(
+                    let task = db::insert_new_task(&state.db_conn, title, description, column);
-                                    &state.db_conn,
-                                    title,
-                                    description,
-                                    &column,
-                                );
                     column.add_task(task);
                 }
                 state.task_edit_state = None;
@@ -65,7 +53,11 @@ pub fn handle(state: &mut State<'_>) -> Result<(), std::io::Error> {
         },
     };
 }
-            None => match key.code {
+
+pub fn handle_main(state: &mut State<'_>, key: event::KeyEvent) {
+    let project = &mut state.project;
+    let column = project.get_selected_column_mut();
+    match key.code {
         KeyCode::Char('q') => state.quit = true,
         KeyCode::Char('h') | KeyCode::Left => {
             project.select_previous_column();
@@ -78,41 +70,62 @@ pub fn handle(state: &mut State<'_>) -> Result<(), std::io::Error> {
         KeyCode::Char('g') => column.select_first_task(),
         KeyCode::Char('G') => column.select_last_task(),
         KeyCode::Char('H') => {
+            if !column.tasks.is_empty() {
                 project.move_task_previous_column();
                 let col = project.get_selected_column();
                 let t = col.get_selected_task().unwrap();
-                    db::move_task_to_column(&state.db_conn, &t, &col);
+                db::move_task_to_column(&state.db_conn, t, col);
+            }
         }
         KeyCode::Char('L') => {
+            if !column.tasks.is_empty() {
                 project.move_task_next_column();
                 let col = project.get_selected_column();
                 let t = col.get_selected_task().unwrap();
-                    db::move_task_to_column(&state.db_conn, &t, &col);
+                db::move_task_to_column(&state.db_conn, t, col);
+            }
         }
         KeyCode::Char('J') => {
             if column.move_task_down() {
                 let task1 = column.get_selected_task().unwrap();
                 let task2 = column.get_previous_task().unwrap();
-                        db::swap_task_order(&mut state.db_conn, &task1, &task2);
+                db::swap_task_order(&mut state.db_conn, task1, task2);
             }
         }
         KeyCode::Char('K') => {
             if column.move_task_up() {
                 let task1 = column.get_selected_task().unwrap();
                 let task2 = column.get_next_task().unwrap();
-                        db::swap_task_order(&mut state.db_conn, &task1, &task2);
+                db::swap_task_order(&mut state.db_conn, task1, task2);
             }
         }
         KeyCode::Char('n') => state.task_edit_state = Some(TaskState::default()),
         KeyCode::Char('e') => {
-                    state.task_edit_state = column.get_task_state_from_curr_selected_task()
+            state.task_edit_state = column.get_task_state_from_curr_selected_task();
         }
         KeyCode::Char('D') => {
+            if !column.tasks.is_empty() {
                 db::delete_task(&state.db_conn, column.get_selected_task().unwrap());
                 column.remove_task();
             }
+        }
         _ => {}
-            },
+    }
+}
+
+/// # Errors
+///
+/// Crossterm `event::read()` might return an error
+///
+/// # Panics
+///
+/// Shouldn't really panic because there are checks to ensure we can unwrap safely
+pub fn handle(state: &mut State<'_>) -> Result<(), std::io::Error> {
+    if let Event::Key(key) = event::read()? {
+        if let Some(task) = state.task_edit_state.take() {
+            handle_task_edit(state, key, task);
+        } else {
+            handle_main(state, key);
         }
     }
     Ok(())

src/main.rs

@@ -15,20 +15,34 @@ use tui::Terminal;
 /// kanban-tui is a simple, interactive TUI based task manager using kanban columns
 pub struct CliArgs {
     #[arg(value_name="DATABASE", value_hint=FilePath, index=1)]
-    /// Path to the
+    /// Path to the SQLite database
     pub filepath: Option<PathBuf>,
 }
 
+// TODO: We either make everything async or we remove the dependency
 #[async_std::main]
 async fn main() -> anyhow::Result<(), Box<dyn Error>> {
     let dbpath = CliArgs::parse()
         .filepath
-        .map(PathBuf::into_os_string)
+        .unwrap_or(PathBuf::from("./kanban.db"));
-        .unwrap_or("kanban.db".into());
 
-    let conn = Connection::open(dbpath)?;
+    let migrate = !dbpath.exists();
 
-    let project = Project::load(&conn).await?;
+    let mut conn = Connection::open(dbpath)?;
+
+    if migrate {
+        let migrations = include_str!("../sql/migrations.sql");
+        let migrations: Vec<&str> = migrations.split(';').collect();
+        let tx = conn.transaction()?;
+        for m in migrations {
+            if !m.trim().is_empty() {
+                tx.execute(m, ())?;
+            }
+        }
+        tx.commit()?;
+    }
+
+    let project = Project::load(&conn)?;
     let mut state = State::new(conn, project);
 
     enable_raw_mode()?;