timet 1.5.6 → 1.5.7

data/lib/timet/validation_edit_helper.rb

@@ -1,11 +1,17 @@
 # frozen_string_literal: true
 
 require_relative 'time_helper'
+require_relative 'item_data_helper'
+require_relative 'time_update_helper'
+require_relative 'time_validation_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
+    include TimeValidationHelper
+
     # Constants for time fields.
     TIME_FIELDS = %w[start end].freeze
 
@@ -25,9 +31,9 @@ module Timet
       when 'tag'
         item[3] = new_value
       when 'start'
-        item[1] = validate_time(new_value)
+        item[1] = validate_time(item, 'start', new_value)
       when 'end'
-        item[2] = validate_time(new_value)
+        item[2] = validate_time(item, 'end', new_value)
       else
         raise ArgumentError, "Invalid field: #{field}"
       end
@@ -36,149 +42,119 @@ module Timet
 
     # Validates if a given time string is in a valid format.
     #
-    # @param time_str [String] The time string to validate.
+    # @param item [Array] The item being modified.
+    # @param field [String] The field being validated ('start' or 'end').
+    # @param time_str [String, nil] The new time string (e.g., "HH:MM" or "HH:MM:SS").
+    #                               If nil or empty, it signifies that the original time should be kept.
     #
-    # @return [Integer] The validated time as an integer.
+    # @return [Integer, nil] The validated time as an integer epoch.
+    #                        Returns the original timestamp for the field if time_str is nil/empty.
+    #                        Returns nil if the original field was nil and time_str is nil/empty.
     #
     # @raise [ArgumentError] If the time string is not in a valid format.
-    def validate_time(time_str)
-      Time.parse(time_str).to_i
-    rescue ArgumentError
-      raise ArgumentError, "Invalid time format: #{time_str}"
-    end
+    def validate_time(item, field, time_str)
+      # If time_str is nil or empty, user pressed Enter, meaning no change to this field.
+      return field == 'start' ? item[1] : item[2] if time_str.nil? || time_str.strip.empty?
 
-    private
+      parsed_time_component = parse_time_string(time_str)
 
-    # 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)
+      start_timestamp = item[1]
+      end_timestamp = item[2]
 
-      return print_error(date_value) unless formatted_date
+      new_datetime = determine_and_create_datetime(item, field, start_timestamp, parsed_time_component)
 
-      new_date = update_time_field(item, field, formatted_date)
-      new_value_epoch = new_date.to_i
+      new_epoch = new_datetime.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
+      perform_validation(
+        item: item,
+        field: field,
+        new_epoch: new_epoch,
+        start_timestamp: start_timestamp,
+        end_timestamp: end_timestamp,
+        new_datetime: new_datetime
+      )
 
-    # 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
+      new_epoch
     end
 
-    # Updates a time field (start or end) of a tracking item with a formatted date value.
+    # Validates that the new start or end time does not collide with existing entries.
     #
-    # @param item [Array] The tracking item to be updated.
-    # @param field [String] The time field to be updated.
-    # @param new_time [String] The new time value.
+    # @param item [Array] The item being modified.
+    # @param field [String] The field being validated ('start' or 'end').
+    # @param new_epoch [Integer] The new time in epoch format.
     #
-    # @return [Time] The updated time value.
-    #
-    # @example Update the 'start' field of a tracking item with a formatted date value
-    #   update_time_field(item, 'start', '11:10:00')
-    def update_time_field(item, field, new_time)
-      field_index = Timet::Application::FIELD_INDEX[field]
-      timestamp = item[field_index]
-      edit_time = Time.at(timestamp || item[1]).to_s.split
-      edit_time[1] = new_time
-      DateTime.strptime(edit_time.join(' '), '%Y-%m-%d %H:%M:%S %z').to_time
-    end
+    # @raise [ArgumentError] If the new time collides with a previous or next item.
+    def validate_time_collisions(item, field, new_epoch)
+      item_id = item[0]
+      prev_item = @db.find_item(item_id - 1)
+      next_item = @db.find_item(item_id + 1)
 
-    # 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 = 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.between?(item_before_end, item_end)
-      else
-        new_value_epoch.between?(item_start, item_after_start)
-      end
+      check_collision_with_previous_item(field, new_epoch, prev_item)
+      check_collision_with_next_item(field, new_epoch, next_item)
     end
 
-    # 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']]
+    # Checks for collision with the previous item.
+    def check_collision_with_previous_item(field, new_epoch, prev_item)
+      return unless prev_item && field == 'start' && new_epoch < prev_item[2]
+
+      raise ArgumentError,
+            'New start time collides with previous item (ends at ' \
+            "#{Time.at(prev_item[2]).strftime('%Y-%m-%d %H:%M:%S')})."
     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
+    # Checks for collision with the next item.
+    def check_collision_with_next_item(field, new_epoch, next_item)
+      return unless next_item
+
+      if field == 'start' && new_epoch > next_item[1]
+        raise ArgumentError,
+              'New start time collides with next item (starts at ' \
+              "#{Time.at(next_item[1]).strftime('%Y-%m-%d %H:%M:%S')})."
+      elsif field == 'end' && new_epoch > next_item[1]
+        raise ArgumentError,
+              'New end time collides with next item (starts at ' \
+              "#{Time.at(next_item[1]).strftime('%Y-%m-%d %H:%M:%S')})."
+      end
     end
 
-    # Fetches the end time of the tracking item before the current one.
-    #
-    # @param id [Integer] The ID of the current tracking item.
-    # @param item_start [Integer] The start time of the current tracking item.
+    private
+
+    # Determines the base date and time, creates a new datetime object, and adjusts it if necessary.
     #
-    # @return [Integer] The end time of the previous tracking item in epoch format.
+    # @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.
+    # @param parsed_time_component [Time] The parsed time component.
     #
-    # @example Fetch the end time of the previous tracking item
-    #   fetch_item_before_end(1, 1633072800)
-    def fetch_item_before_end(id, item_start)
-      @db.find_item(id - 1)&.dig(Timet::Application::FIELD_INDEX['end']) || item_start
+    # @return [Time] The new datetime object.
+    def determine_and_create_datetime(item, field, start_timestamp, parsed_time_component)
+      base_date_time = determine_base_date_time(item, field, start_timestamp)
+      new_datetime = create_new_datetime(base_date_time, parsed_time_component)
+      adjust_end_datetime(field, start_timestamp, new_datetime)
     end
 
-    # Fetches the start time of the tracking item after the current one.
-    #
-    # @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(1)
-    def fetch_item_after_start(id)
-      @db.find_item(id + 1)&.dig(Timet::Application::FIELD_INDEX['start']) || TimeHelper.current_timestamp
+    # Performs the appropriate validation based on the field.
+    #
+    # @param options [Hash] A hash containing the parameters for validation.
+    # @option options [Array] :item The item being modified.
+    # @option options [String] :field The field being validated ('start' or 'end').
+    # @option options [Integer] :new_epoch The new time in epoch format.
+    # @option options [Integer, nil] :start_timestamp The start timestamp of the item.
+    # @option options [Integer, nil] :end_timestamp The end timestamp of the item.
+    # @option options [Time] :new_datetime The new datetime object.
+    def perform_validation(options)
+      item = options[:item]
+      field = options[:field]
+      new_epoch = options[:new_epoch]
+      start_timestamp = options[:start_timestamp]
+      end_timestamp = options[:end_timestamp]
+      new_datetime = options[:new_datetime]
+
+      validate_future_date(new_datetime)
+
+      validate_time_collisions(item, field, new_epoch) # Call the new method for both start and end
+      validate_start_time(new_epoch, end_timestamp, new_datetime) if field == 'start' && end_timestamp
+      validate_end_time(new_epoch, start_timestamp, new_datetime) if field == 'end'
     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.5.6'
-  VERSION = '1.5.6'
+  #   Timet::VERSION # => '1.5.7'
+  VERSION = '1.5.7'
 end

data/lib/timet/week_info.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require 'date'
+
+module Timet
+  #
+  # The WeekInfo class encapsulates the date string and weeks array
+  # and provides methods for formatting and determining week information.
+  #
+  # It is instantiated for each date entry in the TimeBlockChart and helps decide
+  # how the week number is displayed and whether a separator line is needed before the entry.
+  class WeekInfo
+    # Initializes a new WeekInfo instance.
+    #
+    # @param date_object [Date] The Date object for the current entry.
+    # @param date_string_for_display [String] The original date string for display (e.g., "2023-10-01").
+    # @param weeks_array_ref [Array<Integer>] A reference to an array that accumulates the
+    #   ISO 8601 week numbers of dates already processed. This array is mutated.
+
+    WEEKEND_DAYS = %w[Sat Sun].freeze
+    def initialize(date_object, date_string_for_display, weeks_array_ref)
+      @date_string = date_string_for_display # Use the passed string for display
+      @current_cweek = date_object.cweek
+
+      # Determine if a separator line should be printed *before* this entry.
+      # A separator is needed if this entry starts a new week group,
+      # and it's not the very first week group in the chart.
+      @print_separator_before_this = !weeks_array_ref.empty? && @current_cweek != weeks_array_ref.last
+
+      # Determine how the week number string should be displayed for this entry.
+      # It's underlined if it's the first time this cweek appears, otherwise blank.
+      is_first_display_of_this_cweek = weeks_array_ref.empty? || @current_cweek != weeks_array_ref.last
+      @week_display_string = if is_first_display_of_this_cweek
+                               format('%02d', @current_cweek).underline
+                             else
+                               '  '
+                             end
+
+      weeks_array_ref << @current_cweek # Record this week as processed
+    end
+
+    # Indicates whether an inter-week separator line should be printed before this date's entry.
+    #
+    # @return [Boolean] True if a separator is needed, false otherwise.
+    def needs_inter_week_separator?
+      @print_separator_before_this
+    end
+
+    # Formats and prints the date information
+    #
+    # @param [String] day The day of the week
+    # @return [void]
+    def format_and_print_date_info(day)
+      weekend_str = @date_string # Use the original date string for display
+      is_weekend_day = WEEKEND_DAYS.include?(day)
+      day_str = is_weekend_day ? day.red : day
+      weekend_str = weekend_str.red if is_weekend_day
+
+      print '┆'.gray + "#{@week_display_string} #{weekend_str} #{day_str}" + '┆- '.gray
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: timet
 version: !ruby/object:Gem::Version
-  version: 1.5.6
+  version: 1.5.7
 platform: ruby
 authors:
 - Frank Vielma
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-04-07 00:00:00.000000000 Z
+date: 2025-05-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: thor
@@ -136,10 +136,12 @@ files:
 - lib/timet.rb
 - lib/timet/application.rb
 - lib/timet/application_helper.rb
+- lib/timet/block_char_helper.rb
 - lib/timet/color_codes.rb
 - lib/timet/database.rb
 - lib/timet/database_sync_helper.rb
 - lib/timet/database_syncer.rb
+- lib/timet/item_data_helper.rb
 - lib/timet/s3_supabase.rb
 - lib/timet/table.rb
 - lib/timet/tag_distribution.rb
@@ -148,8 +150,12 @@ files:
 - 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/version.rb
+- lib/timet/week_info.rb
 - sig/timet.rbs
 homepage: https://frankvielma.github.io/posts/timet-a-powerful-command-line-tool-for-tracking-your-time/
 licenses: