chronic 0.1.5 → 0.6.5

data/lib/chronic/scalar.rb

@@ -1,74 +1,109 @@
 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}s 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
+    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
+        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
-      tokens
     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 && %w{am pm morning afternoon evening night}.include?(post_token)
+        unless post_token && DAY_PORTIONS.include?(post_token.word)
           return Scalar.new(token.word.to_i)
         end
       end
-      return nil
     end
-    
+
+    # @param [Token] token
+    # @param [Token] post_token
+    # @return [ScalarDay, nil]
     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)
+        toi = token.word.to_i
+        unless toi > 31 || toi < 1 || (post_token && DAY_PORTIONS.include?(post_token.word))
+          return ScalarDay.new(toi)
         end
       end
-      return nil
     end
-    
+
+    # @param [Token] token
+    # @param [Token] post_token
+    # @return [ScalarMonth, nil]
     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)
+        toi = token.word.to_i
+        unless toi > 12 || toi < 1 || (post_token && DAY_PORTIONS.include?(post_token.word))
+          return ScalarMonth.new(toi)
         end
       end
-      return nil
     end
-    
-    def self.scan_for_years(token, post_token)
+
+    # @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 && %w{am pm morning afternoon evening night}.include?(post_token)
-          return ScalarYear.new(token.word.to_i)
+        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
-      return nil
     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
+    end
+
     def to_s
       'scalar'
     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,37 @@
+module Chronic
+  class Season
+    # @return [MiniDate]
+    attr_reader :start
+
+    # @return [MiniDate]
+    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
+  end
+end

data/lib/chronic/separator.rb

@@ -1,76 +1,88 @@
 module Chronic
+  class Separator < Tag
 
-  class Separator < Tag #:nodoc:
-    def self.scan(tokens)
-      tokens.each_index do |i|
-        if t = self.scan_for_commas(tokens[i]) then tokens[i].tag(t); next end
-        if t = self.scan_for_slash_or_dash(tokens[i]) then tokens[i].tag(t); next end
-        if t = self.scan_for_at(tokens[i]) then tokens[i].tag(t); next end
-        if t = self.scan_for_in(tokens[i]) then tokens[i].tag(t); next end
+    # Scan an Array of {Token}s 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
+    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_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
       end
-      tokens
     end
-    
+
+    # @param [Token] token
+    # @return [SeparatorComma, nil]
     def self.scan_for_commas(token)
-      scanner = {/^,$/ => :comma}
-      scanner.keys.each do |scanner_item|
-        return SeparatorComma.new(scanner[scanner_item]) if scanner_item =~ token.word
-      end
-      return nil
+      scan_for token, SeparatorComma, { /^,$/ => :comma }
     end
-    
+
+    # @param [Token] token
+    # @return [SeparatorSlashOrDash, nil]
     def self.scan_for_slash_or_dash(token)
-      scanner = {/^-$/ => :dash,
-                 /^\/$/ => :slash}
-      scanner.keys.each do |scanner_item|
-        return SeparatorSlashOrDash.new(scanner[scanner_item]) if scanner_item =~ token.word
-      end
-      return nil
+      scan_for token, SeparatorSlashOrDash,
+      {
+        /^-$/ => :dash,
+        /^\/$/ => :slash
+      }
     end
-    
+
+    # @param [Token] token
+    # @return [SeparatorAt, nil]
     def self.scan_for_at(token)
-      scanner = {/^(at|@)$/ => :at}
-      scanner.keys.each do |scanner_item|
-        return SeparatorAt.new(scanner[scanner_item]) if scanner_item =~ token.word
-      end
-      return nil
+      scan_for token, SeparatorAt, { /^(at|@)$/ => :at }
     end
-    
+
+    # @param [Token] token
+    # @return [SeparatorIn, nil]
     def self.scan_for_in(token)
-      scanner = {/^in$/ => :in}
-      scanner.keys.each do |scanner_item|
-        return SeparatorIn.new(scanner[scanner_item]) if scanner_item =~ token.word
-      end
-      return nil
+      scan_for token, SeparatorIn, { /^in$/ => :in }
+    end
+
+    # @param [Token] token
+    # @return [SeparatorOn, nil]
+    def self.scan_for_on(token)
+      scan_for token, SeparatorOn, { /^on$/ => :on }
     end
-    
+
     def to_s
       'separator'
     end
   end
-  
+
   class SeparatorComma < Separator #:nodoc:
     def to_s
       super << '-comma'
     end
   end
-  
+
   class SeparatorSlashOrDash < Separator #:nodoc:
     def to_s
       super << '-slashordash-' << @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
 end

data/lib/chronic/span.rb

@@ -0,0 +1,31 @@
+module Chronic
+  # A Span represents a range of time. Since this class extends
+  # Range, you can use #begin and #end to get the beginning and
+  # ending times of the span (they will be of class Time)
+  class Span < Range
+    # Returns the width of this span in seconds
+    def width
+      (self.end - self.begin).to_i
+    end
+
+    # Add a number of seconds to this span, returning the
+    # resulting Span
+    def +(seconds)
+      Span.new(self.begin + seconds, self.end + seconds)
+    end
+
+    # Subtract a number of seconds to this span, returning the
+    # resulting Span
+    def -(seconds)
+      self + -seconds
+    end
+
+    # Prints this span in a nice fashion
+    def to_s
+      '(' << self.begin.to_s << '..' << self.end.to_s << ')'
+    end
+
+    alias :cover? :include? unless RUBY_VERSION =~ /^1.9/
+
+  end
+end

data/lib/chronic/tag.rb

@@ -0,0 +1,42 @@
+module Chronic
+  # Tokens are tagged with subclassed instances of this class when
+  # they match specific criteria
+  class Tag
+
+    # @return [Symbol]
+    attr_accessor :type
+
+    # @param [Symbol] type
+    def initialize(type)
+      @type = type
+    end
+
+    # @param [Time] s Set the start timestamp for this Tag
+    def start=(s)
+      @now = s
+    end
+
+    class << self
+      private
+
+      # @param [Token] token
+      # @param [Class] klass The class instance to create
+      # @param [Regexp, Hash] items
+      # @return [Object, nil] either a new instance of `klass` or `nil` if
+      #   no match is found
+      def scan_for(token, klass, items={})
+        case items
+        when Regexp
+          return klass.new(token.word) if items =~ token.word
+        when Hash
+          items.each do |item, symbol|
+            return klass.new(symbol) if item =~ token.word
+          end
+        end
+        nil
+      end
+
+    end
+
+  end
+end

data/lib/chronic/time_zone.rb

@@ -0,0 +1,30 @@
+module Chronic
+  class TimeZone < Tag
+
+    # Scan an Array of {Token}s and apply any necessary TimeZone 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
+    def self.scan(tokens, options)
+      tokens.each do |token|
+        if t = scan_for_all(token) then token.tag(t); next end
+      end
+    end
+
+    # @param [Token] token
+    # @return [TimeZone, nil]
+    def self.scan_for_all(token)
+      scan_for token, self,
+      {
+        /[PMCE][DS]T|UTC/i => :tz,
+        /(tzminus)?\d{2}:?\d{2}/ => :tz
+      }
+    end
+
+    def to_s
+      'timezone'
+    end
+  end
+end

data/lib/chronic/token.rb

@@ -0,0 +1,45 @@
+module Chronic
+  class Token
+
+    # @return [String] The word this Token represents
+    attr_accessor :word
+
+    # @return [Array] A list of tag associated with this Token
+    attr_accessor :tags
+
+    def initialize(word)
+      @word = word
+      @tags = []
+    end
+
+    # Tag this token with the specified tag
+    #
+    # @param [Tag] new_tag An instance of {Tag} or one of its subclasses
+    def tag(new_tag)
+      @tags << new_tag
+    end
+
+    # Remove all tags of the given class
+    #
+    # @param [Class] The tag class to remove
+    def untag(tag_class)
+      @tags.delete_if { |m| m.kind_of? tag_class }
+    end
+
+    # @return [Boolean] true if this token has any tags
+    def tagged?
+      @tags.size > 0
+    end
+
+    # @param [Class] tag_class The tag class to search for
+    # @return [Tag] The first Tag that matches the given class
+    def get_tag(tag_class)
+      @tags.find { |m| m.kind_of? tag_class }
+    end
+
+    # Print this Token in a pretty way
+    def to_s
+      @word << '(' << @tags.join(', ') << ') '
+    end
+  end
+end

data/lib/chronic.rb

@@ -1,14 +1,84 @@
-#=============================================================================
+require 'time'
+require 'date'
+
+# Parse natural language dates and times into Time or {Chronic::Span} objects
+#
+# @example
+#   require 'chronic'
+#
+#   Time.now   #=> Sun Aug 27 23:18:25 PDT 2006
+#
+#   Chronic.parse('tomorrow')
+#     #=> Mon Aug 28 12:00:00 PDT 2006
+#
+#   Chronic.parse('monday', :context => :past)
+#     #=> Mon Aug 21 12:00:00 PDT 2006
+#
+#   Chronic.parse('this tuesday 5:00')
+#     #=> Tue Aug 29 17:00:00 PDT 2006
+#
+#   Chronic.parse('this tuesday 5:00', :ambiguous_time_range => :none)
+#     #=> Tue Aug 29 05:00:00 PDT 2006
 #
-#  Name:       Chronic
-#  Author:     Tom Preston-Werner
-#  Purpose:    Parse natural language dates and times into Time or
-#              Chronic::Span objects
+#   Chronic.parse('may 27th', :now => Time.local(2000, 1, 1))
+#     #=> Sat May 27 12:00:00 PDT 2000
 #
-#=============================================================================
+#   Chronic.parse('may 27th', :guess => false)
+#     #=> Sun May 27 00:00:00 PDT 2007..Mon May 28 00:00:00 PDT 2007
+#
+# @author Tom Preston-Werner, Lee Jarvis
+module Chronic
+  VERSION = "0.6.5"
+
+  class << self
+
+    # @return [Boolean] true when debug mode is enabled
+    attr_accessor :debug
+
+    # @example
+    #   require 'chronic'
+    #   require 'active_support/time'
+    #
+    #   Time.zone = 'UTC'
+    #   Chronic.time_class = Time.zone
+    #   Chronic.parse('June 15 2006 at 5:54 AM')
+    #     # => Thu, 15 Jun 2006 05:45:00 UTC +00:00
+    #
+    # @return [Time] The time class Chronic uses internally
+    attr_accessor :time_class
+
+    # The current Time Chronic is using to base from
+    #
+    # @example
+    #   Time.now #=> 2011-06-06 14:13:43 +0100
+    #   Chronic.parse('yesterday') #=> 2011-06-05 12:00:00 +0100
+    #
+    #   now = Time.local(2025, 12, 24)
+    #   Chronic.parse('tomorrow', :now => now) #=> 2025-12-25 12:00:00 +0000
+    #
+    # @return [Time, nil]
+    attr_accessor :now
+  end
+
+  self.debug = false
+  self.time_class = Time
+end
 
 require 'chronic/chronic'
+require 'chronic/handler'
 require 'chronic/handlers'
+require 'chronic/mini_date'
+require 'chronic/tag'
+require 'chronic/span'
+require 'chronic/token'
+require 'chronic/grabber'
+require 'chronic/pointer'
+require 'chronic/scalar'
+require 'chronic/ordinal'
+require 'chronic/separator'
+require 'chronic/time_zone'
+require 'chronic/numerizer'
+require 'chronic/season'
 
 require 'chronic/repeater'
 require 'chronic/repeaters/repeater_year'
@@ -19,6 +89,7 @@ require 'chronic/repeaters/repeater_month_name'
 require 'chronic/repeaters/repeater_fortnight'
 require 'chronic/repeaters/repeater_week'
 require 'chronic/repeaters/repeater_weekend'
+require 'chronic/repeaters/repeater_weekday'
 require 'chronic/repeaters/repeater_day'
 require 'chronic/repeaters/repeater_day_name'
 require 'chronic/repeaters/repeater_day_portion'
@@ -27,21 +98,14 @@ require 'chronic/repeaters/repeater_minute'
 require 'chronic/repeaters/repeater_second'
 require 'chronic/repeaters/repeater_time'
 
-require 'chronic/grabber'
-require 'chronic/pointer'
-require 'chronic/scalar'
-require 'chronic/ordinal'
-require 'chronic/separator'
+class Time
+  def self.construct(year, month = 1, day = 1, hour = 0, minute = 0, second = 0)
+    warn "Chronic.construct will be deprecated in version 0.7.0. Please use Chronic.construct instead"
+    Chronic.construct(year, month, day, hour, minute, second)
+  end
 
-module Chronic
-  VERSION = "0.1.5"
-  
-  def self.debug; false; end
+  def to_minidate
+    warn "Time.to_minidate will be deprecated in version 0.7.0. Please use Chronic::MiniDate.from_time(time) instead"
+    Chronic::MiniDate.from_time(self)
+  end
 end
-
-alias p_orig p
-
-def p(val)
-  p_orig val
-  puts
-end

data/test/helper.rb

@@ -0,0 +1,6 @@
+unless defined? Chronic
+  $:.unshift File.expand_path('../../lib', __FILE__)
+  require 'chronic'
+end
+
+require 'test/unit'