refactor(cli,models,commands): modularize activity logic, update list handling, and reorganize utils

- move activity-related command logic into src/commands/activity.rs
- update CLI commands and subcommands for improved UX, including better period/date filtering, richer aliases, and input validation
- refactor list command and printable logic; optimize data flow for listing activities, logs, and tags
- Update models to add tags to activities, rework how activity rows are rendered
- Clean up main.rs command dispatch and remove obsolete local implementations, using refactored modules instead
- various small improvements and internal API changes

Author: coko7

src/cli.rs

@@ -1,8 +1,11 @@
 use boat_lib::repository::Id;
+use chrono::NaiveDate;
 use clap::ColorChoice;
 use clap::Parser;
 use clap::{ArgAction, Args, Subcommand, ValueEnum};
 
+use crate::utils;
+
 #[derive(Parser)]
 #[command(
     name = "boat",
@@ -83,24 +86,42 @@ pub enum Commands {
 #[command(rename_all = "kebab-case")]
 pub enum ListSubcommand {
     /// List activity logs
-    #[command(alias = "l", alias = "log")]
+    #[command(name = "logs", alias = "l", alias = "log")]
     Logs(ListActivityArgs),
 
     /// List activities
-    #[command(alias = "a", alias = "act", alias = "acts", alias = "activity")]
+    #[command(
+        name = "acts",
+        alias = "act",
+        alias = "a",
+        alias = "activity",
+        alias = "activities"
+    )]
     Activities(ListArgs),
 
     /// List tags
-    #[command(alias = "t", alias = "tag")]
+    #[command(name = "tags", alias = "t", alias = "tag")]
     Tags(ListArgs),
 }
 
 #[derive(Args, Debug)]
 pub struct ListActivityArgs {
-    /// Only show activities matching a certain period
-    #[arg(short = 'p', long = "period", value_name = "PERIOD", default_value_t = Period::Today, value_enum)]
+    /// Restrict to entries starting in the given <PERIOD>
+    #[arg(short = 'p', long = "period", value_name = "PERIOD", default_value_t = Period::Today, value_enum, conflicts_with_all = ["from", "to", "date"])]
     pub period: Period,
 
+    /// Restrict to entries starting after <DATE> (YYYY-MM-DD format)
+    #[arg(short = 'f', long = "from", value_name = "DATE", value_parser = utils::date::parse_date, conflicts_with = "date")]
+    pub from: Option<NaiveDate>,
+
+    /// Restrict to entries starting before <DATE> (YYYY-MM-DD format)
+    #[arg(short = 't', long = "to", value_name = "DATE", value_parser = utils::date::parse_date, conflicts_with = "date")]
+    pub to: Option<NaiveDate>,
+
+    /// Restrict to entries starting and ending on <DATE> (YYYY-MM-DD format)
+    #[arg(short = 'd', long = "date", value_name = "DATE", value_parser = utils::date::parse_date, conflicts_with_all = ["period", "from", "to"])]
+    pub date: Option<NaiveDate>,
+
     /// Output in JSON
     #[arg(short = 'j', long = "json")]
     pub use_json_format: bool,
@@ -115,23 +136,32 @@ pub struct ListArgs {
 
 #[derive(ValueEnum, Clone, Debug)]
 pub enum Period {
-    #[value(name = "today", alias = "tod", alias = "td")]
+    #[value(name = "today", alias = "td")]
     Today,
-    #[value(name = "yesterday", alias = "yes", alias = "yd")]
+    #[value(name = "yesterday", alias = "yd", alias = "ytd")]
     Yesterday,
-    #[value(name = "this-week", alias = "wk", alias = "week", alias = "toweek")]
+    #[value(name = "this-week", alias = "tw", alias = "twk")]
     ThisWeek,
-    #[value(name = "last-week", alias = "last-wk", alias = "yesterweek")]
+    #[value(
+        name = "last-week",
+        alias = "lw",
+        alias = "lwk",
+        alias = "yesterweek",
+        alias = "yw",
+        alias = "ywk"
+    )]
     LastWeek,
-    #[value(name = "this-month", alias = "mo", alias = "month", alias = "tomonth")]
+    #[value(name = "this-month", alias = "tm", alias = "tmo")]
     ThisMonth,
-    #[value(name = "last-month", alias = "last-mo", alias = "yestermonth")]
+    #[value(
+        name = "last-month",
+        alias = "lm",
+        alias = "lmo",
+        alias = "yestermonth",
+        alias = "ym",
+        alias = "ymo"
+    )]
     LastMonth,
-    // #[value(name = "range")]
-    // DateRange {
-    //     #[arg(value_parser = range_parser)]
-    //     range: RangeInclusive<u32>,
-    // },
 }
 
 #[derive(Args, Debug)]

src/commands/activity.rs

@@ -0,0 +1,92 @@
+use anyhow::{Context, Result};
+use boat_lib::{models::activity::NewActivity, repository::activities_repository as activities};
+use rusqlite::Connection;
+
+use crate::{
+    cli,
+    models::{TablePrintable, activity_log::PrintableActivityLog},
+};
+
+pub fn create(conn: &mut Connection, args: &cli::CreateActivityArgs) -> Result<()> {
+    let new_activity = NewActivity {
+        name: args.name.clone(),
+        description: args.description.clone(),
+        tags: args.tags.clone(),
+    };
+
+    let created = activities::create(conn, new_activity)?;
+    if args.auto_start {
+        activities::start(conn, created.id)?;
+    }
+
+    println!("{}", created.id);
+    Ok(())
+}
+
+pub fn start(conn: &mut Connection, args: &cli::SelectActivityArgs) -> Result<()> {
+    if let Some(current) = activities::get_current_ongoing(conn)? {
+        println!("stopping activity: {current:?}");
+    }
+
+    let act = activities::get_by_id(conn, args.activity_id)?;
+    activities::start(conn, args.activity_id)?;
+    println!("started activity: {act:?}");
+    Ok(())
+}
+
+pub fn pause_current(conn: &mut Connection) -> Result<()> {
+    if let Some(current) = activities::get_current_ongoing(conn)? {
+        let current = PrintableActivityLog::from_activity(&current);
+        activities::stop_current(conn)?;
+        println!("stopped activity: {current:?}");
+    } else {
+        println!("no current activity");
+    }
+    Ok(())
+}
+
+pub fn modify(conn: &mut Connection, args: &cli::ModifyActivityArgs) -> Result<()> {
+    activities::update(
+        conn,
+        args.id,
+        args.update.name.as_deref(),
+        args.update.description.as_deref(),
+        args.update.tags.as_deref(),
+    )?;
+    let act = activities::get_by_id(conn, args.id)?;
+    println!("modified activity: {act:?}");
+    Ok(())
+}
+
+pub fn delete(conn: &mut Connection, args: &cli::SelectActivityArgs) -> Result<()> {
+    let act = activities::get_by_id(conn, args.activity_id)?;
+    activities::delete(conn, args.activity_id)?;
+    println!("deleted activity: {act:?}");
+    Ok(())
+}
+
+pub fn get_current(conn: &mut Connection, args: &cli::PrintActivityArgs) -> Result<()> {
+    let act = activities::get_current_ongoing(conn)?;
+    match act {
+        Some(v) => {
+            let activity_logs = PrintableActivityLog::from_activity(&v);
+            let ongoing_log = activity_logs
+                .iter()
+                .find(|l| l.log.ends_at.is_none())
+                .context("there should be an ongoing log")?
+                .clone();
+
+            if args.use_json_format {
+                let json = serde_json::to_string(&ongoing_log)?;
+                println!("{json}");
+                return Ok(());
+            }
+
+            let items = vec![ongoing_log];
+            let table = items.to_printable_table();
+            println!("{table}");
+        }
+        None => println!("no current activity"),
+    }
+    Ok(())
+}

src/commands/list.rs

@@ -3,14 +3,12 @@ use boat_lib::repository::{activities_repository as activities, tags_repository
 use rusqlite::Connection;
 use serde::Serialize;
 use std::cmp::Reverse;
-use tabular::{Row, Table};
-use yansi::Paint;
 
 use crate::{
     cli,
     models::{
         RowPrintable, TablePrintable, activity::PrintableActivity,
-        activity_with_log::PrintableActivityWithLogs, tag::PrintableTag,
+        activity_log::PrintableActivityLog, tag::PrintableTag,
     },
     utils,
 };
@@ -23,11 +21,11 @@ pub fn list(conn: &mut Connection, command: &cli::ListSubcommand) -> Result<()>
     }
 }
 
-fn list_printable_items<T: RowPrintable + Serialize>(
+pub fn list_printable_items<T: RowPrintable + Serialize>(
     items: Vec<T>,
-    args: &cli::ListArgs,
+    show_as_json: bool,
 ) -> Result<()> {
-    if args.use_json_format {
+    if show_as_json {
         let json = serde_json::to_string(&items)?;
         println!("{json}");
         return Ok(());
@@ -45,7 +43,7 @@ fn list_tags(conn: &mut Connection, args: &cli::ListArgs) -> Result<()> {
         .collect();
     all_tags.sort_by_key(|t| Reverse(t.id));
 
-    list_printable_items(all_tags, args)
+    list_printable_items(all_tags, args.use_json_format)
 }
 
 fn list_activities(conn: &mut Connection, args: &cli::ListArgs) -> Result<()> {
@@ -55,61 +53,22 @@ fn list_activities(conn: &mut Connection, args: &cli::ListArgs) -> Result<()> {
         .collect();
     all_acts.sort_by_key(|a| Reverse(a.id));
 
-    list_printable_items(all_acts, args)
+    list_printable_items(all_acts, args.use_json_format)
 }
 
 fn list_activity_logs(conn: &mut Connection, args: &cli::ListActivityArgs) -> Result<()> {
     let all: Vec<_> = activities::get_all(conn)?
         .iter()
-        .map(PrintableActivityWithLogs::from_activity)
+        .flat_map(PrintableActivityLog::from_activity)
+        .filter(|al| match args.period {
+            cli::Period::Today => utils::date::is_today(al.log.starts_at),
+            cli::Period::Yesterday => utils::date::is_yesterday(al.log.starts_at),
+            cli::Period::ThisWeek => utils::date::is_this_week(al.log.starts_at),
+            cli::Period::LastWeek => utils::date::is_last_week(al.log.starts_at),
+            cli::Period::ThisMonth => utils::date::is_this_month(al.log.starts_at),
+            cli::Period::LastMonth => utils::date::is_last_month(al.log.starts_at),
+        })
         .collect();
 
-    if args.use_json_format {
-        let json = serde_json::to_string(&all)?;
-        println!("{json}");
-    } else {
-        let mut table = Table::new("{:>}  {:<}  {:<}  {:<}  {:<}  {:<}  {:<}");
-        table.add_row(
-            Row::new()
-                .with_ansi_cell("ID".underline())
-                .with_ansi_cell("Name".underline())
-                .with_ansi_cell("Description".underline())
-                .with_ansi_cell("Tags".underline())
-                .with_ansi_cell("Start".underline())
-                .with_ansi_cell("End".underline())
-                .with_ansi_cell("Duration".underline()),
-        );
-
-        let mut log_lines: Vec<_> = all
-            .iter()
-            .flat_map(|act| act.logs.iter().zip(std::iter::repeat(act)))
-            .filter(|(log, _act)| match args.period {
-                cli::Period::Today => utils::is_today(log.starts_at),
-                cli::Period::Yesterday => utils::is_yesterday(log.starts_at),
-                cli::Period::ThisWeek => utils::is_this_week(log.starts_at),
-                cli::Period::LastWeek => utils::is_last_week(log.starts_at),
-                cli::Period::ThisMonth => utils::is_this_month(log.starts_at),
-                cli::Period::LastMonth => utils::is_last_month(log.starts_at),
-            })
-            // .filter(|(log, _act)| utils::is_today(log.starts_at))
-            .collect();
-
-        log_lines.sort_by_key(|(log, _)| log.starts_at);
-
-        for &(log, act) in log_lines.iter() {
-            let mut row = Row::new();
-            let values = utils::convert_to_log_line(log, act);
-            for val in values.iter() {
-                if log.ends_at.is_none() {
-                    row = row.with_ansi_cell(val.green());
-                } else {
-                    row = row.with_cell(val);
-                }
-            }
-            table.add_row(row);
-        }
-        println!("{table}");
-    }
-
-    Ok(())
+    list_printable_items(all, args.use_json_format)
 }

src/commands/mod.rs

@@ -1 +1,2 @@
+pub mod activity;
 pub mod list;