recurs 0.0.1

data/.gitignore

@@ -0,0 +1,4 @@
+pkg/*
+*.gem
+.bundle
+.idea

data/Gemfile

@@ -0,0 +1,9 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in recurs.gemspec
+gemspec
+
+group :test do
+  #gem 'rails', '3.0.1'
+  gem 'rspec'
+end

data/README

@@ -0,0 +1,17 @@
+#  Recurs
+Is a small Recurring Event parsing library. It will take symbolized input and output icalendar standard recurring events,
+see the specs for examples of the api
+
+This gem has been tested as a standalone in ruby 1.9, or using Rails 3
+
+It also allows the developer to specifiy specialized Recurrence schemes by using the power of Ruby closures
+
+##  Rails (ActiveRecord)
+
+    class Event < AR
+        acts_as_recurring
+    end
+
+
+## TODO
+  Finish the instance functionality

data/Rakefile

@@ -0,0 +1,2 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks

data/lib/recurs.rb

@@ -0,0 +1,245 @@
+require 'util/module' unless defined? Rails
+require 'recurs/consts'
+require 'recurs/rules'
+require 'ri_cal'
+module Recurs
+  include RiCal
+  # Your code goes here...
+
+  module Parser
+
+    def self.included(base)
+      base.send :extend, ClassMethods
+    end
+
+    # class << self is NOT the same as including ( seen above ) which makes methods available to CLASSES that include the module
+    #, it ONLY makes the methods available to the MODULE itself
+    class << self
+      def rrule(repeats=nil, args={})
+        args[:rule] = :r
+        rule(repeats, args)
+      end
+
+      def exrule(repeats=nil, args={})
+        args[:rule] = :e
+        rule(repeats, args)
+      end
+
+      def rdate(dates=nil, args={})
+        args[:rule] = :r
+        date(dates, args)
+      end
+
+      def exdate(dates=nil, args={})
+        args[:rule] = :e
+        date(dates, args)
+      end
+
+      def date(dates=nil, args={})
+        args[:rule] == :r ? r = "RDATE" : r = "EXDATE"
+        if dates.is_a? Hash
+          f_dates = dates.flatten
+          if (f_dates[0] == :period) || (f_dates[0] == :range)
+            r += ";VALUE=PERIOD:"
+            i = 0
+            l = f_dates[1].length
+            e = 1
+            f_dates[1].each { |d|
+              r += RiCal::FastDateTime.from_date_time(d.to_datetime).ical_str
+              r += '/' if i == 0
+              r += ',' if (e < l) && (i != 0)
+              i += 1
+              e += 1
+            }
+          elsif f_dates[0] == :dates
+          r += ":"
+            l = f_dates[1].length
+            e = 1
+            f_dates[1].each {|d|
+              r += "#{RiCal::FastDateTime.from_date_time(d.to_datetime).ical_str}"
+              r += "," if (e < l)
+              e += 1
+            }
+          end
+        elsif dates.is_a?(Date) || dates.is_a?(DateTime)
+          r += ":#{RiCal::FastDateTime.from_date_time(dates.to_datetime).ical_str}"
+        end
+        r
+      end
+
+      protected
+      @@rule = nil
+
+        # The BYSECOND attr could be eg: 14 or multiple: 14, 45 between 0 and 59 ( i assume )
+        # The BYMINUTE attr could be eg: 14 or multiple: 14, 45 between 0 and 59 ( i assume )
+        # The BYSECOND attr could be eg: 14 or multiple: 14, 22 between 0 and 23 ( i assume )
+        # The BYDAY attribute allows you to specify exactly which days (SA, SU, MO, TU, WE, TH, FR)
+        # The BYMONTH is any month value between 1 .. 12
+        # the BYMONTHDAY is any value between 1 and 31
+        # WKST is the week starting on BYDAY eg SU,MO,TU,WE,TH
+
+        #args.each {|a| args[a[0]] = a[1].to_s.upcase if (a[1].is_a? String) || (a[1].is_a? Symbol)}
+
+
+      def rule(repeats, args = {})
+        args[:rule] == :r ? @@rule = "RRULE" : @@rule = "EXRULE"
+        @@rule += ":FREQ=#{repeats.to_s.upcase}"
+        interval(args)
+        args.each { |ar|
+          unless [:rule, :by_set_pos, :by_week_at, :count, :occurrences, :until, :ends_at, :repeats_every, :interval].include? ar[0]
+            @@rule += ";#{ar[0].to_s.gsub('_', '').upcase}=#{by_unit(ar[0], ar[1])}"
+          end
+        }
+        @@rule += ";BYSETPOS=#{args[:by_set_pos]}" if args[:by_set_pos]
+        @@rule += ";WKST=#{args[:by_week_st]}" if args[:by_week_st]
+        ending(args)
+        @@rule
+      end
+
+      def by_unit(measure, units)
+        ms       = {:by_second    => [60, get_num, BY_N_SECONDS],
+                    :by_minute    => [60, get_num, BY_N_MINUTES],
+                    :by_hour      => [23, get_num, BY_N_HOURS],
+                    :by_day       => [7, get_day_num, BY_DAYS],
+                    :by_month_day => [31, get_day_num, BY_N_MONTH_DAYS],
+                    :by_year_day  => [366, get_day_num, BY_N_YEAR_DAYS],
+                    :by_week      => [52, get_num, BY_N_WEEKS],
+                    :by_month     => [12, get_month_num, BY_N_MONTHS]}
+
+        @measure = ms[measure]
+
+        r        = ""
+        d        = get_unit_nums(units)
+        comp     = d.uniq.compact
+        c        = comp.count
+        z        = 0
+        comp.each { |i|
+          z += 1
+          r += @measure[2][i].to_s
+          r += "," unless z == c
+        }
+        r
+      end
+
+      def get_unit_nums(units)
+        r = []
+        # consts DAYS, BY_DAY
+        if units.is_a? Array
+          units.each { |d|
+            r << @measure[1].call(d)
+          }
+        else
+          r << @measure[1].call(units)
+        end
+        r
+      end
+
+      def get_num
+        ->(num){
+        num.to_i.modulo(@measure[0]) unless num.is_a? Symbol;
+        }
+      end
+
+      def get_day_num
+        ->(day){
+        if DAYS.include?(day.to_s.capitalize)
+          DAYS.find_index(day.to_s.capitalize)
+        elsif BY_DAYS.include?(day.to_s.upcase)
+          BY_DAYS.find_index(day.to_s.upcase)
+        else
+          day.to_i.modulo(7) unless day.is_a? Symbol
+        end;
+        }
+      end
+
+      def get_month_num
+        ->(mon){
+        if MONTHS.include?(mon.to_s.capitalize)
+          MONTHS.find_index(mon.to_s.capitalize)
+        elsif BY_N_MONTHS.include?(mon.to_s.upcase)
+          BY_N_MONTHS.find_index(mon.to_s.upcase)
+        else
+          mon.to_i.modulo(12) unless mon.is_a? Symbol
+        end;
+        }
+      end
+
+      def interval(args)
+        if args[:repeats_every]
+          @@rule += ";INTERVAL=#{args[:repeats_every]}"
+        elsif args[:interval]
+          @@rule += ";INTERVAL=#{args[:interval]}"
+        end
+      end
+
+      def ending(args)
+        if args[:count]
+          @@rule += ";COUNT=#{args[:count]}"
+        elsif args[:occurrences]
+          @@rule += ";COUNT=#{args[:occurrences]}"
+        elsif args[:until]
+          @@rule += ";UNTIL=#{RiCal::FastDateTime.from_date_time(args[:until].to_datetime).ical_str}"
+        elsif args[:ends_at]
+          @@rule += ";UNTIL=#{RiCal::FastDateTime.from_date_time(args[:ends_at].to_datetime).ical_str}"
+        end
+      end
+
+    end
+
+    module ClassMethods
+      def acts_as_recurring
+        send :include, InstanceMethods
+      end
+    end
+
+    module InstanceMethods
+      def initialize
+        @rrules  ||= []
+        @exrules ||= []
+        @rdates  ||= []
+        @exdates ||= []
+        super
+      end
+
+      def recurs
+        r = @rrules
+        r.concat @exrules
+        r.concat @rdates
+        r.concat @exdates
+        r.join
+      end
+
+      def add_rrule(repeats, args = {})
+        rrule = Parser.rrule(repeats, args)
+        @rrules << rrule
+        rrule
+      end
+
+      def add_exrule(repeats, args = {})
+        exrule = Parser.exrule(repeats, args)
+        @exrules << exrule
+        exrule
+      end
+
+      def add_rdate(args = {})
+        rdate = Parser.rdate(args)
+        @rdates << rdate
+        rdate
+      end
+
+      def add_exdate(args = {})
+        exdate = Parser.exdate(args)
+        @exdates << exdate
+        exdate
+      end
+
+      protected
+      attr_accessor :rrules, :exrules, :rdates, :exdates
+    end
+
+
+  end
+
+
+end
+ActiveRecord::Base.send(:include, Recurs::Parser) if defined? Rails

data/lib/recurs/consts.rb

@@ -0,0 +1,40 @@
+module Recurs
+  #module Consts
+    #  0       1         2          3           4         5        6
+    DAYS              = ['Sunday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday']
+    MONTHS            = ['January', "February", 'March', 'April', 'May', 'June',
+                         'July', 'August', 'September', 'October', 'November', 'December']
+    BY_N_SECONDS      = (0..59).to_a
+    BY_N_MINUTES      = (0..59).to_a
+    BY_N_HOURS        = (0..23).to_a
+    BY_N_DAYS         = (0..6).to_a
+    BY_N_MONTH_DAYS   = (1..31).to_a
+    BY_N_YEAR_DAYS    = (1..366).to_a
+    BY_DAYS           = ['SU', 'MO', 'TU', 'WE', 'TH', 'FR', 'SA']
+    BY_N_WEEKS        = (1..54).to_a
+    BY_N_MONTHS       = (1..12).to_a
+    BY_MONTHS         = ['jan', 'feb', 'mar', 'jun', 'jul', 'aug', 'sep', 'oct', 'nov', 'dec']
+
+    #SYM_DAYS = [:sunday, :monday, :tuesday, :wednesday, :thursday, :friday, :saturday]
+    SYM_INTEGERS      = [:zero, :one, :two, :three, :four, :five, :six, :seven, :eight, :nine, :ten]
+    SYM_TEENS         = [:eleven, :twelve, :thirteen, :fourteen, :fifteen, :sixteen, :seventeen, :eighteen, :nineteen]
+    SYM_INTEGER_GROUP = SYM_INTEGERS+SYM_TEENS
+
+    # SYM_TENS[(34 - 34.modulo(10))/10]
+    SYM_TENS          = [:ten, :twenty, :thirty, :fourty, :fifty, :sixty, :seventy, :eighty, :ninety, :hundred]
+
+    def get_integer_from_sym(sym)
+      SYM_INTEGER_GROUP(sym)
+    end
+
+    def build_num_sym(int)
+      if int > 19
+        r = int.modulo(10)
+        t = int - r
+        [SYM_TENS(t), SYM_INTEGERS[r]]
+      else
+        SYM_INTEGER_GROUP[int]
+      end
+    end
+  #end
+end

data/lib/recurs/rules.rb

@@ -0,0 +1,92 @@
+module Recurs
+  module Rules
+  mattr_accessor :repeat_procs, :schema
+  @@repeat_procs = {
+
+=begin
+    'Daily' => ->(args = {}){
+        args[:repeats] = 'DAILY'
+        rrule(args);
+    }, # 0
+=end
+
+#=begin
+    'Daily' => ->(set=false, args = {}){
+      unless set
+        @recurrence_template = ['standard','Days']
+      else
+        Parser.rrule(:daily, args)
+      end;
+    }, # 0
+#=end
+
+    'Every Weekday ( Mon - Fri )' => ->(set=false, args = {}){
+      unless set
+        @recurrence_template = 'set_points'
+      else
+        args[:by_day] = [1,2,3,4,5]
+        Parser.rrule(:weekly, args)
+        #
+        # .
+      end;
+    }, # 1
+
+    'Every Mon, Wed, Fri' => ->(set=false, args = {}){
+      unless set
+        @recurrence_template = 'set_points'
+      else
+        args[:by_day] = [1,3,5]
+        Parser.rrule(:weekly, args)
+      end;
+    }, # 2
+
+    'Every Tues, Thurs' => ->(set=false, args = {}){
+      unless set
+        @recurrence_template = 'set_points'
+      else
+        args[:by_day] = [2,4]
+        Parser.rrule(:weekly, args)
+      end;
+    }, # 3
+
+    'Every Weekend' => ->(set=false, args = {}){
+      unless set
+        @recurrence_template = 'set_points'
+      else
+        args[:by_day] = [0,6]
+        Parser.rrule(:weekly, args)
+      end;
+    }, # 4
+
+    'Weekly' => ->(set=false, args = {}){
+      unless set
+        @recurrence_template = ['weekly', 'Weeks']
+      else
+        Parser.rrule(:weekly, args)
+      end;
+    }, # 5
+
+    'Monthly' => ->(set=false, args = {}){
+      unless set
+        @recurrence_template = ['monthly', 'Months']
+      else
+        Parser.rrule(:monthly, args)
+      end;
+    }, # 6
+
+    'Yearly' => ->(set=false, args = {}){
+      unless set
+        @recurrence_template = ['standard', 'Years']
+      else
+        Parser.rrule(:yearly, args)
+      end;
+    } # 7
+
+  }
+  class << self
+    def schemes
+      @@schemas = @@repeat_procs.keys if @@repeat_procs.is_a? Hash
+    end
+  end
+  end
+end

data/lib/recurs/version.rb

@@ -0,0 +1,3 @@
+module Recurs
+  VERSION = "0.0.1"
+end

data/lib/util/module.rb

@@ -0,0 +1,67 @@
+# these utility methods are taken from Ruby On Rails ActiveSupport module
+
+class Array
+  # Extracts options from a set of arguments. Removes and returns the last
+  # element in the array if it's a hash, otherwise returns a blank hash.
+  #
+  #   def options(*args)
+  #     args.extract_options!
+  #   end
+  #
+  #   options(1, 2)           # => {}
+  #   options(1, 2, :a => :b) # => {:a=>:b}
+  def extract_options!
+    if last.is_a?(Hash) && last.extractable_options?
+      pop
+    else
+      {}
+    end
+  end
+end
+
+class Module
+  def mattr_reader(*syms)
+    syms.each do |sym|
+      next if sym.is_a?(Hash)
+      class_eval(<<-EOS, __FILE__, __LINE__)
+        unless defined? @@#{sym}
+          @@#{sym} = nil
+        end
+
+        def self.#{sym}
+          @@#{sym}
+        end
+
+        def #{sym}
+          @@#{sym}
+        end
+      EOS
+    end
+  end
+
+  def mattr_writer(*syms)
+    options = syms.extract_options!
+    syms.each do |sym|
+      class_eval(<<-EOS, __FILE__, __LINE__)
+        unless defined? @@#{sym}
+          @@#{sym} = nil
+        end
+
+        def self.#{sym}=(obj)
+          @@#{sym} = obj
+        end
+
+        #{"
+        def #{sym}=(obj)
+          @@#{sym} = obj
+        end
+        " unless options[:instance_writer] == false }
+      EOS
+    end
+  end
+
+  def mattr_accessor(*syms)
+    mattr_reader(*syms)
+    mattr_writer(*syms)
+  end
+end

data/recurs.gemspec

@@ -0,0 +1,22 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "recurs/version"
+
+Gem::Specification.new do |s|
+  s.name        = "recurs"
+  s.version     = Recurs::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Steve Caney Martin"]
+  s.email       = ["steve@shakewell.co.uk"]
+  s.homepage    = "http://rubygems.org/gems/recurs"
+  s.summary     = %q{A recurrence generator for ical format}
+  s.description = %q{Specifiy you're recurrence pattern in symbols and strings and get an ical format recurrence string}
+
+  s.rubyforge_project = "recurs"
+  s.add_dependency('ri_cal', '>= 0.8.7')
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+end

data/spec/models/event_spec.rb

@@ -0,0 +1,66 @@
+require 'spec_helper'
+
+class Event;end
+Event.send(:include, Recurs::Parser)
+class Event
+  acts_as_recurring
+end
+
+describe Event do
+  before :each do
+    @event = Event.new
+  end
+
+  it "should act as recurring" do
+    #@event.rrules
+    #@event.exrules
+    #@event.rdates
+    #@event.exdates
+    @event.recurs
+  end
+
+  it "should add an rrule" do
+    @event.add_rrule(:daily).should == "RRULE:FREQ=DAILY"
+    @event.recurs.should == "RRULE:FREQ=DAILY"
+  end
+
+    it "should add an exrule" do
+    @event.add_exrule(:daily).should == "EXRULE:FREQ=DAILY"
+    @event.recurs.should == "EXRULE:FREQ=DAILY"
+    end
+
+  it "should add an rdate" do
+    @event.add_rdate(Date.today).should == "RDATE:#{RiCal::FastDateTime.from_date_time(Date.today.to_datetime).ical_str}"
+  end
+
+  it "should add an rdate range" do
+    @event.add_rdate(:period => [Date.today, (Date.today+2)]).should == "RDATE;VALUE=PERIOD:#{RiCal::FastDateTime.from_date_time(Date.today.to_datetime).ical_str}/#{RiCal::FastDateTime.from_date_time((Date.today+2).to_datetime).ical_str}"
+  end
+  it "should add a list of rdates" do
+    @event.add_rdate(:dates => [Date.today, (Date.today+2)]).should == "RDATE:#{RiCal::FastDateTime.from_date_time(Date.today.to_datetime).ical_str},#{RiCal::FastDateTime.from_date_time((Date.today+2).to_datetime).ical_str}"
+  end
+  it "should add an exdate" do
+    @event.add_exdate(Date.today).should == "EXDATE:#{RiCal::FastDateTime.from_date_time(Date.today.to_datetime).ical_str}"
+  end
+
+end
+
+=begin
+  An event has recurrence
+
+  @event.recurs #"DTSTART;TZID=US-Eastern:19970902T0900
+                  RRULE:FREQ=DAILY;COUNT=10
+                  EXRULE:"
+
+TODO: Ascertain how ri_cal parses complex rules
+
+While building the recurrence the event must use private instance attributes from the recurrrence module:
+
+The recurrence module must be mixed into the model transparently, either by using an acts_as
+or by inheriting from the module
+
+class Event < AR
+acts_as_recurring_event
+end
+
+=end

data/spec/models/recurrence_spec.rb

@@ -0,0 +1,128 @@
+require 'spec_helper'
+
+describe Recurs do
+
+end
+
+describe Recurs::Parser do
+  #pending "add some examples to (or delete) #{__FILE__}"
+
+  it "should respond to class/module methods:" do
+    Recurs::Parser.rrule
+    Recurs::Parser.exrule
+  end
+
+  it "should get basic rrule" do
+    Recurs::Parser.rrule.should == "RRULE:FREQ="
+  end
+
+  it "should get basic exrule" do
+    Recurs::Parser.exrule.should == "EXRULE:FREQ="
+  end
+
+  it "should build a basic daily rule" do
+    Recurs::Parser.rrule(:daily).should == "RRULE:FREQ=DAILY"
+  end
+
+ it "should create a daily recurrence with a two day interval" do
+   Recurs::Parser.rrule(:daily, :interval => 2).should == "RRULE:FREQ=DAILY;INTERVAL=2"
+   Recurs::Parser.rrule(:daily, :repeats_every => 2).should == "RRULE:FREQ=DAILY;INTERVAL=2"
+   Recurs::Parser.rrule(:daily, :repeats_every => 2, :interval => 2).should == "RRULE:FREQ=DAILY;INTERVAL=2"
+ end
+#=begin
+ it "should create a daily recurrence with a two day interval for ten occurrences" do
+   Recurs::Parser.rrule(:daily, :interval => 2, :count => 10).should == "RRULE:FREQ=DAILY;INTERVAL=2;COUNT=10"
+   Recurs::Parser.rrule(:daily, :interval => 2, :occurrences => 10).should == "RRULE:FREQ=DAILY;INTERVAL=2;COUNT=10"
+   Recurs::Parser.rrule(:daily, :interval => 2, :count => 10, :occurrences => 10).should == "RRULE:FREQ=DAILY;INTERVAL=2;COUNT=10"
+ end
+
+ it "should create a valid ending, 'count' OR 'until' NOT both, PREFER 'count'" do
+   Recurs::Parser.rrule(:daily, :interval => 2, :count => 10).should == "RRULE:FREQ=DAILY;INTERVAL=2;COUNT=10"
+   Recurs::Parser.rrule(:daily, :interval => 2, :ends_at => Date.today).should == "RRULE:FREQ=DAILY;INTERVAL=2;UNTIL=#{RiCal::FastDateTime.from_date_time(Date.today.to_datetime).ical_str}"
+   Recurs::Parser.rrule(:daily, :interval => 2, :until => Date.today).should == "RRULE:FREQ=DAILY;INTERVAL=2;UNTIL=#{RiCal::FastDateTime.from_date_time(Date.today.to_datetime).ical_str}"
+   Recurs::Parser.rrule(:daily, :interval => 2, :until => Date.today, :count => 10).should == "RRULE:FREQ=DAILY;INTERVAL=2;COUNT=10"
+ end
+#=end
+ it "should create a weekly occurrence" do
+   Recurs::Parser.rrule(:weekly).should == "RRULE:FREQ=WEEKLY"
+ end  
+
+  it "should build a basic daily rule with a count" do
+    Recurs::Parser.rrule(:daily, :count => 10).should == "RRULE:FREQ=DAILY;COUNT=10"
+  end
+
+ it "should create a weekly occurrence on monday and thursday" do
+   Recurs::Parser.rrule(:weekly, :by_day => [1, 4]).should == "RRULE:FREQ=WEEKLY;BYDAY=MO,TH"
+   Recurs::Parser.rrule(:weekly, :by_day => [1, '4']).should == "RRULE:FREQ=WEEKLY;BYDAY=MO,TH"
+   Recurs::Parser.rrule(:weekly, :by_day => ['MO', 'TH']).should == "RRULE:FREQ=WEEKLY;BYDAY=MO,TH"
+   Recurs::Parser.rrule(:weekly, :by_day => ['Monday', 'THURSDAY']).should == "RRULE:FREQ=WEEKLY;BYDAY=MO,TH"
+   Recurs::Parser.rrule(:weekly, :by_day => [1, 'TH']).should == "RRULE:FREQ=WEEKLY;BYDAY=MO,TH"
+   Recurs::Parser.rrule(:weekly, :by_day => [2, 'TH']).should_not == "RRULE:FREQ=WEEKLY;BYDAY=MO,TH"
+
+   #Unique
+   Recurs::Parser.rrule(:weekly, :by_day => [1, 1, 4, 'TH', 'Thursday', 'MO']).should == "RRULE:FREQ=WEEKLY;BYDAY=MO,TH"
+ end
+
+  it "should create a weekly occurrence for three weeks" do
+   Recurs::Parser.rrule(:weekly, :count => 3).should == "RRULE:FREQ=WEEKLY;COUNT=3"
+  end
+
+  it "should create a weekly occurrence for three weeks on fridays" do
+   Recurs::Parser.rrule(:weekly, :count => 3, :by_day => 'FR').should == "RRULE:FREQ=WEEKLY;BYDAY=FR;COUNT=3"
+    Recurs::Parser.rrule(:weekly, :count => 3, :by_day => :friday).should == "RRULE:FREQ=WEEKLY;BYDAY=FR;COUNT=3"
+  end
+
+  it "should create a weekly occurrence for three weeks on fridays and sundays" do
+   Recurs::Parser.rrule(:weekly, :count => 3, :by_day => ['FR', 0]).should == "RRULE:FREQ=WEEKLY;BYDAY=FR,SU;COUNT=3"
+    Recurs::Parser.rrule(:weekly, :count => 3, :by_day => [:friday, 0]).should == "RRULE:FREQ=WEEKLY;BYDAY=FR,SU;COUNT=3"
+  end
+
+  it "should bypass badly input days and use good values" do
+   Recurs::Parser.rrule(:weekly, :count => 3, :by_day => ['fer', 0]).should == "RRULE:FREQ=WEEKLY;BYDAY=SU;COUNT=3"
+    Recurs::Parser.rrule(:weekly, :count => 3, :by_day => [:fer, 0]).should == "RRULE:FREQ=WEEKLY;BYDAY=SU;COUNT=3"
+    Recurs::Parser.rrule(:weekly, :count => 3, :by_day => [:fesefra, :sunday]).should == "RRULE:FREQ=WEEKLY;BYDAY=SU;COUNT=3"
+  end
+
+  it "should occur every month" do
+   Recurs::Parser.rrule(:monthly).should == "RRULE:FREQ=MONTHLY"
+  end
+
+  it "should occur every year" do
+    Recurs::Parser.rrule(:yearly).should == "RRULE:FREQ=YEARLY"
+  end
+
+  it "should occur every january of each year" do
+        Recurs::Parser.rrule(:yearly, :by_month => :january).should == "RRULE:FREQ=YEARLY;BYMONTH=1"
+  end
+
+  it "should occur on every thursday of every janruary of each year" do
+     Recurs::Parser.rrule(:yearly, :by_month => :january, :by_day => :thursday).should == "RRULE:FREQ=YEARLY;BYMONTH=1;BYDAY=TH"
+  end
+
+ it "should have independent instance rules" do
+    Recurs::Parser.rrule(:yearly, :by_month => :january).should == "RRULE:FREQ=YEARLY;BYMONTH=1"
+    Recurs::Parser.rrule(:weekly, :count => 3, :by_day => ['fer', 0]).should == "RRULE:FREQ=WEEKLY;BYDAY=SU;COUNT=3"
+    Recurs::Parser.rrule(:yearly, :by_month => :january).should == "RRULE:FREQ=YEARLY;BYMONTH=1"
+ end  
+  
+end
+
+
+=begin
+# A recurrence instance should implement a couple of attributes ( recurs, rrules, rdates, exrules )
+
+Recurs::Parser.recurs is a composite method combining all rrules and exrules
+Recurs::Parser.rrules is an array of rrules similarly exrules is the same
+
+  it "instance should respond to instance methods:" do
+    Recurs::Parser = Parser.new
+    Recurs::Parser.recurs
+    Recurs::Parser.rrules
+  end
+
+# The Parser Class should implement singular versions ( rrule, exrule ), these methods generate atomic rules
+
+The Parser class implements the rrule and exrule methods => alias_method_chain perhaps
+( these are actually just aliases of the same method but with predefined flags )
+
+=end

data/spec/models/rules_spec.rb

@@ -0,0 +1,40 @@
+require 'spec_helper'
+describe Recurs::Rules do
+  it "should respond to class/module variables" do
+    Recurs::Rules.repeat_procs
+    Recurs::Rules.schemes
+  end
+
+    it "should build Daily" do
+      Recurs::Rules.repeat_procs['Daily'].call(true, :count => 10).should == "RRULE:FREQ=DAILY;COUNT=10"
+    end
+#=begin
+    it 'Every Weekday ( Mon - Fri )' do
+      Recurs::Rules.repeat_procs['Every Weekday ( Mon - Fri )'].call(true, :count => 10).should == "RRULE:FREQ=WEEKLY;BYDAY=MO,TU,WE,TH,FR;COUNT=10"
+    end
+
+    it 'Every Mon, Wed, Fri' do
+      Recurs::Rules.repeat_procs['Every Mon, Wed, Fri'].call(true, :count => 10).should == "RRULE:FREQ=WEEKLY;BYDAY=MO,WE,FR;COUNT=10"
+    end
+
+    it 'Every Tues, Thurs' do
+      Recurs::Rules.repeat_procs['Every Tues, Thurs'].call(true, :count => 10).should == "RRULE:FREQ=WEEKLY;BYDAY=TU,TH;COUNT=10"
+    end
+
+    it 'Every Weekend' do
+      Recurs::Rules.repeat_procs['Every Weekend'].call(true, :count => 10).should == "RRULE:FREQ=WEEKLY;BYDAY=SU,SA;COUNT=10"
+    end
+
+    it 'Weekly' do
+      Recurs::Rules.repeat_procs['Weekly'].call(true, :count => 10).should == "RRULE:FREQ=WEEKLY;COUNT=10"
+    end
+
+    it 'Monthly' do
+      Recurs::Rules.repeat_procs['Monthly'].call(true, :count => 10).should == "RRULE:FREQ=MONTHLY;COUNT=10"
+    end
+
+    it 'Yearly' do
+      Recurs::Rules.repeat_procs['Yearly'].call(true, :count => 10).should == "RRULE:FREQ=YEARLY;COUNT=10"
+    end
+#=end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,4 @@
+require File.expand_path('lib/recurs')
+RSpec.configure do |config|
+  config.mock_with :rspec
+end

metadata

@@ -0,0 +1,95 @@
+--- !ruby/object:Gem::Specification 
+name: recurs
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 1
+  version: 0.0.1
+platform: ruby
+authors: 
+- Steve Caney Martin
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-12-14 00:00:00 +00:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: ri_cal
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        - 8
+        - 7
+        version: 0.8.7
+  type: :runtime
+  version_requirements: *id001
+description: Specifiy you're recurrence pattern in symbols and strings and get an ical format recurrence string
+email: 
+- steve@shakewell.co.uk
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- Gemfile
+- README
+- Rakefile
+- lib/recurs.rb
+- lib/recurs/consts.rb
+- lib/recurs/rules.rb
+- lib/recurs/version.rb
+- lib/util/module.rb
+- recurs.gemspec
+- spec/models/event_spec.rb
+- spec/models/recurrence_spec.rb
+- spec/models/rules_spec.rb
+- spec/spec_helper.rb
+has_rdoc: true
+homepage: http://rubygems.org/gems/recurs
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: recurs
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: A recurrence generator for ical format
+test_files: 
+- spec/models/event_spec.rb
+- spec/models/recurrence_spec.rb
+- spec/models/rules_spec.rb
+- spec/spec_helper.rb