ice_cube 0.12.0 → 0.12.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: f8d575d65663825eb9be2a82f9e931537009d485
-  data.tar.gz: 2e292c2f229a8a7b7aaaf8f8dcaf009412741745
+  metadata.gz: 2ac4ca18d263a59f5e9499349ce536e63d8ec59f
+  data.tar.gz: 3d2d4ed0d0cf8c0632b870b19e59ac964d64f93a
 SHA512:
-  metadata.gz: 98e4ffa4ddc22fb26da6eb632203e389361149216ad62193f64c773fe1a68da07dff80ab3f0470cbc1d0dabfc049780b86eb4f270469b2e47539e46016709c1e
-  data.tar.gz: 2882dc6f6af47db013a1ee079c2fc06ecf254274b0d39b00f24bc6a8e72021b4935e27463a65ab7c01740180bcab4236bfc15507825b3db910b4bf16f5ab6ce3
+  metadata.gz: d6715a91023b1c7c0fa7f1bdc59776c0182b3742bd37a6fc28fd14e0bd15ee5e4d0e2c1014c03c43c04cfaaee8b73ed19d5a7557b815f949fe72d044fb9a61bb
+  data.tar.gz: f2941f23021a8062fc35cc3f3dd1bd2010903645d723aa9bf7ba3b50a4c240ef88757539c6317b4cab967f7d357a5ccf915d84c963659a97a54d47f5c05efc53

data/lib/ice_cube.rb

@@ -57,7 +57,6 @@ module IceCube
     autoload :DayOfWeek, 'ice_cube/validations/day_of_week'
     autoload :Day, 'ice_cube/validations/day'
     autoload :DayOfYear, 'ice_cube/validations/day_of_year'
-
   end
 
   # Define some useful constants

data/lib/ice_cube/deprecated.rb

@@ -1,38 +1,36 @@
 module IceCube
-	module Deprecated
+  module Deprecated
 
-		# Define a deprecated alias for a method
-		# @param [Symbol] name - name of method to define
-		# @param [Symbol] replacement - name of method to replace (alias)
-		def deprecated_alias(name, replacement)
-			# Create a wrapped version
-			define_method(name) do |*args, &block|
-				warn "IceCube: ##{name} deprecated (please use ##{replacement})"
-				send replacement, *args, &block
-			end
-		end
+    # Define a deprecated alias for a method
+    # @param [Symbol] name - name of method to define
+    # @param [Symbol] replacement - name of method to replace (alias)
+    def deprecated_alias(name, replacement)
+      # Create a wrapped version
+      define_method(name) do |*args, &block|
+        warn "IceCube: #{self.class}##{name} is deprecated, please use ##{replacement} at: #{ caller[0] }"
+        send replacement, *args, &block
+      end
+    end
 
-		# Deprecate a defined method
-		# @param [Symbol] name - name of deprecated method
-		# @param [Symbol] replacement - name of the desired replacement
-		def deprecated(name, replacement)
-			# Replace old method
-			old_name = :"#{name}_without_deprecation"
-			alias_method old_name, name
-			# And replace it with a wrapped version
-			define_method(name) do |*args, &block|
-				warn "IceCube: ##{name} deprecated (please use ##{replacement})"
-				send old_name, *args, &block
-			end
-		end
+    # Deprecate a defined method
+    # @param [Symbol] name - name of deprecated method
+    # @param [Symbol] replacement - name of the desired replacement
+    def deprecated(name, replacement)
+      # Replace old method
+      old_name = :"#{name}_without_deprecation"
+      alias_method old_name, name
+      # And replace it with a wrapped version
+      define_method(name) do |*args, &block|
+        warn "IceCube: #{self.class}##{name} is deprecated, please use ##{replacement} at: #{ caller[0] }"
+        send old_name, *args, &block
+      end
+    end
 
     def self.schedule_options(schedule, options)
       if options[:start_date_override]
-        warn "IceCube: :start_date_override option deprecated. " \
-          "(please use a block { |s| s.start_time = override })"
+        warn "IceCube: :start_date_override option is deprecated, please use a block {|s| s.start_time = override }. at: #{ caller[0] }"
         schedule.start_time = options[:start_date_override]
       end
     end
-
-	end
+  end
 end

data/lib/ice_cube/parsers/hash_parser.rb

@@ -26,13 +26,13 @@ module IceCube
       data = IceCube::FlexibleHash.new(hash.dup)
 
       if (start_date = data.delete(:start_date))
-				warn "IceCube: :start_date deprecated. (please use :start_time)"
+        warn "IceCube: :start_date is deprecated, please use :start_time at: #{ caller[0] }"
         data[:start_time] = start_date
       end
 
       {:rdates => :rtimes, :exdates => :extimes}.each do |old_key, new_key|
         if (times = data.delete(old_key))
-          warn "IceCube: :#{old_key} deprecated. (please use :#{new_key})"
+          warn "IceCube: :#{old_key} is deprecated, please use :#{new_key} at: #{ caller[0] }"
           (data[new_key] ||= []).concat times
         end
       end
@@ -59,7 +59,7 @@ module IceCube
 
     def apply_exrules(schedule, data)
       return unless data[:exrules]
-      warn "IceCube: :exrules deprecated. (This will be going away)"
+      warn "IceCube: :exrules is deprecated, and will be removed in a future release. at: #{ caller[0] }"
       data[:exrules].each do |h|
         schedule.exrule(IceCube::Rule.from_hash(h))
       end

data/lib/ice_cube/parsers/yaml_parser.rb

@@ -1,3 +1,5 @@
+require 'yaml'
+
 module IceCube
   class YamlParser < HashParser
 
@@ -7,15 +9,11 @@ module IceCube
 
     def initialize(yaml)
       @hash = YAML::load(yaml)
-      yaml.match(SERIALIZED_START) do |match|
+      yaml.match SERIALIZED_START do |match|
         start_time = hash[:start_time] || hash[:start_date]
-        hash = FlexibleHash.new(@hash)
         TimeUtil.restore_deserialized_offset start_time, match[:tz]
       end
     end
 
-    private
-
-
   end
 end

data/lib/ice_cube/schedule.rb

@@ -380,11 +380,13 @@ module IceCube
     end
 
     def self.dump(schedule)
+      return schedule if schedule.nil? || schedule == ""
       schedule.to_yaml
     end
 
     def self.load(yaml)
-      from_yaml(yaml) unless yaml.nil? || yaml.empty?
+      return yaml if yaml.nil? || yaml == ""
+      from_yaml(yaml)
     end
 
     private

data/lib/ice_cube/time_util.rb

@@ -1,4 +1,5 @@
 require 'date'
+require 'time'
 
 module IceCube
   module TimeUtil
@@ -42,7 +43,7 @@ module IceCube
     def self.ensure_time(time, date_eod = false)
       case time
       when DateTime
-        warn "IceCube: DateTime support is deprecated (please use Time)"
+        warn "IceCube: DateTime support is deprecated (please use Time) at: #{ caller[2] }"
         Time.local(time.year, time.month, time.day, time.hour, time.min, time.sec)
       when Date
         date_eod ? end_of_date(time) : time.to_time
@@ -69,13 +70,16 @@ module IceCube
       end
     end
 
-    # Deserialize a time serialized with serialize_time
+    # Deserialize a time serialized with serialize_time or in ISO8601 string format
     def self.deserialize_time(time_or_hash)
-      if time_or_hash.is_a?(Time)
+      case time_or_hash
+      when Time
         time_or_hash
-      elsif time_or_hash.is_a?(Hash)
+      when Hash
         hash = FlexibleHash.new(time_or_hash)
         hash[:time].in_time_zone(hash[:zone])
+      when String
+        Time.parse(time_or_hash)
       end
     end
 
@@ -87,7 +91,7 @@ module IceCube
     def self.restore_deserialized_offset(time, orig_offset_str)
       return time if time.respond_to?(:time_zone) ||
                      time.getlocal(orig_offset_str).utc_offset == time.utc_offset
-      warn 'IceCube: parsed Time from nonlocal TZ. Use ActiveSupport to fix DST'
+      warn "IceCube: parsed Time from nonlocal TZ. Use ActiveSupport to fix DST at: #{ caller[0] }"
       time.localtime(orig_offset_str)
     end
 

data/lib/ice_cube/validated_rule.rb

@@ -106,6 +106,11 @@ module IceCube
     end
 
     private
+    def normalized_interval(interval)
+      int = interval.to_i
+      raise ArgumentError, "'#{interval}' is not a valid input for interval. Please pass an integer." unless int > 0
+      int
+    end
 
     def finds_acceptable_time?
       validation_names.all? do |type|

data/lib/ice_cube/validations/daily_interval.rb

@@ -4,8 +4,8 @@ module IceCube
 
     # Add a new interval validation
     def interval(interval)
-      @interval = interval
-      replace_validations_for(:interval, [Validation.new(interval)])
+      @interval = normalized_interval(interval)
+      replace_validations_for(:interval, [Validation.new(@interval)])
       clobber_base_validations(:wday, :day)
       self
     end

data/lib/ice_cube/validations/hourly_interval.rb

@@ -3,8 +3,8 @@ module IceCube
   module Validations::HourlyInterval
 
     def interval(interval)
-      @interval = interval
-      replace_validations_for(:interval, [Validation.new(interval)])
+      @interval = normalized_interval(interval)
+      replace_validations_for(:interval, [Validation.new(@interval)])
       clobber_base_validations(:hour)
       self
     end

data/lib/ice_cube/validations/minutely_interval.rb

@@ -3,8 +3,8 @@ module IceCube
   module Validations::MinutelyInterval
 
     def interval(interval)
-      @interval = interval
-      replace_validations_for(:interval, [Validation.new(interval)])
+      @interval = normalized_interval(interval)
+      replace_validations_for(:interval, [Validation.new(@interval)])
       clobber_base_validations(:min)
       self
     end

data/lib/ice_cube/validations/monthly_interval.rb

@@ -3,8 +3,8 @@ module IceCube
   module Validations::MonthlyInterval
 
     def interval(interval)
-      @interval = interval
-      replace_validations_for(:interval, [Validation.new(interval)])
+      @interval = normalized_interval(interval)
+      replace_validations_for(:interval, [Validation.new(@interval)])
       clobber_base_validations(:month)
       self
     end

data/lib/ice_cube/validations/secondly_interval.rb

@@ -3,8 +3,8 @@ module IceCube
   module Validations::SecondlyInterval
 
     def interval(interval)
-      @interval = interval
-      replace_validations_for(:interval, [Validation.new(interval)])
+      @interval = normalized_interval(interval)
+      replace_validations_for(:interval, [Validation.new(@interval)])
       clobber_base_validations(:sec)
       self
     end

data/lib/ice_cube/validations/weekly_interval.rb

@@ -5,9 +5,9 @@ module IceCube
   module Validations::WeeklyInterval
 
     def interval(interval, week_start = :sunday)
-      @interval = interval
+      @interval = normalized_interval(interval)
       @week_start = TimeUtil.wday_to_sym(week_start)
-      replace_validations_for(:interval, [Validation.new(interval, week_start)])
+      replace_validations_for(:interval, [Validation.new(@interval, week_start)])
       clobber_base_validations(:day)
       self
     end

data/lib/ice_cube/validations/yearly_interval.rb

@@ -3,9 +3,10 @@ module IceCube
   module Validations::YearlyInterval
 
     def interval(interval)
-      @interval = interval
-      replace_validations_for(:interval, [Validation.new(interval)])
+      @interval = normalized_interval(interval)
+      replace_validations_for(:interval, [Validation.new(@interval)])
       clobber_base_validations(:year)
+      self
     end
 
     class Validation

data/lib/ice_cube/version.rb

@@ -1,5 +1,5 @@
 module IceCube
 
-  VERSION = '0.12.0'
+  VERSION = '0.12.1'
 
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ice_cube
 version: !ruby/object:Gem::Version
-  version: 0.12.0
+  version: 0.12.1
 platform: ruby
 authors:
 - John Crepezzi
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-04-06 00:00:00.000000000 Z
+date: 2014-07-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -39,7 +39,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: 2.12.0
 - !ruby/object:Gem::Dependency
-  name: active_support
+  name: activesupport
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -78,12 +78,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/formatters/string.rb
-- lib/ice_cube/hash_input.rb
 - lib/ice_cube/occurrence.rb
 - lib/ice_cube/parsers/hash_parser.rb
 - lib/ice_cube/parsers/yaml_parser.rb
@@ -97,8 +94,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
@@ -148,4 +143,3 @@ 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/formatters/string.rb

@@ -1,155 +0,0 @@
-class IceCube::StringBuilder
-
-  format :day do |entries|
-    case entries = entries.sort
-    when [0, 6]          then 'on Weekends'
-    when [1, 2, 3, 4, 5] then 'on Weekdays'
-    else
-      "on " << build(:sentence, build(:daynames, entries))
-    end
-  end
-
-  format :dayname do |number|
-    Date::DAYNAMES[number]
-  end
-
-  format :daynames do |entries|
-    entries.map { |wday| build(:dayname, wday) + "s" }
-  end
-
-  format :monthnames do |entries|
-    entries.map { |m| Date::MONTHNAMES[m] }
-  end
-
-  format :count do |number|
-    times = number == 1 ? "time" : "times"
-    "#{number} #{times}"
-  end
-
-  format :day_of_month do |entries|
-    numbered = build(:sentence, build(:ordinals, entries))
-    days = entries.size == 1 ? "day" : "days"
-    "on the #{numbered} #{days} of the month"
-  end
-
-  format :day_of_week do |entries|
-    numbered_weekdays = build(:daynames_of_week, entries).join(" and ")
-    "on the #{numbered_weekdays}"
-  end
-
-  format :daynames_of_week do |entries|
-    entries.map do |occurrence, wday|
-      numbered = build(:ordinal, occurrence)
-      weekday  = build(:dayname, wday)
-      "#{numbered} #{weekday}"
-    end
-  end
-
-  format :day_of_year do |entries|
-    numbered = build(:sentence, build(:ordinals, entries))
-    days = entries.size == 1 ? "day" : "days"
-    "on the #{numbered} #{days} of the year"
-  end
-
-  format :hour_of_day do |entries|
-    numbered = build(:sentence, build(:ordinals, entries))
-    hours = entries.size == 1 ? "hour" : "hours"
-    "on the #{numbered} #{hours} of the day"
-  end
-
-  format :minute_of_hour do |entries|
-    numbered = build(:sentence, build(:ordinals, entries))
-    minutes = entries.size == 1 ? "minute" : "minutes"
-    "on the #{numbered} #{minutes} of the hour"
-  end
-
-  format :month_of_year do |entries|
-    "in " << build(:sentence, build(:monthnames, entries))
-  end
-
-  format :second_of_minute do |entries|
-    numbered = build(:sentence, build(:ordinals, entries))
-    seconds = entries.size == 1 ? "second" : "seconds"
-    "on the #{numbered} #{seconds} of the minute"
-  end
-
-  format :time do |time|
-    time.strftime(IceCube.to_s_time_format)
-  end
-
-  format :until do |time|
-    "until " << build(:time, time)
-  end
-
-  format :sentence do |entries|
-    case entries.length
-    when 0 then ''
-    when 1 then entries[0].to_s
-    when 2 then "#{entries[0]} and #{entries[1]}"
-    else "#{entries[0...-1].join(', ')}, and #{entries[-1]}"
-    end
-  end
-
-  format :ordinals do |entries|
-    entries = entries.sort
-    entries.rotate! while entries[0] < 0 if entries.last > 0
-    entries.map { |number| build(:ordinal, number) }
-  end
-
-  format :ordinal do |number|
-    next "last" if number == -1
-    suffix = SPECIAL_SUFFIX[number] || NUMBER_SUFFIX[number.abs % 10]
-    if number < -1
-      number.abs.to_s << suffix << " to last"
-    else
-      number.to_s << suffix
-    end
-  end
-
-  format :daily_interval do |i|
-    i == 1 ? "Daily" : "Every #{i} days"
-  end
-
-  format :hourly_interval do |i|
-    i == 1 ? "Hourly" : "Every #{i} hours"
-  end
-
-  format :minutely_interval do |i|
-    i == 1 ? "Minutely" : "Every #{i} minutes"
-  end
-
-  format :monthly_interval do |i|
-    i == 1 ? "Monthly" : "Every #{i} months"
-  end
-
-  format :secondly_interval do |i|
-    i == 1 ? "Secondly" : "Every #{i} seconds"
-  end
-
-  format :weekly_interval do |i|
-    i == 1 ? "Weekly" : "Every #{i} weeks"
-  end
-
-  format :yearly_interval do |i|
-    i == 1 ? "Yearly" : "Every #{i} years"
-  end
-
-  format :exrule do |rule|
-    "not #{rule}"
-  end
-
-  format :extime do |time|
-    "not on #{build(:time, time)}"
-  end
-
-  format :schedule do |s|
-    times = s.recurrence_times_with_start_time - s.extimes
-    pieces = []
-    pieces.concat times.uniq.sort.map     { |t| build(:time, t) }
-    pieces.concat s.rrules.map            { |t| t.to_s }
-    pieces.concat s.exrules.map           { |t| build(:exrule, t) }
-    pieces.concat s.extimes.uniq.sort.map { |t| build(:extime, t) }
-    pieces.join(' / ')
-  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