pangel-chronic 0.3.0.2

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[iy](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_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

data/lib/chronic/repeaters/repeater_hour.rb

@@ -0,0 +1,58 @@
+class Chronic::RepeaterHour < Chronic::Repeater #:nodoc:
+	HOUR_SECONDS = 3600 # 60 * 60
+
+	def initialize(type)
+		super
+		@current_hour_start = nil
+	end
+
+	def next(pointer)
+		super
+
+		if !@current_hour_start
+			case pointer
+			when :future
+				@current_hour_start = Time.construct(@now.year, @now.month, @now.day, @now.hour + 1)
+			when :past
+				@current_hour_start = Time.construct(@now.year, @now.month, @now.day, @now.hour - 1)
+			end
+		else
+			direction = pointer == :future ? 1 : -1
+			@current_hour_start += direction * HOUR_SECONDS
+		end
+
+		Chronic::Span.new(@current_hour_start, @current_hour_start + HOUR_SECONDS)
+	end
+
+	def this(pointer = :future)
+		super
+
+		case pointer
+		when :future
+			hour_start = Time.construct(@now.year, @now.month, @now.day, @now.hour, @now.min + 1)
+			hour_end = Time.construct(@now.year, @now.month, @now.day, @now.hour + 1)
+		when :past
+			hour_start = Time.construct(@now.year, @now.month, @now.day, @now.hour)
+			hour_end = Time.construct(@now.year, @now.month, @now.day, @now.hour, @now.min)
+		when :none
+			hour_start = Time.construct(@now.year, @now.month, @now.day, @now.hour)
+			hour_end = hour_start + HOUR_SECONDS
+		end
+
+		Chronic::Span.new(hour_start, hour_end)
+	end
+
+	def offset(span, amount, pointer)
+		direction = pointer == :future ? 1 : -1
+		p [span, amount, pointer] if Chronic.debug
+		span + direction * amount * HOUR_SECONDS
+	end
+
+	def width
+		HOUR_SECONDS
+	end
+
+	def to_s
+		super << '-hour'
+	end
+end

data/lib/chronic/repeaters/repeater_minute.rb

@@ -0,0 +1,57 @@
+class Chronic::RepeaterMinute < Chronic::Repeater #:nodoc:
+	MINUTE_SECONDS = 60
+
+	def initialize(type)
+		super
+		@current_minute_start = nil
+	end
+
+	def next(pointer = :future)
+		super
+
+		if !@current_minute_start
+			case pointer
+			when :future
+				@current_minute_start = Time.construct(@now.year, @now.month, @now.day, @now.hour, @now.min + 1)
+			when :past
+				@current_minute_start = Time.construct(@now.year, @now.month, @now.day, @now.hour, @now.min - 1)
+			end
+		else
+			direction = pointer == :future ? 1 : -1
+			@current_minute_start += direction * MINUTE_SECONDS
+		end
+
+		Chronic::Span.new(@current_minute_start, @current_minute_start + MINUTE_SECONDS)
+	end
+
+	def this(pointer = :future)
+		super
+
+		case pointer
+		when :future
+			minute_begin = @now
+			minute_end = Time.construct(@now.year, @now.month, @now.day, @now.hour, @now.min)
+		when :past
+			minute_begin = Time.construct(@now.year, @now.month, @now.day, @now.hour, @now.min)
+			minute_end = @now
+		when :none
+			minute_begin = Time.construct(@now.year, @now.month, @now.day, @now.hour, @now.min)
+			minute_end = Time.construct(@now.year, @now.month, @now.day, @now.hour, @now.min) + MINUTE_SECONDS
+		end
+
+		Chronic::Span.new(minute_begin, minute_end)
+	end
+
+	def offset(span, amount, pointer)
+		direction = pointer == :future ? 1 : -1
+		span + direction * amount * MINUTE_SECONDS
+	end
+
+	def width
+		MINUTE_SECONDS
+	end
+
+	def to_s
+		super << '-minute'
+	end
+end

data/lib/chronic/repeaters/repeater_month.rb

@@ -0,0 +1,66 @@
+class Chronic::RepeaterMonth < Chronic::Repeater #:nodoc:
+	MONTH_SECONDS = 2_592_000 # 30 * 24 * 60 * 60
+	YEAR_MONTHS = 12
+
+	def initialize(type)
+		super
+		@current_month_start = nil
+	end
+
+	def next(pointer)
+		super
+
+		if !@current_month_start
+			@current_month_start = offset_by(Time.construct(@now.year, @now.month), 1, pointer)
+		else
+			@current_month_start = offset_by(Time.construct(@current_month_start.year, @current_month_start.month), 1, pointer)
+		end
+
+		Chronic::Span.new(@current_month_start, Time.construct(@current_month_start.year, @current_month_start.month + 1))
+	end
+
+	def this(pointer = :future)
+		super
+
+		case pointer
+		when :future
+			month_start = Time.construct(@now.year, @now.month, @now.day + 1)
+			month_end = self.offset_by(Time.construct(@now.year, @now.month), 1, :future)
+		when :past
+			month_start = Time.construct(@now.year, @now.month)
+			month_end = Time.construct(@now.year, @now.month, @now.day)
+		when :none
+			month_start = Time.construct(@now.year, @now.month)
+			month_end = self.offset_by(Time.construct(@now.year, @now.month), 1, :future)
+		end
+
+		Chronic::Span.new(month_start, month_end)
+	end
+
+	def offset(span, amount, pointer)
+		Chronic::Span.new(offset_by(span.begin, amount, pointer), offset_by(span.end, amount, pointer))
+	end
+
+	def offset_by(time, amount, pointer)
+		direction = pointer == :future ? 1 : -1
+
+		amount_years = direction * amount / YEAR_MONTHS
+		amount_months = direction * amount % YEAR_MONTHS
+
+		new_year = time.year + amount_years
+		new_month = time.month + amount_months
+		if new_month > YEAR_MONTHS
+			new_year += 1
+			new_month -= YEAR_MONTHS
+		end
+		Time.construct(new_year, new_month, time.day, time.hour, time.min, time.sec)
+	end
+
+	def width
+		MONTH_SECONDS
+	end
+
+	def to_s
+		super << '-month'
+	end
+end

data/lib/chronic/repeaters/repeater_month_name.rb

@@ -0,0 +1,98 @@
+class Chronic::RepeaterMonthName < Chronic::Repeater #:nodoc:
+	MONTH_SECONDS = 2_592_000 # 30 * 24 * 60 * 60
+
+	def initialize(type)
+		super
+		@current_month_begin = nil
+	end
+
+	def next(pointer)
+		super
+
+		if !@current_month_begin
+			target_month = symbol_to_number(@type)
+			case pointer
+			when :future
+				if @now.month < target_month
+					@current_month_begin = Time.construct(@now.year, target_month)
+				elsif @now.month > target_month
+					@current_month_begin = Time.construct(@now.year + 1, target_month)
+				end
+			when :none
+				if @now.month <= target_month
+					@current_month_begin = Time.construct(@now.year, target_month)
+				elsif @now.month > target_month
+					@current_month_begin = Time.construct(@now.year + 1, target_month)
+				end
+			when :past
+				if @now.month > target_month
+					@current_month_begin = Time.construct(@now.year, target_month)
+				elsif @now.month < target_month
+					@current_month_begin = Time.construct(@now.year - 1, target_month)
+				end
+			end
+			@current_month_begin || raise("Current month should be set by now")
+		else
+			case pointer
+			when :future
+				@current_month_begin = Time.construct(@current_month_begin.year + 1, @current_month_begin.month)
+			when :past
+				@current_month_begin = Time.construct(@current_month_begin.year - 1, @current_month_begin.month)
+			end
+		end
+
+		cur_month_year = @current_month_begin.year
+		cur_month_month = @current_month_begin.month
+
+		if cur_month_month == 12
+			next_month_year = cur_month_year + 1
+			next_month_month = 1
+		else
+			next_month_year = cur_month_year
+			next_month_month = cur_month_month + 1
+		end
+
+		Chronic::Span.new(@current_month_begin, Time.construct(next_month_year, next_month_month))
+	end
+
+	def this(pointer = :future)
+		super
+
+		case pointer
+		when :past
+			self.next(pointer)
+		when :future, :none
+			self.next(:none)
+		end
+	end
+
+	def width
+		MONTH_SECONDS
+	end
+
+	def index
+		symbol_to_number(@type)
+	end
+
+	def to_s
+		super << '-monthname-' << @type.to_s
+	end
+
+	private
+
+	def symbol_to_number(sym)
+		lookup = {:january => 1,
+			:february => 2,
+			:march => 3,
+			:april => 4,
+			:may => 5,
+			:june => 6,
+			:july => 7,
+			:august => 8,
+			:september => 9,
+			:october => 10,
+			:november => 11,
+			:december => 12}
+		lookup[sym] || raise("Invalid symbol specified")
+	end
+end