timely 0.0.2 → 0.1.0

data/lib/timely/rails/calendar_tag.rb

@@ -0,0 +1,52 @@
+module Timely
+  # Uses Date.current to be more accurate for Rails applications
+  def self.current_date
+    ::Date.respond_to?(:current) ? ::Date.current : ::Date.today
+  end
+
+
+  module ActionViewHelpers
+    module FormTagHelper
+      def calendar_tag(name, value = Timely.current_date, *args)
+        options = args.extract_options!
+
+        value = value.to_s(:calendar) if value.respond_to?(:day)
+
+        name = name.to_s if name.is_a?(Symbol)
+
+        options[:id] = options[:id] || name.gsub(/\]$/, '').gsub(/\]\[/, '[').gsub(/[\[\]]/, '_')
+
+        options[:class] = options[:class].split(' ') if options[:class].is_a?(String)
+        options[:class] ||= []
+        options[:class] += %w(datepicker input-small)
+        options[:class] = options[:class].join(' ') # Rails 2 requires string values
+
+        options[:size] ||= 10
+        options[:maxlength] ||= 10
+
+        tag(:input, options.merge(:name => name, :type => 'text', :value => value)).html_safe
+      end
+    end
+
+
+    module DateHelper
+      def calendar(object_name, method, options = {})
+        value = options[:object] || Timely.current_date
+        calendar_tag("#{object_name}[#{method}]", value, options)
+      end
+    end
+
+    module FormBuilder
+      def calendar(method, options = {})
+        options[:object] = @object.send(method) unless options.key?(:object)
+        @template.calendar(@object_name, method, options)
+      end
+    end
+  end
+end
+
+if defined?(ActionView)
+  ActionView::Base.send :include, Timely::ActionViewHelpers::FormTagHelper
+  ActionView::Base.send :include, Timely::ActionViewHelpers::DateHelper
+  ActionView::Helpers::FormBuilder.send :include, Timely::ActionViewHelpers::FormBuilder
+end

data/lib/timely/rails/date.rb

@@ -0,0 +1,5 @@
+class Date
+  def to_time_in_time_zone
+    (Time.zone || ActiveSupport::TimeZone["UTC"]).local(self.year, self.month, self.day)
+  end
+end

data/lib/timely/rails/date_group.rb

@@ -1,115 +1,84 @@
 module Timely
-class DateGroup < ActiveRecord::Base
-  
-#  acts_as_audited
+  class DateGroup < ActiveRecord::Base
+    belongs_to :season, :class_name => 'Timely::Season'
 
-  belongs_to :season
+    weekdays_field :weekdays
 
-  weekdays_field :weekdays
+    validates_presence_of :start_date, :end_date
+    validate :validate_date_range!
 
-  validates_presence_of :start_date, :end_date
-  validate :validate_date_range!
+    def includes_date?(date)
+      date >= start_date && date <= end_date && weekdays.applies_for_date?(date)
+    end
 
-  def includes_date?(date)
-    date >= start_date && date <= end_date && weekdays.applies_for_date?(date)
-  end
+    def applicable_for_duration?(date_range)
+      if date_range.first > end_date || date_range.last < start_date
+        false
+      elsif weekdays.all_days?
+        true
+      else
+        date_range.intersecting_dates(start_date..end_date).any?{|d| weekdays.applies_for_date?(d)}
+      end
+    end
 
-  
-  def applicable_for_duration?(date_range)
-    if date_range.first > end_date || date_range.last < start_date
-      false
-    elsif weekdays.all_days?
-      true
-    else
-      date_range.intersecting_dates(start_date..end_date).any?{|d| weekdays.applies_for_date?(d)}
+    def dates
+      start_date.upto(end_date).select { |d| weekdays.applies_for_date?(d) }
     end
-  end
-  
-  
-  def dates
-    start_date.upto(end_date).select { |d| weekdays.applies_for_date?(d) }
-  end
 
-  
-  def to_s
-    str = start_date && end_date ? (start_date..end_date).to_date_range.to_s : (start_date || end_date).to_s
-    
-    unless weekdays.all_days?
-      str += " on #{weekdays}"
+    def to_s
+      str = start_date && end_date ? (start_date..end_date).to_date_range.to_s : (start_date || end_date).to_s
+      str += " on #{weekdays}" unless weekdays.all_days?
+      str
     end
-    str
-  end
-  
-  alias_method :audit_name, :to_s
-  
-  
-  
-  ################################################################
-  #---------------- Date intervals and patterns -----------------#
-  ################################################################
-  
-    
-  def pattern
-    ranges = dates.group_by(&:wday).values.map { |weekdates| (weekdates.min..weekdates.max) }
-    TemporalPatterns::Pattern.new(ranges, 1.week)
-  end
-  
-  
-  def self.from_patterns(patterns)
-    date_groups = []
-    Array.wrap(patterns).each do |pattern|
-      if pattern.frequency.unit == :weeks
-        weekdays = pattern.intervals.map { |i| i.first_datetime.wday }.inject({}) do |hash, wday|
-          hash[wday] = 1
-          hash
-        end
-        date_groups << DateGroup.new(
-          :start_date => pattern.first_datetime.to_date,
-          :end_date => pattern.last_datetime.to_date,
-          :weekdays => weekdays)
-      elsif pattern.frequency.unit == :days && pattern.frequency.duration == 1.day
-        date_groups << DateGroup.new(
-          :start_date => pattern.first_datetime.to_date,
-          :end_date => pattern.last_datetime.to_date,
-          :weekdays => 127)
-      else
-        pattern.datetimes.each do |datetimes|
-          datetimes.group_by(&:week).values.each do |dates|
-            weekdays = dates.map(&:wday).inject({}) do |hash, wday|
-              hash[wday] = 1
-              hash
+
+    ################################################################
+    #---------------- Date intervals and patterns -----------------#
+    ################################################################
+
+    def pattern
+      ranges = dates.group_by(&:wday).values.map { |weekdates| (weekdates.min..weekdates.max) }
+      TemporalPatterns::Pattern.new(ranges, 1.week)
+    end
+
+    def self.from_patterns(patterns)
+      date_groups = []
+      Array.wrap(patterns).each do |pattern|
+        if pattern.frequency.unit == :weeks
+          weekdays = pattern.intervals.map { |i| i.first_datetime.wday }.inject({}) do |hash, wday|
+            hash[wday] = 1
+            hash
+          end
+          date_groups << DateGroup.new(
+            :start_date => pattern.first_datetime.to_date,
+            :end_date => pattern.last_datetime.to_date,
+            :weekdays => weekdays)
+        elsif pattern.frequency.unit == :days && pattern.frequency.duration == 1.day
+          date_groups << DateGroup.new(
+            :start_date => pattern.first_datetime.to_date,
+            :end_date => pattern.last_datetime.to_date,
+            :weekdays => 127)
+        else
+          pattern.datetimes.each do |datetimes|
+            datetimes.group_by(&:week).values.each do |dates|
+              weekdays = dates.map(&:wday).inject({}) do |hash, wday|
+                hash[wday] = 1
+                hash
+              end
+              date_groups << DateGroup.new(
+                :start_date => dates.min.to_date.beginning_of_week,
+                :end_date => dates.max.to_date.end_of_week,
+                :weekdays => weekdays)
             end
-            date_groups << DateGroup.new(
-              :start_date => dates.min.to_date.beginning_of_week,
-              :end_date => dates.max.to_date.end_of_week,
-              :weekdays => weekdays)
           end
         end
       end
+      date_groups
     end
-    date_groups
-  end
-    
-  
-  private
-  
-  def validate_date_range!
-    raise InvalidInputException, "Incorrect date range" if start_date && end_date && (start_date > end_date)
-  end
 
-end
-end
-
-# == Schema Information
-#
-# Table name: date_groups
-#
-#  id                 :integer(4)      not null, primary key
-#  season_id          :integer(4)
-#  start_date         :date
-#  end_date           :date
-#  created_at         :datetime
-#  updated_at         :datetime
-#  weekdays_bit_array :integer(4)
-#
+    private
 
+    def validate_date_range!
+      raise ArgumentError, "Incorrect date range" if start_date && end_date && (start_date > end_date)
+    end
+  end
+end

data/lib/timely/rails/date_range_validity_module.rb

@@ -0,0 +1,27 @@
+module Timely
+  module DateRangeValidityModule
+    def self.included(base)
+      base.class_eval do
+        validates :from, :to, :presence => true
+      end
+    end
+
+    def validity_range
+      (from .. to)
+    end
+
+    def correctness_of_date_range
+      if (from.present? && to.present?)
+        errors.add(:base, "Invalid Date Range. From date should be less than or equal to To date") if from > to
+      end
+    end
+
+    def validity_range_to_s
+      "#{from.to_s(:short)} ~ #{to.to_s(:short)}"
+    end
+    
+    def valid_on?(date)
+      validity_range.include?(date)
+    end
+  end
+end

data/lib/timely/rails/date_time.rb

@@ -0,0 +1,20 @@
+module RailsCoreExtensions
+  module DateTime
+    def advance_considering_calendar(units, num_units)
+      case units
+      when :seconds, :minutes, :hours, :days, :weeks, :months, :years
+        advance(units => num_units)
+      when :calendar_days
+        advance(:days => num_units - 1).end_of_day
+      when :calendar_months
+        advance(:months => num_units - 1).end_of_month
+      when :calendar_years
+        advance(:years => num_units - 1).end_of_year
+      end
+    end
+  end
+end
+
+class DateTime
+  include RailsCoreExtensions::DateTime
+end

data/lib/timely/rails/extensions.rb

@@ -14,22 +14,34 @@ module Timely
     end
 
     def acts_as_seasonal
-      belongs_to :season
+      belongs_to :season, :class_name => 'Timely::Season'
       accepts_nested_attributes_for :season
       validates_associated :season
 
-      named_scope :season_on, lambda { |*args|
-        date = args.first || ::Date.current # Can't assign in block in Ruby 1.8
-        {
-          :joins => {:season => :date_groups},
-          :conditions => ["date_groups.start_date <= ? AND date_groups.end_date >= ?", date, date]
+      if ::ActiveRecord::VERSION::MAJOR >= 3
+        scope :season_on, lambda { |*args|
+          date = args.first || ::Date.current # Can't assign in block in Ruby 1.8
+          joins(:season => :date_groups).where("date_groups.start_date <= ? AND date_groups.end_date >= ?", date, date)
         }
-      }
 
-      named_scope :available_from, lambda { |*args|
-        date = args.first || ::Date.current # Can't assign in block in Ruby 1.8
-        {:conditions => ["boundary_end >= ?", date]}
-      }
+        scope :available_from, lambda { |*args|
+          date = args.first || ::Date.current # Can't assign in block in Ruby 1.8
+          where("boundary_end >= ?", date)
+        }
+      else
+        named_scope :season_on, lambda { |*args|
+          date = args.first || ::Date.current # Can't assign in block in Ruby 1.8
+          {
+            :joins => {:season => :date_groups},
+            :conditions => ["date_groups.start_date <= ? AND date_groups.end_date >= ?", date, date]
+          }
+        }
+
+        named_scope :available_from, lambda { |*args|
+          date = args.first || ::Date.current # Can't assign in block in Ruby 1.8
+          {:conditions => ["boundary_end >= ?", date]}
+        }
+      end
 
       before_save do |object|
         if object.season

data/lib/timely/rails/period.rb

@@ -0,0 +1,31 @@
+module Timely
+  class Period
+    attr_reader :number, :units
+
+    UNITS = [
+      :seconds,
+      :minutes,
+      :hours,
+      :days,
+      :weeks,
+      :months,
+      :years,
+      :calendar_days,
+      :calendar_months,
+      :calendar_years
+    ]
+
+    def initialize(number, units)
+      @number = number
+      @units  = units.to_sym
+    end
+
+    def after(time)
+      time.advance_considering_calendar(units, number)
+    end
+
+    def to_s
+      "#{number} #{units.to_s.gsub('_', '')}"
+    end
+  end
+end

data/lib/timely/rails/season.rb

@@ -1,99 +1,89 @@
 module Timely
-class Season < ActiveRecord::Base
-#  acts_as_audited
+  class Season < ActiveRecord::Base
 
-  has_many :date_groups, :order => :start_date, :dependent => :destroy
-
- # has_many :fare_bases
-
-  accepts_nested_attributes_for :date_groups,
-    :reject_if => proc {|attributes| attributes['start_date'].blank?},
-    :allow_destroy => true
-
-
-  def validate
-    errors.add_to_base("No dates specified") if date_groups.blank?
-    errors.empty?
-  end
+    if ::ActiveRecord::VERSION::MAJOR >= 4
+      has_many :date_groups, lambda { order(:start_date) }, :dependent => :destroy, :class_name => 'Timely::DateGroup'
+    else
+      has_many :date_groups, :order => :start_date, :dependent => :destroy, :class_name => 'Timely::DateGroup'
+    end
 
 
-  def includes_date?(date)
-    date_groups.any?{|dg| dg.includes_date?(date)}
-  end
+    accepts_nested_attributes_for :date_groups,
+      :reject_if => proc {|attributes| attributes['start_date'].blank?},
+      :allow_destroy => true
 
+    validate :validate_dates_specified
 
-  def has_gaps?
-    last_date = nil
-    date_groups.each do |dg|
-      return true if last_date && dg.start_date != last_date + 1
+    def validate_dates_specified
+      errors.add(:base, "No dates specified") if date_groups.blank?
+      errors.empty?
     end
-    false
-  end
 
-  def dates
-    date_groups.map do |date_group|
-      ((date_group.start_date)..(date_group.end_date)).to_a
-    end.flatten
-  end
-
-  def boundary_range
-    boundary_start..boundary_end
-  end
+    def includes_date?(date)
+      date_groups.any?{|dg| dg.includes_date?(date)}
+    end
 
+    def has_gaps?
+      last_date = nil
+      date_groups.each do |dg|
+        return true if last_date && dg.start_date != last_date + 1
+      end
+      false
+    end
 
-  def boundary_start
-    date_groups.map(&:start_date).sort.first
-  end
+    def dates
+      date_groups.map do |date_group|
+        ((date_group.start_date)..(date_group.end_date)).to_a
+      end.flatten
+    end
 
+    def boundary_range
+      boundary_start..boundary_end
+    end
 
-  def boundary_end
-    date_groups.map(&:end_date).sort.last
-  end
+    def past?
+      boundary_end && boundary_end < ::Date.current
+    end
 
+    def boundary_start
+      date_groups.map(&:start_date).sort.first
+    end
 
-  def within_boundary?(date)
-    boundary_start && boundary_end && boundary_start <= date && boundary_end >= date
-  end
+    def boundary_end
+      date_groups.map(&:end_date).sort.last
+    end
 
+    def within_boundary?(date)
+      boundary_start && boundary_end && boundary_start <= date && boundary_end >= date
+    end
 
-  def deep_clone
-    cloned = self.clone
-    date_groups.each do |dg|
-      cloned.date_groups.build(dg.clone.attributes.except(:id))
+    def deep_clone
+      # Use clone until it is removed in AR 3.1, then dup is the same
+      method = ActiveRecord::Base.instance_methods(false).include?(:clone) ? :clone : :dup
+      cloned = self.send(method)
+      date_groups.each do |dg|
+        cloned.date_groups.build(dg.send(method).attributes)
+      end
+      cloned
     end
-    cloned
-  end
 
+    def self.build_season_for(dates=[])
+      season = Season.new
+      date_groups = dates.map do |date|
+        DateGroup.new(:start_date => date, :end_date => date)
+      end
+      season.date_groups = date_groups
+      season
+    end
 
-  def self.build_season_for(dates=[])
-    season = Season.new
-    date_groups = dates.map do |date|
-      DateGroup.new(:start_date => date, :end_date => date)
+    def to_s
+      name.presence || Timely::DateRange.to_s(boundary_start, boundary_end)
     end
-    season.date_groups = date_groups
-    season
-  end
 
-  def to_s
-    name
-  end
-  alias_method :audit_name, :to_s
+    alias_method :audit_name, :to_s
 
-  def string_of_date_groups
-    date_groups.map{|dg| "#{dg.start_date.to_s(:short)} - #{dg.end_date.to_s(:short)}"}.to_sentence
+    def string_of_date_groups
+      date_groups.map{|dg| "#{dg.start_date.to_s(:short)} - #{dg.end_date.to_s(:short)}"}.to_sentence
+    end
   end
 end
-end
-
-
-
-# == Schema Information
-#
-# Table name: seasons
-#
-#  id         :integer(4)      not null, primary key
-#  name       :string(255)
-#  created_at :datetime
-#  updated_at :datetime
-#
-