chronic-davispuh 0.10.2.v0.1da32066b3f46f2506b3471e39557497e34afa27

data/lib/chronic/tokenizer.rb

@@ -0,0 +1,42 @@
+module Chronic
+  module Tokenizer
+    def self.char_type(char)
+      case char
+      when '.'
+        :period
+      when /[[:alpha:]]/
+        :letter
+      when /[[:digit:]]/
+        :digit
+      when /[[:space:]]/
+        :space
+      when /[[:punct:]]/
+        :punct
+      else
+        :other
+      end
+    end
+
+    # Proccess text to tokens
+    def self.tokenize(text)
+      tokens = []
+      index = 0
+      previos_index = 0
+      previos_type = nil
+      text.each_char do |char|
+        type = char_type(char)
+        if previos_type and type != previos_type
+          if not (previos_type == :letter and type == :period)
+            tokens << Token.new(text[previos_index...index], text, previos_index)
+            previos_index = index
+          end
+        end
+        previos_type = type
+        index += 1
+      end
+      tokens << Token.new(text[previos_index...index], text, previos_index)
+      tokens
+    end
+
+  end
+end

data/lib/chronic/version.rb

@@ -0,0 +1,3 @@
+module Chronic
+  VERSION = '0.10.2.v0.1da32066b3f46f2506b3471e39557497e34afa27'
+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::Test
+  def self.test(name, &block)
+    define_method("test_#{name.gsub(/\W/, '_')}", &block) if block
+  end
+end

data/test/test_chronic.rb

@@ -0,0 +1,190 @@
+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::Parser.new.pre_normalize('three quarters'), Chronic::Parser.new.pre_normalize('3 quarters')
+    assert_equal Chronic::Parser.new.pre_normalize('one second'), Chronic::Parser.new.pre_normalize('1 second')
+    assert_equal Chronic::Parser.new.pre_normalize('third'), Chronic::Parser.new.pre_normalize('3rd')
+    assert_equal Chronic::Parser.new.pre_normalize('fourth'), Chronic::Parser.new.pre_normalize('4th')
+  end
+
+  def test_pre_normalize_numerized_string
+    string = 'two and a half years'
+    assert_equal Numerizer.numerize(string), Chronic::Parser.new.pre_normalize(string)
+  end
+
+  def test_post_normalize_am_pm_aliases
+    # affect wanted patterns
+
+    tokens = [Chronic::Token.new("5"), Chronic::Token.new("morning")]
+    tokens[0].tag(Chronic::ScalarHour.new("5", 1))
+    tokens[1].tag(Chronic::TimeSpecial.new(:morning))
+
+    assert_equal :morning, 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::DayName.new(:friday))
+    tokens[1].tag(Chronic::TimeSpecial.new(:morning))
+
+    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::Parser.new.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::Parser.new.guess(span)
+
+    span = Chronic::Span.new(Time.local(2006, 11), Time.local(2006, 12))
+    assert_equal Time.local(2006, 11, 16), Chronic::Parser.new.guess(span)
+  end
+
+  def test_endian_definitions
+    middle = Chronic::EndianDefinitions.middle
+    little = Chronic::EndianDefinitions.little
+
+    assert_equal middle + little, Chronic::SpanDictionary.new.definitions[:endian]
+
+    defs = Chronic::SpanDictionary.new(:endian_precedence => :little).definitions
+    assert_equal little, defs[:endian]
+
+    defs = Chronic::SpanDictionary.new(:endian_precedence => [:little, :middle]).definitions
+    assert_equal little + middle, defs[:endian]
+
+    assert_raises(ArgumentError) do
+      Chronic::SpanDictionary.new(:endian_precedence => :invalid).definitions
+    end
+  end
+
+  def test_debug
+    require 'stringio'
+    $stdout = StringIO.new
+    Chronic.debug = true
+
+    Chronic.parse 'now'
+    assert $stdout.string.include?('now(timespecial-now)')
+  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_equal Time.local(2006, 2, 26), Chronic.construct(2006, 1, 57)
+  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
+
+  def test_time
+    org = Chronic.time_class
+    begin
+      Chronic.time_class = ::Time
+      assert_equal ::Time.new(2013, 8, 27, 20, 30, 40, '+05:30'), Chronic.construct(2013, 8, 27, 20, 30, 40, '+05:30')
+      assert_equal ::Time.new(2013, 8, 27, 20, 30, 40, '-08:00'), Chronic.construct(2013, 8, 27, 20, 30, 40, -28800)
+    ensure
+      Chronic.time_class = org
+    end
+  end
+
+  def test_date
+    org = Chronic.time_class
+    begin
+      Chronic.time_class = ::Date
+      assert_equal Date.new(2013, 8, 27), Chronic.construct(2013, 8, 27)
+    ensure
+      Chronic.time_class = org
+    end
+  end
+
+  def test_datetime
+    org = Chronic.time_class
+    begin
+      Chronic.time_class = ::DateTime
+      assert_equal DateTime.new(2013, 8, 27, 20, 30, 40, '+05:30'), Chronic.construct(2013, 8, 27, 20, 30, 40, '+05:30')
+      assert_equal DateTime.new(2013, 8, 27, 20, 30, 40, '-08:00'), Chronic.construct(2013, 8, 27, 20, 30, 40, -28800)
+    ensure
+      Chronic.time_class = org
+    end
+  end
+
+  def test_valid_options
+    options = {
+      :context => :future,
+      :now => nil,
+      :hours24 => nil,
+      :week_start => :sunday,
+      :guess => true,
+      :ambiguous_time_range => 6,
+      :endian_precedence    => [:middle, :little],
+      :ambiguous_year_future_bias => 50
+    }
+    refute_nil Chronic.parse('now', options)
+  end
+
+  def test_invalid_options
+    assert_raises(ArgumentError) { Chronic.parse('now', foo: 'boo') }
+    assert_raises(ArgumentError) { Chronic.parse('now', time_class: Time) }
+  end
+
+  def test_activesupport
+=begin
+    # ActiveSupport needs MiniTest '~> 4.2' which conflicts with '~> 5.0'
+    require 'active_support/time'
+    org = Chronic.time_class
+    org_zone = ::Time.zone
+    begin
+      ::Time.zone = "Tokyo"
+      Chronic.time_class = ::Time.zone
+      assert_equal Time.new(2013, 8, 27, 20, 30, 40, '+09:00'), Chronic.construct(2013, 8, 27, 20, 30, 40)
+      ::Time.zone = "Indiana (East)"
+      Chronic.time_class = ::Time.zone
+      assert_equal Time.new(2013, 8, 27, 20, 30, 40, -14400), Chronic.construct(2013, 8, 27, 20, 30, 40)
+    ensure
+      Chronic.time_class = org
+      ::Time.zone = org_zone
+    end
+=end
+  end
+end

data/test/test_daylight_savings.rb

@@ -0,0 +1,98 @@
+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
+    # resolve to last night
+    t = Chronic.parse('9:00 PM', :guess => false, :context => :past, :now => @begin_daylight_savings)
+    assert_equal Time.local(2008, 3, 8, 21), t.begin
+
+    # resolve to this afternoon
+    t = Chronic.parse('9:00 PM', :guess => false, :context => :none, :now => Time.local(2008, 3, 9, 22, 0, 0, 0))
+    assert_equal Time.local(2008, 3, 9, 21), t.begin
+
+    # resolve to this morning
+    t = Chronic.parse('4:00 AM', :guess => false, :context => :none, :now => @begin_daylight_savings)
+    assert_equal Time.local(2008, 3, 9, 4), t.begin
+
+    # resolve to today
+    t = Chronic.parse('04:00', :guess => false, :context => :none, :now => @begin_daylight_savings)
+    assert_equal Time.local(2008, 3, 9, 4), t.begin
+
+    # resolve to yesterday
+    t = Chronic.parse('13:00', :guess => false, :context => :past, :now => @begin_daylight_savings)
+    assert_equal Time.local(2008, 3, 8, 13), t.begin
+  end
+
+  def test_begin_future
+    # resolve to this morning
+    t = Chronic.parse('9:00 AM', :guess => false, :now => @begin_daylight_savings)
+    assert_equal Time.local(2008, 3, 9, 9), t.begin
+
+    # resolve to this afternoon
+    t = Chronic.parse('9:00 PM', :guess => false, :now => Time.local(2008, 3, 9, 13, 0, 0, 0))
+    assert_equal Time.local(2008, 3, 9, 21), t.begin
+
+    # resolve to tomorrow
+    t = Chronic.parse('9:00', :guess => false, :now => Time.local(2008, 3, 9, 22, 0, 0, 0))
+    assert_equal Time.local(2008, 3, 10, 9), t.begin
+
+    # resolve to today
+    t = Chronic.parse('09:00', :guess => false, :now => @begin_daylight_savings)
+    assert_equal Time.local(2008, 3, 9, 9), t.begin
+
+    # resolve to tomorrow
+    t = Chronic.parse('04:00', :guess => false, :now => @begin_daylight_savings)
+    assert_equal Time.local(2008, 3, 10, 4), t.begin
+  end
+
+  def test_end_past
+    # resolve to last night
+    t = Chronic.parse('9:00 PM', :guess => false, :context => :past, :now => @end_daylight_savings)
+    assert_equal Time.local(2008, 11, 1, 21), t.begin
+
+    # resolve to this afternoon
+    t = Chronic.parse('9:00 PM', :guess => false, :context => :none, :now => Time.local(2008, 11, 2, 22, 0, 0, 0))
+    assert_equal Time.local(2008, 11, 2, 21), t.begin
+
+    # resolve to this morning
+    t = Chronic.parse('4:00', :guess => false, :context => :none, :now => @end_daylight_savings)
+    assert_equal Time.local(2008, 11, 2, 4), t.begin
+
+    # resolve to today
+    t = Chronic.parse('04:00', :guess => false, :context => :none, :now => @end_daylight_savings)
+    assert_equal Time.local(2008, 11, 2, 4), t.begin
+
+    # resolve to yesterday
+    t = Chronic.parse('13:00', :guess => false, :context => :past, :now => @end_daylight_savings)
+    assert_equal Time.local(2008, 11, 1, 13), t.begin
+  end
+
+  def test_end_future
+    # resolve to this morning
+    t = Chronic.parse('at 9:00', :guess => false, :now => @end_daylight_savings)
+    assert_equal Time.local(2008, 11, 2, 9), t.begin
+
+    # resolve to this afternoon
+    t = Chronic.parse('9:00 PM', :guess => false, :now => Time.local(2008, 11, 2, 13, 0, 0, 0))
+    assert_equal Time.local(2008, 11, 2, 21), t.begin
+
+    # resolve to tomorrow
+    t = Chronic.parse('9:00', :guess => false, :now => Time.local(2008, 11, 2, 22, 0, 0, 0))
+    assert_equal Time.local(2008, 11, 3, 9), t.begin
+
+    # resolve to today
+    t = Chronic.parse('09:00', :guess => false, :now => @end_daylight_savings)
+    assert_equal Time.local(2008, 11, 2, 9), t.begin
+
+    # resolve to tomorrow
+    t = Chronic.parse('04:00', :guess => false, :now => @end_daylight_savings)
+    assert_equal Time.local(2008, 11, 3, 4), t.begin
+  end
+
+end

data/test/test_handler.rb

@@ -0,0 +1,113 @@
+require_relative '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 definitions
+    @definitions ||= Chronic::SpanDictionary.new.definitions
+  end
+
+  def test_handler_class_1
+    tokens = [Chronic::Token.new('friday')]
+    tokens[0].tag(Chronic::DayName.new(:friday))
+
+    assert Chronic::Handler.match(tokens, 0, [Chronic::DayName])
+
+    tokens << Chronic::Token.new('afternoon')
+    tokens[1].tag(Chronic::TimeSpecial.new(:afternoon))
+
+    assert !Chronic::Handler.match(tokens, 1, [Chronic::DayName])
+  end
+
+  def test_handler_class_2
+    tokens = [Chronic::Token.new('friday')]
+    tokens[0].tag(Chronic::DayName.new(:friday))
+
+    assert !Chronic::Handler.match(tokens, 0, [Chronic::TimeSpecial])
+
+    tokens << Chronic::Token.new('afternoon')
+    tokens[1].tag(Chronic::TimeSpecial.new(:afternoon))
+
+    assert Chronic::Handler.match(tokens, 1, [Chronic::TimeSpecial])
+
+    tokens << Chronic::Token.new('afternoon')
+    tokens[2].tag(Chronic::TimeSpecial.new(:afternoon))
+
+    assert Chronic::Handler.match(tokens, 1, [Chronic::TimeSpecial, Chronic::TimeSpecial])
+  end
+
+  def test_handler_class_3
+    tokens = [Chronic::Token.new('friday')]
+    tokens[0].tag(Chronic::DayName.new(:friday))
+
+    assert !Chronic::Handler.match(tokens, 0, [Chronic::DayName, Chronic::TimeSpecial])
+
+    tokens << Chronic::Token.new('afternoon')
+    tokens[1].tag(Chronic::TimeSpecial.new(:afternoon))
+
+    assert Chronic::Handler.match(tokens, 0, [Chronic::DayName, Chronic::TimeSpecial])
+  end
+
+  def test_handler_class_4
+    tokens = [Chronic::Token.new('may')]
+    tokens[0].tag(Chronic::MonthName.new(:may))
+
+    assert !Chronic::Handler.match(tokens, 0, [Chronic::MonthName, Chronic::ScalarDay])
+
+    tokens << Chronic::Token.new('27')
+    tokens[1].tag(Chronic::ScalarDay.new(27))
+
+    assert Chronic::Handler.match(tokens, 0, [Chronic::MonthName, Chronic::ScalarDay])
+  end
+
+  def test_handler_class_5
+    tokens = [Chronic::Token.new('friday')]
+    tokens[0].tag(Chronic::DayName.new(:friday))
+
+    assert !Chronic::Handler.match(tokens, 0, [Chronic::DayName, Chronic::ScalarHour])
+
+    tokens << Chronic::Token.new('5')
+    tokens[1].tag(Chronic::ScalarHour.new('5'))
+
+    assert Chronic::Handler.match(tokens, 0, [Chronic::DayName, Chronic::ScalarHour])
+
+    tokens << Chronic::Token.new('pm')
+    tokens[2].tag(Chronic::DayPortion.new(:pm))
+
+    assert Chronic::Handler.match(tokens, 0, [Chronic::DayName, Chronic::ScalarHour, Chronic::DayPortion])
+  end
+
+  def test_handler_class_6
+    tokens = [Chronic::Token.new('3'),
+              Chronic::Token.new('years'),
+              Chronic::Token.new('past')]
+
+    tokens[0].tag(Chronic::Scalar.new(3))
+    tokens[1].tag(Chronic::UnitYear.new(:year))
+    tokens[2].tag(Chronic::Pointer.new(:past))
+
+    assert Chronic::Handler.match(tokens, 0, [Chronic::Scalar, Chronic::UnitYear, Chronic::Pointer])
+  end
+
+  def test_handler_class_7
+    tokens = [Chronic::Token.new('at'),
+              Chronic::Token.new('14')]
+
+    tokens[0].tag(Chronic::SeparatorAt.new('at'))
+    tokens[1].tag(Chronic::Scalar.new(14))
+
+    assert Chronic::Handler.match(tokens, 0, [Chronic::SeparatorAt, Chronic::Scalar])
+
+    tokens = [Chronic::Token.new('on'),
+              Chronic::Token.new('15')]
+
+    tokens[0].tag(Chronic::SeparatorOn.new('on'))
+    tokens[1].tag(Chronic::Scalar.new(15))
+
+    assert Chronic::Handler.match(tokens, 0, [Chronic::SeparatorOn, Chronic::Scalar])
+  end
+end