timet 0.1.0 → 0.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 86b753ecfeaeaa477431908419a5a20c1446d146f52dbd72a2a2cda1e4664873
-  data.tar.gz: e5a13c6eef4c17aacbb907df19731cd2f736ddb3ef9b2155f9c4c35416123ffc
+  metadata.gz: 31d714405b3e7c5ff73a15f62e00f633b09aa6740b03eb0adfd248a83445320e
+  data.tar.gz: 98251bb40809c2c1d1151cd2c55fc5666faa029e9f7fc8958db3ec0460893253
 SHA512:
-  metadata.gz: 9a94bc189c1c507fd918d229a020dcdf674e5d7b0ce6cff127e9968d727c514aaecaa1c35d8c1cdd1f722505c7d01bca9fbf5ec187d369528aea35f3120c61b2
-  data.tar.gz: b67dd26bd7e5a8725051ef657cde914f2b2b6ef00771af08c86c2b04da0762a9df8cb9ea5e58296c74928258e808eb23d88ee27a733c2a5a3a5fabd5bef96d50
+  metadata.gz: 12ba0176fb4d85870dcf87ca83d8b9fe9dca1c9303b39e9ab8cc0595d64ced68e3c10fef86ffbb1f0a7d6ad8114f08d2355abcfed894e7e4e609f3c319fd68e5
+  data.tar.gz: '04194e7a85dbfc73755f8b3bb2db20759aef24219046865102d23867ff9ee92e12807734cc07590cfeb07ba52ad60a66da4d3762f47ff059f089ed7dd2330cb6'

data/.rubocop.yml

@@ -8,10 +8,4 @@ AllCops:
 Metrics/MethodLength:
   Max: 12
 
-Style/StringLiterals:
-  EnforcedStyle: double_quotes
-
-Style/StringLiteralsInInterpolation:
-  EnforcedStyle: double_quotes
-
 require: rubocop-rspec

data/CHANGELOG.md

@@ -1,5 +1,28 @@
 ## [Unreleased]
 
+## [0.2.1] - 2024-09-24
+
+* **Improved `resume` behavior:**
+    * If no notes are provided, it will attempt to retrieve them from the last tracked task.
+* **Enhanced `export_sheet` functionality:**
+    * A new `notes` column has been added to the exported CSV file.
+* **Minor bug fixes:**
+    * Resolved issues related to resuming tasks with notes and deleting items.
+
+
+## [0.2.0] - 2024-09-24
+
+* **Improved code quality:**
+    * Enforces consistent quoting style with `RuboCop` integration.
+    * Removes unused gems (`mini_portile2`) from the `Gemfile`.
+* **Database enhancements:**
+    * Adds a new column named "notes" to the `items` table to store additional information about tracked time entries.
+* **Command-line improvements:**
+    * Allows adding notes to a new time entry using the `start` command with the `--notes` option (e.g., `timet start work --notes="meeting with client"`).
+    * Improves formatting and clarity of some command descriptions.
+* **General code formatting:**
+    * Uses single quotes (`'`) for strings and source paths in the `Gemfile`.
+
 ## [0.1.0] - 2024-08-01
 
 - Initial release

data/README.md

@@ -1,5 +1,6 @@
 ![timet workflow](https://github.com/frankvielma/timet/actions/workflows/ci.yml/badge.svg)
-
+[![Maintainability](https://api.codeclimate.com/v1/badges/44d57b6c561b9be717f5/maintainability)](https://codeclimate.com/github/frankvielma/timet/maintainability)
+[![Test Coverage](https://api.codeclimate.com/v1/badges/44d57b6c561b9be717f5/test_coverage)](https://codeclimate.com/github/frankvielma/timet/test_coverage)
 
 # Timet
 
@@ -32,145 +33,120 @@ Old versions of Ruby and Sqlite:
 
 ## Installation
 
-Install the gem and add to the application's Gemfile by executing:
-
-    $ bundle add timet
-
-If bundler is not being used to manage dependencies, install the gem by executing:
-
-    $ gem install timet
+Install the gem by executing:
+```bash
+$ gem install timet
+```
 
 ## Usage
 
-Using timet or tt as an alias is possible
-
-- **timet start [tag]**: Starts tracking time for a task labeled with the provided [tag]. Example:
-    ```shell
-    timet start task1
-
-    or 
-
-    tt start task1
+- **timet start [tag] --notes='...'**: Starts tracking time for a task labeled with the provided [tag] and notes (optional). Example:
+    ```bash
+    timet start task1 --notes='Meeting with client'
     ```
 
     ```
-    Tracked time report:
-    +-------+--------+---------------------+-------------------+------------+
-    | Id    | Tag    | Start Time          | End Time          | Duration   |
-    +-------+--------+---------------------+-------------------+------------+
-    |     1 | task1  | 2024-08-09 14:55:07 |                 - |   00:00:00 |
-    +-------+--------+---------------------+-------------------+------------+
-    |                                                  Total:  |   00:00:00 |
-    +-------+--------+---------------------+-------------------+------------+
+    Tracked time report [today]:
+    +-------+------------+--------+----------+----------+----------+--------------------------+
+    | Id    | Date       | Tag    | Start    | End      | Duration | Notes                    |
+    +-------+------------+--------+----------+----------+----------+--------------------------+
+    |     1 | 2024-08-09 | task1  | 14:55:07 |        - | 00:00:00 | Meeting with client      |
+    +-------+------------+--------+----------+----------+----------+--------------------------+
+    |                                           Total:  | 00:00:00 |                          |
+    +-------+------------+--------+----------+----------+----------+--------------------------+
     ```
 
 - **timet stop**: Stops tracking the current task, records the elapsed time, and displays the total time spent on all tasks.
 
-    ```shell
+    ```bash
     timet stop
     ```
 
     ```
-    Tracked time report:
-    +-------+--------+---------------------+---------------------+------------+
-    | Id    | Tag    | Start Time          | End Time            | Duration   |
-    +-------+--------+---------------------+--------------------+-------------+
-    |     1 | task1  | 2024-08-09 14:55:07 | 2024-08-09 14:56:20 |   00:01:13 |
-    +-------+--------+---------------------+---------------------+------------+
-    |                                                  Total:    |   00:01:13 |
-    +-------+--------+---------------------+---------------------+------------+
+    Tracked time report [today]:
+    +-------+------------+--------+----------+----------+----------+--------------------------+
+    | Id    | Date       | Tag    | Start    | End      | Duration | Notes                    |
+    +-------+------------+--------+----------+----------+----------+--------------------------+
+    |     1 | 2024-08-09 | task1  | 14:55:07 | 15:55:07 | 01:00:00 | Meeting with client      |
+    +-------+------------+--------+----------+----------+----------+--------------------------+
+    |                                           Total:  | 01:00:00 |                          |
+    +-------+------------+--------+----------+----------+----------+--------------------------+
     ```
 
 - **timet resume**: It allows users to quickly resume tracking a task that was previously in progress.
     ```
-    Tracked time report:
-    +-------+--------+---------------------+---------------------+------------+
-    | Id    | Tag    | Start Time          | End Time            | Duration   |
-    +-------+--------+---------------------+--------------------+-------------+
-    |     2 | task1  | 2024-08-09 16:45:12 |                   - |   00:00:00 |
-    |     1 | task1  | 2024-08-09 14:55:07 | 2024-08-09 14:56:20 |   00:01:13 |
-    +-------+--------+---------------------+---------------------+------------+
-    |                                                  Total:    |   00:01:13 |
-    +-------+--------+---------------------+---------------------+------------+
+    Tracked time report [today]:
+    +-------+------------+--------+----------+----------+----------+--------------------------+
+    | Id    | Date       | Tag    | Start    | End      | Duration | Notes                    |
+    +-------+------------+--------+----------+----------+----------+--------------------------+
+    |     2 | 2024-08-09 | task1  | 16:15:07 |        - | 00:00:00 | Meeting with client      |
+    |     1 |            | task1  | 14:55:07 | 15:55:07 | 01:00:00 | Meeting with client      |
+    +-------+------------+--------+----------+----------+----------+--------------------------+
+    |                                           Total:  | 01:00:00 |                          |
+    +-------+------------+--------+----------+----------+----------+--------------------------+
     ```
 
 - **timet summary today (t)**: Display a report of tracked time for today.
 
-```shell
+```bash
 timet summary today
-
-or
-
-tt su t
 ```
 
 - **timet summary yesterday (y)**: Display a report of tracked time for yesterday.
 
-```shell
+```bash
 timet summary yesterday
-
-or
-
-tt su y
 ```
 
 - **timet summary week (w)**: Display a report of tracked time for the week.
 
-```shell
+```bash
 timet summary week
-
-or
-
-tt su w
 ```
 
 - **timet summary resume (r)**: Resume tracking the last task.
 
-```shell
+```bash
 timet summary resume
-
-or
-
-tt su r
 ```
 
 - **timet summary resume (r)**: Resume tracking the last month.
 
-```shell
+```bash
 timet summary month
-
-or
-
-tt su m
 ```
 
 - **timet su t --csv=[filename]**:  Display a report of tracked time for today and export it to filename.csv
 
-```shell
-tt su t --csv=summary_today.csv
+```bash
+timet su t --csv=summary_today.csv
 ```
 
 - **timet delete [id]**: Delete a task
 
-```shell
+```bash
 timet delete [id]
 
 or
 
-tt d [id]
+timet d [id]
 ```
 
 - **timet cancel**: Cancel active time tracking
 
-```shell
+```bash
 timet cancel
 
 or
 
-tt c
+timet c
 ```
 
 
+## Data
+Timet's data is stored in ~/.timet.db
+
+
 ## Development
 
 After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.

data/Rakefile

@@ -1,11 +1,11 @@
 # frozen_string_literal: true
 
-require "bundler/gem_tasks"
-require "rspec/core/rake_task"
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
 
 RSpec::Core::RakeTask.new(:spec)
 
-require "rubocop/rake_task"
+require 'rubocop/rake_task'
 
 RuboCop::RakeTask.new
 

data/bin/timet

@@ -1,6 +1,6 @@
 #!/usr/bin/env ruby
 # frozen_string_literal: true
 
-require_relative "../lib/timet"
+require_relative '../lib/timet'
 
 Timet::Application.start(ARGV)

data/lib/timet/application.rb

@@ -1,8 +1,9 @@
 # frozen_string_literal: true
 
-require_relative "version"
-require "thor"
-require "tty-prompt"
+require_relative 'version'
+require 'thor'
+require 'tty-prompt'
+require 'byebug'
 
 module Timet
   # Tracks time spent on various tasks.
@@ -12,14 +13,16 @@ module Timet
       @db = Timet::Database.new
     end
 
-    desc "start [tag]", "start time tracking"
-    def start(tag)
+    desc "start [tag] --notes='...'", "start time tracking  --notes='my notes...'"
+    option :notes, type: :string, desc: 'Add a note'
+    def start(tag, notes = nil)
       start = Time.now.to_i
-      @db.insert_item(start, tag) if %i[no_items complete].include?(@db.last_item_status)
+      notes = options[:notes] || notes
+      @db.insert_item(start, tag, notes) if %i[no_items complete].include?(@db.last_item_status)
       summary
     end
 
-    desc "stop", "stop time tracking"
+    desc 'stop', 'stop time tracking'
     def stop
       stop = Time.now.to_i
       @db.update(stop) if @db.last_item_status == :incomplete
@@ -30,19 +33,21 @@ module Timet
       summary
     end
 
-    desc "resume (r)", "resume last task"
+    desc 'resume (r)', 'resume last task'
     def resume
       if @db.last_item_status == :incomplete
-        puts "A task is currently being tracked."
-      else
-        last_task = @db.last_item&.last
-        start last_task if last_task
+        puts 'A task is currently being tracked.'
+      elsif @db.last_item.any?
+        tag = @db.last_item[3]
+        notes = @db.last_item[4]
+        start(tag, notes)
       end
     end
 
-    desc "summary (su) [filter] [tag] --csv=csv_filename",
-         "Display a summary of tracked time filter => [today (t), yesterday (y), week (w), month (m)] [tag] and export to csv_filename"
-    option :csv, type: :string, desc: "Export to CSV file"
+    desc 'summary (su) [filter] [tag] --csv=csv_filename',
+         "Display a summary of tracked time filter => [today (t), yesterday (y), week (w), month (m)] [tag]
+          and export to csv_filename"
+    option :csv, type: :string, desc: 'Export to CSV file'
     def summary(filter = nil, tag = nil)
       csv_filename = options[:csv]
       summary = TimeReport.new(@db, filter, tag, csv_filename)
@@ -50,21 +55,21 @@ module Timet
       summary.export_sheet if csv_filename
     end
 
-    desc "delete (d) [id]", "delete a task"
+    desc 'delete (d) [id]', 'delete a task'
     def delete(id)
       item = @db.find_item(id)
       return puts "No tracked time found for id: #{id}" unless item
 
-      TimeReport.new(@db, nil, nil).row(item)
-      return unless TTY::Prompt.new.yes?("Are you sure you want to delete this entry?")
+      TimeReport.new(@db, nil, nil, nil).show_row(item)
+      return unless TTY::Prompt.new.yes?('Are you sure you want to delete this entry?')
 
       delete_item_and_print_message(id, "Deleted #{id}")
     end
 
-    desc "cancel (c)", "cancel active time tracking"
+    desc 'cancel (c)', 'cancel active time tracking'
     def cancel
       id = @db.fetch_last_id
-      return puts "There is no active time tracking" if @db.last_item_status == :complete
+      return puts 'There is no active time tracking' if @db.last_item_status == :complete
 
       delete_item_and_print_message(id, "Canceled active time tracking #{id}")
     end

data/lib/timet/database.rb

@@ -1,15 +1,16 @@
 # frozen_string_literal: true
 
-require "sqlite3"
+require 'sqlite3'
 
 module Timet
   # Provides database access for managing time tracking data.
   class Database
-    DEFAULT_DATABASE_PATH = File.join(Dir.home, ".timet.db")
+    DEFAULT_DATABASE_PATH = File.join(Dir.home, '.timet.db')
 
     def initialize(database_path = DEFAULT_DATABASE_PATH)
       @db = SQLite3::Database.new(database_path)
       create_table
+      add_notes
     end
 
     # Creates the items table if it doesn't already exist
@@ -24,9 +25,21 @@ module Timet
       SQL
     end
 
+    # Adds a new column named "notes" to the "items" table if it doesn't exist.
+    def add_notes
+      table_name = 'items'
+      new_column_name = 'notes'
+      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
+
+      execute_sql("ALTER TABLE #{table_name} ADD COLUMN #{new_column_name} TEXT")
+      puts "Column '#{new_column_name}' added to table '#{table_name}'."
+    end
+
     # Inserts a new item into the items table
-    def insert_item(start, tag)
-      execute_sql("INSERT INTO items (start, tag) VALUES (?, ?)", [start, tag])
+    def insert_item(start, tag, notes)
+      execute_sql('INSERT INTO items (start, tag, notes) VALUES (?, ?, ?)', [start, tag, notes])
     end
 
     # Updates the end time of the last item
@@ -34,7 +47,7 @@ module Timet
       last_id = fetch_last_id
       return unless last_id
 
-      execute_sql("UPDATE items SET end = ? WHERE id = ?", [stop, last_id])
+      execute_sql('UPDATE items SET end = ? WHERE id = ?', [stop, last_id])
     end
 
     def delete_item(id)
@@ -43,16 +56,16 @@ module Timet
 
     # Fetches 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 = execute_sql('SELECT id FROM items ORDER BY id DESC LIMIT 1').first
       result ? result[0] : nil
     end
 
     def last_item
-      execute_sql("SELECT * FROM items ORDER BY id DESC LIMIT 1").first
+      execute_sql('SELECT * FROM items ORDER BY id DESC LIMIT 1').first
     end
 
     def last_item_status
-      result = execute_sql("SELECT id, end FROM items ORDER BY id DESC LIMIT 1")
+      result = execute_sql('SELECT id, end FROM items ORDER BY id DESC LIMIT 1')
       StatusHelper.determine_status(result)
     end
 
@@ -62,8 +75,8 @@ module Timet
 
     # Calculates the total time elapsed since the last recorded time.
     def total_time
-      last_item = execute_sql("SELECT * FROM items ORDER BY id DESC LIMIT 1").first
-      return "00:00:00" unless last_item
+      last_item = execute_sql('SELECT * FROM items ORDER BY id DESC LIMIT 1').first
+      return '00:00:00' unless last_item
 
       start_time = last_item[1]
       end_time = last_item[2]
@@ -94,7 +107,7 @@ module Timet
       hours, remainder = seconds.divmod(3600)
       minutes, seconds = remainder.divmod(60)
 
-      format "%<hours>02d:%<minutes>02d:%<seconds>02d", hours: hours, minutes: minutes, seconds: seconds
+      format '%<hours>02d:%<minutes>02d:%<seconds>02d', hours: hours, minutes: minutes, seconds: seconds
     end
   end
 end

data/lib/timet/time_helper.rb

@@ -7,7 +7,15 @@
 # - converting a Date object to a timestamp
 module TimeHelper
   def self.format_time(timestamp)
-    timestamp&.then { |time| Time.at(time).strftime("%Y-%m-%d %H:%M:%S").ljust(19) }
+    timestamp&.then { |time| Time.at(time).strftime('%Y-%m-%d %H:%M:%S').ljust(19) }
+  end
+
+  def self.timestamp_to_date(timestamp)
+    timestamp&.then { |time| Time.at(time).strftime('%Y-%m-%d') }
+  end
+
+  def self.timestamp_to_time(timestamp)
+    timestamp&.then { |time| Time.at(time).strftime('%H:%M:%S') }
   end
 
   def self.calculate_duration(start_time, end_time)

data/lib/timet/time_report.rb

@@ -1,9 +1,9 @@
 # frozen_string_literal: true
 
-require "date"
-require "csv"
-require_relative "time_helper"
-require_relative "status_helper"
+require 'date'
+require 'csv'
+require_relative 'time_helper'
+require_relative 'status_helper'
 
 module Timet
   # The TimeReport class is responsible for displaying a report of tracked time
@@ -15,21 +15,23 @@ module Timet
     def initialize(db, filter, tag, csv)
       @db = db
       @filename = csv
-      @items = filter ? filter_items(filter, tag) : @db.all_items
+      @filter = formatted_filter(filter)
+      @items = filter ? filter_items(@filter, tag) : @db.all_items
     end
 
     def display
-      return puts "No tracked time found for the specified filter." if items.empty?
+      return puts 'No tracked time found for the specified filter.' if items.empty?
 
       format_table_header
-      items.each do |item|
-        display_time_entry(item)
+      items.each_with_index do |item, idx|
+        date = extract_date(items, idx)
+        display_time_entry(item, date)
       end
       puts format_table_separator
       total
     end
 
-    def row(item)
+    def show_row(item)
       format_table_header
       display_time_entry(item)
       puts format_table_separator
@@ -37,75 +39,83 @@ module Timet
     end
 
     def export_sheet
-      header = %w[ID Start End Tag]
-
-      CSV.open("#{filename}.csv", "w") do |csv|
-        csv << header
-
-        items.each do |row|
-          # Convert start and end times from timestamps to ISO 8601 format
-          start_time = Time.at(row[1]).strftime("%Y-%m-%d %H:%M:%S")
-          end_time = Time.at(row[2]).strftime("%Y-%m-%d %H:%M:%S")
-
-          # Write the row with formatted times
-          csv << [row[0], start_time, end_time, row[3]]
+      CSV.open("#{filename}.csv", 'w') do |csv|
+        csv << %w[ID Start End Tag Notes]
+
+        items.each do |id, start_time, end_time, tags, notes|
+          csv << [
+            id,
+            TimeHelper.format_time(start_time),
+            TimeHelper.format_time(end_time),
+            tags,
+            notes
+          ]
         end
       end
     end
 
     private
 
-    def display_time_entry(item)
-      return puts "Missing time entry data." unless item
+    def extract_date(items, idx)
+      current_start_date = items[idx][1]
+      date = TimeHelper.timestamp_to_date(current_start_date)
+
+      last_start_date = items[idx - 1][1]
+      date if idx.zero? || date != TimeHelper.timestamp_to_date(last_start_date)
+    end
+
+    def display_time_entry(item, date = nil)
+      return puts 'Missing time entry data.' unless item
 
-      id, start_time_value, end_time_value, tag_name = item
+      id, start_time_value, end_time_value, tag_name, notes = item
       duration = TimeHelper.calculate_duration(start_time_value, end_time_value)
       start_time = TimeHelper.format_time(start_time_value)
-      end_time = TimeHelper.format_time(end_time_value) || "-".rjust(19)
-      puts format_table_row(id, tag_name[0..5], start_time, end_time, duration)
+      end_time = TimeHelper.format_time(end_time_value) || '- -'
+      start_date = date.nil? ? ' ' * 10 : date
+      puts format_table_row(id, tag_name[0..5], start_date, start_time, end_time, duration, notes)
     end
 
     def total
       total = @items.map do |item|
         TimeHelper.calculate_duration(item[1], item[2])
       end.sum
-      puts "|#{" " * 52}\033[94mTotal:  | #{@db.seconds_to_hms(total).rjust(10)} |\033[0m"
+      puts "|#{' ' * 43}\033[94mTotal:  | #{@db.seconds_to_hms(total).rjust(8)} |\033[0m                          |"
       puts format_table_separator
     end
 
     def format_table_header
       header = <<~TABLE
-        Tracked time report:
+        Tracked time report \u001b[31m[#{@filter}]\033[0m:
         #{format_table_separator}
-        \033[32m| Id    | Tag    | Start Time          | End Time            | Duration   |\033[0m
+        \033[32m| Id    | Date       | Tag    | Start    | End      | Duration | Notes                    |\033[0m
         #{format_table_separator}
       TABLE
       puts header
     end
 
     def format_table_separator
-      "+-------+--------+---------------------+---------------------+------------+"
+      '+-------+------------+--------+----------+----------+----------+--------------------------+'
     end
 
     def format_table_row(*row)
-      id, tag, start_time, end_time, duration = row
-      "| #{id.to_s.rjust(5)} | #{tag.ljust(6)} | #{start_time} | #{end_time} | " \
-        "#{@db.seconds_to_hms(duration).rjust(10)} |"
+      id, tag, start_date, start_time, end_time, duration, notes = row
+      "| #{id.to_s.rjust(5)} | #{start_date} | #{tag.ljust(6)} | #{start_time.split[1]} | " \
+        "#{end_time.split[1].rjust(8)} | #{@db.seconds_to_hms(duration).rjust(8)} | #{format_notes(notes)}  |"
     end
 
     def filter_items(filter, tag)
       today = Date.today
       case filter
-      when "today", "t"
+      when 'today'
         filter_by_date_range(today, nil, tag)
-      when "yesterday", "y"
+      when 'yesterday'
         filter_by_date_range(today - 1, nil, tag)
-      when "week", "w"
+      when 'week'
         filter_by_date_range(today - 7, today + 1, tag)
-      when "month", "m"
+      when 'month'
         filter_by_date_range(today - 30, today + 1, tag)
       else
-        puts "Invalid filter. Supported filters: today, yesterday, week"
+        puts 'Invalid filter. Supported filters: today, yesterday, week'
         []
       end
     end
@@ -118,5 +128,21 @@ module Timet
         "select * from items where #{query} ORDER BY id DESC"
       )
     end
+
+    def format_notes(notes)
+      return ' ' * 23 if notes.nil?
+
+      notes = "#{notes.slice(0, 20)}..." if notes.length > 20
+      notes.ljust(23)
+    end
+
+    def formatted_filter(filter)
+      return 'today' if %w[today t].include?(filter)
+      return 'yesterday' if %w[yesterday y].include?(filter)
+      return 'week' if %w[week w].include?(filter)
+      return 'month' if %w[month m].include?(filter)
+
+      'today'
+    end
   end
 end

data/lib/timet/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Timet
-  VERSION = "0.1.0"
+  VERSION = '0.2.1'
 end

data/lib/timet.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
-require_relative "timet/application"
-require_relative "timet/database"
-require_relative "timet/time_report"
+require_relative 'timet/application'
+require_relative 'timet/database'
+require_relative 'timet/time_report'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: timet
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.1
 platform: ruby
 authors:
 - Frank Vielma
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-09-22 00:00:00.000000000 Z
+date: 2024-09-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: thor
@@ -84,11 +84,11 @@ files:
 - lib/timet/time_report.rb
 - lib/timet/version.rb
 - sig/timet.rbs
-homepage: https://github.com/frankvielma/timet/blob/main/README.md
+homepage: https://frankvielma.github.io/posts/timet-a-powerful-command-line-tool-for-tracking-your-time/
 licenses:
 - MIT
 metadata:
-  homepage_uri: https://github.com/frankvielma/timet/blob/main/README.md
+  homepage_uri: https://frankvielma.github.io/posts/timet-a-powerful-command-line-tool-for-tracking-your-time/
   source_code_uri: https://github.com/frankvielma/timet
   changelog_uri: https://github.com/frankvielma/timet/blob/main/CHANGELOG.md
   rubygems_mfa_required: 'true'
@@ -107,7 +107,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.3
+rubygems_version: 3.5.9
 signing_key:
 specification_version: 4
 summary: Command line time tracking with reports