jruby-rfc2445 0.0.4

data/MIT-LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2009 Jerry Luk <jerryluk@gmail.com>
+
+Permission is hereby granted, free of charge, to any person
+obtaining a copy of this software and associated documentation
+files (the "Software"), to deal in the Software without
+restriction, including without limitation the rights to use,
+copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the
+Software is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+OTHER DEALINGS IN THE SOFTWARE.

data/README

@@ -0,0 +1,14 @@
+jruby-rfc2445
+=============
+A JRuby implementation of RFC 2445 (ical) recurrence rules.
+
+This library makes use of the google-rfc-2445 library (http://code.google.com/p/google-rfc-2445/)
+To see the usage, please see the RSpec test cases.
+
+The JTime class uses Joda-time as its underlying implementation. To find out more about Joda time, visit:
+http://joda-time.sourceforge.net/
+
+Getting Started
+===============
+1. Make sure you can install RubyGem from GitHub (you only have to do this once): jruby -S gem sources -a http://gems.github.com
+2. Install JRuby RFC 2445 library: jruby -S gem install jerryluk-jruby-rfc2445

data/lib/ical_parse_util.rb

@@ -0,0 +1,51 @@
+require 'java'
+require File.dirname(__FILE__) + '/rfc2445.jar'
+
+class ICalParseUtil
+  include_class('com.google.ical.values.IcalParseUtil'){|package,name| "J#{name}" }
+  
+  # Class Methods
+  class << self
+    def parse_date_value(s, tzid = 'UTC')
+      timezone = java.util.TimeZone.getTimeZone(tzid || 'UTC')
+      s ? JIcalParseUtil.parseDateValue(s, timezone) : nil
+    end
+    
+    def parse_jtime(s, tzid = 'UTC')
+      s ? JTime.from_date_time_value(parse_date_value(s, tzid || 'UTC')) : nil
+    end
+    
+    # Parse a recurrence block and returns DTSTART, DTEND, RRULE, EXRULE, RDATE, and EXDATE
+    def parse_recurrence(s)
+      result = {}
+      
+      # Strip out all the begin..end blocks
+      s = s.gsub(/BEGIN.*END[^\s]+/m, '')
+      
+      s =~ /(DTSTART[^\s]+)/
+      result[:dtstart] = $1 if $1
+      
+      s =~ /(DTEND[^\s]+)/
+      result[:dtend] = $1 if $1
+      
+      s =~ /(RRULE[^\s]+)/
+      result[:rrule] = $1 if $1
+      
+      s =~ /(EXRULE[^\s]+)/
+      result[:exrule] = $1 if $1
+      
+      s =~ /(RDATE[^\s]+)/
+      result[:rdate] = $1 if $1
+      
+      s =~ /(EXDATE[^\s]+)/
+      result[:exdate] = $1 if $1
+      
+      result
+    end
+    
+    def parse_datetime(s)
+      s =~ /(;TZID=([^\s]+))?:([^\s]+)/
+      parse_jtime($3, $2)
+    end
+  end
+end

data/lib/jtime.rb

@@ -0,0 +1,201 @@
+require 'java'
+require File.dirname(__FILE__) + '/rfc2445.jar'
+
+class JTime
+  include Comparable
+  include_class('org.joda.time.DateTime'){|package,name| "J#{name}" }
+  
+  # Class Methods
+  class << self
+    # Creates a new time object with the given number of seconds (and optional
+    # microseconds) from epoch.
+    # 
+    # ==== Options
+    # +seconds+:: given number of seconds from epoch
+    # +microseconds+:: Optional. microseconds from epoch
+    #
+    def at(seconds, microseconds=0)
+      datetime = JDateTime.new(seconds * 1000 + microseconds)
+      new(datetime)
+    end
+    
+    # Creates a time based on given values, interpreted as UTC (GMT).
+    # The year must be specified. Other values default to the minimum
+    # value for that field.
+    # 
+    # ==== Options
+    # +year+:: Year
+    # +month+:: Optional. Numbers from 1 to 12, or by the three-letter
+    #           English month names
+    # +hour+:: Optional.24-hour clock (0..23)
+    # +min+:: Optional. 0..59
+    # +sec+:: Optional. seconds of the time
+    # +usec+:: Optional. microsecond of the time
+    def utc(year, month=1, day=1, hour=0, min=0, sec=0, usec=0)
+      datetime = JDateTime.new(year, numeric_month(month), day, hour, min, sec, usec, 
+                               org.joda.time.DateTimeZone::UTC)
+      new(datetime)
+    end
+    
+    # Same as JTime.utc, but interprets the values in local time zone
+    def local(year, month=1, day=1, hour=0, min=0, sec=0, usec=0)
+      datetime = JDateTime.new(year, numeric_month(month), day, hour, min, sec, usec)
+      new(datetime)
+    end
+    
+    # Initialize a JTime object from DateTimeValue
+    def from_date_time_value(dtv)
+      utc(dtv.year, dtv.month, dtv.day, dtv.hour, dtv.minute, dtv.second)
+    end
+    
+    # Initialize a JTime object from Ruby Time object
+    def from_time(time)
+      datetime = JDateTime.new((time.to_f * 1000).to_i)
+      new(datetime)
+    end
+    
+    alias :now :new
+    alias :gm :utc
+    alias :mktime :local
+    
+    protected
+    MONTH_NAME_HASH = {
+      'jan' => 1,
+      'feb' => 2,
+      'mar' => 3,
+      'apr' => 4,
+      'may' => 5,
+      'jun' => 6,
+      'jul' => 7,
+      'aug' => 8,
+      'sep' => 9,
+      'oct' => 10,
+      'nov' => 11,
+      'dec' => 12
+    }
+    
+    def numeric_month(mon)
+      return mon if mon.kind_of? Fixnum
+      MONTH_NAME_HASH[mon.downcase]
+    end
+  end
+  
+  # Instance Methods
+  
+  # Returns a JTime object. If a Java DateTime object is passed, it is initialized
+  # from the Java JDateTime object, otherwise it is initialized to the current
+  # system time
+  # 
+  # ==== Options
+  # +datetime+:: Optional. The Java DateTime (org.joda.time.DateTime')object
+  #
+  def initialize(datetime = JDateTime.new)
+    @time = datetime
+    self
+  end
+  
+  # Returns a Ruby Time object
+  def to_time
+    millis = @time.getMillis
+    Time.at(millis / 1000, millis % 1000 * 1000)
+  end
+  
+  # Returns the underlying Java DateTime object
+  def to_java
+    @time
+  end
+  
+  # Returns the value of time as an integer number of seconds since epoch
+  def to_i
+    @time.getMillis / 1000
+  end
+  
+  # Returns the value of time as a floating point number of seconds since epoch
+  def to_f
+    @time.getMillis / 1000.0
+  end
+  
+  # Returns a string representing JTime
+  def to_s
+    @time.toString
+  end
+
+  # Returns a new JTime object in UTC time. The receiver is unchanged
+  # IMPORTANT: The original utc in Ruby modified the receiver object
+  def utc
+    datetime = @time.toDateTime(org.joda.time.DateTimeZone::UTC)
+    self.class.new(datetime)
+  end
+  
+  def <=>(another_time)
+    @time.compareTo(another_time.to_java)
+  end
+  
+  def year
+    @time.getYear
+  end
+  
+  def month
+    @time.getMonthOfYear
+  end
+  
+  def day
+    @time.getDayOfMonth
+  end
+  
+  def hour
+    @time.getHourOfDay
+  end
+  
+  def min
+    @time.getMinuteOfHour
+  end
+  
+  def sec
+    @time.getSecondOfMinute
+  end
+  
+  def wday
+    @time.getDayOfWeek
+  end
+  
+  def yday
+    @time.getDayOfYear
+  end
+  
+  def week
+    @time.getWeekOfWeekyear
+  end
+  
+  # Returns the name of the timezone used for time. 
+  # IMPORTANT: Unlike Ruby Time, which returns "PST"
+  # it actuallys return real timezone ID such as 'America/Los_Angeles'
+  def zone
+    @time.getZone.getID
+  end
+  
+  # Returns DateTimeValue object
+  def to_date_time_value
+    com.google.ical.values.DateTimeValueImpl.new(self.year, self.month, self.day, self.hour, self.min, self.sec)
+  end
+  
+  # Returns the Java Timezone object
+  def java_zone
+    @time.getZone
+  end
+  
+  # Returns true if time occurs during Daylight Saveing Time in its timeezone
+  def isdst
+    timezone = @time.getZone.toTimeZone
+    timezone.inDaylightTime(@time.toDate)
+  end
+  
+  # We should consider getting rid of this or implement this using meta-programming
+  def method_missing(key, *params)
+    @time.send(key, *params)
+  end
+  
+  alias :mon :month
+  alias :dst? :isdst
+  
+end

data/lib/rdate_list.rb

@@ -0,0 +1,95 @@
+require 'java'
+require File.dirname(__FILE__) + '/rfc2445.jar'
+
+class RDateList
+  include_class('com.google.ical.values.RDateList') { |package,name| "J#{name}" }
+  include_class('java.util.TimeZone') { |package,name| "J#{name}" }
+  
+  RDATE = 'RDATE'
+  EXDATE = 'EXDATE'
+  VEVENT = 'VEVENT'
+  
+  # Initializes a RDateList with optionally a time zone ID and an iCal string
+  #
+  # ==== Options
+  # +timezone+:: Optional. Time zone ID. For instance, the time zone ID for the 
+  #              U.S. Pacific Time zone is "America/Los_Angeles"
+  #              If no timezone is specify, it uses time zone where the program
+  #              is run
+  # +ical_string+:: Optional. The iCal string for the recurrent rule.
+  #                 The string must specify the rule type (RRULE, EXRULE or VEVENT)
+  #
+  def initialize(timezone=nil, ical_string=nil)
+    tz = timezone ? JTimeZone.getTimeZone(timezone) : JTimeZone.getDefault
+    @rdatelist = ical_string ? 
+                 JRDateList.new(ical_string, tz) :
+                 JRDateList.new(tz)
+    self
+  end
+  
+  # Returns the underlying Java object
+  def to_java
+    @rdatelist
+  end
+  
+  # Returns the unfolded RFC 2445 content line.
+  def to_ical
+    @rdatelist.toIcal
+  end
+  
+  # Returns a hash map of any extension parameters such as
+  # the X-FOO=BAR in RRULE;X-FOO=BAR
+  def ext_params
+    h = {}
+    @rdatelist.getExtParams.to_a.each do |p|
+      h[p[0]] = p[1]
+    end
+    h
+  end
+  
+  # Returns the type of the object name such as
+  # RRULE, EXRULE, or VEVENT
+  def name
+    @rdatelist.getName
+  end
+  
+  # Sets the type of the object such as
+  # RRULE, EXRULE, or VEVENT
+  # 
+  # ==== Options
+  # +new_name+:: 'RRULE', 'EXRULE', or 'VEVENT'
+  def name=(new_name)
+    @rdatelist.setName(new_name)
+    self
+  end
+  
+  # Returns the timezone ID. For instance, the time zone ID for the 
+  # U.S. Pacific Time zone is "America/Los_Angeles"
+  def zone
+    @rdatelist.getTzid.getID
+  end
+  
+  # Sets the timezone using Time zone ID
+  def zone=(timezone)
+    @rdatelist.setTzid(JTimeZone.getTimeZone(timezone))
+    self
+  end
+  
+  # Returns the JTime in UTC time zone
+  def utc_dates
+    dates = @rdatelist.getDatesUtc
+    dates.map do |d|
+      JTime.utc(d.year, d.month, d.day)
+    end
+  end
+  
+  # Sets the dates. It will convert the dates into UTC.
+  def utc_dates=(dates)
+    dates = dates.map do |d|
+      utc_d = d.utc
+      com.google.ical.values.DateValueImpl.new(utc_d.year, utc_d.month, utc_d.day)
+    end
+    @rdatelist.setDatesUtc(dates.to_java('com.google.ical.values.DateValue'))
+    self
+  end
+end

data/lib/recurrence_time.rb

@@ -0,0 +1,58 @@
+require 'java'
+require File.dirname(__FILE__) + '/rfc2445.jar'
+
+class RecurrenceTime
+  include Enumerable
+  include_class('com.google.ical.compat.jodatime.DateTimeIteratorFactory')
+  
+  # Initializes a RecurrenceTime objects which generates JTime based on 
+  # recurrence rule
+  # 
+  # ==== Options
+  # +rdata+:: it can be one of the following:
+  #           1. RRULE, EXRULE, RDATE, and EXDATE lines (RFC 2445 content strings)
+  #           2. RRule or RDateList object
+  #           3. Array of RRule and RDateList objects, which can be a combinations of 
+  #              RRULE and EXRULE
+  # +start_time+:: Optional. Start time of the recurrence time. The default is now 
+  # +strict+:: Optional. Any failure to parse should result in a ParseException
+  #            false causes bad content lines to be logged and ignored. Default is true
+  # 
+  def initialize(rdata, start_time=JTime.new, strict=true)
+    rdata = rdata.to_ical if (rdata.kind_of? RRule or
+                              rdata.kind_of? RDateList)
+    rdata = (rdata.map {|r| r.to_ical}).join("\n") if rdata.kind_of? Array
+    @iterator = DateTimeIteratorFactory.createDateTimeIterator(rdata, 
+                start_time.to_java, 
+                start_time.java_zone,
+                strict)
+    self
+  end
+  
+  # Returns a JTime for the instance of next recurrence time
+  def next
+    @iterator.hasNext ? JTime.new(@iterator.next) : nil
+  end
+  
+  # Skips all dates in the series before the given date. 
+  # 
+  # ==== Options
+  # +new_start_time+:: JTime which the iterator is advanced to.
+  # 
+  def advance_to(new_start_time)
+    @iterator.advanceTo(new_start_time.to_java)
+    self
+  end
+  
+  def has_next?
+    @iterator.hasNext
+  end
+  
+  def to_java
+    @iterator
+  end
+  
+  def each
+    yield self.next until self.has_next? == false
+  end
+end

data/lib/rfc2445.rb

@@ -0,0 +1,9 @@
+require 'java'
+require File.dirname(__FILE__) + '/jtime.rb'
+require File.dirname(__FILE__) + '/weekday.rb'
+require File.dirname(__FILE__) + '/weekday_num.rb'
+require File.dirname(__FILE__) + '/rrule.rb'
+require File.dirname(__FILE__) + '/rdate_list.rb'
+require File.dirname(__FILE__) + '/recurrence_time.rb'
+require File.dirname(__FILE__) + '/ical_parse_util.rb'
+include_class "com.google.ical.values.Frequency"

data/lib/rrule.rb

@@ -0,0 +1,244 @@
+require 'java'
+require File.dirname(__FILE__) + '/rfc2445.jar'
+
+class RRule
+  include_class('com.google.ical.values.RRule'){|package,name| "J#{name}" }
+  
+  RRULE = 'RRULE'
+  EXRULE = 'EXRULE'
+  VEVENT = 'VEVENT'
+  
+  # Initializes a Recurrence Rule with optionally an iCal string
+  #
+  # ==== Options
+  # +ical_string+:: Optional. The iCal string for the recurrent rule.
+  #                 The string must specify the rule type (RRULE, EXRULE or VEVENT)
+  # 
+  def initialize(ical_string=nil)
+    @rrule = ical_string ? JRRule.new(ical_string) : JRRule.new
+    self
+  end
+  
+  # Returns the underlying Java object
+  def to_java
+    @rrule
+  end
+  
+  # Returns the unfolded RFC 2445 content line.
+  def to_ical
+    @rrule.toIcal
+  end
+  
+  # Returns a hash map of any extension parameters such as
+  # the X-FOO=BAR in RRULE;X-FOO=BAR
+  def ext_params
+    h = {}
+    @rrule.getExtParams.to_a.each do |p|
+      h[p[0]] = p[1]
+    end
+    h
+  end
+  
+  def count
+    @rrule.getCount
+  end
+  
+  # ==== Options
+  # +new_count+:: number of count
+  def count=(new_count)
+    @rrule.setCount(new_count)
+    self
+  end
+  
+  def hours
+    @rrule.getByHour.to_a
+  end
+  
+  # ==== Options
+  # +new_hours+:: array of numbers (0..23)
+  def hours=(new_hours=[])
+    @rrule.setByHour(new_hours.to_java(:int))
+    self
+  end
+  
+  def minutes
+    @rrule.getByMinute.to_a
+  end
+  
+  # ==== Options
+  # +new_minutes+:: array of numbers (0..59)
+  def minutes=(new_minutes=[])
+    @rrule.setByMinute(new_minutes.to_java(:int))
+    self
+  end
+  
+  def months
+    @rrule.getByMonth.to_a
+  end
+  
+  # ==== Options
+  # +new_months+:: array of numbers (1..12)
+  def months=(new_months=[])
+    @rrule.setByMonth(new_months.to_java(:int))
+    self
+  end
+  
+  # Gets the days of month
+  def mdays
+    @rrule.getByMonthDay.to_a
+  end
+  
+  # Sets the days of month
+  # 
+  # ==== Options
+  # +new_mdays+:: array of days of month (1..31)
+  def mdays=(new_mdays=[])
+    @rrule.setByMonthDay(new_mdays.to_java(:int))
+    self
+  end
+  
+  def seconds
+    @rrule.getBySecond.to_a
+  end
+  
+  # ==== Options
+  # +new_seconds+:: array of days of month (0..59)
+  def seconds=(new_seconds=[])
+    @rrule.setBySecond(new_seconds.to_java(:int))
+    self
+  end
+  
+  def setpos
+    @rrule.getBySetPos.to_a
+  end
+  
+  def setpos=(new_setpos=[])
+    @rrule.setByPos(new_setpos.to_java(:int))
+    self
+  end
+  
+  def weeknums
+    @rrule.getByWeekNo.to_a
+  end
+  
+  # Sets the numbers of week
+  # 
+  # ==== Options
+  # +new_weeknums+:: array of weeks (1..52)
+  def weeknums=(new_weeknums=[])
+    @rrule.setByWeekNo(new_weeknums.to_java(:int))
+    self
+  end
+  
+  # Gets the day of year
+  def ydays
+    @rrule.getByYearDay.to_a
+  end
+  
+  # Sets the day of year
+  # 
+  # ==== Options
+  # +new_ydays+:: array of day of year (1..365)
+  def ydays=(new_ydays=[])
+    @rrule.setByYearDay(new_ydays.to_java(:int))
+    self
+  end
+  
+  # Gets the recurrence frequency, return type is defined in
+  # "com.google.ical.values.Frequency", such as Frequency::MONTHLY
+  def frequency
+    @rrule.getFreq
+  end
+  
+  # Sets the recurrence frequency
+  # 
+  # ==== Options
+  # +freq+:: defined in com.google.ical.values.Frequency, such as
+  #          Frequency::MONTHLY or Frequency::DAILY
+  def frequency=(freq)
+    @rrule.setFreq(freq)
+    self
+  end
+  
+  def interval
+    @rrule.getInterval
+  end
+  
+  def interval=(new_interval)
+    @rrule.setInterval(new_interval)
+    self
+  end
+  
+  # Returns the type of the recurrence rule such as
+  # RRULE, EXRULE, or VEVENT
+  def name
+    @rrule.getName
+  end
+  
+  # Sets the type of the recurrence rule such as
+  # RRULE, EXRULE, or VEVENT
+  # 
+  # ==== Options
+  # +new_name+:: 'RRULE', 'EXRULE', or 'VEVENT'
+  def name=(new_name)
+    @rrule.setName(new_name)
+    self
+  end
+  
+  # Gets the WeekdayNums for the recurrence rule
+  # WeekdayNum is an object which specifies the week of year
+  # and the day of week
+  def days
+    @rrule.getByDay.to_a.map do |d|
+      WeekdayNum.new(d)
+    end
+  end
+  
+  # Sets the WeekdayNums for the recurrence rule
+  # WeekdayNum is an object which specifies the week of year
+  # and the day of week
+  # 
+  # ==== Options
+  # +new_days+:: Array of WeekdayNums
+  def days=(new_days)
+    @rrule.setByDay(new_days.map {|d| d.to_java})
+    self
+  end
+  
+  # Gets the starting day of the week (0-6)
+  def wdaystart
+    weekday = @rrule.getWkSt
+    Weekday::MAP[weekday]
+  end
+  
+  # Sets the starting day of the week (0-6, Mon-Sun, Mo-Su)
+  # 
+  # ==== Options
+  # +wday+:: 0-6, 'Mon' - 'Sun', or 'Mo' - 'Su'
+  def wdaystart=(wday)
+    wday = Weekday::MAP[wday.to_s.downcase]
+    @rrule.setWkSt(wday)
+    self
+  end
+  
+  # Gets the end date
+  def until
+    d = @rrule.getUntil
+    d ? JTime.local(d.year, d.month, d.day, d.hour, d.minute, d.second) : nil
+  end
+  
+  # Sets the end date
+  # 
+  # ==== Options
+  # +new_date+:: JTime object
+  def until=(new_date)
+    d = com.google.ical.values.DateTimeValueImpl.new(new_date.year, new_date.month, new_date.day, new_date.hour, new_date.min, new_date.sec)
+    @rrule.setUntil(d)
+    self
+  end
+  
+  # We should consider getting rid of this or implement this using meta-programming
+  def method_missing(key, *params)
+    @rrule.send(key, *params)
+  end
+end

data/lib/weekday.rb

@@ -0,0 +1,23 @@
+require 'java'
+require File.dirname(__FILE__) + '/rfc2445.jar'
+
+class Weekday
+  include_class('com.google.ical.values.Weekday') {|package,name| "J#{name}" }
+  MAP = {
+    '0' => JWeekday::SU, 'sun' => JWeekday::SU, 'su' => JWeekday::SU,
+    '1' => JWeekday::MO, 'mon' => JWeekday::MO, 'mo' => JWeekday::MO,
+    '2' => JWeekday::TU, 'tue' => JWeekday::TU, 'tu' => JWeekday::TU,
+    '3' => JWeekday::WE, 'wed' => JWeekday::WE, 'we' => JWeekday::WE,
+    '4' => JWeekday::TH, 'thu' => JWeekday::TH, 'th' => JWeekday::TH,
+    '5' => JWeekday::FR, 'fri' => JWeekday::FR, 'fr' => JWeekday::FR,
+    '6' => JWeekday::SA, 'sat' => JWeekday::SA, 'sa' => JWeekday::SA,
+    JWeekday::SU => 0,
+    JWeekday::MO => 1,
+    JWeekday::TU => 2,
+    JWeekday::WE => 3,
+    JWeekday::TH => 4,
+    JWeekday::FR => 5,
+    JWeekday::SA => 6,
+  }
+  
+end

data/lib/weekday_num.rb

@@ -0,0 +1,36 @@
+require 'java'
+require File.dirname(__FILE__) + '/rfc2445.jar'
+
+class WeekdayNum
+  include_class('com.google.ical.values.WeekdayNum'){|package,name| "J#{name}" }
+  
+  # Initializes a WeekdayNum objects.
+  # It accepts a Java WeekdayNum object (com.google.ical.values.WeekdayNum) or
+  # the number of the week and the day of the week
+  def initialize(*args)
+    if args.size == 1
+      @weekdaynum = args[0]
+    elsif args.size == 2
+      num = args[0]
+      wday = args[1]
+      @weekdaynum = JWeekdayNum.new(num, Weekday::MAP[wday.to_s.downcase])
+    end
+    self
+  end
+  
+  def to_ical
+    @weekdaynum.toIcal
+  end
+  
+  def to_s
+    @weekdaynum.toString
+  end
+  
+  def ==(weekdaynum)
+    @weekdaynum.equals(weekdaynum.to_java)
+  end
+  
+  def to_java
+    @weekdaynum
+  end
+end

data/spec/rfc2445_spec.rb

@@ -0,0 +1,501 @@
+require 'rubygems'
+require 'spec'
+require File.dirname(__FILE__) + '/../lib/rfc2445'
+
+describe JTime do
+  it "should able to initialize a new JTime with the current time" do
+    now = Time.now
+    time = JTime.new
+    time.should_not be_nil
+    time.to_java.getYear.should == now.year
+    time.to_java.getDayOfMonth.should == now.day
+    time.to_java.getMonthOfYear.should == now.month
+    time.to_java.getHourOfDay.should == now.hour
+    time.to_java.getMinuteOfHour.should == now.min
+    
+    time = JTime.now
+    time.should_not be_nil
+    time.to_java.getYear.should == now.year
+    time.to_java.getDayOfMonth.should == now.day
+    time.to_java.getMonthOfYear.should == now.month
+    time.to_java.getHourOfDay.should == now.hour
+    time.to_java.getMinuteOfHour.should == now.min
+  end
+  
+  it "should able to initialize a new JTime with epoch second" do
+    now = Time.now
+    time = JTime.at(now.to_i)
+    time.to_java.getYear.should == now.year
+    time.to_java.getDayOfMonth.should == now.day
+    time.to_java.getMonthOfYear.should == now.month
+    time.to_java.getHourOfDay.should == now.hour
+    time.to_java.getMinuteOfHour.should == now.min
+  end
+  
+  it "should able to initialize a new JTime with utc" do
+    time = JTime.utc(2000, "dec", 25, 20, 15, 1)
+    time.to_java.getYear.should == 2000
+    time.to_java.getMonthOfYear.should == 12
+    time.to_java.getDayOfMonth.should == 25
+    time.to_java.getHourOfDay.should == 20
+    time.to_java.getMinuteOfHour.should == 15
+  end
+  
+  it "should able to initialize a new JTime with local" do
+    time = JTime.local(2000, "dec", 25, 20, 15, 1)
+    time.to_java.getYear.should == 2000
+    time.to_java.getMonthOfYear.should == 12
+    time.to_java.getDayOfMonth.should == 25
+    time.to_java.getHourOfDay.should == 20
+    time.to_java.getMinuteOfHour.should == 15
+  end
+  
+  it "should able to initialize a new JTime with DateTimeValue" do
+    dtv = com.google.ical.values.DateTimeValueImpl.new(2000, 12, 25, 20, 15, 1)
+    time = JTime.from_date_time_value(dtv)
+    time.to_java.getYear.should == 2000
+    time.to_java.getMonthOfYear.should == 12
+    time.to_java.getDayOfMonth.should == 25
+    time.to_java.getHourOfDay.should == 20
+    time.to_java.getMinuteOfHour.should == 15
+  end
+  
+  it "should able to initialize a new JTime object from Ruby Time" do
+    now = Time.now
+    jtime = JTime.from_time(now)
+    jtime.should be_instance_of(JTime)
+    jtime.year.should == now.year
+    jtime.month.should == now.month
+    jtime.day.should == now.day
+    jtime.hour.should == now.hour
+    jtime.min.should == now.min
+  end
+  
+  it "should return a Ruby time object" do
+    now = Time.now
+    time = JTime.new
+    rtime = time.to_time
+    rtime.should be_instance_of(Time)
+    rtime.year.should == now.year
+    rtime.month.should == now.month
+    rtime.day.should == now.day
+    rtime.hour.should == now.hour
+    rtime.min.should == now.min
+  end
+  
+  it "should return a Java DateTime object" do
+    time = JTime.new
+    jtime = time.to_java
+    jtime.java_kind_of?(org.joda.time.DateTime).should == true
+  end
+  
+  it "should return a date time value object" do
+    time = JTime.new
+    dtv = time.to_date_time_value
+    dtv.java_kind_of?(com.google.ical.values.DateTimeValueImpl).should == true
+  end
+  
+  it "should able to return a UTC time" do
+    time = JTime.now
+    utc_time = time.utc
+    ruby_utc_time = time.to_time.utc
+    utc_time.to_java.getHourOfDay.should == ruby_utc_time.hour
+    utc_time.to_java.getMinuteOfHour.should == ruby_utc_time.min
+  end
+  
+  it "should return if dst" do
+    time1 = JTime.local(2008, "dec", 25, 20, 15, 1)
+    time2 = JTime.local(2008, "jul", 1, 20, 15, 1)    
+    time1.dst?.should == false
+    time2.isdst.should == true
+  end
+  
+  it "should able to compare with another JTime" do
+    time1 = JTime.new
+    time2 = JTime.local(2000, "dec", 25, 20, 15, 1)
+    (time1 > time2).should == true
+    (time1 < time2).should == false
+    (time1 == time1).should == true
+  end
+  
+  it "should return the year for time" do
+    time = JTime.local(2008, "dec", 25, 20, 15, 1)
+    time.year.should == 2008
+  end
+  
+  it "should return the month of the year" do
+    time = JTime.local(2008, "dec", 25, 20, 15, 1)
+    time.month.should == 12
+    time.mon.should == 12
+  end
+  
+  it "should return the day of the month" do
+    time = JTime.local(2008, "dec", 25, 20, 15, 1)
+    time.day.should == 25
+  end
+  
+  it "should return the hour of the day" do
+    time = JTime.local(2008, "dec", 25, 20, 15, 1)
+    time.hour.should == 20
+  end
+  
+  it "should return the minute of the hour" do
+    time = JTime.local(2008, "dec", 25, 20, 15, 1)
+    time.min.should == 15
+  end
+  
+  it "should return the second of the minute" do
+    time = JTime.local(2008, "dec", 25, 20, 15, 1)
+    time.day.should == 25
+  end
+  
+  it "should return the day of the week"do
+    time = JTime.local(2008, "dec", 25, 20, 15, 1)
+    time.wday.should == 4
+  end
+  
+  it "should return the day of the year"do
+    time = JTime.local(2008, "dec", 25, 20, 15, 1)
+    time.yday.should == 360
+  end
+  
+  it "should return the week number of the year"do
+    time = JTime.local(2008, "dec", 25, 20, 15, 1)
+    time.week.should == 52
+  end
+  
+  it "should return a value of time as a floating-point number of seconds since epoch" do
+    time = JTime.new
+    rtime = time.to_time
+    time.to_f.should == rtime.to_f
+  end
+  
+  it "should return a value of time as an integer number of seconds since epoch" do
+    time = JTime.new
+    rtime = time.to_time
+    time.to_i.should == rtime.to_i
+  end
+  
+  it "should return a string representing time" do
+    time = JTime.new
+    time.should respond_to(:to_s)    
+  end
+  
+  it "should return the name of the time zone" do
+    # Notice that it is different than the Ruby Time object, it returns the real ID 'America/Los_Angeles' instead of "PST"
+    time = JTime.new.utc
+    time.should respond_to(:zone)
+    time.zone.should == 'UTC'
+  end
+end
+
+describe RRule do
+  before(:each) do
+    @rrule = RRule.new
+  end
+  
+  it "should initialize a RRule object with ical string" do
+    ical_string = "RRULE:FREQ=MONTHLY;BYDAY=FR;BYMONTHDAY=13;COUNT=13"
+    rrule = RRule.new(ical_string)
+    rrule.should_not be_nil
+  end
+  
+  it "should return an ical string" do
+    ical_string = "RRULE:FREQ=MONTHLY;BYDAY=FR;BYMONTHDAY=13;COUNT=13"
+    rrule = RRule.new(ical_string)
+    (rrule.to_ical =~ /FREQ=MONTHLY/).should_not be_nil
+    (rrule.to_ical =~ /BYDAY=FR/).should_not be_nil
+    (rrule.to_ical =~ /BYMONTHDAY=13/).should_not be_nil
+    (rrule.to_ical =~ /COUNT=13/).should_not be_nil
+  end
+  
+  it "should return extra parameters" do
+    ical_string = "RRULE;X-FOO=BAR:FREQ=MONTHLY;BYDAY=FR;BYMONTHDAY=13;COUNT=13;"
+    rrule = RRule.new(ical_string)
+    ext_params = rrule.ext_params
+    ext_params['X-FOO'].should == 'BAR'
+  end
+  
+  it "should set and get the count" do
+    @rrule.count = 13
+    @rrule.count.should == 13
+  end
+  
+  it "should set and get the days" do
+    wday = WeekdayNum.new(5, 'Fri')
+    @rrule.days = [wday]
+    (@rrule.days.first == wday).should == true
+  end
+  
+  it "should set and get the hours" do
+    @rrule.hours = [1, 13]
+    @rrule.hours.include?(1).should == true
+    @rrule.hours.include?(13).should == true
+  end
+  
+  it "should set and get the minutes" do
+    @rrule.minutes = [1, 13]
+    @rrule.minutes.include?(1).should == true
+    @rrule.minutes.include?(13).should == true
+  end
+  
+  it "should set and get the monthdays" do
+    @rrule.mdays = [1, 13]
+    @rrule.mdays.include?(1).should == true
+    @rrule.mdays.include?(13).should == true
+  end
+  
+  it "should set and get the seconds" do
+    @rrule.seconds = [1, 13]
+    @rrule.seconds.include?(1).should == true
+    @rrule.seconds.include?(13).should == true
+  end
+  
+  it "should set and get the week numbers" do
+    @rrule.weeknums = [1, 13]
+    @rrule.weeknums.include?(1).should == true
+    @rrule.weeknums.include?(13).should == true
+  end
+  
+  it "should set and get the year days" do
+    @rrule.ydays = [1, 360]
+    @rrule.ydays.include?(1).should == true
+    @rrule.ydays.include?(360).should == true
+  end
+  
+  it "should set and get the frequency" do
+    @rrule.frequency = Frequency::MONTHLY
+    @rrule.frequency.should == Frequency::MONTHLY
+  end
+  
+  it "should set and get the starting weekday" do
+    @rrule.wdaystart = 'Fri'
+    @rrule.wdaystart.should == 5
+    @rrule.wdaystart = 3
+    @rrule.wdaystart.should == 3
+  end 
+  
+  it "should set and get the interval" do
+    @rrule.interval = 10
+    @rrule.interval.should == 10
+  end
+  
+  it "should set and get the object name, such as RRULE, EXRULE, VEVENT" do
+    @rrule.name = RRule::EXRULE
+    @rrule.name.should == RRule::EXRULE
+  end
+  
+  it "should set and get the until date" do
+    now = JTime.new
+    @rrule.until = now
+    @rrule.until.year.should == now.year
+    @rrule.until.month.should == now.month
+    @rrule.until.day.should == now.day
+    @rrule.until.hour.should == now.hour
+    @rrule.until.min.should == now.min
+    @rrule.until.sec.should == now.sec
+  end
+end
+
+describe RDateList do
+  before(:each) do
+    @rdatelist = RDateList.new
+  end
+  
+  it "should initialize a RDateList object with no params" do
+    @rdatelist.should_not be_nil
+  end
+  
+  it "should initialize a RDatelist object with a timezone" do
+    rdatelist = RDateList.new('UTC')
+    @rdatelist.should_not be_nil
+  end
+  
+  it "should initialize a RDateList object with ical string" do
+    ical_string = "RDATE:19960402T010000,19960403T010000,19960404T010000"
+    rdatelist = RDateList.new(nil, ical_string)
+    rdatelist.should_not be_nil
+  end
+  
+  it "should return an ical string" do
+    ical_string = "RDATE:19960402T010000,19960403T010000,19960404T010000"
+    rdatelist = RDateList.new(nil, ical_string)
+    (rdatelist.to_ical =~ /TZID=/).should_not be_nil
+    (rdatelist.to_ical =~ /VALUE=DATE-TIME:/).should_not be_nil
+    (rdatelist.to_ical =~ /19960402/).should_not be_nil
+    (rdatelist.to_ical =~ /19960403/).should_not be_nil
+    (rdatelist.to_ical =~ /19960404/).should_not be_nil
+  end
+  
+  it "should return extra parameters" do
+    ical_string = "RDATE;X-FOO=BAR:19960402T010000,19960403T010000,19960404T010000"
+    rdatelist = RDateList.new(nil, ical_string)
+    ext_params = rdatelist.ext_params
+    ext_params['X-FOO'].should == 'BAR'
+  end
+  
+  it "should set and get the object name, such as RRULE, EXRULE, VEVENT" do
+    @rdatelist.name = RRule::EXRULE
+    @rdatelist.name.should == RRule::EXRULE
+  end
+  
+  it "should set and get timezone" do
+    @rdatelist.zone = 'UTC'
+    @rdatelist.zone.should == 'UTC'
+  end
+  
+  it "should set array of utc dates and get array of utc dates" do
+    utc_date = JTime.utc(2008, 12, 25)
+    @rdatelist.utc_dates = [utc_date]
+    @rdatelist.utc_dates.first.year.should == 2008
+    @rdatelist.utc_dates.first.month.should == 12
+    @rdatelist.utc_dates.first.day.should == 25    
+  end
+end
+
+describe ICalParseUtil do
+  it "should parse an ical string and timezone to a date time value" do
+    dtv = ICalParseUtil.parse_date_value('20090327T180000', 'America/Los_Angeles')
+    dtv.java_kind_of?(com.google.ical.values.DateTimeValueImpl).should == true
+    dtv.hour.should == 1
+    dtv.day.should == 28
+  end
+  
+  it "should return nil if passing nil to parse_date_value" do
+    dtv = ICalParseUtil.parse_date_value(nil)
+    dtv.should be_nil
+  end
+  
+  it "should parse an ical string and timezone to a JTime object" do
+    jtime = ICalParseUtil.parse_jtime('20090327T180000', 'America/Los_Angeles')
+    jtime.should be_instance_of(JTime)
+    jtime.hour.should == 1
+    jtime.day.should == 28
+  end
+  
+  it "should return nil if passing nil to parse_jtime" do
+    jtime = ICalParseUtil.parse_jtime(nil)
+    jtime.should be_nil
+  end
+  
+  it "should parse a recurrence block" do
+    string = <<-end_src
+    DTSTART;TZID=America/Los_Angeles:20090320T170000
+    DTEND;TZID=America/Los_Angeles:20090320T180000
+    RRULE:FREQ=WEEKLY;BYDAY=FR;WKST=SU
+    EXRULE:FREQ=MONTHLY;BYDAY=1FR
+    RDATE;TZID=America/Los_Angeles:20090321T170000
+    BEGIN:VTIMEZONE
+    TZID:America/Los_Angeles
+    X-LIC-LOCATION:America/Los_Angeles
+    BEGIN:DAYLIGHT
+    TZOFFSETFROM:-0800
+    TZOFFSETTO:-0700
+    TZNAME:PDT
+    DTSTART:19700308T020000
+    RRULE:FREQ=YEARLY;BYMONTH=3;BYDAY=2SU
+    END:DAYLIGHT
+    BEGIN:STANDARD
+    TZOFFSETFROM:-0700
+    TZOFFSETTO:-0800
+    TZNAME:PST
+    DTSTART:19701101T020000
+    RRULE:FREQ=YEARLY;BYMONTH=11;BYDAY=1SU
+    END:STANDARD
+    END:VTIMEZONE
+    end_src
+    
+    r = ICalParseUtil.parse_recurrence(string)
+    r[:dtstart].should == "DTSTART;TZID=America/Los_Angeles:20090320T170000"
+    r[:dtend].should == "DTEND;TZID=America/Los_Angeles:20090320T180000"
+    r[:rrule].should == "RRULE:FREQ=WEEKLY;BYDAY=FR;WKST=SU"
+    r[:exrule].should == "EXRULE:FREQ=MONTHLY;BYDAY=1FR"
+    r[:rdate].should == "RDATE;TZID=America/Los_Angeles:20090321T170000"
+    r[:exdate].should == nil
+  end
+  
+  it "should parse datetime into JTime" do
+    jtime1 = ICalParseUtil.parse_datetime('DTSTART;TZID=America/Los_Angeles:20090320T170000')
+    jtime1.should be_instance_of(JTime)
+    jtime1.hour.should == 0
+    
+    jtime2 = ICalParseUtil.parse_datetime('DTEND;TZID=America/Los_Angeles:20090320T170000')
+    jtime2.should be_instance_of(JTime)
+    jtime2.hour.should == 0
+    
+    jtime3 = ICalParseUtil.parse_datetime(nil)
+    jtime3.should be_nil
+  end
+end
+
+describe RecurrenceTime do
+  before(:each) do
+    @ical_string = "RRULE:FREQ=MONTHLY;BYDAY=FR;BYMONTHDAY=13;COUNT=13"
+    @start_date = JTime.local(2001, 4, 13)
+    @rtime = RecurrenceTime.new(@ical_string, @start_date)
+  end
+  
+  it "should be initialized by RRule object" do
+    rrule = RRule.new(@ical_string)
+    rtime = RecurrenceTime.new(rrule, @start_date)
+    rtime.should be_instance_of(RecurrenceTime)
+  end
+  
+  it "should be initialized by an array of RRules" do
+    rrule1 = RRule.new(@ical_string)
+    # The first date is excluded
+    rrule2 = RRule.new("EXRULE:FREQ=MONTHLY;BYDAY=FR;BYMONTHDAY=13;COUNT=1")
+    rtime = RecurrenceTime.new([rrule1, rrule2], @start_date)
+    rtime.should be_instance_of(RecurrenceTime)
+    rtime.next.should > @start_date
+  end
+  
+  it "should initialized by an array of RRules and RDateLists" do
+    rrule = RRule.new(@ical_string)
+    rdatelist = RDateList.new
+    rdatelist.utc_dates = [JTime.utc(2001, 4, 14)]
+    rtime = RecurrenceTime.new([rdatelist, rrule], @start_date)
+    rtime.should be_instance_of(RecurrenceTime)
+    rtime.next
+    first_next = rtime.next
+    first_next.mon.should == 4
+    first_next.day.should == 14
+    first_next.year.should == 2001
+  end
+  
+  it "should able to generate a JTime by invoking next" do
+    nexttime = @rtime.next
+    nexttime.should be_instance_of(JTime)
+    (nexttime <=> @start_date).should == 0
+  end
+  
+  it "should able to advance to a specific date" do
+    # It skips 2 dates 4/13 and 7/13
+    @rtime.advance_to(JTime.utc(2001, 7, 15))
+    third_next = @rtime.next
+    third_next.mon.should == 9
+    third_next.day.should == 13
+    third_next.year.should == 2002
+  end
+  
+  it "should return true if there is more time for the recurrence time" do
+    13.times do
+      @rtime.has_next?.should == true
+      @rtime.next
+    end
+    @rtime.has_next?.should == false
+  end
+  
+  it "should return the java iterator" do
+    @rtime.to_java.java_kind_of?(com.google.ical.compat.jodatime.DateTimeIterator).should == true
+  end
+  
+  it "should able to iterate" do
+    i = 0
+    @rtime.each do |t|
+      i += 1
+      t.should be_instance_of(JTime)
+    end
+    i.should == 13
+  end
+end

metadata

@@ -0,0 +1,66 @@
+--- !ruby/object:Gem::Specification 
+name: jruby-rfc2445
+version: !ruby/object:Gem::Version 
+  version: 0.0.4
+platform: ruby
+authors: 
+  - Jerry Luk
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-03-24 00:00:00 -07:00
+default_executable: 
+dependencies: []
+
+description: A JRuby implementation of RFC 2445 (ical) recurrence rule
+email: jerryluk@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+  - README
+  - MIT-LICENSE
+  - lib/ical_parse_util.rb
+  - lib/jtime.rb
+  - lib/rdate_list.rb
+  - lib/recurrence_time.rb
+  - lib/rfc2445.rb
+  - lib/rfc2445.jar
+  - lib/rrule.rb
+  - lib/weekday.rb
+  - lib/weekday_num.rb
+  - spec/rfc2445_spec.rb
+has_rdoc: true
+homepage: http://www.linkedin.com/in/jerryluk
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+  - lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: A JRuby implementation of RFC 2445 (ical) recurrence rule
+test_files: 
+  - spec/rfc2445_spec.rb