master

PhutilCalendarRecurrenceRule.php
View Options

			<?php

			final class PhutilCalendarRecurrenceRule
			extends PhutilCalendarRecurrenceSource {

			private $startDateTime;
			private $frequency;
			private $frequencyScale;
			private $interval = 1;
			private $bySecond = array();
			private $byMinute = array();
			private $byHour = array();
			private $byDay = array();
			private $byMonthDay = array();
			private $byYearDay = array();
			private $byWeekNumber = array();
			private $byMonth = array();
			private $bySetPosition = array();
			private $weekStart = self::WEEKDAY_MONDAY;
			private $count;
			private $until;

			private $cursorSecond;
			private $cursorMinute;
			private $cursorHour;
			private $cursorHourState;
			private $cursorWeek;
			private $cursorWeekday;
			private $cursorWeekState;
			private $cursorDay;
			private $cursorDayState;
			private $cursorMonth;
			private $cursorYear;

			private $setSeconds;
			private $setMinutes;
			private $setHours;
			private $setDays;
			private $setMonths;
			private $setWeeks;
			private $setYears;

			private $stateSecond;
			private $stateMinute;
			private $stateHour;
			private $stateDay;
			private $stateWeek;
			private $stateMonth;
			private $stateYear;

			private $baseYear;
			private $isAllDay;
			private $activeSet = array();
			private $nextSet = array();
			private $minimumEpoch;

			const FREQUENCY_SECONDLY = 'SECONDLY';
			const FREQUENCY_MINUTELY = 'MINUTELY';
			const FREQUENCY_HOURLY = 'HOURLY';
			const FREQUENCY_DAILY = 'DAILY';
			const FREQUENCY_WEEKLY = 'WEEKLY';
			const FREQUENCY_MONTHLY = 'MONTHLY';
			const FREQUENCY_YEARLY = 'YEARLY';

			const SCALE_SECONDLY = 1;
			const SCALE_MINUTELY = 2;
			const SCALE_HOURLY = 3;
			const SCALE_DAILY = 4;
			const SCALE_WEEKLY = 5;
			const SCALE_MONTHLY = 6;
			const SCALE_YEARLY = 7;

			const WEEKDAY_SUNDAY = 'SU';
			const WEEKDAY_MONDAY = 'MO';
			const WEEKDAY_TUESDAY = 'TU';
			const WEEKDAY_WEDNESDAY = 'WE';
			const WEEKDAY_THURSDAY = 'TH';
			const WEEKDAY_FRIDAY = 'FR';
			const WEEKDAY_SATURDAY = 'SA';

			const WEEKINDEX_SUNDAY = 0;
			const WEEKINDEX_MONDAY = 1;
			const WEEKINDEX_TUESDAY = 2;
			const WEEKINDEX_WEDNESDAY = 3;
			const WEEKINDEX_THURSDAY = 4;
			const WEEKINDEX_FRIDAY = 5;
			const WEEKINDEX_SATURDAY = 6;

			public function toDictionary() {
			$parts = array();

			$parts['FREQ'] = $this->getFrequency();

			$interval = $this->getInterval();
			if ($interval != 1) {
			$parts['INTERVAL'] = $interval;
			}

			$by_second = $this->getBySecond();
			if ($by_second) {
			$parts['BYSECOND'] = $by_second;
			}

			$by_minute = $this->getByMinute();
			if ($by_minute) {
			$parts['BYMINUTE'] = $by_minute;
			}

			$by_hour = $this->getByHour();
			if ($by_hour) {
			$parts['BYHOUR'] = $by_hour;
			}

			$by_day = $this->getByDay();
			if ($by_day) {
			$parts['BYDAY'] = $by_day;
			}

			$by_month = $this->getByMonth();
			if ($by_month) {
			$parts['BYMONTH'] = $by_month;
			}

			$by_monthday = $this->getByMonthDay();
			if ($by_monthday) {
			$parts['BYMONTHDAY'] = $by_monthday;
			}

			$by_yearday = $this->getByYearDay();
			if ($by_yearday) {
			$parts['BYYEARDAY'] = $by_yearday;
			}

			$by_weekno = $this->getByWeekNumber();
			if ($by_weekno) {
			$parts['BYWEEKNO'] = $by_weekno;
			}

			$by_setpos = $this->getBySetPosition();
			if ($by_setpos) {
			$parts['BYSETPOS'] = $by_setpos;
			}

			$wkst = $this->getWeekStart();
			if ($wkst != self::WEEKDAY_MONDAY) {
			$parts['WKST'] = $wkst;
			}

			$count = $this->getCount();
			if ($count) {
			$parts['COUNT'] = $count;
			}

			$until = $this->getUntil();
			if ($until) {
			$parts['UNTIL'] = $until->getISO8601();
			}

			return $parts;
			}

			public static function newFromDictionary(array $dict) {
			static $expect;
			if ($expect === null) {
			$expect = array_fuse(
			array(
			'FREQ',
			'INTERVAL',
			'BYSECOND',
			'BYMINUTE',
			'BYHOUR',
			'BYDAY',
			'BYMONTH',
			'BYMONTHDAY',
			'BYYEARDAY',
			'BYWEEKNO',
			'BYSETPOS',
			'WKST',
			'UNTIL',
			'COUNT',
			));
			}

			foreach ($dict as $key => $value) {
			if (empty($expect[$key])) {
			throw new Exception(
			pht(
			'RRULE dictionary includes unknown key "%s". Expected keys '.
			'are: %s.',
			$key,
			implode(', ', array_keys($expect))));
			}
			}

			$rrule = id(new self())
			->setFrequency(idx($dict, 'FREQ'))
			->setInterval(idx($dict, 'INTERVAL', 1))
			->setBySecond(idx($dict, 'BYSECOND', array()))
			->setByMinute(idx($dict, 'BYMINUTE', array()))
			->setByHour(idx($dict, 'BYHOUR', array()))
			->setByDay(idx($dict, 'BYDAY', array()))
			->setByMonth(idx($dict, 'BYMONTH', array()))
			->setByMonthDay(idx($dict, 'BYMONTHDAY', array()))
			->setByYearDay(idx($dict, 'BYYEARDAY', array()))
			->setByWeekNumber(idx($dict, 'BYWEEKNO', array()))
			->setBySetPosition(idx($dict, 'BYSETPOS', array()))
			->setWeekStart(idx($dict, 'WKST', self::WEEKDAY_MONDAY));

			$count = idx($dict, 'COUNT');
			if ($count) {
			$rrule->setCount($count);
			}

			$until = idx($dict, 'UNTIL');
			if ($until) {
			$until = PhutilCalendarAbsoluteDateTime::newFromISO8601($until);
			$rrule->setUntil($until);
			}

			return $rrule;
			}

			public function toRRULE() {
			$dict = $this->toDictionary();

			$parts = array();
			foreach ($dict as $key => $value) {
			if (is_array($value)) {
			$value = implode(',', $value);
			}
			$parts[] = "{$key}={$value}";
			}

			return implode(';', $parts);
			}

			public static function newFromRRULE($rrule) {
			$parts = explode(';', $rrule);

			$dict = array();
			foreach ($parts as $part) {
			list($key, $value) = explode('=', $part, 2);
			switch ($key) {
			case 'FREQ':
			case 'INTERVAL':
			case 'WKST':
			case 'COUNT':
			case 'UNTIL';
			break;
			default:
			$value = explode(',', $value);
			break;
			}
			$dict[$key] = $value;
			}

			$int_lists = array_fuse(
			array(
			// NOTE: "BYDAY" is absent, and takes a list like "MO, TU, WE".
			'BYSECOND',
			'BYMINUTE',
			'BYHOUR',
			'BYMONTH',
			'BYMONTHDAY',
			'BYYEARDAY',
			'BYWEEKNO',
			'BYSETPOS',
			));

			$int_values = array_fuse(
			array(
			'COUNT',
			'INTERVAL',
			));

			foreach ($dict as $key => $value) {
			if (isset($int_values[$key])) {
			// None of these values may be negative.
			if (!preg_match('/^\d+\z/', $value)) {
			throw new Exception(
			pht(
			'Unexpected value "%s" in "%s" RULE property: expected an '.
			'integer.',
			$value,
			$key));
			}
			$dict[$key] = (int)$value;
			}

			if (isset($int_lists[$key])) {
			foreach ($value as $k => $v) {
			if (!preg_match('/^-?\d+\z/', $v)) {
			throw new Exception(
			pht(
			'Unexpected value "%s" in "%s" RRULE property: expected '.
			'only integers.',
			$v,
			$key));
			}
			$value[$k] = (int)$v;
			}
			$dict[$key] = $value;
			}
			}

			return self::newFromDictionary($dict);
			}

			private static function getAllWeekdayConstants() {
			return array_keys(self::getWeekdayIndexMap());
			}

			private static function getWeekdayIndexMap() {
			static $map = array(
			self::WEEKDAY_SUNDAY => self::WEEKINDEX_SUNDAY,
			self::WEEKDAY_MONDAY => self::WEEKINDEX_MONDAY,
			self::WEEKDAY_TUESDAY => self::WEEKINDEX_TUESDAY,
			self::WEEKDAY_WEDNESDAY => self::WEEKINDEX_WEDNESDAY,
			self::WEEKDAY_THURSDAY => self::WEEKINDEX_THURSDAY,
			self::WEEKDAY_FRIDAY => self::WEEKINDEX_FRIDAY,
			self::WEEKDAY_SATURDAY => self::WEEKINDEX_SATURDAY,
			);

			return $map;
			}

			private static function getWeekdayIndex($weekday) {
			$map = self::getWeekdayIndexMap();
			if (!isset($map[$weekday])) {
			$constants = array_keys($map);
			throw new Exception(
			pht(
			'Weekday "%s" is not a valid weekday constant. Valid constants '.
			'are: %s.',
			$weekday,
			implode(', ', $constants)));
			}

			return $map[$weekday];
			}

			public function setStartDateTime(PhutilCalendarDateTime $start) {
			$this->startDateTime = $start;
			return $this;
			}

			public function getStartDateTime() {
			return $this->startDateTime;
			}

			public function setCount($count) {
			if ($count < 1) {
			throw new Exception(
			pht(
			'RRULE COUNT value "%s" is invalid: count must be at least 1.',
			$count));
			}

			$this->count = $count;
			return $this;
			}

			public function getCount() {
			return $this->count;
			}

			public function setUntil(PhutilCalendarDateTime $until) {
			$this->until = $until;
			return $this;
			}

			public function getUntil() {
			return $this->until;
			}

			public function setFrequency($frequency) {
			static $map = array(
			self::FREQUENCY_SECONDLY => self::SCALE_SECONDLY,
			self::FREQUENCY_MINUTELY => self::SCALE_MINUTELY,
			self::FREQUENCY_HOURLY => self::SCALE_HOURLY,
			self::FREQUENCY_DAILY => self::SCALE_DAILY,
			self::FREQUENCY_WEEKLY => self::SCALE_WEEKLY,
			self::FREQUENCY_MONTHLY => self::SCALE_MONTHLY,
			self::FREQUENCY_YEARLY => self::SCALE_YEARLY,
			);

			if (empty($map[$frequency])) {
			throw new Exception(
			pht(
			'RRULE FREQ "%s" is invalid. Valid frequencies are: %s.',
			$frequency,
			implode(', ', array_keys($map))));
			}

			$this->frequency = $frequency;
			$this->frequencyScale = $map[$frequency];

			return $this;
			}

			public function getFrequency() {
			return $this->frequency;
			}

			public function getFrequencyScale() {
			return $this->frequencyScale;
			}

			public function setInterval($interval) {
			if (!is_int($interval)) {
			throw new Exception(
			pht(
			'RRULE INTERVAL "%s" is invalid: interval must be an integer.',
			$interval));
			}

			if ($interval < 1) {
			throw new Exception(
			pht(
			'RRULE INTERVAL "%s" is invalid: interval must be 1 or more.',
			$interval));
			}

			$this->interval = $interval;
			return $this;
			}

			public function getInterval() {
			return $this->interval;
			}

			public function setBySecond(array $by_second) {
			$this->assertByRange('BYSECOND', $by_second, 0, 60);
			$this->bySecond = array_fuse($by_second);
			return $this;
			}

			public function getBySecond() {
			return $this->bySecond;
			}

			public function setByMinute(array $by_minute) {
			$this->assertByRange('BYMINUTE', $by_minute, 0, 59);
			$this->byMinute = array_fuse($by_minute);
			return $this;
			}

			public function getByMinute() {
			return $this->byMinute;
			}

			public function setByHour(array $by_hour) {
			$this->assertByRange('BYHOUR', $by_hour, 0, 23);
			$this->byHour = array_fuse($by_hour);
			return $this;
			}

			public function getByHour() {
			return $this->byHour;
			}

			public function setByDay(array $by_day) {
			$constants = self::getAllWeekdayConstants();
			$constants = implode('\|', $constants);

			$pattern = '/^(?:[+-]?([1-9]\d?))?('.$constants.')\z/';
			foreach ($by_day as $key => $value) {
			$matches = null;
			if (!preg_match($pattern, $value, $matches)) {
			throw new Exception(
			pht(
			'RRULE BYDAY value "%s" is invalid: rule part must be in the '.
			'expected form (like "MO", "-3TH", or "+2SU").',
			$value));
			}

			// The maximum allowed value is 53, which corresponds to "the 53rd
			// Monday every year" or similar when evaluated against a YEARLY rule.

			$maximum = 53;
			$magnitude = (int)$matches[1];
			if ($magnitude > $maximum) {
			throw new Exception(
			pht(
			'RRULE BYDAY value "%s" has an offset with magnitude "%s", but '.
			'the maximum permitted value is "%s".',
			$value,
			$magnitude,
			$maximum));
			}

			// Normalize "+3FR" into "3FR".
			$by_day[$key] = ltrim($value, '+');
			}

			$this->byDay = array_fuse($by_day);
			return $this;
			}

			public function getByDay() {
			return $this->byDay;
			}

			public function setByMonthDay(array $by_month_day) {
			$this->assertByRange('BYMONTHDAY', $by_month_day, -31, 31, false);
			$this->byMonthDay = array_fuse($by_month_day);
			return $this;
			}

			public function getByMonthDay() {
			return $this->byMonthDay;
			}

			public function setByYearDay($by_year_day) {
			$this->assertByRange('BYYEARDAY', $by_year_day, -366, 366, false);
			$this->byYearDay = array_fuse($by_year_day);
			return $this;
			}

			public function getByYearDay() {
			return $this->byYearDay;
			}

			public function setByMonth(array $by_month) {
			$this->assertByRange('BYMONTH', $by_month, 1, 12);
			$this->byMonth = array_fuse($by_month);
			return $this;
			}

			public function getByMonth() {
			return $this->byMonth;
			}

			public function setByWeekNumber(array $by_week_number) {
			$this->assertByRange('BYWEEKNO', $by_week_number, -53, 53, false);
			$this->byWeekNumber = array_fuse($by_week_number);
			return $this;
			}

			public function getByWeekNumber() {
			return $this->byWeekNumber;
			}

			public function setBySetPosition(array $by_set_position) {
			$this->assertByRange('BYSETPOS', $by_set_position, -366, 366, false);
			$this->bySetPosition = $by_set_position;
			return $this;
			}

			public function getBySetPosition() {
			return $this->bySetPosition;
			}

			public function setWeekStart($week_start) {
			// Make sure this is a valid weekday constant.
			self::getWeekdayIndex($week_start);

			$this->weekStart = $week_start;
			return $this;
			}

			public function getWeekStart() {
			return $this->weekStart;
			}

			public function resetSource() {
			$frequency = $this->getFrequency();

			if ($this->getByMonthDay()) {
			switch ($frequency) {
			case self::FREQUENCY_WEEKLY:
			// RFC5545: "The BYMONTHDAY rule part MUST NOT be specified when the
			// FREQ rule part is set to WEEKLY."
			throw new Exception(
			pht(
			'RRULE specifies BYMONTHDAY with FREQ set to WEEKLY, which '.
			'violates RFC5545.'));
			default:
			break;
			}

			}

			if ($this->getByYearDay()) {
			switch ($frequency) {
			case self::FREQUENCY_DAILY:
			case self::FREQUENCY_WEEKLY:
			case self::FREQUENCY_MONTHLY:
			// RFC5545: "The BYYEARDAY rule part MUST NOT be specified when the
			// FREQ rule part is set to DAILY, WEEKLY, or MONTHLY."
			throw new Exception(
			pht(
			'RRULE specifies BYYEARDAY with FREQ of DAILY, WEEKLY or '.
			'MONTHLY, which violates RFC5545.'));
			default:
			break;
			}
			}

			// TODO
			// RFC5545: "The BYDAY rule part MUST NOT be specified with a numeric
			// value when the FREQ rule part is not set to MONTHLY or YEARLY."
			// RFC5545: "Furthermore, the BYDAY rule part MUST NOT be specified with a
			// numeric value with the FREQ rule part set to YEARLY when the BYWEEKNO
			// rule part is specified."


			$date = $this->getStartDateTime();

			$this->cursorSecond = $date->getSecond();
			$this->cursorMinute = $date->getMinute();
			$this->cursorHour = $date->getHour();

			$this->cursorDay = $date->getDay();
			$this->cursorMonth = $date->getMonth();
			$this->cursorYear = $date->getYear();

			$year_map = $this->getYearMap($this->cursorYear, $this->getWeekStart());
			$key = $this->cursorMonth.'M'.$this->cursorDay.'D';
			$this->cursorWeek = $year_map['info'][$key]['week'];
			$this->cursorWeekday = $year_map['info'][$key]['weekday'];

			$this->setSeconds = array();
			$this->setMinutes = array();
			$this->setHours = array();
			$this->setDays = array();
			$this->setMonths = array();
			$this->setYears = array();

			$this->stateSecond = null;
			$this->stateMinute = null;
			$this->stateHour = null;
			$this->stateDay = null;
			$this->stateWeek = null;
			$this->stateMonth = null;
			$this->stateYear = null;

			// If we have a BYSETPOS, we need to generate the entire set before we
			// can filter it and return results. Normally, we start generating at
			// the start date, but we need to go back one interval to generate
			// BYSETPOS events so we can make sure the entire set is generated.
			if ($this->getBySetPosition()) {
			$interval = $this->getInterval();
			switch ($frequency) {
			case self::FREQUENCY_YEARLY:
			$this->cursorYear -= $interval;
			break;
			case self::FREQUENCY_MONTHLY:
			$this->cursorMonth -= $interval;
			$this->rewindMonth();
			break;
			case self::FREQUENCY_WEEKLY:
			$this->cursorWeek -= $interval;
			$this->rewindWeek();
			break;
			case self::FREQUENCY_DAILY:
			$this->cursorDay -= $interval;
			$this->rewindDay();
			break;
			case self::FREQUENCY_HOURLY:
			$this->cursorHour -= $interval;
			$this->rewindHour();
			break;
			case self::FREQUENCY_MINUTELY:
			$this->cursorMinute -= $interval;
			$this->rewindMinute();
			break;
			case self::FREQUENCY_SECONDLY:
			default:
			throw new Exception(
			pht(
			'RRULE specifies BYSETPOS with FREQ "%s", but this is invalid.',
			$frequency));
			}
			}

			// We can generate events from before the cursor when evaluating rules
			// with BYSETPOS or FREQ=WEEKLY.
			$this->minimumEpoch = $this->getStartDateTime()->getEpoch();

			$cursor_state = array(
			'year' => $this->cursorYear,
			'month' => $this->cursorMonth,
			'week' => $this->cursorWeek,
			'day' => $this->cursorDay,
			'hour' => $this->cursorHour,
			);

			$this->cursorDayState = $cursor_state;
			$this->cursorWeekState = $cursor_state;
			$this->cursorHourState = $cursor_state;

			$by_hour = $this->getByHour();
			$by_minute = $this->getByMinute();
			$by_second = $this->getBySecond();

			$scale = $this->getFrequencyScale();

			// We return all-day events if the start date is an all-day event and we
			// don't have more granular selectors or a more granular frequency.
			$this->isAllDay = $date->getIsAllDay()
			&& !$by_hour
			&& !$by_minute
			&& !$by_second
			&& ($scale > self::SCALE_HOURLY);
			}

			public function getNextEvent($cursor) {
			while (true) {
			$event = $this->generateNextEvent();
			if (!$event) {
			break;
			}

			$epoch = $event->getEpoch();
			if ($this->minimumEpoch) {
			if ($epoch < $this->minimumEpoch) {
			continue;
			}
			}

			if ($epoch < $cursor) {
			continue;
			}

			break;
			}

			return $event;
			}

			private function generateNextEvent() {
			if ($this->activeSet) {
			return array_pop($this->activeSet);
			}

			$this->baseYear = $this->cursorYear;

			$by_setpos = $this->getBySetPosition();
			if ($by_setpos) {
			$old_state = $this->getSetPositionState();
			}

			while (!$this->activeSet) {
			$this->activeSet = $this->nextSet;
			$this->nextSet = array();

			while (true) {
			if ($this->isAllDay) {
			$this->nextDay();
			} else {
			$this->nextSecond();
			}

			$result = id(new PhutilCalendarAbsoluteDateTime())
			->setTimezone($this->getStartDateTime()->getTimezone())
			->setViewerTimezone($this->getViewerTimezone())
			->setYear($this->stateYear)
			->setMonth($this->stateMonth)
			->setDay($this->stateDay);

			if ($this->isAllDay) {
			$result->setIsAllDay(true);
			} else {
			$result
			->setHour($this->stateHour)
			->setMinute($this->stateMinute)
			->setSecond($this->stateSecond);
			}

			// If we don't have BYSETPOS, we're all done. We put this into the
			// set and will immediately return it.
			if (!$by_setpos) {
			$this->activeSet[] = $result;
			break;
			}

			// Otherwise, check if we've completed a set. The set is complete if
			// the state has moved past the span we were examining (for example,
			// with a YEARLY event, if the state is now in the next year).
			$new_state = $this->getSetPositionState();
			if ($new_state == $old_state) {
			$this->activeSet[] = $result;
			continue;
			}

			$this->activeSet = $this->applySetPos($this->activeSet, $by_setpos);
			$this->activeSet = array_reverse($this->activeSet);
			$this->nextSet[] = $result;
			$old_state = $new_state;
			break;
			}
			}

			return array_pop($this->activeSet);
			}


			protected function nextSecond() {
			if ($this->setSeconds) {
			$this->stateSecond = array_pop($this->setSeconds);
			return;
			}

			$frequency = $this->getFrequency();
			$interval = $this->getInterval();
			$is_secondly = ($frequency == self::FREQUENCY_SECONDLY);
			$by_second = $this->getBySecond();

			while (!$this->setSeconds) {
			$this->nextMinute();

			if ($is_secondly \|\| $by_second) {
			$seconds = $this->newSecondsSet(
			($is_secondly ? $interval : 1),
			$by_second);
			} else {
			$seconds = array(
			$this->cursorSecond,
			);
			}

			$this->setSeconds = array_reverse($seconds);
			}

			$this->stateSecond = array_pop($this->setSeconds);
			}

			protected function nextMinute() {
			if ($this->setMinutes) {
			$this->stateMinute = array_pop($this->setMinutes);
			return;
			}

			$frequency = $this->getFrequency();
			$interval = $this->getInterval();
			$scale = $this->getFrequencyScale();
			$is_minutely = ($frequency === self::FREQUENCY_MINUTELY);
			$by_minute = $this->getByMinute();

			while (!$this->setMinutes) {
			$this->nextHour();

			if ($is_minutely \|\| $by_minute) {
			$minutes = $this->newMinutesSet(
			($is_minutely ? $interval : 1),
			$by_minute);
			} else if ($scale < self::SCALE_MINUTELY) {
			$minutes = $this->newMinutesSet(
			1,
			array());
			} else {
			$minutes = array(
			$this->cursorMinute,
			);
			}

			$this->setMinutes = array_reverse($minutes);
			}

			$this->stateMinute = array_pop($this->setMinutes);
			}

			protected function nextHour() {
			if ($this->setHours) {
			$this->stateHour = array_pop($this->setHours);
			return;
			}

			$frequency = $this->getFrequency();
			$interval = $this->getInterval();
			$scale = $this->getFrequencyScale();
			$is_hourly = ($frequency === self::FREQUENCY_HOURLY);
			$by_hour = $this->getByHour();

			while (!$this->setHours) {
			$this->nextDay();

			$is_dynamic = $is_hourly
			\|\| $by_hour
			\|\| ($scale < self::SCALE_HOURLY);

			if ($is_dynamic) {
			$hours = $this->newHoursSet(
			($is_hourly ? $interval : 1),
			$by_hour);
			} else {
			$hours = array(
			$this->cursorHour,
			);
			}

			$this->setHours = array_reverse($hours);
			}

			$this->stateHour = array_pop($this->setHours);
			}

			protected function nextDay() {
			if ($this->setDays) {
			$info = array_pop($this->setDays);
			$this->setDayState($info);
			return;
			}

			$frequency = $this->getFrequency();
			$interval = $this->getInterval();
			$scale = $this->getFrequencyScale();
			$is_daily = ($frequency === self::FREQUENCY_DAILY);
			$is_weekly = ($frequency === self::FREQUENCY_WEEKLY);

			$by_day = $this->getByDay();
			$by_monthday = $this->getByMonthDay();
			$by_yearday = $this->getByYearDay();
			$by_weekno = $this->getByWeekNumber();
			$by_month = $this->getByMonth();
			$week_start = $this->getWeekStart();

			while (!$this->setDays) {
			if ($is_weekly) {
			$this->nextWeek();
			} else {
			$this->nextMonth();
			}

			// NOTE: We normally handle BYMONTH when iterating months, but it acts
			// like a filter if FREQ=WEEKLY.

			$is_dynamic = $is_daily
			\|\| $is_weekly
			\|\| $by_day
			\|\| $by_monthday
			\|\| $by_yearday
			\|\| $by_weekno
			\|\| ($by_month && $is_weekly)
			\|\| ($scale < self::SCALE_DAILY);

			if ($is_dynamic) {
			$weeks = $this->newDaysSet(
			($is_daily ? $interval : 1),
			$by_day,
			$by_monthday,
			$by_yearday,
			$by_weekno,
			$by_month,
			$week_start);
			} else {
			// The cursor day may not actually exist in the current month, so
			// make sure the day is valid before we generate a set which contains
			// it.
			$year_map = $this->getYearMap($this->stateYear, $week_start);
			if ($this->cursorDay > $year_map['monthDays'][$this->stateMonth]) {
			$weeks = array(
			array(),
			);
			} else {
			$key = $this->stateMonth.'M'.$this->cursorDay.'D';
			$weeks = array(
			array($year_map['info'][$key]),
			);
			}
			}

			// Unpack the weeks into days.
			$days = array_mergev($weeks);

			$this->setDays = array_reverse($days);
			}

			$info = array_pop($this->setDays);
			$this->setDayState($info);
			}

			private function setDayState(array $info) {
			$this->stateDay = $info['monthday'];
			$this->stateWeek = $info['week'];
			$this->stateMonth = $info['month'];
			}

			protected function nextMonth() {
			if ($this->setMonths) {
			$this->stateMonth = array_pop($this->setMonths);
			return;
			}

			$frequency = $this->getFrequency();
			$interval = $this->getInterval();
			$scale = $this->getFrequencyScale();
			$is_monthly = ($frequency === self::FREQUENCY_MONTHLY);

			$by_month = $this->getByMonth();

			// If we have a BYMONTHDAY, we consider that set of days in every month.
			// For example, "FREQ=YEARLY;BYMONTHDAY=3" means "the third day of every
			// month", so we need to expand the month set if the constraint is present.
			$by_monthday = $this->getByMonthDay();

			// Likewise, we need to generate all months if we have BYYEARDAY or
			// BYWEEKNO or BYDAY.
			$by_yearday = $this->getByYearDay();
			$by_weekno = $this->getByWeekNumber();
			$by_day = $this->getByDay();

			while (!$this->setMonths) {
			$this->nextYear();

			$is_dynamic = $is_monthly
			\|\| $by_month
			\|\| $by_monthday
			\|\| $by_yearday
			\|\| $by_weekno
			\|\| $by_day
			\|\| ($scale < self::SCALE_MONTHLY);

			if ($is_dynamic) {
			$months = $this->newMonthsSet(
			($is_monthly ? $interval : 1),
			$by_month);
			} else {
			$months = array(
			$this->cursorMonth,
			);
			}

			$this->setMonths = array_reverse($months);
			}

			$this->stateMonth = array_pop($this->setMonths);
			}

			protected function nextWeek() {
			if ($this->setWeeks) {
			$this->stateWeek = array_pop($this->setWeeks);
			return;
			}

			$frequency = $this->getFrequency();
			$interval = $this->getInterval();
			$scale = $this->getFrequencyScale();
			$by_weekno = $this->getByWeekNumber();

			while (!$this->setWeeks) {
			$this->nextYear();

			$weeks = $this->newWeeksSet(
			$interval,
			$by_weekno);

			$this->setWeeks = array_reverse($weeks);
			}

			$this->stateWeek = array_pop($this->setWeeks);
			}

			protected function nextYear() {
			$this->stateYear = $this->cursorYear;

			$frequency = $this->getFrequency();
			$is_yearly = ($frequency === self::FREQUENCY_YEARLY);

			if ($is_yearly) {
			$interval = $this->getInterval();
			} else {
			$interval = 1;
			}

			$this->cursorYear = $this->cursorYear + $interval;

			if ($this->cursorYear > ($this->baseYear + 100)) {
			throw new Exception(
			pht(
			'RRULE evaluation failed to generate more events in the next 100 '.
			'years. This RRULE is likely invalid or degenerate.'));
			}

			}

			private function newSecondsSet($interval, $set) {
			// TODO: This doesn't account for leap seconds. In theory, it probably
			// should, although this shouldn't impact any real events.
			$seconds_in_minute = 60;

			if ($this->cursorSecond >= $seconds_in_minute) {
			$this->cursorSecond -= $seconds_in_minute;
			return array();
			}

			list($cursor, $result) = $this->newIteratorSet(
			$this->cursorSecond,
			$interval,
			$set,
			$seconds_in_minute);

			$this->cursorSecond = ($cursor - $seconds_in_minute);

			return $result;
			}

			private function newMinutesSet($interval, $set) {
			// NOTE: This value is legitimately a constant! Amazing!
			$minutes_in_hour = 60;

			if ($this->cursorMinute >= $minutes_in_hour) {
			$this->cursorMinute -= $minutes_in_hour;
			return array();
			}

			list($cursor, $result) = $this->newIteratorSet(
			$this->cursorMinute,
			$interval,
			$set,
			$minutes_in_hour);

			$this->cursorMinute = ($cursor - $minutes_in_hour);

			return $result;
			}

			private function newHoursSet($interval, $set) {
			// TODO: This doesn't account for hours caused by daylight savings time.
			// It probably should, although this seems unlikely to impact any real
			// events.
			$hours_in_day = 24;

			// If the hour cursor is behind the current time, we need to forward it in
			// INTERVAL increments so we end up with the right offset.
			list($skip, $this->cursorHourState) = $this->advanceCursorState(
			$this->cursorHourState,
			self::SCALE_HOURLY,
			$interval,
			$this->getWeekStart());

			if ($skip) {
			return array();
			}

			list($cursor, $result) = $this->newIteratorSet(
			$this->cursorHour,
			$interval,
			$set,
			$hours_in_day);

			$this->cursorHour = ($cursor - $hours_in_day);

			return $result;
			}

			private function newWeeksSet($interval, $set) {
			$week_start = $this->getWeekStart();

			list($skip, $this->cursorWeekState) = $this->advanceCursorState(
			$this->cursorWeekState,
			self::SCALE_WEEKLY,
			$interval,
			$week_start);

			if ($skip) {
			return array();
			}

			$year_map = $this->getYearMap($this->stateYear, $week_start);

			$result = array();
			while (true) {
			if (!isset($year_map['weekMap'][$this->cursorWeek])) {
			break;
			}
			$result[] = $this->cursorWeek;
			$this->cursorWeek += $interval;
			}

			$this->cursorWeek -= $year_map['weekCount'];

			return $result;
			}

			private function newDaysSet(
			$interval_day,
			$by_day,
			$by_monthday,
			$by_yearday,
			$by_weekno,
			$by_month,
			$week_start) {

			$frequency = $this->getFrequency();
			$is_yearly = ($frequency == self::FREQUENCY_YEARLY);
			$is_monthly = ($frequency == self::FREQUENCY_MONTHLY);
			$is_weekly = ($frequency == self::FREQUENCY_WEEKLY);

			$selection = array();
			if ($is_weekly) {
			$year_map = $this->getYearMap($this->stateYear, $week_start);

			if (isset($year_map['weekMap'][$this->stateWeek])) {
			foreach ($year_map['weekMap'][$this->stateWeek] as $key) {
			$selection[] = $year_map['info'][$key];
			}
			}
			} else {
			// If the day cursor is behind the current year and month, we need to
			// forward it in INTERVAL increments so we end up with the right offset
			// in the current month.
			list($skip, $this->cursorDayState) = $this->advanceCursorState(
			$this->cursorDayState,
			self::SCALE_DAILY,
			$interval_day,
			$week_start);

			if (!$skip) {
			$year_map = $this->getYearMap($this->stateYear, $week_start);
			while (true) {
			$month_idx = $this->stateMonth;
			$month_days = $year_map['monthDays'][$month_idx];
			if ($this->cursorDay > $month_days) {
			// NOTE: The year map is now out of date, but we're about to break
			// out of the loop anyway so it doesn't matter.
			break;
			}

			$day_idx = $this->cursorDay;

			$key = "{$month_idx}M{$day_idx}D";
			$selection[] = $year_map['info'][$key];

			$this->cursorDay += $interval_day;
			}
			}
			}

			// As a special case, BYDAY applies to relative month offsets if BYMONTH
			// is present in a YEARLY rule.
			if ($is_yearly) {
			if ($this->getByMonth()) {
			$is_yearly = false;
			$is_monthly = true;
			}
			}

			// As a special case, BYDAY makes us examine all week days. This doesn't
			// check BYMONTHDAY or BYYEARDAY because they are not valid with WEEKLY.
			$filter_weekday = true;
			if ($is_weekly) {
			if ($by_day) {
			$filter_weekday = false;
			}
			}

			$weeks = array();
			foreach ($selection as $key => $info) {
			if ($is_weekly) {
			if ($filter_weekday) {
			if ($info['weekday'] != $this->cursorWeekday) {
			continue;
			}
			}
			} else {
			if ($info['month'] != $this->stateMonth) {
			continue;
			}
			}

			if ($by_day) {
			if (empty($by_day[$info['weekday']])) {
			if ($is_yearly) {
			if (empty($by_day[$info['weekday.yearly']]) &&
			empty($by_day[$info['-weekday.yearly']])) {
			continue;
			}
			} else if ($is_monthly) {
			if (empty($by_day[$info['weekday.monthly']]) &&
			empty($by_day[$info['-weekday.monthly']])) {
			continue;
			}
			} else {
			continue;
			}
			}
			}

			if ($by_monthday) {
			if (empty($by_monthday[$info['monthday']]) &&
			empty($by_monthday[$info['-monthday']])) {
			continue;
			}
			}

			if ($by_yearday) {
			if (empty($by_yearday[$info['yearday']]) &&
			empty($by_yearday[$info['-yearday']])) {
			continue;
			}
			}

			if ($by_weekno) {
			if (empty($by_weekno[$info['week']]) &&
			empty($by_weekno[$info['-week']])) {
			continue;
			}
			}

			if ($by_month) {
			if (empty($by_month[$info['month']])) {
			continue;
			}
			}

			$weeks[$info['week']][] = $info;
			}

			return array_values($weeks);
			}

			private function newMonthsSet($interval, $set) {
			// NOTE: This value is also a real constant! Wow!
			$months_in_year = 12;

			if ($this->cursorMonth > $months_in_year) {
			$this->cursorMonth -= $months_in_year;
			return array();
			}

			list($cursor, $result) = $this->newIteratorSet(
			$this->cursorMonth,
			$interval,
			$set,
			$months_in_year + 1);

			$this->cursorMonth = ($cursor - $months_in_year);

			return $result;
			}

			public static function getYearMap($year, $week_start) {
			static $maps = array();

			$key = "{$year}/{$week_start}";
			if (isset($maps[$key])) {
			return $maps[$key];
			}

			$map = self::newYearMap($year, $week_start);
			$maps[$key] = $map;

			return $maps[$key];
			}

			private static function newYearMap($year, $weekday_start) {
			$weekday_index = self::getWeekdayIndex($weekday_start);

			$is_leap = (($year % 4 === 0) && ($year % 100 !== 0)) \|\|
			($year % 400 === 0);

			// There may be some clever way to figure out which day of the week a given
			// year starts on and avoid the cost of a DateTime construction, but I
			// wasn't able to turn it up and we only need to do this once per year.
			$datetime = new DateTime("{$year}-01-01", new DateTimeZone('UTC'));
			$weekday = (int)$datetime->format('w');

			if ($is_leap) {
			$max_day = 366;
			} else {
			$max_day = 365;
			}

			$month_days = array(
			1 => 31,
			2 => $is_leap ? 29 : 28,
			3 => 31,
			4 => 30,
			5 => 31,
			6 => 30,
			7 => 31,
			8 => 31,
			9 => 30,
			10 => 31,
			11 => 30,
			12 => 31,
			);

			// Per the spec, the first week of the year must contain at least four
			// days. If the week starts on a Monday but the year starts on a Saturday,
			// the first couple of days don't count as a week. In this case, the first
			// week will begin on January 3.
			$first_week_size = 0;
			$first_weekday = $weekday;
			for ($year_day = 1; $year_day <= $max_day; $year_day++) {
			$first_weekday = ($first_weekday + 1) % 7;
			$first_week_size++;
			if ($first_weekday === $weekday_index) {
			break;
			}
			}

			if ($first_week_size >= 4) {
			$week_number = 1;
			} else {
			$week_number = 0;
			}

			$info_map = array();

			$weekday_map = self::getWeekdayIndexMap();
			$weekday_map = array_flip($weekday_map);

			$yearly_counts = array();
			$monthly_counts = array();

			$month_number = 1;
			$month_day = 1;
			for ($year_day = 1; $year_day <= $max_day; $year_day++) {
			$key = "{$month_number}M{$month_day}D";

			$short_day = $weekday_map[$weekday];
			if (empty($yearly_counts[$short_day])) {
			$yearly_counts[$short_day] = 0;
			}
			$yearly_counts[$short_day]++;

			if (empty($monthly_counts[$month_number][$short_day])) {
			$monthly_counts[$month_number][$short_day] = 0;
			}
			$monthly_counts[$month_number][$short_day]++;

			$info = array(
			'year' => $year,
			'key' => $key,
			'month' => $month_number,
			'monthday' => $month_day,
			'-monthday' => -$month_days[$month_number] + $month_day - 1,
			'yearday' => $year_day,
			'-yearday' => -$max_day + $year_day - 1,
			'week' => $week_number,
			'weekday' => $short_day,
			'weekday.yearly' => $yearly_counts[$short_day],
			'weekday.monthly' => $monthly_counts[$month_number][$short_day],
			);

			$info_map[$key] = $info;

			$weekday = ($weekday + 1) % 7;
			if ($weekday === $weekday_index) {
			$week_number++;
			}

			$month_day = ($month_day + 1);
			if ($month_day > $month_days[$month_number]) {
			$month_day = 1;
			$month_number++;
			}
			}

			// Check how long the final week is. If it doesn't have four days, this
			// is really the first week of the next year.
			$final_week = array();
			foreach ($info_map as $key => $info) {
			if ($info['week'] == $week_number) {
			$final_week[] = $key;
			}
			}

			if (count($final_week) < 4) {
			$week_number = $week_number - 1;
			$next_year = self::getYearMap($year + 1, $weekday_start);
			$next_year_weeks = $next_year['weekCount'];
			} else {
			$next_year_weeks = null;
			}

			if ($first_week_size < 4) {
			$last_year = self::getYearMap($year - 1, $weekday_start);
			$last_year_weeks = $last_year['weekCount'];
			} else {
			$last_year_weeks = null;
			}

			// Now that we know how many weeks the year has, we can compute the
			// negative offsets.
			foreach ($info_map as $key => $info) {
			$week = $info['week'];

			if ($week === 0) {
			// If this day is part of the first partial week of the year, give
			// it the week number of the last week of the prior year instead.
			$info['week'] = $last_year_weeks;
			$info['-week'] = -1;
			} else if ($week > $week_number) {
			// If this day is part of the last partial week of the year, give
			// it week numbers from the next year.
			$info['week'] = 1;
			$info['-week'] = -$next_year_weeks;
			} else {
			$info['-week'] = -$week_number + $week - 1;
			}

			// Do all the arithmetic to figure out if this is the -19th Thursday
			// in the year and such.
			$month_number = $info['month'];
			$short_day = $info['weekday'];
			$monthly_count = $monthly_counts[$month_number][$short_day];
			$monthly_index = $info['weekday.monthly'];
			$info['-weekday.monthly'] = -$monthly_count + $monthly_index - 1;
			$info['-weekday.monthly'] .= $short_day;
			$info['weekday.monthly'] .= $short_day;

			$yearly_count = $yearly_counts[$short_day];
			$yearly_index = $info['weekday.yearly'];
			$info['-weekday.yearly'] = -$yearly_count + $yearly_index - 1;
			$info['-weekday.yearly'] .= $short_day;
			$info['weekday.yearly'] .= $short_day;

			$info_map[$key] = $info;
			}

			$week_map = array();
			foreach ($info_map as $key => $info) {
			$week_map[$info['week']][] = $key;
			}

			return array(
			'info' => $info_map,
			'weekCount' => $week_number,
			'dayCount' => $max_day,
			'monthDays' => $month_days,
			'weekMap' => $week_map,
			);
			}

			private function newIteratorSet($cursor, $interval, $set, $limit) {
			if ($interval < 1) {
			throw new Exception(
			pht(
			'Invalid iteration interval ("%d"), must be at least 1.',
			$interval));
			}

			$result = array();
			$seen = array();

			$ii = $cursor;
			while (true) {
			if (!$set \|\| isset($set[$ii])) {
			$result[] = $ii;
			}

			$ii = ($ii + $interval);

			if ($ii >= $limit) {
			break;
			}
			}

			sort($result);
			$result = array_values($result);

			return array($ii, $result);
			}

			private function applySetPos(array $values, array $setpos) {
			$select = array();

			$count = count($values);
			foreach ($setpos as $pos) {
			if ($pos > 0 && $pos <= $count) {
			$select[] = ($pos - 1);
			} else if ($pos < 0 && $pos >= -$count) {
			$select[] = ($count + $pos);
			}
			}

			sort($select);
			$select = array_unique($select);

			return array_select_keys($values, $select);
			}

			private function assertByRange(
			$source,
			array $values,
			$min,
			$max,
			$allow_zero = true) {

			foreach ($values as $value) {
			if (!is_int($value)) {
			throw new Exception(
			pht(
			'Value "%s" in RRULE "%s" parameter is invalid: values must be '.
			'integers.',
			$value,
			$source));
			}

			if ($value < $min \|\| $value > $max) {
			throw new Exception(
			pht(
			'Value "%s" in RRULE "%s" parameter is invalid: it must be '.
			'between %s and %s.',
			$value,
			$source,
			$min,
			$max));
			}

			if (!$value && !$allow_zero) {
			throw new Exception(
			pht(
			'Value "%s" in RRULE "%s" parameter is invalid: it must not '.
			'be zero.',
			$value,
			$source));
			}
			}
			}

			private function getSetPositionState() {
			$scale = $this->getFrequencyScale();

			$parts = array();
			$parts[] = $this->stateYear;

			if ($scale == self::SCALE_WEEKLY) {
			$parts[] = $this->stateWeek;
			} else {
			if ($scale < self::SCALE_YEARLY) {
			$parts[] = $this->stateMonth;
			}
			if ($scale < self::SCALE_MONTHLY) {
			$parts[] = $this->stateDay;
			}
			if ($scale < self::SCALE_DAILY) {
			$parts[] = $this->stateHour;
			}
			if ($scale < self::SCALE_HOURLY) {
			$parts[] = $this->stateMinute;
			}
			}

			return implode('/', $parts);
			}

			private function rewindMonth() {
			while ($this->cursorMonth < 1) {
			$this->cursorYear--;
			$this->cursorMonth += 12;
			}
			}

			private function rewindWeek() {
			$week_start = $this->getWeekStart();
			while ($this->cursorWeek < 1) {
			$this->cursorYear--;
			$year_map = $this->getYearMap($this->cursorYear, $week_start);
			$this->cursorWeek += $year_map['weekCount'];
			}
			}

			private function rewindDay() {
			$week_start = $this->getWeekStart();
			while ($this->cursorDay < 1) {
			$year_map = $this->getYearMap($this->cursorYear, $week_start);
			$this->cursorDay += $year_map['monthDays'][$this->cursorMonth];
			$this->cursorMonth--;
			$this->rewindMonth();
			}
			}

			private function rewindHour() {
			while ($this->cursorHour < 0) {
			$this->cursorHour += 24;
			$this->cursorDay--;
			$this->rewindDay();
			}
			}

			private function rewindMinute() {
			while ($this->cursorMinute < 0) {
			$this->cursorMinute += 60;
			$this->cursorHour--;
			$this->rewindHour();
			}
			}

			private function advanceCursorState(
			array $cursor,
			$scale,
			$interval,
			$week_start) {

			$state = array(
			'year' => $this->stateYear,
			'month' => $this->stateMonth,
			'week' => $this->stateWeek,
			'day' => $this->stateDay,
			'hour' => $this->stateHour,
			);

			// In the common case when the interval is 1, we'll visit every possible
			// value so we don't need to do any math and can just jump to the first
			// hour, day, etc.
			if ($interval == 1) {
			if ($this->isCursorBehind($cursor, $state, $scale)) {
			switch ($scale) {
			case self::SCALE_DAILY:
			$this->cursorDay = 1;
			break;
			case self::SCALE_HOURLY:
			$this->cursorHour = 0;
			break;
			case self::SCALE_WEEKLY:
			$this->cursorWeek = 1;
			break;
			}
			}

			return array(false, $state);
			}

			$year_map = $this->getYearMap($cursor['year'], $week_start);
			while ($this->isCursorBehind($cursor, $state, $scale)) {
			switch ($scale) {
			case self::SCALE_DAILY:
			$cursor['day'] += $interval;
			break;
			case self::SCALE_HOURLY:
			$cursor['hour'] += $interval;
			break;
			case self::SCALE_WEEKLY:
			$cursor['week'] += $interval;
			break;
			}

			if ($scale <= self::SCALE_HOURLY) {
			while ($cursor['hour'] >= 24) {
			$cursor['hour'] -= 24;
			$cursor['day']++;
			}
			}

			if ($scale == self::SCALE_WEEKLY) {
			while ($cursor['week'] > $year_map['weekCount']) {
			$cursor['week'] -= $year_map['weekCount'];
			$cursor['year']++;
			$year_map = $this->getYearMap($cursor['year'], $week_start);
			}
			}

			if ($scale <= self::SCALE_DAILY) {
			while ($cursor['day'] > $year_map['monthDays'][$cursor['month']]) {
			$cursor['day'] -= $year_map['monthDays'][$cursor['month']];
			$cursor['month']++;
			if ($cursor['month'] > 12) {
			$cursor['month'] -= 12;
			$cursor['year']++;
			$year_map = $this->getYearMap($cursor['year'], $week_start);
			}
			}
			}
			}

			switch ($scale) {
			case self::SCALE_DAILY:
			$this->cursorDay = $cursor['day'];
			break;
			case self::SCALE_HOURLY:
			$this->cursorHour = $cursor['hour'];
			break;
			case self::SCALE_WEEKLY:
			$this->cursorWeek = $cursor['week'];
			break;
			}

			$skip = $this->isCursorBehind($state, $cursor, $scale);

			return array($skip, $cursor);
			}

			private function isCursorBehind(array $cursor, array $state, $scale) {
			if ($cursor['year'] < $state['year']) {
			return true;
			} else if ($cursor['year'] > $state['year']) {
			return false;
			}

			if ($scale == self::SCALE_WEEKLY) {
			return false;
			}

			if ($cursor['month'] < $state['month']) {
			return true;
			} else if ($cursor['month'] > $state['month']) {
			return false;
			}

			if ($scale >= self::SCALE_DAILY) {
			return false;
			}

			if ($cursor['day'] < $state['day']) {
			return true;
			} else if ($cursor['day'] > $state['day']) {
			return false;
			}

			if ($scale >= self::SCALE_HOURLY) {
			return false;
			}

			if ($cursor['hour'] < $state['hour']) {
			return true;
			} else if ($cursor['hour'] > $state['hour']) {
			return false;
			}

			return false;
			}


			}

Owner Packages

No Owners

phorge/src/applications/calendar/parser/data/PhutilCalendarRecurrenceRule.phpe81eff68e581HEAD -> master

PhutilCalendarRecurrenceRule.phpView Options

Owner Packages

phorge/src/applications/calendar/parser/data/PhutilCalendarRecurrenceRule.php
e81eff68e581HEAD -> master

PhutilCalendarRecurrenceRule.php
View Options