timet 1.6.2 → 1.6.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 60cf8b709509db9c6a6a5bd27ed60db0c3c08a22f44aeced1d758d0790f74e5a
-  data.tar.gz: 7dd85ae0a812e4102218c553256740f184313008b694d8478eced986392ecc90
+  metadata.gz: 84fa974afe30946a8b292569e74917c3992097e0ae652339320981f2951f298d
+  data.tar.gz: dc6cf2d3f5bd30feebb93db4aa07c436203e53bf1d9d0dbba5166695b622b021
 SHA512:
-  metadata.gz: cfa8731849d0ac4f4e1b7d3da1d676e3b93a2e3c730d332b33a12bc8c589ef33214a36f5a37c4e6793ff07fdcf534b085a10b6e412c15d4052f2075c5b4fe02a
-  data.tar.gz: 226ebaef071767418b9ac6257d334e45e1aff0d65fa19968deb5eba198524f3145093b520e2c7e6c69e31ba5b222018aa819e6f03a5f63c5bc41a18d233a1d2b
+  metadata.gz: 49cf7cc38f9e44687d27bee93a8de5678963fd92a9589241e38635afcdf4b86f8229d1c401483d2d6e955ee83e5423ca10f832f4beb0101873e60f5d0ff34821
+  data.tar.gz: 2098f1a3c297277bd07425961b3e84425a1189ae5984e21c35649a3a2c517a5a175dfd5b477abb59ba49f78925a9c4ec872006d3be025ddc4ee363bf86ff7004

data/.reek.yml

@@ -3,4 +3,20 @@ detectors:
   TooManyStatements:
     max_statements: 7
   UncommunicativeVariableName:
-    enabled: false
+    enabled: false
+  FeatureEnvy:
+    exclude:
+      - fetch_last_id
+      - last_item
+      - update_time_columns
+  TooManyMethods:
+    max_methods: 20
+    exclude:
+      - ValidationEditor
+  LongParameterList:
+    exclude:
+      - process_and_update_time_field
+      - invalid_time_value?
+  DataClump:
+    exclude:
+      - TimeValidationHelpers

data/.rubocop.yml

@@ -6,6 +6,10 @@ AllCops:
     - timet.gemspec
     - "vendor/**/*" # Exclude vendor/bundle gems
 
+Metrics/ModuleLength:
+  Exclude:
+    - 'lib/timet/tag_distribution.rb'
+
 Metrics/MethodLength:
   Max: 15
 

data/CHANGELOG.md

@@ -1,3 +1,22 @@
+## [1.6.3] - 2026-02-28
+
+**Improvements:**
+
+- **Validation Architecture:** Refactored validation logic from `ValidationEditHelper` module to `ValidationEditor` class for better encapsulation and testability.
+- **Synchronization & Storage:** Simplified `DatabaseSyncer` and `S3Supabase` by extracting modular helper methods, introducing `S3Config` module, and `S3ObjectRef` struct.
+- **Reporting Features:** Added `export_csv` and `export_icalendar` methods to `TimeReport` for enhanced data portability.
+- **Database Refactoring:** Converted `Timet::Database` methods to class methods where appropriate, extracted column checks, and simplified item fetching logic.
+- **Tag Distribution:** Split `TagDistribution` into dedicated formatting and logic modules using a Context struct for clearer rendering.
+- **Dependencies:** Updated `aws-sdk-s3` to `~> 1.213`, removed unused `httparty` gem, and bumped RuboCop, parser, and thor dependencies.
+- **Code Quality:** Updated `.reek.yml` and RuboCop configs to accommodate new method structures, exclusions, and added code coverage badge to README.
+- **Cleanup:** Removed obsolete helper modules (`item_data_helper`, `time_report_helper`, `time_update_helper`, `time_validation_helper`).
+
+**Bug Fixes:**
+
+- **Status Determination:** Added nil guards to `determine_status` to prevent runtime errors during item status checks.
+- **Data Integrity:** Resolved duplicated `get_item_values` logic in syncer to ensure consistency during inserts and updates.
+- **Validation Logic:** Updated validation methods to correctly handle end datetime adjustments for the next day.
+
 ## [1.6.2] - 2025-12-28
 
 **Improvements:**
@@ -440,7 +459,6 @@
 **Improvements:**
 
 - **Refactor `TimeReport` to use `TimeReportHelper` module for utility methods:**
-
   - Extracted utility methods (`add_hashes`, `date_ranges`, `format_item`, `valid_date_format?`) into a new `TimeReportHelper` module.
   - Updated `TimeReport` class to include `TimeReportHelper` module.
   - Removed redundant utility methods from `TimeReport` class.
@@ -450,7 +468,6 @@
   - Adjusted formatting in `total` method for better alignment.
 
 - **Refactor `Timet::Formatter` to improve readability and modularity:**
-
   - Introduced a constant `CHAR_MAPPING` to store block characters for different value ranges.
   - Refactored `format_notes` method to use a more descriptive variable name for the maximum length.
   - Updated `format_tag_distribution` method to accept `colors` parameter and pass it to `process_and_print_tags`.

data/README.md

@@ -1,6 +1,7 @@
 [![Gem Version](https://badge.fury.io/rb/timet.svg)](https://badge.fury.io/rb/timet)
 ![timet workflow](https://github.com/frankvielma/timet/actions/workflows/ci.yml/badge.svg)
 [![Maintainability](https://qlty.sh/gh/frankvielma/projects/timet/maintainability.svg)](https://qlty.sh/gh/frankvielma/projects/timet)
+[![Code Coverage](https://qlty.sh/gh/frankvielma/projects/timet/coverage.svg)](https://qlty.sh/gh/frankvielma/projects/timet)
 
 # Timet
 

data/lib/timet/application.rb

@@ -4,7 +4,7 @@ require 'thor'
 require 'tty-prompt'
 require 'icalendar'
 require_relative 's3_supabase'
-require_relative 'validation_edit_helper'
+require_relative 'validation_editor'
 require_relative 'application_helper'
 require_relative 'time_helper'
 require_relative 'version'
@@ -22,7 +22,6 @@ module Timet
   # - delete: Delete a task
   # - cancel: Cancel active time tracking
   class Application < Thor
-    include ValidationEditHelper
     include ApplicationHelper
     include TimeHelper
 
@@ -271,7 +270,8 @@ Update start time => tt edit 12 start 12:33'
         new_value = prompt_for_new_value(item, field)
       end
 
-      updated_item = validate_and_update(item, field, new_value)
+      editor = Timet::ValidationEditor.new(item, @db)
+      updated_item = editor.update(field, new_value)
       @db.update_item(id, field, updated_item[FIELD_INDEX[field]])
       display_item(updated_item)
     end

data/lib/timet/database.rb

@@ -24,7 +24,7 @@ module Timet
     # @note The method creates a new SQLite3 database connection and initializes the necessary tables if they
     # do not already exist.
     def initialize(database_path = DEFAULT_DATABASE_PATH)
-      move_old_database_file(database_path)
+      self.class.move_old_database_file(database_path)
 
       @db = SQLite3::Database.new(database_path)
       create_table
@@ -76,15 +76,17 @@ module Timet
       raise 'Invalid table name' unless table_name == 'items'
       raise 'Invalid column name' unless /\A[a-zA-Z0-9_]+\z/.match?(new_column_name)
       raise 'Invalid date type' unless %w[INTEGER TEXT BOOLEAN].include?(date_type)
-
-      result = execute_sql("SELECT count(*) FROM pragma_table_info('items') where name=?", [new_column_name])
-      column_exists = result[0][0].positive?
-      return if column_exists
+      return if column_exists?(new_column_name)
 
       execute_sql("ALTER TABLE #{table_name} ADD COLUMN #{new_column_name} #{date_type}")
       puts "Column '#{new_column_name}' added to table '#{table_name}'."
     end
 
+    def column_exists?(new_column_name)
+      execute_sql("SELECT count(*) FROM pragma_table_info('items') where name=?",
+                  [new_column_name]).first.first.positive?
+    end
+
     # Inserts a new item into the items table.
     #
     # @param start [Integer] The start time of the item.
@@ -150,8 +152,8 @@ module Timet
     #
     # @note The method executes SQL to fetch the ID of the last inserted item.
     def fetch_last_id
-      result = execute_sql('SELECT id FROM items WHERE deleted IS NULL OR deleted = 0 ORDER BY id DESC LIMIT 1')
-      result.empty? ? nil : result[0][0]
+      execute_sql('SELECT id FROM items WHERE deleted IS NULL OR deleted = 0 ORDER BY id DESC LIMIT 1')
+        .then { |result| result.empty? ? nil : result.first.first }
     end
 
     # Fetches the last item from the items table.
@@ -163,8 +165,8 @@ module Timet
     #
     # @note The method executes SQL to fetch the last item from the 'items' table.
     def last_item
-      result = execute_sql('SELECT * FROM items WHERE deleted IS NULL OR deleted = 0 ORDER BY id DESC LIMIT 1')
-      result.empty? ? nil : result[0]
+      execute_sql('SELECT * FROM items WHERE deleted IS NULL OR deleted = 0 ORDER BY id DESC LIMIT 1')
+        .then { |result| result.empty? ? nil : result.first }
     end
 
     # Finds an item by its ID.
@@ -180,8 +182,7 @@ module Timet
     # @note If the item is found, it returns the item as an array.
     # @note If the item is not found, it returns nil.
     def find_item(id)
-      result = execute_sql('SELECT * FROM items WHERE id = ?', [id])
-      result.first.dup if result.any? # Add .dup to create a copy
+      execute_sql('SELECT * FROM items WHERE id = ?', [id]).first&.dup
     end
 
     # Fetches all items from the items table that have a start time greater than or equal to today.
@@ -212,8 +213,8 @@ module Timet
     #
     # @see StatusHelper#determine_status
     def item_status(id = nil)
-      id = fetch_last_id if id.nil?
-      determine_status(find_item(id))
+      id ||= fetch_last_id
+      self.class.determine_status(find_item(id))
     end
 
     # Executes a SQL query and returns the result.
@@ -281,8 +282,8 @@ module Timet
     # @note The method checks if the result set is empty and returns :no_items if true.
     # @note If the last item in the result set has no end time, it returns :in_progress.
     # @note If the last item in the result set has an end time, it returns :complete.
-    def determine_status(result)
-      return :no_items if result.nil?
+    def self.determine_status(result)
+      return :no_items unless result
 
       last_item_end = result[2]
       return :in_progress unless last_item_end
@@ -293,11 +294,12 @@ module Timet
     # Moves the old database file to the new location if it exists.
     #
     # @param database_path [String] The path to the new SQLite database file.
-    def move_old_database_file(database_path)
+    def self.move_old_database_file(database_path)
       old_file = File.join(Dir.home, '.timet.db')
       return unless File.exist?(old_file)
 
-      FileUtils.mkdir_p(File.dirname(database_path)) unless File.directory?(File.dirname(database_path))
+      dir = File.dirname(database_path)
+      FileUtils.mkdir_p(dir) unless File.directory?(dir)
       FileUtils.mv(old_file, database_path)
     end
 
@@ -317,14 +319,12 @@ 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.each do |item|
-        id = item[0]
-        start_time = item[1]
-        end_time = item[2]
-        fallback_time = end_time || start_time || Time.now.to_i
-        execute_sql('UPDATE items SET updated_at = ?, created_at = ? WHERE id = ?', [fallback_time, fallback_time, id])
-      end
+      execute_sql('SELECT * FROM items WHERE updated_at IS NULL OR created_at IS NULL')
+        .each { |item| update_timestamp_for_item(item[0], item[2] || item[1] || Time.now.to_i) }
+    end
+
+    def update_timestamp_for_item(id, fallback_time)
+      execute_sql('UPDATE items SET updated_at = ?, created_at = ? WHERE id = ?', [fallback_time, fallback_time, id])
     end
   end
 end

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