ice_cube_chosko 0.1.0 → 0.1.1

data/config/locales/sv.yml

@@ -0,0 +1,169 @@
+sv:
+  ice_cube:
+    pieces_connector: ' / '
+    not: 'inte %{target}'
+    not_on: 'inte i %{target}'
+    date:
+      formats:
+        default: '%-d %B %Y'
+      month_names:
+      -
+      - januari
+      - februari
+      - mars
+      - april
+      - maj
+      - juni
+      - juli
+      - augusti
+      - september
+      - oktober
+      - november
+      - december
+      day_names:
+      - söndag
+      - måndag
+      - tisdag
+      - onsdag
+      - torsdag
+      - fredag
+      - lördag
+    times:
+      other: '%{count} gånger'
+      one: '%{count} gång'
+    until: 'tills %{date}'
+    days_of_week: '%{segments} %{day}'
+    days_of_month:
+      other: '%{segments} dagen i månaden'
+      one: '%{segments} dagen i månaden'
+    days_of_year:
+      other: '%{segments} dagen på året'
+      one: '%{segments} dagen på året'
+    at_hours_of_the_day:
+      other: i %{segments} timme på dygnet
+      one: i %{segments} timme på dygnet
+    on_minutes_of_hour:
+      other: i %{segments} minuter av timmen
+      one: i %{segments} minuten av timmen
+    on_seconds_of_minute:
+      other: på %{segments} sekunden av minuten
+      one: på %{segments} sekunden av minuten
+    each_second:
+      one: Varje sekund
+      other: Varje %{count} sekund
+    each_minute:
+      one: Varje minut
+      other: Varje %{count} minut
+    each_hour:
+      one: Varje timme
+      other: Varje %{count} timme
+    each_day:
+      one: Varje dag
+      other: Varje %{count} dag
+    each_week:
+      one: Varje vecka
+      other: Varje %{count} vecka
+    each_month:
+      one: Varje månad
+      other: Varje %{count} månad
+    each_year:
+      one: Varje år
+      other: Varje %{count} år
+    'on': i %{sentence}
+    in: 'efter %{target}'
+    integer:
+      negative: '%{ordinal} från slutet'
+      literal_ordinals:
+        -1: sista
+        -2: nästsista
+      ordinal: '%{number}%{ordinal}'
+      ordinals:
+        default: ''
+    on_weekends: på helger
+    on_weekdays: på vardagar
+    days_on:
+      - söndagar
+      - måndagar
+      - tisdagar
+      - onsdagar
+      - torsdagar
+      - fredagar
+      - lördagar
+    on_days: på %{days}
+    array:
+      last_word_connector: ' och '
+      two_words_connector: ' och '
+      words_connector: ', '
+    string:
+      format:
+        day: '%{rest} %{current}'
+        day_of_week: '%{rest} %{current}'
+        day_of_month: '%{rest} %{current}'
+        day_of_year: '%{rest} %{current}'
+        hour_of_day: '%{rest} %{current}'
+        minute_of_hour: '%{rest} %{current}'
+        until: '%{rest} %{current}'
+        count: '%{rest} %{current}'
+        default: '%{rest} %{current}'
+
+  date:
+    abbr_day_names:
+    - Sön
+    - Mån
+    - Tis
+    - Ons
+    - Tor
+    - Fre
+    - Lör
+    abbr_month_names:
+    -
+    - Jan
+    - Feb
+    - Mar
+    - Apr
+    - Maj
+    - Jun
+    - Jul
+    - Aug
+    - Sep
+    - Okt
+    - Mov
+    - Dec
+    day_names:
+    - Söndag
+    - Måndag
+    - Tisdag
+    - Onsdag
+    - Torsdag
+    - Fredag
+    - Lördag
+    formats:
+      default: "%Y-%m-%d"
+      long: "%e %B %Y"
+      short: "%e %b"
+    month_names:
+    -
+    - Januari
+    - Februari
+    - Mars
+    - April
+    - Maj
+    - Juni
+    - Juli
+    - Augusti
+    - September
+    - Oktober
+    - November
+    - December
+    order:
+    - :day
+    - :month
+    - :year
+
+  time:
+    am: ''
+    formats:
+      default: "%a, %e %b %Y %H:%M:%S %z"
+      long: "%e %B %Y %H:%M"
+      short: "%e %b %H:%M"
+    pm: ''

data/lib/ice_cube.rb

@@ -43,6 +43,7 @@ module IceCube
 
     autoload :Count, 'ice_cube/validations/count'
     autoload :Until, 'ice_cube/validations/until'
+    autoload :OverrideDuration, 'ice_cube/validations/override_duration'
 
     autoload :SecondlyInterval, 'ice_cube/validations/secondly_interval'
     autoload :MinutelyInterval, 'ice_cube/validations/minutely_interval'

data/lib/ice_cube/parsers/ical_parser.rb

@@ -24,14 +24,18 @@ module IceCube
     end
 
     def self.rule_from_ical(ical)
-      params = { validations: { } }
+      raise ArgumentError, 'empty ical rule' if ical.nil?
+
+      validations = {}
+      params = {validations: validations, interval: 1}
 
       ical.split(';').each do |rule|
         (name, value) = rule.split('=')
+        raise ArgumentError, "Invalid iCal rule component" if value.nil?
         value.strip!
         case name
         when 'FREQ'
-          params[:freq] = value.downcase
+          params[:rule_type] = "IceCube::#{value[0]}#{value.downcase[1..-1]}Rule"
         when 'INTERVAL'
           params[:interval] = value.to_i
         when 'COUNT'
@@ -39,13 +43,13 @@ module IceCube
         when 'UNTIL'
           params[:until] = Time.parse(value).utc
         when 'WKST'
-          params[:wkst] = TimeUtil.ical_day_to_symbol(value)
+          params[:week_start] = TimeUtil.ical_day_to_symbol(value)
         when 'BYSECOND'
-          params[:validations][:second_of_minute] = value.split(',').collect(&:to_i)
+          validations[:second_of_minute] = value.split(',').map(&:to_i)
         when 'BYMINUTE'
-          params[:validations][:minute_of_hour] = value.split(',').collect(&:to_i)
+          validations[:minute_of_hour] = value.split(',').map(&:to_i)
         when 'BYHOUR'
-          params[:validations][:hour_of_day] = value.split(',').collect(&:to_i)
+          validations[:hour_of_day] = value.split(',').map(&:to_i)
         when 'BYDAY'
           dows = {}
           days = []
@@ -59,33 +63,21 @@ module IceCube
               days.push TimeUtil.sym_to_wday(day) if dows[day].nil?
             end
           end
-          params[:validations][:day_of_week] = dows unless dows.empty?
-          params[:validations][:day] = days unless days.empty?
+          validations[:day_of_week] = dows unless dows.empty?
+          validations[:day] = days unless days.empty?
         when 'BYMONTHDAY'
-          params[:validations][:day_of_month] = value.split(',').collect(&:to_i)
+          validations[:day_of_month] = value.split(',').map(&:to_i)
         when 'BYMONTH'
-          params[:validations][:month_of_year] = value.split(',').collect(&:to_i)
+          validations[:month_of_year] = value.split(',').map(&:to_i)
         when 'BYYEARDAY'
-          params[:validations][:day_of_year] = value.split(',').collect(&:to_i)
+          validations[:day_of_year] = value.split(',').map(&:to_i)
         when 'BYSETPOS'
         else
-          raise "Invalid or unsupported rrule command: #{name}"
+          validations[name] = nil # invalid type
         end
       end
 
-      params[:interval] ||= 1
-
-      # WKST only valid for weekly rules
-      params.delete(:wkst) unless params[:freq] == 'weekly'
-
-      rule = Rule.send(*params.values_at(:freq, :interval, :wkst).compact)
-      rule.count(params[:count]) if params[:count]
-      rule.until(params[:until]) if params[:until]
-      params[:validations].each do |key, value|
-        value.is_a?(Array) ? rule.send(key, *value) : rule.send(key, value)
-      end
-
-      rule
+      Rule.from_hash(params)
     end
   end
 end

data/lib/ice_cube/rule.rb

@@ -4,6 +4,11 @@ module IceCube
 
   class Rule
 
+    INTERVAL_TYPES = [
+      :secondly, :minutely, :hourly,
+      :daily, :weekly, :monthly, :yearly
+    ]
+
     attr_reader :uses
 
     # Is this a terminating schedule?
@@ -11,6 +16,11 @@ module IceCube
       until_time || occurrence_count
     end
 
+    # Does this rule override the schedule's duration?
+    def overrides_duration?
+      !duration.nil?
+    end
+
     def ==(rule)
       if rule.is_a? Rule
         hash = to_hash
@@ -46,21 +56,6 @@ module IceCube
       raise MethodNotImplemented, "Expected to be overridden by subclasses"
     end
 
-    # Convert from a hash and create a rule
-    def self.from_hash(original_hash)
-      hash = IceCube::FlexibleHash.new original_hash
-      return nil unless match = hash[:rule_type].match(/\:\:(.+?)Rule/)
-      rule = IceCube::Rule.send(match[1].downcase.to_sym, hash[:interval] || 1)
-      rule.interval(hash[:interval] || 1, TimeUtil.wday_to_sym(hash[:week_start] || 0)) if match[1] == "Weekly"
-      rule.until(TimeUtil.deserialize_time(hash[:until])) if hash[:until]
-      rule.count(hash[:count]) if hash[:count]
-      hash[:validations] && hash[:validations].each do |key, value|
-        key = key.to_sym unless key.is_a?(Symbol)
-        value.is_a?(Array) ? rule.send(key, *value) : rule.send(key, value)
-      end
-      rule
-    end
-
     # Reset the uses on the rule to 0
     def reset
       @uses = 0
@@ -78,6 +73,52 @@ module IceCube
       !@count.nil?
     end
 
+    class << self
+
+      # Convert from a hash and create a rule
+      def from_hash(original_hash)
+        hash = IceCube::FlexibleHash.new original_hash
+
+        unless hash[:rule_type] && match = hash[:rule_type].match(/\:\:(.+?)Rule/)
+          raise ArgumentError, 'Invalid rule type'
+        end
+
+        interval_type = match[1].downcase.to_sym
+
+        unless INTERVAL_TYPES.include?(interval_type)
+          raise ArgumentError, "Invalid rule frequency type: #{match[1]}"
+        end
+
+        rule = IceCube::Rule.send(interval_type, hash[:interval] || 1)
+
+        if match[1] == "Weekly"
+          rule.interval(hash[:interval] || 1, TimeUtil.wday_to_sym(hash[:week_start] || 0))
+        end
+
+        rule.until(TimeUtil.deserialize_time(hash[:until])) if hash[:until]
+        rule.count(hash[:count]) if hash[:count]
+
+        hash[:validations] && hash[:validations].each do |name, args|
+          apply_validation(rule, name, args)
+        end
+
+        rule
+      end
+
+      private
+
+      def apply_validation(rule, name, args)
+        name = name.to_sym
+
+        unless ValidatedRule::VALIDATION_ORDER.include?(name)
+          raise ArgumentError, "Invalid rule validation type: #{name}"
+        end
+
+        args.is_a?(Array) ? rule.send(name, *args) : rule.send(name, args)
+      end
+
+    end
+
     # Convenience methods for creating Rules
     class << self
 

data/lib/ice_cube/schedule.rb

@@ -44,6 +44,16 @@ module IceCube
       @end_time = start_time + seconds
     end
 
+    # Return the maximum value between schedule's duration and
+    # the durations of all the recurrence and exception rules included
+    # in this schedule
+    def max_duration
+      all_durations = [duration]
+      all_durations += @all_recurrence_rules.map { |r| r.duration }.compact
+      all_durations += @all_exception_rules.map { |r| r.duration }.compact
+      all_durations.max
+    end
+
     # Add a recurrence time to the schedule
     def add_recurrence_time(time)
       return nil if time.nil?
@@ -166,55 +176,55 @@ module IceCube
     end
 
     # The next n occurrences after now
-    def next_occurrences(num, from = nil, spans = false)
+    def next_occurrences(num, from = nil, options = {})
       from = TimeUtil.match_zone(from, start_time) || TimeUtil.now(start_time)
-      enumerate_occurrences(from + 1, nil, spans).take(num)
+      enumerate_occurrences(from + 1, nil, options).take(num)
     end
 
     # The next occurrence after now (overridable)
-    def next_occurrence(from = nil, spans = false)
+    def next_occurrence(from = nil, options = {})
       from = TimeUtil.match_zone(from, start_time) || TimeUtil.now(start_time)
-      enumerate_occurrences(from + 1, nil, spans).next
+      enumerate_occurrences(from + 1, nil, options).next
     rescue StopIteration
       nil
     end
 
     # The previous occurrence from a given time
     def previous_occurrence(from)
-      from = TimeUtil.match_zone(from, start_time) or raise ArgumentError, "Time required, got #{time.inspect}"
+      from = TimeUtil.match_zone(from, start_time) or raise ArgumentError, "Time required, got #{from.inspect}"
       return nil if from <= start_time
       enumerate_occurrences(start_time, from - 1).to_a.last
     end
 
     # The previous n occurrences before a given time
     def previous_occurrences(num, from)
-      from = TimeUtil.match_zone(from, start_time) or raise ArgumentError, "Time required, got #{time.inspect}"
+      from = TimeUtil.match_zone(from, start_time) or raise ArgumentError, "Time required, got #{from.inspect}"
       return [] if from <= start_time
       a = enumerate_occurrences(start_time, from - 1).to_a
       a.size > num ? a[-1*num,a.size] : a
     end
 
     # The remaining occurrences (same requirements as all_occurrences)
-    def remaining_occurrences(from = nil, spans = false)
+    def remaining_occurrences(from = nil, options = {})
       require_terminating_rules
       from ||= TimeUtil.now(@start_time)
-      enumerate_occurrences(from, nil, spans).to_a
+      enumerate_occurrences(from, nil, options).to_a
     end
 
     # Returns an enumerator for all remaining occurrences
-    def remaining_occurrences_enumerator(from = nil, spans = false)
+    def remaining_occurrences_enumerator(from = nil, options = {})
       from ||= TimeUtil.now(@start_time)
-      enumerate_occurrences(from, nil, spans)
+      enumerate_occurrences(from, nil, options)
     end
 
     # Occurrences between two times
-    def occurrences_between(begin_time, closing_time, spans = false)
-      enumerate_occurrences(begin_time, closing_time, spans).to_a
+    def occurrences_between(begin_time, closing_time, options = {})
+      enumerate_occurrences(begin_time, closing_time, options).to_a
     end
 
     # Return a boolean indicating if an occurrence falls between two times
-    def occurs_between?(begin_time, closing_time, spans = false)
-      enumerate_occurrences(begin_time, closing_time, spans).next
+    def occurs_between?(begin_time, closing_time, options = {})
+      enumerate_occurrences(begin_time, closing_time, options).next
       true
     rescue StopIteration
       false
@@ -226,7 +236,7 @@ module IceCube
     # occurrences at the end of the range since none of their duration
     # intersects the range.
     def occurring_between?(opening_time, closing_time)
-      occurs_between?(opening_time, closing_time, true)
+      occurs_between?(opening_time, closing_time, :spans => true)
     end
 
     # Return a boolean indicating if an occurrence falls on a certain date
@@ -240,9 +250,14 @@ module IceCube
     # Determine if the schedule is occurring at a given time
     def occurring_at?(time)
       time = TimeUtil.match_zone(time, start_time) or raise ArgumentError, "Time required, got #{time.inspect}"
-      if duration > 0
+      if max_duration > 0
         return false if exception_time?(time)
-        occurs_between?(time - duration + 1, time)
+        begin
+          enumerate_occurrences(time, time, :spans => true).next
+          true
+        rescue StopIteration
+          false
+        end
       else
         occurs_at?(time)
       end
@@ -405,15 +420,15 @@ module IceCube
     # Find all of the occurrences for the schedule between opening_time
     # and closing_time
     # Iteration is unrolled in pairs to skip duplicate times in end of DST
-    def enumerate_occurrences(opening_time, closing_time = nil, spans = false, &block)
+    def enumerate_occurrences(opening_time, closing_time = nil, options = {}, &block)
       opening_time = TimeUtil.match_zone(opening_time, start_time)
       closing_time = TimeUtil.match_zone(closing_time, start_time)
       opening_time += start_time.subsec - opening_time.subsec rescue 0
       opening_time = start_time if opening_time < start_time
-      spans = false if duration == 0
+      spans = options[:spans] == true && max_duration != 0
       Enumerator.new do |yielder|
         reset
-        t1 = full_required? ? start_time : realign((spans ? opening_time - duration : opening_time))
+        t1 = full_required? ? start_time : realign(opening_time) - (spans ? max_duration : 0)
         loop do
           break unless (t0 = next_time(t1, closing_time))
           break if closing_time && t0 > closing_time
@@ -437,17 +452,30 @@ module IceCube
     # Get the next time after (or including) a specific time
     def next_time(time, closing_time)
       loop do
-        min_time = recurrence_rules_with_implicit_start_occurrence.reduce(nil) do |min_time, rule|
+        min_time_with_duration = recurrence_rules_with_implicit_start_occurrence.reduce(nil) do |min_time_with_duration, rule|
+          min_time = (min_time_with_duration && min_time_with_duration[0]) || nil
           begin
             new_time = rule.next_time(time, self, min_time || closing_time)
-            [min_time, new_time].compact.min
+            new_time_with_duration = [new_time, rule.duration]
+
+            if new_time.nil?
+              min_time_with_duration
+            elsif min_time.nil?
+              new_time_with_duration
+            elsif new_time < min_time
+              new_time_with_duration
+            else
+              min_time_with_duration
+            end
           rescue StopIteration
-            min_time
+            (min_time && [min_time, rule.duration]) || nil
           end
         end
+        min_time = (min_time_with_duration && min_time_with_duration[0]) || nil
+        rule_duration = (min_time_with_duration && min_time_with_duration[1]) || nil
         break nil unless min_time
         next (time = min_time + 1) if exception_time?(min_time)
-        break Occurrence.new(min_time, min_time + duration)
+        break Occurrence.new(min_time, min_time + (rule_duration || duration))
       end
     end