fnando-recurrence 0.0.7 → 0.1.0

data/History.txt

@@ -38,4 +38,18 @@
 == 0.0.7 2009-01-06
 
 * 1 major enhancement:
-	* The events method now accepts :starts and :until dates
+	* The events method now accepts :starts and :until dates
+
+== 0.0.8 2009-01-07
+
+* 1 small enhancement:
+	* The iteration is stopped when the :until is reached when limiting events
+
+== 0.1.0 2009-07-18
+
+* 3 major enhancements:
+  * Allow monthly recurrences to occur by weekday:
+    Recurrence.new(:every => :month, :on => :first, :weekday => :thursday)
+  * Allow several weekdays to be given to weekly recurrence:
+    Recurrence.new(:every => :week, :on => [:monday, :wednesday, :friday])
+  * Added :daily, :weekly, :monthly and :yearly shortcuts to Recurrence.

data/README.markdown

@@ -38,18 +38,26 @@ USAGE:
 	r = Recurrence.new(:every => :day, :interval => 9)
 	
 	# Weekly
-	r = Recurrence.new(:every => :week, :on => :friday)
 	r = Recurrence.new(:every => :week, :on => 5)
+	r = Recurrence.new(:every => :week, :on => :monday)
+	r = Recurrence.new(:every => :week, :on => [:monday, :friday])
+	r = Recurrence.new(:every => :week, :on => [:monday, :wednesday, :friday])
 	r = Recurrence.new(:every => :week, :on => :friday, :interval => 2)
 	
-	# Monthly
+	# Monthly by month day
 	r = Recurrence.new(:every => :month, :on => 15)
 	r = Recurrence.new(:every => :month, :on => 31)
 	r = Recurrence.new(:every => :month, :on => 7, :interval => 2)
 	r = Recurrence.new(:every => :month, :on => 7, :interval => :monthly)
 	r = Recurrence.new(:every => :month, :on => 7, :interval => :bimonthly)
-	r = Recurrence.new(:every => :month, :on => 7, :interval => :quarterly)
-	r = Recurrence.new(:every => :month, :on => 7, :interval => :semesterly)
+	
+	# Monthly by week day
+	r = Recurrence.new(:every => :month, :on => :first, :weekday => :sunday)
+	r = Recurrence.new(:every => :month, :on => :third, :weekday => :monday)
+	r = Recurrence.new(:every => :month, :on => :last,  :weekday => :friday)
+	r = Recurrence.new(:every => :month, :on => :last,  :weekday => :friday, :interval => 2)
+	r = Recurrence.new(:every => :month, :on => :last,  :weekday => :friday, :interval => :quarterly)
+	r = Recurrence.new(:every => :month, :on => :last,  :weekday => :friday, :interval => :semesterly)
 	
 	# Yearly
 	r = Recurrence.new(:every => :year, :on => [7, 4]) # => [month, day]
@@ -86,7 +94,12 @@ USAGE:
 MAINTAINER
 ----------
  
-* Nando Vieira ([http://simplesideias.com.br](http://simplesideias.com.br))
+* Nando Vieira (<http://simplesideias.com.br/>)
+
+CONTRIBUTORS
+------------
+ 
+* José Valim (<http://josevalim.blogspot.com/>)
 
 LICENSE:
 --------
@@ -110,4 +123,4 @@ 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.
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Rakefile

@@ -5,7 +5,7 @@ PKG_FILES = %w(init.rb Rakefile recurrence.gemspec History.txt License.txt READM
 
 spec = Gem::Specification.new do |s|
   s.name = "recurrence"
-  s.version = "0.0.7"
+  s.version = "0.1.0"
   s.summary = "A simple library to handle recurring events"
   s.authors = ["Nando Vieira"]
   s.email = ["fnando.vieira@gmail.com"]
@@ -14,7 +14,6 @@ spec = Gem::Specification.new do |s|
   s.has_rdoc = false
   s.files = PKG_FILES
 	
-  s.add_dependency "rubigen"
   s.add_dependency "activesupport", ">=2.1.1"
 end
 
@@ -74,4 +73,4 @@ end
 desc "Execute specs"
 task :spec do
   system "spec spec/recurrence_spec.rb -c -f s"
-end
+end

data/lib/recurrence.rb

@@ -1,6 +1,17 @@
-require "rubygems"
-require "date"
-gem "activesupport", ">=2.1.1"
-require "activesupport"
-require File.dirname(__FILE__) + "/recurrence/base"
-require File.dirname(__FILE__) + "/recurrence/event"
+require 'rubygems'
+require 'date'
+require 'activesupport'
+
+dirname = File.dirname(__FILE__)
+require dirname + '/recurrence/base'
+require dirname + '/recurrence/shortcuts'
+require dirname + '/recurrence/event'
+require dirname + '/recurrence/event/daily'
+require dirname + '/recurrence/event/weekly'
+require dirname + '/recurrence/event/monthly'
+require dirname + '/recurrence/event/yearly'
+
+class Recurrence
+  include Base
+  extend Shortcuts
+end

data/lib/recurrence/base.rb

@@ -1,145 +1,127 @@
 class Recurrence
-  FREQUENCY = %w(day week month year)
-  DAYS = %w(sunday monday tuesday wednesday thursday friday saturday)
-  MONTHS = {
-    "jan" => 1, "january" => 1,
-    "feb" => 2, "february" => 2,
-    "mar" => 3, "march" => 3,
-    "apr" => 4, "april" => 4,
-    "may" => 5,
-    "jun" => 6, "june" => 6,
-    "jul" => 7, "july" => 7,
-    "aug" => 8, "august" => 8,
-    "sep" => 9, "september" => 9,
-    "oct" => 10, "october" => 10,
-    "nov" => 11, "november" => 11,
-    "dec" => 12, "december" => 12
-  }
-  
-  INTERVALS = {
-    :monthly => 1,
-    :bimonthly => 2,
-    :quarterly => 3,
-    :semesterly => 6
-  }
-  
-  attr_reader :event
-  
-  def initialize(options)
-    raise ArgumentError, ':every option is required' unless options.key?(:every)
-    raise ArgumentError, 'invalid :every option' unless FREQUENCY.include?(options[:every].to_s)
-    
-    if options.key?(:interval)
-      if options[:every].to_sym == :month && options[:interval].is_a?(Symbol) && !INTERVALS.key?(options[:interval])
-        raise ArgumentError, 'interval symbol is not valid'
-      elsif options[:interval].to_i == 0
-        raise ArgumentError, 'interval should be greater than zero'
+  module Base
+    FREQUENCY = %w(day week month year)
+
+    attr_reader :event
+
+    def self.included(base) #:nodoc:
+      base.extend ClassMethods
+    end
+
+    # Holds default_until_date configuration.
+    #
+    module ClassMethods #:nodoc:
+      def default_until_date
+        @default_until_date ||= Date.new(2037, 12, 31)
+      end
+
+      def default_until_date=(date)
+        @default_until_date = if date.is_a?(String)
+          Date.parse(date)
+        else
+          date
+        end
       end
     end
-    
-    @options = initialize_dates(options)
-    @options[:interval] ||= 1
-    
-    case @options[:every].to_sym
-      when :day then
-        @event = Recurrence::Event.new(:day, @options)
-      when :week then
-        raise ArgumentError, 'invalid day' if !DAYS.include?(@options[:on].to_s) && !(0..6).include?(@options[:on])
-        @options.merge!(:on => DAYS.index(@options[:on].to_s)) if DAYS.include?(@options[:on].to_s)
-        @event = Recurrence::Event.new(:week, @options)
-      when :month then
-        raise ArgumentError, 'invalid day' unless (1..31).include?(@options[:on])
-        options.merge!(:interval => INTERVALS[options[:interval]]) if options[:interval].is_a?(Symbol)
-        @event = Recurrence::Event.new(:month, @options)
-      when :year then
-        raise ArgumentError, 'invalid month' if !(1..12).include?(@options[:on].first) && !MONTHS.keys.include?(@options[:on].first)
-        raise ArgumentError, 'invalid day' unless (1..31).include?(@options[:on].last)
-        @options.merge!(:on => [MONTHS[@options[:on].first.to_s], @options.last]) unless @options[:on].first.kind_of?(Numeric)
-        @event = Recurrence::Event.new(:year, @options)
+
+    def initialize(options)
+      raise ArgumentError, ':every option is required' unless options.key?(:every)
+      raise ArgumentError, 'invalid :every option'     unless FREQUENCY.include?(options[:every].to_s)
+
+      @options = initialize_dates(options)
+      @options[:interval] ||= 1
+
+      @event = case @options[:every].to_sym
+        when :day
+          Recurrence::Event::Daily.new(@options)
+        when :week
+          Recurrence::Event::Weekly.new(@options)
+        when :month
+          Recurrence::Event::Monthly.new(@options)
+        when :year
+          Recurrence::Event::Yearly.new(@options)
+      end
     end
-  end
-  
-  def reset!
-    @event.reset!
-    @events = nil
-  end
-  
-  def include?(required_date)
-    required_date = Date.parse(required_date) if required_date.is_a?(String)
-    
-    if required_date < @options[:starts] || required_date > @options[:until]
-      false
-    else
-      each do |date|
-        return true if date == required_date
+
+    def reset!
+      @event.reset!
+      @events = nil
+    end
+
+    def include?(required_date)
+      required_date = Date.parse(required_date) if required_date.is_a?(String)
+
+      if required_date < @options[:starts] || required_date > @options[:until]
+        false
+      else
+        each do |date|
+          return true if date == required_date
+        end
       end
+
+      return false
     end
-    
-    return false
-  end
-  
-  def next
-    @event.next
-  end
-  
-  def next!
-    @event.next!
-  end
-  
-  def events(options={})
-    options[:starts] = Date.parse(options[:starts]) if options[:starts].is_a?(String)
-    options[:until] = Date.parse(options[:until]) if options[:until].is_a?(String)
-    
-    reset! if options[:starts] || options[:until]
-    
-    @events ||= begin
-      _events = []
-      
-      loop do
-        date = @event.next!
-
-        break if date.nil?
-
-        if options[:starts] && options[:until] && date >= options[:starts] && date <= options[:until]
-          _events << date
-        elsif options[:starts] && options[:until].nil? && date >= options[:starts]
-          _events << date
-        elsif options[:until] && options[:starts].nil? && date <= options[:until]
-          _events << date
-        elsif options[:starts].nil? && options[:until].nil?
-          _events << date
+
+    def next
+      @event.next
+    end
+
+    def next!
+      @event.next!
+    end
+
+    def events(options={})
+      options[:starts] = Date.parse(options[:starts]) if options[:starts].is_a?(String)
+      options[:until]  = Date.parse(options[:until])  if options[:until].is_a?(String)
+
+      reset! if options[:starts] || options[:until]
+
+      @events ||= begin
+        _events = []
+
+        loop do
+          date = @event.next!
+
+          break if date.nil?
+
+          valid_start = options[:starts].nil? || date >= options[:starts]
+          valid_until = options[:until].nil?  || date <= options[:until]
+          _events << date if valid_start && valid_until
+
+          break if options[:until] && options[:until] <= date
         end
+
+        _events
       end
-      
-      _events
     end
-  end
-  
-  def events!(options={})
-    reset!
-    events(options)
-  end
-  
-  def each!(&block)
-    reset!
-    each(&block)
-  end
-  
-  def each(&block)
-    events.each do |item|
-      yield item
+
+    def events!(options={})
+      reset!
+      events(options)
     end
-  end
-  
-  private
-    def initialize_dates(options)
-      [:starts, :until].each do |name|
-        options[name] = Date.parse(options[name]) if options[name].is_a?(String)
+
+    def each!(&block)
+      reset!
+      each(&block)
+    end
+
+    def each(&block)
+      events.each do |item|
+        yield item
       end
-      
-      options[:starts] ||= Date.today
-      options[:until] ||= Date.parse('2037-12-31')
-      
-      options
     end
-end
+
+    private
+
+      def initialize_dates(options) #:nodoc:
+        [:starts, :until].each do |name|
+          options[name] = Date.parse(options[name]) if options[name].is_a?(String)
+        end
+
+        options[:starts] ||= Date.today
+        options[:until]  ||= self.class.default_until_date
+
+        options
+      end
+  end
+end

data/lib/recurrence/event.rb

@@ -1,130 +1,78 @@
 class Recurrence::Event
-  attr_accessor :date, :start_date, :options, :every
-  
-  def initialize(every, options={})
-    @every   = every
-    @options = options
-    @current = nil
-    @date    = options[:starts]
+  CARDINALS = %w(first second third fourth fifth)
+  DAYS = %w(sunday monday tuesday wednesday thursday friday saturday)
+
+  attr_accessor :start_date
+
+  def initialize(options={})
+    every, options = nil, every if every.is_a?(Hash)
+
+    @options    = options
+    @date       = options[:starts]
+    @finished   = false
+
+    validate
+    raise ArgumentError, 'interval should be greater than zero' if @options[:interval] <= 0
+
     prepare!
   end
-  
-  def prepare!
-    self.next!
-    @start_date = @date
-  end
-  
-  def next?
-    !!@next
-  end
-  
+
   def next!
-    # just continue if date object is null or 
-    # hasn't been initialized yet
-    return nil unless @date || !inited?
-    
-    # return the date if is the first interaction after
-    # initializing object
-    if inited? && !next?
-      @next = true
-      return @date
-    end
-    
-    case @every
-      when :day
-        @date = next_day
-      when :week
-        @date = next_week
-      when :month
-        @date = next_month
-      when :year
-        @date = next_year
-    end
-    
-    # if limit date has been reached just set the date 
-    # object to nil
-    @date = nil unless @date.to_date <= @options[:until].to_date
-    
+    return nil if finished?
+    return @date = @start_date if @start_date && @date.nil?
+
+    @date = next_in_recurrence
+
+    @finished, @date = true, nil if @date > @options[:until]
     @date
   end
-  
+
   def next
-    @date
+    return nil if finished?
+    @date || @start_date
   end
-  
+
   def reset!
-    @date = @start_date
+    @date = nil
   end
-  
+
+  def finished?
+    @finished
+  end
+
   private
-    def inited?
+
+    def initialized?
       !!@start_date
     end
-  
-    def next_day
-      date = @date
-      date = date + @options[:interval].days if inited? || @options[:interval] > 1
-      
-      date.to_date
-    end
-    
-    def next_week
-      date = @date
-      
-      if inited?
-        date = date + @options[:interval].weeks
-      elsif date.wday != @options[:on]
-        date = date.next until @options[:on] == date.wday && date > @options[:starts]
-        date = date + (@options[:interval] - 1).weeks
-      end
-      
-      date.to_date
+
+    def prepare!
+      @start_date = next!
+      @date       = nil
     end
-    
-    def next_month
-      date = @date
-      
-      if inited?
-        date = advance_to_month(date)
-      else
-        day = [options[:on], Time.days_in_month(date.month, date.year)].min
-        date = Date.new(date.year, date.month, day)
-        date = advance_to_month(date) if @date.day > day
-      end
 
-      date.to_date
+    def validate
+      # Inject custom validations
     end
-    
-    def advance_to_month(date)
-      date = date.beginning_of_month + @options[:interval].months
-      day = [options[:on], Time.days_in_month(date.month, date.year)].min
-      
-      if date.day != day && date.day < day
-        date = date.to_date.next until date.day == day
-      end
-      
-      date
+
+    # Common validation for inherited classes.
+    #
+    def valid_month_day?(day) #:nodoc:
+      raise ArgumentError, "invalid day #{day}" unless (1..31).include?(day)
     end
-    
-    def next_year
-      date = @date
-      
-      if inited?
-        date = advance_to_year(date)
+
+    # Check if the given key has a valid weekday (0 upto 6) or a valid weekday
+    # name (defined in the DAYS constant). If a weekday name (String) is given,
+    # convert it to a weekday (Integer).
+    #
+    def valid_weekday_or_weekday_name?(value)
+      if value.kind_of?(Numeric)
+        raise ArgumentError, "invalid day #{value}" unless (0..6).include?(value)
+        value
       else
-        day = [options[:on].last, Time.days_in_month(options[:on].first, date.year)].min
-        date = Date.new(date.year, options[:on].first, day)
-        date = advance_to_year(date) if @date.month > date.month || @options[:on].last < @date.day
+        raise ArgumentError, "invalid weekday #{value}" unless DAYS.include?(value.to_s)
+        DAYS.index(value.to_s)
       end
-      
-      date.to_date
-    end
-    
-    def advance_to_year(date)
-      date = date.beginning_of_month + @options[:interval].years
-      day = [Time.days_in_month(@options[:on].first, date.year), @options[:on].last].min
-      year = date.year
-    
-      date = Date.new(year, @options[:on].first, day)
     end
+
 end

data/lib/recurrence/event/daily.rb

@@ -0,0 +1,10 @@
+class Recurrence::Event::Daily < Recurrence::Event
+
+  protected
+    def next_in_recurrence
+      date  = @date.to_date
+      date += @options[:interval] if initialized?
+      date
+    end
+
+end

data/lib/recurrence/event/monthly.rb

@@ -0,0 +1,102 @@
+class Recurrence::Event::Monthly < Recurrence::Event
+  INTERVALS = {
+    :monthly => 1,
+    :bimonthly => 2,
+    :quarterly => 3,
+    :semesterly => 6
+  }
+
+  protected
+
+    def validate
+      if @options.key?(:weekday)
+
+        # Allow :on => :last, :weekday => :thursday contruction.
+        if @options[:on].to_s == 'last'
+          @options[:on] = 5 
+        elsif @options[:on].kind_of?(Numeric)
+          valid_week?(@options[:on])
+        else
+          valid_cardinal?(@options[:on])
+          @options[:on] = CARDINALS.index(@options[:on].to_s) + 1
+        end
+
+        @options[:weekday] = valid_weekday_or_weekday_name?(@options[:weekday])
+      else
+        valid_month_day?(@options[:on])
+      end
+
+      if @options[:interval].is_a?(Symbol)
+        valid_interval?(@options[:interval])
+        @options[:interval] = INTERVALS[@options[:interval]]
+      end
+    end
+
+    def next_in_recurrence
+      return next_month if self.respond_to?(:next_month)
+      type = @options.key?(:weekday) ? :weekday : :monthday
+
+      class_eval <<-METHOD
+        def next_month
+          if initialized?
+            advance_to_month_by_#{type}(@date)
+          else
+            new_date = advance_to_month_by_#{type}(@date, 0)
+            new_date = advance_to_month_by_#{type}(new_date) if @date > new_date
+            new_date
+          end
+        end
+      METHOD
+
+      next_month
+    end
+
+    def advance_to_month_by_monthday(date, interval=@options[:interval])
+      # Have a raw month from 0 to 11 interval
+      raw_month  = date.month + interval - 1
+
+      next_year  = date.year + raw_month / 12
+      next_month = (raw_month % 12) + 1 # change back to ruby interval
+      next_day   = [ @options[:on], Time.days_in_month(next_month, next_year) ].min
+
+      Date.new(next_year, next_month, next_day)
+    end
+
+    def advance_to_month_by_weekday(date, interval=@options[:interval])
+      raw_month  = date.month + interval - 1
+      next_year  = date.year + raw_month / 12
+      next_month = (raw_month % 12) + 1 # change back to ruby interval
+      date       = Date.new(next_year, next_month, 1)
+
+      weekday, month = @options[:weekday], date.month
+
+      # Adjust week day
+      to_add  = weekday - date.wday
+      to_add += 7 if to_add < 0
+      to_add += (@options[:on] - 1) * 7
+      date   += to_add
+
+      # Go to the previous month if we lost it
+      if date.month != month
+        weeks = (date.day - 1) / 7 + 1
+        date -= weeks * 7
+      end
+
+      date
+    end
+
+  private
+
+    def valid_cardinal?(cardinal) #:nodoc:
+      raise ArgumentError, "invalid cardinal #{cardinal}" unless CARDINALS.include?(cardinal.to_s)
+    end
+
+    def valid_interval?(interval) #:nodoc:
+      raise ArgumentError, "invalid cardinal #{interval}" unless INTERVALS.key?(interval)
+    end
+
+    def valid_week?(week) #:nodoc:
+      raise ArgumentError, "invalid week #{week}" unless (1..5).include?(week)
+    end
+
+end

data/lib/recurrence/event/weekly.rb

@@ -0,0 +1,27 @@
+class Recurrence::Event::Weekly < Recurrence::Event
+
+  protected
+
+    def validate
+      @options[:on] = Array.wrap(@options[:on]).inject([]) do |days, value|
+        days << valid_weekday_or_weekday_name?(value)
+      end
+
+      @options[:on].sort!
+    end
+
+    def next_in_recurrence
+      return @date if !initialized? && @options[:on].include?(@date.wday)
+
+      if next_day = @options[:on].find { |day| day > @date.wday }
+        to_add = next_day - @date.wday
+      else 
+        to_add = (7 - @date.wday)                # Move to next week
+        to_add += (@options[:interval] - 1) * 7  # Add extra intervals
+        to_add += @options[:on].first            # Go to first required day
+      end
+
+      @date.to_date + to_add
+    end
+
+end

data/lib/recurrence/event/yearly.rb

@@ -0,0 +1,58 @@
+class Recurrence::Event::Yearly < Recurrence::Event
+  MONTHS = {
+    "jan" => 1, "january" => 1,
+    "feb" => 2, "february" => 2,
+    "mar" => 3, "march" => 3,
+    "apr" => 4, "april" => 4,
+    "may" => 5,
+    "jun" => 6, "june" => 6,
+    "jul" => 7, "july" => 7,
+    "aug" => 8, "august" => 8,
+    "sep" => 9, "september" => 9,
+    "oct" => 10, "october" => 10,
+    "nov" => 11, "november" => 11,
+    "dec" => 12, "december" => 12
+  }
+
+  protected
+
+    def validate
+      valid_month_day?(@options[:on].last)
+
+      if @options[:on].first.kind_of?(Numeric)
+        valid_month?(@options[:on].first)
+      else
+        valid_month_name?(@options[:on].first)
+        @options[:on] = [ MONTHS[@options[:on].first.to_s], @options.last ]
+      end
+    end
+
+    def next_in_recurrence
+      if initialized?
+        advance_to_year(@date)
+      else
+        new_date = advance_to_year(@date, 0)
+        new_date = advance_to_year(new_date) if @date > new_date
+        new_date
+      end
+    end
+
+    def advance_to_year(date, interval=@options[:interval])
+      next_year  = date.year + interval
+      next_month = @options[:on].first
+      next_day   = [ @options[:on].last, Time.days_in_month(next_month, next_year) ].min
+
+      Date.new(next_year, next_month, next_day)
+    end
+
+  private
+
+    def valid_month?(month) #:nodoc:
+      raise ArgumentError, "invalid month #{month}" unless (1..12).include?(month)
+    end
+
+    def valid_month_name?(month) #:nodoc:
+      raise ArgumentError, "invalid month #{month}" unless MONTHS.keys.include?(month.to_s)
+    end
+
+end

data/lib/recurrence/shortcuts.rb

@@ -0,0 +1,23 @@
+class Recurrence
+  module Shortcuts
+    def daily(options={})
+      options[:every] = :day
+      new(options)
+    end
+
+    def weekly(options)
+      options[:every] = :week
+      new(options)
+    end
+
+    def monthly(options)
+      options[:every] = :month
+      new(options)
+    end
+
+    def yearly(options)
+      options[:every] = :year
+      new(options)
+    end
+  end
+end

data/recurrence.gemspec

@@ -2,26 +2,31 @@
 # RUN : 'rake gem:update_gemspec'
 
 Gem::Specification.new do |s|
-  s.authors = ["Nando Vieira"]
+  s.add_dependency "activesupport", ">= 2.1.1"
   s.require_paths = ["lib"]
-  s.required_rubygems_version = ">= 0"
-  s.has_rdoc = false
   s.files = ["init.rb",
  "Rakefile",
  "recurrence.gemspec",
  "History.txt",
  "License.txt",
  "README.markdown",
+ "lib/recurrence.rb",
  "lib/recurrence",
  "lib/recurrence/base.rb",
  "lib/recurrence/event.rb",
- "lib/recurrence.rb"]
+ "lib/recurrence/shortcuts.rb",
+ "lib/recurrence/event",
+ "lib/recurrence/event/monthly.rb",
+ "lib/recurrence/event/daily.rb",
+ "lib/recurrence/event/weekly.rb",
+ "lib/recurrence/event/yearly.rb"]
+  s.authors = ["Nando Vieira"]
+  s.name = "recurrence"
+  s.required_rubygems_version = ">= 0"
+  s.has_rdoc = false
   s.email = ["fnando.vieira@gmail.com"]
-  s.version = "0.0.7"
   s.homepage = "http://github.com/fnando/recurrence"
-  s.name = "recurrence"
-  s.summary = "A simple library to handle recurring events"
-  s.add_dependency "rubigen", ">= 0"
-  s.add_dependency "activesupport", ">= 2.1.1"
   s.bindir = "bin"
+  s.version = "0.1.0"
+  s.summary = "A simple library to handle recurring events"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: fnando-recurrence
 version: !ruby/object:Gem::Version 
-  version: 0.0.7
+  version: 0.1.0
 platform: ruby
 authors: 
 - Nando Vieira
@@ -9,20 +9,12 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2008-12-22 00:00:00 -08:00
+date: 2009-05-16 00:00:00 -07:00
 default_executable: 
 dependencies: 
-- !ruby/object:Gem::Dependency 
-  name: rubigen
-  version_requirement: 
-  version_requirements: !ruby/object:Gem::Requirement 
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        version: "0"
-    version: 
 - !ruby/object:Gem::Dependency 
   name: activesupport
+  type: :runtime
   version_requirement: 
   version_requirements: !ruby/object:Gem::Requirement 
     requirements: 
@@ -46,10 +38,16 @@ files:
 - History.txt
 - License.txt
 - README.markdown
+- lib/recurrence.rb
 - lib/recurrence
 - lib/recurrence/base.rb
 - lib/recurrence/event.rb
-- lib/recurrence.rb
+- lib/recurrence/shortcuts.rb
+- lib/recurrence/event
+- lib/recurrence/event/monthly.rb
+- lib/recurrence/event/daily.rb
+- lib/recurrence/event/weekly.rb
+- lib/recurrence/event/yearly.rb
 has_rdoc: false
 homepage: http://github.com/fnando/recurrence
 post_install_message: