timely 0.4.2 → 0.9.0

data/lib/timely/rails.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'timely/rails/extensions'
 if defined?(ActiveRecord)
   ActiveRecord::Base.extend Timely::Extensions

data/lib/timely/rails/calendar_tag.rb

@@ -1,10 +1,11 @@
+# frozen_string_literal: true
+
 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)
@@ -24,11 +25,10 @@ module Timely
         options[:size] ||= 10
         options[:maxlength] ||= 10
 
-        tag(:input, options.merge(:name => name, :type => 'text', :value => value)).html_safe
+        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

data/lib/timely/rails/date.rb

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

data/lib/timely/rails/date_group.rb

@@ -1,12 +1,35 @@
+# frozen_string_literal: true
+
 module Timely
   class DateGroup < ActiveRecord::Base
-    belongs_to :season, :class_name => 'Timely::Season', optional: true
+    belongs_to :season, class_name: 'Timely::Season', optional: true, inverse_of: :date_groups
 
     weekdays_field :weekdays
 
+    validates :weekdays_bit_array, presence: true
     validates_presence_of :start_date, :end_date
     validate :validate_date_range!
 
+    scope :covering_date, lambda { |date|
+      # Suitable for use with joins/merge!
+      where(arel_table[:start_date].lteq(date)).where(arel_table[:end_date].gteq(date))
+    }
+
+    scope :within_range, lambda { |date_range|
+      # IMPORTANT: Required for correctness in case of string param.
+      dates = Array(date_range)
+      where(arel_table[:start_date].lteq(dates.last)).where(arel_table[:end_date].gteq(dates.first))
+    }
+
+    scope :for_any_weekdays, lambda { |weekdays_int|
+      where((arel_table[:weekdays_bit_array] & weekdays_int.to_i).not_eq(0))
+    }
+
+    scope :applying_for_duration, lambda { |date_range|
+      weekdays_int = Timely::WeekDays.from_range(date_range).weekdays_int
+      within_range(date_range).for_any_weekdays(weekdays_int)
+    }
+
     def includes_date?(date)
       date >= start_date && date <= end_date && weekdays.applies_for_date?(date)
     end
@@ -17,7 +40,7 @@ module Timely
       elsif weekdays.all_days?
         true
       else
-        date_range.intersecting_dates(start_date..end_date).any?{|d| weekdays.applies_for_date?(d)}
+        date_range.intersecting_dates(start_date..end_date).any? { |d| weekdays.applies_for_date?(d) }
       end
     end
 
@@ -44,30 +67,31 @@ module Timely
       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|
+          weekdays = pattern.intervals.map { |i| i.first_datetime.wday }.each_with_object({}) do |wday, hash|
             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)
+            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)
+            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|
+              weekdays = dates.map(&:wday).each_with_object({}) do |wday, hash|
                 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)
+                start_date: dates.min.to_date.beginning_of_week,
+                end_date: dates.max.to_date.end_of_week,
+                weekdays: weekdays
+              )
             end
           end
         end
@@ -78,9 +102,9 @@ module Timely
     private
 
     def validate_date_range!
-      if start_date && end_date && (start_date > end_date)
-        raise ArgumentError, "Incorrect date range #{start_date} is before #{end_date}"
-      end
+      return unless start_date && end_date && start_date > end_date
+
+      raise ArgumentError, "Incorrect date range #{start_date} is before #{end_date}"
     end
   end
 end

data/lib/timely/rails/date_range_validity_module.rb

@@ -1,25 +1,27 @@
+# frozen_string_literal: true
+
 module Timely
   module DateRangeValidityModule
     def self.included(base)
       base.class_eval do
-        validates :from, :to, :presence => true
+        validates :from, :to, presence: true
       end
     end
 
     def validity_range
-      (from .. to)
+      (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
+      return unless from.present? && to.present? && from > to
+
+      errors.add(:base, 'Invalid Date Range. From date should be less than or equal to To date')
     end
 
     def validity_range_to_s
       "#{from.to_s(:short)} ~ #{to.to_s(:short)}"
     end
-    
+
     def valid_on?(date)
       validity_range.include?(date)
     end

data/lib/timely/rails/date_time.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module RailsCoreExtensions
   module DateTime
     def advance_considering_calendar(units, num_units)
@@ -5,11 +7,11 @@ module RailsCoreExtensions
       when :seconds, :minutes, :hours, :days, :weeks, :months, :years
         advance(units => num_units)
       when :calendar_days
-        advance(:days => num_units - 1).end_of_day
+        advance(days: num_units - 1).end_of_day
       when :calendar_months
-        advance(:months => num_units - 1).end_of_month
+        advance(months: num_units - 1).end_of_month
       when :calendar_years
-        advance(:years => num_units - 1).end_of_year
+        advance(years: num_units - 1).end_of_year
       end
     end
   end

data/lib/timely/rails/extensions.rb

@@ -1,55 +1,30 @@
+# frozen_string_literal: true
+
 module Timely
   module Extensions
     # Add a WeekDays attribute
     #
     # By default it will use attribute_bit_array as db field, but this can
     # be overridden by specifying :db_field => 'somthing_else'
-    def weekdays_field(attribute, options={})
+    def weekdays_field(attribute, options = {})
       db_field = options[:db_field] || attribute.to_s + '_bit_array'
-      self.composed_of(attribute,
-        :class_name => "::Timely::WeekDays",
-        :mapping    => [[db_field, 'weekdays_int']],
-        :converter  => Proc.new {|field| ::Timely::WeekDays.new(field)}
-      )
+      composed_of(attribute,
+                  class_name: '::Timely::WeekDays',
+                  mapping: [[db_field, 'weekdays_int']],
+                  converter: proc { |field| ::Timely::WeekDays.new(field) })
     end
 
     def acts_as_seasonal
-      belongs_to :season, :class_name => 'Timely::Season', optional: true
+      belongs_to :season, class_name: 'Timely::Season', optional: true
       accepts_nested_attributes_for :season
       validates_associated :season
 
-      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)
-        }
-
-        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
-          object.boundary_start = object.season.boundary_start
-          object.boundary_end   = object.season.boundary_end
-        end
+        next unless object.season
+
+        object.boundary_start = object.season.boundary_start
+        object.boundary_end   = object.season.boundary_end
       end
     end
   end
 end
-

data/lib/timely/rails/period.rb

@@ -1,19 +1,21 @@
+# frozen_string_literal: true
+
 module Timely
   class Period
     attr_reader :number, :units
 
-    UNITS = [
-      :seconds,
-      :minutes,
-      :hours,
-      :days,
-      :weeks,
-      :months,
-      :years,
-      :calendar_days,
-      :calendar_months,
-      :calendar_years
-    ]
+    UNITS = %i[
+      seconds
+      minutes
+      hours
+      days
+      weeks
+      months
+      years
+      calendar_days
+      calendar_months
+      calendar_years
+    ].freeze
 
     def initialize(number, units)
       @number = number

data/lib/timely/rails/season.rb

@@ -1,34 +1,22 @@
+# frozen_string_literal: true
+
 module Timely
   class Season < ActiveRecord::Base
-
-    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
-
+    has_many :date_groups, -> { order(:start_date) }, dependent: :destroy, class_name: 'Timely::DateGroup', inverse_of: :season
 
     accepts_nested_attributes_for :date_groups,
-      :reject_if => proc {|attributes| attributes['start_date'].blank?},
-      :allow_destroy => true
+                                  reject_if: proc { |attributes| attributes['start_date'].blank? },
+                                  allow_destroy: true
 
     validate :validate_dates_specified
 
     def validate_dates_specified
-      errors.add(:base, "No dates specified") if date_groups.blank?
+      errors.add(:base, 'No dates specified') if date_groups.blank?
       errors.empty?
     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
+      date_groups.any? { |dg| dg.includes_date?(date) }
     end
 
     def dates
@@ -46,11 +34,11 @@ module Timely
     end
 
     def boundary_start
-      date_groups.map(&:start_date).sort.first
+      date_groups.map(&:start_date).min
     end
 
     def boundary_end
-      date_groups.map(&:end_date).sort.last
+      date_groups.map(&:end_date).max
     end
 
     def within_boundary?(date)
@@ -60,30 +48,23 @@ module Timely
     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)
+      cloned = send(method)
       date_groups.each do |dg|
         cloned.date_groups.build(dg.send(method).attributes)
       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 to_s
       name.presence || Timely::DateRange.to_s(boundary_start, boundary_end)
     end
 
-    alias_method :audit_name, :to_s
+    alias 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
+      date_groups.map  do |dg|
+        "#{dg.start_date.to_s(:short)} - #{dg.end_date.to_s(:short)}"
+      end.to_sentence
     end
   end
 end

data/lib/timely/rails/time.rb

@@ -1,18 +1,22 @@
+# frozen_string_literal: true
+
 module Timely
   module Rails
     module Time
       def on_date(year, month = nil, day = nil)
         if year.is_a?(Date)
           date = year
-          year, month, day = date.year, date.month, date.day
+          year = date.year
+          month = date.month
+          day = date.day
         end
 
-        raise ArgumentError, "Year, month, and day needed" unless [year, month, day].all?
+        raise ArgumentError, 'Year, month, and day needed' unless [year, month, day].all?
 
         ::Time.zone.local(year, month, day, hour, min, sec)
       end
 
-      alias_method :on, :on_date
+      alias on on_date
     end
   end
 end

data/lib/timely/railtie.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class Railtie < Rails::Railtie
   initializer 'timely.initialize' do
     ActiveSupport.on_load(:action_view) do

data/lib/timely/range.rb

@@ -1,11 +1,13 @@
+# frozen_string_literal: true
+
 module Timely
   module Range
     def to_date_range
-      DateRange.new(self.first, self.last)
+      DateRange.new(first, last)
     end
 
     def days_from(date = Date.today)
-      (date + self.first)..(date + self.last)
+      (date + first)..(date + last)
     end
   end
 end

data/lib/timely/string.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Timely
   module String
     # fmt e.g. '%d/%m/%Y'
@@ -12,12 +14,12 @@ module Timely
       else
         ::Date.new(*::Date._parse(self, false).values_at(:year, :mon, :mday))
       end
-    rescue NoMethodError, ArgumentError => e
+    rescue NoMethodError, ArgumentError
       raise DateFormatException, "Date #{self} is invalid or not formatted correctly."
     end
   end
 
-  class DateFormatException < Exception; end
+  class DateFormatException < RuntimeError; end
 end
 
 class String