timet 1.6.1.1 → 1.6.3

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

data/lib/timet/validation_edit_helper.rb

@@ -1,160 +0,0 @@
-# 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
-
-    # Validates and updates an item's attribute based on the provided field and new value.
-    #
-    # @param item [Array] The item to be updated.
-    # @param field [String] The field to be updated.
-    # @param new_value [String] The new value for the field.
-    #
-    # @return [Array] The updated item.
-    #
-    # @raise [ArgumentError] If the field is invalid or the new value is invalid.
-    def validate_and_update(item, field, new_value)
-      case field
-      when 'notes'
-        item[4] = new_value
-      when 'tag'
-        item[3] = new_value
-      when 'start'
-        item[1] = validate_time(item, 'start', new_value)
-      when 'end'
-        item[2] = validate_time(item, 'end', new_value)
-      else
-        raise ArgumentError, "Invalid field: #{field}"
-      end
-      item
-    end
-
-    # Validates if a given time string is in a valid format.
-    #
-    # @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, 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(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?
-
-      parsed_time_component = parse_time_string(time_str)
-
-      start_timestamp = item[1]
-      end_timestamp = item[2]
-
-      new_datetime = determine_and_create_datetime(item, field, start_timestamp, parsed_time_component)
-
-      new_epoch = new_datetime.to_i
-
-      perform_validation(
-        item: item,
-        field: field,
-        new_epoch: new_epoch,
-        start_timestamp: start_timestamp,
-        end_timestamp: end_timestamp,
-        new_datetime: new_datetime
-      )
-
-      new_epoch
-    end
-
-    # Validates that the new start or end time does not collide with existing entries.
-    #
-    # @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.
-    #
-    # @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)
-
-      check_collision_with_previous_item(field, new_epoch, prev_item)
-      check_collision_with_next_item(field, new_epoch, next_item)
-    end
-
-    # 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
-
-    # 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
-
-    private
-
-    # Determines the base date and time, creates a new datetime object, and adjusts it if necessary.
-    #
-    # @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.
-    #
-    # @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
-
-    # 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