refactor(cli,models,config): modularize commands, update config to use db, and modernize listing system

- replace monolithic CLI and models with modular structure (new commands/* and models/* modules)
- switch config from CSV-based to database-based; add setup of config/database paths and improve config initialization
- update list command to use subcommands (logs/activities/tags), wip support for advanced filtering/formatting
- refine help/usage output text
- clean up main.rs for new flow and generalized configuration/command bootstrapping
- add date utilities for period filtering (today, week, month, etc.)

Author: coko7

README.md

@@ -15,13 +15,13 @@ This is only the code for the command line application. It relies on [`boat-lib`
 > This cli is actively being developed. Since it's in its early stages, things will likely break often.
 > Don't use it for now.
 
-## Why was this tool created?
+## 🤔 Why was this tool created?
 
 The [`bartib`](https://github.com/nikolassv/bartib) cli is what inspired me to create `boat`.
 It's a feature-full tool that I used for a while, but I found it quite limiting for my usage due to its [lack of support for machine-readable output](https://github.com/nikolassv/bartib/pull/26).
 That's it, I wanted an activity tracker that I could combine easily with [`jq`](https://github.com/jqlang/jq) and so I decided to make my own tool.
 
-## Installation
+## 🛠️ Installation
 
 The easiest way to install is through [crates.io](https://crates.io/crates/boat-cli):
 ```sh
@@ -51,28 +51,45 @@ cd boat-cli
 cargo build --release --features bundled-sqlite
 ```
 
-## Usage
+## ⚙️ Configuration
+
+By default, `boat` will create a configuration file in one of the following dirs:
+- 🐧 **Linux:** `/home/<user>/.config/boat/config.toml`
+- 🪟 **Windows:** `C:\Users\<user>\AppData\Roaming\boat\config.toml`
+- 🍎 **macOS:** `/Users/<user>/Library/Application Support/boat/config.toml`
+
+It will also keep the SQLite database file `boat.db` in the same directory (unless specified otherwise in config):
+```toml
+database_path = "/home/<user>/.config/boat/boat.db"
+```
+You can override the default configuration file path by setting the `BOAT_CONFIG` environment variable.
+
+## ✨ Usage
 
 To get a feel of how `boat` can be used, you can try `boat help` to get the list of commands:
 ```help
+boat 0.2.1
+
 Basic Opinionated Activity Tracker
 
-Usage: boat <COMMAND>
+Usage:
+boat <COMMAND>
 
 Commands:
   new     Create a new activity
   start   Start/resume an activity
-  config  Manage configuration
   pause   Pause/stop the current activity
   modify  Modify an activity
   delete  Delete an activity
   get     Get the current activity
-  list    List activities and tags
+  list    List boat objects
   help    Print this message or the help of the given subcommand(s)
 
 Options:
   -h, --help     Print help
   -V, --version  Print version
+
+Made by @coko7 <contact@coko7.fr>
 ```
 
 If you want to invoke `boat` from your command-line directly, you can make use of a variety of shorter aliases:
@@ -86,6 +103,7 @@ Commands:
   delete  d, del
   get     g
   list    l, ls
+  help    h, -h, --help
 ```
 I really wanted to have each command start with a different character so that I could assign a single-char alias to all of them.
 That explains why some of the commands do not use a more fitting keyword.

src/cli.rs

@@ -1,15 +1,16 @@
-use std::ops::RangeInclusive;
-
 use boat_lib::repository::Id;
-use clap::{ArgAction, Args, Parser, Subcommand, ValueEnum};
+use clap::ColorChoice;
+use clap::Parser;
+use clap::{ArgAction, Args, Subcommand, ValueEnum};
 
 #[derive(Parser)]
 #[command(
     name = "boat",
     version,
+    author = "Made by @coko7 <contact@coko7.fr>",
+    color = ColorChoice::Auto,
     about = "Basic Opinionated Activity Tracker",
-    author = "coko7",
-    long_about = None
+    help_template = "{name} {version}\n\n{about}\n\n{usage-heading}\n{usage}\n\n{all-args}\n\n{author}"
 )]
 pub struct Cli {
     #[command(subcommand)]
@@ -31,10 +32,9 @@ pub enum Commands {
     #[command(alias = "s", alias = "st", alias = "sail")]
     Start(SelectActivityArgs),
 
-    /// Manage configuration
-    #[command(alias = "c", alias = "cfg", alias = "conf")]
-    Config {},
-
+    // /// Manage configuration
+    // #[command(alias = "c", alias = "cfg", alias = "conf")]
+    // Config {},
     /// Pause/stop the current activity
     #[command(alias = "p", alias = "stop")]
     Pause,
@@ -51,9 +51,12 @@ pub enum Commands {
     #[command(alias = "g")]
     Get(PrintActivityArgs),
 
-    /// List activities and tags
+    /// List boat objects
     #[command(alias = "l", alias = "ls")]
-    List(ListActivityArgs),
+    List {
+        #[command(subcommand)]
+        command: ListSubcommand,
+    },
 
     // This is ONLY way I could find to use the 'h' short alias for help.
     #[command(alias = "h", hide = true)]
@@ -76,8 +79,23 @@ pub enum Commands {
     // ^^^ or maybe export 'x' ???
 }
 
+#[derive(Subcommand)]
+#[command(rename_all = "kebab-case")]
+pub enum ListSubcommand {
+    /// List activity logs
+    #[command(alias = "l", alias = "log")]
+    Logs(ListActivityArgs),
+
+    /// List activities
+    #[command(alias = "a", alias = "act", alias = "acts", alias = "activity")]
+    Activities(ListArgs),
+
+    /// List tags
+    #[command(alias = "t", alias = "tag")]
+    Tags(ListArgs),
+}
+
 #[derive(Args, Debug)]
-#[group(multiple = false)]
 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)]
@@ -88,18 +106,27 @@ pub struct ListActivityArgs {
     pub use_json_format: bool,
 }
 
+#[derive(Args, Debug)]
+pub struct ListArgs {
+    /// Output in JSON
+    #[arg(short = 'j', long = "json")]
+    pub use_json_format: bool,
+}
+
 #[derive(ValueEnum, Clone, Debug)]
 pub enum Period {
     #[value(name = "today", alias = "tod", alias = "td")]
     Today,
     #[value(name = "yesterday", alias = "yes", alias = "yd")]
     Yesterday,
-    #[value(name = "week", alias = "wk")]
+    #[value(name = "this-week", alias = "wk", alias = "week", alias = "toweek")]
     ThisWeek,
-    #[value(name = "last_week")]
+    #[value(name = "last-week", alias = "last-wk", alias = "yesterweek")]
     LastWeek,
-    #[value(name = "month", alias = "mo")]
+    #[value(name = "this-month", alias = "mo", alias = "month", alias = "tomonth")]
     ThisMonth,
+    #[value(name = "last-month", alias = "last-mo", alias = "yestermonth")]
+    LastMonth,
     // #[value(name = "range")]
     // DateRange {
     //     #[arg(value_parser = range_parser)]

src/commands/list.rs

@@ -0,0 +1,115 @@
+use anyhow::Result;
+use boat_lib::repository::{activities_repository as activities, tags_repository as tags};
+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,
+    },
+    utils,
+};
+
+pub fn list(conn: &mut Connection, command: &cli::ListSubcommand) -> Result<()> {
+    match command {
+        cli::ListSubcommand::Logs(args) => list_activity_logs(conn, args),
+        cli::ListSubcommand::Activities(args) => list_activities(conn, args),
+        cli::ListSubcommand::Tags(args) => list_tags(conn, args),
+    }
+}
+
+fn list_printable_items<T: RowPrintable + Serialize>(
+    items: Vec<T>,
+    args: &cli::ListArgs,
+) -> Result<()> {
+    if args.use_json_format {
+        let json = serde_json::to_string(&items)?;
+        println!("{json}");
+        return Ok(());
+    }
+
+    let table = items.to_printable_table();
+    println!("{table}");
+    Ok(())
+}
+
+fn list_tags(conn: &mut Connection, args: &cli::ListArgs) -> Result<()> {
+    let mut all_tags: Vec<_> = tags::get_all(conn)?
+        .iter()
+        .map(PrintableTag::from_tag)
+        .collect();
+    all_tags.sort_by_key(|t| Reverse(t.id));
+
+    list_printable_items(all_tags, args)
+}
+
+fn list_activities(conn: &mut Connection, args: &cli::ListArgs) -> Result<()> {
+    let mut all_acts: Vec<_> = activities::get_all(conn)?
+        .iter()
+        .map(PrintableActivity::from_activity)
+        .collect();
+    all_acts.sort_by_key(|a| Reverse(a.id));
+
+    list_printable_items(all_acts, args)
+}
+
+fn list_activity_logs(conn: &mut Connection, args: &cli::ListActivityArgs) -> Result<()> {
+    let all: Vec<_> = activities::get_all(conn)?
+        .iter()
+        .map(PrintableActivityWithLogs::from_activity)
+        .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(())
+}

src/commands/mod.rs

@@ -0,0 +1 @@
+pub mod list;

src/config.rs

@@ -7,31 +7,32 @@ use std::{env, fs, path::PathBuf};
 pub const APP_NAME: &str = "boat";
 pub const CONFIG_VAR: &str = "BOAT_CONFIG";
 pub const DEFAULT_CONFIG_PATH: &str = "config.toml";
-
-pub const DEFAULT_ACT_DEFS_PATH: &str = "act_defs.csv";
-pub const DEFAULT_ACT_LOGS_PATH: &str = "act_logs.csv";
+pub const DEFAULT_DB_FILE: &str = "boat.db";
 
 #[derive(Debug, Serialize, Deserialize)]
 pub struct Configuration {
-    #[serde(rename = "activity_definitions_path")]
-    pub activity_definitions_path: PathBuf,
-
-    #[serde(rename = "activity_logs_path")]
-    pub activity_logs_path: PathBuf,
+    #[serde(rename = "database_path")]
+    pub database_path: PathBuf,
 }
 
 impl Configuration {
-    pub fn new() -> Result<Self> {
-        let config_file = get_config_file()?;
-        let config_dir = config_file.parent().context("wait")?;
+    pub fn create_default() -> Result<Self> {
+        let config_file = get_config_file_path()?;
+        let config_dir = config_file
+            .parent()
+            .context("config file should have a parent directory")?;
+        let database_path = config_dir.join(DEFAULT_DB_FILE);
+
+        Ok(Self { database_path })
+    }
 
-        let activity_definitions_path = config_dir.join(DEFAULT_ACT_DEFS_PATH);
-        let activity_logs_path = config_dir.join(DEFAULT_ACT_LOGS_PATH);
+    pub fn load_from_fs() -> Result<Configuration> {
+        let config_file_path = get_config_file_path()?;
+        let content = fs::read_to_string(config_file_path)?;
 
-        Ok(Self {
-            activity_definitions_path,
-            activity_logs_path,
-        })
+        info!("parsing config toml");
+        let config: Configuration = toml::from_str(&content)?;
+        Ok(config)
     }
 
     pub fn to_toml_str(&self) -> Result<String> {
@@ -41,7 +42,7 @@ impl Configuration {
     }
 }
 
-pub fn get_config_file() -> Result<PathBuf> {
+pub fn get_config_file_path() -> Result<PathBuf> {
     if let Ok(config_var) = env::var(CONFIG_VAR) {
         let val = PathBuf::from(config_var);
         debug!(
@@ -67,13 +68,13 @@ pub fn get_config_file() -> Result<PathBuf> {
 }
 
 pub fn initialize_config() -> Result<()> {
-    let config_path = get_config_file()?;
+    let config_path = get_config_file_path()?;
     if let Some(parent) = config_path.parent() {
         info!("creating config dir at: {}", parent.display());
         fs::create_dir_all(parent)?;
     }
 
-    let config = Configuration::new()?;
+    let config = Configuration::create_default()?;
     let toml = config.to_toml_str()?;
     debug!("generating default config: {config:?}");