rizwanreza-chronic 0.0.1

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,26 @@
+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)
+      if RUBY_VERSION =~ /1\.9\./
+        scanner = {/[PMCE][DS]T/i => :tz}
+      else
+        scanner = {/[PMCE][DS]T/i => :tz, /(tzminus)?[01]\d[304][05]/ => :tz}
+      end
+      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/core_ext/object.rb

@@ -0,0 +1,7 @@
+alias p_orig p
+
+def p(val)
+	p_orig val
+	puts
+end
+

data/lib/core_ext/time.rb

@@ -0,0 +1,74 @@
+require 'time'
+
+# class Time
+#   def self.construct(year, month = 1, day = 1, hour = 0, minute = 0, second = 0)
+#     # extra_seconds = second > 60 ? second - 60 : 0
+#     # extra_minutes = minute > 59 ? minute - 59 : 0
+#     # extra_hours = hour > 23 ? hour - 23 : 0
+#     # extra_days = day >
+#
+#     if month > 12
+#       if month % 12 == 0
+#         year += (month - 12) / 12
+#         month = 12
+#       else
+#         year += month / 12
+#         month = month % 12
+#       end
+#     end
+#
+#     base = Time.local(year, month)
+#     puts base
+#     offset = ((day - 1) * 24 * 60 * 60) + (hour * 60 * 60) + (minute * 60) + second
+#     puts offset.to_s
+#     date = base + offset
+#     puts date
+#     date
+#   end
+# end
+
+class Time
+	def self.construct(year, month = 1, day = 1, hour = 0, minute = 0, second = 0)
+		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
+			leap_year = (year % 4 == 0) && !(year % 100 == 0)
+			leap_year_month_days = [31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]
+			common_year_month_days = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]
+			days_this_month = leap_year ? leap_year_month_days[month - 1] : common_year_month_days[month - 1]
+			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
+
+		Chronic.time_class.local(year, month, day, hour, minute, second)
+	end
+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/test_Chronic.rb

@@ -0,0 +1,75 @@
+require File.expand_path('../../lib/chronic', __FILE__)
+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
+	
+	def test_date_string
+	  assert_equal(Chronic.date_string("9pm"), Chronic.date_string("9pm"))
+	  assert_equal(Chronic.date_string("9/27/2009"), Chronic.date_string("9/27/2009"))
+	  assert_equal(Chronic.date_string("9/27/2009"), Chronic.date_string("Meeting 9/27/2009"))
+	  assert_equal(Chronic.date_string("this day"), Chronic.date_string("Meeting today"))
+	end
+	
+	def test_tokenize_ignores_trailing_tokens
+	  # tokenize will keep tokens like "at" in the string "Meeting 9/27/2009 at the bar" even though it is
+	  # not part of the date
+	  tokens = Chronic.tokenize("9/27/2009 at")
+	  assert_nil(tokens[-1].get_tag(Chronic::Separator), "The last token in this string should not be tagged")
+	  assert_equal(Chronic.date_string("9/27/2009"), Chronic.date_string("9/27/2009 at"))
+	  
+	  # test a string with two of the same separator -- one of which will be tagged, one will not
+	  separator_test = "Meeting 9/27/2009 at 7pm at the bar"
+	  tokens = Chronic.tokenize(separator_test)
+	  assert_not_nil(tokens[6].get_tag(Chronic::Separator))
+	  assert_nil(tokens[9].get_tag(Chronic::Separator))
+	  assert_equal("Meeting at the bar", Chronic.strip_tokens(separator_test))
+	  assert_equal(Chronic.date_string("9/27/2009 at 7pm"), Chronic.date_string(separator_test), "date_string does not return the correct date string for <#{separator_test}>")
+	  
+	  # because the trailing "at" separator here is not tagged anymore, it will be part of the strip_tokens string
+	  assert_equal("Meeting at the bar", Chronic.strip_tokens("Meeting 9/27/2009 at the bar"))
+	end
+end