taskish 0.3 → 0.4

data/lib/taskish/app.rb

@@ -57,15 +57,14 @@ class Taskish # :nodoc:
           Taskish.new do |taskish|
             app.files.each { |f| taskish.readlines(f) }
             case  app.command
+            when  'debug'
+              taskish.debug
             when  'done'
-              # taskish.readlines(app.file)
-              puts "DONE\n~~~~~"
+              puts "DONE\n~~~~"
               taskish.done.each { |task| puts task }
-            when  'today', 'week'
-              # taskish.readlines(app.file)
+            when  'today', 'tomorrow', 'week'
               tasks = taskish.due( app.command.to_sym )
               if tasks.size > 0
-                puts "#{ app.command.upcase }\n#{ '~' * app.command.length }"
                 tasks.each { |task| puts task }
               end
             else
@@ -77,7 +76,7 @@ class Taskish # :nodoc:
     end
 
     def usage
-      "USAGE: taskish { done | today | week } <file>"
+      "USAGE: taskish { debug | done | today | tomorrow | week } <file>"
     end
 
   end # class Taskish::App

data/lib/taskish/project.rb

@@ -0,0 +1,80 @@
+require 'date'
+
+class Taskish # :nodoc:
+
+  # = Taskish::Project - A single project
+  #
+  # == USAGE
+  #
+  #   Taskish::Project.new(project) do |project|
+  #     # Get project's name
+  #     project.name
+  #
+  #     # Add task to project
+  #     project << Taskish::Task.new( project.name, 'my task' )
+  #
+  #     # Add child project to project
+  #     project << Taskish::Project.new( 'child project' )
+  #
+  #     # Get project's child projects
+  #     project.projects
+  #
+  #     # Get project's tasks
+  #     project.tasks
+  #
+  #   end
+  #
+  # == SEE ALSO
+  #
+  # <Taskish>, <Taskish::Task>
+  #
+  class Project
+    attr_reader :name, :parent
+
+    def initialize(project)
+      @name     = project
+      @children = []
+      @parent   = nil
+      yield self if block_given?
+    end
+
+    def <<(child)
+      if ( child.nil? || !( child.kind_of?(Taskish::Project) || child.kind_of?(Taskish::Task) ) )
+        raise(ArgumentError, 'invalid project/task')
+      end
+      if child.kind_of?(Taskish::Project)
+        child.instance_variable_set( :@parent, self )
+      end
+      @children << child
+      self
+    end
+
+    def debug(depth = 0)
+      puts "%s#{ @name }:" % [ '  ' * depth ]
+      projects.each { |p| p.debug( depth + 1 ) }
+      tasks(false).each do |t|
+        puts "%s- #{ t.raw }" % [ '  ' * ( depth + 1 ) ]
+      end
+    end
+
+    def projects
+      @children.select { |child| child.kind_of? Taskish::Project }
+    end
+
+    def tasks(recurse = true)
+      if recurse
+        return @children.collect { |child| child.kind_of?( Taskish::Project ) ? child.tasks : child }.flatten
+      else
+        return @children.select { |child| child.kind_of?( Taskish::Task ) }
+      end
+    end
+
+    # TODO Include parent information?
+    def to_s
+      @parent ? sprintf( "%s: %s" % [ self.parent, @name ] ) : @name
+    end
+     
+  end # class Taskish::Project
+
+end # class Taskish
+

data/lib/taskish/task.rb

@@ -15,8 +15,12 @@ class Taskish # :nodoc:
   # <Taskish>
   #
   class Task
+    attr_reader :parent
+
     def initialize(project, task)
-      @data = Task.parse(project, task)
+      raise(ArgumentError, 'invalid project') if ( project.nil? || !project.kind_of?(Taskish::Project) )
+      @data   = Task.parse(task)
+      @parent = project
       yield self if block_given?
     end
  
@@ -33,10 +37,10 @@ class Taskish # :nodoc:
       case  date
       when  :today
         return @data[:due] <= Date.today
+      when  :tomorrow
+        return @data[:due] > Date.today && @data[:due] <= ( Date.today + 1 )
       when  :week
-        d     = Date.today + 7
-        week  = DateTime.new( d.year, d.mon, d.mday, 23, 59 )
-        return @data[:due] <= week
+        return @data[:due] <= ( Date.today + 7 )
       else
         warn "invalid due date specification - '#{date}'"
       end
@@ -47,10 +51,9 @@ class Taskish # :nodoc:
       @data.key? key
     end
 
-    def self.parse(project, task)
-      raise(ArgumentError, 'invalid project') if ( project.nil? || project.empty? )
+    def self.parse(task)
       raise(ArgumentError, 'invalid task')    if ( task.nil?    || task.empty?    )
-      data = { :project => project }
+      data = { :raw => task }
 
       # TODO Extract to something that sucks less.
       task.gsub!(/\s*$/, '')
@@ -73,12 +76,17 @@ class Taskish # :nodoc:
       data
     end
 
+    def raw
+      @data[:raw]
+    end
+
     def task
       @data[:task]
     end
 
+    # TODO Make more flexible
     def to_s
-      s = sprintf( "%-20s\t%s" % [ @data[:project], @data[:task] ] )
+      s = sprintf( "%-25s\t%s" % [ self.parent.to_s + ':', @data[:task] ] )
       if key? :due
         s = sprintf( "%s @due(%s)" % [ s, @data[:due] ] )
       end 

data/lib/taskish/version.rb

@@ -1,3 +1,3 @@
 class Taskish # :nodoc:
-  VERSION = '0.3'
+  VERSION = '0.4'
 end

data/taskish.gemspec

@@ -20,4 +20,5 @@ Gem::Specification.new do |s|
 
   s.add_development_dependency( %q<rdoc-readme>,  [ '>=0.1.1'   ] )
   s.add_development_dependency( %q<shoulda>,      [ '>=2.11.3'  ] )
+  s.add_development_dependency( %q<simplecov>,    [ '>=0.4.2'   ] )
 end

data/test/app_test.rb

@@ -46,7 +46,7 @@ class AppTest < Test::Unit::TestCase
 
   context '#usage()' do
     should 'return expected usage string' do
-      assert_equal "USAGE: taskish { done | today | week } <file>", Taskish::App.new.usage
+      assert_equal "USAGE: taskish { debug | done | today | tomorrow | week } <file>", Taskish::App.new.usage
     end
   end
 

data/test/project_test.rb

@@ -0,0 +1,125 @@
+require 'test_helper'
+#require 'date'
+
+class ProjectTest < Test::Unit::TestCase
+
+   context '#initialize()' do
+     should 'return object if no block given' do
+       assert_instance_of Taskish::Project, Taskish::Project.new("p")
+     end
+     should 'work as a block' do
+       Taskish::Project.new("p") do |project|
+         assert_instance_of Taskish::Project, project
+       end
+     end
+   end
+
+  context 'accessors' do
+    setup do
+      @name     = 'my project'
+      @project  = Taskish::Project.new(@name)
+      @tasks    = []
+    end
+    should 'provide getter for :name' do
+      assert_equal  @name,  @project.name
+    end
+    should 'provide getter for :tasks' do
+      assert_equal  @tasks, @project.tasks
+    end
+    should 'raise NoMethodError for :name setter' do
+      assert_raise(NoMethodError, 'undefined method `name=')  { @project.name = 'foo' }
+    end
+    should 'raise NoMethodError for :tasks setter' do
+      assert_raise(NoMethodError, 'undefined method `tasks=')  { @project.tasks = [] }
+    end
+  end
+
+  context '#<<(child)' do
+    setup do
+      @project = Taskish::Project.new('my project')
+    end
+    should 'raise ArgumentError if child nil' do
+      assert_raise(ArgumentError, 'invalid project/task') { @project << nil }
+    end
+    should 'raise ArgumentError if child string' do
+      assert_raise(ArgumentError, 'invalid project/task') { @project << '' }
+    end
+  end
+
+  context 'tasks' do
+    setup do
+      @project = Taskish::Project.new('my project')
+    end
+    should 'default to 0 tasks' do
+      assert_equal  0, @project.tasks.size
+    end
+    should 'be able to add tasks' do
+      ( 1 .. 5 ).to_a.each do |n|
+        assert_equal  n - 1,  @project.tasks.size
+        @project << Taskish::Task.new( @project, n.to_s )
+        assert_equal  n,      @project.tasks.size
+      end
+      ( 1 .. 5 ).to_a.each do |n|
+        assert_equal  n.to_s, @project.tasks[n - 1].task
+      end
+    end
+  end
+
+  context 'child projects' do
+    setup do
+      @parent       =   Taskish::Project.new('parent project')
+      @child        =   Taskish::Project.new('child project')
+      @parent_task  =   Taskish::Task.new( @parent, 'parent task' )
+      @child_task   =   Taskish::Task.new( @child, 'child task' )
+      @parent       <<  @parent_task
+      @child        <<  @child_task
+      @parent       <<  @child
+    end
+    should 'be able to add child project to a project' do
+      @parent << @child
+    end
+    should 'return appropriate tasks for child' do
+      assert_equal  1,      @child.tasks.size
+      assert_equal  false,  @child.tasks.include?( @parent_task )
+      assert_equal  true,   @child.tasks.include?( @child_task )
+    end
+    should 'return appropriate tasks for parent' do
+      assert_equal  2,      @parent.tasks.size
+      assert_equal  true,   @parent.tasks.include?( @parent_task )
+      assert_equal  true,   @parent.tasks.include?( @child_task )
+    end
+    should 'return appropriate projects for child' do
+      assert_equal  0,      @child.projects.size
+      assert_equal  false,  @child.projects.include?( @parent )
+      assert_equal  false,  @child.projects.include?( @child )
+    end
+    should 'return appropriate projects for parent' do
+      assert_equal  1,      @parent.projects.size
+      assert_equal  false,  @parent.projects.include?( @parent )
+      assert_equal  true,   @parent.projects.include?( @child )
+    end
+  end
+
+  context '#to_s()' do
+    setup do
+      @parent   = Taskish::Project.new('parent project')
+      @child_1  = Taskish::Project.new('child project #1')
+      @child_2  = Taskish::Project.new('child project #2')
+    end
+    should 'return correct string representation when solo' do
+      assert_equal  'parent project',   @parent.to_s
+      assert_equal  'child project #1', @child_1.to_s
+      assert_equal  'child project #2', @child_2.to_s
+    end
+    should 'return correct string representation when child projects have been added' do
+      @parent << @child_1
+      @parent << @child_2
+      assert_equal  'parent project',                   @parent.to_s
+      assert_equal  'parent project: child project #1', @child_1.to_s
+      assert_equal  'parent project: child project #2', @child_2.to_s
+    end
+  end
+
+ 
+end # class ProjectTest
+

data/test/task_test.rb

@@ -4,22 +4,28 @@ require 'date'
 class TaskTest < Test::Unit::TestCase
 
   context '#initialize()' do
+    setup do
+      @p = Taskish::Project.new('my project')
+    end
     should 'return object if no block given' do
-      assert_instance_of Taskish::Task, Taskish::Task.new("p", "t")
+      assert_instance_of Taskish::Task, Taskish::Task.new(@p, "t")
     end
     should 'work as a block' do
-      Taskish::Task.new("p", "t") do |task|
+      Taskish::Task.new(@p, "t") do |task|
         assert_instance_of Taskish::Task, task
       end
     end
   end
 
   context '#done?' do
+    setup do
+      @p = Taskish::Project.new('my project')
+    end
     should 'return false if @done not set' do
-      assert_equal  false,  Taskish::Task.new('proj', 'foo').done?
+      assert_equal  false,  Taskish::Task.new(@p, 'foo').done?
     end
     should 'return true if @done set' do
-      assert_equal  true,   Taskish::Task.new('proj', 'foo @done').done?
+      assert_equal  true,   Taskish::Task.new(@p, 'foo @done').done?
     end
   end
 
@@ -27,7 +33,7 @@ class TaskTest < Test::Unit::TestCase
 
     context ' with no due date' do
       setup do 
-        @task = Taskish::Task.new('proj', 'do something')
+        @task = Taskish::Task.new( Taskish::Project.new('my project'), 'do something')
       end
       should 'be nil' do
         assert_nil  @task.due
@@ -43,7 +49,7 @@ class TaskTest < Test::Unit::TestCase
     context ' with implicit due date of today' do
       setup do 
         @d    = Date.today
-        @task = Taskish::Task.new('proj', 'do something @due')
+        @task = Taskish::Task.new( Taskish::Project.new('my project') , 'do something @due' )
       end
       should 'not be nil' do
         assert_not_nil  @task.due
@@ -62,7 +68,7 @@ class TaskTest < Test::Unit::TestCase
     context ' with implicit due date of today and additional tag' do
       setup do 
         @d    = Date.today
-        @task = Taskish::Task.new('proj', 'do something @due @weekly')
+        @task = Taskish::Task.new( Taskish::Project.new('my project'), 'do something @due @weekly' )
       end
       should 'not be nil' do
         assert_not_nil  @task.due
@@ -81,7 +87,7 @@ class TaskTest < Test::Unit::TestCase
     context ' with explicit due date of today' do
       setup do 
         @d    = Date.today
-        @task = Taskish::Task.new('proj', "do something @due(#{ @d.strftime('%Y-%m-%d') })")
+        @task = Taskish::Task.new( Taskish::Project.new('my project'), "do something @due(#{ @d.strftime('%Y-%m-%d') })" )
       end
       should 'not be nil' do
         assert_not_nil  @task.due
@@ -100,7 +106,7 @@ class TaskTest < Test::Unit::TestCase
     context ' with explicit due date of today and additional tag' do
       setup do 
         @d    = Date.today
-        @task = Taskish::Task.new('proj', "do something @due(#{ @d.strftime('%Y-%m-%d') }) @weekly")
+        @task = Taskish::Task.new( Taskish::Project.new('my project'), "do something @due(#{ @d.strftime('%Y-%m-%d') }) @weekly" )
       end
       should 'not be nil' do
         assert_not_nil  @task.due
@@ -119,7 +125,7 @@ class TaskTest < Test::Unit::TestCase
     context ' with explicit due date of tomorrow' do
       setup do 
         @d    = Date.today + 1
-        @task = Taskish::Task.new('proj', "do something @due(#{ @d.strftime('%Y-%m-%d') })")
+        @task = Taskish::Task.new( Taskish::Project.new('my project'), "do something @due(#{ @d.strftime('%Y-%m-%d') })" )
       end
       should 'not be nil' do
         assert_not_nil @task.due
@@ -138,28 +144,27 @@ class TaskTest < Test::Unit::TestCase
 
   context 'parse()' do
     setup do
-      @project  = 'some project'
+      @project  = Taskish::Project.new('my project')
       @task     = 'some task'
       @today    = Date.today
     end
 
     should 'raise ArgumentError if nil project' do
-      assert_raise(ArgumentError, 'invalid project')  { Taskish::Task.new(nil, @task) }
+      assert_raise(ArgumentError, 'invalid project')      { Taskish::Task.new(nil, @task) }
     end
     should 'raise ArgumentError if empty project' do
-      assert_raise(ArgumentError, 'invalid project')  { Taskish::Task.new('', @task)  }
+      assert_raise(ArgumentError, 'invalid project')      { Taskish::Task.new('', @task)  }
     end
     should 'raise ArgumentError if nil task' do
-      assert_raise(ArgumentError, 'invalid task')     { Taskish::Task.new(@project, nil) }
+      assert_raise(ArgumentError, 'invalid project/task') { Taskish::Task.new(@project, nil) }
     end
     should 'raise ArgumentError if empty task' do
-      assert_raise(ArgumentError, 'invalid task')     { Taskish::Task.new(@project, '')  }
+      assert_raise(ArgumentError, 'invalid project/task') { Taskish::Task.new(@project, '')  }
     end
 
     should 'handle :project and :task' do
       task  = @task
-      hash  = Taskish::Task.parse(@project, task)
-      assert_equal  @project, hash[:project]
+      hash  = Taskish::Task.parse(task)
       assert_equal  @task,    hash[:task]
       assert_equal  false,    hash.key?(:due)
       assert_equal  false,    hash.key?(:done)
@@ -168,8 +173,7 @@ class TaskTest < Test::Unit::TestCase
 
     should 'handle :project and :task with trailing whitespace' do
       task  = "#{ @task }     "
-      hash  = Taskish::Task.parse(@project, task)
-      assert_equal  @project, hash[:project]
+      hash  = Taskish::Task.parse(task)
       assert_equal  @task,    hash[:task]
       assert_equal  false,    hash.key?(:due)
       assert_equal  false,    hash.key?(:done)
@@ -178,8 +182,7 @@ class TaskTest < Test::Unit::TestCase
 
     should 'handle :project, :task and implicit :due' do
       task  = "#{ @task } @due"
-      hash  = Taskish::Task.parse(@project, task)
-      assert_equal  @project,     hash[:project]
+      hash  = Taskish::Task.parse(task)
       assert_equal  @task,        hash[:task]
       assert_equal  @today.to_s,  hash[:due].to_s
       assert_equal  false,        hash.key?(:done)
@@ -188,8 +191,7 @@ class TaskTest < Test::Unit::TestCase
 
     should 'handle :project, :task and :done' do
       task  = "#{ @task } @done"
-      hash  = Taskish::Task.parse(@project, task)
-      assert_equal  @project,     hash[:project]
+      hash  = Taskish::Task.parse(task)
       assert_equal  @task,        hash[:task]
       assert_equal  false,        hash.key?(:due)
       assert_equal  true,         hash.key?(:done)
@@ -198,8 +200,7 @@ class TaskTest < Test::Unit::TestCase
 
     should 'handle :project, :task, implicit :due and :done' do
       task  = "#{ @task } @due @done"
-      hash  = Taskish::Task.parse(@project, task)
-      assert_equal  @project,     hash[:project]
+      hash  = Taskish::Task.parse(task)
       assert_equal  @task,        hash[:task]
       assert_equal  @today.to_s,  hash[:due].to_s
       assert_equal  true,         hash.key?(:done)
@@ -208,8 +209,7 @@ class TaskTest < Test::Unit::TestCase
 
     should 'handle :project, :task and explicit :due' do
       task  = "#{ @task } @due(#{ @today.to_s })"
-      hash  = Taskish::Task.parse(@project, task)
-      assert_equal  @project,     hash[:project]
+      hash  = Taskish::Task.parse(task)
       assert_equal  @task,        hash[:task]
       assert_equal  @today.to_s,  hash[:due].to_s
       assert_equal  false,        hash.key?(:done)
@@ -218,8 +218,7 @@ class TaskTest < Test::Unit::TestCase
 
     should 'handle :project, :task, explicit :due and :done' do
       task  = "#{ @task } @due(#{ @today.to_s }) @done"
-      hash  = Taskish::Task.parse(@project, task)
-      assert_equal  @project,     hash[:project]
+      hash  = Taskish::Task.parse(task)
       assert_equal  @task,        hash[:task]
       assert_equal  @today.to_s,  hash[:due].to_s
       assert_equal  true,         hash.key?(:done)
@@ -228,8 +227,7 @@ class TaskTest < Test::Unit::TestCase
 
     should 'handle :project, :task and random other tag (by ignoring random other tag)' do
       task  = "#{ @task } @weekly"
-      hash  = Taskish::Task.parse(@project, task)
-      assert_equal  @project,     hash[:project]
+      hash  = Taskish::Task.parse(task)
       assert_equal  task,         hash[:task]
       assert_equal  false,        hash.key?(:due)
       assert_equal  false,        hash.key?(:done)
@@ -237,5 +235,26 @@ class TaskTest < Test::Unit::TestCase
     end
   end
 
+  context '#to_s()' do
+    setup do
+      @parent   = Taskish::Project.new('parent project')
+      @task     = Taskish::Task.new( @parent, 'child task #1' )
+      @child_p1 = Taskish::Project.new('child project #1')
+      @child_p2 = Taskish::Project.new('child project #2')
+      @child_t1 = Taskish::Task.new( @child_p1, 'child project #1 task #1' )
+      @child_t2 = Taskish::Task.new( @child_p2, 'child project #2 task #1' )
+      @parent   << @task
+      @child_p1 << @child_t1
+      @child_p2 << @child_t2
+      @parent   << @child_p1
+      @parent   << @child_p2
+    end
+    should 'return correct string representation' do
+      assert_equal  "parent project:          \tchild task #1",                   @task.to_s
+      assert_equal  "parent project: child project #1:\tchild project #1 task #1", @child_t1.to_s
+      assert_equal  "parent project: child project #2:\tchild project #2 task #1", @child_t2.to_s
+    end
+  end
+
 end # class TaskTest