timet 1.5.6 → 1.5.7

data/lib/timet/time_report_helper.rb

@@ -6,81 +6,6 @@ module Timet
   # and validating date formats.
   # This module is designed to be included in classes that require time report processing functionalities.
   module TimeReportHelper
-    # Provides predefined date ranges for filtering.
-    #
-    # @return [Hash] A hash containing predefined date ranges.
-    #
-    # @example Get the predefined date ranges
-    #   date_ranges
-    #
-    # @note The method returns a hash with predefined date ranges for 'today', 'yesterday', 'week', and 'month'.
-    def date_ranges
-      today = Date.today
-      tomorrow = today + 1
-      {
-        'today' => [today, nil],
-        'yesterday' => [today - 1, nil],
-        'week' => [today - 7, tomorrow],
-        'month' => [today - 30, tomorrow]
-      }
-    end
-
-    # Formats an item for CSV export.
-    #
-    # @param item [Array] The item to format.
-    #
-    # @return [Array] The formatted item.
-    #
-    # @example Format an item for CSV export
-    #   format_item(item)
-    #
-    # @note The method formats the item's ID, start time, end time, tag, and notes.
-    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
-
-    # Validates the date format.
-    #
-    # @param date_string [String] The date string to validate.
-    #
-    # @return [Boolean] True if the date format is valid, otherwise false.
-    #
-    # @example Validate the date format
-    #   valid_date_format?('2021-10-01') # => true
-    #
-    # @note The method validates the date format for single dates and date ranges.
-    def valid_date_format?(date_string)
-      date_format_single = /^\d{4}-\d{2}-\d{2}$/
-      date_format_range = /^\d{4}-\d{2}-\d{2}\.\.\d{4}-\d{2}-\d{2}$/
-
-      date_string.match?(date_format_single) || date_string.match?(date_format_range)
-    end
-
-    # Merges two hashes, summing the numeric values of corresponding keys.
-    #
-    # @param base_hash [Hash] The base hash to which the additional hash will be merged.
-    # @param additional_hash [Hash] The additional hash whose values will be added to the base hash.
-    # @return [Hash] A new hash with the summed values.
-    #
-    # @example
-    #   base_hash = { 'key1' => [10, 'tag1'], 'key2' => [20, 'tag2'] }
-    #   additional_hash = { 'key1' => [5, 'tag1'], 'key3' => [15, 'tag3'] }
-    #   add_hashes(base_hash, additional_hash)
-    #   #=> { 'key1' => [15, 'tag1'], 'key2' => [20, 'tag2'], 'key3' => [15, 'tag3'] }
-    def add_hashes(base_hash, additional_hash)
-      base_hash.merge(additional_hash) do |_key, old_value, new_value|
-        summed_number = old_value[0] + new_value[0]
-        [summed_number, old_value[1]]
-      end
-    end
-
     # 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.
@@ -101,51 +26,11 @@ module Timet
     # @return [void]
     def export_icalendar
       file_name = "#{ics_filename}.ics"
-      cal = add_events
+      cal = Timet::Utils.add_events(items)
 
       File.write(file_name, cal.to_ical)
 
       puts "The #{file_name} has been generated."
     end
-
-    private
-
-    # Creates an iCalendar object and adds events to it.
-    #
-    # @return [Icalendar::Calendar] the populated iCalendar object
-    def add_events
-      cal = Icalendar::Calendar.new
-      items.each do |item|
-        event = create_event(item)
-        cal.add_event(event)
-      end
-      cal.publish
-      cal
-    end
-
-    # Creates an iCalendar event from the given item.
-    #
-    # @param item [Array] the item containing event details
-    # @return [Icalendar::Event] the created event
-    def create_event(item)
-      dtstart = convert_to_datetime(item[1])
-      dtend = convert_to_datetime(item[2] || TimeHelper.current_timestamp)
-
-      Icalendar::Event.new.tap do |e|
-        e.dtstart     = dtstart
-        e.dtend       = dtend
-        e.summary     = item[3]
-        e.description = item[4]
-        e.ip_class    = 'PRIVATE'
-      end
-    end
-
-    # Converts a timestamp to a DateTime object.
-    #
-    # @param timestamp [Integer] the timestamp to convert
-    # @return [DateTime] the converted DateTime object
-    def convert_to_datetime(timestamp)
-      Time.at(timestamp).to_datetime
-    end
   end
 end

data/lib/timet/time_update_helper.rb

@@ -0,0 +1,93 @@
+# 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 = 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
+
+    # Updates a time field (start or end) of a tracking item with a formatted date value.
+    #
+    # @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.
+    #
+    # @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
+
+    # 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

@@ -0,0 +1,174 @@
+# 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)
+      return unless new_datetime > Time.now
+
+      raise ArgumentError, "Cannot set time to a future date: #{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/utils.rb

@@ -0,0 +1,130 @@
+# frozen_string_literal: true
+
+require_relative 'time_helper'
+
+module Timet
+  # The Utils module provides a collection of general utility methods used across the Timet gem.
+  module Utils
+    # Merges two hashes, summing the numeric values of corresponding keys.
+    #
+    # @param base_hash [Hash] The base hash to which the additional hash will be merged.
+    # @param additional_hash [Hash] The additional hash whose values will be added to the base hash.
+    # @return [Hash] A new hash with the summed values.
+    #
+    # @example
+    #   base_hash = { 'key1' => [10, 'tag1'], 'key2' => [20, 'tag2'] }
+    #   additional_hash = { 'key1' => [5, 'tag1'], 'key3' => [15, 'tag3'] }
+    #   Utils.add_hashes(base_hash, additional_hash)
+    #   #=> { 'key1' => [15, 'tag1'], 'key2' => [20, 'tag2'], 'key3' => [15, 'tag3'] }
+    def self.add_hashes(base_hash, additional_hash)
+      base_hash.merge(additional_hash) do |_key, old_value, new_value|
+        summed_number = old_value[0] + new_value[0]
+        [summed_number, old_value[1]]
+      end
+    end
+
+    # Converts a timestamp to a DateTime object.
+    #
+    # @param timestamp [Integer] the timestamp to convert
+    # @return [DateTime] the converted DateTime object
+    def self.convert_to_datetime(timestamp)
+      Time.at(timestamp).to_datetime
+    end
+
+    # Provides predefined date ranges for filtering.
+    #
+    # @return [Hash] A hash containing predefined date ranges.
+    #
+    # @example Get the predefined date ranges
+    #   Utils.date_ranges
+    #
+    # @note The method returns a hash with predefined date ranges for 'today', 'yesterday', 'week', and 'month'.
+    def self.date_ranges
+      today = Date.today
+      tomorrow = today + 1
+      {
+        'today' => [today, nil],
+        'yesterday' => [today - 1, nil],
+        'week' => [today - 7, tomorrow],
+        'month' => [today - 30, tomorrow]
+      }
+    end
+
+    # Formats an item for CSV export.
+    #
+    # @param item [Array] The item to format.
+    #
+    # @return [Array] The formatted item.
+    #
+    # @example Format an item for CSV export
+    #   Utils.format_item(item)
+    #
+    # @note The method formats the item's ID, start time, end time, tag, and notes.
+    def self.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
+
+    # Validates the date format.
+    #
+    # @param date_string [String] The date string to validate.
+    #
+    # @return [Boolean] True if the date format is valid, otherwise false.
+    #
+    # @example Validate the date format
+    #   Utils.valid_date_format?('2021-10-01') # => true
+    #
+    # @note The method validates the date format for single dates and date ranges.
+    def self.valid_date_format?(date_string)
+      date_format_single = /^\d{4}-\d{2}-\d{2}$/
+      date_format_range = /^\d{4}-\d{2}-\d{2}\.\.\d{4}-\d{2}-\d{2}$/
+
+      date_string.match?(date_format_single) || date_string.match?(date_format_range)
+    end
+
+    # Assigns attributes to an iCalendar event.
+    #
+    # @param event [Icalendar::Event] the event object
+    # @param item [Array] the item containing event details
+    def self.assign_event_attributes(event, item)
+      dtstart = convert_to_datetime(item[1])
+      dtend = convert_to_datetime(item[2] || TimeHelper.current_timestamp)
+
+      event.dtstart     = dtstart
+      event.dtend       = dtend
+      event.summary     = item[3]
+      event.description = item[4]
+      event.ip_class    = 'PRIVATE'
+    end
+
+    # Creates an iCalendar event from the given item.
+    #
+    # @param item [Array] the item containing event details
+    # @return [Icalendar::Event] the created event
+    def self.create_event(item)
+      event = Icalendar::Event.new
+      assign_event_attributes(event, item)
+      event
+    end
+
+    # Creates an iCalendar object and adds events to it.
+    #
+    # @param items [Array] the items containing event details
+    # @return [Icalendar::Calendar] the populated iCalendar object
+    def self.add_events(items)
+      cal = Icalendar::Calendar.new
+      items.each do |item|
+        event = create_event(item)
+        cal.add_event(event)
+      end
+      cal.publish
+      cal
+    end
+  end
+end