timely 0.0.2 → 0.1.0

data/lib/timely/railtie.rb

@@ -0,0 +1,7 @@
+class Railtie < Rails::Railtie
+  initializer 'timely.initialize' do
+    ActiveSupport.on_load(:action_view) do
+      require 'timely/rails'
+    end
+  end
+end

data/lib/timely/temporal_patterns/finder.rb

@@ -0,0 +1,152 @@
+module Timely
+  module TemporalPatterns
+    class Finder
+      class << self
+        def patterns(datetimes, options = nil)
+          return [] if datetimes.blank?
+          options ||= {}
+
+          datetimes = Array.wrap(datetimes).uniq.map(&:to_datetime).sort
+
+          if options[:split].is_a?(ActiveSupport::Duration)
+            find_patterns_split_by_duration(datetimes, options)
+          elsif options[:split].is_a?(Numeric)
+            find_patterns_split_by_size(datetimes, options)
+          else
+            find_patterns(datetimes, options)
+          end
+        end
+
+        private
+
+        def find_patterns(datetimes, options = {})
+          frequency_patterns = []
+
+          return [] if datetimes.blank?
+
+          if frequencies = options[:frequency] || options[:frequencies]
+            Array.wrap(frequencies).each do |frequency|
+              unmatched_datetimes = nil
+              if pattern = frequency_pattern(datetimes, frequency)
+                frequency_patterns << pattern
+                unmatched_datetimes = datetimes - pattern[:intervals].flatten
+              end
+              break if unmatched_datetimes && unmatched_datetimes.empty?
+            end
+          end
+
+          if options[:all] || !frequencies
+            frequency_patterns.concat(frequency_patterns(datetimes))
+          end
+
+          if best_fit = best_pattern(frequency_patterns)
+            ranges = best_fit[:ranges].map { |r| (r[0]..r[1]) }
+            frequency = best_fit[:frequency]
+            unmatched_datetimes = datetimes - best_fit[:intervals].flatten
+            pattern = Pattern.new(ranges, frequency)
+            ([pattern] + find_patterns(unmatched_datetimes, options)).sort_by(&:first_datetime)
+          else
+            datetimes.map { |d| Pattern.new((d..d), 1.day) }.sort_by(&:first_datetime)
+          end
+        end
+
+        def find_patterns_split_by_duration(datetimes, options = {})
+          slice_size = options[:split]
+          slices = []
+          slice_start = 0
+          while slice_start < datetimes.size
+            slice_end = datetimes.index(datetimes[slice_start] + slice_size) || (datetimes.size - 1)
+            slices << datetimes[slice_start..slice_end]
+            slice_start = slice_end + 1
+          end
+          split_patterns = []
+          slices.each do |slice|
+            split_patterns.concat(find_patterns(slice, options))
+          end
+          join_patterns(split_patterns)
+        end
+
+        def find_patterns_split_by_size(datetimes, options = {})
+          slice_size = options[:split]
+          split_patterns = []
+          datetimes.each_slice(slice_size) do |slice|
+            split_patterns.concat(find_patterns(slice, options))
+          end
+          join_patterns(split_patterns)
+        end
+
+        def join_patterns(patterns)
+          split_patterns = patterns.sort_by(&:first_datetime)
+          joint_patterns = []
+          while pattern = split_patterns.pop
+            joint_pattern = pattern
+            while (next_pattern = split_patterns.pop) && (pattern = joint_pattern.join(next_pattern))
+              joint_pattern = pattern
+            end
+            joint_patterns << joint_pattern
+          end
+          joint_patterns.sort_by(&:first_datetime)
+        end
+
+        def frequency_pattern(datetimes, frequency)
+          return nil if datetimes.blank? || frequency.to_f < 1 || ((datetimes.first + frequency) > datetimes.last)
+          pattern_intervals = []
+          pattern_ranges = []
+          intervals = condition_intervals(datetimes) do |current_date, next_date|
+            if (current_date + frequency) == next_date
+              pattern_intervals << [current_date, next_date]
+              true
+            else
+              false
+            end
+          end
+          pattern_ranges = intervals.map { |r| [r.first,r.last] }
+          {:frequency => frequency, :ranges => pattern_ranges, :intervals => pattern_intervals} unless intervals.blank?
+        end
+
+        def condition_intervals(datetimes, &block)
+          return [] if datetimes.blank? || !block_given?
+          datetimes = datetimes.clone
+          current_datetime = first_datetime = datetimes.shift
+          last_datetime = nil
+          while next_datetime = datetimes.delete(datetimes.find { |datetime| block.call(current_datetime, datetime) })
+            current_datetime = last_datetime = next_datetime
+          end
+          (last_datetime ? [(first_datetime..current_datetime)] : []) + condition_intervals(datetimes, &block)
+        end
+
+        def frequency_patterns(datetimes)
+          return [] if datetimes.blank?
+          datetimes = datetimes.clone
+          patterns = {}
+          while (current_datetime = datetimes.pop)
+            datetimes.reverse_each do |compared_datetime|
+              frequency = current_datetime - compared_datetime
+              patterns[frequency] ||= {:frequency => frequency.days, :ranges => [], :intervals => []}
+              patterns[frequency][:intervals] << [compared_datetime, current_datetime]
+              if interval = patterns[frequency][:ranges].find { |i| i[0] == current_datetime }
+                interval[0] = compared_datetime
+              else
+                patterns[frequency][:ranges] << [compared_datetime, current_datetime]
+              end
+            end
+          end
+          patterns.values
+        end
+
+        def best_pattern(frequency_patterns)
+          best_fit = nil
+          frequency_patterns.each do |pattern_hash|
+            if best_fit.nil? ||
+                (best_fit[:intervals].count < pattern_hash[:intervals].count) ||
+                (best_fit[:intervals].count == pattern_hash[:intervals].count && (best_fit[:ranges].count > pattern_hash[:ranges].count ||
+                (best_fit[:ranges].count == pattern_hash[:ranges].count && best_fit[:frequency] < pattern_hash[:frequency])))
+              best_fit = pattern_hash
+            end
+          end
+          best_fit
+        end
+      end
+    end
+  end
+end

data/lib/timely/temporal_patterns/frequency.rb

@@ -0,0 +1,108 @@
+module Timely
+  module TemporalPatterns
+    class Frequency
+      UNITS = [:second, :minute, :hour, :day, :week, :fortnight, :month, :year]
+
+      attr_accessor :duration
+
+      def initialize(duration)
+        self.duration = duration
+      end
+
+      def duration=(duration)
+        raise ArgumentError, "Frequency (#{duration}) must be a duration" unless duration.is_a?(ActiveSupport::Duration)
+        raise ArgumentError, "Frequency (#{duration}) must be positive" unless duration > 0
+        @duration = self.class.parse(duration)
+      end
+
+      def <=>(other)
+        self.duration <=> other.duration
+      end
+
+      def to_s
+         "every " + duration.parts.
+                      reduce(::Hash.new(0)) { |h,(l,r)| h[l] += r; h }.
+                      sort_by {|unit,  _ | [:years, :months, :days, :minutes, :seconds].index(unit)}.
+                      map     {|unit, val| "#{val} #{val == 1 ? unit.to_s.chop : unit.to_s}" if val.nonzero?}.compact.
+                      to_sentence(:locale => :en)
+      end
+
+      def unit
+        parts = self.class.decompose(duration)
+        parts.size == 1 && parts.first.last == 1? parts.first.first : nil
+      end
+
+      def min_unit
+        parts = self.class.decompose(duration)
+        {parts.last.first => parts.last.last}
+      end
+
+      def max_unit
+        parts = self.class.decompose(duration)
+        {parts.first.first => parts.first.last}
+      end
+
+      def units
+        self.class.decompose_to_hash(duration)
+      end
+
+      class << self
+        def singular_units
+          UNITS.dup
+        end
+
+        def plural_units
+          UNITS.map { |unit| unit.to_s.pluralize.to_sym }
+        end
+
+        def unit_durations
+          UNITS.map { |unit| 1.call(unit) }
+        end
+
+        def valid_units
+          singular_units + plural_units
+        end
+
+        def valid_unit?(unit)
+          valid_units.include?(unit.to_s.to_sym)
+        end
+
+        def parse(duration)
+          parsed = 0.seconds
+          decompose(duration).each do |part|
+            parsed += part.last.send(part.first)
+          end
+          parsed
+        end
+
+        def decompose(duration)
+          whole = duration
+          parts = []
+          plural_units.reverse_each do |unit|
+            if whole >= (one_unit = 1.send(unit))
+              current_unit_value = ((whole / one_unit).floor)
+              if current_unit_value > 0
+                parts << [unit, current_unit_value]
+                whole -= current_unit_value.send(unit)
+              end
+            end
+          end
+          parts
+        end
+
+        def decompose_to_hash(duration)
+          decompose(duration).inject({}) do |hash, unit|
+            hash[unit.first] = unit.last
+            hash
+          end
+        end
+      end
+
+      private
+
+      def method_missing(method, *args, &block) #:nodoc:
+        duration.send(method, *args, &block)
+      end
+    end
+  end
+end

data/lib/timely/temporal_patterns/interval.rb

@@ -0,0 +1,67 @@
+module Timely
+  module TemporalPatterns
+    class Interval
+      attr_accessor :first_datetime, :last_datetime
+
+      def self.surrounding(intervals)
+        first_datetime = nil
+        last_datetime = nil
+        intervals.each do |i|
+          first_datetime = i.first_datetime if first_datetime.nil? || i.first_datetime < first_datetime
+          last_datetime = i.last_datetime if last_datetime.nil? || i.last_datetime > last_datetime
+        end
+        new(first_datetime, last_datetime)
+      end
+
+      def initialize(first_datetime, last_datetime = nil)
+        self.first_datetime = first_datetime
+        self.last_datetime = last_datetime || first_datetime
+      end
+
+      def first_datetime=(first_datetime)
+        @first_datetime = first_datetime.to_datetime
+      end
+
+      def last_datetime=(last_datetime)
+        @last_datetime = last_datetime.to_datetime
+      end
+
+      def range
+        (first_datetime..last_datetime)
+      end
+
+      def datetimes
+        range.to_a
+      end
+
+      def ==(other)
+        self.range == other.range
+      end
+
+      def to_s
+        if first_datetime == last_datetime
+          "on #{first_datetime}#{first_datetime == first_datetime.beginning_of_day ? "" : " at #{first_datetime.strftime("%I:%M %p")}"}"
+        elsif first_datetime == first_datetime.beginning_of_month && last_datetime == last_datetime.end_of_month
+          if first_datetime.month == last_datetime.month
+            "during #{first_datetime.strftime('%b %Y')}"
+          else
+            "from #{first_datetime.strftime('%b %Y')} to #{last_datetime.strftime('%b %Y')}"
+          end
+        else
+          "from #{first_datetime}#{first_datetime == first_datetime.beginning_of_day ? "" : " at #{first_datetime.strftime("%I:%M %p")}"} "+
+          "to #{last_datetime}#{last_datetime == last_datetime.beginning_of_day ? "" : " at #{last_datetime.strftime("%I:%M %p")}"}"
+        end
+      end
+
+      def date_time_to_s(datetime)
+        datetime.strftime("%I:%M %p")
+      end
+
+      private
+
+      def method_missing(method, *args, &block) #:nodoc:
+        range.send(method, *args, &block)
+      end
+    end
+  end
+end

data/lib/timely/temporal_patterns/pattern.rb

@@ -0,0 +1,160 @@
+require 'active_support/core_ext/integer/inflections' # ordinalize
+
+module Timely
+  module TemporalPatterns
+    class Pattern
+      attr_reader :intervals, :frequency
+
+      def initialize(ranges, frequency)
+        @intervals = Array.wrap(ranges).map { |r| Interval.new(r.first, r.last) }.sort_by(&:first_datetime)
+        @frequency = Frequency.new(frequency)
+        fix_frequency
+      end
+
+      # Convert each interval to a list of datetimes
+      def datetimes
+        intervals.map do |interval|
+          datetimes = []
+          datetime = interval.first_datetime
+          while datetime <= interval.last_datetime
+            datetimes << datetime
+            datetime = datetime + frequency.duration
+          end
+          datetimes
+        end
+      end
+
+      def ranges
+        intervals.map { |i| (i.first_datetime..i.last_datetime) }
+      end
+
+      def first_datetime
+        surrounding_interval.first_datetime
+      end
+
+      def last_datetime
+        surrounding_interval.last_datetime
+      end
+
+      def surrounding_interval
+        Interval.surrounding(intervals)
+      end
+      alias_method :interval, :surrounding_interval # backwards compatibility
+
+      def match?(datetimes)
+        datetimes = Array.wrap(datetimes).map(&:to_datetime)
+        intervals.each do |interval|
+          current_datetime = interval.first_datetime
+          while current_datetime <= interval.last_datetime
+            datetimes.delete_if { |datetime| datetime == current_datetime }
+            return true if datetimes.empty?
+            current_datetime = current_datetime + frequency.duration
+          end
+        end
+        false
+      end
+
+      def <=>(other)
+        self.intervals.count <=> other.intervals.count
+      end
+
+      # Join with other IF same frequency AND same number of intervals
+      def join(other)
+        return nil unless self.frequency == other.frequency
+
+        expanded_datetimes = self.datetimes.map { |datetimes_within_an_interval|
+          back_one    = datetimes_within_an_interval.first - frequency.duration
+          forward_one = datetimes_within_an_interval.last + frequency.duration
+
+          [back_one] + datetimes_within_an_interval + [forward_one]
+        }
+
+        joint_ranges = []
+
+        # Look for overlaps, where an overlap may be 'off by 1' -- hence the 'expanded_datetimes'
+        # ...but start with other and join to each of it's intervals.
+        #
+        # Remember that 'pattern.datetimes' returns a list of datetimes per interval
+        other.datetimes.each do |other_datetimes_within_an_interval|
+
+          joinable_datetimes = expanded_datetimes.find { |expanded_datetimes_within_an_interval|
+            other_datetimes_within_an_interval.any? { |d|
+              expanded_datetimes_within_an_interval.include?(d)
+            }
+          }
+          break unless joinable_datetimes
+
+          # Joint ranges should be those that overlap
+          #
+          # This is buggy, because joinable_datetimes is a list of datetimes per interval that overlap
+          # Excluding the first doesn't make sense
+          #
+          # Instead, we should exclude the first AND last for each element within joinable_datetimes 
+          joint_datetimes = (other_datetimes_within_an_interval + joinable_datetimes[1...-1]).sort
+          joint_ranges << (joint_datetimes.first..joint_datetimes.last)
+        end
+
+        # This seems to be trying to say "Only join when we got one for each interval of self"
+        # ...it also seems too restrictive...
+        #
+        # What if other includes multiple intervals of self?
+        # Then we don't need same number of intervals
+        #
+        # Also might be wrong in other ways, it's tricky to tell
+        if joint_ranges.size == self.intervals.size
+          Pattern.new(joint_ranges, frequency.duration)
+        end
+      end
+
+      def to_s
+        single_date_intervals, multiple_dates_intervals = intervals.partition { |i| i.first_datetime == i.last_datetime}
+        patterns_strings = if multiple_dates_intervals.empty?
+          single_date_intervals.map(&:to_s)
+        else
+          interval_surrounding_multiple_dates = Interval.surrounding(multiple_dates_intervals)
+
+          multiple_dates_intervals_string = case frequency.unit
+          when :years
+            "every #{multiple_dates_intervals.map { |i| "#{i.first_datetime.day.ordinalize} of #{i.first_datetime.strftime('%B')}" }.uniq.to_sentence} #{interval_surrounding_multiple_dates}"
+          when :months
+            "every #{multiple_dates_intervals.map { |i| i.first_datetime.day.ordinalize }.uniq.to_sentence} of the month #{interval_surrounding_multiple_dates}"
+          when :weeks
+            weekdays = multiple_dates_intervals.map { |i| i.first_datetime.strftime('%A') }.uniq
+            if weekdays.count == 7
+              "every day #{interval_surrounding_multiple_dates}"
+            else
+              "every #{weekdays.to_sentence} #{interval_surrounding_multiple_dates}"
+            end
+          when :days
+            if multiple_dates_intervals.any? { |i| i.first_datetime != i.first_datetime.beginning_of_day }
+              "every day at #{multiple_dates_intervals.map { |i| i.first_datetime.strftime("%I:%M %p") }.to_sentence} #{interval_surrounding_multiple_dates}"
+            else
+              "every day #{interval_surrounding_multiple_dates}"
+            end
+          else
+            "#{frequency} #{multiple_dates_intervals.map(&:to_s).to_sentence}"
+          end
+          [multiple_dates_intervals_string] + single_date_intervals.map(&:to_s)
+        end
+        patterns_strings.to_sentence
+      end
+
+      private
+
+      # Fix the time units inconsistency problem
+      # e.g.: a year isn't exactly 12 months, it's a little bit more, but it is commonly considered to be equal to 12 months
+      def fix_frequency
+        return unless frequency.duration > 1.month
+        if frequency.duration < 12.months
+          if intervals.all? { |i| i.first_datetime.day == i.last_datetime.day }
+            frequency.duration = frequency.units[:months].months
+          end
+        else
+          if intervals.all? { |i| i.first_datetime.month == i.last_datetime.month && i.first_datetime.day == i.last_datetime.day }
+            frequency.duration = (frequency.duration / 12.months).floor.years
+          end
+        end
+      end
+    end
+  end
+end