fieldTextarea::canPrePopulate() - Code Metrics - Inspection of "Release 2.7.1" - symphonycms/symphony-2 - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 2f9dc2...c88488 )

by Nicolas

created 2018-02-01 16:13 UTC

fieldTextarea::canPrePopulate() A

↳ Parent: fieldTextarea

Complexity

Conditions	1
Paths	1

Size

Total Lines	4
Code Lines	2

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	1
eloc	2
nc	1
nop	0
dl	0
loc	4
rs	10
c	0
b	0
f	0

<?php

/**
 * @package toolkit
 */

/**
 * A simple Textarea field that essentially maps to HTML's `<textarea/>`.
 */
class fieldTextarea extends Field implements ExportableField, ImportableField
{
    public function __construct()
    {
        parent::__construct();
        $this->_name = __('Textarea');
class MyClass { }

$x = new MyClass();
$x->foo = true;
        $this->_required = true;

        // Set default
        $this->set('show_column', 'no');
        $this->set('required', 'no');
    }

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

    public function canFilter()
    {
        return true;
    }
    
    public function canPrePopulate()
    {
        return true;
    }
    
    /*-------------------------------------------------------------------------
        Setup:
    -------------------------------------------------------------------------*/

    public function createTable()
    {
        return Symphony::Database()->query(
            "CREATE TABLE IF NOT EXISTS `tbl_entries_data_" . $this->get('id') . "` (
              `id` int(11) unsigned NOT null auto_increment,
              `entry_id` int(11) unsigned NOT null,
              `value` MEDIUMTEXT,
              `value_formatted` MEDIUMTEXT,
              PRIMARY KEY  (`id`),
              UNIQUE KEY `entry_id` (`entry_id`),
              FULLTEXT KEY `value` (`value`)
            ) ENGINE=MyISAM DEFAULT CHARSET=utf8 COLLATE=utf8_unicode_ci;"
        );
    }

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

    protected function __applyFormatting($data, $validate = false, &$errors = null)
    {
        $result = '';

        if ($this->get('formatter')) {
            $formatter = TextformatterManager::create($this->get('formatter'));
            $result = $formatter->run($data);
        }

        if ($validate === true) {
            if (!General::validateXML($result, $errors, false, new XsltProcess)) {
                $result = html_entity_decode($result, ENT_QUOTES, 'UTF-8');
                $result = $this->__replaceAmpersands($result);

                if (!General::validateXML($result, $errors, false, new XsltProcess)) {
                    return false;
                }
            }
        }

        return $result;
    }

    private function __replaceAmpersands($value)
    {
        return preg_replace('/&(?!(#[0-9]+|#x[0-9a-f]+|amp|lt|gt);)/i', '&amp;', trim($value));
    }

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

    public function findDefaults(array &$settings)
    {
        if (!isset($settings['size'])) {
            $settings['size'] = 15;
        }
    }

    public function displaySettingsPanel(XMLElement &$wrapper, $errors = null)
    {
        parent::displaySettingsPanel($wrapper, $errors);

        // Textarea Size
        $label = Widget::Label(__('Number of default rows'));
        $label->setAttribute('class', 'column');
        $input = Widget::Input('fields['.$this->get('sortorder').'][size]', (string)$this->get('size'));
        $label->appendChild($input);

        $div = new XMLElement('div', null, array('class' => 'two columns'));
        $div->appendChild($label);
        $div->appendChild($this->buildFormatterSelect($this->get('formatter'), 'fields['.$this->get('sortorder').'][formatter]', __('Text Formatter')));
        $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();

        if ($this->get('formatter') != 'none') {
            $fields['formatter'] = $this->get('formatter');
        }

        $fields['size'] = $this->get('size');

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

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

    public function displayPublishPanel(XMLElement &$wrapper, $data = null, $flagWithError = null, $fieldnamePrefix = null, $fieldnamePostfix = null, $entry_id = null)
    {
        $label = Widget::Label($this->get('label'));

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

        $value = isset($data['value']) ? $data['value'] : null;
        $textarea = Widget::Textarea('fields'.$fieldnamePrefix.'['.$this->get('element_name').']'.$fieldnamePostfix, (int)$this->get('size'), 50, (strlen($value) != 0 ? General::sanitize($value) : null));

        if ($this->get('formatter') != 'none') {
            $textarea->setAttribute('class', $this->get('formatter'));
        }

        /**
         * Allows developers modify the textarea before it is rendered in the publish forms
         *
         * @delegate ModifyTextareaFieldPublishWidget
         * @param string $context
         * '/backend/'
         * @param Field $field
         * @param Widget $label
         * @param Widget $textarea
         */
        Symphony::ExtensionManager()->notifyMembers('ModifyTextareaFieldPublishWidget', '/backend/', array(
            'field' => &$this,
            'label' => &$label,
            'textarea' => &$textarea
        ));

        $label->appendChild($textarea);

        if ($flagWithError != null) {
            $wrapper->appendChild(Widget::Error($label, $flagWithError));
        } else {
            $wrapper->appendChild($label);
        }
    }

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

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

        if ($this->__applyFormatting($data, true, $errors) === false) {
            $message = __('‘%s’ contains invalid XML.', array($this->get('label'))) . ' ' . __('The following error was returned:') . ' <code>' . $errors[0]['message'] . '</code>';
            return self::__INVALID_FIELDS__;
        }

        return self::__OK__;
    }

    public function processRawFieldData($data, &$status, &$message = null, $simulate = false, $entry_id = null)
    {
        $status = self::__OK__;

        if (strlen(trim($data)) == 0) {
            return array();
        }

        $result = array(
            'value' => $data
        );

        $result['value_formatted'] = $this->__applyFormatting($data, true, $errors);

        if ($result['value_formatted'] === false) {
            // Run the formatter again, but this time do not validate. We will sanitize the output
            $result['value_formatted'] = General::sanitize($this->__applyFormatting($data));

        }

        return $result;
    }

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

    public function fetchIncludableElements()
    {
        if ($this->get('formatter')) {
            return array(
                $this->get('element_name') . ': formatted',
                $this->get('element_name') . ': unformatted'
            );
        }

        return array(
            $this->get('element_name')
        );
    }

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

        if (!is_null($mode)) {
            $attributes['mode'] = $mode;
        }

        if ($mode == 'formatted') {
            if ($this->get('formatter') && isset($data['value_formatted'])) {
                $value = $data['value_formatted'];
            } else {
                $value = $this->__replaceAmpersands($data['value']);
            }

            $wrapper->appendChild(
                new XMLElement(
                    $this->get('element_name'),
                    ($encode ? General::sanitize($value) : $value),
                    $attributes
                )
            );
        } elseif ($mode == null || $mode == 'unformatted') {
            $value = !empty($data['value'])
                ? sprintf('<![CDATA[%s]]>', str_replace(']]>', ']]]]><![CDATA[>', $data['value']))
                : $data['value'];

            $wrapper->appendChild(
                new XMLElement($this->get('element_name'), $value, $attributes)
            );
        }
    }

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

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

    public function prepareImportValue($data, $mode, $entry_id = null)
    {
        $message = $status = null;
        $modes = (object)$this->getImportModes();

        if ($mode === $modes->getValue) {
            return $data;
        } 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(
            'getHandle' =>      ExportableField::HANDLE,
            'getFormatted' =>   ExportableField::FORMATTED,
            'getUnformatted' => ExportableField::UNFORMATTED,
            '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 string|null
     */
    public function prepareExportValue($data, $mode, $entry_id = null)
    {
        $modes = (object)$this->getExportModes();

        // Export handles:
        if ($mode === $modes->getHandle) {
            if (isset($data['handle'])) {
                return $data['handle'];
            } elseif (isset($data['value'])) {
                return Lang::createHandle($data['value']);
            }

            // Export unformatted:
        } elseif ($mode === $modes->getUnformatted || $mode === $modes->getPostdata) {
            return isset($data['value'])
                ? $data['value']
                : null;

            // Export formatted:
        } elseif ($mode === $modes->getFormatted) {
            if (isset($data['value_formatted'])) {
                return $data['value_formatted'];
            } elseif (isset($data['value'])) {
                return General::sanitize($data['value']);
            }
        }

        return null;
    }

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

    public function buildDSRetrievalSQL($data, &$joins, &$where, $andOperation = false)
    {
        $field_id = $this->get('id');

        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 {
            if (is_array($data)) {
                $data = $data[0];
            }

            $this->_key++;
            $data = $this->cleanValue($data);
            $joins .= "
                LEFT JOIN
                    `tbl_entries_data_{$field_id}` AS t{$field_id}_{$this->_key}
                    ON (e.id = t{$field_id}_{$this->_key}.entry_id)
            ";
            $where .= "
                AND MATCH (t{$field_id}_{$this->_key}.value) AGAINST ('{$data}' IN BOOLEAN MODE)
            ";
        }

        return true;
    }

    /*-------------------------------------------------------------------------
        Events:
    -------------------------------------------------------------------------*/

    public function getExampleFormMarkup()
    {
        $label = Widget::Label($this->get('label'));
        $label->appendChild(Widget::Textarea('fields['.$this->get('element_name').']', (int)$this->get('size'), 50));

        return $label;
    }
}


1		<?php
2
3		/**
4		* @package toolkit
5		*/
6
7		/**
8		* A simple Textarea field that essentially maps to HTML's `<textarea/>`.
9		*/
10		class fieldTextarea extends Field implements ExportableField, ImportableField
11		{
12	View Code Duplication	public function __construct()
13		{
14		parent::__construct();
15		$this->_name = __('Textarea');
		0 ignored issues – show Bug introduced 2015-11-22 04:43 UTC by Report Bug Copy Issue Report The property `_name` does not exist. Did you maybe forget to declare it? In PHP it is possible to write to properties without declaring them. For example, the following is perfectly valid PHP code: class MyClass { } $x = new MyClass(); $x->foo = true; Generally, it is a good practice to explictly declare properties to avoid accidental typos and provide IDE auto-completion: class MyClass { public $foo; } $x = new MyClass(); $x->foo = true; Loading history...
16		$this->_required = true;
17
18		// Set default
19		$this->set('show_column', 'no');
20		$this->set('required', 'no');
21		}
22
23		/*-------------------------------------------------------------------------
24		Definition:
25		-------------------------------------------------------------------------*/
26
27		public function canFilter()
28		{
29		return true;
30		}
31
32		public function canPrePopulate()
33		{
34		return true;
35		}
36
37		/*-------------------------------------------------------------------------
38		Setup:
39		-------------------------------------------------------------------------*/
40
41		public function createTable()
42		{
43		return Symphony::Database()->query(
44		"CREATE TABLE IF NOT EXISTS `tbl_entries_data_" . $this->get('id') . "` (
45		`id` int(11) unsigned NOT null auto_increment,
46		`entry_id` int(11) unsigned NOT null,
47		`value` MEDIUMTEXT,
48		`value_formatted` MEDIUMTEXT,
49		PRIMARY KEY (`id`),
50		UNIQUE KEY `entry_id` (`entry_id`),
51		FULLTEXT KEY `value` (`value`)
52		) ENGINE=MyISAM DEFAULT CHARSET=utf8 COLLATE=utf8_unicode_ci;"
53		);
54		}
55
56		/*-------------------------------------------------------------------------
57		Utilities:
58		-------------------------------------------------------------------------*/
59
60		protected function __applyFormatting($data, $validate = false, &$errors = null)
61		{
62		$result = '';
63
64		if ($this->get('formatter')) {
65		$formatter = TextformatterManager::create($this->get('formatter'));
66		$result = $formatter->run($data);
67		}
68
69		if ($validate === true) {
70		if (!General::validateXML($result, $errors, false, new XsltProcess)) {
71		$result = html_entity_decode($result, ENT_QUOTES, 'UTF-8');
72		$result = $this->__replaceAmpersands($result);
73
74		if (!General::validateXML($result, $errors, false, new XsltProcess)) {
75		return false;
76		}
77		}
78		}
79
80		return $result;
81		}
82
83		private function __replaceAmpersands($value)
84		{
85		return preg_replace('/&(?!(#[0-9]+\|#x[0-9a-f]+\|amp\|lt\|gt);)/i', '&', trim($value));
86		}
87
88		/*-------------------------------------------------------------------------
89		Settings:
90		-------------------------------------------------------------------------*/
91
92		public function findDefaults(array &$settings)
93		{
94		if (!isset($settings['size'])) {
95		$settings['size'] = 15;
96		}
97		}
98
99		public function displaySettingsPanel(XMLElement &$wrapper, $errors = null)
100		{
101		parent::displaySettingsPanel($wrapper, $errors);
102
103		// Textarea Size
104		$label = Widget::Label(__('Number of default rows'));
105		$label->setAttribute('class', 'column');
106		$input = Widget::Input('fields['.$this->get('sortorder').'][size]', (string)$this->get('size'));
107		$label->appendChild($input);
108
109		$div = new XMLElement('div', null, array('class' => 'two columns'));
110		$div->appendChild($label);
111		$div->appendChild($this->buildFormatterSelect($this->get('formatter'), 'fields['.$this->get('sortorder').'][formatter]', __('Text Formatter')));
112		$wrapper->appendChild($div);
113
114		// Requirements and table display
115		$this->appendStatusFooter($wrapper);
116		}
117
118		public function commit()
119		{
120		if (!parent::commit()) {
121		return false;
122		}
123
124		$id = $this->get('id');
125
126		if ($id === false) {
127		return false;
128		}
129
130		$fields = array();
131
132		if ($this->get('formatter') != 'none') {
133		$fields['formatter'] = $this->get('formatter');
134		}
135
136		$fields['size'] = $this->get('size');
137
138		return FieldManager::saveSettings($id, $fields);
139		}
140
141		/*-------------------------------------------------------------------------
142		Publish:
143		-------------------------------------------------------------------------*/
144
145		public function displayPublishPanel(XMLElement &$wrapper, $data = null, $flagWithError = null, $fieldnamePrefix = null, $fieldnamePostfix = null, $entry_id = null)
146		{
147		$label = Widget::Label($this->get('label'));
148
149		if ($this->get('required') !== 'yes') {
150		$label->appendChild(new XMLElement('i', __('Optional')));
151		}
152
153		$value = isset($data['value']) ? $data['value'] : null;
154		$textarea = Widget::Textarea('fields'.$fieldnamePrefix.'['.$this->get('element_name').']'.$fieldnamePostfix, (int)$this->get('size'), 50, (strlen($value) != 0 ? General::sanitize($value) : null));
155
156		if ($this->get('formatter') != 'none') {
157		$textarea->setAttribute('class', $this->get('formatter'));
158		}
159
160		/**
161		* Allows developers modify the textarea before it is rendered in the publish forms
162		*
163		* @delegate ModifyTextareaFieldPublishWidget
164		* @param string $context
165		* '/backend/'
166		* @param Field $field
167		* @param Widget $label
168		* @param Widget $textarea
169		*/
170		Symphony::ExtensionManager()->notifyMembers('ModifyTextareaFieldPublishWidget', '/backend/', array(
171		'field' => &$this,
172		'label' => &$label,
173		'textarea' => &$textarea
174		));
175
176		$label->appendChild($textarea);
177
178		if ($flagWithError != null) {
179		$wrapper->appendChild(Widget::Error($label, $flagWithError));
180		} else {
181		$wrapper->appendChild($label);
182		}
183		}
184
185		public function checkPostFieldData($data, &$message, $entry_id = null)
186		{
187		$message = null;
188
189	View Code Duplication	if ($this->get('required') === 'yes' && strlen(trim($data)) == 0) {
190		$message = __('‘%s’ is a required field.', array($this->get('label')));
191		return self::__MISSING_FIELDS__;
192		}
193
194		if ($this->__applyFormatting($data, true, $errors) === false) {
195		$message = __('‘%s’ contains invalid XML.', array($this->get('label'))) . ' ' . __('The following error was returned:') . ' <code>' . $errors[0]['message'] . '</code>';
196		return self::__INVALID_FIELDS__;
197		}
198
199		return self::__OK__;
200		}
201
202		public function processRawFieldData($data, &$status, &$message = null, $simulate = false, $entry_id = null)
203		{
204		$status = self::__OK__;
205
206		if (strlen(trim($data)) == 0) {
207		return array();
208		}
209
210		$result = array(
211		'value' => $data
212		);
213
214		$result['value_formatted'] = $this->__applyFormatting($data, true, $errors);
215
216		if ($result['value_formatted'] === false) {
217		// Run the formatter again, but this time do not validate. We will sanitize the output
218		$result['value_formatted'] = General::sanitize($this->__applyFormatting($data));
		0 ignored issues – show Security Bug introduced 2015-11-22 04:43 UTC by Report Bug Copy Issue Report It seems like `$this->__applyFormatting($data)` targeting `fieldTextarea::__applyFormatting()` can also be of type `false`; however, `General::sanitize()` does only seem to accept `string`, did you maybe forget to handle an error condition? Loading history...
219		}
220
221		return $result;
222		}
223
224		/*-------------------------------------------------------------------------
225		Output:
226		-------------------------------------------------------------------------*/
227
228		public function fetchIncludableElements()
229		{
230		if ($this->get('formatter')) {
231		return array(
232		$this->get('element_name') . ': formatted',
233		$this->get('element_name') . ': unformatted'
234		);
235		}
236
237		return array(
238		$this->get('element_name')
239		);
240		}
241
242		public function appendFormattedElement(XMLElement &$wrapper, $data, $encode = false, $mode = null, $entry_id = null)
243		{
244		$attributes = array();
245
246		if (!is_null($mode)) {
247		$attributes['mode'] = $mode;
248		}
249
250		if ($mode == 'formatted') {
251		if ($this->get('formatter') && isset($data['value_formatted'])) {
252		$value = $data['value_formatted'];
253		} else {
254		$value = $this->__replaceAmpersands($data['value']);
255		}
256
257		$wrapper->appendChild(
258		new XMLElement(
259		$this->get('element_name'),
260		($encode ? General::sanitize($value) : $value),
261		$attributes
262		)
263		);
264		} elseif ($mode == null \|\| $mode == 'unformatted') {
265		$value = !empty($data['value'])
266		? sprintf('<![CDATA[%s]]>', str_replace(']]>', ']]]]><![CDATA[>', $data['value']))
267		: $data['value'];
268
269		$wrapper->appendChild(
270		new XMLElement($this->get('element_name'), $value, $attributes)
271		);
272		}
273		}
274
275		/*-------------------------------------------------------------------------
276		Import:
277		-------------------------------------------------------------------------*/
278
279		public function getImportModes()
280		{
281		return array(
282		'getValue' => ImportableField::STRING_VALUE,
283		'getPostdata' => ImportableField::ARRAY_VALUE
284		);
285		}
286
287	View Code Duplication	public function prepareImportValue($data, $mode, $entry_id = null)
288		{
289		$message = $status = null;
290		$modes = (object)$this->getImportModes();
291
292		if ($mode === $modes->getValue) {
293		return $data;
294		} elseif ($mode === $modes->getPostdata) {
295		return $this->processRawFieldData($data, $status, $message, true, $entry_id);
296		}
297
298		return null;
299		}
300
301		/*-------------------------------------------------------------------------
302		Export:
303		-------------------------------------------------------------------------*/
304
305		/**
306		* Return a list of supported export modes for use with `prepareExportValue`.
307		*
308		* @return array
309		*/
310		public function getExportModes()
311		{
312		return array(
313		'getHandle' => ExportableField::HANDLE,
314		'getFormatted' => ExportableField::FORMATTED,
315		'getUnformatted' => ExportableField::UNFORMATTED,
316		'getPostdata' => ExportableField::POSTDATA
317		);
318		}
319
320		/**
321		* Give the field some data and ask it to return a value using one of many
322		* possible modes.
323		*
324		* @param mixed $data
325		* @param integer $mode
326		* @param integer $entry_id
327		* @return string\|null
328		*/
329		public function prepareExportValue($data, $mode, $entry_id = null)
330		{
331		$modes = (object)$this->getExportModes();
332
333		// Export handles:
334		if ($mode === $modes->getHandle) {
335	View Code Duplication	if (isset($data['handle'])) {
336		return $data['handle'];
337		} elseif (isset($data['value'])) {
338		return Lang::createHandle($data['value']);
339		}
340
341		// Export unformatted:
342	View Code Duplication	} elseif ($mode === $modes->getUnformatted \|\| $mode === $modes->getPostdata) {
343		return isset($data['value'])
344		? $data['value']
345		: null;
346
347		// Export formatted:
348		} elseif ($mode === $modes->getFormatted) {
349		if (isset($data['value_formatted'])) {
350		return $data['value_formatted'];
351		} elseif (isset($data['value'])) {
352		return General::sanitize($data['value']);
353		}
354		}
355
356		return null;
357		}
358
359		/*-------------------------------------------------------------------------
360		Filtering:
361		-------------------------------------------------------------------------*/
362
363		public function buildDSRetrievalSQL($data, &$joins, &$where, $andOperation = false)
364		{
365		$field_id = $this->get('id');
366
367		if (self::isFilterRegex($data[0])) {
368		$this->buildRegexSQL($data[0], array('value'), $joins, $where);
369	View Code Duplication	} elseif (self::isFilterSQL($data[0])) {
370		$this->buildFilterSQL($data[0], array('value'), $joins, $where);
371		} else {
372		if (is_array($data)) {
373		$data = $data[0];
374		}
375
376		$this->_key++;
377		$data = $this->cleanValue($data);
378		$joins .= "
379		LEFT JOIN
380		`tbl_entries_data_{$field_id}` AS t{$field_id}_{$this->_key}
381		ON (e.id = t{$field_id}_{$this->_key}.entry_id)
382		";
383		$where .= "
384		AND MATCH (t{$field_id}_{$this->_key}.value) AGAINST ('{$data}' IN BOOLEAN MODE)
385		";
386		}
387
388		return true;
389		}
390
391		/*-------------------------------------------------------------------------
392		Events:
393		-------------------------------------------------------------------------*/
394
395	View Code Duplication	public function getExampleFormMarkup()
396		{
397		$label = Widget::Label($this->get('label'));
398		$label->appendChild(Widget::Textarea('fields['.$this->get('element_name').']', (int)$this->get('size'), 50));
399
400		return $label;
401		}
402		}
403

symphonycms / symphony-2

GitHub Access Token became invalid

Push — master ( 2f9dc2...c88488 )

fieldTextarea::canPrePopulate() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like