timet 1.6.2 → 1.6.4

data/lib/timet/validation_editor.rb

@@ -0,0 +1,303 @@
+# frozen_string_literal: true
+
+require 'time'
+require_relative 'time_helper'
+
+module Timet
+  # Helper module containing validation logic for time tracking items.
+  module TimeValidationHelpers
+    module_function
+
+    def adjust_end_datetime_for_next_day(start_timestamp, new_datetime)
+      return new_datetime unless start_timestamp && (new_datetime.to_i <= start_timestamp)
+
+      new_datetime + (24 * 60 * 60)
+    end
+
+    def create_new_datetime(base_date_time, parsed_time_component)
+      Time.new(
+        base_date_time.year,
+        base_date_time.month,
+        base_date_time.day,
+        parsed_time_component.hour,
+        parsed_time_component.min,
+        parsed_time_component.sec,
+        base_date_time.utc_offset
+      )
+    end
+
+    def determine_start_base_date_time(start_timestamp)
+      start_timestamp ? Time.at(start_timestamp) : Time.now
+    end
+
+    def determine_end_base_date_time(start_timestamp)
+      raise ArgumentError, "Cannot set 'end' time because 'start' time is not set." unless start_timestamp
+
+      Time.at(start_timestamp)
+    end
+
+    def determine_base_date_time(_item, field, start_timestamp)
+      case field
+      when 'start'
+        determine_start_base_date_time(start_timestamp)
+      when 'end'
+        determine_end_base_date_time(start_timestamp)
+      else
+        raise ArgumentError, "Invalid field: #{field}"
+      end
+    end
+
+    def parse_time_string(time_str)
+      Time.parse(time_str)
+    rescue ArgumentError
+      raise ArgumentError, "Invalid time format: #{time_str}"
+    end
+
+    def format_time(epoch)
+      Time.at(epoch).strftime('%Y-%m-%d %H:%M:%S')
+    end
+
+    def validate_future_date(new_datetime)
+      return unless new_datetime > Time.now.getlocal
+
+      raise ArgumentError, "Cannot set time to a future date or time: #{new_datetime.strftime('%Y-%m-%d %H:%M:%S')}"
+    end
+
+    def validate_time_difference(earlier_timestamp, later_timestamp)
+      return unless (later_timestamp - earlier_timestamp).abs >= 24 * 60 * 60
+
+      raise ArgumentError, 'The difference between start and end time must be less than 24 hours.'
+    end
+
+    def validate_end_after_start(new_epoch, ref_timestamp, new_datetime)
+      reference_time = Time.at(ref_timestamp)
+      formatted_new = new_datetime.strftime('%Y-%m-%d %H:%M:%S')
+      formatted_ref = reference_time.strftime('%Y-%m-%d %H:%M:%S')
+
+      return unless new_epoch <= ref_timestamp
+
+      raise ArgumentError, "End time (#{formatted_new}) must be after start time (#{formatted_ref})."
+    end
+
+    def validate_start_before_end(new_epoch, ref_timestamp, new_datetime)
+      reference_time = Time.at(ref_timestamp)
+      formatted_new = new_datetime.strftime('%Y-%m-%d %H:%M:%S')
+      formatted_ref = reference_time.strftime('%Y-%m-%d %H:%M:%S')
+
+      return unless new_epoch >= ref_timestamp
+
+      raise ArgumentError, "Start time (#{formatted_new}) must be before end time (#{formatted_ref})."
+    end
+
+    def validate_end_time(new_epoch, ref_timestamp, new_datetime)
+      validate_end_after_start(new_epoch, ref_timestamp, new_datetime)
+      validate_time_difference(ref_timestamp, new_epoch)
+    end
+
+    def check_start_before_end(new_epoch, ref_timestamp, new_datetime)
+      validate_start_before_end(new_epoch, ref_timestamp, new_datetime)
+      validate_time_difference(new_epoch, ref_timestamp)
+    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(db, id, item_start)
+      db.find_item(id - 1)&.dig(Timet::Application::FIELD_INDEX['end']) || item_start
+    end
+
+    def fetch_item_after_start(db, id)
+      db.find_item(id + 1)&.dig(Timet::Application::FIELD_INDEX['start']) || TimeHelper.current_timestamp
+    end
+  end
+
+  # Handles validation and editing of time tracking items.
+  class ValidationEditor
+    include TimeValidationHelpers
+
+    TIME_FIELDS = %w[start end].freeze
+
+    def initialize(item, db)
+      @item = item
+      @db = db
+    end
+
+    def update(field, new_value)
+      case field
+      when 'notes' then update_notes(new_value)
+      when 'tag' then update_tag(new_value)
+      when 'start' then update_start_time(new_value)
+      when 'end' then update_end_time(new_value)
+      else raise ArgumentError, "Invalid field: #{field}"
+      end
+      @item
+    end
+
+    private
+
+    def update_notes(value)
+      @item[4] = value
+    end
+
+    def update_tag(value)
+      @item[3] = value
+    end
+
+    def update_start_time(time_str)
+      @item[1] = process_start_time(time_str)
+    end
+
+    def update_end_time(time_str)
+      @item[2] = process_end_time(time_str)
+    end
+
+    def process_start_time(time_str)
+      return @item[1] if time_str.to_s.strip.empty?
+
+      build_and_validate_start_time(time_str)
+    end
+
+    def process_end_time(time_str)
+      return @item[2] if time_str.to_s.strip.empty?
+
+      build_and_validate_end_time(time_str)
+    end
+
+    def start_timestamp
+      @item[1]
+    end
+
+    def end_timestamp
+      @item[2]
+    end
+
+    def item_id
+      @item[0]
+    end
+
+    def build_and_validate_start_time(time_str)
+      new_epoch = parse_to_epoch(time_str, :start)
+      run_start_validations(new_epoch)
+      new_epoch
+    end
+
+    def build_and_validate_end_time(time_str)
+      new_epoch = parse_to_epoch(time_str, :end)
+      run_end_validations(new_epoch)
+      new_epoch
+    end
+
+    def parse_to_epoch(time_str, field_type)
+      parsed_time = parse_time_string(time_str)
+      base = determine_base_date_time(@item, field_type.to_s, start_timestamp)
+      new_dt = create_new_datetime(base, parsed_time)
+      adjusted_dt = field_type == :end ? adjust_end_datetime_for_next_day(start_timestamp, new_dt) : new_dt
+      adjusted_dt.to_i
+    end
+
+    def run_start_validations(new_epoch)
+      validate_start_not_future(new_epoch)
+      validate_start_collision_with_previous(new_epoch)
+      validate_start_collision_with_next(new_epoch)
+      validate_start_before_item_end(new_epoch)
+    end
+
+    def run_end_validations(new_epoch)
+      validate_end_not_future(new_epoch)
+      validate_end_collision_with_previous(new_epoch)
+      validate_end_collision_with_next(new_epoch)
+      validate_end_after_start_item(new_epoch)
+    end
+
+    def validate_start_not_future(new_epoch)
+      validate_future_date(Time.at(new_epoch))
+    end
+
+    def validate_end_not_future(new_epoch)
+      validate_future_date(Time.at(new_epoch))
+    end
+
+    def validate_start_collision_with_previous(new_epoch)
+      prev = @db.find_item(item_id - 1)
+      return unless prev
+
+      prev_end = prev[2]
+      return unless new_epoch < prev_end
+
+      raise ArgumentError, "New start time collides with previous item (ends at #{format_time(prev_end)})."
+    end
+
+    def validate_end_collision_with_previous(new_epoch)
+      prev = @db.find_item(item_id - 1)
+      return unless prev
+
+      prev_end = prev[2]
+      return unless new_epoch < prev_end
+
+      raise ArgumentError, "New end time collides with previous item (ends at #{format_time(prev_end)})."
+    end
+
+    def validate_start_collision_with_next(new_epoch)
+      next_item = @db.find_item(item_id + 1)
+      return unless next_item
+
+      next_start = next_item[1]
+      return unless new_epoch >= next_start
+
+      raise ArgumentError, "New start time collides with next item (starts at #{format_time(next_start)})."
+    end
+
+    def validate_end_collision_with_next(new_epoch)
+      next_item = @db.find_item(item_id + 1)
+      return unless next_item
+
+      next_start = next_item[1]
+      return unless new_epoch > next_start
+
+      raise ArgumentError, "New end time collides with next item (starts at #{format_time(next_start)})."
+    end
+
+    def validate_start_before_item_end(new_epoch)
+      end_ts = end_timestamp
+      return unless end_ts
+
+      check_start_before_end(new_epoch, end_ts, Time.at(new_epoch))
+    end
+
+    def validate_end_after_start_item(new_epoch)
+      start_ts = start_timestamp
+      validate_end_time(new_epoch, start_ts, Time.at(new_epoch))
+    end
+
+    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 = TimeHelper.update_time_field(item, field, formatted_date)
+      new_value_epoch = new_date.to_i
+
+      return @db.update_item(id, field, new_value_epoch) unless invalid_time_value?(item, field, new_value_epoch, id)
+
+      print_error(new_date)
+    end
+
+    def print_error(message)
+      puts "Invalid date: #{message}".red
+    end
+
+    def invalid_time_value?(item, field, new_value_epoch, id)
+      is_start = field == 'start'
+      item_start = fetch_item_start(item)
+      item_end = fetch_item_end(item)
+      min_val = is_start ? fetch_item_before_end(@db, id, item_start) : item_start
+      max_val = is_start ? item_end : fetch_item_after_start(@db, id)
+      !new_value_epoch.between?(min_val, max_val)
+    end
+  end
+end

data/lib/timet/version.rb

@@ -6,6 +6,6 @@ module Timet
   # @return [String] The version number in the format 'major.minor.patch'.
   #
   # @example Get the version of the Timet application
-  #   Timet::VERSION # => '1.6.2'
-  VERSION = '1.6.2'
+  #   Timet::VERSION # => '1.6.4'
+  VERSION = '1.6.4'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: timet
 version: !ruby/object:Gem::Version
-  version: 1.6.2
+  version: 1.6.4
 platform: ruby
 authors:
 - Frank Vielma
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-12-28 00:00:00.000000000 Z
+date: 2026-03-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: thor
@@ -144,19 +144,15 @@ files:
 - lib/timet/database_sync_helper.rb
 - lib/timet/database_syncer.rb
 - lib/timet/discord_notifier.rb
-- lib/timet/item_data_helper.rb
 - lib/timet/s3_supabase.rb
 - lib/timet/table.rb
 - lib/timet/tag_distribution.rb
 - lib/timet/time_block_chart.rb
 - lib/timet/time_helper.rb
 - lib/timet/time_report.rb
-- lib/timet/time_report_helper.rb
 - lib/timet/time_statistics.rb
-- lib/timet/time_update_helper.rb
-- lib/timet/time_validation_helper.rb
 - lib/timet/utils.rb
-- lib/timet/validation_edit_helper.rb
+- lib/timet/validation_editor.rb
 - lib/timet/version.rb
 - lib/timet/week_info.rb
 - sig/timet.rbs

data/lib/timet/item_data_helper.rb

@@ -1,59 +0,0 @@
-# frozen_string_literal: true
-
-module Timet
-  # Helper methods for fetching item data.
-  module ItemDataHelper
-    module_function
-
-    # Fetches the start time of a tracking item.
-    #
-    # @param item [Array] The tracking item.
-    #
-    # @return [Integer] The start time in epoch format.
-    #
-    # @example Fetch the start time of a tracking item
-    #   fetch_item_start(item)
-    def fetch_item_start(item)
-      item[Timet::Application::FIELD_INDEX['start']]
-    end
-
-    # Fetches the end time of a tracking item.
-    #
-    # @param item [Array] The tracking item.
-    #
-    # @return [Integer] The end time in epoch format.
-    #
-    # @example Fetch the end time of a tracking item
-    #   fetch_item_end(item)
-    def fetch_item_end(item)
-      item[Timet::Application::FIELD_INDEX['end']] || TimeHelper.current_timestamp
-    end
-
-    # Fetches the end time of the tracking item before the current one.
-    #
-    # @param db [Timet::Database] The database instance.
-    # @param id [Integer] The ID of the current tracking item.
-    # @param item_start [Integer] The start time of the current tracking item.
-    #
-    # @return [Integer] The end time of the previous tracking item in epoch format.
-    #
-    # @example Fetch the end time of the previous tracking item
-    #   fetch_item_before_end(db, 1, 1633072800)
-    def fetch_item_before_end(db, id, item_start)
-      db.find_item(id - 1)&.dig(Timet::Application::FIELD_INDEX['end']) || item_start
-    end
-
-    # Fetches the start time of the tracking item after the current one.
-    #
-    # @param db [Timet::Database] The database instance.
-    # @param id [Integer] The ID of the current tracking item.
-    #
-    # @return [Integer] The start time of the next tracking item in epoch format.
-    #
-    # @example Fetch the start time of the next tracking item
-    #   fetch_item_after_start(db, id)
-    def fetch_item_after_start(db, id)
-      db.find_item(id + 1)&.dig(Timet::Application::FIELD_INDEX['start']) || TimeHelper.current_timestamp
-    end
-  end
-end

data/lib/timet/time_report_helper.rb

@@ -1,36 +0,0 @@
-# frozen_string_literal: true
-
-module Timet
-  # The TimeReportHelper module provides a collection of utility methods for processing and formatting time report data.
-  # It includes methods for processing time entries, handling time blocks, formatting items for CSV export,
-  # and validating date formats.
-  # This module is designed to be included in classes that require time report processing functionalities.
-  module TimeReportHelper
-    # Exports the report to a CSV file.
-    #
-    # @return [void] This method does not return a value; it performs side effects such as writing the CSV file.
-    #
-    # @example Export the report to a CSV file
-    #   time_report.export_csv
-    #
-    # @note The method writes the items to a CSV file and prints a confirmation message.
-    def export_csv
-      file_name = "#{csv_filename}.csv"
-      write_csv(file_name)
-
-      puts "The #{file_name} has been exported."
-    end
-
-    # Generates an iCalendar file and writes it to disk.
-    #
-    # @return [void]
-    def export_icalendar
-      file_name = "#{ics_filename}.ics"
-      cal = Timet::Utils.add_events(items)
-
-      File.write(file_name, cal.to_ical)
-
-      puts "The #{file_name} has been generated."
-    end
-  end
-end

data/lib/timet/time_update_helper.rb

@@ -1,75 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'time_helper'
-require_relative 'item_data_helper'
-require 'date'
-
-module Timet
-  # Helper methods for processing and updating time fields.
-  module TimeUpdateHelper
-    # Processes and updates a time field (start or end) of a tracking item.
-    #
-    # @param item [Array] The tracking item to be updated.
-    # @param field [String] The time field to be updated.
-    # @param date_value [String] The new value for the time field.
-    # @param id [Integer] The ID of the tracking item.
-    #
-    # @return [void] This method does not return a value; it performs side effects such as updating the time field.
-    #
-    # @note The method formats the date value and checks if it is valid.
-    # @note If the date value is valid, it updates the time field with the new value.
-    # @note If the date value is invalid, it prints an error message.
-    def process_and_update_time_field(*args)
-      item, field, date_value, id = args
-      formatted_date = TimeHelper.format_time_string(date_value)
-
-      return print_error(date_value) unless formatted_date
-
-      new_date = TimeHelper.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
-
-    # Prints an error message for an invalid date.
-    #
-    # @param message [String] The error message to be printed.
-    #
-    # @return [void] This method does not return a value; it performs side effects such as printing an error message.
-    #
-    # @example Print an error message for an invalid date
-    #   print_error('Invalid date: 2023-13-32')
-    def print_error(message)
-      puts "Invalid date: #{message}".red
-    end
-
-    # Validates if a new time value is valid for a specific time field (start or end).
-    #
-    # @param item [Array] The tracking item to be validated.
-    # @param field [String] The time field to be validated.
-    # @param new_value_epoch [Integer] The new time value in epoch format.
-    # @param id [Integer] The ID of the tracking item.
-    #
-    # @return [Boolean] Returns true if the new time value is valid, otherwise false.
-    #
-    # @example Validate a new 'start' time value
-    #   valid_time_value?(item, 'start', 1633072800, 1)
-    def valid_time_value?(*args)
-      item, field, new_value_epoch, id = args
-      item_start = ItemDataHelper.fetch_item_start(item)
-      item_end = ItemDataHelper.fetch_item_end(item)
-      item_before_end = ItemDataHelper.fetch_item_before_end(@db, id, item_start)
-      item_after_start = ItemDataHelper.fetch_item_after_start(@db, id)
-
-      if field == 'start'
-        new_value_epoch.between?(item_before_end, item_end)
-      else
-        new_value_epoch.between?(item_start, item_after_start)
-      end
-    end
-  end
-end

data/lib/timet/time_validation_helper.rb

@@ -1,175 +0,0 @@
-# frozen_string_literal: true
-
-require 'time'
-
-module Timet
-  # Helper module for time validation logic.
-  module TimeValidationHelper
-    # Parses the time string and raises an ArgumentError if the format is invalid.
-    #
-    # @param time_str [String] The time string to parse.
-    #
-    # @return [Time] The parsed time component.
-    #
-    # @raise [ArgumentError] If the time string is not in a valid format.
-    def parse_time_string(time_str)
-      Time.parse(time_str)
-    rescue ArgumentError
-      raise ArgumentError, "Invalid time format: #{time_str}"
-    end
-
-    # Adjusts the end datetime if it's earlier than or same as the start time, assuming it's for the next day.
-    #
-    # @param field [String] The field being validated ('start' or 'end').
-    # @param start_timestamp [Integer, nil] The start timestamp of the item.
-    # @param new_datetime [Time] The new datetime object.
-    #
-    # @return [Time] The adjusted datetime object.
-    def adjust_end_datetime(field, start_timestamp, new_datetime)
-      # If setting 'end' time and the parsed new_datetime (based on start_date)
-      # is earlier than or same as start_time, assume it's for the next calendar day.
-      if field == 'end' && start_timestamp && (new_datetime.to_i <= start_timestamp)
-        new_datetime += (24 * 60 * 60) # Add one day
-      end
-      new_datetime
-    end
-
-    # Determines the base date and time for creating a new datetime object.
-    #
-    # @param item [Array] The item being modified.
-    # @param field [String] The field being validated ('start' or 'end').
-    # @param start_timestamp [Integer, nil] The start timestamp of the item.
-    #
-    # @return [Time] The base date and time.
-    #
-    # @raise [ArgumentError] If the field is 'end' and the start timestamp is not set or if the field is invalid.
-    def determine_base_date_time(_item, field, start_timestamp)
-      case field
-      when 'start'
-        determine_start_base_date_time(start_timestamp)
-      when 'end'
-        determine_end_base_date_time(start_timestamp)
-      else
-        raise ArgumentError, "Invalid field: #{field}"
-      end
-    end
-
-    # Determines the base date and time for the 'start' field.
-    #
-    # @param start_timestamp [Integer, nil] The start timestamp of the item.
-    #
-    # @return [Time] The base date and time.
-    def determine_start_base_date_time(start_timestamp)
-      start_timestamp ? Time.at(start_timestamp) : Time.now
-    end
-    private :determine_start_base_date_time
-
-    # Determines the base date and time for the 'end' field.
-    #
-    # @param start_timestamp [Integer, nil] The start timestamp of the item.
-    #
-    # @return [Time] The base date and time.
-    #
-    # @raise [ArgumentError] If the start timestamp is not set.
-    def determine_end_base_date_time(start_timestamp)
-      # This ensures that start_timestamp is not nil when setting/editing an end time.
-      raise ArgumentError, "Cannot set 'end' time because 'start' time is not set." unless start_timestamp
-
-      Time.at(start_timestamp)
-    end
-    private :determine_end_base_date_time
-
-    # Creates a new datetime object based on the parsed time component.
-    #
-    # @param _base_date_time [Time] The base date and time (not used for date components).
-    # @param parsed_time_component [Time] The parsed time component.
-    #
-    # @return [Time] The new datetime object.
-    def create_new_datetime(_base_date_time, parsed_time_component)
-      Time.new(
-        parsed_time_component.year,
-        parsed_time_component.month,
-        parsed_time_component.day,
-        parsed_time_component.hour,
-        parsed_time_component.min,
-        parsed_time_component.sec,
-        parsed_time_component.utc_offset # Preserve timezone context
-      )
-    end
-
-    # Validates that the new datetime is not in the future.
-    #
-    # @param new_datetime [Time] The new datetime object.
-    #
-    # @raise [ArgumentError] If the new datetime is in the future.
-    def validate_future_date(new_datetime)
-      # Ensure the new datetime is not in the future relative to the current time.
-      return unless new_datetime > Time.now.getlocal
-
-      raise ArgumentError, "Cannot set time to a future date or time: #{new_datetime.strftime('%Y-%m-%d %H:%M:%S')}"
-    end
-
-    # Validates that the difference between two timestamps is less than 24 hours.
-    #
-    # @param timestamp1 [Integer] The first timestamp.
-    # @param timestamp2 [Integer] The second timestamp.
-    #
-    # @raise [ArgumentError] If the difference is >= 24 hours.
-    def validate_time_difference(timestamp1, timestamp2)
-      return unless (timestamp2 - timestamp1).abs >= 24 * 60 * 60
-
-      raise ArgumentError, 'The difference between start and end time must be less than 24 hours.'
-    end
-    private :validate_time_difference
-
-    # Validates the time order (start before end, end after start).
-    #
-    # @param new_epoch [Integer] The new time in epoch format.
-    # @param reference_timestamp [Integer] The reference timestamp (start or end).
-    # @param new_datetime [Time] The new datetime object.
-    # @param field [String] The field being validated ('start' or 'end').
-    #
-    # @raise [ArgumentError] If the time order is invalid.
-    def validate_time_order(new_epoch, reference_timestamp, new_datetime, field)
-      case field
-      when 'end'
-        if new_epoch <= reference_timestamp
-          raise ArgumentError,
-                "End time (#{new_datetime.strftime('%Y-%m-%d %H:%M:%S')}) must be after start time " \
-                "(#{Time.at(reference_timestamp).strftime('%Y-%m-%d %H:%M:%S')})."
-        end
-      when 'start'
-        if new_epoch >= reference_timestamp
-          raise ArgumentError,
-                "Start time (#{new_datetime.strftime('%Y-%m-%d %H:%M:%S')}) must be before end time " \
-                "(#{Time.at(reference_timestamp).strftime('%Y-%m-%d %H:%M:%S')})."
-        end
-      end
-    end
-    private :validate_time_order
-
-    # Validates the end time against the start time.
-    #
-    # @param new_epoch [Integer] The new end time in epoch format.
-    # @param start_timestamp [Integer] The start timestamp of the item.
-    # @param new_datetime [Time] The new datetime object.
-    #
-    # @raise [ArgumentError] If the end time is not after the start time or the difference is >= 24 hours.
-    def validate_end_time(new_epoch, start_timestamp, new_datetime)
-      validate_time_order(new_epoch, start_timestamp, new_datetime, 'end')
-      validate_time_difference(start_timestamp, new_epoch)
-    end
-
-    # Validates the start time against the end time.
-    #
-    # @param new_epoch [Integer] The new start time in epoch format.
-    # @param end_timestamp [Integer] The end timestamp of the item.
-    # @param new_datetime [Time] The new datetime object.
-    #
-    # @raise [ArgumentError] If the start time is not before the end time or the difference is >= 24 hours.
-    def validate_start_time(new_epoch, end_timestamp, new_datetime)
-      validate_time_order(new_epoch, end_timestamp, new_datetime, 'start')
-      validate_time_difference(new_epoch, end_timestamp)
-    end
-  end
-end