chronic 0.2.2 → 0.10.2

data/lib/chronic/chronic.rb

@@ -1,239 +0,0 @@
-module Chronic
-  class << self
-    
-    # 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 <tt>:guess</tt>). If no date or time can be found,
-    # +nil+ will be returned.
-    #
-    # Options are:
-    #
-    # [<tt>:context</tt>]
-    #     <tt>:past</tt> or <tt>:future</tt> (defaults to <tt>:future</tt>)
-    #
-    #     If your string represents a birthday, you can set <tt>:context</tt> to <tt>:past</tt> 
-    #     and if an ambiguous string is given, it will assume it is in the 
-    #     past. Specify <tt>:future</tt> or omit to set a future context.
-    #
-    # [<tt>:now</tt>]
-    #     Time (defaults to Time.now)
-    #
-    #     By setting <tt>:now</tt> to a Time, all computations will be based off
-    #     of that time instead of Time.now
-    #
-    # [<tt>:guess</tt>]
-    #     +true+ or +false+ (defaults to +true+)
-    #
-    #     By default, the parser will guess a single point in time for the
-    #     given date or time. If you'd rather have the entire time span returned,
-    #     set <tt>:guess</tt> to +false+ and a Chronic::Span will be returned.
-    #     
-    # [<tt>:ambiguous_time_range</tt>]
-    #     Integer or <tt>:none</tt> (defaults to <tt>6</tt> (6am-6pm))
-    #
-    #     If an Integer is given, ambiguous times (like 5:00) will be 
-    #     assumed to be within the range of that time in the AM to that time
-    #     in the PM. For example, if you set it to <tt>7</tt>, then the parser will
-    #     look for the time between 7am and 7pm. In the case of 5:00, it would
-    #     assume that means 5:00pm. If <tt>:none</tt> is given, no assumption
-    #     will be made, and the first matching instance of that time will 
-    #     be used.
-    def parse(text, specified_options = {})
-      # get options and set defaults if necessary
-      default_options = {:context => :future,
-                         :now => Time.now,
-                         :guess => true,
-                         :ambiguous_time_range => 6}
-      options = default_options.merge specified_options
-            
-      # ensure the specified options are valid
-      specified_options.keys.each do |key|
-        default_options.keys.include?(key) || raise(InvalidArgumentException, "#{key} is not a valid option key.")
-      end
-      [:past, :future, :none].include?(options[:context]) || raise(InvalidArgumentException, "Invalid value ':#{options[:context]}' for :context specified. Valid values are :past and :future.")
-      
-      # store now for later =)
-      @now = options[:now]
-      
-      # put the text into a normal format to ease scanning
-      text = self.pre_normalize(text)
-          
-      # get base tokens for each word
-      @tokens = self.base_tokenize(text)
-    
-      # scan the tokens with each token scanner
-      [Repeater].each do |tokenizer|
-        @tokens = tokenizer.scan(@tokens, options)
-      end
-      
-      [Grabber, Pointer, Scalar, Ordinal, Separator, TimeZone].each do |tokenizer|
-        @tokens = tokenizer.scan(@tokens)
-      end
-      
-      # strip any non-tagged tokens
-      @tokens = @tokens.select { |token| token.tagged? }
-      
-      if Chronic.debug
-        puts "+---------------------------------------------------"
-        puts "| " + @tokens.to_s
-        puts "+---------------------------------------------------"
-      end
-      
-      # do the heavy lifting
-      begin
-        span = self.tokens_to_span(@tokens, options)
-      rescue
-        raise
-        return nil
-      end
-      
-      # guess a time within a span if required
-      if options[:guess]
-        return self.guess(span)
-      else
-        return span
-      end
-    end
-    
-    # Clean up the specified input text by stripping unwanted characters,
-    # converting idioms to their canonical form, converting number words
-    # to numbers (three => 3), and converting ordinal words to numeric
-    # ordinals (third => 3rd)
-    def pre_normalize(text) #:nodoc:
-      normalized_text = text.to_s.downcase
-      normalized_text = numericize_numbers(normalized_text)
-      normalized_text.gsub!(/['"\.]/, '')
-      normalized_text.gsub!(/([\/\-\,\@])/) { ' ' + $1 + ' ' }
-      normalized_text.gsub!(/\btoday\b/, 'this day')
-      normalized_text.gsub!(/\btomm?orr?ow\b/, 'next day')
-      normalized_text.gsub!(/\byesterday\b/, 'last day')
-      normalized_text.gsub!(/\bnoon\b/, '12:00')
-      normalized_text.gsub!(/\bmidnight\b/, '24:00')
-      normalized_text.gsub!(/\bbefore now\b/, 'past')
-      normalized_text.gsub!(/\bnow\b/, 'this second')
-      normalized_text.gsub!(/\b(ago|before)\b/, 'past')
-      normalized_text.gsub!(/\bthis past\b/, 'last')
-      normalized_text.gsub!(/\bthis last\b/, 'last')
-      normalized_text.gsub!(/\b(?:in|during) the (morning)\b/, '\1')
-      normalized_text.gsub!(/\b(?:in the|during the|at) (afternoon|evening|night)\b/, '\1')
-      normalized_text.gsub!(/\btonight\b/, 'this night')
-      normalized_text.gsub!(/(?=\w)([ap]m|oclock)\b/, ' \1')
-      normalized_text.gsub!(/\b(hence|after|from)\b/, 'future')
-      normalized_text = numericize_ordinals(normalized_text)
-    end
-  
-    # Convert number words to numbers (three => 3)
-    def numericize_numbers(text) #:nodoc:
-      Numerizer.numerize(text)
-    end
-  
-    # Convert ordinal words to numeric ordinals (third => 3rd)
-    def numericize_ordinals(text) #:nodoc:
-      text
-    end
-  
-    # Split the text on spaces and convert each word into
-    # a Token
-    def base_tokenize(text) #:nodoc:
-      text.split(' ').map { |word| Token.new(word) }
-    end
-    
-    # Guess a specific time within the given span
-    def guess(span) #:nodoc:
-      return nil if span.nil?
-      if span.width > 1
-        span.begin + (span.width / 2)
-      else
-        span.begin
-      end
-    end
-  end
-  
-  class Token #:nodoc:
-    attr_accessor :word, :tags
-    
-    def initialize(word)
-      @word = word
-      @tags = []
-    end
-    
-    # Tag this token with the specified tag
-    def tag(new_tag)
-      @tags << new_tag
-    end
-    
-    # Remove all tags of the given class
-    def untag(tag_class)
-      @tags = @tags.select { |m| !m.kind_of? tag_class }
-    end
-    
-    # Return true if this token has any tags
-    def tagged?
-      @tags.size > 0
-    end
-    
-    # Return the Tag that matches the given class
-    def get_tag(tag_class)
-      matches = @tags.select { |m| m.kind_of? tag_class }
-      #matches.size < 2 || raise("Multiple identical tags found")
-      return matches.first
-    end
-    
-    # Print this Token in a pretty way
-    def to_s
-      @word << '(' << @tags.join(', ') << ') '
-    end
-  end
-  
-  # A Span represents a range of time. Since this class extends
-  # Range, you can use #begin and #end to get the beginning and
-  # ending times of the span (they will be of class Time)
-  class Span < Range   
-    # Returns the width of this span in seconds   
-    def width
-      (self.end - self.begin).to_i
-    end
-    
-    # Add a number of seconds to this span, returning the 
-    # resulting Span
-    def +(seconds)
-      Span.new(self.begin + seconds, self.end + seconds)
-    end
-    
-    # Subtract a number of seconds to this span, returning the 
-    # resulting Span
-    def -(seconds)
-      self + -seconds
-    end
-    
-    # Prints this span in a nice fashion
-    def to_s
-      '(' << self.begin.to_s << '..' << self.end.to_s << ')'
-    end
-  end
-
-  # Tokens are tagged with subclassed instances of this class when
-  # they match specific criteria
-  class Tag #:nodoc:
-    attr_accessor :type
-    
-    def initialize(type)
-      @type = type
-    end
-    
-    def start=(s)
-      @now = s
-    end
-  end
-  
-  # Internal exception
-  class ChronicPain < Exception #:nodoc:
-    
-  end
-  
-  # This exception is raised if an invalid argument is provided to
-  # any of Chronic's methods
-  class InvalidArgumentException < Exception
-    
-  end
-end

data/lib/numerizer/numerizer.rb

@@ -1,103 +0,0 @@
-require 'strscan'
-
-class Numerizer
-
-  DIRECT_NUMS = [
-                  ['eleven', '11'],
-                  ['twelve', '12'],
-                  ['thirteen', '13'],
-                  ['fourteen', '14'],
-                  ['fifteen', '15'],
-                  ['sixteen', '16'],
-                  ['seventeen', '17'],
-                  ['eighteen', '18'],
-                  ['nineteen', '19'],
-                  ['ninteen', '19'], # Common mis-spelling
-                  ['zero', '0'],
-                  ['one', '1'],
-                  ['two', '2'],
-                  ['three', '3'],
-                  ['four(\W|$)', '4\1'],  # The weird regex is so that it matches four but not fourty
-                  ['five', '5'],
-                  ['six(\W|$)', '6\1'],
-                  ['seven(\W|$)', '7\1'],
-                  ['eight(\W|$)', '8\1'],
-                  ['nine(\W|$)', '9\1'],
-                  ['ten', '10'],
-                  ['\ba[\b^$]', '1'] # doesn't make sense for an 'a' at the end to be a 1
-                ]
-
-  TEN_PREFIXES = [ ['twenty', 20],
-                    ['thirty', 30],
-                    ['fourty', 40],
-                    ['fifty', 50],
-                    ['sixty', 60],
-                    ['seventy', 70],
-                    ['eighty', 80],
-                    ['ninety', 90]
-                  ]
-
-  BIG_PREFIXES = [ ['hundred', 100],
-                    ['thousand', 1000],
-                    ['million', 1_000_000],
-                    ['billion', 1_000_000_000],
-                    ['trillion', 1_000_000_000_000],
-                  ]
-
-class << self
-  def numerize(string)
-    string = string.dup
-  
-    # preprocess
-    string.gsub!(/ +|([^\d])-([^d])/, '\1 \2') # will mutilate hyphenated-words but shouldn't matter for date extraction
-    string.gsub!(/a half/, 'haAlf') # take the 'a' out so it doesn't turn into a 1, save the half for the end
-
-    # easy/direct replacements
-  
-    DIRECT_NUMS.each do |dn|
-      string.gsub!(/#{dn[0]}/i, dn[1])
-    end
-
-    # ten, twenty, etc.
-
-    TEN_PREFIXES.each do |tp|
-      string.gsub!(/(?:#{tp[0]})( *\d(?=[^\d]|$))*/i) { (tp[1] + $1.to_i).to_s }
-    end
-
-    # hundreds, thousands, millions, etc.
-
-    BIG_PREFIXES.each do |bp|
-      string.gsub!(/(\d*) *#{bp[0]}/i) { (bp[1] * $1.to_i).to_s}
-      andition(string)
-      #combine_numbers(string) # Should to be more efficient way to do this
-    end
-
-    # fractional addition
-    # I'm not combining this with the previous block as using float addition complicates the strings
-    # (with extraneous .0's and such )
-    string.gsub!(/(\d+)(?: | and |-)*haAlf/i) { ($1.to_f + 0.5).to_s }
-
-    string
-  end
-
-private
-  def andition(string)
-    sc = StringScanner.new(string)
-    while(sc.scan_until(/(\d+)( | and )(\d+)(?=[^\w]|$)/i))
-      if sc[2] =~ /and/ || sc[1].size > sc[3].size
-        string[(sc.pos - sc.matched_size)..(sc.pos-1)] = (sc[1].to_i + sc[3].to_i).to_s
-        sc.reset
-      end
-    end
-  end
-
-#  def combine_numbers(string)
-#    sc = StringScanner.new(string)
-#    while(sc.scan_until(/(\d+)(?: | and |-)(\d+)(?=[^\w]|$)/i))
-#      string[(sc.pos - sc.matched_size)..(sc.pos-1)] = (sc[1].to_i + sc[2].to_i).to_s
-#      sc.reset
-#    end
-#  end
-
-end
-end

data/test/suite.rb

@@ -1,9 +0,0 @@
-require 'test/unit'
-
-tests = Dir["#{File.dirname(__FILE__)}/test_*.rb"]
-tests.delete_if { |o| o =~ /test_parsing/ }
-tests.each do |file|
-  require file
-end
-
-require File.dirname(__FILE__) + '/test_parsing.rb'

data/test/test_Chronic.rb

@@ -1,50 +0,0 @@
-require 'chronic'
-require 'test/unit'
-
-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_Numerizer.rb

@@ -1,48 +0,0 @@
-require 'test/unit'
-require 'chronic'
-
-class ParseNumbersTest < Test::Unit::TestCase
-
-  def test_straight_parsing
-    strings = { 1 => 'one',
-               5 => 'five',
-               10 => 'ten',
-               11 => 'eleven',
-               12 => 'twelve',
-               13 => 'thirteen',
-               14 => 'fourteen',
-               15 => 'fifteen',
-               16 => 'sixteen',
-               17 => 'seventeen',
-               18 => 'eighteen',
-               19 => 'nineteen',
-               20 => 'twenty',
-               27 => 'twenty seven',
-               31 => 'thirty-one',
-               59 => 'fifty nine',
-               100 => 'a hundred',
-               100 => 'one hundred',
-               150 => 'one hundred and fifty',
-            #   150 => 'one fifty',
-               200 => 'two-hundred',
-               500 => '5 hundred',
-               999 => 'nine hundred and ninety nine',
-               1_000 => 'one thousand',
-               1_200 => 'twelve hundred',
-               1_200 => 'one thousand two hundred',
-               17_000 => 'seventeen thousand',
-               21_473 => 'twentyone-thousand-four-hundred-and-seventy-three',
-               74_002 => 'seventy four thousand and two',
-               99_999 => 'ninety nine thousand nine hundred ninety nine',
-               100_000 => '100 thousand',
-               250_000 => 'two hundred fifty thousand',
-               1_000_000 => 'one million',
-               1_250_007 => 'one million two hundred fifty thousand and seven',
-               1_000_000_000 => 'one billion',
-               1_000_000_001 => 'one billion and one' }
-               
-    strings.keys.sort.each do |key|
-      assert_equal key, Numerizer.numerize(strings[key]).to_i
-    end
-  end
-end

data/test/test_Time.rb

@@ -1,50 +0,0 @@
-require 'chronic'
-require 'test/unit'
-
-class TestTime < Test::Unit::TestCase
-  
-  def setup
-  end
-  
-  def test_normal
-    assert_equal Time.local(2006, 1, 2, 0, 0, 0), Time.construct(2006, 1, 2, 0, 0, 0)
-    assert_equal Time.local(2006, 1, 2, 3, 0, 0), Time.construct(2006, 1, 2, 3, 0, 0)
-    assert_equal Time.local(2006, 1, 2, 3, 4, 0), Time.construct(2006, 1, 2, 3, 4, 0)
-    assert_equal Time.local(2006, 1, 2, 3, 4, 5), Time.construct(2006, 1, 2, 3, 4, 5)
-  end
-  
-  def test_second_overflow
-    assert_equal Time.local(2006, 1, 1, 0, 1, 30), Time.construct(2006, 1, 1, 0, 0, 90)
-    assert_equal Time.local(2006, 1, 1, 0, 5, 0), Time.construct(2006, 1, 1, 0, 0, 300)
-  end
-  
-  def test_minute_overflow
-    assert_equal Time.local(2006, 1, 1, 1, 30), Time.construct(2006, 1, 1, 0, 90)
-    assert_equal Time.local(2006, 1, 1, 5), Time.construct(2006, 1, 1, 0, 300)
-  end
-  
-  def test_hour_overflow
-    assert_equal Time.local(2006, 1, 2, 12), Time.construct(2006, 1, 1, 36)
-    assert_equal Time.local(2006, 1, 7), Time.construct(2006, 1, 1, 144)
-  end
-  
-  def test_day_overflow
-    assert_equal Time.local(2006, 2, 1), Time.construct(2006, 1, 32)
-    assert_equal Time.local(2006, 3, 5), Time.construct(2006, 2, 33)
-    assert_equal Time.local(2004, 3, 4), Time.construct(2004, 2, 33)
-    assert_equal Time.local(2000, 3, 5), Time.construct(2000, 2, 33)
-    
-    assert_nothing_raised do
-      Time.construct(2006, 1, 56)
-    end
-    
-    assert_raise(RuntimeError) do
-      Time.construct(2006, 1, 57)
-    end
-  end
-  
-  def test_month_overflow
-    assert_equal Time.local(2006, 1), Time.construct(2005, 13)
-    assert_equal Time.local(2005, 12), Time.construct(2000, 72)
-  end
-end