chronic 0.6.7 → 0.7.0

data/lib/chronic/separator.rb

@@ -1,12 +1,13 @@
 module Chronic
   class Separator < Tag
 
-    # Scan an Array of {Token}s and apply any necessary Separator tags to
-    # each token
+    # Scan an Array of Token objects 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
+    # 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_commas(token) then token.tag(t); next end
@@ -17,14 +18,16 @@ module Chronic
       end
     end
 
-    # @param [Token] token
-    # @return [SeparatorComma, nil]
+    # token - The Token object we want to scan.
+    #
+    # Returns a new SeparatorComma object.
     def self.scan_for_commas(token)
       scan_for token, SeparatorComma, { /^,$/ => :comma }
     end
 
-    # @param [Token] token
-    # @return [SeparatorSlashOrDash, nil]
+    # token - The Token object we want to scan.
+    #
+    # Returns a new SeparatorSlashOrDash object.
     def self.scan_for_slash_or_dash(token)
       scan_for token, SeparatorSlashOrDash,
       {
@@ -33,20 +36,23 @@ module Chronic
       }
     end
 
-    # @param [Token] token
-    # @return [SeparatorAt, nil]
+    # token - The Token object we want to scan.
+    #
+    # Returns a new SeparatorAt object.
     def self.scan_for_at(token)
       scan_for token, SeparatorAt, { /^(at|@)$/ => :at }
     end
 
-    # @param [Token] token
-    # @return [SeparatorIn, nil]
+    # token - The Token object we want to scan.
+    #
+    # Returns a new SeparatorIn object.
     def self.scan_for_in(token)
       scan_for token, SeparatorIn, { /^in$/ => :in }
     end
 
-    # @param [Token] token
-    # @return [SeparatorOn, nil]
+    # token - The Token object we want to scan.
+    #
+    # Returns a new SeparatorOn object.
     def self.scan_for_on(token)
       scan_for token, SeparatorOn, { /^on$/ => :on }
     end

data/lib/chronic/tag.rb

@@ -1,29 +1,23 @@
 module Chronic
   # Tokens are tagged with subclassed instances of this class when
-  # they match specific criteria
+  # they match specific criteria.
   class Tag
 
-    # @return [Symbol]
     attr_accessor :type
 
-    # @param [Symbol] type
+    # type - The Symbol type of this tag.
     def initialize(type)
       @type = type
     end
 
-    # @param [Time] s Set the start timestamp for this Tag
-    def start=(s)
-      @now = s
+    # time - Set the start Time for this Tag.
+    def start=(time)
+      @now = time
     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

data/lib/chronic/time_zone.rb

@@ -1,20 +1,22 @@
 module Chronic
   class TimeZone < Tag
 
-    # Scan an Array of {Token}s and apply any necessary TimeZone tags to
-    # each token
+    # Scan an Array of Token objects 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
+    # 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
 
-    # @param [Token] token
-    # @return [TimeZone, nil]
+    # token - The Token object we want to scan.
+    #
+    # Returns a new Pointer object.
     def self.scan_for_all(token)
       scan_for token, self,
       {

data/lib/chronic/token.rb

@@ -1,10 +1,7 @@
 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)
@@ -12,27 +9,32 @@ module Chronic
       @tags = []
     end
 
-    # Tag this token with the specified tag
+    # Tag this token with the specified tag.
+    #
+    # new_tag - The new Tag object.
     #
-    # @param [Tag] new_tag An instance of {Tag} or one of its subclasses
+    # Returns nothing.
     def tag(new_tag)
       @tags << new_tag
     end
 
-    # Remove all tags of the given class
+    # Remove all tags of the given class.
     #
-    # @param [Class] The tag class to remove
+    # tag_class - The tag Class to remove.
+    #
+    # Returns nothing.
     def untag(tag_class)
       @tags.delete_if { |m| m.kind_of? tag_class }
     end
 
-    # @return [Boolean] true if this token has any tags
+    # Returns 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
+    # 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

data/test/helper.rb

@@ -3,4 +3,10 @@ unless defined? Chronic
   require 'chronic'
 end
 
-require 'test/unit'
+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 → test_chronic.rb}

@@ -1,12 +1,16 @@
 require 'helper'
 
-class TestChronic < Test::Unit::TestCase
+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)
@@ -131,11 +135,7 @@ class TestChronic < Test::Unit::TestCase
     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_nothing_raised do
-      Chronic.construct(2006, 1, 56)
-    end
-
-    assert_raise(RuntimeError) do
+    assert_raises(RuntimeError) do
       Chronic.construct(2006, 1, 57)
     end
   end

data/test/{test_DaylightSavings.rb → test_daylight_savings.rb}

@@ -1,6 +1,6 @@
 require 'helper'
 
-class TestDaylightSavings < Test::Unit::TestCase
+class TestDaylightSavings < TestCase
 
   def setup
     @begin_daylight_savings = Time.local(2008, 3, 9, 5, 0, 0, 0)

data/test/{test_Handler.rb → test_handler.rb}

@@ -1,6 +1,6 @@
 require 'helper'
 
-class TestHandler < Test::Unit::TestCase
+class TestHandler < TestCase
 
   def setup
     # Wed Aug 16 14:00:00 UTC 2006

data/test/{test_MiniDate.rb → test_mini_date.rb}

@@ -1,32 +1,32 @@
 require 'helper'
 
-class TestMiniDate < Test::Unit::TestCase
+class TestMiniDate < TestCase
   def test_valid_month
-    assert_raise(ArgumentError){ Chronic::MiniDate.new(0,12) }
-    assert_raise(ArgumentError){ Chronic::MiniDate.new(13,1) }
+    assert_raises(ArgumentError){ Chronic::MiniDate.new(0,12) }
+    assert_raises(ArgumentError){ Chronic::MiniDate.new(13,1) }
   end
-  
+
   def test_is_between
     m=Chronic::MiniDate.new(3,2)
     assert m.is_between?(Chronic::MiniDate.new(2,4), Chronic::MiniDate.new(4,7))
-    assert !m.is_between?(Chronic::MiniDate.new(1,5), Chronic::MiniDate.new(2,7))    
-    
+    assert !m.is_between?(Chronic::MiniDate.new(1,5), Chronic::MiniDate.new(2,7))
+
     #There was a hang if date tested is in december and outside the testing range
     m=Chronic::MiniDate.new(12,24)
     assert !m.is_between?(Chronic::MiniDate.new(10,1), Chronic::MiniDate.new(12,21))
   end
-  
+
   def test_is_between_short_range
     m=Chronic::MiniDate.new(5,10)
     assert m.is_between?(Chronic::MiniDate.new(5,3), Chronic::MiniDate.new(5,12))
     assert !m.is_between?(Chronic::MiniDate.new(5,11), Chronic::MiniDate.new(5,15))
   end
-  
+
   def test_is_between_wrapping_range
     m=Chronic::MiniDate.new(1,1)
     assert m.is_between?(Chronic::MiniDate.new(11,11), Chronic::MiniDate.new(2,2))
     m=Chronic::MiniDate.new(12,12)
     assert m.is_between?(Chronic::MiniDate.new(11,11), Chronic::MiniDate.new(1,5))
   end
-  
+
 end

data/test/{test_Numerizer.rb → test_numerizer.rb}

@@ -1,6 +1,6 @@
 require 'helper'
 
-class ParseNumbersTest < Test::Unit::TestCase
+class ParseNumbersTest < TestCase
 
   def test_straight_parsing
     strings = {

data/test/test_parsing.rb

@@ -1,6 +1,6 @@
 require 'helper'
 
-class TestParsing < Test::Unit::TestCase
+class TestParsing < TestCase
   # Wed Aug 16 14:00:00 UTC 2006
   TIME_2006_08_16_14_00_00 = Time.local(2006, 8, 16, 14, 0, 0, 0)
 
@@ -252,6 +252,9 @@ class TestParsing < Test::Unit::TestCase
 
     time = parse_now("27/5/1979 @ 0700")
     assert_equal Time.local(1979, 5, 27, 7), time
+
+    time = parse_now("03/18/2012 09:26 pm")
+    assert_equal Time.local(2012, 3, 18, 21, 26), time
   end
 
   def test_handle_sy_sm_sd
@@ -278,19 +281,34 @@ class TestParsing < Test::Unit::TestCase
 
     time = parse_now("1902-08-20")
     assert_equal Time.local(1902, 8, 20, 12, 0, 0), time
+
+    # exif date time original
+    time = parse_now("2012:05:25 22:06:50")
+    assert_equal Time.local(2012, 5, 25, 22, 6, 50), time
   end
 
-  def test_handle_sm_sy
+  def test_handle_sm_sd
     time = parse_now("05/06")
-    assert_equal Time.local(2006, 5, 16, 12), time
+    assert_equal Time.local(2006, 5, 6, 12), time
 
-    time = parse_now("12/06")
-    assert_equal Time.local(2006, 12, 16, 12), time
+    time = parse_now("05/06", :endian_precedence => [:little, :medium])
+    assert_equal Time.local(2006, 6, 5, 12), time
 
-    time = parse_now("13/06")
-    assert_equal nil, time
+    time = parse_now("13/01")
+    assert_nil time
   end
 
+  # def test_handle_sm_sy
+  #   time = parse_now("05/06")
+  #   assert_equal Time.local(2006, 5, 16, 12), time
+  #
+  #   time = parse_now("12/06")
+  #   assert_equal Time.local(2006, 12, 16, 12), time
+  #
+  #   time = parse_now("13/06")
+  #   assert_equal nil, time
+  # end
+
   def test_handle_r
   end
 
@@ -354,6 +372,11 @@ class TestParsing < Test::Unit::TestCase
     assert_equal Time.local(2006, 8, 9, 12), time
   end
 
+  def test_handle_sm_rmn_sy
+    time = parse_now('30-Mar-11')
+    assert_equal Time.local(2011, 3, 30, 12), time
+  end
+
   # end of testing handlers
 
   def test_parse_guess_r
@@ -575,13 +598,33 @@ class TestParsing < Test::Unit::TestCase
     time = parse_now("tonight")
     assert_equal Time.local(2006, 8, 16, 22), time
 
+    # hour
+
+    time = parse_now("next hr")
+    assert_equal Time.local(2006, 8, 16, 15, 30, 0), time
+
+    time = parse_now("next hrs")
+    assert_equal Time.local(2006, 8, 16, 15, 30, 0), time
+
     # minute
 
+    time = parse_now("next min")
+    assert_equal Time.local(2006, 8, 16, 14, 1, 30), time
+
+    time = parse_now("next mins")
+    assert_equal Time.local(2006, 8, 16, 14, 1, 30), time
+
     time = parse_now("next minute")
     assert_equal Time.local(2006, 8, 16, 14, 1, 30), time
 
     # second
 
+    time = parse_now("next sec")
+    assert_equal Time.local(2006, 8, 16, 14, 0, 1), time
+
+    time = parse_now("next secs")
+    assert_equal Time.local(2006, 8, 16, 14, 0, 1), time
+
     time = parse_now("this second")
     assert_equal Time.local(2006, 8, 16, 14), time
 
@@ -674,6 +717,20 @@ class TestParsing < Test::Unit::TestCase
     assert_equal Time.local(2006, 8, 8, 12), time
   end
 
+  def test_parse_guess_a_ago
+    time = parse_now("AN hour ago")
+    assert_equal Time.local(2006, 8, 16, 13), time
+
+    time = parse_now("A day ago")
+    assert_equal Time.local(2006, 8, 15, 14), time
+
+    time = parse_now("a month ago")
+    assert_equal Time.local(2006, 7, 16, 14), time
+
+    time = parse_now("a year ago")
+    assert_equal Time.local(2005, 8, 16, 14), time
+  end
+
   def test_parse_guess_s_r_p
     # past
 
@@ -836,6 +893,7 @@ class TestParsing < Test::Unit::TestCase
     assert_equal parse_now("33 days from now"), parse_now("thirty-three days from now")
     assert_equal parse_now("2867532 seconds from now"), parse_now("two million eight hundred and sixty seven thousand five hundred and thirty two seconds from now")
     assert_equal parse_now("may 10th"), parse_now("may tenth")
+    assert_equal parse_now("second monday in january"), parse_now("2nd monday in january")
   end
 
   def test_parse_only_complete_pointers
@@ -855,11 +913,11 @@ class TestParsing < Test::Unit::TestCase
   end
 
   def test_argument_validation
-    assert_raise(ArgumentError) do
+    assert_raises(ArgumentError) do
       time = Chronic.parse("may 27", :foo => :bar)
     end
 
-    assert_raise(ArgumentError) do
+    assert_raises(ArgumentError) do
       time = Chronic.parse("may 27", :context => :bar)
     end
   end
@@ -915,7 +973,7 @@ class TestParsing < Test::Unit::TestCase
     t1 = Chronic.parse("now")
     sleep 0.1
     t2 = Chronic.parse("now")
-    assert_not_equal t1, t2
+    refute_equal t1, t2
   end
 
   def test_noon