JosephFerano/kanban-tui
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

WIP Refactoring methods: Merge Project into State, add DBConn struct with impl

Browse Source
This commit is contained in:
Joseph Ferano 2023-06-14 19:13:24 +07:00
parent 4accf41c45
commit 71f12ec7f9
5 changed files with 279 additions and 309 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

153
src/app.rs
View File

@ -2,7 +2,7 @@
// use int_enum::IntEnum; // use int_enum::IntEnum;
use rusqlite::Connection; use rusqlite::Connection;
use serde::{Deserialize, Serialize}; use serde::{Deserialize, Serialize};
use std::{cmp::min, error::Error}; use std::cmp::min;
use tui_textarea::TextArea; use tui_textarea::TextArea;
use crate::db; use crate::db;
@ -25,22 +25,6 @@ pub struct Task {
pub description: String, 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<Column>,
}
#[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)] #[derive(Debug)]
pub enum TaskEditFocus { pub enum TaskEditFocus {
Title, Title,
@ -68,24 +52,77 @@ impl Default for TaskState<'_> {
} }
pub struct State<'a> { pub struct State<'a> {
pub project: Project, pub selected_column_idx: usize,
pub db_conn: Connection,
pub quit: bool,
pub columns: Vec<Column>, pub columns: Vec<Column>,
pub db_conn: db::DBConn,
pub quit: bool,
pub task_edit_state: Option<TaskState<'a>>, pub task_edit_state: Option<TaskState<'a>>,
} }
impl State<'_> { impl State<'_> {
#[must_use] #[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 { State {
columns,
selected_column_idx: selected_column,
quit: false, quit: false,
task_edit_state: None, task_edit_state: None,
db_conn: db_pool, db_conn,
project,
columns: vec![],
} }
} }
#[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 { 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<Self, Box<dyn Error>> {
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);
}
}

64
src/db.rs
View File

@ -1,13 +1,20 @@
use crate::{Column, Task}; use crate::{Column, Task};
use rusqlite::{params, Connection, Result}; use rusqlite::{params, Connection, Result};
pub struct DBConn(Connection);
impl DBConn {
pub fn new(conn: Connection) -> Self {
DBConn(conn)
}
/// . /// .
/// ///
/// # Errors /// # Errors
/// ///
/// This function will return an error if something is wrong with the SQL /// 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>> { pub fn get_tasks_by_column(&self, column_name: &String) -> Result<Vec<Task>> {
let mut stmt = conn.prepare( let mut stmt = self.0.prepare(
r#" r#"
select task.id, title, description from task select task.id, title, description from task
join kb_column on column_id = kb_column.id join kb_column on column_id = kb_column.id
@ -34,14 +41,14 @@ pub fn get_tasks_by_column(conn: &Connection, column_name: &String) -> Result<Ve
/// # Errors /// # Errors
/// ///
/// This function will return an error if there are issues with the SQL /// This function will return an error if there are issues with the SQL
pub fn get_all_columns(conn: &Connection) -> Result<Vec<Column>> { pub fn get_all_columns(&self) -> Result<Vec<Column>> {
let mut stmt = conn.prepare("select id, name, selected_task from kb_column")?; let mut stmt = self.0.prepare("select id, name, selected_task from kb_column")?;
let columns = stmt let columns = stmt
.query_map((), |row| { .query_map((), |row| {
let name = row.get(1)?; let name = row.get(1)?;
Ok(Column { Ok(Column {
id: row.get(0)?, id: row.get(0)?,
tasks: get_tasks_by_column(conn, &name)?, tasks: self.get_tasks_by_column(&name)?,
name, name,
selected_task_idx: row.get(2)?, selected_task_idx: row.get(2)?,
}) })
@ -56,18 +63,14 @@ pub fn get_all_columns(conn: &Connection) -> Result<Vec<Column>> {
/// # Panics /// # Panics
/// ///
/// Panics if something goes wrong with the SQL /// Panics if something goes wrong with the SQL
pub fn insert_new_task( pub fn insert_new_task(&self, title: String, description: String, column: &Column) -> Task {
conn: &Connection, let mut stmt = self
title: String, .0
description: String,
column: &Column,
) -> Task {
let mut stmt = conn
.prepare("insert into task(title, description, column_id) values (?1, ?2, ?3)") .prepare("insert into task(title, description, column_id) values (?1, ?2, ?3)")
.unwrap(); .unwrap();
stmt.execute(params![title, description, column.id]) stmt.execute(params![title, description, column.id])
.unwrap(); .unwrap();
let id = conn.last_insert_rowid(); let id = self.0.last_insert_rowid();
Task { Task {
id, id,
title, title,
@ -80,8 +83,8 @@ pub fn insert_new_task(
/// # Panics /// # Panics
/// ///
/// Panics if something goes wrong with the SQL /// Panics if something goes wrong with the SQL
pub fn delete_task(conn: &Connection, task: &Task) { pub fn delete_task(&self, task: &Task) {
let mut stmt = conn.prepare("delete from task where id = ?1").unwrap(); let mut stmt = self.0.prepare("delete from task where id = ?1").unwrap();
stmt.execute([task.id]).unwrap(); stmt.execute([task.id]).unwrap();
} }
@ -90,8 +93,8 @@ pub fn delete_task(conn: &Connection, task: &Task) {
/// # Panics /// # Panics
/// ///
/// Panics if something goes wrong with the SQL /// Panics if something goes wrong with the SQL
pub fn update_task_text(conn: &Connection, task: &Task) { pub fn update_task_text(&self, task: &Task) {
let mut stmt = conn let mut stmt = self.0
.prepare("update task set title = ?2, description = ?3 where id = ?1") .prepare("update task set title = ?2, description = ?3 where id = ?1")
.unwrap(); .unwrap();
stmt.execute((&task.id, &task.title, &task.description)) stmt.execute((&task.id, &task.title, &task.description))
@ -103,8 +106,8 @@ pub fn update_task_text(conn: &Connection, task: &Task) {
/// # Panics /// # Panics
/// ///
/// Panics if something goes wrong with the SQL /// Panics if something goes wrong with the SQL
pub fn move_task_to_column(conn: &Connection, task: &Task, target_column: &Column) { pub fn move_task_to_column(&self, task: &Task, target_column: &Column) {
let mut stmt = conn let mut stmt = self.0
.prepare( .prepare(
"update task "update task
set set
@ -117,7 +120,7 @@ pub fn move_task_to_column(conn: &Connection, task: &Task, target_column: &Colum
) )
.unwrap(); .unwrap();
stmt.execute((&task.id, &target_column.id)).unwrap(); stmt.execute((&task.id, &target_column.id)).unwrap();
set_selected_task_for_column(conn, target_column.selected_task_idx, target_column.id); self.set_selected_task_for_column(target_column.selected_task_idx, target_column.id);
} }
/// . /// .
@ -125,8 +128,8 @@ pub fn move_task_to_column(conn: &Connection, task: &Task, target_column: &Colum
/// # Panics /// # Panics
/// ///
/// Panics if something goes wrong with the SQL /// Panics if something goes wrong with the SQL
pub fn swap_task_order(conn: &mut Connection, task1: &Task, task2: &Task) { pub fn swap_task_order(&mut self, task1: &Task, task2: &Task) {
let tx = conn.transaction().unwrap(); let tx = self.0.transaction().unwrap();
tx.execute( tx.execute(
"create temp table temp_order as select sort_order from task where id = ?1", "create temp table temp_order as select sort_order from task where id = ?1",
@ -154,8 +157,8 @@ pub fn swap_task_order(conn: &mut Connection, task1: &Task, task2: &Task) {
/// # Panics /// # Panics
/// ///
/// Panics if something goes wrong with the SQL /// Panics if something goes wrong with the SQL
pub fn set_selected_column(conn: &Connection, column_id: usize) { pub fn set_selected_column(&self, column_id: usize) {
let mut stmt = conn let mut stmt = self.0
.prepare("insert or replace into app_state(key, value) values (?1, ?2)") .prepare("insert or replace into app_state(key, value) values (?1, ?2)")
.unwrap(); .unwrap();
stmt.execute((&"selected_column", column_id.to_string())) stmt.execute((&"selected_column", column_id.to_string()))
@ -165,8 +168,8 @@ pub fn set_selected_column(conn: &Connection, column_id: usize) {
/// # Panics /// # Panics
/// ///
/// Panics if something goes wrong with the SQL /// Panics if something goes wrong with the SQL
pub fn get_selected_column(conn: &Connection) -> usize { pub fn get_selected_column(&self) -> usize {
let mut stmt = conn let mut stmt = self.0
.prepare("select value from app_state where key = ?1") .prepare("select value from app_state where key = ?1")
.unwrap(); .unwrap();
stmt.query_row(["selected_column"], |row| { stmt.query_row(["selected_column"], |row| {
@ -179,8 +182,8 @@ pub fn get_selected_column(conn: &Connection) -> usize {
/// # Panics /// # Panics
/// ///
/// Panics if something goes wrong with the SQL /// Panics if something goes wrong with the SQL
pub fn set_selected_task_for_column(conn: &Connection, task_idx: usize, column_id: i32) { pub fn set_selected_task_for_column(&self, task_idx: usize, column_id: i32) {
let mut stmt = conn let mut stmt = self.0
.prepare("update kb_column set selected_task = ?2 where id = ?1") .prepare("update kb_column set selected_task = ?2 where id = ?1")
.unwrap(); .unwrap();
stmt.execute((column_id, task_idx)).unwrap(); stmt.execute((column_id, task_idx)).unwrap();
@ -189,9 +192,10 @@ pub fn set_selected_task_for_column(conn: &Connection, task_idx: usize, column_i
/// # Panics /// # Panics
/// ///
/// Panics if something goes wrong with the SQL /// Panics if something goes wrong with the SQL
pub fn get_selected_task_for_column(conn: &Connection, column_id: i32) -> usize { pub fn get_selected_task_for_column(&self, column_id: i32) -> usize {
let mut stmt = conn let mut stmt = self.0
.prepare("select selected_task from kb_column where key = ?1") .prepare("select selected_task from kb_column where key = ?1")
.unwrap(); .unwrap();
stmt.query_row([column_id], |row| row.get(0)).unwrap() stmt.query_row([column_id], |row| row.get(0)).unwrap()
} }
}

80
src/input.rs
View File

@ -2,11 +2,10 @@ use crate::app::{State, TaskEditFocus, TaskState};
use crate::{db, Column}; use crate::{db, Column};
use crossterm::event; use crossterm::event;
use crossterm::event::{Event, KeyCode}; 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(state: &mut State<'_>, key: event::KeyEvent, mut task: TaskState<'_>) {
pub fn handle_task_edit( pub fn handle_task_edit(
db_conn: &Connection, db_conn: &db::DBConn,
column: &mut Column, column: &mut Column,
key: event::KeyEvent, key: event::KeyEvent,
task_opt: &mut Option<TaskState<'_>>, task_opt: &mut Option<TaskState<'_>>,
@ -39,12 +38,12 @@ pub fn handle_task_edit(
if let Some(selected_task) = column.get_selected_task_mut() { if let Some(selected_task) = column.get_selected_task_mut() {
selected_task.title = title; selected_task.title = title;
selected_task.description = description; selected_task.description = description;
db::update_task_text(db_conn, selected_task); db_conn.update_task_text(selected_task);
} }
} else { } 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); 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; *task_opt = None;
} }
@ -62,95 +61,94 @@ pub fn handle_task_edit(
} }
pub fn handle_main(state: &mut State<'_>, key: event::KeyEvent) { pub fn handle_main(state: &mut State<'_>, key: event::KeyEvent) {
let project = &mut state.project; let column = state.get_selected_column_mut();
let column = project.get_selected_column_mut();
match key.code { match key.code {
KeyCode::Char('q') => state.quit = true, KeyCode::Char('q') => state.quit = true,
KeyCode::Char('h') | KeyCode::Left => { KeyCode::Char('h') | KeyCode::Left => {
project.select_previous_column(); state.select_previous_column();
db::set_selected_column(&state.db_conn, project.selected_column_idx); state.db_conn.set_selected_column(state.selected_column_idx);
} }
KeyCode::Char('j') | KeyCode::Down => { KeyCode::Char('j') | KeyCode::Down => {
column.select_next_task(); column.select_next_task();
let task_idx = column.selected_task_idx; let task_idx = column.selected_task_idx;
let col_id = project.get_selected_column().id; let col_id = state.get_selected_column().id;
db::set_selected_task_for_column(&state.db_conn, task_idx, col_id); state.db_conn.set_selected_task_for_column(task_idx, col_id);
} }
KeyCode::Char('k') | KeyCode::Up => { KeyCode::Char('k') | KeyCode::Up => {
column.select_previous_task(); column.select_previous_task();
let task_idx = column.selected_task_idx; let task_idx = column.selected_task_idx;
let col_id = project.get_selected_column().id; let col_id = state.get_selected_column().id;
db::set_selected_task_for_column(&state.db_conn, task_idx, col_id); state.db_conn.set_selected_task_for_column(task_idx, col_id);
} }
KeyCode::Char('l') | KeyCode::Right => { KeyCode::Char('l') | KeyCode::Right => {
project.select_next_column(); state.select_next_column();
db::set_selected_column(&state.db_conn, project.selected_column_idx); state.db_conn.set_selected_column(state.selected_column_idx);
} }
KeyCode::Char('g') => { KeyCode::Char('g') => {
column.select_first_task(); column.select_first_task();
let task_idx = column.selected_task_idx; let task_idx = column.selected_task_idx;
let col_id = project.get_selected_column().id; let col_id = state.get_selected_column().id;
db::set_selected_task_for_column(&state.db_conn, task_idx, col_id); state.db_conn.set_selected_task_for_column(task_idx, col_id);
} }
KeyCode::Char('G') => { KeyCode::Char('G') => {
column.select_last_task(); column.select_last_task();
let task_idx = column.selected_task_idx; let task_idx = column.selected_task_idx;
let col_id = project.get_selected_column().id; let col_id = state.get_selected_column().id;
db::set_selected_task_for_column(&state.db_conn, task_idx, col_id); state.db_conn.set_selected_task_for_column(task_idx, col_id);
} }
KeyCode::Char('H') => { KeyCode::Char('H') => {
if !column.tasks.is_empty() { 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); 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); state.db_conn.set_selected_task_for_column(task_idx, first_col.id);
project.move_task_previous_column(); state.move_task_previous_column();
let col = project.get_selected_column(); let col = state.get_selected_column();
let t = col.get_selected_task().unwrap(); let t = col.get_selected_task().unwrap();
db::move_task_to_column(&state.db_conn, t, col); state.db_conn.move_task_to_column(t, col);
db::set_selected_column(&state.db_conn, project.selected_column_idx); state.db_conn.set_selected_column(state.selected_column_idx);
} }
} }
KeyCode::Char('L') => { KeyCode::Char('L') => {
if !column.tasks.is_empty() { 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); 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); state.db_conn.set_selected_task_for_column(task_idx, first_col.id);
project.move_task_next_column(); state.move_task_next_column();
let col = project.get_selected_column(); let col = state.get_selected_column();
let t = col.get_selected_task().unwrap(); let t = col.get_selected_task().unwrap();
db::move_task_to_column(&state.db_conn, t, col); state.db_conn.move_task_to_column(t, col);
db::set_selected_column(&state.db_conn, project.selected_column_idx); state.db_conn.set_selected_column(state.selected_column_idx);
} }
} }
KeyCode::Char('J') => { KeyCode::Char('J') => {
if column.move_task_down() { if column.move_task_down() {
let task1 = column.get_selected_task().unwrap(); let task1 = column.get_selected_task().unwrap();
let task2 = column.get_previous_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 task_idx = column.selected_task_idx;
let col_id = project.get_selected_column().id; let col_id = state.get_selected_column().id;
db::set_selected_task_for_column(&state.db_conn, task_idx, col_id); state.db_conn.set_selected_task_for_column(task_idx, col_id);
} }
} }
KeyCode::Char('K') => { KeyCode::Char('K') => {
if column.move_task_up() { if column.move_task_up() {
let task1 = column.get_selected_task().unwrap(); let task1 = column.get_selected_task().unwrap();
let task2 = column.get_next_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 task_idx = column.selected_task_idx;
let col_id = project.get_selected_column().id; let col_id = state.get_selected_column().id;
db::set_selected_task_for_column(&state.db_conn, task_idx, col_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('n') => state.task_edit_state = Some(TaskState::default()),
KeyCode::Char('e') => state.task_edit_state = column.get_task_state_from_current(), KeyCode::Char('e') => state.task_edit_state = column.get_task_state_from_current(),
KeyCode::Char('D') => { KeyCode::Char('D') => {
if !column.tasks.is_empty() { 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(); column.remove_task();
let task_idx = column.selected_task_idx; let task_idx = column.selected_task_idx;
let col_id = project.get_selected_column().id; let col_id = state.get_selected_column().id;
db::set_selected_task_for_column(&state.db_conn, task_idx, col_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> { pub fn handle(state: &mut State<'_>) -> Result<(), std::io::Error> {
if let Event::Key(key) = event::read()? { if let Event::Key(key) = event::read()? {
if state.task_edit_state.is_some() { 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); handle_task_edit(&state.db_conn, column, key, &mut state.task_edit_state);
} else { } else {
handle_main(state, key); handle_main(state, key);

5
src/main.rs
View File

@ -4,7 +4,7 @@ use crossterm::{
event::{DisableMouseCapture, EnableMouseCapture}, event::{DisableMouseCapture, EnableMouseCapture},
terminal::{disable_raw_mode, enable_raw_mode, EnterAlternateScreen, LeaveAlternateScreen}, terminal::{disable_raw_mode, enable_raw_mode, EnterAlternateScreen, LeaveAlternateScreen},
}; };
use kanban_tui::{Project, State}; use kanban_tui::State;
use rusqlite::Connection; use rusqlite::Connection;
use std::{error::Error, io, path::PathBuf}; use std::{error::Error, io, path::PathBuf};
use tui::backend::CrosstermBackend; use tui::backend::CrosstermBackend;
@ -40,8 +40,7 @@ fn main() -> anyhow::Result<(), Box<dyn Error>> {
tx.commit()?; tx.commit()?;
} }
let project = Project::load(&conn)?; let mut state = State::new(conn);
let mut state = State::new(conn, project);
enable_raw_mode()?; enable_raw_mode()?;
let mut stdout = io::stdout(); let mut stdout = io::stdout();

14
src/ui.rs
View File

@ -11,22 +11,22 @@ fn draw_tasks<B: Backend>(f: &mut Frame<'_, B>, area: Rect, state: &State<'_>) {
.direction(Direction::Horizontal) .direction(Direction::Horizontal)
.constraints( .constraints(
vec![ vec![
Constraint::Percentage(100 / u16::try_from(state.project.columns.len()).unwrap()); Constraint::Percentage(100 / u16::try_from(state.columns.len()).unwrap());
state.project.columns.len() state.columns.len()
] ]
.as_ref(), .as_ref(),
) )
.split(area); .split(area);
for (i, column) in state.project.columns.iter().enumerate() { for (i, column) in state.columns.iter().enumerate() {
let items: Vec<ListItem<'_>> = column let items: Vec<ListItem<'_>> = column
.tasks .tasks
.iter() .iter()
.enumerate() .enumerate()
.map(|(j, task)| { .map(|(j, task)| {
let mut style = Style::default(); let mut style = Style::default();
let col_idx = state.project.selected_column_idx; let col_idx = state.selected_column_idx;
let task_idx = state.project.get_selected_column().selected_task_idx; let task_idx = state.get_selected_column().selected_task_idx;
let item_txt; let item_txt;
if i == col_idx && j == task_idx { if i == col_idx && j == task_idx {
style = style.add_modifier(Modifier::BOLD | Modifier::UNDERLINED); style = style.add_modifier(Modifier::BOLD | Modifier::UNDERLINED);
@ -40,7 +40,7 @@ fn draw_tasks<B: Backend>(f: &mut Frame<'_, B>, area: Rect, state: &State<'_>) {
}) })
.collect(); .collect();
let mut style = Style::default(); let mut style = Style::default();
if i == state.project.selected_column_idx { if i == state.selected_column_idx {
style = style.add_modifier(Modifier::REVERSED); style = style.add_modifier(Modifier::REVERSED);
}; };
let mut s = Span::raw(column.name.as_str()); let mut s = Span::raw(column.name.as_str());
@ -60,7 +60,7 @@ fn draw_tasks<B: Backend>(f: &mut Frame<'_, B>, area: Rect, state: &State<'_>) {
fn draw_task_info<B: Backend>(f: &mut Frame<'_, B>, area: Rect, state: &State<'_>) { fn draw_task_info<B: Backend>(f: &mut Frame<'_, B>, area: Rect, state: &State<'_>) {
let block = Block::default().title("TASK INFO").borders(Borders::ALL); 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()) let p = Paragraph::new(task.description.as_str())
.block(block) .block(block)
.wrap(Wrap { trim: true }); .wrap(Wrap { trim: true });