ice_cube 0.11.1 → 0.11.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 0cf51eea4a5e3f9a8c15eedc224978494d2a79df
-  data.tar.gz: 8daed67d6ab9f6e610ea40c08e7e032a96552e47
+  metadata.gz: ad4d50b4bb41ce4aa716c1e8a21881ef46c5d392
+  data.tar.gz: 8b056f0639eedf325853e14a7218bb413f73b534
 SHA512:
-  metadata.gz: 7acfe2a1546d074b0b43a9250ce4e937f339f084fd3abf9a04b840cc529849140d224b4d2bdd134254ecf1088c19e6845fce195b9440eea2fddbb31baa25ca2b
-  data.tar.gz: d722e7ef0d0ee4fb2bfaaf5e28b330df6898ad49f183f2cb0ab43e6115bcf91be64cd07755df568318dd83deffe94439b83ec8ba0c60f2b06711d39a3c174534
+  metadata.gz: 1fbb5f63f50525151a1a4e5e8725b32d84fcf32ce766800f3e297be2662786bfda057ce59cd968ebd89aae321ed6943ef9d4a9bb3a9c539850f2d913689f2224
+  data.tar.gz: 261ff22883b072727b92e966610742a08908f91808341b180c02a55160ab6be12748545ee90a5d4c6c9c04ce2cd918a567f4b46e887ad50078f0e5495f2061ec

data/lib/ice_cube/rule.rb

@@ -70,7 +70,7 @@ module IceCube
 
     # Whether this rule requires a full run
     def full_required?
-      !@count.nil? || (!@interval.nil? && @interval > 1)
+      !@count.nil?
     end
 
     # Convenience methods for creating Rules

data/lib/ice_cube/schedule.rb

@@ -145,60 +145,78 @@ module IceCube
     # Get all of the occurrences from the start_time up until a
     # given Time
     def occurrences(closing_time)
-      find_occurrences(start_time, closing_time)
+      enumerate_occurrences(start_time, closing_time).to_a
     end
 
     # All of the occurrences
     def all_occurrences
       require_terminating_rules
-      find_occurrences(start_time)
+      enumerate_occurrences(start_time).to_a
+    end
+    
+    # Emit an enumerator based on the start time
+    def all_occurrences_enumerator
+      enumerate_occurrences(start_time)
     end
 
     # Iterate forever
     def each_occurrence(&block)
-      find_occurrences(start_time, &block)
+      enumerate_occurrences(start_time, &block).to_a
       self
     end
 
     # The next n occurrences after now
     def next_occurrences(num, from = nil)
       from ||= TimeUtil.now(@start_time)
-      find_occurrences(from + 1, nil, num)
+      enumerate_occurrences(from + 1, nil).take(num)
     end
 
     # The next occurrence after now (overridable)
     def next_occurrence(from = nil)
       from ||= TimeUtil.now(@start_time)
-      find_occurrences(from + 1, nil, 1).first
+      enumerate_occurrences(from + 1, nil).next()
     end
 
     # The previous occurrence from a given time
     def previous_occurrence(from)
       return nil if from <= start_time
-      find_occurrences(start_time, from - 1, nil, 1).last
+      enumerate_occurrences(start_time, from - 1).to_a.last
     end
 
     # The previous n occurrences before a given time
     def previous_occurrences(num, from)
       return [] if from <= start_time
-      find_occurrences(start_time, from - 1, nil, num)
+      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)
       require_terminating_rules
       from ||= TimeUtil.now(@start_time)
-      find_occurrences(from)
+      enumerate_occurrences(from).to_a
+    end
+
+    # Returns an enumerator for all remaining occurrences
+    def remaining_occurrences_enumerator(from = nil)
+      from ||= TimeUtil.now(@start_time)
+      enumerate_occurrences(from)
     end
 
     # Occurrences between two times
     def occurrences_between(begin_time, closing_time)
-      find_occurrences(begin_time, closing_time)
+      enumerate_occurrences(begin_time, closing_time).to_a
     end
 
     # Return a boolean indicating if an occurrence falls between two times
     def occurs_between?(begin_time, closing_time)
-      !find_occurrences(begin_time, closing_time, 1).empty?
+      begin 
+        enumerate_occurrences(begin_time, closing_time).next()
+        true
+      rescue StopIteration
+        false
+      end
+
     end
 
     # Return a boolean indicating if an occurrence is occurring between two
@@ -247,6 +265,7 @@ module IceCube
       end
       # Go through each occurrence of the terminating schedule and determine
       # if the other occurs at that time
+      #
       last_time = nil
       terminating_schedule.each_occurrence do |time|
         if closing_time && time > closing_time
@@ -276,7 +295,7 @@ module IceCube
 
     # Get the first n occurrences, or the first occurrence if n is skipped
     def first(n = nil)
-      occurrences = find_occurrences start_time, nil, n || 1
+      occurrences = enumerate_occurrences(start_time).take(n || 1)
       n.nil? ? occurrences.first : occurrences
     end
 
@@ -284,7 +303,7 @@ module IceCube
     # or the final one if no n is given
     def last(n = nil)
       require_terminating_rules
-      occurrences = find_occurrences(start_time, nil, nil, n || 1)
+      occurrences = enumerate_occurrences(start_time).to_a
       n.nil? ? occurrences.last : occurrences[-n..-1]
     end
 
@@ -391,30 +410,27 @@ module IceCube
 
     # Find all of the occurrences for the schedule between opening_time
     # and closing_time
-    def find_occurrences(opening_time, closing_time = nil, limit = nil, tail_limit = nil, &block)
+    def enumerate_occurrences(opening_time, closing_time = nil, &block)
       opening_time = TimeUtil.ensure_time opening_time
       closing_time = TimeUtil.ensure_time closing_time
       opening_time += start_time.subsec - opening_time.subsec rescue 0
       reset
-      answers = []
       opening_time = start_time if opening_time < start_time
       # walk up to the opening time - and off we go
       # If we have rules with counts, we need to walk from the beginning of time,
       # otherwise opening_time
       time = full_required? ? start_time : opening_time
-      loop do
-        res = next_time(time, closing_time)
-        break unless res
-        break if closing_time && res > closing_time
-        if res >= opening_time
-          block_given? ? block.call(res) : (answers << res)
-          answers.shift if tail_limit && answers.length > tail_limit
-          break if limit && answers.length == limit
+      e = Enumerator.new do |yielder|
+        loop do
+          res = next_time(time, closing_time)
+          break unless res
+          break if closing_time && res > closing_time
+          if res >= opening_time
+            yielder.yield (block_given? ? block.call(res) : res)
+          end
+          time = res + 1
         end
-        time = res + 1
       end
-      # and return our answers
-      answers
     end
 
     # Get the next time after (or including) a specific time

data/lib/ice_cube/version.rb

@@ -1,5 +1,5 @@
 module IceCube
 
-  VERSION = '0.11.1'
+  VERSION = '0.11.2'
 
 end

data/spec/spec_helper.rb

@@ -9,6 +9,7 @@ require File.dirname(__FILE__) + '/../lib/ice_cube'
 
 DAY = Time.utc(2010, 3, 1)
 WEDNESDAY = Time.utc(2010, 6, 23, 5, 0, 0)
+
 WORLD_TIME_ZONES = [
   'America/Anchorage',  # -1000 / -0900
   'Europe/London',      # +0000 / +0100
@@ -48,4 +49,5 @@ RSpec.configure do |config|
       end
     end
   end
+
 end

metadata

@@ -1,69 +1,69 @@
 --- !ruby/object:Gem::Specification
 name: ice_cube
 version: !ruby/object:Gem::Version
-  version: 0.11.1
+  version: 0.11.2
 platform: ruby
 authors:
 - John Crepezzi
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-10-28 00:00:00.000000000 Z
+date: 2014-01-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: 2.12.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: 2.12.0
 - !ruby/object:Gem::Dependency
   name: active_support
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: 3.0.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: 3.0.0
 - !ruby/object:Gem::Dependency
   name: tzinfo
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 description: ice_cube is a recurring date library for Ruby.  It allows for quick,
@@ -73,15 +73,14 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- lib/ice_cube.rb
 - lib/ice_cube/builders/hash_builder.rb
 - lib/ice_cube/builders/ical_builder.rb
 - lib/ice_cube/builders/string_builder.rb
 - lib/ice_cube/deprecated.rb
-- lib/ice_cube/enumerator.rb
 - lib/ice_cube/errors/count_exceeded.rb
 - lib/ice_cube/errors/until_exceeded.rb
 - lib/ice_cube/flexible_hash.rb
-- lib/ice_cube/hash_input.rb
 - lib/ice_cube/occurrence.rb
 - lib/ice_cube/rule.rb
 - lib/ice_cube/rules/daily_rule.rb
@@ -93,8 +92,6 @@ files:
 - lib/ice_cube/rules/yearly_rule.rb
 - lib/ice_cube/schedule.rb
 - lib/ice_cube/single_occurrence_rule.rb
-- lib/ice_cube/string_helpers.rb
-- lib/ice_cube/time_step.rb
 - lib/ice_cube/time_util.rb
 - lib/ice_cube/validated_rule.rb
 - lib/ice_cube/validations/count.rb
@@ -117,7 +114,6 @@ files:
 - 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
 homepage: http://seejohnrun.github.com/ice_cube/
 licenses:
@@ -129,20 +125,19 @@ require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: ice-cube
-rubygems_version: 2.0.6
+rubygems_version: 2.2.0
 signing_key: 
 specification_version: 4
 summary: Ruby Date Recurrence Library
 test_files:
 - spec/spec_helper.rb
-has_rdoc: true

data/lib/ice_cube/enumerator.rb

@@ -1,63 +0,0 @@
-module IceCube
-  class Enumerator < ::Enumerator
-
-    def initialize(schedule, from_time, to_time)
-      @schedule  = schedule
-      @from_time = TimeUtil.ensure_time(from_time)
-      @to_time   = TimeUtil.ensure_time(to_time)
-      align_start_time
-      @cursor = @from_time
-    end
-
-    def each
-      while res = self.find_next && @to_time.nil? || res <= @to_time
-        yield Occurrence.new(res, res + schedule.duration)
-      end
-      raise StopIteration
-    end
-
-    def find_next
-      loop do
-        min_time = recurrence_rules.reduce(nil) do |min_time, rule|
-          catch :limit do
-            new_time = rule.next_time(time, schedule, min_time || @to_time)
-            [min_time, new_time].compact.min
-          end
-        end
-        break nil unless min_time
-        @cursor = min_time + 1
-        next if exception_time?(min_time)
-        break min_time
-      end
-    end
-
-    private
-
-    def align_start_time
-      if @from_time <= schedule.start_time || full_required?
-        @from_time = schedule.start_time
-      else
-        @from_time += @schedule.start_time.subsec - @from_time.subsec rescue 0
-      end
-    end
-
-    # Return a boolean indicating if any rule needs to be run from the start of time
-    def full_required?
-      recurrence_rules.any?(&:full_required?) ||
-      exception_rules.any?(&:full_required?)
-    end
-
-    def exception_rules
-      schedule.instance_variable_get(:@all_exception_rules)
-    end
-
-    def recurrence_rules
-      @recurrence_rules ||= if recurrence_rules.empty?
-        [SingleOccurrenceRule.new(schedule.start_time)].concat schedule.instance_variable_get(:@all_recurrence_rules)
-      else
-        schedule.instance_variable_get(:@all_recurrence_rules)
-      end
-    end
-
-  end
-end

data/lib/ice_cube/hash_input.rb

@@ -1,71 +0,0 @@
-module IceCube
-  class HashInput
-
-    class Mash
-      def initialize(hash)
-        @hash = hash
-      end
-
-      # Fetch values indifferently by symbol or string key without symbolizing
-      # arbitrary string input
-      #
-      def [](key)
-        @hash.fetch(key) do |key|
-          str_key = key.to_s
-          @hash.each_pair.detect do |sym_key, value|
-            return value if sym_key.to_s == str_key
-          end
-        end
-      end
-    end
-
-    def initialize(hash)
-      @input = Mash.new(hash)
-    end
-
-    def [](key)
-      @input[key]
-    end
-
-    def to_rule
-      return nil unless rule_class
-      rule = rule_class.new(interval, week_start)
-      rule.until(limit_time) if limit_time
-      rule.count(limit_count) if limit_count
-      validations.each do |validation, args|
-        rule.send(validation, *args)
-      end
-    end
-
-    def rule_class
-      return @rule_class if @rule_class
-      match = @input[:rule_type].match(/::(\w+Rule)$/)
-      @rule_class = IceCube.const_get(match[1]) if match
-    end
-
-    def interval
-      @input[:interval] || 1
-    end
-
-    def week_start
-      @input[:week_start] || :sunday
-    end
-
-    def limit_time
-      @limit_time ||= TimeUtil.deserialize_time(@input[:until])
-    end
-
-    def limit_count
-      @input[:count]
-    end
-
-    def validations
-      input_validations = Mash.new(@input[:validations] || {})
-      ValidatedRule::VALIDATION_ORDER.each_with_object({}) do |key, output_validations|
-        args = input_validations[key]
-        output_validations[key] = Array(args) if args
-      end
-    end
-
-  end
-end

data/lib/ice_cube/string_helpers.rb

@@ -1,10 +0,0 @@
-module IceCube
-  module StringHelpers
-
-    module_function
-
-    def nice_number(number)
-    end
-
-  end
-end

data/lib/ice_cube/time_step.rb

@@ -1,30 +0,0 @@
-module IceCube
-  class TimeStep
-    SECS   = 1
-    MINS   = 60
-    HOURS  = MINS * 60
-    DAYS   = HOURS * 24
-    WEEKS  = DAYS * 7
-    MONTHS = {
-      1  => [ 28,  29,  30,  31].map { |m| m * DAYS },
-      2  => [ 59,  60,  61,  62].map { |m| m * DAYS },
-      3  => [ 89,  90,  91,  92].map { |m| m * DAYS },
-      4  => [120, 121, 122, 123].map { |m| m * DAYS },
-      5  => [150, 151, 152, 153].map { |m| m * DAYS },
-      6  => [181, 182, 183, 184].map { |m| m * DAYS },
-      7  => [212, 213, 214, 215].map { |m| m * DAYS },
-      8  => [242, 243, 244, 245].map { |m| m * DAYS },
-      9  => [273, 274, 275, 276].map { |m| m * DAYS },
-      10 => [303, 304, 305, 306].map { |m| m * DAYS },
-      11 => [334, 335, 336, 337].map { |m| m * DAYS },
-      12 => [365, 366]          .map { |m| m * DAYS }
-    }
-    YEARS = [365, 366]
-
-    def next(base, validations)
-    end
-
-    def prev(base, validations)
-    end
-  end
-end