ice_cube 0.6.14 → 0.7.0

data/lib/ice_cube/validations/second_of_minute.rb

@@ -1,40 +1,49 @@
 module IceCube
 
-  class SecondOfMinuteValidation < Validation
+  module Validations::SecondOfMinute
 
-    attr_reader :seconds_of_minute
-  
-    def initialize(rule)
-      @seconds_of_minute = rule.validations[:second_of_minute]
-    end
-  
-    def validate(date)
-      return true if !@seconds_of_minute || @seconds_of_minute.empty?
-      @seconds_of_minute.include?(date.sec)
-    end
-  
-    def closest(date)
-      return nil if !@seconds_of_minute || @seconds_of_minute.empty?
-      # turn seconds into seconds of minute
-      # second >= 60 should fall into the next minute
-      seconds = @seconds_of_minute.map do |s|
-        s > date.sec ? s - date.sec : 60 - date.sec + s
+    def second_of_minute(*seconds)
+      seconds.each do |second|
+        validations_for(:second_of_minute) << Validation.new(second)
       end
-      seconds.compact!
-      # go to the closest distance away
-      closest_second = seconds.min
-      goal = date + closest_second
-      self.class.adjust(goal, date)
+      clobber_base_validations :sec
+      self
     end
 
-    def to_s
-      'on the ' << self.class.nice_numbers(@seconds_of_minute) << (@seconds_of_minute.size == 1 ? ' second' : ' seconds') << ' of the minute' unless @seconds_of_minute.empty?
-    end
+    class Validation
+
+      include Validations::Lock
+
+      StringBuilder.register_formatter(:second_of_minute) do |segments|
+        str = "on the #{StringBuilder.sentence(segments)} "
+        str << (segments.size == 1 ? 'second of the minute' : 'seconds of the minute')
+      end
+
+      attr_reader :second
+      alias :value :second
+
+      def initialize(second)
+        @second = second
+      end
+
+      def type
+        :sec
+      end
+
+      def build_s(builder)
+        builder.piece(:second_of_minute) << StringBuilder.nice_number(second)
+      end
+
+      def build_hash(builder)
+        builder.validations_array(:second_of_minute) << second
+      end
+
+      def build_ical(builder)
+        builder['BYSECOND'] << second
+      end
 
-    def to_ical
-      'BYSECOND=' << @seconds_of_minute.join(',') unless @seconds_of_minute.empty?
     end
-  
+
   end
-  
+
 end

data/lib/ice_cube/validations/secondly_interval.rb

@@ -0,0 +1,50 @@
+module IceCube
+
+  module Validations::SecondlyInterval
+
+    def interval(interval)
+      validations_for(:interval) << Validation.new(interval)
+      clobber_base_validations(:sec)
+      self
+    end
+
+    class Validation
+
+      attr_reader :interval
+
+      def type
+        :sec
+      end
+
+      def dst_adjust?
+        false
+      end
+
+      def build_s(builder)
+        builder.base = interval == 1 ? 'Secondly' : "Every #{interval} seconds"
+      end
+
+      def build_ical(builder)
+        builder['FREQ'] << 'SECONDLY'
+      end
+
+      def build_hash(builder)
+        builder.validations[:interval] = interval
+      end
+
+      def initialize(interval)
+        @interval = interval
+      end
+
+      def validate(time, schedule)
+        seconds = time.to_i - schedule.start_time.to_i
+        unless seconds % interval == 0
+          interval - (seconds % interval)
+        end
+      end
+
+    end
+
+  end
+
+end

data/lib/ice_cube/validations/until.rb

@@ -0,0 +1,49 @@
+module IceCube
+
+  module Validations::Until
+
+    # accessor
+    def until_time
+      @until
+    end
+    alias :until_date :until_time
+
+    def until(time)
+      @until = time
+      replace_validations_for(:until, [Validation.new(time)])
+      self
+    end
+
+    class Validation
+
+      attr_reader :time
+
+      def type
+        :dealbreaker
+      end
+
+      def initialize(time)
+        @time = time
+      end
+
+      def build_ical(builder)
+        builder['UNTIL'] << IcalBuilder.ical_utc_format(time)
+      end
+
+      def build_hash(builder)
+        builder[:until] = TimeUtil.serialize_time(time)
+      end
+
+      def build_s(builder)
+        builder.piece(:until) << "until #{time.strftime(TO_S_TIME_FORMAT)}"
+      end
+
+      def validate(t, schedule)
+        raise UntilExceeded if t > time 
+      end
+
+    end
+      
+  end
+
+end

data/lib/ice_cube/validations/weekly_interval.rb

@@ -0,0 +1,50 @@
+require 'date'
+
+module IceCube
+
+  module Validations::WeeklyInterval
+
+    def interval(interval)
+      validations_for(:interval) << Validation.new(interval)
+      clobber_base_validations(:day)
+    end
+
+    class Validation
+
+      attr_reader :interval
+
+      def type
+        :day
+      end
+
+      def build_s(builder)
+        builder.base = interval == 1 ? 'Weekly' : "Every #{interval} weeks"
+      end
+
+      def build_ical(builder)
+        builder['FREQ'] << 'WEEKLY'
+      end
+
+      def build_hash(builder)
+        builder.validations[:interval] = interval
+      end
+
+      def initialize(interval)
+        @interval = interval
+      end
+
+      def validate(time, schedule)
+        date = Date.new(time.year, time.month, time.day)
+        st = schedule.start_time
+        start_date = Date.new(st.year, st.month, st.day)
+        weeks = ((date - date.wday) - (start_date - start_date.wday)) / 7
+        unless weeks % interval == 0
+          (interval - (weeks % interval)) * 7
+        end
+      end
+
+    end
+
+  end
+
+end

data/lib/ice_cube/validations/yearly_interval.rb

@@ -0,0 +1,45 @@
+module IceCube
+
+  module Validations::YearlyInterval
+
+    def interval(interval = 1)
+      validations_for(:interval) << Validation.new(interval)
+      clobber_base_validations(:year)
+    end
+
+    class Validation
+
+      attr_reader :interval
+
+      def type
+        :year
+      end
+
+      def build_s(builder)
+        builder.base = interval == 1 ? 'Yearly' : "Every #{interval} years"
+      end
+
+      def build_hash(builder)
+        builder.validations[:interval] = interval
+      end
+
+      def build_ical(builder)
+        builder['FREQ'] << 'YEARLY'
+      end
+
+      def initialize(interval)
+        @interval = interval
+      end
+
+      def validate(time, schedule)
+        years_to_start = time.year - schedule.start_time.year
+        unless years_to_start % interval == 0
+          interval - (years_to_start % interval)
+        end
+      end
+
+    end
+
+  end
+
+end

data/lib/ice_cube/version.rb

@@ -1,5 +1,5 @@
 module IceCube
-  
-  VERSION = '0.6.14'
+
+  VERSION = '0.7.0'
 
 end

data/spec/spec_helper.rb

@@ -0,0 +1,13 @@
+require File.dirname(__FILE__) + '/../lib/ice_cube'
+
+begin
+  require 'cover_me'
+  # https://github.com/markbates/cover_me/issues/50
+  at_exit do
+    CoverMe.complete!
+  end
+rescue LoadError
+end
+
+DAY = Time.utc(2010, 3, 1)
+WEDNESDAY = Time.utc(2010, 6, 23, 5, 0, 0)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ice_cube
 version: !ruby/object:Gem::Version
-  version: 0.6.14
+  version: 0.7.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,11 +9,12 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2011-09-14 00:00:00.000000000Z
+date: 2011-12-08 00:00:00.000000000 -05:00
+default_executable: 
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
-  requirement: &70254752836240 !ruby/object:Gem::Requirement
+  requirement: &70154139759660 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -21,7 +22,29 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70254752836240
+  version_requirements: *70154139759660
+- !ruby/object:Gem::Dependency
+  name: active_support
+  requirement: &70154139758460 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 3.0.0
+  type: :development
+  prerelease: false
+  version_requirements: *70154139758460
+- !ruby/object:Gem::Dependency
+  name: tzinfo
+  requirement: &70154139757400 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70154139757400
 description: ice_cube is a recurring date library for Ruby.  It allows for quick,
   programatic expansion of recurring date rules.
 email: john@crepezzi.com
@@ -29,8 +52,12 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- lib/ice_cube/builders/hash_builder.rb
+- lib/ice_cube/builders/ical_builder.rb
+- lib/ice_cube/builders/string_builder.rb
+- lib/ice_cube/errors/count_exceeded.rb
+- lib/ice_cube/errors/until_exceeded.rb
 - lib/ice_cube/rule.rb
-- lib/ice_cube/rule_occurrence.rb
 - lib/ice_cube/rules/daily_rule.rb
 - lib/ice_cube/rules/hourly_rule.rb
 - lib/ice_cube/rules/minutely_rule.rb
@@ -39,19 +66,32 @@ files:
 - lib/ice_cube/rules/weekly_rule.rb
 - lib/ice_cube/rules/yearly_rule.rb
 - lib/ice_cube/schedule.rb
+- lib/ice_cube/single_occurrence_rule.rb
 - lib/ice_cube/time_util.rb
-- lib/ice_cube/validation.rb
-- lib/ice_cube/validation_types.rb
+- lib/ice_cube/validated_rule.rb
+- lib/ice_cube/validations/count.rb
+- lib/ice_cube/validations/daily_interval.rb
 - lib/ice_cube/validations/day.rb
 - lib/ice_cube/validations/day_of_month.rb
 - lib/ice_cube/validations/day_of_week.rb
 - lib/ice_cube/validations/day_of_year.rb
 - lib/ice_cube/validations/hour_of_day.rb
+- lib/ice_cube/validations/hourly_interval.rb
+- lib/ice_cube/validations/lock.rb
 - lib/ice_cube/validations/minute_of_hour.rb
+- lib/ice_cube/validations/minutely_interval.rb
 - lib/ice_cube/validations/month_of_year.rb
+- lib/ice_cube/validations/monthly_interval.rb
+- lib/ice_cube/validations/schedule_lock.rb
 - lib/ice_cube/validations/second_of_minute.rb
+- lib/ice_cube/validations/secondly_interval.rb
+- lib/ice_cube/validations/until.rb
+- lib/ice_cube/validations/weekly_interval.rb
+- lib/ice_cube/validations/yearly_interval.rb
 - lib/ice_cube/version.rb
 - lib/ice_cube.rb
+- spec/spec_helper.rb
+has_rdoc: true
 homepage: http://seejohnrun.github.com/ice_cube/
 licenses: []
 post_install_message: 
@@ -72,8 +112,9 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: ice-cube
-rubygems_version: 1.8.10
+rubygems_version: 1.6.2
 signing_key: 
 specification_version: 3
 summary: Ruby Date Recurrence Library
-test_files: []
+test_files:
+- spec/spec_helper.rb

data/lib/ice_cube/rule_occurrence.rb

@@ -1,94 +0,0 @@
-module IceCube
-  
-  class RuleOccurrence
-
-    def to_time
-      @date
-    end
-       
-    def all_occurrences
-      raise ArgumentError.new("Rule must specify either an until date or a count to use 'all_occurrences'") unless @rule.occurrence_count || @rule.until_date || @end_time
-      find_occurrences { |roc| false }
-    end
-   
-    def between(begin_time, end_time)
-      find_occurrences { |roc| roc > end_time }.select { |d| d >= begin_time }
-    end
-
-    def upto(end_date)
-      find_occurrences { |roc| roc > end_date }
-    end
-
-    # Break after the first occurrence after now
-    def next_occurrence(from)
-      next_occurrences(1, from).first
-    end
-
-    # Break after the first n occurrences after now
-    def next_occurrences(n, from, exclude_dates)
-      found_all = false
-      num_found = 0
-      nexts = find_occurrences do |roc|
-        num_found += 1 if roc > from && !exclude_dates.include?(roc.to_time)
-        success = found_all
-        found_all = num_found == n
-        success
-      end
-      #Since the above returns all up to and including the next N that were requested, we need
-      #to grab the last n, making sure to prune out ones that were actually before the from time
-      nexts.last(n).select{|occurrence| occurrence > from}
-    end
-
-    def first(n)
-      count = 0
-      find_occurrences { |roc| count += 1; count > n }
-    end
-
-    #get the next occurrence of this rule
-    def succ
-      return nil if @rule.occurrence_count && @index >= @rule.occurrence_count # count check
-      # get the next date to walk to
-      if @date.nil?
-        date = @start_date if @rule.validate_single_date(@start_date)
-        date = @rule.next_suggestion(@start_date) unless date
-      else
-        date = @rule.next_suggestion(@date)
-      end
-      # walk through all of the successive dates, looking for the next occurrence (interval-valid), then return it.
-      begin
-        return nil if @end_time && date > @end_time
-        return nil if @rule.until_date && date > @rule.until_date # until check
-        next unless @rule.in_interval?(date, @start_date)
-        return nil if yield(date)
-        return RuleOccurrence.new(@rule, @start_date, @end_time, date, @index + 1)
-      end while date = @rule.next_suggestion(date)
-    end
-    
-    attr_reader :rule
-    attr_accessor :start_date
-   
-    private
-
-    def find_occurrences(&block)
-      include_dates = []
-      roc = self
-      begin
-        break if roc.nil? #go until we run out of dates
-        next if roc.to_time.nil? #handle the case where start_date is not a valid occurrence
-        include_dates << roc.to_time
-      end while roc = roc.succ(&block)
-      include_dates
-    end
-
-    def initialize(rule, start_date, end_time, date = nil, index = 0)
-      #set some variables
-      @rule = rule
-      @start_date = start_date
-      @end_time = end_time
-      @date = date
-      @index = index
-    end
-      
-  end
-  
-end