fewald-worklog 0.2.19 → 0.2.21

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e2bd1127e65b1c43b9ae95773b29d5648818940b44cfa82be0e69741148f3b16
-  data.tar.gz: e30b8828d79177651e0179a2a7ec915fd03075de857e47280eaaec8bf682b8b4
+  metadata.gz: a799c589dedc9f7ed68ef9b2acfd8ad08e29f3fb5f3a26d0a90dee1320ee164e
+  data.tar.gz: 9e38d05b4303b41cf7ae2016d23990290ef2b41eba34db9b8c53f4a7587a84d2
 SHA512:
-  metadata.gz: 05f0bc3f9acd0ebe71b8fd78608c4227c0a54c6b54c711fb657eaa6d1ce24e952bf8e37785327745cfb100a8574705d1441b12110fed80b6103f24b2532761aa
-  data.tar.gz: 31130d1928c6420c7c681d796189ccfc696875e92befb981463034d3d12c299f6aaab0ef3634c87fa787311e0042e3ff2cb8232be0db6a759505753446a998aa
+  metadata.gz: a9cc6c2ef435e43390491c2d31793c4e2ae8febd54bdd68ea535decb109defd70538bdaaaa1dc70d660c0f1193e9786d4bab66cf1a0619bf5166146b1c8eb95c
+  data.tar.gz: aa43dfa148848d4161a791105934e36c9caf21929d4e978e3b20468fe076b288b555137cf7b74f06fb17157f9312fcc40050894e494c176334679d61033fa198

data/.version

@@ -1 +1 @@
-0.2.19
+0.2.21

data/lib/cli.rb

@@ -31,7 +31,7 @@ class WorklogCLI < Thor
   # Initialize the CLI with the given arguments, options, and configuration
   def initialize(args = [], options = {}, config = {})
     @config = Worklog::Configuration.load
-    @storage = Storage.new(@config)
+    @storage = Worklog::Storage.new(@config)
     super
   end
 

data/lib/daily_log.rb

@@ -2,52 +2,54 @@
 
 require 'hash'
 
-# DailyLog is a container for a day's work log.
-class DailyLog
-  # Container for a day's work log.
-  include Hashify
-
-  # Represents a single day's work log.
-  attr_accessor :date, :entries
-
-  def initialize(params = {})
-    @date = params[:date]
-    @entries = params[:entries]
-  end
-
-  # Returns true if there are people mentioned in any entry of the current day.
-  #
-  # @return [Boolean] true if there are people mentioned, false otherwise.
-  def people?
-    people.size.positive?
-  end
-
-  # Returns a hash of people mentioned in the log for the current day
-  # with the number of times they are mentioned.
-  # People are defined as words starting with @ or ~.
-  #
-  # @return [Hash<String, Integer>]
-  def people
-    entries.map { |entry| entry.people.to_a }.flatten.tally
-  end
-
-  # Returns a sorted list of tags used in the entries for the current day.
-  #
-  # @return [Array<String>]
-  #
-  # @example
-  #   log = DailyLog.new(date: Date.today,
-  #                      entries: [LogEntry.new(message: "Work on something", tags: ['work', 'project'])])
-  #   log.tags # => ["project", "work"]
-  def tags
-    entries.flat_map(&:tags).uniq.sort
-  end
-
-  # Equals method to compare two DailyLog objects.
-  #
-  # @param other [DailyLog] the other DailyLog object to compare with
-  # @return [Boolean] true if both DailyLog objects have the same date and entries, false otherwise
-  def ==(other)
-    date == other.date && entries == other.entries
+module Worklog
+  # DailyLog is a container for a day's work log.
+  class DailyLog
+    # Container for a day's work log.
+    include Hashify
+
+    # Represents a single day's work log.
+    attr_accessor :date, :entries
+
+    def initialize(params = {})
+      @date = params[:date]
+      @entries = params[:entries]
+    end
+
+    # Returns true if there are people mentioned in any entry of the current day.
+    #
+    # @return [Boolean] true if there are people mentioned, false otherwise.
+    def people?
+      people.size.positive?
+    end
+
+    # Returns a hash of people mentioned in the log for the current day
+    # with the number of times they are mentioned.
+    # People are defined as words starting with @ or ~.
+    #
+    # @return [Hash<String, Integer>]
+    def people
+      entries.map { |entry| entry.people.to_a }.flatten.tally
+    end
+
+    # Returns a sorted list of tags used in the entries for the current day.
+    #
+    # @return [Array<String>]
+    #
+    # @example
+    #   log = DailyLog.new(date: Date.today,
+    #                      entries: [LogEntry.new(message: "Work on something", tags: ['work', 'project'])])
+    #   log.tags # => ["project", "work"]
+    def tags
+      entries.flat_map(&:tags).uniq.sort
+    end
+
+    # Equals method to compare two DailyLog objects.
+    #
+    # @param other [DailyLog] the other DailyLog object to compare with
+    # @return [Boolean] true if both DailyLog objects have the same date and entries, false otherwise
+    def ==(other)
+      date == other.date && entries == other.entries
+    end
   end
 end

data/lib/log_entry.rb

@@ -5,95 +5,117 @@ require 'rainbow'
 require 'daily_log'
 require 'hash'
 
-# A single log entry.
-class LogEntry
-  PERSON_REGEX = /(?:\s|^)[~@](\w+)/
-
-  include Hashify
-
-  # Represents a single entry in the work log.
-  attr_accessor :time, :tags, :ticket, :url, :epic, :message, :project
-
-  attr_reader :day
-
-  def initialize(params = {})
-    @time = params[:time]
-    # If tags are nil, set to empty array.
-    # This is similar to the CLI default value.
-    @tags = params[:tags] || []
-    @ticket = params[:ticket]
-    @url = params[:url] || ''
-    @epic = params[:epic]
-    @message = params[:message]
-    @project = params[:project]
-
-    # Back reference to the day
-    @day = params[:day] || nil
-  end
+module Worklog
+  # A single log entry in a DailyLog.
+  # @see DailyLog
+  # @!attribute [rw] time
+  #   @return [DateTime] the date and time of the log entry.
+  # @!attribute [rw] tags
+  #   @return [Array<String>] the tags associated with the log entry.
+  # @!attribute [rw] ticket
+  #   @return [String] the ticket associated with the log entry.
+  # @!attribute [rw] url
+  #   @return [String] the URL associated with the log entry.
+  # @!attribute [rw] epic
+  #   @return [Boolean] whether the log entry is an epic.
+  # @!attribute [rw] message
+  #   @return [String] the message of the log entry.
+  # @!attribute [rw] project
+  #   @return [String] the project associated with the log entry.
+  class LogEntry
+    PERSON_REGEX = /(?:\s|^)[~@](\w+)/
+
+    include Hashify
+
+    attr_accessor :time, :tags, :ticket, :url, :epic, :message, :project
+
+    attr_reader :day
+
+    def initialize(params = {})
+      @time = params[:time]
+      # If tags are nil, set to empty array.
+      # This is similar to the CLI default value.
+      @tags = params[:tags] || []
+      @ticket = params[:ticket]
+      @url = params[:url] || ''
+      @epic = params[:epic]
+      @message = params[:message]
+      @project = params[:project]
+
+      # Back reference to the day
+      @day = params[:day] || nil
+    end
 
-  # Returns true if the entry is an epic, false otherwise.
-  def epic?
-    @epic == true
-  end
+    # Returns true if the entry is an epic, false otherwise.
+    # @return [Boolean]
+    def epic?
+      @epic == true
+    end
 
-  # Returns the message string with formatting without the time.
-  # @param known_people Hash[String, Person] A hash of people with their handles as keys.
-  def message_string(known_people = nil)
-    # replace all mentions of people with their names.
-    msg = @message.dup
-    people.each do |person|
-      next unless known_people && known_people[person]
-
-      msg.gsub!(/[~@]#{person}/) do |match|
-        s = ''
-        s += ' ' if match[0] == ' '
-        s += "#{Rainbow(known_people[person].name).underline} (~#{person})" if known_people && known_people[person]
-        s
+    # Returns the message string with formatting without the time.
+    # @param known_people Hash[String, Person] A hash of people with their handles as keys.
+    def message_string(known_people = nil)
+      # replace all mentions of people with their names.
+      msg = @message.dup
+      people.each do |person|
+        next unless known_people && known_people[person]
+
+        msg.gsub!(/[~@]#{person}/) do |match|
+          s = ''
+          s += ' ' if match[0] == ' '
+          s += "#{Rainbow(known_people[person].name).underline} (~#{person})" if known_people && known_people[person]
+          s
+        end
       end
-    end
 
-    s = ''
+      s = ''
 
-    s += if epic
-           Rainbow("[EPIC] #{msg}").bg(:white).fg(:black)
-         else
-           msg
-         end
+      s += if epic
+             Rainbow("[EPIC] #{msg}").bg(:white).fg(:black)
+           else
+             msg
+           end
 
-    s += "  [#{Rainbow(@ticket).fg(:blue)}]" if @ticket
+      s += "  [#{Rainbow(@ticket).fg(:blue)}]" if @ticket
 
-    # Add tags in brackets if defined.
-    s += '  [' + @tags.map { |tag| "#{tag}" }.join(', ') + ']' if @tags && @tags.size > 0
+      # Add tags in brackets if defined.
+      s += '  [' + @tags.map { |tag| "#{tag}" }.join(', ') + ']' if @tags && @tags.size > 0
 
-    # Add URL in brackets if defined.
-    s += "  [#{@url}]" if @url && @url != ''
+      # Add URL in brackets if defined.
+      s += "  [#{@url}]" if @url && @url != ''
 
-    s += "  [#{@project}]" if @project && @project != ''
+      s += "  [#{@project}]" if @project && @project != ''
 
-    s
-  end
+      s
+    end
 
-  def people
-    # Return people that are mentioned in the entry. People are defined as character sequences
-    # starting with @ or ~. Whitespaces are used to separate people. Punctuation is ignored.
-    # Empty set if no people are mentioned.
-    # @return [Set<String>]
-    @message.scan(PERSON_REGEX).flatten.uniq.sort.to_set
-  end
+    def people
+      # Return people that are mentioned in the entry. People are defined as character sequences
+      # starting with @ or ~. Whitespaces are used to separate people. Punctuation is ignored.
+      # Empty set if no people are mentioned.
+      # @return [Set<String>]
+      @message.scan(PERSON_REGEX).flatten.uniq.sort.to_set
+    end
 
-  def people?
     # Return true if there are people in the entry.
     #
     # @return [Boolean]
-    people.size.positive?
-  end
+    def people?
+      people.size.positive?
+    end
 
-  def to_yaml
-    to_hash.to_yaml
-  end
+    # Convert the log entry to YAML format.
+    def to_yaml
+      to_hash.to_yaml
+    end
 
-  def ==(other)
-    time == other.time && tags == other.tags && ticket == other.ticket && url == other.url &&
-      epic == other.epic && message == other.message
+    # Compare two log entries for equality.
+    #
+    # @param other [LogEntry] The other log entry to compare against.
+    # @return [Boolean] True if the log entries are equal, false otherwise.
+    def ==(other)
+      time == other.time && tags == other.tags && ticket == other.ticket && url == other.url &&
+        epic == other.epic && message == other.message
+    end
   end
 end

data/lib/printer.rb

@@ -9,7 +9,7 @@ class Printer
   # Initializes the printer with a list of people.
   # @param people [Array<Person>] An array of Person objects.
   def initialize(people = nil)
-    @people = (people || []).to_h { |person| [person.handle, person] }
+    @people = people || {}
   end
 
   # Prints a whole day of work log entries.

data/lib/project.rb

@@ -17,10 +17,18 @@ module Worklog
   #   @return [String, nil] The status of the project, can be nil
   #   Possible values: 'active', 'completed', 'archived', etc.
   #   Indicates the current state of the project.
+  # @!attribute [rw] entries
+  #   These entries are related to the work done on this project.
+  #   Entries are populated dynamically when processing daily logs.
+  #   They are not stored in the project itself.
+  #   @return [Array<LogEntry>] An array of log entries associated with the project.
   # @!attribute [rw] last_activity
-  #  @return [Date, nil] The last activity date or nil if not set.
+  #   The last activity is not stored in the project itself.
+  #   Instead, it is updated dynamically when processing daily logs.
+  #   It represents the most recent log entry time for this project.
+  #   @return [Date, nil] The last activity date or nil if not set.
   class Project
-    attr_accessor :key, :name, :description, :start_date, :end_date, :status, :last_activity
+    attr_accessor :key, :name, :description, :start_date, :end_date, :status, :entries, :last_activity
 
     # Creates a new Project instance from a hash of attributes.
     # @param hash [Hash] A hash containing project attributes

data/lib/statistics.rb

@@ -10,7 +10,7 @@ class Statistics
   # Initialize the Statistics class.
   def initialize(config)
     @config = config
-    @storage = Storage.new(config)
+    @storage = Worklog::Storage.new(config)
   end
 
   # Calculate statistics for the work log for all days.

data/lib/storage.rb

@@ -6,176 +6,186 @@ require 'log_entry'
 require 'worklogger'
 require 'person'
 
-# Handles storage of daily logs and people
-class Storage
-  # LogNotFoundError is raised when a log file is not found
-  class LogNotFoundError < StandardError; end
+# Alias for classes to handle existing log entries
+DailyLog = Worklog::DailyLog
+LogEntry = Worklog::LogEntry
 
-  FILE_SUFFIX = '.yaml'
+module Worklog
+  # Handles storage of daily logs and people
+  class Storage
+    # LogNotFoundError is raised when a log file is not found
+    class LogNotFoundError < StandardError; end
 
-  # Regular expression to match daily log file names
-  LOG_PATTERN = /\d{4}-\d{2}-\d{2}#{FILE_SUFFIX}\z/
+    FILE_SUFFIX = '.yaml'
 
-  def initialize(config)
-    @config = config
-  end
+    # Regular expression to match daily log file names
+    LOG_PATTERN = /\d{4}-\d{2}-\d{2}#{FILE_SUFFIX}\z/
 
-  def folder_exists?
-    Dir.exist?(@config.storage_path)
-  end
+    def initialize(config)
+      @config = config
+    end
 
-  # Return all logs for all available days
-  # @return [Array<DailyLog>] List of all logs
-  def all_days
-    return [] unless folder_exists?
+    def folder_exists?
+      Dir.exist?(@config.storage_path)
+    end
 
-    logs = []
-    Dir.glob(File.join(@config.storage_path, "*#{FILE_SUFFIX}")).map do |file|
-      next unless file.match?(LOG_PATTERN)
+    # Return all logs for all available days
+    # @return [Array<DailyLog>] List of all logs
+    def all_days
+      return [] unless folder_exists?
 
-      logs << load_log(file)
-    end
+      logs = []
+      Dir.glob(File.join(@config.storage_path, "*#{FILE_SUFFIX}")).map do |file|
+        next unless file.match?(LOG_PATTERN)
 
-    logs
-  end
+        logs << load_log(file)
+      end
+
+      logs
+    end
 
-  # Return all tags as a set
-  # @return [Set<String>] Set of all tags
-  def tags
-    logs = all_days
-    tags = Set[]
-    logs.each do |log|
-      log.entries.each do |entry|
-        next unless entry.tags
-
-        entry.tags.each do |tag|
-          tags << tag
+    # Return all tags as a set
+    # @return [Set<String>] Set of all tags
+    def tags
+      logs = all_days
+      tags = Set[]
+      logs.each do |log|
+        log.entries.each do |entry|
+          next unless entry.tags
+
+          entry.tags.each do |tag|
+            tags << tag
+          end
         end
       end
+      tags
     end
-    tags
-  end
 
-  # Return days between start_date and end_date
-  # If end_date is nil, return logs from start_date to today
-  #
-  # @param [Date] start_date The start date, inclusive
-  # @param [Date] end_date The end date, inclusive
-  # @param [Boolean] epics_only If true, only return logs with epic entries
-  # @param [Array<String>] tags_filter If provided, only return logs with entries that have at least one of the tags
-  # @return [Array<DailyLog>] List of logs
-  def days_between(start_date, end_date = nil, epics_only = nil, tags_filter = nil)
-    return [] unless folder_exists?
-
-    logs = []
-    end_date = Date.today if end_date.nil?
-
-    return [] if start_date > end_date
-
-    while start_date <= end_date
-      if File.exist?(filepath(start_date))
-        tmp_logs = load_log!(filepath(start_date))
-        tmp_logs.entries.keep_if { |entry| entry.epic? } if epics_only
-
-        if tags_filter
-          # Safeguard against entries without any tags, not just empty array
-          tmp_logs.entries.keep_if { |entry| entry.tags && (entry.tags & tags_filter).size > 0 }
+    # Return days between start_date and end_date
+    # If end_date is nil, return logs from start_date to today
+    #
+    # @param [Date] start_date The start date, inclusive
+    # @param [Date] end_date The end date, inclusive
+    # @param [Boolean] epics_only If true, only return logs with epic entries
+    # @param [Array<String>] tags_filter If provided, only return logs with entries that have at least one of the tags
+    # @return [Array<DailyLog>] List of logs
+    def days_between(start_date, end_date = nil, epics_only = nil, tags_filter = nil)
+      return [] unless folder_exists?
+
+      logs = []
+      end_date = Date.today if end_date.nil?
+
+      return [] if start_date > end_date
+
+      while start_date <= end_date
+        if File.exist?(filepath(start_date))
+          tmp_logs = load_log!(filepath(start_date))
+          tmp_logs.entries.keep_if { |entry| entry.epic? } if epics_only
+
+          if tags_filter
+            # Safeguard against entries without any tags, not just empty array
+            tmp_logs.entries.keep_if { |entry| entry.tags && (entry.tags & tags_filter).size > 0 }
+          end
+
+          logs << tmp_logs if tmp_logs.entries.length > 0
         end
 
-        logs << tmp_logs if tmp_logs.entries.length > 0
+        start_date += 1
       end
+      logs
+    end
 
-      start_date += 1
+    # Create file for a new day if it does not exist
+    # @param [Date] date The date, used as the file name.
+    def create_file_skeleton(date)
+      File.write(filepath(date), YAML.dump(DailyLog.new(date:, entries: []))) unless File.exist?(filepath(date))
     end
-    logs
-  end
 
-  # Create file for a new day if it does not exist
-  # @param [Date] date The date, used as the file name.
-  def create_file_skeleton(date)
-    File.write(filepath(date), YAML.dump(DailyLog.new(date:, entries: []))) unless File.exist?(filepath(date))
-  end
+    def load_log(file)
+      load_log!(file)
+    rescue LogNotFoundError
+      WorkLogger.error "No work log found for #{file}. Aborting."
+      nil
+    end
 
-  def load_log(file)
-    load_log!(file)
-  rescue LogNotFoundError
-    WorkLogger.error "No work log found for #{file}. Aborting."
-    nil
-  end
+    def load_log!(file)
+      WorkLogger.debug "Loading file #{file}"
+
+      # Alias DailyLog to Worklog::DailyLog
 
-  def load_log!(file)
-    WorkLogger.debug "Loading file #{file}"
-    begin
-      log = YAML.load_file(file, permitted_classes: [Date, Time, DailyLog, LogEntry])
-      log.entries.each do |entry|
-        entry.time = Time.parse(entry.time) unless entry.time.respond_to?(:strftime)
+      begin
+        log = YAML.load_file(file, permitted_classes: [Date, Time, DailyLog, LogEntry])
+        log.entries.each do |entry|
+          entry.time = Time.parse(entry.time) unless entry.time.respond_to?(:strftime)
+        end
+        log
+      rescue Errno::ENOENT
+        raise LogNotFoundError
       end
-      log
-    rescue Errno::ENOENT
-      raise LogNotFoundError
     end
-  end
 
-  def write_log(file, daily_log)
-    WorkLogger.debug "Writing to file #{file}"
+    def write_log(file, daily_log)
+      WorkLogger.debug "Writing to file #{file}"
 
-    File.open(file, 'w') do |f|
-      f.puts daily_log.to_yaml
+      File.open(file, 'w') do |f|
+        f.puts daily_log.to_yaml
+      end
     end
-  end
 
-  def load_single_log_file(file, headline = true)
-    daily_log = load_log!(file)
-    puts "Work log for #{Rainbow(daily_log.date).gold}:" if headline
-    daily_log.entries
-  end
+    # Load a single log file and return its entries
+    def load_single_log_file(file, headline = true)
+      daily_log = load_log!(file)
+      puts "Work log for #{Rainbow(daily_log.date).gold}:" if headline
+      daily_log.entries
+    end
 
-  # Load all people from the people file, or return an empty array if the file does not exist
-  #
-  # @return [Array<Person>] List of people
-  def load_people
-    load_people!
-  rescue Errno::ENOENT
-    WorkLogger.info 'Unable to load people.'
-    []
-  end
+    # Load all people from the people file, or return an empty array if the file does not exist
+    #
+    # @return [Array<Person>] List of people
+    def load_people
+      load_people!
+    rescue Errno::ENOENT
+      WorkLogger.info 'Unable to load people.'
+      []
+    end
 
-  # Load all people from the people file and return them as a hash with handle as key
-  # @return [Hash<String, Person>] Hash of people with handle as key
-  def load_people_hash
-    load_people.to_h { |person| [person.handle, person] }
-  end
+    # Load all people from the people file and return them as a hash with handle as key
+    # @return [Hash<String, Person>] Hash of people with handle as key
+    def load_people_hash
+      load_people.to_h { |person| [person.handle, person] }
+    end
 
-  # Load all people from the people file
-  # @return [Array<Person>] List of people
-  def load_people!
-    people_file = File.join(@config.storage_path, 'people.yaml')
-    return [] unless File.exist?(people_file)
+    # Load all people from the people file
+    # @return [Array<Person>] List of people
+    def load_people!
+      people_file = File.join(@config.storage_path, 'people.yaml')
+      return [] unless File.exist?(people_file)
 
-    YAML.load_file(people_file, permitted_classes: [Person])
-  end
+      YAML.load_file(people_file, permitted_classes: [Person])
+    end
 
-  # Write people to the people file
-  # @param [Array<Person>] people List of people
-  def write_people!(people)
-    people_file = File.join(@config.storage_path, 'people.yaml')
-    File.open(people_file, 'w') do |f|
-      f.puts people.to_yaml
+    # Write people to the people file
+    # @param [Array<Person>] people List of people
+    def write_people!(people)
+      people_file = File.join(@config.storage_path, 'people.yaml')
+      File.open(people_file, 'w') do |f|
+        f.puts people.to_yaml
+      end
     end
-  end
 
-  # Create folder if not exists already.
-  def create_default_folder
-    # Do nothing if the storage path is not the default path
-    return unless @config.default_storage_path?
+    # Create folder if not exists already.
+    def create_default_folder
+      # Do nothing if the storage path is not the default path
+      return unless @config.default_storage_path?
 
-    Dir.mkdir(@config.storage_path) unless Dir.exist?(@config.storage_path)
-  end
+      Dir.mkdir(@config.storage_path) unless Dir.exist?(@config.storage_path)
+    end
 
-  # Construct filepath for a given date.
-  # @param [Date] date The date
-  # @return [String] The filepath
-  def filepath(date)
-    File.join(@config.storage_path, "#{date}#{FILE_SUFFIX}")
+    # Construct filepath for a given date.
+    # @param [Date] date The date
+    # @return [String] The filepath
+    def filepath(date)
+      File.join(@config.storage_path, "#{date}#{FILE_SUFFIX}")
+    end
   end
 end

data/lib/worklog.rb

@@ -54,6 +54,9 @@ module Worklog
     # Bootstrap the worklog application.
     def bootstrap
       @storage.create_default_folder
+
+      # Load all people as they're used in multiple/most of the methods.
+      @people = @storage.load_people_hash
     end
 
     # Add new entry to the work log.
@@ -89,8 +92,7 @@ module Worklog
 
       @storage.write_log(@storage.filepath(options[:date]), daily_log)
 
-      people_hash = @storage.load_people_hash
-      (new_entry.people - people_hash.keys).each do |handle|
+      (new_entry.people - @people.keys).each do |handle|
         WorkLogger.warn "Person with handle #{handle} not found. Consider adding them to people.yaml"
       end
 
@@ -130,8 +132,7 @@ module Worklog
     #   worklog.show(from: '2023-10-01', to: '2023-10-31')
     #   worklog.show(date: '2023-10-01')
     def show(options = {})
-      people = @storage.load_people!
-      printer = Printer.new(people)
+      printer = Printer.new(@people)
 
       start_date, end_date = start_end_date(options)
 
@@ -145,17 +146,16 @@ module Worklog
       end
     end
 
+    # Show all known people and details about a specific person.
     def people(person = nil, _options = {})
-      all_people = @storage.load_people!
-      people_map = all_people.to_h { |p| [p.handle, p] }
       all_logs = @storage.all_days
 
       if person
-        unless people_map.key?(person)
+        unless @people.key?(person)
           WorkLogger.error Rainbow("No person found with handle #{person}.").red
           return
         end
-        person_detail(all_logs, all_people, people_map[person.strip])
+        person_detail(all_logs, @people, @people[person.strip])
       else
         puts 'People mentioned in the work log:'
 
@@ -169,8 +169,8 @@ module Worklog
         mentions = mentions.to_a.sort_by { |handle, _| handle }
 
         mentions.each do |handle, v|
-          if people_map.key?(handle)
-            person = people_map[handle]
+          if @people.key?(handle)
+            person = @people[handle]
             print "#{Rainbow(person.name).gold} (#{handle})"
             print " (#{person.team})" if person.team
           else
@@ -203,13 +203,43 @@ module Worklog
     def projects(_options = {})
       project_storage = ProjectStorage.new(@config)
       projects = project_storage.load_projects
-      puts Rainbow('Projects:').gold
+
+      # Load all entries to find latest activity for each project
+      @storage.all_days.each do |daily_log|
+        daily_log.entries.each do |entry|
+          if projects.key?(entry.project)
+            project = projects[entry.project]
+            project.entries ||= []
+            project.entries << entry
+            # Update last activity date if entry time is more recent
+            project.last_activity = entry.time if project.last_activity.nil? || entry.time > project.last_activity
+          else
+            WorkLogger.debug "Project with key '#{entry.project}' not found in projects. Skipping."
+          end
+        end
+      end
+      print_projects(projects)
+    end
+
+    def print_projects(projects)
+      puts Rainbow('Active Projects:').gold
       projects.each_value do |project|
+        # Sort entries by descending time
+        project.entries.sort_by!(&:time).reverse!
+
         puts "#{Rainbow(project.name).gold} (#{project.key})"
         puts "  Description: #{project.description}" if project.description
         puts "  Start date: #{project.start_date.strftime('%b %d, %Y')}" if project.start_date
         puts "  End date: #{project.end_date.strftime('%b %d, %Y')}" if project.end_date
         puts "  Status: #{project.status}" if project.status
+        puts "  Last activity: #{project.last_activity.strftime('%b %d, %Y')}" if project.last_activity
+
+        next unless project.entries && !project.entries.empty?
+
+        puts "  Last #{[project.entries&.size, 3].min} entries:"
+        puts "    #{project.entries.last(3).map do |e|
+          "#{e.time.strftime('%b %d, %Y')} #{e.message_string(@people)}"
+        end.join("\n    ")}"
       end
       puts 'No projects found.' if projects.empty?
     end
@@ -254,7 +284,7 @@ module Worklog
     # @example
     #   worklog.tag_detail('example_tag', from: '2023-10-01', to: '2023-10-31')
     def tag_detail(tag, options)
-      printer = Printer.new(@storage.load_people!)
+      printer = Printer.new(@people)
       start_date, end_date = start_end_date(options)
 
       @storage.days_between(start_date, end_date).each do |daily_log|

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: fewald-worklog
 version: !ruby/object:Gem::Version
-  version: 0.2.19
+  version: 0.2.21
 platform: ruby
 authors:
 - Friedrich Ewald