Mercurial > hg > rc1

comparison plugins/calendar/lib/Horde_Date.php @ 3:f6fe4b6ae66a

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
calendar plugin nearly as distributed
author Charlie Root
date Sat, 13 Jan 2018 08:56:12 -0500
parents
children
comparison
equal deleted inserted replaced
2:c828b0fd4a6e 3:f6fe4b6ae66a
1 <?php
2
3 /**
4 * This is a concatenated copy of the following files:
5 * Horde/Date/Utils.php, Horde/Date/Recurrence.php
6 * Pull the latest version of these files from the PEAR channel of the Horde
7 * project at http://pear.horde.org by installing the Horde_Date package.
8 */
9
10
11 /**
12 * Horde Date wrapper/logic class, including some calculation
13 * functions.
14 *
15 * @category Horde
16 * @package Date
17 *
18 * @TODO in format():
19 * http://php.net/intldateformatter
20 *
21 * @TODO on timezones:
22 * http://trac.agavi.org/ticket/1008
23 * http://trac.agavi.org/changeset/3659
24 *
25 * @TODO on switching to PHP::DateTime:
26 * The only thing ever stored in the database *IS* Unix timestamps. Doing
27 * anything other than that is unmanageable, yet some frameworks use 'server
28 * based' times in their systems, simply because they do not bother with
29 * daylight saving and only 'serve' one timezone!
30 *
31 * The second you have to manage 'real' time across timezones then daylight
32 * saving becomes essential, BUT only on the display side! Since the browser
33 * only provides a time offset, this is useless and to be honest should simply
34 * be ignored ( until it is upgraded to provide the correct information ;)
35 * ). So we need a 'display' function that takes a simple numeric epoch, and a
36 * separate timezone id into which the epoch is to be 'converted'. My W3C
37 * mapping works simply because ADOdb then converts that to it's own simple
38 * offset abbreviation - in my case GMT or BST. As long as DateTime passes the
39 * full 64 bit number the date range from 100AD is also preserved ( and
40 * further back if 2 digit years are disabled ). If I want to display the
41 * 'real' timezone with this 'time' then I just add it in place of ADOdb's
42 * 'timezone'. I am tempted to simply adjust the ADOdb class to take a
43 * timezone in place of the simple GMT switch it currently uses.
44 *
45 * The return path is just the reverse and simply needs to take the client
46 * display offset off prior to storage of the UTC epoch. SO we use
47 * DateTimeZone to get an offset value for the clients timezone and simply add
48 * or subtract this from a timezone agnostic display on the client end when
49 * entering new times.
50 *
51 *
52 * It's not really feasible to store dates in specific timezone, as most
53 * national/local timezones support DST - and that is a pain to support, as
54 * eg. sorting breaks when some timestamps get repeated. That's why it's
55 * usually better to store datetimes as either UTC datetime or plain unix
56 * timestamp. I usually go with the former - using database datetime type.
57 */
58
59 /**
60 * @category Horde
61 * @package Date
62 */
63 class Horde_Date
64 {
65 const DATE_SUNDAY = 0;
66 const DATE_MONDAY = 1;
67 const DATE_TUESDAY = 2;
68 const DATE_WEDNESDAY = 3;
69 const DATE_THURSDAY = 4;
70 const DATE_FRIDAY = 5;
71 const DATE_SATURDAY = 6;
72
73 const MASK_SUNDAY = 1;
74 const MASK_MONDAY = 2;
75 const MASK_TUESDAY = 4;
76 const MASK_WEDNESDAY = 8;
77 const MASK_THURSDAY = 16;
78 const MASK_FRIDAY = 32;
79 const MASK_SATURDAY = 64;
80 const MASK_WEEKDAYS = 62;
81 const MASK_WEEKEND = 65;
82 const MASK_ALLDAYS = 127;
83
84 const MASK_SECOND = 1;
85 const MASK_MINUTE = 2;
86 const MASK_HOUR = 4;
87 const MASK_DAY = 8;
88 const MASK_MONTH = 16;
89 const MASK_YEAR = 32;
90 const MASK_ALLPARTS = 63;
91
92 const DATE_DEFAULT = 'Y-m-d H:i:s';
93 const DATE_JSON = 'Y-m-d\TH:i:s';
94
95 /**
96 * Year
97 *
98 * @var integer
99 */
100 protected $_year;
101
102 /**
103 * Month
104 *
105 * @var integer
106 */
107 protected $_month;
108
109 /**
110 * Day
111 *
112 * @var integer
113 */
114 protected $_mday;
115
116 /**
117 * Hour
118 *
119 * @var integer
120 */
121 protected $_hour = 0;
122
123 /**
124 * Minute
125 *
126 * @var integer
127 */
128 protected $_min = 0;
129
130 /**
131 * Second
132 *
133 * @var integer
134 */
135 protected $_sec = 0;
136
137 /**
138 * String representation of the date's timezone.
139 *
140 * @var string
141 */
142 protected $_timezone;
143
144 /**
145 * Default format for __toString()
146 *
147 * @var string
148 */
149 protected $_defaultFormat = self::DATE_DEFAULT;
150
151 /**
152 * Default specs that are always supported.
153 * @var string
154 */
155 protected static $_defaultSpecs = '%CdDeHImMnRStTyY';
156
157 /**
158 * Internally supported strftime() specifiers.
159 * @var string
160 */
161 protected static $_supportedSpecs = '';
162
163 /**
164 * Map of required correction masks.
165 *
166 * @see __set()
167 *
168 * @var array
169 */
170 protected static $_corrections = array(
171 'year' => self::MASK_YEAR,
172 'month' => self::MASK_MONTH,
173 'mday' => self::MASK_DAY,
174 'hour' => self::MASK_HOUR,
175 'min' => self::MASK_MINUTE,
176 'sec' => self::MASK_SECOND,
177 );
178
179 protected $_formatCache = array();
180
181 /**
182 * Builds a new date object. If $date contains date parts, use them to
183 * initialize the object.
184 *
185 * Recognized formats:
186 * - arrays with keys 'year', 'month', 'mday', 'day'
187 * 'hour', 'min', 'minute', 'sec'
188 * - objects with properties 'year', 'month', 'mday', 'hour', 'min', 'sec'
189 * - yyyy-mm-dd hh:mm:ss
190 * - yyyymmddhhmmss
191 * - yyyymmddThhmmssZ
192 * - yyyymmdd (might conflict with unix timestamps between 31 Oct 1966 and
193 * 03 Mar 1973)
194 * - unix timestamps
195 * - anything parsed by strtotime()/DateTime.
196 *
197 * @throws Horde_Date_Exception
198 */
199 public function __construct($date = null, $timezone = null)
200 {
201 if (!self::$_supportedSpecs) {
202 self::$_supportedSpecs = self::$_defaultSpecs;
203 if (function_exists('nl_langinfo')) {
204 self::$_supportedSpecs .= 'bBpxX';
205 }
206 }
207
208 if (func_num_args() > 2) {
209 // Handle args in order: year month day hour min sec tz
210 $this->_initializeFromArgs(func_get_args());
211 return;
212 }
213
214 $this->_initializeTimezone($timezone);
215
216 if (is_null($date)) {
217 return;
218 }
219
220 if (is_string($date)) {
221 $date = trim($date, '"');
222 }
223
224 if (is_object($date)) {
225 $this->_initializeFromObject($date);
226 } elseif (is_array($date)) {
227 $this->_initializeFromArray($date);
228 } elseif (preg_match('/^(\d{4})-?(\d{2})-?(\d{2})T? ?(\d{2}):?(\d{2}):?(\d{2})(?:\.\d+)?(Z?)$/', $date, $parts)) {
229 $this->_year = (int)$parts[1];
230 $this->_month = (int)$parts[2];
231 $this->_mday = (int)$parts[3];
232 $this->_hour = (int)$parts[4];
233 $this->_min = (int)$parts[5];
234 $this->_sec = (int)$parts[6];
235 if ($parts[7]) {
236 $this->_initializeTimezone('UTC');
237 }
238 } elseif (preg_match('/^(\d{4})-?(\d{2})-?(\d{2})$/', $date, $parts) &&
239 $parts[2] > 0 && $parts[2] <= 12 &&
240 $parts[3] > 0 && $parts[3] <= 31) {
241 $this->_year = (int)$parts[1];
242 $this->_month = (int)$parts[2];
243 $this->_mday = (int)$parts[3];
244 $this->_hour = $this->_min = $this->_sec = 0;
245 } elseif ((string)(int)$date == $date) {
246 // Try as a timestamp.
247 $parts = @getdate($date);
248 if ($parts) {
249 $this->_year = $parts['year'];
250 $this->_month = $parts['mon'];
251 $this->_mday = $parts['mday'];
252 $this->_hour = $parts['hours'];
253 $this->_min = $parts['minutes'];
254 $this->_sec = $parts['seconds'];
255 }
256 } else {
257 // Use date_create() so we can catch errors with PHP 5.2. Use
258 // "new DateTime() once we require 5.3.
259 $parsed = date_create($date);
260 if (!$parsed) {
261 throw new Horde_Date_Exception(sprintf(Horde_Date_Translation::t("Failed to parse time string (%s)"), $date));
262 }
263 $parsed->setTimezone(new DateTimeZone(date_default_timezone_get()));
264 $this->_year = (int)$parsed->format('Y');
265 $this->_month = (int)$parsed->format('m');
266 $this->_mday = (int)$parsed->format('d');
267 $this->_hour = (int)$parsed->format('H');
268 $this->_min = (int)$parsed->format('i');
269 $this->_sec = (int)$parsed->format('s');
270 $this->_initializeTimezone(date_default_timezone_get());
271 }
272 }
273
274 /**
275 * Returns a simple string representation of the date object
276 *
277 * @return string This object converted to a string.
278 */
279 public function __toString()
280 {
281 try {
282 return $this->format($this->_defaultFormat);
283 } catch (Exception $e) {
284 return '';
285 }
286 }
287
288 /**
289 * Returns a DateTime object representing this object.
290 *
291 * @return DateTime
292 */
293 public function toDateTime()
294 {
295 $date = new DateTime(null, new DateTimeZone($this->_timezone));
296 $date->setDate($this->_year, $this->_month, $this->_mday);
297 $date->setTime($this->_hour, $this->_min, $this->_sec);
298 return $date;
299 }
300
301 /**
302 * Converts a date in the proleptic Gregorian calendar to the no of days
303 * since 24th November, 4714 B.C.
304 *
305 * Returns the no of days since Monday, 24th November, 4714 B.C. in the
306 * proleptic Gregorian calendar (which is 24th November, -4713 using
307 * 'Astronomical' year numbering, and 1st January, 4713 B.C. in the
308 * proleptic Julian calendar). This is also the first day of the 'Julian
309 * Period' proposed by Joseph Scaliger in 1583, and the number of days
310 * since this date is known as the 'Julian Day'. (It is not directly
311 * to do with the Julian calendar, although this is where the name
312 * is derived from.)
313 *
314 * The algorithm is valid for all years (positive and negative), and
315 * also for years preceding 4714 B.C.
316 *
317 * Algorithm is from PEAR::Date_Calc
318 *
319 * @author Monte Ohrt <monte@ispi.net>
320 * @author Pierre-Alain Joye <pajoye@php.net>
321 * @author Daniel Convissor <danielc@php.net>
322 * @author C.A. Woodcock <c01234@netcomuk.co.uk>
323 *
324 * @return integer The number of days since 24th November, 4714 B.C.
325 */
326 public function toDays()
327 {
328 if (function_exists('GregorianToJD')) {
329 return gregoriantojd($this->_month, $this->_mday, $this->_year);
330 }
331
332 $day = $this->_mday;
333 $month = $this->_month;
334 $year = $this->_year;
335
336 if ($month > 2) {
337 // March = 0, April = 1, ..., December = 9,
338 // January = 10, February = 11
339 $month -= 3;
340 } else {
341 $month += 9;
342 --$year;
343 }
344
345 $hb_negativeyear = $year < 0;
346 $century = intval($year / 100);
347 $year = $year % 100;
348
349 if ($hb_negativeyear) {
350 // Subtract 1 because year 0 is a leap year;
351 // And N.B. that we must treat the leap years as occurring
352 // one year earlier than they do, because for the purposes
353 // of calculation, the year starts on 1st March:
354 //
355 return intval((14609700 * $century + ($year == 0 ? 1 : 0)) / 400) +
356 intval((1461 * $year + 1) / 4) +
357 intval((153 * $month + 2) / 5) +
358 $day + 1721118;
359 } else {
360 return intval(146097 * $century / 4) +
361 intval(1461 * $year / 4) +
362 intval((153 * $month + 2) / 5) +
363 $day + 1721119;
364 }
365 }
366
367 /**
368 * Converts number of days since 24th November, 4714 B.C. (in the proleptic
369 * Gregorian calendar, which is year -4713 using 'Astronomical' year
370 * numbering) to Gregorian calendar date.
371 *
372 * Returned date belongs to the proleptic Gregorian calendar, using
373 * 'Astronomical' year numbering.
374 *
375 * The algorithm is valid for all years (positive and negative), and
376 * also for years preceding 4714 B.C. (i.e. for negative 'Julian Days'),
377 * and so the only limitation is platform-dependent (for 32-bit systems
378 * the maximum year would be something like about 1,465,190 A.D.).
379 *
380 * N.B. Monday, 24th November, 4714 B.C. is Julian Day '0'.
381 *
382 * Algorithm is from PEAR::Date_Calc
383 *
384 * @author Monte Ohrt <monte@ispi.net>
385 * @author Pierre-Alain Joye <pajoye@php.net>
386 * @author Daniel Convissor <danielc@php.net>
387 * @author C.A. Woodcock <c01234@netcomuk.co.uk>
388 *
389 * @param int $days the number of days since 24th November, 4714 B.C.
390 * @param string $format the string indicating how to format the output
391 *
392 * @return Horde_Date A Horde_Date object representing the date.
393 */
394 public static function fromDays($days)
395 {
396 if (function_exists('JDToGregorian')) {
397 list($month, $day, $year) = explode('/', JDToGregorian($days));
398 } else {
399 $days = intval($days);
400
401 $days -= 1721119;
402 $century = floor((4 * $days - 1) / 146097);
403 $days = floor(4 * $days - 1 - 146097 * $century);
404 $day = floor($days / 4);
405
406 $year = floor((4 * $day + 3) / 1461);
407 $day = floor(4 * $day + 3 - 1461 * $year);
408 $day = floor(($day + 4) / 4);
409
410 $month = floor((5 * $day - 3) / 153);
411 $day = floor(5 * $day - 3 - 153 * $month);
412 $day = floor(($day + 5) / 5);
413
414 $year = $century * 100 + $year;
415 if ($month < 10) {
416 $month +=3;
417 } else {
418 $month -=9;
419 ++$year;
420 }
421 }
422
423 return new Horde_Date($year, $month, $day);
424 }
425
426 /**
427 * Getter for the date and time properties.
428 *
429 * @param string $name One of 'year', 'month', 'mday', 'hour', 'min' or
430 * 'sec'.
431 *
432 * @return integer The property value, or null if not set.
433 */
434 public function __get($name)
435 {
436 if ($name == 'day') {
437 $name = 'mday';
438 }
439
440 return $this->{'_' . $name};
441 }
442
443 /**
444 * Setter for the date and time properties.
445 *
446 * @param string $name One of 'year', 'month', 'mday', 'hour', 'min' or
447 * 'sec'.
448 * @param integer $value The property value.
449 */
450 public function __set($name, $value)
451 {
452 if ($name == 'timezone') {
453 $this->_initializeTimezone($value);
454 return;
455 }
456 if ($name == 'day') {
457 $name = 'mday';
458 }
459
460 if ($name != 'year' && $name != 'month' && $name != 'mday' &&
461 $name != 'hour' && $name != 'min' && $name != 'sec') {
462 throw new InvalidArgumentException('Undefined property ' . $name);
463 }
464
465 $down = $value < $this->{'_' . $name};
466 $this->{'_' . $name} = $value;
467 $this->_correct(self::$_corrections[$name], $down);
468 $this->_formatCache = array();
469 }
470
471 /**
472 * Returns whether a date or time property exists.
473 *
474 * @param string $name One of 'year', 'month', 'mday', 'hour', 'min' or
475 * 'sec'.
476 *
477 * @return boolen True if the property exists and is set.
478 */
479 public function __isset($name)
480 {
481 if ($name == 'day') {
482 $name = 'mday';
483 }
484 return ($name == 'year' || $name == 'month' || $name == 'mday' ||
485 $name == 'hour' || $name == 'min' || $name == 'sec') &&
486 isset($this->{'_' . $name});
487 }
488
489 /**
490 * Adds a number of seconds or units to this date, returning a new Date
491 * object.
492 */
493 public function add($factor)
494 {
495 $d = clone($this);
496 if (is_array($factor) || is_object($factor)) {
497 foreach ($factor as $property => $value) {
498 $d->$property += $value;
499 }
500 } else {
501 $d->sec += $factor;
502 }
503
504 return $d;
505 }
506
507 /**
508 * Subtracts a number of seconds or units from this date, returning a new
509 * Horde_Date object.
510 */
511 public function sub($factor)
512 {
513 if (is_array($factor)) {
514 foreach ($factor as &$value) {
515 $value *= -1;
516 }
517 } else {
518 $factor *= -1;
519 }
520
521 return $this->add($factor);
522 }
523
524 /**
525 * Converts this object to a different timezone.
526 *
527 * @param string $timezone The new timezone.
528 *
529 * @return Horde_Date This object.
530 */
531 public function setTimezone($timezone)
532 {
533 $date = $this->toDateTime();
534 $date->setTimezone(new DateTimeZone($timezone));
535 $this->_timezone = $timezone;
536 $this->_year = (int)$date->format('Y');
537 $this->_month = (int)$date->format('m');
538 $this->_mday = (int)$date->format('d');
539 $this->_hour = (int)$date->format('H');
540 $this->_min = (int)$date->format('i');
541 $this->_sec = (int)$date->format('s');
542 $this->_formatCache = array();
543 return $this;
544 }
545
546 /**
547 * Sets the default date format used in __toString()
548 *
549 * @param string $format
550 */
551 public function setDefaultFormat($format)
552 {
553 $this->_defaultFormat = $format;
554 }
555
556 /**
557 * Returns the day of the week (0 = Sunday, 6 = Saturday) of this date.
558 *
559 * @return integer The day of the week.
560 */
561 public function dayOfWeek()
562 {
563 if ($this->_month > 2) {
564 $month = $this->_month - 2;
565 $year = $this->_year;
566 } else {
567 $month = $this->_month + 10;
568 $year = $this->_year - 1;
569 }
570
571 $day = (floor((13 * $month - 1) / 5) +
572 $this->_mday + ($year % 100) +
573 floor(($year % 100) / 4) +
574 floor(($year / 100) / 4) - 2 *
575 floor($year / 100) + 77);
576
577 return (int)($day - 7 * floor($day / 7));
578 }
579
580 /**
581 * Returns the day number of the year (1 to 365/366).
582 *
583 * @return integer The day of the year.
584 */
585 public function dayOfYear()
586 {
587 return $this->format('z') + 1;
588 }
589
590 /**
591 * Returns the week of the month.
592 *
593 * @return integer The week number.
594 */
595 public function weekOfMonth()
596 {
597 return ceil($this->_mday / 7);
598 }
599
600 /**
601 * Returns the week of the year, first Monday is first day of first week.
602 *
603 * @return integer The week number.
604 */
605 public function weekOfYear()
606 {
607 return $this->format('W');
608 }
609
610 /**
611 * Returns the number of weeks in the given year (52 or 53).
612 *
613 * @param integer $year The year to count the number of weeks in.
614 *
615 * @return integer $numWeeks The number of weeks in $year.
616 */
617 public static function weeksInYear($year)
618 {
619 // Find the last Thursday of the year.
620 $date = new Horde_Date($year . '-12-31');
621 while ($date->dayOfWeek() != self::DATE_THURSDAY) {
622 --$date->mday;
623 }
624 return $date->weekOfYear();
625 }
626
627 /**
628 * Sets the date of this object to the $nth weekday of $weekday.
629 *
630 * @param integer $weekday The day of the week (0 = Sunday, etc).
631 * @param integer $nth The $nth $weekday to set to (defaults to 1).
632 */
633 public function setNthWeekday($weekday, $nth = 1)
634 {
635 if ($weekday < self::DATE_SUNDAY || $weekday > self::DATE_SATURDAY) {
636 return;
637 }
638
639 if ($nth < 0) { // last $weekday of month
640 $this->_mday = $lastday = Horde_Date_Utils::daysInMonth($this->_month, $this->_year);
641 $last = $this->dayOfWeek();
642 $this->_mday += ($weekday - $last);
643 if ($this->_mday > $lastday)
644 $this->_mday -= 7;
645 }
646 else {
647 $this->_mday = 1;
648 $first = $this->dayOfWeek();
649 if ($weekday < $first) {
650 $this->_mday = 8 + $weekday - $first;
651 } else {
652 $this->_mday = $weekday - $first + 1;
653 }
654 $diff = 7 * $nth - 7;
655 $this->_mday += $diff;
656 $this->_correct(self::MASK_DAY, $diff < 0);
657 }
658 }
659
660 /**
661 * Is the date currently represented by this object a valid date?
662 *
663 * @return boolean Validity, counting leap years, etc.
664 */
665 public function isValid()
666 {
667 return ($this->_year >= 0 && $this->_year <= 9999);
668 }
669
670 /**
671 * Compares this date to another date object to see which one is
672 * greater (later). Assumes that the dates are in the same
673 * timezone.
674 *
675 * @param mixed $other The date to compare to.
676 *
677 * @return integer == 0 if they are on the same date
678 * >= 1 if $this is greater (later)
679 * <= -1 if $other is greater (later)
680 */
681 public function compareDate($other)
682 {
683 if (!($other instanceof Horde_Date)) {
684 $other = new Horde_Date($other);
685 }
686
687 if ($this->_year != $other->year) {
688 return $this->_year - $other->year;
689 }
690 if ($this->_month != $other->month) {
691 return $this->_month - $other->month;
692 }
693
694 return $this->_mday - $other->mday;
695 }
696
697 /**
698 * Returns whether this date is after the other.
699 *
700 * @param mixed $other The date to compare to.
701 *
702 * @return boolean True if this date is after the other.
703 */
704 public function after($other)
705 {
706 return $this->compareDate($other) > 0;
707 }
708
709 /**
710 * Returns whether this date is before the other.
711 *
712 * @param mixed $other The date to compare to.
713 *
714 * @return boolean True if this date is before the other.
715 */
716 public function before($other)
717 {
718 return $this->compareDate($other) < 0;
719 }
720
721 /**
722 * Returns whether this date is the same like the other.
723 *
724 * @param mixed $other The date to compare to.
725 *
726 * @return boolean True if this date is the same like the other.
727 */
728 public function equals($other)
729 {
730 return $this->compareDate($other) == 0;
731 }
732
733 /**
734 * Compares this to another date object by time, to see which one
735 * is greater (later). Assumes that the dates are in the same
736 * timezone.
737 *
738 * @param mixed $other The date to compare to.
739 *
740 * @return integer == 0 if they are at the same time
741 * >= 1 if $this is greater (later)
742 * <= -1 if $other is greater (later)
743 */
744 public function compareTime($other)
745 {
746 if (!($other instanceof Horde_Date)) {
747 $other = new Horde_Date($other);
748 }
749
750 if ($this->_hour != $other->hour) {
751 return $this->_hour - $other->hour;
752 }
753 if ($this->_min != $other->min) {
754 return $this->_min - $other->min;
755 }
756
757 return $this->_sec - $other->sec;
758 }
759
760 /**
761 * Compares this to another date object, including times, to see
762 * which one is greater (later). Assumes that the dates are in the
763 * same timezone.
764 *
765 * @param mixed $other The date to compare to.
766 *
767 * @return integer == 0 if they are equal
768 * >= 1 if $this is greater (later)
769 * <= -1 if $other is greater (later)
770 */
771 public function compareDateTime($other)
772 {
773 if (!($other instanceof Horde_Date)) {
774 $other = new Horde_Date($other);
775 }
776
777 if ($diff = $this->compareDate($other)) {
778 return $diff;
779 }
780
781 return $this->compareTime($other);
782 }
783
784 /**
785 * Returns number of days between this date and another.
786 *
787 * @param Horde_Date $other The other day to diff with.
788 *
789 * @return integer The absolute number of days between the two dates.
790 */
791 public function diff($other)
792 {
793 return abs($this->toDays() - $other->toDays());
794 }
795
796 /**
797 * Returns the time offset for local time zone.
798 *
799 * @param boolean $colon Place a colon between hours and minutes?
800 *
801 * @return string Timezone offset as a string in the format +HH:MM.
802 */
803 public function tzOffset($colon = true)
804 {
805 return $colon ? $this->format('P') : $this->format('O');
806 }
807
808 /**
809 * Returns the unix timestamp representation of this date.
810 *
811 * @return integer A unix timestamp.
812 */
813 public function timestamp()
814 {
815 if ($this->_year >= 1970 && $this->_year < 2038) {
816 return mktime($this->_hour, $this->_min, $this->_sec,
817 $this->_month, $this->_mday, $this->_year);
818 }
819 return $this->format('U');
820 }
821
822 /**
823 * Returns the unix timestamp representation of this date, 12:00am.
824 *
825 * @return integer A unix timestamp.
826 */
827 public function datestamp()
828 {
829 if ($this->_year >= 1970 && $this->_year < 2038) {
830 return mktime(0, 0, 0, $this->_month, $this->_mday, $this->_year);
831 }
832 $date = new DateTime($this->format('Y-m-d'));
833 return $date->format('U');
834 }
835
836 /**
837 * Formats date and time to be passed around as a short url parameter.
838 *
839 * @return string Date and time.
840 */
841 public function dateString()
842 {
843 return sprintf('%04d%02d%02d', $this->_year, $this->_month, $this->_mday);
844 }
845
846 /**
847 * Formats date and time to the ISO format used by JSON.
848 *
849 * @return string Date and time.
850 */
851 public function toJson()
852 {
853 return $this->format(self::DATE_JSON);
854 }
855
856 /**
857 * Formats date and time to the RFC 2445 iCalendar DATE-TIME format.
858 *
859 * @param boolean $floating Whether to return a floating date-time
860 * (without time zone information).
861 *
862 * @return string Date and time.
863 */
864 public function toiCalendar($floating = false)
865 {
866 if ($floating) {
867 return $this->format('Ymd\THis');
868 }
869 $dateTime = $this->toDateTime();
870 $dateTime->setTimezone(new DateTimeZone('UTC'));
871 return $dateTime->format('Ymd\THis\Z');
872 }
873
874 /**
875 * Formats time using the specifiers available in date() or in the DateTime
876 * class' format() method.
877 *
878 * To format in languages other than English, use strftime() instead.
879 *
880 * @param string $format
881 *
882 * @return string Formatted time.
883 */
884 public function format($format)
885 {
886 if (!isset($this->_formatCache[$format])) {
887 $this->_formatCache[$format] = $this->toDateTime()->format($format);
888 }
889 return $this->_formatCache[$format];
890 }
891
892 /**
893 * Formats date and time using strftime() format.
894 *
895 * @return string strftime() formatted date and time.
896 */
897 public function strftime($format)
898 {
899 if (preg_match('/%[^' . self::$_supportedSpecs . ']/', $format)) {
900 return strftime($format, $this->timestamp());
901 } else {
902 return $this->_strftime($format);
903 }
904 }
905
906 /**
907 * Formats date and time using a limited set of the strftime() format.
908 *
909 * @return string strftime() formatted date and time.
910 */
911 protected function _strftime($format)
912 {
913 return preg_replace(
914 array('/%b/e',
915 '/%B/e',
916 '/%C/e',
917 '/%d/e',
918 '/%D/e',
919 '/%e/e',
920 '/%H/e',
921 '/%I/e',
922 '/%m/e',
923 '/%M/e',
924 '/%n/',
925 '/%p/e',
926 '/%R/e',
927 '/%S/e',
928 '/%t/',
929 '/%T/e',
930 '/%x/e',
931 '/%X/e',
932 '/%y/e',
933 '/%Y/',
934 '/%%/'),
935 array('$this->_strftime(Horde_Nls::getLangInfo(constant(\'ABMON_\' . (int)$this->_month)))',
936 '$this->_strftime(Horde_Nls::getLangInfo(constant(\'MON_\' . (int)$this->_month)))',
937 '(int)($this->_year / 100)',
938 'sprintf(\'%02d\', $this->_mday)',
939 '$this->_strftime(\'%m/%d/%y\')',
940 'sprintf(\'%2d\', $this->_mday)',
941 'sprintf(\'%02d\', $this->_hour)',
942 'sprintf(\'%02d\', $this->_hour == 0 ? 12 : ($this->_hour > 12 ? $this->_hour - 12 : $this->_hour))',
943 'sprintf(\'%02d\', $this->_month)',
944 'sprintf(\'%02d\', $this->_min)',
945 "\n",
946 '$this->_strftime(Horde_Nls::getLangInfo($this->_hour < 12 ? AM_STR : PM_STR))',
947 '$this->_strftime(\'%H:%M\')',
948 'sprintf(\'%02d\', $this->_sec)',
949 "\t",
950 '$this->_strftime(\'%H:%M:%S\')',
951 '$this->_strftime(Horde_Nls::getLangInfo(D_FMT))',
952 '$this->_strftime(Horde_Nls::getLangInfo(T_FMT))',
953 'substr(sprintf(\'%04d\', $this->_year), -2)',
954 (int)$this->_year,
955 '%'),
956 $format);
957 }
958
959 /**
960 * Corrects any over- or underflows in any of the date's members.
961 *
962 * @param integer $mask We may not want to correct some overflows.
963 * @param integer $down Whether to correct the date up or down.
964 */
965 protected function _correct($mask = self::MASK_ALLPARTS, $down = false)
966 {
967 if ($mask & self::MASK_SECOND) {
968 if ($this->_sec < 0 || $this->_sec > 59) {
969 $mask |= self::MASK_MINUTE;
970
971 $this->_min += (int)($this->_sec / 60);
972 $this->_sec %= 60;
973 if ($this->_sec < 0) {
974 $this->_min--;
975 $this->_sec += 60;
976 }
977 }
978 }
979
980 if ($mask & self::MASK_MINUTE) {
981 if ($this->_min < 0 || $this->_min > 59) {
982 $mask |= self::MASK_HOUR;
983
984 $this->_hour += (int)($this->_min / 60);
985 $this->_min %= 60;
986 if ($this->_min < 0) {
987 $this->_hour--;
988 $this->_min += 60;
989 }
990 }
991 }
992
993 if ($mask & self::MASK_HOUR) {
994 if ($this->_hour < 0 || $this->_hour > 23) {
995 $mask |= self::MASK_DAY;
996
997 $this->_mday += (int)($this->_hour / 24);
998 $this->_hour %= 24;
999 if ($this->_hour < 0) {
1000 $this->_mday--;
1001 $this->_hour += 24;
1002 }
1003 }
1004 }
1005
1006 if ($mask & self::MASK_MONTH) {
1007 $this->_correctMonth($down);
1008 /* When correcting the month, always correct the day too. Months
1009 * have different numbers of days. */
1010 $mask |= self::MASK_DAY;
1011 }
1012
1013 if ($mask & self::MASK_DAY) {
1014 while ($this->_mday > 28 &&
1015 $this->_mday > Horde_Date_Utils::daysInMonth($this->_month, $this->_year)) {
1016 if ($down) {
1017 $this->_mday -= Horde_Date_Utils::daysInMonth($this->_month + 1, $this->_year) - Horde_Date_Utils::daysInMonth($this->_month, $this->_year);
1018 } else {
1019 $this->_mday -= Horde_Date_Utils::daysInMonth($this->_month, $this->_year);
1020 $this->_month++;
1021 }
1022 $this->_correctMonth($down);
1023 }
1024 while ($this->_mday < 1) {
1025 --$this->_month;
1026 $this->_correctMonth($down);
1027 $this->_mday += Horde_Date_Utils::daysInMonth($this->_month, $this->_year);
1028 }
1029 }
1030 }
1031
1032 /**
1033 * Corrects the current month.
1034 *
1035 * This cannot be done in _correct() because that would also trigger a
1036 * correction of the day, which would result in an infinite loop.
1037 *
1038 * @param integer $down Whether to correct the date up or down.
1039 */
1040 protected function _correctMonth($down = false)
1041 {
1042 $this->_year += (int)($this->_month / 12);
1043 $this->_month %= 12;
1044 if ($this->_month < 1) {
1045 $this->_year--;
1046 $this->_month += 12;
1047 }
1048 }
1049
1050 /**
1051 * Handles args in order: year month day hour min sec tz
1052 */
1053 protected function _initializeFromArgs($args)
1054 {
1055 $tz = (isset($args[6])) ? array_pop($args) : null;
1056 $this->_initializeTimezone($tz);
1057
1058 $args = array_slice($args, 0, 6);
1059 $keys = array('year' => 1, 'month' => 1, 'mday' => 1, 'hour' => 0, 'min' => 0, 'sec' => 0);
1060 $date = array_combine(array_slice(array_keys($keys), 0, count($args)), $args);
1061 $date = array_merge($keys, $date);
1062
1063 $this->_initializeFromArray($date);
1064 }
1065
1066 protected function _initializeFromArray($date)
1067 {
1068 if (isset($date['year']) && is_string($date['year']) && strlen($date['year']) == 2) {
1069 if ($date['year'] > 70) {
1070 $date['year'] += 1900;
1071 } else {
1072 $date['year'] += 2000;
1073 }
1074 }
1075
1076 foreach ($date as $key => $val) {
1077 if (in_array($key, array('year', 'month', 'mday', 'hour', 'min', 'sec'))) {
1078 $this->{'_'. $key} = (int)$val;
1079 }
1080 }
1081
1082 // If $date['day'] is present and numeric we may have been passed
1083 // a Horde_Form_datetime array.
1084 if (isset($date['day']) &&
1085 (string)(int)$date['day'] == $date['day']) {
1086 $this->_mday = (int)$date['day'];
1087 }
1088 // 'minute' key also from Horde_Form_datetime
1089 if (isset($date['minute']) &&
1090 (string)(int)$date['minute'] == $date['minute']) {
1091 $this->_min = (int)$date['minute'];
1092 }
1093
1094 $this->_correct();
1095 }
1096
1097 protected function _initializeFromObject($date)
1098 {
1099 if ($date instanceof DateTime) {
1100 $this->_year = (int)$date->format('Y');
1101 $this->_month = (int)$date->format('m');
1102 $this->_mday = (int)$date->format('d');
1103 $this->_hour = (int)$date->format('H');
1104 $this->_min = (int)$date->format('i');
1105 $this->_sec = (int)$date->format('s');
1106 $this->_initializeTimezone($date->getTimezone()->getName());
1107 } else {
1108 $is_horde_date = $date instanceof Horde_Date;
1109 foreach (array('year', 'month', 'mday', 'hour', 'min', 'sec') as $key) {
1110 if ($is_horde_date || isset($date->$key)) {
1111 $this->{'_' . $key} = (int)$date->$key;
1112 }
1113 }
1114 if (!$is_horde_date) {
1115 $this->_correct();
1116 } else {
1117 $this->_initializeTimezone($date->timezone);
1118 }
1119 }
1120 }
1121
1122 protected function _initializeTimezone($timezone)
1123 {
1124 if (empty($timezone)) {
1125 $timezone = date_default_timezone_get();
1126 }
1127 $this->_timezone = $timezone;
1128 }
1129
1130 }
1131
1132 /**
1133 * @category Horde
1134 * @package Date
1135 */
1136
1137 /**
1138 * Horde Date wrapper/logic class, including some calculation
1139 * functions.
1140 *
1141 * @category Horde
1142 * @package Date
1143 */
1144 class Horde_Date_Utils
1145 {
1146 /**
1147 * Returns whether a year is a leap year.
1148 *
1149 * @param integer $year The year.
1150 *
1151 * @return boolean True if the year is a leap year.
1152 */
1153 public static function isLeapYear($year)
1154 {
1155 if (strlen($year) != 4 || preg_match('/\D/', $year)) {
1156 return false;
1157 }
1158
1159 return (($year % 4 == 0 && $year % 100 != 0) || $year % 400 == 0);
1160 }
1161
1162 /**
1163 * Returns the date of the year that corresponds to the first day of the
1164 * given week.
1165 *
1166 * @param integer $week The week of the year to find the first day of.
1167 * @param integer $year The year to calculate for.
1168 *
1169 * @return Horde_Date The date of the first day of the given week.
1170 */
1171 public static function firstDayOfWeek($week, $year)
1172 {
1173 return new Horde_Date(sprintf('%04dW%02d', $year, $week));
1174 }
1175
1176 /**
1177 * Returns the number of days in the specified month.
1178 *
1179 * @param integer $month The month
1180 * @param integer $year The year.
1181 *
1182 * @return integer The number of days in the month.
1183 */
1184 public static function daysInMonth($month, $year)
1185 {
1186 static $cache = array();
1187 if (!isset($cache[$year][$month])) {
1188 $date = new DateTime(sprintf('%04d-%02d-01', $year, $month));
1189 $cache[$year][$month] = $date->format('t');
1190 }
1191 return $cache[$year][$month];
1192 }
1193
1194 /**
1195 * Returns a relative, natural language representation of a timestamp
1196 *
1197 * @todo Wider range of values ... maybe future time as well?
1198 * @todo Support minimum resolution parameter.
1199 *
1200 * @param mixed $time The time. Any format accepted by Horde_Date.
1201 * @param string $date_format Format to display date if timestamp is
1202 * more then 1 day old.
1203 * @param string $time_format Format to display time if timestamp is 1
1204 * day old.
1205 *
1206 * @return string The relative time (i.e. 2 minutes ago)
1207 */
1208 public static function relativeDateTime($time, $date_format = '%x',
1209 $time_format = '%X')
1210 {
1211 $date = new Horde_Date($time);
1212
1213 $delta = time() - $date->timestamp();
1214 if ($delta < 60) {
1215 return sprintf(Horde_Date_Translation::ngettext("%d second ago", "%d seconds ago", $delta), $delta);
1216 }
1217
1218 $delta = round($delta / 60);
1219 if ($delta < 60) {
1220 return sprintf(Horde_Date_Translation::ngettext("%d minute ago", "%d minutes ago", $delta), $delta);
1221 }
1222
1223 $delta = round($delta / 60);
1224 if ($delta < 24) {
1225 return sprintf(Horde_Date_Translation::ngettext("%d hour ago", "%d hours ago", $delta), $delta);
1226 }
1227
1228 if ($delta > 24 && $delta < 48) {
1229 $date = new Horde_Date($time);
1230 return sprintf(Horde_Date_Translation::t("yesterday at %s"), $date->strftime($time_format));
1231 }
1232
1233 $delta = round($delta / 24);
1234 if ($delta < 7) {
1235 return sprintf(Horde_Date_Translation::t("%d days ago"), $delta);
1236 }
1237
1238 if (round($delta / 7) < 5) {
1239 $delta = round($delta / 7);
1240 return sprintf(Horde_Date_Translation::ngettext("%d week ago", "%d weeks ago", $delta), $delta);
1241 }
1242
1243 // Default to the user specified date format.
1244 return $date->strftime($date_format);
1245 }
1246
1247 /**
1248 * Tries to convert strftime() formatters to date() formatters.
1249 *
1250 * Unsupported formatters will be removed.
1251 *
1252 * @param string $format A strftime() formatting string.
1253 *
1254 * @return string A date() formatting string.
1255 */
1256 public static function strftime2date($format)
1257 {
1258 $replace = array(
1259 '/%a/' => 'D',
1260 '/%A/' => 'l',
1261 '/%d/' => 'd',
1262 '/%e/' => 'j',
1263 '/%j/' => 'z',
1264 '/%u/' => 'N',
1265 '/%w/' => 'w',
1266 '/%U/' => '',
1267 '/%V/' => 'W',
1268 '/%W/' => '',
1269 '/%b/' => 'M',
1270 '/%B/' => 'F',
1271 '/%h/' => 'M',
1272 '/%m/' => 'm',
1273 '/%C/' => '',
1274 '/%g/' => '',
1275 '/%G/' => 'o',
1276 '/%y/' => 'y',
1277 '/%Y/' => 'Y',
1278 '/%H/' => 'H',
1279 '/%I/' => 'h',
1280 '/%i/' => 'g',
1281 '/%M/' => 'i',
1282 '/%p/' => 'A',
1283 '/%P/' => 'a',
1284 '/%r/' => 'h:i:s A',
1285 '/%R/' => 'H:i',
1286 '/%S/' => 's',
1287 '/%T/' => 'H:i:s',
1288 '/%X/e' => 'Horde_Date_Utils::strftime2date(Horde_Nls::getLangInfo(T_FMT))',
1289 '/%z/' => 'O',
1290 '/%Z/' => '',
1291 '/%c/' => '',
1292 '/%D/' => 'm/d/y',
1293 '/%F/' => 'Y-m-d',
1294 '/%s/' => 'U',
1295 '/%x/e' => 'Horde_Date_Utils::strftime2date(Horde_Nls::getLangInfo(D_FMT))',
1296 '/%n/' => "\n",
1297 '/%t/' => "\t",
1298 '/%%/' => '%'
1299 );
1300
1301 return preg_replace(array_keys($replace), array_values($replace), $format);
1302 }
1303
1304 }