todo

todo.rb

#!/usr/bin/env ruby

require 'term/ansicolor'
require "docopt"

doc = <<DOCOPT
Usage:
  #{__FILE__} add <task>...
  #{__FILE__} prepend <task>
  #{__FILE__} list <optional : --tag --priority>
  #{__FILE__} delete <task_id>
  #{__FILE__} complete <task_id>
  #{__FILE__} set_priority <task_id> <priority>
  #{__FILE__} tag <tag>
  #{__FILE__} sort_completed
  #{__FILE__} sort_outstanding
  #{__FILE__} sort_priority
  #{__FILE__} --help

DOCOPT

begin
  require "pp"
  pp Docopt::docopt(doc)
rescue Docopt::Exit => e
  puts e.message
end

class Color
  extend Term::ANSIColor
end

class TodoList
  def initialize()
    @file_name = "file.txt"
    @file = File.new(@file_name,'a+')
    @todo_list = []
    @delim = " || "

    read_file
  end

  def add_to_list(task)
    @todo_list << task
    display_write(@todo_list)
  end

  def prepend_to_list(task)
    @todo_list.unshift(task)
    display_write(@todo_list)
  end

  def delete(task_id)
    @todo_list.delete_at(task_id.to_i - 1)
    display_write(@todo_list)
  end

  def mark_completed(task_id)
    @todo_list[task_id.to_i - 1].completed = true
    @todo_list[task_id.to_i - 1].completion_date = Time.now
    @todo_list[task_id.to_i - 1].priority = ""
    display_write(@todo_list)
  end

  def sort_completed
    @sorted = @todo_list.clone
    @sorted.select!{|element| element.completed == true.to_s}
    @sorted.sort!{|a,b| a.completion_date <=> b.completion_date}
    display_todos(@sorted)
  end

  def sort_outstanding
    @sorted = @todo_list.clone
    @sorted.select!{|element| element.completed == false.to_s}
    @sorted.sort!{|a,b| a.completion_date <=> b.completion_date}
    display_todos(@sorted)
  end

  def sort_priority
    @sorted = @todo_list.clone
    @sorted.sort!{|a,b| b.priority <=> a.priority}
    display_todos(@sorted)
  end

  def display_tasks_with_tag(tags)
    @tag_search = @todo_list.clone
    @tag_search.select!{|element| element.tags.split(', ') & tags != []}
    display_todos(@tag_search)
  end

  def load_tags_to_array(todo_list)
    todo_list.each{|element| element.tags = element.tags.split(', ')}
  end

  def display_tasks_with_priority(priority)
    @priority_search = @todo_list.clone
    @priority_search.select!{|element| element.priority == priority}
    display_todos(@priority_search)
  end

  def apply_tag(task_id, tags)
    tags.each {|i| @todo_list[task_id.to_i - 1].tags << i + " "}
    @todo_list.each {|i| i.tags.strip!}
    puts @todo_list[task_id.to_i - 1].inspect
    display_write(@todo_list)
  end

  def display_write(list)
    display_todos(list)
    write_to_file
  end

  def set_priority(task_id,priority)
    raise "Invalid Priority : Please select a value between [1] and [3]" if verify_priority(priority.to_i) == 0
    @todo_list[task_id.to_i - 1].priority = priority
    display_write(@todo_list)
  end

  def verify_priority(priority)
    return 0 if priority < 0 || priority > 3
  end

  def display_todos(list = @todo_list,color_array = [])
    list.each_with_index {|elem,index| color_array[index] = elem.priority}
    string_array = generate_string_array(list)
    string_array.each_with_index do |elem,index|
      print Color.red + elem + Color.clear if color_array[index] == "3"
      print Color.yellow + elem + Color.clear if color_array[index] == "2"
      print Color.green + elem + Color.clear if color_array[index] == "1"
      print Color.clear + elem + Color.clear if color_array[index] == ""
    end
  end

  def tags_to_string(tag_list)
    tag_string = ""
    tag_list.each do |element|
      tag_string << element.to_s + " "
    end
    tag_string.strip
  end

  def parse_task(task_array_from_file)
    { "name" => task_array_from_file[1], "creation_date" => task_array_from_file[6], "completed" => task_array_from_file[2], "completion_date" => task_array_from_file[3], "tags" => task_array_from_file[4], "priority" => task_array_from_file[5] }
  end

  def read_file
    @file.each_line do |line|
      split_line = line.split(@delim)
      task_hash = parse_task(split_line)
      new_task = Task.new(task_hash["name"],task_hash["creation_date"],task_hash["completed"],task_hash["completion_date"],task_hash["tags"],task_hash["priority"])
      @todo_list << new_task
    end
    @file.close
  end

  def stringify_task(task, index)
    array = [index + 1, task.task_name, task.completed, task.completion_date, task.tags, task.priority, task.creation_date]

    array.join(@delim)
  end

  def generate_string_array(task_object_array)
    task_string_array = []
    task_object_array.each_with_index do |task, index|
      task_string_array << stringify_task(task, index)
    end
    task_string_array
  end

  def write_to_file
    @file = File.new(@file_name,'w')
    task_string_array = generate_string_array(@todo_list)
    task_string_array.each do |stringified_task|
      @file.puts(stringified_task)
    end
    @file.close
  end

end

class Task

  attr_accessor :task_name, :creation_date, :completed, :task_num, :completion_date, :tags, :priority

  def initialize(task_name, creation_date = Time.now, completed = false, completion_date = "incomplete", tags = [""], priority = "")
    @task_name = task_name
    @creation_date = creation_date
    @completed = completed
    @tags = tags
    @completion_date = completion_date
    @priority = priority
  end
end

class Main
  def initialize
    @command = ARGV[0]
    @additional_arguments = ARGV[1..-1].join(' ') if ARGV[1]
    @valid_commands = ['add','prepend','list','delete','complete','sort_completed','sort_outstanding','sort_priority','tag','set_priority']
  end

  def parse_command
    unless @valid_commands.include?(@command)
      return# puts "invalid command"
    end
    new_task = Task.new(@additional_arguments)
    todo_list = TodoList.new
    additional_parameters = @additional_arguments ? @additional_arguments.split(' ') : []

    case @command
    when "add"
      todo_list.add_to_list(new_task)
    when "prepend"
      todo_list.prepend_to_list(new_task)
    when "list"
      parse_list(todo_list, additional_parameters)
    when "delete"
      todo_list.delete(@additional_arguments)
    when "complete"
      todo_list.mark_completed(@additional_arguments)
    when "sort_completed"
      todo_list.sort_completed
    when "sort_outstanding"
      todo_list.sort_outstanding
    when "sort_priority"
      todo_list.sort_priority
    when "tag"
      todo_list.apply_tag(additional_parameters[0],additional_parameters[1..-1])
    when "set_priority"
      todo_list.set_priority(additional_parameters[0],additional_parameters[1])
    end
  end

  def parse_list(todo_list, additional_parameters)
    if additional_parameters[0] == "--tag"
      todo_list.display_tasks_with_tag(additional_parameters[1..-1])
    elsif additional_parameters[0] == "--priority"
      todo_list.display_tasks_with_priority(additional_parameters[1])
    else
      todo_list.display_todos
    end
  end
end

new_main = Main.new
new_main.parse_command