taskish 0.0.1 → 0.2.0

data/.gitignore

@@ -1,3 +1,4 @@
+.*.swp
 *.gem
 .bundle
 Gemfile.lock

data/HISTORY

@@ -1,3 +1,10 @@
+2011-06-23 v0.2.0
+  - Added 'help' command to executable
+  - Added 'done' command to executable
+  - Added 'version' command to executable
+  - Improved task parsing
+  - Added support for '@done' tag
+
 2011-06-23 v0.0.1
   - Initial prototype release.
 

data/bin/taskish

@@ -1,28 +1,12 @@
 #!/usr/bin/env ruby
 
 require 'taskish'
+require 'taskish/app'
 
-if __FILE__ == $0
-  # TODO Extract to class?
-  cmd, file = ARGV.shift, ARGV.shift
-  unless cmd && file
-    warn "USAGE: #{ File.basename(__FILE__) } { today | week } <file>"
-    exit
-  end
-  Taskish.new do |taskish|
-    case  cmd
-    when  'today'
-      taskish.readlines(file)
-      puts "TODAY\n~~~~~"
-      taskish.due(:today).each { |task| puts task }
-    when  'week'
-      taskish.readlines(file)
-      puts "WEEK\n~~~~"
-      taskish.due(:week).each  { |task| puts task }
-    else
-      warn "unknown command: #{cmd}"
-      exit 1
-    end
-  end
+begin
+  Taskish::App.run(ARGV) || exit(1)
+rescue => e
+  warn "#{e.class.name}: #{e.message}"
+  exit(1)
 end
 

data/lib/taskish.rb

@@ -3,6 +3,8 @@ require 'taskish/version'
 
 # = Taskish - Pending
 #
+# A text-based to-do list manager inspired by <TaskPaper|URL:http://www.hogbaysoftware.com/products/taskpaper>
+#
 # == USAGE
 #
 #   Taskish.new do |taskish|
@@ -26,16 +28,29 @@ require 'taskish/version'
 #
 # Blair Christensen, <blair.christensen@gmail.com>
 #
+# == SEE ALSO
+#
+# <Taskish::App>
+# http://www.hogbaysoftware.com/products/taskpaper
+#
 class Taskish
   def initialize
     @data = {}
     yield self if block_given?
   end
 
+  def done
+    task_list = []
+    @data.each_pair do |project, tasks|
+      tasks.each { |task| task_list << task if task.done? }
+    end
+    task_list
+  end
+
   def due( due = :today )
     task_list = []
     @data.each_pair do |project, tasks|
-      tasks.each { |task| task_list << task if task.due?(due) }
+      tasks.each { |task| task_list << task if ( task.due?(due) and !task.done? ) }
     end
     task_list.sort_by { |t| t.due }
   end

data/lib/taskish/app.rb

@@ -0,0 +1,86 @@
+
+class Taskish # :nodoc:
+
+  # = Taskish::App - Taskish application.
+  #
+  # == USAGE
+  #
+  # API:
+  #
+  #   Taskish::App.run(ARGV)
+  #
+  # Command Line:
+  #
+  #   % taskish [args]
+  #
+  # == SEE ALSO
+  #
+  # <Taskish>
+  #
+  class App
+
+    attr_reader :command, :file
+
+    def initialize
+      @command  = nil
+      @file     = nil
+      yield self if block_given?
+    end
+
+    def abort(message = nil)
+      warn "ERROR: #{message}" if message
+      warn self.usage
+      false 
+    end
+
+    def args(args)
+      raise(ArgumentError, 'invalid argument(s)') if ( args.nil? || !args.kind_of?(Array) )
+      @command  = args.shift
+      @file     = args.shift
+      self
+    end
+
+    def self.run(args)
+      Taskish::App.new do |app|
+        app.args(args)
+        return app.abort('no command specified') unless app.command
+
+        case  app.command
+        when  'help'
+          puts app.usage
+          return true
+        when  'version'
+          puts "Taskish v#{ Taskish::VERSION }"
+          return true
+        else
+          return app.abort('no file specified') unless app.file
+          Taskish.new do |taskish|
+            case  app.command
+            when  'done'
+              taskish.readlines(app.file)
+              puts "DONE\n~~~~~"
+              taskish.done.each { |task| puts task }
+            when  'today'
+              taskish.readlines(app.file)
+              puts "TODAY\n~~~~~"
+              taskish.due(:today).each { |task| puts task }
+            when  'week'
+              taskish.readlines(app.file)
+              puts "WEEK\n~~~~"
+              taskish.due(:week).each  { |task| puts task }
+            else
+              return app.abort("unknown command: #{app.command}")
+            end
+          end
+        end
+      end
+    end
+
+    def usage
+      "USAGE: taskish { done | today | week } <file>"
+    end
+
+  end # class Taskish::App
+
+end # class Taskish
+

data/lib/taskish/task.rb

@@ -10,19 +10,20 @@ class Taskish # :nodoc:
   #     ...
   #   end
   #
+  # == SEE ALSO
+  #
+  # <Taskish>
+  #
   class Task
     def initialize(project, task)
-      raise(ArgumentError, 'invalid project') if ( project.nil? || project.empty? )
-      raise(ArgumentError, 'invalid task')    if ( task.nil?    || task.empty?    )
-      @data = { :project => project, :task => task }
-      if task =~ /^(.+?)\s+\@due(.*?)\s*$/
-        @data[:task]  = $1
-        @data[:due]   = $2.empty? ? Date.today : Date.parse( $2.gsub(/^\(/, '').gsub(/\)$/, '') )
-      else
-      end
+      @data = Task.parse(project, task)
       yield self if block_given?
     end
-
+ 
+    def done?
+      @data.key?(:done) && @data[:done]
+    end
+ 
     def due
       @data[:due] || nil
     end
@@ -46,6 +47,32 @@ class Taskish # :nodoc:
       @data.key? key
     end
 
+    def self.parse(project, task)
+      raise(ArgumentError, 'invalid project') if ( project.nil? || project.empty? )
+      raise(ArgumentError, 'invalid task')    if ( task.nil?    || task.empty?    )
+      data = { :project => project }
+
+      # TODO Extract to something that sucks less.
+      task.gsub!(/\s*$/, '')
+      # @done
+      if    task =~ /^(.+?)\s+\@done\s?(.*)$/
+        task        = "#{ $1 }#{ $3 }"
+        data[:done] = true
+      end
+      # @due
+      if    task =~ /^(.+?)\s+\@due(\S+)(.*)$/
+        task        = "#{ $1 }#{ $3 }"
+        due         = $2.gsub(/^\(/, '').gsub(/\)$/, '')
+        data[:due]  = Date.parse(due)
+      elsif task =~ /^(.+?)\s+\@due\s?(.*)$/
+        task        = "#{ $1 }#{ $3 }"
+        data[:due]  = Date.today
+      end
+
+      data[:task] = task
+      data
+    end
+
     def task
       @data[:task]
     end

data/lib/taskish/version.rb

@@ -1,3 +1,3 @@
 class Taskish # :nodoc:
-  VERSION = '0.0.1'
+  VERSION = '0.2.0'
 end

data/taskish.gemspec

@@ -16,7 +16,7 @@ Gem::Specification.new do |s|
   s.files         = `git ls-files`.split("\n")
   s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
   s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
-  s.require_paths = ["lib"]
+  s.require_paths = ['lib']
 
   s.add_development_dependency( %q<rdoc-readme>,  [ '>=0.1.1'   ] )
   s.add_development_dependency( %q<shoulda>,      [ '>=2.11.3'  ] )

data/test/app_test.rb

@@ -0,0 +1,49 @@
+require 'test_helper'
+require 'taskish/app'
+
+class AppTest < Test::Unit::TestCase
+
+  context '#initialize()' do
+    should 'return object if no block given' do
+      assert_instance_of Taskish::App, Taskish::App.new
+    end
+    should 'work as a block' do
+      Taskish::App.new do |app|
+        assert_instance_of Taskish::App, app
+      end
+    end
+  end
+
+  context '#args()' do
+    setup do
+      @app = Taskish::App.new
+    end
+    
+    context 'with non-array argument' do
+      should 'raise ArgumentError' do
+        assert_raise(ArgumentError, 'invalid argument(s)') { @app.args(nil) }
+      end
+    end
+
+    context 'with arguments' do
+      should 'have nil args before parsing args' do
+        assert_nil  @app.command
+        assert_nil  @app.file
+      end
+      should 'have set args after parsing args' do
+        @app.args( [ 'command', 'file' ] )
+        assert_equal  'command',  @app.command
+        assert_equal  'file',     @app.file
+      end
+    end
+
+  end
+
+  context '#usage()' do
+    should 'return expected usage string' do
+      assert_equal "USAGE: taskish { done | today | week } <file>", Taskish::App.new.usage
+    end
+  end
+
+end # class AppTest
+

data/test/task_test.rb

@@ -1,27 +1,239 @@
 require 'test_helper'
+require 'date'
 
 class TaskTest < Test::Unit::TestCase
 
   context '#initialize()' do
+    should 'return object if no block given' do
+      assert_instance_of Taskish::Task, Taskish::Task.new("p", "t")
+    end
+    should 'work as a block' do
+      Taskish::Task.new("p", "t") do |task|
+        assert_instance_of Taskish::Task, task
+      end
+    end
+  end
+
+  context '#done?' do
+    should 'return false if @done not set' do
+      assert_equal  false,  Taskish::Task.new('proj', 'foo').done?
+    end
+    should 'return true if @done set' do
+      assert_equal  true,   Taskish::Task.new('proj', 'foo @done').done?
+    end
+  end
+
+  context '#due() and #due?()' do
+
+    context ' with no due date' do
+      setup do 
+        @task = Taskish::Task.new('proj', 'do something')
+      end
+      should 'be nil' do
+        assert_nil  @task.due
+      end
+      should 'not be due today' do
+        assert_equal  false, @task.due?(:today)
+      end
+      should 'not be due this week' do
+        assert_equal  false, @task.due?(:week)
+      end
+    end
+
+    context ' with implicit due date of today' do
+      setup do 
+        @d    = Date.today
+        @task = Taskish::Task.new('proj', 'do something @due')
+      end
+      should 'not be nil' do
+        assert_not_nil  @task.due
+      end
+      should 'be expected date' do
+        assert_equal  @d, @task.due
+      end
+      should 'be due today' do
+        assert_equal  true, @task.due?(:today)
+      end
+      should 'be due this week' do
+        assert_equal  true, @task.due?(:week)
+      end
+    end
+
+    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')
+      end
+      should 'not be nil' do
+        assert_not_nil  @task.due
+      end
+      should 'be expected date' do
+        assert_equal  @d, @task.due
+      end
+      should 'be due today' do
+        assert_equal  true, @task.due?(:today)
+      end
+      should 'be due this week' do
+        assert_equal  true, @task.due?(:week)
+      end
+    end
+
+    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') })")
+      end
+      should 'not be nil' do
+        assert_not_nil  @task.due
+      end
+      should 'be expected date' do
+        assert_equal  @d, @task.due
+      end
+      should 'be due today' do
+        assert_equal  true, @task.due?(:today)
+      end
+      should 'be due this week' do
+        assert_equal  true, @task.due?(:week)
+      end
+    end
+
+    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")
+      end
+      should 'not be nil' do
+        assert_not_nil  @task.due
+      end
+      should 'be expected date' do
+        assert_equal  @d, @task.due
+      end
+      should 'be due today' do
+        assert_equal  true, @task.due?(:today)
+      end
+      should 'be due this week' do
+        assert_equal  true, @task.due?(:week)
+      end
+    end
+
+    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') })")
+      end
+      should 'not be nil' do
+        assert_not_nil @task.due
+      end
+      should 'be expected date' do
+        assert_equal  @d, @task.due
+      end
+      should 'not be due today' do
+        assert_equal  false, @task.due?(:today)
+      end
+      should 'be due this week' do
+        assert_equal  true, @task.due?(:week)
+      end
+    end
+  end
+
+  context 'parse()' do
+    setup do
+      @project  = 'some project'
+      @task     = 'some task'
+      @today    = Date.today
+    end
+
     should 'raise ArgumentError if nil project' do
-      assert_raise(ArgumentError, 'invalid project')  { Taskish::Task.new(nil, "t") }
+      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('', "t")  }
+      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("p", nil) }
+      assert_raise(ArgumentError, 'invalid task')     { Taskish::Task.new(@project, nil) }
     end
     should 'raise ArgumentError if empty task' do
-      assert_raise(ArgumentError, 'invalid task')     { Taskish::Task.new("p", '')  }
+      assert_raise(ArgumentError, 'invalid task')     { Taskish::Task.new(@project, '')  }
     end
-    should 'return object if no block given' do
-      assert_instance_of Taskish::Task, Taskish::Task.new("p", "t")
+
+    should 'handle :project and :task' do
+      task  = @task
+      hash  = Taskish::Task.parse(@project, task)
+      assert_equal  @project, hash[:project]
+      assert_equal  @task,    hash[:task]
+      assert_equal  false,    hash.key?(:due)
+      assert_equal  false,    hash.key?(:done)
+      assert_equal  false,    hash.key?(:weekly)
     end
-    should 'work as a block' do
-      Taskish::Task.new("p", "t") do |task|
-        assert_instance_of Taskish::Task, task
-      end
+
+    should 'handle :project and :task with trailing whitespace' do
+      task  = "#{ @task }     "
+      hash  = Taskish::Task.parse(@project, task)
+      assert_equal  @project, hash[:project]
+      assert_equal  @task,    hash[:task]
+      assert_equal  false,    hash.key?(:due)
+      assert_equal  false,    hash.key?(:done)
+      assert_equal  false,    hash.key?(:weekly)
+    end
+
+    should 'handle :project, :task and implicit :due' do
+      task  = "#{ @task } @due"
+      hash  = Taskish::Task.parse(@project, task)
+      assert_equal  @project,     hash[:project]
+      assert_equal  @task,        hash[:task]
+      assert_equal  @today.to_s,  hash[:due].to_s
+      assert_equal  false,        hash.key?(:done)
+      assert_equal  false,        hash.key?(:weekly)
+    end
+
+    should 'handle :project, :task and :done' do
+      task  = "#{ @task } @done"
+      hash  = Taskish::Task.parse(@project, task)
+      assert_equal  @project,     hash[:project]
+      assert_equal  @task,        hash[:task]
+      assert_equal  false,        hash.key?(:due)
+      assert_equal  true,         hash.key?(:done)
+      assert_equal  false,        hash.key?(:weekly)
+    end
+
+    should 'handle :project, :task, implicit :due and :done' do
+      task  = "#{ @task } @due @done"
+      hash  = Taskish::Task.parse(@project, task)
+      assert_equal  @project,     hash[:project]
+      assert_equal  @task,        hash[:task]
+      assert_equal  @today.to_s,  hash[:due].to_s
+      assert_equal  true,         hash.key?(:done)
+      assert_equal  false,        hash.key?(:weekly)
+    end
+
+    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]
+      assert_equal  @task,        hash[:task]
+      assert_equal  @today.to_s,  hash[:due].to_s
+      assert_equal  false,        hash.key?(:done)
+      assert_equal  false,        hash.key?(:weekly)
+    end
+
+    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]
+      assert_equal  @task,        hash[:task]
+      assert_equal  @today.to_s,  hash[:due].to_s
+      assert_equal  true,         hash.key?(:done)
+      assert_equal  false,        hash.key?(:weekly)
+    end
+
+    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]
+      assert_equal  task,         hash[:task]
+      assert_equal  false,        hash.key?(:due)
+      assert_equal  false,        hash.key?(:done)
+      assert_equal  false,        hash.key?(:weekly)
     end
   end
 

data/test/taskish.txt

@@ -2,3 +2,10 @@ Project 1:
   - Task 1-A @due
   - Task 1-B
 
+Project 2:
+  - Task 2-A @due @done
+  - Task 2-B @done
+
+Project 3:
+  - Task 3-A @weekly
+

data/test/taskish_test.rb

@@ -1,7 +1,6 @@
 require 'test_helper'
 
 class TaskishTest < Test::Unit::TestCase
-
   context '#initialize()' do
     should 'return object if no block given' do
       assert_instance_of Taskish, Taskish.new
@@ -13,21 +12,42 @@ class TaskishTest < Test::Unit::TestCase
     end
   end
 
+  context '#done' do
+    setup do
+      @taskish  = Taskish.new
+      @fn       = File.join( File.dirname(__FILE__), 'taskish.txt' )
+      @taskish.readlines(@fn)
+    end
+    should 'return correct # of entries' do
+      assert_equal  2, @taskish.done.size  
+    end
+  end
+
+  context '#due' do
+    setup do
+      @taskish  = Taskish.new
+      @fn       = File.join( File.dirname(__FILE__), 'taskish.txt' )
+      @taskish.readlines(@fn)
+    end
+    should 'return correct # of entries for :today' do
+      assert_equal  1, @taskish.due(:today).size  
+    end
+  end
+
   context '#readlines()' do
     setup do
-      @taskish    = Taskish.new
-      @bad_file   = File.join( File.dirname(__FILE__), 'no_such_file.txt' )
-      @good_file  = File.join( File.dirname(__FILE__), 'taskish.txt' )
+      @taskish  = Taskish.new
+      @fn       = File.join( File.dirname(__FILE__), 'taskish.txt' )
     end
 
     should 'raise ArgumentError if file does not exist' do
-      assert_raise(ArgumentError, 'no such file') { @taskish.readlines(nil)       }
-      assert_raise(ArgumentError, 'no such file') { @taskish.readlines('')        }
-      assert_raise(ArgumentError, 'no such file') { @taskish.readlines(@bad_file) }
+      assert_raise(ArgumentError, 'no such file') { @taskish.readlines(nil)             }
+      assert_raise(ArgumentError, 'no such file') { @taskish.readlines('')              }
+      assert_raise(ArgumentError, 'no such file') { @taskish.readlines('no such file')  }
     end
 
     should 'not return self after reading file' do
-      assert_equal @taskish, @taskish.readlines(@good_file)
+      assert_equal @taskish, @taskish.readlines(@fn)
     end
   end
 

data/test/version_test.rb

@@ -3,7 +3,7 @@ require 'test_helper'
 class VersionTest < Test::Unit::TestCase
 
   should 'have expected version' do
-    assert_equal '0.0.1', Taskish::VERSION
+    assert_equal '0.2.0', Taskish::VERSION
   end
 
 end # class VersionTest

metadata

@@ -4,9 +4,9 @@ version: !ruby/object:Gem::Version
   prerelease: false
   segments: 
   - 0
+  - 2
   - 0
-  - 1
-  version: 0.0.1
+  version: 0.2.0
 platform: ruby
 authors: 
 - blair christensen.
@@ -64,9 +64,11 @@ files:
 - Rakefile
 - bin/taskish
 - lib/taskish.rb
+- lib/taskish/app.rb
 - lib/taskish/task.rb
 - lib/taskish/version.rb
 - taskish.gemspec
+- test/app_test.rb
 - test/task_test.rb
 - test/taskish.txt
 - test/taskish_test.rb
@@ -105,6 +107,7 @@ signing_key:
 specification_version: 3
 summary: Pending
 test_files: 
+- test/app_test.rb
 - test/task_test.rb
 - test/taskish.txt
 - test/taskish_test.rb