Bug fixes

Author: Per-Gunnar Eriksson

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "tt"
-version = "0.1.0"
+version = "0.1.1"
 edition = "2024"
 description = "Timetracker (TT) - a CLI time tracking application"
 authors = ["pergeri <[email protected]>"]

src/commands/hello.rs

@@ -1,5 +1,4 @@
 use anyhow::Result;
-use chrono::{Local, NaiveTime, TimeZone};
 
 use crate::config::Config;
 use crate::entry::{Entry, HELLO_ENTRY_NAME, MIDNIGHT_SEPARATOR_PREFIX};
@@ -34,20 +33,17 @@ pub fn execute(cli: &crate::Cli, config: &Config) -> Result<()> {
 
     // If needed, add a midnight separator entry
     if create_midnight_separator {
-        // Create a midnight entry at 00:00 of the current day
-        let midnight_naive = now.date_naive().and_time(NaiveTime::from_hms_opt(0, 0, 0).unwrap());
-        let midnight = Local.from_local_datetime(&midnight_naive).single().unwrap();
-        
-        // Create a midnight separator entry
-        let midnight_entry = Entry::new(
-            midnight, 
+        // Create a separator entry with current time, not midnight
+        // This indicates a new day is starting when the hello command is run
+        let separator_entry = Entry::new(
+            now, 
             format!("{}", MIDNIGHT_SEPARATOR_PREFIX), 
             false, 
             None
         );
 
         // Write the midnight separator to the log file
-        storage::append_entry(&data_file, &midnight_entry)?;
+        storage::append_entry(&data_file, &separator_entry)?;
     }
 
     // Create a hello entry

src/commands/report.rs

@@ -35,6 +35,13 @@ pub fn execute(
     // Read all entries from the log file
     let all_entries = storage::read_entries(&data_file)?;
 
+    // Check if we're displaying just today's report (the default case)
+    let is_today_only = range.start_date == now.date_naive() && 
+                         range.end_date == now.date_naive() && 
+                         date.is_none() && from_date.is_none() && 
+                         to_date.is_none() && month.is_none() && 
+                         week.is_none();
+    
     // Filter entries by date range considering midnight separators
     let filtered_entries = storage::filter_entries_by_date_range(
         &all_entries, 
@@ -45,13 +52,18 @@ pub fn execute(
     // Convert entries to activities
     let mut activities = storage::entries_to_activities(&filtered_entries, Some(range.start_date), Some(range.end_date));
 
-    // Filter activities to only include those that fall within our date range
-    // This ensures we don't include activities from previous days
-    activities.retain(|activity| {
-        // Activity end time must be within our date range
-        let activity_date = activity.end.date_naive();
-        activity_date >= range.start_date && activity_date <= range.end_date
-    });
+    // For today-only reports, ensure we only show activities that occurred today
+    if is_today_only {
+        activities.retain(|activity| {
+            activity.end.date_naive() == now.date_naive()
+        });
+    } else {
+        // For other date ranges, ensure activities fall within the specified range
+        activities.retain(|activity| {
+            let activity_date = activity.end.date_naive();
+            activity_date >= range.start_date && activity_date <= range.end_date
+        });
+    }
 
     // Add current activity if requested
     if !no_current_activity && !filtered_entries.is_empty() {

src/storage.rs

@@ -1,10 +1,10 @@
 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;
 
-use crate::entry::{Activity, Entry, MIDNIGHT_SEPARATOR_PREFIX};
+use crate::entry::{Activity, Entry, MIDNIGHT_SEPARATOR_PREFIX, HELLO_ENTRY_NAME};
 
 pub fn read_entries(data_file: &Path) -> Result<Vec<Entry>> {
     if !data_file.exists() {
@@ -134,32 +134,58 @@ 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
-            }
-        }
+        // Special handling for "hello" entries
+        // Make the hello entry start at the beginning of the day instead of from the last entry of the previous day
+        let adjusted_start_time = if entries[i+1].name == HELLO_ENTRY_NAME {
+            // Use midnight of the current day as the start time for hello entries
+            let naive_midnight = end_time.date_naive().and_time(chrono::NaiveTime::from_hms_opt(0, 0, 0).unwrap());
+            Local.from_local_datetime(&naive_midnight).single().unwrap()
+        } else {
+            start_time
+        };
 
-        if let Some(end_date) = end_date {
-            if start_time.date_naive() > end_date {
-                continue;  // Skip activities that start after the end date
-            }
-        }
+        // Activities are defined by their end time (the timestamp when they were recorded)
+        // The activity belongs to the day of its end timestamp
+        let activity_date = end_time.date_naive();
 
-        // Only include activities where the end time is within the date range
-        // This ensures only activities that complete within the requested range are shown
+        // Filter based on date range
         if let (Some(start_date), Some(end_date)) = (start_date, end_date) {
-            let activity_date = end_time.date_naive();
+            // Only include activities that end within the specified date range
             if activity_date < start_date || activity_date > end_date {
                 continue;
             }
+            
+            // Additional check: if this is for a single day report (default "today" behavior)
+            // and the start time is from a previous day, make sure it's only from the 
+            // immediately preceding day, unless it's a "hello" entry which we already adjusted
+            if start_date == end_date && entries[i+1].name != HELLO_ENTRY_NAME {
+                let start_activity_date = adjusted_start_time.date_naive();
+                if start_activity_date < activity_date {
+                    // Calculate days between the dates
+                    let days_between = (activity_date - start_activity_date).num_days();
+                    if days_between > 1 {
+                        continue; // Skip activities that started more than one day before
+                    }
+                }
+            }
+        } else {
+            // Apply date filtering if only one date boundary is specified
+            if let Some(start_date) = start_date {
+                if activity_date < start_date {
+                    continue;  // Skip activities that end before the start date
+                }
+            }
+            
+            if let Some(end_date) = end_date {
+                if activity_date > end_date {
+                    continue;  // Skip activities that end after the end date
+                }
+            }
         }
 
         let activity = Activity::new(
             entries[i+1].name.clone(),
-            start_time,
+            adjusted_start_time,  // Use the adjusted start time
             end_time,
             false,
             entries[i+1].comment.clone(),
@@ -181,15 +207,22 @@ pub fn filter_entries_by_date_range(entries: &[Entry], start_date: NaiveDate, en
 
     // Find the last entry before the start date (needed for calculating the first activity's duration)
     // This handles the case where an activity starts before our date range but ends within it
+    // Only include this entry if it's from the same day as start_date or from the immediate previous day
     let mut last_entry_before_range = None;
     for entry in entries.iter().rev() {
-        if entry.datetime.date_naive() < start_date {
-            last_entry_before_range = Some(entry.clone());
+        let entry_date = entry.datetime.date_naive();
+        if entry_date < start_date {
+            // Only include the previous entry if it's from the same day or immediately before
+            // This prevents showing activities from days far in the past
+            let days_between = (start_date - entry_date).num_days();
+            if days_between <= 1 {
+                last_entry_before_range = Some(entry.clone());
+            }
             break;
         }
     }
 
-    // If we found a last entry before the range, include it
+    // If we found a valid last entry before the range, include it
     if let Some(entry) = last_entry_before_range {
         filtered_entries.push(entry);
     }