timet 1.4.4 → 1.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c617b0cdad056a121039feaacfb0fe04df4e3e21cea8d9261e0414a01c2e9014
-  data.tar.gz: cac525344920d23e05ed0cab8798aa70e0153337328cac6bb170c6d96b9b509a
+  metadata.gz: fcf74496e5767f780af32f515ddaa47aac3a80056c62dd4e4ab680b4e380d9ea
+  data.tar.gz: 8013d89eb5d8f13c794bc3a8b65d976e6e5658d674183a82aa5c11df3c5e65e3
 SHA512:
-  metadata.gz: e48e71078a2cfb0e7f92a67b008f323b487366ad41392e0027a1d229e29680018dbcf1b13012322735f94302e5c0e03576d544dd7b1897fd3973cf49ee7cc1d1
-  data.tar.gz: 2a5a3fdabd064518b57aac6142c690dba881ce3d68ace78bd6770d5679fc11f24a71878a7422a80482aaaffb0e723bd8aa4c9a0ebf2de2fa5b8ee35a3082d98d
+  metadata.gz: b0b961c8397a2db270284d7a25530265c79861e812674f376a2457675cdf5f1b6614117ead4e7de39ae73118ffcf30998a17d15ee010b6ec08725f63803bc99a
+  data.tar.gz: aa487be7cff8c23f5c578ea624ad2cd8382d5216833275fde531266d87efd850b678a3df28e350d95561758ba5ea1efa255db9e7eb5fe60e1c09580e4c805ea6

data/CHANGELOG.md

@@ -1,8 +1,43 @@
 ## [Unreleased]
 
+## [1.5.0] - 2024-12-06
+
+**Improvements:**
+
+- Implemented soft delete for items, adding a `deleted` column to the `items` table.
+- Improved database synchronization logic with better error handling and resource management.
+- Refactored synchronization methods to improve readability and maintainability.
+- Added `updated_at` and `created_at` columns to the `items` table for better tracking of item changes.
+- Updated synchronization logic to handle deleted items during synchronization.
+- Updated various gems to their latest versions, including `aws-sdk-core`, `aws-sdk-s3`, `json`, `regexp_parser`, `rubocop`, `rubocop-ast`, `sqlite3`, and `unicode-display_width`.
+- Improved the handling of environment variables in the S3 configuration.
+- Improved table formatting and display logic for better readability.
+- Simplified pomodoro end time formatting for better performance.
+- Added a check to skip items marked as deleted when generating CSV reports.
+- Updated the README to reflect new features and improvements.
+- Added YARD documentation for the `S3Supabase` class.
+
+**Bug Fixes:**
+
+- (No bug fixes listed in the provided commit messages)
+
+## [1.4.5] - 2024-11-18
+
+**Improvements:**
+
+- Added `base64` gem to the Gemfile to ensure compatibility with Ruby 3.4.0.
+- Updated the `json` gem from version 2.8.1 to 2.8.2.
+- Updated the `rubocop-ast` gem from version 1.35.0 to 1.36.1.
+- Added the `icalendar` gem to the application.
+
+**Bug Fixes:**
+
+- Fixed the deprecation warning related to `base64` being removed from the Ruby standard library in Ruby 3.4.0.
+
 ## [1.4.4] - 2024-11-12
 
 **Improvements:**
+
 - Refactored tag distribution and time statistics methods:
   - Split `process_and_print_tags` into `print_summary` and `print_tags_info` for better modularity and readability.
   - Added Yardoc comments to document the new methods and updated existing comments for clarity.
@@ -13,12 +48,14 @@
   - Ensured that the iCalendar file generation logic is encapsulated within the `TimeReportHelper` module.
 
 **Tasks:**
+
 - Bumped version to 1.4.4.
 - Updated `Gemfile.lock`.
 
 ## [1.4.3] - 2024-11-06
 
 **Improvements:**
+
 - **Refactor export logic**: Introduced a new `ReportExporter` class to handle the export of reports to CSV and iCalendar formats, addressing the Feature Envy code smell and making the `ApplicationHelper` module more modular.
 - **Update gem dependencies**: Updated several gems to their latest versions, including `icalendar`, `sqlite3`, `json`, `parser`, `rubocop`, and `rubocop-ast`.
 - **Refactor `TimeReport` initialization**: Refactored `TimeReport` initialization to use an options hash instead of individual parameters, and added support for exporting tracking summaries to iCalendar format.
@@ -26,10 +63,10 @@
 - **Add `icalendar` gem**: Added the `icalendar` gem to support iCalendar functionality and updated the `timet` gem version to `1.4.3`.
 
 **Bug Fixes:**
+
 - Corrected platform names in the lockfile.
 - Updated the `TimeReport` spec to use the new options hash in the `TimeReport` initialization.
 
-
 ## [1.4.2] - 2024-11-01
 
 **Improvements:**

data/README.md

@@ -7,9 +7,24 @@
 
 ![Timet](timet.webp)
 
-[Timet](https://rubygems.org/gems/timet) is a command-line tool designed to track your activities by recording the time spent on each task. This allows you to monitor your work hours and productivity directly from your terminal without needing a graphical interface. Essentially, it's a way to log your time spent on different projects or tasks using simple text commands.
 
-🔑 **Key Features:**
+## Table of Contents
+
+- [🔑 Key Features](#key-features)
+- [✔️ Requirements](#requirements)
+- [Examples](#examples)
+- [💾 Installation](#installation)
+- [⏳ Usage](#usage)
+- [📋 Command Reference](#command-reference)
+- [🗃️ Data](#️-data)
+- [🔒 S3 Cloud Backup Configuration](#-s3-cloud-backup-configuration)
+- [Contributing](#contributing)
+- [License](#license)
+
+
+[Timet](https://rubygems.org/gems/timet) is a command-line tool designed to track your activities by recording the time spent on each task. This tool allows you to monitor your work hours and productivity directly from your terminal, eliminating the need for a graphical interface. Essentially, it's a way to log your time spent on different projects or tasks using simple text commands.
+
+<h2 id="key-features">🔑 Key Features:</h2>
 
 - **Local Data Storage:** Timet uses SQLite to store your time tracking data locally, ensuring privacy and security.
 - **Lightweight and Fast:** Its efficient design and local data storage make Timet a speedy and responsive tool.
@@ -23,12 +38,14 @@
 - **Tag Distribution Plot:** Illustrates the proportion of total tracked time allocated to each tag, showing the relative contribution of each tag to the overall time tracked.
 - **Detailed Statistics:** Displays detailed statistics for each tag, including total duration, average duration, and standard deviation.
 - **iCalendar Export:** Easily export your time tracking data to iCalendar format for integration with calendar applications.
+- **S3 Cloud Backup:** Seamlessly backup and sync your time tracking data with S3-compatible storage services, providing an additional layer of data protection and accessibility.
 
-**Examples:**
+## Examples:
 
-![Timet1 demo](timet1.gif)
+![Timet demo](timet1.gif)
 
-## ✔️ Requirements
+<a name="requirements"></a>
+<h2 id="requirements">✔️ Requirements</h2>
 
 - Ruby version: >= 3.0.0
 - sqlite3: > 1.7
@@ -38,6 +55,7 @@ For older versions of Ruby and Sqlite:
 - [Ruby >= 2.7](https://github.com/frankvielma/timet/tree/ruby-2.7.0)
 - [Ruby >= 2.4](https://github.com/frankvielma/timet/tree/ruby-2.4.0)
 
+<a name="installation"></a>
 ## 💾 Installation
 
 Install the gem by executing:
@@ -46,6 +64,7 @@ Install the gem by executing:
 gem install timet
 ```
 
+<a name="usage"></a>
 ## ⏳ Usage
 
 ### Command Aliases
@@ -172,24 +191,26 @@ gem install timet
   +-------+------------+--------+----------+----------+----------+--------------------------+
   ```
 
+<a name="command-reference"></a>
 ## 📋 Command Reference
 
 | Command                                      | Description                                                                 | Example Usage                     |
 | -------------------------------------------- | --------------------------------------------------------------------------- | --------------------------------- |
-| `timet start [tag] --notes='' --pomodoro=[time]` | Start tracking time for a task labeled [tag] and notes (optional).          | `timet start Task "My notes" 25`     |
-| `timet stop`                                 | Stop tracking time.                                                         | `timet stop`                       |
+| `timet start [tag] --notes='' --pomodoro=[time]` | Start tracking time for a task labeled [tag] and notes (optional).      | `timet start Task "My notes" 25`  |
+| `timet stop`                                 | Stop tracking time.                                                         | `timet stop`                      |
 | `timet summary today (t)`                    | Display a report of tracked time for today.                                 | `timet su t` or `timet su`        |
 | `timet summary yesterday (y)`                | Display a report of tracked time for yesterday.                             | `timet su y`                      |
 | `timet summary week (w)`                     | Display a report of tracked time for the week.                              | `timet su w`                      |
 | `timet summary month (m)`                    | Display a report of tracked time for the month.                             | `timet su m`                      |
-| `timet su t --csv=[filename]`                | Display a report of tracked time for today and export to CSV file | `timet su t --csv=file.csv`       |
-| `timet su w --ics=[filename]`                | Display a report of tracked time for week and export to iCalendar file | `timet su w --ics=file.csv`       |
+| `timet su t --csv=[filename]`                | Display a report of tracked time for today and export to CSV file | `timet su t --csv=file.csv`                 |
+| `timet su w --ics=[filename]`                | Display a report of tracked time for week and export to iCalendar file | `timet su w --ics=file.csv`            |
 | `timet delete [id]`                          | Delete a task by its ID.                                                    | `timet d [id]`                    |
 | `timet cancel`                               | Cancel active time tracking.                                                | `timet c`                         |
 | `timet edit [id]`                            | Update a task's notes, tag, start, or end fields.                           | `timet e [id]`                    |
 | `timet su [date]`                            | Display a report of tracked time for a specific date.                       | `timet su 2024-01-03`             |
 | `timet su [start_date]..[end_date]`          | Display a report of tracked time for a date range.                          | `timet su 2024-01-02..2024-01-03` |
 | `timet resume (r) [id]`                      | Resume tracking a task by ID or the last completed task.                    | `timet resume [id]`               |
+| `timet sync`                                 | Sync local db with remote (S3) external db                                | `timet sync`                      |
 
 ### Date Range in Summary
 
@@ -209,9 +230,35 @@ The `timet summary` command now supports specifying a date range for generating
   timet su 2024-01-02..2024-01-03
   ```
 
-## Data
+<a name="data"></a>
+## 🗃️ Data
+
+Timet's data is stored in `~/.timet`.
+
+<a name="s3-cloud-backup-configuration"></a>
+## 🔒 S3 Cloud Backup Configuration
+
+Timet supports backing up and syncing your time tracking data with S3-compatible storage services (such as Supabase S3). To configure S3 backup, follow these steps:
+
+### Environment Variables
+
+Create a `.env` file in your project root (`~/.timet`) with the following variables:
+
+```bash
+S3_ENDPOINT=your_s3_endpoint_url
+S3_ACCESS_KEY=your_access_key
+S3_SECRET_KEY=your_secret_key
+S3_REGION=your_s3_region
+```
+
+### Security Considerations
+
+- Keep your `.env` file private and never commit it to version control
+- Use strong, unique access keys
+- Regularly rotate your S3 access credentials
+- Implement appropriate IAM policies to restrict bucket access
+
 
-Timet's data is stored in `~/.timet.db`.
 
 ## Development
 

data/lib/timet/application.rb

@@ -1,12 +1,16 @@
 # frozen_string_literal: true
 
-require_relative 'version'
 require 'thor'
 require 'tty-prompt'
+require 'icalendar'
+require_relative 's3_supabase'
 require_relative 'validation_edit_helper'
 require_relative 'application_helper'
 require_relative 'time_helper'
-
+require_relative 'version'
+require_relative 'database_sync_helper'
+require 'tempfile'
+require 'digest'
 module Timet
   # Application class that defines CLI commands for time tracking:
   # - start: Start time tracking with optional notes
@@ -35,6 +39,8 @@ module Timet
 
     VALID_STATUSES_FOR_INSERTION = %i[no_items complete].freeze
 
+    BUCKET = 'timet'
+
     desc "start [tag] --notes='' --pomodoro=[min]",
          'Start time tracking for a task labeled with the provided [tag], notes and "pomodoro time"
         in minutes (optional).
@@ -72,7 +78,7 @@ module Timet
 
       return puts 'A task is currently being tracked.' unless VALID_STATUSES_FOR_INSERTION.include?(@db.item_status)
 
-      @db.insert_item(start_time, tag, notes, pomodoro)
+      @db.insert_item(start_time, tag, notes, pomodoro, start_time, start_time)
       play_sound_and_notify(pomodoro * 60, tag) if pomodoro.positive?
       summary
     end
@@ -271,5 +277,11 @@ module Timet
     def version
       puts Timet::VERSION
     end
+
+    desc 'sync', 'Sync local db with supabase external db'
+    def sync
+      puts 'Syncing database with remote storage...'
+      DatabaseSyncHelper.sync(@db, BUCKET)
+    end
   end
 end

data/lib/timet/database.rb

@@ -1,11 +1,12 @@
 # frozen_string_literal: true
 
+require 'fileutils'
 require 'sqlite3'
 module Timet
   # Provides database access for managing time tracking data.
   class Database
     # The default path to the SQLite database file.
-    DEFAULT_DATABASE_PATH = File.join(Dir.home, '.timet.db')
+    DEFAULT_DATABASE_PATH = File.join(Dir.home, '.timet', 'timet.db')
 
     # Initializes a new instance of the Database class.
     #
@@ -23,11 +24,17 @@ 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)
+
       @db = SQLite3::Database.new(database_path)
       create_table
 
       add_column('items', 'notes', 'TEXT')
       add_column('items', 'pomodoro', 'INTEGER')
+      add_column('items', 'updated_at', 'INTEGER')
+      add_column('items', 'created_at', 'INTEGER')
+      add_column('items', 'deleted', 'INTEGER')
+      update_time_columns
     end
 
     # Creates the items table if it doesn't already exist.
@@ -87,8 +94,9 @@ module Timet
     #   insert_item(1633072800, 'work', 'Completed task X')
     #
     # @note The method executes SQL to insert a new row into the 'items' table.
-    def insert_item(start, tag, notes, pomodoro = nil)
-      execute_sql('INSERT INTO items (start, tag, notes, pomodoro) VALUES (?, ?, ?, ?)', [start, tag, notes, pomodoro])
+    def insert_item(start, tag, notes, pomodoro = nil, updated_at = nil, created_at = nil)
+      execute_sql('INSERT INTO items (start, tag, notes, pomodoro, updated_at, created_at) VALUES (?, ?, ?, ?, ?, ?)',
+                  [start, tag, notes, pomodoro, updated_at, created_at])
     end
 
     # Updates an existing item in the items table.
@@ -107,7 +115,7 @@ module Timet
     def update_item(id, field, value)
       return if %w[start end].include?(field) && value.nil?
 
-      execute_sql("UPDATE items SET #{field}='#{value}' WHERE id = #{id}")
+      execute_sql("UPDATE items SET #{field}='#{value}', updated_at=#{Time.now.utc.to_i} WHERE id = #{id}")
     end
 
     # Deletes an item from the items table.
@@ -122,7 +130,8 @@ module Timet
     #
     # @note The method executes SQL to delete the item with the given ID from the 'items' table.
     def delete_item(id)
-      execute_sql("DELETE FROM items WHERE id = #{id}")
+      current_time = Time.now.to_i
+      execute_sql('UPDATE items SET deleted = 1, updated_at = ? WHERE id = ?', [current_time, id])
     end
 
     # Fetches the ID of the last inserted item.
@@ -134,8 +143,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 ORDER BY id DESC LIMIT 1').first
-      result ? result[0] : nil
+      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]
     end
 
     # Fetches the last item from the items table.
@@ -147,23 +156,8 @@ module Timet
     #
     # @note The method executes SQL to fetch the last item from the 'items' table.
     def last_item
-      execute_sql('SELECT * FROM items ORDER BY id DESC LIMIT 1').first
-    end
-
-    # Determines the status of the last item in the items table.
-    #
-    # @return [Symbol] The status of the last item. Possible values are :no_items, :in_progress, or :complete.
-    #
-    # @example Determine the status of the last item
-    #   item_status
-    #
-    # @note The method executes SQL to fetch the last item and determines its status using the `StatusHelper` module.
-    #
-    # @param id [Integer, nil] The ID of the item to check. If nil, the last item in the table is used.
-    #
-    def item_status(id = nil)
-      id = fetch_last_id if id.nil?
-      determine_status(find_item(id))
+      result = execute_sql('SELECT * FROM items WHERE deleted IS NULL OR deleted = 0 ORDER BY id DESC LIMIT 1')
+      result.empty? ? nil : result[0]
     end
 
     # Finds an item in the items table by its ID.
@@ -177,7 +171,8 @@ module Timet
     #
     # @note The method executes SQL to find the item with the given ID in the 'items' table.
     def find_item(id)
-      execute_sql("SELECT * from items where id=#{id}").first
+      result = execute_sql('SELECT * FROM items WHERE id = ? AND (deleted IS NULL OR deleted = 0)', [id])
+      result.empty? ? nil : result[0]
     end
 
     # Fetches all items from the items table that have a start time greater than or equal to today.
@@ -190,7 +185,25 @@ module Timet
     # @note The method executes SQL to fetch all items from the 'items' table that have a start time greater than
     # or equal to today.
     def all_items
-      execute_sql("SELECT * FROM items where start >= '#{Date.today.to_time.to_i}' ORDER BY id DESC")
+      today = Time.now.to_i - (Time.now.to_i % 86_400)
+      execute_sql('SELECT * FROM items WHERE start >= ? AND (deleted IS NULL OR deleted = 0) ORDER BY start DESC',
+                  [today])
+    end
+
+    # Determines the status of the last item in the items table.
+    #
+    # @return [Symbol] The status of the last item. Possible values are :no_items, :in_progress, or :complete.
+    #
+    # @example Determine the status of the last item
+    #   item_status
+    #
+    # @note The method executes SQL to fetch the last item and determines its status using the `StatusHelper` module.
+    #
+    # @param id [Integer, nil] The ID of the item to check. If nil, the last item in the table is used.
+    #
+    def item_status(id = nil)
+      id = fetch_last_id if id.nil?
+      determine_status(find_item(id))
     end
 
     # Executes a SQL query and returns the result.
@@ -269,5 +282,42 @@ 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.
+    def 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))
+      FileUtils.mv(old_file, database_path)
+    end
+
+    # Updates the `updated_at` and `created_at` columns for items where either of these columns is null.
+    #
+    # This method queries the database for items where the `updated_at` or `created_at` columns are null.
+    # For each item found, it sets both the `updated_at` and `created_at` columns to the value of the `end_time` column.
+    #
+    # @note This method directly executes SQL queries on the database. Ensure that the `execute_sql` method is properly
+    # defined and handles SQL injection risks.
+    #
+    # @return [void] This method does not return a value.
+    #
+    # @example
+    #   update_time_columns
+    #
+    # @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]
+        end_time = item[2]
+        execute_sql("UPDATE items SET updated_at = #{end_time}, created_at = #{end_time} WHERE id = #{id}")
+      end
+    end
   end
 end

data/lib/timet/database_sync_helper.rb

@@ -0,0 +1,273 @@
+# frozen_string_literal: true
+
+require 'tempfile'
+require 'digest'
+
+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
+
+    # Main entry point for database synchronization
+    #
+    # @param local_db [SQLite3::Database] The local database connection
+    # @param bucket [String] The S3 bucket name
+    # @return [void]
+    # @note This method initiates the database synchronization process by checking for the presence of a remote database
+    def self.sync(local_db, bucket)
+      remote_storage = S3Supabase.new
+      remote_storage.create_bucket(bucket)
+
+      objects = remote_storage.list_objects(bucket)
+      if objects&.any? { |obj| obj[:key] == 'timet.db' }
+        process_remote_database(local_db, remote_storage, bucket, Timet::Database::DEFAULT_DATABASE_PATH)
+      else
+        puts 'No remote database found, uploading local database'
+        remote_storage.upload_file(bucket, Timet::Database::DEFAULT_DATABASE_PATH, 'timet.db')
+      end
+    end
+
+    # Processes the remote database by comparing it with the local database and syncing changes
+    #
+    # @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
+    # @return [void]
+    # @note This method orchestrates the entire sync process by downloading the remote database,
+    #   comparing it with the local database, and handling any differences found
+    def self.process_remote_database(local_db, remote_storage, bucket, local_db_path)
+      with_temp_file do |temp_file|
+        remote_storage.download_file(bucket, 'timet.db', temp_file.path)
+
+        if databases_are_in_sync?(temp_file.path, local_db_path)
+          puts 'Local database is up to date'
+        else
+          handle_database_differences(local_db, remote_storage, bucket, local_db_path, temp_file.path)
+        end
+      end
+    end
+
+    # Creates a temporary file and ensures it is properly cleaned up after use
+    #
+    # @yield [Tempfile] The temporary file object to use
+    # @return [void]
+    # @note This method ensures proper resource cleanup by using ensure block
+    def self.with_temp_file
+      temp_file = Tempfile.new('remote_db')
+      yield temp_file
+    ensure
+      temp_file.close
+      temp_file.unlink
+    end
+
+    # Compares two database files to check if they are identical
+    #
+    # @param remote_path [String] Path to the remote database file
+    # @param local_path [String] Path to the local database file
+    # @return [Boolean] true if databases are identical, false otherwise
+    # @note Uses MD5 hashing to compare file contents
+    def self.databases_are_in_sync?(remote_path, local_path)
+      remote_md5 = Digest::MD5.file(remote_path).hexdigest
+      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')
+
+      remote_by_id = items_to_hash(remote_items)
+      local_by_id = items_to_hash(local_items)
+      all_ids = (remote_by_id.keys + local_by_id.keys).uniq
+
+      all_ids.each do |id|
+        remote_item = remote_by_id[id]
+        local_item = local_by_id[id]
+
+        if remote_item && local_item
+          process_existing_item(id, local_item, remote_item, local_db)
+        elsif remote_item
+          puts "Adding remote item #{id} to local"
+          insert_item_from_hash(local_db, remote_item)
+        else # local_item exists
+          puts "Local item #{id} will be uploaded"
+        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/s3_supabase.rb

@@ -0,0 +1,229 @@
+# frozen_string_literal: true
+
+require 'aws-sdk-s3'
+require 'logger'
+require 'dotenv'
+require 'fileutils'
+
+# The module includes several components:
+# - S3 integration for data backup and sync
+#
+module Timet
+  # 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)
+    dir_path = File.dirname(env_file_path)
+    FileUtils.mkdir_p(dir_path)
+
+    # Create file if it doesn't exist or is empty
+    File.write(env_file_path, '', mode: 'a')
+
+    # Load and check environment variables
+    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
+    ENV_FILE_PATH = File.join(Dir.home, '.timet', '.env')
+    Timet.ensure_env_file_exists(ENV_FILE_PATH)
+    Dotenv.load(ENV_FILE_PATH)
+
+    S3_ENDPOINT = ENV.fetch('S3_ENDPOINT', nil)
+    S3_ACCESS_KEY = ENV.fetch('S3_ACCESS_KEY', nil)
+    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')
+
+    # 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)
+      @logger.level = Logger::INFO
+      @s3_client = Aws::S3::Client.new(
+        region: S3_REGION,
+        access_key_id: S3_ACCESS_KEY,
+        secret_access_key: S3_SECRET_KEY,
+        endpoint: S3_ENDPOINT,
+        force_path_style: true
+      )
+    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
+      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)
+      end
+    rescue Aws::S3::Errors::ServiceError => e
+      @logger.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."
+    rescue Aws::S3::Errors::ServiceError => e
+      @logger.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."
+    rescue Aws::S3::Errors::ServiceError => e
+      @logger.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."
+    rescue Aws::S3::Errors::ServiceError => e
+      @logger.error "Error deleting object: #{e.message}"
+    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
+      @s3_client.delete_bucket(bucket: bucket_name)
+      @logger.info "Bucket '#{bucket_name}' deleted successfully."
+    rescue Aws::S3::Errors::ServiceError => e
+      @logger.error "Error deleting bucket: #{e.message}"
+    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 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?
+
+      return if missing_vars.empty?
+
+      error_message = "Missing required environment variables (.env): #{missing_vars.join(', ')}"
+      raise CustomError, error_message
+    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
+      end
+    end
+  end
+end

data/lib/timet/table.rb

@@ -44,7 +44,7 @@ module Timet
       header = <<~TABLE
         #{title}
         #{separator}
-        \033[32m| Id    | Date       | Tag    | Start    | End      | Duration | Notes              |\033[0m
+        \033[32m| Id    | Date       | Tag    | Start    | End      | Duration | Notes\033[0m
         #{separator}
       TABLE
       puts header
@@ -59,7 +59,7 @@ module Timet
     #
     # @note The method returns a string representing the separator line for the table.
     def separator
-      '+-------+------------+--------+----------+----------+----------+--------------------+'
+      '+-------+------------+--------+----------+----------+----------+'
     end
 
     # Processes time entries and generates a time block structure.
@@ -165,7 +165,7 @@ module Timet
       mark = format_mark(id)
 
       "| #{id.to_s.rjust(6)}| #{start_date} | #{tag.ljust(6)} | #{start_time.split[1]} | " \
-        "#{end_time.rjust(8)} | #{@db.seconds_to_hms(duration).rjust(8)} | #{format_notes(notes)}  #{mark}"
+        "#{end_time.rjust(8)} | #{@db.seconds_to_hms(duration).rjust(8)} #{mark} #{format_notes(notes)}"
     end
 
     # Formats the end time of the time entry.
@@ -190,9 +190,9 @@ module Timet
       pomodoro = @db.find_item(id)[5] || 0
 
       if pomodoro.positive? && end_time == '-'
-        delta = (@db.find_item(id)[5] - (duration / 60.0)).round(1)
-        timet = "\e]8;;Session ends\a#{delta} min\e]8;;\a".green
-        end_time = " #{timet}".blink
+        delta = @db.seconds_to_hms((@db.find_item(id)[5] * 60) - duration)
+        timet = "\e]8;;Session ends\a#{delta}\e]8;;\a".green
+        end_time = timet.to_s.blink
       end
 
       end_time
@@ -216,7 +216,7 @@ module Timet
     def format_mark(id)
       pomodoro = @db.find_item(id)[5] || 0
       mark = '|'
-      mark = "#{'├'.white} #{'P'.blue.blink}" if pomodoro.positive?
+      mark = "#{'├'.white}#{'P'.blue.blink}" if pomodoro.positive?
       mark
     end
 
@@ -230,7 +230,7 @@ module Timet
     #
     # @note The method truncates the notes to a maximum of 20 characters and pads them to a fixed width.
     def format_notes(notes)
-      spaces = 17
+      spaces = 80
       return ' ' * spaces unless notes
 
       max_length = spaces - 3
@@ -250,7 +250,7 @@ module Timet
       total = @items.map do |item|
         TimeHelper.calculate_duration(item[1], item[2])
       end.sum
-      puts "|#{' ' * 43}#{'Total:'.blue}  | #{@db.seconds_to_hms(total).rjust(8).blue} |#{' ' * 20}|"
+      puts "|#{' ' * 43}#{'Total:'.blue}  | #{@db.seconds_to_hms(total).rjust(8).blue} |"
       puts separator
       display_pomodoro_label
     end

data/lib/timet/time_report.rb

@@ -168,7 +168,12 @@ module Timet
     def filter_by_date_range(start_date, end_date = nil, tag = nil)
       start_time = TimeHelper.date_to_timestamp(start_date)
       end_time = TimeHelper.calculate_end_time(start_date, end_date)
-      query = "start >= #{start_time} and start < #{end_time} and tag like '%#{tag}%'"
+      query = [
+        "start >= #{start_time}",
+        "start < #{end_time}",
+        "tag like '%#{tag}%'",
+        '(deleted IS NULL OR deleted = 0)'
+      ].join(' and ')
       @db.execute_sql(
         "select * from items where #{query} ORDER BY id DESC"
       )

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.4.4'
-  VERSION = '1.4.4'
+  #   Timet::VERSION # => '1.5.0'
+  VERSION = '1.5.0'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: timet
 version: !ruby/object:Gem::Version
-  version: 1.4.4
+  version: 1.5.0
 platform: ruby
 authors:
 - Frank Vielma
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-11-12 00:00:00.000000000 Z
+date: 2024-12-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: thor
@@ -58,6 +58,62 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '1.7'
+- !ruby/object:Gem::Dependency
+  name: icalendar
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2'
+- !ruby/object:Gem::Dependency
+  name: descriptive_statistics
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2'
+- !ruby/object:Gem::Dependency
+  name: dotenv
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3'
+- !ruby/object:Gem::Dependency
+  name: aws-sdk-s3
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.171'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.171'
 description: Timet is a command-line time tracker that keeps track of your activities.
 email:
 - frankvielma@gmail.com
@@ -82,6 +138,8 @@ files:
 - lib/timet/application_helper.rb
 - lib/timet/color_codes.rb
 - lib/timet/database.rb
+- lib/timet/database_sync_helper.rb
+- lib/timet/s3_supabase.rb
 - lib/timet/table.rb
 - lib/timet/tag_distribution.rb
 - lib/timet/time_block_chart.rb