syc-task 0.0.7 → 0.1.15

data/lib/syctask/settings.rb

@@ -0,0 +1,43 @@
+require 'yaml'
+require_relative 'environment.rb'
+
+# Syctask module implements functions for managing tasks
+module Syctask
+
+  # Creates settings for syctask that are saved to files and retrieved when
+  # syctask is started
+  class Settings
+
+    # Creates general purpose tasks that can be tracked with syctask start. The
+    # general purpose files are saved to a file default_tasks in the syctask
+    # system directory
+    def tasks(tasks)
+      service = Syctask::TaskService.new
+      if File.exists? Syctask::DEFAULT_TASKS
+        general = YAML.load_file(Syctask::DEFAULT_TASKS)
+      else
+        general = {}
+      end
+      tasks.split(',').each do |task|
+        index = general.keys.find_index(task.upcase)
+        general[task.upcase] = service.create(Syctask::SYC_DIR,
+                                              {},
+                                              task.upcase) unless index
+      end
+      File.open(Syctask::DEFAULT_TASKS, 'w') {|f| YAML.dump(general, f)}
+    end
+
+    # Retrieves the general purpose files from the default_tasks file in the
+    # syctask system directory
+    def read_tasks
+      if File.exists? Syctask::DEFAULT_TASKS and not \
+         File.read(Syctask::DEFAULT_TASKS).empty?
+        YAML.load_file(Syctask::DEFAULT_TASKS) 
+      else
+        {}
+      end
+    end
+
+  end
+
+end

data/lib/syctask/statistics.rb

@@ -0,0 +1,196 @@
+require 'rainbow'
+require_relative '../syctime/time_util.rb'
+require_relative 'settings.rb'
+
+include Syctime
+
+module Syctask
+  
+  # Creates statistics about the work and meeting times as well about the task
+  # processing
+  class Statistics
+
+    # Initializes the Statistics object with the general purpose tassk
+    def initialize
+      settings = Settings::new
+      tasks = settings.read_tasks
+      @general_purpose_tasks = tasks.nil? ? [] : tasks.keys
+    end
+
+    # Creates a statistics report
+    def report(file, from="", to=from)
+
+      from, to, time_log, count_log = logs(file, from, to)
+      working_days = time_log["work"].count.to_s if time_log["work"]
+      working_days ||= "0"
+      value_size = {key: 0, total: 0, min: 0, max: 0, average: 0}
+      report_lines = {}
+      report = sprintf("%s to %s", "#{from.strftime("%Y-%m-%d")}".bright,
+                                   "#{to.strftime("%Y-%m-%d")}".bright) +
+               sprintf(" (%s working days)\n", working_days.bright) +
+               sprintf("%24s", "Total".bright) +
+               sprintf("%26s", "Min  ".bright) +
+               sprintf("%26s", "Max  ".bright) + 
+               sprintf("%29s", "Average\n".bright) 
+      report << sprintf("%s\n", "Time".bright)
+      time_log.each do |key,value|
+        total, min, max, average = stats(value)
+        total   = Syctime::separated_time_string(total, ":")
+        min     = Syctime::separated_time_string(min, ":")
+        max     = Syctime::separated_time_string(max, ":")
+        average = Syctime::separated_time_string(average, ":")
+        set_max_value_sizes(key, total, min, max, average, value_size)
+        report_lines[key] = [total, min, max, average]
+      end
+      
+      report << create_report_line_strings(report_lines, value_size)
+
+      report_lines = {}
+      value_size = {key: 0, total: 0, min: 0, max: 0, average: 0}
+      
+      report << sprintf("%s\n", "Count".bright)
+      count_log.each do |key,value|
+        total, min, max, average = stats_count(value)
+        set_max_value_sizes(key, total, min, max, average, value_size)
+        report_lines[key] = [total, min, max, average]
+      end
+
+      report << create_report_line_strings(report_lines, value_size)
+
+    end
+
+    # Creates report line strings
+    def create_report_line_strings(lines, value_size)
+      report = ""
+      lines.each do |key, value| 
+        total   = value[0]
+        min     = value[1]
+        max     = value[2]
+        average = value[3]
+        report << report_line(key, total, min, max, average, value_size)
+      end
+      report
+    end
+
+    # Determines the max string size of the values
+    def set_max_value_sizes(key, total, min, max, average, value_size)
+      value_size[:key]     = [value_size[:key],     key.size].max
+      value_size[:total]   = [value_size[:total],   total.size].max
+      value_size[:min]     = [value_size[:min],     min.size].max
+      value_size[:max]     = [value_size[:max],     max.size].max
+      value_size[:average] = [value_size[:average], average.size].max 
+    end
+
+    # Creates a report line for the report
+    def report_line(key, total, min, max, average, sizes={})
+      color = :green if key == 'task' 
+      color = :yellow if key == 'unplanned' or @general_purpose_tasks.
+                                                 find_index(key)
+      key = key[0..8]
+      report =  sprintf(" %s#{' '*(10-key.size)}", key).color(color)
+      report << sprintf("%#{sizes[:total]}s#{' '*(10-sizes[:total]+8)}", total).
+        color(color)
+      report << sprintf("%#{sizes[:min]}s#{' '*(10-sizes[:min]+8)}", min).
+        color(color)
+      report << sprintf("%#{sizes[:max]}s#{' '*(10-sizes[:max]+8)}", max).
+        color(color)
+      report << sprintf("%#{sizes[:average]}s\n", average).color(color)
+    end
+
+    # Calculates the average of a task processing, work or meeting time
+    def average(data)
+      sum = 0
+      data.each do |d|
+        sum += time_for_string(d[1]) - time_for_string(d[0])
+      end
+      sum / data.size
+    end
+
+    # Calculates the minimum duration of task processing, work or meeting time
+    def min(data)
+      diffs = []
+      data.each do |d|
+        diffs << time_for_string(d[1]) - time_for_string(d[0])
+      end
+      diffs.min
+    end
+
+    # Calculates the maximum duration of task processing, work or meeting time
+    def max(data)
+      diffs = []
+      data.each do |d|
+        diffs << time_for_string(d[1]) - time_for_string(d[0])
+      end
+      diffs.max
+    end
+
+    # Calculates total, min, max and average time of task processing, work or
+    # meeting time
+    def stats(data)
+      diffs = []
+      data.each do |d|
+        diffs << time_for_string(d[1]) - time_for_string(d[0])
+      end
+      [diffs.inject(:+), diffs.min, diffs.max, diffs.inject(:+) / diffs.size]
+    end
+
+    # Calculates the total, min, max and average count of task processing, 
+    # creation, update, done, delete
+    def stats_count(data)
+      count = []
+      data.each do |key,value|
+        count << value.to_i 
+      end
+      [count.inject(:+), count.min, count.max, count.inject(:+) / count.size]
+    end
+    
+    # Retrieves the log entries from the log file
+    def logs(file, from="", to=from)
+      times = []
+      time_data  = {}
+      time_types = %w{work meeting task}
+      time_types << @general_purpose_tasks
+      time_types.flatten!
+      count_data = {}
+      count_types = %w{meeting task create done update delete}
+      count_types << @general_purpose_tasks
+      count_types.flatten!
+      IO.readlines(file).each do |line|
+        values = line.split(";")
+        time = time_for_string(values[4])
+        times << time
+        next if values[0] == "start"
+        unless from == ""
+          next unless Syctime::date_between?(time, from, to)
+        end
+        values[0] = values[3] if @general_purpose_tasks.find_index(values[3])
+        values[0] = "task" if values[0] == "stop"
+        if count_types.find_index(values[0])
+          time = time.strftime("%Y-%m-%d")
+          count_data[values[0]] = {} unless count_data[values[0]]
+          count_data[values[0]][time] = 0 unless count_data[values[0]][time]
+          count_data[values[0]][time] += 1
+          if @general_purpose_tasks.find_index(values[0])
+            count_data['unplanned'] = {} unless count_data['unplanned']
+            count_data['unplanned'][time] = 0 unless \
+              count_data['unplanned'][time]
+            count_data['unplanned'][time] += 1
+          end 
+        end
+        if time_types.find_index(values[0])
+          time_data[values[0]] = [] unless time_data[values[0]]
+          time_data[values[0]] << [values[4],values[5]]
+          if @general_purpose_tasks.find_index(values[0])
+            time_data['unplanned'] = [] unless time_data['unplanned']
+            time_data['unplanned'] << [values[4],values[5]]
+          end
+        end
+      end
+      from = times.min if from == ""
+      to   = times.max if to   == ""
+      [from, to, time_data, count_data]
+    end
+
+  end
+
+end

data/lib/syctask/task.rb

@@ -1,6 +1,8 @@
 require 'fileutils'
 require 'rainbow'
 require_relative 'evaluator'
+require_relative 'environment.rb'
+require_relative 'task_tracker.rb'
 
 # Syctask provides functions for managing tasks in a task list
 module Syctask
@@ -25,9 +27,11 @@ module Syctask
     # ID of the task
     attr_reader :id
     # Duration specifies the planned time for processing the task
-    attr_accessor :duration
+    attr_reader :duration
+    # Remaining time is the duration subtracted by the lead time since last plan
+    attr_reader :remaining
     # Lead time is the time this task has been processed
-    attr_accessor :lead_time
+    attr_reader :lead_time
     # Creation date
     attr_reader :creation_date
     # Update date
@@ -45,6 +49,13 @@ module Syctask
       @options = options
       @options[:note] = 
                   "#{@creation_date}\n#{@options[:note]}\n" if @options[:note]
+      if @options[:follow_up] or @options[:due_date]
+        @duration = 2 * 15 * 60
+        @remaining = 2 * 15 * 60
+      else
+        @duration = 0
+        @remaining = 0
+      end
       @id = id
     end
     
@@ -69,6 +80,11 @@ module Syctask
     # supplemented with the new values and not overridden.
     def update(options)
       @update_date = Time.now.strftime("%Y-%m-%d - %H:%M:%S")
+      if options[:duration]
+        set_duration(options.delete(:duration).to_i * 15 * 60)
+      elsif options[:follow_up] or options[:due_date]
+        set_duration(2 * 15 * 60) if @duration.nil?
+      end
       options.keys.each do |key|
         new_value = options[key]
         
@@ -95,6 +111,28 @@ module Syctask
       !@updated_date.nil?
     end
 
+    # Sets the duration that this task is planned for processing. Assigns to
+    # remaining the duration time
+    def set_duration(duration)
+      @duration = duration
+      @remaining = duration
+    end
+
+    # Updates the lead time. Adds the lead time to @lead_time and calculates
+    # @remaining
+    def update_lead_time(lead_time)
+      if @lead_time
+        @lead_time += lead_time
+      else
+        @lead_time = lead_time
+      end
+      if @remaining
+        @remaining -= lead_time
+      else
+        @remaining = @duration.to_i - lead_time
+      end
+    end
+
     # Marks the task as done. When done than the done date is set. Optionally a
     # note can be provided.
     def done(note="")
@@ -102,6 +140,7 @@ module Syctask
       if note
         options[:note] = "#{@done_date}\n#{note}\n#{@options[:note]}"
       end
+      Syctask::log_task("done", self)
     end
 
     # Checks if this task is done. Returns true if done otherwise false
@@ -109,6 +148,23 @@ module Syctask
       !@done_date.nil?
     end
 
+    # Checks if task is scheduled for today. Returns true if follow up or due
+    # date is today otherwise false.
+    def today?
+      evaluator = Evaluator.new
+      today = Time.now.strftime("%Y-%m-%d")
+      evaluator.compare_dates(@options[:follow_up], today) or \
+       evaluator.compare_dates(@options[:due_date], today) 
+    end
+
+    # Checks whether the task is currently tracked. Returns true if so otherwise
+    # false
+    def tracked?
+      tracker = Syctask::TaskTracker.new
+      task = tracker.tracked_task
+      task.nil? ? false : task == self
+    end
+
     # Compares the provided elements in the filter with the correspondent
     # elements in the task. When all comparissons match than true is returned.
     # If one comparisson does not match false is returned. If filter is empty

data/lib/syctask/task_planner.rb

@@ -1,10 +1,15 @@
 require 'fileutils'
+require 'rainbow'
 require_relative '../sycutil/console.rb'
 require_relative 'task_service.rb'
+require_relative 'environment.rb'
 
 module Syctask
   # String that is prompted during planning
   PROMPT_STRING = '(a)dd, (c)omplete, (s)kip, (q)uit: '
+  # String that is prompted during inspect
+  INSPECT_STRING = '(e)dit, (d)one, de(l)ete, (p)lan, (c)omplete, (s)kip, '+
+                   '(q)uit: '
   # String that is prompted during prioritization
   PRIORITIZE_STRING = 'Task 1 has (h)igher or (l)ower priority, or (q)uit: '
 
@@ -12,7 +17,7 @@ module Syctask
   # be prioritized to determine the most to the least important tasks.
   class TaskPlanner
     # The task where the planned tasks are saved to
-    WORK_DIR = File.expand_path("~/.tasks")
+    WORK_DIR = Syctask::SYC_DIR #File.expand_path("~/.tasks")
 
     # Creates a new TaskPlanner
     def initialize
@@ -41,9 +46,71 @@ module Syctask
         choice = @console.prompt PROMPT_STRING
         case choice
         when 'a'
-          print "Duration (1 = 15 minutes, return 30 minutes): "
-          duration = gets.chomp
-          task.duration = duration.empty? ? 2 : duration
+          duration = 0
+          until duration > 0
+            print "Duration (1 = 15 minutes, RETURN defaults to 30 minutes): "
+            answer = gets.chomp
+            duration = answer.empty? ? 2 : answer.to_i
+          end
+          task.set_duration(units_to_time(duration))
+          task.options[:follow_up] = date
+          @service.save(task.dir, task)
+          planned << task
+          count += 1
+        when 'c'
+          re_display = true
+          redo
+        when 's'
+          #do nothing
+        when 'q'
+          break
+        end
+      end
+      save_tasks(planned)
+      count
+    end
+
+    # Inspect allows to edit, delete and mark tasks as done
+    def inspect_tasks(tasks, date=Time.now.strftime("%Y-%m-%d"))
+      already_planned = self.get_tasks(date)
+      count = 0
+      re_display = false
+      planned = []
+      tasks.each do |task|
+        next if already_planned.find_index {|t| t == task}
+        unless re_display
+          task.print_pretty
+        else
+          task.print_pretty(true)
+          re_display = false
+        end
+        choice = @console.prompt INSPECT_STRING
+        case choice
+        when 'e'
+          task_file = "#{task.dir}/#{task.id}.task"
+          system "vi #{task_file}" if File.exists? task_file
+          redo
+        when 'd'
+          puts "Enter a note or hit <RETURN>"
+          note = gets.chomp
+          task.done(note)
+          @service.save(task.dir, task)
+          STDOUT.puts sprintf("--> Marked task %d as done", 
+                              task.id).color(:green)
+        when 'l'
+          print "Confirm delete task (Y/n)? "
+          answer = gets.chomp
+          count = @service.delete(task.dir, {id: task.id.to_s}) if answer == "Y"
+          puts sprintf("--> Deleted %d task%s", 
+                       count, count == 1 ? "" : "s").color(:green)
+        when 'p'
+          duration = 0
+          until duration > 0
+            print "Duration (1 = 15 minutes, RETURN defaults to 30 minutes): "
+            answer = gets.chomp
+            duration = answer.empty? ? 2 : answer.to_i
+          end
+          task.set_duration(units_to_time(duration))
           task.options[:follow_up] = date
           @service.save(task.dir, task)
           planned << task
@@ -61,19 +128,25 @@ module Syctask
       count
     end
 
-    # Order tasks in the provided IDs sequence at the specified date. If not
-    # IDs are provided than rest of tasks is appended to the end of the plan.
-    # Returns the count of ordered tasks and the count of the rest of the tasks.
-    def order_tasks(date, ids)
+    # Order tasks in the provided IDs sequence at the specified date. If not all
+    # IDs are provided than rest of tasks is appended to the end of the plan. If
+    # a position (last, first and a number) is provided the ordered tasks are 
+    # inserted at the specified position. Returns the count of ordered tasks,
+    # the count of the rest of the tasks and the position where the ordered 
+    # tasks have been inserted.
+    def order_tasks(date, ids, pos=0)
       tasks = get_tasks(date)
+      pos = "0" if pos.class == String and pos.downcase == 'first'
+      pos = tasks.size.to_s if pos.class == String and pos.downcase == 'last'
       ordered = []
       ids.each do |id|
         index = tasks.find_index {|t| t.id == id.to_i}
         ordered << tasks.delete_at(index) if index
       end
-      ordered << tasks
-      save_tasks(ordered.flatten!, true)
-      [ordered.size - tasks.size, tasks.size]
+      pos = [pos.to_i.abs,tasks.size].min
+      tasks.insert(pos, ordered)
+      save_tasks(tasks.flatten!, true)
+      [ordered.size, tasks.size, pos]
     end
 
     # Prioritize tasks by pair wise comparisson. Each task is compared to the
@@ -119,13 +192,15 @@ module Syctask
       save_tasks(planned, true)
     end
 
-    # Moves the specified tasks to the specified date. Returns the count of
-    # moved files
+    # Moves the specified tasks to the specified date. Sets the remaining timer
+    # to at least 15 minutes and sets the duration to the remaining timer's 
+    # values. Returns the count of moved files
     def move_tasks(filter={}, from_date=Time.now.strftime("%Y-%m-%d"), to_date)
       return 0 if from_date == to_date
       moved = get_tasks(from_date, filter)
       moved.each do |task| 
         task.options[:follow_up] = to_date
+        task.set_duration([task.remaining, 900].max)
         @service.save(task.dir, task)
       end
       add_tasks(moved, to_date)
@@ -170,6 +245,12 @@ module Syctask
 
    private
 
+    # Calculates the time for time units. One time unit equals to 900 seconds or
+    # 15 minutes. The return value is in seconds
+    def units_to_time(units)
+      units * 15 * 60
+    end
+
     # Creates a file where the planned tasks are saved to
     def make_todo_today_file(date)
       file_name = Time.now.strftime("#{date}_planned_tasks")