timet 1.6.1.1 → 1.6.3

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.1.1'
-  VERSION = '1.6.1.1'
+  #   Timet::VERSION # => '1.6.3'
+  VERSION = '1.6.3'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: timet
 version: !ruby/object:Gem::Version
-  version: 1.6.1.1
+  version: 1.6.3
 platform: ruby
 authors:
 - Frank Vielma
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-10-10 00:00:00.000000000 Z
+date: 2026-02-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: thor
@@ -106,14 +106,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.178'
+        version: '1.209'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.178'
+        version: '1.209'
 description: Timet is a command-line time tracker that keeps track of your activities.
 email:
 - frankvielma@gmail.com
@@ -124,6 +124,7 @@ extensions: []
 extra_rdoc_files: []
 files:
 - ".deepsource.toml"
+- ".qlty/qlty.toml"
 - ".reek.yml"
 - ".rspec"
 - ".rubocop.yml"
@@ -143,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