chronic-mmlac 0.6.4.2 → 0.10.2.1

data/lib/chronic/repeaters/repeater_year.rb

@@ -2,14 +2,15 @@ module Chronic
   class RepeaterYear < Repeater #:nodoc:
     YEAR_SECONDS =  31536000  # 365 * 24 * 60 * 60
 
-    def initialize(type)
+    def initialize(type, options = {})
       super
+      @current_year_start = nil
     end
 
     def next(pointer)
       super
 
-      if !@current_year_start
+      unless @current_year_start
         case pointer
         when :future
           @current_year_start = Chronic.construct(@now.year + 1)
@@ -67,11 +68,11 @@ module Chronic
     end
 
     def month_days(year, month)
-      if Date.leap?(year)
+      if ::Date.leap?(year)
         RepeaterMonth::MONTH_DAYS_LEAP[month - 1]
       else
         RepeaterMonth::MONTH_DAYS[month - 1]
       end
     end
   end
-end
+end

data/lib/chronic/scalar.rb

@@ -2,90 +2,62 @@ module Chronic
   class Scalar < Tag
     DAY_PORTIONS = %w( am pm morning afternoon evening night )
 
-    # Scan an Array of {Token}s and apply any necessary Scalar tags to
-    # each token
+    # Scan an Array of Token objects and apply any necessary Scalar
+    # tags to each token.
     #
-    # @param [Array<Token>] tokens Array of tokens to scan
-    # @param [Hash] options Options specified in {Chronic.parse}
-    # @return [Array] list of tokens
+    # 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 = scan_for_scalars(tokens[i], tokens[i + 1]) then tokens[i].tag(t) end
-        if t = scan_for_days(tokens[i], tokens[i + 1]) then tokens[i].tag(t) end
-        if t = scan_for_months(tokens[i], tokens[i + 1]) then tokens[i].tag(t) end
-        if t = scan_for_years(tokens[i], tokens[i + 1], options) then tokens[i].tag(t) end
-      end
-    end
-
-    # @param [Token] token
-    # @param [Token] post_token
-    # @return [Scalar, nil]
-    def self.scan_for_scalars(token, post_token)
-      if token.word =~ /^\d*$/
-        unless post_token && DAY_PORTIONS.include?(post_token.word)
-          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
     end
 
-    # @param [Token] token
-    # @param [Token] post_token
-    # @return [ScalarDay, nil]
-    def self.scan_for_days(token, post_token)
-      if token.word =~ /^\d\d?$/
-        toi = token.word.to_i
-        unless toi > 31 || toi < 1 || (post_token && DAY_PORTIONS.include?(post_token.word))
-          return ScalarDay.new(toi)
-        end
-      end
+    def to_s
+      'scalar'
     end
+  end
 
-    # @param [Token] token
-    # @param [Token] post_token
-    # @return [ScalarMonth, nil]
-    def self.scan_for_months(token, post_token)
-      if token.word =~ /^\d\d?$/
-        toi = token.word.to_i
-        unless toi > 12 || toi < 1 || (post_token && DAY_PORTIONS.include?(post_token.word))
-          return ScalarMonth.new(toi)
-        end
-      end
+  class ScalarSubsecond < Scalar #:nodoc:
+    def to_s
+      super << '-subsecond-' << @type.to_s
     end
+  end
 
-    # @param [Token] token
-    # @param [Token] post_token
-    # @param [Hash] options Options specified in {Chronic.parse}
-    # @return [ScalarYear, nil]
-    def self.scan_for_years(token, post_token, options)
-      if token.word =~ /^([1-9]\d)?\d\d?$/
-        unless post_token && DAY_PORTIONS.include?(post_token.word)
-          year = make_year(token.word.to_i, options[:ambiguous_year_future_bias])
-          return ScalarYear.new(year.to_i)
-        end
-      end
+  class ScalarSecond < Scalar #:nodoc:
+    def to_s
+      super << '-second-' << @type.to_s
     end
+  end
 
-    # Build a year from a 2 digit suffix
-    #
-    # @example
-    #   make_year(96, 50) #=> 1996
-    #   make_year(79, 20) #=> 2079
-    #   make_year(00, 50) #=> 2000
-    #
-    # @param [Integer] year The two digit year to build from
-    # @param [Integer] bias The amount of future years to bias
-    # @return [Integer] The 4 digit year
-    def self.make_year(year, bias)
-      return year if year.to_s.size > 2
-      start_year = Chronic.time_class.now.year - bias
-      century = (start_year / 100) * 100
-      full_year = century + year
-      full_year += 100 if full_year < start_year
-      full_year
+  class ScalarMinute < Scalar #:nodoc:
+    def to_s
+      super << '-minute-' << @type.to_s
     end
+  end
 
+  class ScalarHour < Scalar #:nodoc:
     def to_s
-      'scalar'
+      super << '-hour-' << @type.to_s
     end
   end
 

data/lib/chronic/season.rb

@@ -1,35 +1,24 @@
 module Chronic
   class Season
-    # @return [MiniDate]
-    attr_reader :start
 
-    # @return [MiniDate]
+    attr_reader :start
     attr_reader :end
 
-    # @param [MiniDate] start_date
-    # @param [MiniDate] end_date
     def initialize(start_date, end_date)
       @start = start_date
       @end = end_date
     end
 
-    # @param [Symbol]  season  The season name
-    # @param [Integer] pointer The direction (-1 for past, 1 for future)
-    # @return [Symbol] The new season name
     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
 
-    # @param [Symbol] season The season name
-    # @return [Symbol] The new season name
     def self.season_after(season)
       find_next_season(season, +1)
     end
 
-    # @param [Symbol] season The season name
-    # @return [Symbol] The new season name
     def self.season_before(season)
       find_next_season(season, -1)
     end

data/lib/chronic/separator.rb

@@ -1,56 +1,126 @@
 module Chronic
   class Separator < Tag
 
-    # Scan an Array of {Token}s and apply any necessary Separator tags to
-    # each token
+    # Scan an Array of Token objects and apply any necessary Separator
+    # tags to each token.
     #
-    # @param [Array<Token>] tokens Array of tokens to scan
-    # @param [Hash] options Options specified in {Chronic.parse}
-    # @return [Array] list of tokens
+    # 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_slash_or_dash(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
 
-    # @param [Token] token
-    # @return [SeparatorComma, nil]
+    # 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
 
-    # @param [Token] token
-    # @return [SeparatorSlashOrDash, nil]
-    def self.scan_for_slash_or_dash(token)
-      scan_for token, SeparatorSlashOrDash,
+    # 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,
       {
-        /^-$/ => :dash,
-        /^\/$/ => :slash
+        /^'$/ => :single_quote,
+        /^"$/ => :double_quote
       }
     end
 
-    # @param [Token] token
-    # @return [SeparatorAt, nil]
+    # 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
 
-    # @param [Token] token
-    # @return [SeparatorIn, nil]
+    # 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
 
-    # @param [Token] token
-    # @return [SeparatorOn, nil]
+    # 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
@@ -62,9 +132,39 @@ module Chronic
     end
   end
 
-  class SeparatorSlashOrDash < Separator #:nodoc:
+  class SeparatorDot < Separator #:nodoc:
     def to_s
-      super << '-slashordash-' << @type.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
 
@@ -85,4 +185,23 @@ module Chronic
       super << '-on'
     end
   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

data/lib/chronic/sign.rb

@@ -0,0 +1,49 @@
+module Chronic
+  class Sign < Tag
+
+    # Scan an Array of Token objects and apply any necessary Sign
+    # 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_plus(token) then token.tag(t); next end
+        if t = scan_for_minus(token) then token.tag(t); next end
+      end
+    end
+
+    # token - The Token object we want to scan.
+    #
+    # Returns a new SignPlus object.
+    def self.scan_for_plus(token)
+      scan_for token, SignPlus, { /^\+$/ => :plus }
+    end
+
+    # token - The Token object we want to scan.
+    #
+    # Returns a new SignMinus object.
+    def self.scan_for_minus(token)
+      scan_for token, SignMinus, { /^-$/ => :minus }
+    end
+
+    def to_s
+      'sign'
+    end
+  end
+
+  class SignPlus < Sign #:nodoc:
+    def to_s
+      super << '-plus'
+    end
+  end
+
+  class SignMinus < Sign #:nodoc:
+    def to_s
+      super << '-minus'
+    end
+  end
+
+end