timet 1.5.2 → 1.5.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f538523396dc470f91334a3abe44915e63dec009a60901a1ae4ef7b432a9a37f
-  data.tar.gz: 262da1d62b413102d4ff33932fa7fb05c10c4b13abcb832d6382683d2d314d8d
+  metadata.gz: 9d3673e96ff9410f3b77d1ecdd59b74cbfe794bd50b9f6fad75701200c911742
+  data.tar.gz: d405e584648c18a4119b7f4c242923b74e28e433779ad3929ff22da3e569bba1
 SHA512:
-  metadata.gz: 4d1d90414bda675c2f09827ec99c63b4e86e04f826e969d07af15a757e29b1cb868d412d17b7995012b1091173cd50e2093009600bb55888b06ffd1c1a4397e0
-  data.tar.gz: cad0f0569224af29941301173dcfa1045c4419db21265b5cdb2d64e5e14f9eeca52d5ada931be7fed1757305ba55bb05823111d974a40c2e57ca0a25c4f8cff7
+  metadata.gz: 63267d2db22ceabb15c2ca4e8114a25854bf71446799992de552ce91f6ff7d8487fb7204f1ea76df8be77dcfa71ac89d21f26084c87fb17831469406920f1862
+  data.tar.gz: 2f7d784e8f9b3385d37c90a04fce2b4ea869c5fb3b1e62be613e835b898a2b6f4f8742dbb38785295e695309c7b6b6f6b3fe804a8e5afb7f03655510612ce05d

data/.rubocop.yml

@@ -9,3 +9,9 @@ Metrics/MethodLength:
   Max: 12
 
 require: rubocop-rspec
+
+RSpec/ExampleLength:
+  Max: 10 
+
+Metrics/CyclomaticComplexity:
+  Max: 8

data/CHANGELOG.md

@@ -1,5 +1,42 @@
 ## [Unreleased]
 
+## [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
+
+**Improvements:**
+
+- Upgraded dependencies in `Gemfile` and `Gemfile.lock` to their latest compatible versions, including `aws-sdk-s3`, `csv`, `sqlite3`, and others.
+- Refactored `TimeBlockChart` from a module to a class, encapsulating `start_hour` and `end_hour` as instance variables for better state management.
+- Added a `print_footer` method to `tag_distribution.rb` to provide clear explanations for summary metrics (total duration, average duration, and standard deviation).
+- Improved documentation for the `TimeBlockChart` class, including example usage and `attr_reader` for `start_hour` and `end_hour`.
+- Simplified method signatures in `TimeBlockChart` by removing redundant parameters and leveraging instance variables.
+
+**Bug Fixes:**
+
+- Fixed an issue in `tag_distribution.rb` where the calculation of `percentage_value` was redundant and simplified the logic.
+- Corrected the display of the day abbreviation in `TimeBlockChart` to include the full three-letter abbreviation (e.g., "Mon" instead of "Mo").
+- Removed unused code in `time_statistics.rb` that was not contributing to the `totals` method.
+
 ## [1.5.2] - 2024-12-12
 
 **Improvements:**

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.