timely 0.5.0 → 0.6.0

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/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/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

data/lib/timely/time.rb

@@ -1,16 +1,20 @@
+# frozen_string_literal: true
+
 module Timely
   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.local(year, month, day, hour, min, sec)
     end
 
-    alias_method :on, :on_date
+    alias on on_date
   end
 end

data/lib/timely/time_since.rb

@@ -1,15 +1,17 @@
+# frozen_string_literal: true
+
 module Timely
   module TimeSince
     def seconds_since
-      ::DateTime.now.to_i - self.to_i
+      ::DateTime.now.to_i - to_i
     end
 
     def minutes_since
-      seconds_since/60
+      seconds_since / 60
     end
 
     def hours_since
-      minutes_since/60
+      minutes_since / 60
     end
   end
 end

data/lib/timely/trackable_date_set.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'set'
 
 # Track a set of dates (usually a range)
@@ -40,22 +42,20 @@ module Timely
       @dates_to_do = @dates.dup
     end
 
-    def self.new_for_date(date, opts={})
+    def self.new_for_date(date, opts = {})
       duration = opts[:duration] || 1
       TrackableDateSet.new(date..(date + duration - 1))
     end
 
-    # Todo: remove
+    # TODO: remove
     # Initialize from a date + duration
-    def self.from_params(date_string, duration_string=nil)
+    def self.from_params(date_string, duration_string = nil)
       duration = duration_string.to_i
-      duration = 1 if duration == 0
-      new_for_date(date_string.to_date, :duration => duration)
+      duration = 1 if duration.zero?
+      new_for_date(date_string.to_date, duration: duration)
     end
 
-    def dates
-      @dates
-    end
+    attr_reader :dates
 
     # Find the set of dates which are YET to do
     def find_to_do
@@ -66,18 +66,16 @@ module Timely
     def dates_done
       @dates - @dates_to_do
     end
-    alias_method :find_done, :dates_done
+    alias find_done dates_done
 
     # Yield each date to do
     def each_date_to_do
-      # Sort method needed as Ruby 1.8 set's aren't ordered
-      @dates_to_do.sort.each{|date| yield date}
+      @dates_to_do.each { |date| yield date }
     end
 
     # Yield each date in the whole set
     def each_date
-      # Sort method needed as Ruby 1.8 set's aren't ordered
-      @dates.sort.each{|date| yield date}
+      @dates.each { |date| yield date }
     end
 
     # Set dates as done
@@ -94,9 +92,9 @@ module Timely
       @dates_to_do.clear
     end
 
-    def has_done?(date_or_date_range)
+    def done_dates?(date_or_date_range)
       if date_or_date_range.is_a?(Enumerable)
-        @dates_to_do.none?{|date_to_do| date_or_date_range.include?(date_to_do)}
+        @dates_to_do.none? { |date_to_do| date_or_date_range.include?(date_to_do) }
       else
         !@dates_to_do.include? date_or_date_range
       end
@@ -112,8 +110,9 @@ module Timely
     #
     #   action_name => Name to track
     #   {:job_done_when} => Block to call, passed result of yield
-    def do_once(action_name, opts={})
+    def do_once(action_name, opts = {})
       return if action_applied?(action_name)
+
       result = yield
 
       job_done = opts[:job_done_when].blank? || opts[:job_done_when].call(result)
@@ -133,14 +132,15 @@ module Timely
     def duration
       @dates.size
     end
-    alias_method :number_of_nights, :duration
+    alias number_of_nights duration
 
-  # Can't say whole_period anymore... it's not necessarily sequential dates
-  #  def whole_period
-  #    self.dates
-  #  end
+    # Can't say whole_period anymore... it's not necessarily sequential dates
+    #  def whole_period
+    #    self.dates
+    #  end
 
     private
+
     def actions_applied
       @actions_applied ||= Set.new
     end

data/lib/timely/version.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Timely
-  VERSION = "0.5.0"
+  VERSION = '0.6.0'
 end

data/lib/timely/week_days.rb

@@ -1,15 +1,17 @@
+# frozen_string_literal: true
+
 module Timely
   class WeekDays
-    WEEKDAY_KEYS = %i[sun mon tue wed thu fri sat]
+    WEEKDAY_KEYS = %i[sun mon tue wed thu fri sat].freeze
 
     def self.from_range(date_range)
       dates = Array(date_range)
       return ALL_WEEKDAYS if dates.count >= WEEKDAY_KEYS.count
 
-      new(dates.each_with_object({}) { |date, result|
+      new(dates.each_with_object({}) do |date, result|
         # e.g. {3: true, 5: true}
         result[date.to_date.wday] = true
-      })
+      end)
     end
 
     # Create a new Weekdays object
@@ -36,7 +38,7 @@ module Timely
       when Integer
         # 4 -> 0000100 (binary) -> "0010000" (reversed string) -> {:tue => true}
         weekdays.to_s(2).reverse.each_char.with_index do |char, index|
-          set_day(index, char == "1")
+          set_day(index, char == '1')
         end
       when Hash
         weekdays.each_pair do |day, value|
@@ -58,7 +60,7 @@ module Timely
         }
       else
         raise ArgumentError,
-              "You must initialize with an Integer, Hash or Array"
+              'You must initialize with an Integer, Hash or Array'
       end
     end
 
@@ -73,10 +75,9 @@ module Timely
 
     def set_day(day, set)
       key = day_to_index(day)
-      unless WEEKDAY_KEYS.include?(key)
-        raise ArgumentError, "Invalid week day index #{key}"
-      end
-      @weekdays[key] = [true, "true", 1, "1"].include?(set)
+      raise ArgumentError, "Invalid week day index #{key}" unless WEEKDAY_KEYS.include?(key)
+
+      @weekdays[key] = [true, 'true', 1, '1'].include?(set)
     end
 
     def applies_for_date?(date)
@@ -105,10 +106,7 @@ module Timely
     # Returns array of weekday selected
     # e.g. [:sun, :sat]
     def weekdays
-      selected = @weekdays.select { |_day, day_selected| day_selected }
-      # Ruby 1.8 returns an array for Hash#select and loses order
-      return selected.keys if selected.is_a?(Hash)
-      selected.map(&:first).sort_by { |v| WEEKDAY_KEYS.index(v) }
+      @weekdays.select { |_day, day_selected| day_selected }.keys
     end
 
     # Returns comma separated and capitalized in Sun-Sat order
@@ -117,7 +115,7 @@ module Timely
       days = weekdays.map { |day| day.to_s.capitalize }
       last_day = days.pop
 
-      days.empty? ? last_day : days.join(", ") + ", and " + last_day
+      days.empty? ? last_day : days.join(', ') + ', and ' + last_day
     end
 
     # 7 bits encoded in decimal number
@@ -126,7 +124,7 @@ module Timely
     def weekdays_int
       int = 0
       WEEKDAY_KEYS.each.with_index do |day, index|
-        int += 2 ** index if @weekdays[day]
+        int += 2**index if @weekdays[day]
       end
       int
     end
@@ -143,6 +141,6 @@ module Timely
       end
     end
 
-    ALL_WEEKDAYS = WeekDays.new(%w[1 1 1 1 1 1 1])
+    ALL_WEEKDAYS = WeekDays.new(%w[1 1 1 1 1 1 1]).freeze
   end
 end

data/lib/timely.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Timely
   require 'time'
   require 'date'

data/rails/init.rb

@@ -1 +1,3 @@
+# frozen_string_literal: true
+
 require 'timely/rails'

data/spec/calendar_tag_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 class ActionViewTest
@@ -8,22 +10,21 @@ describe Timely::ActionViewHelpers do
   subject { ActionViewTest.new }
   let(:string) { double(:string) }
   let(:date) { Date.new(2000, 12, 25) }
-  before {
+  before do
     expect(date).to receive(:to_s).with(:calendar).and_return('25-12-2000')
     expect(Timely).to receive(:current_date).and_return(date)
-  }
+  end
 
   it 'should generate calendar tags' do
     expect(string).to receive(:html_safe)
     expect(subject).to receive(:tag).with(:input,
-      :id    => 'test',
-      :class => 'datepicker',
-      :size  => 10,
-      :maxlength => 10,
-      :name  => 'test',
-      :type  => 'text',
-      :value => '25-12-2000'
-    ).and_return(string)
+                                          id: 'test',
+                                          class: 'datepicker',
+                                          size: 10,
+                                          maxlength: 10,
+                                          name: 'test',
+                                          type: 'text',
+                                          value: '25-12-2000').and_return(string)
     subject.calendar_tag :test
   end
 end

data/spec/date_chooser_spec.rb

@@ -1,110 +1,115 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 describe Timely::DateChooser do
   before(:all) do
-    @from = "01-01-2011".to_date
-    @to = "01-03-2011".to_date
+    @from = '01-01-2011'.to_date
+    @to = '01-03-2011'.to_date
   end
 
-  #Validation
-  it "rejects blank FROM dates" do
-    expect { Timely::DateChooser.new({:from=>""}) }.to raise_error(
-      Timely::DateChooserException, 'A Start Date is required')
+  # Validation
+  it 'rejects blank FROM dates' do
+    expect { Timely::DateChooser.new(from: '') }.to raise_error(
+      Timely::DateChooserException, 'A Start Date is required'
+    )
   end
 
-  it "rejects TO dates later than FROM dates" do
-    expect {Timely::DateChooser.new(
-      :multiple_dates => true, :from => @from + 10, :to => @from
-    )}.to raise_error(Timely::DateChooserException, 'Start Date is after End Date')
+  it 'rejects TO dates later than FROM dates' do
+    expect do
+      Timely::DateChooser.new(
+        multiple_dates: true, from: @from + 10, to: @from
+      )
+    end .to raise_error(Timely::DateChooserException, 'Start Date is after End Date')
   end
 
-  #Operation
-  it "returns today if client only wants single date" do
+  # Operation
+  it 'returns today if client only wants single date' do
     expect(Timely::DateChooser.new(
-      :multiple_dates => false, :from => @from
+      multiple_dates: false, from: @from
     ).choose_dates).to eq [@from]
   end
 
-  #Test specific date of month
-  it "returns from and to as same (one) day in the case that only from date is given" do
+  # Test specific date of month
+  it 'returns from and to as same (one) day in the case that only from date is given' do
     expect(Timely::DateChooser.new(
-      :multiple_dates => true, :from => @from, :to => ''
+      multiple_dates: true, from: @from, to: ''
     ).choose_dates).to eq [@from]
   end
 
-  it "returns all days between from and to days in the basic case" do
+  it 'returns all days between from and to days in the basic case' do
     expect(Timely::DateChooser.new(
-      :multiple_dates => true, :from => @from, :to => @to
-    ).choose_dates).to eq (@from..@to).to_a
+      multiple_dates: true, from: @from, to: @to
+    ).choose_dates).to eq((@from..@to).to_a)
   end
 
-  it "returns the recurring dates within the range if this option is picked" do
+  it 'returns the recurring dates within the range if this option is picked' do
     expect(Timely::DateChooser.new(
-      :multiple_dates => true, :select => 'days', :dates => '1,11,3', :from => @from, :to => @to
-    ).choose_dates).to eq [
-      "1-01-2011", "3-01-2011", "11-01-2011", "1-02-2011",
-      "3-02-2011", "11-02-2011", "1-03-2011"
+      multiple_dates: true, select: 'days', dates: '1,11,3', from: @from, to: @to
+    ).choose_dates).to eq %w[
+      1-01-2011 3-01-2011 11-01-2011 1-02-2011
+      3-02-2011 11-02-2011 1-03-2011
     ].map(&:to_date)
   end
 
-  it "returns the specific dates, within or outside of the range, if this option is picked" do
+  it 'returns the specific dates, within or outside of the range, if this option is picked' do
     expect(Timely::DateChooser.new(
-      :multiple_dates => true, :select => 'specific_days', :specific_dates => '11-01-2011, 18-02-2011, 22-06-2011', :from => @from, :to => @to
-    ).choose_dates).to eq [
-      "11-01-2011", "18-02-2011", "22-06-2011"
+      multiple_dates: true, select: 'specific_days', specific_dates: '11-01-2011, 18-02-2011, 22-06-2011', from: @from, to: @to
+    ).choose_dates).to eq %w[
+      11-01-2011 18-02-2011 22-06-2011
     ].map(&:to_date)
   end
 
-  #Test days of week, every X weeks
-  it "returns every sunday correctly" do
+  # Test days of week, every X weeks
+  it 'returns every sunday correctly' do
     expect(Timely::DateChooser.new(
-      :multiple_dates => true, :select => 'weekdays', :from => @from, :to => @to,
-      :interval => {:level => "1", :unit => "week"}, :weekdays => {:sun => true}
-    ).choose_dates).to eq [
-      "2-01-2011", "9-01-2011", "16-01-2011", "23-01-2011", "30-01-2011",
-      "06-02-2011", "13-02-2011", "20-02-2011", "27-02-2011"
+      multiple_dates: true, select: 'weekdays', from: @from, to: @to,
+      interval: { level: '1', unit: 'week' }, weekdays: { sun: true }
+    ).choose_dates).to eq %w[
+      2-01-2011 9-01-2011 16-01-2011 23-01-2011 30-01-2011
+      06-02-2011 13-02-2011 20-02-2011 27-02-2011
     ].map(&:to_date)
   end
 
-  it "returns every thursday and sunday correctly" do
+  it 'returns every thursday and sunday correctly' do
     expect(Timely::DateChooser.new(
-      :multiple_dates => true, :select => 'weekdays',
-      :interval => {:level => "1", :unit => "week"},
-      :weekdays => {:sun => true, :thu => true}, :from => @from, :to => @to
-    ).choose_dates).to eq [
-      "2-01-2011", "6-01-2011", "9-01-2011", "13-01-2011", "16-01-2011",
-      "20-01-2011", "23-01-2011", "27-01-2011", "30-01-2011", "3-02-2011",
-      "06-02-2011", "10-02-2011", "13-02-2011", "17-02-2011", "20-02-2011",
-      "24-02-2011", "27-02-2011"
+      multiple_dates: true, select: 'weekdays',
+      interval: { level: '1', unit: 'week' },
+      weekdays: { sun: true, thu: true }, from: @from, to: @to
+    ).choose_dates).to eq %w[
+      2-01-2011 6-01-2011 9-01-2011 13-01-2011 16-01-2011
+      20-01-2011 23-01-2011 27-01-2011 30-01-2011 3-02-2011
+      06-02-2011 10-02-2011 13-02-2011 17-02-2011 20-02-2011
+      24-02-2011 27-02-2011
     ].map(&:to_date)
   end
 
-  it "returns every 2nd thursday and sunday correctly" do
+  it 'returns every 2nd thursday and sunday correctly' do
     expect(Timely::DateChooser.new(
-      :multiple_dates => true, :select => 'weekdays',
-      :interval => {:level => "2", :unit => "week"},
-      :weekdays => {:sun => "1", :thu => "1"}, :from => @from, :to => @to
-    ).choose_dates).to eq [
-      "2-01-2011", "6-01-2011", "16-01-2011", "20-01-2011", "30-01-2011",
-      "3-02-2011", "13-02-2011", "17-02-2011", "27-02-2011"
+      multiple_dates: true, select: 'weekdays',
+      interval: { level: '2', unit: 'week' },
+      weekdays: { sun: '1', thu: '1' }, from: @from, to: @to
+    ).choose_dates).to eq %w[
+      2-01-2011 6-01-2011 16-01-2011 20-01-2011 30-01-2011
+      3-02-2011 13-02-2011 17-02-2011 27-02-2011
     ].map(&:to_date)
   end
 
-  #Test correct results for every Nth week of month
-  it "returns every 1st Tuesday" do
+  # Test correct results for every Nth week of month
+  it 'returns every 1st Tuesday' do
     expect(Timely::DateChooser.new(
-      :multiple_dates => true, :select => 'weekdays', :from => @from, :to => @to,
-      :interval => {:level => "1", :unit => "week_of_month"}, :weekdays => {:tue => true}
-    ).choose_dates).to eq ["4-01-2011", "1-02-2011", "1-03-2011"].map(&:to_date)
+      multiple_dates: true, select: 'weekdays', from: @from, to: @to,
+      interval: { level: '1', unit: 'week_of_month' }, weekdays: { tue: true }
+    ).choose_dates).to eq %w[4-01-2011 1-02-2011 1-03-2011].map(&:to_date)
   end
 
-  it "returns every 3st Monday and Friday" do
+  it 'returns every 3st Monday and Friday' do
     expect(Timely::DateChooser.new(
-      :multiple_dates => true, :select => 'weekdays',
-      :interval => {:level => "3", :unit => "week_of_month"},
-      :weekdays => {:mon => true, :fri => true}, :from => @from, :to => @to
-    ).choose_dates).to eq [
-      "17-01-2011", "21-01-2011", "18-02-2011", "21-02-2011"
+      multiple_dates: true, select: 'weekdays',
+      interval: { level: '3', unit: 'week_of_month' },
+      weekdays: { mon: true, fri: true }, from: @from, to: @to
+    ).choose_dates).to eq %w[
+      17-01-2011 21-01-2011 18-02-2011 21-02-2011
     ].map(&:to_date)
   end
 end