ice_cube_chosko 0.1.0

data/lib/ice_cube.rb

@@ -0,0 +1,92 @@
+require 'date'
+require 'ice_cube/deprecated'
+require 'ice_cube/i18n'
+
+IceCube::I18n.detect_backend!
+
+module IceCube
+
+  autoload :VERSION, 'ice_cube/version'
+
+  autoload :TimeUtil, 'ice_cube/time_util'
+  autoload :FlexibleHash, 'ice_cube/flexible_hash'
+
+  autoload :Rule, 'ice_cube/rule'
+  autoload :Schedule, 'ice_cube/schedule'
+  autoload :Occurrence, 'ice_cube/occurrence'
+
+  autoload :IcalBuilder, 'ice_cube/builders/ical_builder'
+  autoload :HashBuilder, 'ice_cube/builders/hash_builder'
+  autoload :StringBuilder, 'ice_cube/builders/string_builder'
+
+  autoload :HashParser, 'ice_cube/parsers/hash_parser'
+  autoload :YamlParser, 'ice_cube/parsers/yaml_parser'
+  autoload :IcalParser, 'ice_cube/parsers/ical_parser'
+
+  autoload :CountExceeded, 'ice_cube/errors/count_exceeded'
+  autoload :UntilExceeded, 'ice_cube/errors/until_exceeded'
+
+  autoload :ValidatedRule, 'ice_cube/validated_rule'
+  autoload :SingleOccurrenceRule, 'ice_cube/single_occurrence_rule'
+
+  autoload :SecondlyRule, 'ice_cube/rules/secondly_rule'
+  autoload :MinutelyRule, 'ice_cube/rules/minutely_rule'
+  autoload :HourlyRule, 'ice_cube/rules/hourly_rule'
+  autoload :DailyRule, 'ice_cube/rules/daily_rule'
+  autoload :WeeklyRule, 'ice_cube/rules/weekly_rule'
+  autoload :MonthlyRule, 'ice_cube/rules/monthly_rule'
+  autoload :YearlyRule, 'ice_cube/rules/yearly_rule'
+
+  module Validations
+    autoload :FixedValue, 'ice_cube/validations/fixed_value'
+    autoload :ScheduleLock, 'ice_cube/validations/schedule_lock'
+
+    autoload :Count, 'ice_cube/validations/count'
+    autoload :Until, 'ice_cube/validations/until'
+
+    autoload :SecondlyInterval, 'ice_cube/validations/secondly_interval'
+    autoload :MinutelyInterval, 'ice_cube/validations/minutely_interval'
+    autoload :DailyInterval, 'ice_cube/validations/daily_interval'
+    autoload :WeeklyInterval, 'ice_cube/validations/weekly_interval'
+    autoload :MonthlyInterval, 'ice_cube/validations/monthly_interval'
+    autoload :YearlyInterval, 'ice_cube/validations/yearly_interval'
+    autoload :HourlyInterval, 'ice_cube/validations/hourly_interval'
+
+    autoload :HourOfDay, 'ice_cube/validations/hour_of_day'
+    autoload :MonthOfYear, 'ice_cube/validations/month_of_year'
+    autoload :MinuteOfHour, 'ice_cube/validations/minute_of_hour'
+    autoload :SecondOfMinute, 'ice_cube/validations/second_of_minute'
+    autoload :DayOfMonth, 'ice_cube/validations/day_of_month'
+    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
+  ONE_SECOND = 1
+  ONE_MINUTE = ONE_SECOND * 60
+  ONE_HOUR =   ONE_MINUTE * 60
+  ONE_DAY =    ONE_HOUR   * 24
+  ONE_WEEK =   ONE_DAY    * 7
+
+  # Defines the format used by IceCube when printing out Schedule#to_s.
+  # Defaults to '%B %e, %Y'
+  def self.to_s_time_format
+    IceCube::I18n.t("ice_cube.date.formats.default")
+  end
+
+  # Sets the format used by IceCube when printing out Schedule#to_s.
+  def self.to_s_time_format=(format)
+    @to_s_time_format = format
+  end
+
+  # Retain backwards compatibility for schedules exported from older versions
+  # This represents the version number, 11 = 0.11, 1.0 will be 100
+  def self.compatibility
+    @compatibility ||= IceCube::VERSION.scan(/\d+/)[0..1].join.to_i
+  end
+
+  def self.compatibility=(version)
+    @compatibility = version
+  end
+end

data/lib/ice_cube/builders/hash_builder.rb

@@ -0,0 +1,27 @@
+module IceCube
+
+  class HashBuilder
+
+    def initialize(rule = nil)
+      @hash = { :validations => {}, :rule_type => rule.class.name }
+    end
+
+    def validations
+      @hash[:validations]
+    end
+
+    def []=(key, value)
+      @hash[key] = value
+    end
+
+    def validations_array(type)
+      validations[type] ||= []
+    end
+
+    def to_hash
+      @hash
+    end
+
+  end
+
+end

data/lib/ice_cube/builders/ical_builder.rb

@@ -0,0 +1,59 @@
+module IceCube
+
+  class IcalBuilder
+
+    ICAL_DAYS = ['SU', 'MO', 'TU', 'WE', 'TH', 'FR', 'SA']
+
+    def initialize
+      @hash = {}
+    end
+
+    def self.fixnum_to_ical_day(num)
+      ICAL_DAYS[num]
+    end
+
+    def [](key)
+      @hash[key] ||= []
+    end
+
+    # Build for a single rule entry
+    def to_s
+      arr = []
+      if freq = @hash.delete('FREQ')
+        arr << "FREQ=#{freq.join(',')}"
+      end
+      arr.concat(@hash.map do |key, value|
+        if value.is_a?(Array)
+          "#{key}=#{value.join(',')}"
+        end
+      end.compact)
+      arr.join(';')
+    end
+
+    def self.ical_utc_format(time)
+      time = time.dup.utc
+      IceCube::I18n.l(time, format: '%Y%m%dT%H%M%SZ') # utc time
+    end
+
+    def self.ical_format(time, force_utc)
+      time = time.dup.utc if force_utc
+      if time.utc?
+        ":#{IceCube::I18n.l(time, format: '%Y%m%dT%H%M%SZ')}" # utc time
+      else
+        ";TZID=#{IceCube::I18n.l(time, format: '%Z:%Y%m%dT%H%M%S')}" # local time specified
+      end
+    end
+
+    def self.ical_duration(duration)
+      hours = duration / 3600; duration %= 3600
+      minutes = duration / 60; duration %= 60
+      repr = ''
+      repr << "#{hours}H" if hours > 0
+      repr << "#{minutes}M" if minutes > 0
+      repr << "#{duration}S" if duration > 0
+      "PT#{repr}"
+    end
+
+  end
+
+end

data/lib/ice_cube/builders/string_builder.rb

@@ -0,0 +1,76 @@
+module IceCube
+
+  class StringBuilder
+
+    attr_writer :base
+
+    def initialize
+      @types = {}
+    end
+
+    def piece(type, prefix = nil, suffix = nil)
+      @types[type] ||= []
+    end
+
+    def to_s
+      string = @base || ''
+      @types.each do |type, segments|
+        if f = self.class.formatter(type)
+          current = f.call(segments)
+        else
+          next if segments.empty?
+          current = self.class.sentence(segments)
+        end
+        f = IceCube::I18n.t('ice_cube.string.format')[type] ? type : 'default'
+        string = IceCube::I18n.t("ice_cube.string.format.#{f}", rest: string, current: current)
+      end
+      string
+    end
+
+    def self.formatter(type)
+      @formatters[type]
+    end
+
+    def self.register_formatter(type, &formatter)
+      @formatters ||= {}
+      @formatters[type] = formatter
+    end
+
+    module Helpers
+
+      # influenced by ActiveSupport's to_sentence
+      def sentence(array)
+        case array.length
+        when 0 ; ''
+        when 1 ; array[0].to_s
+        when 2 ; "#{array[0]}#{IceCube::I18n.t('ice_cube.array.two_words_connector')}#{array[1]}"
+        else ; "#{array[0...-1].join(IceCube::I18n.t('ice_cube.array.words_connector'))}#{IceCube::I18n.t('ice_cube.array.last_word_connector')}#{array[-1]}"
+        end
+      end
+
+      def nice_number(number)
+        literal_ordinal(number) || ordinalize(number)
+      end
+
+      def ordinalize(number)
+        IceCube::I18n.t('ice_cube.integer.ordinal', number: number, ordinal: ordinal(number))
+      end
+
+      def literal_ordinal(number)
+        IceCube::I18n.t("ice_cube.integer.literal_ordinals")[number]
+      end
+
+      def ordinal(number)
+        ord = IceCube::I18n.t("ice_cube.integer.ordinals")[number] ||
+          IceCube::I18n.t("ice_cube.integer.ordinals")[number % 10] ||
+          IceCube::I18n.t('ice_cube.integer.ordinals')[:default]
+        number >= 0 ? ord : IceCube::I18n.t("ice_cube.integer.negative", ordinal: ord)
+      end
+
+    end
+
+    extend Helpers
+
+  end
+
+end

data/lib/ice_cube/deprecated.rb

@@ -0,0 +1,36 @@
+module IceCube
+  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: #{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: #{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 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

data/lib/ice_cube/errors/count_exceeded.rb

@@ -0,0 +1,7 @@
+module IceCube
+
+  # An exception for when a count on a Rule is passed
+  class CountExceeded < StopIteration
+  end
+
+end

data/lib/ice_cube/errors/until_exceeded.rb

@@ -0,0 +1,7 @@
+module IceCube
+
+  # An exception for when an until date on a Rule is passed
+  class UntilExceeded < StopIteration
+  end
+
+end

data/lib/ice_cube/flexible_hash.rb

@@ -0,0 +1,40 @@
+require 'delegate'
+
+module IceCube
+
+  # Find keys by symbol or string without symbolizing user input
+  # Due to the serialization format of ice_cube, this limited implementation
+  # is entirely sufficient
+
+  class FlexibleHash < SimpleDelegator
+
+    def [](key)
+      key = _match_key(key)
+      super
+    end
+
+    def fetch(key)
+      key = _match_key(key)
+      super
+    end
+
+    def delete(key)
+      key = _match_key(key)
+      super
+    end
+
+    private
+
+    def _match_key(key)
+      return key if __getobj__.has_key? key
+      if Symbol == key.class
+        __getobj__.keys.detect { |k| return k if k == key.to_s }
+      elsif String == key.class
+        __getobj__.keys.detect { |k| return k if k.to_s == key }
+      end
+      key
+    end
+
+  end
+
+end

data/lib/ice_cube/i18n.rb

@@ -0,0 +1,24 @@
+module IceCube
+  module I18n
+    def self.t(*args)
+      backend.t(*args)
+    end
+
+    def self.l(*args)
+      backend.l(*args)
+    end
+
+    def self.backend
+      @backend
+    end
+
+    def self.detect_backend!
+      require 'i18n'
+      ::I18n.load_path += Dir[File.expand_path('../../../config/locales/*{rb,yml}', __FILE__)]
+      @backend = ::I18n
+    rescue LoadError
+      require 'ice_cube/null_i18n'
+      @backend = NullI18n
+    end
+  end
+end

data/lib/ice_cube/null_i18n.rb

@@ -0,0 +1,28 @@
+require 'yaml'
+
+module IceCube
+  module NullI18n
+    def self.t(key, options = {})
+      base = key.to_s.split('.').reduce(config) { |hash, current_key| hash[current_key] }
+
+      base = base[options[:count] == 1 ? "one" : "other"] if options[:count]
+
+      if base.is_a?(Hash)
+        return base.each_with_object({}) do |(key, value), hash|
+          hash[key.is_a?(String) ? key.to_sym : key] = value
+        end
+      end
+
+      options.reduce(base) { |result, (find, replace)| result.gsub("%{#{find}}", "#{replace}") }
+    end
+
+    def self.l(date_or_time, options = {})
+      return date_or_time.strftime(options[:format]) if options[:format]
+      date_or_time.strftime(t('ice_cube.date.formats.default'))
+    end
+
+    def self.config
+      @config ||= YAML.load(File.read(File.join(File.dirname(__FILE__), '..', '..', 'config', 'locales', 'en.yml')))['en']
+    end
+  end
+end

data/lib/ice_cube/occurrence.rb

@@ -0,0 +1,101 @@
+require 'forwardable'
+require 'delegate'
+
+module IceCube
+
+  # Wraps start_time and end_time in a single concept concerning the duration.
+  # This delegates to the enclosed start_time so it behaves like a normal Time
+  # in almost all situations, however:
+  #
+  # Without ActiveSupport, it's necessary to cast the occurrence using
+  # +#to_time+ before doing arithmetic, else Time will try to subtract it
+  # using +#to_i+ and return a new time instead.
+  #
+  #     Time.now - Occurrence.new(start_time) # => 1970-01-01 01:00:00
+  #     Time.now - Occurrence.new(start_time).to_time # => 3600
+  #
+  # When ActiveSupport::Time core extensions are loaded, it's possible to
+  # subtract an Occurrence object directly from a Time to get the difference:
+  #
+  #     Time.now - Occurrence.new(start_time) # => 3600
+  #
+  class Occurrence < SimpleDelegator
+
+    # Report class name as 'Time' to thwart type checking.
+    def self.name
+      'Time'
+    end
+
+    # Optimize for common methods to avoid method_missing
+    extend Forwardable
+    def_delegators :start_time, :to_i, :<=>, :==
+    def_delegators :to_range, :cover?, :include?, :each, :first, :last
+
+    attr_reader :start_time, :end_time
+
+    def initialize(start_time, end_time=nil)
+      @start_time = start_time
+      @end_time = end_time || start_time
+      __setobj__ @start_time
+    end
+
+    def is_a?(klass)
+      klass == ::Time || super
+    end
+    alias_method :kind_of?, :is_a?
+
+    def intersects? other
+      if other.is_a?(Occurrence) || other.is_a?(Range)
+        lower_bound_1 = first + 1
+        upper_bound_1 = last # exclude end
+        lower_bound_2 = other.first + 1
+        upper_bound_2 = other.last + 1
+        if (lower_bound_2 <=> upper_bound_2) > 0
+          false
+        elsif (lower_bound_1 <=> upper_bound_1) > 0
+          false
+        else
+          (upper_bound_1 <=> lower_bound_2) >= 0 and
+            (upper_bound_2 <=> lower_bound_1) >= 0
+        end
+      else
+        cover? other
+      end
+    end
+
+    def comparable_time
+      start_time
+    end
+
+    def duration
+      end_time - start_time
+    end
+
+    def to_range
+      start_time..end_time
+    end
+
+    def to_time
+      start_time
+    end
+
+    # Shows both the start and end time if there is a duration.
+    # Optional format argument (e.g. :long, :short) supports Rails
+    # time formats and is only used when ActiveSupport is available.
+    #
+    def to_s(format=nil)
+      if format && to_time.public_method(:to_s).arity != 0
+        t0, t1 = start_time.to_s(format), end_time.to_s(format)
+      else
+        t0, t1 = start_time.to_s, end_time.to_s
+      end
+      duration > 0 ? "#{t0} - #{t1}" : t0
+    end
+
+    def overnight?
+      offset = start_time + 3600 * 24
+      midnight = Time.new(offset.year, offset.month, offset.day)
+      midnight < end_time
+    end
+  end
+end