28229017084

Committed 26 Jun 2026 09:17AM UTC coverage: 69.907% (-0.07%) from 69.98%

Build # 28229017084

Build Type

push

github

Committed by

NamelessCoder

Commit Message

[REMOVAL] Drop support for PHP versions below 8.3

Coverage Stats

4811 of 6882 relevant lines covered (69.91%)

4.06 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

79.82

/Classes/ViewHelpers/Format/DateRangeViewHelper.php

<?php
namespace FluidTYPO3\Vhs\ViewHelpers\Format;

/*
 * This file is part of the FluidTYPO3/Vhs project under GPLv2 or later.
 *
 * For the full copyright and license information, please read the
 * LICENSE.md file that was distributed with this source code.
 */

use FluidTYPO3\Vhs\Core\ViewHelper\AbstractViewHelper;
use FluidTYPO3\Vhs\Utility\ErrorUtility;
use TYPO3Fluid\Fluid\Core\Rendering\RenderingContextInterface;

/**
 * ### Date range calculation/formatting ViewHelper
 *
 * Uses DateTime and DateInterval operations to calculate a range
 * between two DateTimes.
 *
 * #### Usages
 *
 * - As formatter, the ViewHelper can output a string value such as
 *   "2013-04-30 - 2013-05-30" where you can configure both the start
 *   and end date (or their common) formats as well as the "glue"
 *   which binds the two dates together.
 * - As interval calculator, the ViewHelper can be used with a special
 *   "intervalFormat" which is a string used in the constructor method
 *   for the DateInterval class - for example, "P3M" to add three months.
 *   Used this way, you can specify the start date (or rely on the
 *   default "now" DateTime) and specify the "intervalFormat" to add
 *   your desired duration to your starting date and use that as end
 *   date. Without the "return" attribute, this mode simply outputs
 *   the formatted dates with interval deciding the end date.
 * - When used with the "return" attribute you can specify which type
 *   of data to return:
 *   - if "return" is "DateTime", a single DateTime instance is returned
 *     (which is the end date). Use this with a start date to return the
 *     DateTime corresponding to "intervalFormat" into the future/past.
 *   - if "return" is a string such as "w", "d", "h" etc. the corresponding
 *     counter value (weeks, days, hours etc.) is returned.
 *   - if "return" is an array of counter IDs, for example ["w", "d"],
 *     the corresponding counters from the range are returned as an array.
 *
 * #### Note about LLL support and array consumers
 *
 * When used with the "return" attribute and when this attribute is an
 * array, the output becomes suitable for consumption by f:translate, v:l
 * or f:format.sprintf for example - as the "arguments" attribute:
 *
 * ```
 * <f:translate key="myDateDisplay"
 *     arguments="{v:format.dateRange(intervalFormat: 'P3W', return: {0: 'w', 1: 'd'})}"
 * />
 * ```
 *
 * Which if "myDateDisplay" is a string such as "Deadline: %d week(s) and
 * %d day(s)" would output a result such as "Deadline: 4 week(s) and 2 day(s)".
 *
 * > Tip: the values returned by this ViewHelper in both array and single
 * > value return modes, are also nicely consumable by the "math" suite
 * > of ViewHelpers, for example `v:math.division` would be able to divide
 * > number of days by two, three etc. to further divide the date range.
 */
class DateRangeViewHelper extends AbstractViewHelper
{
    /**
     * @var boolean
     */
    protected $escapingInterceptorEnabled = false;

    public function initializeArguments(): void
    {
        $this->registerArgument(
            'start',
            'mixed',
            'Start date which can be a DateTime object or a string consumable by DateTime constructor',
            false,
            'now'
        );
        $this->registerArgument(
            'end',
            'mixed',
            'End date which can be a DateTime object or a string consumable by DateTime constructor'
        );
        $this->registerArgument(
            'intervalFormat',
            'string',
            'Interval format consumable by DateInterval'
        );
        $this->registerArgument(
            'format',
            'string',
            'Date format to apply to both start and end date',
            false,
            'Y-m-d'
        );
        $this->registerArgument('startFormat', 'string', 'Date format to apply to start date');
        $this->registerArgument('endFormat', 'string', 'Date format to apply to end date');
        $this->registerArgument('glue', 'string', 'Glue string to concatenate dates with', false, '-');
        $this->registerArgument(
            'spaceGlue',
            'boolean',
            'If TRUE glue string is surrounded with whitespace',
            false,
            true
        );
        $this->registerArgument(
            'return',
            'mixed',
            'Return type; can be exactly "DateTime" to return a DateTime instance, a string like "w" or "d" to ' .
            'return weeks, days between the two dates - or an array of w, d, etc. strings to return the ' .
            'corresponding range count values as an array.'
        );
    }

    /**
     * @return mixed
     */
    public static function renderStatic(
        array $arguments,
        \Closure $renderChildrenClosure,
        RenderingContextInterface $renderingContext
    ) {
        /** @var string|null $start */
        $start = $renderChildrenClosure() ?? $arguments['start'] ?? 'now';
        if (empty($arguments['start'])) {
            $start = 'now';
        }
        $startDateTime = static::enforceDateTime($start);

        /** @var string|null $end */
        $end = $arguments['end'];
        $endDateTime = null;
        if (!empty($end)) {
            $endDateTime = static::enforceDateTime($end);
        }

        $intervalFormat = null;
        if (!empty($arguments['intervalFormat'])) {
            /** @var string $intervalFormat */
            $intervalFormat = $arguments['intervalFormat'];
        }

        if (null === $intervalFormat && null === $endDateTime) {
            ErrorUtility::throwViewHelperException('Either end or intervalFormat has to be provided.', 1369573110);
        }

        $interval = null;
        if ($intervalFormat !== null) {
            try {
                $interval = new \DateInterval($intervalFormat);
            } catch (\Exception | \Error $exception) {
                ErrorUtility::throwViewHelperException(
                    '"' . $intervalFormat . '" could not be parsed by \DateInterval constructor.',
                    1369573111
                );
            }
        } elseif ($endDateTime instanceof \DateTime) {
            $interval = $endDateTime->diff($startDateTime);
        }

        if (null !== $interval && null === $endDateTime) {
            $endDateTime = new \DateTime();
            $endDateTime->add($endDateTime->diff($startDateTime));
            $endDateTime->add($interval);
        }

        $output = null;
        $return = $arguments['return'];
        if (null === $return) {
            $spaceGlue = (bool) $arguments['spaceGlue'];
            /** @var string $glue */
            $glue = $arguments['glue'];
            /** @var string $startFormat */
            $startFormat = $arguments['format'] ?? '';
            /** @var string $endFormat */
            $endFormat = $arguments['format'] ?? '';
            if (!empty($arguments['startFormat'])) {
                /** @var string $startFormat */
                $startFormat = $arguments['startFormat'];
            }
            if (!empty($arguments['endFormat'])) {
                /** @var string $endFormat */
                $endFormat = $arguments['endFormat'];
            }
            $output = static::formatDate($startDateTime, $startFormat);
            $output .= true === $spaceGlue ? ' ' : '';
            $output .= $glue;
            $output .= true === $spaceGlue ? ' ' : '';
            $output .= static::formatDate($endDateTime ?? new \DateTime('now'), $endFormat);
        } elseif ('DateTime' === $return) {
            $output = $endDateTime;
        } elseif (is_string($return) && $interval instanceof \DateInterval) {
            if (false === strpos($return, '%')) {
                $return = '%' . $return;
            }
            $output = $interval->format($return);
        } elseif (is_array($return) && $interval instanceof \DateInterval) {
            $output = [];
            foreach ($return as $format) {
                if (false === strpos($format, '%')) {
                    $format = '%' . $format;
                }
                $output[] = $interval->format($format);
            }
        }
        return $output;
    }

    /**
     * @param \DateTime|scalar|null $date
     */
    protected static function enforceDateTime($date): \DateTime
    {
        if (!$date instanceof \DateTime) {
            try {
                $input = $date;
                if (is_integer($date)) {
                    $date = new \DateTime('@' . $date);
                } elseif (is_scalar($date)) {
                    $date = new \DateTime((string) $date);
                } else {
                    $date = new \DateTime('now');
                }
                $date->setTimezone(new \DateTimeZone(date_default_timezone_get()));
            } catch (\Exception | \Error $exception) {
                ErrorUtility::throwViewHelperException(
                    '"' . (string) $input . '" could not be parsed by \DateTime constructor.',
                    1369573112
                );
            }
        }
        /** @var \DateTime $date */
        return $date;
    }

    protected static function formatDate(\DateTime $date, string $format = 'Y-m-d'): string
    {
        if (false !== strpos($format, '%')) {
            return (string) strftime($format, (int) $date->format('U'));
        }
        return $date->format($format);
    }
}

1	<?php
2	namespace FluidTYPO3\Vhs\ViewHelpers\Format;
3
4	/*
5	* This file is part of the FluidTYPO3/Vhs project under GPLv2 or later.
6	*
7	* For the full copyright and license information, please read the
8	* LICENSE.md file that was distributed with this source code.
9	*/
10
11	use FluidTYPO3\Vhs\Core\ViewHelper\AbstractViewHelper;
12	use FluidTYPO3\Vhs\Utility\ErrorUtility;
13	use TYPO3Fluid\Fluid\Core\Rendering\RenderingContextInterface;
14
15	/**
16	* ### Date range calculation/formatting ViewHelper
17	*
18	* Uses DateTime and DateInterval operations to calculate a range
19	* between two DateTimes.
20	*
21	* #### Usages
22	*
23	* - As formatter, the ViewHelper can output a string value such as
24	* "2013-04-30 - 2013-05-30" where you can configure both the start
25	* and end date (or their common) formats as well as the "glue"
26	* which binds the two dates together.
27	* - As interval calculator, the ViewHelper can be used with a special
28	* "intervalFormat" which is a string used in the constructor method
29	* for the DateInterval class - for example, "P3M" to add three months.
30	* Used this way, you can specify the start date (or rely on the
31	* default "now" DateTime) and specify the "intervalFormat" to add
32	* your desired duration to your starting date and use that as end
33	* date. Without the "return" attribute, this mode simply outputs
34	* the formatted dates with interval deciding the end date.
35	* - When used with the "return" attribute you can specify which type
36	* of data to return:
37	* - if "return" is "DateTime", a single DateTime instance is returned
38	* (which is the end date). Use this with a start date to return the
39	* DateTime corresponding to "intervalFormat" into the future/past.
40	* - if "return" is a string such as "w", "d", "h" etc. the corresponding
41	* counter value (weeks, days, hours etc.) is returned.
42	* - if "return" is an array of counter IDs, for example ["w", "d"],
43	* the corresponding counters from the range are returned as an array.
44	*
45	* #### Note about LLL support and array consumers
46	*
47	* When used with the "return" attribute and when this attribute is an
48	* array, the output becomes suitable for consumption by f:translate, v:l
49	* or f:format.sprintf for example - as the "arguments" attribute:
50	*
51	* ```
52	* <f:translate key="myDateDisplay"
53	* arguments="{v:format.dateRange(intervalFormat: 'P3W', return: {0: 'w', 1: 'd'})}"
54	* />
55	* ```
56	*
57	* Which if "myDateDisplay" is a string such as "Deadline: %d week(s) and
58	* %d day(s)" would output a result such as "Deadline: 4 week(s) and 2 day(s)".
59	*
60	* > Tip: the values returned by this ViewHelper in both array and single
61	* > value return modes, are also nicely consumable by the "math" suite
62	* > of ViewHelpers, for example `v:math.division` would be able to divide
63	* > number of days by two, three etc. to further divide the date range.
64	*/
65	class DateRangeViewHelper extends AbstractViewHelper
66	{
67	/**
68	* @var boolean
69	*/
70	protected $escapingInterceptorEnabled = false;
71
72	public function initializeArguments(): void
73	{
74	$this->registerArgument(	2✔
75	'start',	2✔
76	'mixed',	2✔
77	'Start date which can be a DateTime object or a string consumable by DateTime constructor',	2✔
78	false,	2✔
79	'now'	2✔
80	);	2✔
81	$this->registerArgument(	2✔
82	'end',	2✔
83	'mixed',	2✔
84	'End date which can be a DateTime object or a string consumable by DateTime constructor'	2✔
85	);	2✔
86	$this->registerArgument(	2✔
87	'intervalFormat',	2✔
88	'string',	2✔
89	'Interval format consumable by DateInterval'	2✔
90	);	2✔
91	$this->registerArgument(	2✔
92	'format',	2✔
93	'string',	2✔
94	'Date format to apply to both start and end date',	2✔
95	false,	2✔
96	'Y-m-d'	2✔
97	);	2✔
98	$this->registerArgument('startFormat', 'string', 'Date format to apply to start date');	2✔
99	$this->registerArgument('endFormat', 'string', 'Date format to apply to end date');	2✔
100	$this->registerArgument('glue', 'string', 'Glue string to concatenate dates with', false, '-');	2✔
101	$this->registerArgument(	2✔
102	'spaceGlue',	2✔
103	'boolean',	2✔
104	'If TRUE glue string is surrounded with whitespace',	2✔
105	false,	2✔
106	true	2✔
107	);	2✔
108	$this->registerArgument(	2✔
109	'return',	2✔
110	'mixed',	2✔
111	'Return type; can be exactly "DateTime" to return a DateTime instance, a string like "w" or "d" to ' .	2✔
112	'return weeks, days between the two dates - or an array of w, d, etc. strings to return the ' .	2✔
113	'corresponding range count values as an array.'	2✔
114	);	2✔
115	}
116
117	/**
118	* @return mixed
119	*/
120	public static function renderStatic(
121	array $arguments,
122	\Closure $renderChildrenClosure,
123	RenderingContextInterface $renderingContext
124	) {
125	/** @var string\|null $start */
126	$start = $renderChildrenClosure() ?? $arguments['start'] ?? 'now';	6✔
127	if (empty($arguments['start'])) {	6✔
128	$start = 'now';	×
129	}
130	$startDateTime = static::enforceDateTime($start);	6✔
131
132	/** @var string\|null $end */
133	$end = $arguments['end'];	6✔
134	$endDateTime = null;	6✔
135	if (!empty($end)) {	6✔
136	$endDateTime = static::enforceDateTime($end);	4✔
137	}
138
139	$intervalFormat = null;	6✔
140	if (!empty($arguments['intervalFormat'])) {	6✔
141	/** @var string $intervalFormat */
142	$intervalFormat = $arguments['intervalFormat'];	2✔
143	}
144
145	if (null === $intervalFormat && null === $endDateTime) {	6✔
146	ErrorUtility::throwViewHelperException('Either end or intervalFormat has to be provided.', 1369573110);	×
147	}
148
149	$interval = null;	6✔
150	if ($intervalFormat !== null) {	6✔
151	try {
152	$interval = new \DateInterval($intervalFormat);	2✔
153	} catch (\Exception \| \Error $exception) {	×
154	ErrorUtility::throwViewHelperException(	×
155	'"' . $intervalFormat . '" could not be parsed by \DateInterval constructor.',	×
156	1369573111	×
157	);	×
158	}
159	} elseif ($endDateTime instanceof \DateTime) {	4✔
160	$interval = $endDateTime->diff($startDateTime);	4✔
161	}
162
163	if (null !== $interval && null === $endDateTime) {	6✔
164	$endDateTime = new \DateTime();	2✔
165	$endDateTime->add($endDateTime->diff($startDateTime));	2✔
166	$endDateTime->add($interval);	2✔
167	}
168
169	$output = null;	6✔
170	$return = $arguments['return'];	6✔
171	if (null === $return) {	6✔
172	$spaceGlue = (bool) $arguments['spaceGlue'];	4✔
173	/** @var string $glue */
174	$glue = $arguments['glue'];	4✔
175	/** @var string $startFormat */
176	$startFormat = $arguments['format'] ?? '';	4✔
177	/** @var string $endFormat */
178	$endFormat = $arguments['format'] ?? '';	4✔
179	if (!empty($arguments['startFormat'])) {	4✔
180	/** @var string $startFormat */
181	$startFormat = $arguments['startFormat'];	4✔
182	}
183	if (!empty($arguments['endFormat'])) {	4✔
184	/** @var string $endFormat */
185	$endFormat = $arguments['endFormat'];	4✔
186	}
187	$output = static::formatDate($startDateTime, $startFormat);	4✔
188	$output .= true === $spaceGlue ? ' ' : '';	4✔
189	$output .= $glue;	4✔
190	$output .= true === $spaceGlue ? ' ' : '';	4✔
191	$output .= static::formatDate($endDateTime ?? new \DateTime('now'), $endFormat);	4✔
192	} elseif ('DateTime' === $return) {	2✔
193	$output = $endDateTime;	×
194	} elseif (is_string($return) && $interval instanceof \DateInterval) {	2✔
195	if (false === strpos($return, '%')) {	2✔
196	$return = '%' . $return;	2✔
197	}
198	$output = $interval->format($return);	2✔
199	} elseif (is_array($return) && $interval instanceof \DateInterval) {	×
200	$output = [];	×
201	foreach ($return as $format) {	×
202	if (false === strpos($format, '%')) {	×
203	$format = '%' . $format;	×
204	}
205	$output[] = $interval->format($format);	×
206	}
207	}
208	return $output;	6✔
209	}
210
211	/**
212	* @param \DateTime\|scalar\|null $date
213	*/
214	protected static function enforceDateTime($date): \DateTime
215	{
216	if (!$date instanceof \DateTime) {	6✔
217	try {
218	$input = $date;	6✔
219	if (is_integer($date)) {	6✔
220	$date = new \DateTime('@' . $date);	6✔
221	} elseif (is_scalar($date)) {	×
222	$date = new \DateTime((string) $date);	×
223	} else {
224	$date = new \DateTime('now');	×
225	}
226	$date->setTimezone(new \DateTimeZone(date_default_timezone_get()));	6✔
227	} catch (\Exception \| \Error $exception) {	×
228	ErrorUtility::throwViewHelperException(	×
229	'"' . (string) $input . '" could not be parsed by \DateTime constructor.',	×
230	1369573112	×
231	);	×
232	}
233	}
234	/** @var \DateTime $date */
235	return $date;	6✔
236	}
237
238	protected static function formatDate(\DateTime $date, string $format = 'Y-m-d'): string
239	{
240	if (false !== strpos($format, '%')) {	4✔
241	return (string) strftime($format, (int) $date->format('U'));	×
242	}
243	return $date->format($format);	4✔
244	}
245	}

FluidTYPO3 / vhs / 28229017084

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous