chronic-davispuh 0.10.2.v0.1da32066b3f46f2506b3471e39557497e34afa27

data/lib/chronic/tags/scalar.rb

@@ -0,0 +1,101 @@
+module Chronic
+  class Scalar < Tag
+    DAY_PORTIONS = %w( am pm morning afternoon evening night )
+
+    # 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 is_scalar?(tokens, i)
+            token = tokens[i]
+            post_token = tokens[i + 1]
+            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)
+            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)
+              token.tag(ScalarFullYear.new(scalar, width)) if width == 4 and Chronic::Date::could_be_year?(scalar, width)
+              if Chronic::Date::could_be_year?(scalar, width)
+                year = Chronic::Date::make_year(scalar, options[:ambiguous_year_future_bias])
+                token.tag(ScalarYear.new(year.to_i, width))
+              end
+          end
+        end
+      end
+    end
+
+    def self.is_scalar?(tokens, i)
+      tokens[i].word =~ /^\d+$/ and (not tokens[i + 1] or not tokens[i + 1].word =~ /^st|nd|rd|th$/)
+    end
+
+    def to_s
+      'scalar'
+    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
+    end
+  end
+
+  class ScalarSecond < Scalar #:nodoc:
+    def to_s
+      super << '-second-' << @type.to_s
+    end
+  end
+
+  class ScalarMinute < Scalar #:nodoc:
+    def to_s
+      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
+
+  class ScalarFullYear < Scalar #:nodoc:
+    def to_s
+      super << '-fullyear-' << @type.to_s
+    end
+  end
+
+end

data/lib/chronic/tags/season_name.rb

@@ -0,0 +1,31 @@
+module Chronic
+  class SeasonName < Tag
+
+    # Scan an Array of Token objects and apply any necessary SeasonName
+    # 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|
+        token.tag scan_for(token, self, patterns, options)
+      end
+    end
+
+    def self.patterns
+      @@patterns ||= {
+        /^springs?$/i          => :spring,
+        /^summers?$/i          => :summer,
+        /^(autumn)|(fall)s?$/i => :autumn,
+        /^winters?$/i          => :winter
+      }
+    end
+
+    def to_s
+      'seasonname-' << @type.to_s
+    end
+  end
+
+end

data/lib/chronic/tags/separator.rb

@@ -0,0 +1,130 @@
+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|
+        token.tag scan_for(token, SeparatorComma, { ','.to_sym => :comma })
+        token.tag scan_for(token, SeparatorDot,   { '.'.to_sym => :dot })
+        token.tag scan_for(token, SeparatorColon, { ':'.to_sym => :colon })
+        token.tag scan_for(token, SeparatorSpace, { ' '.to_sym => :space })
+        token.tag scan_for(token, SeparatorSlash, { '/'.to_sym => :slash })
+        token.tag scan_for(token, SeparatorApostrophe, { '\''.to_sym => :apostrophe })
+        token.tag scan_for(token, SeparatorDash,  { :- => :dash })
+        token.tag scan_for(token, SeparatorAt,    { /^(at|@)$/i => :at })
+        token.tag scan_for(token, SeparatorIn,    { 'in' => :in })
+        token.tag scan_for(token, SeparatorOn,    { 'on' => :on })
+        token.tag scan_for(token, SeparatorAnd,   { 'and' => :and })
+        token.tag scan_for(token, SeparatorT,     { :T => :T })
+        token.tag scan_for(token, SeparatorW,     { :W => :W })
+        token.tag scan_for_quote(token)
+      end
+    end
+
+    # token - The Token object we want to scan.
+    #
+    # Returns a new SeparatorQuote object.
+    def self.scan_for_quote(token)
+      scan_for token, SeparatorQuote,
+      {
+        "'".to_sym => :single_quote,
+        '"'.to_sym => :double_quote
+      }
+    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 SeparatorApostrophe < Separator #:nodoc:
+    def to_s
+      super << '-apostrophe-' << @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

data/lib/chronic/tags/sign.rb

@@ -0,0 +1,35 @@
+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|
+        token.tag scan_for(token, SignPlus, { :+ => :plus })
+        token.tag scan_for(token, SignMinus, { :- => :minus })
+      end
+    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

data/lib/chronic/tags/time_special.rb

@@ -0,0 +1,34 @@
+module Chronic
+  class TimeSpecial < Tag
+
+    # Scan an Array of Token objects and apply any necessary TimeSpecial
+    # 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|
+        token.tag scan_for(token, self, patterns, options)
+      end
+    end
+
+    def self.patterns
+      @@patterns ||= {
+        'now'                 => :now,
+        'morning'             => :morning,
+        'noon'                => :noon,
+        'afternoon'           => :afternoon,
+        'evening'             => :evening,
+        /^(to)?(night|nite)$/ => :night,
+        'midnight'            => :midnight
+      }
+    end
+
+    def to_s
+      'timespecial-' << @type.to_s
+    end
+  end
+
+end

data/lib/chronic/tags/time_zone.rb

@@ -0,0 +1,56 @@
+module Chronic
+  class TimeZoneTag < Tag
+
+    # Scan an Array of Token objects and apply any necessary TimeZoneTag
+    # 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|
+        token = tokens[i]
+        token.tag scan_for(token, TimeZoneGeneric, patterns)
+        token.tag TimeZoneAbbreviation.new(token.word, nil, options) if TimeZone::is_valid_abbr?(token.word)
+      end
+    end
+
+    def self.patterns
+      @@patterns ||= {
+        :UTC => 0,
+        :Z   => 0
+      }
+    end
+
+    def to_s
+      'timezone'
+    end
+
+  end
+
+  class TimeZoneGeneric < TimeZoneTag #:nodoc:
+    def to_s
+      super + '-generic-' + @type.to_s
+    end
+  end
+
+  class TimeZoneAbbreviation < TimeZoneTag #:nodoc:
+    def to_s
+      super + '-abbr-' + @type.to_s
+    end
+  end
+
+  class TimeZoneName < TimeZoneTag #:nodoc:
+    def to_s
+      super + '-name-' + @type.to_s
+    end
+  end
+
+  class TimeZoneTZ < TimeZoneTag #:nodoc:
+    def to_s
+      super + '-tz-' + @type.to_s
+    end
+  end
+
+end

data/lib/chronic/tags/unit.rb

@@ -0,0 +1,174 @@
+module Chronic
+  class Unit < Tag
+
+    # Scan an Array of Token objects and apply any necessary Unit
+    # 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|
+        token.tag scan_for_units(token, options)
+      end
+    end
+
+    # token - The Token object we want to scan.
+    #
+    # Returns a new Unit object.
+    def self.scan_for_units(token, options = {})
+      patterns.each do |item, symbol|
+        if item =~ token.word
+          klass_name = 'Unit' + symbol.to_s.capitalize
+          klass = Chronic.const_get(klass_name)
+          return klass.new(symbol, options)
+        end
+      end
+      return nil
+    end
+
+    def self.patterns
+      @@paterns ||= {
+        /^years?$/i               => :year,
+        /^seasons?$/i             => :season,
+        /^quarters?$/i            => :quarter,
+        /^months?$/i              => :month,
+        /^fortnights?$/i          => :fortnight,
+        /^weeks?$/i               => :week,
+        /^weekends?$/i            => :weekend,
+        /^(week|business)days?$/i => :weekday,
+        /^days?$/i                => :day,
+        /^mornings?$/i            => :morning,
+        /^noons?$/                => :noon,
+        /^afternoons?$/i          => :afternoon,
+        /^evenings?$/i            => :evening,
+        /^(to)?(night|nite)s?$/i  => :night,
+        /^midnights?$/i           => :midnight,
+        /^(hr|hour)s?$/i          => :hour,
+        /^(min|minute)s?$/i       => :minute,
+        /^(sec|second)s?$/i       => :second,
+        /^(ms|miliseconds?)$/i    => :milisecond
+      }
+    end
+
+    def to_s
+      'unit'
+    end
+  end
+
+  class UnitYear < Unit #:nodoc:
+    def to_s
+      super << '-year'
+    end
+  end
+
+  class UnitSeason < Unit #:nodoc:
+    def to_s
+      super << '-season'
+    end
+  end
+
+  class UnitQuarter < Unit #:nodoc:
+    def to_s
+      super << '-quarter'
+    end
+  end
+
+  class UnitMonth < Unit #:nodoc:
+    def to_s
+      super << '-month'
+    end
+  end
+
+  class UnitFortnight < Unit #:nodoc:
+    def to_s
+      super << '-fortnight'
+    end
+  end
+
+  class UnitWeek < Unit #:nodoc:
+    def to_s
+      super << '-week'
+    end
+  end
+
+  class UnitWeekend < Unit #:nodoc:
+    def to_s
+      super << '-weekend'
+    end
+  end
+
+  class UnitWeekday < Unit #:nodoc:
+    def to_s
+      super << '-weekday'
+    end
+  end
+
+  class UnitDay < Unit #:nodoc:
+    def to_s
+      super << '-day'
+    end
+  end
+
+  class UnitMorning < Unit #:nodoc:
+    def to_s
+      super << '-morning'
+    end
+  end
+
+  class UnitNoon < Unit #:nodoc:
+    def to_s
+      super << '-noon'
+    end
+  end
+
+  class UnitAfternoon < Unit #:nodoc:
+    def to_s
+      super << '-afternoon'
+    end
+  end
+
+  class UnitEvening < Unit #:nodoc:
+    def to_s
+      super << '-evening'
+    end
+  end
+
+  class UnitNight < Unit #:nodoc:
+    def to_s
+      super << '-night'
+    end
+  end
+
+  class UnitMidnight < Unit #:nodoc:
+    def to_s
+      super << '-night'
+    end
+  end
+
+  class UnitHour < Unit #:nodoc:
+    def to_s
+      super << '-hour'
+    end
+  end
+
+  class UnitMinute < Unit #:nodoc:
+    def to_s
+      super << '-minute'
+    end
+  end
+
+  class UnitSecond < Unit #:nodoc:
+    def to_s
+      super << '-second'
+    end
+  end
+
+  class UnitMilisecond < Unit #:nodoc:
+    def to_s
+      super << '-milisecond'
+    end
+  end
+
+end