rizwanreza-chronic 0.0.1

data/lib/chronic/ordinal.rb

@@ -0,0 +1,39 @@
+module Chronic
+
+	class Ordinal < Tag #:nodoc:
+		def self.scan(tokens)
+			# for each token
+			tokens.each_index do |i|
+				if t = self.scan_for_ordinals(tokens[i]) then tokens[i].tag(t) end
+				if t = self.scan_for_days(tokens[i]) then tokens[i].tag(t) end
+			end
+			tokens
+		end
+
+		def self.scan_for_ordinals(token)
+			if token.word =~ /^(\d*)(st|nd|rd|th)$/i
+				return Ordinal.new($1.to_i)
+			end
+			return nil
+		end
+
+		def self.scan_for_days(token)
+			if token.word =~ /^(\d*)(st|nd|rd|th)$/i
+				unless $1.to_i > 31 || $1.to_i < 1
+					return OrdinalDay.new(token.word.to_i)
+				end
+			end
+			return nil
+		end
+
+		def to_s
+			'ordinal'
+		end
+	end
+
+	class OrdinalDay < Ordinal #:nodoc:
+		def to_s
+			super << '-day-' << @type.to_s
+		end
+	end
+end

data/lib/chronic/pointer.rb

@@ -0,0 +1,29 @@
+module Chronic
+
+	class Pointer < Tag #:nodoc:
+		def self.scan(tokens)
+			# for each token
+			tokens.each_index do |i|
+				if t = self.scan_for_all(tokens[i]) then tokens[i].tag(t) end
+			end
+			tokens
+		end
+
+		def self.scan_for_all(token)
+			scanner = {/\bpast\b/i => :past,
+				/\bfuture\b/i => :future,
+				/\bfor\b/i => :future,
+				/\bin\b/i => :future}
+
+			scanner.keys.each do |scanner_item|
+				return self.new(scanner[scanner_item]) if scanner_item =~ token.word
+			end
+			return nil
+		end
+
+		def to_s
+			'pointer-' << @type.to_s
+		end
+	end
+
+end

data/lib/chronic/repeater.rb

@@ -0,0 +1,139 @@
+class Chronic::Repeater < Chronic::Tag #:nodoc:
+	def self.scan(tokens, options)
+		# for each token
+		tokens.each_index do |i|
+			if t = self.scan_for_season_names(tokens[i]) then tokens[i].tag(t); next end
+			if t = self.scan_for_month_names(tokens[i]) then tokens[i].tag(t); next end
+			if t = self.scan_for_day_names(tokens[i]) then tokens[i].tag(t); next end
+			if t = self.scan_for_day_portions(tokens[i]) then tokens[i].tag(t); next end
+			if t = self.scan_for_times(tokens[i], options) then tokens[i].tag(t); next end
+			if t = self.scan_for_units(tokens[i]) then tokens[i].tag(t); next end
+			if t = self.scan_for_decades(tokens[i]) then tokens[i].tag(t); next end
+		end
+		tokens
+	end
+
+	def self.scan_for_season_names(token)
+		scanner = {/^springs?$/i => :spring,
+			/^summers?$/i => :summer,
+			/^(autumn)|(fall)s?$/i => :autumn,
+			/^winters?$/i => :winter}
+		scanner.keys.each do |scanner_item|
+			return Chronic::RepeaterSeasonName.new(scanner[scanner_item]) if scanner_item =~ token.word
+		end
+
+		return nil
+	end
+
+	def self.scan_for_month_names(token)
+		scanner = {/^jan\.?(uary)?$/i => :january,
+			/^feb\.?(ruary)?$/i => :february,
+			/^mar\.?(ch)?$/i => :march,
+			/^apr\.?(il)?$/i => :april,
+			/^may$/i => :may,
+			/^jun\.?e?$/i => :june,
+			/^jul\.?y?$/i => :july,
+			/^aug\.?(ust)?$/i => :august,
+			/^sep\.?(t\.?|tember)?$/i => :september,
+			/^oct\.?(ober)?$/i => :october,
+			/^nov\.?(ember)?$/i => :november,
+			/^dec\.?(ember)?$/i => :december}
+		scanner.keys.each do |scanner_item|
+			return Chronic::RepeaterMonthName.new(scanner[scanner_item]) if scanner_item =~ token.word
+		end
+		return nil
+	end
+
+	def self.scan_for_day_names(token)
+		scanner = {/^m[ou]n(day)?$/i => :monday,
+			/^t(ue|eu|oo|u|)s(day)?$/i => :tuesday,
+			/^tue$/i => :tuesday,
+			/^we(dnes|nds|nns)day$/i => :wednesday,
+			/^wed$/i => :wednesday,
+			/^th(urs|ers)day$/i => :thursday,
+			/^thu$/i => :thursday,
+			/^fr[i](day)?$/i => :friday,
+			/^sat(t?[ue]rday)?$/i => :saturday,
+			/^su[nm](day)?$/i => :sunday}
+		scanner.keys.each do |scanner_item|
+			return Chronic::RepeaterDayName.new(scanner[scanner_item]) if scanner_item =~ token.word
+		end
+		return nil
+	end
+
+	def self.scan_for_day_portions(token)
+		puts "scan_for_day_portions -- #{token}" if Chronic.debug
+		scanner = {/^ams?$/i => :am,
+			/^pms?$/i => :pm,
+			/^mornings?$/i => :morning,
+			/^afternoons?$/i => :afternoon,
+			/^evenings?$/i => :evening,
+			/^(night|nite)s?$/i => :night}
+		scanner.keys.each do |scanner_item|
+			return Chronic::RepeaterDayPortion.new(scanner[scanner_item]) if scanner_item =~ token.word
+		end
+		return nil
+	end
+
+	def self.scan_for_times(token, options)
+		if token.word =~ /^\d{1,2}(:?\d{2})?([\.:]?\d{2})?$/
+			return Chronic::RepeaterTime.new(token.word, options)
+		end
+		return nil
+	end
+
+	def self.scan_for_decades(token)
+		if token.word =~ Chronic::RepeaterDecade::DECADE_PATTERN
+			return Chronic::RepeaterDecade.new(token.word)
+		end
+		return nil
+	end
+
+	def self.scan_for_units(token)
+		scanner = {/^years?$/i => :year,
+			/^seasons?$/i => :season,
+			/^months?$/i => :month,
+			/^fortnights?$/i => :fortnight,
+			/^weeks?$/i => :week,
+			/^weekends?$/i => :weekend,
+			/^(week|business)days?$/i => :weekday,
+			/^days?$/i => :day,
+			/^hours?$/i => :hour,
+			/^minutes?$/i => :minute,
+			/^seconds?$/i => :second,
+		}
+		scanner.keys.each do |scanner_item|
+			if scanner_item =~ token.word
+				klass_name = 'Chronic::Repeater' + scanner[scanner_item].to_s.capitalize
+				klass = eval(klass_name)
+				return klass.new(scanner[scanner_item])
+			end
+		end
+		return nil
+	end
+
+	def <=>(other)
+		width <=> other.width
+	end
+
+	# returns the width (in seconds or months) of this repeatable.
+	def width
+		raise("Repeatable#width must be overridden in subclasses")
+	end
+
+	# returns the next occurance of this repeatable.
+	def next(pointer)
+		!@now.nil? || raise("Start point must be set before calling #next")
+		[:future, :none, :past].include?(pointer) || raise("First argument 'pointer' must be one of :past or :future")
+		#raise("Repeatable#next must be overridden in subclasses")
+	end
+
+	def this(pointer)
+		!@now.nil? || raise("Start point must be set before calling #this")
+		[:future, :past, :none].include?(pointer) || raise("First argument 'pointer' must be one of :past, :future, :none")
+	end
+
+	def to_s
+		'repeater'
+	end
+end

data/lib/chronic/repeaters/repeater_day.rb

@@ -0,0 +1,52 @@
+class Chronic::RepeaterDay < Chronic::Repeater #:nodoc:
+	DAY_SECONDS = 86_400 # (24 * 60 * 60)
+
+	def initialize(type)
+		super
+		@current_day_start = nil
+	end
+
+	def next(pointer)
+		super
+
+		if !@current_day_start
+			@current_day_start = Chronic.time_class.local(@now.year, @now.month, @now.day)
+		end
+
+		direction = pointer == :future ? 1 : -1
+		@current_day_start += direction * DAY_SECONDS
+
+		Chronic::Span.new(@current_day_start, @current_day_start + DAY_SECONDS)
+	end
+
+	def this(pointer = :future)
+		super
+
+		case pointer
+		when :future
+			day_begin = Time.construct(@now.year, @now.month, @now.day, @now.hour + 1)
+			day_end = Time.construct(@now.year, @now.month, @now.day) + DAY_SECONDS
+		when :past
+			day_begin = Time.construct(@now.year, @now.month, @now.day)
+			day_end = Time.construct(@now.year, @now.month, @now.day, @now.hour)
+		when :none
+			day_begin = Time.construct(@now.year, @now.month, @now.day)
+			day_end = Time.construct(@now.year, @now.month, @now.day) + DAY_SECONDS
+		end
+
+		Chronic::Span.new(day_begin, day_end)
+	end
+
+	def offset(span, amount, pointer)
+		direction = pointer == :future ? 1 : -1
+		span + direction * amount * DAY_SECONDS
+	end
+
+	def width
+		DAY_SECONDS
+	end
+
+	def to_s
+		super << '-day'
+	end
+end

data/lib/chronic/repeaters/repeater_day_name.rb

@@ -0,0 +1,53 @@
+require 'date'
+class Chronic::RepeaterDayName < Chronic::Repeater #:nodoc:
+	DAY_SECONDS = 86400 # (24 * 60 * 60)
+
+	def initialize(type)
+		super
+		@current_date = nil
+	end
+
+	def next(pointer)
+		super
+
+		direction = pointer == :future ? 1 : -1
+
+		unless @current_date
+			@current_date = DateTime.new(y=@now.year, m=@now.month, d=@now.day)
+			@current_date += direction
+			day_num = symbol_to_number(@type)
+
+			while @current_date.wday != day_num
+				@current_date += direction
+			end
+		else
+			@current_date += direction * 7
+		end
+		next_date = @current_date.succ
+		Chronic::Span.new(Chronic.time_class.local(@current_date.year, @current_date.month, @current_date.day),
+				  Chronic.time_class.local(next_date.year, next_date.month, next_date.day))
+	end
+
+
+	def this(pointer = :future)
+		super
+
+		pointer = :future if pointer == :none
+		self.next(pointer)
+	end
+
+	def width
+		DAY_SECONDS
+	end
+
+	def to_s
+		super << '-dayname-' << @type.to_s
+	end
+
+	private
+
+	def symbol_to_number(sym)
+		lookup = {:sunday => 0, :monday => 1, :tuesday => 2, :wednesday => 3, :thursday => 4, :friday => 5, :saturday => 6}
+		lookup[sym] || raise("Invalid symbol specified")
+	end
+end

data/lib/chronic/repeaters/repeater_day_portion.rb

@@ -0,0 +1,94 @@
+class Chronic::RepeaterDayPortion < Chronic::Repeater #:nodoc:
+	@@morning = (6 * 60 * 60)..(12 * 60 * 60) # 6am-12am
+	@@afternoon = (13 * 60 * 60)..(17 * 60 * 60) # 1pm-5pm
+	@@evening = (17 * 60 * 60)..(20 * 60 * 60) # 5pm-8pm
+	@@night = (20 * 60 * 60)..(24 * 60 * 60) # 8pm-12pm
+
+	def initialize(type)
+		super
+		@current_span = nil
+
+		if type.kind_of? Integer
+			@range = (@type * 60 * 60)..((@type + 12) * 60 * 60)
+		else
+			lookup = {:am => 0..(12 * 60 * 60 - 1),
+				:pm => (12 * 60 * 60)..(24 * 60 * 60 - 1),
+				:morning => @@morning,
+				:afternoon => @@afternoon,
+				:evening => @@evening,
+				:night => @@night}
+			@range = lookup[type]
+			lookup[type] || raise("Invalid type '#{type}' for RepeaterDayPortion")
+		end
+		@range || raise("Range should have been set by now")
+	end
+
+	def next(pointer)
+		super
+
+		full_day = 60 * 60 * 24
+
+		if !@current_span
+			now_seconds = @now - Time.construct(@now.year, @now.month, @now.day)
+			if now_seconds < @range.begin
+				case pointer
+				when :future
+					range_start = Time.construct(@now.year, @now.month, @now.day) + @range.begin
+				when :past
+					range_start = Time.construct(@now.year, @now.month, @now.day) - full_day + @range.begin
+				end
+			elsif now_seconds > @range.end
+				case pointer
+				when :future
+					range_start = Time.construct(@now.year, @now.month, @now.day) + full_day + @range.begin
+				when :past
+					range_start = Time.construct(@now.year, @now.month, @now.day) + @range.begin
+				end
+			else
+				case pointer
+				when :future
+					range_start = Time.construct(@now.year, @now.month, @now.day) + full_day + @range.begin
+				when :past
+					range_start = Time.construct(@now.year, @now.month, @now.day) - full_day + @range.begin
+				end
+			end
+
+			@current_span = Chronic::Span.new(range_start, range_start + (@range.end - @range.begin))
+		else
+			case pointer
+			when :future
+				@current_span += full_day
+			when :past
+				@current_span -= full_day
+			end
+		end
+	end
+
+	def this(context = :future)
+		super
+
+		range_start = Time.construct(@now.year, @now.month, @now.day) + @range.begin
+		@current_span = Chronic::Span.new(range_start, range_start + (@range.end - @range.begin))
+	end
+
+	def offset(span, amount, pointer)
+		@now = span.begin
+		portion_span = self.next(pointer)
+		direction = pointer == :future ? 1 : -1
+		portion_span + (direction * (amount - 1) * Chronic::RepeaterDay::DAY_SECONDS)
+	end
+
+	def width
+		@range || raise("Range has not been set")
+		return @current_span.width if @current_span
+		if @type.kind_of? Integer
+			return (12 * 60 * 60)
+		else
+			@range.end - @range.begin
+		end
+	end
+
+	def to_s
+		super << '-dayportion-' << @type.to_s
+	end
+end

data/lib/chronic/repeaters/repeater_decade.rb

@@ -0,0 +1,23 @@
+class Chronic::RepeaterDecade < Chronic::Repeater #:nodoc:
+	DECADE_PATTERN = /^(?:(\d{2})|'|)(\d0)'?s$/
+
+		def initialize(decade)
+			super
+
+			m = decade.match DECADE_PATTERN
+			@decade_start = Time.construct(((m[1] || '19') + m[2]).to_i, 1, 1)
+		end
+
+	def this(context = :past)
+		super
+		Chronic::Span.new(@decade_start, @decade_start + width)
+	end
+
+	def width
+		Time.construct(@decade_start.year + 10, 1, 1) - @decade_start
+	end
+
+	def to_s
+		super << '-year'
+	end
+end

data/lib/chronic/repeaters/repeater_fortnight.rb

@@ -0,0 +1,70 @@
+class Chronic::RepeaterFortnight < Chronic::Repeater #:nodoc:
+	FORTNIGHT_SECONDS = 1_209_600 # (14 * 24 * 60 * 60)
+
+	def initialize(type)
+		super
+		@current_fortnight_start = nil
+	end
+
+	def next(pointer)
+		super
+
+		if !@current_fortnight_start
+			case pointer
+			when :future
+				sunday_repeater = Chronic::RepeaterDayName.new(:sunday)
+				sunday_repeater.start = @now
+				next_sunday_span = sunday_repeater.next(:future)
+				@current_fortnight_start = next_sunday_span.begin
+			when :past
+				sunday_repeater = Chronic::RepeaterDayName.new(:sunday)
+				sunday_repeater.start = (@now + Chronic::RepeaterDay::DAY_SECONDS)
+				2.times { sunday_repeater.next(:past) }
+				last_sunday_span = sunday_repeater.next(:past)
+				@current_fortnight_start = last_sunday_span.begin
+			end
+		else
+			direction = pointer == :future ? 1 : -1
+			@current_fortnight_start += direction * FORTNIGHT_SECONDS
+		end
+
+		Chronic::Span.new(@current_fortnight_start, @current_fortnight_start + FORTNIGHT_SECONDS)
+	end
+
+	def this(pointer = :future)
+		super
+
+		pointer = :future if pointer == :none
+
+		case pointer
+		when :future
+			this_fortnight_start = Time.construct(@now.year, @now.month, @now.day, @now.hour) + Chronic::RepeaterHour::HOUR_SECONDS
+			sunday_repeater = Chronic::RepeaterDayName.new(:sunday)
+			sunday_repeater.start = @now
+			sunday_repeater.this(:future)
+			this_sunday_span = sunday_repeater.this(:future)
+			this_fortnight_end = this_sunday_span.begin
+			Chronic::Span.new(this_fortnight_start, this_fortnight_end)
+		when :past
+			this_fortnight_end = Time.construct(@now.year, @now.month, @now.day, @now.hour)
+			sunday_repeater = Chronic::RepeaterDayName.new(:sunday)
+			sunday_repeater.start = @now
+			last_sunday_span = sunday_repeater.next(:past)
+			this_fortnight_start = last_sunday_span.begin
+			Chronic::Span.new(this_fortnight_start, this_fortnight_end)
+		end
+	end
+
+	def offset(span, amount, pointer)
+		direction = pointer == :future ? 1 : -1
+		span + direction * amount * FORTNIGHT_SECONDS
+	end
+
+	def width
+		FORTNIGHT_SECONDS
+	end
+
+	def to_s
+		super << '-fortnight'
+	end
+end