chronic_2011 0.1.0

data/lib/chronic/time_zone.rb

@@ -0,0 +1,32 @@
+module Chronic
+  class TimeZone < Tag
+
+    # Scan an Array of Token objects and apply any necessary TimeZone
+    # 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_all(token) then token.tag(t); next end
+      end
+    end
+
+    # token - The Token object we want to scan.
+    #
+    # Returns a new Pointer object.
+    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,47 @@
+module Chronic
+  class Token
+
+    attr_accessor :word
+    attr_accessor :tags
+
+    def initialize(word)
+      @word = word
+      @tags = []
+    end
+
+    # Tag this token with the specified tag.
+    #
+    # new_tag - The new Tag object.
+    #
+    # Returns nothing.
+    def tag(new_tag)
+      @tags << new_tag
+    end
+
+    # Remove all tags of the given class.
+    #
+    # tag_class - The tag Class to remove.
+    #
+    # Returns nothing.
+    def untag(tag_class)
+      @tags.delete_if { |m| m.kind_of? tag_class }
+    end
+
+    # Returns true if this token has any tags.
+    def tagged?
+      @tags.size > 0
+    end
+
+    # tag_class - The tag Class to search for.
+    #
+    # Returns 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/test/helper.rb

@@ -0,0 +1,12 @@
+unless defined? Chronic
+  $:.unshift File.expand_path('../../lib', __FILE__)
+  require 'chronic'
+end
+
+require 'minitest/autorun'
+
+class TestCase < MiniTest::Unit::TestCase
+  def self.test(name, &block)
+    define_method("test_#{name.gsub(/\W/, '_')}", &block) if block
+  end
+end

data/test/test_chronic.rb

@@ -0,0 +1,148 @@
+require 'helper'
+
+class TestChronic < 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
+    assert_equal Chronic.pre_normalize('12:55 pm'), Chronic.pre_normalize('12.55 pm')
+  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::Handlers.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::Handlers.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
+
+  def test_now
+    Chronic.parse('now', :now => Time.local(2006, 01))
+    assert_equal Time.local(2006, 01), Chronic.now
+
+    Chronic.parse('now', :now => Time.local(2007, 01))
+    assert_equal Time.local(2007, 01), Chronic.now
+  end
+
+  def test_endian_definitions
+    # middle, little
+    endians = [
+      Chronic::Handler.new([:scalar_month, :separator_slash_or_dash, :scalar_day, :separator_slash_or_dash, :scalar_year, :separator_at?, 'time?'], :handle_sm_sd_sy),
+      Chronic::Handler.new([:scalar_day, :separator_slash_or_dash, :scalar_month, :separator_slash_or_dash, :scalar_year, :separator_at?, 'time?'], :handle_sd_sm_sy)
+    ]
+
+    assert_equal endians, Chronic.definitions[:endian]
+
+    defs = Chronic.definitions(:endian_precedence => :little)
+    assert_equal endians.reverse, defs[:endian]
+
+    defs = Chronic.definitions(:endian_precedence => [:little, :middle])
+    assert_equal endians.reverse, defs[:endian]
+
+    assert_raises(ArgumentError) do
+      Chronic.definitions(:endian_precedence => :invalid)
+    end
+  end
+
+  def test_passing_options
+    assert_raises(ArgumentError) do
+      Chronic.parse('now', :invalid => :option)
+    end
+
+    assert_raises(ArgumentError) do
+      Chronic.parse('now', :context => :invalid_context)
+    end
+  end
+
+  def test_debug
+    require 'stringio'
+    $stdout = StringIO.new
+    Chronic.debug = true
+
+    Chronic.parse 'now'
+    assert $stdout.string.include?('this(grabber-this)')
+  ensure
+    $stdout = STDOUT
+    Chronic.debug = false
+  end
+
+  # Chronic.construct
+
+  def test_normal
+    assert_equal Time.local(2006, 1, 2, 0, 0, 0), Chronic.construct(2006, 1, 2, 0, 0, 0)
+    assert_equal Time.local(2006, 1, 2, 3, 0, 0), Chronic.construct(2006, 1, 2, 3, 0, 0)
+    assert_equal Time.local(2006, 1, 2, 3, 4, 0), Chronic.construct(2006, 1, 2, 3, 4, 0)
+    assert_equal Time.local(2006, 1, 2, 3, 4, 5), Chronic.construct(2006, 1, 2, 3, 4, 5)
+  end
+
+  def test_second_overflow
+    assert_equal Time.local(2006, 1, 1, 0, 1, 30), Chronic.construct(2006, 1, 1, 0, 0, 90)
+    assert_equal Time.local(2006, 1, 1, 0, 5, 0), Chronic.construct(2006, 1, 1, 0, 0, 300)
+  end
+
+  def test_minute_overflow
+    assert_equal Time.local(2006, 1, 1, 1, 30), Chronic.construct(2006, 1, 1, 0, 90)
+    assert_equal Time.local(2006, 1, 1, 5), Chronic.construct(2006, 1, 1, 0, 300)
+  end
+
+  def test_hour_overflow
+    assert_equal Time.local(2006, 1, 2, 12), Chronic.construct(2006, 1, 1, 36)
+    assert_equal Time.local(2006, 1, 7), Chronic.construct(2006, 1, 1, 144)
+  end
+
+  def test_day_overflow
+    assert_equal Time.local(2006, 2, 1), Chronic.construct(2006, 1, 32)
+    assert_equal Time.local(2006, 3, 5), Chronic.construct(2006, 2, 33)
+    assert_equal Time.local(2004, 3, 4), Chronic.construct(2004, 2, 33)
+    assert_equal Time.local(2000, 3, 4), Chronic.construct(2000, 2, 33)
+
+    assert_raises(RuntimeError) do
+      Chronic.construct(2006, 1, 57)
+    end
+  end
+
+  def test_month_overflow
+    assert_equal Time.local(2006, 1), Chronic.construct(2005, 13)
+    assert_equal Time.local(2005, 12), Chronic.construct(2000, 72)
+  end
+
+end

data/test/test_daylight_savings.rb

@@ -0,0 +1,118 @@
+require 'helper'
+
+class TestDaylightSavings < TestCase
+
+  def setup
+    @begin_daylight_savings = Time.local(2008, 3, 9, 5, 0, 0, 0)
+    @end_daylight_savings = Time.local(2008, 11, 2, 5, 0, 0, 0)
+  end
+
+  def test_begin_past
+    # ambiguous - resolve to last night
+    t = Chronic::RepeaterTime.new('900')
+    t.start = @begin_daylight_savings
+    assert_equal Time.local(2008, 3, 8, 21), t.next(:past).begin
+
+    # ambiguous - resolve to this afternoon
+    t = Chronic::RepeaterTime.new('900')
+    t.start = Time.local(2008, 3, 9, 22, 0, 0, 0)
+    assert_equal Time.local(2008, 3, 9, 21), t.next(:past).begin
+
+    # ambiguous - resolve to this morning
+    t = Chronic::RepeaterTime.new('400')
+    t.start = @begin_daylight_savings
+    assert_equal Time.local(2008, 3, 9, 4), t.next(:past).begin
+
+    # unambiguous - resolve to today
+    t = Chronic::RepeaterTime.new('0400')
+    t.start = @begin_daylight_savings
+    assert_equal Time.local(2008, 3, 9, 4), t.next(:past).begin
+
+    # unambiguous - resolve to yesterday
+    t = Chronic::RepeaterTime.new('1300')
+    t.start = @begin_daylight_savings
+    assert_equal Time.local(2008, 3, 8, 13), t.next(:past).begin
+  end
+
+  def test_begin_future
+    # ambiguous - resolve to this morning
+    t = Chronic::RepeaterTime.new('900')
+    t.start = @begin_daylight_savings
+    assert_equal Time.local(2008, 3, 9, 9), t.next(:future).begin
+
+    # ambiguous - resolve to this afternoon
+    t = Chronic::RepeaterTime.new('900')
+    t.start = Time.local(2008, 3, 9, 13, 0, 0, 0)
+    assert_equal Time.local(2008, 3, 9, 21), t.next(:future).begin
+
+    # ambiguous - resolve to tomorrow
+    t = Chronic::RepeaterTime.new('900')
+    t.start = Time.local(2008, 3, 9, 22, 0, 0, 0)
+    assert_equal Time.local(2008, 3, 10, 9), t.next(:future).begin
+
+    # unambiguous - resolve to today
+    t = Chronic::RepeaterTime.new('0900')
+    t.start = @begin_daylight_savings
+    assert_equal Time.local(2008, 3, 9, 9), t.next(:future).begin
+
+    # unambiguous - resolve to tomorrow
+    t = Chronic::RepeaterTime.new('0400')
+    t.start = @begin_daylight_savings
+    assert_equal Time.local(2008, 3, 10, 4), t.next(:future).begin
+  end
+
+  def test_end_past
+    # ambiguous - resolve to last night
+    t = Chronic::RepeaterTime.new('900')
+    t.start = @end_daylight_savings
+    assert_equal Time.local(2008, 11, 1, 21), t.next(:past).begin
+
+    # ambiguous - resolve to this afternoon
+    t = Chronic::RepeaterTime.new('900')
+    t.start = Time.local(2008, 11, 2, 22, 0, 0, 0)
+    assert_equal Time.local(2008, 11, 2, 21), t.next(:past).begin
+
+    # ambiguous - resolve to this morning
+    t = Chronic::RepeaterTime.new('400')
+    t.start = @end_daylight_savings
+    assert_equal Time.local(2008, 11, 2, 4), t.next(:past).begin
+
+    # unambiguous - resolve to today
+    t = Chronic::RepeaterTime.new('0400')
+    t.start = @end_daylight_savings
+    assert_equal Time.local(2008, 11, 2, 4), t.next(:past).begin
+
+    # unambiguous - resolve to yesterday
+    t = Chronic::RepeaterTime.new('1300')
+    t.start = @end_daylight_savings
+    assert_equal Time.local(2008, 11, 1, 13), t.next(:past).begin
+  end
+
+  def test_end_future
+    # ambiguous - resolve to this morning
+    t = Chronic::RepeaterTime.new('900')
+    t.start = @end_daylight_savings
+    assert_equal Time.local(2008, 11, 2, 9), t.next(:future).begin
+
+    # ambiguous - resolve to this afternoon
+    t = Chronic::RepeaterTime.new('900')
+    t.start = Time.local(2008, 11, 2, 13, 0, 0, 0)
+    assert_equal Time.local(2008, 11, 2, 21), t.next(:future).begin
+
+    # ambiguous - resolve to tomorrow
+    t = Chronic::RepeaterTime.new('900')
+    t.start = Time.local(2008, 11, 2, 22, 0, 0, 0)
+    assert_equal Time.local(2008, 11, 3, 9), t.next(:future).begin
+
+    # unambiguous - resolve to today
+    t = Chronic::RepeaterTime.new('0900')
+    t.start = @end_daylight_savings
+    assert_equal Time.local(2008, 11, 2, 9), t.next(:future).begin
+
+    # unambiguous - resolve to tomorrow
+    t = Chronic::RepeaterTime.new('0400')
+    t.start = @end_daylight_savings
+    assert_equal Time.local(2008, 11, 3, 4), t.next(:future).begin
+  end
+
+end

data/test/test_handler.rb

@@ -0,0 +1,104 @@
+require 'helper'
+
+class TestHandler < TestCase
+
+  def setup
+    # Wed Aug 16 14:00:00 UTC 2006
+    @now = Time.local(2006, 8, 16, 14, 0, 0, 0)
+  end
+
+  def test_handler_class_1
+    handler = Chronic::Handler.new([:repeater], :handler)
+
+    tokens = [Chronic::Token.new('friday')]
+    tokens[0].tag(Chronic::RepeaterDayName.new(:friday))
+
+    assert handler.match(tokens, Chronic.definitions)
+
+    tokens << Chronic::Token.new('afternoon')
+    tokens[1].tag(Chronic::RepeaterDayPortion.new(:afternoon))
+
+    assert !handler.match(tokens, Chronic.definitions)
+  end
+
+  def test_handler_class_2
+    handler = Chronic::Handler.new([:repeater, :repeater?], :handler)
+
+    tokens = [Chronic::Token.new('friday')]
+    tokens[0].tag(Chronic::RepeaterDayName.new(:friday))
+
+    assert handler.match(tokens, Chronic.definitions)
+
+    tokens << Chronic::Token.new('afternoon')
+    tokens[1].tag(Chronic::RepeaterDayPortion.new(:afternoon))
+
+    assert handler.match(tokens, Chronic.definitions)
+
+    tokens << Chronic::Token.new('afternoon')
+    tokens[2].tag(Chronic::RepeaterDayPortion.new(:afternoon))
+
+    assert !handler.match(tokens, Chronic.definitions)
+  end
+
+  def test_handler_class_3
+    handler = Chronic::Handler.new([:repeater, 'time?'], :handler)
+
+    tokens = [Chronic::Token.new('friday')]
+    tokens[0].tag(Chronic::RepeaterDayName.new(:friday))
+
+    assert handler.match(tokens, Chronic.definitions)
+
+    tokens << Chronic::Token.new('afternoon')
+    tokens[1].tag(Chronic::RepeaterDayPortion.new(:afternoon))
+
+    assert !handler.match(tokens, Chronic.definitions)
+  end
+
+  def test_handler_class_4
+    handler = Chronic::Handler.new([:repeater_month_name, :scalar_day, 'time?'], :handler)
+
+    tokens = [Chronic::Token.new('may')]
+    tokens[0].tag(Chronic::RepeaterMonthName.new(:may))
+
+    assert !handler.match(tokens, Chronic.definitions)
+
+    tokens << Chronic::Token.new('27')
+    tokens[1].tag(Chronic::ScalarDay.new(27))
+
+    assert handler.match(tokens, Chronic.definitions)
+  end
+
+  def test_handler_class_5
+    handler = Chronic::Handler.new([:repeater, 'time?'], :handler)
+
+    tokens = [Chronic::Token.new('friday')]
+    tokens[0].tag(Chronic::RepeaterDayName.new(:friday))
+
+    assert handler.match(tokens, Chronic.definitions)
+
+    tokens << Chronic::Token.new('5:00')
+    tokens[1].tag(Chronic::RepeaterTime.new('5:00'))
+
+    assert handler.match(tokens, Chronic.definitions)
+
+    tokens << Chronic::Token.new('pm')
+    tokens[2].tag(Chronic::RepeaterDayPortion.new(:pm))
+
+    assert handler.match(tokens, Chronic.definitions)
+  end
+
+  def test_handler_class_6
+    handler = Chronic::Handler.new([:scalar, :repeater, :pointer], :handler)
+
+    tokens = [Chronic::Token.new('3'),
+              Chronic::Token.new('years'),
+              Chronic::Token.new('past')]
+
+    tokens[0].tag(Chronic::Scalar.new(3))
+    tokens[1].tag(Chronic::RepeaterYear.new(:year))
+    tokens[2].tag(Chronic::Pointer.new(:past))
+
+    assert handler.match(tokens, Chronic.definitions)
+  end
+
+end