ice_cube 0.13.3 → 0.14.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 1cd6fca3c4607f135ad7b4628cc08c627cb437c9
-  data.tar.gz: 5018a7cf1feb4910571ac5695dcb3b051cad71d7
+  metadata.gz: 5882c908ac2e56578482bda2b172c91edf4a55df
+  data.tar.gz: f4ec09ff6db92240f0d3ed669ca6b8be495d2784
 SHA512:
-  metadata.gz: 9c5446069c5e5c45819e7247114661aec92cdb0dff6a5dd2a8259aa12f7423df9bdc9dae671d9fad21180d478528ce08a846762742154f334f8b2791af34d85b
-  data.tar.gz: 7bbb442e21950216fb329699446ab0466848c97e50d4765623a5888d6c66f5e601d6166932df62d55e4cfe14c27cef759fafa835f7761ba31f82bb6b16011327
+  metadata.gz: 4e94d7e1c2a4a4745957bbe13bda1d05211af20bb04618852aad3d114c7ff24632a0588012d7ef5b6aeda3e268d93f060e98c5ad8cddb55f330d157758328e6a
+  data.tar.gz: 5384b4f0700a8c185b3bc88d628ed82825f3115a71331cff0e0689f1446422277e1443f96a90c3c1d18e469ae1784e89c095d5f84041a5004eca66da39bf240b

data/lib/ice_cube/parsers/ical_parser.rb

@@ -16,7 +16,8 @@ module IceCube
         when 'DURATION'
           data[:duration] # FIXME
         when 'RRULE'
-          data[:rrules] = [rule_from_ical(value)]
+          data[:rrules] ||= []
+          data[:rrules] += [rule_from_ical(value)]
         end
       end
       Schedule.from_hash data

data/lib/ice_cube/schedule.rb

@@ -166,15 +166,15 @@ module IceCube
     end
 
     # The next n occurrences after now
-    def next_occurrences(num, from = nil)
+    def next_occurrences(num, from = nil, options = {})
       from = TimeUtil.match_zone(from, start_time) || TimeUtil.now(start_time)
-      enumerate_occurrences(from + 1, nil).take(num)
+      enumerate_occurrences(from + 1, nil, options).take(num)
     end
 
     # The next occurrence after now (overridable)
-    def next_occurrence(from = nil)
+    def next_occurrence(from = nil, options = {})
       from = TimeUtil.match_zone(from, start_time) || TimeUtil.now(start_time)
-      enumerate_occurrences(from + 1, nil).next
+      enumerate_occurrences(from + 1, nil, options).next
     rescue StopIteration
       nil
     end
@@ -195,26 +195,26 @@ module IceCube
     end
 
     # The remaining occurrences (same requirements as all_occurrences)
-    def remaining_occurrences(from = nil)
+    def remaining_occurrences(from = nil, options = {})
       require_terminating_rules
       from ||= TimeUtil.now(@start_time)
-      enumerate_occurrences(from).to_a
+      enumerate_occurrences(from, nil, options).to_a
     end
 
     # Returns an enumerator for all remaining occurrences
-    def remaining_occurrences_enumerator(from = nil)
+    def remaining_occurrences_enumerator(from = nil, options = {})
       from ||= TimeUtil.now(@start_time)
-      enumerate_occurrences(from)
+      enumerate_occurrences(from, nil, options)
     end
 
     # Occurrences between two times
-    def occurrences_between(begin_time, closing_time)
-      enumerate_occurrences(begin_time, closing_time).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)
-      enumerate_occurrences(begin_time, closing_time).next
+    def occurs_between?(begin_time, closing_time, options = {})
+      enumerate_occurrences(begin_time, closing_time, options).next
       true
     rescue StopIteration
       false
@@ -226,9 +226,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)
-      opening_time = opening_time - duration
-      closing_time = closing_time - 1 if duration > 0
-      occurs_between?(opening_time, closing_time)
+      occurs_between?(opening_time, closing_time, :spans => true)
     end
 
     # Return a boolean indicating if an occurrence falls on a certain date
@@ -407,25 +405,30 @@ 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, &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 = options[:spans] == true && duration != 0
       Enumerator.new do |yielder|
         reset
-        t1 = full_required? ? start_time : realign(opening_time)
+        t1 = full_required? ? start_time : realign((spans ? opening_time - duration : opening_time))
         loop do
           break unless (t0 = next_time(t1, closing_time))
           break if closing_time && t0 > closing_time
-          yielder << (block_given? ? block.call(t0) : t0) if t0 >= opening_time
+          if (spans ? (t0.end_time > opening_time) : (t0 >= opening_time))
+            yielder << (block_given? ? block.call(t0) : t0)
+          end
           break unless (t1 = next_time(t0 + 1, closing_time))
           break if closing_time && t1 > closing_time
           if TimeUtil.same_clock?(t0, t1) && recurrence_rules.any?(&:dst_adjust?)
             wind_back_dst
             next (t1 += 1)
           end
-          yielder << (block_given? ? block.call(t1) : t1) if t1 >= opening_time
+          if (spans ? (t1.end_time > opening_time) : (t1 >= opening_time))
+            yielder << (block_given? ? block.call(t1) : t1)
+          end
           next (t1 += 1)
         end
       end

data/lib/ice_cube/version.rb

@@ -1,5 +1,5 @@
 module IceCube
 
-  VERSION = '0.13.3'
+  VERSION = '0.14.0'
 
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ice_cube
 version: !ruby/object:Gem::Version
-  version: 0.13.3
+  version: 0.14.0
 platform: ruby
 authors:
 - John Crepezzi
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-01-31 00:00:00.000000000 Z
+date: 2016-02-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -95,11 +95,9 @@ files:
 - 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/i18n.rb
 - lib/ice_cube/null_i18n.rb
 - lib/ice_cube/occurrence.rb
@@ -116,7 +114,6 @@ files:
 - lib/ice_cube/rules/yearly_rule.rb
 - lib/ice_cube/schedule.rb
 - lib/ice_cube/single_occurrence_rule.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
@@ -128,7 +125,6 @@ files:
 - lib/ice_cube/validations/fixed_value.rb
 - lib/ice_cube/validations/hour_of_day.rb
 - lib/ice_cube/validations/hourly_interval.rb
-- lib/ice_cube/validations/interval.rb
 - lib/ice_cube/validations/lock.rb
 - lib/ice_cube/validations/minute_of_hour.rb
 - lib/ice_cube/validations/minutely_interval.rb
@@ -141,7 +137,6 @@ files:
 - lib/ice_cube/validations/weekly_interval.rb
 - lib/ice_cube/validations/yearly_interval.rb
 - lib/ice_cube/version.rb
-- spec/manual_regression.rb
 - spec/spec_helper.rb
 homepage: http://seejohnrun.github.com/ice_cube/
 licenses:
@@ -163,10 +158,9 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: ice-cube
-rubygems_version: 2.2.2
+rubygems_version: 2.4.5
 signing_key: 
 specification_version: 4
 summary: Ruby Date Recurrence Library
 test_files:
-- spec/manual_regression.rb
 - spec/spec_helper.rb

data/lib/ice_cube/enumerator.rb

@@ -1,69 +0,0 @@
-module IceCube
-  class Enumerator < ::Enumerator
-
-    def initialize(schedule, opening_time, closing_time)
-      @schedule = schedule
-      @opening_time = TimeUtil.ensure_time(opening_time)
-      @closing_time = TimeUtil.ensure_time(closing_time)
-      align_opening_time
-      @cursor = @opening_time
-    end
-
-    def each
-      return to_enum unless block_given?
-      while res = self.next && @closing_time.nil? || res <= @closing_time
-        yield Occurrence.new(res, res + schedule.duration)
-      end
-      raise StopIteration
-    end
-
-    def next
-      t1 = full_required? ? schedule.start_time : opening_time
-      Enumerator.new do |yielder|
-        loop do
-          t1.tap { |t| puts "LDA #{t}" + " #{File.basename(__FILE__)}:#{__LINE__}" }
-          break unless (t0 = next_time(t1, closing_time).tap { |t| puts "LDB #{t}" + " #{File.basename(__FILE__)}:#{__LINE__}" })
-          break if closing_time && t0 > closing_time
-          yielder << (block_given? ? block.call(t0) : t0) if t0 >= opening_time
-          break unless (t1 = next_time(t0 + 1, closing_time))
-          break if closing_time && t1 > closing_time
-          if TimeUtil.same_clock?(t0, t1) && recurrence_rules.any?(&:dst_adjust?)
-            wind_back_dst
-            next (t1 += 1)
-          end
-          yielder << (block_given? ? block.call(t1) : t1) if t1 >= opening_time
-          next (t1 += 1)
-        end
-      end
-    end
-
-    private
-
-    def align_start_time
-      if @opening_time <= schedule.start_time || full_required?
-        @opening_time = schedule.start_time
-      else
-        @opening_time += @schedule.start_time.subsec - @opening_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/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

data/lib/ice_cube/validations/interval.rb

@@ -1,19 +0,0 @@
-module IceCube
-  class Validations::Interval
-
-    def initialize(interval)
-      self.interval = interval
-    end
-
-    def interval=(number)
-      i = number.to_i
-      raise unless i > 0
-      @interval = i
-    rescue
-      raise ArgumentError.new "#{number.inspect} is not a valid input for interval, expecting positive integer"
-    end
-
-    attr_reader :interval
-
-  end
-end

data/spec/manual_regression.rb

@@ -1,50 +0,0 @@
-require 'rbkit'
-Rbkit.start_profiling
-require 'ice_cube'
-
-module Kwip
-  def self.womp
-    threads = []
-    start = Time.new(2104,1,1)
-    daily = IceCube::Rule.daily.hour_of_day(6, 12, 18, 23)
-
-    # ObjectSpace.dump_all(output: File.open('heap1.json','w'))
-    3.times do
-    threads << Thread.new do
-    schedule = IceCube::Schedule.new(start)
-    schedule.add_recurrence_rule(daily)
-    schedule.next_occurrence
-    end
-    end
-
-    threads.each &:join
-    threads.clear
-    nil
-  end
-end
-
-# GC::Tracer.start_logging('gc.log') do
-#     GC.disable
-  10000.times do
-    Kwip.womp
-    Kwip.womp
-    Kwip.womp
-  end
-    # GC.enable
-    # GC.start
-
-    # str = 'asdf'
-    # str = nil
-    # GC.start
-# end
-
-# ObjectSpace.each_object do |o|
-#   if o.is_a?(IceCube::Occurrence) || o.is_a?(IceCube::Schedule) || o.is_a?(IceCube::Rule)
-#     puts "#{o.object_id} => #{o.class} (#{ObjectSpace.memsize_of(o)})"
-#     # puts ObjectSpace.allocation_sourcefile(o), #=> "example.rb"
-#     #   ObjectSpace.allocation_sourceline(o), #=> 6
-#     #   ObjectSpace.allocation_generation(o), #=> 1
-#     #   ObjectSpace.allocation_class_path(o), #=> "MyApp"
-#     #   ObjectSpace.allocation_method_id(o)  #=> :perform
-#   end
-# end