slaxor-chronic 0.3.1

data/lib/chronic/scalar.rb

@@ -0,0 +1,76 @@
+module Chronic
+
+  class Scalar < Tag #:nodoc:
+    def self.scan(tokens)
+      # 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
+      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)
+          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?$/
+        toi = token.word.to_i
+        unless toi > 31 || toi < 1 || (post_token && %w{am pm morning afternoon evening night}.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?$/
+        toi = token.word.to_i
+        unless toi > 12 || toi < 1 || (post_token && %w{am pm morning afternoon evening night}.include?(post_token.word))
+          return ScalarMonth.new(toi)
+        end
+      end
+      return nil
+    end
+
+    def self.scan_for_years(token, post_token)
+      if token.word =~ /^([1-9]\d)?\d\d?$/
+        unless post_token && %w{am pm morning afternoon evening night}.include?(post_token.word)
+          return ScalarYear.new(token.word.to_i)
+        end
+      end
+      return nil
+    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/separator.rb

@@ -0,0 +1,91 @@
+module Chronic
+
+  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
+        if t = self.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
+    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
+    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
+    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
+    end
+
+    def self.scan_for_on(token)
+      scanner = {/^on$/ => :on}
+      scanner.keys.each do |scanner_item|
+        return SeparatorOn.new(scanner[scanner_item]) if scanner_item =~ token.word
+      end
+      return nil
+    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/time_zone.rb

@@ -0,0 +1,23 @@
+module Chronic
+  class TimeZone < Tag #:nodoc:
+    def self.scan(tokens)
+      tokens.each_index do |i|
+        if t = self.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,
+                 /(tzminus)?\d{4}/ => :tz}
+      scanner.keys.each do |scanner_item|
+        return self.new(scanner[scanner_item]) if scanner_item =~ token.word
+      end
+      return nil
+    end
+
+    def to_s
+      'timezone'
+    end
+  end
+end

data/slaxor-chronic.gemspec

@@ -0,0 +1,85 @@
+Gem::Specification.new do |s|
+  s.specification_version = 2 if s.respond_to? :specification_version=
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.rubygems_version = '1.3.5'
+
+  s.name              = 'slaxor-chronic'
+  s.version           = '0.3.1'
+  s.date              = '2010-10-22'
+  s.rubyforge_project = 'slaxor-chronic'
+
+  s.summary     = "Natural language date/time parsing with proper namespacing."
+  s.description = "Chronic is a natural language date/time parser written in pure Ruby. Use this if you get naming conflicts with the original"
+
+  s.authors  = ["Tom Preston-Werner", "Sascha Teske"]
+  s.email    = 'sascha.teske@gmail.com'
+  s.homepage = 'http://github.com/slaxor/chronic'
+
+  s.require_paths = %w[lib]
+
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.extra_rdoc_files = %w[README.md HISTORY.md LICENSE]
+
+  # = MANIFEST =
+  s.files = %w[
+    HISTORY.md
+    LICENSE
+    Manifest.txt
+    README.md
+    Rakefile
+    benchmark/benchmark.rb
+    slaxor-chronic.gemspec
+    lib/chronic.rb
+    lib/chronic/chronic.rb
+    lib/chronic/grabber.rb
+    lib/chronic/handlers.rb
+    lib/chronic/numerizer/numerizer.rb
+    lib/chronic/ordinal.rb
+    lib/chronic/pointer.rb
+    lib/chronic/repeater.rb
+    lib/chronic/repeaters/repeater_day.rb
+    lib/chronic/repeaters/repeater_day_name.rb
+    lib/chronic/repeaters/repeater_day_portion.rb
+    lib/chronic/repeaters/repeater_fortnight.rb
+    lib/chronic/repeaters/repeater_hour.rb
+    lib/chronic/repeaters/repeater_minute.rb
+    lib/chronic/repeaters/repeater_month.rb
+    lib/chronic/repeaters/repeater_month_name.rb
+    lib/chronic/repeaters/repeater_season.rb
+    lib/chronic/repeaters/repeater_season_name.rb
+    lib/chronic/repeaters/repeater_second.rb
+    lib/chronic/repeaters/repeater_time.rb
+    lib/chronic/repeaters/repeater_week.rb
+    lib/chronic/repeaters/repeater_weekday.rb
+    lib/chronic/repeaters/repeater_weekend.rb
+    lib/chronic/repeaters/repeater_year.rb
+    lib/chronic/scalar.rb
+    lib/chronic/separator.rb
+    lib/chronic/time_zone.rb
+    test/helper.rb
+    test/test_Chronic.rb
+    test/test_DaylightSavings.rb
+    test/test_Handler.rb
+    test/test_Numerizer.rb
+    test/test_RepeaterDayName.rb
+    test/test_RepeaterFortnight.rb
+    test/test_RepeaterHour.rb
+    test/test_RepeaterMinute.rb
+    test/test_RepeaterMonth.rb
+    test/test_RepeaterMonthName.rb
+    test/test_RepeaterTime.rb
+    test/test_RepeaterWeek.rb
+    test/test_RepeaterWeekday.rb
+    test/test_RepeaterWeekend.rb
+    test/test_RepeaterYear.rb
+    test/test_Span.rb
+    test/test_Time.rb
+    test/test_Token.rb
+    test/test_parsing.rb
+  ]
+  # = MANIFEST =
+
+  ## Test files will be grabbed from the file list. Make sure the path glob
+  ## matches what you actually use.
+  s.test_files = s.files.select { |path| path =~ /^test\/test_.*\.rb/ }
+end

data/test/helper.rb

@@ -0,0 +1,7 @@
+require 'test/unit'
+
+dir = File.dirname(File.expand_path(__FILE__))
+$LOAD_PATH.unshift(File.join(dir, '..', 'lib'))
+$LOAD_PATH.unshift(dir)
+
+require 'chronic'

data/test/test_Chronic.rb

@@ -0,0 +1,49 @@
+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_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

data/test/test_DaylightSavings.rb

@@ -0,0 +1,118 @@
+require File.join(File.dirname(__FILE__), *%w[helper])
+
+class TestDaylightSavings < Test::Unit::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