todd 0.0.9

data/bin/todd_old.rb

@@ -0,0 +1,161 @@
+#!/usr/bin/env ruby
+
+require 'todd_model'
+require 'todd_util'
+require 'digest/md5'
+require 'pp'
+
+config = {
+  :default_db_path  =>  "/home/carl/dev/todd/test.db",
+  :config_filename  =>  ".todd",
+  :default_category =>  "default",
+  :default_config   =>  "todd_hash: %s\n",
+  :output_format    =>  "minimal"
+}
+
+module Docs
+  Short = {
+    :init     => ["todd init          ", "Initialize a Todd list in the local directory."],
+    :add      => ["todd add <string>  ", "Add an item to the local Todd list."],
+    :rm       => ["todd rm <id>       ", "Remove an item from the local todo list."],
+    :list     => ["todd list          ", "List all items in all categories."],
+    :find     => ["todd find <query>  ", "List all items which match the query."],
+    :start    => ["todd start <id>    ", "Start the timer on task with id == <id>."],
+    :stop     => ["todd stop <id>     ", "Stop the timer on task with id == <id>."],
+    :listd    => ["todd listd         ", "List all deleted tasks."]
+  }
+end
+
+def docs_for(method)
+  puts "%s\t%s" % Docs::Short[method.to_sym]
+end
+
+class Todd
+
+  @config = {}
+
+  def initialize(config)
+    @config = config
+    @todo_list = TodoList.first(:conditions => { :md5_id => @config[:todd_hash] })
+  end
+
+  # COMMANDS
+  
+  def init
+    if File.exists?(@config[:config_filename])
+      puts "Todd is already initialized in the local directory"
+      return
+    end
+
+    current_dir = Dir.getwd
+    current_dir_md5 = Digest::MD5.hexdigest(current_dir)
+
+    TodoList.create(:md5_id => current_dir_md5)
+
+    File.open(@config[:config_filename], 'w') do |f|
+      f.write(sprintf(@config[:default_config],current_dir_md5))
+    end
+
+    puts "Initialized Todd in #{current_dir}"
+  end
+
+  def add task_str
+    category_name = @config[:default_category]
+    task_str = task_str.sub(/#(\S*)/) do |cat|
+      puts "Cat name: #{$1}"
+      category_name = $1
+      ""
+    end
+    task_str.strip!
+
+    puts "Task: #{task_str}"
+
+    category = @todo_list.categories.find_or_create_by_name(category_name)
+    task = category.tasks.create(:title => task_str)
+  end
+
+  def rm id
+    t = Task.find(id).destroy
+  end
+
+  def list
+    puts format_bundle @todo_list.bundle, @config[:output_format]
+  end
+
+  def find
+  end
+
+  def start id
+    t = Task.find(id).start!
+    puts t ? "Task #{t.id} started" : "Task already running"
+  end
+
+  def stop id
+    t = Task.find(id).stop!
+    puts t ? "Task #{t.id} stopped" : "Task already stopped"
+    puts format_bundle t.bundle, @config[:output_format] if t
+  end
+
+  def listd
+    puts "Not Implemented"
+  end
+
+  def restore
+    puts "Not Implemented"
+  end
+
+  def add_remote
+    puts "Not Implemented"
+  end
+
+  def sync
+    puts "Not Implemented"
+  end
+end
+
+# Parse the .todd file if it exists
+
+if File.exists? config[:config_filename]
+  begin
+    conf = YAML.load(File.open(config[:config_filename], 'r').read)
+    conf.each { |key, val|
+      config[key.to_sym] = val
+    } unless conf == nil
+  rescue ScriptError=>e
+    warn("Error reading #{config[:config_filename]}, you might have an error in your local .todd file")
+    puts "Exception Trace:"
+    pp e
+    exit
+  end
+else
+  unless ARGV.include? "init"
+    warn("Error finding #{config[:config_filename]}")
+    exit
+  end
+end
+
+todd = Todd.new(config)
+
+if ARGV.length > 0
+  command = ARGV.shift
+
+  break if command == "help"
+
+  begin
+    todd.send(command.to_sym, *ARGV)
+  rescue ArgumentError => e
+    puts e
+    pp e.backtrace
+    docs_for command
+  end
+
+  exit
+end
+
+## show help
+
+puts "Usage: todd [OPTION] [ARGS]"
+
+Docs::Short.keys.each do |command|
+  docs_for command
+end

data/db/database.yml

@@ -0,0 +1,2 @@
+adapter: sqlite3
+database: /home/carl/dev/todd/db/todd.db

data/db/migrations/0214102019_initialize_database.rb

@@ -0,0 +1,48 @@
+class InitializeDatabase < ActiveRecord::Migration
+  def self.up
+    create_table :todo_lists do |t|
+      t.string      :md5_id,      :null => false
+
+      t.timestamps
+    end
+
+    create_table :categories do |t|
+      t.string      :name,        :null => false
+
+      t.references  :todo_list
+
+      t.timestamps
+    end
+
+    create_table :tasks do |t|
+      t.string      :title,       :null => false
+      t.text        :notes,       :default => ""
+      t.boolean     :running,     :default => false
+      t.datetime    :start_time
+      t.datetime    :total_time,  :default => Time.at(0)
+
+      t.references :category
+
+      t.timestamps
+    end
+
+    create_table :archived_tasks do |t|
+      t.string      :title,       :null => false
+      t.text        :notes,       :default => ""
+      t.boolean     :running,     :default => false
+      t.datetime    :start_time
+      t.datetime    :total_time, :default => Time.at(0)
+
+      t.references :category
+
+      t.timestamps
+    end
+  end
+
+  def self.down
+    drop_table :archived_tasks
+    drop_table :tasks
+    drop_table :categories
+    drop_table :todo_lists
+  end
+end

data/db/migrations/0221102255_add_punch_table.rb

@@ -0,0 +1,28 @@
+class AddPunchTable < ActiveRecord::Migration
+  def self.up
+    create_table :punches do |t|
+      t.boolean     :running,   :default => false
+      t.datetime    :start
+      t.datetime    :stop
+
+      t.references  :task
+    end
+
+    remove_column :tasks, :start_time
+    add_column    :tasks, :current_punch, :integer
+
+    remove_column :archived_tasks, :start_time
+    add_column    :archived_tasks, :current_punch, :integer
+
+  end
+
+  def self.down
+    drop_table :punches
+
+    add_column    :tasks, :start_time, :boolean
+    remove_column :tasks, :current_punch
+
+    add_column    :archived_tasks, :start_time, :boolean
+    remove_column :archived_tasks, :current_punch
+  end
+end

data/db/migrations/0222102121_remove_archived_tasks.rb

@@ -0,0 +1,19 @@
+class RemoveArchivedTasks < ActiveRecord::Migration
+  def self.up
+    drop_table :archived_tasks
+  end
+
+  def self.down
+    create_table :archived_tasks do |t|
+      t.string      :title,       :null => false
+      t.text        :notes,       :default => ""
+      t.boolean     :running,     :default => false
+      t.datetime    :total_time, :default => Time.at(0)
+      t.integer     :current_punch
+
+      t.references :category
+
+      t.timestamps
+    end
+  end
+end

data/db/migrations/0222102124_add_archived_column_to_tasks.rb

@@ -0,0 +1,15 @@
+class AddArchivedColumnToTasks < ActiveRecord::Migration
+  def self.up
+    add_column :tasks, :archived, :boolean, :default => false
+    
+    Todd::Task.reset_column_information
+    Todd::Task.find_each do |t|
+      t.archived = false
+      t.save
+    end
+  end
+
+  def self.down
+    remove_column :tasks, :archived
+  end
+end

data/lib/todd.rb

@@ -0,0 +1,10 @@
+require 'rubygems'
+require 'digest/md5'
+require 'pp'
+require 'active_record'
+require 'singleton'
+
+require 'todd/util'
+require 'todd/model'
+require 'todd/version'
+require 'todd/config'

data/lib/todd/config.rb

@@ -0,0 +1,67 @@
+module Todd
+  class Base
+    include Singleton
+
+    def self.setup
+      self.instance
+    end
+
+    def self.[](key)
+      @__instance__.config[key]
+    end
+
+    attr_reader :config
+
+    def initialize
+      @config = {
+        :default_db_path    => "/home/carl/dev/todd/test.db",
+        :config_filename    => ".todd",
+        :default_category   => "default",
+        :default_config     => "todd_hash: %s\n",
+        :output_format      => "minimal"
+      }
+
+      if File.exists? @config[:config_filename]
+        begin
+          conf = YAML.load(File.open(@config[:config_filename], 'r').read)
+          conf.each { |key, val|
+            @config[key.to_sym] = val
+          } unless conf == nil
+        rescue scripterror => e
+          warn("error reading #{@config[:config_filename]}, you might have an error in your local .todd file.")
+          puts "exception trace:"
+          pp e
+          exit
+        end
+      else
+        unless ARGV.include? "init"
+          warn("Error finding #{@config[:config_filename]}")
+          warn("If you want to use Todd in this dir, please run todd init")
+          exit
+        end
+      end
+    end
+
+    def self.init_local_dir
+      if File.exists? self[:config_filename]
+        warn "Todd is already initialized in the local directory"
+        return
+      end
+
+      current_dir = Dir.getwd
+      current_dir_md5 = Digest::MD5.hexdigest(current_dir)
+      
+      TodoList.create(:md5_id => current_dir_md5)
+
+      File.open(self[:config_filename], 'w') do |f|
+        f.write(sprintf(self[:default_config], current_dir_md5))
+      end
+
+      puts "Initialized Todd in #{current_dir}"
+    end
+
+    def self.set_formatting format
+      @__instance__.config[:output_format] = format
+    end
+  end
+end

data/lib/todd/model.rb

@@ -0,0 +1,254 @@
+module Todd
+
+  class DB
+
+    def self.initialize_db
+      conf_path = File.dirname(__FILE__) + '/../../db/database.yml'
+      ActiveRecord::Base.establish_connection(YAML::load(File.open(conf_path)))
+      ActiveRecord::Base.logger = Logger.new(File.open('logs/database.log', 'a'))
+      ActiveRecord::Base.colorize_logging = false
+    end
+
+    def self.get_current_list
+      TodoList.first(:conditions => { :md5_id => Base[:todd_hash] })
+    end
+
+    def self.find query, category_ids, archived = false
+      found = []
+      query ||= 'last'
+
+      case query
+        when 'all'
+          found = Task.find(:all, :conditions => {:category_id => category_ids, :archived => archived})
+        when 'last'
+          found << Task.find(:first, :conditions => {:category_id => category_ids, :archived => archived}, :order => "updated_at DESC")
+        when 'active', 'running', 'started'
+          found = Task.find(:all, :conditions => {:category_id => category_ids, :running => true, :archived => archived})
+        when 'inactive', 'stopped'
+          found = Task.find(:all, :conditions => {:category_id => category_ids, :running => false, :archived => archived})
+        when /(\d+)\.\.(\d+)/
+          found = Task.find(:all, :conditions => {:category_id => category_ids, :id => $1.to_i..$2.to_i, :archived => archived})
+        when /(\d+)/
+          found << Task.find($1.to_i, :conditions => {:category_id => category_ids, :archived => archived})
+        else
+          warn "Invalid query: #{query}"
+          exit
+      end
+      
+      raise ActiveRecord::RecordNotFound if found == [nil]
+
+      if block_given?
+        found.each do |f|
+          yield f
+        end
+      end
+
+      found
+    rescue ActiveRecord::RecordNotFound => e
+      puts "Not task matched query"
+    end
+        
+  end
+
+  class TodoList < ActiveRecord::Base
+    has_many :categories, :dependent => :destroy
+    has_many :tasks, :through => :categories
+    validates_uniqueness_of :md5_id
+
+    def category_ids
+      return @_category_ids if @_category_ids
+
+      @_category_ids = []
+      self.categories.find_each do |cat|
+        @_category_ids << cat.id
+      end
+
+      @_category_ids
+    end
+
+    def bundle query = nil, archived = false
+      bund = {
+        :type => :todolist,
+        :categories => []
+      }
+      
+      self.categories.each do |cat|
+        next unless cat.visible?
+        sub_bundle = cat.bundle(query, archived)
+        bund[:categories] << sub_bundle unless sub_bundle[:tasks] == []
+      end
+
+      bund
+    end
+
+    def add task_str
+      category_name = Base[:default_category]
+      task_str = task_str.sub(/#(\S*)/) do |cat|
+        puts "Category: #{$1}"
+        category_name = $1
+        ""    # this kills the category in the task_str
+      end
+      task_str.strip!
+
+      puts "Task #{task_str}"
+
+      category = self.categories.find_or_create_by_name(category_name)
+      task = category.tasks.create(:title => task_str)
+    end
+
+    def rm query
+      DB.find(query, category_ids) do |t|
+        puts "Removed Task #{t.id}"
+        t.destroy
+      end
+    end
+
+    def archive query
+      DB.find(query, category_ids) do |t|
+        t = t.archive!
+        puts t ? "Archived Task #{t.id}" : "Cannot archive active task"
+      end
+    end
+
+    def restore query
+      DB.find(query, category_ids, true) do |t|
+        puts "Restored Task #{t.id}"
+        t.restore!
+      end
+    end
+
+    def start query
+      DB.find(query, category_ids) do |t|
+        t = t.start!
+        puts t ? "Task #{t.id} started" : "Task already running"
+      end
+    end
+
+    def stop query
+      DB.find(query, category_ids) do |t|
+        t = t.stop!
+        puts t ? "Task #{t.id} stopped" : "Task already stopped"
+        puts Util.format_bundle t.bundle if t
+      end
+    end
+
+
+  end
+
+  class Category < ActiveRecord::Base
+    belongs_to :todo_list
+    has_many :tasks, :dependent => :destroy
+    has_many :archived_tasks
+    validates_uniqueness_of :name
+
+    def bundle query = nil, archived = false
+      bund = {
+        :type => :category,
+        :name => name,
+        :tasks => []
+      }
+      
+      found = (query != nil) ? DB.find(query, [id], archived) : self.tasks
+      found.each do |task|
+        bund[:tasks] << task.bundle if task.archived == archived
+      end
+
+      bund
+    end
+
+    def visible?
+      (tasks.count > 0)
+    end
+  end
+
+  class Task < ActiveRecord::Base
+    belongs_to :category
+
+    def bundle
+      {
+        :type => :task,
+        :id => id,
+        :title => title,
+        :active => running,
+        :session_time => session_time,
+        :total_time => total_time
+      }
+    end
+
+    def start!
+      return nil if running
+
+      punch = Punch.new
+      punch.clock_in!
+
+      self[:current_punch] = punch.id
+      toggle(:running)
+
+      self.save
+
+      self
+    end
+
+    def stop!
+      return nil if !running
+
+      punch = Punch.find(current_punch)
+      session_time = punch.clock_out!
+
+      self[:total_time] += session_time if session_time
+      toggle(:running)
+
+      self.save
+
+      self
+    end
+
+    def archive!
+      return nil if running
+
+      self[:archived] = true
+      self.save
+
+      self
+    end
+
+    def restore!
+      self[:archived] = false
+      self.save
+      
+      self
+    end
+
+    def session_time
+      running ? Punch.find(current_punch).session_time : 0
+    end
+  end
+
+  class Punch < ActiveRecord::Base
+    belongs_to :task
+
+    def clock_in!
+      return false if running
+      self[:start] = Time.now
+      toggle(:running)
+
+      self.save
+      
+      true
+    end
+
+    def clock_out!
+      return nil unless running
+      self[:stop] = Time.now
+      toggle(:running)
+
+      self.save
+
+      session_time
+    end
+
+    def session_time
+      running ? (Time.now - start) : (stop - start)
+    end
+  end
+end