Final fixes reporting

Author: Per-Gunnar Eriksson

src/commands/report.rs

@@ -52,15 +52,21 @@ pub fn execute(
     // Convert entries to activities
     let mut activities = storage::entries_to_activities(&filtered_entries, Some(range.start_date), Some(range.end_date));
 
-    // For today-only reports, ensure we only show activities that occurred today
+    // For today-only reports, ensure we show all activities that have a start or end time today
     if is_today_only {
         activities.retain(|activity| {
-            activity.end.date_naive() == now.date_naive()
+            let today = now.date_naive();
+            let activity_date = activity.end.date_naive();
+            
+            // For current day reports, show activities that end today
+            activity_date == today
         });
     } else {
-        // For other date ranges, ensure activities fall within the specified range
+        // For date range reports, show all activities that occur within the range
         activities.retain(|activity| {
             let activity_date = activity.end.date_naive();
+            
+            // Include activities where the end date falls within the range
             activity_date >= range.start_date && activity_date <= range.end_date
         });
     }
@@ -108,6 +114,7 @@ pub fn execute(
 
     Ok(())
 }
+
 /// Parse date range from various command line arguments
 fn parse_date_range(
     date: Option<&str>,

src/report/mod.rs

@@ -1,6 +1,6 @@
 use anyhow::Result;
 use chrono::NaiveDate;
-use std::collections::HashMap;
+use std::collections::{HashMap, HashSet};
 
 use crate::entry::{Activity, ActivityType};
 use crate::util;
@@ -217,9 +217,9 @@ fn format_projects(projects: &HashMap<String, (chrono::Duration, Vec<String>)>)
     output
 }
 
-fn group_by_activity(activities: &[Activity]) -> HashMap<ActivityType, Vec<(String, String, chrono::Duration)>> {
-    let mut grouped: HashMap<ActivityType, Vec<(String, String, chrono::Duration)>> = HashMap::new();
-    let mut seen_tasks: HashMap<(ActivityType, String, String), chrono::Duration> = HashMap::new();
+fn group_by_activity(activities: &[Activity]) -> HashMap<ActivityType, Vec<(String, String, chrono::Duration, NaiveDate)>> {
+    let mut grouped: HashMap<ActivityType, Vec<(String, String, chrono::Duration, NaiveDate)>> = HashMap::new();
+    let mut seen_tasks: HashMap<(ActivityType, String, String, NaiveDate), chrono::Duration> = HashMap::new();
 
     // First, calculate total durations for each unique activity
     for activity in activities {
@@ -228,26 +228,34 @@ fn group_by_activity(activities: &[Activity]) -> HashMap<ActivityType, Vec<(Stri
         }
 
         let project = activity.project.clone().unwrap_or_default();
-        let key = (activity.activity_type.clone(), project.clone(), activity.task.clone());
+        let activity_date = activity.end.date_naive();
+        let key = (activity.activity_type.clone(), project.clone(), activity.task.clone(), activity_date);
 
         let duration = seen_tasks.entry(key).or_insert(chrono::Duration::zero());
         *duration = *duration + activity.duration;
     }
 
     // Then, populate the groups
-    for ((activity_type, project, task), duration) in seen_tasks {
+    for ((activity_type, project, task, date), duration) in seen_tasks {
         if !grouped.contains_key(&activity_type) {
             grouped.insert(activity_type.clone(), Vec::new());
         }
 
         if let Some(group) = grouped.get_mut(&activity_type) {
-            group.push((project, task, duration));
+            group.push((project, task, duration, date));
         }
     }
 
-    // Sort each group by project and task
+    // Sort each group by date, then by project and task
     for group in grouped.values_mut() {
         group.sort_by(|a, b| {
+            // First sort by date
+            let date_cmp = a.3.cmp(&b.3);
+            if date_cmp != std::cmp::Ordering::Equal {
+                return date_cmp;
+            }
+            
+            // Then sort by project and task
             let a_key = format!("{}{}", a.0.to_lowercase(), a.1.to_lowercase());
             let b_key = format!("{}{}", b.0.to_lowercase(), b.1.to_lowercase());
             a_key.cmp(&b_key)
@@ -257,12 +265,35 @@ fn group_by_activity(activities: &[Activity]) -> HashMap<ActivityType, Vec<(Stri
     grouped
 }
 
-fn format_activity_groups(groups: &HashMap<ActivityType, Vec<(String, String, chrono::Duration)>>) -> String {
+fn format_activity_groups(groups: &HashMap<ActivityType, Vec<(String, String, chrono::Duration, NaiveDate)>>) -> String {
     let mut output = String::new();
+    let mut saw_multi_days = false;
+    
+    // Check if we have activities from multiple days
+    let mut unique_dates = HashSet::new();
+    for activities in groups.values() {
+        for (_, _, _, date) in activities {
+            unique_dates.insert(*date);
+        }
+    }
+    
+    saw_multi_days = unique_dates.len() > 1;
 
     // Format work activities
     if let Some(work_activities) = groups.get(&ActivityType::Work) {
-        for (project, task, duration) in work_activities {
+        let mut current_date: Option<NaiveDate> = None;
+        
+        for (project, task, duration, date) in work_activities {
+            // Add date header if date changes and we have multiple days
+            if saw_multi_days && current_date.map_or(true, |d| d != *date) {
+                if current_date.is_some() {
+                    output.push('\n');
+                }
+                
+                current_date = Some(*date);
+                output.push_str(&format!("{}:\n", date.format("%Y-%m-%d")));
+            }
+            
             let project_str = if project.is_empty() {
                 String::new()
             } else {
@@ -280,7 +311,19 @@ fn format_activity_groups(groups: &HashMap<ActivityType, Vec<(String, String, ch
 
     // Format break activities
     if let Some(break_activities) = groups.get(&ActivityType::Break) {
-        for (project, task, duration) in break_activities {
+        let mut current_date: Option<NaiveDate> = None;
+        
+        for (project, task, duration, date) in break_activities {
+            // Add date header if date changes and we have multiple days
+            if saw_multi_days && current_date.map_or(true, |d| d != *date) {
+                if current_date.is_some() {
+                    output.push('\n');
+                }
+                
+                current_date = Some(*date);
+                output.push_str(&format!("{}:\n", date.format("%Y-%m-%d")));
+            }
+            
             let project_str = if project.is_empty() {
                 String::new()
             } else {

src/storage.rs

@@ -1,5 +1,5 @@
 use anyhow::{Context, Result};
-use chrono::{DateTime, Local, NaiveDate};
+use chrono::{DateTime, Local, NaiveDate, TimeZone};
 use std::fs::{self, File, OpenOptions};
 use std::io::{BufRead, BufReader, Read, Seek, SeekFrom, Write};
 use std::path::Path;
@@ -144,38 +144,61 @@ pub fn entries_to_activities(entries: &[Entry], start_date: Option<NaiveDate>, e
         let start_time = entries[i].datetime;
         let end_time = entries[i+1].datetime;
 
-        // Apply date filtering if specified
-        // Only include activities that occur within the date range
-        if let Some(start_date) = start_date {
-            if end_time.date_naive() < start_date {
-                continue;  // Skip activities that end before the start date
-            }
-        }
-        
-        if let Some(end_date) = end_date {
-            if start_time.date_naive() > end_date {
-                continue;  // Skip activities that start after the end date
-            }
-        }
-        
-        // Only include activities where the end time is within the date range
-        // This ensures only activities that complete within the requested range are shown
-        if let (Some(start_date), Some(end_date)) = (start_date, end_date) {
-            let activity_date = end_time.date_naive();
-            if activity_date < start_date || activity_date > end_date {
-                continue;
+        // If the times span multiple days, split them into separate daily activities
+        if start_time.date_naive() != end_time.date_naive() {
+            // Create an activity for each day in the range
+            let mut current_date = start_time.date_naive();
+            let end_date = end_time.date_naive();
+            
+            while current_date <= end_date {
+                // Define the start and end of the activity for this specific day
+                let day_start = if current_date == start_time.date_naive() {
+                    start_time
+                } else {
+                    // Start of the day (midnight)
+                    Local.from_utc_datetime(&current_date.and_hms_opt(0, 0, 0).unwrap())
+                };
+                
+                let day_end = if current_date == end_date {
+                    end_time
+                } else {
+                    // End of the day (23:59:59)
+                    Local.from_utc_datetime(&current_date.and_hms_opt(23, 59, 59).unwrap())
+                };
+                
+                let activity = Activity::new(
+                    entries[i+1].name.clone(),
+                    day_start,
+                    day_end,
+                    false,
+                    entries[i+1].comment.clone(),
+                );
+                
+                activities.push(activity);
+                
+                // Move to the next day
+                current_date = current_date.succ_opt().unwrap();
             }
+        } else {
+            // Regular single-day activity
+            let activity = Activity::new(
+                entries[i+1].name.clone(),
+                start_time,
+                end_time,
+                false,
+                entries[i+1].comment.clone(),
+            );
+            
+            activities.push(activity);
         }
-        
-        let activity = Activity::new(
-            entries[i+1].name.clone(),
-            start_time,
-            end_time,
-            false,
-            entries[i+1].comment.clone(),
-        );
-        
-        activities.push(activity);
+    }
+    
+    // Apply date filtering if specified
+    if let (Some(start), Some(end)) = (start_date, end_date) {
+        activities.retain(|activity| {
+            let activity_date = activity.end.date_naive();
+            activity_date >= start && activity_date <= end
+        });
     }
 
     activities