ftg 2.0

data/lib/ftg.rb

@@ -0,0 +1,316 @@
+require_relative './colors'
+require_relative './utils'
+require_relative './ftg_options'
+require_relative './ftg_logger'
+require 'json'
+require 'date'
+
+class Ftg
+  include FtgOptions
+
+  def initialize
+    @commands = {
+      help: { fn: -> { help }, aliases: [] },
+      gtfo: { fn: -> {
+        gtfo(day_option, get_option(['--restore']), get_option(['--reset'])) # option union
+      }, aliases: [:recap, :leave, :wrap_up] },
+      status: { fn: -> { status }, aliases: [:stack] },
+      current: { fn: -> { current }, aliases: [] },
+      git_stats: { fn: -> { git_stats }, aliases: [] },
+      start: { fn: -> { start(ARGV[1]) }, aliases: [] },
+      stop: { fn: -> { stop(get_option(['--all'])) }, aliases: [:end, :pop] },
+      pause: { fn: -> { pause }, aliases: [] },
+      resume: { fn: -> { resume }, aliases: [] },
+      edit: { fn: -> {
+        edit(day_option, get_option(['--restore']), get_option(['--reset'])) # option union
+      }, aliases: [] },
+      list: { fn: -> { list(get_option(['--day', '-d'])) }, aliases: [:ls, :history, :recent] },
+      sync: { fn: -> { sync }, aliases: [] },
+      config: { fn: -> { config }, aliases: [] },
+      touch: { fn: -> { touch(ARGV[1]) }, aliases: [] },
+      delete: { fn: -> { delete(ARGV[1]) }, aliases: [:remove] },
+      email: { fn: -> { email(day_option) }, aliases: [:mail] },
+      migrate: { fn: -> { migrate }, aliases: [] },
+      console: { fn: -> { console }, aliases: [:shell] },
+      coffee: { fn: -> { coffee(get_option(['--big'])) } }
+    }
+
+    @ftg_dir = "#{ENV['HOME']}/.ftg"
+    private_config = JSON.parse(File.open("#{@ftg_dir}/config/private.json", 'r').read)
+    public_config = JSON.parse(File.open("#{@ftg_dir}/config/public.json", 'r').read)
+    @config = public_config.deep_merge(private_config)
+    @ftg_logger = FtgLogger.new(@ftg_dir)
+  end
+
+
+  def require_models
+    require 'active_record'
+    require_relative './models/task'
+    require_relative './migrations/create_tasks'
+    require_relative './task_formatter'
+
+    ActiveRecord::Base.establish_connection(
+      adapter: 'sqlite3',
+      database: 'db/ftg.sqlite3'
+    )
+    fail('Cannot open task connection') unless Task.connection
+  end
+
+  def run
+    help(1) if ARGV[0].nil?
+    cmd = get_command(ARGV[0])
+    fail("Unknown command #{ARGV[0]}") if cmd.nil?
+    cmd[1][:fn].call
+  end
+
+#####################################################################################
+####################################### COMMANDS ####################################
+#####################################################################################
+
+  def help(exit_code = 0)
+    help = <<-HELP
+Usage: ftg <command> [arguments...]
+By default, the day param is the current day.
+
+Command list:
+  start, stop, pause, resume <task>  Manage tasks
+  gtfo                               Executes: edit, sync, mail
+  edit <task> [-d <day>, --reset]    Manually edit times
+  sync [-d <day>]                    Sync times with jira and toggl
+  mail                               Send an email
+  stats [-d <day>]                   Show time stats
+  current                            Show current task
+  pop                                Stop current task and resume previous one
+  touch <task>                       Start and end a task right away
+  remove <task>                      Delete a task
+  list                               List of tasks/meetings of the day
+  config                             Show config files
+  console                            Open a console
+    HELP
+    puts help
+    exit(exit_code)
+  end
+
+  def config
+    require 'ap'
+    puts 'Settings are in the ./config folder:'
+    puts '  public.json     default settings. Do not edit manually. Added to git'
+    puts '  private.json    personal settings. This will overwrite public.json. Ignored in git'
+
+    puts "\nCurrent config:\n"
+    ap @config
+  end
+
+  def start(task)
+    if task == 'auto' || task == 'current_branch'
+      task = `git rev-parse --abbrev-ref HEAD`.strip
+    end
+    if task.nil? || task == ''
+      fail('Enter a task. Eg: ftg start jt-1234')
+    end
+    if @ftg_logger.on_pause?
+      status
+      fail("\nCannot start a task while on pause. Use \"ftg resume\" first")
+    end
+    if @ftg_logger.get_unclosed_logs.find { |l| l[:task_name] == task }
+      status
+      fail("\nTask #{task} already started")
+    end
+    @ftg_logger.add_log('ftg_start', task)
+    status
+    @ftg_logger.update_current
+  end
+
+  def stop(all)
+    @ftg_logger.get_unclosed_logs.each do |log|
+      @ftg_logger.add_log('ftg_stop', log[:task_name])
+      break unless all
+    end
+    status
+    @ftg_logger.update_current
+  end
+
+  def pause
+    if @ftg_logger.on_pause?
+      status
+      fail("\nAlready on pause")
+    end
+    @ftg_logger.add_log('ftg_start', 'pause')
+    status
+    @ftg_logger.update_current
+  end
+
+  def resume
+    @ftg_logger.add_log('ftg_stop', 'pause')
+    status
+    @ftg_logger.update_current
+  end
+
+  def touch(task)
+    @ftg_logger.add_log('ftg_start', task)
+    @ftg_logger.add_log('ftg_stop', task)
+    status
+  end
+
+  def delete(task)
+    if task == '--all'
+      @ftg_logger.remove_all_logs
+    end
+    @ftg_logger.remove_logs(task)
+    status
+    @ftg_logger.update_current
+  end
+
+  def gtfo(day, restore, reset)
+    edit(day, restore, reset)
+    email(day)
+    puts "sync soon..."
+  end
+
+  def status
+    current_logs = @ftg_logger.get_unclosed_logs
+    if current_logs.empty?
+      puts 'No current task'
+    else
+      task_name = current_logs[0][:task_name]
+      puts(task_name == 'pause' ? 'On pause' : "Now working on: [#{task_name.cyan}]")
+      unless current_logs[1..-1].empty?
+        puts "next tasks: #{current_logs[1..-1].map { |l| l[:task_name].light_blue }.join(', ')}"
+      end
+    end
+  end
+
+  def current
+    puts `cat #{@ftg_dir}/current.txt`
+  end
+
+  def edit(day, restore, reset)
+    require_relative './interactive'
+    require_relative './ftg_stats'
+    require_models
+
+    ftg_stats = FtgStats.new(day == Time.now.strftime('%F'))
+    tasks = []
+    Hash[ftg_stats.stats][day].each do |branch, by_branch|
+      next if branch == 'unknown'
+      by_idle = Hash[by_branch]
+      scope = Task.where(day: day).where(name: branch)
+      scope.delete_all if reset
+      task = scope.first_or_create
+      task.duration = task.edited_at ? task.duration : by_idle[false].to_i
+      task.save
+      tasks << task if restore || !task.deleted_at
+    end
+
+    deleted_tasks = Interactive.new.interactive_edit(tasks)
+    tasks.each do |task|
+      task.deleted_at = nil if restore
+      task.save if restore || task.changed.include?('edited_at')
+    end
+    deleted_tasks.each do |task|
+      task.save if task.changed.include?('deleted_at')
+    end
+  end
+
+  def sync
+    require_relative './ftg_sync'
+    abort('todo')
+  end
+
+  def git_stats
+    require_relative './ftg_stats'
+    FtgStats.new(false).run
+  end
+
+  def list(days)
+    days ||= 14
+    begin_time = Time.now.to_i - (days.to_i * 24 * 3600)
+
+    # Date.parse(day).to_time.to_i
+    git_branches_raw = `git for-each-ref --sort=-committerdate --format='%(refname:short) | %(committerdate:iso)' refs/heads/` rescue nil
+
+    git_branches = []
+    git_branches_raw.split("\n").map do |b|
+      parts = b.split(' | ')
+      next if parts.count != 2
+      timestamp = DateTime.parse(parts[1]).to_time.to_i
+      if timestamp > begin_time
+        git_branches << [timestamp, parts[0]]
+      end
+    end
+
+    commands_log_path = "#{@ftg_dir}/log/commands.log"
+    history_branches = []
+    `tail -n #{days * 500} #{commands_log_path}`.split("\n").each do |command|
+      parts = command.split("\t")
+      time = parts[5].to_i
+      branch = parts[4]
+      if time > begin_time && branch != 'no_branch'
+        history_branches << [time, branch]
+      end
+    end
+    history_branches = history_branches.group_by { |e| e[1] }.map { |k, v| [v.last[0], k] }
+
+    ftg_log_path = "#{@ftg_dir}/log/ftg.log"
+    ftg_tasks = []
+    `tail -n #{days * 100} #{ftg_log_path}`.split("\n").each do |log|
+      parts = log.split("\t")
+      task = parts[1]
+      time = parts[2].to_i
+      if time > begin_time
+        ftg_tasks << [time, task]
+      end
+    end
+    ftg_tasks = ftg_tasks.group_by { |e| e[1] }.map { |k, v| [v.last[0], k] }
+
+    all_tasks = git_branches + history_branches + ftg_tasks
+    all_tasks = all_tasks.sort_by { |e| -e[0] }.group_by { |e| e[1] }.map { |task, times| task }
+    puts all_tasks.join("\n")
+  end
+
+  def migrate
+    require_models
+    CreateTasks.new.up
+  end
+
+  def render_email(day, tasks)
+    max_len = TaskFormatter.max_length(tasks)
+    content = "Salut,\n\n<Expliquer ici pourquoi le sprint ne sera pas fini à temps>\n\n#{day}\n"
+    content += tasks.map do |task|
+      TaskFormatter.new.format(task, max_len).line_for_email
+    end.join("\n")
+    content
+  end
+
+  def email(day)
+    require_models
+    email = @config['ftg']['recap_mailto'].join(', ')
+    week_days_fr = ['lundi', 'mardi', 'mercredi', 'jeudi', 'vendredi', 'samedi', 'dimanche']
+    week_day_fr = week_days_fr[Date.parse(day).strftime('%u').to_i - 1]
+    week_day_en = Time.now.strftime('%A').downcase
+    greeting = @config['ftg']['greetings'][week_day_en] || nil
+    subject = "Recap #{week_day_fr} #{day}"
+
+    body = [render_email(day, Task.where(day: day).where(deleted_at: nil)), greeting].compact.join("\n\n")
+    system('open', "mailto: #{email}?subject=#{subject}&body=#{body}")
+  end
+
+  def console
+    require 'pry'
+    require_relative './interactive'
+    require_relative './ftg_stats'
+    require_models
+    binding.pry
+  end
+
+  def coffee(big = false)
+    require_relative './coffee'
+    puts(big ? Coffee.coffee2 : Coffee.coffee1)
+    puts "\nHave a nice coffee !"
+    puts '=========================================='
+    pause
+  end
+end
+
+
+# Ftg.new.run

data/lib/ftg_logger.rb

@@ -0,0 +1,67 @@
+class FtgLogger
+
+  def initialize(ftg_dir)
+    @ftg_dir = ftg_dir
+    @log_file = "#{ftg_dir}/log/ftg.log"
+  end
+
+  def add_log(command, task)
+    lines = [command, task, Time.now.getutc.to_i]
+    `echo "#{lines.join('\t')}" >> #{@log_file}`
+  end
+
+  def remove_all_logs
+    `echo "" > #{@log_file}`
+  end
+
+  def remove_logs(name)
+    count = 0
+    logs = get_logs
+    logs.keep_if do |log|
+      cond = log[:task_name] != name || log[:timestamp].to_i <= Time.now.to_i - 24*3600
+      count += 1 unless cond
+      cond
+    end
+
+    File.open(@log_file, 'w') do |f|
+      f.write(logs.map{|l| l.values.join("\t")}.join("\n") + "\n")
+    end
+
+    puts "Removed #{count} entries"
+  end
+
+  def get_logs
+    File.open(@log_file, File::RDONLY|File::CREAT) do |file|
+      file.read.split("\n").map do |e|
+        parts = e.split("\t")
+        { command: parts[0], task_name: parts[1], timestamp: parts[2] }
+      end
+    end
+  end
+
+  def on_pause?
+    unclosed_logs = get_unclosed_logs
+    unclosed_logs[0] && unclosed_logs[0][:task_name] == 'pause'
+  end
+
+  def get_unclosed_logs
+    unclosed_logs = []
+    closed = {}
+    get_logs.reverse.each do |log|
+      if log[:command] == 'ftg_stop'
+        closed[log[:task_name]] = true
+      end
+      if log[:command] == 'ftg_start' && !closed[log[:task_name]]
+        unclosed_logs << log
+      end
+    end
+    unclosed_logs
+  end
+
+  def update_current
+    current = ''
+    current_logs = get_unclosed_logs
+    current = current_logs[0][:task_name] unless current_logs.empty?
+    `echo "#{current}" > #{@ftg_dir}/current.txt`
+  end
+end

data/lib/ftg_options.rb

@@ -0,0 +1,28 @@
+module FtgOptions
+  def get_option(names)
+    ARGV.each_with_index do |opt_name, i|
+      return (ARGV[i + 1] || 1) if names.include?(opt_name)
+    end
+    nil
+  end
+
+  # day, not gay
+  def day_option
+    day_option = get_option(['-d', '--day'])
+    day_option ||= '0'
+
+    Utils.is_integer?(day_option) ?
+      Time.at(Time.now.to_i - day_option.to_i * 86400).strftime('%F') :
+      Date.parse(day_option).strftime('%F')
+  end
+
+  def get_command(name)
+    @commands.find { |cmd_name, _| cmd_name.to_s.start_with?(name) } ||
+      @commands.find { |_, cmd| cmd[:aliases] && cmd[:aliases].any? { |a| a.to_s.start_with?(name) } }
+  end
+
+  def fail(message = nil)
+    STDERR.puts message if message
+    exit(1)
+  end
+end

data/lib/ftg_stats.rb

@@ -0,0 +1,135 @@
+class FtgStats
+  IDLE_THRESHOLD = 5 * 60
+
+  attr_accessor :stats
+
+  def initialize(only_last_day)
+    load_data(only_last_day)
+    crunch
+    group
+  end
+
+  def run
+
+    display
+    # sync_toggl
+  end
+
+  def search_idle_key(timestamp)
+    (0..10).each do |k|
+      key = timestamp + k
+      return key if @idle_parts[key]
+    end
+    # puts("not found #{Utils.format_time(timestamp)}")
+    nil
+  end
+
+  def load_data(only_last_day)
+    home = `echo $HOME`.strip
+    ftg_dir = "#{home}/.ftg"
+    commands_log_path = "#{ftg_dir}/log/commands.log"
+    idle_log_path = "#{ftg_dir}/log/idle.log"
+    records_to_load = only_last_day ? 24 * 360 : 0
+    @commands = {}
+    @idle_parts = {}
+
+    # sample row:
+    # pinouchon       fg      no_alias        /Users/pinouchon/.ftg   no_branch       1438867098
+    (only_last_day ?
+      `tail -n #{records_to_load} #{commands_log_path}`.split("\n") :
+      File.foreach(commands_log_path)).each do |line|
+      parts = line.split("\t")
+      next if !parts[5] || parts[5].empty?
+      @commands[parts[5].strip.to_i] = { :user => parts[0],
+                                         :command => parts[1],
+                                         :alias => parts[2], :dir => parts[3], :branch => parts[4] }
+    end
+
+    (only_last_day ?
+      `tail -n #{records_to_load} #{idle_log_path}`.split("\n") :
+      File.foreach(idle_log_path)).each do |line|
+      parts = line.split("\t")
+      next if !parts[1] || parts[1].empty?
+      @idle_parts[parts[1].strip.to_i] = { :time_elapsed => parts[0] }
+    end
+  end
+
+  def crunch
+    # tagging branches in idle_parts
+    @commands.each do |timestamp, command_info|
+      if (key = search_idle_key(timestamp))
+        @idle_parts[key][:branch] = command_info[:branch]
+      end
+    end
+
+    # filling branches in idle_parts
+    # tagging thresholds in idle_parts
+    last_branch = 'unknown'
+    @idle_parts.each do |timestamp, part|
+      if part[:branch] && part[:branch] != '' && part[:branch] != 'no_branch'
+        last_branch = part[:branch]
+      end
+      # puts "setting to #{last_branch} (#{Time.at(timestamp).strftime('%Y/%m/%d at %I:%M%p')})"
+      @idle_parts[timestamp][:branch] = last_branch
+      @idle_parts[timestamp][:idle] = part[:time_elapsed].to_i > IDLE_THRESHOLD
+    end
+  end
+
+  def group
+    @stats = @idle_parts.group_by { |ts, _| Time.at(ts).strftime('%F') }.map do |day, parts_by_day|
+      [
+        day,
+        parts_by_day.group_by { |_, v| v[:branch] }.map do |branch, parts_by_branch|
+          [
+            branch,
+            parts_by_branch.group_by { |_, v| v[:idle] }.map { |k, v| [k, v.count*10] }
+          ]
+        end
+      ]
+    end
+  end
+
+  def display
+    Hash[@stats].each do |day, by_day|
+      puts "#{day}:"
+      Hash[by_day].each do |branch, by_branch|
+        by_idle = Hash[by_branch]
+        idle_str = by_idle[true] ? "(and #{Utils.format_time(by_idle[true])} idle)" : ''
+        puts "  #{branch}: #{Utils.format_time(by_idle[false]) || '00:00:00'} #{idle_str}"
+      end
+    end
+  end
+
+  def sync_toggl
+    require 'pry'
+    sync = FtgSync.new
+    i = 0
+
+    Hash[@stats].each do |day, by_day|
+      puts "#{day}:"
+      Hash[by_day].each do |branch, by_branch|
+        by_idle = Hash[by_branch]
+        idle_str = by_idle[true] ? "(and #{by_idle[true]} idle)" : ''
+        puts "  #{branch}: #{by_idle[false] || '00:00:00'} #{idle_str}"
+
+        if branch =~ /jt-/ && by_idle[false]
+          ps = day.split('-')
+          time = Time.new(ps[0], ps[1], ps[2], 12,0,0)
+          begining_of_day = Time.new(ps[0], ps[1], ps[2], 0,0,0)
+          end_of_day = begining_of_day + (24*3600)
+
+          jt = branch[/(jt-[0-9]+)/]
+          duration_parts = by_idle[false].split(':')
+          duration = duration_parts[0].to_i * 3600 + duration_parts[1].to_i * 60 + duration_parts[2].to_i
+          type = sync.maintenance?(jt) ? :maintenance : :sprint
+          sync.create_entry("#{branch} [via FTG]", duration, time, type)
+          i += 1
+
+          puts "logging #{branch}: #{by_idle[false]}"
+        end
+      end
+    end
+    puts "total: #{i}"
+  end
+
+end