timert 1.0.0

checksums.yaml

@@ -0,0 +1,15 @@
+---
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    NjVmYmVjODViODExZGJkNmEyOGE5YWY5NjE3Nzg4NDcwODE3NjYwYw==
+  data.tar.gz: !binary |-
+    ODljMWE2ZTk3NzY4ZjVkOGNkOThlNjRjNzhiZjY3ZDhkN2Q1N2Q3OA==
+!binary "U0hBNTEy":
+  metadata.gz: !binary |-
+    OTMyMWM4OTJlZjU3OTVjZjM5OThjMjg4YzUwZmJlZDUxZWM5YjYxYjJiYmQx
+    M2E2M2RjZTk3Y2U4YjdjNTA1ZWIwNDkxMGZkN2NiOTlkYjYzNjE4ODE0OTI4
+    ZWI5YzJkODVlMTk5MjZlNTQ4OTg1NmU4Njc1N2RiNTA0MmVlMTU=
+  data.tar.gz: !binary |-
+    MTIwOTk3NGYwY2ZmMmZjODg2MDE3YmIzOGEyYTg0ZTUwMmQ3NjAzZmNkZTZm
+    ZTI1ZTJkMDYwNzEwZjMzOTcwNWFlZWMxNzhjZmExN2I1MDhjODA5ZWI4Mzk2
+    MWQxYzZlZTQ3OGNjNjQ1MDJiY2EyNmUxNzhmZjNjMGQyOGI4Nzc=

data/bin/timert

@@ -0,0 +1,8 @@
+#!/usr/bin/env ruby
+
+require_relative "../lib/timert"
+
+DATABASE_PATH = ENV["HOME"] + "/.timert"
+
+app = Timert::Application.new(ARGV, DATABASE_PATH)
+puts app.result["message"]

data/lib/timert.rb

@@ -0,0 +1,10 @@
+require_relative 'timert/application'
+require_relative 'timert/argument_parser'
+require_relative 'timert/database'
+require_relative 'timert/database_file'
+require_relative 'timert/date_util'
+require_relative 'timert/day'
+require_relative 'timert/duration'
+require_relative 'timert/help'
+require_relative 'timert/report'
+require_relative 'timert/timer'

data/lib/timert/application.rb

@@ -0,0 +1,73 @@
+require_relative 'argument_parser'
+require_relative 'timer'
+require_relative 'date_util'
+require_relative 'database'
+require_relative 'database_file'
+require_relative 'report'
+require_relative 'help'
+
+module Timert
+  class Application
+    attr_reader :result
+
+    def initialize(argv, db_path)
+      @database = Database.new(DatabaseFile.new(db_path))    
+      @timer = Timer.new(@database.today)
+      @result = {}
+
+      parser = ArgumentParser.new(argv)
+      send(parser.action, *[parser.argument].compact)
+    end
+
+    private
+    def start(time = nil)
+      begin
+        timer_result = @timer.start(time)
+        if timer_result[:started]
+          add_message("start timer at #{format_hour(timer_result[:time])}")
+          @database.save(@timer.today)
+        else
+          add_message("timer already started at #{format_hour(timer_result[:time])}")
+        end    
+      rescue ArgumentError => e
+        add_message(e.message)
+      end
+    end
+
+    def stop(time = nil)
+      begin
+        timer_result = @timer.stop(time)
+        if timer_result[:stopped]      
+          add_message("stop timer at #{format_hour(timer_result[:time])}")
+          @database.save(@timer.today)
+        else
+          add_message("timer isn't started yet")
+        end    
+      rescue ArgumentError => e
+        add_message(e.message)
+      end
+    end
+
+    def report(time_expression)
+      add_message(Report.generate(@database, time_expression))
+    end
+
+    def add_task(task)    
+      add_message("added task: #{task}")
+      @timer.add_task(task)
+      @database.save(@timer.today)
+    end
+
+    def help
+      add_message(Help.generate)
+    end
+
+    def format_hour(timestamp)
+      DateUtil.format_hour(timestamp)
+    end
+
+    def add_message(msg)
+      @result["message"] = msg
+    end  
+  end
+end

data/lib/timert/argument_parser.rb

@@ -0,0 +1,53 @@
+require_relative "date_util"
+
+module Timert
+  class ArgumentParser
+    attr_reader :action, :argument
+
+    def initialize(args)
+      if args.empty?
+        @action = "help"
+        @argument = nil
+      elsif is_api?(args[0])      
+        @action = args[0]      
+        @argument = api_argument(@action, args[1])
+      else
+        @action = 'add_task'
+        @argument = args.join(" ")
+      end
+    end
+
+    private
+    def is_api?(method_name)
+      ["start", "stop", "report"].include?(method_name)
+    end
+
+    def api_argument(action, arg)
+      if is_time_method?(action)
+        parse_time(arg)
+      elsif is_report?(action)
+        parse_report_arg(arg)
+      end
+    end
+
+    def is_time_method?(method_name)
+      ["start", "stop"].include?(method_name)
+    end
+
+    def is_report?(method_name)
+      method_name == "report"
+    end
+
+    def is_month_or_week?(arg)
+      arg == "month" || arg == "week"
+    end
+
+    def parse_report_arg(arg)
+      is_month_or_week?(arg) ? arg : arg.to_i
+    end
+
+    def parse_time(arg)
+      DateUtil.parse_time(arg)
+    end
+  end
+end

data/lib/timert/database.rb

@@ -0,0 +1,62 @@
+require 'json'
+require_relative 'day'
+
+module Timert
+  class Database
+    
+    def initialize(file)
+      @file = file
+    end
+
+    def today
+      day
+    end
+
+    def day(date = Date.today)    
+      hash_to_day(load_data[key(date)], date)
+    end
+
+    def days(range)
+      entries = load_data
+      result = []
+      entries.each_pair do |date, day_hash|
+        day = hash_to_day(day_hash, Time.at(date.to_i).to_date)
+        if range.include?(day.date)
+          result << day
+        end
+      end 
+      result
+    end
+
+    def save(day)
+      current_data = load_data
+      current_data[key(day.date)] = day.to_hash
+      save_data(current_data)
+    end
+
+    private
+    
+    def load_data
+      @file.load
+    end
+
+    def save_data(hash)
+      @file.save(hash)
+    end
+
+    def key(date = nil)
+      date ? date.to_time.to_i.to_s : key(Date.today)
+    end
+
+    def hash_to_day(day_hash, date)
+      if day_hash
+        Day.new(
+          intervals: day_hash["intervals"], 
+          tasks: day_hash["tasks"],
+          date: date)
+      else
+        Day.new
+      end
+    end
+  end
+end

data/lib/timert/database_file.rb

@@ -0,0 +1,20 @@
+require 'json'
+
+module Timert
+  class DatabaseFile
+
+    def initialize(path)
+      @path = path
+    end
+
+    def load
+      File.open(@path, 'a+') do |file|
+        file.size > 0 ? JSON.load(file) : {}
+      end
+    end
+
+    def save(hash)
+      File.open(@path, 'w+') { |f| f.write(hash.to_json) }
+    end
+  end
+end

data/lib/timert/date_util.rb

@@ -0,0 +1,22 @@
+require 'date'
+
+module Timert
+  class DateUtil
+    
+    def self.format_hour(timestamp)
+      timestamp ? Time.at(timestamp).strftime("%H:%M:%S") : ""
+    end
+
+    def self.format_date(date)
+      date ? date.strftime("%Y-%m-%d") : ""
+    end
+
+    def self.parse_time(arg)
+      if arg
+        hours, minutes = arg.split(":")
+        now = Time.now
+        Time.new(now.year, now.month, now.day, hours, minutes).to_i
+      end
+    end
+  end
+end

data/lib/timert/day.rb

@@ -0,0 +1,109 @@
+module Timert
+  class Day
+
+    attr_reader :intervals, :tasks, :date
+    attr_accessor :on
+
+    def initialize(args = {})    
+      @intervals = args[:intervals] || []
+      @tasks = args[:tasks] || []  
+      @date = args[:date]
+      
+      raise ArgumentError.new("intervals should be an array") if !@intervals.is_a?(Array)
+      raise ArgumentError.new("tasks should be an array") if !@tasks.is_a?(Array)      
+    end
+
+    def add_start(time)
+      if !is_interval_started?      
+        if time <= last_start
+          raise ArgumentError.new("Invalid start time")
+        elsif time < last_stop
+          raise ArgumentError.new("Invalid start time. It's before the last stop time.")      
+        elsif !is_date_correct?(time)
+          raise ArgumentError.new("Invalid date")
+        end
+        @intervals.push({"start" => time}) 
+        time
+      end
+    end
+
+    def add_stop(time)
+      if is_interval_started?      
+        if time < last_start
+          raise ArgumentError.new("Invalid stop time")
+        elsif !is_date_correct?(time)
+          raise ArgumentError.new("Invalid date")
+        end
+        @intervals.last["stop"] = time 
+        time
+      end
+    end
+
+    def total_elapsed_time
+      total = 0
+      @intervals.each { |i| total += interval_duration(i) }
+      total
+    end
+
+    def add_task(task)
+      @tasks.push(task)
+    end
+
+    def to_hash
+      {
+        "tasks" => @tasks.uniq,
+        "intervals" => @intervals
+      }
+    end
+
+    def is_interval_started?
+      @intervals.length > 0 && 
+        @intervals.last["start"] && 
+        !@intervals.last["stop"]
+    end
+
+    def ==(other)
+      other.to_hash == to_hash
+    end
+
+    def last_start
+      last_interval['start'].to_i
+    end  
+
+    def last_stop
+      last_interval['stop'].to_i
+    end
+
+    private 
+    def interval_duration(interval)    
+      start, stop = interval["start"], interval["stop"]
+      if start      
+        stop ||= interval_end_when_start(start)
+        stop.to_i - start.to_i    
+      else
+        0
+      end
+    end
+
+    def last_interval
+      @intervals.length > 0 ? @intervals.last : {}
+    end
+
+    def is_date_correct?(timestamp)
+      !@date || Time.at(timestamp).to_date == @date 
+    end
+
+    def interval_end_when_start(timestamp)
+      day_is_today?(timestamp) ? Time.now.to_i : last_second_of_day(timestamp)    
+    end
+
+    def day_is_today?(timestamp)
+      Time.now.to_date == Time.at(timestamp).to_date
+    end
+
+    def last_second_of_day(timestamp)
+      time = Time.at(timestamp)
+      Time.new(time.year, time.month, time.day + 1, 0)
+    end
+  end
+end

data/lib/timert/duration.rb

@@ -0,0 +1,24 @@
+module Timert
+  class Duration
+    attr_reader :hours, :minutes, :seconds, :value
+
+    def initialize(duration)    
+      @hours = duration / 3600
+      @minutes = (duration % 3600) / 60
+      @seconds = duration % 60
+      @value = duration
+    end
+
+    def self.from(hours, minutes, seconds)
+      Duration.new(hours * 3600 + minutes * 60 + seconds)
+    end
+
+    def round
+      ((value / 1800.0).round / 2.0).to_s
+    end
+
+    def to_s
+      "#{hours}h #{minutes}min #{seconds}sec"
+    end
+  end
+end

data/lib/timert/help.rb

@@ -0,0 +1,21 @@
+module Timert
+    class Help
+      def self.generate
+        "usage: timert <command> [ARG]\n\n"\
+        "List of commands:\n"\
+        "   start [ARG]             Starts the timer. [ARG]: time.\n"\
+        "   stop [ARG]              Stops the timer. [ARG]: time.\n"\
+        "   report [ARG]            Displays a summary report. [ARG]: number, 'week' or 'month'.\n"\
+        "   <anything else>         Adds a task.\n\n"\
+        "Usage examples: \n"\
+        "   timert start            Starts the timer at the current time.\n"\
+        "   timert start 12:20      Starts the timer at the given time.\n"\
+        "   timert stop 14          Stops the timer at the given time.\n"\
+        "   timert report           Displays a summary for today.\n"\
+        "   timert report -1        Displays a summary for yesterday.\n"\
+        "   timert report week      Displays a summary for this week.\n"\
+        "   timert report month     Displays a summary report for this month.\n"\
+        "   timert writing emails   Adds a task: 'writing emails'."
+      end
+    end
+end

data/lib/timert/report.rb

@@ -0,0 +1,104 @@
+require 'colorize'
+require 'date'
+require_relative 'date_util'
+require_relative 'duration'
+
+module Timert
+  class Report
+    
+    def self.generate(database, time_expression = "")
+      if time_expression == "month"
+        report_for_month(database)
+      elsif time_expression == "week"
+        report_for_week(database)
+      else 
+        report_for_day(database, time_expression.to_i)
+      end
+    end
+
+    private
+    def self.report_for_week(database)
+      today = Date.today
+      first = today - today.cwday
+      last = first + 6
+      "REPORT FOR THIS WEEK\n".blue +
+        report_for_range(Range.new(first, last), database)
+    end
+
+    def self.report_for_month(database)
+      today = Date.today
+      first = Date.new(today.year, today.month, 1)
+      last = Date.new(today.year, today.month, -1)
+      "REPORT FOR THIS MONTH\n".blue +
+        report_for_range(Range.new(first, last), database)
+    end
+
+    def self.report_for_range(range, database)
+      days = database.days(range)
+      
+      s = "\nDay/time elapsed\n".green
+      total_time, total_rounded_duration = 0, 0
+      
+      days.each do |day|
+        duration = duration(day.total_elapsed_time)
+        s += "#{format_date(day.date)}: ".yellow + 
+          "#{duration.to_s} / #{duration.round} " +
+          "(#{format_tasks(day)})\n"
+        total_time += duration.value
+        total_rounded_duration += duration.round.to_f
+      end
+      
+      s += "\nTotal:\n".green
+      s += "#{parse_duration(total_time)} / #{total_rounded_duration}"
+      s
+    end
+
+    def self.report_for_day(database, day_counter = 0)
+      date = Date.today + day_counter
+      day = database.day(date)
+      if day      
+        "REPORT FOR #{format_date(date)}\n".blue + 
+          "\nTasks:\n".green + 
+          "#{format_tasks(day)}\n" + 
+          "\nWork time:\n".green + 
+          "#{format_intervals(day)}" + 
+          "\nTotal elapsed time:\n".green + 
+          "#{parse_duration(day.total_elapsed_time)}\n" + 
+          "\nSummary:\n".red + 
+          "#{round_duration(day.total_elapsed_time)} #{format_tasks(day)}"
+      else
+        "No data"    
+      end
+    end
+
+    def self.format_tasks(day)
+      day.tasks.length > 0 ? day.tasks.join(", ") : "-"
+    end
+
+    def self.format_intervals(day)
+      s = ""
+      day.intervals.each do |i| 
+        start = DateUtil.format_hour(i["start"])
+        stop = DateUtil.format_hour(i["stop"])
+        s += "#{start} - #{stop}\n"
+      end
+      s
+    end  
+
+    def self.format_date(date)
+      DateUtil.format_date(date)
+    end
+
+    def self.parse_duration(duration)
+      duration(duration).to_s
+    end
+
+    def self.duration(duration)
+      Duration.new(duration)
+    end
+
+    def self.round_duration(duration)
+      duration(duration).round
+    end
+  end
+end