fewald-worklog 0.2.9 → 0.2.11

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 236505ddc94f7f28294723a0c6e0afc7c6b9c2ef49baf6b32f555eafddbff9e7
-  data.tar.gz: b7ed9f40ecf876b199b2c3526b2c42775302c980fb4e862f852a947631c2bc76
+  metadata.gz: d1bb6e2ee81700ee384981acfa68bfde33ba9d2e5e7d0af30b0c08c392bde042
+  data.tar.gz: ac0fa2e1c558f97bc11cdcb145e5a1b8eb12fd0ca661dd932f545108b0386732
 SHA512:
-  metadata.gz: 0fedfe9d106478c247dfd175e076b15c3da4d293dd2ae7385319d51b52c33fed9c99add51dcbd64228edd70569fcba6eb25eb7ae7368181948bf1993d94c8c3c
-  data.tar.gz: ab040f7009457b38e20453f4af7251deea62baad23c2557f0e0455399a48df6288c77433de1c6cd04a26f4ba13ef3d374dc8903908ee60c524f1d37b57d06e85
+  metadata.gz: 5dcae260eadbe46143a35b2dab7a6c3e780104d5b95dbeef0b439f52613e2dcc4ffa014d2963947715700feca90a88ec9c814fa5a7b90bea56068262b8bd8891
+  data.tar.gz: a4eedd1a9d6e7395fdfd7a758c90548e1eccc62195c80fb6475433500c4a376b67b3ba1e6ab857f9048234b643670f9b814908941093f9881be3d8d4aedb31b3

data/.version

@@ -1 +1 @@
-0.2.9
+0.2.11

data/lib/cli.rb

@@ -53,22 +53,23 @@ class WorklogCLI < Thor
   option :ticket, type: :string, desc: 'Ticket number associated with the entry. Can be any alphanumeric string.'
   option :url, type: :string, desc: 'URL to associate with the entry'
   option :epic, type: :boolean, default: false, desc: 'Mark the entry as an epic'
+  option :project, type: :string, desc: 'Key of the project. The project needs to be defined first.'
   def add(message)
-    worklog = Worklog.new
+    worklog = Worklog::Worklog.new
     worklog.add(message, options)
   end
 
   desc 'edit', 'Edit a day in the work log. By default, the current date is used.'
   option :date, type: :string, default: DateTime.now.strftime('%Y-%m-%d')
   def edit
-    worklog = Worklog.new
+    worklog = Worklog::Worklog.new
     worklog.edit(options)
   end
 
   desc 'remove', 'Remove last entry from the log'
   option :date, type: :string, default: DateTime.now.strftime('%Y-%m-%d')
   def remove
-    worklog = Worklog.new
+    worklog = Worklog::Worklog.new
     worklog.remove(options)
   end
 
@@ -92,16 +93,22 @@ class WorklogCLI < Thor
   option :epics_only, type: :boolean, default: false, desc: 'Show only entries that are marked as epic'
   option :tags, type: :array, default: [], desc: 'Filter entries by tags. Tags are treated as an OR condition.'
   def show
-    worklog = Worklog.new
+    worklog = Worklog::Worklog.new
     worklog.show(options)
   end
 
   desc 'people', 'Show all people mentioned in the work log'
   def people(person = nil)
-    worklog = Worklog.new
+    worklog = Worklog::Worklog.new
     worklog.people(person, options)
   end
 
+  desc 'projects', 'Show all projects defined in the work log'
+  def projects(options = {})
+    worklog = Worklog::Worklog.new
+    worklog.projects(options)
+  end
+
   desc 'tags', 'Show all tags used in the work log'
   option :date, type: :string, default: DateTime.now.strftime('%Y-%m-%d'),
                 desc: <<~DESC
@@ -117,19 +124,19 @@ class WorklogCLI < Thor
     Number of days to show starting from --date. Takes precedence over --from and --to if defined.
   EOF
   def tags(tag = nil)
-    worklog = Worklog.new
+    worklog = Worklog::Worklog.new
     worklog.tags(tag, options)
   end
 
   desc 'server', 'Start the work log server'
   def server
-    worklog = Worklog.new
+    worklog = Worklog::Worklog.new
     worklog.server
   end
 
   desc 'stats', 'Show statistics for the work log'
   def stats
-    worklog = Worklog.new
+    worklog = Worklog::Worklog.new
     worklog.stats(options)
   end
 
@@ -145,7 +152,7 @@ class WorklogCLI < Thor
     'Number of days to show starting from --date. Takes precedence over --from and --to if defined.'
   EOF
   def summary
-    worklog = Worklog.new
+    worklog = Worklog::Worklog.new
     worklog.summary(options)
   end
 
@@ -158,4 +165,5 @@ class WorklogCLI < Thor
   map 'a' => :add
   map 'statistics' => :stats
   map 'serve' => :server
+  map 'project' => :projects
 end

data/lib/daily_log.rb

@@ -28,7 +28,7 @@ class DailyLog
   #
   # @return [Hash<String, Integer>]
   def people
-    entries.map(&:people).flatten.tally
+    entries.map { |entry| entry.people.to_a }.flatten.tally
   end
 
   # Returns a sorted list of tags used in the entries for the current day.

data/lib/date_parser.rb

@@ -4,6 +4,10 @@ require 'date'
 
 module DateParser
   # Best effort date parsing from multiple formats.
+  #
+  # @param date_str [String] The date string to parse.
+  # @param from_beginning [Boolean] If true, returns the beginning of the date (e.g., first day of month or year).
+  # @return [Date, nil] Returns a Date object if parsing is successful, or nil if parsing fails.
   def self.parse_date_string(date_str, from_beginning = true)
     return nil if date_str.nil?
     return nil if date_str.empty?
@@ -60,6 +64,7 @@ module DateParser
     Date.new(d.year, d.month + 2, -1)
   end
 
+  # Similar to parse_date_string, but raises an error if parsing fails.
   def self.parse_date_string!(date_str, from_beginning = true)
     date = parse_date_string(date_str, from_beginning)
     raise ArgumentError, "Could not parse date string: \"#{date_str}\"" if date.nil?

data/lib/log_entry.rb

@@ -12,7 +12,9 @@ class LogEntry
   include Hashify
 
   # Represents a single entry in the work log.
-  attr_accessor :time, :tags, :ticket, :url, :epic, :message
+  attr_accessor :time, :tags, :ticket, :url, :epic, :message, :project
+
+  attr_reader :day
 
   def initialize(params = {})
     @time = params[:time]
@@ -23,6 +25,10 @@ class LogEntry
     @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.
@@ -62,18 +68,17 @@ class LogEntry
     # Add URL in brackets if defined.
     s += "  [#{@url}]" if @url && @url != ''
 
+    s += "  [#{@project}]" if @project && @project != ''
+
     s
   end
 
   def people
-    # Return people that are mentioned in the entry.
-    # People are defined as words starting with @ or ~.
-    # Whitespaces are used to separate people.
-    # Punctuation is not considered.
-    # Empty array if no people are mentioned.
-    #
-    # @return [Array<String>]
-    @message.scan(PERSON_REGEX).flatten.uniq.sort
+    # 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?

data/lib/project.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Worklog
+  # Represents a project. A project is a longer running task or initiative.
+  # Single log entries can be associated with a project.
+  class Project
+    attr_accessor :key, :name, :description, :start_date, :end_date, :status
+
+    # Creates a new Project instance from a hash of attributes.
+    # @param hash [Hash] A hash containing project attributes
+    # @option hash [String] :key The project key
+    # @option hash [String] :name The project name
+    # @option hash [String] :description The project description
+    # @option hash [Date] :start_date The project start date
+    # @option hash [Date] :end_date The project end date
+    # @option hash [String] :status The project status
+    # @return [Project] A new Project instance
+    def self.from_hash(hash)
+      project = new
+      # Ensure that at least the key is present
+      raise ArgumentError, 'Project key is required' unless hash[:key] || hash['key']
+
+      project.key = hash[:key] || hash['key']
+      project.name = hash[:name] || hash['name']
+      project.description = hash[:description] || hash['description']
+      project.start_date = hash[:start_date] || hash['start_date']
+      project.end_date = hash[:end_date] || hash['end_date']
+      project.status = hash[:status] || hash['status']
+      project
+    end
+
+    # Returns true if the project has started, false otherwise.
+    # A project is considered started if either
+    #  - its start date is nil or
+    #  - its start date is less than or equal to today's date.
+    # @return [Boolean] true if the project has started, false otherwise
+    def started?
+      start_date.nil? || (!start_date.nil? && start_date <= Date.today)
+    end
+
+    # Returns true if the project has ended, false otherwise.
+    # @return [Boolean] true if the project has ended, false otherwise
+    def ended?
+      !end_date.nil? && end_date < Date.today
+    end
+  end
+end

data/lib/project_storage.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+require 'project'
+
+module Worklog
+  # Custom error for when a project is not found.
+  # This error is raised when a project with a given key does not exist in the project storage.
+  # It is used to signal that an operation requiring a project cannot proceed.
+  class ProjectNotFoundError < StandardError; end
+
+  # ProjectStorage is responsible for loading and managing project data.
+  # It provides methods to load projects from a YAML file and check if a project exists.
+  #
+  # @see Project
+  # @see Configuration
+  # Handles storage operations for projects.
+  class ProjectStorage
+    attr_writer :projects
+
+    PROJECT_TEMPLATE = <<~YAML
+      # Each project is defined by the following attributes:
+      # - key: <project_key>
+      #   name: <project_name>
+      #   description: <project_description>
+      #   start_date: <start_date>
+      #   end_date: <end_date>
+      #   status: <status>
+      #   --- Define your projects below this line ---
+    YAML
+
+    # Constructs a new ProjectStorage instance.
+    # @param configuration [Configuration] The configuration object.
+    def initialize(configuration)
+      @configuration = configuration
+    end
+
+    def projects
+      @projects ||= load_projects
+    end
+
+    # Loads all projects from disk.
+    # If the file does not exist, it creates a template.
+    # @return [Hash<String, Project>] A hash of project objects keyed by their project keys.
+    def load_projects
+      create_template unless file_exist?
+
+      file_path = File.join(@configuration.storage_path, 'projects.yml')
+      projects = {}
+      YAML.load_file(file_path, permitted_classes: [Date])&.each do |project_hash|
+        project = Project.from_hash(project_hash)
+        projects[project.key] = project if project
+      end
+
+      projects
+    end
+
+    # Check if a project with a given handle exists.
+    # @param handle [String] The handle of the project to check.
+    # @return [Boolean] Returns true if the project exists, false otherwise.
+    def exist?(handle)
+      projects = load_projects
+      projects.key?(handle)
+    end
+
+    private
+
+    # Check whether projects.yaml exists in the project_dir
+    # @return [Boolean] Returns true if the project YAML file exists, false otherwise
+    def file_exist?
+      file_path = File.join(@configuration.storage_path, 'projects.yml')
+      File.exist?(file_path)
+    end
+
+    def create_template
+      File.write(File.join(@configuration.storage_path, 'projects.yml'), PROJECT_TEMPLATE)
+    end
+  end
+end

data/lib/storage.rb

@@ -131,6 +131,9 @@ class Storage
     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
@@ -138,6 +141,12 @@ class Storage
     []
   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!

data/lib/worklog.rb

@@ -15,250 +15,326 @@ require 'string_helper'
 require 'printer'
 require 'statistics'
 require 'summary'
+require 'project_storage'
 
-# Main class providing all worklog functionality.
-# This class is the main entry point for the application.
-# It handles command line arguments, configuration, and logging.
-class Worklog
-  include StringHelper
-  attr_reader :config
+module Worklog
+  # Main class providing all worklog functionality.
+  # This class is the main entry point for the application.
+  # It handles command line arguments, configuration, and logging.
+  class Worklog
+    include StringHelper
+    attr_reader :config, :storage
 
-  def initialize(config = nil)
-    @config = config || Configuration.new
-    @storage = Storage.new(@config)
+    def initialize(config = nil)
+      @config = config || Configuration.new
+      @storage = Storage.new(@config)
 
-    WorkLogger.level = @config.log_level == :debug ? Logger::Severity::DEBUG : Logger::Severity::INFO
-  end
+      WorkLogger.level = @config.log_level == :debug ? Logger::Severity::DEBUG : Logger::Severity::INFO
+    end
 
-  def add(message, options = {})
-    # Remove leading and trailing whitespaces
-    # Raise an error if the message is empty
-    message = message.strip
-    raise ArgumentError, 'Message cannot be empty' if message.empty?
+    # Add new entry to the work log.
+    # @param message [String] the message to add to the work log. This cannot be empty.
+    # @param options [Hash] the options hash containing date, time, tags, ticket, url, epic, and project.
+    # @raise [ArgumentError] if the message is empty.
+    #
+    # @example
+    #   worklog.add('Worked on feature X', date: '2023-10-01', time: '10:00:00', tags: ['feature', 'x'], ticket:
+    #   'TICKET-123', url: 'https://example.com/', epic: true, project: 'my_project')
+    #
+    # @return [void]
+    def add(message, options = {})
+      # Remove leading and trailing whitespaces
+      # Raise an error if the message is empty
+      message = message.strip
+      raise ArgumentError, 'Message cannot be empty' if message.empty?
+
+      date = Date.strptime(options[:date], '%Y-%m-%d')
+      time = Time.strptime(options[:time], '%H:%M:%S')
+      @storage.create_file_skeleton(date)
+
+      # Validate that the project exists if provided
+      validate_projects!(options[:project]) if options[:project] && !options[:project].empty?
+
+      daily_log = @storage.load_log!(@storage.filepath(date))
+      new_entry = LogEntry.new(time:, tags: options[:tags], ticket: options[:ticket], url: options[:url],
+                               epic: options[:epic], message:, project: options[:project])
+      daily_log.entries << new_entry
+
+      # Sort by time in case an entry was added later out of order.
+      daily_log.entries.sort_by!(&:time)
+
+      @storage.write_log(@storage.filepath(options[:date]), daily_log)
+
+      people_hash = @storage.load_people_hash
+      (new_entry.people - people_hash.keys).each do |handle|
+        WorkLogger.warn "Person with handle #{handle} not found. Consider adding them to people.yaml"
+      end
 
-    date = Date.strptime(options[:date], '%Y-%m-%d')
-    time = Time.strptime(options[:time], '%H:%M:%S')
-    @storage.create_file_skeleton(date)
+      WorkLogger.info Rainbow("Added entry on #{options[:date]}: #{message}").green
+    end
 
-    daily_log = @storage.load_log!(@storage.filepath(date))
-    daily_log.entries << LogEntry.new(time:, tags: options[:tags], ticket: options[:ticket], url: options[:url],
-                                      epic: options[:epic], message:)
+    def edit(options = {})
+      date = Date.strptime(options[:date], '%Y-%m-%d')
 
-    # Sort by time in case an entry was added later out of order.
-    daily_log.entries.sort_by!(&:time)
+      # Load existing log
+      log = @storage.load_log(@storage.filepath(date))
+      unless log
+        WorkLogger.error "No work log found for #{options[:date]}. Aborting."
+        exit 1
+      end
 
-    @storage.write_log(@storage.filepath(options[:date]), daily_log)
+      txt = Editor::EDITOR_PREAMBLE.result_with_hash(content: YAML.dump(log))
+      return_val = Editor.open_editor(txt)
 
-    WorkLogger.info Rainbow("Added entry on #{options[:date]}: #{message}").green
-  end
+      @storage.write_log(@storage.filepath(date),
+                         YAML.load(return_val, permitted_classes: [Date, Time, DailyLog, LogEntry]))
+      WorkLogger.info Rainbow("Updated work log for #{options[:date]}").green
+    end
+
+    def show(options = {})
+      people = @storage.load_people!
+      printer = Printer.new(people)
 
-  def edit(options = {})
-    date = Date.strptime(options[:date], '%Y-%m-%d')
+      start_date, end_date = start_end_date(options)
 
-    # Load existing log
-    log = @storage.load_log(@storage.filepath(date))
-    unless log
-      WorkLogger.error "No work log found for #{options[:date]}. Aborting."
-      exit 1
+      entries = @storage.days_between(start_date, end_date)
+      if entries.empty?
+        printer.no_entries(start_date, end_date)
+      else
+        entries.each do |entry|
+          printer.print_day(entry, entries.size > 1, options[:epics_only])
+        end
+      end
     end
 
-    txt = Editor::EDITOR_PREAMBLE.result_with_hash(content: YAML.dump(log))
-    return_val = Editor.open_editor(txt)
+    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
 
-    @storage.write_log(@storage.filepath(date),
-                       YAML.load(return_val, permitted_classes: [Date, Time, DailyLog, LogEntry]))
-    WorkLogger.info Rainbow("Updated work log for #{options[:date]}").green
-  end
+      if person
+        unless people_map.key?(person)
+          WorkLogger.error Rainbow("No person found with handle #{person}.").red
+          return
+        end
+        person_detail(all_logs, all_people, people_map[person.strip])
+      else
+        puts 'People mentioned in the work log:'
 
-  def show(options = {})
-    people = @storage.load_people!
-    printer = Printer.new(people)
+        mentions = {}
 
-    start_date, end_date = start_end_date(options)
+        all_logs.map(&:people).each do |people|
+          mentions.merge!(people) { |_key, oldval, newval| oldval + newval }
+        end
 
-    entries = @storage.days_between(start_date, end_date)
-    if entries.empty?
-      printer.no_entries(start_date, end_date)
-    else
-      entries.each do |entry|
-        printer.print_day(entry, entries.size > 1, options[:epics_only])
+        # Sort the mentions by handle
+        mentions = mentions.to_a.sort_by { |handle, _| handle }
+
+        mentions.each do |handle, v|
+          if people_map.key?(handle)
+            person = people_map[handle]
+            print "#{Rainbow(person.name).gold} (#{handle})"
+            print " (#{person.team})" if person.team
+          else
+            print handle
+          end
+          puts ": #{v} #{pluralize(v, 'occurrence')}"
+        end
       end
     end
-  end
 
-  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
+    def person_detail(all_logs, all_people, person)
+      printer = Printer.new(all_people)
+      puts "All interactions with #{Rainbow(person.name).gold}"
 
-    if person
-      unless people_map.key?(person)
-        WorkLogger.error Rainbow("No person found with handle #{person}.").red
-        return
+      if person.notes
+        puts 'Notes:'
+        person.notes.each do |note|
+          puts "* #{note}"
+        end
       end
-      person_detail(all_logs, all_people, people_map[person.strip])
-    else
-      puts 'People mentioned in the work log:'
-
-      mentions = {}
 
-      all_logs.map(&:people).each do |people|
-        mentions.merge!(people) { |_key, oldval, newval| oldval + newval }
+      puts 'Interactions:'
+      all_logs.each do |daily_log|
+        daily_log.entries.each do |entry|
+          printer.print_entry(daily_log, entry, true) if entry.people.include?(person.handle)
+        end
       end
+    end
 
-      # Sort the mentions by handle
-      mentions = mentions.to_a.sort_by { |handle, _| handle }
+    def projects(_options = {})
+      project_storage = ProjectStorage.new(@config)
+      projects = project_storage.load_projects
+      puts Rainbow('Projects:').gold
+      projects.each_value do |project|
+        puts "#{Rainbow(project.name).gold} (#{project.key})"
+        puts "  Description: #{project.description}" if project.description
+        puts "  Start date: #{project.start_date}" if project.start_date
+        puts "  End date: #{project.end_date}" if project.end_date
+        puts "  Status: #{project.status}" if project.status
+      end
+      puts 'No projects found.' if projects.empty?
+    end
 
-      mentions.each do |handle, v|
-        if people_map.key?(handle)
-          print "#{Rainbow(people_map[handle].name).gold} (#{handle})"
-        else
-          print handle
-        end
-        puts ": #{v} #{pluralize(v, 'occurrence')}"
+    # Show all tags used in the work log or details for a specific tag
+    #
+    # @param tag [String, nil] the tag to show details for, or nil to show all tags
+    # @param options [Hash] the options hash containing date range
+    # @return [void]
+    #
+    # @example
+    #   worklog.tags('example_tag', from: '2023-10-01', to: '2023-10-31')
+    #   worklog.tags(nil) # Show all tags for all time
+    def tags(tag = nil, options = {})
+      if tag.nil? || tag.empty?
+        tag_overview
+      else
+        tag_detail(tag, options)
       end
     end
-  end
 
-  def person_detail(all_logs, all_people, person)
-    printer = Printer.new(all_people)
-    puts "All interactions with #{Rainbow(person.name).gold}"
+    def tag_overview
+      all_logs = @storage.all_days
+      puts Rainbow('Tags used in the work log:').gold
 
-    if person.notes
-      puts 'Notes:'
-      person.notes.each do |note|
-        puts "* #{note}"
-      end
+      # Count all tags used in the work log
+      tags = all_logs.map(&:entries).flatten.map(&:tags).flatten.compact.tally
+
+      # Determine length of longest tag for formatting
+      # Add one additonal space for formatting
+      max_len = tags.empty? ? 0 : tags.keys.map(&:length).max + 1
+
+      tags.sort.each { |k, v| puts "#{Rainbow(k.ljust(max_len)).gold}: #{v} #{pluralize(v, 'occurrence')}" }
     end
 
-    puts 'Interactions:'
-    all_logs.each do |daily_log|
-      daily_log.entries.each do |entry|
-        printer.print_entry(daily_log, entry, true) if entry.people.include?(person.handle)
+    # Show detailed information about a specific tag
+    #
+    # @param tag [String] the tag to show details for
+    # @param options [Hash] the options hash containing date range
+    # @return [void]
+    #
+    # @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!)
+      start_date, end_date = start_end_date(options)
+
+      @storage.days_between(start_date, end_date).each do |daily_log|
+        next unless daily_log.tags.include?(tag)
+
+        daily_log.entries.each do |entry|
+          next unless entry.tags.include?(tag)
+
+          printer.print_entry(daily_log, entry, true)
+        end
       end
     end
-  end
 
-  # Show all tags used in the work log or details for a specific tag
-  #
-  # @param tag [String, nil] the tag to show details for, or nil to show all tags
-  # @param options [Hash] the options hash containing date range
-  # @return [void]
-  #
-  # @example
-  #   worklog.tags('example_tag', from: '2023-10-01', to: '2023-10-31')
-  #   worklog.tags(nil) # Show all tags for all time
-  def tags(tag = nil, options = {})
-    if tag.nil? || tag.empty?
-      tag_overview
-    else
-      tag_detail(tag, options)
+    def stats(_options = {})
+      stats = Statistics.new(@config).calculate
+      puts "#{format_left('Total days')}: #{stats.total_days}"
+      puts "#{format_left('Total entries')}: #{stats.total_entries}"
+      puts "#{format_left('Total epics')}: #{stats.total_epics}"
+      puts "#{format_left('Entries per day')}: #{format('%.2f', stats.avg_entries)}"
+      puts "#{format_left('First entry')}: #{stats.first_entry}"
+      puts "#{format_left('Last entry')}: #{stats.last_entry}"
     end
-  end
 
-  def tag_overview
-    all_logs = @storage.all_days
-    puts Rainbow('Tags used in the work log:').gold
+    def summary(options = {})
+      start_date, end_date = start_end_date(options)
+      entries = @storage.days_between(start_date, end_date).map(&:entries).flatten
 
-    # Count all tags used in the work log
-    tags = all_logs.map(&:entries).flatten.map(&:tags).flatten.compact.tally
+      # Do nothing if no entries are found.
+      if entries.empty?
+        Printer.new.no_entries(start_date, end_date)
+        return
+      end
 
-    # Determine length of longest tag for formatting
-    # Add one additonal space for formatting
-    max_len = tags.empty? ? 0 : tags.keys.map(&:length).max + 1
+      # List all the epics
+      epics = entries.filter(&:epic)
+      puts Rainbow("Found #{epics.size} epics.").green if epics.any?
+      epics.each do |entry|
+        puts "#{entry.time.strftime('%b %d, %Y')} #{entry.message}"
+      end
 
-    tags.sort.each { |k, v| puts "#{Rainbow(k.ljust(max_len)).gold}: #{v} #{pluralize(v, 'occurrence')}" }
-  end
+      # List all the tags and their count
+      tags = entries.map(&:tags).flatten.compact.tally
+      puts Rainbow("Found #{tags.size} tags.").green if tags.any?
+      tags.each do |tag, count|
+        print "#{tag} (#{count}x), "
+      end
+      puts '' if tags.any?
 
-  # Show detailed information about a specific tag
-  #
-  # @param tag [String] the tag to show details for
-  # @param options [Hash] the options hash containing date range
-  # @return [void]
-  #
-  # @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!)
-    start_date, end_date = start_end_date(options)
-
-    @storage.days_between(start_date, end_date).each do |daily_log|
-      next unless daily_log.tags.include?(tag)
-
-      daily_log.entries.each do |entry|
-        next unless entry.tags.include?(tag)
-
-        printer.print_entry(daily_log, entry, true)
+      # List all the people and their count
+      people = entries.map(&:people).flatten.compact.tally.sort_by { |_, count| -count }.filter { |_, count| count > 1 }
+      puts Rainbow("Found #{people.size} people.").green if people.any?
+      people.each do |person, count|
+        print "#{person} (#{count}x), "
       end
+      puts '' if people.any?
+
+      # # Print the summary
+      # summary = Summary.new(entries)
+      # puts summary.to_s
     end
-  end
 
-  def stats(_options = {})
-    stats = Statistics.new(@config).calculate
-    puts "#{format_left('Total days')}: #{stats.total_days}"
-    puts "#{format_left('Total entries')}: #{stats.total_entries}"
-    puts "#{format_left('Total epics')}: #{stats.total_epics}"
-    puts "#{format_left('Entries per day')}: #{format('%.2f', stats.avg_entries)}"
-    puts "#{format_left('First entry')}: #{stats.first_entry}"
-    puts "#{format_left('Last entry')}: #{stats.last_entry}"
-  end
+    def remove(options = {})
+      date = Date.strptime(options[:date], '%Y-%m-%d')
+      unless File.exist?(@storage.filepath(date))
+        WorkLogger.error Rainbow("No work log found for #{options[:date]}. Aborting.").red
+        exit 1
+      end
 
-  def summary(options = {})
-    start_date, end_date = start_end_date(options)
-    entries = @storage.days_between(start_date, end_date).map(&:entries).flatten
+      daily_log = @storage.load_log!(@storage.filepath(options[:date]))
+      if daily_log.entries.empty?
+        WorkLogger.error Rainbow("No entries found for #{options[:date]}. Aborting.").red
+        exit 1
+      end
 
-    # Do nothing if no entries are found.
-    if entries.empty?
-      Printer.new.no_entries(start_date, end_date)
-      return
+      removed_entry = daily_log.entries.pop
+      @storage.write_log(@storage.filepath(date), daily_log)
+      WorkLogger.info Rainbow("Removed entry: #{removed_entry.message}").green
     end
-    puts Summary.new(@config).generate_summary(entries)
-  end
 
-  def remove(options = {})
-    date = Date.strptime(options[:date], '%Y-%m-%d')
-    unless File.exist?(@storage.filepath(date))
-      WorkLogger.error Rainbow("No work log found for #{options[:date]}. Aborting.").red
-      exit 1
+    # Start webserver
+    def server
+      app = WorkLogApp.new(@storage)
+      WorkLogServer.new(app).start
     end
 
-    daily_log = @storage.load_log!(@storage.filepath(options[:date]))
-    if daily_log.entries.empty?
-      WorkLogger.error Rainbow("No entries found for #{options[:date]}. Aborting.").red
-      exit 1
+    # Parse the start and end date based on the options provided
+    #
+    # @param options [Hash] the options hash
+    # @return [Array] the start and end date as an array
+    def start_end_date(options)
+      if options[:days]
+        # Safeguard against negative days
+        raise ArgumentError, 'Number of days cannot be negative' if options[:days].negative?
+
+        start_date = Date.today - options[:days]
+        end_date = Date.today
+      elsif options[:from]
+        start_date = DateParser.parse_date_string!(options[:from], true)
+        end_date = DateParser.parse_date_string!(options[:to], false) if options[:to]
+      elsif options[:date]
+        start_date = Date.strptime(options[:date], '%Y-%m-%d')
+        end_date = start_date
+      else
+        raise ArgumentError, 'No date range specified. Use --days, --from, --to or --date options.'
+      end
+      [start_date, end_date]
     end
 
-    removed_entry = daily_log.entries.pop
-    @storage.write_log(@storage.filepath(date), daily_log)
-    WorkLogger.info Rainbow("Removed entry: #{removed_entry.message}").green
-  end
-
-  # Start webserver
-  def server
-    app = WorkLogApp.new(@storage)
-    WorkLogServer.new(app).start
-  end
+    def validate_projects!(project_key)
+      project_storage = ProjectStorage.new(@config)
+      begin
+        projects = project_storage.load_projects
+      rescue Errno::ENOENT
+        raise ProjectNotFoundError, 'No projects found. Please create a project first.'
+      end
+      return if projects.key?(project_key)
 
-  # Parse the start and end date based on the options provided
-  #
-  # @param options [Hash] the options hash
-  # @return [Array] the start and end date as an array
-  def start_end_date(options)
-    if options[:days]
-      # Safeguard against negative days
-      raise ArgumentError, 'Number of days cannot be negative' if options[:days].negative?
-
-      start_date = Date.today - options[:days]
-      end_date = Date.today
-    elsif options[:from]
-      start_date = DateParser.parse_date_string!(options[:from], true)
-      end_date = DateParser.parse_date_string!(options[:to], false) if options[:to]
-    elsif options[:date]
-      start_date = Date.strptime(options[:date], '%Y-%m-%d')
-      end_date = start_date
-    else
-      raise ArgumentError, 'No date range specified. Use --days, --from, --to or --date options.'
+      raise ProjectNotFoundError, "Project with key '#{project_key}' does not exist."
     end
-    [start_date, end_date]
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: fewald-worklog
 version: !ruby/object:Gem::Version
-  version: 0.2.9
+  version: 0.2.11
 platform: ruby
 authors:
 - Friedrich Ewald
@@ -131,6 +131,8 @@ files:
 - lib/log_entry.rb
 - lib/person.rb
 - lib/printer.rb
+- lib/project.rb
+- lib/project_storage.rb
 - lib/statistics.rb
 - lib/storage.rb
 - lib/string_helper.rb