syc-task 0.0.2 → 0.0.3

data/lib/syctask/meeting.rb

@@ -0,0 +1,23 @@
+require_relative 'times.rb'
+
+module Syctask
+
+ class Meeting
+
+    attr_accessor :starts
+    attr_accessor :ends
+    attr_accessor :title
+    attr_accessor :tasks
+
+    # Sets the busy time for the schedule. The busy times have to be provided
+    # as hh:mm-hh:mm. Optionally a title for the busy time can be provided 
+    def initialize(time, title="", tasks=[])
+      @starts = Syctask::Times.new(time[0..1])
+      @ends = Syctask::Times.new(time[2..3])
+      @title = title
+      @tasks = tasks
+    end
+
+  end
+
+end

data/lib/syctask/schedule.rb

@@ -0,0 +1,335 @@
+require_relative 'times.rb'
+require_relative 'meeting.rb'
+
+module Syctask
+
+  # Schedule represents a working day with a start and end time, meeting times
+  # and titles and tasks. Tasks can also be associated to meetings as in an
+  # agenda.
+  # Invokation example
+  #     work = ["8","30","18","45"]
+  #     busy = [["9","0","10","0"],["11","30","12","15"]]
+  #     titles = ["Ruby class room training","Discuss Ruby"]
+  #     tasks = [task1,task2,task3,task4,task5,task6]
+  #     schedule = Syctask::Schedule.new(work,busy,titles,tasks)
+  #     schedule.graph.each {|output| puts output}
+  #     
+  # This will create following output
+  #     Meetings
+  #     --------
+  #     A - Ruby class room training
+  #     B - Discuss Ruby
+  #
+  #         A         B
+  #     xxoo/////xxx|-////oooooxoooo|---|---|---|---|
+  #     8   9  10  11  12  13  14  15  16  17  18  19
+  #     1 2      3        4    5    
+  #                             6
+  #
+  #     Tasks
+  #     -----
+  #     0 - 1: task1
+  #     1 - 2: task2
+  #     2 - 3: task3
+  #     3 - 4: task4
+  #     4 - 5: task5
+  #     5 - 6: task6
+  #         
+  # Subsequent tasks are are displayed in the graph alternating with x and o.
+  # Meetings are indicated with / and the start is marked with A, B and so on.
+  # Task IDs are shown below the graph. The graph will be printed colored.
+  # Meetings in red, free times in green and tasks in blue. The past time is
+  # shown in black.
+  class Schedule
+    # Color of meetings
+    BUSY_COLOR = :red
+    # Color of free times
+    FREE_COLOR = :green
+    # Color of tasks
+    WORK_COLOR = :blue
+    # If tasks cannot be assigned to the working time this color is used
+    UNSCHEDULED_COLOR = :yellow
+    # Regex scans tasks and free times in the graph
+    GRAPH_PATTERN = /[\|-]+|\/+|[xo]+/
+    # Regex scans meetings in the graph
+    BUSY_PATTERN = /\/+/
+    # Regex scans free times in the graph
+    FREE_PATTERN = /[\|-]+/
+    # Regex scans tasks in the graph
+    WORK_PATTERN = /[xo]+/
+ 
+    # Start time of working day
+    attr_reader :starts
+    # End time of working day
+    attr_reader :ends
+    # Meetings assigned to the work time
+    attr_accessor :meetings
+    # Tasks assigned to the work time
+    attr_accessor :tasks
+
+    # Creates a new Schedule and initializes work time, busy times, titles and
+    # tasks. Work time is mandatory, busy times, titles and tasks are optional.
+    # Values have to be provided as
+    # * work time: [start_hour, start_minute, end_hour, end_minute]
+    # * busy time: [[start_hour, start_minute, end_hour, end_minute],[...]]
+    # * titles:    [title,...]
+    # * tasks:     [task,...]
+    def initialize(work_time, busy_time=[], titles=[], tasks=[])
+      @starts = Syctask::Times.new([work_time[0], work_time[1]])
+      @ends = Syctask::Times.new([work_time[2], work_time[3]])
+      @meetings = []
+      titles ||= []
+      busy_time.each.with_index do |busy,index|
+        title = titles[index] ? titles[index] : "Meeting #{index}"
+        @meetings << Syctask::Meeting.new(busy, title) 
+      end
+      @tasks = tasks
+    end
+
+    # Sets the assignments containing tasks that are assigned to meetings.
+    # Returns true if succeeds
+    def assign(assignments)
+      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]
+        end
+        @meetings[number].tasks.uniq!
+      end
+      true
+    end
+
+    # Creates a meeting list for printing. Returns the meeting list
+    def meeting_list
+      list = sprintf("%s", "Meetings\n").color(:red)
+      list << sprintf("%s", "--------\n").color(:red)
+      meeting_number = "A"
+      @meetings.each do |meeting|
+        list << sprintf("%s - %s\n", meeting_number, meeting.title).color(:red)
+        meeting_number.next!
+        meeting.tasks.each do |task|
+          task_color = task.done? ? :green : :blue
+          list << sprintf("%5s - %s\n", task.id, task.title).color(task_color)
+        end
+      end      
+      list
+    end
+
+    # Creates a meeting caption and returns it for printing
+    def meeting_caption
+      work_time, meeting_times = get_times
+      caption = ""
+      meeting_number = "A"
+      meeting_times.each do |times|
+        caption << ' ' * (times[0] - caption.size) + meeting_number 
+        meeting_number.next!
+      end
+      sprintf("%s", caption).color(:red)
+    end
+
+    # Creates the time caption for the time line
+    def time_caption
+      work_time = get_times[0]
+      caption = ""
+      work_time[0].upto(work_time[1]) do |time|
+        caption << time.to_s + (time < 9 ? ' ' * 3 : ' ' * 2)
+      end
+      sprintf("%s", caption)
+    end
+
+    # graph first creates creates the time line. Then the busy times are added.
+    # After that the tasks are added to the time line and the task caption and
+    # task list is created.
+    # graph returns the graph, task caption, task list and meeting list
+    # * time line
+    # * add meetings to time line
+    # * add tasks to time line
+    # * create task caption
+    # * create task list
+    # * create meeting caption
+    # * create meeting list
+    # * return time line, task caption, task list, meeting caption and meeting
+    # list
+    def graph
+      work_time, meeting_times = get_times
+      time_line = "|---" * (work_time[1]-work_time[0]) + "|"
+      meeting_times.each do |time|
+        time_line[time[0]..time[1]] = '/' * (time[1] - time[0]+1)
+      end
+
+      task_list, task_caption = assign_tasks_to_graph(time_line)
+
+      [meeting_list, meeting_caption,
+       colorize(time_line), time_caption, 
+       task_caption, task_list]
+    end
+
+    private 
+
+    # Colors the time line free time green, busy time red and tasks blue. The
+    # past time is colored black
+    def colorize(time_line)
+      time_line, future = split_time_line(time_line)
+      future.scan(GRAPH_PATTERN) do |part|
+        time_line << sprintf("%s", part).color(BUSY_COLOR) unless part.scan(BUSY_PATTERN).empty?
+        time_line << sprintf("%s", part).color(FREE_COLOR) unless part.scan(FREE_PATTERN).empty?
+        time_line << sprintf("%s", part).color(WORK_COLOR) unless part.scan(WORK_PATTERN).empty?
+      end if future
+      time_line
+    end
+
+    # Splits the time line at the current time. Returning the past part and the
+    # future part.
+    def split_time_line(time_line)
+      time = Time.now
+      offset = (time.hour - @starts.h) * 4 + time.min.div(15)      
+      past = time_line.slice(0,offset)
+      future = time_line.slice(offset, time_line.size - offset)
+      [past, future]
+    end
+
+    # 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)
+      unscheduled_tasks = []
+      signs = ['x','o']
+      positions = {}
+      position = 0
+      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?
+          unscheduled_tasks << task
+          next
+        end
+        time_line[position..(position + duration-1)] = 
+          signs[index%2] * duration
+        positions[position] = task.id
+      end
+
+      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
+
+      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?
+          color = :green
+        elsif unscheduled_tasks.find_index(task)
+          color = UNSCHEDULED_COLOR
+        else
+          color = WORK_COLOR
+        end
+        task_list << sprintf("%#{max_ord_size}d: %#{max_id_size}s - %s\n", i, task.id, task.title).
+                       color(color)
+      end
+
+      task_caption = ""
+      create_caption(positions).each do |caption| 
+        task_caption << sprintf("%s\n", caption).color(WORK_COLOR)
+      end
+
+      [task_list, task_caption]
+ 
+    end
+
+    # creates the caption of the graph with hours in 1 hour steps and task IDs
+    # that indicate where in the schedule a task is scheduled.
+    def create_caption(positions)
+      counter = 0
+      lines = [""]
+      positions.each do |position,id|
+        line_id = next_line(position,lines,counter)
+        legend = ' ' * [0, position - lines[line_id].size].max + id.to_s
+        lines[line_id] += legend
+        counter += 1
+      end
+      lines
+    end
+
+    # Creates a new line if the the task ID in the caption would override the
+    # task ID of a previous task. The effect is shown below
+    #     |xx-|//o|x--|
+    #     8   9  10  10
+    #      10    101 
+    #       11     2
+    # position is the position (time) within the schedule
+    # lines is the available ID lines (above we have 2 ID lines)
+    # counter is the currently displayed line. IDs are displayed alternating in
+    # each line, when we have 2 lines IDs will be printed in line 1,2,1,2...
+    def next_line(position, lines, counter)
+      line = lines[counter%lines.size]
+      return counter%lines.size if line.size == 0 or line.size < position - 1
+      lines.each.with_index do |line, index|
+        return index if line.size < position - 1
+      end
+      lines << ""
+      return lines.size - 1
+    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)
+      pattern = /(?!\/)[\|-]{#{count}}(?<=-|\||\/)/
+
+      positions = []
+      index = position
+      while index and index < graph.size
+        index = graph.index(pattern, index)
+        if index
+          positions << index
+          index += 1
+        end
+      end
+      positions
+    end
+
+    # Returns the tasks that are not assigned to meetings
+    def unassigned_tasks
+      assigned = []
+      @meetings.each do |meeting|
+        assigned << meeting.tasks
+      end
+      assigned.flatten!
+
+      unassigned = []
+      unassigned << @tasks
+      unassigned.flatten.delete_if {|task| assigned.find_index(task)}
+    end
+
+    public
+
+    # Retrieves the work and busy times transformed to the time line scale
+    def get_times
+      work_time = [@starts.h, @ends.round_up]
+      meeting_times = []
+      @meetings.each do |meeting|
+        meeting_time = Array.new(2)
+        meeting_time[0] = hour_offset(@starts.h, meeting.starts.h) + 
+          minute_offset(meeting.starts.m)
+        meeting_time[1] = hour_offset(@starts.h, meeting.ends.h) + 
+          minute_offset(meeting.ends.m)
+        meeting_times << meeting_time
+      end if @meetings
+      
+      times = [work_time, meeting_times]
+    end
+
+    private
+
+    # Transposes a time hour to a graph hour
+    def hour_offset(starts, ends)
+      (ends - starts) * 4
+    end
+
+    # Transposes a time minute to a graph minute
+    def minute_offset(minutes)
+      minutes.to_i.div(15)
+    end
+
+  end
+end

data/lib/syctask/task_planner.rb

@@ -0,0 +1,111 @@
+require 'fileutils'
+require_relative '../sycutil/console.rb'
+require_relative 'task_service.rb'
+
+module Syctask
+  PROMPT_STRING = '(a)dd, (c)omplete, (s)kip, (q)uit: '
+
+  class TaskPlanner
+    WORK_DIR = File.expand_path("~/.tasks")
+
+    def initialize
+      @console = Sycutil::Console.new
+      @service = TaskService.new
+      make_todo_today_file(Time.now.strftime("%Y-%m-%d"))
+    end
+
+    # List each task and prompt the user whether to add the task to the planned
+    # tasks. The user doesn't specify a duration for the task operation the
+    # duration will be set to 30 minutes which equals two time chunks. The
+    # count of planned tasks is returned
+    def plan_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 PROMPT_STRING
+        case choice
+        when 'a'
+          print "Duration (1 = 15 minutes, return 30 minutes): "
+          duration = gets.chomp
+          task.duration = duration.empty? ? 2 : 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
+
+    # Add the tasks to the planned tasks
+    def add_tasks(tasks)
+      save_tasks(tasks)
+    end
+
+    # Remove planned tasks from the task plan based on the provided filter
+    # (filter options see Task#matches?). Returns the count of removed tasks
+    def remove_tasks(date=Time.now.strftime("%Y-%m-%d"), filter={})
+      planned = []
+      tasks = self.get_tasks(date)
+      tasks.each do |task|
+        planned << task unless task.matches?(filter)
+      end
+      save_tasks(planned, true)
+      tasks.size - planned.size
+    end
+
+    # Get planned tasks of the specified date. Retrieve only tasks that match
+    # the specified filter (filter options see Task#matches?)
+    def get_tasks(date=Time.now.strftime("%Y-%m-%d"), filter={})
+      make_todo_today_file(date)
+      tasks = []
+      File.open(@todo_today_file, 'r') do |file|
+        file.each do |line|
+          dir, id = line.chomp.split(",")
+          task = @service.read(dir, id)
+          tasks << task if not task.nil? and task.matches?(filter)
+        end
+      end if File.exists? @todo_today_file
+      tasks
+    end
+
+   private
+
+    # Creates a file where the planned tasks are saved to
+    def make_todo_today_file(date)
+      file_name = Time.now.strftime("#{date}_planned_tasks")
+      @todo_today_file = WORK_DIR+"/"+file_name
+    end
+
+    # Save the tasks to a file. If override is true the file is overriden
+    # otherwise the tasks are appended
+    def save_tasks(tasks, override=false)
+      mode = override ? 'w' : 'a'
+      FileUtils.mkdir_p WORK_DIR unless File.exists? WORK_DIR
+      File.open(@todo_today_file, mode) do |file|
+        tasks.each do |task|
+          file.puts("#{task.dir},#{task.id}")
+        end 
+      end
+    end
+
+  end
+
+end

data/lib/syctask/task_scheduler.rb

@@ -0,0 +1,172 @@
+require_relative 'schedule.rb'
+
+module Syctask
+
+  # The TaskScheduler creates a graphical representation of a working schedule
+  # with busy times visualized. A typical invokation would be
+  #     work_time = "8:00-18:00"
+  #     busy_time = "9:00-9:30,13:00-14:30"
+  #     scheduler = Syctask::TaskScheduler.new(work_time, busy_time)
+  #     scheduler.print_graph
+  # The output would be
+  #     |---///-|---|---|---///////-|---|---|---|
+  #     8   9  10  11  12  13  14  15  16  17  18
+  # To add tasks to the schedule tasks have to provided (see Task). A task has
+  # a duration which indicates the time it is planned to process a task. The
+  # duration is an Integer 1,2,.. where 1 is 15 minutes and 2 is 30 minutes and
+  # so on. Assuming we have 5 tasks with a duration of 2, 5, 3, 2 and 3 15
+  # minute chunks. Then the invokation of 
+  #     scheduler.schedule_tasks(tasks)
+  # would output the schedule
+  #     |xx-///ooooo|xxx|oo-///////xxx--|---|---|
+  #     8   9  10  11  12  13  14  15  16  17  18
+  # The tasks are added to the schedule dependent on the time chunks and the
+  # available free time gaps. 
+  class TaskScheduler
+    # Time pattern that matches 24 hour times '12:30'
+    TIME_PATTERN = /(2[0-3]|[01]?[0-9]):([0-5]?[0-9])/
+
+    # Work time pattern scans time like '8:00-18:00'
+    WORK_TIME_PATTERN = /#{TIME_PATTERN}-#{TIME_PATTERN}/ 
+
+    # Busy time pattern scans times like '9:00-9:30,11:00-11:45'
+    BUSY_TIME_PATTERN = 
+      /#{TIME_PATTERN}-#{TIME_PATTERN}(?=,)|#{TIME_PATTERN}-#{TIME_PATTERN}$/
+
+    # Scans assignments of tasks to meetings 'A:0,2,4;B:3,4,5'
+    ASSIGNMENT_PATTERN = /([a-zA-Z]):(\d+(?:,\d+|\d+;)*)/ 
+
+    # Working directory
+    WORK_DIR = File.expand_path("~/.tasks")
+
+    # Creates a new TaskScheduler. 
+    def initialize
+      @work_time = []
+      @busy_time = []
+      @meetings = []
+      @tasks = []
+    end
+
+    # Set the work time. Raises an exception if begin time is after start time
+    # Invokation: set_work_time(["8","0","18","30"])
+    def set_work_time(work_time)
+      @work_time = process_work_time(work_time)
+      unless sequential?(@work_time)
+        raise Exception, "Begin time has to be before end time" 
+      end
+    end
+
+    # Set the busy times. Raises an exception if one begin time is after start
+    # time
+    # Invokation: set_busy_times([["9","30","10","45"],["12","0","13","45"]])
+    def set_busy_times(busy_time)
+      @busy_time = process_busy_time(busy_time)
+      @busy_time.each do |busy|
+        unless sequential?(busy)
+          raise Exception, "Begin time has to be before end time" 
+        end
+      end
+    end
+
+    # Sets the titles of the meetings (busy times)
+    # Invokation: set_meeting_titles("title1,title2,title3")
+    def set_meeting_titles(titles)
+      @meetings = titles.split(",") if titles
+    end
+
+    def set_tasks(tasks)
+      @tasks = tasks
+    end
+
+    # Add scheduled tasks to busy times
+    # Invokation: set_task_assignments([["A","1,2,3"],["B","2,5,6,7"]])
+    def set_task_assignments(assignments)
+      @assignments = assignments.scan(ASSIGNMENT_PATTERN)
+      raise "No valid assignment" if @assignments.empty? 
+    end
+
+    private
+
+    # Checks the sequence of begin and end time. Returns true if begin is before
+    # end time otherwise false
+    def sequential?(range)
+      return true if range[0].to_i < range[2].to_i
+      if range[0].to_i == range[2].to_i
+        return true if range[1].to_i < range[3].to_i
+      end
+      false
+    end
+    
+    # Scans the work time and separates hours and minutes. Raises an Exception
+    # if work time is nil or empty 
+    def process_work_time(work_time)
+      raise Exception, "Work time must not be nil" if work_time.nil?
+      time = work_time.scan(WORK_TIME_PATTERN).flatten
+      raise Exception, "Work time cannot be empty" if time.empty?
+      time
+    end
+    
+    # Scans the busy times and separates hours and minutes. 
+    def process_busy_time(busy_time)
+      busy_time = "" if busy_time.nil?
+      busy_time.scan(BUSY_TIME_PATTERN).each {|busy| busy.compact!}
+    end
+
+    public
+
+    # Restores the value of a previous invokation. Posible values are
+    # :work_time, :busy_time, :meetings and :assignments
+    # Returns true if a value from a previous call is available otherwise false
+    def restore(value)
+      work_time, busy_time, meetings, assignments = restore_state
+      @work_time   = work_time   if value == :work_time
+      @busy_time   = busy_time   if value == :busy_time
+      @meetings    = meetings    if value == :meetings
+      @assignments = assignments if value == :assignments
+      return false if value == :work_time   and (@work_time.nil? or @work_time.empty?)
+      return false if value == :busy_time   and (@busy_time.nil? or @busy_time.empty?)
+      return false if value == :meetings    and (@busy_time.nil? or @meetings.empty?)
+      return false if value == :assignments and (@assignments.nil? or @assignments.empty?)
+      true
+    end
+    
+    # Prints the meeting list, timeline and task list
+    def show
+      schedule = Syctask::Schedule.new(@work_time, @busy_time, @meetings, @tasks)
+      schedule.assign(@assignments) if @assignments
+      schedule.graph.each {|output| puts output}
+      save_state @work_time, @busy_time, @meetings, @assignments
+      true
+    end
+
+    private
+
+    # Saves the work time, busy time, meetings and assignments from the
+    # invokation for later retrieval
+    def save_state(work_time, busy_time, meetings, assignments)
+      state = {work_time: work_time, 
+               busy_time: busy_time, 
+               meetings: meetings, 
+               assignments: assignments}
+      FileUtils.mkdir WORK_DIR unless File.exists? WORK_DIR
+      state_file = WORK_DIR+'/'+Time.now.strftime("%Y-%m-%d_time_schedule")
+      File.open(state_file, 'w') do |file|
+        YAML.dump(state, file)
+      end
+    end
+
+    # Retrieves the state of the last invokation. Returns the work and busy
+    # time, meetings and assignments
+    def restore_state
+      state_file = WORK_DIR+'/'+Time.now.strftime("%Y-%m-%d_time_schedule")
+      return [[], [], [], []] unless File.exists? state_file
+      state = YAML.load_file(state_file)
+      [state[:work_time], 
+       state[:busy_time], 
+       state[:meetings], 
+       state[:assignments]]
+    end
+
+  end
+
+end

data/lib/syctask/times.rb

@@ -0,0 +1,19 @@
+module Syctask
+
+  class Times
+
+    attr_reader :h
+    attr_reader :m
+
+    def initialize(time)
+      @h = time[0].to_i
+      @m = time[1].to_i
+    end
+
+    def round_up
+      @m > 0 ? @h+1 : @h
+    end
+
+  end
+
+end

data/lib/syctask/version.rb

@@ -1,5 +1,5 @@
 # Syctask provides functions for managing tasks in a task list
 module Syctask
   #Holds the version number of syctask
-  VERSION = '0.0.2'
+  VERSION = '0.0.3'
 end

data/lib/syctask.rb

@@ -4,6 +4,8 @@ require 'syctask/task.rb'
 require 'syctask/task_service.rb'
 require 'syctask/task_scheduler.rb'
 require 'syctask/task_planner.rb'
+require 'syctask/schedule.rb'
+require 'sycutil/console.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/sycutil/console.rb

@@ -0,0 +1,60 @@
+require 'io/wait'
+
+# Module Inspector contains functions related to the Console that is helpers
+# for user input
+module Sycutil
+  
+  # Console provides functions for user input
+  class Console
+    
+    # Listens on Ctrl-C and exits the application
+    Signal.trap("INT") do
+      puts "-> program terminated by user"
+      exit
+    end
+
+    # Listens for key presses and returns the pressed key without pressing
+    # return
+    #
+    # :call-seq:
+    #   char_if_pressed
+    def char_if_pressed
+      begin
+        system("stty raw -echo")
+        c = nil
+        if $stdin.ready?
+            c = $stdin.getc
+        end
+        c.chr if c
+      ensure
+        system "stty -raw echo"
+      end
+    end
+
+    # Prompts the user for input.
+    #
+    # :call-seq:
+    #   prompt(choice_line) -> char
+    #
+    # choice_line is the prompt string. If the prompt string contains a (x)
+    # sequence x is a valid choice the is relized when pressed and returned.
+    def prompt(choice_line)
+      pattern = /(?<=\()./
+      choices = choice_line.scan(pattern)
+
+      choice = nil
+
+      while choices.find_index(choice).nil?
+        print choice_line 
+        choice = nil
+        choice = char_if_pressed while choice == nil
+        sleep 0.1
+        puts
+      end
+
+      choice
+    end
+
+  end
+
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: syc-task
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.0.3
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-03-10 00:00:00.000000000 Z
+date: 2013-03-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -154,8 +154,14 @@ files:
 - lib/syctask/version.rb
 - lib/syctask/task.rb
 - lib/syctask/task_service.rb
+- lib/syctask/task_planner.rb
 - lib/syctask/evaluator.rb
 - lib/syctask.rb
+- lib/syctask/task_scheduler.rb
+- lib/syctask/meeting.rb
+- lib/syctask/times.rb
+- lib/syctask/schedule.rb
+- lib/sycutil/console.rb
 - README.rdoc
 - syctask.rdoc
 homepage: http://syc.dyndns.org/drupal/syc-task