FieldDate

Complexity

Total Complexity

122

Size/Duplication

Total Lines	801
Duplicated Lines	0 %

Importance

Changes	8
Bugs	0	Features	0

32 Methods

Rating	Name	Duplication	Size	Complexity
A	createTable()	0	4	1
A	canPrePopulate()	0	3	1
A	isSortable()	0	3	1
A	fetchSuggestionTypes()	0	3	1
A	findDefaults()	0	4	2
A	getParameterPoolValue()	0	3	1
A	canFilter()	0	3	1
A	allowDatasourceParamOutput()	0	3	1
A	allowDatasourceOutputGrouping()	0	3	1
A	buildSortingSelectSQL()	0	3	1
A	fetchFilterableOperators()	0	47	1
A	formatDate()	0	8	2
B	buildRangeFilterSQL()	0	34	9
A	appendFormattedElement()	0	12	3
A	commit()	0	19	6
B	processRawFieldData()	0	30	7
B	groupRecords()	0	41	8
B	parseDate()	0	57	9
B	prepareExportValue()	0	28	7
A	getExportModes()	0	6	1
A	getImportModes()	0	5	1
A	buildSortingSQL()	0	15	2
A	cleanFilterString()	0	5	1
A	checkPostFieldData()	0	19	5
B	prepareImportValue()	0	33	9
A	__construct()	0	10	1
C	parseFilter()	0	83	16
A	isEqualTo()	0	13	3
B	displayPublishPanel()	0	53	9
B	buildDSRetrievalSQL()	0	30	7
A	displaySettingsPanel()	0	20	2
A	prepareTextValue()	0	9	2

<?php

/**
 * @package toolkit
 */

/**
 * A simple Date field that stores a full ISO date. Symphony will attempt
 * to localize the date on a per Author basis. The field essentially maps to
 * PHP's `strtotime`, so it is very flexible in terms of what an Author can
 * input into it.
 */
class FieldDate extends Field implements ExportableField, ImportableField
{
    const SIMPLE = 0;
    const REGEXP = 1;
    const RANGE = 3;
    const ERROR = 4;

    private $key;

    protected static $min_date = '1000-01-01 00:00:00';
    protected static $max_date = '9999-12-31 23:59:59';

    public function __construct()
    {
        parent::__construct();
        $this->_name = __('Date');

The property _name does not exist. Although not strictly required by PHP, it is generally a best practice to declare properties explicitly.

        $this->_required = true;
        $this->key = 1;

        $this->set('pre_populate', 'now');
        $this->set('required', 'no');
        $this->set('location', 'sidebar');
    }

    /*-------------------------------------------------------------------------
        Definition:
    -------------------------------------------------------------------------*/

    public function canFilter()
    {
        return true;
    }

    public function isSortable()
    {
        return true;
    }

    public function canPrePopulate()
    {
        return true;
    }

    public function allowDatasourceOutputGrouping()
    {
        return true;
    }

    public function allowDatasourceParamOutput()
    {
        return true;
    }

    public function fetchFilterableOperators()
    {
        return array(
            array(
                'title' => 'is',
                'filter' => ' ',
                'help' => __('Find values that are an exact match for the given string.')
            ),
            array(
                'filter' => 'sql: NOT NULL',
                'title' => 'is not empty',
                'help' => __('Find entries where any value is selected.')
            ),
            array(
                'filter' => 'sql: NULL',
                'title' => 'is empty',
                'help' => __('Find entries where no value is selected.')
            ),
            array(
                'title' => 'contains',
                'filter' => 'regexp: ',
                'help' => __('Find values that match the given <a href="%s">MySQL regular expressions</a>.', array(
                    'https://dev.mysql.com/doc/mysql/en/regexp.html'
                ))
            ),
            array(
                'title' => 'does not contain',
                'filter' => 'not-regexp: ',
                'help' => __('Find values that do not match the given <a href="%s">MySQL regular expressions</a>.', array(
                    'https://dev.mysql.com/doc/mysql/en/regexp.html'
                ))
            ),
            array(
                'title' => 'later than',
                'filter' => 'later than '
            ),
            array(
                'title' => 'earlier than',
                'filter' => 'earlier than '
            ),
            array(
                'title' => 'equal to or later than',
                'filter' => 'equal to or later than '
            ),
            array(
                'title' => 'equal to or earlier than',
                'filter' => 'equal to or earlier than '
            ),
        );
    }

    public function fetchSuggestionTypes()
    {
        return array('date');
    }

    /*-------------------------------------------------------------------------
        Setup:
    -------------------------------------------------------------------------*/

    public function createTable()
    {
        return Symphony::Database()->query(
            "CREATE TABLE IF NOT EXISTS `tbl_entries_data_" . $this->get('id') . "` (

The string literal CREATE TABLE IF NOT EXISTS `tbl_entries_data_ does not require double quotes, as per coding-style, please use single quotes.

The string literal ` (\n `id` int(11) unsigned NOT null auto_increment,\n `entry_id` int(11) unsigned NOT null,\n `value` varchar(80) default null,\n `date` DATETIME default null,\n PRIMARY KEY (`id`),\n UNIQUE KEY `entry_id` (`entry_id`),\n KEY `value` (`value`),\n KEY `date` (`date`)\n ) ENGINE=MyISAM DEFAULT CHARSET=utf8 COLLATE=utf8_unicode_ci; does not require double quotes, as per coding-style, please use single quotes.

Are you sure $this->get('id') of type array|mixed|null can be used in concatenation?

              `id` int(11) unsigned NOT null auto_increment,
              `entry_id` int(11) unsigned NOT null,
              `value` varchar(80) default null,
              `date` DATETIME default null,
              PRIMARY KEY  (`id`),
              UNIQUE KEY `entry_id` (`entry_id`),
              KEY `value` (`value`),
              KEY `date` (`date`)
            ) ENGINE=MyISAM DEFAULT CHARSET=utf8 COLLATE=utf8_unicode_ci;"
        );
    }

    /*-------------------------------------------------------------------------
        Utilities:
    -------------------------------------------------------------------------*/

    /**
     * Given a string, this function builds the range of dates that match it.
     * The strings should be in ISO8601 style format, or a natural date, such
     * as 'last week' etc.
     *
     * @since Symphony 2.2.2
     * @param array $string
     *  The date string to be parsed
     * @param string $direction
     *  Either later or earlier, defaults to null.
     * @param boolean $equal_to
     *  If the filter is equal_to or not, defaults to false.
     * @return array
     *  An associative array containing a date in ISO8601 format (or natural)
     *  with two keys, start and end.
     */
    public static function parseDate($string, $direction = null, $equal_to = false)

Incorrect spacing between argument "$direction" and equals sign; expected 0 but found 1

Incorrect spacing between default value and equals sign for argument "$direction"; expected 0 but found 1

Incorrect spacing between argument "$equal_to" and equals sign; expected 0 but found 1

Incorrect spacing between default value and equals sign for argument "$equal_to"; expected 0 but found 1

    {
        $parts = array(
            'start' => null,
            'end' => null
        );

        // Year
        if (preg_match('/^\d{1,4}$/', $string, $matches)) {

$string of type array is incompatible with the type string expected by parameter $subject of preg_match().

            $year = current($matches);

            $parts['start'] = "$year-01-01 00:00:00";

As per coding-style, please use concatenation or sprintf for the variable $year instead of interpolation.

            $parts['end'] = "$year-12-31 23:59:59";

As per coding-style, please use concatenation or sprintf for the variable $year instead of interpolation.

            $parts = self::isEqualTo($parts, $direction, $equal_to);

            // Year/Month/Day/Time
        } elseif (preg_match('/^\d{1,4}[-\/]\d{1,2}[-\/]\d{1,2}\s\d{1,2}:\d{2}/', $string, $matches)) {
            // Handles the case of `to` filters
            if ($equal_to || is_null($direction)) {
                $parts['start'] = $parts['end'] = DateTimeObj::get('Y-m-d H:i:s', $string);

$string of type array is incompatible with the type null|string expected by parameter $timestamp of DateTimeObj::get().

            } else {
                $parts['start'] = DateTimeObj::get('Y-m-d H:i:s', $string . ' - 1 second');

Are you sure $string of type array can be used in concatenation?

                $parts['end'] = DateTimeObj::get('Y-m-d H:i:s', $string . ' + 1 second');
            }

            // Year/Month/Day
        } elseif (preg_match('/^\d{1,4}[-\/]\d{1,2}[-\/]\d{1,2}$/', $string, $matches)) {
            $year_month_day = current($matches);

            $parts['start'] = "$year_month_day 00:00:00";

As per coding-style, please use concatenation or sprintf for the variable $year_month_day instead of interpolation.

            $parts['end'] = "$year_month_day 23:59:59";

As per coding-style, please use concatenation or sprintf for the variable $year_month_day instead of interpolation.

            $parts = self::isEqualTo($parts, $direction, $equal_to);

            // Year/Month
        } elseif (preg_match('/^\d{1,4}[-\/]\d{1,2}$/', $string, $matches)) {
            $year_month = current($matches);

            $parts['start'] = "$year_month-01 00:00:00";

As per coding-style, please use concatenation or sprintf for the variable $year_month instead of interpolation.

            $parts['end'] = DateTimeObj::get('Y-m-t', $parts['start']) . " 23:59:59";

Are you sure DateTimeObj::get('Y-m-t', $parts['start']) of type false|string can be used in concatenation?

The string literal 23:59:59 does not require double quotes, as per coding-style, please use single quotes.

            $parts = self::isEqualTo($parts, $direction, $equal_to);

            // Relative date, aka '+ 3 weeks'
        } else {
            // Handles the case of `to` filters

            if ($equal_to || is_null($direction)) {
                $parts['start'] = $parts['end'] = DateTimeObj::get('Y-m-d H:i:s', $string);
            } else {
                $parts['start'] = DateTimeObj::get('Y-m-d H:i:s', $string . ' - 1 second');
                $parts['end'] = DateTimeObj::get('Y-m-d H:i:s', $string . ' + 1 second');
            }
        }

        return $parts;
    }

    /**
     * Builds the correct date array depending if the filter should include
     * the filter as well, ie. later than 2011, is effectively the same as
     * equal to or later than 2012.
     *
     * @since Symphony 2.2.2
     * @param array $parts
     *  An associative array containing a date in ISO8601 format (or natural)
     *  with two keys, start and end.
     * @param string $direction
     *  Either later or earlier, defaults to null.
     * @param boolean $equal_to
     *  If the filter is equal_to or not, defaults to false.
     * @return array
     */
    public static function isEqualTo(array $parts, $direction, $equal_to = false)

Incorrect spacing between argument "$equal_to" and equals sign; expected 0 but found 1

Incorrect spacing between default value and equals sign for argument "$equal_to"; expected 0 but found 1

    {
        if (!$equal_to) {
            return $parts;
        }

        if ($direction == 'later') {
            $parts['end'] = $parts['start'];
        } else {
            $parts['start'] = $parts['end'];
        }

        return $parts;
    }

    public static function parseFilter(&$string)
    {
        $string = self::cleanFilterString($string);

        // Relative check, earlier or later
        if (preg_match('/^(equal to or )?(earlier|later) than (.*)$/i', $string, $match)) {
            $string = $match[3];

            // Validate date
            if (!DateTimeObj::validate($string)) {
                return self::ERROR;
            }

            // Date is equal to or earlier/later than
            // Date is earlier/later than
            $parts = self::parseDate($string, $match[2], $match[1] == "equal to or ");

The string literal equal to or does not require double quotes, as per coding-style, please use single quotes.

            $earlier = $parts['start'];
            $later = $parts['end'];

            // Switch between earlier than and later than logic
            // The earlier/later range is defined by MySQL's support. RE: #1560
            // @link https://dev.mysql.com/doc/refman/en/datetime.html
            switch ($match[2]) {
                case 'later':
                    $string = $later . ' to ' . self::$max_date;
                    break;
                case 'earlier':
                    $string = self::$min_date . ' to ' . $earlier;
                    break;
            }

            // Look to see if its a shorthand date (year only), and convert to full date
            // Look to see if the give date is a shorthand date (year and month) and convert it to full date
            // Match single dates
        } elseif (

Expected 0 spaces after opening bracket; newline found

            preg_match('/^(1|2)\d{3}$/i', $string)
            || preg_match('/^(1|2)\d{3}[-\/]\d{1,2}$/i', $string)
            || !preg_match('/\s+to\s+/i', $string)
        ) {
            // Validate
            if (!DateTimeObj::validate($string)) {
                return self::ERROR;
            }

            $parts = self::parseDate($string);

$string of type string is incompatible with the type array expected by parameter $string of FieldDate::parseDate().

            $string = $parts['start'] . ' to ' . $parts['end'];

            // Match date ranges
        } elseif (preg_match('/\s+to\s+/i', $string)) {
            if (!$parts = preg_split('/\s+to\s+/', $string, 2, PREG_SPLIT_NO_EMPTY)) {
                return self::ERROR;
            }

            foreach ($parts as $i => &$part) {
                // Validate
                if (!DateTimeObj::validate($part)) {
                    return self::ERROR;
                }

                $part = self::parseDate($part);
            }

            $string = $parts[0]['start'] . " to " . $parts[1]['end'];

The string literal to does not require double quotes, as per coding-style, please use single quotes.

        }

        // Parse the full date range and return an array
        if (!$parts = preg_split('/\s+to\s+/i', $string, 2, PREG_SPLIT_NO_EMPTY)) {
            return self::ERROR;
        }

        $parts = array_map(array('self', 'cleanFilterString'), $parts);

        list($start, $end) = $parts;

        // Validate
        if (!DateTimeObj::validate($start) || !DateTimeObj::validate($end)) {
            return self::ERROR;
        }

        $string = array('start' => $start, 'end' => $end);

        return self::RANGE;
    }

    public static function cleanFilterString($string)
    {
        $string = trim($string, ' -/');

        return urldecode($string);
    }

    public function buildRangeFilterSQL($data, &$joins, &$where, $andOperation = false)

Incorrect spacing between argument "$andOperation" and equals sign; expected 0 but found 1

Incorrect spacing between default value and equals sign for argument "$andOperation"; expected 0 but found 1

    {
        $field_id = $this->get('id');

        if (empty($data)) {
            return;
        }

        if ($andOperation) {
            foreach ($data as $date) {
                // Prevent the DateTimeObj creating a range that isn't supported by MySQL.
                $start = ($date['start'] === self::$min_date) ? self::$min_date : DateTimeObj::getGMT('Y-m-d H:i:s', $date['start']);
                $end = ($date['end'] === self::$max_date) ? self::$max_date : DateTimeObj::getGMT('Y-m-d H:i:s', $date['end']);

                $joins .= " LEFT JOIN `tbl_entries_data_$field_id` AS `t$field_id".$this->key."` ON `e`.`id` = `t$field_id".$this->key."`.entry_id ";

As per coding-style, please use concatenation or sprintf for the variable $field_id instead of interpolation.

The string literal `.entry_id does not require double quotes, as per coding-style, please use single quotes.

                $where .= " AND (`t$field_id".$this->key."`.date >= '" . $start . "' AND `t$field_id".$this->key."`.date <= '" . $end . "') ";

As per coding-style, please use concatenation or sprintf for the variable $field_id instead of interpolation.

                $this->key++;
            }
        } else {
            $tmp = array();

            foreach ($data as $date) {
                // Prevent the DateTimeObj creating a range that isn't supported by MySQL.
                $start = ($date['start'] === self::$min_date) ? self::$min_date : DateTimeObj::getGMT('Y-m-d H:i:s', $date['start']);
                $end = ($date['end'] === self::$max_date) ? self::$max_date : DateTimeObj::getGMT('Y-m-d H:i:s', $date['end']);

                $tmp[] = "`t$field_id".$this->key."`.date >= '" . $start . "' AND `t$field_id".$this->key."`.date <= '" . $end . "' ";

As per coding-style, please use concatenation or sprintf for the variable $field_id instead of interpolation.

            }

            $joins .= " LEFT JOIN `tbl_entries_data_$field_id` AS `t$field_id".$this->key."` ON `e`.`id` = `t$field_id".$this->key."`.entry_id ";

As per coding-style, please use concatenation or sprintf for the variable $field_id instead of interpolation.

The string literal `.entry_id does not require double quotes, as per coding-style, please use single quotes.

            $where .= " AND (".implode(' OR ', $tmp).") ";

The string literal AND ( does not require double quotes, as per coding-style, please use single quotes.

The string literal ) does not require double quotes, as per coding-style, please use single quotes.

            $this->key++;
        }
    }

    /**
     * Format the $data parameter according to this field's settings.
     *
     * @since Symphony 2.6.0
     * @param array $date
     *  The date to format
     * @return string
     */
    public function formatDate($date)
    {
        // Get format
        $format = 'date_format';
        if ($this->get('time') === 'yes') {
            $format = 'datetime_format';
        }

No blank line found after control structure

        return DateTimeObj::format($date, DateTimeObj::getSetting($format));

The expression return DateTimeObj::format($date, DateTimeObj::getSetting($format)) could also return false which is incompatible with the documented return type string. Did you maybe forget to handle an error condition?

$date of type array is incompatible with the type string expected by parameter $string of DateTimeObj::format().

It seems like DateTimeObj::getSetting($format) can also be of type array; however, parameter $format of DateTimeObj::format() does only seem to accept string, maybe add an additional type check?

    }

    /*-------------------------------------------------------------------------
        Settings:
    -------------------------------------------------------------------------*/

    public function findDefaults(array &$settings)
    {
        if (!isset($settings['pre_populate'])) {
            $settings['pre_populate'] = $this->get('pre_populate');
        }
    }

    public function displaySettingsPanel(XMLElement &$wrapper, $errors = null)

Incorrect spacing between argument "$errors" and equals sign; expected 0 but found 1

Incorrect spacing between default value and equals sign for argument "$errors"; expected 0 but found 1

    {
        parent::displaySettingsPanel($wrapper, $errors);

        // Default date
        $label = Widget::Label(__('Default date'));
        $help = new XMLElement('i', __('optional, accepts absolute or relative dates'));
        $input = Widget::Input('fields['.$this->get('sortorder').'][pre_populate]', $this->get('pre_populate') ? $this->get('pre_populate') : '', 'input');

Are you sure $this->get('sortorder') of type array|mixed|null can be used in concatenation?

It seems like $this->get('pre_populate') ? $this->get('pre_populate') : '' can also be of type array; however, parameter $value of Widget::Input() does only seem to accept string, maybe add an additional type check?

        $label->appendChild($help);
        $label->appendChild($input);
        $wrapper->appendChild($label);

        // Display settings
        $div = new XMLElement('div', null, array('class' => 'two columns'));
        $this->createCheckboxSetting($div, 'time', __('Display time'));
        $this->createCheckboxSetting($div, 'calendar', __('Show calendar'));
        $wrapper->appendChild($div);

        // Requirements and table display
        $this->appendStatusFooter($wrapper);
    }

    public function commit()
    {
        if (!parent::commit()) {
            return false;
        }

        $id = $this->get('id');

        if ($id === false) {
            return false;
        }

        $fields = array();

        $fields['pre_populate'] = ($this->get('pre_populate') ? $this->get('pre_populate') : '');
        $fields['time'] = ($this->get('time') ? $this->get('time') : 'no');
        $fields['calendar'] = ($this->get('calendar') ? $this->get('calendar') : 'no');

        return FieldManager::saveSettings($id, $fields);

It seems like $id can also be of type array; however, parameter $field_id of FieldManager::saveSettings() does only seem to accept integer, maybe add an additional type check?

    }

    /*-------------------------------------------------------------------------
        Publish:
    -------------------------------------------------------------------------*/

    public function displayPublishPanel(XMLElement &$wrapper, $data = null, $flagWithError = null, $fieldnamePrefix = null, $fieldnamePostfix = null, $entry_id = null)

Incorrect spacing between argument "$data" and equals sign; expected 0 but found 1

Incorrect spacing between default value and equals sign for argument "$data"; expected 0 but found 1

Incorrect spacing between argument "$flagWithError" and equals sign; expected 0 but found 1

Incorrect spacing between default value and equals sign for argument "$flagWithError"; expected 0 but found 1

Incorrect spacing between argument "$fieldnamePrefix" and equals sign; expected 0 but found 1

Incorrect spacing between default value and equals sign for argument "$fieldnamePrefix"; expected 0 but found 1

Incorrect spacing between argument "$fieldnamePostfix" and equals sign; expected 0 but found 1

Incorrect spacing between default value and equals sign for argument "$fieldnamePostfix"; expected 0 but found 1

Incorrect spacing between argument "$entry_id" and equals sign; expected 0 but found 1

Incorrect spacing between default value and equals sign for argument "$entry_id"; expected 0 but found 1

    {
        $name = $this->get('element_name');
        $value = null;

        // New entry
        if (empty($data) && is_null($flagWithError) && !is_null($this->get('pre_populate'))) {
            $prepopulate = $this->get('pre_populate');

            $date = self::parseDate($prepopulate);
            $date = $date['start'];
            $value = $this->formatDate($date);

            // Error entry, display original data
        } elseif (!is_null($flagWithError)) {
            $value = $_POST['fields'][$name];

            // Empty entry
        } elseif (isset($data['value'])) {
            $value = $this->formatDate($data['value']);
        }

        $label = Widget::Label($this->get('label'));

It seems like $this->get('label') can also be of type array; however, parameter $name of Widget::Label() does only seem to accept string, maybe add an additional type check?

        if ($this->get('required') !== 'yes') {
            $label->appendChild(new XMLElement('i', __('Optional')));
        }

        // Input
        $label->appendChild(Widget::Input("fields{$fieldnamePrefix}[{$name}]", $value));

As per coding-style, please use concatenation or sprintf for the variable $fieldnamePrefix instead of interpolation.

As per coding-style, please use concatenation or sprintf for the variable $name instead of interpolation.

        $label->setAttribute('class', 'date');

        // Calendar
        if ($this->get('calendar') === 'yes') {
            $wrapper->setAttribute('data-interactive', 'data-interactive');

            $ul = new XMLElement('ul');
            $ul->setAttribute('class', 'suggestions');
            $ul->setAttribute('data-field-id', $this->get('id'));

It seems like $this->get('id') can also be of type array; however, parameter $value of XMLElement::setAttribute() does only seem to accept string, maybe add an additional type check?

            $ul->setAttribute('data-search-types', 'date');

            $calendar = new XMLElement('li');
            $calendar->appendChild(Widget::Calendar(($this->get('time') === 'yes')));
            $ul->appendChild($calendar);

            $label->appendChild($ul);
        }

        // Wrap label in error
        if (!is_null($flagWithError)) {
            $label = Widget::Error($label, $flagWithError);
        }

No blank line found after control structure

        $wrapper->appendChild($label);
    }

    public function checkPostFieldData($data, &$message, $entry_id = null)

Incorrect spacing between argument "$entry_id" and equals sign; expected 0 but found 1

Incorrect spacing between default value and equals sign for argument "$entry_id"; expected 0 but found 1

    {
        $message = null;

        // If this field is required
        if ($this->get('required') === 'yes' && strlen(trim($data)) == 0) {
            $message = __('‘%s’ is a required field.', array($this->get('label')));
            return self::__MISSING_FIELDS__;
        } elseif (empty($data)) {
            return self::__OK__;
        }

        // Handle invalid dates
        if (!DateTimeObj::validate($data)) {
            $message = __('The date specified in ‘%s’ is invalid.', array($this->get('label')));
            return self::__INVALID_FIELDS__;
        }

        return self::__OK__;
    }

    public function processRawFieldData($data, &$status, &$message = null, $simulate = false, $entry_id = null)

Incorrect spacing between argument "$message" and equals sign; expected 0 but found 1

Incorrect spacing between default value and equals sign for argument "$message"; expected 0 but found 1

Incorrect spacing between argument "$simulate" and equals sign; expected 0 but found 1

Incorrect spacing between default value and equals sign for argument "$simulate"; expected 0 but found 1

Incorrect spacing between argument "$entry_id" and equals sign; expected 0 but found 1

Incorrect spacing between default value and equals sign for argument "$entry_id"; expected 0 but found 1

    {
        $status = self::__OK__;
        $timestamp = null;

        // Prepopulate date
        if (is_null($data) || $data == '') {
            if ($this->get('pre_populate') !='') {
                $date = self::parseDate($this->get('pre_populate'));
                $date = $date['start'];
                $timestamp = $this->formatDate($date);
            }

            // Convert given date to timestamp
        } elseif ($status == self::__OK__ && DateTimeObj::validate($data)) {
            $timestamp = DateTimeObj::get('U', $data);
        }

        // Valid date
        if (!is_null($timestamp)) {
            return array(
                'value' => DateTimeObj::get('c', $timestamp),

It seems like $timestamp can also be of type false; however, parameter $timestamp of DateTimeObj::get() does only seem to accept null|string, maybe add an additional type check?

                'date' => DateTimeObj::getGMT('Y-m-d H:i:s', $timestamp)

It seems like $timestamp can also be of type false; however, parameter $timestamp of DateTimeObj::getGMT() does only seem to accept null|string, maybe add an additional type check?

            );

            // Invalid date
        } else {
            return array(
                'value' => null,
                'date' => null
            );
        }
    }

    /*-------------------------------------------------------------------------
        Output:
    -------------------------------------------------------------------------*/

    public function appendFormattedElement(XMLElement &$wrapper, $data, $encode = false, $mode = null, $entry_id = null)

Incorrect spacing between argument "$encode" and equals sign; expected 0 but found 1

Incorrect spacing between default value and equals sign for argument "$encode"; expected 0 but found 1

Incorrect spacing between argument "$mode" and equals sign; expected 0 but found 1

Incorrect spacing between default value and equals sign for argument "$mode"; expected 0 but found 1

Incorrect spacing between argument "$entry_id" and equals sign; expected 0 but found 1

Incorrect spacing between default value and equals sign for argument "$entry_id"; expected 0 but found 1

    {
        if (isset($data['value'])) {

Blank line found at start of control structure

            // Get date
            if (is_array($data['value'])) {
                $date = current($data['value']);
            } else {
                $date = $data['value'];
            }

            $wrapper->appendChild(General::createXMLDateObject($date, $this->get('element_name')));

It seems like $this->get('element_name') can also be of type array; however, parameter $element of General::createXMLDateObject() does only seem to accept string, maybe add an additional type check?

It seems like General::createXMLDateObject($date, $this->get('element_name')) can also be of type false; however, parameter $child of XMLElement::appendChild() does only seem to accept XMLElement|string, maybe add an additional type check?

        }
    }

    public function prepareTextValue($data, $entry_id = null)

Incorrect spacing between argument "$entry_id" and equals sign; expected 0 but found 1

Incorrect spacing between default value and equals sign for argument "$entry_id"; expected 0 but found 1

    {
        $value = '';

        if (isset($data['value'])) {
            $value = $this->formatDate($data['value']);
        }

        return $value;
    }

    public function getParameterPoolValue(array $data, $entry_id = null)

Incorrect spacing between argument "$entry_id" and equals sign; expected 0 but found 1

Incorrect spacing between default value and equals sign for argument "$entry_id"; expected 0 but found 1

    {
        return DateTimeObj::get('Y-m-d H:i:s', $data['value']);
    }

    /*-------------------------------------------------------------------------
        Import:
    -------------------------------------------------------------------------*/

    public function getImportModes()
    {
        return array(
            'getValue' =>       ImportableField::STRING_VALUE,
            'getPostdata' =>    ImportableField::ARRAY_VALUE
        );
    }

    public function prepareImportValue($data, $mode, $entry_id = null)

Incorrect spacing between argument "$entry_id" and equals sign; expected 0 but found 1

Incorrect spacing between default value and equals sign for argument "$entry_id"; expected 0 but found 1

    {
        $value = $status = $message = null;
        $modes = (object)$this->getImportModes();

        // Prepopulate date:
        if ($data === null || $data === '') {
            if (!is_null($this->get('pre_populate'))) {
                $timestamp = self::parseDate($this->get('pre_populate'));
                $timestamp = $timestamp['start'];
            }

            // DateTime to timestamp:
        } elseif ($data instanceof DateTime) {
            $timestamp = $data->getTimestamp();

            // Convert given date to timestamp:
        } elseif (DateTimeObj::validate($data)) {
            $timestamp = DateTimeObj::get('U', $data);
        }

        // Valid date found:
        if (isset($timestamp)) {
            $value = DateTimeObj::get('c', $timestamp);
        }

        if ($mode === $modes->getValue) {
            return $value;

The expression return $value also could return the type false which is incompatible with the return type mandated by ImportableField::prepareImportValue() of array|string.

        } elseif ($mode === $modes->getPostdata) {
            return $this->processRawFieldData($data, $status, $message, true, $entry_id);
        }

        return null;
    }

    /*-------------------------------------------------------------------------
        Export:
    -------------------------------------------------------------------------*/

    /**
     * Return a list of supported export modes for use with `prepareExportValue`.
     *
     * @return array
     */
    public function getExportModes()
    {
        return array(
            'getValue'    => ExportableField::VALUE,
            'getObject'   => ExportableField::OBJECT,
            'getPostdata' => ExportableField::POSTDATA
        );
    }

    /**
     * Give the field some data and ask it to return a value using one of many
     * possible modes.
     *
     * @param mixed $data
     * @param integer $mode
     * @param integer $entry_id
     * @return DateTime|null
     */
    public function prepareExportValue($data, $mode, $entry_id = null)

Incorrect spacing between argument "$entry_id" and equals sign; expected 0 but found 1

Incorrect spacing between default value and equals sign for argument "$entry_id"; expected 0 but found 1

    {
        $modes = (object)$this->getExportModes();

        if ($mode === $modes->getValue) {
            return $this->formatDate(

The expression return $this->formatDate(IssetNode ? $data['value'] : null) returns the type string which is incompatible with the documented return type DateTime|null.

                isset($data['value']) ? $data['value'] : null
            );
        }

        if ($mode === $modes->getObject) {
            $timezone = Symphony::Configuration()->get('timezone', 'region');

            $date = new DateTime(
                isset($data['value']) ? $data['value'] : 'now'
            );

            $date->setTimezone(new DateTimeZone($timezone));

It seems like $timezone can also be of type array; however, parameter $timezone of DateTimeZone::__construct() does only seem to accept string, maybe add an additional type check?

            return $date;
        } elseif ($mode === $modes->getPostdata) {
            return isset($data['value'])
                ? $data['value']

Inline shorthand IF statement must be declared on a single line

                : null;
        }

        return null;
    }

    /*-------------------------------------------------------------------------
        Filtering:
    -------------------------------------------------------------------------*/

    public function buildDSRetrievalSQL($data, &$joins, &$where, $andOperation = false)

Incorrect spacing between argument "$andOperation" and equals sign; expected 0 but found 1

Incorrect spacing between default value and equals sign for argument "$andOperation"; expected 0 but found 1

    {
        if (self::isFilterRegex($data[0])) {
            $this->buildRegexSQL($data[0], array('value'), $joins, $where);
        } elseif (self::isFilterSQL($data[0])) {
            $this->buildFilterSQL($data[0], array('value'), $joins, $where);
        } else {
            $parsed = array();

            // For the filter provided, loop over each piece
            foreach ($data as $string) {
                $type = self::parseFilter($string);

                if ($type == self::ERROR) {
                    return false;
                }

                if (!is_array($parsed[$type])) {
                    $parsed[$type] = array();
                }

                $parsed[$type][] = $string;
            }

            foreach ($parsed as $value) {
                $this->buildRangeFilterSQL($value, $joins, $where, $andOperation);
            }
        }

        return true;
    }

    /*-------------------------------------------------------------------------
        Sorting:
    -------------------------------------------------------------------------*/

    public function buildSortingSQL(&$joins, &$where, &$sort, $order = 'ASC')

Incorrect spacing between argument "$order" and equals sign; expected 0 but found 1

Incorrect spacing between default value and equals sign for argument "$order"; expected 0 but found 1

    {
        if ($this->isRandomOrder($order)) {
            $sort = 'ORDER BY RAND()';
        } else {
            $sort = sprintf(
                'ORDER BY (
                    SELECT %s
                    FROM tbl_entries_data_%d AS `ed`
                    WHERE entry_id = e.id
                ) %s, `e`.`id` %s',
                '`ed`.date',
                $this->get('id'),

It seems like $this->get('id') can also be of type array; however, parameter $args of sprintf() does only seem to accept string, maybe add an additional type check?

                $order,
                $order
            );
        }
    }

    public function buildSortingSelectSQL($sort, $order = 'ASC')

Incorrect spacing between argument "$order" and equals sign; expected 0 but found 1

Incorrect spacing between default value and equals sign for argument "$order"; expected 0 but found 1

    {
        return null;
    }

    /*-------------------------------------------------------------------------
        Grouping:
    -------------------------------------------------------------------------*/

    public function groupRecords($records)
    {
        if (!is_array($records) || empty($records)) {
            return;
        }

        $groups = array('year' => array());

        foreach ($records as $r) {
            $data = $r->getData($this->get('id'));

            $timestamp = DateTimeObj::get('U', $data['value']);
            $info = getdate($timestamp);

$timestamp of type false|string is incompatible with the type integer expected by parameter $timestamp of getdate().

            $year = $info['year'];
            $month = ($info['mon'] < 10 ? '0' . $info['mon'] : $info['mon']);

Inline shorthand IF statement requires brackets around comparison

            if (!isset($groups['year'][$year])) {
                $groups['year'][$year] = array(
                    'attr' => array('value' => $year),
                    'records' => array(),
                    'groups' => array()
                );
            }

            if (!isset($groups['year'][$year]['groups']['month'])) {
                $groups['year'][$year]['groups']['month'] = array();
            }

            if (!isset($groups['year'][$year]['groups']['month'][$month])) {
                $groups['year'][$year]['groups']['month'][$month] = array(
                    'attr' => array('value' => $month),
                    'records' => array(),
                    'groups' => array()
                );
            }

            $groups['year'][$year]['groups']['month'][$month]['records'][] = $r;
        }

        return $groups;
    }
}