chronic 0.4.1 → 0.4.2

data/lib/chronic/pointer.rb

@@ -1,11 +1,20 @@
 module Chronic
-  class Pointer < Tag #:nodoc:
+  class Pointer < Tag
+
+    # Scan an Array of {Token}s and apply any necessary Pointer 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
     def self.scan(tokens, options)
       tokens.each_index do |i|
         if t = scan_for_all(tokens[i]) then tokens[i].tag(t) end
       end
     end
 
+    # @param [Token] token
+    # @return [Pointer, nil]
     def self.scan_for_all(token)
       scan_for token, self,
       {

data/lib/chronic/repeater.rb

@@ -1,5 +1,12 @@
 module Chronic
-  class Repeater < Tag #:nodoc:
+  class Repeater < Tag
+
+    # Scan an Array of {Token}s and apply any necessary Repeater 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
     def self.scan(tokens, options)
       tokens.each_index do |i|
         if t = scan_for_season_names(tokens[i]) then tokens[i].tag(t); next end
@@ -11,6 +18,8 @@ module Chronic
       end
     end
 
+    # @param [Token] token
+    # @return [RepeaterSeasonName, nil]
     def self.scan_for_season_names(token)
       scan_for token, RepeaterSeasonName,
       {
@@ -21,6 +30,8 @@ module Chronic
       }
     end
 
+    # @param [Token] token
+    # @return [RepeaterMonthName, nil]
     def self.scan_for_month_names(token)
       scan_for token, RepeaterMonthName,
       {
@@ -39,6 +50,8 @@ module Chronic
       }
     end
 
+    # @param [Token] token
+    # @return [RepeaterDayName, nil]
     def self.scan_for_day_names(token)
       scan_for token, RepeaterDayName,
       {
@@ -55,6 +68,8 @@ module Chronic
       }
     end
 
+    # @param [Token] token
+    # @return [RepeaterDayPortion, nil]
     def self.scan_for_day_portions(token)
       scan_for token, RepeaterDayPortion,
       {
@@ -67,10 +82,14 @@ module Chronic
       }
     end
 
+    # @param [Token] token
+    # @return [RepeaterTime, nil]
     def self.scan_for_times(token)
       scan_for token, RepeaterTime, /^\d{1,2}(:?\d{2})?([\.:]?\d{2})?$/
     end
 
+    # @param [Token] token
+    # @return [Repeater] A new instance of a subclass of Repeater
     def self.scan_for_units(token)
       {
         /^years?$/ => :year,

data/lib/chronic/repeaters/repeater_month.rb

@@ -2,6 +2,8 @@ module Chronic
   class RepeaterMonth < Repeater #:nodoc:
     MONTH_SECONDS = 2_592_000 # 30 * 24 * 60 * 60
     YEAR_MONTHS = 12
+    MONTH_DAYS = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]
+    MONTH_DAYS_LEAP = [31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]
 
     def initialize(type)
       super
@@ -54,7 +56,11 @@ module Chronic
         new_year += 1
         new_month -= YEAR_MONTHS
       end
-      Time.construct(new_year, new_month, time.day, time.hour, time.min, time.sec)
+
+      days = month_days(new_year, new_month)
+      new_day = time.day > days ? days : time.day
+
+      Time.construct(new_year, new_month, new_day, time.hour, time.min, time.sec)
     end
 
     def width
@@ -64,5 +70,11 @@ module Chronic
     def to_s
       super << '-month'
     end
+
+    private
+
+    def month_days(year, month)
+      Date.leap?(year) ? MONTH_DAYS_LEAP[month - 1] : MONTH_DAYS[month - 1]
+    end
   end
 end

data/lib/chronic/scalar.rb

@@ -1,7 +1,13 @@
 module Chronic
-  class Scalar < Tag #:nodoc:
+  class Scalar < Tag
     DAY_PORTIONS = %w( am pm morning afternoon evening night )
 
+    # Scan an Array of {Token}s and apply any necessary Scalar 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
     def self.scan(tokens, options)
       tokens.each_index do |i|
         if t = scan_for_scalars(tokens[i], tokens[i + 1]) then tokens[i].tag(t) end
@@ -11,6 +17,9 @@ module Chronic
       end
     end
 
+    # @param [Token] token
+    # @param [Token] post_token
+    # @return [Scalar, nil]
     def self.scan_for_scalars(token, post_token)
       if token.word =~ /^\d*$/
         unless post_token && DAY_PORTIONS.include?(post_token.word)
@@ -19,6 +28,9 @@ module Chronic
       end
     end
 
+    # @param [Token] token
+    # @param [Token] post_token
+    # @return [ScalarDay, nil]
     def self.scan_for_days(token, post_token)
       if token.word =~ /^\d\d?$/
         toi = token.word.to_i
@@ -28,6 +40,9 @@ module Chronic
       end
     end
 
+    # @param [Token] token
+    # @param [Token] post_token
+    # @return [ScalarMonth, nil]
     def self.scan_for_months(token, post_token)
       if token.word =~ /^\d\d?$/
         toi = token.word.to_i
@@ -37,6 +52,10 @@ module Chronic
       end
     end
 
+    # @param [Token] token
+    # @param [Token] post_token
+    # @param [Hash] options Options specified in {Chronic.parse}
+    # @return [ScalarYear, nil]
     def self.scan_for_years(token, post_token, options)
       if token.word =~ /^([1-9]\d)?\d\d?$/
         unless post_token && DAY_PORTIONS.include?(post_token.word)
@@ -47,6 +66,15 @@ module Chronic
     end
 
     # Build a year from a 2 digit suffix
+    #
+    # @example
+    #   make_year(96, 50) #=> 1996
+    #   make_year(79, 20) #=> 2079
+    #   make_year(00, 50) #=> 2000
+    #
+    # @param [Integer] year The two digit year to build from
+    # @param [Integer] bias The amount of future years to bias
+    # @return [Integer] The 4 digit year
     def self.make_year(year, bias)
       return year if year.to_s.size > 2
       start_year = Chronic.time_class.now.year - bias

data/lib/chronic/separator.rb

@@ -1,5 +1,12 @@
 module Chronic
-  class Separator < Tag #:nodoc:
+  class Separator < Tag
+
+    # Scan an Array of {Token}s 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
     def self.scan(tokens, options)
       tokens.each_index do |i|
         if t = scan_for_commas(tokens[i]) then tokens[i].tag(t); next end
@@ -10,10 +17,14 @@ module Chronic
       end
     end
 
+    # @param [Token] token
+    # @return [SeparatorComma, nil]
     def self.scan_for_commas(token)
       scan_for token, SeparatorComma, { /^,$/ => :comma }
     end
 
+    # @param [Token] token
+    # @return [SeparatorSlashOrDash, nil]
     def self.scan_for_slash_or_dash(token)
       scan_for token, SeparatorSlashOrDash,
       {
@@ -22,14 +33,20 @@ module Chronic
       }
     end
 
+    # @param [Token] token
+    # @return [SeparatorAt, nil]
     def self.scan_for_at(token)
       scan_for token, SeparatorAt, { /^(at|@)$/ => :at }
     end
 
+    # @param [Token] token
+    # @return [SeparatorIn, nil]
     def self.scan_for_in(token)
       scan_for token, SeparatorIn, { /^in$/ => :in }
     end
 
+    # @param [Token] token
+    # @return [SeparatorOn, nil]
     def self.scan_for_on(token)
       scan_for token, SeparatorOn, { /^on$/ => :on }
     end

data/lib/chronic/time_zone.rb

@@ -1,11 +1,20 @@
 module Chronic
-  class TimeZone < Tag #:nodoc:
+  class TimeZone < Tag
+
+    # Scan an Array of {Token}s 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
     def self.scan(tokens, options)
       tokens.each_index do |i|
         if t = scan_for_all(tokens[i]) then tokens[i].tag(t); next end
       end
     end
 
+    # @param [Token] token
+    # @return [TimeZone, nil]
     def self.scan_for_all(token)
       scan_for token, self,
       {

data/lib/chronic/token.rb

@@ -1,6 +1,11 @@
 module Chronic
-  class Token #:nodoc:
-    attr_accessor :word, :tags
+  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)
       @word = word
@@ -8,21 +13,26 @@ module Chronic
     end
 
     # Tag this token with the specified tag
+    #
+    # @param [Tag] new_tag A instance of {Tag} or one of its subclasses
     def tag(new_tag)
       @tags << new_tag
     end
 
     # Remove all tags of the given class
+    #
+    # @param [Class] The tag class to remove
     def untag(tag_class)
       @tags.delete_if { |m| m.kind_of? tag_class }
     end
 
-    # Return true if this token has any tags
+    # @return [Boolean] true if this token has any tags
     def tagged?
       @tags.size > 0
     end
 
-    # Return the Tag that matches the given class
+    # @param [Class] tag_class The tag class to search for
+    # @return [Tag] The first Tag that matches the given class
     def get_tag(tag_class)
       @tags.find { |m| m.kind_of? tag_class }
     end

data/test/test_Chronic.rb

@@ -21,7 +21,7 @@ class TestChronic < Test::Unit::TestCase
 
     assert_equal :morning, tokens[1].tags[0].type
 
-    tokens = Chronic.dealias_and_disambiguate_times(tokens, {})
+    tokens = Chronic::Handlers.dealias_and_disambiguate_times(tokens, {})
 
     assert_equal :am, tokens[1].tags[0].type
     assert_equal 2, tokens.size
@@ -34,7 +34,7 @@ class TestChronic < Test::Unit::TestCase
 
     assert_equal :morning, tokens[1].tags[0].type
 
-    tokens = Chronic.dealias_and_disambiguate_times(tokens, {})
+    tokens = Chronic::Handlers.dealias_and_disambiguate_times(tokens, {})
 
     assert_equal :morning, tokens[1].tags[0].type
     assert_equal 2, tokens.size
@@ -51,4 +51,54 @@ class TestChronic < Test::Unit::TestCase
     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(Chronic::InvalidArgumentException) do
+      Chronic.definitions(:endian_precedence => :invalid)
+    end
+  end
+
+  def test_passing_options
+    assert_raises(Chronic::InvalidArgumentException) do
+      Chronic.parse('now', :invalid => :option)
+    end
+
+    assert_raises(Chronic::InvalidArgumentException) 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
+
 end

data/test/test_RepeaterMonth.rb

@@ -23,6 +23,10 @@ class TestRepeaterMonth < Test::Unit::TestCase
 
     time = Chronic::RepeaterMonth.new(:month).offset_by(@now, 10, :past)
     assert_equal Time.local(2005, 10, 16, 14), time
+
+    time = Chronic::RepeaterMonth.new(:month).offset_by(Time.local(2010, 3, 29), 1, :past)
+    assert_equal 2, time.month
+    assert_equal 28, time.day
   end
 
   def test_offset

metadata

@@ -2,7 +2,7 @@
 name: chronic
 version: !ruby/object:Gem::Version 
   prerelease: 
-  version: 0.4.1
+  version: 0.4.2
 platform: ruby
 authors: 
 - Tom Preston-Werner
@@ -11,7 +11,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-06-05 00:00:00 Z
+date: 2011-06-07 00:00:00 Z
 dependencies: []
 
 description: Chronic is a natural language date/time parser written in pure Ruby.