timet 1.5.3 → 1.5.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f65773f17ed00b4aff9ff1a3157191f8753686755b6ffd2e985bde5927783c99
-  data.tar.gz: b3f6474b4db6fc4f3ebed7b0d976c46061cfc29c85461c6f437a16f48c824aa5
+  metadata.gz: bc6553610acca8f30eb067accd9a8ff09756ea7c0fdb231dac896210018e0db1
+  data.tar.gz: 41e673fa16e1a7ea7d7c7c3f75a7131c7add0fa4ea297ae3044ca9ddbbd1b4f3
 SHA512:
-  metadata.gz: a0db80d8b3671e64d6afc2d1164c74567fedb707a83493042ffb1e3cc87f8242580442e1ad21afc7fb1fd567c1e0b70de96a4647edcc6aef47f44406790d1a5e
-  data.tar.gz: 394458e551db981b18b6c1e72a9fa0b734031e6c8408f70f1fd7d2498a98e292204eca0835374b03a7e51df47d0fcc63266d696a9744863a31e153210a3e26d1
+  metadata.gz: '01793d4487cd53b78a2d35721a3e6d91ff29a8c98976e9e861bfc599e49dfbf89939bec66da4fd986f8b8f99c4cf2001ac859274859185aaf4a89f9f56bae7a3'
+  data.tar.gz: c0f27b5b4656c07a16e861544daf610b94d397a5b245e89d65850c23e24f1a5318042b6871430cd2c0341c0bdb3f27b4163781bbf024680157cd68889202459c

data/.rubocop.yml

@@ -8,4 +8,13 @@ AllCops:
 Metrics/MethodLength:
   Max: 12
 
-require: rubocop-rspec
+plugins: rubocop-rspec
+
+RSpec/ExampleLength:
+  Max: 15 
+
+Metrics/CyclomaticComplexity:
+  Max: 8
+
+RSpec/MultipleMemoizedHelpers:
+  Max: 15

data/CHANGELOG.md

@@ -1,4 +1,51 @@
-## [Unreleased]
+## [1.5.5] - 2025-02-26
+
+**Improvements:**
+
+- Refactored `DatabaseSyncer` specs to improve clarity, maintainability, and reduce redundancy.
+  - Removed `#process_existing_item` as its logic was redundant.
+  - Improved `#remote_wins?` tests with `let` blocks and better descriptions.
+  - Split multi-expectation tests into smaller, focused tests.
+  - Improved test descriptions for accuracy and clarity.
+  - Reorganized tests into more logical `describe` blocks.
+  - Moved S3 download tests to the `Timet::S3Supabase` `describe` block.
+  - Improved CSV export tests with extracted common data, centralized database setup, and a helper method.
+  - Improved message expectations in `#export_report` using `class_spy` and `have_received`.
+  - Improved test readability in `ApplicationHelper` with `let` blocks and separate `it` blocks.
+  - Refactored `DatabaseSyncer` specs with `let` blocks, focused examples, and explicit `expect` assertions.
+  - Prefer `have_received` for setting message expectations.
+  - Improved granularity in specs with smaller, focused examples and shared test data.
+- Updated gem dependencies to latest versions.
+- Overall code cleanup and improved test structure.
+- Update the way rubocop plugins are defined in the config.
+- Removed unnecessary comments.
+
+**Bug Fixes:**
+
+- Fixed a bug in the time field update logic in `validation_edit_helper`, specifically regarding the end time.
+
+## [1.5.4] - 2025-02-11
+
+**Improvements:**
+
+- Added `.env` file creation in CI workflow for testing environment variables.
+- Updated Code Climate coverage reporting to use `simplecov-lcov` for LCOV format compatibility.
+- Refactored validation error message tests in `ValidationEditHelper` for clarity and maintainability.
+- Simplified environment variable validation in `S3Supabase` by introducing a helper method `check_env_var`.
+- Improved integration tests for `play_sound_and_notify` with better stubbing and platform-specific behavior checks.
+- Added comprehensive tests for `#process_existing_item`, `#update_item_from_hash`, and `#insert_item_from_hash` in `DatabaseSyncer`.
+- Enhanced database synchronization logic and moved `ITEM_FIELDS` to `DatabaseSyncer` for better organization.
+- Added `.format_time_string` method to `TimeHelper` with tests for various input formats.
+- Updated AWS SDK dependencies and improved database sync logging.
+- Consolidated integration tests and improved readability.
+- Improved error handling and added tests for `S3Supabase`.
+
+**Bug Fixes:**
+
+- Fixed environment variable validation in `S3Supabase` to handle `nil` values.
+- Resolved issues with database synchronization logic in `DatabaseSyncer`.
+- Fixed test setup and cleanup in `S3Supabase` and `DatabaseSyncer` specs.
+- Addressed edge cases in `#process_and_update_time_field` and `#valid_time_value?`.
 
 ## [1.5.3] - 2025-01-02
 

data/lib/timet/application.rb

@@ -52,15 +52,14 @@ module Timet
     def initialize(*args)
       super
 
-      # Initialize database without validation in test environment
       if defined?(RSpec)
         @db = Database.new
       else
-        command_name = args[2][:current_command].name
+        command_name = args.dig(2, :current_command, :name)
         if VALID_ARGUMENTS.include?(command_name)
           @db = Database.new
         else
-          puts 'Invalid arguments provided. Please check your input.'
+          warn 'Invalid arguments provided. Please check your input.'
           exit(1)
         end
       end
@@ -110,6 +109,7 @@ module Timet
 
     desc 'stop', 'Stop time tracking'
     # Stops the current tracking session if there is one in progress.
+    # After stopping the tracking session, it displays a summary of the tracked time.
     #
     # @return [void] This method does not return a value; it performs side effects such as updating the tracking item
     # and generating a summary.
@@ -120,15 +120,14 @@ module Timet
     # @note The method checks if the last tracking item is in progress by calling `@db.item_status`.
     # @note If the last item is in progress, it fetches the last item's ID using `@db.fetch_last_id` and updates it
     # with the current timestamp.
-    # @note The method then fetches the last item using `@db.last_item` and generates a summary if the result
-    # is not nil.
-    def stop(display = nil)
+    # @note The method always generates a summary after stopping the tracking session.
+    def stop
       return unless @db.item_status == :in_progress
 
       last_id = @db.fetch_last_id
       @db.update_item(last_id, 'end', TimeHelper.current_timestamp)
 
-      summary unless display
+      summary
     end
 
     desc 'resume (r) [id]', 'Resume last task (id is an optional parameter) => tt resume'
@@ -306,6 +305,7 @@ module Timet
     desc 'sync', 'Sync local db with supabase external db'
     def sync
       puts 'Syncing database with remote storage...'
+      puts 'Sync method called'
       DatabaseSyncHelper.sync(@db, BUCKET)
     end
   end

data/lib/timet/application_helper.rb

@@ -111,7 +111,7 @@ module Timet
     def run_linux_session(time, tag)
       notification_command = "notify-send --icon=clock '#{show_message(tag)}'"
       command = "sleep #{time} && tput bel && tt stop 0 && #{notification_command} &"
-      pid = spawn(command)
+      pid = Kernel.spawn(command)
       Process.detach(pid)
     end
 
@@ -123,7 +123,7 @@ module Timet
     def run_mac_session(time, tag)
       notification_command = "osascript -e 'display notification \"#{show_message(tag)}\"'"
       command = "sleep #{time} && afplay /System/Library/Sounds/Basso.aiff && tt stop 0 && #{notification_command} &"
-      pid = spawn(command)
+      pid = Kernel.spawn(command)
       Process.detach(pid)
     end
 

data/lib/timet/database.rb

@@ -285,8 +285,6 @@ module Timet
       :complete
     end
 
-    private
-
     # Moves the old database file to the new location if it exists.
     #
     # @param database_path [String] The path to the new SQLite database file.
@@ -314,7 +312,7 @@ module Timet
     # @raise [StandardError] If there is an issue executing the SQL queries, an error may be raised.
     #
     def update_time_columns
-      result = execute_sql('SELECT * FROM items where updated_at is null or created_at is null')
+      result = execute_sql('SELECT * FROM items WHERE updated_at IS NULL OR created_at IS NULL')
       result.each do |item|
         id = item[0]
         end_time = item[2]

data/lib/timet/database_sync_helper.rb

@@ -2,13 +2,13 @@
 
 require 'tempfile'
 require 'digest'
+require_relative 'database_syncer'
 
 module Timet
   # Helper module for database synchronization operations
   # Provides methods for comparing and syncing local and remote databases
   module DatabaseSyncHelper
-    # Fields used in item operations
-    ITEM_FIELDS = %w[start end tag notes pomodoro updated_at created_at deleted].freeze
+    extend DatabaseSyncer
 
     # Main entry point for database synchronization
     #
@@ -57,6 +57,8 @@ module Timet
     # @note This method ensures proper resource cleanup by using ensure block
     def self.with_temp_file
       temp_file = Tempfile.new('remote_db')
+      raise 'Temporary file path is nil' unless temp_file.path
+
       yield temp_file
     ensure
       temp_file.close
@@ -74,209 +76,5 @@ module Timet
       local_md5 = Digest::MD5.file(local_path).hexdigest
       remote_md5 == local_md5
     end
-
-    # Handles the synchronization process when differences are detected between databases
-    #
-    # @param local_db [SQLite3::Database] The local database connection
-    # @param remote_storage [S3Supabase] The remote storage client for cloud operations
-    # @param bucket [String] The S3 bucket name
-    # @param local_db_path [String] Path to the local database file
-    # @param remote_path [String] Path to the downloaded remote database file
-    # @return [void]
-    # @note This method attempts to sync the databases and handles any errors that occur during the process
-    def self.handle_database_differences(*args)
-      local_db, remote_storage, bucket, local_db_path, remote_path = args
-      puts 'Differences detected between local and remote databases'
-      begin
-        sync_with_remote_database(local_db, remote_path, remote_storage, bucket, local_db_path)
-      rescue SQLite3::Exception => e
-        handle_sync_error(e, remote_storage, bucket, local_db_path)
-      end
-    end
-
-    # Performs the actual database synchronization by setting up connections and syncing data
-    #
-    # @param local_db [SQLite3::Database] The local database connection
-    # @param remote_path [String] Path to the remote database file
-    # @param remote_storage [S3Supabase] The remote storage client for cloud operations
-    # @param bucket [String] The S3 bucket name
-    # @param local_db_path [String] Path to the local database file
-    # @return [void]
-    # @note Configures both databases to return results as hashes for consistent data handling
-    def self.sync_with_remote_database(*args)
-      local_db, remote_path, remote_storage, bucket, local_db_path = args
-      db_remote = open_remote_database(remote_path)
-      db_remote.results_as_hash = true
-      local_db.instance_variable_get(:@db).results_as_hash = true
-      sync_databases(local_db, db_remote, remote_storage, bucket, local_db_path)
-    end
-
-    # Opens and validates a connection to the remote database
-    #
-    # @param remote_path [String] Path to the remote database file
-    # @return [SQLite3::Database] The initialized database connection
-    # @raise [RuntimeError] If the database connection cannot be established
-    # @note Validates that the database connection is properly initialized
-    def self.open_remote_database(remote_path)
-      db_remote = SQLite3::Database.new(remote_path)
-      raise 'Failed to initialize remote database' unless db_remote
-
-      db_remote
-    end
-
-    # Handles errors that occur during database synchronization
-    #
-    # @param error [SQLite3::Exception] The error that occurred during sync
-    # @param remote_storage [S3Supabase] The remote storage client for cloud operations
-    # @param bucket [String] The S3 bucket name
-    # @param local_db_path [String] Path to the local database file
-    # @return [void]
-    # @note When sync fails, this method falls back to uploading the local database
-    def self.handle_sync_error(error, remote_storage, bucket, local_db_path)
-      puts "Error opening remote database: #{error.message}"
-      puts 'Uploading local database to replace corrupted remote database'
-      remote_storage.upload_file(bucket, local_db_path, 'timet.db')
-    end
-
-    # Converts database items to a hash indexed by ID
-    #
-    # @param items [Array<Hash>] Array of database items
-    # @return [Hash] Items indexed by ID
-    def self.items_to_hash(items)
-      items.to_h { |item| [item['id'], item] }
-    end
-
-    # Determines if remote item should take precedence
-    #
-    # @param remote_item [Hash] Remote database item
-    # @param remote_time [Integer] Remote item timestamp
-    # @param local_time [Integer] Local item timestamp
-    # @return [Boolean] true if remote item should take precedence
-    def self.remote_wins?(remote_item, remote_time, local_time)
-      remote_time > local_time && (remote_item['deleted'].to_i == 1 || remote_time > local_time)
-    end
-
-    # Formats item status message
-    #
-    # @param id [Integer] Item ID
-    # @param item [Hash] Database item
-    # @param source [String] Source of the item ('Remote' or 'Local')
-    # @return [String] Formatted status message
-    def self.format_status_message(id, item, source)
-      deleted = item['deleted'].to_i == 1 ? ' and deleted' : ''
-      "#{source} item #{id} is newer#{deleted} - #{source == 'Remote' ? 'updating local' : 'will be uploaded'}"
-    end
-
-    # Processes an item that exists in both databases
-    #
-    # @param id [Integer] Item ID
-    # @param local_item [Hash] Local database item
-    # @param remote_item [Hash] Remote database item
-    # @param local_db [SQLite3::Database] Local database connection
-    # @return [Symbol] :local_update if local was updated, :remote_update if remote needs update
-    def self.process_existing_item(*args)
-      id, local_item, remote_item, local_db = args
-      local_time = local_item['updated_at'].to_i
-      remote_time = remote_item['updated_at'].to_i
-
-      if remote_wins?(remote_item, remote_time, local_time)
-        puts format_status_message(id, remote_item, 'Remote')
-        update_item_from_hash(local_db, remote_item)
-        :local_update
-      elsif local_time > remote_time
-        puts format_status_message(id, local_item, 'Local')
-        :remote_update
-      end
-    end
-
-    # Processes items from both databases and syncs them
-    #
-    # @param local_db [SQLite3::Database] The local database connection
-    # @param remote_db [SQLite3::Database] The remote database connection
-    # @return [void]
-    def self.process_database_items(local_db, remote_db)
-      remote_items = remote_db.execute('SELECT * FROM items ORDER BY updated_at DESC')
-      local_items = local_db.execute_sql('SELECT * FROM items ORDER BY updated_at DESC')
-
-      sync_items_by_id(
-        local_db,
-        items_to_hash(local_items),
-        items_to_hash(remote_items)
-      )
-    end
-
-    # Syncs items between local and remote databases based on their IDs
-    #
-    # @param local_db [SQLite3::Database] The local database connection
-    # @param local_items_by_id [Hash] Local items indexed by ID
-    # @param remote_items_by_id [Hash] Remote items indexed by ID
-    # @return [void]
-    def self.sync_items_by_id(local_db, local_items_by_id, remote_items_by_id)
-      all_item_ids = (remote_items_by_id.keys + local_items_by_id.keys).uniq
-
-      all_item_ids.each do |id|
-        if !remote_items_by_id[id]
-          puts "Local item #{id} will be uploaded"
-        elsif !local_items_by_id[id]
-          puts "Adding remote item #{id} to local"
-          insert_item_from_hash(local_db, remote_items_by_id[id])
-        else
-          process_existing_item(id, local_items_by_id[id], remote_items_by_id[id], local_db)
-        end
-      end
-    end
-
-    # Synchronizes the local and remote databases by comparing and merging their items
-    #
-    # @param local_db [SQLite3::Database] The local database connection
-    # @param remote_db [SQLite3::Database] The remote database connection
-    # @param remote_storage [S3Supabase] The remote storage client for cloud operations
-    # @param bucket [String] The S3 bucket name
-    # @param local_db_path [String] Path to the local database file
-    # @return [void]
-    # @note This method orchestrates the entire database synchronization process
-    def self.sync_databases(*args)
-      local_db, remote_db, remote_storage, bucket, local_db_path = args
-      process_database_items(local_db, remote_db)
-      remote_storage.upload_file(bucket, local_db_path, 'timet.db')
-      puts 'Database sync completed'
-    end
-
-    # Gets the values array for database operations
-    #
-    # @param item [Hash] Hash containing item data
-    # @param include_id [Boolean] Whether to include ID at start (insert) or end (update)
-    # @return [Array] Array of values for database operation
-    def self.get_item_values(item, include_id_at_start: false)
-      values = ITEM_FIELDS.map { |field| item[field] }
-      include_id_at_start ? [item['id'], *values] : [*values, item['id']]
-    end
-
-    # Updates an existing item in the database with values from a hash
-    #
-    # @param db [SQLite3::Database] The database connection
-    # @param item [Hash] Hash containing item data
-    # @return [void]
-    def self.update_item_from_hash(db, item)
-      fields = "#{ITEM_FIELDS.join(' = ?, ')} = ?"
-      db.execute_sql(
-        "UPDATE items SET #{fields} WHERE id = ?",
-        get_item_values(item)
-      )
-    end
-
-    # Inserts a new item into the database from a hash
-    #
-    # @param db [SQLite3::Database] The database connection
-    # @param item [Hash] Hash containing item data
-    # @return [void]
-    def self.insert_item_from_hash(db, item)
-      fields = ['id', *ITEM_FIELDS].join(', ')
-      placeholders = Array.new(ITEM_FIELDS.length + 1, '?').join(', ')
-      db.execute_sql(
-        "INSERT INTO items (#{fields}) VALUES (#{placeholders})",
-        get_item_values(item, include_id_at_start: true)
-      )
-    end
   end
 end

data/lib/timet/database_syncer.rb

@@ -0,0 +1,214 @@
+# frozen_string_literal: true
+
+module Timet
+  # Module responsible for synchronizing local and remote databases
+  module DatabaseSyncer
+    # Fields used in item operations
+    ITEM_FIELDS = %w[start end tag notes pomodoro updated_at created_at deleted].freeze
+
+    # Handles the synchronization process when differences are detected between databases
+    #
+    # @param local_db [SQLite3::Database] The local database connection
+    # @param remote_storage [S3Supabase] The remote storage client for cloud operations
+    # @param bucket [String] The S3 bucket name
+    # @param local_db_path [String] Path to the local database file
+    # @param remote_path [String] Path to the downloaded remote database file
+    # @return [void]
+    # @note This method attempts to sync the databases and handles any errors that occur during the process
+    def handle_database_differences(*args)
+      local_db, remote_storage, bucket, local_db_path, remote_path = args
+      puts 'Differences detected between local and remote databases'
+      begin
+        sync_with_remote_database(local_db, remote_path, remote_storage, bucket, local_db_path)
+      rescue SQLite3::Exception => e
+        handle_sync_error(e, remote_storage, bucket, local_db_path)
+      end
+    end
+
+    # Handles errors that occur during database synchronization
+    #
+    # @param error [SQLite3::Exception] The error that occurred during sync
+    # @param remote_storage [S3Supabase] The remote storage client for cloud operations
+    # @param bucket [String] The S3 bucket name
+    # @param local_db_path [String] Path to the local database file
+    # @return [void]
+    # @note When sync fails, this method falls back to uploading the local database
+    def handle_sync_error(error, remote_storage, bucket, local_db_path)
+      puts "Error opening remote database: #{error.message}"
+      puts 'Uploading local database to replace corrupted remote database'
+      remote_storage.upload_file(bucket, local_db_path, 'timet.db')
+    end
+
+    # Performs the actual database synchronization by setting up connections and syncing data
+    #
+    # @param local_db [SQLite3::Database] The local database connection
+    # @param remote_path [String] Path to the remote database file
+    # @param remote_storage [S3Supabase] The remote storage client for cloud operations
+    # @param bucket [String] The S3 bucket name
+    # @param local_db_path [String] Path to the local database file
+    # @return [void]
+    # @note Configures both databases to return results as hashes for consistent data handling
+    def sync_with_remote_database(*args)
+      local_db, remote_path, remote_storage, bucket, local_db_path = args
+      db_remote = open_remote_database(remote_path)
+      db_remote.results_as_hash = true
+      local_db.instance_variable_get(:@db).results_as_hash = true
+      sync_databases(local_db, db_remote, remote_storage, bucket, local_db_path)
+    end
+
+    # Opens and validates a connection to the remote database
+    #
+    # @param remote_path [String] Path to the remote database file
+    # @return [SQLite3::Database] The initialized database connection
+    # @raise [RuntimeError] If the database connection cannot be established
+    # @note Validates that the database connection is properly initialized
+    def open_remote_database(remote_path)
+      db_remote = SQLite3::Database.new(remote_path)
+      raise 'Failed to initialize remote database' unless db_remote
+
+      db_remote
+    end
+
+    # Synchronizes the local and remote databases by comparing and merging their items
+    #
+    # @param local_db [SQLite3::Database] The local database connection
+    # @param remote_db [SQLite3::Database] The remote database connection
+    # @param remote_storage [S3Supabase] The remote storage client for cloud operations
+    # @param bucket [String] The S3 bucket name
+    # @param local_db_path [String] Path to the local database file
+    # @return [void]
+    # @note This method orchestrates the entire database synchronization process
+    def sync_databases(*args)
+      local_db, remote_db, remote_storage, bucket, local_db_path = args
+      process_database_items(local_db, remote_db)
+      remote_storage.upload_file(bucket, local_db_path, 'timet.db')
+      puts 'Database sync completed'
+    end
+
+    # Processes items from both databases and syncs them
+    #
+    # @param local_db [SQLite3::Database] The local database connection
+    # @param remote_db [SQLite3::Database] The remote database connection
+    # @return [void]
+    def process_database_items(local_db, remote_db)
+      remote_items = remote_db.execute('SELECT * FROM items ORDER BY updated_at DESC')
+      local_items = local_db.execute_sql('SELECT * FROM items ORDER BY updated_at DESC')
+
+      sync_items_by_id(
+        local_db,
+        items_to_hash(local_items),
+        items_to_hash(remote_items)
+      )
+    end
+
+    # Syncs items between local and remote databases based on their IDs
+    #
+    # @param local_db [SQLite3::Database] The local database connection
+    # @param local_items_by_id [Hash] Local items indexed by ID
+    # @param remote_items_by_id [Hash] Remote items indexed by ID
+    # @return [void]
+    def sync_items_by_id(local_db, local_items_by_id, remote_items_by_id)
+      all_item_ids = (remote_items_by_id.keys + local_items_by_id.keys).uniq
+
+      all_item_ids.each do |id|
+        if !remote_items_by_id[id]
+          puts "Local item #{id} will be uploaded"
+        elsif !local_items_by_id[id]
+          puts "Adding remote item #{id} to local"
+          insert_item_from_hash(local_db, remote_items_by_id[id])
+        else
+          process_existing_item(id, local_items_by_id[id], remote_items_by_id[id], local_db)
+        end
+      end
+    end
+
+    # Inserts a new item into the database from a hash
+    #
+    # @param db [SQLite3::Database] The database connection
+    # @param item [Hash] Hash containing item data
+    # @return [void]
+    def insert_item_from_hash(db, item)
+      fields = ['id', *ITEM_FIELDS].join(', ')
+      placeholders = Array.new(ITEM_FIELDS.length + 1, '?').join(', ')
+      db.execute_sql(
+        "INSERT INTO items (#{fields}) VALUES (#{placeholders})",
+        get_item_values(item, include_id_at_start: true)
+      )
+    end
+
+    # Processes an item that exists in both databases
+    #
+    # @param id [Integer] Item ID
+    # @param local_item [Hash] Local database item
+    # @param remote_item [Hash] Remote database item
+    # @param local_db [SQLite3::Database] Local database connection
+    # @return [Symbol] :local_update if local was updated, :remote_update if remote needs update
+    def process_existing_item(*args)
+      id, local_item, remote_item, local_db = args
+      local_time = local_item['updated_at'].to_i
+      remote_time = remote_item['updated_at'].to_i
+
+      if remote_wins?(remote_item, remote_time, local_time)
+        puts format_status_message(id, remote_item, 'Remote')
+        update_item_from_hash(local_db, remote_item)
+        :local_update
+      elsif local_time > remote_time
+        puts format_status_message(id, local_item, 'Local')
+        :remote_update
+      end
+    end
+
+    # Converts database items to a hash indexed by ID
+    #
+    # @param items [Array<Hash>] Array of database items
+    # @return [Hash] Items indexed by ID
+    def items_to_hash(items)
+      items.to_h { |item| [item['id'], item] }
+    end
+
+    # Determines if remote item should take precedence
+    #
+    # @param remote_item [Hash] Remote database item
+    # @param remote_time [Integer] Remote item timestamp
+    # @param local_time [Integer] Local item timestamp
+    # @return [Boolean] true if remote item should take precedence
+    def remote_wins?(remote_item, remote_time, local_time)
+      remote_time > local_time && (remote_item['deleted'].to_i == 1 || remote_time > local_time)
+    end
+
+    # Formats item status message
+    #
+    # @param id [Integer] Item ID
+    # @param item [Hash] Database item
+    # @param source [String] Source of the item ('Remote' or 'Local')
+    # @return [String] Formatted status message
+    def format_status_message(id, item, source)
+      deleted = item['deleted'].to_i == 1 ? ' and deleted' : ''
+      "#{source} item #{id} is newer#{deleted} - #{source == 'Remote' ? 'updating local' : 'will be uploaded'}"
+    end
+
+    # Updates an existing item in the database with values from a hash
+    #
+    # @param db [SQLite3::Database] The database connection
+    # @param item [Hash] Hash containing item data
+    # @return [void]
+    def update_item_from_hash(db, item)
+      fields = "#{ITEM_FIELDS.join(' = ?, ')} = ?"
+      db.execute_sql(
+        "UPDATE items SET #{fields} WHERE id = ?",
+        get_item_values(item)
+      )
+    end
+
+    # Gets the values array for database operations
+    #
+    # @param item [Hash] Hash containing item data
+    # @param include_id [Boolean] Whether to include ID at start (insert) or end (update)
+    # @return [Array] Array of values for database operation
+    def get_item_values(item, include_id_at_start: false)
+      @database_fields ||= ITEM_FIELDS
+      values = @database_fields.map { |field| item[field] }
+      include_id_at_start ? [item['id'], *values] : values
+    end
+  end
+end

data/lib/timet/s3_supabase.rb

@@ -179,6 +179,7 @@ module Timet
       @logger.info "Object '#{object_key}' deleted successfully."
     rescue Aws::S3::Errors::ServiceError => e
       @logger.error "Error deleting object: #{e.message}"
+      raise e
     end
 
     # Deletes a bucket and all its contents.
@@ -197,6 +198,7 @@ module Timet
       @logger.info "Bucket '#{bucket_name}' deleted successfully."
     rescue Aws::S3::Errors::ServiceError => e
       @logger.error "Error deleting bucket: #{e.message}"
+      raise e
     end
 
     private
@@ -207,14 +209,19 @@ module Timet
     # @return [void]
     def validate_env_vars
       missing_vars = []
-      missing_vars << 'S3_ENDPOINT' if S3_ENDPOINT.empty?
-      missing_vars << 'S3_ACCESS_KEY' if S3_ACCESS_KEY.empty?
-      missing_vars << 'S3_SECRET_KEY' if S3_SECRET_KEY.empty?
+      missing_vars.concat(check_env_var('S3_ENDPOINT', S3_ENDPOINT))
+      missing_vars.concat(check_env_var('S3_ACCESS_KEY', S3_ACCESS_KEY))
+      missing_vars.concat(check_env_var('S3_SECRET_KEY', S3_SECRET_KEY))
 
       return if missing_vars.empty?
 
-      error_message = "Missing required environment variables (.env): #{missing_vars.join(', ')}"
-      raise CustomError, error_message
+      raise CustomError, "Missing required environment variables (.env): #{missing_vars.join(', ')}"
+    end
+
+    def check_env_var(name, value)
+      return [] if value && !value.empty?
+
+      [name]
     end
 
     # Custom error class that suppresses the backtrace for cleaner error messages.

data/lib/timet/table.rb

@@ -1,9 +1,21 @@
 # frozen_string_literal: true
 
+# require_relative 'color_codes'
+require 'timet/time_report_helper'
 module Timet
-  # This module is responsible for formatting the output of the `timet` application.
+  # This class is responsible for formatting the output of the `timet` application.
   # It provides methods for formatting the table header, separators, and rows.
-  module Table
+  class Table
+    include TimeReportHelper
+
+    attr_reader :filter, :items
+
+    def initialize(filter, items, db)
+      @filter = filter
+      @items = items
+      @db = db
+    end
+
     # Generates and displays a table summarizing time entries, including headers, time blocks, and total durations.
     #
     # @example
@@ -64,22 +76,26 @@ module Timet
 
     # Processes time entries and generates a time block structure.
     #
-    # @return [Hash] A nested hash representing the time block structure.
+    # This method iterates over each item in the `items` array, displays the time entry (if enabled),
+    # and processes the time block item to build a nested hash representing the time block structure.
+    #
+    # @param display [Boolean] Whether to display the time entry during processing. Defaults to `true`.
+    # @return [Hash] A nested hash representing the time block structure, where keys are dates and values
+    #                are processed time block items.
     #
     # @note
-    #   - The method iterates over each item in the `items` array.
-    #   - For each item, it calls `display_time_entry` to display the time entry.
-    #   - It then processes the time block item using `process_time_block_item`.
+    #   - The method uses `display_time_entry` to display the time entry if `display` is `true`.
+    #   - It processes each time block item using `process_time_block_item`.
     #   - The `TimeHelper.extract_date` method is used to extract the date from the items.
     #
     # @see #display_time_entry
     # @see #process_time_block_item
     # @see TimeHelper#extract_date
-    def process_time_entries
+    def process_time_entries(display: true)
       time_block = Hash.new { |hash, key| hash[key] = {} }
 
-      items.each_with_index do |item, idx|
-        display_time_entry(item, TimeHelper.extract_date(items, idx))
+      @items.each_with_index do |item, idx|
+        display_time_entry(item, TimeHelper.extract_date(@items, idx)) if display
         time_block = process_time_block_item(item, time_block)
       end
 

data/lib/timet/time_block_chart.rb

@@ -12,8 +12,8 @@ module Timet
   #     "2023-10-02" => { "10" => [4500, "work"] }
   #   }
   #   colors = { "work" => 31, "break" => 32 }
-  #   chart = TimeBlockChart.new(time_block)
-  #   chart.print_time_block_chart(time_block, colors)
+  #   chart = TimeBlockChart.new(table)
+  #   chart.print_time_block_chart(table, colors)
   #
   # @attr_reader [Integer] start_hour The starting hour of the time block
   # @attr_reader [Integer] end_hour The ending hour of the time block
@@ -34,22 +34,49 @@ module Timet
     # Separator character for the chart
     SEPARATOR_CHAR = '░'
 
-    # Initializes a new TimeBlockChart
+    # Initializes a new TimeBlockChart instance.
     #
-    # @param [Hash] time_block The time block data
-    def initialize(time_block)
-      @start_hour = time_block.values.map(&:keys).flatten.uniq.min.to_i
-      @end_hour = time_block.values.map(&:keys).flatten.uniq.max.to_i
+    # This method sets up the time block chart by processing the time entries from the provided table
+    # and determining the start and end hours for the chart based on the time block data.
+    #
+    # @param table [Table] The table instance containing the time entries to be processed.
+    # @return [void] This method does not return a value; it initializes the instance variables.
+    #
+    # @note
+    #   - The `@time_block` instance variable is populated by processing the time entries from the table.
+    #   - The `@start_hour` and `@end_hour` instance variables are calculated based on the earliest and latest
+    #     hours present in the time block data.
+    #
+    # @see Table#process_time_entries
+    def initialize(table)
+      @time_block = table.process_time_entries(display: false)
+      @start_hour = @time_block.values.map(&:keys).flatten.uniq.min.to_i
+      @end_hour = @time_block.values.map(&:keys).flatten.uniq.max.to_i
     end
 
-    # Prints the time block chart
+    # Prints the time block chart.
     #
-    # @param [Hash] time_block The time block data
-    # @param [Hash] colors The color mapping for different tags
-    # @return [void]
-    def print_time_block_chart(time_block, colors)
+    # This method formats and prints the time block chart, including the header and the time blocks
+    # for each entry. The chart is color-coded based on the provided color mapping for different tags.
+    #
+    # @param table [Hash] The time block data to be displayed in the chart.
+    # @param colors [Hash] A mapping of tags to colors, used to color-code the time blocks.
+    # @return [void] This method does not return a value; it performs side effects such as printing the chart.
+    #
+    # @example Print a time block chart
+    #   chart = TimeBlockChart.new(table)
+    #   chart.print_time_block_chart(table, colors)
+    #
+    # @note
+    #   - The method first prints the header of the chart, which includes the time range.
+    #   - It then prints the time blocks, using the provided color mapping to visually distinguish
+    #     between different tags.
+    #
+    # @see #print_header
+    # @see #print_blocks
+    def print_time_block_chart(table, colors)
       print_header
-      print_blocks(time_block, colors)
+      print_blocks(table, colors)
     end
 
     private
@@ -65,22 +92,44 @@ module Timet
       puts '┌╴W ╴╴╴╴╴╴⏰╴╴╴╴╴╴┼'.gray + "#{'╴' * (@end_hour - @start_hour + 1) * 4}╴╴╴┼".gray
     end
 
-    # Prints the time blocks
+    # Prints the time blocks for each date in the time block data.
     #
-    # @param [Hash] time_block The time block data
-    # @param [Hash] colors The color mapping for different tags
-    # @return [void]
-    def print_blocks(time_block, colors)
-      return unless time_block
+    # This method iterates over the time block data, formats and prints the date information,
+    # prints the time blocks for each date using the provided color mapping, and calculates
+    # and prints the total hours for each day. It also prints a footer at the end.
+    #
+    # @param table [Hash] The time block data containing the time entries for each date.
+    # @param colors [Hash] A mapping of tags to colors, used to color-code the time blocks.
+    # @return [void] This method does not return a value; it performs side effects such as printing
+    #   the time blocks and related information.
+    #
+    # @example Print time blocks
+    #   chart = TimeBlockChart.new(table)
+    #   chart.print_blocks(table, colors)
+    #
+    # @note
+    #   - The method skips processing if the `table` parameter is `nil`.
+    #   - For each date in the time block data, it formats and prints the date and day of the week.
+    #   - It prints the time blocks using the provided color mapping to visually distinguish
+    #     between different tags.
+    #   - It calculates and prints the total hours for each day.
+    #   - A footer is printed at the end to provide a visual separation.
+    #
+    # @see #format_and_print_date_info
+    # @see #print_time_blocks
+    # @see #calculate_and_print_hours
+    # @see #print_footer
+    def print_blocks(table, colors)
+      return unless table
 
       weeks = []
-      time_block.each_key do |date_string|
+      @time_block.each_key do |date_string|
         date = Date.parse(date_string)
         day = date.strftime('%a')[0..2]
 
         format_and_print_date_info(date_string, day, weeks)
 
-        time_block_initial = time_block[date_string]
+        time_block_initial = @time_block[date_string]
         print_time_blocks(time_block_initial, colors)
 
         calculate_and_print_hours(time_block_initial)

data/lib/timet/time_report.rb

@@ -14,7 +14,6 @@ module Timet
   # a formatted table with the relevant information.
   class TimeReport
     include TimeReportHelper
-    include Table
     include TagDistribution
 
     # Provides access to the database instance.
@@ -32,37 +31,55 @@ module Timet
     # Initializes a new instance of the TimeReport class.
     #
     # @param db [Database] The database instance to use for fetching data.
-    # @param options [Hash] A hash containing optional parameters.
-    # @option options [String, nil] :filter The filter to apply when fetching items. Possible values include 'today',
-    #   'yesterday', 'week', 'month', or a date range in the format 'YYYY-MM-DD..YYYY-MM-DD'.
-    # @option options [String, nil] :tag The tag to filter the items by.
-    # @option options [String, nil] :csv The filename to use when exporting the report to CSV.
-    # @option options [String, nil] :ics The filename to use when exporting the report to iCalendar.
-    #
-    # @return [void] This method does not return a value; it performs side effects such as initializing the
-    # instance variables.
+    # @param options [Hash] A hash containing optional parameters for configuring the report.
+    # @option options [String, nil] :filter The filter to apply when fetching items. Possible values include:
+    #   - 'today': Filters items for the current day.
+    #   - 'yesterday': Filters items for the previous day.
+    #   - 'week': Filters items for the current week.
+    #   - 'month': Filters items for the current month.
+    #   - A date range in the format 'YYYY-MM-DD..YYYY-MM-DD': Filters items within the specified date range.
+    # @option options [String, nil] :tag The tag to filter the items by. Only items with this tag will be included.
+    # @option options [String, nil] :csv The filename to use when exporting the report to CSV. If provided, the report
+    #   will be exported to the specified file.
+    # @option options [String, nil] :ics The filename to use when exporting the report to iCalendar format. If provided,
+    #   the report will be exported to the specified file.
+    #
+    # @return [void] This method does not return a value; it initializes the instance variables and prepares the report.
     #
     # @example Initialize a new TimeReport instance with a filter and tag
     #   TimeReport.new(db, filter: 'today', tag: 'work', csv: 'report.csv', ics: 'icalendar.ics')
+    #
+    # @example Initialize a new TimeReport instance with a date range filter
+    #   TimeReport.new(db, filter: '2023-10-01..2023-10-31', tag: 'project')
+    #
+    # @note
+    #   - If no filter is provided, all items from the database will be fetched.
+    #   - The `@table` instance variable is initialized with the filtered items and filter configuration.
     def initialize(db, options = {})
       @db = db
       @csv_filename = options[:csv]
       @ics_filename = options[:ics]
       @filter = formatted_filter(options[:filter])
       @items = options[:filter] ? filter_items(@filter, options[:tag]) : @db.all_items
+      @table = Table.new(@filter, @items, @db)
     end
 
     # Displays the report of tracked time entries.
     #
+    # This method formats and prints the report, including the table header, rows, total duration,
+    # a time block chart, and tag distribution. If no tracked time entries are found for the specified filter,
+    # it displays a message indicating no data is available.
+    #
     # @return [void] This method does not return a value; it performs side effects such as printing the report.
     #
     # @example Display the report
     #   time_report.display
     #
-    # @note The method formats and prints the table header, rows, and total duration.
-    #
-    # @param items [Array<Hash>] The list of time entries to be displayed.
-    # @param options [Hash] Additional options for customizing the display (e.g., color scheme).
+    # @note
+    #   - The method checks if there are any tracked time entries. If not, it prints a message and exits.
+    #   - It uses the `@table` instance to format and display the table.
+    #   - A time block chart is generated and printed using the `TimeBlockChart` class.
+    #   - The tag distribution is calculated and displayed based on the unique colors assigned to tags.
     #
     # @see #table
     # @see #print_time_block_chart
@@ -70,30 +87,38 @@ module Timet
     def display
       return puts 'No tracked time found for the specified filter.' if @items.empty?
 
-      time_block = table
-
+      @table.table
       colors = @items.map { |x| x[3] }.uniq.each_with_index.to_h
-      chart = TimeBlockChart.new(time_block)
-      chart.print_time_block_chart(time_block, colors)
-
+      chart = TimeBlockChart.new(@table)
+      chart.print_time_block_chart(@table, colors)
       tag_distribution(colors)
     end
 
     # Displays a single row of the report.
     #
-    # @param item [Array] The item to display.
+    # This method formats and prints a single row of the report, including the table header, the specified row,
+    # a separator, and the total duration. It is used to display individual time entries in a structured format.
+    #
+    # @param item [Array] The item (time entry) to display. The item is expected to contain the necessary data
+    #   for the row, such as the time, description, and duration.
     #
     # @return [void] This method does not return a value; it performs side effects such as printing the row.
     #
     # @example Display a single row
     #   time_report.show_row(item)
     #
-    # @note The method formats and prints the table header, row, and total duration.
+    # @note
+    #   - The method uses the `@table` instance to format and display the table header and row.
+    #   - A separator is printed after the row to visually distinguish it from other rows.
+    #   - The total duration is displayed at the end of the row.
+    #
+    # @see #table
+    # @see #display_time_entry
     def show_row(item)
-      header
-      display_time_entry(item)
-      puts separator
-      total
+      @table.header
+      @table.display_time_entry(item)
+      puts @table.separator
+      @table.total
     end
 
     private

data/lib/timet/validation_edit_helper.rb

@@ -83,18 +83,18 @@ module Timet
     #
     # @param item [Array] The tracking item to be updated.
     # @param field [String] The time field to be updated.
-    # @param formatted_value [String] The formatted date value.
+    # @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', '2023-10-01 12:00:00')
-    def update_time_field(item, field, formatted_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]
-      current_time = Time.at(timestamp || TimeHelper.current_timestamp).to_s.split
-      current_time[1] = formatted_value
-      DateTime.strptime(current_time.join(' '), '%Y-%m-%d %H:%M:%S %z').to_time
+      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).

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.3'
-  VERSION = '1.5.3'
+  #   Timet::VERSION # => '1.5.5'
+  VERSION = '1.5.5'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: timet
 version: !ruby/object:Gem::Version
-  version: 1.5.3
+  version: 1.5.5
 platform: ruby
 authors:
 - Frank Vielma
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-01-02 00:00:00.000000000 Z
+date: 2025-02-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: thor
@@ -106,14 +106,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.171'
+        version: '1.178'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.171'
+        version: '1.178'
 description: Timet is a command-line time tracker that keeps track of your activities.
 email:
 - frankvielma@gmail.com
@@ -139,6 +139,7 @@ files:
 - lib/timet/color_codes.rb
 - lib/timet/database.rb
 - lib/timet/database_sync_helper.rb
+- lib/timet/database_syncer.rb
 - lib/timet/s3_supabase.rb
 - lib/timet/table.rb
 - lib/timet/tag_distribution.rb