syc-task 0.0.1

data/README.rdoc

@@ -0,0 +1,64 @@
+= Simple task organizer
+With syctask you can organize your tasks (inspired by David Bryant Copland's book <b>Build Awesome Command-Line Applications in Ruby</b>.
+
+==Install
+The application can be installed with
+    $ gem install syc-task
+
+== Usage
+syctask provides basic task organizer functions as create, update, list und complete a task. Addtional functions are to plan tasks you want to accomplish today. If you are not sure in which sequence to conduct the task you can prioritize them with a pair wise comparisson. You can time tasks with start and stop and you can finally extract tasks from a minutes of meetings file.
+
+===Create tasks with new
+Create a new task in the default task directory ~/.tasks
+    $ syctask "My first task"
+
+Provide a description
+    $ syctask "My first task" --description "Explanation of my first task"
+
+Schedule a task with a follow-up and due date
+    $ syctask "My first task" --follow-up "2013-02-25" --due "2013-03-11"
+
+Set a proirity for a task
+    $ syctask "My first task" --prio 3
+
+Except for --description you can also provide short forms for the options.
+
+===List tasks
+List tasks that are not marked as done in short form
+    $ syctask list
+
+List all tasks in long form
+    $ syctask list --all --complete
+
+Search tasks that match a pattern
+    $ syctask list --id "<10" --follow_up ">2013-02-25" --title "My \w task"
+
+===Update tasks
+Except for title and id all values can be updated. Note and tags are not
+overridden rather supplemented with the update value.
+
+Update task with ID 1 and provide some informative note
+    $ syctask update 1 --note "Some explanation about the progress on the task"
+
+===Complete tasks
+Complete the task with ID 1 and provide a final note
+    $ syctask done 1 --note "Finalize my first task"
+
+==Supported platform
+syc-task has been tested with 1.9.3
+
+==Notes
+As with version 0.0.1 only new, update, list and done is implemented.
+
+The test files live in the folder test and start with test_.
+
+There is a rake file available to run all tests
+    $ rake test
+
+==License
+syc-task is released under the {MIT License}[http://opensource.org/licenses/MIT]
+
+==Links
+* [http://www.github.com/sugaryourcoffee/syc-task] - Source code on GitHub
+* [http://syc.dyndns.org/drupal/wiki/syc-task] - Development notebook
+* [https://rubygems.org/gems/syc-backup] - RubyGems

data/bin/syctask

@@ -0,0 +1,258 @@
+#!/usr/bin/env ruby
+require 'gli'
+require 'syctask'
+include GLI::App
+
+program_desc 'A simple task manager'
+
+version Syctask::VERSION
+
+desc 'The directory where tasks are saved to'
+default_value File.expand_path('~/.tasks')
+arg_name 'TASK_DIR'
+flag [:t,:taskdir]
+
+desc 'Project name where tasks are saved'
+arg_name 'PROJECT'
+flag [:p, :project]
+
+desc 'Create a new task'
+arg_name 'TASK_TITLE'
+command :new do |c|
+  c.desc 'Priority of the task, 1 highes priority'
+  c.default_value 3
+  c.arg_name 'PRIO'
+  c.flag [:p, :prio], :type => Integer
+
+  c.desc 'Follow-up date'
+  c.arg_name 'FOLLOW-UP'
+  c.flag [:f, :follow_up], :must_match => /\d{4}-\d{2}-\d{2}/
+  
+  c.desc 'Due date'
+  c.arg_name 'DUE'
+  c.flag [:d, :due_date], :must_match => /\d{4}-\d{2}-\d{2}/
+
+  c.desc 'Description of the task'
+  c.arg_name 'DESCRIPTION'
+  c.flag :description
+
+  c.desc 'Note on progress of the task'
+  c.arg_name 'NOTE'
+  c.flag [:n, :note]
+
+  c.desc 'Tags that describe the task'
+  c.arg_name 'TAG1,TAG2,TAG3'
+  c.flag [:t, :tags], :must_match => /^\w+(?:,\w+)*/
+
+  c.action do |global_options,options,args|
+    filter = [:tags, :description, :prio, :due_date, :follow_up, 
+              :note]
+    options.keep_if {|key, value| filter.find_index(key)}
+    if args.empty?
+      STDOUT.puts "Reading new tasks from STDIN now... (end with CTRL-D)"
+      args = STDIN.readlines.map {|t| t.chomp}
+    end
+    task_numbers = nil
+    args.each do |title|
+      task_number = @service.create(global_options[:t], options, title)
+      if task_numbers.nil? 
+        task_numbers = task_number.to_s 
+      else 
+        task_numbers += ", #{task_number}"
+      end
+    end
+    if args.empty?
+      puts
+      help_now! "You have to provide at least a title to create a task"
+    else
+      STDOUT.puts sprintf("%s %s", "--> created tasks with task numbers",
+                          " #{task_numbers}").color(:green)
+    end
+  end
+end
+
+desc 'Extract tasks from a file'
+arg_name 'TASK_FILE'
+command :scan do |c|
+  c.action do |global_options,options,args|
+    puts "scan command not implemented yet"
+  end
+end
+
+desc 'List tasks'
+command :list do |c|
+
+  c.desc 'List all tasks done and open'
+  c.switch [:a, :all]
+  
+  c.desc 'Print complete task'
+  c.switch [:c, :complete]
+
+  c.desc 'Filter for ID'
+  c.arg_name 'ID1,ID2,ID3|[<|=|>]ID'
+  c.flag [:i, :id], :must_match => /^\d+(?:,\d+)*|^[<|=|>]\d+/ 
+
+  c.desc 'REGEXP as filter for title'
+  c.arg_name 'REGEXP'
+  c.flag [:title]
+
+  c.desc 'Filter for priority'
+  c.arg_name '[<|=|>]PRIO'
+  c.flag [:p, :prio], :must_match => /^\d+|^[<|=|>]\d+/
+
+  c.desc 'Filter for follow-up date'
+  c.arg_name '[<|=|>]DATE'
+  c.flag [:f, :follow_up], :must_match => /^(?:[<|=|>])?\d{4}-\d{2}-\d{2}/
+  
+  c.desc 'Filter for due date'
+  c.arg_name '[<|=|>]DATE'
+  c.flag [:d, :due_date], :must_match => /^(?:[<|=|>])?\d{4}-\d{2}-\d{2}/
+
+  c.desc 'REGEXP as filter for description'
+  c.arg_name 'REGEXP'
+  c.flag :description
+
+  c.desc 'REGEXP as filter for note'
+  c.arg_name 'REGEXP'
+  c.flag [:n, :note]
+
+  c.desc 'Tags or REGEXP as filter for tags'
+  c.arg_name 'TAG1,TAG2,TAG3|REGEXP'
+  c.flag [:t, :tags], :must_match => /^\w+(?:,\w+)*|\/.*\//
+
+  c.action do |global_options,options,args|
+    filter = [:id, :tags, :description, :prio, :due_date, :follow_up, 
+              :note, :title]
+    all = options[:all]
+    complete = options[:complete]
+    options.keep_if {|key, value| filter.find_index(key) and value != nil}
+    count = 0
+    @service.find(global_options[:t], options, all).each do |task|
+      task.print_pretty(complete)
+      count += 1
+    end      
+    STDOUT.puts sprintf("--> found %d tasks", count).color(:green)
+  end
+end
+
+desc 'Plan tasks for today'
+command :plan do |c|
+  c.action do |global_options,options,args|
+    puts "plan command not implemented yet"
+  end
+end
+
+desc 'Prioritize tasks'
+command :prio do |c|
+  c.action do |global_options,options,args|
+    puts "prio command not implemented yet"
+  end
+end
+
+desc 'Start and time a task'
+arg_name 'TASK_NUMBER'
+command :start do |c|
+  c.action do |global_options,options,args|
+    puts "start command not implemented yet"
+  end
+end
+
+desc 'Stop the running task'
+command :stop do |c|
+  c.action do |global_options,options,args|
+    puts "stop command not implemented yet"
+  end
+end
+
+desc 'Update the task'
+arg_name 'TASK_NUMBER'
+command :update do |c|
+  c.desc 'Priority of the task, 1 highes priority'
+  c.arg_name 'PRIO'
+  c.flag [:p, :prio], :type => Integer
+
+  c.desc 'Follow-up date'
+  c.arg_name 'FOLLOW-UP'
+  c.flag [:f, :follow_up], :must_match => /\d{4}-\d{2}-\d{2}/
+  
+  c.desc 'Due date'
+  c.arg_name 'DUE'
+  c.flag [:d, :due_date], :must_match => /\d{4}-\d{2}-\d{2}/
+
+  c.desc 'Description of the task'
+  c.arg_name 'DESCRIPTION'
+  c.flag :description
+
+  c.desc 'Note on progress of the task'
+  c.arg_name 'NOTE'
+  c.flag [:n, :note]
+
+  c.desc 'Tags that describe the task'
+  c.arg_name 'TAG1,TAG2,TAG3'
+  c.flag [:t, :tags], :must_match => /^\w+(?:,\w+)*/
+
+  c.action do |global_options,options,args|
+    help_now! "TASK_NUMBER required" if args.empty?
+    filter = [:tags, :description, :prio, :due_date, :follow_up, 
+              :note]
+    options.keep_if {|key, value| filter.find_index(key) and value != nil}
+
+    success = @service.update(global_options[:t], args[0], options) 
+    STDOUT.puts sprintf("sucessfully updated task with TASK_NUMBER ", args[0]).color(:green) if success
+    STDOUT.puts sprintf("could not update task with TASK_NUMBER ", args[0]).color(:red) unless success
+  end
+end
+
+desc 'Mark task as done'
+arg_name 'TASK_NUMBER'
+command :done do |c|
+  c.desc 'Print task after marked as done'
+  c.switch [:p, :print]
+  c.desc 'Print complete task'
+  c.switch [:c, :complete]
+
+  c.desc 'Final note for the task'
+  c.arg_name 'NOTE'
+  c.flag [:n, :note]
+
+  c.action do |global_options,options,args|
+    help_now!('TASK_NUMBER is required') if args.empty?
+    task = @service.read(global_options[:t], args[0])
+    exit_now!("Task with TASK_NUMBER #{args[0]} does not exist") unless task
+    task.done(options[:note])
+    @service.save(global_options[:t], task)
+    STDOUT.puts sprintf("Marked task with TASK_NUMBER %d as done", args[0]).color(:green)
+    task.print_pretty(options[:c]) if options[:p] 
+  end
+end
+
+pre do |global,command,options,args|
+  # Pre logic here
+  # Return true to proceed; false to abort and not call the
+  # chosen command
+  # Use skips_pre before a command to skip this block
+  # on that command only
+
+  @service = Syctask::TaskService.new
+
+  dir = File.expand_path(global[:t])
+  dir += "/" + global[:p] if global[:p]
+  global[:taskdir] = global[:t] = dir.squeeze("/")
+  
+ 
+  true
+end
+
+post do |global,command,options,args|
+  # Post logic here
+  # Use skips_post before a command to skip this
+  # block on that command only
+end
+
+on_error do |exception|
+  # Error logic here
+  # return false to skip default error handling
+  true
+end
+
+exit run(ARGV)

data/lib/syctask.rb

@@ -0,0 +1,7 @@
+require 'syctask/version.rb'
+require 'rainbow'
+require 'syctask/task.rb'
+require 'syctask/task_service.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/evaluator.rb

@@ -0,0 +1,80 @@
+# Syctask provides functions for managing tasks in a task list.
+module Syctask
+
+  # Evaluator provides different evaluatons for comparing numbers,
+  # dates and strings. Also provides methods to check whether a value is part 
+  # of a list
+  class Evaluator
+    # Pattern to match operands <|=|> followed by a number or a single number
+    NUMBER_COMPARE_PATTERN = /^(<|=|>)(\d+)|^(\d+)/
+    # Pattern to match comma separated values
+    CSV_PATTERN = /\w+(?=,)|(?<!<|=|>)\w+$/
+    # Pattern to match comma separated numbers
+    NUMBER_CSV_PATTERN = /\d+(?=,)|\d+$/
+    # Pattern to match a date prepended by <|=|> or a single date
+    DATE_COMPARE_PATTERN = /^(<|=|>)(\d{4}-\d{2}-\d{2})|(\d{4}-\d{2}-\d{2})/
+    # Pattern to match a date in the form of yyyy-mm-dd
+    DATE_PATTERN = /^\d{4}-\d{2}-\d{2}/
+    # Pattern that matches anything that is not prepended with <|=|>
+    NON_COMPARE_PATTERN = /[^<=>]*/
+
+    # Compares two numbers regarding <|=|>. Returns true if the comparisson
+    # succeeds otherwise false. If eather value or pattern is nil false is
+    # returned. If value is empty false is returned. 
+    def compare_numbers(value, pattern)
+      return false if value.nil? or pattern.nil?
+      return false if value.class == String and value.empty?
+      result = pattern.match(NUMBER_COMPARE_PATTERN)
+      return false unless result
+      compare(value, result.captures)
+    end
+
+    # Compares two dates regarding <|=|>. Returns true if the comparisson
+    # succeeds otherwise false. If eather value or pattern is nil false is
+    # returned. 
+    def compare_dates(value, pattern)
+      return false if value.nil? or pattern.nil?
+      result = pattern.match(DATE_COMPARE_PATTERN)
+      return false unless result
+      value = "'#{value}'"
+      captures = result.captures.collect! do |c| 
+        c and c.match(DATE_PATTERN) ? "'#{c}'" : c
+      end
+      compare(value, captures)
+    end
+
+    # Compares two values regarding <|=|>. Returns true if the comparisson
+    # succeeds otherwise false. If eather value or operand is nil false is
+    # returned. 
+    def compare(value, operands)
+
+      if operands[2]
+        operands[0] = "=="
+        operands[1] = operands[2]
+      elsif operands[0] == "="
+        operands[0] = "=="
+      end
+
+      expression = "#{value} #{operands[0]} #{operands[1]}"
+      eval(expression) 
+    end
+
+    # Evaluates whether value is part of the provided csv pattern. Returns true
+    # if it evaluates to true otherwise false. If value or pattern is nil false
+    # is returned. 
+    def includes?(value, pattern)
+      return false if value.nil? or pattern.nil?
+      captures = pattern.scan(CSV_PATTERN)
+      !captures.find_index(value.to_s).nil?
+    end
+
+    # Evaluates if value matches the provided regex. Returns true if a match is
+    # found. If value or regex is nil false is returned.
+    def matches?(value, regex)
+      return false if value.nil? or regex.nil?
+      !value.match(Regexp.new(regex, true)).nil?
+    end
+
+  end
+
+end

data/lib/syctask/task.rb

@@ -0,0 +1,229 @@
+require 'fileutils'
+require 'rainbow'
+require_relative 'evaluator'
+
+# Syctask provides functions for managing tasks in a task list
+module Syctask
+
+  # A Task is the basic element of the task list and holds all information
+  # about a task.
+  class Task
+
+    # Holds the options of the task. 
+    # Options are
+    # * description - additional information about the task
+    # * follow_up - follow-up date of the task
+    # * due - due date of the task
+    # * prio - priority of the task
+    # * note - information about the progress or state of the task
+    # * tags - can be used to search for tasks that belong to a certain category
+    attr_accessor :options
+    # Title of the class
+    attr_reader :title
+    # ID of the task
+    attr_reader :id
+    # Creation date
+    attr_reader :creation_date
+    # Update date
+    attr_reader :update_date
+    # Done date
+    attr_reader :done_date
+    # Directory where the file of the task is located
+    attr_reader :dir
+
+    # Creates a new task. If the options contain a note than the current date
+    # and time is added.
+    def initialize(options={}, title, id)
+      @creation_date = Time.now.strftime("%Y-%m-%d - %H:%M:%S")
+      @title = title
+      @options = options
+      @options[:note] = 
+                  "#{@creation_date}\n#{@options[:note]}\n" if @options[:note]
+      @id = id
+    end
+    
+    # Updates the task with new values. Except for note and tags which are
+    # supplemented with the new values and not overridden.
+    def update(options)
+      @update_date = Time.now.strftime("%Y-%m-%d - %H:%M:%S")
+      options.keys.each do |key|
+        new_value = options[key]
+        
+        case key
+        when :note
+          new_value = "#{@update_date}\n#{new_value}\n#{@options[key]}"
+        when :tags
+          if @options[key].include? new_value
+            new_value = @options[key]
+          else
+            new_value = "#{@options[key]},#{new_value}"
+          end
+        end
+
+        @options[key] = new_value
+      end 
+    end
+
+    # Checks whether this task has been updated. Returns true if updated
+    # otherwise false
+    def update?
+      !@updated_date.nil?
+    end
+
+    # Marks the task as done. When done than the done date is set. Optionally a
+    # note can be provided.
+    def done(note="")
+      @done_date = Time.now.strftime("%Y-%m-%d - %H:%M:%S")
+      if note
+        options[:note] = "#{@done_date}\n#{note}\n#{@options[:note]}"
+      end
+    end
+
+    # Checks if this task is done. Returns true if done otherwise false
+    def done?
+      !@done_date.nil?
+    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
+    # than true is returned. The values can be compared regarding <, =, > or 
+    # whether the task's value is part of a list of provided values. It is also
+    # possible to provide a regex as a filter. Following comparissons are
+    # available
+    # Value                           Compare
+    # :title                          regex
+    # :description                    regex
+    # :id                             contains, <|=|> no operator same as =
+    # :prio                           contains, <|=|> no operator same as =
+    # :tags                           contains, regex
+    # :follow_up                      <|=|>
+    # :due                            <|=|>
+    def matches?(filter = {})
+      return true if filter.empty?
+      evaluator = Evaluator.new
+      filter.each do |key, value|
+        matches = false
+        case key
+        when :title, :t
+          matches = evaluator.matches?(@title, value)
+        when :description
+          matches = evaluator.matches?(@options[:description], value)
+        when :id, :i, "id", "i"
+          matches = (evaluator.includes?(@id, value) or 
+                     evaluator.compare_numbers(@id, value))
+        when :prio, :p
+          matches = (evaluator.includes?(@options[:prio], value) or
+                     evaluator.compare(@options[:prio], value))
+        when :tags
+          matches = evaluator.matches?(@options[:tags], value)
+        when :follow_up, :f, :d, :due_date
+          matches = evaluator.compare_dates(@options[key], value)
+        end
+        return false unless matches
+      end
+      true
+    end
+
+    # Prints the task in a formatted way eather all values when long is true
+    # or only id, title, prio, follow-up and due date.
+    def print_pretty(long=false)
+      pretty_string(long)
+    end
+
+    # Prints the task as a CSV
+    def print_csv
+      STDOUT.puts(csv_string)
+    end
+
+    private
+
+    # Creates the directory if it does not exist
+    def create_dir(dir)
+      fileutils.mkdir_p dir unless file.exists? dir
+    end
+
+    # creates the task's id based on the tasks available in the task directory.
+    # the task's file name is in the form id.task. create_task_id determines
+    # the biggest number and adds one to create the task's id.
+    def create_task_id
+      tasks = dir.glob("#{@dir}/*")
+      ids = []
+      tasks.each {|task| ids << task.scan(/^\d+(?=\.task)/)[0].to_i }
+      if ids.empty?
+        @id = 1
+      elsif
+        @id = ids[ids.size-1] + 1
+      end
+    end
+
+    # Prints the task formatted. Values that are nil are not printed. A type all
+    # will print all available values. Otherwise only ID, title, description,
+    # prio, follow-up and due date are printed.
+    def pretty_string(long)
+      color = :default
+      color = :green if self.done?
+
+      puts sprintf("%04d - %s", @id, @title.bright).color(color)
+      puts sprintf("%6s %s", " ", @options[:description]).color(color) if @options[:description]
+      puts sprintf("%6s Prio: %s", " ", @options[:prio]).color(color) if @options[:prio]
+      puts sprintf("%6s Follow-up: %s", " ", @options[:follow_up]).color(color) if @options[:follow_up]
+      puts sprintf("%6s Due: %s", " ", @options[:due]).color(color) if @options[:due]
+      if long
+        if @options[:note]
+          note = split_lines(@options[:note].chomp, 70)
+          note = note.chomp.
+            gsub(/\n(?!\d{4}-\d{2}-\d{2} - \d{2}:\d{2}:\d{2})/, "\n#{' '*9}") 
+          note = note.
+            gsub(/\n(?=\d{4}-\d{2}-\d{2} - \d{2}:\d{2}:\d{2})/, "\n#{' '*7}")
+          puts sprintf("%6s %s", " ", note.chomp).color(color)
+        end
+        puts sprintf("%6s Tags: %s", " ", @options[:tags]).color(color) if @options[:tags]
+        puts sprintf("%6s Created: %s", " ", @creation_date).color(color)
+        puts sprintf("%6s Updated: %s", " ", @update_date).color(color) if @update_date
+        puts sprintf("%6s Closed: %s", " ", @done_date).color(color) if @done_date
+      end
+    end
+
+    # Prints all values as a csv separated with ";". This string can be read by
+    # another application. The values are
+    # id;title;description;prio;follow-up;due;note;tags;created;
+    # updated|UNCHANGED;DONE|OPEN
+    def csv_string
+      string = "\n#{@id};#{@title};"
+      string +" #{@options[:description]};#{@options[:prio]};"
+      string += "#{@options[:follow_up]};#{@options[:due]};"
+      string += "#{@options[:note].gsub(/\n/, '\\n')};"
+      string += "#{@options[:tags]};"
+      string += "#{@creation_date};"
+      string += "#{@udpate_date ? "UPDATED" : "UNCHANGED"};"
+      string += "#{@done_date ? "DONE" : "OPEN"}\n"
+      string
+    end
+
+    # Splits a string to size (chars) less or equal to length
+    def split_lines(string, length)
+      lines = string.squeeze(" ").split("\n")
+      i = 0
+      new_lines = []
+      new_lines[i] = ""
+      lines.each do |line|
+        line.squeeze(" ").split.each do |w|
+          if new_lines[i].length + w.length < length
+            new_lines[i] += "#{w} "
+          else
+            i += 1
+            new_lines[i] = "#{w} "
+          end
+        end
+        i += 1
+        new_lines[i] = ""
+      end
+      text = ""
+      new_lines.each {|l| text << "#{l}\n"}
+      text.chomp
+    end
+
+  end
+
+end

data/lib/syctask/task_service.rb

@@ -0,0 +1,108 @@
+require 'yaml'
+
+# Syctask provides functions for managing tasks in a task list
+module Syctask
+
+  # Provides services to operate tasks as create, read, find, update and save
+  # Task objects
+  class TaskService
+
+    # Creates a new task in the specified directory, with the specified options
+    # and the specified title. If the directory doesn't exist it is created.
+    # When the task is created it is assigned a unique ID within the directory.
+    # Options are
+    # * description - additional information about the task
+    # * follow_up - follow-up date of the task
+    # * due  - due date of the task
+    # * prio - priority of the task
+    # * note - information about the progress or state of the task
+    # * tags - can be used to searching tasks that belong to a certain category
+    def create(dir, options, title)
+      create_dir(dir)
+      task = Task.new(options, title, create_id(dir))
+      save(dir, task)
+      task.id
+    end
+
+    # Reads the task with given ID id located in given directory dir. If task
+    # does not exist nil is returned otherwise the task is returned
+    def read(dir, id)
+      task = nil
+      Dir.glob("#{dir}/*").each do |file|
+        task = YAML.load_file(file) if File.file? file
+        return task if task and task.id == id.to_i
+      end
+      nil
+    end
+
+    # Finds all tasks that match the given filter. The filter can be provided
+    # for :id, :title, :description, :follow_up, :due, :tags and :prio.
+    # id can be eather a selection of IDs ID1,ID2,ID3 or a comparison <|=|>ID.
+    # title and :description can be a REGEX as /look for \d+ examples/
+    # follow-up and :due can be <|=|>DATE
+    # tags can be eather a selection TAG1,TAG2,TAG3 or a REGEX /[Ll]ecture/
+    # prio can be <|=|>PRIO 
+    def find(dir, filter={}, all=true)
+      tasks = []
+      Dir.glob("#{dir}/*").sort.each do |file|
+        File.file?(file) ? task = YAML.load_file(file) : next
+        next if task and not all and task.done?
+        next if not task 
+        tasks << task if task.matches?(filter)
+      end
+      tasks
+    end
+
+    # Updates the task with the given id in the given directory dir with the
+    # provided options. 
+    # Options are
+    # * description - additional information about the task
+    # * follow_up - follow-up date of the task
+    # * due - due date of the task
+    # * prio - priority of the task
+    # * note - information about the progress or state of the task
+    # * tags - can be used to searching tasks that belong to a certain category
+    # Except for note and tags the values of the task are overridden with the
+    # new value. If note and tags are provided these are added to the existing
+    # values.
+    def update(dir, id, options)
+      task_file = Dir.glob("#{dir}/#{id}.task")[0]
+      task = YAML.load_file(task_file) if task_file
+      updated = false
+      if task
+        task.update(options) 
+        save(dir, task)
+        updated = true
+      end
+      updated
+    end
+
+    # Saves the task to the task directory
+    def save(dir, task)
+      File.open("#{dir}/#{task.id}.task", 'w') {|f| YAML.dump(task, f)}
+    end
+
+    private
+
+    # Creates the task directory if it does not exist
+    def create_dir(dir)
+      FileUtils.mkdir_p dir unless File.exists? dir
+    end
+
+    # Creates the task's ID based on the tasks available in the task directory.
+    # The task's file name is in the form ID.task. create_id determines
+    # the biggest number and adds one to create the task's ID.
+    def create_id(dir)
+      tasks = Dir.glob("#{dir}/*")
+      ids = []
+      tasks.each do |task| 
+        id = File.basename(task).scan(/^\d+(?=\.task)/)[0]
+        ids << id.to_i if id
+      end
+      ids.empty? ? 1 : ids.sort[ids.size-1] + 1
+   end
+ 
+  end
+end
+
+

data/lib/syctask/version.rb

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

data/syctask.rdoc

@@ -0,0 +1,5 @@
+= syctask
+
+Generate this with
+    syctask rdoc
+After you have described your command line interface

metadata

@@ -0,0 +1,168 @@
+--- !ruby/object:Gem::Specification
+name: syc-task
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Pierre Sugar
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-02-25 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rdoc
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: aruba
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: gli
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 2.5.4
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 2.5.4
+- !ruby/object:Gem::Dependency
+  name: rainbow
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: ! "= Simple task organizer\nWith syctask you can organize your tasks
+  (inspired by David Bryant Copland's book <b>Build Awesome Command-Line Applications
+  in Ruby</b>.\n\n==Install\nThe application can be installed with\n    $ gem install
+  syc-task\n\n== Usage\nsyctask provides basic task organizer functions as create,
+  update, list und complete a task. Addtional functions are to plan tasks you want
+  to accomplish today. If you are not sure in which sequence to conduct the task you
+  can prioritize them with a pair wise comparisson. You can time tasks with start
+  and stop and you can finally extract tasks from a minutes of meetings file.\n\n===Create
+  tasks with new\nCreate a new task in the default task directory ~/.tasks\n    $
+  syctask \"My first task\"\n\nProvide a description\n    $ syctask \"My first task\"
+  --description \"Explanation of my first task\"\n\nSchedule a task with a follow-up
+  and due date\n    $ syctask \"My first task\" --follow-up \"2013-02-25\" --due \"2013-03-11\"\n\nSet
+  a proirity for a task\n    $ syctask \"My first task\" --prio 3\n\nExcept for --description
+  you can also provide short forms for the options.\n\n===List tasks\nList tasks that
+  are not marked as done in short form\n    $ syctask list\n\nList all tasks in long
+  form\n    $ syctask list --all --complete\n\nSearch tasks that match a pattern\n
+  \   $ syctask list --id \"<10\" --follow_up \">2013-02-25\" --title \"My \\w task\"\n\n===Update
+  tasks\nExcept for title and id all values can be updated. Note and tags are not\noverridden
+  rather supplemented with the update value.\n\nUpdate task with ID 1 and provide
+  some informative note\n    $ syctask update 1 --note \"Some explanation about the
+  progress on the task\"\n\n===Complete tasks\nComplete the task with ID 1 and provide
+  a final note\n    $ syctask done 1 --note \"Finalize my first task\"\n\n==Supported
+  platform\nsyc-task has been tested with 1.9.3\n\n==Notes\nAs with version 0.0.1
+  only new, update, list and done is implemented.\n\nThe test files live in the folder
+  test and start with test_.\n\nThere is a rake file available to run all tests\n
+  \   $ rake test\n\n==License\nsyc-task is released under the {MIT License}[http://opensource.org/licenses/MIT]\n\n==Links\n*
+  [http://www.github.com/sugaryourcoffee/syc-task] - Source code on GitHub\n* [http://syc.dyndns.org/drupal/wiki/syc-task]
+  - Development notebook\n* [https://rubygems.org/gems/syc-backup] - RubyGems\n"
+email: pierre@sugaryourcoffee.de
+executables:
+- syctask
+extensions: []
+extra_rdoc_files:
+- README.rdoc
+- syctask.rdoc
+files:
+- bin/syctask
+- lib/syctask/version.rb
+- lib/syctask/task.rb
+- lib/syctask/task_service.rb
+- lib/syctask/evaluator.rb
+- lib/syctask.rb
+- README.rdoc
+- syctask.rdoc
+homepage: http://syc.dyndns.org/drupal/syc-task
+licenses: []
+post_install_message: 
+rdoc_options:
+- --title
+- syctask
+- --main
+- README.rdoc
+- -ri
+require_paths:
+- lib
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.25
+signing_key: 
+specification_version: 3
+summary: Simple task organizer
+test_files: []