fewald-worklog 0.2.20 → 0.2.22

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7fab9613b51251c6cc9e6cd0f43dd1bd663db717c4783f2a1863b1441c7d8314
-  data.tar.gz: a73221bf9dec2a5ada555243d7258fe4b68ba1427e6deaf8c303afd71dabdf41
+  metadata.gz: 03ec04755ea87ebd6808b5b9256ad07a0c95514e35ed719628531cbb5cb5a0d9
+  data.tar.gz: e8c62ab27e88132df53066704a09d0baf585b1c5208c1c2481e0b3940f69419c
 SHA512:
-  metadata.gz: 94922720491591e24299a6da3abdd92e716a6cd61c1e91ea1cb05f880c4b11b0a4de36e04051d548b372653575753a633f279268d7e21b68c5cb895de17e7eaf
-  data.tar.gz: 604b44430a2c1b85856cf461e4d79aa7425acc95694eca1fa557909cb80fbc6b80879b2dec0f61ae5bdf8093dc6483a779e96600716f4606d3f35f237feea219
+  metadata.gz: e735b3fb91b5125e6607e2a2b018fd41038f8b02c32c31fc8bd0f2f56f87ec40ede9731361071071e752addd260f10b65a50bc6678aa8b6d8618bba0acfa975d
+  data.tar.gz: 85a223a42f4b88a1957e74f570aca7eac3f879a8967b2a40dc266e192b4a36142ae82635df11cb22fb1d1fc941cffa6bd0c3a4b1ba131bec179c1a60913dacca

data/.version

@@ -1 +1 @@
-0.2.20
+0.2.22

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,65 @@
 
 require 'hash'
 
-# DailyLog is a container for a day's work log.
-class DailyLog
-  # Container for a day's work log.
-  include Hashify
+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
+    # Represents a single day's work log.
+    attr_accessor :date, :entries
 
-  def initialize(params = {})
-    @date = params[:date]
-    @entries = params[:entries]
-  end
+    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 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 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
+    # 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
+
+    # Create a DailyLog from a hash with symbolized keys
+    #
+    # @param hash [Hash] the hash to convert
+    # @return [DailyLog] the created DailyLog object
+    def self.from_hash(hash)
+      new(
+        date: hash[:date],
+        entries: hash[:entries].map { |entry| LogEntry.from_hash(entry) }
+      )
+    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
+    # 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,115 +5,133 @@ require 'rainbow'
 require 'daily_log'
 require 'hash'
 
-# 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
+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.
-  # @return [Boolean]
-  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
 
-  # Return true if there are people in the entry.
-  #
-  # @return [Boolean]
-  def people?
-    people.size.positive?
-  end
+    # Return true if there are people in the entry.
+    #
+    # @return [Boolean]
+    def people?
+      people.size.positive?
+    end
 
-  # Convert the log entry to YAML format.
-  def to_yaml
-    to_hash.to_yaml
-  end
+    # Create a LogEntry from a hash with symbolized keys
+    #
+    # @param hash [Hash] the hash to convert
+    # @return [LogEntry] the created LogEntry object
+    def self.from_hash(hash)
+      new(
+        time: hash[:time],
+        tags: hash[:tags],
+        ticket: hash[:ticket],
+        url: hash[:url],
+        epic: hash[:epic],
+        message: hash[:message],
+        project: hash[:project]
+      )
+    end
+
+    # Convert the log entry to YAML format.
+    def to_yaml
+      to_hash.to_yaml
+    end
 
-  # 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
+    # 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/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,177 +6,189 @@ 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
+        yaml_content = File.read(file)
+        cleaned_yaml = yaml_content.gsub(%r{!ruby/object:[^\s]+}, '')
+        log = DailyLog.from_hash(YAML.safe_load(cleaned_yaml, permitted_classes: [Date, Time], symbolize_names: true))
+
+        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
 
-  # 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 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

metadata

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