diff --git a/core/includes/common.inc b/core/includes/common.inc
index 0f252ca..c1bb0ff 100644
--- a/core/includes/common.inc
+++ b/core/includes/common.inc
@@ -1896,21 +1896,42 @@ function format_interval($interval, $granularity = 2, $langcode = NULL) {
* @param $langcode
* (optional) Language code to translate to. Defaults to the language used to
* display the page.
+ * @params array $settings
+ * - string $format_string_type
+ * Which pattern is used by the format string. When using the
+ * Intl formatter, the format string must use the Intl pattern,
+ * which is different from the pattern used by the DateTime
+ * format function. Defaults to DateTimePlus::PHP.
+ * - string $country
+ * The two letter country code to construct the locale string by the
+ * intlDateFormatter class. Used to control the result of the
+ * format() method if that class is available. Defaults to NULL.
+ * - string $calendar
+ * A calendar to use for the date, Defaults to the site
+ * default calendar.
+ * - int $date_type
+ * The datetype to use in the formatter, defaults to
+ * IntlDateFormatter::FULL.
+ * - int $time_type
+ * The datetype to use in the formatter, defaults to
+ * IntlDateFormatter::FULL.
+ * - boolean $lenient
+ * Whether or not to use lenient processing in the intl
+ * formatter. Defaults to FALSE;
*
* @return
* A translated date string in the requested format.
*/
-function format_date($timestamp, $type = 'medium', $format = '', $timezone = NULL, $langcode = NULL) {
+function format_date($timestamp, $type = 'medium', $format = '', $timezone = NULL, $langcode = NULL, $settings = array()) {
+
// Use the advanced drupal_static() pattern, since this is called very often.
static $drupal_static_fast;
if (!isset($drupal_static_fast)) {
$drupal_static_fast['timezones'] = &drupal_static(__FUNCTION__);
}
$timezones = &$drupal_static_fast['timezones'];
+ $timezone = !empty($timezone) ? $timezone : date_default_timezone_get();
- if (!isset($timezone)) {
- $timezone = date_default_timezone_get();
- }
// Store DateTimeZone objects in an array rather than repeatedly
// constructing identical objects over the life of a request.
if (!isset($timezones[$timezone])) {
@@ -1921,45 +1942,72 @@ function format_date($timestamp, $type = 'medium', $format = '', $timezone = NUL
$langcode = language(LANGUAGE_TYPE_INTERFACE)->langcode;
}
+ if (empty($settings['calendar'])) {
+ $settings['calendar'] = config('system.calendar')->get('calendar');
+ }
+
+ // Adjust $settings to include all the values the Dateobject will need.
+ $settings += array(
+ 'timezone' => $timezone,
+ 'langcode' => $langcode,
+ );
+
+ // Format strings and settings differ for the IntlDateFormatter
+ // and the normal PHP format() method.
+ $intl_format = '';
+ $intl_type = '';
+
switch ($type) {
case 'short':
$format = variable_get('date_format_short', 'm/d/Y - H:i');
+ $intl_format = '';
+ $intl_type = 'SHORT';
break;
case 'long':
$format = variable_get('date_format_long', 'l, F j, Y - H:i');
+ $intl_format = '';
+ $intl_type = 'LONG';
break;
case 'html_datetime':
$format = variable_get('date_format_html_datetime', 'Y-m-d\TH:i:sO');
+ $intl_format = "yyyy-MM-dd'Tkk:mm:ssZZ";
break;
case 'html_date':
$format = variable_get('date_format_html_date', 'Y-m-d');
+ $intl_format = "yyyy-MM-dd";
break;
case 'html_time':
$format = variable_get('date_format_html_time', 'H:i:s');
+ $intl_format = "H:mm:ss";
break;
case 'html_yearless_date':
$format = variable_get('date_format_html_yearless_date', 'm-d');
+ $intl_format = "MM-d";
break;
case 'html_week':
$format = variable_get('date_format_html_week', 'Y-\WW');
+ $intl_format = "Y-'WW";
break;
case 'html_month':
$format = variable_get('date_format_html_month', 'Y-m');
+ $intl_format = "Y-MM";
break;
case 'html_year':
$format = variable_get('date_format_html_year', 'Y');
+ $intl_format = "Y";
break;
case 'custom':
// No change to format.
+ $intl_format = $format;
break;
case 'medium':
@@ -1967,34 +2015,44 @@ function format_date($timestamp, $type = 'medium', $format = '', $timezone = NUL
// Retrieve the format of the custom $type passed.
if ($type != 'medium') {
$format = variable_get('date_format_' . $type, '');
+ $intl_format = $format;
}
// Fall back to 'medium'.
if ($format === '') {
$format = variable_get('date_format_medium', 'D, m/d/Y - H:i');
+ $intl_format = '';
+ $intl_type = 'MEDIUM';
}
break;
}
- // Create a DateTime object from the timestamp.
- $date_time = date_create('@' . $timestamp);
- // Set the time zone for the DateTime object.
- date_timezone_set($date_time, $timezones[$timezone]);
-
- // Encode markers that should be translated. 'A' becomes '\xEF\AA\xFF'.
- // xEF and xFF are invalid UTF-8 sequences, and we assume they are not in the
- // input string.
- // Paired backslashes are isolated to prevent errors in read-ahead evaluation.
- // The read-ahead expression ensures that A matches, but not \A.
- $format = preg_replace(array('/\\\\\\\\/', '/(?format().
+ return $date->format($format, $settings);
}
/**
@@ -2015,6 +2073,65 @@ function date_iso8601($date) {
}
/**
+ * Handle a string like -3:+3 or 2001:2010 to describe a dynamic range
+ * of minimum and maximum years to use in a date selector.
+ *
+ * Center the range around the current year, if any, but expand it far
+ * enough so it will pick up the year value in the field in case
+ * the value in the field is outside the initial range.
+ *
+ * @param string $string
+ * A min and max year string like '-3:+1' or '2000:2010' or '2000:+3'.
+ * @param object $date
+ * (optional) A date object to test as a default value. Defaults to NULL.
+ *
+ * @return array
+ * A numerically indexed array, containing the minimum and maximum
+ * year described by this pattern.
+ */
+function date_range_years($string, $date = NULL) {
+
+ // We use the full path to the date class to avoid the need to
+ // include this file when not being used.
+ $this_year = date_format(new \Drupal\Core\Datetime\DrupalDateTime(), 'Y');
+ list($min_year, $max_year) = explode(':', $string);
+
+ // Valid patterns would be -5:+5, 0:+1, 2008:2010.
+ $plus_pattern = '@[\+|\-][0-9]{1,4}@';
+ $year_pattern = '@^[0-9]{4}@';
+ if (!preg_match($year_pattern, $min_year, $matches)) {
+ if (preg_match($plus_pattern, $min_year, $matches)) {
+ $min_year = $this_year + $matches[0];
+ }
+ else {
+ $min_year = $this_year;
+ }
+ }
+ if (!preg_match($year_pattern, $max_year, $matches)) {
+ if (preg_match($plus_pattern, $max_year, $matches)) {
+ $max_year = $this_year + $matches[0];
+ }
+ else {
+ $max_year = $this_year;
+ }
+ }
+ // We expect the $min year to be less than the $max year.
+ // Some custom values for -99:+99 might not obey that.
+ if ($min_year > $max_year) {
+ $temp = $max_year;
+ $max_year = $min_year;
+ $min_year = $temp;
+ }
+ // If there is a current value, stretch the range to include it.
+ $value_year = $date instanceOf \Drupal\Core\Datetime\DrupalDateTime ? $date->format('Y') : '';
+ if (!empty($value_year)) {
+ $min_year = min($value_year, $min_year);
+ $max_year = max($value_year, $max_year);
+ }
+ return array($min_year, $max_year);
+}
+
+/**
* Translates a formatted date string.
*
* Callback for preg_replace_callback() within format_date().
@@ -4974,7 +5091,8 @@ function drupal_page_set_cache($body) {
$cache->data['headers'][$header_names[$name_lower]] = $value;
if ($name_lower == 'expires') {
// Use the actual timestamp from an Expires header if available.
- $cache->expire = strtotime($value);
+ $date = new DrupalDateTime($value);
+ $cache->expire = $date->getTimestamp();
}
}
diff --git a/core/includes/form.inc b/core/includes/form.inc
index 49ace44..6759bed 100644
--- a/core/includes/form.inc
+++ b/core/includes/form.inc
@@ -2922,7 +2922,9 @@ function password_confirm_validate($element, &$element_state) {
}
/**
- * Returns HTML for a date selection form element.
+ * Returns HTML for an individual date html5 form element.
+ * Supports 'date', 'datetime', 'datetime-local', and 'time',
+ * falls back to a plain textfield.
*
* @param $variables
* An associative array containing:
@@ -2934,6 +2936,29 @@ function password_confirm_validate($element, &$element_state) {
*/
function theme_date($variables) {
$element = $variables['element'];
+ if (empty($element['attribute']['type'])) {
+ $element['attribute']['type'] = 'date';
+ }
+ element_set_attributes($element, array('id', 'name', 'type', 'min', 'max', 'step', 'value', 'size'));
+ _form_set_class($element, array('form-text', 'form-' . $element['attribute']['type']));
+
+ return '';
+}
+
+/**
+ * Returns HTML for a HTML5-compatible combination date/time form element.
+ *
+ * @param $variables
+ * An associative array containing:
+ * - element: An associative array containing the properties of the element.
+ * Properties used: #title, #value, #options, #description, #required,
+ * #attributes.
+ *
+ * @ingroup themeable
+ */
+function theme_form_datetime($variables) {
+
+ $element = $variables['element'];
$attributes = array();
if (isset($element['#id'])) {
@@ -2948,91 +2973,436 @@ function theme_date($variables) {
}
/**
- * Expands a date element into year, month, and day select elements.
+ * Expands a date element into 'date' and/or 'time' elements. All form
+ * elements are designed to have sane defaults so any or all can be
+ * omitted. Both the 'date' and 'time' components are configurable
+ * so they can be output as HTML5 datetime elements or not, as
+ * desired.
+ *
+ * Examples of possible configurations include:
+ * HTML5:
+ * Date: 'date'; Time: 'time'
+ * Date: 'datetime'; Time: 'none'
+ * Date: 'datetime-local'; Time: 'none'
+ * Date: 'none'; Time: 'time'
+ * Non-HTML5:
+ * Date: 'text'; Time: 'text'
+ * Date: 'text'; Time: 'none'
+ *
+ * Required settings:
+ * #default_value
+ * The default value should be expressed in ISO datetime format,
+ * using the format used by DrupalDateTime's __toString() function.
+ * Provide a date with or without a timzone name appended to it,
+ * adjusted to the proper local timezone, i.e. '2012-01-31 10:30:00
+ * America/Chicago'. NOTE - Converting a date stored in the database
+ * from UTC to the local zone and converting it back to UTC before
+ * storing it is not handled here. This element simply explodes and
+ * displays the string date that is provided to it and converts the
+ * user input back into a string value on submission.
+ * Optional properties include:
+ * #date_date_format
+ * A date format string that describes the format that should
+ * be displayed to the end user for the date. When using HTML5
+ * elements the format MUST use the appropriate HTML5 format
+ * for that element, no other format will work. See the
+ * format_date() function for a list of the possible formats.
+ * Defaults to variable_get('date_format_html_date', 'Y-m-d').
+ * #date_date_element
+ * The HTML5 date part to use for the date element. Options are:
+ * - datetime
+ * - datetime-local
+ * - date
+ * - text (no HTML5 element)
+ * - none (do not display)
+ * #date_date_callbacks
+ * Array of optional callbacks for the date element. Can be used
+ * to add a jQuery datepicker, for instance. Core provides the
+ * 'datetime_jquery_datepicker' callback as one possible choice
+ * for this property.
+ * #date_time_format
+ * A date format string that describes the format that should
+ * be displayed to the end user for the time. When using HTML5
+ * elements the format MUST use the appropriate HTML5 format
+ * for that element, no other format will work. See the
+ * format_date() function for a list of the possible formats.
+ * Defaults to variable_get('date_format_html_time', 'H:i:s').
+ * #date_time_element
+ * The HTML5 date part to use for the time element. Options are:
+ * - time
+ * - text (no HTML5 element)
+ * - none (do not display)
+ * #date_time_callbacks
+ * An array of optional callbacks for the time element. Can be used
+ * to add a jQuery timepicker or an 'All day' checkbox.
+ * See the core Timestamp field as an example of that.
+ * #date_year_range
+ * A description of the range of years to allow, like '1900:2050',
+ * '-3:+3' or '2000:+3', where the first value describes the earliest
+ * year and the second the latest year in the range. A year
+ * in either position means that specific year. A +/- value
+ * describes a dynamic value that is that many years earlier or
+ * later than the current year at the time the form is displayed.
+ * Used in jQueryUI datepicker and HTML5 settings.
+ * Defaults to '1900:2050'.
+ * #date_increment
+ * The increment to use for minutes and seconds, i.e. '15' would show
+ * only :00, :15, :30 and :45. Used for HTML5 step values and
+ * jQueryUI datepicker and HTML5 settings.
+ * Defaults to 1 to show every minute and second.
+ * #date_timezone
+ * The local timezone to use when creating dates with the value
+ * in this element. Generally this should be left empty and
+ * it will be set correctly for the user using the form.
+ * Defaults to drupal_get_user_timezone().
+ * #date_calendar
+ * The calendar system to use for displaying possible date parts.
+ * Depends on the calendar plugins available on this site.
+ * Defaults to 'gregorian'.
+ *
+ * Example:
+ * $form = array(
+ * '#type' => 'datetime',
+ * '#default_value' => '2000-01-01 10:30:00',
+ * '#date_date_callbacks' => array('datetime_jquery_datepicker'),
+ * '#date_date_format' => 'd.m.Y',
+ * '#date_date_element' => 'date',
+ * '#date_time_format' => 'H:i',
+ * '#date_time_element' => 'time',
+ * '#date_year_range' => '2010:2020',
+ * '#date_increment' => 15,
+ * );
*/
-function form_process_date($element) {
- // Default to current date
- if (empty($element['#value'])) {
- $element['#value'] = array(
- 'day' => format_date(REQUEST_TIME, 'custom', 'j'),
- 'month' => format_date(REQUEST_TIME, 'custom', 'n'),
- 'year' => format_date(REQUEST_TIME, 'custom', 'Y'),
- );
+function form_process_datetime($element, &$form_state) {
+
+ // If no specific timezone is required, use the Drupal default.
+ if (empty($element['#date_timezone'])) {
+ $element['#date_timezone'] = drupal_get_user_timezone();
+ }
+
+ // Identify the format and value.
+ $expected_format = array();
+ $value = array();
+ if ($element['#date_date_element'] != 'none') {
+ $date_format = datetime_get_format($element['#date_date_element'], $element['#date_date_format']);
+ $expected_format[] = $date_format;
+ $value[] = $element['#value']['date'];
}
+ if ($element['#date_time_element'] != 'none') {
+ $time_format = datetime_get_format($element['#date_time_element'], $element['#date_time_format']);
+ $expected_format[] = $time_format;
+ $value[] = $element['#value']['time'];
+ }
+
+ $value = trim(implode(' ', $value));
+ $expected_format = trim(implode(' ', $expected_format));
+ $element['#date_expected_format'] = $expected_format;
+
+ // Don't create a date for an empty value.
+ $date = NULL;
+ if (!empty($value)) {
+ $date = new \Drupal\Core\Datetime\DrupalDateTime($value, $element['#date_timezone'], $expected_format);
+ }
+
+ // Create an example date for format messages to illustrate how to
+ // format the date and time.
+ $now = new \Drupal\Core\Datetime\DrupalDateTime();
$element['#tree'] = TRUE;
- // Determine the order of day, month, year in the site's chosen date format.
- $format = variable_get('date_format_short', 'm/d/Y - H:i');
- $sort = array();
- $sort['day'] = max(strpos($format, 'd'), strpos($format, 'j'));
- $sort['month'] = max(strpos($format, 'm'), strpos($format, 'M'));
- $sort['year'] = strpos($format, 'Y');
- asort($sort);
- $order = array_keys($sort);
-
- // Output multi-selector for date.
- foreach ($order as $type) {
- switch ($type) {
- case 'day':
- $options = drupal_map_assoc(range(1, 31));
- $title = t('Day');
- break;
-
- case 'month':
- $options = drupal_map_assoc(range(1, 12), 'map_month');
- $title = t('Month');
- break;
-
- case 'year':
- $options = drupal_map_assoc(range(1900, 2050));
- $title = t('Year');
- break;
- }
-
- $element[$type] = array(
- '#type' => 'select',
- '#title' => $title,
+ if ($element['#date_date_element'] != 'none') {
+
+ $date_value = $date instanceOf \Drupal\Core\Datetime\DrupalDateTime && !$date->hasErrors() ? $date->format($date_format) : $element['#value']['date'];
+
+ // Creating format examples on every individual date item is messy,
+ // and placeholders are invalid for HTML5 date and datetime, so an
+ // example format is appended to the title to appear in tooltips.
+ $extra_attributes = array(
+ 'title' => t('Date (i.e. @format)', array('@format' => $now->format($date_format))),
+ 'type' => $element['#date_date_element'],
+ );
+
+ // Add the HTML5 date attributes.
+ if ($date instanceOf \Drupal\Core\Datetime\DrupalDateTime && !$date->hasErrors()) {
+ $html5_min = clone($date);
+ $range = date_range_years($element['#date_year_range'], $date);
+ $html5_min->setDate($range[0], 1, 1)->setTime(0, 0, 0);
+ $html5_max = clone($date);
+ $html5_max->setDate($range[1], 12, 31)->setTime(23, 59, 59);
+
+ $extra_attributes += array(
+ 'min' => $html5_min->format($date_format),
+ 'max' => $html5_max->format($date_format),
+ );
+ }
+
+ $element['date'] = array(
+ '#type' => 'date',
+ '#title' => t('Date'),
+ '#title_display' => 'invisible',
+ '#value' => $date_value,
+ '#attributes' => $element['#attributes'] + $extra_attributes,
+ '#required' => $element['#required'],
+ '#size' => 12,
+ );
+
+ // Allow custom callbacks to alter the element.
+ if (!empty($element['#date_date_callbacks'])) {
+ foreach ($element['#date_date_callbacks'] as $callback) {
+ if (function_exists($callback)) {
+ $callback($element, $form_state, $date);
+ }
+ }
+ }
+ }
+
+ if ($element['#date_time_element'] != 'none') {
+
+ $time_value = $date instanceOf \Drupal\Core\Datetime\DrupalDateTime && !$date->hasErrors() ? $date->format($time_format) : $element['#value']['time'];
+
+ // Add the HTML5 attributes.
+ $extra_attributes = array(
+ 'title' =>t('Time (i.e. @format)', array('@format' => $now->format($time_format))),
+ 'type' => $element['#date_time_element'],
+ 'step' => ($element['#date_increment'] * 3600),
+ );
+ $element['time'] = array(
+ '#type' => 'date',
+ '#title' => t('Time'),
'#title_display' => 'invisible',
- '#value' => $element['#value'][$type],
- '#attributes' => $element['#attributes'],
- '#options' => $options,
+ '#value' => $time_value,
+ '#attributes' => $element['#attributes'] + $extra_attributes,
+ '#required' => $element['#required'],
+ '#size' => 12,
);
+
+ // Allow custom callbacks to alter the element.
+ if (!empty($element['#date_time_callbacks'])) {
+ foreach ($element['#date_time_callbacks'] as $callback) {
+ if (function_exists($callback)) {
+ $callback($element, $form_state, $date);
+ }
+ }
+ }
}
return $element;
}
/**
- * Validates the date type to prevent invalid dates (e.g., February 30, 2006).
+ * Element value callback for datetime element.
+ */
+function datetime_value_callback($element, $input = FALSE, &$form_state = array()) {
+ if ($input !== FALSE) {
+ return $input;
+ }
+
+ $return = array();
+ $date = NULL;
+ if (!empty($element['#default_value'])) {
+ $date = new \Drupal\Core\Datetime\DrupalDateTime($element['#default_value'], $element['#date_timezone']);
+ }
+ if ($element['#date_date_element'] != 'none') {
+ $format = datetime_get_format($element['#date_date_element'], $element['#date_date_format']);
+ $return['date'] = $date instanceOf \Drupal\Core\Datetime\DrupalDateTime && !$date->hasErrors() ? $date->format($format) : '';
+ }
+ if ($element['#date_time_element'] != 'none') {
+ $format = datetime_get_format($element['#date_time_element'], $element['#date_time_format']);
+ $return['time'] = $date instanceOf \Drupal\Core\Datetime\DrupalDateTime && !$date->hasErrors() ? $date->format($format) : '';
+ }
+ return $return;
+}
+
+/**
+ * Helper function to turn the user input for date html back into
+ * a qualified date object.
*/
-function date_validate($element) {
- if (!checkdate($element['#value']['month'], $element['#value']['day'], $element['#value']['year'])) {
- form_error($element, t('The specified date is invalid.'));
+function datetime_get_input_date($element, $input) {
+
+ // Was anything entered? If not, we have no date.
+ if (empty($input) || !is_array($input)) {
+ return NULL;
}
+ $test_values = array_values(array_filter($input));
+ if (empty($test_values)) {
+ return NULL;
+ }
+
+ $value = trim((!empty($input['date']) ? $input['date'] : '') . ' ' . (!empty($input['time']) ? $input['time'] : ''));
+ $date = new \Drupal\Core\Datetime\DrupalDateTime(trim($value), $element['#date_timezone'], $element['#date_expected_format']);
+ return $date;
}
/**
- * Renders a month name for display.
+ * Validates the date and sets errors.
*
- * Callback for drupal_map_assoc() within form_process_date().
+ * If the date is valid, the date is set in the form as a string
+ * using the format designated in __toString().
*/
-function map_month($month) {
- $months = &drupal_static(__FUNCTION__, array(
- 1 => 'Jan',
- 2 => 'Feb',
- 3 => 'Mar',
- 4 => 'Apr',
- 5 => 'May',
- 6 => 'Jun',
- 7 => 'Jul',
- 8 => 'Aug',
- 9 => 'Sep',
- 10 => 'Oct',
- 11 => 'Nov',
- 12 => 'Dec',
- ));
- return t($months[$month]);
+function datetime_validate($element, &$form_state) {
+ $input_exists = FALSE;
+ $input = drupal_array_get_nested_value($form_state['values'], $element['#parents'], $input_exists);
+ if ($input_exists) {
+ // If there's empty input and the field is not required, set it to empty.
+ if (empty($input['date']) && empty($input['time']) && !$element['#required']) {
+ form_set_value($element, NULL, $form_state);
+ }
+ // If there's empty input and the field is required, set an error.
+ elseif (empty($input['date']) && empty($input['time']) && $element['#required']) {
+ form_error($element, t('The @field date is required. Please enter a date in the format @format.', array('@field' => $title, '@format' => $now->format($element['#date_expected_format']))));
+ }
+ else {
+ // If there's a date with no errors, save it.
+ $date = datetime_get_input_date($element, $input);
+ if ($date instanceOf \Drupal\Core\Datetime\DrupalDateTime && !$date->hasErrors()) {
+ form_set_value($element, $date->__toString(), $form_state);
+ }
+ // If the input is invalid, set an error.
+ else {
+ $now = new \Drupal\Core\Datetime\DrupalDateTime();
+ $title = !empty($element['#title']) ? $element['#title'] : '';
+ form_error($element, t('The @field date is invalid. Please enter a date in the format @format.', array('@field' => $title, '@format' => $now->format($element['#date_expected_format']))));
+ }
+ }
+ }
+}
+
+/**
+ * Helper function to retrieve the right format for a HTML5
+ * date element. Important because these elements will not
+ * work with any other format.
+ *
+ * @param string $element_type
+ * The type of element being used.
+ * @param string $format
+ * The proposed format.
+ *
+ * @return string
+ * Returns the right format for the type of element, or
+ * the original format if this is not a HTML5 element.
+ */
+function datetime_get_format($element_type, $format) {
+ switch ($element_type) {
+ case 'date':
+ return variable_get('date_format_html_date', 'Y-m-d');
+ case 'datetime':
+ case 'datetime-local':
+ return variable_get('date_format_html_datetime', 'Y-m-d\TH:i:sO');
+ case 'time':
+ return variable_get('date_format_html_time', 'H:i:s');
+ default:
+ return $format;
+ }
+}
+
+/**
+ * Callback to add the jQuery datepicker to a date element.
+ * The javascript in drupal.datepicker will check first for HTML5
+ * compliance, and then apply the jQuery datepicker as a fallback,
+ * only if the HTML5 widget is not supported.
+ *
+ * @param array $element
+ * The 'date' element being altered.
+ * @param array $form_state
+ * The form state array.
+ * @param object $date
+ * The date object being manipulated by this element.
+ */
+function datetime_jquery_datepicker(&$element, &$form_state, $date) {
+
+ // Get the format used by the element, and then convert it to
+ // the format needed by the datepicker.
+ $element_format = datetime_get_format($element['#date_date_element'], $element['#date_date_format']);
+ $datepicker_format = datepicker_get_format($element_format);
+
+ // Make sure the date range includes the current year to avoid odd
+ // behavior when the datepicker doesn't find it in the date range.
+ // The date_range_years function will ensure the current date is
+ // included in the range.
+ $range = date_range_years($element['#date_year_range'], $date);
+
+ $settings = array(
+ 'changeMonth' => 'true',
+ 'changeYear' => 'true',
+ 'autoPopUp' => 'focus',
+ 'closeAtTop' => 'false',
+ 'speed' => 'immediate',
+ 'firstDay' => intval(variable_get('date_first_day', 0)),
+ 'dateFormat' => $datepicker_format,
+ 'yearRange' => $range[0] . ':' . $range[1],
+ );
+
+ // There could be an unknown number of instances of the datepicker
+ // on any page. Set a unique id for each element and its settings.
+ $new_id = datepicker_settings_id($element['#id'], $settings, $date);
+ $element['date']['#id'] = $new_id;
+
+ $js_settings = array(
+ 'type' => 'setting',
+ 'data' => array(
+ 'dateTime' => array(
+ '#' . $new_id => $settings,
+ ),
+ ),
+ );
+ $element['#attached']['js'][] = $js_settings;
+ $element['#attached']['library'][] = array('system', 'jquery.ui.datepicker');
+ $element['#attached']['library'][] = array('system', 'drupal.datepicker');
+}
+
+/**
+ * Alter the format string for the jQuery datepicker.
+ * Used to transform a date format that uses the PHP format
+ * strings to the format used by the datepicker.
+ *
+ * @param string $format
+ * A standard PHP format string.
+ *
+ * @return string
+ * Returns the format string formatted correctly for the jQuery
+ * timepicker.
+ */
+function datepicker_get_format($format) {
+ $replace = array(
+ 'd' => 'dd',
+ 'j' => 'd',
+ 'l' => 'DD',
+ 'D' => 'D',
+ 'm' => 'mm',
+ 'n' => 'm',
+ 'F' => 'MM',
+ 'M' => 'M',
+ 'Y' => 'yy',
+ 'y' => 'y',
+ );
+ return strtr($format, $replace);
+}
+
+/**
+ * A central function and static for creating a unique id for as
+ * many datepicker elements as might be created, to be used by multiple
+ * datepicker elements across a page request.
+ *
+ * @param $id
+ * The id of the element that contains the datepicker.
+ * @param $settings
+ * The settings array to pass to the jQuery function.
+ *
+ * @returns
+ * The CSS id to assign to the element that should have
+ * $func($settings) invoked on it.
+ */
+function datepicker_settings_id($id, &$settings, $date) {
+ static $id_count = array();
+
+ // We use a static array to account for possible multiple form_builder()
+ // calls in the same request (for instance on 'Preview') and when
+ // there are multiple values, as with multiple value fields.
+
+ if (!isset($id_count[$id])) {
+ $id_count[$id] = 0;
+ }
+ return "$id-datepicker-" . $id_count[$id]++;
}
/**
diff --git a/core/includes/theme.inc b/core/includes/theme.inc
index cc29a98..3317929 100644
--- a/core/includes/theme.inc
+++ b/core/includes/theme.inc
@@ -3051,6 +3051,9 @@ function drupal_common_theme() {
'date' => array(
'render element' => 'element',
),
+ 'form_datetime' => array(
+ 'render element' => 'element',
+ ),
'exposed_filters' => array(
'render element' => 'form',
),
diff --git a/core/lib/Drupal/Component/Datetime/DateTimePlus.php b/core/lib/Drupal/Component/Datetime/DateTimePlus.php
new file mode 100644
index 0000000..289d6c0
--- /dev/null
+++ b/core/lib/Drupal/Component/Datetime/DateTimePlus.php
@@ -0,0 +1,739 @@
+ 2014, 'month => 4).
+ * Defaults to 'now'.
+ * @param mixed $timezone
+ * PHP DateTimeZone object, string or NULL allowed.
+ * Defaults to NULL.
+ * @param string $format
+ * PHP date() type format for parsing the input. This is recommended
+ * for specialized input with a known format. If provided the
+ * date will be created using the createFromFormat() method.
+ * Defaults to NULL.
+ * @see http://us3.php.net/manual/en/datetime.createfromformat.php
+ * @param array $settings
+ * - boolean $validate_format
+ * The format used in createFromFormat() allows slightly different
+ * values than format(). If we use an input format that works in
+ * both functions we can add a validation step to confirm that the
+ * date created from a format string exactly matches the input.
+ * We need to know if this can be relied on to do that validation.
+ * Defaults to TRUE.
+ * - string $langcode
+ * The two letter language code to construct the locale string by the
+ * intlDateFormatter class. Used to control the result of the
+ * format() method if that class is available. Defaults to NULL.
+ * - string $country
+ * The two letter country code to construct the locale string by the
+ * intlDateFormatter class. Used to control the result of the
+ * format() method if that class is available. Defaults to NULL.
+ * - string $calendar
+ * A calendar name to use for the date, Defaults to
+ * DateTimePlus::CALENDAR.
+ * - boolean $debug
+ * Leave evidence of the input values in the resulting object
+ * for debugging purposes. Defaults to FALSE.
+ *
+ * @TODO
+ * Potentially there will be additional ways to take advantage
+ * of calendar in date handling in the future.
+ */
+ public function __construct($time = 'now', $timezone = NULL, $format = NULL, $settings = array()) {
+
+ // Unpack settings.
+ $this->validate_format = !empty($settings['validate_format']) ? $settings['validate_format'] : TRUE;
+ $this->langcode = !empty($settings['langcode']) ? $settings['langcode'] : NULL;
+ $this->country = !empty($settings['country']) ? $settings['country'] : NULL;
+ $this->calendar = !empty($settings['calendar']) ? $settings['calendar'] : static::CALENDAR;
+
+ // Store the original input so it is available for validation.
+ $this->input_time_raw = $time;
+ $this->input_timezone_raw = $timezone;
+ $this->input_format_raw = $format;
+
+ // Massage the input values as necessary.
+ $this->prepareTime($time);
+ $this->prepareTimezone($timezone);
+ $this->prepareFormat($format);
+
+ // Create a date as a clone of an input DateTime object.
+ if ($this->inputIsObject()) {
+ $this->constructFromObject();
+ }
+
+ // Create date from array of date parts.
+ elseif ($this->inputIsArray()) {
+ $this->constructFromArray();
+ }
+
+ // Create a date from a Unix timestamp.
+ elseif ($this->inputIsTimestamp()) {
+ $this->constructFromTimestamp();
+ }
+
+ // Create a date from a time string and an expected format.
+ elseif ($this->inputIsFormat()) {
+ $this->constructFromFormat();
+ }
+
+ // Create a date from any other input.
+ else {
+ $this->constructFallback();
+ }
+
+ // Clean up the error messages.
+ $this->getErrors();
+ $this->errors = array_unique($this->errors);
+
+ // Now that we've validated the input, clean up the extra values.
+ if (empty($settings['debug'])) {
+ unset(
+ $this->input_time_raw,
+ $this->input_time_adjusted,
+ $this->input_timezone_raw,
+ $this->input_timezone_adjusted,
+ $this->input_format_raw,
+ $this->input_format_adjusted,
+ $this->validate_format
+ );
+ }
+
+ }
+
+ /**
+ * Implementation of __toString() for dates. The base DateTime
+ * class does not implement this.
+ *
+ * @see https://bugs.php.net/bug.php?id=62911 and
+ * http://www.serverphorums.com/read.php?7,555645
+ */
+ public function __toString() {
+ $format = static::FORMAT;
+ return $this->format($format) . ' ' . $this->getTimeZone()->getName();
+ }
+
+ /**
+ * Prepare the input value before trying to use it.
+ * Can be overridden to handle special cases.
+ *
+ * @param mixed $time
+ * An input value, which could be a timestamp, a string,
+ * or an array of date parts.
+ */
+ public function prepareTime($time) {
+ $this->input_time_adjusted = $time;
+ }
+
+ /**
+ * Prepare the timezone before trying to use it.
+ * Most imporantly, make sure we have a valid timezone
+ * object before moving further.
+ *
+ * @param mixed $timezone
+ * Either a timezone name or a timezone object or NULL.
+ */
+ public function prepareTimezone($timezone) {
+ // If the passed in timezone is a valid timezone object, use it.
+ if ($timezone instanceOf \DateTimezone) {
+ $timezone_adjusted = $timezone;
+ }
+
+ // When the passed-in time is a DateTime object with its own
+ // timezone, try to use the date's timezone.
+ elseif (empty($timezone) && $this->input_time_adjusted instanceOf \DateTime) {
+ $timezone_adjusted = $this->input_time_adjusted->getTimezone();
+ }
+
+ // Allow string timezone input, and create a timezone from it.
+ elseif (!empty($timezone) && is_string($timezone)) {
+ $timezone_adjusted = new \DateTimeZone($timezone);
+ }
+
+ // Default to the system timezone when not explicitly provided.
+ // If the system timezone is missing, use 'UTC'.
+ if (empty($timezone_adjusted) || !$timezone_adjusted instanceOf \DateTimezone) {
+ $system_timezone = date_default_timezone_get();
+ $timezone_name = !empty($system_timezone) ? $system_timezone : 'UTC';
+ $timezone_adjusted = new \DateTimeZone($timezone_name);
+ }
+
+ // We are finally certain that we have a usable timezone.
+ $this->input_timezone_adjusted = $timezone_adjusted;
+ }
+
+ /**
+ * Prepare the input format before trying to use it.
+ * Can be overridden to handle special cases.
+ *
+ * @param string $format
+ * A PHP format string.
+ */
+ public function prepareFormat($format) {
+ $this->input_format_adjusted = $format;
+ }
+
+ /**
+ * Check if input is a DateTime object.
+ *
+ * @return boolean
+ * TRUE if the input time is a DateTime object.
+ */
+ public function inputIsObject() {
+ return $this->input_time_adjusted instanceOf \DateTime;
+ }
+
+ /**
+ * Create a date object from an input date object.
+ */
+ public function constructFromObject() {
+ try {
+ $this->input_time_adjusted = $this->input_time_adjusted->format(static::FORMAT);
+ parent::__construct($this->input_time_adjusted, $this->input_timezone_adjusted);
+ }
+ catch (\Exception $e) {
+ $this->errors[] = $e->getMessage();
+ }
+ }
+
+ /**
+ * Check if input time seems to be a timestamp.
+ *
+ * Providing an input format will prevent ISO values without separators
+ * from being mis-interpreted as timestamps. Providing a format can also
+ * avoid interpreting a value like '2010' with a format of 'Y' as a
+ * timestamp. The 'U' format indicates this is a timestamp.
+ *
+ * @return boolean
+ * TRUE if the input time is a timestamp.
+ */
+ public function inputIsTimestamp() {
+ return is_numeric($this->input_time_adjusted) && (empty($this->input_format_adjusted) || $this->input_format_adjusted == 'U');
+ }
+
+ /**
+ * Create a date object from timestamp input.
+ *
+ * The timezone for timestamps is always UTC. In this case the
+ * timezone we set controls the timezone used when displaying
+ * the value using format().
+ */
+ public function constructFromTimestamp() {
+ try {
+ parent::__construct('', $this->input_timezone_adjusted);
+ $this->setTimestamp($this->input_time_adjusted);
+ }
+ catch (\Exception $e) {
+ $this->errors[] = $e->getMessage();
+ }
+ }
+
+ /**
+ * Check if input is an array of date parts.
+ *
+ * @return boolean
+ * TRUE if the input time is a DateTime object.
+ */
+ public function inputIsArray() {
+ return is_array($this->input_time_adjusted);
+ }
+
+ /**
+ * Create a date object from an array of date parts.
+ *
+ * Convert the input value into an ISO date, forcing a full ISO
+ * date even if some values are missing.
+ */
+ public function constructFromArray() {
+ try {
+ parent::__construct('', $this->input_timezone_adjusted);
+ $this->input_time_adjusted = static::prepareArray($this->input_time_adjusted, TRUE);
+ if (static::checkArray($this->input_time_adjusted)) {
+ // Even with validation, we can end up with a value that the
+ // parent class won't handle, like a year outside the range
+ // of -9999 to 9999, which will pass checkdate() but
+ // fail to construct a date object.
+ $this->input_time_adjusted = static::arrayToISO($this->input_time_adjusted);
+ parent::__construct($this->input_time_adjusted, $this->input_timezone_adjusted);
+ }
+ else {
+ throw new \Exception('The array contains invalid values.');
+ }
+ }
+ catch (\Exception $e) {
+ $this->errors[] = $e->getMessage();
+ }
+ }
+
+ /**
+ * Check if input is a string with an expected format.
+ *
+ * @return boolean
+ * TRUE if the input time is a string with an expected format.
+ */
+ public function inputIsFormat() {
+ return is_string($this->input_time_adjusted) && !empty($this->input_format_adjusted);
+ }
+
+ /**
+ * Create a date object from an input format.
+ *
+ */
+ public function constructFromFormat() {
+ // Try to create a date from the format and use it if possible.
+ // A regular try/catch won't work right here, if the value is
+ // invalid it doesn't return an exception.
+ try {
+ parent::__construct('', $this->input_timezone_adjusted);
+ $date = parent::createFromFormat($this->input_format_adjusted, $this->input_time_adjusted, $this->input_timezone_adjusted);
+ if (!$date instanceOf \DateTime) {
+ throw new \Exception('The date cannot be created from a format.');
+ }
+ else {
+ $this->setTimestamp($date->getTimestamp());
+ $this->setTimezone($date->getTimezone());
+
+ try {
+ // The createFromFormat function is forgiving, it might
+ // create a date that is not exactly a match for the provided
+ // value, so test for that. For instance, an input value of
+ // '11' using a format of Y (4 digits) gets created as
+ // '0011' instead of '2011'.
+ // Use the parent::format() because we do not want to use
+ // the IntlDateFormatter here.
+ if ($this->validate_format && parent::format($this->input_format_adjusted) != $this->input_time_raw) {
+ throw new \Exception('The created date does not match the input value.');
+ }
+ }
+ catch (\Exception $e) {
+ $this->errors[] = $e->getMessage();
+ }
+ }
+ }
+ catch (\Exception $e) {
+ $this->errors[] = $e->getMessage();
+ }
+ }
+
+ /**
+ * Fallback construction for values that don't match any of the
+ * other patterns.
+ *
+ * Let the parent dateTime attempt to turn this string into a
+ * valid date.
+ */
+ public function constructFallback() {
+
+ try {
+ // One last test for invalid input before we try to construct
+ // a date. If the input contains totally bogus information
+ // it will blow up badly if we pass it to the constructor.
+ // The date_parse() function will tell us if the input
+ // makes sense.
+ if (!empty($this->input_time_adjusted)) {
+ $test = date_parse($this->input_time_adjusted);
+ if (!empty($test['errors'])) {
+ $this->errors[] = $test['errors'];
+ }
+ }
+
+ if (empty($this->errors)) {
+ @parent::__construct($this->input_time_adjusted, $this->input_timezone_adjusted);
+ }
+ }
+ catch (\Exception $e) {
+ dsm('HERE');
+ $this->errors[] = $e->getMessage();
+ }
+ }
+
+ /**
+ * Examine getLastErrors() and see what errors to report.
+ *
+ * We're interested in two kinds of errors: anything that DateTime
+ * considers an error, and also a warning that the date was invalid.
+ * PHP creates a valid date from invalid data with only a warning,
+ * 2011-02-30 becomes 2011-03-03, for instance, but we don't want that.
+ *
+ * @see http://us3.php.net/manual/en/time.getlasterrors.php
+ */
+ public function getErrors() {
+ $errors = $this->getLastErrors();
+ if (!empty($errors['errors'])) {
+ $this->errors += $errors['errors'];
+ }
+ // Most warnings are messages that the date could not be parsed
+ // which causes it to be altered. We're going to consider a warning
+ // as bad as an error.
+ if (!empty($errors['warnings'])) {
+ $this->errors[] = 'The date is invalid.';
+ }
+ }
+
+ /**
+ * Detect if there were errors in the processing of this date.
+ */
+ function hasErrors() {
+ if (count($this->errors)) {
+ return TRUE;
+ }
+
+ return FALSE;
+ }
+
+ /**
+ * Creates an ISO date from an array of values.
+ *
+ * @param array $array
+ * An array of date values keyed by date part.
+ * @param bool $force_valid_date
+ * (optional) Whether to force a full date by filling in missing
+ * values. Defaults to FALSE.
+ *
+ * @return string
+ * The date as an ISO string.
+ */
+ public static function arrayToISO($array, $force_valid_date = FALSE) {
+ $array = static::prepareArray($array, $force_valid_date);
+ $input_time_adjusted = '';
+ if ($array['year'] !== '') {
+ $input_time_adjusted = static::datePad(intval($array['year']), 4);
+ if ($force_valid_date || $array['month'] !== '') {
+ $input_time_adjusted .= '-' . static::datePad(intval($array['month']));
+ if ($force_valid_date || $array['day'] !== '') {
+ $input_time_adjusted .= '-' . static::datePad(intval($array['day']));
+ }
+ }
+ }
+ if ($array['hour'] !== '') {
+ $input_time_adjusted .= $input_time_adjusted ? 'T' : '';
+ $input_time_adjusted .= static::datePad(intval($array['hour']));
+ if ($force_valid_date || $array['minute'] !== '') {
+ $input_time_adjusted .= ':' . static::datePad(intval($array['minute']));
+ if ($force_valid_date || $array['second'] !== '') {
+ $input_time_adjusted .= ':' . static::datePad(intval($array['second']));
+ }
+ }
+ }
+ return $input_time_adjusted;
+ }
+
+ /**
+ * Creates a complete array from a possibly incomplete array of date parts.
+ *
+ * @param array $array
+ * An array of date values keyed by date part.
+ * @param bool $force_valid_date
+ * (optional) Whether to force a valid date by filling in missing
+ * values with valid values or just to use empty values instead.
+ * Defaults to FALSE.
+ *
+ * @return array
+ * A complete array of date parts.
+ */
+ public static function prepareArray($array, $force_valid_date = FALSE) {
+ if ($force_valid_date) {
+ $now = new \DateTime();
+ $array += array(
+ 'year' => $now->format('Y'),
+ 'month' => 1,
+ 'day' => 1,
+ 'hour' => 0,
+ 'minute' => 0,
+ 'second' => 0,
+ );
+ }
+ else {
+ $array += array(
+ 'year' => '',
+ 'month' => '',
+ 'day' => '',
+ 'hour' => '',
+ 'minute' => '',
+ 'second' => '',
+ );
+ }
+ return $array;
+ }
+
+ /**
+ * Check that an array of date parts has a year, month, and day,
+ * and that those values create a valid date. If time is provided,
+ * verify that the time values are valid. Sort of an
+ * equivalent to checkdate().
+ *
+ * @param array $array
+ * An array of datetime values keyed by date part.
+ *
+ * @return boolean
+ * TRUE if the datetime parts contain valid values, otherwise FALSE.
+ */
+ public static function checkArray($array) {
+ $valid_date = FALSE;
+ $valid_input_time_adjusted = TRUE;
+ // Check for a valid date using checkdate(). Only values that
+ // meet that test are valid.
+ if (array_key_exists('year', $array) && array_key_exists('month', $array) && array_key_exists('day', $array)) {
+ if (@checkdate($array['month'], $array['day'], $array['year'])) {
+ $valid_date = TRUE;
+ }
+ }
+ // Testing for valid time is reversed. Missing time is OK,
+ // but incorrect values are not.
+ foreach (array('hour', 'minute', 'second') as $key) {
+ if (array_key_exists($key, $array)) {
+ $value = $array[$key];
+ switch ($value) {
+ case 'hour':
+ if (!preg_match('/^([1-2][0-3]|[01]?[0-9])$/', $value)) {
+ $valid_input_time_adjusted = FALSE;
+ }
+ break;
+ case 'minute':
+ case 'second':
+ default:
+ if (!preg_match('/^([0-5][0-9]|[0-9])$/', $value)) {
+ $valid_input_time_adjusted = FALSE;
+ }
+ break;
+ }
+ }
+ }
+ return $valid_date && $valid_input_time_adjusted;
+ }
+
+ /**
+ * Helper function to left pad date parts with zeros.
+ *
+ * Provided because this is needed so often with dates.
+ *
+ * @param int $value
+ * The value to pad.
+ * @param int $size
+ * (optional) Size expected, usually 2 or 4. Defaults to 2.
+ *
+ * @return string
+ * The padded value.
+ */
+ public static function datePad($value, $size = 2) {
+ return sprintf("%0" . $size . "d", $value);
+ }
+
+
+ /**
+ * Test if the IntlDateFormatter is available and we have the
+ * right information to be able to use it.
+ */
+ function canUseIntl() {
+ return class_exists('IntlDateFormatter') && !empty($this->calendar) && !empty($this->langcode) && !empty($this->country);
+ }
+
+ /**
+ * Format the date for display.
+ *
+ * Use the IntlDateFormatter to display the format, if possible.
+ * Because the IntlDateFormatter is not always available, we
+ * add an optional array of settings that provides the information
+ * the IntlDateFormatter will need.
+ *
+ * @param string $format
+ * A format string using either PHP's date() or the
+ * IntlDateFormatter() format.
+ * @param array $settings
+ * - string $format_string_type
+ * Which pattern is used by the format string. When using the
+ * Intl formatter, the format string must use the Intl pattern,
+ * which is different from the pattern used by the DateTime
+ * format function. Defaults to DateTimePlus::PHP.
+ * - string $timezone
+ * A timezone name. Defaults to the timezone of the date object.
+ * - string $langcode
+ * The two letter language code to construct the locale string by the
+ * intlDateFormatter class. Used to control the result of the
+ * format() method if that class is available. Defaults to NULL.
+ * - string $country
+ * The two letter country code to construct the locale string by the
+ * intlDateFormatter class. Used to control the result of the
+ * format() method if that class is available. Defaults to NULL.
+ * - string $calendar
+ * A calendar name to use for the date, Defaults to
+ * DateTimePlus::CALENDAR.
+ * - int $date_type
+ * The date type to use in the formatter, defaults to
+ * IntlDateFormatter::FULL.
+ * - int $time_type
+ * The date type to use in the formatter, defaults to
+ * IntlDateFormatter::FULL.
+ * - boolean $lenient
+ * Whether or not to use lenient processing in the intl
+ * formatter. Defaults to FALSE;
+ *
+ * @return string
+ * The formatted value of the date.
+ *
+ * @TODO
+ * Potentially there will be additional ways to take advantage
+ * of calendar in date handling in the future.
+ */
+ function format($format, $settings = array()) {
+
+ // If there were construction errors, we can't format the date.
+ if ($this->hasErrors()) {
+ return;
+ }
+
+ $format_string_type = isset($settings['format_string_type']) ? $settings['format_string_type'] : static::PHP;
+ $langcode = !empty($settings['langcode']) ? $settings['langcode'] : $this->langcode;
+ $country = !empty($settings['country']) ? $settings['country'] : $this->country;
+ $calendar = !empty($settings['calendar']) ? $settings['calendar'] : $this->calendar;
+ $time_zone = !empty($settings['timezone']) ? $settings['timezone'] : $this->getTimezone()->getName();
+ $lenient = !empty($settings['lenient']) ? $settings['lenient'] : FALSE;
+
+ // Format the date and catch errors.
+ try {
+
+ // If we have what we need to use the IntlDateFormatter, do so.
+ if ($this->canUseIntl() && $format_string_type == static::INTL) {
+
+ // Construct the $locale variable needed by the IntlDateFormatter.
+ $locale = $langcode . '_' . $country;
+
+ // If we have information about a calendar, add it.
+ if (!empty($calendar) && $calendar != static::CALENDAR) {
+ $locale .= '@calendar=' . $calendar;
+ }
+
+ // If we're working with a non-gregorian calendar, indicate that.
+ $calendar_type = \IntlDateFormatter::GREGORIAN;
+ if ($calendar != SELF::CALENDAR) {
+ $calendar_type = \IntlDateFormatter::TRADITIONAL;
+ }
+
+ $date_type = !empty($settings['date_type']) ? $settings['date_type'] : \IntlDateFormatter::FULL;
+ $time_type = !empty($settings['time_type']) ? $settings['time_type'] : \IntlDateFormatter::FULL;
+ $formatter = new \IntlDateFormatter($locale, $date_type, $time_type, $time_zone, $calendar_type);
+ $formatter->setLenient($lenient);
+ $value = $formatter->format($format);
+ }
+
+ // Otherwise, use the parent method.
+ else {
+ $value = parent::format($format);
+ }
+ }
+ catch (\Exception $e) {
+ $this->errors[] = $e->getMessage();
+ }
+ return $value;
+ }
+}
diff --git a/core/lib/Drupal/Core/Datetime/DrupalDateTime.php b/core/lib/Drupal/Core/Datetime/DrupalDateTime.php
new file mode 100644
index 0000000..d917c3e
--- /dev/null
+++ b/core/lib/Drupal/Core/Datetime/DrupalDateTime.php
@@ -0,0 +1,178 @@
+ 2014, 'month => 4).
+ * Defaults to 'now'.
+ * @param mixed $timezone
+ * PHP DateTimeZone object, string or NULL allowed.
+ * Defaults to NULL.
+ * @param string $format
+ * PHP date() type format for parsing the input. This is recommended
+ * to use things like negative years, which php's parser fails on, or
+ * any other specialized input with a known format. If provided the
+ * date will be created using the createFromFormat() method.
+ * Defaults to NULL.
+ * @see http://us3.php.net/manual/en/datetime.createfromformat.php
+ * @param array $settings
+ * - boolean $validate_format
+ * The format used in createFromFormat() allows slightly different
+ * values than format(). If we use an input format that works in
+ * both functions we can add a validation step to confirm that the
+ * date created from a format string exactly matches the input.
+ * We need to know if this can be relied on to do that validation.
+ * Defaults to TRUE.
+ * - string $langcode
+ * The two letter language code to construct the locale string by the
+ * intlDateFormatter class. Used to control the result of the
+ * format() method if that class is available. Defaults to NULL.
+ * - string $country
+ * The two letter country code to construct the locale string by the
+ * intlDateFormatter class. Used to control the result of the
+ * format() method if that class is available. Defaults to NULL.
+ * - string $calendar
+ * A calendar name to use for the date, Defaults to
+ * DateTimePlus::CALENDAR.
+ * - boolean $debug
+ * Leave evidence of the input values in the resulting object
+ * for debugging purposes. Defaults to FALSE.
+ *
+ * @TODO
+ * Potentially there will be additional ways to take advantage
+ * of calendar in date handling in the future.
+ */
+ public function __construct($time = 'now', $timezone = NULL, $format = NULL, $settings = array()) {
+
+ // We can set the langcode and country using Drupal values.
+ $settings['langcode'] = !empty($settings['langcode']) ? $settings['langcode'] : language(LANGUAGE_TYPE_INTERFACE)->langcode;
+ $settings['country'] = !empty($settings['country']) ? $settings['country'] : variable_get('site_default_country');
+
+ // Instantiate the parent class.
+ parent::__construct($time, $timezone, $format, $settings);
+
+ }
+
+ /**
+ * Override basic component timezone handling to use Drupal's
+ * knowledge of the preferred user timezone.
+ */
+ public function prepareTimezone($timezone) {
+ $user_timezone = drupal_get_user_timezone();
+ if (empty($timezone) && !empty($user_timezone)) {
+ $timezone = $user_timezone;
+ }
+ parent::prepareTimezone($timezone);
+ }
+
+ /**
+ * Format the date for display.
+ *
+ * Use the IntlDateFormatter to display the format, if available.
+ * Because the IntlDateFormatter is not always available, we
+ * need to know whether the $format string uses the standard
+ * format strings used by the date() function or the alternative
+ * format provided by the IntlDateFormatter.
+ *
+ * @param string $format
+ * A format string using either date() or IntlDateFormatter()
+ * format.
+ * @param array $settings
+ * - string $format_string_type
+ * Which pattern is used by the format string. When using the
+ * Intl formatter, the format string must use the Intl pattern,
+ * which is different from the pattern used by the DateTime
+ * format function. Defaults to DateTimePlus::PHP.
+ * - string $timezone
+ * A timezone name. Defaults to the timezone of the date object.
+ * - string $langcode
+ * The two letter language code to construct the locale string by the
+ * intlDateFormatter class. Used to control the result of the
+ * format() method if that class is available. Defaults to NULL.
+ * - string $country
+ * The two letter country code to construct the locale string by the
+ * intlDateFormatter class. Used to control the result of the
+ * format() method if that class is available. Defaults to NULL.
+ * - string $calendar
+ * A calendar name to use for the date, Defaults to
+ * DateTimePlus::CALENDAR.
+ * - int $datetype
+ * The datetype to use in the formatter, defaults to
+ * IntlDateFormatter::FULL.
+ * - int $timetype
+ * The datetype to use in the formatter, defaults to
+ * IntlDateFormatter::FULL.
+ * - boolean $lenient
+ * Whether or not to use lenient processing in the intl
+ * formatter. Defaults to FALSE;
+ *
+ * @return string
+ * The formatted value of the date.
+ *
+ * @TODO
+ * Potentially there will be additional ways to take advantage
+ * of calendar in date handling in the future.
+ */
+ function format($format, $settings = array()) {
+
+ $format_string_type = isset($settings['format_string_type']) ? $settings['format_string_type'] : static::PHP;
+
+ $settings['langcode'] = !empty($settings['langcode']) ? $settings['langcode'] : $this->langcode;
+ $settings['country'] = !empty($settings['country']) ? $settings['country'] : $this->country;
+
+ // Format the date and catch errors.
+ try {
+
+ // If we have what we need to use the IntlDateFormatter, do so.
+ if ($this->canUseIntl() && $format_string_type == parent::INTL) {
+ $value = parent::format($format, $settings);
+ }
+
+ // Otherwise, use the default Drupal method.
+ else {
+
+ // Encode markers that should be translated. 'A' becomes
+ // '\xEF\AA\xFF'. xEF and xFF are invalid UTF-8 sequences,
+ // and we assume they are not in the input string.
+ // Paired backslashes are isolated to prevent errors in
+ // read-ahead evaluation. The read-ahead expression ensures that
+ // A matches, but not \A.
+ $format = preg_replace(array('/\\\\\\\\/', '/(?errors[] = $e->getMessage();
+ }
+ return $value;
+ }
+}
diff --git a/core/lib/Drupal/Core/Datetime/Plugin/DateCalendar.php b/core/lib/Drupal/Core/Datetime/Plugin/DateCalendar.php
new file mode 100644
index 0000000..e445b41
--- /dev/null
+++ b/core/lib/Drupal/Core/Datetime/Plugin/DateCalendar.php
@@ -0,0 +1,55 @@
+discovery = new HookDiscovery('date_calendar_info');
+ $this->factory = new DefaultFactory($this->discovery);
+ }
+
+ /**
+ * Implements Drupal\Component\Plugin\PluginManagerInterface::createInstance().
+ *
+ * @param string $plugin_id
+ * The id of a plugin, i.e. the calendar type.
+ * @param array $configuration
+ * Not used in this plugin.
+ *
+ * @return Drupal\Core\TypedData\TypedDataInterface
+ */
+ public function createInstance($plugin_id, array $configuration = array()) {
+
+ // A missing or invalid calendar $plugin_id creates serious problems,
+ // so check first and swap in the known default calendar if the
+ // value won't work.
+ $plugins = array_keys($this->getDefinitions());
+ if (!in_array($plugin_id, $plugins)) {
+ watchdog('datetime', t("The system was unable to use the '@calendar' calendar. Using @default calendar instead.", array('@calendar' => $plugin_id, '@default' => self::DEFAULT_CALENDAR)));
+ $plugin_id = self::DEFAULT_CALENDAR;
+ }
+ return $this->factory->createInstance($plugin_id, $configuration);
+ }
+
+}
diff --git a/core/lib/Drupal/Core/Datetime/Plugin/DateCalendarInterface.php b/core/lib/Drupal/Core/Datetime/Plugin/DateCalendarInterface.php
new file mode 100644
index 0000000..234557b
--- /dev/null
+++ b/core/lib/Drupal/Core/Datetime/Plugin/DateCalendarInterface.php
@@ -0,0 +1,269 @@
+ 'January',
+ 2 => 'February',
+ 3 => 'March',
+ 4 => 'April',
+ 5 => 'May',
+ 6 => 'June',
+ 7 => 'July',
+ 8 => 'August',
+ 9 => 'September',
+ 10 => 'October',
+ 11 => 'November',
+ 12 => 'December',
+ );
+ }
+
+ /**
+ * Constructs an untranslated array of abbreviated month names.
+ *
+ * @return array
+ * An array of month names.
+ */
+ public static function month_names_abbr_untranslated() {
+ // Force the key to use the correct month value, rather than
+ // starting with zero.
+ return array(
+ 1 => 'Jan',
+ 2 => 'Feb',
+ 3 => 'Mar',
+ 4 => 'Apr',
+ 5 => 'May',
+ 6 => 'Jun',
+ 7 => 'Jul',
+ 8 => 'Aug',
+ 9 => 'Sep',
+ 10 => 'Oct',
+ 11 => 'Nov',
+ 12 => 'Dec',
+ );
+ }
+
+ /**
+ * Constructs an untranslated array of week days.
+ *
+ * @return array
+ * An array of week day names
+ */
+ public static function week_days_untranslated() {
+ return array(
+ 'Sunday',
+ 'Monday',
+ 'Tuesday',
+ 'Wednesday',
+ 'Thursday',
+ 'Friday',
+ 'Saturday',
+ );
+ }
+
+ /**
+ * Returns a translated array of month names.
+ *
+ * @param bool $required
+ * (optional) If FALSE, the returned array will include a blank value.
+ * Defaults to FALSE.
+ *
+ * @return array
+ * An array of month names.
+ */
+ public static function month_names($required = FALSE) {
+ // Force the key to use the correct month value, rather than
+ // starting with zero.
+ $month_names = array(
+ 1 => t('January', array(), array('context' => 'Long month name')),
+ 2 => t('February', array(), array('context' => 'Long month name')),
+ 3 => t('March', array(), array('context' => 'Long month name')),
+ 4 => t('April', array(), array('context' => 'Long month name')),
+ 5 => t('May', array(), array('context' => 'Long month name')),
+ 6 => t('June', array(), array('context' => 'Long month name')),
+ 7 => t('July', array(), array('context' => 'Long month name')),
+ 8 => t('August', array(), array('context' => 'Long month name')),
+ 9 => t('September', array(), array('context' => 'Long month name')),
+ 10 => t('October', array(), array('context' => 'Long month name')),
+ 11 => t('November', array(), array('context' => 'Long month name')),
+ 12 => t('December', array(), array('context' => 'Long month name')),
+ );
+ $none = array('' => '');
+ return !$required ? $none + $month_names : $month_names;
+ }
+
+ /**
+ * Constructs a translated array of month name abbreviations
+ *
+ * @param bool $required
+ * (optional) If FALSE, the returned array will include a blank value.
+ * Defaults to FALSE.
+ *
+ * @return array
+ * An array of month abbreviations.
+ */
+ public static function month_names_abbr($required = FALSE) {
+ // Force the key to use the correct month value, rather than
+ // starting with zero.
+ $month_names = array(
+ 1 => t('Jan'),
+ 2 => t('Feb'),
+ 3 => t('Mar'),
+ 4 => t('Apr'),
+ 5 => t('May'),
+ 6 => t('Jun'),
+ 7 => t('Jul'),
+ 8 => t('Aug'),
+ 9 => t('Sep'),
+ 10 => t('Oct'),
+ 11 => t('Nov'),
+ 12 => t('Dec'),
+ );
+ $none = array('' => '');
+ return !$required ? $none + $month_names : $month_names;
+ }
+
+ /**
+ * Returns a translated array of week names.
+ *
+ * @param bool $required
+ * (optional) If FALSE, the returned array will include a blank value.
+ * Defaults to FALSE.
+ *
+ * @return array
+ * An array of week day names
+ */
+ public static function week_days($required = FALSE) {
+ $weekdays = array(
+ t('Sunday'),
+ t('Monday'),
+ t('Tuesday'),
+ t('Wednesday'),
+ t('Thursday'),
+ t('Friday'),
+ t('Saturday'),
+ );
+ $none = array('' => '');
+ return !$required ? $none + $weekdays : $weekdays;
+ }
+
+ /**
+ * Constructs a translated array of week day abbreviations.
+ *
+ * @param bool $required
+ * (optional) If FALSE, the returned array will include a blank value.
+ * Defaults to FALSE.
+ *
+ * @return array
+ * An array of week day abbreviations
+ */
+ public static function week_days_abbr($required = FALSE) {
+ $weekdays = array(
+ t('Sun', array(), array('context' => 'Sunday abbreviation')),
+ t('Mon', array(), array('context' => 'Monday abbreviation')),
+ t('Tue', array(), array('context' => 'Tuesday abbreviation')),
+ t('Wed', array(), array('context' => 'Wednesday abbreviation')),
+ t('Thu', array(), array('context' => 'Thursday abbreviation')),
+ t('Fri', array(), array('context' => 'Friday abbreviation')),
+ t('Sat', array(), array('context' => 'Saturday abbreviation')),
+ );
+ $none = array('' => '');
+ return !$required ? $none + $weekdays : $weekdays;
+ }
+
+ /**
+ * Constructs a translated array of 2-letter week day abbreviations.
+ *
+ * @param bool $required
+ * (optional) If FALSE, the returned array will include a blank value.
+ * Defaults to FALSE.
+ *
+ * @return array
+ * An array of week day 2 letter abbreviations
+ */
+ public static function week_days_abbr2($required = FALSE) {
+ $weekdays = array(
+ t('Su', array(), array('context' => 'Sunday 2 letter abbreviation')),
+ t('Mo', array(), array('context' => 'Monday 2 letter abbreviation')),
+ t('Tu', array(), array('context' => 'Tuesday 2 letter abbreviation')),
+ t('We', array(), array('context' => 'Wednesday 2 letter abbreviation')),
+ t('Th', array(), array('context' => 'Thursday 2 letter abbreviation')),
+ t('Fr', array(), array('context' => 'Friday 2 letter abbreviation')),
+ t('Sa', array(), array('context' => 'Saturday 2 letter abbreviation')),
+ );
+ $none = array('' => '');
+ return !$required ? $none + $weekdays : $weekdays;
+ }
+
+ /**
+ * Constructs a translated array of 1-letter week day abbreviations.
+ *
+ * @param bool $required
+ * (optional) If FALSE, the returned array will include a blank value.
+ * Defaults to FALSE.
+ *
+ * @return array
+ * An array of week day 1 letter abbreviations
+ */
+ public static function week_days_abbr1($required = FALSE) {
+ $weekdays = array(
+ t('S', array(), array('context' => 'Sunday 1 letter abbreviation')),
+ t('M', array(), array('context' => 'Monday 1 letter abbreviation')),
+ t('T', array(), array('context' => 'Tuesday 1 letter abbreviation')),
+ t('W', array(), array('context' => 'Wednesday 1 letter abbreviation')),
+ t('T', array(), array('context' => 'Thursday 1 letter abbreviation')),
+ t('F', array(), array('context' => 'Friday 1 letter abbreviation')),
+ t('S', array(), array('context' => 'Saturday 1 letter abbreviation')),
+ );
+ $none = array('' => '');
+ return !$required ? $none + $weekdays : $weekdays;
+ }
+
+ /**
+ * Reorders weekdays to match the first day of the week.
+ *
+ * @param array $weekdays
+ * An array of weekdays.
+ *
+ * @return array
+ * An array of weekdays reordered to match the first day of the week.
+ */
+ public static function week_days_ordered($weekdays) {
+ $first_day = variable_get('date_first_day', 0);
+ if ($first_day > 0) {
+ for ($i = 1; $i <= $first_day; $i++) {
+ $last = array_shift($weekdays);
+ array_push($weekdays, $last);
+ }
+ }
+ return $weekdays;
+ }
+
+ /**
+ * Constructs an array of years in a specified range.
+ *
+ * @param int $min
+ * The minimum year in the array.
+ * @param int $max
+ * The maximum year in the array.
+ * @param bool $required
+ * (optional) If FALSE, the returned array will include a blank value.
+ * Defaults to FALSE.
+ *
+ * @return array
+ * An array of years in the selected range.
+ */
+ public static function years($min = 0, $max = 0, $required = FALSE) {
+ // Ensure $min and $max are valid values.
+ if (empty($min)) {
+ $min = intval(date('Y', REQUEST_TIME) - 3);
+ }
+ if (empty($max)) {
+ $max = intval(date('Y', REQUEST_TIME) + 3);
+ }
+ $none = array(0 => '');
+ $range = drupal_map_assoc(range($min, $max));
+ return !$required ? $none + $range : $range;
+ }
+
+ /**
+ * Constructs an array of days in a month.
+ *
+ * @param bool $required
+ * (optional) If FALSE, the returned array will include a blank value.
+ * Defaults to FALSE.
+ * @param int $month
+ * (optional) The month in which to find the number of days.
+ * @param int $year
+ * (optional) The year in which to find the number of days.
+ *
+ * @return array
+ * An array of days for the selected month.
+ */
+ public static function days($required = FALSE, $month = NULL, $year = NULL) {
+ // If we have a month and year, find the right last day of the month.
+ if (!empty($month) && !empty($year)) {
+ $date = new DrupalDateTime($year . '-' . $month . '-01 00:00:00', 'UTC');
+ $max = $date->format('t');
+ }
+ // If there is no month and year given, default to 31.
+ if (empty($max)) {
+ $max = 31;
+ }
+ $none = array(0 => '');
+ $range = drupal_map_assoc(range(1, $max));
+ return !$required ? $none + $range : $range;
+ }
+
+
+ /**
+ * Constructs an array of hours.
+ *
+ * @param string $format
+ * A date format string that indicates the format to use for the hours.
+ * @param bool $required
+ * (optional) If FALSE, the returned array will include a blank value.
+ * Defaults to FALSE.
+ *
+ * @return array
+ * An array of hours in the selected format.
+ */
+ public static function hours($format = 'H', $required = FALSE) {
+ $hours = array();
+ if ($format == 'h' || $format == 'g') {
+ $min = 1;
+ $max = 12;
+ }
+ else {
+ $min = 0;
+ $max = 23;
+ }
+ for ($i = $min; $i <= $max; $i++) {
+ $formatted = ($format == 'H' || $format == 'h') ? DrupalDateTime::datePad($i) : $i;
+ $hours[$i] = $formatted;
+ }
+ $none = array('' => '');
+ return !$required ? $none + $hours : $hours;
+ }
+
+ /**
+ * Constructs an array of minutes.
+ *
+ * @param string $format
+ * A date format string that indicates the format to use for the minutes.
+ * @param bool $required
+ * (optional) If FALSE, the returned array will include a blank value.
+ * Defaults to FALSE.
+ * @param int $increment
+ * A the integer value to increment the values. Defaults to 1.
+ *
+ * @return array
+ * An array of minutes in the selected format.
+ */
+ public static function minutes($format = 'i', $required = FALSE, $increment = 1) {
+ $minutes = array();
+ // Ensure $increment has a value so we don't loop endlessly.
+ if (empty($increment)) {
+ $increment = 1;
+ }
+ for ($i = 0; $i < 60; $i += $increment) {
+ $formatted = $format == 'i' ? DrupalDateTime::datePad($i) : $i;
+ $minutes[$i] = $formatted;
+ }
+ $none = array('' => '');
+ return !$required ? $none + $minutes : $minutes;
+ }
+
+ /**
+ * Constructs an array of seconds.
+ *
+ * @param string $format
+ * A date format string that indicates the format to use for the seconds.
+ * @param bool $required
+ * (optional) If FALSE, the returned array will include a blank value.
+ * Defaults to FALSE.
+ * @param int $increment
+ * A the integer value to increment the values. Defaults to 1.
+ *
+ * @return array
+ * An array of seconds in the selected format.
+ */
+ public static function seconds($format = 's', $required = FALSE, $increment = 1) {
+ $seconds = array();
+ // Ensure $increment has a value so we don't loop endlessly.
+ if (empty($increment)) {
+ $increment = 1;
+ }
+ for ($i = 0; $i < 60; $i += $increment) {
+ $formatted = $format == 's' ? DrupalDateTime::datePad($i) : $i;
+ $seconds[$i] = $formatted;
+ }
+ $none = array('' => '');
+ return !$required ? $none + $seconds : $seconds;
+ }
+
+ /**
+ * Constructs an array of AM and PM options.
+ *
+ * @param bool $required
+ * (optional) If FALSE, the returned array will include a blank value.
+ * Defaults to FALSE.
+ *
+ * @return array
+ * An array of AM and PM options.
+ */
+ public static function ampm($required = FALSE) {
+ $none = array('' => '');
+ $ampm = array(
+ 'am' => t('am', array(), array('context' => 'ampm')),
+ 'pm' => t('pm', array(), array('context' => 'ampm')),
+ );
+ return !$required ? $none + $ampm : $ampm;
+ }
+
+ /**
+ * Identifies the number of days in a month for a date.
+ *
+ * @param mixed $date
+ * (optional) A date object, timestamp, or a date string.
+ * Defaults to current date.
+ *
+ * @return integer
+ * The number of days in the month.
+ */
+ public static function days_in_month($date = NULL) {
+ if (!$date instanceOf DrupalDateTime) {
+ $date = new DrupalDateTime($date);
+ }
+ if (!$date->hasErrors()) {
+ return $date->format('t');
+ }
+ return NULL;
+ }
+
+ /**
+ * Identifies the number of days in a year for a date.
+ *
+ * @param mixed $date
+ * (optional) A date object, timestamp, or a date string.
+ * Defaults to current date.
+ *
+ * @return integer
+ * The number of days in the year.
+ */
+ public static function days_in_year($date = NULL) {
+ if (!$date instanceOf DrupalDateTime) {
+ $date = new DrupalDateTime($date);
+ }
+ if (!$date->hasErrors()) {
+ if ($date->format('L')) {
+ return 366;
+ }
+ else {
+ return 365;
+ }
+ }
+ return NULL;
+ }
+
+ /**
+ * Returns day of week for a given date (0 = Sunday).
+ *
+ * @param mixed $date
+ * (optional) A date object, timestamp, or a date string.
+ * Defaults to current date.
+ *
+ * @return int
+ * The number of the day in the week.
+ */
+ public static function day_of_week($date = NULL) {
+ if (!$date instanceOf DrupalDateTime) {
+ $date = new DrupalDateTime($date);
+ }
+ if (!$date->hasErrors()) {
+ return $date->format('w');
+ }
+ return NULL;
+ }
+
+ /**
+ * Returns translated name of the day of week for a given date.
+ *
+ * @param mixed $date
+ * (optional) A date object, timestamp, or a date string.
+ * Defaults to current date.
+ * @param string $abbr
+ * (optional) Whether to return the abbreviated name for that day.
+ * Defaults to TRUE.
+ *
+ * @return string
+ * The name of the day in the week for that date.
+ */
+ public static function day_of_week_name($date = NULL, $abbr = TRUE) {
+ if (!$date instanceOf DrupalDateTime) {
+ $date = new DrupalDateTime($date);
+ }
+ $dow = self::day_of_week($date);
+ $days = $abbr ? self::week_days_abbr() : self::week_days();
+ return $days[$dow];
+ }
+
+}
diff --git a/core/lib/Drupal/Core/TypedData/Type/Date.php b/core/lib/Drupal/Core/TypedData/Type/Date.php
index 07767e9..ae54856 100644
--- a/core/lib/Drupal/Core/TypedData/Type/Date.php
+++ b/core/lib/Drupal/Core/TypedData/Type/Date.php
@@ -7,16 +7,17 @@
namespace Drupal\Core\TypedData\Type;
+use Drupal\Core\Datetime\DrupalDateTime;
use Drupal\Core\TypedData\TypedDataInterface;
-use DateTime;
use InvalidArgumentException;
/**
* The date data type.
*
- * The plain value of a date is an instance of the DateTime class. For setting
- * the value an instance of the DateTime class, any string supported by
- * DateTime::__construct(), or a timestamp as integer may be passed.
+ * The plain value of a date is an instance of the DrupalDateTime class. For setting
+ * the value any value supported by the __construct() of the DrupalDateTime
+ * class will work, including a DateTime object, a timestamp, a string
+ * date, or an array of date parts.
*/
class Date extends TypedData implements TypedDataInterface {
@@ -31,18 +32,17 @@ class Date extends TypedData implements TypedDataInterface {
* Implements TypedDataInterface::setValue().
*/
public function setValue($value) {
- if ($value instanceof DateTime || !isset($value)) {
+
+ // Don't try to create a date from an empty value.
+ // It would default to the current time.
+ if (!isset($value)) {
$this->value = $value;
}
- // Treat integer values as timestamps, even if supplied as PHP string.
- elseif ((string) (int) $value === (string) $value) {
- $this->value = new DateTime('@' . $value);
- }
- elseif (is_string($value)) {
- $this->value = new DateTime($value);
- }
else {
- throw new InvalidArgumentException("Invalid date format given.");
+ $this->value = $value instanceOf DrupalDateTime ? $value : new DrupalDateTime($value);
+ if ($this->value->hasErrors()) {
+ throw new InvalidArgumentException("Invalid date format given.");
+ }
}
}
@@ -50,7 +50,7 @@ public function setValue($value) {
* Implements TypedDataInterface::getString().
*/
public function getString() {
- return (string) $this->getValue()->format(DateTime::ISO8601);
+ return (string) $this->getValue()->__toString();
}
/**
diff --git a/core/misc/datepicker.js b/core/misc/datepicker.js
new file mode 100644
index 0000000..3fef66a
--- /dev/null
+++ b/core/misc/datepicker.js
@@ -0,0 +1,29 @@
+/**
+ * Attaches the datepicker behavior to all required fields
+ */
+(function ($) {
+Drupal.behaviors.dateTime = {
+ attach: function (context, settings) {
+
+ var i = document.createElement("input");
+ i.setAttribute("type", "date");
+ if (i.type == "text") {
+ // No native date picker support? Use jQueryUI.
+ for (var id in Drupal.settings.dateTime) {
+ $(id).bind('focus', Drupal.settings.dateTime[id], function(e) {
+ if (!$(this).hasClass('date-popup-init')) {
+ var dateTime = e.data;
+ $(this)
+ .datepicker(dateTime)
+ .addClass('date-popup-init')
+ $(this).click(function(){
+ $(this).focus();
+ });
+ }
+ });
+ }
+ }
+ }
+};
+})(jQuery);
+
diff --git a/core/modules/comment/lib/Drupal/comment/CommentFormController.php b/core/modules/comment/lib/Drupal/comment/CommentFormController.php
index cead0cd..3e3dcca 100644
--- a/core/modules/comment/lib/Drupal/comment/CommentFormController.php
+++ b/core/modules/comment/lib/Drupal/comment/CommentFormController.php
@@ -9,6 +9,7 @@
use Drupal\Core\Entity\EntityInterface;
use Drupal\Core\Entity\EntityFormController;
+use Drupal\Core\Datetime\DrupalDateTime;
/**
* Base for controller for comment forms.
@@ -236,7 +237,8 @@ public function validate(array $form, array &$form_state) {
$account = user_load_by_name($form_state['values']['name']);
$form_state['values']['uid'] = $account ? $account->uid : 0;
- if ($form_state['values']['date'] && strtotime($form_state['values']['date']) === FALSE) {
+ $date = new DrupalDateTime($form_state['values']['date']);
+ if ($date->hasErrors()) {
form_set_error('date', t('You have to specify a valid date.'));
}
if ($form_state['values']['name'] && !$form_state['values']['is_anonymous'] && !$account) {
@@ -271,7 +273,8 @@ public function submit(array $form, array &$form_state) {
if (empty($comment->date)) {
$comment->date = 'now';
}
- $comment->created = strtotime($comment->date);
+ $date = new DrupalDateTime($comment->date);
+ $comment->created = $date->getTimestamp();
$comment->changed = REQUEST_TIME;
// If the comment was posted by a registered user, assign the author's ID.
diff --git a/core/modules/field/modules/timestamp/lib/Drupal/timestamp/Plugin/field/formatter/TimestampDefaultFormatter.php b/core/modules/field/modules/timestamp/lib/Drupal/timestamp/Plugin/field/formatter/TimestampDefaultFormatter.php
new file mode 100644
index 0000000..8c82258
--- /dev/null
+++ b/core/modules/field/modules/timestamp/lib/Drupal/timestamp/Plugin/field/formatter/TimestampDefaultFormatter.php
@@ -0,0 +1,103 @@
+ $item) {
+ $date = new DrupalDateTime($item['value'], 'UTC');
+ $date->setTimeZone(timezone_open(drupal_get_user_timezone()));
+ $output = $this->dateFormat($date);
+
+ $elements[$delta] = array('#markup' => $output);
+ }
+
+ return $elements;
+
+ }
+
+ /**
+ * Format a date.
+ *
+ * @param object $date
+ * A date object.
+ *
+ * @return
+ * Returns a date formatted with the formatter's chosen format.
+ */
+ function dateFormat($date) {
+ $format_type = $this->getSetting('format_type');
+ return format_date($date->getTimestamp(), $format_type);
+ }
+
+ /**
+ * Implements Drupal\field\Plugin\Type\Formatter\FormatterInterface::settingsForm().
+ */
+ public function settingsForm(array $form, array &$form_state) {
+
+ $element = array();
+
+ $time = new DrupalDateTime();
+ $format_types = system_get_date_types();
+ if (!empty($format_types)) {
+ foreach ($format_types as $type => $type_info) {
+ $options[$type] = $type_info['title'] . ' (' . format_date($time->format('U'), $type) . ')';
+ }
+ }
+
+ $elements['format_type'] = array(
+ '#type' => 'select',
+ '#title' => t('Date format'),
+ '#description' => t("Choose a format for displaying the date."),
+ '#options' => $options,
+ '#default_value' => $this->getSetting('format_type'),
+ );
+
+ return $elements;
+ }
+
+ /**
+ * Implements Drupal\field\Plugin\Type\Formatter\FormatterInterface::settingsForm().
+ */
+ public function settingsSummary() {
+
+ $date = new DrupalDateTime();
+ $output = array();
+ $output[] = t('Format: @display', array('@display' => $this->dateFormat($date, FALSE)));
+ return implode(' ', $output);
+
+ }
+}
diff --git a/core/modules/field/modules/timestamp/lib/Drupal/timestamp/Plugin/field/formatter/TimestampPlainFormatter.php b/core/modules/field/modules/timestamp/lib/Drupal/timestamp/Plugin/field/formatter/TimestampPlainFormatter.php
new file mode 100644
index 0000000..d266117
--- /dev/null
+++ b/core/modules/field/modules/timestamp/lib/Drupal/timestamp/Plugin/field/formatter/TimestampPlainFormatter.php
@@ -0,0 +1,45 @@
+ $item) {
+ $elements[$delta] = array('#markup' => $item['value']);
+ }
+
+ return $elements;
+
+ }
+
+}
diff --git a/core/modules/field/modules/timestamp/lib/Drupal/timestamp/Plugin/field/widget/DatepickerWidget.php b/core/modules/field/modules/timestamp/lib/Drupal/timestamp/Plugin/field/widget/DatepickerWidget.php
new file mode 100644
index 0000000..fa8c29e
--- /dev/null
+++ b/core/modules/field/modules/timestamp/lib/Drupal/timestamp/Plugin/field/widget/DatepickerWidget.php
@@ -0,0 +1,104 @@
+field;
+ $instance = $this->instance;
+
+ // We're nesting some sub-elements inside the parent, so we
+ // need a wrapper. We also need to add another #title attribute
+ // at the top level for ease in identifying this item in error
+ // messages. We don't want to display this title because the
+ // actual title display is handled at a higher level by the Field
+ // module.
+
+ $element['#theme_wrappers'][] = 'form_element';
+ $element['#attributes']['class'] = 'container-inline';
+
+ switch ($field['settings']['datetime']) {
+ case 'date':
+ $date_type = 'date';
+ $time_type = 'none';
+ break;
+ default:
+ $date_type = 'date';
+ $time_type = 'time';
+ break;
+ }
+
+ $element['value'] = array(
+ '#type' => 'datetime',
+ '#title' => $instance->definition['label'],
+ '#title_display' => 'invisible',
+ '#delta' => $delta,
+ '#default_value' => isset($items[$delta]['value']) ? $items[$delta]['value'] : NULL,
+ '#date_increment' => 1,
+ '#date_date_format'=> variable_get('date_format_html_date', 'Y-m-d'),
+ '#date_date_element' => $date_type,
+ '#date_date_callbacks' => array('datetime_jquery_datepicker'),
+ '#date_time_format' => variable_get('date_format_html_time', 'H:i:s'),
+ '#date_time_element' => $time_type,
+ '#date_time_callbacks' => array(),
+ '#required' => $element['#required'],
+ );
+ $element['#element_validate'][] = 'timestamp_validate';
+
+ return $element;
+ }
+
+}
diff --git a/core/modules/field/modules/timestamp/lib/Drupal/timestamp/Type/TimestampItem.php b/core/modules/field/modules/timestamp/lib/Drupal/timestamp/Type/TimestampItem.php
new file mode 100644
index 0000000..a86ee54
--- /dev/null
+++ b/core/modules/field/modules/timestamp/lib/Drupal/timestamp/Type/TimestampItem.php
@@ -0,0 +1,39 @@
+ 'integer',
+ 'label' => t('Timestamp value'),
+ );
+ }
+ return self::$propertyDefinitions;
+ }
+}
diff --git a/core/modules/field/modules/timestamp/timestamp.info b/core/modules/field/modules/timestamp/timestamp.info
new file mode 100644
index 0000000..12789bd
--- /dev/null
+++ b/core/modules/field/modules/timestamp/timestamp.info
@@ -0,0 +1,6 @@
+name = Timestamp
+description = A simple date/time field stored as a timestamp.
+package = Core
+version = VERSION
+core = 8.x
+dependencies[] = field
\ No newline at end of file
diff --git a/core/modules/field/modules/timestamp/timestamp.install b/core/modules/field/modules/timestamp/timestamp.install
new file mode 100644
index 0000000..0408c80
--- /dev/null
+++ b/core/modules/field/modules/timestamp/timestamp.install
@@ -0,0 +1,18 @@
+ 'int',
+ 'not null' => FALSE,
+ );
+ return array('columns' => $db_columns);
+}
diff --git a/core/modules/field/modules/timestamp/timestamp.module b/core/modules/field/modules/timestamp/timestamp.module
new file mode 100644
index 0000000..1cf5e87
--- /dev/null
+++ b/core/modules/field/modules/timestamp/timestamp.module
@@ -0,0 +1,121 @@
+getTimestamp();
+ }
+
+ $item = array();
+ $item[0]['value'] = $value;
+
+ return $item;
+}
+
+/**
+ * Implements hook_field_is_empty().
+ */
+function timestamp_field_is_empty($item, $field) {
+ if (empty($item['value'])) {
+ return TRUE;
+ }
+ return FALSE;
+}
+
+/**
+ * Implements hook_field_info().
+ */
+function timestamp_field_info() {
+ return array(
+ 'timestamp' => array(
+ 'label' => 'Timestamp',
+ 'description' => t('Store a date as a timestamp, most suitable for contemporary dates and times.'),
+ 'settings' => array(
+ 'datetime' => '',
+ ),
+ 'instance_settings' => array(
+ 'default_value' => 'now',
+ ),
+ 'default_widget' => 'timestamp',
+ 'default_formatter' => 'timestamp_default',
+ 'default_token_formatter' => 'timestamp_plain',
+ 'field item class' => '\Drupal\timestamp\Type\TimestampItem',
+ ),
+ );
+}
+
+/**
+ * Implements hook_field_settings_form().
+ */
+function timestamp_field_settings_form($field, $instance, $has_data) {
+ $settings = $field['settings'];
+
+ $form['datetime'] = array(
+ '#type' => 'select',
+ '#title' => t('Date type'),
+ '#description' => t('Choose the type of date to create.'),
+ '#default_value' => $settings['datetime'],
+ '#options' => array(
+ '' => t('Date and time'),
+ 'date' => t('Date only'),
+ ),
+ );
+ return $form;
+}
+
+/**
+ * Implements hook_field_instance_settings_form().
+ */
+function timestamp_field_instance_settings_form($field, $instance) {
+ $widget = $instance['widget'];
+ $settings = $instance['settings'];
+ $widget_settings = $instance['widget']['settings'];
+
+ $form['default_value'] = array(
+ '#type' => 'select',
+ '#title' => t('Default date'),
+ '#description' => t('Set a default value for this date.'),
+ '#default_value' => $settings['default_value'],
+ '#options' => array('blank' => t('No default value'), 'now' => t('The current date')),
+ '#weight' => 1,
+ );
+
+ return $form;
+}
+
+/**
+ * Custom validation for the timestamp form element.
+ * The date has already been validated by the datetime form type
+ * validator and transformed to an ISO date string. We just need to
+ * convert the date back to a timestamp.
+ */
+function timestamp_validate(&$element, &$form_state) {
+ if (!form_get_errors()) {
+ $input_exists = FALSE;
+ $input = drupal_array_get_nested_value($form_state['values'], $element['#parents'], $input_exists);
+ if ($input_exists) {
+ if (!empty($input['value'])) {
+ $date = new DrupalDateTime($input['value'], $element['value']['#date_timezone']);
+ if (!$date->hasErrors()) {
+ // If this is a date-only field, set the time to midnight.
+ if ($element['value']['#date_time_element'] == 'none') {
+ $date->setTime(0, 0, 0);
+ }
+ form_set_value($element['value'], $date->getTimestamp(), $form_state);
+ }
+ }
+ }
+ }
+}
diff --git a/core/modules/node/lib/Drupal/node/NodeFormController.php b/core/modules/node/lib/Drupal/node/NodeFormController.php
index 5add3df..2424146 100644
--- a/core/modules/node/lib/Drupal/node/NodeFormController.php
+++ b/core/modules/node/lib/Drupal/node/NodeFormController.php
@@ -9,6 +9,7 @@
use Drupal\Core\Entity\EntityInterface;
use Drupal\Core\Entity\EntityFormController;
+use Drupal\Core\Datetime\DrupalDateTime;
/**
* Form controller for the node edit forms.
@@ -189,12 +190,11 @@ public function form(array $form, array &$form_state, EntityInterface $node) {
'#weight' => -1,
'#description' => t('Leave blank for %anonymous.', array('%anonymous' => $user_config->get('anonymous'))),
);
-
+ $format = variable_get('date_format_html_date', 'Y-m-d') . ' ' . variable_get('date_format_html_time', 'H:i:s');
$form['author']['date'] = array(
- '#type' => 'textfield',
+ '#type' => 'datetime',
'#title' => t('Authored on'),
- '#maxlength' => 25,
- '#description' => t('Format: %time. The date format is YYYY-MM-DD and %timezone is the time zone offset from UTC. Leave blank to use the time of form submission.', array('%time' => !empty($node->date) ? date_format(date_create($node->date), 'Y-m-d H:i:s O') : format_date($node->created, 'custom', 'Y-m-d H:i:s O'), '%timezone' => !empty($node->date) ? date_format(date_create($node->date), 'O') : format_date($node->created, 'custom', 'O'))),
+ '#description' => t('Format: %time. Leave blank to use the time of form submission.', array('%time' => !empty($node->date) ? date_format(date_create($node->date), $format) : format_date($node->created, 'custom', $format))),
'#default_value' => !empty($node->date) ? $node->date : '',
);
@@ -288,9 +288,15 @@ public function validate(array $form, array &$form_state) {
}
// Validate the "authored on" field.
- if (!empty($node->date) && strtotime($node->date) === FALSE) {
+ // The date element contains the date in its ISO form, transform
+ // it back to a timestamp.
+ $date = new DrupalDateTime($node->date);
+ if ($date->hasErrors()) {
form_set_error('date', t('You have to specify a valid date.'));
}
+ else {
+ $node->date = $date->getTimestamp();
+ }
// Invoke hook_validate() for node type specific validation and
// hook_node_validate() for miscellaneous validation needed by modules.
diff --git a/core/modules/node/node.module b/core/modules/node/node.module
index 55989de..b2f2fdc 100644
--- a/core/modules/node/node.module
+++ b/core/modules/node/node.module
@@ -18,6 +18,7 @@
use Drupal\node\Node;
use Drupal\file\File;
use Drupal\Core\Entity\EntityInterface;
+use Drupal\Core\Datetime\DrupalDateTime;
/**
* Denotes that the node is not published.
@@ -1070,7 +1071,8 @@ function node_submit(Node $node) {
$node->revision_uid = $user->uid;
}
- $node->created = !empty($node->date) ? strtotime($node->date) : REQUEST_TIME;
+ $node_created = new DrupalDateTime(!empty($node->date) ? $node->date : REQUEST_TIME);
+ $node->created = $node_created->getTimestamp();
$node->validated = TRUE;
return $node;
diff --git a/core/modules/system/config/system.calendar.yml b/core/modules/system/config/system.calendar.yml
new file mode 100644
index 0000000..a711b76
--- /dev/null
+++ b/core/modules/system/config/system.calendar.yml
@@ -0,0 +1 @@
+calendar: gregorian
diff --git a/core/modules/system/lib/Drupal/system/Tests/Datetime/DateCalendarTest.php b/core/modules/system/lib/Drupal/system/Tests/Datetime/DateCalendarTest.php
new file mode 100644
index 0000000..346abf9
--- /dev/null
+++ b/core/modules/system/lib/Drupal/system/Tests/Datetime/DateCalendarTest.php
@@ -0,0 +1,70 @@
+ 'Date Calendar',
+ 'description' => 'Test Date Calendar functionality.',
+ 'group' => 'Datetime',
+ );
+ }
+
+ /**
+ * Set up required modules.
+ */
+ public static $modules = array('datetime_test');
+
+ /**
+ * Test setup.
+ */
+ public function setUp() {
+ parent::setUp();
+ }
+
+ /**
+ * Test .
+ */
+ public function testDateCalendar() {
+
+ // Test gregorian system calendar.
+ $plugin = new DateCalendar();
+ $calendar = $plugin->createInstance('gregorian');
+ $this->assertTrue(in_array('January', $calendar->month_names()), 'The gregorian calendar can be loaded.');
+
+ // Test alternate 'Gamma' calendar.
+ $plugin = new DateCalendar();
+ $options = $plugin->getDefinitions();
+ $this->assertTrue(array_key_exists('gamma', $options), 'An alternate calendar can be found.');
+
+ $calendar = $plugin->createInstance('gamma');
+ $this->assertTrue(in_array('Alpha', $calendar->month_names()), 'An alternate calendar can be loaded.');
+
+ // Test that a bogus calendar is switched to gregorian.
+ $plugin = new DateCalendar();
+ $calendar = $plugin->createInstance('bogus');
+ $this->assertTrue(in_array('January', $calendar->month_names()), 'A nonexisting calendar is replaced with the gregorian calendar.');
+
+
+ }
+
+ /**
+ * Tear down after tests.
+ */
+ public function tearDown() {
+ parent::tearDown();
+ }
+}
diff --git a/core/modules/system/lib/Drupal/system/Tests/Datetime/DateTimePlusTest.php b/core/modules/system/lib/Drupal/system/Tests/Datetime/DateTimePlusTest.php
new file mode 100644
index 0000000..a76e988
--- /dev/null
+++ b/core/modules/system/lib/Drupal/system/Tests/Datetime/DateTimePlusTest.php
@@ -0,0 +1,436 @@
+ 'DateTimePlus',
+ 'description' => 'Test DateTimePlus functionality.',
+ 'group' => 'Datetime',
+ );
+ }
+
+ /**
+ * Set up required modules.
+ */
+ public static $modules = array();
+
+ /**
+ * Test setup.
+ */
+ public function setUp() {
+ parent::setUp();
+ variable_set('date_first_day', 1);
+ }
+
+ /**
+ * Test creating dates from string input.
+ */
+ public function testDateStrings() {
+
+ // Create date object from datetime string.
+ $input = '2009-03-07 10:30';
+ $timezone = 'America/Chicago';
+ $date = new DateTimePlus($input, $timezone);
+ $value = $date->format('c');
+ $expected = '2009-03-07T10:30:00-06:00';
+ $this->assertEqual($expected, $value, "Test new DateTimePlus($input, $timezone): should be $expected, found $value.");
+
+ // Same during daylight savings time.
+ $input = '2009-06-07 10:30';
+ $timezone = 'America/Chicago';
+ $date = new DateTimePlus($input, $timezone);
+ $value = $date->format('c');
+ $expected = '2009-06-07T10:30:00-05:00';
+ $this->assertEqual($expected, $value, "Test new DateTimePlus($input, $timezone): should be $expected, found $value.");
+
+ // Create date object from date string.
+ $input = '2009-03-07';
+ $timezone = 'America/Chicago';
+ $date = new DateTimePlus($input, $timezone);
+ $value = $date->format('c');
+ $expected = '2009-03-07T00:00:00-06:00';
+ $this->assertEqual($expected, $value, "Test new DateTimePlus($input, $timezone): should be $expected, found $value.");
+
+ // Same during daylight savings time.
+ $input = '2009-06-07';
+ $timezone = 'America/Chicago';
+ $date = new DateTimePlus($input, $timezone);
+ $value = $date->format('c');
+ $expected = '2009-06-07T00:00:00-05:00';
+ $this->assertEqual($expected, $value, "Test new DateTimePlus($input, $timezone): should be $expected, found $value.");
+
+ // Create date object from date string.
+ $input = '2009-03-07 10:30';
+ $timezone = 'Australia/Canberra';
+ $date = new DateTimePlus($input, $timezone);
+ $value = $date->format('c');
+ $expected = '2009-03-07T10:30:00+11:00';
+ $this->assertEqual($expected, $value, "Test new DateTimePlus($input, $timezone): should be $expected, found $value.");
+
+ // Same during daylight savings time.
+ $input = '2009-06-07 10:30';
+ $timezone = 'Australia/Canberra';
+ $date = new DateTimePlus($input, $timezone);
+ $value = $date->format('c');
+ $expected = '2009-06-07T10:30:00+10:00';
+ $this->assertEqual($expected, $value, "Test new DateTimePlus($input, $timezone): should be $expected, found $value.");
+
+ }
+
+ /**
+ * Test creating dates from arrays of date parts.
+ */
+ function testDateArrays() {
+
+ // Create date object from date array, date only.
+ $input = array('year' => 2010, 'month' => 2, 'day' => 28);
+ $timezone = 'America/Chicago';
+ $date = new DateTimePlus($input, $timezone);
+ $value = $date->format('c');
+ $expected = '2010-02-28T00:00:00-06:00';
+ $this->assertEqual($expected, $value, "Test new DateTimePlus(array('year' => 2010, 'month' => 2, 'day' => 28), $timezone): should be $expected, found $value.");
+
+ // Create date object from date array with hour.
+ $input = array('year' => 2010, 'month' => 2, 'day' => 28, 'hour' => 10);
+ $timezone = 'America/Chicago';
+ $date = new DateTimePlus($input, $timezone);
+ $value = $date->format('c');
+ $expected = '2010-02-28T10:00:00-06:00';
+ $this->assertEqual($expected, $value, "Test new DateTimePlus(array('year' => 2010, 'month' => 2, 'day' => 28, 'hour' => 10), $timezone): should be $expected, found $value.");
+
+ // Create date object from date array, date only.
+ $input = array('year' => 2010, 'month' => 2, 'day' => 28);
+ $timezone = 'Europe/Berlin';
+ $date = new DateTimePlus($input, $timezone);
+ $value = $date->format('c');
+ $expected = '2010-02-28T00:00:00+01:00';
+ $this->assertEqual($expected, $value, "Test new DateTimePlus(array('year' => 2010, 'month' => 2, 'day' => 28), $timezone): should be $expected, found $value.");
+
+ // Create date object from date array with hour.
+ $input = array('year' => 2010, 'month' => 2, 'day' => 28, 'hour' => 10);
+ $timezone = 'Europe/Berlin';
+ $date = new DateTimePlus($input, $timezone);
+ $value = $date->format('c');
+ $expected = '2010-02-28T10:00:00+01:00';
+ $this->assertEqual($expected, $value, "Test new DateTimePlus(array('year' => 2010, 'month' => 2, 'day' => 28, 'hour' => 10), $timezone): should be $expected, found $value.");
+
+
+ }
+
+ /**
+ * Test creating dates from timestamps.
+ */
+ function testDateTimestamp() {
+
+ // Create date object from a unix timestamp and display it in
+ // local time.
+ $input = 0;
+ $timezone = 'UTC';
+ $date = new DateTimePlus($input, $timezone);
+ $value = $date->format('c');
+ $expected = '1970-01-01T00:00:00+00:00';
+ $this->assertEqual($expected, $value, "Test new DateTimePlus($input, $timezone): should be $expected, found $value.");
+
+ $expected = 'UTC';
+ $value = $date->getTimeZone()->getName();
+ $this->assertEqual($expected, $value, "The current timezone is $value: should be $expected.");
+ $expected = 0;
+ $value = $date->getOffset();
+ $this->assertEqual($expected, $value, "The current offset is $value: should be $expected.");
+
+ $timezone = 'America/Los_Angeles';
+ $date->setTimezone(new DateTimeZone($timezone));
+ $value = $date->format('c');
+ $expected = '1969-12-31T16:00:00-08:00';
+ $this->assertEqual($expected, $value, "Test \$date->setTimezone(new DateTimeZone($timezone)): should be $expected, found $value.");
+
+ $expected = 'America/Los_Angeles';
+ $value = $date->getTimeZone()->getName();
+ $this->assertEqual($expected, $value, "The current timezone should be $expected, found $value.");
+ $expected = '-28800';
+ $value = $date->getOffset();
+ $this->assertEqual($expected, $value, "The current offset should be $expected, found $value.");
+
+ // Create a date using the timestamp of zero, then display its
+ // value both in UTC and the local timezone.
+ $input = 0;
+ $timezone = 'America/Los_Angeles';
+ $date = new DateTimePlus($input, $timezone);
+ $offset = $date->getOffset();
+ $value = $date->format('c');
+ $expected = '1969-12-31T16:00:00-08:00';
+ $this->assertEqual($expected, $value, "Test new DateTimePlus($input, $timezone): should be $expected, found $value.");
+
+ $expected = 'America/Los_Angeles';
+ $value = $date->getTimeZone()->getName();
+ $this->assertEqual($expected, $value, "The current timezone should be $expected, found $value.");
+ $expected = '-28800';
+ $value = $date->getOffset();
+ $this->assertEqual($expected, $value, "The current offset should be $expected, found $value.");
+
+ $timezone = 'UTC';
+ $date->setTimezone(new DateTimeZone($timezone));
+ $value = $date->format('c');
+ $expected = '1970-01-01T00:00:00+00:00';
+ $this->assertEqual($expected, $value, "Test \$date->setTimezone(new DateTimeZone($timezone)): should be $expected, found $value.");
+
+ $expected = 'UTC';
+ $value = $date->getTimeZone()->getName();
+ $this->assertEqual($expected, $value, "The current timezone should be $expected, found $value.");
+ $expected = '0';
+ $value = $date->getOffset();
+ $this->assertEqual($expected, $value, "The current offset should be $expected, found $value.");
+ }
+
+ /**
+ * Test timezone manipulation.
+ */
+ function testTimezoneConversion() {
+
+ // Create date object from datetime string in UTC, and convert
+ // it to a local date.
+ $input = '1970-01-01 00:00:00';
+ $timezone = 'UTC';
+ $date = new DateTimePlus($input, $timezone);
+ $value = $date->format('c');
+ $expected = '1970-01-01T00:00:00+00:00';
+ $this->assertEqual($expected, $value, "Test new DateTimePlus('$input', '$timezone'): should be $expected, found $value.");
+
+ $expected = 'UTC';
+ $value = $date->getTimeZone()->getName();
+ $this->assertEqual($expected, $value, "The current timezone is $value: should be $expected.");
+ $expected = 0;
+ $value = $date->getOffset();
+ $this->assertEqual($expected, $value, "The current offset is $value: should be $expected.");
+
+ $timezone = 'America/Los_Angeles';
+ $date->setTimezone(new DateTimeZone($timezone));
+ $value = $date->format('c');
+ $expected = '1969-12-31T16:00:00-08:00';
+ $this->assertEqual($expected, $value, "Test \$date->setTimezone(new DateTimeZone($timezone)): should be $expected, found $value.");
+
+ $expected = 'America/Los_Angeles';
+ $value = $date->getTimeZone()->getName();
+ $this->assertEqual($expected, $value, "The current timezone should be $expected, found $value.");
+ $expected = '-28800';
+ $value = $date->getOffset();
+ $this->assertEqual($expected, $value, "The current offset should be $expected, found $value.");
+
+ // Convert the local time to UTC using string input.
+ $input = '1969-12-31 16:00:00';
+ $timezone = 'America/Los_Angeles';
+ $date = new DateTimePlus($input, $timezone);
+ $offset = $date->getOffset();
+ $value = $date->format('c');
+ $expected = '1969-12-31T16:00:00-08:00';
+ $this->assertEqual($expected, $value, "Test new DateTimePlus('$input', '$timezone'): should be $expected, found $value.");
+
+ $expected = 'America/Los_Angeles';
+ $value = $date->getTimeZone()->getName();
+ $this->assertEqual($expected, $value, "The current timezone should be $expected, found $value.");
+ $expected = '-28800';
+ $value = $date->getOffset();
+ $this->assertEqual($expected, $value, "The current offset should be $expected, found $value.");
+
+ $timezone = 'UTC';
+ $date->setTimezone(new DateTimeZone($timezone));
+ $value = $date->format('c');
+ $expected = '1970-01-01T00:00:00+00:00';
+ $this->assertEqual($expected, $value, "Test \$date->setTimezone(new DateTimeZone($timezone)): should be $expected, found $value.");
+
+ $expected = 'UTC';
+ $value = $date->getTimeZone()->getName();
+ $this->assertEqual($expected, $value, "The current timezone should be $expected, found $value.");
+ $expected = '0';
+ $value = $date->getOffset();
+ $this->assertEqual($expected, $value, "The current offset should be $expected, found $value.");
+
+ // Convert the local time to UTC using string input.
+ $input = '1969-12-31 16:00:00';
+ $timezone = 'Europe/Warsaw';
+ $date = new DateTimePlus($input, $timezone);
+ $offset = $date->getOffset();
+ $value = $date->format('c');
+ $expected = '1969-12-31T16:00:00+01:00';
+ $this->assertEqual($expected, $value, "Test new DateTimePlus('$input', '$timezone'): should be $expected, found $value.");
+
+ $expected = 'Europe/Warsaw';
+ $value = $date->getTimeZone()->getName();
+ $this->assertEqual($expected, $value, "The current timezone should be $expected, found $value.");
+ $expected = '+3600';
+ $value = $date->getOffset();
+ $this->assertEqual($expected, $value, "The current offset should be $expected, found $value.");
+
+
+ }
+
+ /**
+ * Test creating dates from format strings.
+ */
+ function testDateFormat() {
+
+ // Create a year-only date.
+ $input = '2009';
+ $timezone = NULL;
+ $format = 'Y';
+ $date = new DateTimePlus($input, $timezone, $format);
+ $value = $date->format('Y');
+ $expected = '2009';
+ $this->assertEqual($expected, $value, "Test new DateTimePlus($input, $timezone, $format): should be $expected, found $value.");
+
+ // Create a month and year-only date.
+ $input = '2009-10';
+ $timezone = NULL;
+ $format = 'Y-m';
+ $date = new DateTimePlus($input, $timezone, $format);
+ $value = $date->format('Y-m');
+ $expected = '2009-10';
+ $this->assertEqual($expected, $value, "Test new DateTimePlus($input, $timezone, $format): should be $expected, found $value.");
+
+ // Create a time-only date.
+ $input = 'T10:30:00';
+ $timezone = NULL;
+ $format = '\TH:i:s';
+ $date = new DateTimePlus($input, $timezone, $format);
+ $value = $date->format('H:i:s');
+ $expected = '10:30:00';
+ $this->assertEqual($expected, $value, "Test new DateTimePlus($input, $timezone, $format): should be $expected, found $value.");
+
+ // Create a time-only date.
+ $input = '10:30:00';
+ $timezone = NULL;
+ $format = 'H:i:s';
+ $date = new DateTimePlus($input, $timezone, $format);
+ $value = $date->format('H:i:s');
+ $expected = '10:30:00';
+ $this->assertEqual($expected, $value, "Test new DateTimePlus($input, $timezone, $format): should be $expected, found $value.");
+
+ }
+
+ /**
+ * Test invalid date handling.
+ */
+ function testInvalidDates() {
+
+ // Test for invalid month names when we are using a short version
+ // of the month.
+ $input = '23 abc 2012';
+ $timezone = NULL;
+ $format = 'd M Y';
+ $date = new DateTimePlus($input, $timezone, $format);
+ $this->assertNotEqual(count($date->errors), 0, "$input contains an invalid month name and produces errors.");
+
+ // Test for invalid hour.
+ $input = '0000-00-00T45:30:00';
+ $timezone = NULL;
+ $format = 'Y-m-d\TH:i:s';
+ $date = new DateTimePlus($input, $timezone, $format);
+ $this->assertNotEqual(count($date->errors), 0, "$input contains an invalid hour and produces errors.");
+
+ // Test for invalid day.
+ $input = '0000-00-99T05:30:00';
+ $timezone = NULL;
+ $format = 'Y-m-d\TH:i:s';
+ $date = new DateTimePlus($input, $timezone, $format);
+ $this->assertNotEqual(count($date->errors), 0, "$input contains an invalid day and produces errors.");
+
+ // Test for invalid month.
+ $input = '0000-75-00T15:30:00';
+ $timezone = NULL;
+ $format = 'Y-m-d\TH:i:s';
+ $date = new DateTimePlus($input, $timezone, $format);
+ $this->assertNotEqual(count($date->errors), 0, "$input contains an invalid month and produces errors.");
+
+ // Test for invalid year.
+ $input = '11-08-01T15:30:00';
+ $timezone = NULL;
+ $format = 'Y-m-d\TH:i:s';
+ $date = new DateTimePlus($input, $timezone, $format);
+ $this->assertNotEqual(count($date->errors), 0, "$input contains an invalid year and produces errors.");
+
+ // Test for invalid year from date array. 10000 as a year will
+ // create an exception error in the PHP DateTime object.
+ $input = array('year' => 10000, 'month' => 7, 'day' => 8, 'hour' => 8, 'minute' => 0, 'second' => 0);
+ $timezone = 'America/Chicago';
+ $date = new DateTimePlus($input, $timezone);
+ $this->assertNotEqual(count($date->errors), 0, "array('year' => 10000, 'month' => 7, 'day' => 8, 'hour' => 8, 'minute' => 0, 'second' => 0) contains an invalid year and produces errors.");
+
+ // Test for invalid month from date array.
+ $input = array('year' => 2010, 'month' => 27, 'day' => 8, 'hour' => 8, 'minute' => 0, 'second' => 0);
+ $timezone = 'America/Chicago';
+ $date = new DateTimePlus($input, $timezone);
+ $this->assertNotEqual(count($date->errors), 0, "array('year' => 2010, 'month' => 27, 'day' => 8, 'hour' => 8, 'minute' => 0, 'second' => 0) contains an invalid month and produces errors.");
+
+ // Test for invalid hour from date array.
+ $input = array('year' => 2010, 'month' => 2, 'day' => 28, 'hour' => 80, 'minute' => 0, 'second' => 0);
+ $timezone = 'America/Chicago';
+ $date = new DateTimePlus($input, $timezone);
+ $this->assertNotEqual(count($date->errors), 0, "array('year' => 2010, 'month' => 2, 'day' => 28, 'hour' => 80, 'minute' => 0, 'second' => 0) contains an invalid hour and produces errors.");
+
+ // Test for invalid minute from date array.
+ $input = array('year' => 2010, 'month' => 7, 'day' => 8, 'hour' => 8, 'minute' => 88, 'second' => 0);
+ $timezone = 'America/Chicago';
+ $date = new DateTimePlus($input, $timezone);
+ $this->assertNotEqual(count($date->errors), 0, "array('year' => 2010, 'month' => 7, 'day' => 8, 'hour' => 8, 'minute' => 88, 'second' => 0) contains an invalid minute and produces errors.");
+
+ }
+
+ /**
+ * Test that DrupalDateTime can detect the right timezone to use.
+ * When specified or not.
+ */
+ public function testDateTimezone() {
+ global $user;
+
+ $date_string = '2007-01-31 21:00:00';
+
+ // Detect the system timezone.
+ $system_timezone = date_default_timezone_get();
+
+ // Create a date object with an unspecified timezone, which should
+ // end up using the system timezone.
+ $date = new DateTimePlus($date_string);
+ $timezone = $date->getTimezone()->getName();
+ $this->assertTrue($timezone == $system_timezone, 'DateTimePlus uses the system timezone when there is no site timezone.');
+
+ // Create a date object with a specified timezone name.
+ $date = new DateTimePlus($date_string, 'America/Yellowknife');
+ $timezone = $date->getTimezone()->getName();
+ $this->assertTrue($timezone == 'America/Yellowknife', 'DateTimePlus uses the specified timezone if provided.');
+
+ // Create a date object with a timezone object.
+ $date = new DateTimePlus($date_string, new \DateTimeZone('Australia/Canberra'));
+ $timezone = $date->getTimezone()->getName();
+ $this->assertTrue($timezone == 'Australia/Canberra', 'DateTimePlus uses the specified timezone if provided.');
+
+ // Create a date object with another date object.
+ $new_date = new DateTimePlus('now', 'Pacific/Midway');
+ $date = new DateTimePlus($new_date);
+ $timezone = $date->getTimezone()->getName();
+ $this->assertTrue($timezone == 'Pacific/Midway', 'DateTimePlus uses the specified timezone if provided.');
+
+ }
+
+ /**
+ * Tear down after tests.
+ */
+ public function tearDown() {
+ variable_del('date_first_day');
+ parent::tearDown();
+ }
+}
diff --git a/core/modules/system/lib/Drupal/system/Tests/Datetime/DrupalDateTimeTest.php b/core/modules/system/lib/Drupal/system/Tests/Datetime/DrupalDateTimeTest.php
new file mode 100644
index 0000000..ea10896
--- /dev/null
+++ b/core/modules/system/lib/Drupal/system/Tests/Datetime/DrupalDateTimeTest.php
@@ -0,0 +1,110 @@
+ 'DrupalDateTime',
+ 'description' => 'Test DrupalDateTime functionality.',
+ 'group' => 'Datetime',
+ );
+ }
+
+ /**
+ * Set up required modules.
+ */
+ public static $modules = array();
+
+ /**
+ * Test setup.
+ */
+ public function setUp() {
+ parent::setUp();
+
+ }
+
+ /**
+ * Test that DrupalDateTime can detect the right timezone to use.
+ * Test with a variety of less commonly used timezone names to
+ * help ensure that the system timezone will be different than the
+ * stated timezones.
+ */
+ public function testDateTimezone() {
+ global $user;
+
+ $date_string = '2007-01-31 21:00:00';
+
+ // Make sure no site timezone has been set.
+ variable_set('date_default_timezone', NULL);
+ variable_set('configurable_timezones', 0);
+
+ // Detect the system timezone.
+ $system_timezone = date_default_timezone_get();
+
+ // Create a date object with an unspecified timezone, which should
+ // end up using the system timezone.
+ $date = new DrupalDateTime($date_string);
+ $timezone = $date->getTimezone()->getName();
+ $this->assertTrue($timezone == $system_timezone, 'DrupalDateTime uses the system timezone when there is no site timezone.');
+
+ // Create a date object with a specified timezone.
+ $date = new DrupalDateTime($date_string, 'America/Yellowknife');
+ $timezone = $date->getTimezone()->getName();
+ $this->assertTrue($timezone == 'America/Yellowknife', 'DrupalDateTime uses the specified timezone if provided.');
+
+ // Set a site timezone.
+ variable_set('date_default_timezone', 'Europe/Warsaw');
+
+ // Create a date object with an unspecified timezone, which should
+ // end up using the site timezone.
+ $date = new DrupalDateTime($date_string);
+ $timezone = $date->getTimezone()->getName();
+ $this->assertTrue($timezone == 'Europe/Warsaw', 'DrupalDateTime uses the site timezone if provided.');
+
+ // Create user.
+ variable_set('configurable_timezones', 1);
+ $test_user = $this->drupalCreateUser(array());
+ $this->drupalLogin($test_user);
+
+ // Set up the user with a different timezone than the site.
+ $edit = array('mail' => $test_user->mail, 'timezone' => 'Asia/Manila');
+ $this->drupalPost('user/' . $test_user->uid . '/edit', $edit, t('Save'));
+
+ // Disable session saving as we are about to modify the global $user.
+ drupal_save_session(FALSE);
+ // Save the original user and then replace it with the test user.
+ $real_user = $user;
+ $user = user_load($test_user->uid, TRUE);
+
+ // Simulate a Drupal bootstrap with the logged-in user.
+ date_default_timezone_set(drupal_get_user_timezone());
+
+ // Create a date object with an unspecified timezone, which should
+ // end up using the user timezone.
+
+ $date = new DrupalDateTime($date_string);
+ $timezone = $date->getTimezone()->getName();
+ $this->assertTrue($timezone == 'Asia/Manila', 'DrupalDateTime uses the user timezone, if configurable timezones are used and it is set.');
+
+ // Restore the original user, and enable session saving.
+ $user = $real_user;
+ // Restore default time zone.
+ date_default_timezone_set(drupal_get_user_timezone());
+ drupal_save_session(TRUE);
+
+
+ }
+}
diff --git a/core/modules/system/lib/Drupal/system/Tests/TypedData/TypedDataTest.php b/core/modules/system/lib/Drupal/system/Tests/TypedData/TypedDataTest.php
index 62bd35e..66a4272 100644
--- a/core/modules/system/lib/Drupal/system/Tests/TypedData/TypedDataTest.php
+++ b/core/modules/system/lib/Drupal/system/Tests/TypedData/TypedDataTest.php
@@ -8,7 +8,7 @@
namespace Drupal\system\Tests\TypedData;
use Drupal\simpletest\WebTestBase;
-use DateTime;
+use Drupal\Core\Datetime\DrupalDateTime;
use DateInterval;
/**
@@ -72,7 +72,7 @@ public function testGetAndSet() {
$this->assertNull($wrapper->getValue(), 'Float wrapper is null-able.');
// Date type.
- $value = new DateTime('@' . REQUEST_TIME);
+ $value = new DrupalDateTime();
$wrapper = $this->createTypedData(array('type' => 'date'), $value);
$this->assertTrue($wrapper->getValue() === $value, 'Date value was fetched.');
$new_value = REQUEST_TIME + 1;
diff --git a/core/modules/system/system.admin.inc b/core/modules/system/system.admin.inc
index c55289c..9d365df 100644
--- a/core/modules/system/system.admin.inc
+++ b/core/modules/system/system.admin.inc
@@ -1861,6 +1861,11 @@ function system_regional_settings() {
// Date settings:
$zones = system_time_zones();
+ // Get calendar information.
+ $calendar_type = config('system.calendar')->get('calendar');
+ $calendar_plugin = new \Drupal\Core\Datetime\Plugin\DateCalendar();
+ $calendar = $calendar_plugin->createInstance($calendar_type);
+
$form['locale'] = array(
'#type' => 'fieldset',
'#title' => t('Locale'),
@@ -1875,11 +1880,23 @@ function system_regional_settings() {
'#attributes' => array('class' => array('country-detect')),
);
+ // Find out what calendar systems are available.
+ foreach ($calendar_plugin->getDefinitions() as $name => $definition) {
+ $options[$name] = $definition['label'];
+ }
+ $form['locale']['calendar'] = array(
+ '#type' => 'select',
+ '#title' => t('Default calendar system'),
+ '#default_value' => $calendar_type,
+ '#options' => $options,
+ );
+
+ // Get a list of day names using the site calendar.
$form['locale']['date_first_day'] = array(
'#type' => 'select',
'#title' => t('First day of week'),
'#default_value' => variable_get('date_first_day', 0),
- '#options' => array(0 => t('Sunday'), 1 => t('Monday'), 2 => t('Tuesday'), 3 => t('Wednesday'), 4 => t('Thursday'), 5 => t('Friday'), 6 => t('Saturday')),
+ '#options' => $calendar->week_days(TRUE),
);
$form['timezone'] = array(
@@ -1930,10 +1947,23 @@ function system_regional_settings() {
'#description' => t('Only applied if users may set their own time zone.')
);
+ $form['#submit'][] = 'system_calendar_settings_submit';
+
return system_settings_form($form);
}
/**
+ * Form submission handler for system_calendar_settings().
+ *
+ * @ingroup forms
+ */
+function system_calendar_settings_submit($form, &$form_state) {
+ $config = config('system.calendar');
+ $config->set('calendar', $form_state['values']['calendar']);
+ $config->save();
+}
+
+/**
* Form builder; Configure the site date and time settings.
*
* @ingroup forms
diff --git a/core/modules/system/system.api.php b/core/modules/system/system.api.php
index a9a2e17..32df69f 100644
--- a/core/modules/system/system.api.php
+++ b/core/modules/system/system.api.php
@@ -147,6 +147,34 @@ function hook_cron() {
}
/**
+ * Defines available calendar system information.
+ *
+ * Drupal provides a pluggable system for defining the calendar
+ * system used when displaying dates and date parts. Modules that provide
+ * information about calendar systems other than Gregorian can
+ * implement this hook and identify the calendar system being added
+ * and the values for days, weeks, and months in that system.
+ *
+ * @return array
+ * An associative array where the key is the calendar name and the value is
+ * again an associative array. Supported keys are:
+ * - label: The human readable label of the calendar system.
+ * - class: The associated calendar class. Must implement
+ * \Drupal\Core\Datetime\Plugin\DateCalendarInterface.
+ *
+ * @see system_calendar()
+ * @see \Drupal\Date\Datetime\Plugin\Type\Gregorian
+ */
+function hook_date_calendar_info() {
+ return array(
+ 'gregorian' => array(
+ 'label' => t('Gregorian'),
+ 'class' => '\Drupal\Core\Datetime\Plugin\Type\Gregorian',
+ ),
+ );
+}
+
+/**
* Defines available data types for the typed data API.
*
* The typed data API allows modules to support any kind of data based upon
diff --git a/core/modules/system/system.module b/core/modules/system/system.module
index ea3dadc..ae40560 100644
--- a/core/modules/system/system.module
+++ b/core/modules/system/system.module
@@ -480,11 +480,27 @@ function system_element_info() {
);
$types['date'] = array(
'#input' => TRUE,
- '#element_validate' => array('date_validate'),
- '#process' => array('form_process_date'),
'#theme' => 'date',
'#theme_wrappers' => array('form_element'),
);
+ $types['datetime'] = array(
+ '#input' => TRUE,
+ '#element_validate' => array('datetime_validate'),
+ '#process' => array('form_process_datetime'),
+ '#value_callback' => 'datetime_value_callback',
+ '#theme' => 'form_datetime',
+ '#theme_wrappers' => array('form_element'),
+ '#date_date_format' => variable_get('date_format_html_date', 'Y-m-d'),
+ '#date_date_element' => 'date',
+ '#date_date_callbacks' => array('datetime_jquery_datepicker'),
+ '#date_time_format' => variable_get('date_format_html_time', 'H:i:s'),
+ '#date_time_element' => 'time',
+ '#date_time_callbacks' => array(),
+ '#date_year_range' => '1900:2050',
+ '#date_increment' => 1,
+ '#date_timezone' => '',
+ '#date_calendar' => 'gregorian',
+ );
$types['file'] = array(
'#input' => TRUE,
'#size' => 60,
@@ -1932,7 +1948,21 @@ function system_library_info() {
array('system', 'drupalSettings'),
),
);
-
+ $libraries['drupal.datepicker'] = array(
+ 'title' => 'Drupal datepicker',
+ 'version' => VERSION,
+ 'js' => array(
+ 'core/misc/datepicker.js' => array(),
+ ),
+ 'dependencies' => array(
+ array('system', 'jquery'),
+ array('system', 'jquery.ui.core'),
+ array('system', 'jquery.ui.datepicker'),
+ array('system', 'jquery.once'),
+ array('system', 'drupal'),
+ array('system', 'drupalSettings'),
+ ),
+ );
$libraries['drupal.system'] = array(
'title' => 'System',
'version' => VERSION,
@@ -1995,6 +2025,42 @@ function system_stream_wrappers() {
}
/**
+ * Implements hook_date_calendar_info().
+ */
+function system_date_calendar_info() {
+ return array(
+ 'gregorian' => array(
+ 'label' => t('Gregorian'),
+ 'class' => '\Drupal\Core\Datetime\Plugin\Type\Gregorian',
+ ),
+ );
+}
+
+/**
+* Get system calendar information and store for future use.
+*/
+function system_calendar($calendar = NULL) {
+ // Use the advanced drupal_static() pattern, since this could
+ // be called very often.
+ static $drupal_static_fast;
+ if (!isset($drupal_static_fast)) {
+ $drupal_static_fast['calendars'] = &drupal_static(__FUNCTION__);
+ }
+ $calendars = &$drupal_static_fast['calendars'];
+
+ if (!isset($calendar)) {
+ $calendar = config('system.calendar')->get('calendar');
+ }
+ // Store Calendar objects in an array rather than repeatedly
+ // constructing identical objects over the life of a request.
+ if (!isset($calendars[$calendar])) {
+ $plugin = new \Drupal\Core\Datetime\Plugin\DateCalendar();
+ $calendars[$calendar] = $plugin->createInstance($calendar);
+ }
+ return $calendars[$calendar];
+}
+
+/**
* Implements hook_data_type_info().
*/
function system_data_type_info() {
diff --git a/core/modules/system/tests/modules/datetime_test/datetime_test.info b/core/modules/system/tests/modules/datetime_test/datetime_test.info
new file mode 100644
index 0000000..127781f
--- /dev/null
+++ b/core/modules/system/tests/modules/datetime_test/datetime_test.info
@@ -0,0 +1,6 @@
+name = "Datetime Test"
+description = "Support module for Datetime tests."
+core = 8.x
+package = Testing
+version = VERSION
+hidden = TRUE
diff --git a/core/modules/system/tests/modules/datetime_test/datetime_test.module b/core/modules/system/tests/modules/datetime_test/datetime_test.module
new file mode 100644
index 0000000..77f564b
--- /dev/null
+++ b/core/modules/system/tests/modules/datetime_test/datetime_test.module
@@ -0,0 +1,19 @@
+ array(
+ 'label' => t('Gamma'),
+ 'class' => '\Drupal\datetime_test\Gamma',
+ ),
+ );
+}
+
diff --git a/core/modules/system/tests/modules/datetime_test/lib/Drupal/datetime_test/Gamma.php b/core/modules/system/tests/modules/datetime_test/lib/Drupal/datetime_test/Gamma.php
new file mode 100644
index 0000000..b817d3e
--- /dev/null
+++ b/core/modules/system/tests/modules/datetime_test/lib/Drupal/datetime_test/Gamma.php
@@ -0,0 +1,284 @@
+ 'Alpha',
+ 2 => 'Beta',
+ 3 => 'Gamma',
+ 4 => 'Delta',
+ );
+ }
+
+ /**
+ * Constructs a translated array of month name abbreviations
+ *
+ * @param bool $required
+ * (optional) If FALSE, the returned array will include a blank value.
+ * Defaults to FALSE.
+ *
+ * @return array
+ * An array of month abbreviations.
+ */
+ public static function month_names_abbr($required = FALSE) {}
+
+ /**
+ * Returns a translated array of week names.
+ *
+ * @param bool $required
+ * (optional) If FALSE, the returned array will include a blank value.
+ * Defaults to FALSE.
+ *
+ * @return array
+ * An array of week day names
+ */
+ public static function week_days($required = FALSE) {}
+
+ /**
+ * Constructs a translated array of week day abbreviations.
+ *
+ * @param bool $required
+ * (optional) If FALSE, the returned array will include a blank value.
+ * Defaults to FALSE.
+ *
+ * @return array
+ * An array of week day abbreviations
+ */
+ public static function week_days_abbr($required = FALSE) {}
+
+ /**
+ * Constructs a translated array of 2-letter week day abbreviations.
+ *
+ * @param bool $required
+ * (optional) If FALSE, the returned array will include a blank value.
+ * Defaults to FALSE.
+ *
+ * @return array
+ * An array of week day 2 letter abbreviations
+ */
+ public static function week_days_abbr2($required = FALSE) {}
+
+ /**
+ * Constructs a translated array of 1-letter week day abbreviations.
+ *
+ * @param bool $required
+ * (optional) If FALSE, the returned array will include a blank value.
+ * Defaults to FALSE.
+ *
+ * @return array
+ * An array of week day 1 letter abbreviations
+ */
+ public static function week_days_abbr1($required = FALSE) {}
+
+ /**
+ * Reorders weekdays to match the first day of the week.
+ *
+ * @param array $weekdays
+ * An array of weekdays.
+ *
+ * @return array
+ * An array of weekdays reordered to match the first day of the week.
+ */
+ public static function week_days_ordered($weekdays) {}
+
+ /**
+ * Constructs an array of years in a specified range.
+ *
+ * @param int $min
+ * The minimum year in the array.
+ * @param int $max
+ * The maximum year in the array.
+ * @param bool $required
+ * (optional) If FALSE, the returned array will include a blank value.
+ * Defaults to FALSE.
+ *
+ * @return array
+ * An array of years in the selected range.
+ */
+ public static function years($min = 0, $max = 0, $required = FALSE) {}
+
+ /**
+ * Constructs an array of days in a month.
+ *
+ * @param bool $required
+ * (optional) If FALSE, the returned array will include a blank value.
+ * Defaults to FALSE.
+ * @param int $month
+ * (optional) The month in which to find the number of days.
+ * @param int $year
+ * (optional) The year in which to find the number of days.
+ *
+ * @return array
+ * An array of days for the selected month.
+ */
+ public static function days($required = FALSE, $month = NULL, $year = NULL) {}
+
+ /**
+ * Constructs an array of hours.
+ *
+ * @param string $format
+ * A date format string that indicates the format to use for the hours.
+ * @param bool $required
+ * (optional) If FALSE, the returned array will include a blank value.
+ * Defaults to FALSE.
+ *
+ * @return array
+ * An array of hours in the selected format.
+ */
+ public static function hours($format = 'H', $required = FALSE) {}
+
+ /**
+ * Constructs an array of minutes.
+ *
+ * @param string $format
+ * A date format string that indicates the format to use for the minutes.
+ * @param bool $required
+ * (optional) If FALSE, the returned array will include a blank value.
+ * Defaults to FALSE.
+ * @param int $increment
+ * A the integer value to increment the values. Defaults to 1.
+ *
+ * @return array
+ * An array of minutes in the selected format.
+ */
+ public static function minutes($format = 'i', $required = FALSE, $increment = 1) {}
+
+ /**
+ * Constructs an array of seconds.
+ *
+ * @param string $format
+ * A date format string that indicates the format to use for the seconds.
+ * @param bool $required
+ * (optional) If FALSE, the returned array will include a blank value.
+ * Defaults to FALSE.
+ * @param int $increment
+ * A the integer value to increment the values. Defaults to 1.
+ *
+ * @return array
+ * An array of seconds in the selected format.
+ */
+ public static function seconds($format = 's', $required = FALSE, $increment = 1) {}
+
+ /**
+ * Constructs an array of AM and PM options.
+ *
+ * @param bool $required
+ * (optional) If FALSE, the returned array will include a blank value.
+ * Defaults to FALSE.
+ *
+ * @return array
+ * An array of AM and PM options.
+ */
+ public static function ampm($required = FALSE) {}
+
+ /**
+ * Identifies the number of days in a month for a date.
+ *
+ * @param mixed $date
+ * (optional) A date object, timestamp, or a date string.
+ * Defaults to current date.
+ *
+ * @return integer
+ * The number of days in the month.
+ */
+ public static function days_in_month($date = NULL) {}
+
+ /**
+ * Identifies the number of days in a year for a date.
+ *
+ * @param mixed $date
+ * (optional) A date object, timestamp, or a date string.
+ * Defaults to current date.
+ *
+ * @return integer
+ * The number of days in the year.
+ */
+ public static function days_in_year($date = NULL) {}
+
+ /**
+ * Returns day of week for a given date (0 = Sunday).
+ *
+ * @param mixed $date
+ * (optional) A date object, timestamp, or a date string.
+ * Defaults to current date.
+ *
+ * @return int
+ * The number of the day in the week.
+ */
+ public static function day_of_week($date = NULL) {}
+
+ /**
+ * Returns translated name of the day of week for a given date.
+ *
+ * @param mixed $date
+ * (optional) A date object, timestamp, or a date string.
+ * Defaults to current date.
+ * @param string $abbr
+ * (optional) Whether to return the abbreviated name for that day.
+ * Defaults to TRUE.
+ *
+ * @return string
+ * The name of the day in the week for that date.
+ */
+ public static function day_of_week_name($date = NULL, $abbr = TRUE) {}
+
+}