fewald-worklog 0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: dc96d7e3c9fa2cb64c09f04b13683f64dbce8b993d16e0529df92fddff947901
+  data.tar.gz: 0d4de596547f66de795f7de9ec979924b18d19bac9e5b4722f755306db85f8fd
+SHA512:
+  metadata.gz: a48499cd05d20d472b4126e18b588114740c26a18cb7b9fe6eb10aaabff231654406a70cf467c3a5d175165b8b6a7c81749bed376a8f0ffebbf97d43e50a1e94
+  data.tar.gz: ef081d883a7f2ed48e7513690a2844235851cf90bd03792d49e74f0b574b42161e1f674a37fadded9a37c66b6f938719dfdda4666a94a7066b11de17da5b18ce

data/.version

@@ -0,0 +1 @@
+

data/bin/wl

@@ -0,0 +1,16 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# This is the main entry point for the worklog CLI.
+
+if ENV['WL_PATH']
+  # Import the worklog CLI from the path specified in the WL_PATH environment variable
+  # This is used during development to avoid having to rely on the order of the $PATH.
+  puts "Loading worklog from #{ENV['WL_PATH']}. This should only be used during development."
+  puts 'To use the installed worklog, unset the WL_PATH environment variable.'
+  require_relative File.join(ENV['WL_PATH'], 'lib', 'cli')
+else
+  require_relative '../lib/cli'
+end
+
+WorklogCLI.start

data/lib/cli.rb

@@ -0,0 +1,149 @@
+# frozen_string_literal: true
+
+# Add the current directory to the load path
+# curr_dir = File.expand_path(__dir__)
+# $LOAD_PATH << curr_dir unless $LOAD_PATH.include?(curr_dir)
+
+require 'thor'
+require 'date'
+require 'worklogger'
+
+require 'worklog'
+require 'date_parser'
+require 'configuration'
+require 'editor'
+require 'printer'
+require 'statistics'
+require 'storage'
+require 'string_helper'
+require 'summary'
+require 'version'
+require 'webserver'
+
+# CLI for the work log application
+class WorklogCLI < Thor
+  attr_accessor :config, :storage
+
+  include StringHelper
+  class_option :verbose, type: :boolean, aliases: '-v', desc: 'Enable verbose output'
+
+  package_name 'Worklog'
+
+  # Initialize the CLI with the given arguments, options, and configuration
+  def initialize(args = [], options = {}, config = {})
+    @config = load_configuration
+    @storage = Storage.new(@config)
+    super
+  end
+
+  def self.exit_on_failure?
+    true
+  end
+
+  desc 'add MESSAGE', 'Add a new entry to the work log, defaults to the current date.'
+  long_desc <<~LONGDESC
+    Add a new entry with the current date and time to the work log.
+    The message is required and must be enclosed in quotes if it contains more than one word.
+
+    People can be referenced either by using the tilde "~" or the at symbol "@", followed by
+    an alphanumeric string.
+  LONGDESC
+  option :date, type: :string, default: DateTime.now.strftime('%Y-%m-%d'), desc: 'Set the date of the entry'
+  option :time, type: :string, default: DateTime.now.strftime('%H:%M:%S'), desc: 'Set the time of the entry'
+  option :tags, type: :array, default: [], desc: 'Add tags to the entry'
+  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'
+  def add(message)
+    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.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.remove(options)
+  end
+
+  desc 'show', 'Show the work log for a specific date or a range of dates. Defaults to todays date.'
+  long_desc <<~LONGDESC
+    Show the work log for a specific date or a range of dates. As a default, all items from the current day will be shown.
+  LONGDESC
+  option :date, type: :string, default: DateTime.now.strftime('%Y-%m-%d'),
+                desc: <<~DESC
+                  Show the work log for a specific date. If this option is provided, --from and --to and --days should not be used.
+                DESC
+  option :from, type: :string, desc: <<~EOF
+    Inclusive start date of the range. Takes precedence over --date, if defined.
+  EOF
+  option :to, type: :string, desc: <<~EOF
+    Inclusive end date of the range. Takes precedence over --date, if defined.
+  EOF
+  option :days, type: :numeric, desc: <<~EOF
+    Number of days to show starting from --date. Takes precedence over --from and --to if defined.
+  EOF
+  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.show(options)
+  end
+
+  desc 'people', 'Show all people mentioned in the work log'
+  def people(person = nil)
+    worklog = Worklog.new
+    worklog.people(person, options)
+  end
+
+  desc 'tags', 'Show all tags used in the work log'
+  def tags
+    worklog = Worklog.new
+    worklog.tags(options)
+  end
+
+  desc 'server', 'Start the work log server'
+  def server
+    app = WorkLogApp.new(@storage)
+    WorkLogServer.new(app).start
+  end
+
+  desc 'stats', 'Show statistics for the work log'
+  def stats
+    worklog = Worklog.new
+    worklog.stats(options)
+  end
+
+  desc 'summary', 'Generate a summary of the work log entries'
+  option :date, type: :string, default: DateTime.now.strftime('%Y-%m-%d')
+  option :from, type: :string, desc: <<-EOF
+    'Inclusive start date of the range. Takes precedence over --date if defined.'
+  EOF
+  option :to, type: :string, desc: <<-EOF
+    'Inclusive end date of the range. Takes precedence over --date if defined.'
+  EOF
+  option :days, type: :numeric, desc: <<-EOF
+    'Number of days to show starting from --date. Takes precedence over --from and --to if defined.'
+  EOF
+  def summary
+    worklog = Worklog.new
+    worklog.summary(options)
+  end
+
+  desc 'version', 'Show the version of the Worklog'
+  def version
+    puts "Worklog #{current_version} running on Ruby #{RUBY_VERSION}"
+  end
+
+  # Define shortcuts and aliases
+  map 'a' => :add
+  map 'statistics' => :stats
+  map 'serve' => :server
+end

data/lib/configuration.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require 'yaml'
+
+# Configuration class for the application.
+class Configuration
+  attr_accessor :storage_path, :log_level, :webserver_port
+
+  def initialize(&block)
+    block.call(self) if block_given?
+
+    # Set default values if not set
+    @storage_path ||= File.join(Dir.home, '.worklog')
+    @log_level ||= :info
+    @webserver_port ||= 3000
+  end
+end
+
+# Load configuration from a YAML file.
+# The file should be located at ~/.worklog.yaml.
+def load_configuration
+  file_path = File.join(Dir.home, '.worklog.yaml')
+  if File.exist?(file_path)
+    file_cfg = YAML.load_file(file_path)
+    Configuration.new do |cfg|
+      cfg.storage_path = file_cfg['storage_path'] if file_cfg['storage_path']
+      cfg.log_level = file_cfg['log_level'].to_sym if file_cfg['log_level']
+      cfg.webserver_port = file_cfg['webserver_port'] if file_cfg['webserver_port']
+    end
+  else
+    puts "Configuration file does not exist in #{file_path}"
+  end
+end

data/lib/daily_log.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+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
+
+  def people?
+    # Returns true if there are people mentioned in any entry of the current day.
+    people.size.positive?
+  end
+
+  def people
+    # 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>]
+    entries.map(&:people).flatten.tally
+  end
+
+  def ==(other)
+    date == other.date && entries == other.entries
+  end
+end

data/lib/date_parser.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+require 'date'
+
+module DateParser
+  # Best effort date parsing from multiple formats.
+  def self.parse_date_string(date_str, from_beginning = true)
+    return nil if date_str.nil?
+    return nil if date_str.empty?
+    return nil if date_str.length > 10
+
+    # Try to parse basic format YYYY-MM-DD
+    begin
+      return Date.strptime(date_str, '%Y-%m-%d') if date_str.match(/^\d{4}-\d{1,2}-\d{1,2}$/)
+    rescue Date::Error
+      # puts "Date not in format YYYY-MM-DD."
+    end
+
+    # Try to parse format YYYY-MM
+    begin
+      if date_str.match(/^\d{4}-\d{1,2}$/)
+        d = Date.strptime(date_str, '%Y-%m')
+        return d if from_beginning
+
+        return Date.new(d.year, d.month, -1)
+
+      end
+    rescue Date::Error
+      # puts "Date not in format YYYY-MM."
+    end
+
+    # Try to parse format YYYY (without Q1234)
+    if date_str.match(/^\d{4}$/)
+      d = Date.strptime(date_str, '%Y')
+      return d if from_beginning
+
+      return Date.new(d.year, -1, -1)
+
+    end
+
+    # Long form quarter (2024-Q1, etc.)
+    match = date_str.match(/(\d{4})-[qQ]([1234])/)
+    if match
+      year, quarter = match.captures.map(&:to_i)
+      d = Date.new(year, ((quarter - 1) * 3) + 1, 1)
+      return d if from_beginning
+
+      return Date.new(d.year, d.month + 2, -1)
+
+    end
+
+    # Short form quarter
+    match = date_str.match(/[qQ]([1234])/)
+    return unless match
+
+    quarter = match.captures.first.to_i
+    d = Date.new(Date.today.year, ((quarter - 1) * 3) + 1, 1)
+    return d if from_beginning
+
+    Date.new(d.year, d.month + 2, -1)
+  end
+
+  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?
+
+    date
+  end
+end

data/lib/editor.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require 'erb'
+require 'tempfile'
+
+# Editor to handle editing of log entries.
+module Editor
+  EDITOR_PREAMBLE = ERB.new <<~README
+    # Edit the content below, then save the file and quit the editor.
+    # The update content will be saved. The content MUST be valid YAML
+    # in order for the application to be able to update the records.
+
+    <%= content %>
+  README
+
+  # Open text editor (currently ViM) with the initial text.
+  # Upon saving and exiting the editor, the updated text is returned.
+  # @param initial_text [String] The initial text to display in the editor.
+  # @return [String] The updated text.
+  def self.open_editor(initial_text)
+    file_handle = Tempfile.create
+    file_handle.write(initial_text)
+    file_handle.close
+
+    # Open the editor with the temporary file.
+    system('vim', file_handle.path)
+
+    updated_text = nil
+
+    # Read the updated text from the file.
+    File.open(file_handle.path, 'r') do |f|
+      updated_text = f.read
+      WorkLogger.debug("Updated text: #{updated_text}")
+    end
+    File.unlink(file_handle.path)
+    updated_text
+  end
+end

data/lib/hash.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Hashify
+  def to_hash
+    hash = {}
+    instance_variables.each do |var|
+      value = instance_variable_get(var)
+      hash[var.to_s.delete('@')] = value
+    end
+    hash
+  end
+end
+
+class Hash
+  # Convert all keys to strings so that the YAML file can be read from different languages.
+  # This is a monkey patch to the Hash class.
+
+  def stringify_keys
+    # Convert all keys to strings.
+    # This is useful when the hash is serialized to YAML.
+    #
+    # @return [Hash] the hash with all keys converted to strings
+    map { |k, v| [k.to_s, v] }.to_h
+  end
+end

data/lib/log_entry.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+require 'yaml'
+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
+
+  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]
+  end
+
+  # Returns true if the entry is an epic, false otherwise.
+  def epic?
+    @epic == true
+  end
+
+  # Returns the message string with formatting without the time.
+  # @param 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
+
+    s = ''
+
+    s += if epic
+           Rainbow("[EPIC] #{msg}").bg(:white).fg(:black)
+         else
+           msg
+         end
+
+    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 URL in brackets if defined.
+    s += "  [#{@url}]" if @url && @url != ''
+
+    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
+  end
+
+  def people?
+    # Return true if there are people in the entry.
+    #
+    # @return [Boolean]
+    people.size.positive?
+  end
+
+  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
+  end
+end

data/lib/person.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+# Represents a person at work.
+class Person
+  attr_reader :handle, :name, :email, :team, :notes
+
+  def initialize(handle, name, email, team, notes = [])
+    @handle = handle
+    @name = name
+    @email = email
+    @team = team
+    @notes = notes
+  end
+
+  def to_s
+    return "#{name} (~#{handle})" if @email.nil?
+
+    "#{name} (~#{handle}) <#{email}>"
+  end
+
+  def ==(other)
+    return false unless other.is_a?(Person)
+
+    handle == other.handle && name == other.name && email == other.email && team == other.team && notes == other.notes
+  end
+end

data/lib/printer.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+require 'rainbow'
+
+# Printer for work log entries
+class Printer
+  attr_reader :people
+
+  # 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] }
+  end
+
+  # Prints a whole day of work log entries.
+  # If date_inline is true, the date is printed inline with the time.
+  # If epics_only is true, only epic entries are printed.
+  def print_day(daily_log, date_inline = false, epics_only = false)
+    daily_log.date = Date.strptime(daily_log.date, '%Y-%m-%d') unless daily_log.date.respond_to?(:strftime)
+
+    date_string = daily_log.date.strftime('%a, %B %-d, %Y')
+    puts "Work log for #{Rainbow(date_string).gold}" unless date_inline
+
+    daily_log.entries.each do |entry|
+      next if epics_only && !entry.epic?
+
+      print_entry(daily_log, entry, date_inline)
+    end
+  end
+
+  # Print a message when no entries are found.
+  # @param start_date [Date]
+  # @param end_date [Date]
+  # @return [void]
+  def no_entries(start_date, end_date)
+    if start_date == end_date
+      date_string = start_date.strftime('%a, %B %-d, %Y')
+      puts "No entries found for #{Rainbow(date_string).gold}."
+    else
+      start_date_string = start_date.strftime('%a, %B %-d, %Y')
+      end_date_string = end_date.strftime('%a, %B %-d, %Y')
+      puts "No entries found between #{Rainbow(start_date_string).gold} and #{Rainbow(end_date_string).gold}."
+    end
+  end
+
+  # Prints a single entry, formats the date and time.
+  # @param daily_log [DailyLog]
+  # @param entry [LogEntry]
+  # @param date_inline [Boolean] If true, the date is printed inline with the time.
+  def print_entry(daily_log, entry, date_inline = false)
+    entry.time = DateTime.strptime(entry.time, '%H:%M:%S') unless entry.time.respond_to?(:strftime)
+
+    time_string = if date_inline
+                    "#{daily_log.date.strftime('%a, %Y-%m-%d')} #{entry.time.strftime('%H:%M')}"
+                  else
+                    entry.time.strftime('%H:%M')
+                  end
+
+    puts "#{Rainbow(time_string).gold} #{entry.message_string(@people)}"
+  end
+end

data/lib/statistics.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require 'date'
+require 'storage'
+
+STATS = Data.define(:total_days, :total_entries, :total_epics, :avg_entries, :first_entry, :last_entry)
+
+# Module for calculating statistics for the work log.
+class Statistics
+  # Initialize the Statistics class.
+  def initialize(config)
+    @config = config
+    @storage = Storage.new(config)
+  end
+
+  # Calculate statistics for the work log for all days.
+  # @return [STATS] The statistics for the work log
+  def calculate
+    all_entries = @storage.all_days
+    return STATS.new(0, 0, 0, 0, Date.today, Date.today) if all_entries.empty?
+
+    total_days = all_entries.length
+    total_entries = all_entries.sum { |entry| entry.entries.length }
+    total_epics = all_entries.sum { |entry| entry.entries.select { |item| item.epic? }.length }
+    avg_entries = total_entries.to_f / total_days
+    min_day = all_entries.min_by { |entry| entry.date }.date
+    max_day = all_entries.max_by { |entry| entry.date }.date
+
+    STATS.new(
+      total_days,
+      total_entries,
+      total_epics,
+      avg_entries,
+      min_day,
+      max_day
+    )
+  end
+end