timet 0.2.2 → 0.8.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5987e8625e55cc1ce0c9ceca0cdafc752d6299bb61cf25b910d5cf27997145fe
-  data.tar.gz: dbcd75820a2f84d1870592d37ff698986e40b6b938bf57f598ca335a3bf592b8
+  metadata.gz: 85190a5b5ae6c446a96b2dda4c71efbe19ae0a1ec907dd5d699b1d831ecd0cd7
+  data.tar.gz: ecfd87a600e956b45703fc02865503dd739079f5d8b003770ee9dcb554338903
 SHA512:
-  metadata.gz: 619fecc791710b66e6022dca17526b8a728ba6bad7da09053052dcd632321b5a3400af4b3fd5d477857aff9d04dee326f109cb84c5feac3ad13a8f8e550d7dbe
-  data.tar.gz: e51aa5af43607e9176dd90b5f0eab61492117d97a517039684e38fe93de76fb6b81b642f550226ecaaa8b83e5708ae09bc77ba406da06a10d43230e81bf1645f
+  metadata.gz: 2866257d4d685e76cbd32874922f7bd837f7a68d59bd152e9575935f63dd98ac1514e5e08a1c019bf661ded1ed409ad6733a235194e996c1d50d4dec9494226c
+  data.tar.gz: a7e80d8c5e6f1d433b1549f98351721f5b6d28da242062c149cf47289f81ccb8c7808b2a13a3338550770c7594ad26ca4c91862e0da667c7f50259b6a10841cf

data/CHANGELOG.md

@@ -1,5 +1,88 @@
 ## [Unreleased]
 
+## [0.8.1] - 2024-10-02
+**Bug fixes:**
+  - Fixed a LoadError caused by the byebug gem being required after its removal.
+
+## [0.8.0] - 2024-10-01
+
+**Improvements:**
+- Introduced TimeHelper module to encapsulate time-related functionalities.
+- Replaced direct calls to Time.now.to_i with TimeHelper.current_timestamp for consistency and modularity.
+- Moved current_timestamp method to TimeHelper to centralize time-related logic.
+- Ensured all timestamps are handled in UTC to avoid timezone issues.
+- Refactored ValidationEditHelper to use TimeHelper for time-related operations.
+- Simplified the conditional logic in update_time_field by using a single assignment with the || operator.
+- Introduced local variables field_index and timestamp to store intermediate results, reducing redundancy and improving readability.
+- Added ApplicationHelper module to handle common application tasks.
+- Moved display and prompt logic for editing items into helper methods.
+- Removed redundant field_value method and integrated its functionality into the helper methods.
+- Consolidated the validation logic for start and end fields into a single conditional statement.
+- Removed redundant validate_start_field and validate_end_field methods.
+- Added a check to ensure the CSV export only occurs if there are items to export.
+- Added a message to inform the user if no items are found for export.
+- Refactored the validate_and_update method from Timet::Application to a more modular approach.
+- Created new helper methods in ValidationEditHelper for fetching item values and validating start/end times.
+- Enhanced readability and maintainability of the code by isolating concerns and reusing logic.
+- Renamed item to last_item for clarity in the context where it represents the last task.
+- Added a new variable last_item_status to explicitly define the status of the last item.
+- Extracted table formatting logic into a new Formatter module.
+- Removed redundant methods (format_table_header, format_table_separator, format_table_row, format_notes) from the TimeReport class.
+- Introduced current_timestamp method to encapsulate the logic for getting the current timestamp.
+- Added insert_item_if_valid method to handle item insertion based on valid statuses.
+- Introduced VALID_STATUSES_FOR_INSERTION constant to define valid statuses for item insertion.
+- Updated StatusHelper to use :in_progress status instead of :incomplete.
+- Ensured consistency in timestamp handling across methods.
+- Added support for editing notes.
+- Added the csv gem and moved the extract_date method to the TimeHelper module.
+- Improved error handling by ensuring the CSV filename is correctly processed and validated.
+- Added a confirmation message when the CSV file is successfully exported.
+
+**Bug fixes:**
+- Updated timestamp_to_time method to return nil if the input timestamp is nil.
+- Removed unnecessary &.then syntax for clarity and consistency.
+- Corrected the test expectations to use the correct Unix timestamp.
+- Updated format_time and timestamp_to_date methods to return nil if the input timestamp is nil.
+- Ensured that the formatted time string does not include an extra space at the end.
+- Updated update_time_field to handle nil values for the time field by using a conditional assignment.
+- Ensured that the method correctly handles cases where the time field is not set, defaulting to the current timestamp.
+- Addressed the NilCheck warning and improved the robustness of the method.
+- Added validation to prevent updating start or end times with nil values.
+
+**Tasks:**
+- Added ENV['TZ'] = 'UTC' to spec_helper.rb to ensure that all RSpec tests run in the UTC time zone.
+- Updated tests to reflect the new structure and ensure items are returned for export.
+- Updated and added tests to cover the new export logic.
+- Updated the expectations to use the renamed variables, ensuring the code remains clear and maintainable.
+- Included the Formatter module in the TimeReport class to utilize its formatted output.
+- Updated README.md with alternative syntax for 'timet start' command.
+- Update README.md with new command reference and edit functionality
+- Refactored start method tests to use context blocks for better readability and organization.
+- Added tests to verify the behavior of the start method when the database is empty, the last item is complete, or the last item is still in progress.
+- Added tests to ensure the start method handles notes provided via the --notes option correctly.
+- Refactored stop method tests to use context blocks and added tests to verify the behavior when the last item is in progress or complete.
+- Refactored resume method tests to use context blocks and added tests to verify the behavior when a task is currently being tracked, when there is a last task, and when there are no items.
+- Refactored summary method tests to use context blocks and added tests to verify the behavior for different combinations of arguments.
+- Updated cancel method test to reflect the correct status for active time tracking.
+- Updated database_spec.rb to reflect the correct status for in-progress items.
+
+**Additional Considerations:**
+- Ensured that all timestamps are handled in UTC to avoid timezone issues across different environments.
+- Updated the test to reflect the correct UTC time zone.
+- Ensured consistency in timestamp handling across methods.
+- Improved overall structure, readability, and maintainability of the code.
+- Made the application easier to maintain and extend in the future.
+
+**Refactor and enhance time formatting methods**
+- Refactored `format_time_string` method in `TimeHelper` to improve readability and maintainability.
+- Added detailed documentation for the `format_time_string` method.
+- Simplified the logic for parsing and validating time components.
+- Updated `ValidationEditHelper` to use the refactored `format_time_string` method.
+- Added comprehensive RSpec tests for the `format_time_string` method to cover various input scenarios, including edge cases.
+- Fixed a bug where `nil` input was not handled correctly.
+- Ensured that invalid time values return `nil` instead of an empty string.
+- Refactored the CSV export logic in `TimeReport` to improve readability and maintainability.
+
 ## [0.2.2] - 2024-09-27
 
 * **Improvements**:

data/README.md

@@ -35,7 +35,7 @@ Old versions of Ruby and Sqlite:
 
 Install the gem by executing:
 ```bash
-$ gem install timet
+gem install timet
 ```
 
 ## Usage
@@ -43,6 +43,10 @@ $ gem install timet
 - **timet start [tag] --notes='...'**: Starts tracking time for a task labeled with the provided [tag] and notes (optional). Example:
     ```bash
     timet start task1 --notes='Meeting with client'
+    
+    or
+
+    timet start task1 'Meeting with client'
     ```
 
     ```
@@ -86,61 +90,44 @@ $ gem install timet
     +-------+------------+--------+----------+----------+----------+--------------------------+
     ```
 
-- **timet summary today (t)**: Display a report of tracked time for today.
-
-```bash
-timet summary today
-```
-
-- **timet summary yesterday (y)**: Display a report of tracked time for yesterday.
-
-```bash
-timet summary yesterday
-```
-
-- **timet summary week (w)**: Display a report of tracked time for the week.
-
-```bash
-timet summary week
-```
-
-- **timet summary resume (r)**: Resume tracking the last task.
-
-```bash
-timet summary resume
-```
-
-- **timet summary resume (r)**: Resume tracking the last month.
-
-```bash
-timet summary month
-```
-
-- **timet su t --csv=[filename]**:  Display a report of tracked time for today and export it to filename.csv
-
-```bash
-timet su t --csv=summary_today.csv
-```
-
-- **timet delete [id]**: Delete a task
-
-```bash
-timet delete [id]
-
-or
-
-timet d [id]
-```
-
-- **timet cancel**: Cancel active time tracking
 
-```bash
-timet cancel
+- **timet edit**: It allows users update a task's notes, tag, start or end fields. 
+    ```bash
+    timet e 1
+    ```
 
-or
+    ```
+    Tracked time report [today]:
+    +-------+------------+--------+----------+----------+----------+--------------------------+
+    | Id    | Date       | Tag    | Start    | End      | Duration | Notes                    |
+    +-------+------------+--------+----------+----------+----------+--------------------------+
+    |     2 | 2024-08-09 | task1  | 16:15:07 |        - | 00:00:00 | Meeting with client      |
+    |     1 |            | task1  | 14:55:07 | 15:55:07 | 01:00:00 | Meeting with client      |
+    +-------+------------+--------+----------+----------+----------+--------------------------+
+    |                                           Total:  | 01:00:00 |                          |
+    +-------+------------+--------+----------+----------+----------+--------------------------+
+    Edit Field? (Press ↑/↓ arrow to move and Enter to select)
+    ‣ Notes
+      Tag
+      Start
+      End
+    ```
 
-timet c
-```
+## Command Reference
+
+| Command                                      | Description                                                                 | Example Usage                                      |
+|----------------------------------------------|-----------------------------------------------------------------------------|---------------------------------------------------|
+| `timet start [tag] --notes='...'`            | Start tracking time for a task labeled [tag] and notes (optional).          | `timet start Task "My notes"`                  |
+| `timet stop`                                 | Stop tracking time.                                                         | `timet start Task "My notes"`                  |
+| `timet summary today (t)`                    | Display a report of tracked time for today.                                 | `timet su t` or `timet su`         |
+| `timet summary yesterday (y)`                | Display a report of tracked time for yesterday.                             | `timet su y`                         |
+| `timet summary week (w)`                     | Display a report of tracked time for the week.                              | `timet su w`                              |
+| `timet summary month (m)`                    | Resume tracking the last month.                                             | `timet su m`                             |
+| `timet su t --csv=[filename]`                | Display a report of tracked time for today and export it to `filename.csv`. | `timet su t --csv=file.csv`              |
+| `timet summary resume (r)`                   | Resume tracking the last task.                                              | `timet su r`                            |
+| `timet delete [id]`                          | Delete a task by its ID.                                                    | `timet d [id]`       |
+| `timet cancel`                               | Cancel active time tracking.                                                | `timet c`                 |
+| `timet edit [id]`                            | Update a task's notes, tag, start or end fields.                            | `timet e [1]`                 |
 
 
 ## Data

data/lib/timet/application.rb

@@ -3,29 +3,51 @@
 require_relative 'version'
 require 'thor'
 require 'tty-prompt'
-require 'byebug'
+require_relative 'validation_edit_helper'
+require_relative 'application_helper'
+require_relative 'time_helper'
 
 module Timet
-  # Tracks time spent on various tasks.
+  # Application class that defines CLI commands for time tracking:
+  # - start: Start time tracking with optional notes
+  # - stop: Stop time tracking
+  # - resume: Resume the last task
+  # - summary: Display a summary of tracked time and export to CSV
+  # - edit: Edit a task
+  # - delete: Delete a task
+  # - cancel: Cancel active time tracking
   class Application < Thor
+    include ValidationEditHelper
+    include ApplicationHelper
+
     def initialize(*args)
       super
       @db = Timet::Database.new
     end
 
+    FIELD_INDEX = {
+      'notes' => 4,
+      'tag' => 3,
+      'start' => 1,
+      'end' => 2
+    }.freeze
+
+    VALID_STATUSES_FOR_INSERTION = %i[no_items complete].freeze
+
     desc "start [tag] --notes='...'", "start time tracking  --notes='my notes...'"
     option :notes, type: :string, desc: 'Add a note'
     def start(tag, notes = nil)
-      start = Time.now.to_i
+      start_time = TimeHelper.current_timestamp
       notes = options[:notes] || notes
-      @db.insert_item(start, tag, notes) if %i[no_items complete].include?(@db.last_item_status)
+
+      insert_item_if_valid(start_time, tag, notes)
       summary
     end
 
     desc 'stop', 'stop time tracking'
     def stop
-      stop = Time.now.to_i
-      @db.update(stop) if @db.last_item_status == :incomplete
+      stop = TimeHelper.current_timestamp
+      @db.update(stop) if @db.last_item_status == :in_progress
       result = @db.last_item
 
       return unless result
@@ -35,12 +57,18 @@ module Timet
 
     desc 'resume (r)', 'resume last task'
     def resume
-      if @db.last_item_status == :incomplete
+      status = @db.last_item_status
+
+      case status
+      when :in_progress
         puts 'A task is currently being tracked.'
-      elsif @db.last_item.any?
-        tag = @db.last_item[3]
-        notes = @db.last_item[4]
-        start(tag, notes)
+      when :complete
+        last_item = @db.last_item
+        if last_item
+          tag = last_item[FIELD_INDEX['tag']]
+          notes = last_item[FIELD_INDEX['notes']]
+          start(tag, notes)
+        end
       end
     end
 
@@ -49,10 +77,27 @@ module Timet
           and export to csv_filename"
     option :csv, type: :string, desc: 'Export to CSV file'
     def summary(filter = nil, tag = nil)
-      csv_filename = options[:csv]
+      csv_filename = options[:csv].split('.')[0] if options[:csv]
       summary = TimeReport.new(@db, filter, tag, csv_filename)
       summary.display
-      summary.export_sheet if csv_filename
+      if csv_filename && summary.items.any?
+        summary.export_sheet
+      elsif summary.items.empty?
+        puts 'No items found to export'
+      end
+    end
+
+    desc 'edit (e) [id]', 'edit a task'
+    def edit(id)
+      item = @db.find_item(id)
+      return puts "No tracked time found for id: #{id}" unless item
+
+      display_item(item)
+      field = select_field_to_edit
+      new_value = prompt_for_new_value(item, field)
+      validate_and_update(item, field, new_value)
+
+      summary.display
     end
 
     desc 'delete (d) [id]', 'delete a task'
@@ -60,7 +105,7 @@ module Timet
       item = @db.find_item(id)
       return puts "No tracked time found for id: #{id}" unless item
 
-      TimeReport.new(@db, nil, nil, nil).show_row(item)
+      TimeReport.new(@db).show_row(item)
       return unless TTY::Prompt.new.yes?('Are you sure you want to delete this entry?')
 
       delete_item_and_print_message(id, "Deleted #{id}")
@@ -80,6 +125,12 @@ module Timet
 
     private
 
+    def insert_item_if_valid(start_time, tag, notes)
+      return unless VALID_STATUSES_FOR_INSERTION.include?(@db.last_item_status)
+
+      @db.insert_item(start_time, tag, notes)
+    end
+
     def delete_item_and_print_message(id, message)
       @db.delete_item(id)
       puts message

data/lib/timet/application_helper.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Timet
+  # Provides helper methods for the Timet application.
+  module ApplicationHelper
+    def display_item(item)
+      TimeReport.new(@db).show_row(item)
+    end
+
+    def prompt_for_new_value(item, field)
+      current_value = field_value(item, field)
+      prompt = TTY::Prompt.new(active_color: :green)
+      prompt.ask("Update #{field} (#{current_value}):")
+    end
+
+    def select_field_to_edit
+      prompt = TTY::Prompt.new(active_color: :green)
+      prompt.select('Edit Field?', Timet::Application::FIELD_INDEX.keys.map(&:capitalize), active_color: :cyan).downcase
+    end
+
+    def field_value(item, field)
+      index = Timet::Application::FIELD_INDEX[field]
+      value = item[index]
+      return TimeHelper.timestamp_to_time(value) if %w[start end].include?(field)
+
+      value
+    end
+  end
+end

data/lib/timet/database.rb

@@ -54,6 +54,12 @@ module Timet
       execute_sql("DELETE FROM items WHERE id = #{id}")
     end
 
+    def update_item(id, field, value)
+      return if %w[start end].include?(field) && value.nil?
+
+      execute_sql("UPDATE items SET #{field}='#{value}' WHERE id = #{id}")
+    end
+
     # Fetches the ID of the last inserted item
     def fetch_last_id
       result = execute_sql('SELECT id FROM items ORDER BY id DESC LIMIT 1').first
@@ -81,7 +87,7 @@ module Timet
       start_time = last_item[1]
       end_time = last_item[2]
 
-      total_seconds = end_time ? end_time - start_time : Time.now.to_i - start_time
+      total_seconds = end_time ? end_time - start_time : TimeHelper.current_timestamp - start_time
       seconds_to_hms(total_seconds)
     end
 

data/lib/timet/formatter.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Timet
+  # This module is responsible for formatting the output of the `timet` application.
+  # It provides methods for formatting the table header, separators, and rows.
+  module Formatter
+    def format_table_header
+      header = <<~TABLE
+        Tracked time report \u001b[31m[#{@filter}]\033[0m:
+        #{format_table_separator}
+        \033[32m| Id    | Date       | Tag    | Start    | End      | Duration | Notes                    |\033[0m
+        #{format_table_separator}
+      TABLE
+      puts header
+    end
+
+    def format_table_separator
+      '+-------+------------+--------+----------+----------+----------+--------------------------+'
+    end
+
+    def format_table_row(*row)
+      id, tag, start_date, start_time, end_time, duration, notes = row
+      "| #{id.to_s.rjust(5)} | #{start_date} | #{tag.ljust(6)} | #{start_time.split[1]} | " \
+        "#{end_time.split[1].rjust(8)} | #{@db.seconds_to_hms(duration).rjust(8)} | #{format_notes(notes)}  |"
+    end
+
+    def format_notes(notes)
+      return ' ' * 23 if notes.nil?
+
+      notes = "#{notes.slice(0, 20)}..." if notes.length > 20
+      notes.ljust(23)
+    end
+  end
+end

data/lib/timet/status_helper.rb

@@ -1,13 +1,15 @@
 # frozen_string_literal: true
 
-# Determines the status of a time tracking result based on the presence and end time of items.
-module StatusHelper
-  def self.determine_status(result)
-    return :no_items if result.empty?
+module Timet
+  # Determines the status of a time tracking result based on the presence and end time of items.
+  module StatusHelper
+    def self.determine_status(result)
+      return :no_items if result.empty?
 
-    last_item_end = result.first[1]
-    return :incomplete unless last_item_end
+      last_item_end = result.first[1]
+      return :in_progress unless last_item_end
 
-    :complete
+      :complete
+    end
   end
 end

data/lib/timet/time_helper.rb

@@ -1,36 +1,96 @@
 # frozen_string_literal: true
 
-# This module provides helper functions for working with time and dates.
-# It includes methods for:
-# - formatting timestamps into a specific format
-# - calculating the duration between two timestamps
-# - converting a Date object to a timestamp
-module TimeHelper
-  def self.format_time(timestamp)
-    timestamp&.then { |time| Time.at(time).strftime('%Y-%m-%d %H:%M:%S').ljust(19) }
-  end
+module Timet
+  # This module provides helper functions for working with time and dates.
+  # It includes methods for:
+  # - formatting timestamps into a specific format
+  # - calculating the duration between two timestamps
+  # - converting a Date object to a timestamp
+  module TimeHelper
+    def self.format_time(timestamp)
+      return nil if timestamp.nil?
 
-  def self.timestamp_to_date(timestamp)
-    timestamp&.then { |time| Time.at(time).strftime('%Y-%m-%d') }
-  end
+      Time.at(timestamp).strftime('%Y-%m-%d %H:%M:%S')
+    end
 
-  def self.timestamp_to_time(timestamp)
-    timestamp&.then { |time| Time.at(time).strftime('%H:%M:%S') }
-  end
+    def self.timestamp_to_date(timestamp)
+      return nil if timestamp.nil?
 
-  def self.calculate_duration(start_time, end_time)
-    start_time = Time.at(start_time)
-    end_time = end_time ? Time.at(end_time) : Time.now
+      Time.at(timestamp).strftime('%Y-%m-%d')
+    end
 
-    (end_time - start_time).to_i
-  end
+    def self.timestamp_to_time(timestamp)
+      return nil if timestamp.nil?
 
-  def self.date_to_timestamp(date)
-    date.to_time.to_i
-  end
+      Time.at(timestamp).strftime('%H:%M:%S')
+    end
+
+    def self.calculate_duration(start_time, end_time)
+      end_time = end_time ? Time.at(end_time) : current_timestamp
+      (end_time - start_time).to_i
+    end
+
+    def self.date_to_timestamp(date)
+      date.to_time.to_i
+    end
+
+    def self.calculate_end_time(start_date, end_date)
+      end_date ||= start_date + 1
+      date_to_timestamp(end_date)
+    end
+
+    def self.extract_date(items, idx)
+      current_start_date = items[idx][1]
+      date = TimeHelper.timestamp_to_date(current_start_date)
+
+      last_start_date = items[idx - 1][1] if idx.positive?
+      date if idx.zero? || date != TimeHelper.timestamp_to_date(last_start_date)
+    end
+
+    # Formats a time string into a standard HH:MM:SS format.
+    #
+    # @param input [String] The input string to format.
+    # @return [String] The formatted time string in HH:MM:SS format, or nil if the input is invalid.
+    #
+    # @example
+    #  TimeHelper.format_time_string('123456') # => "12:34:56"
+    #  TimeHelper.format_time_string('1234567') # => "12:34:56"
+    #  TimeHelper.format_time_string('1234') # => "12:34:00"
+    #  TimeHelper.format_time_string('123') # => "12:30:00"
+    #  TimeHelper.format_time_string('12') # => "12:00:00"
+    #  TimeHelper.format_time_string('1') # => "01:00:00"
+    #  TimeHelper.format_time_string('127122') # => nil
+    #  TimeHelper.format_time_string('abc') # => nil
+    def self.format_time_string(input)
+      return nil if input.nil? || input.empty?
+
+      digits = input.gsub(/\D/, '')[0..5]
+      return nil if digits.empty?
+
+      hours, minutes, seconds = parse_time_components(digits)
+      return nil unless valid_time?(hours, minutes, seconds)
+
+      format('%<hours>02d:%<minutes>02d:%<seconds>02d', hours: hours, minutes: minutes, seconds: seconds)
+    end
+
+    def self.parse_time_components(digits)
+      padded_digits = case digits.size
+                      when 1 then "0#{digits}0000"
+                      when 2 then "#{digits}0000"
+                      when 3 then "#{digits}000"
+                      when 4 then "#{digits}00"
+                      else digits.ljust(6, '0')
+                      end
+
+      padded_digits.scan(/.{2}/).map(&:to_i)
+    end
+
+    def self.valid_time?(hours, minutes, seconds)
+      hours < 24 && minutes < 60 && seconds < 60
+    end
 
-  def self.calculate_end_time(start_date, end_date)
-    end_date ||= start_date + 1
-    date_to_timestamp(end_date)
+    def self.current_timestamp
+      Time.now.utc.to_i
+    end
   end
 end

data/lib/timet/time_report.rb

@@ -2,17 +2,19 @@
 
 require 'date'
 require 'csv'
-require_relative 'time_helper'
 require_relative 'status_helper'
+require_relative 'formatter'
 
 module Timet
   # The TimeReport class is responsible for displaying a report of tracked time
-  # entries. It allows filtering the report by time periods (today, yesterday,
-  # week) and displays a formatted table with the relevant information.
+  # entries. It allows filtering the report by time periods and displays
+  # a formatted table with the relevant information.
   class TimeReport
+    include Formatter
+
     attr_reader :db, :items, :filename
 
-    def initialize(db, filter, tag, csv)
+    def initialize(db, filter = nil, tag = nil, csv = nil)
       @db = db
       @filename = csv
       @filter = formatted_filter(filter)
@@ -24,7 +26,7 @@ module Timet
 
       format_table_header
       items.each_with_index do |item, idx|
-        date = extract_date(items, idx)
+        date = TimeHelper.extract_date(items, idx)
         display_time_entry(item, date)
       end
       puts format_table_separator
@@ -39,29 +41,32 @@ module Timet
     end
 
     def export_sheet
-      CSV.open("#{filename}.csv", 'w') do |csv|
-        csv << %w[ID Start End Tag Notes]
+      file_name = "#{filename}.csv"
+      write_csv(file_name)
 
-        items.each do |id, start_time, end_time, tags, notes|
-          csv << [
-            id,
-            TimeHelper.format_time(start_time),
-            TimeHelper.format_time(end_time),
-            tags,
-            notes
-          ]
-        end
-      end
+      puts "The #{file_name} has been exported."
     end
 
     private
 
-    def extract_date(items, idx)
-      current_start_date = items[idx][1]
-      date = TimeHelper.timestamp_to_date(current_start_date)
+    def write_csv(file_name)
+      CSV.open(file_name, 'w') do |csv|
+        csv << %w[ID Start End Tag Notes]
+        items.each do |item|
+          csv << format_item(item)
+        end
+      end
+    end
 
-      last_start_date = items[idx - 1][1]
-      date if idx.zero? || date != TimeHelper.timestamp_to_date(last_start_date)
+    def format_item(item)
+      id, start_time, end_time, tags, notes = item
+      [
+        id,
+        TimeHelper.format_time(start_time),
+        TimeHelper.format_time(end_time),
+        tags,
+        notes
+      ]
     end
 
     def display_time_entry(item, date = nil)
@@ -71,7 +76,7 @@ module Timet
       duration = TimeHelper.calculate_duration(start_time_value, end_time_value)
       start_time = TimeHelper.format_time(start_time_value)
       end_time = TimeHelper.format_time(end_time_value) || '- -'
-      start_date = date.nil? ? ' ' * 10 : date
+      start_date = date || (' ' * 10)
       puts format_table_row(id, tag_name[0..5], start_date, start_time, end_time, duration, notes)
     end
 
@@ -83,43 +88,26 @@ module Timet
       puts format_table_separator
     end
 
-    def format_table_header
-      header = <<~TABLE
-        Tracked time report \u001b[31m[#{@filter}]\033[0m:
-        #{format_table_separator}
-        \033[32m| Id    | Date       | Tag    | Start    | End      | Duration | Notes                    |\033[0m
-        #{format_table_separator}
-      TABLE
-      puts header
-    end
-
-    def format_table_separator
-      '+-------+------------+--------+----------+----------+----------+--------------------------+'
-    end
-
-    def format_table_row(*row)
-      id, tag, start_date, start_time, end_time, duration, notes = row
-      "| #{id.to_s.rjust(5)} | #{start_date} | #{tag.ljust(6)} | #{start_time.split[1]} | " \
-        "#{end_time.split[1].rjust(8)} | #{@db.seconds_to_hms(duration).rjust(8)} | #{format_notes(notes)}  |"
-    end
-
     def filter_items(filter, tag)
-      today = Date.today
-      case filter
-      when 'today'
-        filter_by_date_range(today, nil, tag)
-      when 'yesterday'
-        filter_by_date_range(today - 1, nil, tag)
-      when 'week'
-        filter_by_date_range(today - 7, today + 1, tag)
-      when 'month'
-        filter_by_date_range(today - 30, today + 1, tag)
+      if date_ranges.key?(filter)
+        start_date, end_date = date_ranges[filter]
+        filter_by_date_range(start_date, end_date, tag)
       else
-        puts 'Invalid filter. Supported filters: today, yesterday, week'
+        puts 'Invalid filter. Supported filters: today, yesterday, week, month'
         []
       end
     end
 
+    def date_ranges
+      today = Date.today
+      {
+        'today' => [today, nil],
+        'yesterday' => [today - 1, nil],
+        'week' => [today - 7, today + 1],
+        'month' => [today - 30, today + 1]
+      }
+    end
+
     def filter_by_date_range(start_date, end_date = nil, tag = nil)
       start_time = TimeHelper.date_to_timestamp(start_date)
       end_time = TimeHelper.calculate_end_time(start_date, end_date)
@@ -129,13 +117,6 @@ module Timet
       )
     end
 
-    def format_notes(notes)
-      return ' ' * 23 if notes.nil?
-
-      notes = "#{notes.slice(0, 20)}..." if notes.length > 20
-      notes.ljust(23)
-    end
-
     def formatted_filter(filter)
       return 'today' if %w[today t].include?(filter)
       return 'yesterday' if %w[yesterday y].include?(filter)

data/lib/timet/validation_edit_helper.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+require_relative 'time_helper'
+module Timet
+  # Validates and updates a specific field of an item based on certain conditions.
+  # If the field is 'start' or 'end', it checks and updates the value accordingly.
+  # Otherwise, it directly updates the field with the new value.
+  module ValidationEditHelper
+    TIME_FIELDS = %w[start end].freeze
+
+    def validate_and_update(item, field, new_value)
+      return if new_value.nil?
+
+      id = item[0]
+
+      if TIME_FIELDS.include?(field)
+        process_and_update_time_field(item, field, new_value, id)
+      else
+        @db.update_item(id, field, new_value)
+      end
+    end
+
+    private
+
+    def process_and_update_time_field(item, field, date_value, id)
+      formatted_date = TimeHelper.format_time_string(date_value)
+
+      return print_error(date_value) unless formatted_date
+
+      new_date = update_time_field(item, field, formatted_date)
+      new_value_epoch = new_date.to_i
+
+      if valid_time_value?(item, field, new_value_epoch, id)
+        @db.update_item(id, field, new_value_epoch)
+      else
+        print_error(new_date)
+      end
+    end
+
+    def print_error(message)
+      puts "\u001b[31mInvalid date: #{message}\033[0m"
+    end
+
+    def update_time_field(item, field, formatted_value)
+      field_index = Timet::Application::FIELD_INDEX[field]
+      timestamp = item[field_index]
+      current_time = Time.at(timestamp || TimeHelper.current_timestamp).to_s.split
+      current_time[1] = formatted_value
+      DateTime.strptime(current_time.join(' '), '%Y-%m-%d %H:%M:%S %z').to_time
+    end
+
+    def valid_time_value?(item, field, new_value_epoch, id)
+      item_start = fetch_item_start(item)
+      item_end = fetch_item_end(item)
+      item_before_end = fetch_item_before_end(id, item_start)
+      item_after_start = fetch_item_after_start(id)
+
+      if field == 'start'
+        new_value_epoch >= item_before_end && new_value_epoch <= item_end
+      else
+        new_value_epoch >= item_start && new_value_epoch <= item_after_start
+      end
+    end
+
+    def fetch_item_start(item)
+      item[Timet::Application::FIELD_INDEX['start']]
+    end
+
+    def fetch_item_end(item)
+      item[Timet::Application::FIELD_INDEX['end']] || TimeHelper.current_timestamp
+    end
+
+    def fetch_item_before_end(id, item_start)
+      @db.find_item(id - 1)&.dig(Timet::Application::FIELD_INDEX['end']) || item_start
+    end
+
+    def fetch_item_after_start(id)
+      @db.find_item(id + 1)&.dig(Timet::Application::FIELD_INDEX['start']) || TimeHelper.current_timestamp
+    end
+  end
+end

data/lib/timet/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Timet
-  VERSION = '0.2.2'
+  VERSION = '0.8.1'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: timet
 version: !ruby/object:Gem::Version
-  version: 0.2.2
+  version: 0.8.1
 platform: ruby
 authors:
 - Frank Vielma
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-09-27 00:00:00.000000000 Z
+date: 2024-10-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: thor
@@ -58,8 +58,7 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '1.7'
-description: It's a time tracking app that keeps track of how long you spend doing
-  different things.
+description: Timet is a command-line time tracker that keeps track of your activities.
 email:
 - frankvielma@gmail.com
 executables:
@@ -78,10 +77,13 @@ files:
 - bin/timet
 - lib/timet.rb
 - lib/timet/application.rb
+- lib/timet/application_helper.rb
 - lib/timet/database.rb
+- lib/timet/formatter.rb
 - lib/timet/status_helper.rb
 - lib/timet/time_helper.rb
 - lib/timet/time_report.rb
+- lib/timet/validation_edit_helper.rb
 - lib/timet/version.rb
 - sig/timet.rbs
 homepage: https://frankvielma.github.io/posts/timet-a-powerful-command-line-tool-for-tracking-your-time/
@@ -110,5 +112,5 @@ requirements: []
 rubygems_version: 3.5.9
 signing_key:
 specification_version: 4
-summary: Command line time tracking with reports
+summary: Command line time tracker with reports
 test_files: []