From 71f12ec7f9425c3ace0008d1a7dfab39257afe68 Mon Sep 17 00:00:00 2001 From: Joseph Ferano Date: Wed, 14 Jun 2023 19:13:24 +0700 Subject: [PATCH] WIP Refactoring methods: Merge Project into State, add DBConn struct with impl --- src/app.rs | 153 ++++++++++------------- src/db.rs | 336 ++++++++++++++++++++++++++------------------------- src/input.rs | 80 ++++++------ src/main.rs | 5 +- src/ui.rs | 14 +-- 5 files changed, 279 insertions(+), 309 deletions(-) diff --git a/src/app.rs b/src/app.rs index f0bd6c9..3ab5766 100644 --- a/src/app.rs +++ b/src/app.rs @@ -2,7 +2,7 @@ // use int_enum::IntEnum; use rusqlite::Connection; use serde::{Deserialize, Serialize}; -use std::{cmp::min, error::Error}; +use std::cmp::min; use tui_textarea::TextArea; use crate::db; @@ -25,22 +25,6 @@ pub struct Task { pub description: String, } -/// Type used mainly for serialization at this time -#[derive(Deserialize, Serialize, Debug)] -pub struct Project { - pub name: String, - pub selected_column_idx: usize, - pub columns: Vec, -} - -#[derive(Debug, thiserror::Error)] -pub enum KanbanError { - #[error("There is something wrong with the json schema, it doesn't match Project struct")] - BadJson, - #[error("IO - {0}")] - Io(#[from] std::io::Error), -} - #[derive(Debug)] pub enum TaskEditFocus { Title, @@ -68,24 +52,77 @@ impl Default for TaskState<'_> { } pub struct State<'a> { - pub project: Project, - pub db_conn: Connection, - pub quit: bool, + pub selected_column_idx: usize, pub columns: Vec, + pub db_conn: db::DBConn, + pub quit: bool, pub task_edit_state: Option>, } impl State<'_> { #[must_use] - pub fn new(db_pool: Connection, project: Project) -> Self { + pub fn new(conn: Connection) -> Self { + let db_conn = db::DBConn::new(conn); + let columns = db_conn.get_all_columns().unwrap(); + let selected_column = db_conn.get_selected_column(); State { + columns, + selected_column_idx: selected_column, quit: false, task_edit_state: None, - db_conn: db_pool, - project, - columns: vec![], + db_conn, } } + + #[must_use] + pub fn get_selected_column(&self) -> &Column { + &self.columns[self.selected_column_idx] + } + + pub fn get_selected_column_mut(&mut self) -> &mut Column { + &mut self.columns[self.selected_column_idx] + } + + pub fn select_previous_column(&mut self) -> &Column { + self.selected_column_idx = self.selected_column_idx.saturating_sub(1); + &self.columns[self.selected_column_idx] + } + + pub fn select_next_column(&mut self) -> &Column { + self.selected_column_idx = min(self.selected_column_idx + 1, self.columns.len() - 1); + &self.columns[self.selected_column_idx] + } + + fn move_task_to_column(&mut self, move_next: bool) { + let col_idx = self.selected_column_idx; + let cols_len = self.columns.len(); + let column = self.get_selected_column_mut(); + let cond = if move_next { + col_idx < cols_len - 1 + } else { + col_idx > 0 + }; + if cond && !column.tasks.is_empty() { + let t = column.tasks.remove(column.selected_task_idx); + column.select_previous_task(); + if move_next { + self.select_next_column(); + } else { + self.select_previous_column(); + } + let col = self.get_selected_column_mut(); + col.tasks.push(t); + col.select_last_task(); + } + } + + pub fn move_task_previous_column(&mut self) { + self.move_task_to_column(false); + } + + pub fn move_task_next_column(&mut self) { + self.move_task_to_column(true); + } } impl<'a> Column { @@ -168,71 +205,3 @@ impl<'a> Column { }) } } - -impl Project { - /// . - /// - /// # Errors - /// - /// This function will return an error if it has issues reading from the database - pub fn load(conn: &Connection) -> Result> { - let columns = db::get_all_columns(conn)?; - let selected_column = db::get_selected_column(conn); - - Ok(Project { - name: String::from("Kanban Board"), - columns, - selected_column_idx: selected_column, - }) - } - - #[must_use] - pub fn get_selected_column(&self) -> &Column { - &self.columns[self.selected_column_idx] - } - - pub fn get_selected_column_mut(&mut self) -> &mut Column { - &mut self.columns[self.selected_column_idx] - } - - pub fn select_previous_column(&mut self) -> &Column { - self.selected_column_idx = self.selected_column_idx.saturating_sub(1); - &self.columns[self.selected_column_idx] - } - - pub fn select_next_column(&mut self) -> &Column { - self.selected_column_idx = min(self.selected_column_idx + 1, self.columns.len() - 1); - &self.columns[self.selected_column_idx] - } - - fn move_task_to_column(&mut self, move_next: bool) { - let col_idx = self.selected_column_idx; - let cols_len = self.columns.len(); - let column = self.get_selected_column_mut(); - let cond = if move_next { - col_idx < cols_len - 1 - } else { - col_idx > 0 - }; - if cond && !column.tasks.is_empty() { - let t = column.tasks.remove(column.selected_task_idx); - column.select_previous_task(); - if move_next { - self.select_next_column(); - } else { - self.select_previous_column(); - } - let col = self.get_selected_column_mut(); - col.tasks.push(t); - col.select_last_task(); - } - } - - pub fn move_task_previous_column(&mut self) { - self.move_task_to_column(false); - } - - pub fn move_task_next_column(&mut self) { - self.move_task_to_column(true); - } -} diff --git a/src/db.rs b/src/db.rs index 4c5f7a2..07c594f 100644 --- a/src/db.rs +++ b/src/db.rs @@ -1,112 +1,115 @@ 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> { - let mut stmt = conn.prepare( - r#" +pub struct DBConn(Connection); + +impl DBConn { + pub fn new(conn: Connection) -> Self { + DBConn(conn) + } + + /// . + /// + /// # Errors + /// + /// This function will return an error if something is wrong with the SQL + pub fn get_tasks_by_column(&self, column_name: &String) -> Result> { + let mut stmt = self.0.prepare( + r#" select task.id, title, description from task join kb_column on column_id = kb_column.id where kb_column.name = ?1 order by sort_order "#, - )?; - let mut tasks = Vec::new(); - let rows = stmt.query_map([column_name], |row| { - Ok(Task { - id: row.get(0)?, - title: row.get(1)?, - description: row.get(2)?, - }) - })?; - for row in rows { - tasks.push(row?); - } - Ok(tasks) -} - -/// . -/// -/// # Errors -/// -/// This function will return an error if there are issues with the SQL -pub fn get_all_columns(conn: &Connection) -> Result> { - let mut stmt = conn.prepare("select id, name, selected_task from kb_column")?; - let columns = stmt - .query_map((), |row| { - let name = row.get(1)?; - Ok(Column { + )?; + let mut tasks = Vec::new(); + let rows = stmt.query_map([column_name], |row| { + Ok(Task { id: row.get(0)?, - tasks: get_tasks_by_column(conn, &name)?, - name, - selected_task_idx: row.get(2)?, + title: row.get(1)?, + description: row.get(2)?, }) - })? - .filter_map(Result::ok) - .collect(); - Ok(columns) -} - -/// . -/// -/// # Panics -/// -/// Panics if something goes wrong with the SQL -pub fn insert_new_task( - conn: &Connection, - title: String, - description: String, - column: &Column, -) -> Task { - let mut stmt = conn - .prepare("insert into task(title, description, column_id) values (?1, ?2, ?3)") - .unwrap(); - stmt.execute(params![title, description, column.id]) - .unwrap(); - let id = conn.last_insert_rowid(); - Task { - id, - title, - description, + })?; + for row in rows { + tasks.push(row?); + } + Ok(tasks) } -} -/// . -/// -/// # 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(); -} + /// . + /// + /// # Errors + /// + /// This function will return an error if there are issues with the SQL + pub fn get_all_columns(&self) -> Result> { + let mut stmt = self.0.prepare("select id, name, selected_task from kb_column")?; + let columns = stmt + .query_map((), |row| { + let name = row.get(1)?; + Ok(Column { + id: row.get(0)?, + tasks: self.get_tasks_by_column(&name)?, + name, + selected_task_idx: row.get(2)?, + }) + })? + .filter_map(Result::ok) + .collect(); + Ok(columns) + } -/// . -/// -/// # 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") - .unwrap(); - stmt.execute((&task.id, &task.title, &task.description)) - .unwrap(); -} + /// . + /// + /// # Panics + /// + /// Panics if something goes wrong with the SQL + pub fn insert_new_task(&self, title: String, description: String, column: &Column) -> Task { + let mut stmt = self + .0 + .prepare("insert into task(title, description, column_id) values (?1, ?2, ?3)") + .unwrap(); + stmt.execute(params![title, description, column.id]) + .unwrap(); + let id = self.0.last_insert_rowid(); + Task { + id, + title, + description, + } + } -/// . -/// -/// # 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 + /// . + /// + /// # Panics + /// + /// Panics if something goes wrong with the SQL + pub fn delete_task(&self, task: &Task) { + let mut stmt = self.0.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(&self, task: &Task) { + let mut stmt = self.0 + .prepare("update task set title = ?2, description = ?3 where id = ?1") + .unwrap(); + stmt.execute((&task.id, &task.title, &task.description)) + .unwrap(); + } + + /// . + /// + /// # Panics + /// + /// Panics if something goes wrong with the SQL + pub fn move_task_to_column(&self, task: &Task, target_column: &Column) { + let mut stmt = self.0 + .prepare( + "update task set column_id = ?2, sort_order = coalesce(1 + @@ -114,84 +117,85 @@ pub fn move_task_to_column(conn: &Connection, task: &Task, target_column: &Colum 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(); + self.set_selected_task_for_column(target_column.selected_task_idx, target_column.id); + } + + /// . + /// + /// # Panics + /// + /// Panics if something goes wrong with the SQL + pub fn swap_task_order(&mut self, task1: &Task, task2: &Task) { + let tx = self.0.transaction().unwrap(); + + tx.execute( + "create temp table temp_order as select sort_order from task where id = ?1", + [&task1.id], ) .unwrap(); - stmt.execute((&task.id, &target_column.id)).unwrap(); - set_selected_task_for_column(conn, target_column.selected_task_idx, target_column.id); -} -/// . -/// -/// # 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], - ) - .unwrap(); - - tx.execute( - "update task set sort_order = (select sort_order from task where id = ?2) + tx.execute( + "update task set sort_order = (select sort_order from task where id = ?2) where id = ?1", - (task1.id, task2.id), - ) - .unwrap(); - - tx.execute( - "update task set sort_order = (select sort_order from temp_order) where id = ?1", - [&task2.id], - ) - .unwrap(); - tx.execute("drop table temp_order", ()).unwrap(); - - tx.commit().unwrap(); -} - -/// # Panics -/// -/// Panics if something goes wrong with the SQL -pub fn set_selected_column(conn: &Connection, column_id: usize) { - let mut stmt = conn - .prepare("insert or replace into app_state(key, value) values (?1, ?2)") + (task1.id, task2.id), + ) .unwrap(); - stmt.execute((&"selected_column", column_id.to_string())) - .unwrap(); -} -/// # Panics -/// -/// Panics if something goes wrong with the SQL -pub fn get_selected_column(conn: &Connection) -> usize { - let mut stmt = conn - .prepare("select value from app_state where key = ?1") + tx.execute( + "update task set sort_order = (select sort_order from temp_order) where id = ?1", + [&task2.id], + ) .unwrap(); - stmt.query_row(["selected_column"], |row| { - let value: String = row.get::(0).unwrap(); - Ok(value.parse::().unwrap()) - }) - .unwrap() -} + tx.execute("drop table temp_order", ()).unwrap(); -/// # Panics -/// -/// Panics if something goes wrong with the SQL -pub fn set_selected_task_for_column(conn: &Connection, task_idx: usize, column_id: i32) { - let mut stmt = conn - .prepare("update kb_column set selected_task = ?2 where id = ?1") - .unwrap(); - stmt.execute((column_id, task_idx)).unwrap(); -} + tx.commit().unwrap(); + } -/// # Panics -/// -/// Panics if something goes wrong with the SQL -pub fn get_selected_task_for_column(conn: &Connection, column_id: i32) -> usize { - let mut stmt = conn - .prepare("select selected_task from kb_column where key = ?1") - .unwrap(); - stmt.query_row([column_id], |row| row.get(0)).unwrap() + /// # Panics + /// + /// Panics if something goes wrong with the SQL + pub fn set_selected_column(&self, column_id: usize) { + let mut stmt = self.0 + .prepare("insert or replace into app_state(key, value) values (?1, ?2)") + .unwrap(); + stmt.execute((&"selected_column", column_id.to_string())) + .unwrap(); + } + + /// # Panics + /// + /// Panics if something goes wrong with the SQL + pub fn get_selected_column(&self) -> usize { + let mut stmt = self.0 + .prepare("select value from app_state where key = ?1") + .unwrap(); + stmt.query_row(["selected_column"], |row| { + let value: String = row.get::(0).unwrap(); + Ok(value.parse::().unwrap()) + }) + .unwrap() + } + + /// # Panics + /// + /// Panics if something goes wrong with the SQL + pub fn set_selected_task_for_column(&self, task_idx: usize, column_id: i32) { + let mut stmt = self.0 + .prepare("update kb_column set selected_task = ?2 where id = ?1") + .unwrap(); + stmt.execute((column_id, task_idx)).unwrap(); + } + + /// # Panics + /// + /// Panics if something goes wrong with the SQL + pub fn get_selected_task_for_column(&self, column_id: i32) -> usize { + let mut stmt = self.0 + .prepare("select selected_task from kb_column where key = ?1") + .unwrap(); + stmt.query_row([column_id], |row| row.get(0)).unwrap() + } } diff --git a/src/input.rs b/src/input.rs index fbc2288..9b7b078 100644 --- a/src/input.rs +++ b/src/input.rs @@ -2,11 +2,10 @@ use crate::app::{State, TaskEditFocus, TaskState}; use crate::{db, Column}; use crossterm::event; use crossterm::event::{Event, KeyCode}; -use rusqlite::Connection; // pub fn handle_task_edit(state: &mut State<'_>, key: event::KeyEvent, mut task: TaskState<'_>) { pub fn handle_task_edit( - db_conn: &Connection, + db_conn: &db::DBConn, column: &mut Column, key: event::KeyEvent, task_opt: &mut Option>, @@ -39,12 +38,12 @@ pub fn handle_task_edit( if let Some(selected_task) = column.get_selected_task_mut() { selected_task.title = title; selected_task.description = description; - db::update_task_text(db_conn, selected_task); + db_conn.update_task_text(selected_task); } } else { - let task = db::insert_new_task(db_conn, title, description, column); + let task = db_conn.insert_new_task(title, description, column); column.add_task(task); - db::set_selected_task_for_column(db_conn, column.selected_task_idx, column.id); + db_conn.set_selected_task_for_column(column.selected_task_idx, column.id); } *task_opt = None; } @@ -62,95 +61,94 @@ pub fn handle_task_edit( } pub fn handle_main(state: &mut State<'_>, key: event::KeyEvent) { - let project = &mut state.project; - let column = project.get_selected_column_mut(); + let column = state.get_selected_column_mut(); match key.code { KeyCode::Char('q') => state.quit = true, KeyCode::Char('h') | KeyCode::Left => { - project.select_previous_column(); - db::set_selected_column(&state.db_conn, project.selected_column_idx); + state.select_previous_column(); + state.db_conn.set_selected_column(state.selected_column_idx); } KeyCode::Char('j') | KeyCode::Down => { column.select_next_task(); let task_idx = column.selected_task_idx; - let col_id = project.get_selected_column().id; - db::set_selected_task_for_column(&state.db_conn, task_idx, col_id); + let col_id = state.get_selected_column().id; + state.db_conn.set_selected_task_for_column(task_idx, col_id); } KeyCode::Char('k') | KeyCode::Up => { column.select_previous_task(); let task_idx = column.selected_task_idx; - let col_id = project.get_selected_column().id; - db::set_selected_task_for_column(&state.db_conn, task_idx, col_id); + let col_id = state.get_selected_column().id; + state.db_conn.set_selected_task_for_column(task_idx, col_id); } KeyCode::Char('l') | KeyCode::Right => { - project.select_next_column(); - db::set_selected_column(&state.db_conn, project.selected_column_idx); + state.select_next_column(); + state.db_conn.set_selected_column(state.selected_column_idx); } KeyCode::Char('g') => { column.select_first_task(); let task_idx = column.selected_task_idx; - let col_id = project.get_selected_column().id; - db::set_selected_task_for_column(&state.db_conn, task_idx, col_id); + let col_id = state.get_selected_column().id; + state.db_conn.set_selected_task_for_column(task_idx, col_id); } KeyCode::Char('G') => { column.select_last_task(); let task_idx = column.selected_task_idx; - let col_id = project.get_selected_column().id; - db::set_selected_task_for_column(&state.db_conn, task_idx, col_id); + let col_id = state.get_selected_column().id; + state.db_conn.set_selected_task_for_column(task_idx, col_id); } KeyCode::Char('H') => { if !column.tasks.is_empty() { - let first_col = project.get_selected_column_mut(); + let first_col = state.get_selected_column_mut(); let task_idx = first_col.selected_task_idx.saturating_sub(1); - db::set_selected_task_for_column(&state.db_conn, task_idx, first_col.id); - project.move_task_previous_column(); - let col = project.get_selected_column(); + state.db_conn.set_selected_task_for_column(task_idx, first_col.id); + state.move_task_previous_column(); + let col = state.get_selected_column(); let t = col.get_selected_task().unwrap(); - db::move_task_to_column(&state.db_conn, t, col); - db::set_selected_column(&state.db_conn, project.selected_column_idx); + state.db_conn.move_task_to_column(t, col); + state.db_conn.set_selected_column(state.selected_column_idx); } } KeyCode::Char('L') => { if !column.tasks.is_empty() { - let first_col = project.get_selected_column_mut(); + let first_col = state.get_selected_column_mut(); let task_idx = first_col.selected_task_idx.saturating_sub(1); - db::set_selected_task_for_column(&state.db_conn, task_idx, first_col.id); - project.move_task_next_column(); - let col = project.get_selected_column(); + state.db_conn.set_selected_task_for_column(task_idx, first_col.id); + state.move_task_next_column(); + let col = state.get_selected_column(); let t = col.get_selected_task().unwrap(); - db::move_task_to_column(&state.db_conn, t, col); - db::set_selected_column(&state.db_conn, project.selected_column_idx); + state.db_conn.move_task_to_column(t, col); + state.db_conn.set_selected_column(state.selected_column_idx); } } 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); + state.db_conn.swap_task_order(task1, task2); let task_idx = column.selected_task_idx; - let col_id = project.get_selected_column().id; - db::set_selected_task_for_column(&state.db_conn, task_idx, col_id); + let col_id = state.get_selected_column().id; + state.db_conn.set_selected_task_for_column(task_idx, col_id); } } 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); + state.db_conn.swap_task_order(task1, task2); let task_idx = column.selected_task_idx; - let col_id = project.get_selected_column().id; - db::set_selected_task_for_column(&state.db_conn, task_idx, col_id); + let col_id = state.get_selected_column().id; + state.db_conn.set_selected_task_for_column(task_idx, col_id); } } KeyCode::Char('n') => state.task_edit_state = Some(TaskState::default()), KeyCode::Char('e') => state.task_edit_state = column.get_task_state_from_current(), KeyCode::Char('D') => { if !column.tasks.is_empty() { - db::delete_task(&state.db_conn, column.get_selected_task().unwrap()); + state.db_conn.delete_task(column.get_selected_task().unwrap()); column.remove_task(); let task_idx = column.selected_task_idx; - let col_id = project.get_selected_column().id; - db::set_selected_task_for_column(&state.db_conn, task_idx, col_id); + let col_id = state.get_selected_column().id; + state.db_conn.set_selected_task_for_column(task_idx, col_id); } } _ => {} @@ -167,7 +165,7 @@ pub fn handle_main(state: &mut State<'_>, key: event::KeyEvent) { pub fn handle(state: &mut State<'_>) -> Result<(), std::io::Error> { if let Event::Key(key) = event::read()? { if state.task_edit_state.is_some() { - let column = state.project.get_selected_column_mut(); + let column = state.get_selected_column_mut(); handle_task_edit(&state.db_conn, column, key, &mut state.task_edit_state); } else { handle_main(state, key); diff --git a/src/main.rs b/src/main.rs index 4000de7..391ed2e 100644 --- a/src/main.rs +++ b/src/main.rs @@ -4,7 +4,7 @@ use crossterm::{ event::{DisableMouseCapture, EnableMouseCapture}, terminal::{disable_raw_mode, enable_raw_mode, EnterAlternateScreen, LeaveAlternateScreen}, }; -use kanban_tui::{Project, State}; +use kanban_tui::State; use rusqlite::Connection; use std::{error::Error, io, path::PathBuf}; use tui::backend::CrosstermBackend; @@ -40,8 +40,7 @@ fn main() -> anyhow::Result<(), Box> { tx.commit()?; } - let project = Project::load(&conn)?; - let mut state = State::new(conn, project); + let mut state = State::new(conn); enable_raw_mode()?; let mut stdout = io::stdout(); diff --git a/src/ui.rs b/src/ui.rs index f64d4a8..d6bd30b 100644 --- a/src/ui.rs +++ b/src/ui.rs @@ -11,22 +11,22 @@ fn draw_tasks(f: &mut Frame<'_, B>, area: Rect, state: &State<'_>) { .direction(Direction::Horizontal) .constraints( vec![ - Constraint::Percentage(100 / u16::try_from(state.project.columns.len()).unwrap()); - state.project.columns.len() + Constraint::Percentage(100 / u16::try_from(state.columns.len()).unwrap()); + state.columns.len() ] .as_ref(), ) .split(area); - for (i, column) in state.project.columns.iter().enumerate() { + for (i, column) in state.columns.iter().enumerate() { let items: Vec> = column .tasks .iter() .enumerate() .map(|(j, task)| { let mut style = Style::default(); - let col_idx = state.project.selected_column_idx; - let task_idx = state.project.get_selected_column().selected_task_idx; + let col_idx = state.selected_column_idx; + let task_idx = state.get_selected_column().selected_task_idx; let item_txt; if i == col_idx && j == task_idx { style = style.add_modifier(Modifier::BOLD | Modifier::UNDERLINED); @@ -40,7 +40,7 @@ fn draw_tasks(f: &mut Frame<'_, B>, area: Rect, state: &State<'_>) { }) .collect(); let mut style = Style::default(); - if i == state.project.selected_column_idx { + if i == state.selected_column_idx { style = style.add_modifier(Modifier::REVERSED); }; let mut s = Span::raw(column.name.as_str()); @@ -60,7 +60,7 @@ fn draw_tasks(f: &mut Frame<'_, B>, area: Rect, state: &State<'_>) { fn draw_task_info(f: &mut Frame<'_, B>, area: Rect, state: &State<'_>) { let block = Block::default().title("TASK INFO").borders(Borders::ALL); - if let Some(task) = state.project.get_selected_column().get_selected_task() { + if let Some(task) = state.get_selected_column().get_selected_task() { let p = Paragraph::new(task.description.as_str()) .block(block) .wrap(Wrap { trim: true });