gitlab-chronic 0.10.4 → 0.10.5

data/lib/chronic/{tags/pointer.rb → pointer.rb}

@@ -10,14 +10,18 @@ module Chronic
     # Returns an Array of tokens.
     def self.scan(tokens, options)
       tokens.each do |token|
-        token.tag scan_for(token, self, patterns, options)
+        if t = scan_for_all(token) then token.tag(t) end
       end
     end
 
-    def self.patterns
-      @@patterns ||= {
-        'past' => :past,
-        /^future|in$/i => :future,
+    # token - The Token object we want to scan.
+    #
+    # Returns a new Pointer object.
+    def self.scan_for_all(token)
+      scan_for token, self,
+      {
+        /\bpast\b/ => :past,
+        /\b(?:future|in)\b/ => :future,
       }
     end
 

data/lib/chronic/{tags/repeater.rb → repeater.rb}

@@ -10,29 +10,15 @@ module Chronic
     # Returns an Array of tokens.
     def self.scan(tokens, options)
       tokens.each do |token|
-        token.tag scan_for_quarter_names(token, options)
-        token.tag scan_for_season_names(token, options)
-        token.tag scan_for_month_names(token, options)
-        token.tag scan_for_day_names(token, options)
-        token.tag scan_for_day_portions(token, options)
-        token.tag scan_for_times(token, options)
-        token.tag scan_for_units(token, options)
+        if t = scan_for_season_names(token, options) then token.tag(t); next end
+        if t = scan_for_month_names(token, options) then token.tag(t); next end
+        if t = scan_for_day_names(token, options) then token.tag(t); next end
+        if t = scan_for_day_portions(token, options) then token.tag(t); next end
+        if t = scan_for_times(token, options) then token.tag(t); next end
+        if t = scan_for_units(token, options) then token.tag(t); next end
       end
     end
 
-    # token - The Token object we want to scan.
-    #
-    # Returns a new Repeater object.
-    def self.scan_for_quarter_names(token, options = {})
-      scan_for token, RepeaterQuarterName,
-      {
-        /^q1$/ => :q1,
-        /^q2$/ => :q2,
-        /^q3$/ => :q3,
-        /^q4$/ => :q4
-      }, options
-    end
-
     # token - The Token object we want to scan.
     #
     # Returns a new Repeater object.
@@ -74,7 +60,7 @@ module Chronic
       scan_for token, RepeaterDayName,
       {
         /^m[ou]n(day)?$/ => :monday,
-        /^t(ue|eu|oo|u)s?(day)?$/ => :tuesday,
+        /^t(ue|eu|oo|u|)s?(day)?$/ => :tuesday,
         /^we(d|dnes|nds|nns)(day)?$/ => :wednesday,
         /^th(u|ur|urs|ers)(day)?$/ => :thursday,
         /^fr[iy](day)?$/ => :friday,
@@ -111,7 +97,6 @@ module Chronic
     def self.scan_for_units(token, options = {})
       {
         /^years?$/ => :year,
-        /^q$/ => :quarter,
         /^seasons?$/ => :season,
         /^months?$/ => :month,
         /^fortnights?$/ => :fortnight,
@@ -129,7 +114,7 @@ module Chronic
         if item =~ token.word
           klass_name = 'Repeater' + symbol.to_s.capitalize
           klass = Chronic.const_get(klass_name)
-          return klass.new(symbol, nil, options)
+          return klass.new(symbol, options)
         end
       end
       return nil
@@ -141,16 +126,16 @@ module Chronic
 
     # returns the width (in seconds or months) of this repeatable.
     def width
-      raise('Repeater#width must be overridden in subclasses')
+      raise("Repeater#width must be overridden in subclasses")
     end
 
     # returns the next occurance of this repeatable.
     def next(pointer)
-      raise('Start point must be set before calling #next') unless @now
+      raise("Start point must be set before calling #next") unless @now
     end
 
     def this(pointer)
-      raise('Start point must be set before calling #this') unless @now
+      raise("Start point must be set before calling #this") unless @now
     end
 
     def to_s

data/lib/chronic/repeaters/repeater_day.rb

@@ -2,7 +2,7 @@ module Chronic
   class RepeaterDay < Repeater #:nodoc:
     DAY_SECONDS = 86_400 # (24 * 60 * 60)
 
-    def initialize(type, width = nil, options = {})
+    def initialize(type, options = {})
       super
       @current_day_start = nil
     end

data/lib/chronic/repeaters/repeater_day_name.rb

@@ -2,7 +2,7 @@ module Chronic
   class RepeaterDayName < Repeater #:nodoc:
     DAY_SECONDS = 86400 # (24 * 60 * 60)
 
-    def initialize(type, width = nil, options = {})
+    def initialize(type, options = {})
       super
       @current_date = nil
     end
@@ -47,7 +47,7 @@ module Chronic
 
     def symbol_to_number(sym)
       lookup = {:sunday => 0, :monday => 1, :tuesday => 2, :wednesday => 3, :thursday => 4, :friday => 5, :saturday => 6}
-      lookup[sym] || raise('Invalid symbol specified')
+      lookup[sym] || raise("Invalid symbol specified")
     end
   end
 end

data/lib/chronic/repeaters/repeater_day_portion.rb

@@ -9,7 +9,7 @@ module Chronic
       :night => (20 * 60 * 60)..(24 * 60 * 60),     # 8pm-12pm
     }
 
-    def initialize(type, width = nil, options = {})
+    def initialize(type, options = {})
       super
       @current_span = nil
 
@@ -20,7 +20,7 @@ module Chronic
         @range || raise("Invalid type '#{type}' for RepeaterDayPortion")
       end
 
-      @range || raise('Range should have been set by now')
+      @range || raise("Range should have been set by now")
     end
 
     def next(pointer)
@@ -84,7 +84,7 @@ module Chronic
     end
 
     def width
-      @range || raise('Range has not been set')
+      @range || raise("Range has not been set")
       return @current_span.width if @current_span
       if @type.kind_of? Integer
         return (12 * 60 * 60)

data/lib/chronic/repeaters/repeater_fortnight.rb

@@ -2,7 +2,7 @@ module Chronic
   class RepeaterFortnight < Repeater #:nodoc:
     FORTNIGHT_SECONDS = 1_209_600 # (14 * 24 * 60 * 60)
 
-    def initialize(type, width = nil, options = {})
+    def initialize(type, options = {})
       super
       @current_fortnight_start = nil
     end

data/lib/chronic/repeaters/repeater_hour.rb

@@ -2,7 +2,7 @@ module Chronic
   class RepeaterHour < Repeater #:nodoc:
     HOUR_SECONDS = 3600 # 60 * 60
 
-    def initialize(type, width = nil, options = {})
+    def initialize(type, options = {})
       super
       @current_hour_start = nil
     end

data/lib/chronic/repeaters/repeater_minute.rb

@@ -2,7 +2,7 @@ module Chronic
   class RepeaterMinute < Repeater #:nodoc:
     MINUTE_SECONDS = 60
 
-    def initialize(type, width = nil, options = {})
+    def initialize(type, options = {})
       super
       @current_minute_start = nil
     end

data/lib/chronic/repeaters/repeater_month.rb

@@ -5,7 +5,7 @@ module Chronic
     MONTH_DAYS = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]
     MONTH_DAYS_LEAP = [31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]
 
-    def initialize(type, width = nil, options = {})
+    def initialize(type, options = {})
       super
       @current_month_start = nil
     end

data/lib/chronic/repeaters/repeater_month_name.rb

@@ -16,7 +16,7 @@ module Chronic
       :december => 12
     }
 
-    def initialize(type, width = nil, options = {})
+    def initialize(type, options = {})
       super
       @current_month_begin = nil
     end
@@ -45,7 +45,7 @@ module Chronic
             @current_month_begin = Chronic.construct(@now.year - 1, index)
           end
         end
-        @current_month_begin || raise('Current month should be set by now')
+        @current_month_begin || raise("Current month should be set by now")
       else
         case pointer
         when :future

data/lib/chronic/repeaters/repeater_season.rb

@@ -8,7 +8,7 @@ module Chronic
       :winter => Season.new(MiniDate.new(12,22), MiniDate.new(3,19))
     }
 
-    def initialize(type, width = nil, options = {})
+    def initialize(type, options = {})
       super
       @next_season_start = nil
       @next_season_end = nil

data/lib/chronic/repeaters/repeater_second.rb

@@ -2,7 +2,7 @@ module Chronic
   class RepeaterSecond < Repeater #:nodoc:
     SECOND_SECONDS = 1 # haha, awesome
 
-    def initialize(type, width = nil, options = {})
+    def initialize(type, options = {})
       super
       @second_start = nil
     end

data/lib/chronic/repeaters/repeater_time.rb

@@ -26,7 +26,7 @@ module Chronic
 
     end
 
-    def initialize(time, width = nil, options = {})
+    def initialize(time, options = {})
       @current_time = nil
       @options = options
       time_parts = time.split(':')
@@ -109,7 +109,7 @@ module Chronic
           end
         end
 
-        @current_time || raise('Current time cannot be nil at this point')
+        @current_time || raise("Current time cannot be nil at this point")
       end
 
       unless first

data/lib/chronic/repeaters/repeater_week.rb

@@ -2,9 +2,8 @@ module Chronic
   class RepeaterWeek < Repeater #:nodoc:
     WEEK_SECONDS = 604800 # (7 * 24 * 60 * 60)
 
-    def initialize(type, width = nil, options = {})
+    def initialize(type, options = {})
       super
-      @repeater_day_name = options[:week_start] || :sunday
       @current_week_start = nil
     end
 
@@ -14,16 +13,16 @@ module Chronic
       unless @current_week_start
         case pointer
         when :future
-          first_week_day_repeater = RepeaterDayName.new(@repeater_day_name)
-          first_week_day_repeater.start = @now
-          next_span = first_week_day_repeater.next(:future)
-          @current_week_start = next_span.begin
+          sunday_repeater = RepeaterDayName.new(:sunday)
+          sunday_repeater.start = @now
+          next_sunday_span = sunday_repeater.next(:future)
+          @current_week_start = next_sunday_span.begin
         when :past
-          first_week_day_repeater = RepeaterDayName.new(@repeater_day_name)
-          first_week_day_repeater.start = (@now + RepeaterDay::DAY_SECONDS)
-          first_week_day_repeater.next(:past)
-          last_span = first_week_day_repeater.next(:past)
-          @current_week_start = last_span.begin
+          sunday_repeater = RepeaterDayName.new(:sunday)
+          sunday_repeater.start = (@now + RepeaterDay::DAY_SECONDS)
+          sunday_repeater.next(:past)
+          last_sunday_span = sunday_repeater.next(:past)
+          @current_week_start = last_sunday_span.begin
         end
       else
         direction = pointer == :future ? 1 : -1
@@ -39,23 +38,23 @@ module Chronic
       case pointer
       when :future
         this_week_start = Chronic.time_class.local(@now.year, @now.month, @now.day, @now.hour) + RepeaterHour::HOUR_SECONDS
-        first_week_day_repeater = RepeaterDayName.new(@repeater_day_name)
-        first_week_day_repeater.start = @now
-        this_span = first_week_day_repeater.this(:future)
-        this_week_end = this_span.begin
+        sunday_repeater = RepeaterDayName.new(:sunday)
+        sunday_repeater.start = @now
+        this_sunday_span = sunday_repeater.this(:future)
+        this_week_end = this_sunday_span.begin
         Span.new(this_week_start, this_week_end)
       when :past
         this_week_end = Chronic.time_class.local(@now.year, @now.month, @now.day, @now.hour)
-        first_week_day_repeater = RepeaterDayName.new(@repeater_day_name)
-        first_week_day_repeater.start = @now
-        last_span = first_week_day_repeater.next(:past)
-        this_week_start = last_span.begin
+        sunday_repeater = RepeaterDayName.new(:sunday)
+        sunday_repeater.start = @now
+        last_sunday_span = sunday_repeater.next(:past)
+        this_week_start = last_sunday_span.begin
         Span.new(this_week_start, this_week_end)
       when :none
-        first_week_day_repeater = RepeaterDayName.new(@repeater_day_name)
-        first_week_day_repeater.start = @now
-        last_span = first_week_day_repeater.next(:past)
-        this_week_start = last_span.begin
+        sunday_repeater = RepeaterDayName.new(:sunday)
+        sunday_repeater.start = @now
+        last_sunday_span = sunday_repeater.next(:past)
+        this_week_start = last_sunday_span.begin
         Span.new(this_week_start, this_week_start + WEEK_SECONDS)
       end
     end

data/lib/chronic/repeaters/repeater_weekday.rb

@@ -11,7 +11,7 @@ module Chronic
       :saturday => 6
     }
 
-    def initialize(type, width = nil, options = {})
+    def initialize(type, options = {})
       super
       @current_weekday_start = nil
     end
@@ -80,7 +80,7 @@ module Chronic
     end
 
     def symbol_to_number(sym)
-      DAYS[sym] || raise('Invalid symbol specified')
+      DAYS[sym] || raise("Invalid symbol specified")
     end
   end
 end

data/lib/chronic/repeaters/repeater_weekend.rb

@@ -2,7 +2,7 @@ module Chronic
   class RepeaterWeekend < Repeater #:nodoc:
     WEEKEND_SECONDS = 172_800 # (2 * 24 * 60 * 60)
 
-    def initialize(type, width = nil, options = {})
+    def initialize(type, options = {})
       super
       @current_week_start = nil
     end

data/lib/chronic/repeaters/repeater_year.rb

@@ -2,7 +2,7 @@ module Chronic
   class RepeaterYear < Repeater #:nodoc:
     YEAR_SECONDS =  31536000  # 365 * 24 * 60 * 60
 
-    def initialize(type, width = nil, options = {})
+    def initialize(type, options = {})
       super
       @current_year_start = nil
     end

data/lib/chronic/{tags/scalar.rb → scalar.rb}

@@ -14,22 +14,20 @@ module Chronic
         token = tokens[i]
         post_token = tokens[i + 1]
         if token.word =~ /^\d+$/
-            width = token.word.length
             scalar = token.word.to_i
-            token.tag(Scalar.new(scalar, width))
-            token.tag(ScalarWide.new(token.word, width)) if width == 4
-            token.tag(ScalarSubsecond.new(scalar, width)) if Chronic::Time::could_be_subsecond?(scalar, width)
-            token.tag(ScalarSecond.new(scalar, width)) if Chronic::Time::could_be_second?(scalar, width)
-            token.tag(ScalarMinute.new(scalar, width)) if Chronic::Time::could_be_minute?(scalar, width)
-            token.tag(ScalarHour.new(scalar, width)) if Chronic::Time::could_be_hour?(scalar, width, options[:hours24] == false)
+            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, width)) if Chronic::Date::could_be_day?(scalar, width)
-              token.tag(ScalarMonth.new(scalar, width)) if Chronic::Date::could_be_month?(scalar, width)
-              if Chronic::Date::could_be_year?(scalar, width)
+              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, width))
+                token.tag(ScalarYear.new(year.to_i))
               end
-          end
+            end
         end
       end
     end
@@ -39,12 +37,6 @@ module Chronic
     end
   end
 
-  class ScalarWide < Scalar #:nodoc:
-    def to_s
-      super << '-wide-' << @type.to_s
-    end
-  end
-
   class ScalarSubsecond < Scalar #:nodoc:
     def to_s
       super << '-subsecond-' << @type.to_s

data/lib/chronic/separator.rb

@@ -0,0 +1,207 @@
+module Chronic
+  class Separator < Tag
+
+    # Scan an Array of Token objects and apply any necessary Separator
+    # 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 do |token|
+        if t = scan_for_commas(token) then token.tag(t); next end
+        if t = scan_for_dots(token) then token.tag(t); next end
+        if t = scan_for_colon(token) then token.tag(t); next end
+        if t = scan_for_space(token) then token.tag(t); next end
+        if t = scan_for_slash(token) then token.tag(t); next end
+        if t = scan_for_dash(token) then token.tag(t); next end
+        if t = scan_for_quote(token) then token.tag(t); next end
+        if t = scan_for_at(token) then token.tag(t); next end
+        if t = scan_for_in(token) then token.tag(t); next end
+        if t = scan_for_on(token) then token.tag(t); next end
+        if t = scan_for_and(token) then token.tag(t); next end
+        if t = scan_for_t(token) then token.tag(t); next end
+        if t = scan_for_w(token) then token.tag(t); next end
+      end
+    end
+
+    # token - The Token object we want to scan.
+    #
+    # Returns a new SeparatorComma object.
+    def self.scan_for_commas(token)
+      scan_for token, SeparatorComma, { /^,$/ => :comma }
+    end
+
+    # token - The Token object we want to scan.
+    #
+    # Returns a new SeparatorDot object.
+    def self.scan_for_dots(token)
+      scan_for token, SeparatorDot, { /^\.$/ => :dot }
+    end
+
+    # token - The Token object we want to scan.
+    #
+    # Returns a new SeparatorColon object.
+    def self.scan_for_colon(token)
+      scan_for token, SeparatorColon, { /^:$/ => :colon }
+    end
+
+    # token - The Token object we want to scan.
+    #
+    # Returns a new SeparatorSpace object.
+    def self.scan_for_space(token)
+      scan_for token, SeparatorSpace, { /^ $/ => :space }
+    end
+
+    # token - The Token object we want to scan.
+    #
+    # Returns a new SeparatorSlash object.
+    def self.scan_for_slash(token)
+      scan_for token, SeparatorSlash, { /^\/$/ => :slash }
+    end
+
+    # token - The Token object we want to scan.
+    #
+    # Returns a new SeparatorDash object.
+    def self.scan_for_dash(token)
+      scan_for token, SeparatorDash, { /^-$/ => :dash }
+    end
+
+    # token - The Token object we want to scan.
+    #
+    # Returns a new SeparatorQuote object.
+    def self.scan_for_quote(token)
+      scan_for token, SeparatorQuote,
+      {
+        /^'$/ => :single_quote,
+        /^"$/ => :double_quote
+      }
+    end
+
+    # token - The Token object we want to scan.
+    #
+    # Returns a new SeparatorAt object.
+    def self.scan_for_at(token)
+      scan_for token, SeparatorAt, { /^(at|@)$/ => :at }
+    end
+
+    # token - The Token object we want to scan.
+    #
+    # Returns a new SeparatorIn object.
+    def self.scan_for_in(token)
+      scan_for token, SeparatorIn, { /^in$/ => :in }
+    end
+
+    # token - The Token object we want to scan.
+    #
+    # Returns a new SeparatorOn object.
+    def self.scan_for_on(token)
+      scan_for token, SeparatorOn, { /^on$/ => :on }
+    end
+
+    # token - The Token object we want to scan.
+    #
+    # Returns a new SeperatorAnd Object object.
+    def self.scan_for_and(token)
+      scan_for token, SeparatorAnd, { /^and$/ => :and }
+    end
+
+    # token - The Token object we want to scan.
+    #
+    # Returns a new SeperatorT Object object.
+    def self.scan_for_t(token)
+      scan_for token, SeparatorT, { /^t$/ => :T }
+    end
+
+    # token - The Token object we want to scan.
+    #
+    # Returns a new SeperatorW Object object.
+    def self.scan_for_w(token)
+      scan_for token, SeparatorW, { /^w$/ => :W }
+    end
+
+    def to_s
+      'separator'
+    end
+  end
+
+  class SeparatorComma < Separator #:nodoc:
+    def to_s
+      super << '-comma'
+    end
+  end
+
+  class SeparatorDot < Separator #:nodoc:
+    def to_s
+      super << '-dot'
+    end
+  end
+
+  class SeparatorColon < Separator #:nodoc:
+    def to_s
+      super << '-colon'
+    end
+  end
+
+  class SeparatorSpace < Separator #:nodoc:
+    def to_s
+      super << '-space'
+    end
+  end
+
+  class SeparatorSlash < Separator #:nodoc:
+    def to_s
+      super << '-slash'
+    end
+  end
+
+  class SeparatorDash < Separator #:nodoc:
+    def to_s
+      super << '-dash'
+    end
+  end
+
+  class SeparatorQuote < Separator #:nodoc:
+    def to_s
+      super << '-quote-' << @type.to_s
+    end
+  end
+
+  class SeparatorAt < Separator #:nodoc:
+    def to_s
+      super << '-at'
+    end
+  end
+
+  class SeparatorIn < Separator #:nodoc:
+    def to_s
+      super << '-in'
+    end
+  end
+
+  class SeparatorOn < Separator #:nodoc:
+    def to_s
+      super << '-on'
+    end
+  end
+
+  class SeparatorAnd < Separator #:nodoc:
+    def to_s
+      super << '-and'
+    end
+  end
+
+  class SeparatorT < Separator #:nodoc:
+    def to_s
+      super << '-T'
+    end
+  end
+
+  class SeparatorW < Separator #:nodoc:
+    def to_s
+      super << '-W'
+    end
+  end
+
+end