pangel-chronic 0.3.0.2

data/lib/chronic/scalar.rb

@@ -0,0 +1,76 @@
+module Chronic
+
+	class Scalar < Tag #:nodoc:
+		def self.scan(tokens)
+			# for each token
+			tokens.each_index do |i|
+				if t = self.scan_for_scalars(tokens[i], tokens[i + 1]) then tokens[i].tag(t) end
+				if t = self.scan_for_days(tokens[i], tokens[i + 1]) then tokens[i].tag(t) end
+				if t = self.scan_for_months(tokens[i], tokens[i + 1]) then tokens[i].tag(t) end
+				if t = self.scan_for_years(tokens[i], tokens[i + 1]) then tokens[i].tag(t) end
+			end
+			tokens
+		end
+
+		def self.scan_for_scalars(token, post_token)
+			if token.word =~ /^\d*$/ || token.word =~ /^\d\.\d*$/
+				unless post_token && %w{am pm morning afternoon evening night}.include?(post_token)
+					return Scalar.new(token.word.to_f)
+				end
+			end
+			return nil
+		end
+
+		def self.scan_for_days(token, post_token)
+			if token.word =~ /^\d\d?$/
+				toi = token.word.to_i
+				unless toi > 31 || toi < 1 || (post_token && %w{am pm morning afternoon evening night}.include?(post_token.word))
+					return ScalarDay.new(toi)
+				end
+			end
+			return nil
+		end
+
+		def self.scan_for_months(token, post_token)
+			if token.word =~ /^\d\d?$/
+				toi = token.word.to_i
+				unless toi > 12 || toi < 1 || (post_token && %w{am pm morning afternoon evening night}.include?(post_token.word))
+					return ScalarMonth.new(toi)
+				end
+			end
+			return nil
+		end
+
+		def self.scan_for_years(token, post_token)
+			if token.word =~ /^([1-9]\d)?\d\d?$/
+				unless post_token && %w{am pm morning afternoon evening night}.include?(post_token.word)
+					return ScalarYear.new(token.word.to_i)
+				end
+			end
+			return nil
+		end
+
+		def to_s
+			'scalar'
+		end
+	end
+
+	class ScalarDay < Scalar #:nodoc:
+		def to_s
+			super << '-day-' << @type.to_s
+		end
+	end
+
+	class ScalarMonth < Scalar #:nodoc:
+		def to_s
+			super << '-month-' << @type.to_s
+		end
+	end
+
+	class ScalarYear < Scalar #:nodoc:
+		def to_s
+			super << '-year-' << @type.to_s
+		end
+	end
+
+end

data/lib/chronic/separator.rb

@@ -0,0 +1,91 @@
+module Chronic
+
+	class Separator < Tag #:nodoc:
+		def self.scan(tokens)
+			tokens.each_index do |i|
+				if t = self.scan_for_commas(tokens[i]) then tokens[i].tag(t); next end
+				if t = self.scan_for_slash_or_dash(tokens[i]) then tokens[i].tag(t); next end
+				if t = self.scan_for_at(tokens[i]) then tokens[i].tag(t); next end
+				if t = self.scan_for_in(tokens[i]) then tokens[i].tag(t); next end
+				if t = self.scan_for_on(tokens[i]) then tokens[i].tag(t); next end
+			end
+			tokens
+		end
+
+		def self.scan_for_commas(token)
+			scanner = {/^,$/ => :comma}
+			scanner.keys.each do |scanner_item|
+				return SeparatorComma.new(scanner[scanner_item]) if scanner_item =~ token.word
+			end
+			return nil
+		end
+
+		def self.scan_for_slash_or_dash(token)
+			scanner = {/^-$/ => :dash,
+				/^\/$/ => :slash}
+			scanner.keys.each do |scanner_item|
+				return SeparatorSlashOrDash.new(scanner[scanner_item]) if scanner_item =~ token.word
+			end
+			return nil
+		end
+
+		def self.scan_for_at(token)
+			scanner = {/^(at|@)$/i => :at}
+			scanner.keys.each do |scanner_item|
+				return SeparatorAt.new(scanner[scanner_item]) if scanner_item =~ token.word
+			end
+			return nil
+		end
+
+		def self.scan_for_in(token)
+			scanner = {/^in$/i => :in}
+			scanner.keys.each do |scanner_item|
+				return SeparatorIn.new(scanner[scanner_item]) if scanner_item =~ token.word
+			end
+			return nil
+		end
+
+		def self.scan_for_on(token)
+			scanner = {/^on$/i => :on}
+			scanner.keys.each do |scanner_item|
+				return SeparatorOn.new(scanner[scanner_item]) if scanner_item =~ token.word
+			end
+			return nil
+		end
+
+		def to_s
+			'separator'
+		end
+	end
+
+	class SeparatorComma < Separator #:nodoc:
+		def to_s
+			super << '-comma'
+		end
+	end
+
+	class SeparatorSlashOrDash < Separator #:nodoc:
+		def to_s
+			super << '-slashordash-' << @type.to_s
+		end
+	end
+
+	class SeparatorAt < Separator #:nodoc:
+		def to_s
+			super << '-at'
+		end
+	end
+
+	class SeparatorIn < Separator #:nodoc:
+		def to_s
+			super << '-in'
+		end
+	end
+
+	class SeparatorOn < Separator #:nodoc:
+		def to_s
+			super << '-on'
+		end
+	end
+
+end

data/lib/chronic/time_zone.rb

@@ -0,0 +1,23 @@
+module Chronic
+	class TimeZone < Tag #:nodoc:
+		def self.scan(tokens)
+			tokens.each_index do |i|
+				if t = self.scan_for_all(tokens[i]) then tokens[i].tag(t); next end
+			end
+			tokens
+		end
+
+		def self.scan_for_all(token)
+			scanner = {/[PMCE][DS]T/i => :tz,
+				/(tzminus)?\d{4}/i => :tz}
+			scanner.keys.each do |scanner_item|
+				return self.new(scanner[scanner_item]) if scanner_item =~ token.word
+			end
+			return nil
+		end
+
+		def to_s
+			'timezone'
+		end
+	end
+end

data/lib/chronic.rb

@@ -0,0 +1,57 @@
+#=============================================================================
+#
+#  Name:       Chronic
+#  Author:     Tom Preston-Werner
+#  Purpose:    Parse natural language dates and times into Time or
+#              Chronic::Span objects
+#
+#=============================================================================
+
+$:.unshift File.dirname(__FILE__)     # For use/testing when no gem is installed
+
+require 'core_ext/object'
+require 'core_ext/time'
+
+require 'chronic/chronic'
+require 'chronic/handlers'
+
+require 'chronic/repeater'
+require 'chronic/repeaters/repeater_year'
+require 'chronic/repeaters/repeater_season'
+require 'chronic/repeaters/repeater_season_name'
+require 'chronic/repeaters/repeater_month'
+require 'chronic/repeaters/repeater_month_name'
+require 'chronic/repeaters/repeater_fortnight'
+require 'chronic/repeaters/repeater_week'
+require 'chronic/repeaters/repeater_weekend'
+require 'chronic/repeaters/repeater_weekday'
+require 'chronic/repeaters/repeater_day'
+require 'chronic/repeaters/repeater_day_name'
+require 'chronic/repeaters/repeater_day_portion'
+require 'chronic/repeaters/repeater_decade'
+require 'chronic/repeaters/repeater_hour'
+require 'chronic/repeaters/repeater_minute'
+require 'chronic/repeaters/repeater_second'
+require 'chronic/repeaters/repeater_time'
+
+require 'chronic/grabber'
+require 'chronic/pointer'
+require 'chronic/scalar'
+require 'chronic/ordinal'
+require 'chronic/separator'
+require 'chronic/time_zone'
+require 'chronic/blunt.rb'
+
+require 'numerizer/numerizer'
+
+module Chronic
+	VERSION = "0.3.0.2"
+
+	class << self
+		attr_accessor :debug
+		attr_accessor :time_class
+	end
+
+	self.debug = false
+	self.time_class = Time
+end

data/lib/numerizer/numerizer.rb

@@ -0,0 +1,98 @@
+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],
+		['forty', 40],
+		['fourty', 40], # Common misspelling
+		['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],
+	]
+
+	def self.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, '<num>' + dn[1])
+		end
+
+		# ten, twenty, etc.
+
+		TEN_PREFIXES.each do |tp|
+			string.gsub!(/(?:#{tp[0]}) *<num>(\d(?=[^\d]|$))*/i) { '<num>' + (tp[1] + $1.to_i).to_s }
+		end
+
+		TEN_PREFIXES.each do |tp|
+			string.gsub!(/#{tp[0]}/i) { '<num>' + tp[1].to_s }
+		end
+
+		# hundreds, thousands, millions, etc.
+
+		BIG_PREFIXES.each do |bp|
+			string.gsub!(/(?:<num>)?(\d*) *#{bp[0]}/i) { '<num>' + (bp[1] * $1.to_i).to_s}
+				andition(string)
+		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.gsub(/<num>/, '')
+	end
+
+	private
+
+	def self.andition(string)
+		sc = StringScanner.new(string)
+		while(sc.scan_until(/<num>(\d+)( | and )<num>(\d+)(?=[^\w]|$)/i))
+			if sc[2] =~ /and/ || sc[1].size > sc[3].size
+				string[(sc.pos - sc.matched_size)..(sc.pos-1)] = '<num>' + (sc[1].to_i + sc[3].to_i).to_s
+				sc.reset
+			end
+		end
+	end
+
+end

data/test/suite.rb

@@ -0,0 +1,9 @@
+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

@@ -0,0 +1,50 @@
+require File.dirname(__FILE__) + '/../lib/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_Handler.rb

@@ -0,0 +1,110 @@
+require 'chronic'
+require 'test/unit'
+
+class TestHandler < 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_handler_class_1
+		handler = Chronic::Handler.new([:repeater], :handler)
+
+		tokens = [Chronic::Token.new('friday')]
+		tokens[0].tag(Chronic::RepeaterDayName.new(:friday))
+
+		assert handler.match(tokens, Chronic.definitions)
+
+		tokens << Chronic::Token.new('afternoon')
+		tokens[1].tag(Chronic::RepeaterDayPortion.new(:afternoon))
+
+		assert !handler.match(tokens, Chronic.definitions)
+	end
+
+	def test_handler_class_2
+		handler = Chronic::Handler.new([:repeater, :repeater?], :handler)
+
+		tokens = [Chronic::Token.new('friday')]
+		tokens[0].tag(Chronic::RepeaterDayName.new(:friday))
+
+		assert handler.match(tokens, Chronic.definitions)
+
+		tokens << Chronic::Token.new('afternoon')
+		tokens[1].tag(Chronic::RepeaterDayPortion.new(:afternoon))
+
+		assert handler.match(tokens, Chronic.definitions)
+
+		tokens << Chronic::Token.new('afternoon')
+		tokens[2].tag(Chronic::RepeaterDayPortion.new(:afternoon))
+
+		assert !handler.match(tokens, Chronic.definitions)
+	end
+
+	def test_handler_class_3
+		handler = Chronic::Handler.new([:repeater, 'time?'], :handler)
+
+		tokens = [Chronic::Token.new('friday')]
+		tokens[0].tag(Chronic::RepeaterDayName.new(:friday))
+
+		assert handler.match(tokens, Chronic.definitions)
+
+		tokens << Chronic::Token.new('afternoon')
+		tokens[1].tag(Chronic::RepeaterDayPortion.new(:afternoon))
+
+		assert !handler.match(tokens, Chronic.definitions)
+	end
+
+	def test_handler_class_4
+		handler = Chronic::Handler.new([:repeater_month_name, :scalar_day, 'time?'], :handler)
+
+		tokens = [Chronic::Token.new('may')]
+		tokens[0].tag(Chronic::RepeaterMonthName.new(:may))
+
+		assert !handler.match(tokens, Chronic.definitions)
+
+		tokens << Chronic::Token.new('27')
+		tokens[1].tag(Chronic::ScalarDay.new(27))
+
+		assert handler.match(tokens, Chronic.definitions)
+	end
+
+	def test_handler_class_5
+		handler = Chronic::Handler.new([:repeater, 'time?'], :handler)
+
+		tokens = [Chronic::Token.new('friday')]
+		tokens[0].tag(Chronic::RepeaterDayName.new(:friday))
+
+		assert handler.match(tokens, Chronic.definitions)
+
+		tokens << Chronic::Token.new('5:00')
+		tokens[1].tag(Chronic::RepeaterTime.new('5:00'))
+
+		assert handler.match(tokens, Chronic.definitions)
+
+		tokens << Chronic::Token.new('pm')
+		tokens[2].tag(Chronic::RepeaterDayPortion.new(:pm))
+
+		assert handler.match(tokens, Chronic.definitions)
+	end
+
+	def test_handler_class_6
+		handler = Chronic::Handler.new([:scalar, :repeater, :pointer], :handler)
+
+		tokens = [Chronic::Token.new('3'),
+			Chronic::Token.new('years'),
+			Chronic::Token.new('past')]
+
+		tokens[0].tag(Chronic::Scalar.new(3))
+		tokens[1].tag(Chronic::RepeaterYear.new(:year))
+		tokens[2].tag(Chronic::Pointer.new(:past))
+
+		assert handler.match(tokens, Chronic.definitions)
+	end
+
+	def test_constantize
+		handler = Chronic::Handler.new([], :handler)
+		assert_equal Chronic::RepeaterTime, handler.constantize(:repeater_time)
+	end
+
+end

data/test/test_Numerizer.rb

@@ -0,0 +1,54 @@
+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',
+			41 => 'forty one',
+			42 => 'fourty two',
+			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
+
+	def test_edges
+		assert_equal "27 Oct 2006 7:30am", Numerizer.numerize("27 Oct 2006 7:30am")
+	end
+end

data/test/test_RepeaterDayName.rb

@@ -0,0 +1,52 @@
+require 'chronic'
+require 'test/unit'
+
+class TestRepeaterDayName < Test::Unit::TestCase
+
+	def setup
+		@now = Time.local(2006, 8, 16, 14, 0, 0, 0)
+	end
+
+	def test_match
+		token = Chronic::Token.new('saturday')
+		repeater = Chronic::Repeater.scan_for_day_names(token)
+		assert_equal Chronic::RepeaterDayName, repeater.class
+		assert_equal :saturday, repeater.type
+
+		token = Chronic::Token.new('sunday')
+		repeater = Chronic::Repeater.scan_for_day_names(token)
+		assert_equal Chronic::RepeaterDayName, repeater.class
+		assert_equal :sunday, repeater.type
+	end
+
+	def test_next_future
+		mondays = Chronic::RepeaterDayName.new(:monday)
+		mondays.start = @now
+
+		span = mondays.next(:future)
+
+		assert_equal Time.local(2006, 8, 21), span.begin
+		assert_equal Time.local(2006, 8, 22), span.end
+
+		span = mondays.next(:future)
+
+		assert_equal Time.local(2006, 8, 28), span.begin
+		assert_equal Time.local(2006, 8, 29), span.end
+	end
+
+	def test_next_past
+		mondays = Chronic::RepeaterDayName.new(:monday)
+		mondays.start = @now
+
+		span = mondays.next(:past)
+
+		assert_equal Time.local(2006, 8, 14), span.begin
+		assert_equal Time.local(2006, 8, 15), span.end
+
+		span = mondays.next(:past)
+
+		assert_equal Time.local(2006, 8, 7), span.begin
+		assert_equal Time.local(2006, 8, 8), span.end
+	end
+
+end

data/test/test_RepeaterFortnight.rb

@@ -0,0 +1,63 @@
+require 'chronic'
+require 'test/unit'
+
+class TestRepeaterFortnight < Test::Unit::TestCase
+
+	def setup
+		@now = Time.local(2006, 8, 16, 14, 0, 0, 0)
+	end
+
+	def test_next_future
+		fortnights = Chronic::RepeaterFortnight.new(:fortnight)
+		fortnights.start = @now
+
+		next_fortnight = fortnights.next(:future)
+		assert_equal Time.local(2006, 8, 20), next_fortnight.begin
+		assert_equal Time.local(2006, 9, 3), next_fortnight.end
+
+		next_next_fortnight = fortnights.next(:future)
+		assert_equal Time.local(2006, 9, 3), next_next_fortnight.begin
+		assert_equal Time.local(2006, 9, 17), next_next_fortnight.end
+	end
+
+	def test_next_past
+		fortnights = Chronic::RepeaterFortnight.new(:fortnight)
+		fortnights.start = @now
+
+		last_fortnight = fortnights.next(:past)
+		assert_equal Time.local(2006, 7, 30), last_fortnight.begin
+		assert_equal Time.local(2006, 8, 13), last_fortnight.end
+
+		last_last_fortnight = fortnights.next(:past)
+		assert_equal Time.local(2006, 7, 16), last_last_fortnight.begin
+		assert_equal Time.local(2006, 7, 30), last_last_fortnight.end
+	end
+
+	def test_this_future
+		fortnights = Chronic::RepeaterFortnight.new(:fortnight)
+		fortnights.start = @now
+
+		this_fortnight = fortnights.this(:future)
+		assert_equal Time.local(2006, 8, 16, 15), this_fortnight.begin
+		assert_equal Time.local(2006, 8, 27), this_fortnight.end
+	end
+
+	def test_this_past
+		fortnights = Chronic::RepeaterFortnight.new(:fortnight)
+		fortnights.start = @now
+
+		this_fortnight = fortnights.this(:past)
+		assert_equal Time.local(2006, 8, 13, 0), this_fortnight.begin
+		assert_equal Time.local(2006, 8, 16, 14), this_fortnight.end
+	end
+
+	def test_offset
+		span = Chronic::Span.new(@now, @now + 1)
+
+		offset_span = Chronic::RepeaterFortnight.new(:week).offset(span, 3, :future)
+
+		assert_equal Time.local(2006, 9, 27, 14), offset_span.begin
+		assert_equal Time.local(2006, 9, 27, 14, 0, 1), offset_span.end
+	end
+
+end