timet 1.6.1.1 → 1.6.3

data/lib/timet/database_syncer.rb

@@ -3,51 +3,41 @@
 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)
+        handle_sync_error(e, remote_storage: remote_storage, bucket: bucket, local_db_path: 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)
+    def handle_sync_error(error, *args)
+      first_arg = args.first
+      if first_arg.is_a?(Hash)
+        options = first_arg
+        remote_storage, bucket, local_db_path = options.values_at(:remote_storage, :bucket, :local_db_path)
+      else
+        remote_storage, bucket, local_db_path = args
+      end
+      report_sync_error(error)
+      upload_local_database(remote_storage, bucket, local_db_path)
+    end
+
+    def report_sync_error(error)
       puts "Error opening remote database: #{error.message}"
       puts 'Uploading local database to replace corrupted remote database'
+    end
+    module_function :report_sync_error
+
+    def upload_local_database(remote_storage, bucket, local_db_path)
       remote_storage.upload_file(bucket, local_db_path, 'timet.db')
     end
+    module_function :upload_local_database
 
-    # 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)
@@ -56,12 +46,6 @@ module Timet
       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
@@ -69,15 +53,6 @@ module Timet
       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)
@@ -85,130 +60,117 @@ module Timet
       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)
-      )
+      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 { |id| sync_single_item(local_db, id, local_items_by_id, remote_items_by_id) }
+    end
 
-      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
+    def sync_single_item(*args)
+      local_db, id, local_items_by_id, remote_items_by_id = args
+      remote_item = remote_items_by_id[id]
+      local_item = local_items_by_id[id]
+
+      if !remote_item
+        log_local_only(id)
+      elsif !local_item
+        add_remote_item(local_db, id, remote_item)
+      else
+        merge_item(local_db, id, local_item, remote_item)
       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 log_local_only(id)
+      puts "Local item #{id} will be uploaded"
+    end
+    module_function :log_local_only
+
+    def add_remote_item(local_db, id, remote_item)
+      puts "Adding remote item #{id} to local"
+      insert_item_from_hash(local_db, remote_item)
+    end
+
+    def process_existing_item(id, local_item, remote_item, local_db)
+      merge_item(local_db, id, local_item, remote_item)
+    end
+
+    def merge_item(*args)
+      local_db, id, local_item, remote_item = args
+      local_time = extract_timestamp(local_item)
+      remote_time = extract_timestamp(remote_item)
+
+      return resolve_remote_wins(local_db, id, remote_item) if remote_wins?(remote_item, remote_time, local_time)
+
+      log_local_wins(id, local_item)
+    end
+
+    def resolve_remote_wins(local_db, id, remote_item)
+      puts format_status_message(id, remote_item, 'Remote')
+      update_item_from_hash(local_db, remote_item)
+      :local_update
+    end
+
+    def log_local_wins(id, local_item)
+      puts format_status_message(id, local_item, 'Local')
+      :remote_update
+    end
+
     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)
+        get_insert_values(item)
       )
     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
+    def update_item_from_hash(db, item)
+      fields = "#{ITEM_FIELDS.join(' = ?, ')} = ?"
+      db.execute_sql(
+        "UPDATE items SET #{fields} WHERE id = ?",
+        get_update_values(item)
+      )
+    end
+
+    def extract_timestamp(item)
+      item['updated_at'].to_i
     end
+    module_function :extract_timestamp
 
-    # 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)
+      time_diff = remote_time > local_time
+      time_diff && (remote_item['deleted'].to_i == 1 || time_diff)
     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
+    module_function :format_status_message
 
-    # 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)
-      )
+    def get_insert_values(item)
+      @database_fields ||= ITEM_FIELDS
+      values = @database_fields.map { |field| item[field] }
+      [item['id'], *values]
     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)
+    def get_update_values(item)
       @database_fields ||= ITEM_FIELDS
-      values = @database_fields.map { |field| item[field] }
-      include_id_at_start ? [item['id'], *values] : values
+      @database_fields.map { |field| item[field] }
+    end
+
+    def get_item_values(item, include_id_at_start: false)
+      include_id_at_start ? get_insert_values(item) : get_update_values(item)
     end
   end
 end

data/lib/timet/discord_notifier.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'net/http'
 require 'uri'
 require 'json'
@@ -83,7 +85,7 @@ module Timet
     # @return [void]
     def self.pomodoro_ended(duration)
       break_duration = (duration / 5).to_i # Assuming a 1/5th break duration
-      break_duration = 5 if break_duration == 0 # Minimum 5 minute break
+      break_duration = 5 if break_duration.zero? # Minimum 5 minute break
       embed = {
         title: 'Pomodoro Session Ended! 🎉',
         description: "Time for a #{break_duration} minute break!",

data/lib/timet/s3_supabase.rb

@@ -5,60 +5,36 @@ require 'logger'
 require 'dotenv'
 require 'fileutils'
 
-# The module includes several components:
-# - S3 integration for data backup and sync
-#
+# Top-level module for the Timet time tracking gem.
 module Timet
-  # Required environment variables for S3 configuration
+  # Required environment variables for S3 configuration.
   REQUIRED_ENV_VARS = %w[S3_ENDPOINT S3_ACCESS_KEY S3_SECRET_KEY].freeze
 
-  # Ensures that the environment file exists and contains the required variables.
-  # If the file doesn't exist, it creates it. If required variables are missing,
-  # it adds them with empty values.
-  #
-  # @param env_file_path [String] The path to the environment file
-  # @return [void]
-  # @example
-  #   Timet.ensure_env_file_exists('/path/to/.env')
   def self.ensure_env_file_exists(env_file_path)
+    ensure_directory_exists(env_file_path)
+    ensure_file_exists(env_file_path)
+    append_missing_env_vars(env_file_path)
+  end
+
+  def self.ensure_directory_exists(env_file_path)
     dir_path = File.dirname(env_file_path)
     FileUtils.mkdir_p(dir_path)
+  end
 
-    # Create file if it doesn't exist or is empty
+  def self.ensure_file_exists(env_file_path)
     File.write(env_file_path, '', mode: 'a')
+  end
 
-    # Load and check environment variables
+  def self.append_missing_env_vars(env_file_path)
     Dotenv.load(env_file_path)
     missing_vars = REQUIRED_ENV_VARS.reject { |var| ENV.fetch(var, nil) }
-
-    # Append missing variables with empty values
     return if missing_vars.empty?
 
     File.write(env_file_path, "#{missing_vars.map { |var| "#{var}=''" }.join("\n")}\n", mode: 'a')
   end
 
-  # S3Supabase is a class that provides methods to interact with an S3-compatible
-  # storage service. It encapsulates common operations such as creating a bucket,
-  # listing objects, uploading and downloading files, deleting objects, and
-  # deleting a bucket.
-  #
-  # This class requires the following environment variables to be set:
-  # - S3_ENDPOINT: The endpoint URL for the S3-compatible storage service.
-  # - S3_ACCESS_KEY: The access key ID for authentication.
-  # - S3_SECRET_KEY: The secret access key for authentication.
-  # - S3_REGION: The region for the S3-compatible storage service (default: 'us-west-1').
-  #
-  # @example Basic usage
-  #   s3_supabase = S3Supabase.new
-  #   s3_supabase.create_bucket('my-bucket')
-  #   s3_supabase.upload_file('my-bucket', '/path/to/local/file.txt', 'file.txt')
-  #
-  # @example Advanced operations
-  #   s3_supabase.list_objects('my-bucket')
-  #   s3_supabase.download_file('my-bucket', 'file.txt', '/path/to/download/file.txt')
-  #   s3_supabase.delete_object('my-bucket', 'file.txt')
-  #   s3_supabase.delete_bucket('my-bucket')
-  class S3Supabase
+  # Configuration constants for S3 Supabase integration.
+  module S3Config
     ENV_FILE_PATH = File.join(Dir.home, '.timet', '.env')
     Timet.ensure_env_file_exists(ENV_FILE_PATH)
     Dotenv.load(ENV_FILE_PATH)
@@ -68,11 +44,15 @@ module Timet
     S3_SECRET_KEY = ENV.fetch('S3_SECRET_KEY', nil)
     S3_REGION = ENV.fetch('S3_REGION', 'us-west-1')
     LOG_FILE_PATH = File.join(Dir.home, '.timet', 's3_supabase.log')
+  end
+
+  # Struct to hold S3 object reference (bucket name and object key).
+  S3ObjectRef = Struct.new(:bucket_name, :object_key, keyword_init: true)
+
+  # S3Supabase provides methods to interact with an S3-compatible storage service.
+  class S3Supabase
+    include S3Config
 
-    # Initializes a new instance of the S3Supabase class.
-    # Sets up the AWS S3 client with the configured credentials and endpoint.
-    #
-    # @raise [CustomError] If required environment variables are missing
     def initialize
       validate_env_vars
       @logger = Logger.new(LOG_FILE_PATH)
@@ -86,127 +66,92 @@ module Timet
       )
     end
 
-    # Creates a new bucket in the S3-compatible storage service.
-    #
-    # @param bucket_name [String] The name of the bucket to create
-    # @return [Boolean] true if bucket was created successfully, false otherwise
-    # @example
-    #   create_bucket('my-new-bucket')
     def create_bucket(bucket_name)
-      begin
-        @s3_client.create_bucket(bucket: bucket_name)
-        @logger.info "Bucket '#{bucket_name}' created successfully!"
-        return true
-      rescue Aws::S3::Errors::BucketAlreadyExists
-        @logger.error "Error: The bucket '#{bucket_name}' already exists."
-      rescue Aws::S3::Errors::BucketAlreadyOwnedByYou
-        @logger.error "Error: The bucket '#{bucket_name}' is already owned by you."
-      rescue Aws::S3::Errors::ServiceError => e
-        @logger.error "Error creating bucket: #{e.message}"
-      end
+      @s3_client.create_bucket(bucket: bucket_name)
+      log(:info, "Bucket '#{bucket_name}' created successfully!")
+      true
+    rescue Aws::S3::Errors::BucketAlreadyExists
+      log(:error, "Error: The bucket '#{bucket_name}' already exists.")
+      false
+    rescue Aws::S3::Errors::BucketAlreadyOwnedByYou
+      log(:error, "Error: The bucket '#{bucket_name}' is already owned by you.")
+      false
+    rescue Aws::S3::Errors::ServiceError => e
+      log(:error, "Error creating bucket: #{e.message}")
       false
     end
 
-    # Lists all objects in the specified bucket.
-    #
-    # @param bucket_name [String] The name of the bucket to list objects from
-    # @return [Array<Hash>, false, nil] Array of object hashes if objects found, false if bucket is empty,
-    # nil if error occurs
-    # @raise [Aws::S3::Errors::ServiceError] if there's an error accessing the S3 service
-    # @example
-    #   list_objects('my-bucket') #=> [{key: 'example.txt', last_modified: '2023-01-01', ...}, ...]
-    #   list_objects('empty-bucket') #=> false
-    #   list_objects('invalid-bucket') #=> nil
     def list_objects(bucket_name)
       response = @s3_client.list_objects_v2(bucket: bucket_name)
-      if response.contents.empty?
-        @logger.info "No objects found in '#{bucket_name}'."
-        false
-      else
-        @logger.info "Objects in '#{bucket_name}':"
-        response.contents.each { |object| @logger.info "- #{object.key} (Last modified: #{object.last_modified})" }
-        response.contents.map(&:to_h)
+      contents = response.contents
+
+      if contents.empty?
+        log(:error, "No objects found in '#{bucket_name}'.")
+        return false
       end
+
+      log_object_list(contents, bucket_name)
+      contents.map(&:to_h)
     rescue Aws::S3::Errors::ServiceError => e
-      @logger.error "Error listing objects: #{e.message}"
+      log(:error, "Error listing objects: #{e.message}")
       nil
     end
 
-    # Uploads a file to the specified bucket.
-    #
-    # @param bucket_name [String] The name of the bucket to upload to
-    # @param file_path [String] The local path of the file to upload
-    # @param object_key [String] The key (name) to give the object in the bucket
-    # @return [void]
-    # @example
-    #   upload_file('my-bucket', '/path/to/local/file.txt', 'remote-file.txt')
     def upload_file(bucket_name, file_path, object_key)
-      @s3_client.put_object(
-        bucket: bucket_name,
-        key: object_key,
-        body: File.open(file_path, 'rb')
-      )
-      @logger.info "File '#{object_key}' uploaded successfully."
+      File.open(file_path, 'rb') do |file|
+        @s3_client.put_object(
+          bucket: bucket_name,
+          key: object_key,
+          body: file
+        )
+      end
+      log(:info, "File '#{object_key}' uploaded successfully.")
     rescue Aws::S3::Errors::ServiceError => e
-      @logger.error "Error uploading file: #{e.message}"
+      log(:error, "Error uploading file: #{e.message}")
     end
 
-    # Downloads a file from the specified bucket.
-    #
-    # @param bucket_name [String] The name of the bucket to download from
-    # @param object_key [String] The key of the object to download
-    # @param download_path [String] The local path where the file should be saved
-    # @return [void]
-    # @example
-    #   download_file('my-bucket', 'remote-file.txt', '/path/to/local/file.txt')
     def download_file(bucket_name, object_key, download_path)
       response = @s3_client.get_object(bucket: bucket_name, key: object_key)
       File.binwrite(download_path, response.body.read)
-      @logger.info "File '#{object_key}' downloaded successfully."
+      log(:info, "File '#{object_key}' downloaded successfully.")
     rescue Aws::S3::Errors::ServiceError => e
-      @logger.error "Error downloading file: #{e.message}"
+      log(:error, "Error downloading file: #{e.message}")
     end
 
-    # Deletes an object from the specified bucket.
-    #
-    # @param bucket_name [String] The name of the bucket containing the object
-    # @param object_key [String] The key of the object to delete
-    # @return [void]
-    # @example
-    #   delete_object('my-bucket', 'file-to-delete.txt')
     def delete_object(bucket_name, object_key)
       @s3_client.delete_object(bucket: bucket_name, key: object_key)
-      @logger.info "Object '#{object_key}' deleted successfully."
+      log(:info, "Object '#{object_key}' deleted successfully.")
     rescue Aws::S3::Errors::ServiceError => e
-      @logger.error "Error deleting object: #{e.message}"
+      log(:error, "Error deleting object: #{e.message}")
       raise e
     end
 
-    # Deletes a bucket and all its contents.
-    # First deletes all objects in the bucket, then deletes the bucket itself.
-    #
-    # @param bucket_name [String] The name of the bucket to delete
-    # @return [void]
-    # @example
-    #   delete_bucket('bucket-to-delete')
     def delete_bucket(bucket_name)
-      list_objects(bucket_name)
-      @s3_client.list_objects_v2(bucket: bucket_name).contents.each do |object|
-        delete_object(bucket_name, object.key)
-      end
+      delete_all_objects_in_bucket(bucket_name)
       @s3_client.delete_bucket(bucket: bucket_name)
-      @logger.info "Bucket '#{bucket_name}' deleted successfully."
+      log(:info, "Bucket '#{bucket_name}' deleted successfully.")
     rescue Aws::S3::Errors::ServiceError => e
-      @logger.error "Error deleting bucket: #{e.message}"
+      log(:error, "Error deleting bucket: #{e.message}")
       raise e
     end
 
     private
 
-    # Validates that all required environment variables are present and non-empty.
-    #
-    # @raise [CustomError] If any required environment variables are missing
-    # @return [void]
+    def log(level, message)
+      @logger.send(level, message)
+    end
+
+    def log_object_list(contents, bucket_name)
+      log(:error, "Objects in '#{bucket_name}':")
+      contents.each { |object| log(:error, "- #{object.key} (Last modified: #{object.last_modified})") }
+    end
+
+    def delete_all_objects_in_bucket(bucket_name)
+      list_objects(bucket_name)
+      contents = @s3_client.list_objects_v2(bucket: bucket_name).contents
+      contents.each { |object| delete_object(bucket_name, object.key) }
+    end
+
     def validate_env_vars
       missing_vars = []
       missing_vars.concat(check_env_var('S3_ENDPOINT', S3_ENDPOINT))
@@ -221,13 +166,11 @@ module Timet
     def check_env_var(name, value)
       return [] if value && !value.empty?
 
+      @s3_client&.list_objects_v2(bucket: 'dummy')
       [name]
     end
 
     # Custom error class that suppresses the backtrace for cleaner error messages.
-    #
-    # @example
-    #   raise CustomError, "Missing required environment variables"
     class CustomError < StandardError
       def backtrace
         nil

data/lib/timet/table.rb

@@ -1,14 +1,10 @@
 # frozen_string_literal: true
 
-# require_relative 'color_codes'
-require 'timet/time_report_helper'
 require_relative 'utils'
 module Timet
   # This class is responsible for formatting the output of the `timet` application.
   # It provides methods for formatting the table header, separators, and rows.
   class Table
-    include TimeReportHelper
-
     attr_reader :filter, :items
 
     def initialize(filter, items, db)