sculd 0.0.3 → 0.1.0

data/lib/sculd/plan/todo.rb

@@ -1,35 +1,43 @@
 #! /usr/bin/env ruby
 # coding: utf-8
 
-require "sculd/event.rb"
-require "sculd/plan.rb"
+#require "sculd/event.rb"
+#require "sculd/plan.rb"
 
 #
 #
 #
 class Sculd::Plan::Todo < Sculd::Plan
 
+  SYMBOL_CHAR = "+"
+  DEFAULT_OPTION = 7
+
   #
   def priority(today)
-    @option = 1 if @option < 1
+    #@option = 1 if @option < 1
+    option = @option || DEFAULT_OPTION
     beginning = @datetime
-    ending    = @datetime + @option
+    ending    = @datetime + option
     if today < beginning
       return 0
     elsif today <= ending
       rp = Sculd::Plan::REMINDER_PRIORITY
       dp = Sculd::Plan::DEADLINE_PRIORITY
-      return (rp + (dp - rp) * (today - beginning)/(@option.to_f)).to_i
+      return (rp + (dp - rp) * (today - beginning)/(option.to_f)).to_i
     else
       return Sculd::Plan::DEADLINE_PRIORITY
     end
   end
 
-  def events
+  def event_dates
+    #@option ||= DEFAULT_OPTION
+
     results = []
-    results << Sculd::Event.new(@datetime, @description)
-    results << Sculd::Event.new(@datetime + @option, @description)
-    return results
+    results << @datetime
+    results << @datetime + (@option || DEFAULT_OPTION)
+    results.map do |datetime|
+      Date.new(datetime.year, datetime.month, datetime.day)
+    end
   end
 end
 

data/test/helper.rb

@@ -0,0 +1,17 @@
+require 'rubygems'
+require 'bundler'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+require 'test/unit'
+
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+require 'sculd'
+
+class Test::Unit::TestCase
+end

data/test/schedule/normal/a.dat

@@ -0,0 +1,10 @@
+[2012-09-15]@ schedule a
+[2012-09-16]! deadline b
+[2012-09-17]- reminder c
+[2012-09-18]+ todo d
+  normal line
+
+[2012-09-15 (Sat) 23:45]@ schedule a'
+[2012-09-16 (Sun) 23:45]!30 deadline b'
+[2012-09-17 (Mon) 23:45]- reminder c'
+[2012-09-18 (Tue) 23:45]+10 todo d'

data/test/schedule/normal/b.dat

@@ -0,0 +1,5 @@
+[2012-10-15]@ schedule a
+[2012-10-16]! deadline b
+[2012-10-17]- reminder c
+[2012-10-18]+ todo d
+  normal line

data/test/test_deadline.rb

@@ -0,0 +1,47 @@
+#! /usr/bin/env ruby
+# coding: utf-8
+
+require "helper"
+
+class TC_Deadline < Test::Unit::TestCase
+  def setup
+    date = Date.new(2012, 10, 15)
+    @d00 = Sculd::Plan::Deadline.new(date, false, 10, 'deadlineA')
+
+    date = DateTime.new(2012, 10, 15, 23, 45, 00)
+    @d01 = Sculd::Plan::Deadline.new(date, false, 10, 'deadlineA')
+  end
+
+  #context 'Date[2012-10-15], 10, [2012-10-15]!10 deadlineA' do
+
+  def test_priority
+    today = Date.new(2012, 10, 15)
+    assert_equal(20000, @d00.priority(today))
+
+    today = Date.new(2012, 10, 20)
+    assert_equal(20000, @d00.priority(today))
+
+    today = Date.new(2012, 10, 10)
+    assert_equal(15000, @d00.priority(today))
+
+    today = Date.new(2012, 10,  1)
+    assert_equal(0, @d00.priority(today))
+  end
+
+  def test_event_dates
+    results = @d00.event_dates
+    assert_equal(2                     , results.size)
+    assert_equal(Date.new(2012, 10,  5), results[0]  )
+    assert_equal(Date.new(2012, 10, 15), results[1]  )
+    assert_equal(Date                  , results[0].class  )
+    assert_equal(Date                  , results[1].class  )
+
+    results = @d01.event_dates
+    assert_equal(2                     , results.size)
+    assert_equal(Date.new(2012, 10,  5), results[0]  )
+    assert_equal(Date.new(2012, 10, 15), results[1]  )
+    assert_equal(Date                  , results[0].class  )
+    assert_equal(Date                  , results[1].class  )
+  end
+
+end

data/test/test_manager.rb

@@ -0,0 +1,114 @@
+#! /usr/bin/env ruby
+# coding: utf-8
+
+require "helper"
+#require "test/unit"
+#require "pkg/klass.rb"
+
+class Sculd::Manager
+  public :load_file, :show_events, :days_events, :show_tasks
+  attr_accessor :plans
+end
+
+class TC_Manager < Test::Unit::TestCase
+  def setup
+    @s00 = Sculd::Manager.new("test/schedule/empty")
+#    @s01 = Sculd::Manager.new("test/schedule/normal")
+  end
+
+#  def test_load_file
+#    #context "correct data" do #it "should overwrite data" do
+#    @s00.load_file("test/schedule/normal/a.dat")
+#    assert_equal(8, @s00.plans.size)
+#    plans = @s00.plans
+#    assert(plans.shift.is_a? Sculd::Plan)
+#    assert(plans.shift.is_a? Sculd::Plan)
+#    assert(plans.shift.is_a? Sculd::Plan)
+#    assert(plans.shift.is_a? Sculd::Plan)
+#    assert(plans.shift.is_a? Sculd::Plan)
+#    assert(plans.shift.is_a? Sculd::Plan)
+#    assert(plans.shift.is_a? Sculd::Plan)
+#    assert(plans.shift.is_a? Sculd::Plan)
+#  end
+
+  def test_load_file_empty
+    @s00.load_file("test/schedule/empty/empty.dat")
+    assert_equal(0, @s00.plans.size)
+
+    #context "data containing error" do it "should interrupt with error line." do
+    io = StringIO.new
+    assert_raise(Sculd::Manager::LoadError){ @s00.load_file("test/schedule/error/error.dat", io)}
+  end
+
+#  def test_days_events
+#    #it 'should return hash dates as keys and events as values.' do
+#    #pp @s01
+#    results = @s01.days_events
+#    keys = results.keys
+#    #pp results
+#
+#    ## normal/a.dat
+#    assert_equal(Date.new(2012, 9, 15), keys.shift)
+#    assert_equal(Date.new(2012, 9,  9), keys.shift)
+#    assert_equal(Date.new(2012, 9, 16), keys.shift)
+#    assert_equal(Date.new(2012, 9, 17), keys.shift)
+#    assert_equal(Date.new(2012, 9, 18), keys.shift)
+#    assert_equal(Date.new(2012, 9, 25), keys.shift)
+#    assert_equal(Date.new(2012, 8, 17), keys.shift)
+#    assert_equal(Date.new(2012, 9, 28), keys.shift)
+#    ## normal/b.dat
+#    assert_equal(Date.new(2012,10, 15), keys.shift)
+#    assert_equal(Date.new(2012,10,  9), keys.shift)
+#    assert_equal(Date.new(2012,10, 16), keys.shift)
+#    assert_equal(Date.new(2012,10, 17), keys.shift)
+#    assert_equal(Date.new(2012,10, 18), keys.shift)
+#    assert_equal(Date.new(2012,10, 25), keys.shift)
+#    assert_equal(nil                  , keys.shift)
+#
+#    assert(results[Date.new(2012, 9, 15)].is_a? Array)
+#    assert(results[Date.new(2012, 9, 15)][0].is_a? Sculd::Plan)
+#  end
+#
+#  def test_show_events
+#    #it 'should return itemized days and events' do
+#    #pp @s01
+#    io = StringIO.new
+#    today = Date.new(2012, 9, 15)
+#    @s01.show_events(2, today, io)
+#    io.rewind
+#    results = io.readlines
+#    #pp results
+#    #assert_equal(9, results.size)
+#    assert_equal("Events:\n"                    , results.shift)
+#    assert_equal("   2012-09-15 Sat \n",
+#                 results.shift)
+#    assert_equal("           @   schedule a\n"  , results.shift)
+#    assert_equal("    [23:45]@   schedule a'\n" , results.shift)
+#    assert_equal("\n"                           , results.shift)
+#    assert_equal("   2012-09-16 Sun \n",
+#                 results.shift)
+#    assert_equal("           !   deadline b\n"  , results.shift)
+#    assert_equal("    [23:45]!30 deadline b'\n"  , results.shift)
+#    assert_equal("\n"                           , results.shift)
+#    assert_equal(nil                            , results.shift)
+#  end
+#
+#  def test_show_tasks
+#    #it 'should return sorted tasks' do
+#    io = StringIO.new
+#    today = Date.new(2012, 9,20)
+#    @s01.show_tasks(6, today, io)
+#    io.rewind
+#    results = io.readlines
+#    #pp results
+#    #assert_equal(7, results.size)
+#    assert_equal("Tasks:\n"                       , results.shift)
+#    assert_equal("  [2012-09-16]!30 deadline b'\n", results.shift)
+#    assert_equal("  [2012-09-16]!   deadline b\n" , results.shift)
+#    assert_equal("  [2012-09-18]+   todo d\n" , results.shift)
+#    assert_equal("  [2012-09-18]+10 todo d'\n", results.shift)
+#    assert_equal("  [2012-09-17]-   reminder c'\n", results.shift)
+#    assert_equal("  [2012-09-17]-   reminder c\n" , results.shift)
+#    assert_equal(nil                              , results.shift)
+#  end
+end

data/test/test_plan.rb

@@ -0,0 +1,97 @@
+#! /usr/bin/env ruby
+# coding: utf-8
+
+require "helper"
+#require "test/unit"
+#require "pkg/klass.rb"
+
+class TC_Plan < Test::Unit::TestCase
+  def test_parse
+    ## correct string
+    result = Sculd::Plan.parse('[2012-10-23]! deadlineA')
+    date = DateTime.new(2012, 10, 23, 0, 0, 0)
+    assert_equal(date       , result[:datetime])
+    assert_equal("!"        , result[:type])
+    assert_equal(nil        , result[:option])
+    assert_equal("deadlineA", result[:description])
+    assert_equal(false      , result[:flag_time])
+
+    result = Sculd::Plan.parse('[2012-10-23]!30 deadlineA')
+    date = DateTime.new(2012, 10, 23, 0, 0, 0)
+    assert_equal(date       , result[:datetime])
+    assert_equal("!"        , result[:type])
+    assert_equal(30         , result[:option])
+    assert_equal("deadlineA", result[:description])
+    assert_equal(false      , result[:flag_time])
+
+    result = Sculd::Plan.parse('[2012-10-23 01:02:03]@ scheduleA')
+    date = DateTime.new(2012, 10, 23, 1, 2, 3)
+    assert_equal(date       , result[:datetime])
+    assert_equal("@"        , result[:type])
+    assert_equal(nil        , result[:option])
+    assert_equal("scheduleA", result[:description])
+    assert_equal(true       , result[:flag_time])
+
+    result = Sculd::Plan.parse('[2012-11-01 01:02:03(Thu)]@ scheduleA')
+    date = DateTime.new(2012, 11,  1, 1, 2, 3)
+    assert_equal(date       , result[:datetime])
+    assert_equal("@"        , result[:type])
+    assert_equal(nil        , result[:option])
+    assert_equal("scheduleA", result[:description])
+    assert_equal(true       , result[:flag_time])
+
+    result = Sculd::Plan.parse('[2012-11-01 01:02:03(th)]@ scheduleA')
+    date = DateTime.new(2012, 11, 01, 1, 2, 3)
+    assert_equal(date       , result[:datetime])
+    assert_equal("@"        , result[:type])
+    assert_equal(nil        , result[:option])
+    assert_equal("scheduleA", result[:description])
+    assert_equal(true       , result[:flag_time])
+
+    #context 'schedule with wrong weekday' do
+    io = StringIO.new
+    assert_raise(Sculd::Plan::WeekdayMismatchError ){ Sculd::Plan.parse('[2012-11-01 01:02:03(Sun)]@ scheduleA', io)}
+
+    assert_raise(Sculd::Plan::WeekdayMismatchError ){ Sculd::Plan.parse( "[2012-11-01(Fri)]@ mismach weekday\n", io)}
+
+    assert_raise(Sculd::Plan::NotWeekdayError      ){ Sculd::Plan.parse('[2012-11-01 01:02:03(abc)]@ scheduleA', io)}
+
+    #Unable to interpret as date in [].
+    #assert_raise(Sculd::Plan::NotDateError ){ Sculd::Plan.parse('[abc]! deadlineA')}
+    assert_raise(ArgumentError){ Sculd::Plan.parse('[abc]! deadlineA')}
+
+    ##Illegal syntax
+    # '[abc]]! deadlineA' do
+    assert_raise(Sculd::Plan::NotNumberError){ 
+      Sculd::Plan.parse('[2012-01-01]]! deadlineA')
+    }
+    #date = DateTime.new(2012, 01, 01)
+    #assert_equal(date       , result[:datetime])
+    #assert_equal("]"        , result[:type])
+    #assert_equal("!"        , result[:option])
+    #assert_equal("deadlineA", result[:description])
+
+    #context '  [2012-10-23]! deadlineA with space at head' do
+    #it 'should return Date, !, deadlineA' do
+    result = Sculd::Plan.parse('  [2012-10-23]! deadlineA with space at head')
+    date = DateTime.new(2012, 10, 23)
+    assert_equal(date       , result[:datetime])
+    assert_equal("!"        , result[:type])
+    assert_equal(nil        , result[:option])
+    assert_equal("deadlineA with space at head", result[:description])
+    assert_equal(false      , result[:flag_time])
+
+    #context '[2012-10-23]!10 deadline with option value' do
+    #it 'should return Date, !, deadlineA' do
+    result = Sculd::Plan.parse( '[2012-10-23]!10 deadline with option value')
+    date = DateTime.new(2012, 10, 23)
+    assert_equal(date       , result[:datetime])
+    assert_equal("!"        , result[:type])
+    assert_equal(10         , result[:option])
+    assert_equal("deadline with option value", result[:description])
+    assert_equal(false      , result[:flag_time])
+
+
+
+  end
+end

data/test/test_reminder.rb

@@ -0,0 +1,38 @@
+#! /usr/bin/env ruby
+# coding: utf-8
+
+require "helper"
+#require "test/unit"
+#require "pkg/klass.rb"
+
+class TC_Klass < Test::Unit::TestCase
+  def setup
+    date = Date.new(2012, 10, 23)
+    @r00 = Sculd::Plan::Reminder.new(date, false, 10, 'reminderA')
+
+    date = DateTime.new(2012, 10, 23, 23, 45, 00)
+    @r01 = Sculd::Plan::Reminder.new(date, false, 10, 'reminderA')
+  end
+
+  def test_priority
+    #it 'return REMINDER_PRIORITY when the day is today .' do
+    date = Date.new(2012, 10, 23)
+    assert_equal(10000, @r00.priority(date))
+
+    #it 'return REMINDER_PRIORITY -1 when the day is yesterday .' do
+    date = Date.new(2012, 10, 24)
+    assert_equal(9999, @r00.priority(date))
+  end
+
+  def test_event_dates
+    #it 'return a Sculd::Event instance.' do
+    results = @r00.event_dates
+    assert_equal([Date.new(2012, 10, 23)], results)
+
+    results = @r01.event_dates
+    assert_equal(1                     , results.size)
+    assert_equal(Date.new(2012, 10, 23), results[0]  )
+    assert_equal(Date                  , results[0].class  )
+  end
+end
+

data/test/test_schedule.rb

@@ -0,0 +1,30 @@
+#! /usr/bin/env ruby
+# coding: utf-8
+
+require "helper"
+#require "test/unit"
+#require "pkg/klass.rb"
+
+class TC_Schedule < Test::Unit::TestCase
+  def setup
+    date = Date.new(2012, 10, 15)
+    @s00 = Sculd::Plan::Schedule.new(date, false,  0, "scheduleA")
+
+    date = DateTime.new(2012, 10, 15, 23, 45, 0)
+    @s01 = Sculd::Plan::Schedule.new(date, false,  0, "scheduleA")
+  end
+
+  def test_priority
+    #it 'should return 0' do
+    assert_equal(0, @s00.priority)
+  end
+
+  def test_event_dates
+    #it 'should return Array of 1 item' do
+    results = @s00.event_dates
+    assert_equal([Date.new(2012, 10, 15)], results)
+
+    results = @s01.event_dates
+    assert_equal([Date.new(2012, 10, 15)], results)
+  end
+end

data/test/test_todo.rb

@@ -0,0 +1,50 @@
+#! /usr/bin/env ruby
+# coding: utf-8
+
+require "helper"
+#require "test/unit"
+#require "pkg/klass.rb"
+
+class TC_Todo < Test::Unit::TestCase
+  def setup
+    today = Date.new(2012, 10, 15)
+    @t00 = Sculd::Plan::Todo.new(today, false, 10, 'todoA')
+
+    today = DateTime.new(2012, 10, 15, 23, 45, 00)
+    @t01 = Sculd::Plan::Todo.new(today, false, 10, 'todoA')
+  end
+
+  def test_priority
+    #it 'return 0 before the period.' do
+    today = Date.new(2012, 10,  1)
+    assert_equal(0, @t00.priority(today))
+
+    #it 'return REMINDER_PRIORITY when the day is today.' do
+    today = Date.new(2012, 10, 15)
+    assert_equal(10000, @t00.priority(today))
+
+    #it 'return values between REMINDER_PRIORITY and DEADLINE_PRIORITY during the period.' do
+    today = Date.new(2012, 10, 20)
+    assert_equal(15000, @t00.priority(today))
+
+    #it 'return DEADLINE_PRIORITY when the day is past.' do
+    today = Date.new(2012, 10, 30)
+    assert_equal(20000, @t00.priority(today))
+  end
+
+  def test_event_dates
+    results = @t00.event_dates
+    assert_equal(2, results.size)
+    assert_equal(Date.new(2012, 10, 15), results[0])
+    assert_equal(Date.new(2012, 10, 25), results[1])
+
+
+    results = @t01.event_dates
+    assert_equal(2                     , results.size)
+    assert_equal(Date.new(2012, 10, 15), results[0]  )
+    assert_equal(Date.new(2012, 10, 25), results[1]  )
+    assert_equal(Date                  , results[0].class  )
+    assert_equal(Date                  , results[1].class  )
+  end
+end
+