syc-task 0.0.7 → 0.1.15

data/lib/syctask.rb

@@ -5,9 +5,12 @@ require 'syctask/task_service.rb'
 require 'syctask/task_scheduler.rb'
 require 'syctask/task_planner.rb'
 require 'syctask/schedule.rb'
-require 'sycutil/console.rb'
 require 'syctask/task_tracker.rb'
+require 'syctask/environment.rb'
+require 'sycutil/console.rb'
 require 'syctime/time_util.rb'
+require 'syctask/settings.rb'
+require 'syctask/statistics.rb'
 
 # Add requires for other files you add to your project here, so
 # you just need to require this one file in your bin file

data/lib/syctask/environment.rb

@@ -1,6 +1,431 @@
 module Syctask
 
-  # Default working directory of the application
-  WORK_DIR = File.expand_path('~/.tasks')
+  # System directory of syctask
+  SYC_DIR = File.expand_path('~/.syc/syctask')
+  # ID file where the last issued ID is saved
+  ID = SYC_DIR + "/id"
+  # File that contains all issued IDs
+  IDS = SYC_DIR + "/ids"
+  # File with tags
+  TAGS = SYC_DIR + "/tags"
+  # File with the general purpose tasks
+  DEFAULT_TASKS = SYC_DIR + "/default_tasks"
+  # File that holds the default task directory
+  DEFAULT_TASKS_DIR = SYC_DIR + "/default_tasks_dir"
+  # Log file that logs all activities of syctask like creation of tasks
+  TASKS_LOG = SYC_DIR + "/tasks.log"
+  # File that holds the tracked task
+  TRACKED_TASK = SYC_DIR + "/tracked_tasks"
+  # If files are re-indexed during re-indexing these tasks are save here
+  RIDX_LOG = SYC_DIR + "/reindex.log"
+ 
+  # Reads the default task directory from the DEFAULT_TASKS_DIR file if it
+  # exists. If it exist but doesn't contain a valid directory ~/.tasks is 
+  # returned as default tasks directory
+  dir = File.read(DEFAULT_TASKS_DIR) if File.exists? DEFAULT_TASKS_DIR
+  # User specified default working directory
+  work_dir = dir if not dir.nil? and not dir.empty? and File.exists? dir
+  # Set eather user defined work directory or default
+  WORK_DIR = work_dir.nil? ? File.expand_path('~/.tasks') : work_dir
+
+  # Logs a task regarding create, update, done, delete
+  def log_task(type, task)
+    File.open(TASKS_LOG, 'a') do |file|
+      log_entry =  "#{type.to_s};"
+      log_entry += "#{task.id};#{task.dir};"
+      log_entry += "#{task.title.gsub(';', '\'semicolon\'')};"
+      log_entry += "#{Time.now};"
+      log_entry += "#{Time.now}" 
+      file.puts log_entry
+    end
+  end
+
+  # Logs the work time
+  def log_work_time(type, work_time)
+    today  = Time.now
+    begins = Time.local(today.year,
+                        today.mon,
+                        today.day,
+                        work_time[0],
+                        work_time[1],
+                        0)
+    ends   = Time.local(today.year,
+                        today.mon,
+                        today.day,
+                        work_time[2],
+                        work_time[3],
+                        0)
+    entry = "#{type};-1;;work;#{begins};#{ends}\n"
+    logs = File.read(TASKS_LOG)
+    return if logs.scan(entry)[0]
+    time_pat = "#{today.strftime("%Y-%m-%d")} \\d{2}:\\d{2}:\\d{2} [+-]\\d{4}"
+    pattern = %r{#{type};-1;;work;#{time_pat};#{time_pat}\n}
+    log = logs.scan(pattern)[0]
+    if log and logs.sub!(log, entry)
+      File.write(TASKS_LOG, logs)
+    else
+      File.open(TASKS_LOG, 'a') {|f| f.puts entry}
+    end
+  end
+
+  # Logs meeting times
+  def log_meetings(type, busy_time, meetings)
+    today = Time.now
+    logs = File.read(TASKS_LOG)
+    time_pat = "#{today.strftime("%Y-%m-%d")} \\d{2}:\\d{2}:\\d{2} [+-]\\d{4}"
+    pattern = %r{#{type};-2;;.*?;#{time_pat};#{time_pat}\n}
+    logs.gsub!(pattern, "")
+    busy_time.each_with_index do |busy,i|
+      begins = Time.local(today.year,today.mon,today.day,busy[0],busy[1],0)
+      ends   = Time.local(today.year,today.mon,today.day,busy[2],busy[3],0)
+      meeting = meetings[i] ? meetings[i] : "Meeting #{i}"
+      logs << "#{type};-2;;#{meeting};#{begins};#{ends}\n"
+    end
+    File.write(TASKS_LOG, logs)
+  end
+
+  # Checks whether all files are available that are needed for syctask's
+  # operation
+  def check_environment
+    FileUtils.mkdir_p WORK_DIR unless File.exists? WORK_DIR
+    unless viable?
+      unless get_files(File.expand_path("~"), "*.task").empty?
+        # Backup ARGV content
+        args = []
+        ARGV.each {|arg| args << arg} unless ARGV.empty?
+        ARGV.clear
+        puts
+        puts "Warning:"
+        puts "-------"
+        puts "There are missing system files of syc-task, even though tasks "+
+             "are available."
+        puts "If you have upgraded from version 0.0.7 or below than this is "+
+             "due to a changed\nfile structure. For changes in version "+
+             "greater 0.0.7 see"
+        puts "--> https://rubygems.org/gems/syc-task"
+        puts "Or you have accidentially deleted system files. In both cases "+
+             "re-indexing\nwill recover syc-task."
+        print "Do you want to recover syc-task (y/n)? "
+        answer = gets.chomp
+        exit -1 unless answer.downcase == "y"
+        reindex_tasks(File.expand_path("~"))
+        puts "Successfully recovered syc-task"
+        puts "-> A log file of re-indexed tasks can be found at\n"+
+             "#{RIDX_LOG}" if File.exists? RIDX_LOG
+        print "Press any key to continue "
+        gets
+        # Restore ARGV content
+        args.each {|arg| ARGV << arg} unless args.empty?
+      else
+        FileUtils.mkdir_p SYC_DIR unless File.exists? SYC_DIR
+        File.write(ID, "0")
+      end
+    end
+  end
+
+  # Checks if system files are available that are needed for running syc-task.
+  # Returns true if neccessary system files are available, otherwise false.
+  def viable?
+    File.exists? SYC_DIR and File.exists? ID 
+  end
+
+  # Re-indexing of tasks is done when tasks are available but SYC_DIR or ID file
+  # is missing. The ID file contains the last issued task ID. The ID file is
+  # referenced for obtaining the next ID for a new task. Re-indexing is done as
+  # follows:
+  # * Retrieve all tasks in and below the given directory *root*
+  # * Determine the highest ID number and add it to the ID file
+  # * Determine all tasks that don't have a unique ID
+  # * Re-index all tasks not having a unique ID and rename the file names
+  #   accordingly
+  # * Adjust the IDs in the planned_tasks, tasks.log and tracked_tasks files
+  # * Copy all system files planned_tasks, time_schedule, tasks.log, id to the
+  #   SYC_DIR directory if not already in the SYC_DIR directory. This should
+  #   only be if upgrading from version 0.0.7 and below.
+  def reindex_tasks(root)
+    FileUtils.mkdir_p SYC_DIR unless File.exists? SYC_DIR
+    new_id = {}
+    to_be_renamed = {}
+    root = File.expand_path(root)
+    puts "-> Collect task files..."
+    task_files = task_files(root)
+    puts "-> Restore ID counter..."
+    initialize_id(task_files)
+    print "-> Start re-indexing now..."
+    collect_by_id(task_files).each do |id, files|
+      next if files.size < 2
+      files.each_with_index do |file,i|
+        next if i == 0 # need to re-index only second and following tasks
+        result = reindex_task(file)
+        # associate old id to new id and dir name
+        if new_id[result[:old_id]].nil?
+          new_id[result[:old_id]] = {result[:dirname] => result[:new_id]}
+        else
+          new_id[result[:old_id]][result[:dirname]] = result[:new_id]
+        end 
+        # assign tmp_file to new_file for later renaming
+        to_be_renamed[result[:tmp_file]] = result[:new_file]
+        # document the re-indexing of tasks
+        log_reindexing(result[:old_id], result[:new_id], result[:new_file]) 
+      end
+    end 
+    to_be_renamed.each {|old_name,new_name| File.rename(old_name, new_name)}
+    puts
+    puts "-> Update task log file"
+    update_tasks_log(root, new_id)
+    puts "-> Update planned tasks files"
+    update_planned_tasks(root, new_id)
+    puts "-> Move schedule files..."
+    move_time_schedule_files(root)
+    puts "-> Update tracked task file..."
+    update_tracked_task(root)
+  end
+
+  # Re-indexes the tasks' IDs and renames the task files to match the new ID.
+  # The orginal file is deleted. Returns old_id, new_id, tmp_file_name and
+  # new_file_name. The task is save with the tmp_file_name in case the new ID
+  # and hence the new_file_name exists already from a not yet re-indexed task.
+  # After all tasks are re-indexed the tmp_file_names have to be renamed to the
+  # new_file_names. The renaming is in the responsibility of the calling method.
+  def reindex_task(file)
+    print "."
+    task = File.read(file)
+    old_id = task.scan(/(?<=^id: )\d+$/)[0]
+    new_id = next_id.to_s
+    task.gsub!(/(?<=^id: )\d+$/, new_id)
+    dirname = File.dirname(file)
+    new_file = "#{dirname}/#{new_id}.task"
+    tmp_file = "#{new_file}_"
+    File.write(tmp_file, task)
+    File.delete(file)
+    {old_id: old_id, 
+     new_id: new_id, 
+     tmp_file: tmp_file, 
+     new_file: new_file,
+     dirname: dirname}
+  end
+
+  # Determines the greatest task ID out of the provided tasks and saves it to
+  # the ID file
+  def initialize_id(tasks)
+    pattern = %r{(?<=\/)\d+(?=\.task)}
+    tasks.sort_by! {|t| t.scan(pattern)[0].to_i}
+    save_id(tasks[tasks.size-1].scan(pattern)[0].to_i)
+  end
+
+  # Saves the ids to ids file
+  def save_ids(id, file)
+    entry = "#{id},#{file}"
+    return if File.exists? IDS and not File.read(IDS).scan(entry).empty?
+    File.open(IDS, 'a') {|f| f.puts entry}
+  end
+
+  # Save the id to the ID file. Returns the id when save was successful
+  def save_id(id)
+    File.write(ID,id)
+    id
+  end
+
+  # Retrieve the next unassigned task id
+  def next_id
+    id = File.read(ID).to_i + 1
+    save_id(id)
+    id
+  end
+
+  # Logs if a task is re-indexed
+  def log_reindexing(old_id, new_id, file)
+    entry = "#{old_id},#{new_id},#{file}"
+    return if File.exists? RIDX_LOG and not File.read(RIDX_LOG).
+      scan(entry).empty?
+    File.open(RIDX_LOG, 'a') {|f| f.puts entry}
+  end
+
+  # Updates the tasks.log file if tasks are re-indexed with the task's new ids
+  def update_tasks_log(dir, new_ids)
+    tasks_log_files(dir).each do |file|
+      logs = File.readlines(file)
+      logs.each_with_index do |log,i|
+        type = log.scan(/^.*?(?=;)/)[0]
+        logs[i] = log.sub!("-",";") if log.scan(/(?<=^#{type};)\d+-/)[0]
+        old_id = log.scan(/(?<=^#{type};)\d+(?=;)/)[0]
+        next unless new_ids[old_id]
+        task_dir = log.scan(/(?<=^#{type};#{old_id};).*?(?=;)/)[0]
+        next unless new_ids[old_id][task_dir]
+        logs[i] = log.sub("#{old_id};#{task_dir}", 
+                          "#{new_ids[old_id][task_dir]};#{task_dir}")
+      end
+      if file == TASKS_LOG
+        File.write(TASKS_LOG, logs.join)
+      else
+        #TODO only append a line if it is not already available in TASKS_LOG
+        File.open(TASKS_LOG, 'a') {|f| f.puts logs.join}
+        FileUtils.rm file
+      end
+    end
+  end
+
+  # TODO delete
+  def update_tasks_log_old(dir, old_id, new_id, file)
+    old_entry = "#{old_id}-#{File.dirname(file)}"
+    # Append '/' to dir name so already updated task is not subsequently updated
+    new_entry = "#{new_id}-#{File.dirname(file)}/"
+    @tasks_log_files = tasks_log_files(dir) if @tasks_log_files.nil?
+    @tasks_log_files.each do |f|
+      tasks_log = File.read(f).gsub(old_entry, new_entry)
+      File.write(f, tasks_log)
+    end
+  end
+
+  # Replaces the old ids with the new ids in the planned tasks files. A planned
+  # tasks file has the form '2013-03-03_planned_tasks' and lives until syctask's
+  # version 0.0.7 in ~/.tasks directory. From version 0.1.0 on the planned tasks
+  # files live in the ~/.syc/syctask directory. So the calling method has the
+  # responsibility to copy or move the planned tasks files after they have been
+  # updated to the new planned tasks directory.
+  def update_planned_tasks(dir, new_ids)
+    planned_tasks_files(dir).each do |file|
+      tasks = File.readlines(file)
+      tasks.each_with_index do |task,i|
+        task_dir, old_id = task.chomp.split(',')
+        next unless new_ids[old_id]
+        next unless new_ids[old_id][task_dir]
+        tasks[i] = "#{task_dir},#{new_ids[old_id][task_dir]}"   
+      end
+      File.write("#{SYC_DIR}/#{File.basename(file)}", tasks.join("\n"))
+    end
+  end
+
+  # TODO delete
+  def update_planned_tasks_old(dir, old_id, new_id, file)
+    old_entry = "#{File.dirname(file)},#{old_id}"
+    # Append '/' to dir name so already updated task is not subsequently updated
+    new_entry = "#{File.dirname(file)}/,#{new_id}"
+    @planned_tasks_files = planned_tasks_files(dir) if @planned_tasks_files.nil?
+    @planned_tasks_files.each do |file|
+      planned_tasks = File.read(file).gsub(old_entry, new_entry)
+      File.write(file, planned_tasks)
+    end
+  end
+
+  # Updates tracked_tasks file if task has been re-indexed with new ID
+  def update_tracked_task(dir)
+    @tracked = get_files(dir, "tracked_tasks") if @tracked.nil?
+    return if @tracked.empty?
+    task = File.read(@tracked[0])
+    if File.exists? RIDX_LOG
+      old_id = task.scan(/(?<=id: )\d+$/)
+      old_dir = task.scan(/(?<=dir: ).*$/)
+      return if old_id.empty? or old_dir.empty?
+      pattern = %r{(?<=#{old_id[0]},)\d+(?=,#{old_dir[0]}\/\d+\.task)}
+      new_id = File.read(RIDX_LOG).scan(pattern)
+      task.gsub!("id: #{old_id}", "id: #{new_id}")
+    end
+    File.write(TRACKED_TASK, task)
+    FileUtils.rm @tracked[0] unless TRACKED_TASK == @tracked[0]
+  end
+
+  # Extracts tasks that have no unique id
+  def collect_by_id(tasks)
+    extract = {}
+    tasks.each do |task|
+      id = task.scan(/(?<=\/)\d+(?=\.task$)/)[0]
+      extract[id].nil? ? extract[id] = [task] : extract[id] << task
+    end
+    extract
+  end
+
+  # Retrieves all task files in and below the provided dir. Returns an array of
+  # task files
+  def task_files(dir)
+    get_files(dir, "*.task").keep_if {|file| file.match /\d+\.task$/}
+  end
+
+  # Retrieves all planned task files in and below the given directory
+  def planned_tasks_files(dir)
+    pattern = %r{\d{4}-\d{2}-\d{2}_planned_tasks}
+    get_files(dir, "*planned_tasks").keep_if {|f| f.match(pattern)}
+  end
+
+  # Retrieves all schedule files in and below the given directory
+  def time_schedule_files(dir)
+    pattern = %r{\d{4}-\d{2}-\d{2}_time_schedule}
+    get_files(dir, "*time_schedule").keep_if {|f| f.match(pattern)}
+  end
+
+  # Retrieves als tasks.log files in and below the given directory
+  def tasks_log_files(dir)
+    get_files(dir, "tasks.log")
+  end
+
+  # Retrieves all files that meet the pattern in and below the given directory
+  def get_files(dir, pattern)
+    original_dir = File.expand_path(".")
+    Dir.chdir(dir)
+    files = Dir.glob("**/#{pattern}", File::FNM_DOTMATCH).map do |f|
+      File.expand_path(f)
+    end
+    Dir.chdir(original_dir)
+    files
+  end
+
+  # Retrieve all directories that contain tasks
+  def get_task_dirs(dir)
+    original_dir = File.expand_path(".")
+    Dir.chdir(dir)
+    dirs = Dir.glob("**/*.task", File::FNM_DOTMATCH).map do |f|
+      File.dirname(File.expand_path(f))
+    end
+    Dir.chdir(original_dir)
+    dirs.uniq
+  end
+
+  # Retrieves all directories that contain tasks and the count of contained
+  # tasks in and below the provided directory
+  def get_task_dirs_and_count(dir)
+    original_dir = File.expand_path(".")
+    Dir.chdir(dir)
+    dirs_and_count = Hash.new(0)
+    Dir.glob("**/*.task", File::FNM_DOTMATCH).each do |f|
+      dirname = File.dirname(File.expand_path(f))
+      dirs_and_count[dirname] += 1
+    end
+    Dir.chdir(original_dir)
+    dirs_and_count
+  end
+
+  # Moves the tasks.log file to the system directory if not there. Should only
+  # be if upgrading from version 0.0.7 and below
+  def move_task_log_file(dir)
+    @tasks_log_files = tasks_log_files(dir) if @tasks_log_files.nil?
+    @tasks_log_files.each do |f|
+      next if f == TASKS_LOG
+      tasks_log = File.read(f)
+      File.open(TASKS_LOG, 'a') {|t| t.puts tasks_log}
+      FileUtils.mv(f, "#{f}_#{Time.now.strftime("%y%m%d")}")
+    end
+  end
+
+  # Moves the planned tasks file to the system directory if not there. Should 
+  # only be if upgrading from version 0.0.7 and below
+  def move_planned_tasks_files(dir)
+    @planned_tasks_files = planned_tasks_files(dir) if @planned_tasks_files.nil?
+    @planned_tasks_files.each do |file|
+      to_file = "#{SYC_DIR}/#{File.basename(file)}"
+      next if file == to_file
+      FileUtils.mv file, to_file
+    end
+  end
+
+  # Moves the schedule file to the system directory if not there. Should 
+  # only be if upgrading from version 0.0.7 and below
+  def move_time_schedule_files(dir)
+    @time_schedule_files = time_schedule_files(dir) if @time_schedule_files.nil?
+    @time_schedule_files.each do |file|
+      to_file = "#{SYC_DIR}/#{File.basename(file)}" 
+      next if file == to_file
+      FileUtils.mv file, to_file
+    end 
+  end
 
 end

data/lib/syctask/schedule.rb

@@ -1,7 +1,10 @@
 require_relative 'times.rb'
 require_relative 'meeting.rb'
 require_relative '../sycstring/string_util.rb'
+require_relative '../syctime/time_util.rb'
+
 include Sycstring
+include Syctime
 
 module Syctask
 
@@ -85,7 +88,10 @@ module Syctask
         title = titles[index] ? titles[index] : "Meeting #{index}"
         @meetings << Syctask::Meeting.new(busy, title) 
       end
-      raise Exception, "Busy times have to be within work time" unless within?(@meetings, @starts, @ends)
+      raise Exception, 
+        "Busy times have to be within work time" unless within?(@meetings, 
+                                                                @starts, 
+                                                                @ends)
       @tasks = tasks
     end
 
@@ -95,8 +101,10 @@ module Syctask
       assignments.each do |assignment|
         number = assignment[0].upcase.ord - "A".ord
         return false if number < 0 or number > @meetings.size
-        assignment[1].split(',').each do |index|
-          @meetings[number].tasks << @tasks[index.to_i] if @tasks[index.to_i]
+        @meetings[number].tasks.clear
+        assignment[1].split(',').each do |id|
+          index = @tasks.find_index{|task| task.id == id.to_i} 
+          @meetings[number].tasks << @tasks[index] if index and @tasks[index]
         end
         @meetings[number].tasks.uniq!
       end
@@ -109,7 +117,13 @@ module Syctask
       list << sprintf("%s", "--------\n").color(:red)
       meeting_number = "A"
       @meetings.each do |meeting|
-        list << sprintf("%s - %s\n", meeting_number, meeting.title).color(:red)
+        hint = "-"
+        hint = "*" if time_between?(Time.now, 
+                                    meeting.starts.time, 
+                                    meeting.ends.time)
+        list << sprintf("%s %s %s\n", meeting_number, 
+                                      hint, 
+                                      meeting.title).color(:red)
         meeting_number.next!
         meeting.tasks.each do |task|
           task_color = task.done? ? :green : :blue
@@ -156,14 +170,19 @@ module Syctask
     # list
     def graph
       work_time, meeting_times = get_times
+
+      heading = sprintf("+++ %s - %s-%s +++", Time.now.strftime("%Y-%m-%d"),
+                        @starts.time.strftime("%H:%M"),
+                        @ends.time.strftime("%H:%M")).color(:blue)
+
       time_line = "|---" * (work_time[1]-work_time[0]) + "|"
       meeting_times.each do |time|
-        time_line[time[0]..time[1]] = '/' * (time[1] - time[0]+1)
+        time_line[time[0]..time[1]-1] = '/' * (time[1] - time[0])
       end
 
       task_list, task_caption = assign_tasks_to_graph(time_line)
 
-      [meeting_list, meeting_caption,
+      [heading.center(80), meeting_list, meeting_caption,
        colorize(time_line), time_caption, 
        task_caption, task_list]
     end
@@ -214,23 +233,50 @@ module Syctask
     # Assigns the tasks to the timeline in alternation x and o subsequent tasks.
     # Returns the task list and the task caption
     def assign_tasks_to_graph(time_line)
+      done_tasks = [] 
       unscheduled_tasks = []
       signs = ['x','o']
       positions = {}
-      position = 0
+      current_time = Time.now
       unassigned_tasks.each.with_index do |task, index|
-        duration = task.duration.to_i
-        free_time = scan_free(time_line, duration, position)
-        position = free_time[0]
-        if position.nil?
+        if task.done? or not task.today?
+          done_tasks << task
+          next
+        else
+          round = task.remaining.to_i % 900 == 0 ? 0 : 0.5
+          duration = [(task.remaining.to_i/900+round).round, 1].max
+          position = [0, position_for_time(current_time)].max
+        end
+        free_time = scan_free(time_line, 1, position)
+        if free_time[0].nil?
           unscheduled_tasks << task
           next
         end
-        time_line[position..(position + duration-1)] = 
-          signs[index%2] * duration
-        positions[position] = task.id
+        0.upto(duration-1) do |i| 
+          break unless free_time[i]
+          time_line[free_time[i]] = signs[index%2]
+        end
+        positions[free_time[0]] = task.id
       end
 
+      unless done_tasks.empty?
+        end_position = position_for_time(current_time)
+        total_duration = 0
+        done_tasks.each_with_index do |task,index|
+          free_time = scan_free(time_line, 1, 0, end_position)
+          lead_time = task.duration.to_i - task.remaining.to_i + 0.0
+          max_duration = [free_time.size - (done_tasks.size - index - 1), 1].max
+          duration = [(lead_time/900).round, 1].max
+          total_duration += duration = [duration, max_duration].min
+          0.upto(duration-1) do |i|
+            break unless free_time[i]
+            time_line[free_time[i]] = signs[index%2]
+          end
+          positions[free_time[0]] = task.id if free_time[0]
+        end
+      end
+
+      # Create task list
       max_id_size = 1
       @tasks.each {|task| max_id_size = [task.id.to_s.size, max_id_size].max}
       max_ord_size = (@tasks.size - 1).to_s.size
@@ -238,20 +284,26 @@ module Syctask
       task_list = sprintf("%s", "Tasks\n").color(:blue)
       task_list << sprintf("%s", "-----\n").color(:blue)
       @tasks.each.with_index do |task, i|
-        if task.done?
+        if task.done? or not task.today?
           color = :green
         elsif unscheduled_tasks.find_index(task)
           color = UNSCHEDULED_COLOR
         else
           color = WORK_COLOR
         end
+
+        hint = "-"
+        hint = "~" unless task.today?
+        hint = "*" if task.tracked?
+
         offset = max_ord_size + max_id_size + 5
         title = split_lines(task.title, 80-offset)
         title = title.chomp.gsub(/\n/, "\n#{' '*offset}")
-        task_list << sprintf("%#{max_ord_size}d: %#{max_id_size}s - %s\n", 
-                             i, task.id, title).color(color)
+        task_list << sprintf("%#{max_ord_size}d: %#{max_id_size}s %s %s\n", 
+                             i, task.id, hint, title).color(color)
       end
 
+      # Create task caption
       task_caption = ""
       create_caption(positions).each do |caption| 
         task_caption << sprintf("%s\n", caption).color(WORK_COLOR)
@@ -267,6 +319,7 @@ module Syctask
       counter = 0
       lines = [""]
       positions.each do |position,id|
+        next unless position
         line_id = next_line(position,lines,counter)
         legend = ' ' * [0, position - lines[line_id].size].max + id.to_s
         lines[line_id] += legend
@@ -295,18 +348,28 @@ module Syctask
       return lines.size - 1
     end
 
+    # Determines the position within the time line for the given time. Each
+    # position represents a 15 minute duration. Minutes below 8 will be rounded
+    # down otherwise rounded up.
+    def position_for_time(time)
+      diff = @starts.diff(time)
+      # as the time line is always rounded down to the full hour we have to add
+      # the minutes with @starts.m / 15 to get the position for the current time
+      ((diff[0] * 60 + diff[1]) / 15.0).round + @starts.m / 15
+    end
+
     # Scans the schedule for free time where a task can be added to. Count
     # specifies the length of the free time and the position where to start
     # scanning within the graph
-    def scan_free(graph, count, position)
+    def scan_free(graph, count, starts, ends=graph.size)
       pattern = /(?!\/)[\|-]{#{count}}(?<=-|\||\/)/
 
       positions = []
-      index = position
-      while index and index < graph.size
+      index = starts
+      while index and index < ends
         index = graph.index(pattern, index)
         if index
-          positions << index
+          positions << index if index < ends
           index += 1
         end
       end