chronic 0.6.3 → 0.10.2

data/lib/chronic/separator.rb

@@ -1,56 +1,126 @@
 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
-        if t = scan_for_slash_or_dash(token) then token.tag(t); next end
+        if t = scan_for_dots(token) then token.tag(t); next end
+        if t = scan_for_colon(token) then token.tag(t); next end
+        if t = scan_for_space(token) then token.tag(t); next end
+        if t = scan_for_slash(token) then token.tag(t); next end
+        if t = scan_for_dash(token) then token.tag(t); next end
+        if t = scan_for_quote(token) then token.tag(t); next end
         if t = scan_for_at(token) then token.tag(t); next end
         if t = scan_for_in(token) then token.tag(t); next end
         if t = scan_for_on(token) then token.tag(t); next end
+        if t = scan_for_and(token) then token.tag(t); next end
+        if t = scan_for_t(token) then token.tag(t); next end
+        if t = scan_for_w(token) then token.tag(t); next end
       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]
-    def self.scan_for_slash_or_dash(token)
-      scan_for token, SeparatorSlashOrDash,
+    # token - The Token object we want to scan.
+    #
+    # Returns a new SeparatorDot object.
+    def self.scan_for_dots(token)
+      scan_for token, SeparatorDot, { /^\.$/ => :dot }
+    end
+
+    # token - The Token object we want to scan.
+    #
+    # Returns a new SeparatorColon object.
+    def self.scan_for_colon(token)
+      scan_for token, SeparatorColon, { /^:$/ => :colon }
+    end
+
+    # token - The Token object we want to scan.
+    #
+    # Returns a new SeparatorSpace object.
+    def self.scan_for_space(token)
+      scan_for token, SeparatorSpace, { /^ $/ => :space }
+    end
+
+    # token - The Token object we want to scan.
+    #
+    # Returns a new SeparatorSlash object.
+    def self.scan_for_slash(token)
+      scan_for token, SeparatorSlash, { /^\/$/ => :slash }
+    end
+
+    # token - The Token object we want to scan.
+    #
+    # Returns a new SeparatorDash object.
+    def self.scan_for_dash(token)
+      scan_for token, SeparatorDash, { /^-$/ => :dash }
+    end
+
+    # token - The Token object we want to scan.
+    #
+    # Returns a new SeparatorQuote object.
+    def self.scan_for_quote(token)
+      scan_for token, SeparatorQuote,
       {
-        /^-$/ => :dash,
-        /^\/$/ => :slash
+        /^'$/ => :single_quote,
+        /^"$/ => :double_quote
       }
     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
 
+    # token - The Token object we want to scan.
+    #
+    # Returns a new SeperatorAnd Object object.
+    def self.scan_for_and(token)
+      scan_for token, SeparatorAnd, { /^and$/ => :and }
+    end
+
+    # token - The Token object we want to scan.
+    #
+    # Returns a new SeperatorT Object object.
+    def self.scan_for_t(token)
+      scan_for token, SeparatorT, { /^t$/ => :T }
+    end
+
+    # token - The Token object we want to scan.
+    #
+    # Returns a new SeperatorW Object object.
+    def self.scan_for_w(token)
+      scan_for token, SeparatorW, { /^w$/ => :W }
+    end
+
     def to_s
       'separator'
     end
@@ -62,9 +132,39 @@ module Chronic
     end
   end
 
-  class SeparatorSlashOrDash < Separator #:nodoc:
+  class SeparatorDot < Separator #:nodoc:
     def to_s
-      super << '-slashordash-' << @type.to_s
+      super << '-dot'
+    end
+  end
+
+  class SeparatorColon < Separator #:nodoc:
+    def to_s
+      super << '-colon'
+    end
+  end
+
+  class SeparatorSpace < Separator #:nodoc:
+    def to_s
+      super << '-space'
+    end
+  end
+
+  class SeparatorSlash < Separator #:nodoc:
+    def to_s
+      super << '-slash'
+    end
+  end
+
+  class SeparatorDash < Separator #:nodoc:
+    def to_s
+      super << '-dash'
+    end
+  end
+
+  class SeparatorQuote < Separator #:nodoc:
+    def to_s
+      super << '-quote-' << @type.to_s
     end
   end
 
@@ -85,4 +185,23 @@ module Chronic
       super << '-on'
     end
   end
-end
+
+  class SeparatorAnd < Separator #:nodoc:
+    def to_s
+      super << '-and'
+    end
+  end
+
+  class SeparatorT < Separator #:nodoc:
+    def to_s
+      super << '-T'
+    end
+  end
+
+  class SeparatorW < Separator #:nodoc:
+    def to_s
+      super << '-W'
+    end
+  end
+
+end

data/lib/chronic/sign.rb

@@ -0,0 +1,49 @@
+module Chronic
+  class Sign < Tag
+
+    # Scan an Array of Token objects and apply any necessary Sign
+    # 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_plus(token) then token.tag(t); next end
+        if t = scan_for_minus(token) then token.tag(t); next end
+      end
+    end
+
+    # token - The Token object we want to scan.
+    #
+    # Returns a new SignPlus object.
+    def self.scan_for_plus(token)
+      scan_for token, SignPlus, { /^\+$/ => :plus }
+    end
+
+    # token - The Token object we want to scan.
+    #
+    # Returns a new SignMinus object.
+    def self.scan_for_minus(token)
+      scan_for token, SignMinus, { /^-$/ => :minus }
+    end
+
+    def to_s
+      'sign'
+    end
+  end
+
+  class SignPlus < Sign #:nodoc:
+    def to_s
+      super << '-plus'
+    end
+  end
+
+  class SignMinus < Sign #:nodoc:
+    def to_s
+      super << '-minus'
+    end
+  end
+
+end

data/lib/chronic/span.rb

@@ -25,7 +25,7 @@ module Chronic
       '(' << self.begin.to_s << '..' << self.end.to_s << ')'
     end
 
-    alias :cover? :include? unless RUBY_VERSION =~ /^1.9/
+    alias :cover? :include? if RUBY_VERSION =~ /^1.8/
 
   end
-end
+end

data/lib/chronic/tag.rb

@@ -1,36 +1,31 @@
 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
-    def initialize(type)
+    # type - The Symbol type of this tag.
+    def initialize(type, options = {})
       @type = type
+      @options = options
     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={})
+      def scan_for(token, klass, items={}, options = {})
         case items
         when Regexp
-          return klass.new(token.word) if items =~ token.word
+          return klass.new(token.word, options) if items =~ token.word
         when Hash
           items.each do |item, symbol|
-            return klass.new(symbol) if item =~ token.word
+            return klass.new(symbol, options) if item =~ token.word
           end
         end
         nil

data/lib/chronic/time.rb

@@ -0,0 +1,40 @@
+module Chronic
+  class Time
+    HOUR_SECONDS = 3600 # 60 * 60
+    MINUTE_SECONDS = 60
+    SECOND_SECONDS = 1 # haha, awesome
+    SUBSECOND_SECONDS = 0.001
+
+    # Checks if given number could be hour
+    def self.could_be_hour?(hour)
+      hour >= 0 && hour <= 24
+    end
+
+    # Checks if given number could be minute
+    def self.could_be_minute?(minute)
+      minute >= 0 && minute <= 60
+    end
+
+    # Checks if given number could be second
+    def self.could_be_second?(second)
+      second >= 0 && second <= 60
+    end
+
+    # Checks if given number could be subsecond
+    def self.could_be_subsecond?(subsecond)
+      subsecond >= 0 && subsecond <= 999999
+    end
+
+    # normalize offset in seconds to offset as string +mm:ss or -mm:ss
+    def self.normalize_offset(offset)
+      return offset if offset.is_a?(String)
+      offset = Chronic.time_class.now.to_time.utc_offset unless offset # get current system's UTC offset if offset is nil
+      sign = '+'
+      sign = '-' if offset < 0
+      hours = (offset.abs / 3600).to_i.to_s.rjust(2,'0')
+      minutes = (offset.abs % 3600).to_s.rjust(2,'0')
+      sign + hours + minutes
+    end
+
+  end
+end

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.
+    #
+    # tag_class - The tag Class to remove.
     #
-    # @param [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
@@ -41,5 +43,9 @@ module Chronic
     def to_s
       @word << '(' << @tags.join(', ') << ') '
     end
+
+    def inspect
+      to_s
+    end
   end
 end

data/lib/chronic.rb

@@ -1,70 +1,10 @@
 require 'time'
 require 'date'
 
-# Parse natural language dates and times into Time or {Chronic::Span} objects
-#
-# @example
-#   require 'chronic'
-#
-#   Time.now   #=> Sun Aug 27 23:18:25 PDT 2006
-#
-#   Chronic.parse('tomorrow')
-#     #=> Mon Aug 28 12:00:00 PDT 2006
-#
-#   Chronic.parse('monday', :context => :past)
-#     #=> Mon Aug 21 12:00:00 PDT 2006
-#
-#   Chronic.parse('this tuesday 5:00')
-#     #=> Tue Aug 29 17:00:00 PDT 2006
-#
-#   Chronic.parse('this tuesday 5:00', :ambiguous_time_range => :none)
-#     #=> Tue Aug 29 05:00:00 PDT 2006
-#
-#   Chronic.parse('may 27th', :now => Time.local(2000, 1, 1))
-#     #=> Sat May 27 12:00:00 PDT 2000
-#
-#   Chronic.parse('may 27th', :guess => false)
-#     #=> Sun May 27 00:00:00 PDT 2007..Mon May 28 00:00:00 PDT 2007
-#
-# @author Tom Preston-Werner, Lee Jarvis
-module Chronic
-  VERSION = "0.6.3"
-
-  class << self
-
-    # @return [Boolean] true when debug mode is enabled
-    attr_accessor :debug
-
-    # @example
-    #   require 'chronic'
-    #   require 'active_support/time'
-    #
-    #   Time.zone = 'UTC'
-    #   Chronic.time_class = Time.zone
-    #   Chronic.parse('June 15 2006 at 5:54 AM')
-    #     # => Thu, 15 Jun 2006 05:45:00 UTC +00:00
-    #
-    # @return [Time] The time class Chronic uses internally
-    attr_accessor :time_class
-
-    # The current Time Chronic is using to base from
-    #
-    # @example
-    #   Time.now #=> 2011-06-06 14:13:43 +0100
-    #   Chronic.parse('yesterday') #=> 2011-06-05 12:00:00 +0100
-    #
-    #   now = Time.local(2025, 12, 24)
-    #   Chronic.parse('tomorrow', :now => now) #=> 2025-12-25 12:00:00 +0000
-    #
-    # @return [Time, nil]
-    attr_accessor :now
-  end
-
-  self.debug = false
-  self.time_class = Time
-end
+require 'chronic/parser'
+require 'chronic/date'
+require 'chronic/time'
 
-require 'chronic/chronic'
 require 'chronic/handler'
 require 'chronic/handlers'
 require 'chronic/mini_date'
@@ -76,6 +16,7 @@ require 'chronic/pointer'
 require 'chronic/scalar'
 require 'chronic/ordinal'
 require 'chronic/separator'
+require 'chronic/sign'
 require 'chronic/time_zone'
 require 'chronic/numerizer'
 require 'chronic/season'
@@ -98,14 +39,112 @@ require 'chronic/repeaters/repeater_minute'
 require 'chronic/repeaters/repeater_second'
 require 'chronic/repeaters/repeater_time'
 
-class Time
-  def self.construct(year, month = 1, day = 1, hour = 0, minute = 0, second = 0)
-    warn "Chronic.construct will be deprecated in version 0.7.0. Please use Chronic.construct instead"
-    Chronic.construct(year, month, day, hour, minute, second)
+# Parse natural language dates and times into Time or Chronic::Span objects.
+#
+# Examples:
+#
+#   require 'chronic'
+#
+#   Time.now   #=> Sun Aug 27 23:18:25 PDT 2006
+#
+#   Chronic.parse('tomorrow')
+#     #=> Mon Aug 28 12:00:00 PDT 2006
+#
+#   Chronic.parse('monday', :context => :past)
+#     #=> Mon Aug 21 12:00:00 PDT 2006
+module Chronic
+  VERSION = "0.10.2"
+
+  class << self
+
+    # Returns true when debug mode is enabled.
+    attr_accessor :debug
+
+    # Examples:
+    #
+    #   require 'chronic'
+    #   require 'active_support/time'
+    #
+    #   Time.zone = 'UTC'
+    #   Chronic.time_class = Time.zone
+    #   Chronic.parse('June 15 2006 at 5:54 AM')
+    #     # => Thu, 15 Jun 2006 05:45:00 UTC +00:00
+    #
+    # Returns The Time class Chronic uses internally.
+    attr_accessor :time_class
+  end
+
+  self.debug = false
+  self.time_class = ::Time
+
+
+  # Parses a string containing a natural language date or time.
+  #
+  # If the parser can find a date or time, either a Time or Chronic::Span
+  # will be returned (depending on the value of `:guess`). If no
+  # date or time can be found, `nil` will be returned.
+  #
+  # text - The String text to parse.
+  # opts - An optional Hash of configuration options passed to Parser::new.
+  def self.parse(text, options = {})
+    Parser.new(options).parse(text)
   end
 
-  def to_minidate
-    warn "Time.to_minidate will be deprecated in version 0.7.0. Please use Chronic::MiniDate.from_time(time) instead"
-    Chronic::MiniDate.from_time(self)
+  # Construct a new time object determining possible month overflows
+  # and leap years.
+  #
+  # year   - Integer year.
+  # month  - Integer month.
+  # day    - Integer day.
+  # hour   - Integer hour.
+  # minute - Integer minute.
+  # second - Integer second.
+  #
+  # Returns a new Time object constructed from these params.
+  def self.construct(year, month = 1, day = 1, hour = 0, minute = 0, second = 0, offset = nil)
+    if second >= 60
+      minute += second / 60
+      second = second % 60
+    end
+
+    if minute >= 60
+      hour += minute / 60
+      minute = minute % 60
+    end
+
+    if hour >= 24
+      day += hour / 24
+      hour = hour % 24
+    end
+
+    # determine if there is a day overflow. this is complicated by our crappy calendar
+    # system (non-constant number of days per month)
+    day <= 56 || raise("day must be no more than 56 (makes month resolution easier)")
+    if day > 28 # no month ever has fewer than 28 days, so only do this if necessary
+      days_this_month = ::Date.leap?(year) ? Date::MONTH_DAYS_LEAP[month] : Date::MONTH_DAYS[month]
+      if day > days_this_month
+        month += day / days_this_month
+        day = day % days_this_month
+      end
+    end
+
+    if month > 12
+      if month % 12 == 0
+        year += (month - 12) / 12
+        month = 12
+      else
+        year += month / 12
+        month = month % 12
+      end
+    end
+    if Chronic.time_class.name == "Date"
+      Chronic.time_class.new(year, month, day)
+    elsif not Chronic.time_class.respond_to?(:new) or (RUBY_VERSION.to_f < 1.9 and Chronic.time_class.name == "Time")
+      Chronic.time_class.local(year, month, day, hour, minute, second)
+    else
+      offset = Time::normalize_offset(offset) if Chronic.time_class.name == "DateTime"
+      Chronic.time_class.new(year, month, day, hour, minute, second, offset)
+    end
   end
+
 end

data/test/helper.rb

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