chronic 0.2.2 → 0.10.2

data/lib/chronic/repeaters/repeater_weekday.rb

@@ -0,0 +1,86 @@
+module Chronic
+  class RepeaterWeekday < Repeater #:nodoc:
+    DAY_SECONDS = 86400 # (24 * 60 * 60)
+    DAYS = {
+      :sunday => 0,
+      :monday => 1,
+      :tuesday => 2,
+      :wednesday => 3,
+      :thursday => 4,
+      :friday => 5,
+      :saturday => 6
+    }
+
+    def initialize(type, options = {})
+      super
+      @current_weekday_start = nil
+    end
+
+    def next(pointer)
+      super
+
+      direction = pointer == :future ? 1 : -1
+
+      unless @current_weekday_start
+        @current_weekday_start = Chronic.construct(@now.year, @now.month, @now.day)
+        @current_weekday_start += direction * DAY_SECONDS
+
+        until is_weekday?(@current_weekday_start.wday)
+          @current_weekday_start += direction * DAY_SECONDS
+        end
+      else
+        loop do
+          @current_weekday_start += direction * DAY_SECONDS
+          break if is_weekday?(@current_weekday_start.wday)
+        end
+      end
+
+      Span.new(@current_weekday_start, @current_weekday_start + DAY_SECONDS)
+    end
+
+    def this(pointer = :future)
+      super
+
+      case pointer
+      when :past
+        self.next(:past)
+      when :future, :none
+        self.next(:future)
+      end
+    end
+
+    def offset(span, amount, pointer)
+      direction = pointer == :future ? 1 : -1
+
+      num_weekdays_passed = 0; offset = 0
+      until num_weekdays_passed == amount
+        offset += direction * DAY_SECONDS
+        num_weekdays_passed += 1 if is_weekday?((span.begin+offset).wday)
+      end
+
+      span + offset
+    end
+
+    def width
+      DAY_SECONDS
+    end
+
+    def to_s
+      super << '-weekday'
+    end
+
+    private
+
+    def is_weekend?(day)
+      day == symbol_to_number(:saturday) || day == symbol_to_number(:sunday)
+    end
+
+    def is_weekday?(day)
+      !is_weekend?(day)
+    end
+
+    def symbol_to_number(sym)
+      DAYS[sym] || raise("Invalid symbol specified")
+    end
+  end
+end

data/lib/chronic/repeaters/repeater_weekend.rb

@@ -1,60 +1,67 @@
-class Chronic::RepeaterWeekend < Chronic::Repeater #:nodoc:
-  WEEKEND_SECONDS = 172_800 # (2 * 24 * 60 * 60)
-  
-  def next(pointer)
-    super
-    
-    if !@current_week_start
+module Chronic
+  class RepeaterWeekend < Repeater #:nodoc:
+    WEEKEND_SECONDS = 172_800 # (2 * 24 * 60 * 60)
+
+    def initialize(type, options = {})
+      super
+      @current_week_start = nil
+    end
+
+    def next(pointer)
+      super
+
+      unless @current_week_start
+        case pointer
+        when :future
+          saturday_repeater = RepeaterDayName.new(:saturday)
+          saturday_repeater.start = @now
+          next_saturday_span = saturday_repeater.next(:future)
+          @current_week_start = next_saturday_span.begin
+        when :past
+          saturday_repeater = RepeaterDayName.new(:saturday)
+          saturday_repeater.start = (@now + RepeaterDay::DAY_SECONDS)
+          last_saturday_span = saturday_repeater.next(:past)
+          @current_week_start = last_saturday_span.begin
+        end
+      else
+        direction = pointer == :future ? 1 : -1
+        @current_week_start += direction * RepeaterWeek::WEEK_SECONDS
+      end
+
+      Span.new(@current_week_start, @current_week_start + WEEKEND_SECONDS)
+    end
+
+    def this(pointer = :future)
+      super
+
       case pointer
-      when :future
-        saturday_repeater = Chronic::RepeaterDayName.new(:saturday)
+      when :future, :none
+        saturday_repeater = RepeaterDayName.new(:saturday)
         saturday_repeater.start = @now
-        next_saturday_span = saturday_repeater.next(:future)
-        @current_week_start = next_saturday_span.begin
+        this_saturday_span = saturday_repeater.this(:future)
+        Span.new(this_saturday_span.begin, this_saturday_span.begin + WEEKEND_SECONDS)
       when :past
-        saturday_repeater = Chronic::RepeaterDayName.new(:saturday)
-        saturday_repeater.start = (@now + Chronic::RepeaterDay::DAY_SECONDS)
-        last_saturday_span = saturday_repeater.next(:past)
-        @current_week_start = last_saturday_span.begin
+        saturday_repeater = RepeaterDayName.new(:saturday)
+        saturday_repeater.start = @now
+        last_saturday_span = saturday_repeater.this(:past)
+        Span.new(last_saturday_span.begin, last_saturday_span.begin + WEEKEND_SECONDS)
       end
-    else
+    end
+
+    def offset(span, amount, pointer)
       direction = pointer == :future ? 1 : -1
-      @current_week_start += direction * Chronic::RepeaterWeek::WEEK_SECONDS
+      weekend = RepeaterWeekend.new(:weekend)
+      weekend.start = span.begin
+      start = weekend.next(pointer).begin + (amount - 1) * direction * RepeaterWeek::WEEK_SECONDS
+      Span.new(start, start + (span.end - span.begin))
     end
-    
-    Chronic::Span.new(@current_week_start, @current_week_start + WEEKEND_SECONDS)
-  end
-  
-  def this(pointer = :future)
-    super
-    
-    case pointer
-    when :future, :none
-      saturday_repeater = Chronic::RepeaterDayName.new(:saturday)
-      saturday_repeater.start = @now
-      this_saturday_span = saturday_repeater.this(:future)
-      Chronic::Span.new(this_saturday_span.begin, this_saturday_span.begin + WEEKEND_SECONDS)
-    when :past
-      saturday_repeater = Chronic::RepeaterDayName.new(:saturday)
-      saturday_repeater.start = @now
-      last_saturday_span = saturday_repeater.this(:past)
-      Chronic::Span.new(last_saturday_span.begin, last_saturday_span.begin + WEEKEND_SECONDS)
+
+    def width
+      WEEKEND_SECONDS
+    end
+
+    def to_s
+      super << '-weekend'
     end
   end
-  
-  def offset(span, amount, pointer)
-    direction = pointer == :future ? 1 : -1
-    weekend = Chronic::RepeaterWeekend.new(:weekend)
-    weekend.start = span.begin
-    start = weekend.next(pointer).begin + (amount - 1) * direction * Chronic::RepeaterWeek::WEEK_SECONDS
-    Chronic::Span.new(start, start + (span.end - span.begin))
-  end
-  
-  def width
-    WEEKEND_SECONDS
-  end
-  
-  def to_s
-    super << '-weekend'
-  end
-end
+end

data/lib/chronic/repeaters/repeater_year.rb

@@ -1,58 +1,78 @@
-class Chronic::RepeaterYear < Chronic::Repeater #:nodoc:
-  
-  def next(pointer)
-    super
-    
-    if !@current_year_start
+module Chronic
+  class RepeaterYear < Repeater #:nodoc:
+    YEAR_SECONDS =  31536000  # 365 * 24 * 60 * 60
+
+    def initialize(type, options = {})
+      super
+      @current_year_start = nil
+    end
+
+    def next(pointer)
+      super
+
+      unless @current_year_start
+        case pointer
+        when :future
+          @current_year_start = Chronic.construct(@now.year + 1)
+        when :past
+          @current_year_start = Chronic.construct(@now.year - 1)
+        end
+      else
+        diff = pointer == :future ? 1 : -1
+        @current_year_start = Chronic.construct(@current_year_start.year + diff)
+      end
+
+      Span.new(@current_year_start, Chronic.construct(@current_year_start.year + 1))
+    end
+
+    def this(pointer = :future)
+      super
+
       case pointer
       when :future
-        @current_year_start = Time.construct(@now.year + 1)
+        this_year_start = Chronic.construct(@now.year, @now.month, @now.day + 1)
+        this_year_end = Chronic.construct(@now.year + 1, 1, 1)
       when :past
-        @current_year_start = Time.construct(@now.year - 1)
+        this_year_start = Chronic.construct(@now.year, 1, 1)
+        this_year_end = Chronic.construct(@now.year, @now.month, @now.day)
+      when :none
+        this_year_start = Chronic.construct(@now.year, 1, 1)
+        this_year_end = Chronic.construct(@now.year + 1, 1, 1)
+      end
+
+      Span.new(this_year_start, this_year_end)
+    end
+
+    def offset(span, amount, pointer)
+      direction = pointer == :future ? 1 : -1
+      new_begin = build_offset_time(span.begin, amount, direction)
+      new_end   = build_offset_time(span.end, amount, direction)
+      Span.new(new_begin, new_end)
+    end
+
+    def width
+      YEAR_SECONDS
+    end
+
+    def to_s
+      super << '-year'
+    end
+
+    private
+
+    def build_offset_time(time, amount, direction)
+      year = time.year + (amount * direction)
+      days = month_days(year, time.month)
+      day = time.day > days ? days : time.day
+      Chronic.construct(year, time.month, day, time.hour, time.min, time.sec)
+    end
+
+    def month_days(year, month)
+      if ::Date.leap?(year)
+        RepeaterMonth::MONTH_DAYS_LEAP[month - 1]
+      else
+        RepeaterMonth::MONTH_DAYS[month - 1]
       end
-    else
-      diff = pointer == :future ? 1 : -1
-      @current_year_start = Time.construct(@current_year_start.year + diff)
     end
-    
-    Chronic::Span.new(@current_year_start, Time.construct(@current_year_start.year + 1))
-  end
-  
-  def this(pointer = :future)
-    super
-    
-    case pointer
-    when :future
-      this_year_start = Time.construct(@now.year, @now.month, @now.day) + Chronic::RepeaterDay::DAY_SECONDS
-      this_year_end = Time.construct(@now.year + 1, 1, 1)
-    when :past
-      this_year_start = Time.construct(@now.year, 1, 1)
-      this_year_end = Time.construct(@now.year, @now.month, @now.day)
-    when :none
-      this_year_start = Time.construct(@now.year, 1, 1)
-      this_year_end = Time.construct(@now.year + 1, 1, 1)
-    end
-    
-    Chronic::Span.new(this_year_start, this_year_end)
-  end
-  
-  def offset(span, amount, pointer)
-    direction = pointer == :future ? 1 : -1
-    
-    sb = span.begin
-    new_begin = Time.construct(sb.year + (amount * direction), sb.month, sb.day, sb.hour, sb.min, sb.sec)
-    
-    se = span.end
-    new_end = Time.construct(se.year + (amount * direction), se.month, se.day, se.hour, se.min, se.sec)
-    
-    Chronic::Span.new(new_begin, new_end)
-  end
-  
-  def width
-    (365 * 24 * 60 * 60)
-  end
-  
-  def to_s
-    super << '-year'
   end
-end
+end

data/lib/chronic/scalar.rb

@@ -1,74 +1,81 @@
 module Chronic
+  class Scalar < Tag
+    DAY_PORTIONS = %w( am pm morning afternoon evening night )
 
-  class Scalar < Tag #:nodoc:
-    def self.scan(tokens)
-      # for each token
+    # Scan an Array of Token objects and apply any necessary Scalar
+    # tags to each token.
+    #
+    # tokens - An Array of tokens to scan.
+    # options - The Hash of options specified in Chronic::parse.
+    #
+    # Returns an Array of tokens.
+    def self.scan(tokens, options)
       tokens.each_index do |i|
-        if t = self.scan_for_scalars(tokens[i], tokens[i + 1]) then tokens[i].tag(t) end
-        if t = self.scan_for_days(tokens[i], tokens[i + 1]) then tokens[i].tag(t) end
-        if t = self.scan_for_months(tokens[i], tokens[i + 1]) then tokens[i].tag(t) end
-        if t = self.scan_for_years(tokens[i], tokens[i + 1]) then tokens[i].tag(t) end
-      end
-      tokens
-    end
-  
-    def self.scan_for_scalars(token, post_token)
-      if token.word =~ /^\d*$/
-        unless post_token && %w{am pm morning afternoon evening night}.include?(post_token)
-          return Scalar.new(token.word.to_i)
+        token = tokens[i]
+        post_token = tokens[i + 1]
+        if token.word =~ /^\d+$/
+            scalar = token.word.to_i
+            token.tag(Scalar.new(scalar))
+            token.tag(ScalarSubsecond.new(scalar)) if Chronic::Time::could_be_subsecond?(scalar)
+            token.tag(ScalarSecond.new(scalar)) if Chronic::Time::could_be_second?(scalar)
+            token.tag(ScalarMinute.new(scalar)) if Chronic::Time::could_be_minute?(scalar)
+            token.tag(ScalarHour.new(scalar)) if Chronic::Time::could_be_hour?(scalar)
+            unless post_token and DAY_PORTIONS.include?(post_token.word)
+              token.tag(ScalarDay.new(scalar)) if Chronic::Date::could_be_day?(scalar)
+              token.tag(ScalarMonth.new(scalar)) if Chronic::Date::could_be_month?(scalar)
+              if Chronic::Date::could_be_year?(scalar)
+                year = Chronic::Date::make_year(scalar, options[:ambiguous_year_future_bias])
+                token.tag(ScalarYear.new(year.to_i))
+              end
+            end
         end
       end
-      return nil
     end
-    
-    def self.scan_for_days(token, post_token)
-      if token.word =~ /^\d\d?$/
-        unless token.word.to_i > 31 || (post_token && %w{am pm morning afternoon evening night}.include?(post_token))
-          return ScalarDay.new(token.word.to_i)
-        end
-      end
-      return nil
+
+    def to_s
+      'scalar'
     end
-    
-    def self.scan_for_months(token, post_token)
-      if token.word =~ /^\d\d?$/
-        unless token.word.to_i > 12 || (post_token && %w{am pm morning afternoon evening night}.include?(post_token))
-          return ScalarMonth.new(token.word.to_i)
-        end
-      end
-      return nil
+  end
+
+  class ScalarSubsecond < Scalar #:nodoc:
+    def to_s
+      super << '-subsecond-' << @type.to_s
     end
-    
-    def self.scan_for_years(token, post_token)
-      if token.word =~ /^([1-9]\d)?\d\d?$/
-        unless post_token && %w{am pm morning afternoon evening night}.include?(post_token)
-          return ScalarYear.new(token.word.to_i)
-        end
-      end
-      return nil
+  end
+
+  class ScalarSecond < Scalar #:nodoc:
+    def to_s
+      super << '-second-' << @type.to_s
     end
-    
+  end
+
+  class ScalarMinute < Scalar #:nodoc:
     def to_s
-      'scalar'
+      super << '-minute-' << @type.to_s
+    end
+  end
+
+  class ScalarHour < Scalar #:nodoc:
+    def to_s
+      super << '-hour-' << @type.to_s
     end
   end
-  
+
   class ScalarDay < Scalar #:nodoc:
     def to_s
       super << '-day-' << @type.to_s
     end
   end
-  
+
   class ScalarMonth < Scalar #:nodoc:
     def to_s
       super << '-month-' << @type.to_s
     end
   end
-  
+
   class ScalarYear < Scalar #:nodoc:
     def to_s
       super << '-year-' << @type.to_s
     end
   end
-
 end

data/lib/chronic/season.rb

@@ -0,0 +1,26 @@
+module Chronic
+  class Season
+
+    attr_reader :start
+    attr_reader :end
+
+    def initialize(start_date, end_date)
+      @start = start_date
+      @end = end_date
+    end
+
+    def self.find_next_season(season, pointer)
+      lookup = [:spring, :summer, :autumn, :winter]
+      next_season_num = (lookup.index(season) + 1 * pointer) % 4
+      lookup[next_season_num]
+    end
+
+    def self.season_after(season)
+      find_next_season(season, +1)
+    end
+
+    def self.season_before(season)
+      find_next_season(season, -1)
+    end
+  end
+end