diff options
Diffstat (limited to 'vendor/symfony/intl/Symfony/Component/Intl/DateFormatter/DateFormat/FullTransformer.php')
-rw-r--r-- | vendor/symfony/intl/Symfony/Component/Intl/DateFormatter/DateFormat/FullTransformer.php | 356 |
1 files changed, 356 insertions, 0 deletions
diff --git a/vendor/symfony/intl/Symfony/Component/Intl/DateFormatter/DateFormat/FullTransformer.php b/vendor/symfony/intl/Symfony/Component/Intl/DateFormatter/DateFormat/FullTransformer.php new file mode 100644 index 00000000..b89db363 --- /dev/null +++ b/vendor/symfony/intl/Symfony/Component/Intl/DateFormatter/DateFormat/FullTransformer.php | |||
@@ -0,0 +1,356 @@ | |||
1 | <?php | ||
2 | |||
3 | /* | ||
4 | * This file is part of the Symfony package. | ||
5 | * | ||
6 | * (c) Fabien Potencier <fabien@symfony.com> | ||
7 | * | ||
8 | * For the full copyright and license information, please view the LICENSE | ||
9 | * file that was distributed with this source code. | ||
10 | */ | ||
11 | |||
12 | namespace Symfony\Component\Intl\DateFormatter\DateFormat; | ||
13 | |||
14 | use Symfony\Component\Intl\Exception\NotImplementedException; | ||
15 | use Symfony\Component\Intl\Globals\IntlGlobals; | ||
16 | use Symfony\Component\Intl\DateFormatter\DateFormat\MonthTransformer; | ||
17 | |||
18 | /** | ||
19 | * Parser and formatter for date formats | ||
20 | * | ||
21 | * @author Igor Wiedler <igor@wiedler.ch> | ||
22 | */ | ||
23 | class FullTransformer | ||
24 | { | ||
25 | private $quoteMatch = "'(?:[^']+|'')*'"; | ||
26 | private $implementedChars = 'MLydQqhDEaHkKmsz'; | ||
27 | private $notImplementedChars = 'GYuwWFgecSAZvVW'; | ||
28 | private $regExp; | ||
29 | |||
30 | /** | ||
31 | * @var Transformer[] | ||
32 | */ | ||
33 | private $transformers; | ||
34 | |||
35 | private $pattern; | ||
36 | private $timezone; | ||
37 | |||
38 | /** | ||
39 | * Constructor | ||
40 | * | ||
41 | * @param string $pattern The pattern to be used to format and/or parse values | ||
42 | * @param string $timezone The timezone to perform the date/time calculations | ||
43 | */ | ||
44 | public function __construct($pattern, $timezone) | ||
45 | { | ||
46 | $this->pattern = $pattern; | ||
47 | $this->timezone = $timezone; | ||
48 | |||
49 | $implementedCharsMatch = $this->buildCharsMatch($this->implementedChars); | ||
50 | $notImplementedCharsMatch = $this->buildCharsMatch($this->notImplementedChars); | ||
51 | $this->regExp = "/($this->quoteMatch|$implementedCharsMatch|$notImplementedCharsMatch)/"; | ||
52 | |||
53 | $this->transformers = array( | ||
54 | 'M' => new MonthTransformer(), | ||
55 | 'L' => new MonthTransformer(), | ||
56 | 'y' => new YearTransformer(), | ||
57 | 'd' => new DayTransformer(), | ||
58 | 'q' => new QuarterTransformer(), | ||
59 | 'Q' => new QuarterTransformer(), | ||
60 | 'h' => new Hour1201Transformer(), | ||
61 | 'D' => new DayOfYearTransformer(), | ||
62 | 'E' => new DayOfWeekTransformer(), | ||
63 | 'a' => new AmPmTransformer(), | ||
64 | 'H' => new Hour2400Transformer(), | ||
65 | 'K' => new Hour1200Transformer(), | ||
66 | 'k' => new Hour2401Transformer(), | ||
67 | 'm' => new MinuteTransformer(), | ||
68 | 's' => new SecondTransformer(), | ||
69 | 'z' => new TimeZoneTransformer(), | ||
70 | ); | ||
71 | } | ||
72 | |||
73 | /** | ||
74 | * Return the array of Transformer objects | ||
75 | * | ||
76 | * @return Transformer[] Associative array of Transformer objects (format char => Transformer) | ||
77 | */ | ||
78 | public function getTransformers() | ||
79 | { | ||
80 | return $this->transformers; | ||
81 | } | ||
82 | |||
83 | /** | ||
84 | * Format a DateTime using ICU dateformat pattern | ||
85 | * | ||
86 | * @param \DateTime $dateTime A DateTime object to be used to generate the formatted value | ||
87 | * | ||
88 | * @return string The formatted value | ||
89 | */ | ||
90 | public function format(\DateTime $dateTime) | ||
91 | { | ||
92 | $that = $this; | ||
93 | |||
94 | $formatted = preg_replace_callback($this->regExp, function($matches) use ($that, $dateTime) { | ||
95 | return $that->formatReplace($matches[0], $dateTime); | ||
96 | }, $this->pattern); | ||
97 | |||
98 | return $formatted; | ||
99 | } | ||
100 | |||
101 | /** | ||
102 | * Return the formatted ICU value for the matched date characters | ||
103 | * | ||
104 | * @param string $dateChars The date characters to be replaced with a formatted ICU value | ||
105 | * @param DateTime $dateTime A DateTime object to be used to generate the formatted value | ||
106 | * | ||
107 | * @return string The formatted value | ||
108 | * | ||
109 | * @throws NotImplementedException When it encounters a not implemented date character | ||
110 | */ | ||
111 | public function formatReplace($dateChars, $dateTime) | ||
112 | { | ||
113 | $length = strlen($dateChars); | ||
114 | |||
115 | if ($this->isQuoteMatch($dateChars)) { | ||
116 | return $this->replaceQuoteMatch($dateChars); | ||
117 | } | ||
118 | |||
119 | if (isset($this->transformers[$dateChars[0]])) { | ||
120 | $transformer = $this->transformers[$dateChars[0]]; | ||
121 | |||
122 | return $transformer->format($dateTime, $length); | ||
123 | } | ||
124 | |||
125 | // handle unimplemented characters | ||
126 | if (false !== strpos($this->notImplementedChars, $dateChars[0])) { | ||
127 | throw new NotImplementedException(sprintf("Unimplemented date character '%s' in format '%s'", $dateChars[0], $this->pattern)); | ||
128 | } | ||
129 | } | ||
130 | |||
131 | /** | ||
132 | * Parse a pattern based string to a timestamp value | ||
133 | * | ||
134 | * @param \DateTime $dateTime A configured DateTime object to use to perform the date calculation | ||
135 | * @param string $value String to convert to a time value | ||
136 | * | ||
137 | * @return int The corresponding Unix timestamp | ||
138 | * | ||
139 | * @throws \InvalidArgumentException When the value can not be matched with pattern | ||
140 | */ | ||
141 | public function parse(\DateTime $dateTime, $value) | ||
142 | { | ||
143 | $reverseMatchingRegExp = $this->getReverseMatchingRegExp($this->pattern); | ||
144 | $reverseMatchingRegExp = '/^'.$reverseMatchingRegExp.'$/'; | ||
145 | |||
146 | $options = array(); | ||
147 | |||
148 | if (preg_match($reverseMatchingRegExp, $value, $matches)) { | ||
149 | $matches = $this->normalizeArray($matches); | ||
150 | |||
151 | foreach ($this->transformers as $char => $transformer) { | ||
152 | if (isset($matches[$char])) { | ||
153 | $length = strlen($matches[$char]['pattern']); | ||
154 | $options = array_merge($options, $transformer->extractDateOptions($matches[$char]['value'], $length)); | ||
155 | } | ||
156 | } | ||
157 | |||
158 | // reset error code and message | ||
159 | IntlGlobals::setError(IntlGlobals::U_ZERO_ERROR); | ||
160 | |||
161 | return $this->calculateUnixTimestamp($dateTime, $options); | ||
162 | } | ||
163 | |||
164 | // behave like the intl extension | ||
165 | IntlGlobals::setError(IntlGlobals::U_PARSE_ERROR, 'Date parsing failed'); | ||
166 | |||
167 | return false; | ||
168 | } | ||
169 | |||
170 | /** | ||
171 | * Retrieve a regular expression to match with a formatted value. | ||
172 | * | ||
173 | * @param string $pattern The pattern to create the reverse matching regular expression | ||
174 | * | ||
175 | * @return string The reverse matching regular expression with named captures being formed by the | ||
176 | * transformer index in the $transformer array | ||
177 | */ | ||
178 | public function getReverseMatchingRegExp($pattern) | ||
179 | { | ||
180 | $that = $this; | ||
181 | |||
182 | $escapedPattern = preg_quote($pattern, '/'); | ||
183 | |||
184 | // ICU 4.8 recognizes slash ("/") in a value to be parsed as a dash ("-") and vice-versa | ||
185 | // when parsing a date/time value | ||
186 | $escapedPattern = preg_replace('/\\\[\-|\/]/', '[\/\-]', $escapedPattern); | ||
187 | |||
188 | $reverseMatchingRegExp = preg_replace_callback($this->regExp, function($matches) use ($that) { | ||
189 | $length = strlen($matches[0]); | ||
190 | $transformerIndex = $matches[0][0]; | ||
191 | |||
192 | $dateChars = $matches[0]; | ||
193 | if ($that->isQuoteMatch($dateChars)) { | ||
194 | return $that->replaceQuoteMatch($dateChars); | ||
195 | } | ||
196 | |||
197 | $transformers = $that->getTransformers(); | ||
198 | if (isset($transformers[$transformerIndex])) { | ||
199 | $transformer = $transformers[$transformerIndex]; | ||
200 | $captureName = str_repeat($transformerIndex, $length); | ||
201 | |||
202 | return "(?P<$captureName>".$transformer->getReverseMatchingRegExp($length).')'; | ||
203 | } | ||
204 | }, $escapedPattern); | ||
205 | |||
206 | return $reverseMatchingRegExp; | ||
207 | } | ||
208 | |||
209 | /** | ||
210 | * Check if the first char of a string is a single quote | ||
211 | * | ||
212 | * @param string $quoteMatch The string to check | ||
213 | * | ||
214 | * @return Boolean true if matches, false otherwise | ||
215 | */ | ||
216 | public function isQuoteMatch($quoteMatch) | ||
217 | { | ||
218 | return ("'" === $quoteMatch[0]); | ||
219 | } | ||
220 | |||
221 | /** | ||
222 | * Replaces single quotes at the start or end of a string with two single quotes | ||
223 | * | ||
224 | * @param string $quoteMatch The string to replace the quotes | ||
225 | * | ||
226 | * @return string A string with the single quotes replaced | ||
227 | */ | ||
228 | public function replaceQuoteMatch($quoteMatch) | ||
229 | { | ||
230 | if (preg_match("/^'+$/", $quoteMatch)) { | ||
231 | return str_replace("''", "'", $quoteMatch); | ||
232 | } | ||
233 | |||
234 | return str_replace("''", "'", substr($quoteMatch, 1, -1)); | ||
235 | } | ||
236 | |||
237 | /** | ||
238 | * Builds a chars match regular expression | ||
239 | * | ||
240 | * @param string $specialChars A string of chars to build the regular expression | ||
241 | * | ||
242 | * @return string The chars match regular expression | ||
243 | */ | ||
244 | protected function buildCharsMatch($specialChars) | ||
245 | { | ||
246 | $specialCharsArray = str_split($specialChars); | ||
247 | |||
248 | $specialCharsMatch = implode('|', array_map(function($char) { | ||
249 | return $char.'+'; | ||
250 | }, $specialCharsArray)); | ||
251 | |||
252 | return $specialCharsMatch; | ||
253 | } | ||
254 | |||
255 | /** | ||
256 | * Normalize a preg_replace match array, removing the numeric keys and returning an associative array | ||
257 | * with the value and pattern values for the matched Transformer | ||
258 | * | ||
259 | * @param array $data | ||
260 | * | ||
261 | * @return array | ||
262 | */ | ||
263 | protected function normalizeArray(array $data) | ||
264 | { | ||
265 | $ret = array(); | ||
266 | |||
267 | foreach ($data as $key => $value) { | ||
268 | if (!is_string($key)) { | ||
269 | continue; | ||
270 | } | ||
271 | |||
272 | $ret[$key[0]] = array( | ||
273 | 'value' => $value, | ||
274 | 'pattern' => $key | ||
275 | ); | ||
276 | } | ||
277 | |||
278 | return $ret; | ||
279 | } | ||
280 | |||
281 | /** | ||
282 | * Calculates the Unix timestamp based on the matched values by the reverse matching regular | ||
283 | * expression of parse() | ||
284 | * | ||
285 | * @param \DateTime $dateTime The DateTime object to be used to calculate the timestamp | ||
286 | * @param array $options An array with the matched values to be used to calculate the timestamp | ||
287 | * | ||
288 | * @return Boolean|int The calculated timestamp or false if matched date is invalid | ||
289 | */ | ||
290 | protected function calculateUnixTimestamp(\DateTime $dateTime, array $options) | ||
291 | { | ||
292 | $options = $this->getDefaultValueForOptions($options); | ||
293 | |||
294 | $year = $options['year']; | ||
295 | $month = $options['month']; | ||
296 | $day = $options['day']; | ||
297 | $hour = $options['hour']; | ||
298 | $hourInstance = $options['hourInstance']; | ||
299 | $minute = $options['minute']; | ||
300 | $second = $options['second']; | ||
301 | $marker = $options['marker']; | ||
302 | $timezone = $options['timezone']; | ||
303 | |||
304 | // If month is false, return immediately (intl behavior) | ||
305 | if (false === $month) { | ||
306 | IntlGlobals::setError(IntlGlobals::U_PARSE_ERROR, 'Date parsing failed'); | ||
307 | |||
308 | return false; | ||
309 | } | ||
310 | |||
311 | // Normalize hour | ||
312 | if ($hourInstance instanceof HourTransformer) { | ||
313 | $hour = $hourInstance->normalizeHour($hour, $marker); | ||
314 | } | ||
315 | |||
316 | // Set the timezone if different from the default one | ||
317 | if (null !== $timezone && $timezone !== $this->timezone) { | ||
318 | $dateTime->setTimezone(new \DateTimeZone($timezone)); | ||
319 | } | ||
320 | |||
321 | // Normalize yy year | ||
322 | preg_match_all($this->regExp, $this->pattern, $matches); | ||
323 | if (in_array('yy', $matches[0])) { | ||
324 | $dateTime->setTimestamp(time()); | ||
325 | $year = $year > $dateTime->format('y') + 20 ? 1900 + $year : 2000 + $year; | ||
326 | } | ||
327 | |||
328 | $dateTime->setDate($year, $month, $day); | ||
329 | $dateTime->setTime($hour, $minute, $second); | ||
330 | |||
331 | return $dateTime->getTimestamp(); | ||
332 | } | ||
333 | |||
334 | /** | ||
335 | * Add sensible default values for missing items in the extracted date/time options array. The values | ||
336 | * are base in the beginning of the Unix era | ||
337 | * | ||
338 | * @param array $options | ||
339 | * | ||
340 | * @return array | ||
341 | */ | ||
342 | private function getDefaultValueForOptions(array $options) | ||
343 | { | ||
344 | return array( | ||
345 | 'year' => isset($options['year']) ? $options['year'] : 1970, | ||
346 | 'month' => isset($options['month']) ? $options['month'] : 1, | ||
347 | 'day' => isset($options['day']) ? $options['day'] : 1, | ||
348 | 'hour' => isset($options['hour']) ? $options['hour'] : 0, | ||
349 | 'hourInstance' => isset($options['hourInstance']) ? $options['hourInstance'] : null, | ||
350 | 'minute' => isset($options['minute']) ? $options['minute'] : 0, | ||
351 | 'second' => isset($options['second']) ? $options['second'] : 0, | ||
352 | 'marker' => isset($options['marker']) ? $options['marker'] : null, | ||
353 | 'timezone' => isset($options['timezone']) ? $options['timezone'] : null, | ||
354 | ); | ||
355 | } | ||
356 | } | ||