chronic 0.2.3 → 0.4.0

data/lib/chronic/repeaters/repeater_year.rb

@@ -1,58 +1,66 @@
-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)
+      super
+      @current_year_start = nil
+    end
+
+    def next(pointer)
+      super
+
+      if !@current_year_start
+        case pointer
+        when :future
+          @current_year_start = Time.construct(@now.year + 1)
+        when :past
+          @current_year_start = Time.construct(@now.year - 1)
+        end
+      else
+        diff = pointer == :future ? 1 : -1
+        @current_year_start = Time.construct(@current_year_start.year + diff)
+      end
+
+      Span.new(@current_year_start, Time.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 = Time.construct(@now.year, @now.month, @now.day) + RepeaterDay::DAY_SECONDS
+        this_year_end = Time.construct(@now.year + 1, 1, 1)
       when :past
-        @current_year_start = Time.construct(@now.year - 1)
+        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
-    else
-      diff = pointer == :future ? 1 : -1
-      @current_year_start = Time.construct(@current_year_start.year + diff)
+
+      Span.new(this_year_start, this_year_end)
     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)
+
+    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)
+
+      Span.new(new_begin, new_end)
+    end
+
+    def width
+      (365 * 24 * 60 * 60)
+    end
+
+    def to_s
+      super << '-year'
     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

data/lib/chronic/scalar.rb

@@ -1,74 +1,84 @@
 module Chronic
 
   class Scalar < Tag #:nodoc:
-    def self.scan(tokens)
+    DAY_PORTIONS = %w( am pm morning afternoon evening night )
+
+    def self.scan(tokens, options)
       # for each token
       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
-  
+
     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
-    
+
     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
-    
+
     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)
+
+    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
+    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
+end

data/lib/chronic/separator.rb

@@ -1,76 +1,73 @@
 module Chronic
 
   class Separator < Tag #:nodoc:
-    def self.scan(tokens)
+    def self.scan(tokens, options)
       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
+        if t = scan_for_commas(tokens[i]) then tokens[i].tag(t); next end
+        if t = scan_for_slash_or_dash(tokens[i]) then tokens[i].tag(t); next end
+        if t = scan_for_at(tokens[i]) then tokens[i].tag(t); next end
+        if t = scan_for_in(tokens[i]) then tokens[i].tag(t); next end
+        if t = scan_for_on(tokens[i]) then tokens[i].tag(t); next end
       end
-      tokens
     end
-    
+
     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
-    
+
     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
-    
+
     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
-    
+
     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
+
+    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
 
-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,26 @@
+module Chronic
+  # Tokens are tagged with subclassed instances of this class when
+  # they match specific criteria
+  class Tag #:nodoc:
+    attr_accessor :type
+
+    def initialize(type)
+      @type = type
+    end
+
+    def start=(s)
+      @now = s
+    end
+
+    class << self
+      private
+
+      def scan_for(token, klass, items={})
+        items.each do |item, symbol|
+          return klass.new(symbol) if item =~ token.word
+        end
+        nil
+      end
+    end
+  end
+end

data/lib/chronic/time_zone.rb

@@ -1,22 +1,21 @@
 module Chronic
-  class TimeZone < Tag #:nodoc:    
-    def self.scan(tokens)
+  class TimeZone < Tag #:nodoc:
+    def self.scan(tokens, options)
       tokens.each_index do |i|
-        if t = self.scan_for_all(tokens[i]) then tokens[i].tag(t); next end
+        if t = scan_for_all(tokens[i]) then tokens[i].tag(t); next end
       end
-      tokens
     end
 
     def self.scan_for_all(token)
-      scanner = {/[PMCE][DS]T/i => :tz}
-      scanner.keys.each do |scanner_item|
-        return self.new(scanner[scanner_item]) if scanner_item =~ token.word
-      end
-      return nil
+      scan_for token, self,
+      {
+        /[PMCE][DS]T/i => :tz,
+        /(tzminus)?\d{4}/ => :tz
+      }
     end
 
     def to_s
       'timezone'
     end
   end
-end
+end

data/lib/chronic/token.rb

@@ -0,0 +1,35 @@
+module Chronic
+  class Token #:nodoc:
+    attr_accessor :word, :tags
+
+    def initialize(word)
+      @word = word
+      @tags = []
+    end
+
+    # Tag this token with the specified tag
+    def tag(new_tag)
+      @tags << new_tag
+    end
+
+    # Remove all tags of the given class
+    def untag(tag_class)
+      @tags.delete_if { |m| m.kind_of? tag_class }
+    end
+
+    # Return true if this token has any tags
+    def tagged?
+      @tags.size > 0
+    end
+
+    # Return the 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

@@ -7,10 +7,27 @@
 #
 #=============================================================================
 
-$:.unshift File.dirname(__FILE__)     # For use/testing when no gem is installed
+module Chronic
+  VERSION = "0.4.0"
+
+  class << self
+    attr_accessor :debug
+    attr_accessor :time_class
+  end
+
+  self.debug = false
+  self.time_class = Time
+end
+
+require 'time'
+require 'date'
 
 require 'chronic/chronic'
 require 'chronic/handlers'
+require 'chronic/mini_date'
+require 'chronic/tag'
+require 'chronic/span'
+require 'chronic/token'
 
 require 'chronic/repeater'
 require 'chronic/repeaters/repeater_year'
@@ -21,6 +38,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'
@@ -36,28 +54,15 @@ require 'chronic/ordinal'
 require 'chronic/separator'
 require 'chronic/time_zone'
 
-require 'numerizer/numerizer'
-
-module Chronic
-  VERSION = "0.2.3"
-  
-  def self.debug; false; end
-end
-
-alias p_orig p
-
-def p(val)
-  p_orig val
-  puts
-end
+require 'chronic/numerizer'
 
 # class Time
 #   def self.construct(year, month = 1, day = 1, hour = 0, minute = 0, second = 0)
 #     # extra_seconds = second > 60 ? second - 60 : 0
 #     # extra_minutes = minute > 59 ? minute - 59 : 0
 #     # extra_hours = hour > 23 ? hour - 23 : 0
-#     # extra_days = day > 
-#     
+#     # extra_days = day >
+#
 #     if month > 12
 #       if month % 12 == 0
 #         year += (month - 12) / 12
@@ -67,7 +72,7 @@ end
 #         month = month % 12
 #       end
 #     end
-#     
+#
 #     base = Time.local(year, month)
 #     puts base
 #     offset = ((day - 1) * 24 * 60 * 60) + (hour * 60 * 60) + (minute * 60) + second
@@ -84,17 +89,17 @@ class Time
       minute += second / 60
       second = second % 60
     end
-    
+
     if minute >= 60
       hour += minute / 60
       minute = minute % 60
     end
-    
+
     if hour >= 24
       day += hour / 24
       hour = hour % 24
     end
-    
+
     # determine if there is a day overflow. this is complicated by our crappy calendar
     # system (non-constant number of days per month)
     day <= 56 || raise("day must be no more than 56 (makes month resolution easier)")
@@ -109,7 +114,7 @@ class Time
         day = day % days_this_month
       end
     end
-    
+
     if month > 12
       if month % 12 == 0
         year += (month - 12) / 12
@@ -119,7 +124,11 @@ class Time
         month = month % 12
       end
     end
-    
-    Time.local(year, month, day, hour, minute, second)
+
+    Chronic.time_class.local(year, month, day, hour, minute, second)
   end
-end
+
+  def to_minidate
+    Chronic::MiniDate.new(self.month, self.day)
+  end
+end

data/test/helper.rb

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

data/test/test_Chronic.rb

@@ -1,50 +1,54 @@
-require 'chronic'
-require 'test/unit'
+require File.join(File.dirname(__FILE__), *%w[helper])
 
 class TestChronic < Test::Unit::TestCase
-  
+
   def setup
     # Wed Aug 16 14:00:00 UTC 2006
     @now = Time.local(2006, 8, 16, 14, 0, 0, 0)
   end
-  
+
+  def test_pre_normalize_numerized_string
+    string = 'two and a half years'
+    assert_equal Chronic::Numerizer.numerize(string), Chronic.pre_normalize(string)
+  end
+
   def test_post_normalize_am_pm_aliases
     # affect wanted patterns
-    
+
     tokens = [Chronic::Token.new("5:00"), Chronic::Token.new("morning")]
     tokens[0].tag(Chronic::RepeaterTime.new("5:00"))
     tokens[1].tag(Chronic::RepeaterDayPortion.new(:morning))
-    
+
     assert_equal :morning, tokens[1].tags[0].type
-    
+
     tokens = Chronic.dealias_and_disambiguate_times(tokens, {})
-    
+
     assert_equal :am, tokens[1].tags[0].type
     assert_equal 2, tokens.size
-    
+
     # don't affect unwanted patterns
-    
+
     tokens = [Chronic::Token.new("friday"), Chronic::Token.new("morning")]
     tokens[0].tag(Chronic::RepeaterDayName.new(:friday))
     tokens[1].tag(Chronic::RepeaterDayPortion.new(:morning))
-    
+
     assert_equal :morning, tokens[1].tags[0].type
-    
+
     tokens = Chronic.dealias_and_disambiguate_times(tokens, {})
-    
+
     assert_equal :morning, tokens[1].tags[0].type
     assert_equal 2, tokens.size
   end
-  
+
   def test_guess
     span = Chronic::Span.new(Time.local(2006, 8, 16, 0), Time.local(2006, 8, 17, 0))
     assert_equal Time.local(2006, 8, 16, 12), Chronic.guess(span)
-    
+
     span = Chronic::Span.new(Time.local(2006, 8, 16, 0), Time.local(2006, 8, 17, 0, 0, 1))
     assert_equal Time.local(2006, 8, 16, 12), Chronic.guess(span)
-    
+
     span = Chronic::Span.new(Time.local(2006, 11), Time.local(2006, 12))
     assert_equal Time.local(2006, 11, 16), Chronic.guess(span)
   end
-  
-end
+
+end