Boundaries.php
4 years ago
Cast.php
4 years ago
Comparison.php
2 years ago
Converter.php
2 years ago
Creator.php
2 years ago
Date.php
9 months ago
DeprecatedProperties.php
4 years ago
Difference.php
2 years ago
IntervalRounding.php
2 years ago
IntervalStep.php
4 years ago
Localization.php
9 months ago
Macro.php
4 years ago
MagicParameter.php
2 years ago
Mixin.php
2 years ago
Modifiers.php
4 years ago
Mutability.php
4 years ago
ObjectInitialisation.php
4 years ago
Options.php
2 years ago
Rounding.php
2 years ago
Serialization.php
2 years ago
Test.php
9 months ago
Timestamp.php
1 year ago
ToStringFormat.php
3 years ago
Units.php
2 years ago
Week.php
4 years ago
index.php
3 years ago
Comparison.php
323 lines
| 1 | <?php |
| 2 | namespace MailPoetVendor\Carbon\Traits; |
| 3 | if (!defined('ABSPATH')) exit; |
| 4 | use BadMethodCallException; |
| 5 | use MailPoetVendor\Carbon\CarbonInterface; |
| 6 | use MailPoetVendor\Carbon\Exceptions\BadComparisonUnitException; |
| 7 | use InvalidArgumentException; |
| 8 | trait Comparison |
| 9 | { |
| 10 | protected $endOfTime = \false; |
| 11 | protected $startOfTime = \false; |
| 12 | public function eq($date) : bool |
| 13 | { |
| 14 | return $this->equalTo($date); |
| 15 | } |
| 16 | public function equalTo($date) : bool |
| 17 | { |
| 18 | $this->discourageNull($date); |
| 19 | $this->discourageBoolean($date); |
| 20 | return $this == $this->resolveCarbon($date); |
| 21 | } |
| 22 | public function ne($date) : bool |
| 23 | { |
| 24 | return $this->notEqualTo($date); |
| 25 | } |
| 26 | public function notEqualTo($date) : bool |
| 27 | { |
| 28 | return !$this->equalTo($date); |
| 29 | } |
| 30 | public function gt($date) : bool |
| 31 | { |
| 32 | return $this->greaterThan($date); |
| 33 | } |
| 34 | public function greaterThan($date) : bool |
| 35 | { |
| 36 | $this->discourageNull($date); |
| 37 | $this->discourageBoolean($date); |
| 38 | return $this > $this->resolveCarbon($date); |
| 39 | } |
| 40 | public function isAfter($date) : bool |
| 41 | { |
| 42 | return $this->greaterThan($date); |
| 43 | } |
| 44 | public function gte($date) : bool |
| 45 | { |
| 46 | return $this->greaterThanOrEqualTo($date); |
| 47 | } |
| 48 | public function greaterThanOrEqualTo($date) : bool |
| 49 | { |
| 50 | $this->discourageNull($date); |
| 51 | $this->discourageBoolean($date); |
| 52 | return $this >= $this->resolveCarbon($date); |
| 53 | } |
| 54 | public function lt($date) : bool |
| 55 | { |
| 56 | return $this->lessThan($date); |
| 57 | } |
| 58 | public function lessThan($date) : bool |
| 59 | { |
| 60 | $this->discourageNull($date); |
| 61 | $this->discourageBoolean($date); |
| 62 | return $this < $this->resolveCarbon($date); |
| 63 | } |
| 64 | public function isBefore($date) : bool |
| 65 | { |
| 66 | return $this->lessThan($date); |
| 67 | } |
| 68 | public function lte($date) : bool |
| 69 | { |
| 70 | return $this->lessThanOrEqualTo($date); |
| 71 | } |
| 72 | public function lessThanOrEqualTo($date) : bool |
| 73 | { |
| 74 | $this->discourageNull($date); |
| 75 | $this->discourageBoolean($date); |
| 76 | return $this <= $this->resolveCarbon($date); |
| 77 | } |
| 78 | public function between($date1, $date2, $equal = \true) : bool |
| 79 | { |
| 80 | $date1 = $this->resolveCarbon($date1); |
| 81 | $date2 = $this->resolveCarbon($date2); |
| 82 | if ($date1->greaterThan($date2)) { |
| 83 | [$date1, $date2] = [$date2, $date1]; |
| 84 | } |
| 85 | if ($equal) { |
| 86 | return $this >= $date1 && $this <= $date2; |
| 87 | } |
| 88 | return $this > $date1 && $this < $date2; |
| 89 | } |
| 90 | public function betweenIncluded($date1, $date2) : bool |
| 91 | { |
| 92 | return $this->between($date1, $date2, \true); |
| 93 | } |
| 94 | public function betweenExcluded($date1, $date2) : bool |
| 95 | { |
| 96 | return $this->between($date1, $date2, \false); |
| 97 | } |
| 98 | public function isBetween($date1, $date2, $equal = \true) : bool |
| 99 | { |
| 100 | return $this->between($date1, $date2, $equal); |
| 101 | } |
| 102 | public function isWeekday() |
| 103 | { |
| 104 | return !$this->isWeekend(); |
| 105 | } |
| 106 | public function isWeekend() |
| 107 | { |
| 108 | return \in_array($this->dayOfWeek, static::$weekendDays, \true); |
| 109 | } |
| 110 | public function isYesterday() |
| 111 | { |
| 112 | return $this->toDateString() === static::yesterday($this->getTimezone())->toDateString(); |
| 113 | } |
| 114 | public function isToday() |
| 115 | { |
| 116 | return $this->toDateString() === $this->nowWithSameTz()->toDateString(); |
| 117 | } |
| 118 | public function isTomorrow() |
| 119 | { |
| 120 | return $this->toDateString() === static::tomorrow($this->getTimezone())->toDateString(); |
| 121 | } |
| 122 | public function isFuture() |
| 123 | { |
| 124 | return $this->greaterThan($this->nowWithSameTz()); |
| 125 | } |
| 126 | public function isPast() |
| 127 | { |
| 128 | return $this->lessThan($this->nowWithSameTz()); |
| 129 | } |
| 130 | public function isLeapYear() |
| 131 | { |
| 132 | return $this->rawFormat('L') === '1'; |
| 133 | } |
| 134 | public function isLongYear() |
| 135 | { |
| 136 | return static::create($this->year, 12, 28, 0, 0, 0, $this->tz)->weekOfYear === 53; |
| 137 | } |
| 138 | public function isLongIsoYear() |
| 139 | { |
| 140 | return static::create($this->isoWeekYear, 12, 28, 0, 0, 0, $this->tz)->weekOfYear === 53; |
| 141 | } |
| 142 | public function isSameAs($format, $date = null) |
| 143 | { |
| 144 | return $this->rawFormat($format) === $this->resolveCarbon($date)->rawFormat($format); |
| 145 | } |
| 146 | public function isSameUnit($unit, $date = null) |
| 147 | { |
| 148 | $units = [ |
| 149 | // @call isSameUnit |
| 150 | 'year' => 'Y', |
| 151 | // @call isSameUnit |
| 152 | 'week' => 'o-W', |
| 153 | // @call isSameUnit |
| 154 | 'day' => 'Y-m-d', |
| 155 | // @call isSameUnit |
| 156 | 'hour' => 'Y-m-d H', |
| 157 | // @call isSameUnit |
| 158 | 'minute' => 'Y-m-d H:i', |
| 159 | // @call isSameUnit |
| 160 | 'second' => 'Y-m-d H:i:s', |
| 161 | // @call isSameUnit |
| 162 | 'micro' => 'Y-m-d H:i:s.u', |
| 163 | // @call isSameUnit |
| 164 | 'microsecond' => 'Y-m-d H:i:s.u', |
| 165 | ]; |
| 166 | if (isset($units[$unit])) { |
| 167 | return $this->isSameAs($units[$unit], $date); |
| 168 | } |
| 169 | if (isset($this->{$unit})) { |
| 170 | return $this->resolveCarbon($date)->{$unit} === $this->{$unit}; |
| 171 | } |
| 172 | if ($this->localStrictModeEnabled ?? static::isStrictModeEnabled()) { |
| 173 | throw new BadComparisonUnitException($unit); |
| 174 | } |
| 175 | return \false; |
| 176 | } |
| 177 | public function isCurrentUnit($unit) |
| 178 | { |
| 179 | return $this->{'isSame' . \ucfirst($unit)}(); |
| 180 | } |
| 181 | public function isSameQuarter($date = null, $ofSameYear = \true) |
| 182 | { |
| 183 | $date = $this->resolveCarbon($date); |
| 184 | return $this->quarter === $date->quarter && (!$ofSameYear || $this->isSameYear($date)); |
| 185 | } |
| 186 | public function isSameMonth($date = null, $ofSameYear = \true) |
| 187 | { |
| 188 | return $this->isSameAs($ofSameYear ? 'Y-m' : 'm', $date); |
| 189 | } |
| 190 | public function isDayOfWeek($dayOfWeek) |
| 191 | { |
| 192 | if (\is_string($dayOfWeek) && \defined($constant = static::class . '::' . \strtoupper($dayOfWeek))) { |
| 193 | $dayOfWeek = \constant($constant); |
| 194 | } |
| 195 | return $this->dayOfWeek === $dayOfWeek; |
| 196 | } |
| 197 | public function isBirthday($date = null) |
| 198 | { |
| 199 | return $this->isSameAs('md', $date); |
| 200 | } |
| 201 | public function isLastOfMonth() |
| 202 | { |
| 203 | return $this->day === $this->daysInMonth; |
| 204 | } |
| 205 | public function isStartOfDay($checkMicroseconds = \false) |
| 206 | { |
| 207 | return $checkMicroseconds ? $this->rawFormat('H:i:s.u') === '00:00:00.000000' : $this->rawFormat('H:i:s') === '00:00:00'; |
| 208 | } |
| 209 | public function isEndOfDay($checkMicroseconds = \false) |
| 210 | { |
| 211 | return $checkMicroseconds ? $this->rawFormat('H:i:s.u') === '23:59:59.999999' : $this->rawFormat('H:i:s') === '23:59:59'; |
| 212 | } |
| 213 | public function isMidnight() |
| 214 | { |
| 215 | return $this->isStartOfDay(); |
| 216 | } |
| 217 | public function isMidday() |
| 218 | { |
| 219 | return $this->rawFormat('G:i:s') === static::$midDayAt . ':00:00'; |
| 220 | } |
| 221 | public static function hasFormat($date, $format) |
| 222 | { |
| 223 | // createFromFormat() is known to handle edge cases silently. |
| 224 | // E.g. "1975-5-1" (Y-n-j) will still be parsed correctly when "Y-m-d" is supplied as the format. |
| 225 | // To ensure we're really testing against our desired format, perform an additional regex validation. |
| 226 | return self::matchFormatPattern((string) $date, \preg_quote((string) $format, '/'), static::$regexFormats); |
| 227 | } |
| 228 | public static function hasFormatWithModifiers($date, $format) : bool |
| 229 | { |
| 230 | return self::matchFormatPattern((string) $date, (string) $format, \array_merge(static::$regexFormats, static::$regexFormatModifiers)); |
| 231 | } |
| 232 | public static function canBeCreatedFromFormat($date, $format) |
| 233 | { |
| 234 | try { |
| 235 | // Try to create a DateTime object. Throws an InvalidArgumentException if the provided time string |
| 236 | // doesn't match the format in any way. |
| 237 | if (!static::rawCreateFromFormat($format, $date)) { |
| 238 | return \false; |
| 239 | } |
| 240 | } catch (InvalidArgumentException $e) { |
| 241 | return \false; |
| 242 | } |
| 243 | return static::hasFormatWithModifiers($date, $format); |
| 244 | } |
| 245 | public function is(string $tester) |
| 246 | { |
| 247 | $tester = \trim($tester); |
| 248 | if (\preg_match('/^\\d+$/', $tester)) { |
| 249 | return $this->year === (int) $tester; |
| 250 | } |
| 251 | if (\preg_match('/^(?:Jan|January|Feb|February|Mar|March|Apr|April|May|Jun|June|Jul|July|Aug|August|Sep|September|Oct|October|Nov|November|Dec|December)$/i', $tester)) { |
| 252 | return $this->isSameMonth(static::parse($tester), \false); |
| 253 | } |
| 254 | if (\preg_match('/^\\d{3,}-\\d{1,2}$/', $tester)) { |
| 255 | return $this->isSameMonth(static::parse($tester)); |
| 256 | } |
| 257 | if (\preg_match('/^\\d{1,2}-\\d{1,2}$/', $tester)) { |
| 258 | return $this->isSameDay(static::parse($this->year . '-' . $tester)); |
| 259 | } |
| 260 | $modifier = \preg_replace('/(\\d)h$/i', '$1:00', $tester); |
| 261 | $median = static::parse('5555-06-15 12:30:30.555555')->modify($modifier); |
| 262 | $current = $this->avoidMutation(); |
| 263 | $other = $this->avoidMutation()->modify($modifier); |
| 264 | if ($current->eq($other)) { |
| 265 | return \true; |
| 266 | } |
| 267 | if (\preg_match('/\\d:\\d{1,2}:\\d{1,2}$/', $tester)) { |
| 268 | return $current->startOfSecond()->eq($other); |
| 269 | } |
| 270 | if (\preg_match('/\\d:\\d{1,2}$/', $tester)) { |
| 271 | return $current->startOfMinute()->eq($other); |
| 272 | } |
| 273 | if (\preg_match('/\\d(?:h|am|pm)$/', $tester)) { |
| 274 | return $current->startOfHour()->eq($other); |
| 275 | } |
| 276 | if (\preg_match('/^(?:january|february|march|april|may|june|july|august|september|october|november|december)(?:\\s+\\d+)?$/i', $tester)) { |
| 277 | return $current->startOfMonth()->eq($other->startOfMonth()); |
| 278 | } |
| 279 | $units = ['month' => [1, 'year'], 'day' => [1, 'month'], 'hour' => [0, 'day'], 'minute' => [0, 'hour'], 'second' => [0, 'minute'], 'microsecond' => [0, 'second']]; |
| 280 | foreach ($units as $unit => [$minimum, $startUnit]) { |
| 281 | if ($minimum === $median->{$unit}) { |
| 282 | $current = $current->startOf($startUnit); |
| 283 | break; |
| 284 | } |
| 285 | } |
| 286 | return $current->eq($other); |
| 287 | } |
| 288 | private static function matchFormatPattern(string $date, string $format, array $replacements) : bool |
| 289 | { |
| 290 | // Preg quote, but remove escaped backslashes since we'll deal with escaped characters in the format string. |
| 291 | $regex = \str_replace('\\\\', '\\', $format); |
| 292 | // Replace not-escaped letters |
| 293 | $regex = \preg_replace_callback('/(?<!\\\\)((?:\\\\{2})*)([' . \implode('', \array_keys($replacements)) . '])/', function ($match) use($replacements) { |
| 294 | return $match[1] . \strtr($match[2], $replacements); |
| 295 | }, $regex); |
| 296 | // Replace escaped letters by the letter itself |
| 297 | $regex = \preg_replace('/(?<!\\\\)((?:\\\\{2})*)\\\\(\\w)/', '$1$2', $regex); |
| 298 | // Escape not escaped slashes |
| 299 | $regex = \preg_replace('#(?<!\\\\)((?:\\\\{2})*)/#', '$1\\/', $regex); |
| 300 | return (bool) @\preg_match('/^' . $regex . '$/', $date); |
| 301 | } |
| 302 | public function isStartOfTime() : bool |
| 303 | { |
| 304 | return $this->startOfTime ?? \false; |
| 305 | } |
| 306 | public function isEndOfTime() : bool |
| 307 | { |
| 308 | return $this->endOfTime ?? \false; |
| 309 | } |
| 310 | private function discourageNull($value) : void |
| 311 | { |
| 312 | if ($value === null) { |
| 313 | @\trigger_error("Since 2.61.0, it's deprecated to compare a date to null, meaning of such comparison is ambiguous and will no longer be possible in 3.0.0, you should explicitly pass 'now' or make an other check to eliminate null values.", \E_USER_DEPRECATED); |
| 314 | } |
| 315 | } |
| 316 | private function discourageBoolean($value) : void |
| 317 | { |
| 318 | if (\is_bool($value)) { |
| 319 | @\trigger_error("Since 2.61.0, it's deprecated to compare a date to true or false, meaning of such comparison is ambiguous and will no longer be possible in 3.0.0, you should explicitly pass 'now' or make an other check to eliminate boolean values.", \E_USER_DEPRECATED); |
| 320 | } |
| 321 | } |
| 322 | } |
| 323 |