vpim 0.619 → 0.658

data/samples/reminder.rb

@@ -118,7 +118,7 @@ end
 puts
 
 def start_of_first_occurrence(t0, t1, e)
-  e.occurrences.each_until(t1).each do |t|
+  e.occurrences(t1) do |t|
     # An event might start before t0, but end after it..., in which case
     # we are still interested.
     if (t + (e.duration || 0)) >= t0

data/test/test_all.rb

@@ -1,14 +1,17 @@
 #!/usr/bin/env ruby
 
+require 'pp'
+
 $-w = true
-$:.unshift File.dirname($0)
+
+$:.unshift File.dirname(__FILE__) + "/../lib"
+
+
+pp [__LINE__, $:, $"]
 
 require 'test/unit'
 
-require 'test_date.rb'
-require 'test_dur.rb'
-require 'test_field.rb'
-require 'test_ical.rb'
-require 'test_rrule.rb'
-require 'test_vcard.rb'
+Dir[File.dirname(__FILE__) + "/test_*.rb"].each do |test|
+  require test unless test =~ /test_all/
+end
 

data/test/test_date.rb

@@ -8,8 +8,8 @@ class TestVpimDate < Test::Unit::TestCase
 
   def test_to_time
     # Need to test with DateTime, but I don't have that with ruby 1.6.
-    assert_equal(Time.at(0), Date.new(1970, 1, 1).to_time)
-    assert_equal(Time.at(24 * 60 * 60), Date.new(1970, 1, 2).to_time)
+    assert_equal(Time.at(0), Date.new(1970, 1, 1).vpim_to_time)
+    assert_equal(Time.at(24 * 60 * 60), Date.new(1970, 1, 2).vpim_to_time)
   end
 
   def test_date_weekstart

data/test/test_ical.rb

@@ -3,6 +3,14 @@
 require 'vpim/icalendar'
 require 'test/unit'
 
+
+# Sorry for the donkey patching...
+module Enumerable
+  def first
+    find{true}
+  end
+end
+
 include Vpim
 
 Req_1 =<<___
@@ -86,6 +94,10 @@ ___
 
 class TestIcal < Test::Unit::TestCase
 
+  def assert_time(expected, actual, msg = nil)
+    assert_in_delta(expected, actual, 1, msg)
+  end
+
   # Reported by Kyle Maxwell
   def test_serialize_todo
 icstodo =<<___
@@ -171,10 +183,12 @@ ___
 
   # FIXME - test bad durations, like 'PT1D'
 
-  def test_duration
-    event = Icalendar::Vevent.create(Date.new(2000, 1, 21))
-    assert_equal(nil,  event.duration)
-    assert_equal(nil,  event.dtend)
+  def test_event_duration
+    now = Time.now
+    event = Icalendar::Vevent.create(now)
+    assert_time(now, event.dtstart)
+    assert_nil(event.duration)
+    assert_nil(event.dtend)
 
     event = Icalendar::Vevent.create(Date.new(2000, 1, 21),
                                     'DURATION' => 'PT1H')
@@ -185,6 +199,33 @@ ___
     assert_equal(24*60*60, event.duration)
   end
 
+  def test_todo_duration
+    todo = Icalendar::Vtodo.create()
+    assert_nil(todo.dtstart)
+    assert_nil(todo.duration)
+    assert_nil(todo.due)
+
+    todo = Icalendar::Vtodo.create('DTSTART' => Date.new(2000, 1, 21),
+                                    'DURATION' => 'PT1H')
+    assert_equal(Time.gm(2000, 1, 21, 1),  todo.due)
+
+    todo = Icalendar::Vtodo.create('DTSTART' => Date.new(2000, 1, 21),
+                                    'DUE' => Date.new(2000, 1, 22))
+    assert_equal(24*60*60, todo.duration)
+  end
+
+  def test_journal_create
+    vj = Icalendar::Vjournal.create('DESCRIPTION' => "description")
+    assert_equal("description", vj.description)
+  end
+
+  def TODO_test_occurrence_with_date_start
+    d = Date.new(2000, 1, 21)
+    event = Icalendar::Vevent.create(d)
+    d1 = event.occurences.to_a.first
+    assert_equal(d.class, d1.class)
+  end
+
   def test_decode_duration_four_weeks
     assert_equal 4*7*86400, Icalendar.decode_duration('P4W')
   end
@@ -216,5 +257,159 @@ ___
   def test_decode_duration_with_composite_duration
     assert_equal((15*86400+5*3600+20), Icalendar.decode_duration('P15DT5H0M20S'))
   end
+
+  def test_create_with_prodid
+    prodid = "me//here/non-sgml"
+    cal = Icalendar.create2(prodid) do |cal|
+      assert_respond_to(cal, :push)
+    end
+    assert_equal(prodid, cal.producer)
+  end
+
+  def test_occurences
+    t0 = Time.now
+    vc = Icalendar.create2 do |vc|
+      vc.add_event do |ve|
+        ve.dtstart t0
+      end
+    end
+    ve = vc.components(Icalendar::Vevent).first
+    assert_time(t0, ve.occurences.select{true}.first)
+    ve.occurences do |t|
+      assert_time(t0, t)
+    end
+
+    vc = Icalendar.decode(<<__).first
+BEGIN:VCALENDAR
+BEGIN:VEVENT
+END:VEVENT
+END:VCALENDAR
+__
+    ve = vc.components(Icalendar::Vevent).first
+    assert_raises(ArgumentError) { ve.occurences }
+  end
+
+  def test_each
+    vc = Icalendar.decode(<<__).first
+BEGIN:VCALENDAR
+BEGIN:VEVENT
+END:VEVENT
+BEGIN:VTODO
+END:VTODO
+BEGIN:VJOURNAL
+END:VJOURNAL
+BEGIN:VTIMEZONE
+END:VTIMEZONE
+BEGIN:X-UNKNOWN
+END:X-UNKNOWN
+END:VCALENDAR
+__
+    count = Hash.new(0)
+
+    vc.each do |c| count[c.class] += 1 end
+
+    assert_equal(3, count.size)
+    count.each do |_,v| assert_equal(1, v) end
+
+    count = Hash.new(0)
+    vc.events do |c| count[c.class] += 1 end
+    vc.todos do |c| count[c.class] += 1 end
+    vc.journals do |c| count[c.class] += 1 end
+    assert_equal(3, count.size)
+    count.each do |_,v| assert_equal(1, v) end
+
+    assert_equal(3, vc.each.to_a.size)
+    assert_equal(1, vc.each.select{|c| Vpim::Icalendar::Vevent === c}.size)
+    assert_equal(1, vc.each.select{|c| Vpim::Icalendar::Vtodo === c}.size)
+    assert_equal(1, vc.each.select{|c| Vpim::Icalendar::Vjournal === c}.size)
+
+    assert_equal(1, vc.events.to_a.size)
+    assert_equal(1, vc.todos.to_a.size)
+    assert_equal(1, vc.journals.to_a.size)
+    
+    vc.to_s # Shouldn't raise...
+    # TODO - encode isn't round-tripping, unknown components are lost, which is
+    # not good.
+  end
+
+  def test_calscale
+    req = Icalendar.decode(<<__).first
+BEGIN:VCALENDAR
+END:VCALENDAR
+__
+    assert_equal("GREGORIAN", req.calscale)
+    req = Icalendar.decode(<<__).first
+BEGIN:VCALENDAR
+CALSCALE:GREGORIAN
+END:VCALENDAR
+__
+    assert_equal("GREGORIAN", req.calscale)
+  end
+
+  def test_version
+    req = Icalendar.decode(<<__).first
+BEGIN:VCALENDAR
+END:VCALENDAR
+__
+    assert_raises(InvalidEncodingError) { req.version }
+
+    req = Icalendar.decode(<<__).first
+BEGIN:VCALENDAR
+VERSION:2.0
+END:VCALENDAR
+__
+    assert_equal(20, req.version)
+  end
+
+  def test_protocol
+    req = Icalendar.decode(<<__).first
+BEGIN:VCALENDAR
+METHOD:GET
+END:VCALENDAR
+__
+    assert(req.protocol?("get"))
+    assert(!req.protocol?("set"))
+  end
+
+  def test_transparency
+    transparency = Icalendar.decode(<<__).first.to_a.first.transparency
+BEGIN:VCALENDAR
+BEGIN:VEVENT
+END:VEVENT
+END:VCALENDAR
+__
+    assert_equal("OPAQUE", transparency, "check default")
+
+    transparency = Icalendar.decode(<<__).first.to_a.first.transparency
+BEGIN:VCALENDAR
+BEGIN:VEVENT
+TRANSP:Opaque
+END:VEVENT
+END:VCALENDAR
+__
+    assert_equal("OPAQUE", transparency, "check opaque")
+
+    transparency = Icalendar.decode(<<__).first.to_a.first.transparency
+BEGIN:VCALENDAR
+BEGIN:VEVENT
+TRANSP:TrANSPARENT
+END:VEVENT
+END:VCALENDAR
+__
+    assert_equal("TRANSPARENT", transparency, "check transparent")
+
+  end
+
+  def test_event_maker_w_rrule
+    vc = Icalendar.create2 do |vc|
+      vc.add_event do |m|
+        m.add_rrule("freq=monthly")
+        m.set_rrule do |_| _.frequency = "daily" end
+      end
+    end
+    assert_no_match(/RRULE:FREQ=MONTHLY/, vc.to_s)
+    assert_match(/RRULE:FREQ=DAILY/, vc.to_s)
+  end
+
 end
 

data/test/test_repo.rb

@@ -0,0 +1,158 @@
+#!/usr/bin/env ruby
+
+require 'vpim/repo'
+require 'vpim/agent/calendars'
+require 'test/unit'
+
+require 'pp'
+
+module Enumerable
+  def count
+    self.inject(0){|i,_| i + 1}
+  end
+end
+
+class TestRepo < Test::Unit::TestCase
+  Apple3 = Vpim::Repo::Apple3
+  Directory = Vpim::Repo::Directory
+  Agent = Vpim::Agent
+  Path = Agent::Path
+  NotFound = Agent::NotFound
+
+  def setup
+    @testdir = Dir.getwd + "/test" #File.dirname($0) doesn't work with rcov :-(
+    @caldir = @testdir + "/calendars"
+    @eventsz = Dir[@caldir + "/**/*.ics"].size
+    assert(@testdir)
+    assert(test(?d, @caldir), "no caldir "+@caldir)
+  end
+
+  def _test_each(repo, eventsz)
+    repo.each do |cal|
+      assert_equal(eventsz, cal.events.count, cal.name)
+      assert("", File.extname(cal.name))
+      assert_equal(cal.displayed, true)
+      cal.events do |c|
+        assert_instance_of(Vpim::Icalendar::Vevent, c)
+      end
+      cal.events.each do |c|
+        assert_instance_of(Vpim::Icalendar::Vevent, c)
+      end
+      assert_equal(0, cal.todos.count)
+      assert(cal.encode)
+    end
+  end
+
+  def test_apple3
+    repo = Apple3.new(@caldir)
+
+    assert_equal(1, repo.count)
+
+    _test_each(repo, @eventsz)
+  end
+
+  def test_dir
+    assert(test(?d, @caldir))
+
+    repo = Directory.new(@caldir)
+
+    assert_equal(@eventsz, repo.count)
+
+    _test_each(repo, 1)
+  end
+
+  def assert_is_text_calendar(text)
+    lines = text.split("\n")
+    lines = lines.first, lines.last
+    assert_equal("BEGIN:VCALENDAR", lines.first.upcase, lines)
+    assert_equal("END:VCALENDAR", lines.last.upcase, lines)
+  end
+
+  def test_agent_calendars
+    repo = Apple3.new(@caldir)
+    rest = Agent::Calendars.new(repo)
+
+    out1, form = rest.get(Path.new("http://host/here", "/here"))
+    assert_equal("text/html", form)
+    #puts(out1)
+
+    out1, form = rest.get(Path.new("http://host/here/weather%2fLeavenworth", "/here"))
+    assert_equal("text/html", form)
+    #puts(out1)
+
+    out2, form = rest.get(Path.new("http://host/here/weather%2fLeavenworth/calendar", "/here"))
+    assert_equal("text/calendar", form)
+    assert_is_text_calendar(out2)
+
+    #assert_equal(out1, out2)
+
+    assert_raise(Vpim::Agent::NotFound) do
+      rest.get(Path.new("http://host/here/weather%2fLeavenworth/an_unknown_protocol", "/here"))
+    end
+    assert_raise(Vpim::Agent::NotFound) do
+      rest.get(Path.new("http://host/here/no_such_calendar", "/here"))
+    end
+
+    assert_equal(["","/","/"], Vpim::Agent::Path.split_path("/%2F/%2F"))
+    assert_equal(["/","/"], Vpim::Agent::Path.split_path("%2F/%2F"))
+    assert_equal(["calendars", "weather/Leavenworth"],
+                 Vpim::Agent::Path.split_path("calendars/weather%2FLeavenworth"))
+  end
+
+  def test_agent_calendar_atom
+    repo = Apple3.new(@caldir)
+    rest = Agent::Calendars.new(repo)
+
+    out, form = rest.get(Path.new("http://host/here/weather%2fLeavenworth/atom", "/here"))
+    assert_equal("application/atom+xml", form)
+    #pp out
+    #assert_is_atom(out)
+  end
+
+  def _test_path_shift(url, shifts)
+    # last shift should be a nil
+    shifts << nil
+
+    # presence or absence of a trailing / should not affect shifting
+    ["", "/"].each do |trailer|
+      path = Path.new(url + trailer)
+      shifts.each do |_|
+        assert_equal(_, path.shift)
+      end
+    end
+  end
+
+  def test_path_shift
+    _test_path_shift("http://host.ex", [])
+    _test_path_shift("http://host.ex/a", ["a"])
+    _test_path_shift("http://host.ex/a/b", ["a", "b"])
+    _test_path_shift("http://host.ex/a/b/c", ["a", "b", "c"])
+  end
+
+  def _test_path_prefix(base, parts, shifts, prefix)
+    path = Path.new(base+parts.join("/"))
+    shifts.times{ path.shift }
+    assert_equal(prefix, path.prefix)
+  end
+
+  def test_path_prefix
+    _test_path_prefix("http://host.ex/", [], 0, "/")
+    _test_path_prefix("http://host.ex/", ["a"], 0, "/")
+    _test_path_prefix("http://host.ex/", ["a"], 1, "/")
+    _test_path_prefix("http://host.ex/", ["a"], 2, "/a/")
+    _test_path_prefix("http://host.ex/", ["a"], 3, "/a/")
+    _test_path_prefix("http://host.ex/", ["a", "b"], 0, "/")
+    _test_path_prefix("http://host.ex/", ["a", "b"], 1, "/")
+    _test_path_prefix("http://host.ex/", ["a", "b"], 2, "/a/")
+    _test_path_prefix("http://host.ex/", ["a", "b"], 3, "/a/b/")
+  end
+
+  def test_atomize
+    repo = Apple3.new(@caldir)
+    cal = repo.find{true}
+    a = Vpim::Agent::Atomize.new(cal)
+    assert( a.get(Path.new("http://example.com/path")))
+  end
+
+end
+

data/test/test_rrule.rb

@@ -3,6 +3,7 @@
 ENV['TZ'] = 'EST5EDT'
 
 require 'vpim/rrule'
+require 'vpim/icalendar'
 require 'test/unit'
 
 require 'pp'
@@ -14,6 +15,8 @@ end
 =end
 
 class TestRrule < Test::Unit::TestCase
+  Rrule = Vpim::Rrule
+
 #=begin
   # Comment out these if you want printing!
   def puts(*args)
@@ -975,5 +978,53 @@ RRULE:FREQ=MONTHLY;BYMONTH=12;INTERVAL=1;BYDAY=MO,TU,WE,TH,FR;BYMONTHDAY=26,27,2
 END:VEVENT
 =end
 
+
+  def test_reccurrence_with_utc_dtstart
+    # Its wrong that the times yielded aren't in the timezone of DTSTART, but
+    # until vPim supports timezones, its the best it'll get.
+    txt = <<'__'
+BEGIN:VCALENDAR
+BEGIN:VEVENT
+DTSTAMP:20080416T174954Z
+ORGANIZER;CN=Anonymous:MAILTO:ano@nymo.us
+CREATED:20080401T090904Z
+LAST-MODIFIED:20080401T090904Z
+SUMMARY:Very important recurring event
+RRULE:FREQ=WEEKLY;UNTIL=20080415T093000Z;BYDAY=TU;BYHOUR=9
+DTSTART:20080401T093000Z
+DTEND:20080401T110000Z
+TRANSP:OPAQUE
+END:VEVENT
+END:VCALENDAR
+__
+    cal = Vpim::Icalendar.decode(txt).first
+    occurs = cal.events.to_a.first.occurrences.to_a
+    #p occurs
+    utc = occurs.map{|y| y.utc}
+    #p utc
+    expects = [
+      Time.utc(2008, 4, 1, 9, 30),
+      Time.utc(2008, 4, 8, 9, 30),
+      Time.utc(2008, 4,15, 9, 30),
+    ]
+    assert_equal(expects, utc)
+  end
+
+  def test_maker
+    assert_equal("FREQ=WEEKLY",
+                 Rrule::Maker.new{|m|m.frequency = "WEEKLY"}.encode)
+    assert_equal("FREQ=WEEKLY;COUNT=2",
+                 Rrule::Maker.new{|m|m.frequency = "WEEKLY"; m.count = 2}.encode)
+    assert_raises(ArgumentError) do
+      Rrule::Maker.new{|m|m.count = 2; m.until = Time.now}
+    end
+    assert_raises(ArgumentError) do
+      Rrule::Maker.new{|m|m.until = Time.now; m.count = 4}
+    end
+    assert_raises(ArgumentError) do
+      Rrule::Maker.new.encode
+    end
+  end
+
 end